Environments, Stores, and Interpreters

Environments, Stores, and Interpreters

Overview

• As we study languages we will build small languages that illustrate language features

• We will use two tools– Observational semantic judgements– Small interpreters

• These tools convey the same information at different levels of detail.

Interpreters

• Programs that detail the same issues as an observational semantics– Operations on environments and stores• E(x)• E+{x v}• Dom(E)• S(l)• S+{l v}• Dom(S)

Values

type Addr = Intdata Value = IntV Int -- An Int | PairV Addr -- Or an address -- into the heap

Tables in hw3.hs

• Tables are like dictionaries storing objects indexed by a key.

-- A table maps keys to objectsdata Table key object = Tab [(key,object)]type Env a = Table String a -- A Table where the key is a String

Lookup and Searching Tables

-- When searching an Env one returns a Resultdata Result a = Found a | NotFound

search :: Eq key => key -> [(key, a)] -> Result asearch x [] = NotFoundsearch x ((k,v):rest) = if x==k then Found v else search x rest

-- Search a TablelookUp :: Eq key => Table key a -> key -> Result alookUp (Tab xs) k = search k xs

Updating Tables

• Update is done by making a new changed copy

-- update a Table at a given key.update n u ((m,v):rest) | n==m = (m,u):restupdate n u (r:rest) = r : update n u restupdate n u [] = error ("Unknown address: "++show n++ " in update")

Environments in hw3.hs

-- A Table where the key is a Stringtype Env a = Table String a

-- Operations on EnvemptyE = Tab [] --

extend key value (Tab xs) = -- E+{x v} Tab ((key,value):xs)

-- E+{x1 v1, x2 v2, … , xn vn}

push pairs (Tab xs) = Tab(pairs ++ xs)

Stores and Heaps• In language E3, the store is implemented by a heap.

Heaps are indexed by addresses (int)

type Heap = [Value]

-- State contains just a Heapdata State = State Heap

-- Access the State for the Value -- at a given Address S(n)access n (State heap) = heap !! n

(list !! n) is the get element at position n. The first element

is at position 0

Allocating on the heap S+{l v}

-- Allocate a new location in the heap. Intitialize it-- with a value, and return its Address and a new heap.

alloc :: Value -> State -> (Addr,State)alloc value (State heap) = (addr,State (heap ++ [value])) where addr = length heap

Note that allocation creates a new copy of the heap with one more location

Multiple allocations

(fun f (x y z) (+ x (* y z)))(@ f 3 5 8)• We need to create 3 new locations on the

heap and note where the formal parameters (x,y,z) are stored

• E {x l1,y l2,z l3}

• S {l1 3,l2 5,l3 8})

Codebind:: [String] -> [Value] -> State -> ([(Vname,Addr)],State)bind names objects state = loop (zip names objects) state where loop [] state = ([],state) loop ((nm,v):more) state = ((nm,ad):xs,state3) where (ad,state2) = alloc v state (xs,state3) = loop more state2

Example

bind [a,b,c] [IntV 3,IntV 7,IntV 1] (State [IntV 17])

• returns the pair

( [(a,1),(b,2),(c,3)], State [IntV 17,IntV 3,IntV 7,IntV 1])

Heap update

• Makes a new copy of the heap with a different object at the given address.

-- Update the State at a given AdressstateStore addr u (State heap) = State (update addr heap) where update 0 (x:xs) = (u:xs) update n (x:xs) = x : update (n-1) xs update n [] = error ("Address "++show addr++ " too large for heap.")

Example

Allocate 1 (St [IntV 3,IntV 7] )

Returns

(2, St [IntV 3,IntV 7,IntV 1] )

The interpreter

• It implements the observational rules but has more detail.

• It also adds the ability to trace a computation.

interpE :: Env (Env Addr,[Vname],Exp) -- The function name space -> Env Addr -- the variable name space -> State -- the state, a heap -> Exp -- the Exp to interpret -> IO(Value,State) -- (result,new_state)

interpE funs vars state exp = (traceG vars) run state exp where run state (Var v) = case lookUp vars v of Found addr -> return(access addr state,state) NotFound -> error ("Unknown variable: "++v++" in lookup.")

--- … many more cases

Constant and assignment case run state (Int n) = return(IntV n,state) run state (Asgn v e ) = do { (val,state2) <- interpE funs vars state e ; case lookUp vars v of Found addr -> return(val,stateStore addr val state2) NotFound -> error ("\nUnknown variable: "++ v++" in assignment.") }

Notes on pairs

• Pairs are allocated in consecutive locations on the heaprun state (Pair x y) = do { (v1,s1) <- interpE funs vars state x ; (v2,s2) <- interpE funs vars s1 y ; let (a1,s3) = alloc v1 s2 (a2,s4) = alloc v2 s3 ; return(PairV a1,s4)}

a1 and a2 should be consecutive

locations

Runtime checking of errors

• Numeric operations (+, *, <=, etc) only operate on (IntV n) and must raise an error on (PairV a)

run state (Add x y) = do { (v1,state1) <- interpE funs vars state x ; (v2,state2) <- interpE funs vars state1 y ; return(numeric state2 "+" (+) v1 v2,state2) }

numeric :: State -> String -> (Int -> Int -> Int) -> Value -> Value -> Valuenumeric st name fun (IntV x) (IntV y) = IntV(fun x y)numeric st name fun (v@(PairV _)) _ = error ("First arg of "++name++ " is not an Int. "++showV (v,st))numeric st name fun _ (v@(PairV _)) = error ("Second arg of "++name++ " is not an Int. "++ showV (v,st))