modelicac 1.12.1
[scilab.git] / scilab / modules / scicos / src / modelica_compiler / parser.mly
1 /*
2  *  Modelicac
3  *
4  *  Copyright (C) 2005 - 2007 Imagine S.A.
5  *  For more information or commercial use please contact us at www.amesim.com
6  *
7  *  This program is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU General Public License
9  *  as published by the Free Software Foundation; either version 2
10  *  of the License, or (at your option) any later version.
11  *
12  *  This program is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to the Free Software
19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20  *
21  */
22
23 /*
24  * Parser
25  * Grammar for the Modelica language v.2.0
26  * V 1.0
27  * S. FURIC
28  */
29
30 %{
31
32 open ParseTree
33
34 %}
35
36 /*names*/
37 %token <string> IDENT
38
39 /*literals*/
40 %token <string> UNSIGNED_INTEGER UNSIGNED_NUMBER STRING
41
42 /*keywords*/
43 %token ALGORITHM AND ANNOTATION ASSERT BLOCK CLASS CONNECT CONNECTOR CONSTANT
44 %token DISCRETE EACH ELSE ELSEIF ELSEWHEN ENCAPSULATED END ENUMERATION EQUATION
45 %token EXTENDS EXTERNAL FALSE FINAL FLOW FOR FUNCTION IF IMPORT IN INITIAL
46 %token INNER INPUT LOOP MODEL NOT OR OUTER OUTPUT PACKAGE PARAMETER PARTIAL
47 %token PROTECTED PUBLIC RECORD REDECLARE REPLACEABLE TERMINATE THEN TRUE TYPE
48 %token WHEN WHILE WITHIN
49
50 /*symbols*/
51 %token LP RP LSB RSB LCB RCB  /*  ( ) [ ] { }  */
52 %token DOT CM SC CL /*  . , ; :  */
53 %token PLUS MINUS STAR SLASH EXP /*  + - * / ^  */
54 %token EQ COLEQ /*  = :=  */
55 %token LT GT LE GE EE NE /*  < > <= >= == <>  */
56
57 /*end of file*/
58 %token EOF
59
60 %type <ParseTree.t> stored_definition_eof
61 %start stored_definition_eof
62
63 %%
64
65 /*(0.0)*/
66 stored_definition_eof
67     : stored_definition EOF                                     { $1 }
68     ;
69
70 /*(2.2.1)*/
71 stored_definition
72     : class_definitions                                         { StoredDefinition (NotWithin, List.rev $1) }
73     | WITHIN SC class_definitions                               { StoredDefinition (Within None, List.rev $3) }
74     | WITHIN name SC class_definitions                          { StoredDefinition (Within (Some $2), List.rev $4) }
75     ;
76
77 class_definitions
78     :                                                           { [] }
79     | class_definitions class_definition SC                     { Definition (NotFinal, $2) :: $1 }
80     | class_definitions FINAL class_definition SC               { Definition (Final, $3) :: $1 }
81     ;
82
83 /*(2.2.2)*/
84 class_definition
85     : encapsulated_option partial_option CLASS
86       IDENT class_specifier                                     { ClassDefinition (Class, $4, $1, $2, $5) }
87     | encapsulated_option partial_option MODEL
88       IDENT class_specifier                                     { ClassDefinition (Model, $4, $1, $2, $5) }
89     | encapsulated_option partial_option RECORD
90       IDENT class_specifier                                     { ClassDefinition (Record, $4, $1, $2, $5) }
91     | encapsulated_option partial_option CONNECTOR
92       IDENT class_specifier                                     { ClassDefinition (Connector, $4, $1, $2, $5) }
93     | encapsulated_option partial_option TYPE
94       IDENT class_specifier                                     { ClassDefinition (Type, $4, $1, $2, $5) }
95     | encapsulated_option partial_option PACKAGE
96       IDENT class_specifier                                     { ClassDefinition (Package, $4, $1, $2, $5) }
97     | encapsulated_option partial_option FUNCTION
98       IDENT class_specifier                                     { ClassDefinition (Function, $4, $1, $2, $5) }
99     ;
100
101 encapsulated_option
102     :                                                           { NotEncapsulated }
103     | ENCAPSULATED                                              { Encapsulated }
104     ;
105
106 partial_option
107     :                                                           { NotPartial }
108     | PARTIAL                                                   { Partial }
109     ;
110
111 class_specifier
112     : string_comment composition END IDENT                      { Specifier ($1, $2, $4) }
113     | EQ base_prefix name array_subscripts_option class_modification_option
114       comment                                                   { ShortSpecifier ($2, $3, $4, $5, $6) }
115     | EQ ENUMERATION LP enum_list_option RP comment             { Enumeration ($4, $6) }
116     ;
117
118 base_prefix
119     : type_prefix                                               { $1 }
120     ;
121
122 enum_list_option
123     :                                                           { [] }
124     | enum_list                                                 { List.rev $1 }
125     ;
126
127 enum_list
128     : enumeration_literal                                       { [$1] }
129     | enum_list SC enumeration_literal                          { $3 :: $1 }
130     ;
131
132 enumeration_literal
133     : IDENT comment                                             { EnumerationLiteral ($1, $2) }
134     ;
135
136 composition
137     : element_list other_lists external_option                  { Composition ($1, List.rev $2, $3) }
138     ;
139
140 other_lists
141     :                                                           { [] }
142     | other_lists PUBLIC element_list                           { Public $3 :: $1 }
143     | other_lists PROTECTED element_list                        { Protected $3 :: $1 }
144     | other_lists equation_clause                               { EquationClauseElement $2 :: $1 }
145     | other_lists algorithm_clause                              { AlgorithmClauseElement $2 :: $1 }
146     ;
147
148 external_option
149     :                                                           { None }
150     | EXTERNAL language_specification_option
151                external_function_call_option SC annotation_option
152                                                                 { Some (External ($2, $3, $5)) }
153     ;
154
155 annotation_option
156     :                                                           { None }
157     | annotation SC                                             { Some $1 }
158     ;
159
160 language_specification_option
161     :                                                           { None }
162     | STRING                                                    { Some $1 }
163     ;
164
165 external_function_call_option
166     :                                                           { None }
167     | IDENT LP expressions RP                                   { Some (ExternalFunctionCall (None, $1, $3)) }
168     | component_reference EQ IDENT LP expressions RP            { Some (ExternalFunctionCall (Some $1, $3, $5)) }
169     ;
170
171
172 expressions
173     :                                                           { [] }
174     | expression CM expressions                                 { $1 :: $3 }
175     ;
176
177 array_subscripts_option
178     :                                                           { [||] }
179     | array_subscripts                                          { Array.of_list $1 }
180     ;
181
182 class_modification_option
183     :                                                           { None }
184     | class_modification                                        { Some $1 }
185     ;
186
187 element_list
188     :                                                           { [] }
189     | element_list IMPORT import_clause SC                      { ImportClause $3 :: $1 }
190     | element_list EXTENDS extends_clause SC                    { ExtendsClause $3 :: $1 }
191     | element_list final_option dynamic_scope_option
192         class_definition SC                                     { ClassDefinitionElement ($4, $2, $3) :: $1 }
193     | element_list final_option dynamic_scope_option
194         component_clause SC                                     { ComponentClauseElement ($4, $2, $3) :: $1 }
195     | element_list final_option dynamic_scope_option
196         REPLACEABLE class_definition
197         constraining_clause_option SC                           { ReplaceableClassDefinition ($5, $6, $2, $3) :: $1 }
198     | element_list final_option dynamic_scope_option
199         REPLACEABLE component_clause
200         constraining_clause_option SC                           { ReplaceableComponentClause ($5, $6, $2, $3) :: $1 }
201     | element_list annotation SC                                { AnnotationElement $2 :: $1 }
202     ;
203
204 final_option
205     :                                                           { NotFinal }
206     | FINAL                                                     { Final }
207     ;
208
209 dynamic_scope_option
210     :                                                           { NoDynamicScope }
211     | INNER                                                     { Inner }
212     | OUTER                                                     { Outer }
213     ;
214
215 import_clause
216     : IDENT EQ name comment                                     { NewIdentifier ($1, $3, $4) }
217     | name comment                                              { Identifier ($1, $2) }
218     | name DOT STAR comment                                     { AllIdentifiers ($1, $4) }
219     ;
220
221 constraining_clause_option
222     :                                                           { None }
223     | constraining_clause comment                               { Some ($1, $2) }
224     ;
225
226 /*(2.2.3)*/
227 extends_clause
228     : name class_modification_option                            { ($1, $2) }
229     ;
230
231 constraining_clause
232     : extends_clause                                            { $1 }
233     ;
234
235 /*(2.2.4)*/
236 component_clause
237     : type_prefix type_specifier array_subscripts_option
238         component_list                                          { ComponentClause ($1, $2, $3, List.rev $4) }
239     ;
240
241 type_prefix
242     : flow_option variability_option inout_option               { TypePrefix ($1, $2, $3) }
243     ;
244
245 flow_option
246     :                                                           { None }
247     | FLOW                                                      { Some Flow }
248     ;
249
250 variability_option
251     :                                                           { None }
252     | DISCRETE                                                  { Some Discrete }
253     | PARAMETER                                                 { Some Parameter }
254     | CONSTANT                                                  { Some Constant }
255     ;
256
257 inout_option
258     :                                                           { None }
259     | INPUT                                                     { Some Input }
260     | OUTPUT                                                    { Some Output }
261     ;
262
263 type_specifier
264     : name                                                      { $1 }
265     ;
266
267 component_list
268     : component_declaration                                     { [$1] }
269     | component_list CM component_declaration                   { $3 :: $1 }
270     ;
271
272 component_declaration
273     : declaration comment                                       { ComponentDeclaration ($1, $2) }
274     ;
275
276 declaration
277     : IDENT array_subscripts_option modification_option         { ($1, $2, $3) }
278     ;
279
280 modification_option
281     :                                                           { None }
282     | modification                                              { Some $1 }
283     ;
284
285 /*(2.2.5)*/
286 modification
287     : class_modification EQ expression                          { Modification ($1, Some $3) }
288     | class_modification                                        { Modification ($1, None) }
289     | EQ expression                                             { Eq $2 }
290     | COLEQ expression                                          { ColEq $2 }
291     ;
292
293 class_modification
294     : LP argument_list RP                                       { ClassModification (List.rev $2) }
295     ;
296
297 argument_list
298     : argument                                                  { [$1] }
299     | argument CM argument_list                                 { $1 :: $3 }
300     ;
301
302 argument
303     : element_modification                                      { $1 }
304     | element_redeclaration                                     { $1 }
305     ;
306
307 element_modification
308     : component_reference modification string_comment           { ElementModification (NotEach, NotFinal,$1, $2, $3) }
309     | EACH component_reference modification string_comment      { ElementModification (Each, NotFinal,$2, $3, $4) }
310     | FINAL component_reference modification string_comment     { ElementModification (NotEach, Final,$2, $3, $4) }
311     | EACH FINAL
312       component_reference modification string_comment           { ElementModification (Each, Final,$3, $4, $5) }
313     ;
314
315 element_redeclaration
316     : REDECLARE  class_definition_or_component_clause1          { ElementRedeclaration (NotEach, NotFinal, $2) }
317     | REDECLARE EACH class_definition_or_component_clause1      { ElementRedeclaration (Each, NotFinal, $3) }
318     | REDECLARE FINAL class_definition_or_component_clause1     { ElementRedeclaration (NotEach, Final, $3) }
319     | REDECLARE EACH FINAL
320       class_definition_or_component_clause1                     { ElementRedeclaration (Each, Final, $4) }
321     ;
322
323 class_definition_or_component_clause1
324     : class_definition                                          { Redeclaration (NotReplaceable, RedeclaredClassDefinition $1, None) }
325     | type_prefix type_specifier component_declaration          { Redeclaration (NotReplaceable, RedeclaredComponentClause ($1, $2, $3), None) }
326     | REPLACEABLE class_definition constraining_clause_option   { Redeclaration (Replaceable, RedeclaredClassDefinition $2, $3) }
327     | REPLACEABLE type_prefix type_specifier
328       component_declaration constraining_clause_option          { Redeclaration (Replaceable, RedeclaredComponentClause ($2, $3, $4), $5) }
329     ;
330
331 /*(2.2.6)*/
332 equation_clause
333     : INITIAL EQUATION equations                                { EquationClause (Initial, List.rev $3) }
334     | EQUATION equations                                        { EquationClause (NotInitial, List.rev $2) }
335     ;
336
337 equations
338     :                                                           { [] }
339     | equations equation comment SC                             { Equation ($2, $3) :: $1 }
340     | equations annotation SC                                   { EquationAnnotation $2 :: $1 }
341     ;
342
343 algorithm_clause
344     : INITIAL ALGORITHM algorithms                              { AlgorithmClause (Initial, List.rev $3) }
345     | ALGORITHM algorithms                                      { AlgorithmClause (NotInitial, List.rev $2) }
346     ;
347
348 algorithms
349     :                                                           { [] }
350     | algorithms algorithm comment SC                           { Algorithm ($2, $3) :: $1 }
351     | algorithms annotation SC                                  { AlgorithmAnnotation $2 :: $1 }
352     ;
353
354 equation
355     : simple_expression EQ expression                           { Equality ($1, $3) }
356     | conditional_equation_e                                    { $1 }
357     | for_clause_e                                              { $1 }
358     | connect_clause                                            { $1 }
359     | when_clause_e                                             { $1 }
360     | component_reference LP RP                                 { FunctionCallE ($1, None) }
361     | component_reference LP function_arguments RP              { FunctionCallE ($1, Some $3) }
362     ;
363
364 algorithm
365     : component_reference COLEQ expression                      { Assignment ($1, $3) }
366     | component_reference LP RP                                 { FunctionCallA ($1, None) }
367     | component_reference LP function_arguments RP              { FunctionCallA ($1, Some $3) }
368     | LP expression_list RP COLEQ
369       component_reference LP RP                                 { MultipleAssignment ($2, $5, None) }
370     | LP expression_list RP COLEQ
371       component_reference LP function_arguments RP              { MultipleAssignment ($2, $5, Some $7) }
372     | conditional_equation_a                                    { $1 }
373     | for_clause_a                                              { $1 }
374     | while_clause                                              { $1 }
375     | when_clause_a                                             { $1 }
376     ;
377
378 conditional_equation_e
379     : IF expression THEN
380         equations_e
381       else_if_expressions_e
382       else_option_e
383       END IF                                                    { ConditionalEquationE (($2, (List.rev $4)) :: $5, $6) }
384     ;
385
386 else_if_expressions_e
387     :                                                           { [] }
388     | ELSEIF expression THEN
389         equations_e
390       else_if_expressions_e                                     { ($2, (List.rev $4)) :: $5 }
391     ;
392
393 else_option_e
394     :                                                           { [] }
395     | ELSE equations_e                                          { List.rev $2 }
396     ;
397
398 equations_e
399     : equation SC                                               { [$1] }
400     | equations_e equation SC                                   { $2 :: $1 }
401     ;
402
403 conditional_equation_a
404     : IF expression THEN
405         algorithms_a
406       else_if_expressions_a
407       else_option_a
408       END IF                                                    { ConditionalEquationA (($2, (List.rev $4)) :: $5, $6) }
409     ;
410
411 else_if_expressions_a
412     :                                                           { [] }
413     | ELSEIF expression THEN
414         algorithms_a
415       else_if_expressions_a                                     { ($2, (List.rev $4)) :: $5 }
416     ;
417
418 else_option_a
419     :                                                           { [] }
420     | ELSE algorithms_a                                         { List.rev $2 }
421     ;
422
423 algorithms_a
424     : algorithm SC                                              { [$1] }
425     | algorithms_a algorithm SC                                 { $2 :: $1 }
426     ;
427
428 for_clause_e
429     : FOR for_indices LOOP
430         equations_e
431       END FOR                                                   { ForClauseE ($2, List.rev $4) }
432     ;
433
434 for_clause_a
435     : FOR for_indices LOOP
436         algorithms_a
437       END FOR                                                   { ForClauseA ($2, List.rev $4) }
438     ;
439
440 for_indices
441     : for_index                                                 { [$1] }
442     | for_index CM for_indices                                  { $1 :: $3 }
443     ;
444
445 for_index
446     : IDENT in_expression_option                                { ($1, $2) }
447     ;
448
449 in_expression_option
450     :                                                           { None }
451     | IN expression                                             { Some $2 }
452     ;
453
454 while_clause
455     : WHILE expression LOOP
456         algorithms_a
457       END WHILE                                                 { WhileClause ($2, List.rev $4) }
458     ;
459
460 when_clause_e
461     : WHEN expression THEN
462         equations_e
463       else_when_expressions_e
464       END WHEN                                                  { WhenClauseE (($2, $4) :: $5) }
465     ;
466
467 when_clause_a
468     : WHEN expression THEN
469         algorithms_a
470       else_when_expressions_a
471       END WHEN                                                  { WhenClauseA (($2, $4) :: $5) }
472     ;
473
474 else_when_expressions_e
475     :                                                           { [] }
476     | ELSEWHEN expression THEN
477         equations_e
478       else_when_expressions_e                                   { ($2, $4) :: $5 }
479     ;
480
481 else_when_expressions_a
482     :                                                           { [] }
483     | ELSEWHEN expression THEN
484         algorithms_a
485       else_when_expressions_a                                   { ($2, $4) :: $5 }
486     ;
487
488 connect_clause
489     : CONNECT LP connector_ref CM connector_ref RP              { ConnectClause ($3, $5) }
490     ;
491
492 connector_ref
493     : IDENT array_subscripts_option                             { [($1, $2)] }
494     | IDENT array_subscripts_option
495         DOT IDENT array_subscripts_option                       { [($1, $2); ($4, $5)] }
496     ;
497
498 /*(2.2.7)*/
499 expression
500     : simple_expression                                         { $1 }
501     | IF expression THEN expression
502       elseifs_option
503       ELSE expression                                           { If (($2, $4) :: $5, $7) }
504     ;
505
506 elseifs_option
507     :                                                           { [] }
508     | ELSEIF expression THEN expression
509       elseifs_option                                            { ($2, $4) :: $5 }
510     ;
511
512 simple_expression
513     : logical_expression                                        { $1 }
514     | logical_expression CL logical_expression                  { Range ($1, $3, None) }
515     | logical_expression
516         CL logical_expression CL logical_expression             { Range ($1, $3, Some $5) }
517     ;
518
519 logical_expression
520     : logical_term                                              { $1 }
521     | logical_expression OR logical_term                        { Or ($1, $3) }
522     ;
523
524 logical_term
525     : logical_factor                                            { $1 }
526     | logical_term AND logical_factor                           { And ($1, $3) }
527     ;
528
529 logical_factor
530     : relation                                                  { $1 }
531     | NOT relation                                              { Not $2 }
532     ;
533
534 relation
535     : arithmetic_expression                                     { $1 }
536     | arithmetic_expression LT arithmetic_expression            { LessThan ($1, $3) }
537     | arithmetic_expression GT arithmetic_expression            { GreaterThan ($1, $3) }
538     | arithmetic_expression LE arithmetic_expression            { LessEqualThan ($1, $3) }
539     | arithmetic_expression GE arithmetic_expression            { GreaterEqualThan ($1, $3) }
540     | arithmetic_expression EE arithmetic_expression            { Equals ($1, $3) }
541     | arithmetic_expression NE arithmetic_expression            { NotEquals ($1, $3) }
542     ;
543
544 arithmetic_expression
545     : signed_term                                               { $1 }
546     | arithmetic_expression PLUS term                           { Addition ($1, $3) }
547     | arithmetic_expression MINUS term                          { Subtraction ($1, $3) }
548     ;
549
550 signed_term
551     : term                                                      { $1 }
552     | PLUS term                                                 { Plus $2 }
553     | MINUS term                                                { Minus $2 }
554     ;
555
556 term
557     : factor                                                    { $1 }
558     | term STAR factor                                          { Multiplication ($1, $3) }
559     | term SLASH factor                                         { Division ($1, $3) }
560     ;
561
562 factor
563     : primary                                                   { $1 }
564     | primary EXP primary                                       { Power ($1, $3) }
565     ;
566
567 primary
568     : UNSIGNED_INTEGER                                          { Integer $1 }
569     | UNSIGNED_NUMBER                                           { Real $1 }
570     | STRING                                                    { String $1 }
571     | FALSE                                                     { False }
572     | TRUE                                                      { True }
573     | component_reference                                       { Reference $1 }
574     | component_reference LP RP                                 { FunctionCall ($1, None) }
575     | component_reference LP function_arguments RP              { FunctionCall ($1, Some $3) }
576     | LP expression_list RP                                     { ExpressionList (Array.of_list $2) }
577     | LSB expression_lists RSB                                  { ArrayConcatenation $2 }
578     | LCB function_arguments RCB                                { VectorOrRecord $2 }
579     ;
580
581 expression_lists
582     : expression_list                                           { [$1] }
583     | expression_list SC expression_lists                       { $1 :: $3 }
584     ;
585
586 name
587     : IDENT                                                     { [$1] }
588     | name DOT IDENT                                            { $1 @ [$3] }
589     ;
590
591 component_reference
592     : IDENT array_subscripts_option                             { [$1, $2] }
593     | IDENT array_subscripts_option DOT component_reference     { ($1, $2) :: $4 }
594     ;
595
596 function_arguments
597     : expression FOR for_indices                                { ArgList ([$1], Some $3) }
598     | expression CM expression_list FOR for_indices             { ArgList ($1 :: $3, Some $5) }
599     | expression                                                { ArgList ([$1], None) }
600     | expression CM expression_list                             { ArgList ($1 :: $3, None) }
601     | named_arguments FOR for_indices                           { NamedArgList ($1, Some $3) }
602     | named_arguments                                           { NamedArgList ($1, None) }
603     ;
604
605 named_arguments
606     : named_argument                                            { [$1] }
607     | named_argument CM named_arguments                         { $1 :: $3 }
608     ;
609
610 named_argument
611     : IDENT EQ expression                                       { ($1, $3) }
612     ;
613
614 expression_list
615     : expression                                                { [$1] }
616     | expression CM expression_list                             { $1 :: $3 }
617     ;
618
619 array_subscripts
620     : LSB subscripts RSB                                        { $2 }
621     ;
622
623 subscripts
624     : subscript                                                 { [$1] }
625     | subscript CM subscripts                                   { $1 :: $3 }
626     ;
627
628 subscript
629     : CL                                                        { All }
630     | expression                                                { Subscript $1 }
631     ;
632
633 comment
634     : string_comment                                            { Comment ($1, None) }
635     | string_comment annotation                                 { Comment ($1, Some $2) }
636     ;
637
638 string_comment
639     :                                                           { StringComment [] }
640     | strings                                                   { StringComment (List.rev $1) }
641     ;
642
643 strings
644     : STRING                                                    { [$1] }
645     | strings PLUS STRING                                       { $3 :: $1 }
646     ;
647
648 annotation
649     : ANNOTATION class_modification                             { Annotation $2 }
650     ;
651
652 %%
653
654 let parse filename token_fun lexbuf =
655   try stored_definition_eof token_fun lexbuf with
656     | Parsing.Parse_error ->
657         let linenum, linebeg =
658           Linenum.for_position filename (Lexing.lexeme_start lexbuf) in
659         let first_char = Lexing.lexeme_start lexbuf - linebeg in
660         Printf.eprintf
661           "Syntax error at line %d, characters %d to %d\n"
662           linenum
663           first_char 
664           ((Lexing.lexeme_end lexbuf - Lexing.lexeme_start lexbuf) + first_char);
665         raise Parsing.Parse_error