st/lama_byterun
1
0
Fork 0
mirror of https://github.com/ProgramSnail/Lama.git synced 2025-12-05 22:38:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Procedures in SM

Browse source
This commit is contained in:
Dmitry Boulytchev 2018-03-27 03:13:00 +03:00
parent b4ef95c8bc
commit 087bdfd10a
3 changed files with 65 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

2
regression/Makefile
View file

@ -9,7 +9,7 @@ check: $(TESTS)
$(TESTS): %: %.expr
# @$(RC) $< && cat $@.input | ./$@ > $@.log && diff $@.log orig/$@.log
@cat $@.input | $(RC) -i $< > $@.log && diff $@.log orig/$@.log
# @cat $@.input | $(RC) -s $< > $@.log && diff $@.log orig/$@.log
@cat $@.input | $(RC) -s $< > $@.log && diff $@.log orig/$@.log
clean:
rm -f test*.log *.s *~ $(TESTS)

2
src/Driver.ml
View file

@ -42,7 +42,7 @@ let main =
let output =
if interpret
then Language.eval prog input
else failwith "Not implemented yet" (*SM.run (SM.compile prog) input*)
else SM.run (SM.compile prog) input
in
List.iter (fun i -> Printf.printf "%d\n" i) output
| `Fail er -> Printf.eprintf "Syntax error: %s\n" er

91
src/SM.ml
View file

@ -11,15 +11,18 @@ open Language
(* store a variable from the stack *) | ST of string
(* a label *) | LABEL of string
(* unconditional jump *) | JMP of string
(* conditional jump *) | CJMP of string * string with show
(* conditional jump *) | CJMP of string * string
(* begins procedure definition *) | BEGIN of string list * string list
(* end procedure definition *) | END
(* calls a procedure *) | CALL of string with show
(* The type for the stack machine program *)
type prg = insn list
(* The type for the stack machine configuration: a stack and a configuration from statement
(* The type for the stack machine configuration: control stack, stack and configuration from statement
interpreter
*)
type config = int list * Stmt.config
type config = (prg * State.t) list * int list * Stmt.config
(* Stack machine interpreter
@ -28,19 +31,31 @@ type config = int list * Stmt.config
Takes an environment, a configuration and a program, and returns a configuration as a result. The
environment is used to locate a label to jump to (via method env#labeled <label_name>)
*)
let rec eval env ((stack, ((st, i, o) as c)) as conf) = function
let rec eval env ((cstack, stack, ((st, i, o) as c)) as conf) = function
| [] -> conf
| insn :: prg' ->
(match insn with
| BINOP op -> let y::x::stack' = stack in eval env (Expr.to_func op x y :: stack', c) prg'
| READ -> let z::i' = i in eval env (z::stack, (st, i', o)) prg'
| WRITE -> let z::stack' = stack in eval env (stack', (st, i, o @ [z])) prg'
| CONST i -> eval env (i::stack, c) prg'
| LD x -> eval env (State.eval st x :: stack, c) prg'
| ST x -> let z::stack' = stack in eval env (stack', (State.update x z st, i, o)) prg'
| LABEL _ -> eval env conf prg'
| JMP l -> eval env conf (env#labeled l)
| CJMP (c, l) -> let x::stack' = stack in eval env conf (if (c = "z" && x = 0) || (c = "nz" && x <> 0) then env#labeled l else prg')
| BINOP op -> let y::x::stack' = stack in eval env (cstack, Expr.to_func op x y :: stack', c) prg'
| READ -> let z::i' = i in eval env (cstack, z::stack, (st, i', o)) prg'
| WRITE -> let z::stack' = stack in eval env (cstack, stack', (st, i, o @ [z])) prg'
| CONST i -> eval env (cstack, i::stack, c) prg'
| LD x -> eval env (cstack, State.eval st x :: stack, c) prg'
| ST x -> let z::stack' = stack in eval env (cstack, stack', (State.update x z st, i, o)) prg'
| LABEL _ -> eval env conf prg'
| JMP l -> eval env conf (env#labeled l)
| CJMP (c, l) -> let x::stack' = stack in eval env conf (if (c = "z" && x = 0) || (c = "nz" && x <> 0) then env#labeled l else prg')
| CALL f -> eval env ((prg', st)::cstack, stack, c) (env#labeled f)
| BEGIN (args, locals) -> let rec combine acc args stack =
match args, stack with
| [], _ -> List.rev acc, stack
| a::args', s::stack' -> combine ((a, s)::acc) args' stack'
in
let state', stack' = combine [] args stack in
eval env (cstack, stack', (List.fold_left (fun s (x, v) -> State.update x v s) (State.push_scope st (args @ locals)) state', i, o)) prg'
| END -> (match cstack with
| (prg', st')::cstack' -> eval env (cstack', stack, (State.drop_scope st st', i, o)) prg'
| [] -> conf
)
)
(* Top-level evaluation
@ -57,53 +72,73 @@ let run p i =
| _ :: tl -> make_map m tl
in
let m = make_map M.empty p in
let (_, (_, _, o)) = eval (object method labeled l = M.find l m end) ([], (State.empty, i, [])) p in o
let (_, _, (_, _, o)) = eval (object method labeled l = M.find l m end) ([], [], (State.empty, i, [])) p in o
(* Stack machine compiler
val compile : Language.Stmt.t -> prg
val compile : Language.t -> prg
Takes a program in the source language and returns an equivalent program for the
stack machine
*)
let compile p =
let compile (defs, p) =
let label s = "L" ^ s in
let rec expr = function
| Expr.Var x -> [LD x]
| Expr.Const n -> [CONST n]
| Expr.Binop (op, x, y) -> expr x @ expr y @ [BINOP op]
in
let rec compile' l env = function
let rec compile_stmt l env = function
| Stmt.Read x -> env, false, [READ; ST x]
| Stmt.Write e -> env, false, expr e @ [WRITE]
| Stmt.Assign (x, e) -> env, false, expr e @ [ST x]
| Stmt.Skip -> env, false, []
| Stmt.Seq (s1, s2) -> let l2, env = env#get_label in
let env, flag1, s1 = compile' l2 env s1 in
let env, flag2, s2 = compile' l env s2 in
let env, flag1, s1 = compile_stmt l2 env s1 in
let env, flag2, s2 = compile_stmt l env s2 in
env, flag2, s1 @ (if flag1 then [LABEL l2] else []) @ s2
| Stmt.If (c, s1, s2) -> let l2, env = env#get_label in
let env, flag1, s1 = compile' l env s1 in
let env, flag2, s2 = compile' l env s2 in
let env, flag1, s1 = compile_stmt l env s1 in
let env, flag2, s2 = compile_stmt l env s2 in
env, true, expr c @ [CJMP ("z", l2)] @ s1 @ (if flag1 then [] else [JMP l]) @ [LABEL l2] @ s2 @ (if flag2 then [] else [JMP l])
| Stmt.While (c, s) -> let loop, env = env#get_label in
let cond, env = env#get_label in
let env, _, s = compile' cond env s in
let env, _, s = compile_stmt cond env s in
env, false, [JMP cond; LABEL loop] @ s @ [LABEL cond] @ expr c @ [CJMP ("nz", loop)]
| Stmt.Repeat (s, c) -> let loop , env = env#get_label in
let check, env = env#get_label in
let env , flag, body = compile' check env s in
let env , flag, body = compile_stmt check env s in
env, false, [LABEL loop] @ body @ (if flag then [LABEL check] else []) @ (expr c) @ [CJMP ("z", loop)]
| Stmt.Call (f, args) -> let args_code = List.concat @@ List.map expr (List.rev args) in
env, false, args_code @ [CALL (label f)]
in
let compile_def env (name, (args, locals, stmt)) =
let lend, env = env#get_label in
let env, flag, code = compile_stmt lend env stmt in
env,
[LABEL name; BEGIN (args, locals)] @
code @
(if flag then [LABEL lend] else []) @
[END]
in
let env =
object
val label = 0
method get_label = "L_" ^ string_of_int label, {< label = label + 1 >}
val ls = 0
method get_label = (label @@ string_of_int ls), {< ls = ls + 1 >}
end
in
let env, def_code =
List.fold_left
(fun (env, code) (name, others) -> let env, code' = compile_def env (label name, others) in env, code'::code)
(env, [])
defs
in
let lend, env = env#get_label in
let _, flag, code = compile' lend env p in
if flag then code @ [LABEL lend] else code
let _, flag, code = compile_stmt lend env p in
(LABEL "main" :: if flag then code @ [LABEL lend] else code) @ [END] @ (List.concat def_code)