411 lines
12 KiB
Haskell
411 lines
12 KiB
Haskell
module Builtins where
|
|
|
|
import Code
|
|
( Builtin(..)
|
|
, Cho(..)
|
|
, Code
|
|
, Datum(..)
|
|
, Dereferenced(..)
|
|
, Instr(..)
|
|
, Interp(..)
|
|
, InterpFn
|
|
, InterpFn
|
|
, derefHeap
|
|
, heapStruct
|
|
, newHeapVars
|
|
)
|
|
import qualified Compiler as Co
|
|
import Control.Exception (IOException, catch)
|
|
import Control.Monad.IO.Class (liftIO)
|
|
import Control.Monad.Trans.Class (lift)
|
|
import Control.Monad.Trans.Except (runExceptT)
|
|
import Control.Monad.Trans.State.Lazy (get, gets, modify)
|
|
import Data.Functor.Identity (runIdentity)
|
|
import Data.List (intercalate)
|
|
import qualified Data.Map as M
|
|
import Data.Maybe (fromJust)
|
|
import Env (PrlgEnv(..), findAtom, findStruct, prlgError)
|
|
import qualified IR
|
|
import Interpreter (backtrack)
|
|
import Load (processInput)
|
|
import qualified Operators as O
|
|
import System.Console.Haskeline (getInputChar, outputStr, outputStrLn)
|
|
|
|
bi = Builtin
|
|
|
|
continue = pure Nothing
|
|
|
|
showTerm itos heap = runIdentity . heapStruct atom struct hrec heap
|
|
where
|
|
atom (Atom a) = pure $ "'" ++ itos M.! a ++ "'"
|
|
atom (Number n) = pure (show n)
|
|
atom VoidRef = pure "_"
|
|
struct (Struct (IR.Id h _)) args =
|
|
pure $ "'" ++ itos M.! h ++ "'(" ++ intercalate "," args ++ ")"
|
|
hrec (HeapRef hr) ref =
|
|
pure $
|
|
(if hr == ref
|
|
then "_X"
|
|
else "_Rec") ++
|
|
show hr
|
|
|
|
printLocals :: InterpFn
|
|
printLocals = do
|
|
scope <- gets (gvar . cur)
|
|
heap <- gets (heap . cur)
|
|
IR.StrTable _ _ itos <- gets strtable
|
|
flip traverse (M.assocs scope) $ \(local, ref) ->
|
|
lift . outputStrLn $
|
|
"_Local" ++ show local ++ " = " ++ showTerm itos heap ref
|
|
continue
|
|
|
|
promptRetry :: InterpFn
|
|
promptRetry = do
|
|
last <- gets (null . cho)
|
|
if last
|
|
then continue
|
|
else promptRetry'
|
|
|
|
promptRetry' :: InterpFn
|
|
promptRetry' = do
|
|
x <- lift $ getInputChar "? "
|
|
case x of
|
|
Just ';' -> backtrack
|
|
_ -> continue
|
|
|
|
withArgs :: [Int] -> ([Int] -> InterpFn) -> InterpFn
|
|
withArgs as f = do
|
|
scope <- gets (hvar . cur)
|
|
if all (`M.member` scope) as
|
|
then f $ map (scope M.!) as
|
|
else prlgError "arguments not bound"
|
|
|
|
write' :: InterpFn -> InterpFn
|
|
write' c =
|
|
withArgs [0] $ \[arg] -> do
|
|
heap <- gets (heap . cur)
|
|
IR.StrTable _ _ itos <- gets strtable
|
|
lift . outputStr $ showTerm itos heap arg
|
|
c --this now allows error fallthrough but we might like EitherT
|
|
|
|
write = write' continue
|
|
|
|
nl :: InterpFn
|
|
nl = do
|
|
lift $ outputStrLn ""
|
|
continue
|
|
|
|
writeln :: InterpFn
|
|
writeln = write' nl
|
|
|
|
assertFact :: (Code -> IR.Id -> PrlgEnv ()) -> InterpFn
|
|
assertFact addClause =
|
|
withArgs [0] $ \[arg] -> do
|
|
heap <- gets (heap . cur)
|
|
case Co.compileGoal . Co.squashVars <$>
|
|
Co.heapStructPrlgInt Nothing heap arg of
|
|
Just (U (Struct s):head) -> do
|
|
addClause (head ++ [NoGoal]) s
|
|
continue
|
|
_ -> prlgError "assert fact failure"
|
|
|
|
assertRule :: (Code -> IR.Id -> PrlgEnv ()) -> InterpFn
|
|
assertRule addClause =
|
|
withArgs [0, 1] $ \args -> do
|
|
scope <- gets (hvar . cur)
|
|
heap <- gets (heap . cur)
|
|
comma <- findAtom ","
|
|
cut <- findAtom "!"
|
|
case Co.squashVars . IR.CallI 0 <$>
|
|
traverse (Co.heapStructPrlgInt Nothing heap) args of
|
|
Just (IR.CallI 0 [hs, gs]) ->
|
|
let (U (Struct s):cs) =
|
|
Co.compileGoal hs ++ Co.seqGoals (Co.compileGoals comma cut gs)
|
|
in do addClause cs s
|
|
continue
|
|
_ -> prlgError "assert clause failure"
|
|
|
|
retractall :: InterpFn
|
|
retractall =
|
|
withArgs [0] $ \[arg] -> do
|
|
heap <- gets (heap . cur)
|
|
case derefHeap heap arg of
|
|
BoundRef _ (Atom a) ->
|
|
dropProcedure (IR.Id {IR.arity = 0, IR.str = a}) >> continue
|
|
BoundRef _ (Struct id) -> dropProcedure id >> continue
|
|
_ -> prlgError "retractall needs a struct"
|
|
|
|
exec' :: (Code -> Code) -> InterpFn
|
|
exec' fgol =
|
|
withArgs [0] $ \[arg] -> do
|
|
heap <- gets (heap . cur)
|
|
case Co.squashVars <$> Co.heapStructPrlgInt Nothing heap arg of
|
|
Just gs -> do
|
|
cur <- gets cur
|
|
comma <- findAtom ","
|
|
cut <- findAtom "!"
|
|
modify $ \s ->
|
|
s
|
|
{ cur =
|
|
cur
|
|
{ hvar = M.empty
|
|
, hed = Co.seqGoals (Co.compileGoals comma cut gs)
|
|
, gol = fgol (gol cur)
|
|
}
|
|
}
|
|
continue
|
|
_ -> prlgError "bad goal"
|
|
|
|
call :: InterpFn
|
|
call = exec' id
|
|
|
|
exec :: InterpFn
|
|
exec = exec' (const [LastCall])
|
|
|
|
{- struct assembly/disassembly -}
|
|
struct :: InterpFn
|
|
struct = do
|
|
heap <- gets (heap . cur)
|
|
scope <- gets (hvar . cur)
|
|
case derefHeap heap <$> scope M.!? 0 of
|
|
Just (BoundRef addr (Struct IR.Id {IR.arity = arity, IR.str = str})) ->
|
|
structUnify arity str
|
|
_ -> structAssemble
|
|
|
|
heapListLength listAtom heap ref = go 0 ref ref (id, fromJust . step)
|
|
where
|
|
nil r
|
|
| BoundRef _ str <- derefHeap heap r = str == Atom listAtom
|
|
| otherwise = False
|
|
step r
|
|
| BoundRef addr (Struct IR.Id {IR.arity = 2, IR.str = listAtom'}) <-
|
|
derefHeap heap r
|
|
, listAtom == listAtom' = Just (addr + 2)
|
|
| otherwise = Nothing
|
|
go n fast slow (f1, f2)
|
|
| nil fast = Just n
|
|
| Just fast' <- step fast =
|
|
if slow == fast'
|
|
then Nothing
|
|
else go (n + 1) fast' (f1 slow) (f2, f1)
|
|
| otherwise = Nothing
|
|
|
|
structAssemble :: InterpFn
|
|
structAssemble = do
|
|
heap <- gets (heap . cur)
|
|
scope <- gets (hvar . cur)
|
|
case derefHeap heap <$> scope M.!? 1 of
|
|
Just (BoundRef addr (Atom str)) -> do
|
|
listAtom <- findAtom "[]"
|
|
case scope M.!? 2 >>= heapListLength listAtom heap of
|
|
Just arity -> structUnify arity str
|
|
_ -> prlgError "struct arity unknown"
|
|
_ -> prlgError "struct id unknown"
|
|
|
|
structUnify arity str = do
|
|
cur <- gets cur
|
|
let h = heap cur
|
|
scope = hvar cur
|
|
listAtom <- findAtom "[]"
|
|
let hcode = map U $ maybe VoidRef HeapRef . (scope M.!?) <$> [0 .. 2]
|
|
(h', pvars) = newHeapVars arity h
|
|
structData =
|
|
Struct IR.Id {IR.arity = arity, IR.str = str} : map HeapRef pvars
|
|
paramsData =
|
|
concatMap
|
|
(\pv -> [Struct IR.Id {IR.arity = 2, IR.str = listAtom}, HeapRef pv])
|
|
pvars ++
|
|
[Atom listAtom]
|
|
gcode = map U $ structData ++ [Atom str] ++ paramsData
|
|
modify $ \s ->
|
|
s {cur = cur {heap = h', gol = gcode ++ gol cur, hed = hcode ++ hed cur}}
|
|
continue
|
|
|
|
{- terms -}
|
|
var :: InterpFn
|
|
var = do
|
|
heap <- gets (heap . cur)
|
|
scope <- gets (hvar . cur)
|
|
case derefHeap heap <$> scope M.!? 0 of
|
|
Nothing -> continue
|
|
Just (FreeRef _) -> continue
|
|
_ -> backtrack
|
|
|
|
same_term :: InterpFn
|
|
same_term = do
|
|
heap <- gets (heap . cur)
|
|
scope <- gets (hvar . cur)
|
|
case map (fmap (derefHeap heap) . (scope M.!?)) [0, 1] of
|
|
[Just a, Just b]
|
|
| a == b -> continue
|
|
_ -> backtrack
|
|
|
|
{- operator management -}
|
|
op :: InterpFn
|
|
op =
|
|
withArgs [0, 1, 2] $ \args -> do
|
|
heap <- gets (heap . cur)
|
|
IR.StrTable _ _ itos <- gets strtable
|
|
case map (derefHeap heap) args of
|
|
[BoundRef _ (Number prio), BoundRef _ (Atom fixityAtom), BoundRef _ (Atom opatom)]
|
|
| Just op <-
|
|
(,) <$> itos M.!? opatom <*>
|
|
(O.Op prio <$> ((itos M.!? fixityAtom) >>= O.fixity)) -> do
|
|
modify $ \s -> s {ops = op : ops s}
|
|
continue
|
|
_ -> prlgError "bad op spec"
|
|
|
|
deop :: InterpFn
|
|
deop =
|
|
withArgs [0] $ \[arg] -> do
|
|
heap <- gets (heap . cur)
|
|
IR.StrTable _ _ itos <- gets strtable
|
|
case derefHeap heap arg of
|
|
BoundRef _ (Atom opatom)
|
|
| Just op <- itos M.!? opatom -> do
|
|
modify $ \s -> s {ops = filter ((/= op) . fst) (ops s)}
|
|
continue
|
|
_ -> prlgError "bad op spec"
|
|
|
|
stashOps :: InterpFn
|
|
stashOps = do
|
|
currentOps <- gets ops
|
|
modify $ \s -> s {opstash = currentOps : opstash s}
|
|
continue
|
|
|
|
popOps :: InterpFn
|
|
popOps = do
|
|
currentOps <- gets opstash
|
|
case currentOps of
|
|
[] -> prlgError "no ops stashed"
|
|
(ops':opss) -> do
|
|
modify $ \s -> s {ops = ops', opstash = opss}
|
|
continue
|
|
|
|
{- expansion environment -}
|
|
stashExpansions :: InterpFn
|
|
stashExpansions = do
|
|
ds <- gets defs
|
|
les <- findStruct "load_expansion" 2
|
|
qes <- findStruct "query_expansion" 2
|
|
let [le, qe] = map (ds M.!?) [les, qes]
|
|
modify $ \s -> s {macrostash = (le, qe) : macrostash s}
|
|
continue
|
|
|
|
popExpansions :: InterpFn
|
|
popExpansions = do
|
|
currentMacros <- gets macrostash
|
|
les <- findStruct "load_expansion" 2
|
|
qes <- findStruct "query_expansion" 2
|
|
case currentMacros of
|
|
[] -> prlgError "no expansions stashed"
|
|
((le, qe):stash') -> do
|
|
modify $ \s ->
|
|
s
|
|
{ defs = M.alter (const le) les $ M.alter (const qe) qes $ defs s
|
|
, macrostash = stash'
|
|
}
|
|
continue
|
|
|
|
{- adding the builtins -}
|
|
addOp :: (String, O.Op) -> PrlgEnv ()
|
|
addOp op = modify $ \s -> s {ops = op : ops s}
|
|
|
|
modDef :: ([Code] -> Maybe [Code]) -> IR.Id -> PrlgEnv ()
|
|
modDef fn struct =
|
|
modify $ \s -> s {defs = M.alter (maybe (fn []) fn) struct $ defs s}
|
|
|
|
addClauseA :: Code -> IR.Id -> PrlgEnv ()
|
|
addClauseA code = modDef $ Just . (code :)
|
|
|
|
addClauseZ :: Code -> IR.Id -> PrlgEnv ()
|
|
addClauseZ code = modDef $ Just . (++ [code])
|
|
|
|
addProcedure :: [Code] -> IR.Id -> PrlgEnv ()
|
|
addProcedure heads = modDef $ Just . const heads
|
|
|
|
dropProcedure :: IR.Id -> PrlgEnv ()
|
|
dropProcedure = modDef $ const Nothing
|
|
|
|
addProc :: [Code] -> String -> Int -> PrlgEnv ()
|
|
addProc c n a = findStruct n a >>= addProcedure c
|
|
|
|
addBi :: InterpFn -> String -> Int -> PrlgEnv ()
|
|
addBi b n a =
|
|
addProc [[U (LocalRef $ r - 1) | r <- [1 .. a]] ++ [Invoke $ bi b]] n a
|
|
|
|
{- loading code -}
|
|
load :: Bool -> InterpFn
|
|
load queryMode =
|
|
withArgs [0] $ \[arg] -> do
|
|
heap <- gets (heap . cur)
|
|
IR.StrTable _ _ itos <- gets strtable --TODO the argument here should preferably be a string, right?
|
|
case derefHeap heap arg of
|
|
BoundRef _ (Atom a) -> do
|
|
let fn = itos M.! a
|
|
src' <- liftIO $ catch (Right <$> readFile fn) (pure . Left)
|
|
case src' of
|
|
Right src -> do
|
|
res <- runExceptT $ processInput fn queryMode src
|
|
case res of
|
|
Right _ -> continue
|
|
Left e -> prlgError $ "loading from '" ++ fn ++ "': " ++ e
|
|
Left e -> prlgError $ show (e :: IOException)
|
|
_ -> prlgError "load needs an atom"
|
|
|
|
{- actual prlgude -}
|
|
addPrelude :: PrlgEnv ()
|
|
addPrelude = do
|
|
pure undefined
|
|
{- primitives -}
|
|
addBi (pure Nothing) "true" 0
|
|
addBi backtrack "fail" 0
|
|
addOp $ O.xfx "=" 700
|
|
addProc [[U (LocalRef 0), U (LocalRef 0), NoGoal]] "=" 2
|
|
{- clauses -}
|
|
addOp $ O.xfy "," 1000
|
|
addOp $ O.xfx ":-" 1200
|
|
addOp $ O.fx ":-" 1200
|
|
horn1 <- findStruct ":-" 1
|
|
horn2 <- findStruct ":-" 2
|
|
let assertCode ac =
|
|
[ [ U (Struct horn2)
|
|
, U (LocalRef 0)
|
|
, U (LocalRef 1)
|
|
, Cut
|
|
, Invoke . bi $ assertRule ac
|
|
]
|
|
, [U (Struct horn1), U (LocalRef 0), Cut, Invoke $ bi exec]
|
|
, [U (LocalRef 0), Invoke . bi $ assertFact ac]
|
|
]
|
|
in do addProc (assertCode addClauseA) "asserta" 1
|
|
addProc (assertCode addClauseZ) "assertz" 1
|
|
addProc (assertCode addClauseZ) "assert" 1
|
|
addBi retractall "retractall" 1
|
|
addBi call "call" 1
|
|
{- terms -}
|
|
addBi struct "struct" 3
|
|
addBi var "var" 1
|
|
addBi same_term "same_term" 2
|
|
{- code loading -}
|
|
addBi (load False) "load" 1
|
|
addBi (load True) "source" 1
|
|
{- operators -}
|
|
addBi op "op" 3
|
|
addBi deop "deop" 1
|
|
addBi stashOps "stash_operators" 0
|
|
addBi popOps "pop_operators" 0
|
|
{- macroenvironment -}
|
|
addBi stashExpansions "stash_expansions" 0
|
|
addBi popExpansions "pop_expansions" 0
|
|
{- query tools -}
|
|
addBi printLocals "print_locals" 0
|
|
addBi promptRetry' "prompt_retry" 0
|
|
addBi (printLocals >> promptRetry) "query" 0
|
|
{- IO -}
|
|
addBi write "write" 1
|
|
addBi writeln "writeln" 1
|
|
addBi nl "nl" 0
|
|
{- debug -}
|
|
addBi (get >>= liftIO . print >> pure Nothing) "interpreter_trace" 0
|