CristalCaveGem » LustreC

(** The core language and its ast. Every element of the ast contains its

    location in the program text. The type and clock of an ast element

    is mutable (and initialized to dummy values). This avoids to have to

    duplicate ast structures (e.g. ast, typed_ast, clocked_ast). *)

type ident = Utils.ident

type label = Utils.ident

type rat = Utils.rat

type tag = Utils.tag

type constant =

  | Const_int of int

  | Const_real of string

  | Const_float of float

  | Const_array of constant list

  | Const_tag of label

  | Const_struct of (label * constant) list

type type_dec = LustreSpec.type_dec

let dummy_type_dec = {ty_dec_desc=Tydec_any; ty_dec_loc=Location.dummy_loc}

type clock_dec = LustreSpec.clock_dec

let dummy_clock_dec = {ck_dec_desc=Ckdec_any; ck_dec_loc=Location.dummy_loc}

type var_decl = LustreSpec.var_decl

(* The tag of an expression is a unique identifier used to distinguish

   different instances of the same node *)

type expr =

    {expr_tag: tag;

     expr_desc: expr_desc;

     mutable expr_type: Types.type_expr;

     mutable expr_clock: Clocks.clock_expr;

     mutable expr_delay: Delay.delay_expr;

     mutable expr_annot: LustreSpec.expr_annot option;

     expr_loc: Location.t}

and expr_desc =

  | Expr_const of constant

  | Expr_ident of ident

  | Expr_tuple of expr list

  | Expr_ite   of expr * expr * expr

  | Expr_arrow of expr * expr

  | Expr_fby of expr * expr

  | Expr_array of expr list

  | Expr_access of expr * Dimension.dim_expr

  | Expr_power of expr * Dimension.dim_expr

  | Expr_pre of expr

  | Expr_when of expr * ident * label

  | Expr_merge of ident * (label * expr) list

  | Expr_appl of call_t

  | Expr_uclock of expr * int

  | Expr_dclock of expr * int

  | Expr_phclock of expr * rat

 and call_t = ident * expr * (ident * label) option (* The third part denotes the reseting clock label and value *)

type eq =

    {eq_lhs: ident list;

     eq_rhs: expr;

     eq_loc: Location.t}

type assert_t = 

    {

      assert_expr: expr;

      assert_loc: Location.t

    } 

type node_desc =

    {node_id: ident;

     mutable node_type: Types.type_expr;

     mutable node_clock: Clocks.clock_expr;

     node_inputs: var_decl list;

     node_outputs: var_decl list;

     node_locals: var_decl list;

     mutable node_gencalls: expr list;

     mutable node_checks: Dimension.dim_expr list;

     node_asserts: assert_t list; 

     node_eqs: eq list;

     mutable node_dec_stateless: bool;

     mutable node_stateless: bool option;

     node_spec: LustreSpec.node_annot option;

     node_annot: LustreSpec.expr_annot option;

    }

type imported_node_desc =

    {nodei_id: ident;

     mutable nodei_type: Types.type_expr;

     mutable nodei_clock: Clocks.clock_expr;

     nodei_inputs: var_decl list;

     nodei_outputs: var_decl list;

     nodei_stateless: bool;

     nodei_spec: LustreSpec.node_annot option;

     nodei_prototype: string option;

     nodei_in_lib: string option;

    }

type const_desc = 

    {const_id: ident; 

     const_loc: Location.t; 

     const_value: constant;      

     mutable const_type: Types.type_expr;

    }

type top_decl_desc =

| Node of node_desc

| Consts of const_desc list

| ImportedNode of imported_node_desc

| Open of bool * string (* the boolean set to true denotes a local 

			   lusi vs a lusi installed at system level *)

type top_decl =

    {top_decl_desc: top_decl_desc;

     top_decl_loc: Location.t}

type program = top_decl list

type error =

    Main_not_found

  | Main_wrong_kind

  | No_main_specified

  | Unbound_symbol of ident

  | Already_bound_symbol of ident

let update_expr_annot e annot =

  { e with expr_annot = LustreSpec.merge_expr_annot e.expr_annot (Some annot) }

  | Expr_uclock(e, i), Expr_uclock(e', i') -> i=i' && is_eq_expr e e'

  | Expr_dclock(e, i), Expr_dclock(e', i') -> i=i' && is_eq_expr e e'

  | Expr_phclock(e, r), Expr_phclock(e', r') -> r=r' && is_eq_expr e e'

let node_vars nd =

let node_var id node =

 List.find (fun v -> v.var_id = id) (node_vars node)

let node_eq id node =

   | _ -> assert false

       | _                    -> assert false)

   | _ -> assert false

    Utils.option_map