add translator & XML2modelica
[scilab.git] / scilab / modules / scicos / src / translator / parsing / syntax.ml
1 (*\r
2  *  Translator from Modelica 2.x to flat Modelica\r
3  *\r
4  *  Copyright (C) 2005 - 2007 Imagine S.A.\r
5  *  For more information or commercial use please contact us at www.amesim.com\r
6  *\r
7  *  This program is free software; you can redistribute it and/or\r
8  *  modify it under the terms of the GNU General Public License\r
9  *  as published by the Free Software Foundation; either version 2\r
10  *  of the License, or (at your option) any later version.\r
11  *\r
12  *  This program is distributed in the hope that it will be useful,\r
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of\r
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
15  *  GNU General Public License for more details.\r
16  *\r
17  *  You should have received a copy of the GNU General Public License\r
18  *  along with this program; if not, write to the Free Software\r
19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.\r
20  *\r
21  *)\r
22 \r
23 (* 'info denotes the type of the information attached to the syntax nodes\r
24    (location for instance) in the parse tree *)\r
25 \r
26 type ('a, 'info) node =\r
27   {\r
28     nature: 'a;\r
29     info: 'info\r
30   }\r
31 \r
32 and 'info toplevel_element = ('info toplevel_element_desc, 'info) node\r
33 \r
34 and 'info toplevel_element_desc =\r
35   | ClassDefinitions of 'info class_definition list\r
36   | Expression of 'info expression\r
37   | VariablesDefinitions of 'info expression * 'info array_subscripts option *\r
38       'info component_declaration list\r
39   | Command of 'info algorithm\r
40   | Within of string list\r
41   | Import of 'info import_clause\r
42 \r
43 and 'info class_definition = ('info class_definition_desc, 'info) node\r
44 \r
45 and 'info class_definition_desc =\r
46   | ClassDefinition of final option * 'info definition\r
47 \r
48 and final = Final\r
49 \r
50 and 'info definition = ('info definition_desc, 'info) node\r
51 \r
52 and 'info definition_desc =\r
53   | Definition of encapsulated option * partial option * class_kind *\r
54       'info class_specifier\r
55 \r
56 and class_kind =\r
57   | Class\r
58   | Model\r
59   | Block\r
60   | Record\r
61   | ExpandableConnector\r
62   | Connector\r
63   | Type\r
64   | Package\r
65   | Function\r
66 \r
67 and encapsulated = Encapsulated\r
68 \r
69 and partial = Partial\r
70 \r
71 and 'info class_specifier = ('info class_specifier_desc, 'info) node\r
72 \r
73 and 'info class_specifier_desc =\r
74   | LongSpecifier of ident * string list * 'info composition\r
75   | ShortSpecifier of ident * 'info base_prefix * 'info expression *\r
76       'info array_subscripts option * 'info class_modification option *\r
77       'info comment\r
78   | EnumerationSpecifier of ident * 'info enumeration_composition *\r
79       'info comment\r
80   | ExtensionSpecifier of ident * 'info class_modification option *\r
81       string list * 'info composition\r
82 \r
83 and 'info base_prefix = 'info type_prefix\r
84 \r
85 and 'info enumeration_composition = ('info enumeration_composition_desc, 'info) node\r
86 \r
87 and 'info enumeration_composition_desc =\r
88   | EnumList of 'info enumeration_literal list option\r
89   | EnumColon\r
90 \r
91 and 'info enumeration_literal = ('info enumeration_literal_desc, 'info) node\r
92 \r
93 and 'info enumeration_literal_desc =\r
94   | EnumerationLiteral of ident * 'info comment\r
95 \r
96 and 'info composition = ('info composition_desc, 'info) node\r
97 \r
98 and 'info composition_desc =\r
99   | Composition of 'info element list * 'info other_elements list *\r
100       'info externalll option\r
101 \r
102 and 'info element = ('info element_desc, 'info) node\r
103 \r
104 and 'info element_desc =\r
105   | ClassAnnotation of 'info annotation\r
106   | ImportClause of 'info import_clause * 'info annotation option\r
107   | ExtendsClause of 'info extends_clause * 'info annotation option\r
108   | ElementDefinition of redeclare option * final option *\r
109       dynamic_scope option * 'info element_definition *\r
110       'info annotation option\r
111 \r
112 and 'info element_definition = ('info element_definition_desc, 'info) node\r
113 \r
114 and 'info element_definition_desc =\r
115   | ClassDefinitionElement of replaceable option * 'info definition *\r
116       'info constraining_clause list\r
117   | ComponentClauseElement of replaceable option * 'info component_clause *\r
118       'info constraining_clause list\r
119 \r
120 and replaceable = Replaceable\r
121 \r
122 and redeclare = Redeclare\r
123 \r
124 and dynamic_scope = Inner | Outer | InnerOuter\r
125 \r
126 and 'info extends_clause = ('info extends_clause_desc, 'info) node\r
127 \r
128 and 'info extends_clause_desc =\r
129   | Extends of 'info expression * 'info class_modification option *\r
130       'info annotation option\r
131 \r
132 and 'info constraining_clause = ('info constraining_clause_desc, 'info) node\r
133 \r
134 and 'info constraining_clause_desc =\r
135   | Constraint of constraint_kind * 'info expression *\r
136       'info class_modification option * 'info comment\r
137 \r
138 and constraint_kind = Extension | Restriction\r
139 \r
140 and 'info other_elements = ('info other_elements_desc, 'info) node\r
141 \r
142 and 'info other_elements_desc =\r
143   | Public of 'info element list\r
144   | Protected of 'info element list\r
145   | EquationClause of initial option * 'info equation_definition list\r
146   | AlgorithmClause of initial option * 'info algorithm_definition list\r
147 \r
148 and initial = Initial\r
149 \r
150 and 'info externalll = ('info externalll_desc, 'info) node\r
151 \r
152 and 'info externalll_desc =\r
153   | External of string option * 'info external_function_call option *\r
154       'info annotation option * 'info annotation option\r
155 \r
156 and 'info external_function_call = ('info external_function_call_desc, 'info) node\r
157 \r
158 and 'info external_function_call_desc =\r
159   | ExternalFunctionCall of 'info expression option * ident * 'info expression list\r
160 \r
161 and 'info import_clause = ('info import_clause_desc, 'info) node\r
162 \r
163 and 'info import_clause_desc =\r
164   | NewIdentifier of ident * 'info expression * 'info comment\r
165   | OldIdentifier of 'info expression * 'info comment\r
166   | AllIdentifiers of 'info expression * 'info comment\r
167 \r
168 and 'info component_clause = ('info component_clause_desc, 'info) node\r
169 \r
170 and 'info component_clause_desc =\r
171   | ComponentClause of 'info type_prefix * 'info type_specifier *\r
172       'info array_subscripts option * 'info component_declaration list\r
173 \r
174 and 'info type_prefix = ('info type_prefix_desc, 'info) node\r
175 \r
176 and 'info type_prefix_desc =\r
177   | TypePrefix of flow option * variability option * inout option\r
178 \r
179 and flow = Flow\r
180 \r
181 and variability = Discrete | Parameter | Constant\r
182 \r
183 and inout = Input | Output\r
184 \r
185 and 'info type_specifier = 'info expression\r
186 \r
187 and 'info component_declaration = ('info component_declaration_desc, 'info) node\r
188 \r
189 and 'info component_declaration_desc =\r
190   | ComponentDeclaration of 'info declaration * 'info comment\r
191 \r
192 and 'info declaration = ('info declaration_desc, 'info) node\r
193 \r
194 and 'info declaration_desc =\r
195   | Declaration of ident * 'info array_subscripts option *\r
196       'info modification option\r
197 \r
198 and 'info modification = ('info modification_desc, 'info) node\r
199 \r
200 and 'info modification_desc =\r
201   | Modification of 'info class_modification * 'info expression option\r
202   | Eq of 'info expression\r
203   | ColEq of 'info expression\r
204 \r
205 and 'info class_modification = ('info class_modification_desc, 'info) node\r
206 \r
207 and 'info class_modification_desc =\r
208   | ClassModification of 'info argument list\r
209 \r
210 and 'info argument = ('info argument_desc, 'info) node\r
211 \r
212 and 'info argument_desc =\r
213   | ElementModification of each option * final option * 'info expression *\r
214       'info modification option * string list\r
215   | ElementRedeclaration of each option * final option *\r
216       'info element_definition\r
217 \r
218 and each = Each\r
219 \r
220 and 'info equation_definition = ('info equation_definition_desc, 'info) node\r
221 \r
222 and 'info equation_definition_desc =\r
223   | Equation of 'info equation * 'info comment * 'info annotation option\r
224 \r
225 and 'info algorithm_definition = ('info algorithm_definition_desc, 'info) node\r
226 \r
227 and 'info algorithm_definition_desc =\r
228   | Algorithm of 'info algorithm * 'info comment * 'info annotation option\r
229 \r
230 and 'info equation = ('info equation_desc, 'info) node\r
231 \r
232 and 'info equation_desc =\r
233   | Equal of 'info expression * 'info expression\r
234   | ConditionalEquationE of ('info expression * 'info equation list) list *\r
235       'info equation list option\r
236   | ForClauseE of 'info for_indices * 'info equation list\r
237   | ConnectClause of 'info expression * 'info expression\r
238   | WhenClauseE of ('info expression * 'info equation list) list\r
239   | FunctionCallE of 'info expression * 'info function_arguments option\r
240 \r
241 and 'info algorithm = ('info algorithm_desc, 'info) node\r
242 \r
243 and 'info algorithm_desc =\r
244   | Assign of 'info expression * 'info expression\r
245   | FunctionCallA of 'info expression * 'info function_arguments option\r
246   | MultipleAssign of 'info expression list * 'info expression *\r
247       'info function_arguments option\r
248   | Break\r
249   | Return\r
250   | ConditionalEquationA of ('info expression * 'info algorithm list) list *\r
251       'info algorithm list option\r
252   | ForClauseA of 'info for_indices * 'info algorithm list\r
253   | WhileClause of 'info expression * 'info algorithm list\r
254   | WhenClauseA of ('info expression * 'info algorithm list) list\r
255 \r
256 and 'info for_indices = (ident * 'info expression option) list\r
257 \r
258 and 'info expression = ('info expression_desc, 'info) node\r
259 \r
260 and 'info expression_desc =\r
261   | BinaryOperation of 'info binary_operator_kind * 'info expression * 'info expression\r
262   | End\r
263   | False\r
264   | FieldAccess of 'info expression * ident\r
265   | FunctionCall of 'info expression * 'info function_arguments option\r
266   | Identifier of string\r
267   | If of ('info expression * 'info expression) list * 'info expression\r
268   | IndexedAccess of 'info expression * 'info array_subscripts\r
269   | Integer of string\r
270   | MatrixConstruction of 'info expression list list\r
271   | NoEvent of 'info expression\r
272   | Range of 'info expression * 'info expression option * 'info expression\r
273   | Real of string\r
274   | String of string\r
275   | True\r
276   | Tuple of 'info expression list\r
277   | UnaryOperation of 'info unary_operator_kind * 'info expression\r
278   | Vector of 'info vector_elements\r
279 \r
280 and 'info unary_operator_kind = ('info unary_operator_kind_desc, 'info) node\r
281 \r
282 and 'info unary_operator_kind_desc =\r
283   | UnaryMinus\r
284   | Not\r
285   | UnaryPlus\r
286 \r
287 and 'info binary_operator_kind = ('info binary_operator_kind_desc, 'info) node\r
288 \r
289 and 'info binary_operator_kind_desc =\r
290   | Plus\r
291   | And\r
292   | Divide\r
293   | EqualEqual\r
294   | GreaterEqual\r
295   | Greater\r
296   | LessEqual\r
297   | Less\r
298   | Times\r
299   | NotEqual\r
300   | Or\r
301   | Power\r
302   | Minus\r
303 \r
304 and 'info vector_elements = ('info vector_elements_desc, 'info) node\r
305 \r
306 and 'info vector_elements_desc =\r
307   | VectorReduction of 'info expression * 'info for_indices\r
308   | VectorElements of 'info expression list\r
309 \r
310 and ident = string\r
311 \r
312 and 'info function_arguments = ('info function_arguments_desc, 'info) node\r
313 \r
314 and 'info function_arguments_desc =\r
315   | Reduction of 'info expression * 'info for_indices\r
316   | ArgumentList of 'info function_arguments_element list\r
317 \r
318 and 'info function_arguments_element = ('info function_arguments_element_desc, 'info) node\r
319 \r
320 and 'info function_arguments_element_desc =\r
321   | Argument of 'info expression\r
322   | NamedArgument of ident * 'info expression\r
323 \r
324 and 'info array_subscripts = ('info array_subscripts_desc, 'info) node\r
325 \r
326 and 'info array_subscripts_desc =\r
327   | Subscripts of 'info array_subscript list\r
328 \r
329 and 'info array_subscript = ('info array_subscript_desc, 'info) node\r
330 \r
331 and 'info array_subscript_desc =\r
332   | Colon\r
333   | Subscript of 'info expression\r
334 \r
335 and 'info comment = ('info comment_desc, 'info) node\r
336 \r
337 and 'info comment_desc =\r
338   | Comment of string list * 'info annotation option\r
339 \r
340 and 'info annotation = ('info annotation_desc, 'info) node\r
341 \r
342 and 'info annotation_desc =\r
343   | Annotation of 'info class_modification\r
344 \r
345 (* Conversion of elements to string, used for error information display *)\r
346 \r
347 let rec string_of_expression expr =\r
348   string_of_subexpression None expr\r
349 \r
350 and string_of_subexpression expr_option subexpr =\r
351   let string_of_subexpression' =\r
352     match subexpr.nature with\r
353       | BinaryOperation (kind, arg1, arg2) ->\r
354           string_of_binOper subexpr kind arg1 arg2\r
355       | End -> "end"\r
356       | False -> "false"\r
357       | FieldAccess (expr, id) ->\r
358           (string_of_expression expr) ^ "." ^ id\r
359       | FunctionCall (expr, fun_args) ->\r
360           string_of_function_call expr fun_args\r
361       | Identifier id -> id\r
362       | If (alts, expr) -> string_of_if expr_option alts expr\r
363       | IndexedAccess (expr, subs) -> string_of_indexedAccess expr subs\r
364       | Integer s -> s\r
365       | MatrixConstruction exprss -> string_of_matrix exprss\r
366       | NoEvent expr -> "noEvent(" ^ (string_of_expression expr) ^ ")"\r
367       | Range (start, step, stop) -> string_of_range start step stop\r
368       | Real s -> s\r
369       | String s -> "\"" ^ s ^ "\""\r
370       | True -> "true"\r
371       | Tuple exprs -> string_of_tuple exprs\r
372       | UnaryOperation (kind, arg) ->\r
373           string_of_unOper subexpr kind arg\r
374       | Vector vec_elts -> string_of_vector vec_elts in\r
375   parenthesize expr_option string_of_subexpression' subexpr\r
376 \r
377 and parenthesize expr_option s subexpr =\r
378   let add_parenthesis =\r
379     "(" ^ s ^ ")" in\r
380   let parenthesize_un_bin_Oper kind kind' =\r
381     match kind.nature, kind'.nature with\r
382       | (UnaryMinus | UnaryPlus),\r
383         (Plus | Minus) ->\r
384           add_parenthesis\r
385       | Not, _ ->\r
386           add_parenthesis\r
387       | _, _ -> s in\r
388   let parenthesize_bin_bin_Oper kind kind' =\r
389     match kind.nature, kind'.nature with\r
390       | Divide,\r
391         (Plus | Minus | Times) ->\r
392         add_parenthesis\r
393       | Times,\r
394         (Plus | Minus | Divide) ->\r
395           add_parenthesis\r
396       | Power, _ ->\r
397           add_parenthesis\r
398       | ( EqualEqual | GreaterEqual | Greater |\r
399           LessEqual | Less | NotEqual | And |\r
400           Or),\r
401         ( EqualEqual | GreaterEqual | Greater |\r
402           LessEqual | Less | NotEqual) ->\r
403           add_parenthesis\r
404       | And, Or -> add_parenthesis\r
405       | Or, And -> add_parenthesis\r
406       | _, _ -> s in\r
407   let parenthesize' expr =\r
408     match expr.nature, subexpr.nature with\r
409       | BinaryOperation (kind, _, _),\r
410         BinaryOperation (kind', _, _) ->\r
411           parenthesize_bin_bin_Oper kind kind'\r
412       | UnaryOperation (kind, _),\r
413         BinaryOperation (kind', _, _) ->\r
414           parenthesize_un_bin_Oper kind kind'\r
415       | ( BinaryOperation (_, _, _) |\r
416           UnaryOperation (_, _) ),\r
417         UnaryOperation (_, _) ->\r
418           add_parenthesis\r
419       | _, _ -> s in\r
420   match expr_option with\r
421     | None -> s\r
422     | Some expr -> parenthesize' expr\r
423 \r
424 and string_of_binOperKind kind =\r
425   match kind.nature with\r
426     | Plus -> " + "\r
427     | And -> " and "\r
428     | Divide -> " / "\r
429     | EqualEqual -> " == "\r
430     | GreaterEqual -> " >= "\r
431     | Greater -> " > "\r
432     | LessEqual -> " <= "\r
433     | Less -> " < "\r
434     | Times -> " * "\r
435     | NotEqual -> " <> "\r
436     | Or -> " or "\r
437     | Power -> " ^ "\r
438     | Minus -> " - "\r
439 \r
440 and string_of_binOper expr kind arg1 arg2 =\r
441   (string_of_subexpression (Some expr) arg1) ^\r
442   (string_of_binOperKind kind) ^\r
443   (string_of_subexpression (Some expr) arg2)\r
444 \r
445 and string_of_range start step stop =\r
446   let sstep = match step with\r
447     | None -> ":"\r
448     | Some step -> ":" ^ (string_of_expression step)  ^ ":" in\r
449   (string_of_expression start) ^ sstep ^ (string_of_expression stop)\r
450 \r
451 and string_of_unOperKind kind =\r
452   match kind.nature with\r
453     | UnaryMinus -> "- "\r
454     | Not -> "not "\r
455     | UnaryPlus -> "+ "\r
456 \r
457 and string_of_unOper expr kind arg =\r
458   (string_of_unOperKind kind) ^\r
459   (string_of_subexpression (Some expr) arg)\r
460 \r
461 and string_of_tuple exprs =\r
462   let rec string_of_tuple' exprs =\r
463     match exprs with\r
464       | [] -> ""\r
465       | [expr] -> string_of_expression expr\r
466       | expr :: exprs ->\r
467           (string_of_expression expr) ^ ", " ^ (string_of_tuple' exprs) in\r
468   "(" ^ (string_of_tuple' exprs) ^ ")"\r
469 \r
470 and string_of_if expr_option alts expr =\r
471   let add_parenthesis s =\r
472     "(" ^ s ^ ")" in\r
473   let rec string_of_alts alts = match alts with\r
474     | [] -> ""\r
475     | (cond, expr) :: alts ->\r
476         "if (" ^ (string_of_expression cond) ^ ") then (" ^\r
477         (string_of_expression expr) ^ ") else" ^\r
478         (string_of_alts alts) in\r
479   let string_of_if' =\r
480     (string_of_alts alts) ^ " " ^\r
481     (add_parenthesis (string_of_expression expr)) in\r
482   match expr_option with\r
483     | None -> string_of_if'\r
484     | Some _ -> add_parenthesis string_of_if'\r
485 \r
486 and string_of_for_inds for_inds =\r
487   let string_of_for_ind for_ind = match for_ind with\r
488     | id, None -> id\r
489     | id, Some expr -> id ^ " in " ^ string_of_expression expr in\r
490   let rec string_of_for_inds' for_inds = match for_inds with\r
491     | [] -> ""\r
492     | [for_ind] -> string_of_for_ind for_ind\r
493     | for_ind :: for_inds ->\r
494         (string_of_for_ind for_ind) ^ ", " ^ (string_of_for_inds' for_inds) in\r
495   "for " ^ (string_of_for_inds' for_inds)\r
496 \r
497 and string_of_function_call expr fun_args =\r
498   let string_of_arg arg = match arg.nature with\r
499     | Argument expr -> string_of_expression expr\r
500     | NamedArgument (id, expr) ->\r
501         id ^ " = " ^ (string_of_expression expr) in\r
502   let rec string_of_args args = match args with\r
503     | [] -> ""\r
504     | [arg] -> string_of_arg arg\r
505     | arg :: args -> (string_of_arg arg) ^ ", " ^ (string_of_args args) in\r
506   let string_of_fun_args fun_args = match fun_args.nature with\r
507     | ArgumentList args -> string_of_args args\r
508     | Reduction (expr, for_inds) when for_inds = [] ->\r
509         string_of_expression expr\r
510     | Reduction (expr, for_inds) ->\r
511         (string_of_expression expr) ^ " " ^\r
512         (string_of_for_inds for_inds) in\r
513   let string_of_fun_args_option fun_args = match fun_args with\r
514     | None -> ""\r
515     | Some fun_args -> string_of_fun_args fun_args in\r
516   (string_of_expression expr) ^\r
517   "(" ^ (string_of_fun_args_option fun_args) ^ ")"\r
518 \r
519 and string_of_indexedAccess expr subs =\r
520   let string_of_sub sub = match sub.nature with\r
521     | Colon -> " : "\r
522     | Subscript expr -> string_of_expression expr in\r
523   let rec string_of_subs subs = match subs with\r
524     | [] -> ""\r
525     | [sub] -> string_of_sub sub\r
526     | sub :: subs ->\r
527         (string_of_sub sub) ^ ", " ^ string_of_subs subs in\r
528   match subs.nature with\r
529     | Subscripts subs ->\r
530         (string_of_expression expr) ^ "[" ^ (string_of_subs subs) ^ "]"\r
531 \r
532 and string_of_vectorElements exprs = match exprs with\r
533   | [] -> ""\r
534   | [expr] -> string_of_expression expr\r
535   | expr :: exprs ->\r
536       (string_of_expression expr) ^ ", " ^\r
537       (string_of_vectorElements exprs)\r
538 \r
539 and string_of_vector vec_elts =\r
540   let string_of_vector' = match vec_elts.nature with\r
541     | VectorReduction (expr, for_inds) ->\r
542         "{" ^ (string_of_expression expr) ^ " " ^\r
543         (string_of_for_inds for_inds) ^ "}"\r
544     | VectorElements exprs ->\r
545         "{" ^ string_of_vectorElements exprs ^ "}" in\r
546   string_of_vector'\r
547 \r
548 and string_of_matrix exprss =\r
549   let rec string_of_matrix' exprss = match exprss with\r
550     | [] -> ""\r
551     | [exprs] -> string_of_vectorElements exprs\r
552     | exprs :: exprss ->\r
553         (string_of_vectorElements exprs) ^ "; " ^\r
554         (string_of_matrix' exprss) in\r
555   "[" ^ (string_of_matrix' exprss) ^ "]"\r
556 \r
557 let string_of_classDefinitions cl_defs = ""\r
558 \r
559 let string_of_within path =\r
560   let rec string_of_path path = match path with\r
561     | [] -> ""\r
562     | [s] -> s\r
563     | s :: path -> s ^ "." ^ (string_of_path path) in\r
564   "within " ^ (string_of_path path) ^ ";"\r
565 \r
566 let string_of_import imprt =\r
567   let string_of_import' = match imprt.nature with\r
568     | NewIdentifier (id, expr, _) ->\r
569         id ^ " = " ^ (string_of_expression expr)\r
570     | OldIdentifier (expr, _) ->\r
571         string_of_expression expr\r
572     | AllIdentifiers (expr, _) ->\r
573         (string_of_expression expr) ^ ".*" in\r
574   "import " ^ string_of_import' ^ ";"\r
575 \r
576 let string_of_MultipleAssign exprs expr func_args =\r
577   let rec string_of_LHS exprs = match exprs with\r
578     | [] -> ""\r
579     | [expr] -> string_of_expression expr\r
580     | expr :: exprs ->\r
581         (string_of_expression expr) ^ ", " ^ (string_of_LHS exprs) in\r
582   (string_of_LHS exprs) ^ " := " ^ (string_of_function_call expr func_args)\r
583 \r
584 let string_of_for_clause for_inds algos =\r
585   (string_of_for_inds for_inds) ^ " loop ... end for"\r
586 \r
587 let string_of_while_clause expr algos =\r
588   "while " ^ (string_of_expression expr) ^ " loop ... end while"\r
589 \r
590 let string_of_when_clause alts = match alts with\r
591   | [] -> ""\r
592   | (expr, algos) :: alts ->\r
593       "when " ^ (string_of_expression expr) ^ " then ... end when"\r
594 \r
595 let string_of_if_cond cond =\r
596   "if (" ^ (string_of_expression cond) ^ ") then ... end if"\r
597 \r
598 let string_of_conditional_equ alts algos = match alts with\r
599   | [] -> ""\r
600   | (expr, algos) :: alts -> string_of_if_cond expr\r
601 \r
602 let string_of_algo algo = match algo.nature with\r
603   | Assign (expr, expr') ->\r
604       (string_of_expression expr) ^ " := " ^ (string_of_expression expr')\r
605   | FunctionCallA (expr, func_args) ->\r
606       string_of_function_call expr func_args\r
607   | MultipleAssign (exprs, expr, func_args) ->\r
608       string_of_MultipleAssign exprs expr func_args\r
609   | Break -> "break"\r
610   | Return -> "return"\r
611   | ConditionalEquationA (alts, algos) ->\r
612       string_of_conditional_equ alts algos\r
613   | ForClauseA (for_inds, algos) ->\r
614       string_of_for_clause for_inds algos\r
615   | WhileClause (expr, algos) ->\r
616       string_of_while_clause expr algos\r
617   | WhenClauseA alts ->\r
618       string_of_when_clause alts\r
619 \r
620 let string_of_toplevel_element node = match node.nature with\r
621   | ClassDefinitions cl_defs -> string_of_classDefinitions cl_defs\r
622   | Expression expr -> string_of_expression expr\r
623   | VariablesDefinitions (expr, subs, cpnt_decls) ->\r
624       string_of_expression expr\r
625   | Command algo -> string_of_algo algo\r
626   | Within path -> string_of_within path\r
627   | Import imprt -> string_of_import imprt\r
628 \r
629 let string_of_base_prefix base_pref =\r
630   let string_of_flow flow_option = match flow_option with\r
631     | None -> ""\r
632     | Some _ -> "flow " in\r
633   let string_of_var var_option = match var_option with\r
634     | None -> ""\r
635     | Some Discrete -> "discrete "\r
636     | Some Parameter -> "parameter "\r
637     | Some Constant -> "constant " in\r
638   let string_of_inout inout_option = match inout_option with\r
639     | None -> ""\r
640     | Some Input -> "input "\r
641     | Some Output -> "output " in\r
642   match base_pref.nature with\r
643     | TypePrefix (flow_option, var_option, inout_option) ->\r
644         (string_of_flow flow_option) ^\r
645         (string_of_var var_option) ^\r
646         (string_of_inout inout_option)\r