(** Module: Faustexp Description: Faust expression evaluation @author WANG Haisheng Created: 03/06/2013 Modified: 04/08/2013 *) open Types;; open Basic;; open Value;; open Signal;; open Beam;; exception NotYetDone;; exception Dimension_error of string;; exception Process_error of string;; class dimension : int * int -> dimension_type = fun (init : int * int) -> object (self) val dim_input = fst init val dim_output = snd init method input = dim_input method output = dim_output method par : dimension_type -> dimension_type = fun dim -> new dimension ((self#input + dim#input), (self#output + dim#output)) method seq : dimension_type -> dimension_type = fun dim -> if self#output = dim#input then new dimension (self#input, dim#output) else raise (Dimension_error "seq dimension not matched.") method split : dimension_type -> dimension_type = fun dim -> if dim#input mod self#output = 0 then new dimension (self#input, dim#output) else raise (Dimension_error "split dimension not matched.") method merge : dimension_type -> dimension_type = fun dim -> if self#output mod dim#input = 0 then new dimension (self#input, dim#output) else raise (Dimension_error "merge dimension not matched.") method _rec : dimension_type -> dimension_type = fun dim -> if self#output >= dim#input && self#input >= dim#output then new dimension (self#input - dim#output, self#output) else raise (Dimension_error "rec dimension not matched.") end;; class process : faust_exp -> process_type = fun (exp_init : faust_exp) -> object (self) val exp = exp_init val left = match exp_init with | Const b -> exp_init | Ident s -> exp_init | Par (e1, e2) -> e1 | Seq (e1, e2) -> e1 | Split (e1, e2) -> e1 | Merge (e1, e2) -> e1 | Rec (e1, e2) -> e1 val right = match exp_init with | Const b -> exp_init | Ident s -> exp_init | Par (e1, e2) -> e2 | Seq (e1, e2) -> e2 | Split (e1, e2) -> e2 | Merge (e1, e2) -> e2 | Rec (e1, e2) -> e2 val proc_left = val dim = new dimension val delay = 0 method get_exp = exp method get_dim = dim method get_delay = delay method to_string = "NotYetDone" method virtual evaluate : beam_type -> beam_type end;; class proc_const : faust_exp -> process_type = fun (exp_init : faust_exp) -> object (self) val _exp = exp_init val _dim = new dimension (0,1) val _delay = 0 val _const = match exp_init with | Const b -> b | _ -> raise (Process_error "const process constructor.") method exp = _exp method dim = _dim method delay = _delay method const = _const method eval : beam_type -> beam_type = fun (input : beam_type) -> if input = [||] then new beam [| new signal 0 (fun t -> new value self#const)|] else raise (Process_error "proc_const accepts no input.") end;; class exp_ident : faust_exp -> process_type = fun (exp_init : faust_exp) -> object (self) val _exp = exp_init val _symbol = match exp_init with | Ident s -> s | _ -> raise (Process_error "ident process constructor.") val _dim = dimension_of_symbol _symbol val _delay = 0 method exp = _exp method dim = _dim method delay = _delay method const = _const method eval : beam_type -> beam_type = fun (input : beam_type) -> if input = [||] then new beam [| new signal 0 (fun t -> new value self#const)|] else raise (Process_error "proc_const accepts no input.") end;; class exp_par = object inherit expression end;; class exp_split = object inherit expression end;; class exp_merge = object inherit expression end;; class exp_seq = object inherit expression end;; class exp_rec = object inherit expression end;; *) (* PROCESS DELAY ESTIMATION *) (** val delay : faust_exp -> int, returns the number of delays estimated staticly. Attention: delays of "@" is estimated as 10 constant, delays of "vectorize" and "serialize" haven't been implemented, delays of "rdtable" hasn't been implemented.*) let rec delay exp_faust = match exp_faust with |Const v -> 0 |Ident s -> ( match s with |Add -> 0 |Sup -> 0 |Mul -> 0 |Div -> 0 |Pass -> 0 |Stop -> 0 |Mem -> 1 |Delay -> 100000 |Floor -> 0 |Int -> 0 |Sin -> 0 |Rdtable -> 100000 |Mod -> 0 |Larger -> 0 |Smaller -> 0 |Vectorize -> 100 |Concat -> 0 |Nth -> 0 |Serialize -> 0 |Prefix -> 1 |Selecttwo -> 0 |Selectthree -> 0 ) |Par (e1, e2) -> max (delay e1) (delay e2) |Seq (e1, e2) -> (delay e1) + (delay e2) |Split (e1, e2) -> (delay e1) + (delay e2) |Merge (e1, e2) -> (delay e1) + (delay e2) |Rec (e1, e2) -> delay e1;; (* PARSER *) (** val exp_of_string : string -> faust_exp, faust expression parser. *) let exp_of_string s = (Parser.main Lexer.token (Lexing.from_string s));; (* PROCESS DIMENSION ESTIMATION *) (* process dimension := (size of input beam, size of output beam).*) (** val get_root : dimension -> int * int, returns the root of dimension tree. *) let get_root = fun d_tree -> match d_tree with | End d -> d | Tree (d, branches) -> d;; (** val subtree : dimention -> int -> dimension, returns a subtree of dimension tree.*) let subtree = fun d_tree -> fun i -> match d_tree with | End d -> raise (Beam_Matching_Error "Subtree left absent.") | Tree (d, branches) -> ( match branches with (left, right) -> if i = 0 then left else right);; (** val subtree_left : dimension -> dimension, returns the left subtree of dimension tree.*) let subtree_left = fun d_tree -> subtree d_tree 0;; (** val subtree_right : dimension -> dimension, returns the right subtree of dimension tree.*) let subtree_right = fun d_tree -> subtree d_tree 1;; (** val dim : faust_exp -> int * int, returns dimension for faust expression, along with beam matching.*) let rec dim exp_faust = (** val dimension_constructor : ((int * int) -> (int * int) -> (int * int)) -> faust_exp -> faust_exp -> dimension, returns the dimension tree of constructor(e1, e2).*) let dimension_constructor = fun constructor -> fun e1 -> fun e2 -> let subtree1 = dim e1 in let subtree2 = dim e2 in let root = constructor (get_root subtree1) (get_root subtree2) in Tree (root, (subtree1, subtree2)) in match exp_faust with |Const v -> End (0, 1) |Ident s -> ( match s with |Add -> End (2, 1) |Sup -> End (2, 1) |Mul -> End (2, 1) |Div -> End (2, 1) |Pass -> End (1, 1) |Stop -> End (1, 0) |Mem -> End (1, 1) |Delay -> End (2, 1) |Floor -> End (1, 1) |Int -> End (1, 1) |Sin -> End (1, 1) |Rdtable -> End (3, 1) |Mod -> End (2, 1) |Vectorize -> End (2, 1) |Concat -> End (2, 1) |Nth -> End (2, 1) |Serialize -> End (1, 1) |Larger -> End (2, 1) |Smaller -> End (2, 1) |Prefix -> End (2, 1) |Selecttwo -> End (3, 1) |Selectthree -> End (4, 1) ) |Par (e1, e2) -> dimension_constructor d_par e1 e2 |Seq (e1, e2) -> dimension_constructor d_seq e1 e2 |Split (e1, e2) -> dimension_constructor d_split e1 e2 |Merge (e1, e2) -> dimension_constructor d_merge e1 e2 |Rec (e1, e2) -> dimension_constructor d_rec e1 e2;; (* AUXILIARY 'CONVERT_TO_STRING' FUNCTIONS *) (** val print_exp : faust_exp -> unit, print to console the input faust expression.*) let print_exp exp = let rec string_of_exp exp = match exp with |Const v -> "Const" ^ " (" ^ (string_of_value v) ^ ")" |Ident s -> "Ident" ^ " \"" ^ "s" ^ "\"" |Par (e1, e2) -> "Par" ^ " (" ^ (string_of_exp e1) ^ ", " ^ (string_of_exp e2) ^ ")" |Seq (e1, e2) -> "Seq" ^ " (" ^ (string_of_exp e1) ^ ", " ^ (string_of_exp e2) ^ ")" |Split (e1, e2) -> "Split" ^ " (" ^ (string_of_exp e1) ^ ", " ^ (string_of_exp e2) ^ ")" |Merge (e1, e2) -> "Merge" ^ " (" ^ (string_of_exp e1) ^ ", " ^ (string_of_exp e2) ^ ")" |Rec (e1, e2) -> "Rec" ^ " (" ^ (string_of_exp e1) ^ ", " ^ (string_of_exp e2) ^ ")" in print_string("Parer : Types.faust_exp = "^ (string_of_exp exp));;