Project

General

Profile

« Previous | Next » 

Revision 65de9931

Added by Pierre-Loïc Garoche about 5 years ago

New feature to specify the number of digits to be printed

View differences:

include/io_frontend.c
67 67
  printf("'%i' ", (_V)? 1 : 0);
68 68
  printf("\n");
69 69
  fprintf(file, "%i\n", _V);
70
  fflush(file);
70 71
}
72

  
71 73
void _put_int(FILE* file, char* n, int _V){
72 74
  if(ISATTY) {
73 75
    printf("%s = ", n);
......
77 79
  printf("'%d' ", _V);
78 80
  printf("\n");
79 81
  fprintf(file, "%d\n", _V);
82
  fflush(file);
80 83
}
81 84

  
82
void _put_float(FILE* file, char* n, float _V){
85
void _put_float(FILE* file, char* n, float _V, int PREC){
83 86
  if(ISATTY) {
84 87
    printf("%s = ", n);
85 88
  } else {
......
88 91
  printf("'%.*f' ", PREC, _V);
89 92
  printf("\n");
90 93
  fprintf(file, "%.*f\n", PREC, _V);
94
  fflush(file);
91 95
}
92 96

  
93
void _put_double(FILE* file, char* n, double _V){
97
void _put_double(FILE* file, char* n, double _V, int PREC){
94 98
  if(ISATTY) {
95 99
    printf("%s = ", n);
96 100
  } else {
......
99 103
  printf("'%.*f' ", PREC, _V);
100 104
  printf("\n");
101 105
  fprintf(file, "%.*f\n", PREC, _V);
106
  fflush(file);
102 107
}
include/io_frontend.h
23 23
extern void _put_int(FILE* file, char* n, int _V);
24 24

  
25 25
/*@ assigns \nothing; */
26
extern void _put_float(FILE* file, char* n, float _V);
26
extern void _put_float(FILE* file, char* n, float _V, int PREC);
27 27

  
28 28
/*@ assigns \nothing; */
29
extern void _put_double(FILE* file, char* n, double _V);
29
extern void _put_double(FILE* file, char* n, double _V, int PREC);
30 30

  
31 31
#endif
include/io_frontend.hpp
69 69
  printf("'%i' ", (_V)? 1 : 0);
70 70
  printf("\n");
71 71
  fprintf(file, "%i\n", _V);
72
  fflush(file);
72 73
}
73 74

  
74 75
void _put_int(FILE* file, char* n, int _V){
......
80 81
  printf("'%d' ", _V);
81 82
  printf("\n");
82 83
  fprintf(file, "%d\n", _V);
84
  fflush(file);
83 85
}
84 86

  
85
void _put_float(FILE* file, char* n, float _V){
87
void _put_float(FILE* file, char* n, float _V, int PREC){
86 88
  if(ISATTY) {
87 89
    printf("%s = ", n);
88 90
  } else {
......
91 93
  printf("'%.*f' ", PREC, _V);
92 94
  printf("\n");
93 95
  fprintf(file, "%.*f\n", PREC, _V);
96
  fflush(file);
94 97
}
95 98

  
96
void _put_double(FILE* file, char* n, double _V){
99
void _put_double(FILE* file, char* n, double _V, int PREC){
97 100
  if(ISATTY) {
98 101
    printf("%s = ", n);
99 102
  } else {
......
102 105
  printf("'%.*f' ", PREC, _V);
103 106
  printf("\n");
104 107
  fprintf(file, "%.*f\n", PREC, _V);
108
  fflush(file);
105 109
}
106 110

  
111

  
107 112
#endif
src/backends/C/c_backend_common.ml
646 646
    aux [] fmt (List.hd inputs).value_type
647 647
  end
648 648

  
649

  
650
(*** Common functions for main ***)
651

  
652
let print_put_var fmt file_suffix name var_type var_id =
653
  match (Types.unclock_type var_type).Types.tdesc with
654
  | Types.Tint -> fprintf fmt "_put_int(f_out%s, \"%s\", %s)" file_suffix name var_id
655
  | Types.Tbool -> fprintf fmt "_put_bool(f_out%s, \"%s\", %s)" file_suffix name var_id
656
  | Types.Treal when !Options.mpfr -> fprintf fmt "_put_double(f_out%s, \"%s\", mpfr_get_d(%s, %s), %i)" file_suffix name var_id (Mpfr.mpfr_rnd ()) !Options.print_prec_double
657
  | Types.Treal -> fprintf fmt "_put_double(f_out%s, \"%s\", %s, %i)" file_suffix name var_id !Options.print_prec_double
658
  | _ -> Format.eprintf "Impossible to print the _put_xx for type %a@.@?" Types.print_ty var_type; assert false
659

  
649 660
(* Local Variables: *)
650 661
(* compile-command:"make -C ../../.." *)
651 662
(* End: *)
src/backends/C/c_backend_main.ml
51 51
    fprintf fmt "@ %a;" pi ((idx+1), v', v);
52 52
  ) m.mname.node_inputs m.mstep.step_inputs
53 53

  
54
    
54 55
let print_put_outputs fmt m = 
55 56
  let po fmt (id, o', o) =
56
    match (Types.unclock_type o.var_type).Types.tdesc with
57
    | Types.Tint -> fprintf fmt "_put_int(f_out%i, \"%s\", %s)" id o'.var_id o.var_id
58
    | Types.Tbool -> fprintf fmt "_put_bool(f_out%i, \"%s\", %s)" id o'.var_id o.var_id
59
    | Types.Treal when !Options.mpfr -> fprintf fmt "_put_double(f_out%i, \"%s\", mpfr_get_d(%s, %s))" id o'.var_id o.var_id (Mpfr.mpfr_rnd ())
60
    | Types.Treal -> fprintf fmt "_put_double(f_out%i, \"%s\", %s)" id o'.var_id o.var_id
61
    | _ -> assert false
57
    let suff = string_of_int id in
58
    print_put_var fmt suff o'.var_id o.var_type o.var_id
62 59
  in
63 60
  Utils.List.iteri2 (fun idx v' v -> fprintf fmt "@ %a;" po ((idx+1), v', v)) m.mname.node_outputs m.mstep.step_outputs
64 61

  
......
142 139
    fprintf fmt "@ /* Infinite loop */@ ";
143 140
    fprintf fmt "@[<v 2>while(1){@ ";
144 141
    fprintf fmt  "fflush(stdout);@ ";
145
    List.iteri (fun idx _ -> fprintf fmt "fflush(f_in%i);@ " (idx+1)) m.mstep.step_inputs;
146
    List.iteri (fun idx _ -> fprintf fmt "fflush(f_out%i);@ " (idx+1)) m.mstep.step_outputs;
147 142
    fprintf fmt "%a@ %t%a"
148 143
      print_get_inputs m
149 144
      (fun fmt -> pp_main_call mname main_mem fmt m input_values m.mstep.step_outputs)
......
158 153
    else "main_mem" in
159 154
  fprintf fmt "@[<v 2>int main (int argc, char *argv[]) {@ ";
160 155
  print_main_inout_declaration basename fmt m;
156
  Plugins.c_backend_main_loop_body_prefix basename mname fmt ();
161 157
  print_main_memory_allocation mname main_mem fmt m;
162 158
  if !Options.mpfr then
163 159
    begin
src/options.ml
52 52
let cpp       = ref false
53 53
let int_type  = ref "int"
54 54
let real_type = ref "double"
55
let print_prec_double = ref 15
56
let print_prec_float = ref 10
55 57

  
56 58
let sfunction = ref ""
57 59

  
......
61 63
let gen_mcdc = ref false
62 64
let no_mutation_suffix = ref false
63 65

  
66

  
67

  
68
  
64 69
let set_mpfr prec =
65 70
  if prec > 0 then (
66 71
    mpfr := true;
......
107 112
    "-c++" , Arg.Set        cpp      , "c++ backend";
108 113
    "-int" , Arg.Set_string int_type , "specifies the integer type (default=\"int\")";
109 114
    "-real", Arg.Set_string real_type, "specifies the real type (default=\"double\" without mpfr option)";
115
    "-real-print-prec", Arg.Set_int print_prec_double, "specifies the number of digits to be printed for real values (default=15)";
110 116

  
111 117
    "-mauve", Arg.String (fun node -> mauve := node; cpp := true; static_mem := false), "generates the mauve code";
112 118
]
src/pluginType.ml
6 6
  val check_force_stateful : unit -> bool
7 7
  val refine_machine_code: LustreSpec.top_decl list ->
8 8
    Machine_code.machine_t list -> Machine_code.machine_t list
9
  val c_backend_main_loop_body_prefix : string -> string -> Format.formatter ->  unit -> unit
9 10
  val c_backend_main_loop_body_suffix : Format.formatter ->  unit -> unit
10 11
end
11 12

  
......
13 14
struct
14 15
  let check_force_stateful () = false
15 16
  let refine_machine_code prog machines = machines
17
  let c_backend_main_loop_body_prefix basename mname fmt () = ()
16 18
  let c_backend_main_loop_body_suffix fmt () = ()
17 19
end
src/plugins.ml
25 25
  ) machine_code plugins
26 26

  
27 27

  
28
let c_backend_main_loop_body_prefix basename mname fmt () = 
29
  List.iter (fun (m: (module PluginType.PluginType)) -> 
30
    let module M = (val m : PluginType.PluginType) in
31
    M.c_backend_main_loop_body_prefix basename mname fmt ()) plugins
32

  
28 33
let c_backend_main_loop_body_suffix fmt () = 
29 34
  List.iter (fun (m: (module PluginType.PluginType)) -> 
30 35
    let module M = (val m : PluginType.PluginType) in
src/plugins/scopes/scopes.ml
169 169
let scopes_map : (LustreSpec.ident list  * scope_t) list ref  = ref []
170 170

  
171 171
let register_scopes s = 
172
  option_scopes := true;
172 173
  option_all_scopes:=false; 
173 174
  let scope_list = Str.split (Str.regexp ", *") s in
174 175
  let scope_list = List.map (fun scope -> Str.split (Str.regexp "\\.") scope) scope_list in
175 176
  scopes_def := scope_list
176 177

  
177 178
let register_inputs s = 
179
  option_scopes := true;
178 180
  let input_list = Str.split (Str.regexp "[;]") s in
179 181
  let input_list = List.map (fun s -> match Str.split (Str.regexp "=") s with | [v;e] -> v, e | _ -> raise (Invalid_argument ("Input list error: " ^ s))) input_list in
180 182
  let input_list = List.map (fun (v, e) -> v, Str.split (Str.regexp "[;]") e) input_list in
......
185 187
   iterer sur path pour construire la suite des xx_mem._reg.yy_mem._reg......flow
186 188
par ex main_mem->n8->n9->_reg.flow
187 189
*)
188
let pp_scopes fmt scopes = 
190
let extract_scopes_defs scopes =
189 191
  let rec scope_path (path, flow) accu = 
190 192
    match path with 
191
      | [] -> accu ^ "_reg." ^ flow.var_id, flow.var_type
192
      | (_, _, Some instance_id)::tl -> scope_path (tl, flow) ( accu ^ instance_id ^ "->" ) 
193
      | _ -> assert false
193
    | [] -> accu ^ "_reg." ^ flow.var_id, flow.var_type
194
    | (_, _, Some instance_id)::tl -> scope_path (tl, flow) ( accu ^ instance_id ^ "->" ) 
195
    | _ -> assert false
194 196
  in
195 197
  let scopes_vars = 
196 198
    List.map 
......
198 200
	String.concat "." sl, scope_path scope "main_mem.") 
199 201
      scopes 
200 202
  in
201
  List.iter (fun (id, (var, typ)) -> 
202
    match (Types.repr typ).Types.tdesc with
203
      | Types.Tint -> Format.fprintf fmt "_put_int(\"%s\", %s);@ " id var
204
      | Types.Tbool -> Format.fprintf fmt "_put_bool(\"%s\", %s);@ " id var
205
      | Types.Treal when !Options.mpfr ->
206
	 Format.fprintf fmt "_put_double(\"%s\", mpfr_get_d(%s, %s));@ " id var (Mpfr.mpfr_rnd ())
207
      | Types.Treal -> Format.fprintf fmt "_put_double(\"%s\", %s);@ " id var
208
      | _ -> Format.eprintf "Impossible to print the _put_xx for type %a@.@?" Types.print_ty typ; assert false
203
  scopes_vars
204

  
205
let pp_scopes_files basename mname fmt scopes =
206
  let scopes_vars = extract_scopes_defs scopes in
207
  List.iteri (fun idx _ (* (id, (var, typ)) *) ->
208
    Format.fprintf fmt "FILE *f_out_scopes_%i;@ " (idx+1); (* we start from 1: in1, in2, ... *)
209
    Format.fprintf fmt "f_out_scopes_%i = fopen(\"%s_%s_simu.scope%i\", \"w\");@ " (idx+1) basename mname (idx+1);
210
  ) scopes_vars
211

  
212
  
213
let pp_scopes fmt scopes = 
214
  let scopes_vars = extract_scopes_defs scopes in
215
  List.iteri (fun idx (id, (var, typ)) ->
216
    Format.fprintf fmt "@ %t;" 
217
      (fun fmt -> C_backend_common.print_put_var fmt ("_scopes_" ^ string_of_int (idx+1)) var typ var)
209 218
  ) scopes_vars
210 219

  
211 220
let update_machine machine =
......
235 244
struct
236 245
  let name = "scopes"
237 246
  let is_active () = 
238
    !option_scopes
247
    !option_scopes || !option_show_scopes || !option_all_scopes || !option_mem_scopes || !option_input_scopes
239 248
      
240 249
  let show_scopes () = 
241 250
    !option_show_scopes && (
......
250 259
    "-select-mem", Arg.Set option_mem_scopes, "select all memory variables to log";
251 260
    "-select-inputs", Arg.Set option_input_scopes, "select all input variables to log";
252 261
  ]
253

  
262
    
254 263
  let activate () = 
255 264
    option_scopes := true;
256 265
    Options.optimization := 0; (* no optimization *)
......
315 324
    let machines = List.map update_machine machines in
316 325
     machines
317 326

  
318
  let pp fmt = pp_scopes fmt !scopes_map
327
  (* let pp fmt = pp_scopes fmt !scopes_map *)
319 328

  
320
  let check_force_stateful () = !option_scopes
329
  let check_force_stateful () = is_active()
321 330

  
322 331
  let refine_machine_code prog machine_code =
323 332
    if show_scopes () then
......
339 348
  let c_backend_main_loop_body_suffix fmt () =
340 349
    if is_active () then
341 350
      begin
342
	Format.fprintf fmt "@ %t" pp 
343
      end;    
344
 
351
	Format.fprintf fmt "@ %a" pp_scopes !scopes_map 
352
      end  
353

  
354
  let c_backend_main_loop_body_prefix basename mname fmt () =
355
    if is_active () then
356
      begin
357
	Format.fprintf fmt "@ %a" (pp_scopes_files basename mname) !scopes_map 
358
      end  
359

  
360

  
345 361
end
346 362
    
347 363
(* Local Variables: *)

Also available in: Unified diff