text stringlengths 12 786k |
|---|
let empty_env = fun x -> complain ( x ^ " is not defined !\ n " ) |
let empty_store = fun x -> complain ( ( string_of_int x ) ^ " is not allocated !\ n " ) |
let interpret_top_level e = let ( v , _ ) = interpret ( e , empty_env , empty_store ) in v |
type value = | REF of address | INT of int | BOOL of bool | UNIT | PAIR of value * value | INL of value | INR of value | REC_CLOSURE of closure | CLOSURE of closure | UNARY of unary_oper | OPER of oper * value | OPER_FST of Ast . expr * env * Ast . oper | ASSIGN of value | ASSIGN_FST of Ast . e... |
type state = | EXAMINE of expr * env * continuation | COMPUTE of continuation * value |
let update ( env , ( x , v ) ) = ( x , v ) :: env |
let rec inlist x = function | [ ] -> false | y :: rest -> ( x = y ) || ( inlist x rest ) |
let rec filter_env fvars = function | [ ] -> [ ] | ( x , v ) :: rest -> if inlist x fvars then ( x , v ) :: ( filter_env fvars rest ) else ( filter_env fvars rest ) |
let mk_fun ( x , body , env ) = let fvars = Free_vars . free_vars ( [ x ] , body ) in let smaller_env = filter_env fvars env in CLOSURE ( x , body , smaller_env ) |
let mk_rec_fun ( f , x , body , env ) = let fvars = Free_vars . free_vars ( [ f ; x ] , body ) in let smaller_env = filter_env fvars env in let f_binding = ( f , REC_CLOSURE ( x , body , [ ] ) ) in CLOSURE ( x , body , f_binding :: smaller_env ) |
let lookup ( env , x ) = let rec aux = function | [ ] -> complain ( x ^ " is not defined !\ n " ) | ( y , v ) :: rest -> if x = y then match v with | REC_CLOSURE ( z , body , _ ) -> CLOSURE ( z , body , ( y , REC_CLOSURE ( z , body , [ ] ) ) :: rest ... |
let readint ( ) = let _ = print_string " input > " in read_int ( ) |
let do_unary = function | ( NOT , BOOL m ) -> BOOL ( not m ) | ( NEG , INT m ) -> INT ( - m ) | ( READ , UNIT ) -> INT ( readint ( ) ) | ( op , _ ) -> complain ( " malformed unary operator : " ^ ( string_of_unary_oper op ) ) |
let do_oper = function | ( AND , BOOL m , BOOL n ) -> BOOL ( m && n ) | ( OR , BOOL m , BOOL n ) -> BOOL ( m || n ) | ( EQB , BOOL m , BOOL n ) -> BOOL ( m = n ) | ( LT , INT m , INT n ) -> BOOL ( m < n ) | ( EQI , INT m , INT n ) -> BOOL ( m = n... |
let string_of_list sep f l = let rec aux f = function | [ ] -> " " | [ t ] -> ( f t ) | t :: rest -> ( f t ) ^ sep ^ ( aux f rest ) in " [ " ^ ( aux f l ) ^ " ] " |
let rec string_of_value = function | REF a -> " REF ( " ^ ( string_of_int a ) ^ " ) " | BOOL b -> string_of_bool b | INT n -> string_of_int n | UNIT -> " UNIT " | PAIR ( v1 , v2 ) -> " PAIR ( " ^ ( string_of_value v1 ) ^ " , " ^ ( string_of_value v2 ) ^ " ... |
let string_of_expr_list = string_of_list " ; " Ast . string_of_expr |
let string_of_continuation_action = function | UNARY op -> " UNARY " ^ ( string_of_unary_oper op ) | MKPAIR v -> " MKPAIR " ^ ( string_of_value v ) | FST -> " FST " | SND -> " SND " | MKINL -> " MKINL " | MKINR -> " MKINR " | APPLY v -> " APPLY " ^ ( string_of_val... |
let string_of_continuation = string_of_list " ; \ n " string_of_continuation_action |
let string_of_state = function | EXAMINE ( e , env , cnt ) -> " EXAMINE ( " ^ ( Ast . string_of_expr e ) ^ " , " ^ ( string_of_env env ) ^ " , " ^ ( string_of_continuation cnt ) ^ " ) " | COMPUTE ( cnt , v ) -> " COMPUTE ( " ^ ( string_of_continuat... |
let heap = Array . make Option . heap_max ( INT 0 ) |
let next_address = ref 0 |
let new_address ( ) = let a = ! next_address in ( next_address := a + 1 ; a ) |
let mk_ref v = let a = new_address ( ) in let _ = heap . ( a ) <- v in REF a |
let do_assign a v = ( heap . ( a ) <- v ) |
let step = function | EXAMINE ( UnaryOp ( op , e ) , env , k ) -> EXAMINE ( e , env , ( UNARY op ) :: k ) | EXAMINE ( Op ( e1 , op , e2 ) , env , k ) -> EXAMINE ( e1 , env , OPER_FST ( e2 , env , op ) :: k ) | EXAMINE ( If ( e1 , e2 , e3 ) , ... |
let rec driver n state = let _ = if Option . verbose then print_string ( " \ nstate " ^ ( string_of_int n ) ^ " = \ n " ^ ( string_of_state state ) ^ " \ n " ) else ( ) in match state with | COMPUTE ( [ ] , v ) -> v | _ -> driver ( n + 1 ) ( step state ) |
let eval ( e , env ) = driver 1 ( EXAMINE ( e , env , [ ] ) ) |
let interpret e = eval ( e , env_empty ) |
type value = | REF of address | INT of int | BOOL of bool | UNIT | PAIR of value * value | INL of value | INR of value | CLOSURE of closure | REC_CLOSURE of code | PUSH of value | LOOKUP of var | UNARY of unary_oper | OPER of oper | ASSIGN | SWAP | POP | BIND of var | FST | SND | DEREF | APPLY |... |
type env_or_value = EV of env | V of value |
type env_value_stack = env_or_value list |
type state = ( value array ) * int |
type interp_state = code * env_value_stack * state |
let string_of_list sep f l = let rec aux f = function | [ ] -> " " | [ t ] -> ( f t ) | t :: rest -> ( f t ) ^ sep ^ ( aux f rest ) in " [ " ^ ( aux f l ) ^ " ] " |
let rec string_of_value = function | REF a -> " REF ( " ^ ( string_of_int a ) ^ " ) " | BOOL b -> string_of_bool b | INT n -> string_of_int n | UNIT -> " UNIT " | PAIR ( v1 , v2 ) -> " ( " ^ ( string_of_value v1 ) ^ " , " ^ ( string_of_value v2 ) ^ " ) ... |
let string_of_env_or_value = function | EV env -> " EV " ^ ( string_of_env env ) | V v -> " V " ^ ( string_of_value v ) |
let string_of_env_value_stack = string_of_list " ; \ n " string_of_env_or_value |
let string_of_state ( heap , i ) = let rec aux k = if i < k in if i = 0 then " " else " \ nHeap = \ n " ^ ( aux 0 ) |
let string_of_interp_state ( c , evs , s ) = " \ nCode Stack = \ n " ^ ( string_of_code c ) ^ " \ nEnv / Value Stack = \ n " ^ ( string_of_env_value_stack evs ) ^ ( string_of_state ( s ) ) |
let allocate ( heap , i ) v = if i < Option . heap_max then let _ = heap . ( i ) <- v in ( i , ( heap , i + 1 ) ) else complain " runtime error : heap kaput " |
let deref ( heap , _ ) a = heap . ( a ) |
let assign ( heap , i ) a v = let _ = heap . ( a ) <- v in ( heap , i ) |
let update ( env , ( x , v ) ) = ( x , v ) :: env |
let mk_fun ( c , env ) = CLOSURE ( c , env ) |
let mk_rec ( f , c , env ) = CLOSURE ( c , ( f , REC_CLOSURE ( c ) ) :: env ) |
let lookup_opt ( env , x ) = let rec aux = function | [ ] -> None | ( y , v ) :: rest -> if x = y then Some ( match v with | REC_CLOSURE ( body ) -> mk_rec ( x , body , rest ) | _ -> v ) else aux rest in aux env |
let rec search ( evs , x ) = match evs with | [ ] -> complain ( x ^ " is not defined !\ n " ) | ( V _ ) :: rest -> search ( rest , x ) | ( EV env ) :: rest -> ( match lookup_opt ( env , x ) with | None -> search ( rest , x ) | Some v -> v ) let rec evs_to_... |
let readint ( ) = let _ = print_string " input > " in read_int ( ) |
let do_unary = function | ( NOT , BOOL m ) -> BOOL ( not m ) | ( NEG , INT m ) -> INT ( - m ) | ( READ , UNIT ) -> INT ( readint ( ) ) | ( op , _ ) -> complain ( " malformed unary operator : " ^ ( string_of_unary_oper op ) ) |
let do_oper = function | ( AND , BOOL m , BOOL n ) -> BOOL ( m && n ) | ( OR , BOOL m , BOOL n ) -> BOOL ( m || n ) | ( EQB , BOOL m , BOOL n ) -> BOOL ( m = n ) | ( LT , INT m , INT n ) -> BOOL ( m < n ) | ( EQI , INT m , INT n ) -> BOOL ( m = n... |
let step = function | ( ( PUSH v ) :: ds , evs , s ) -> ( ds , ( V v ) :: evs , s ) | ( POP :: ds , e :: evs , s ) -> ( ds , evs , s ) | ( SWAP :: ds , e1 :: e2 :: evs , s ) -> ( ds , e2 :: e1 :: evs , s ) | ( ( BIND x ) :: ds , ( V v )... |
let rec driver n state = let _ = if Option . verbose then print_string ( " \ nState " ^ ( string_of_int n ) ^ " : " ^ ( string_of_interp_state state ) ^ " \ n " ) else ( ) in match state with | ( [ ] , [ V v ] , s ) -> ( v , s ) | _ -> driver ( n + 1... |
let leave_scope = [ SWAP ; POP ] |
let rec compile = function | Unit -> [ PUSH UNIT ] | Integer n -> [ PUSH ( INT n ) ] | Boolean b -> [ PUSH ( BOOL b ) ] | Var x -> [ LOOKUP x ] | UnaryOp ( op , e ) -> ( compile e ) @ [ UNARY op ] | Op ( e1 , op , e2 ) -> ( compile e1 ) @ ( compile e2 )... |
let initial_state = ( Array . make Option . heap_max ( INT 0 ) , 0 ) |
let interpret e = let c = compile e in let _ = if Option . verbose then print_string ( " Compile code =\ n " ^ ( string_of_code c ) ^ " \ n " ) else ( ) in driver 1 ( c , initial_env , initial_state ) |
type location = label * ( address option ) |
type value = | REF of address | INT of int | BOOL of bool | UNIT | PAIR of value * value | INL of value | INR of value | CLOSURE of location * env | REC_CLOSURE of location | PUSH of value | LOOKUP of var | UNARY of unary_oper | OPER of oper | ASSIGN | SWAP | POP | BIND of var | FST | SND | DEREF... |
type env_or_value = | EV of env | V of value | RA of address |
type env_value_stack = env_or_value list |
type state = address * env_value_stack |
let update ( env , ( x , v ) ) = ( x , v ) :: env |
let rec lookup ( env , x ) = match env with | [ ] -> None | ( y , v ) :: rest -> if x = y then Some ( match v with | REC_CLOSURE ( loc ) -> CLOSURE ( loc , ( y , REC_CLOSURE loc ) :: rest ) | _ -> v ) else lookup ( rest , x ) |
let rec search ( evs , x ) = match evs with | [ ] -> complain ( x ^ " is not defined !\ n " ) | ( V _ ) :: rest -> search ( rest , x ) | ( RA _ ) :: rest -> search ( rest , x ) | ( EV env ) :: rest -> ( match lookup ( env , x ) with | None -> search ( ... |
let string_of_list sep f l = let rec aux f = function | [ ] -> " " | [ t ] -> ( f t ) | t :: rest -> ( f t ) ^ sep ^ ( aux f rest ) in " [ " ^ ( aux f l ) ^ " ] " |
let rec string_of_value = function | REF a -> " REF ( " ^ ( string_of_int a ) ^ " ) " | BOOL b -> string_of_bool b | INT n -> string_of_int n | UNIT -> " UNIT " | PAIR ( v1 , v2 ) -> " ( " ^ ( string_of_value v1 ) ^ " , " ^ ( string_of_value v2 ) ^ " ) ... |
let string_of_env_or_value = function | EV env -> " EV " ^ ( string_of_env env ) | V v -> " V " ^ ( string_of_value v ) | RA i -> " RA " ^ ( string_of_int i ) |
let string_of_env_value_stack = string_of_list " ; \ n " string_of_env_or_value |
let installed = ref ( Array . of_list [ HALT ] ) |
let string_of_installed_code ( ) = let size = Array . length ! installed in let rec aux k = if size = k ^ ( string_of_instruction ( ! installed . ( k ) ) ) ^ " \ n " ^ ( aux ( k + 1 ) ) in aux 0 |
let get_instruction cp = Array . get ! installed cp |
let heap = Array . make Option . heap_max ( INT 0 ) |
let next_address = ref 0 |
let new_address ( ) = let a = ! next_address in ( next_address := a + 1 ; a ) |
let string_of_heap ( ) = let rec aux k = if ! next_address < k in " \ nHeap = \ n " ^ ( aux 0 ) |
let string_of_state ( cp , evs ) = " \ nCode Pointer = " ^ ( string_of_int cp ) ^ " -> " ^ ( string_of_instruction ( get_instruction cp ) ) ^ " \ nStack = \ n " ^ ( string_of_env_value_stack evs ) ^ ( if ! next_address = 0 then " " else string_of_heap ( ) ) |
let readint ( ) = let _ = print_string " input > " in read_int ( ) |
let do_unary = function | ( NOT , BOOL m ) -> BOOL ( not m ) | ( NEG , INT m ) -> INT ( - m ) | ( READ , UNIT ) -> INT ( readint ( ) ) | ( op , _ ) -> complain ( " malformed unary operator : " ^ ( string_of_unary_oper op ) ) |
let do_oper = function | ( AND , BOOL m , BOOL n ) -> BOOL ( m && n ) | ( OR , BOOL m , BOOL n ) -> BOOL ( m || n ) | ( EQB , BOOL m , BOOL n ) -> BOOL ( m = n ) | ( LT , INT m , INT n ) -> BOOL ( m < n ) | ( EQI , INT m , INT n ) -> BOOL ( m = n... |
let step ( cp , evs ) = match ( get_instruction cp , evs ) with | ( PUSH v , evs ) -> ( cp + 1 , ( V v ) :: evs ) | ( POP , s :: evs ) -> ( cp + 1 , evs ) | ( SWAP , s1 :: s2 :: evs ) -> ( cp + 1 , s2 :: s1 :: evs ) | ( BIND x , ( V v ) ::... |
let new_label = let i = ref 0 in let get ( ) = let v = ! i in ( i := ( ! i ) + 1 ; " L " ^ ( string_of_int v ) ) in get |
let rec comp = function | Unit -> ( [ ] , [ PUSH UNIT ] ) | Integer n -> ( [ ] , [ PUSH ( INT n ) ] ) | Boolean b -> ( [ ] , [ PUSH ( BOOL b ) ] ) | Var x -> ( [ ] , [ LOOKUP x ] ) | UnaryOp ( op , e ) -> let ( defs , c ) = comp e i... |
let compile e = let ( defs , c ) = comp e in let result = c @ [ HALT ] @ defs in let _ = if Option . verbose then print_string ( " \ nCompiled Code = \ n " ^ ( string_of_code result ) ) else ( ) in result |
let rec driver n state = let _ = if Option . verbose then print_string ( " \ nstate " ^ ( string_of_int n ) ^ " " : ^ ( string_of_state state ) ^ " \ n " ) else ( ) in match state with | ( cp , evs ) -> if HALT = get_instruction cp then ( match evs with | [ V v ] ... |
let rec find lab = function | [ ] -> complain ( " find : " ^ lab ^ " is not found " ) | ( x , v ) :: rest -> if x = lab then v else find lab rest in let apply_label_map_to_instruction m = function | GOTO ( lab , _ ) -> GOTO ( lab , Some ( find lab m ) ) | TEST ( la... |
let interpret e = let c = compile e in let _ = installed := load c in let _ = if Option . verbose then print_string ( " \ nInstalled Code = \ n " ^ ( string_of_installed_code ( ) ) ) else ( ) in driver 1 ( 0 , [ ] ) |
type range = { mutable rbegin : int ; mutable rend : int ; } |
type t = { mutable reg : Reg . t ; mutable ibegin : int ; mutable iend : int ; mutable ranges : range list ; } |
type kind = Result | Argument | Live |
let interval_list = ref ( [ ] : t list ) |
let fixed_interval_list = ref ( [ ] : t list ) |
let overlap i0 i1 = let rec overlap_ranges rl0 rl1 = match rl0 , rl1 with r0 :: rl0 ' , r1 :: rl1 ' -> if r0 . rend >= r1 . rbegin && r1 . rend >= r0 . rbegin then true else if r0 . rend < r1 . rend then overlap_ranges rl0 ' rl1 else if r0 . rend > r1 . rend then overlap_ranges rl0 r... |
let is_live i pos = let rec is_live_in_ranges = function [ ] -> false | r :: rl -> if pos < r . rbegin then false else if pos <= r . rend then true else is_live_in_ranges rl in is_live_in_ranges i . ranges |
let remove_expired_ranges i pos = let rec filter = function [ ] -> [ ] | r :: rl ' as rl -> if pos < r . rend then rl else filter rl ' in i . ranges <- filter i . ranges |
let update_interval_position intervals pos kind reg = let i = intervals . ( reg . stamp ) in let on = pos lsl 1 in let off = on + 1 in let rbegin = ( match kind with Result -> off | _ -> on ) in let rend = ( match kind with Argument -> on | _ -> off ) in if i . iend = 0 then begin i... |
let update_interval_position_by_array intervals regs pos kind = Array . iter ( update_interval_position intervals pos kind ) regs |
let update_interval_position_by_set intervals regs pos kind = Set . iter ( update_interval_position intervals pos kind ) regs |
let update_interval_position_by_instr intervals instr pos = update_interval_position_by_array intervals instr . arg pos Argument ; update_interval_position_by_array intervals instr . res pos Result ; update_interval_position_by_set intervals instr . live pos Live |
let insert_destroyed_at_oper intervals instr pos = let destroyed = Proc . destroyed_at_oper instr . desc in if Array . length destroyed > 0 then update_interval_position_by_array intervals destroyed pos Result |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.