88 lines
2.5 KiB
OCaml
88 lines
2.5 KiB
OCaml
open Ast
|
|
|
|
let rec list_select n = function
|
|
| [] -> [], []
|
|
| h :: t ->
|
|
if n = 0
|
|
then ([], h :: t)
|
|
else
|
|
let p1, p2 = list_select (n-1) t in
|
|
h :: p1, p2
|
|
|
|
let rec list_map_option (f: 'a -> 'b option) (l: 'a list) : 'b list option =
|
|
List.fold_right (fun elt acc ->
|
|
match acc, f elt with
|
|
| None, _ | _, None -> None
|
|
| Some acc, Some elt -> Some (elt :: acc)) l (Some [])
|
|
|
|
let rec list_repeat n elt =
|
|
if n = 0 then [] else elt :: (list_repeat (n-1) elt)
|
|
|
|
let rec list_chk v = function
|
|
| [] -> false
|
|
| h :: t -> if h = v then true else list_chk v t
|
|
|
|
exception MyParsingError of (string * location)
|
|
|
|
let type_const = function
|
|
| CReal _ -> [TReal]
|
|
| CInt _ -> [TInt ]
|
|
| CBool _ -> [TBool]
|
|
|
|
let type_var (v: t_var) =
|
|
match v with
|
|
| IVar _ -> [TInt]
|
|
| BVar _ -> [TBool]
|
|
| RVar _ -> [TReal]
|
|
|
|
let type_exp : t_expression -> full_ty = function
|
|
| EVar (full_ty , _) -> full_ty
|
|
| EMonOp (full_ty , _ , _) -> full_ty
|
|
| EBinOp (full_ty , _ , _ , _) -> full_ty
|
|
| ETriOp (full_ty , _ , _ , _ , _) -> full_ty
|
|
| EComp (full_ty , _ , _ , _) -> full_ty
|
|
| EWhen (full_ty , _ , _) -> full_ty
|
|
| EReset (full_ty , _ , _) -> full_ty
|
|
| EConst (full_ty , _) -> full_ty
|
|
| ETuple (full_ty , _) -> full_ty
|
|
| EApp (full_ty , _ , _) -> full_ty
|
|
|
|
let somify f = fun e -> Some (f e)
|
|
|
|
let name_of_var: t_var -> ident = function
|
|
| IVar s -> s
|
|
| BVar s -> s
|
|
| RVar s -> s
|
|
|
|
let rec fresh_var_name (l: t_varlist) n : ident =
|
|
let rec aux acc n =
|
|
let r = Random.int 26 in
|
|
Format.asprintf "%c%s"
|
|
(char_of_int (r + (if Random.bool () then 65 else 97)))
|
|
(if n = 0 then acc else aux acc (n-1))
|
|
in
|
|
let name = aux "" n in
|
|
if List.filter (fun v -> name_of_var v = name) (snd l) = []
|
|
then name
|
|
else fresh_var_name l n
|
|
|
|
let vars_of_patt patt = List.map name_of_var (snd patt)
|
|
|
|
let rec vars_of_expr (expr: t_expression) : ident list =
|
|
match expr with
|
|
| EConst _ -> []
|
|
| EVar (_, v) -> [name_of_var v]
|
|
(** pre (e) does not rely on anything in this round *)
|
|
| EMonOp (_, MOp_pre, _) -> []
|
|
| EApp (_, _, e) | EMonOp (_, _, e) -> vars_of_expr e
|
|
| EComp (_, _, e, e') | EReset (_, e, e') | EBinOp (_, _, e, e')
|
|
| EWhen (_, e, e') ->
|
|
(vars_of_expr e) @ (vars_of_expr e')
|
|
| ETriOp (_, _, e, e', e'') ->
|
|
(vars_of_expr e) @ (vars_of_expr e') @ (vars_of_expr e'')
|
|
| ETuple (_, l) -> List.flatten (List.map vars_of_expr l)
|
|
|
|
let rec varlist_concat (l1: t_varlist) (l2: t_varlist): t_varlist =
|
|
(fst l1 @ fst l2, snd l1 @ snd l2)
|
|
|