Project

General

Profile

Download (3.02 KB) Statistics
| Branch: | Tag: | Revision:
1

    
2
  
3
type backend = GenLus | GenImp
4

    
5
(* Model choice *)
6
let model_name = ref "simple"
7

    
8
let models = [(module Model_simple : Datatype.MODEL_T);
9
	      (module Model_stopwatch : Datatype.MODEL_T);
10
	     (*  (module Model_medium : Datatype.MODEL_T)*)
11
	     ]
12
let get_model_name m = let module M = (val m : Datatype.MODEL_T) in M.name
13
let set_model name = 
14
  if List.exists (fun n -> get_model_name n = name) models then
15
    model_name := name
16
  else failwith ("incorrect model name. Use " ^
17
		    (List.fold_left (fun r n -> r ^ " or " ^ get_model_name n) "" models))
18

    
19
(* Backend selection *)
20
let modular = ref 0
21
let set_modular i = modular := i
22

    
23
let mode = ref GenLus
24
  
25
     
26
let set_mode m =
27
  mode := m
28

    
29
(* Main *)
30
    
31
let options = [
32
  "-model", Arg.String set_model, "model in {simple, stopwatch} (default: simple)";
33
  (* "-eval", Arg.Int set_trace_run_mode, "execute the model on trace <int>"; *)
34
  (* "-eval-mode", Arg.String set_eval_mode, "select evaluator: cps"; *)
35
  "-gen_c", Arg.Unit (fun _ -> set_mode GenImp), "generate imperative code";
36
  "-gen_lustre", Arg.Unit (fun _ -> set_mode GenLus), "generate lustre model";
37
  "-modular", Arg.Int set_modular, "generate modular code (either for imperative or lustre backend) 0 is not modular, 1 modularize nodes, 2 modularize entry, during and exit actions (default 0)"
38
]
39

    
40
let usage =
41
  "lustresf [JSON file] takes as input a stateflow model in the JSON format and a backend.\n"^
42
    "Backends are eother the C code generator or the lustre code generator."
43

    
44
    
45
let _ =
46
  Arg.parse options (fun _ -> ()) usage;
47
  let model = List.find (fun m -> get_model_name m = !model_name) models in
48
  let modularmode =
49
    match !modular with
50
    | 2 -> true, true, true
51
    | 1 -> false, true, false
52
    | _ (* 0 *) -> false, false ,false
53
  in
54
  match !mode with
55
  | GenImp -> (
56
    let module Model = (val model) in
57
    let module T = CPS_ccode_generator.CodeGenerator in
58
    let module Sem = CPS.Semantics (T) (Model) in
59
    let _ = Sem.code_gen modularmode in
60
    ()
61
  )				     
62
  | GenLus ->
63
     let module Model = (val model) in
64
     let state_vars = Datatype.SF.states Model.model in
65
     let global_vars = Datatype.SF.global_vars Model.model in
66
     
67
     let module T = CPS_lustre_generator.LustrePrinter (struct
68
       let state_vars = state_vars
69
       let global_vars = global_vars 
70
     end) in
71
     let module Sem = CPS.Semantics (T) (Model) in
72
     let prog = Sem.code_gen modularmode in
73

    
74
     Format.printf "%a@." Printers.pp_prog prog;
75

    
76
     let prog, deps = Main_lustre_compiler.stage1 prog "" "" in
77

    
78
     
79
     (* (\* Importing source *\) *)
80
     (* let _ = Modules.load_program Utils.ISet.empty prog in *)
81

    
82
     (* (\* Extracting dependencies *\) *)
83
     (* let dependencies, type_env, clock_env = Compiler_common.import_dependencies prog in *)
84

    
85

    
86
     (* (\* Typing *\) *)
87
     (* let computed_types_env = Compiler_common.type_decls type_env prog in *)
88
     
89
     (* (\* Clock calculus *\) *)
90
     (* let computed_clocks_env = Compiler_common.clock_decls clock_env prog in *)
91

    
92
     Format.printf "%a@." Printers.pp_prog prog
93

    
94

    
95
  
(3-3/3)