CristalCaveGem » LustreC

#include <assert.h>

#include "arrow.h"

  struct _arrow_mem *_alloc;

  _alloc = (struct _arrow_mem *) malloc(sizeof(struct _arrow_mem *));

  assert (_alloc);

  return _alloc;

}

extern struct _arrow_mem *_arrow_alloc ();

#define _arrow_DECLARE(attr, inst)\

  attr struct _arrow_mem inst;

let pp_machine_memtype_name fmt id = fprintf fmt "struct %s_mem" id

let pp_machine_regtype_name fmt id = fprintf fmt "struct %s_reg" id

let pp_machine_alloc_name fmt id = fprintf fmt "%s_alloc" id

let pp_machine_static_declare_name fmt id = fprintf fmt "%s_DECLARE" id

let pp_machine_static_link_name fmt id = fprintf fmt "%s_LINK" id

let pp_machine_static_alloc_name fmt id = fprintf fmt "%s_ALLOC" id

    pp_machine_alloc_name name

    (Utils.fprintf_list ~sep:",@ " pp_c_decl_input_var) static

let print_reset_prototype self fmt (name, static) =

  fprintf fmt "void %a (@[<v>%a%t%a *%s@])"

    pp_machine_reset_name name

let print_extern_alloc_prototypes fmt (Dep (_,_, header,_)) =

  List.iter (fun decl -> match decl.top_decl_desc with

  | ImportedNode ind when not ind.nodei_stateless ->

  | _                -> ()

  ) header

	  begin 

            (* Dynamic allocation *)

	    fprintf fmt "extern %a;@.@."

	  end;

	let self = mk_self m in

	fprintf fmt "extern %a;@.@."

      else

	begin 

          (* Dynamic allocation *)

	end

    end

    pp_machine_alloc_name (node_name m)

    (Utils.fprintf_list ~sep:", " Dimension.pp_dimension) static

let print_alloc_const fmt m =

  let const_locals = List.filter (fun vdecl -> vdecl.var_dec_const) m.mstep.step_locals in

  fprintf fmt "%a%t"

    (pp_c_type "") base_type

    vdecl.var_id

let print_alloc_code fmt m =

  let array_mem = List.filter (fun v -> Types.is_array_type v.var_type) m.mmemory in

  fprintf fmt "%a *_alloc;@,_alloc = (%a *) malloc(sizeof(%a));@,assert(_alloc);@,%a%areturn _alloc;"

    (Utils.fprintf_list ~sep:"" print_alloc_array) array_mem

    (Utils.fprintf_list ~sep:"" print_alloc_instance) m.minstances

let print_stateless_init_code dependencies fmt m self =

  let minit = List.map (function MReset i -> i | _ -> assert false) m.minit in

  let array_mems = List.filter (fun v -> Types.is_array_type v.var_type) m.mmemory in

    end

  else

    begin

      if (not !Options.static_mem) then  

	begin

	  fprintf fmt "@[<v 2>%a {@,%a%a@]@,}@.@."

	    print_alloc_prototype (m.mname.node_id, m.mstatic)

	    print_alloc_const m

	    print_alloc_code m;

	end;

      let self = mk_self m in

      (* Reset function *)

      fprintf source_fmt "@]@.";

      fprintf source_fmt "/* Node allocation function prototypes */@.";

      fprintf source_fmt "@[<v>";

      fprintf source_fmt "@]@.";

    end;