source: trunk/Compiler/ModelicaFrontEnd/src/parser/Modelica.parser @ 13009

Last change on this file since 13009 was 13009, checked in by tgutzmann, 5 months ago

#5794 Make SrcFunctionCall and SrcArrayConstructor annotation providers, instead of SrcFunctionCallArguments. Done some cleanup, improved some pretty-printing and fixed some documentation on the side.

File size: 45.9 KB
Line 
1/*
2    Copyright (C) 2009-2014 Modelon AB
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, version 3 of the License.
7
8    This program is distributed in the hope that it will be useful,
9    but WITHOUT ANY WARRANTY; without even the implied warranty of
10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11    GNU General Public License for more details.
12
13    You should have received a copy of the GNU General Public License
14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
15*/
16
17%goal source_root;
18%goal anonymous_short_class;
19%goal exp;
20%goal element;
21%goal abstract_equation;
22%goal argument;
23%goal access_scalar;
24
25%header {:
26 package $PARSER_PACKAGE$;
27 import $AST_PACKAGE$.*;
28 import org.jmodelica.util.AdjustableSymbol;
29 import org.jmodelica.util.AbstractAdjustableSymbol;
30 import org.jmodelica.util.formatting.FormattingRecorder;
31 import org.jmodelica.util.formatting.FormattingType;
32 import org.jmodelica.api.problemHandling.Problem;
33 import org.jmodelica.api.problemHandling.ProblemSeverity;
34 import org.jmodelica.api.problemHandling.ProblemKind;
35 import beaver.Parser.Events;
36 import java.io.*;
37 import java.util.Collection;
38 import java.util.Map;
39:};
40
41%embed {:
42
43    /**
44     * Error reporting class that creates an error message and delegates reporting the
45     * message to a subclass.
46     */
47    public abstract static class Report extends Events {
48
49        /**
50         * Report an error with error message <code>msg</code>.
51         */
52        protected abstract void report(Problem P);
53
54        /**
55         * Creates an error message for when <code>token</code> is found unexpectedly.
56         * Passes the error message to {@link #report(Problem)}.
57         * @param token     the unexpected symbol.
58         */
59        public void syntaxError(Symbol token) {
60           
61            StringBuilder s = new StringBuilder();
62            //s.append("Syntax error at line "+ Symbol.getLine(token.getStart()) + ", column " + Symbol.getColumn(token.getStart()) + "\n");
63            if (token.getId() == Terminals.EOF) {
64                s.append("  Unexpected end of file");
65            } else if (token.value != null) {
66                s.append("   Unexpected token: \"" + token.value + "\"");
67            } else if (token.getId()<Terminals.NAMES.length)
68                s.append("  Unexpected token: " + Terminals.NAMES[token.getId()]);
69            else
70                s.append("  Syntactic error");
71            Problem p = new Problem(fileName, s.toString(), ProblemSeverity.ERROR, ProblemKind.SYNTACTIC,
72                    Symbol.getLine(token.getStart()), Symbol.getColumn(token.getStart()),
73                    Symbol.getLine(token.getEnd()), Symbol.getColumn(token.getEnd()));
74           
75            report(p);
76        }
77
78        /**
79         * Creates an error message for when the scanner throws an exception.
80         * Passes the error message to {@link #report(Problem)}.
81         * @param e     the exception.
82         */
83        public void scannerError(Scanner.Exception e) {
84            /*
85            StringBuilder s = new StringBuilder(e.getMessage());
86            s.append(" at line ");
87            s.append(e.line);
88            s.append(", column ");
89            s.append(e.column);
90            */
91            Problem p = new Problem(fileName, e.getMessage(), ProblemSeverity.ERROR, ProblemKind.LEXICAL,
92                    e.line, e.column, e.line, e.column);
93           
94            report(p);
95        }
96
97        private String fileName = "";
98
99        public void setFileName(String fn) {
100            fileName = fn;
101        }
102
103    }
104   
105    /**
106     * Error reporting class that throws a {@link ParserException} on an error.
107     * Uses error message created by {@link Report}.
108     */
109    public class AbortingReport extends Report {
110
111        /**
112         * Throws a <code>ParserException</code> with <code>msg</code> as the message.
113         */
114        @Override
115        protected void report(Problem p) {
116          throw new ParserException(p);
117        }
118
119    }
120
121    /**
122     * Error reporting class that collects error messages for later retrieval.
123     * Uses error message created by {@link Report}.
124     */
125    public static class CollectingReport extends Report {
126
127        private ArrayList<Problem> errors = new ArrayList<Problem>();
128
129        /**
130         * Adds error message <code>msg</code> to list.
131         */
132        @Override
133        protected void report(Problem p) {
134            errors.add(p);         
135        }
136
137        /**
138         * Get the list of errors. Returns a reference to the internal list, not a copy.
139         * @return a {@link java.util.Collection} with the reported error messages.
140         */
141        public Collection<Problem> getErrors() {
142            return errors;
143        }
144
145        /**
146         * Reset the list of errors.
147         */
148        public void resetErrors() {
149            errors = new ArrayList<Problem>();
150        }
151
152        /**
153         * Checks if any errors has been reported.
154         * @return <code>true</code> if the list contains any errors.
155         */
156        public boolean hasErrors() {
157            return !errors.isEmpty();
158        }
159
160    }
161
162    { report = new AbortingReport(); }  // As default, throw exception on errors.
163
164    /**
165     * Set the error reporting class to use.
166     * @param report    a subclass of {@link Events} to use for reporting errors.
167     */
168    public void setReport(Events report) {
169        this.report = report;
170    }
171
172    public Events getReport() {
173        return report;
174    }
175
176    private int[] lineBreakMap;
177
178    public void setLineBreakMap(int[] map) {
179        lineBreakMap = map;
180    }
181
182    private FormattingRecorder<ASTNode<?>> formattingRecorder;
183
184    public void setFormattingRecorder(FormattingRecorder<ASTNode<?>> formattingRecorder) {
185        this.formattingRecorder = formattingRecorder;
186    }
187
188    public void setFileName(String fn) {
189        if (report instanceof Report)
190            ((Report) report).setFileName(fn);
191    }
192   
193    private LoadInfo loadInfo;
194   
195    public void setLoadInfo(LoadInfo loadInfo) {
196        this.loadInfo = loadInfo;
197    }
198   
199    public LoadInfo getLoadInfo() {
200        return loadInfo;
201    }
202   
203    Symbol annotationTok = null;
204   
205    private void adjustStart(Symbol... syms) {
206        AdjustableSymbol[] aSyms = new AdjustableSymbol[syms.length];
207        for (int i = 0; i < syms.length; i++) {
208            /* All symbols involved implements AdjustableSymbol, but since we can't change
209             * Beaver, the Java compiler can't verify that. If any Symbol used doesn't then
210             * we want to know that - thus the raw cast. */
211            aSyms[i] = (AdjustableSymbol) syms[i];
212        }
213        if (aSyms.length > 0) {
214            aSyms[0].adjustStartOfEmptySymbols(aSyms, 1, 0);
215        }
216    }
217   
218    private static class Bool extends AbstractAdjustableSymbol {
219        public final boolean value;
220       
221        public Bool(boolean val) {
222            value = val;
223        }
224    }
225   
226    private static Bool newTrue() {
227        return new Bool(true);
228    }
229   
230    private static Bool newFalse() {
231        return new Bool(false);
232    }
233   
234    private static class RedeclareReplaceableHeader extends AbstractAdjustableSymbol {
235        public final boolean has_redeclare;
236        public final boolean has_each;
237        public final boolean has_final;
238       
239        public RedeclareReplaceableHeader(boolean has_redeclare,
240                                          boolean has_each,
241                                          boolean has_final) {
242            this.has_redeclare = has_redeclare;
243            this.has_each = has_each;
244            this.has_final = has_final;
245        }
246    }
247   
248    private static class TypePrefixes extends AbstractAdjustableSymbol {
249        public final Opt<SrcTypePrefixFlow> flow;
250        public final Opt<SrcTypePrefixVariability> variability;
251        public final Opt<SrcTypePrefixInputOutput> input_output;
252       
253        public TypePrefixes(Opt<SrcTypePrefixFlow> flow,
254                            Opt<SrcTypePrefixVariability> variability,
255                            Opt<SrcTypePrefixInputOutput> input_output) {
256            super(flow, variability, input_output);
257            this.flow = flow;
258            this.variability = variability;
259            this.input_output = input_output;
260        }
261    }
262   
263    private static class ConstrClauseAndComment extends AbstractAdjustableSymbol {
264        public final Opt<SrcConstrainingClause> constr;
265        public final SrcComment comment;
266       
267        public ConstrClauseAndComment(SrcConstrainingClause constr,
268                                      SrcComment comment) {
269            super(constr, comment);
270            this.constr = new Opt(constr);
271            this.comment = comment;
272        }
273       
274        public ConstrClauseAndComment() {
275            this.constr = new Opt();
276            this.comment = new SrcComment();
277        }
278    }
279:};
280 
281SourceRoot source_root
282    = /* blank */
283    {:
284        SourceRoot sr = new SourceRoot(new Program(new List()));
285        return sr;
286    :}
287    | program
288    {:
289       SourceRoot sr = new SourceRoot(program);
290       return sr;
291    :};
292
293Program program
294    = stored_definition
295    {:
296        return new Program(new List().add(stored_definition));
297    :};
298 
299SrcStoredDefinition stored_definition
300    = within? base_class_decl_list
301    {:
302        SrcStoredDefinition def = new SrcStoredDefinition(within, base_class_decl_list, getLoadInfo());
303        def.setLineBreakMap(lineBreakMap);
304        formattingRecorder.postParsing(def);
305        return def;
306    :}
307    | error
308    {:
309        return new SrcBadDefinition();
310    :};
311
312SrcWithin within
313    = WITHIN access? SEMICOLON
314    {:
315        return new SrcWithin(access);
316    :};
317 
318List base_class_decl_list
319    = base_class_decl SEMICOLON
320    {:
321        return new List().add(base_class_decl);
322    :}
323    | base_class_decl_list base_class_decl SEMICOLON
324    {:
325        base_class_decl_list.add(base_class_decl);
326        return base_class_decl_list;
327    :};
328
329SrcBaseClassDecl anonymous_short_class
330    = extends_clause_short_class
331    {:
332        return new SrcShortClassDecl(
333            new SrcIdDecl("'Anonymous Class'"),
334            false, false,
335            new SrcClass(),
336            false, false, false, false, false,
337            new Opt(), new Opt(),
338            extends_clause_short_class);
339    :};
340
341SrcBaseClassDecl base_class_decl
342    = has_encapsulated
343      has_partial
344      restriction 
345      id_decl.start
346      string_comment?
347      clause_star
348      external_clause?
349      class_annotation?
350      end_decl
351    {:
352        adjustStart(has_encapsulated, has_partial, restriction);
353        return new SrcFullClassDecl(
354            start,
355            has_encapsulated.value,
356            has_partial.value,
357            restriction,
358            false, false, false, false, false,
359            new Opt(), new Opt(),
360            string_comment,
361            clause_star,
362            external_clause,
363            class_annotation,
364            end_decl);
365    :}
366    | has_encapsulated
367      has_partial
368      restriction 
369      id_decl.class_name EQUALS
370      extends_clause_short_class
371    {:
372        adjustStart(has_encapsulated, has_partial, restriction);
373        return new SrcShortClassDecl(
374            class_name,
375            has_encapsulated.value,
376            has_partial.value,
377            restriction,
378            false, false, false, false, false,
379            new Opt(), new Opt(),
380            extends_clause_short_class);
381    :}
382    | has_encapsulated
383      has_partial
384      restriction
385      EXTENDS
386      id_decl.start
387      class_modification?
388      string_comment?
389      clause_star
390      external_clause?
391      class_annotation?
392      end_decl
393    {:
394        adjustStart(has_encapsulated, has_partial, restriction);
395        SrcInlineExtendsClause ext = new SrcInlineExtendsClause(
396            new SrcNamedAccess(start.getID()),
397            class_modification,
398            new Opt());
399        return new SrcExtendClassDecl(
400            start,
401            has_encapsulated.value,
402            has_partial.value,
403            restriction,
404            false, false, false, false, false,
405            new Opt(), new Opt(),
406            string_comment,
407            clause_star,
408            external_clause,
409            class_annotation,
410            end_decl,
411            ext);
412    :}
413    | has_encapsulated
414      has_partial
415      restriction
416      id_decl.enum_name
417      EQUALS
418      ENUMERATION
419      LPAREN
420      enum_specification
421      RPAREN
422      comment
423    {:
424        adjustStart(has_encapsulated, has_partial, restriction);
425        return new SrcEnumClassDecl(
426            enum_name,
427            has_encapsulated.value,
428            has_partial.value,
429            restriction,
430            false, false, false, false, false,
431            new Opt(), new Opt(),
432            comment.getSrcStringCommentOpt(),
433            new List(new SrcDefaultElementList(new List(enum_specification))),
434            new Opt(),
435            comment.getSrcAnnotationOpt(),
436            new SrcEndDecl(enum_name.getID()));
437    :}
438    | error
439    {:
440        return new SrcBadClassDecl();
441    :};
442
443SrcExtendsClauseShortClass extends_clause_short_class
444    = type_prefixes
445      access_scalar
446      array_subscripts?
447      class_modification?
448      comment
449    {:
450        adjustStart(type_prefixes, access_scalar);
451        return new SrcExtendsClauseShortClass(
452            access_scalar,
453            class_modification,
454            new Opt<SrcAnnotation>(),
455            type_prefixes.flow,
456            type_prefixes.variability,
457            type_prefixes.input_output,
458            array_subscripts,
459            comment);
460    :}
461    ;
462
463SrcEnumComponentClause enum_specification
464    = enum_contents
465    {:
466        return new SrcEnumComponentClause(
467                false, false, false, false, false,
468                new Opt(),
469                new Opt(new SrcConstant()),
470                new Opt(),
471                new SrcNamedAccess("EnumType"),
472                new Opt(),
473                enum_contents,
474                new Opt(),
475                new SrcComment());
476    :}
477    ;
478
479List enum_contents
480    = COLON                {: return new List(); :}
481    | enum_literal_list    {: return enum_literal_list; :}
482    ;
483 
484List enum_literal_list
485    = enum_literal
486    {:
487        return new List(enum_literal);
488    :}
489    | enum_literal_list
490      COMMA
491      enum_literal
492    {:
493        enum_literal_list.add(enum_literal);
494        return enum_literal_list;
495    :}
496    ;
497
498SrcEnumLiteralDecl enum_literal
499    = id_decl
500      comment
501    {:
502        return new SrcEnumLiteralDecl(
503                id_decl,
504                new Opt(),
505                new Opt(),
506                new Opt(),
507                comment);
508    :}
509    ;
510
511SrcTypePrefixFlow type_prefix_flow
512    = FLOW      {: return new SrcFlow();   :}
513    | STREAM    {: return new SrcStream(); :}
514    ;
515
516SrcTypePrefixVariability type_prefix_variability
517    = DISCRETE    {: return new SrcDiscrete();  :}
518    | PARAMETER   {: return new SrcParameter(); :}
519    | CONSTANT    {: return new SrcConstant();  :}
520    ;
521
522SrcTypePrefixInputOutput type_prefix_input_output
523    = INPUT     {: return new SrcInput();  :}
524    | OUTPUT    {: return new SrcOutput(); :}
525    ;
526
527TypePrefixes type_prefixes
528    = type_prefix_flow?
529      type_prefix_variability?
530      type_prefix_input_output?
531    {:
532        adjustStart(type_prefix_flow, type_prefix_variability, type_prefix_input_output);
533        return new TypePrefixes(type_prefix_flow, type_prefix_variability, type_prefix_input_output);
534    :}
535    ;
536
537
538SrcRestriction restriction
539    = CLASS                   {: return new SrcClass();              :}
540    | MODEL                   {: return new SrcModel();               :}
541    | BLOCK                   {: return new SrcBlock();               :}
542    | CONNECTOR               {: return new SrcConnector();           :}
543    | EXPANDABLE CONNECTOR    {: return new SrcExpandableConnector(); :}
544    | TYPE                    {: return new SrcType();               :}
545    | PACKAGE                 {: return new SrcPackage();            :}
546    | FUNCTION                {: return new SrcFunction();            :}
547    | RECORD                  {: return new SrcRecord();              :}
548    | OPERATOR RECORD         {: return new SrcOperatorRecord();      :}
549    | OPERATOR FUNCTION       {: return new SrcOperatorFunction();    :}
550    | OPERATOR                {: return new SrcOperator();            :}
551    ;
552
553Bool has_partial
554    = PARTIAL     {: return newTrue();  :}
555    | /* blank */ {: return newFalse(); :}
556    ;
557
558Bool has_encapsulated
559    = ENCAPSULATED {: return newTrue();  :}
560    | /* blank */  {: return newFalse(); :}
561    ;
562
563Bool has_inner
564    = INNER       {: return newTrue();  :}
565    | /* blank */ {: return newFalse(); :}
566    ;
567
568Bool has_outer
569    = OUTER       {: return newTrue();  :}
570    | /* blank */ {: return newFalse(); :}
571    ;
572
573Bool has_redeclare
574    = REDECLARE   {: return newTrue();  :}
575    | /* blank */ {: return newFalse(); :}
576    ;
577
578Bool has_each
579    = EACH        {: return newTrue();  :}
580    | /* blank */ {: return newFalse(); :}
581    ;
582
583Bool has_final
584    = FINAL       {: return newTrue();  :}
585    | /* blank */ {: return newFalse(); :}
586    ;
587
588RedeclareReplaceableHeader redeclare_replaceable_header
589    = REDECLARE
590      has_each
591      has_final
592      REPLACEABLE
593    {:
594        return new RedeclareReplaceableHeader(true, has_each.value, has_final.value);
595    :}
596    | has_each
597      has_final
598      REPLACEABLE
599    {:
600        adjustStart(has_each, has_final, REPLACEABLE);
601        return new RedeclareReplaceableHeader(false, has_each.value, has_final.value);
602    :}
603    ;
604
605
606List clause_star
607    = default_element_list
608    {:
609        return new List(default_element_list);
610    :}
611    | /* blank */
612    {:
613        return new List();
614    :}
615    | clause_star
616      clause
617    {:
618        return clause_star.add(clause);
619    :}
620    ;
621
622SrcDefaultElementList default_element_list
623    = element_plus
624    {:
625        return new SrcDefaultElementList(element_plus);
626    :}
627    ;
628
629List element_plus
630    = element
631    {:
632        return new List(element);
633    :}
634    | element_plus
635      element
636    {:
637        return element_plus.add(element);
638    :}
639    ;
640
641
642SrcClause clause
643    = PUBLIC
644      element*
645    {:
646        return new SrcPublicElementList(element);
647    :}
648    | PROTECTED
649      element*
650    {:
651        return new SrcProtectedElementList(element);
652    :}
653    | EQUATION
654      abstract_equation*
655    {:
656        return new SrcEquationClause(abstract_equation);
657    :}
658    | INITIAL_EQUATION
659      abstract_equation*
660    {:
661        return new SrcInitialEquationClause(abstract_equation);
662    :}
663    | ALGORITHM
664      statement*
665    {:
666        return new SrcAlgorithm(statement);
667    :}
668    | INITIAL_ALGORITHM
669      statement*
670    {:
671        return new SrcInitialAlgorithm(statement);
672    :}
673    ;
674
675
676SrcExternalClause external_clause
677    = EXTERNAL
678      external_language?
679      external_function_call?
680      annotation?
681      SEMICOLON
682    {:
683        return new SrcExternalClause(external_language, external_function_call, annotation);
684    :}
685    ;
686
687SrcExternalLanguage external_language
688    = STRING.s    {: return new SrcExternalLanguage(s); :}
689    ;
690
691SrcAnnotation class_annotation
692    = annotation
693      SEMICOLON
694    {:
695        return annotation;
696    :}
697    ;
698
699SrcExternalFunctionCall external_function_call
700    = access
701      EQUALS
702      id_decl
703      LPAREN
704      arg_list
705      RPAREN
706    {:
707        return new SrcExternalFunctionCall(new Opt(access), id_decl, arg_list);
708    :}
709    | id_decl
710      LPAREN
711      arg_list
712      RPAREN
713    {:
714        return new SrcExternalFunctionCall(new Opt(), id_decl, arg_list);
715    :}
716    ;
717
718
719SrcElement element
720    = has_redeclare
721      has_final
722      has_inner
723      has_outer
724      base_class_decl
725      SEMICOLON
726    {:
727        adjustStart(has_redeclare, has_final, has_inner, has_outer, base_class_decl);
728        base_class_decl.setRedeclare(has_redeclare.value);
729        base_class_decl.setFinal(has_final.value);
730        base_class_decl.setInner(has_inner.value);
731        base_class_decl.setOuter(has_outer.value);
732        return base_class_decl;
733    :}
734    | has_redeclare
735      has_final
736      has_inner
737      has_outer
738      REPLACEABLE
739      base_class_decl
740      constraining_clause_and_comment
741      SEMICOLON
742    {:
743        adjustStart(has_redeclare, has_final, has_inner, has_outer, REPLACEABLE);
744        base_class_decl.setRedeclare(has_redeclare.value);
745        base_class_decl.setFinal(has_final.value);
746        base_class_decl.setInner(has_inner.value);
747        base_class_decl.setOuter(has_outer.value);
748        base_class_decl.setReplaceable(true);
749        base_class_decl.setSrcConstrainingClauseOpt(constraining_clause_and_comment.constr);
750        base_class_decl.setConstrainingClauseComment(constraining_clause_and_comment.comment);
751        return base_class_decl;
752    :} 
753    | extends_clause SEMICOLON
754    {:
755        return extends_clause;
756    :}
757    | import_clause SEMICOLON
758    {:
759        return import_clause;
760    :}
761    | has_redeclare
762      has_final
763      has_inner
764      has_outer
765      type_prefixes
766      access_scalar
767      array_subscripts?
768      component_list
769      SEMICOLON
770    {:
771        adjustStart(has_redeclare, has_final, has_inner, has_outer, type_prefixes, access_scalar);
772        return new SrcComponentClause(
773            has_redeclare.value,
774            has_final.value,
775            has_inner.value,
776            has_outer.value,
777            false,
778            type_prefixes.flow,
779            type_prefixes.variability,
780            type_prefixes.input_output,
781            access_scalar,
782            array_subscripts,
783            component_list,
784            new Opt(),
785            new SrcComment());
786    :}
787    | has_redeclare
788      has_final
789      has_inner
790      has_outer
791      REPLACEABLE
792      type_prefixes
793      access_scalar
794      array_subscripts?
795      component_list
796      constraining_clause_and_comment
797      SEMICOLON
798    {:
799        adjustStart(has_redeclare, has_final, has_inner, has_outer, REPLACEABLE);
800        return new SrcComponentClause(
801            has_redeclare.value,
802            has_final.value,
803            has_inner.value,
804            has_outer.value,
805            true,
806            type_prefixes.flow,
807            type_prefixes.variability,
808            type_prefixes.input_output,
809            access_scalar,
810            array_subscripts,
811            component_list,
812            constraining_clause_and_comment.constr,
813            constraining_clause_and_comment.comment);
814    :}
815    | error SEMICOLON
816    {:
817        return new SrcBadElement();
818    :}
819    ;
820
821ConstrClauseAndComment constraining_clause_and_comment
822    = constraining_clause
823      comment
824    {:
825        return new ConstrClauseAndComment(constraining_clause, comment);
826    :}
827    | /* blank */
828    {:
829        return new ConstrClauseAndComment();
830    :}
831    ;
832
833SrcConstrainingClause constraining_clause
834    = CONSTRAINEDBY
835      access
836      class_modification?
837    {:
838        return new SrcConstrainingClause(access, class_modification);
839    :}
840    ;
841
842SrcExtendsClause extends_clause
843    = EXTENDS
844      access
845      class_modification?
846      annotation?
847    {:
848        return new SrcExtendsClause(access, class_modification, annotation);
849    :}
850  ;
851
852SrcImportClause import_clause
853    = IMPORT
854      access_scalar
855      comment
856    {:
857        return new SrcImportClauseQualified(access_scalar, comment);
858    :}
859    | IMPORT
860      access_scalar
861      DOTMULT
862      comment
863    {:
864        return new SrcImportClauseUnqualified(access_scalar, comment);
865    :}
866    | IMPORT
867      id_decl.alias
868      EQUALS
869      access_scalar
870      comment
871    {:
872        return new SrcImportClauseRename(access_scalar, comment, alias);
873    :}
874    ;
875
876
877SrcArraySubscripts array_subscripts
878    = LBRACK
879      subscript_list
880      RBRACK
881    {:
882        return new SrcArraySubscripts(subscript_list);
883    :}
884    ;
885
886List subscript_list
887    = subscript
888    {:
889        return new List().add(subscript);
890    :}
891    | subscript_list
892      COMMA
893      subscript
894    {:
895        subscript_list.add(subscript);
896        return subscript_list;
897    :}
898    ;
899
900SrcSubscript subscript
901    = COLON   {: return new SrcColonSubscript();  :}
902    | exp     {: return new SrcExpSubscript(exp); :}
903    ;
904
905
906List component_list
907    = component_decl
908    {:
909        return new List(component_decl);
910    :}
911    | component_list
912      COMMA
913      component_decl
914    {:
915        component_list.add(component_decl);
916        return component_list;
917    :}
918    ;
919
920SrcComponentDecl component_decl
921    = id_decl.comp_name
922      array_subscripts?
923      modification?
924      conditional_attribute?
925      comment
926    {:
927        return new SrcComponentDecl(comp_name,
928                                 array_subscripts,
929                                 modification,
930                                 conditional_attribute,
931                                 comment);
932    :}
933    ;
934
935SrcComponentDecl component_decl_no_conditional
936    = id_decl.comp_name
937      array_subscripts?
938      modification?
939      comment
940    {:
941        return new SrcComponentDecl(comp_name,
942                                 array_subscripts,
943                                 modification,
944                                 new Opt(),
945                                 comment);
946    :}
947    ;
948
949SrcConditionalAttribute conditional_attribute
950    = IF exp    {: return new SrcConditionalAttribute(exp); :}
951    ;
952
953SrcModification modification
954    = complete_modification   {: return complete_modification; :}
955    | value_modification      {: return value_modification;    :}
956// Assign modification for binding equations in functions - enable after figuring out
957// a good way to make it an error outside of functions. Preferably parse error, but that
958// likely requires much more code duplication then we want to accept.
959//  | assign_modification     {: return assign_modification;   :}
960    ;
961
962
963SrcCompleteModification complete_modification
964    = class_modification
965      value_modification?
966    {:
967        return new SrcCompleteModification(class_modification, value_modification);
968    :}
969    ;
970 
971SrcValueModification value_modification
972    = EQUALS exp          {: return new SrcValueModification(exp); :}
973    | COLON EQUALS exp    {: return new SrcValueModification(exp); :}
974    ;
975
976/* 
977// Assign modification for binding equations in functions - enable after figuring out
978// a good way to make it an error outside of functions. Preferably parse error, but that
979// likely requires much more code duplication than we want to accept.
980AssignModification assign_modification
981    = COLON EQUALS exp    {: return new AssignModification(exp); :}
982    ;
983*/
984
985SrcClassModification class_modification
986    = LPAREN
987      RPAREN
988    {:
989        return new SrcClassModification();
990    :}
991    | LPAREN
992      argument_list
993      RPAREN
994    {:
995        return new SrcClassModification(argument_list);
996    :}
997    ;
998
999List argument_list
1000    = argument
1001    {:
1002        return new List().add(argument);
1003    :}
1004    | argument_list
1005      COMMA
1006      argument
1007    {:
1008        argument_list.add(argument);
1009        return argument_list;
1010    :}
1011    ;
1012
1013SrcArgument argument
1014    = has_each
1015      has_final
1016      access
1017      modification?
1018      comment
1019    {:
1020        adjustStart(has_each, has_final, access);
1021        return new SrcComponentModification(
1022            has_each.value,
1023            has_final.value,
1024            access,
1025            modification,
1026            comment);
1027    :}
1028    | redeclare_replaceable_header
1029      base_class_decl
1030      constraining_clause?
1031    {:
1032        adjustStart(redeclare_replaceable_header, base_class_decl);
1033        SrcNamedAccess name = new SrcNamedAccess(base_class_decl.getName().getID());
1034        name.setLocationNoTree(base_class_decl.getName());
1035        base_class_decl.setSrcConstrainingClauseOpt(constraining_clause);
1036        base_class_decl.setReplaceable(true);
1037        base_class_decl.setRedeclare(redeclare_replaceable_header.has_redeclare);
1038        return new SrcClassRedeclare(
1039            redeclare_replaceable_header.has_each,
1040            redeclare_replaceable_header.has_final,
1041            name,
1042            base_class_decl);
1043    :}
1044    | REDECLARE
1045      has_each
1046      has_final 
1047      base_class_decl
1048    {:
1049        SrcNamedAccess name = new SrcNamedAccess(base_class_decl.getName().getID());
1050        name.setLocationNoTree(base_class_decl.getName());
1051        base_class_decl.setRedeclare(true);
1052        return new SrcClassRedeclare(
1053            has_each.value,
1054            has_final.value,
1055            name,
1056            base_class_decl);
1057    :}
1058    | redeclare_replaceable_header.header
1059      component_clause_in_argument.cc
1060      constraining_clause.constr?
1061    {:
1062        adjustStart(header, cc);
1063        cc.setSrcConstrainingClauseOpt(constr);
1064        cc.setLocationNoTree(header, (constr.hasChild() ? constr : cc));
1065        cc.setRedeclare(header.has_redeclare);
1066        return new SrcComponentRedeclare(
1067            header.has_each,
1068            header.has_final,
1069            cc.createAccessForRedeclareNode(),
1070            cc);
1071    :}
1072    | REDECLARE
1073      has_each
1074      has_final
1075      component_clause_in_argument.cc
1076    {:
1077        cc.setReplaceable(false);
1078        cc.setLocationNoTree(REDECLARE, cc);
1079        return new SrcComponentRedeclare(
1080            has_each.value,
1081            has_final.value,
1082            cc.createAccessForRedeclareNode(),
1083            cc);
1084    :}
1085    | error
1086    {:
1087        return new SrcBadArgument();
1088    :}
1089    ;
1090
1091SrcComponentClause component_clause_in_argument
1092    = type_prefixes
1093      access_scalar
1094      component_decl_no_conditional
1095    {:
1096        adjustStart(type_prefixes, access_scalar);
1097        return new SrcComponentClause(
1098            true,   // Changed in argument rule for case without "redeclare"
1099            false,
1100            false,
1101            false,
1102            true,   // Changed in argument rule for case without "replaceable"
1103            type_prefixes.flow,
1104            type_prefixes.variability,
1105            type_prefixes.input_output,
1106            access_scalar,
1107            new Opt(),
1108            new List(component_decl_no_conditional),
1109            new Opt(),
1110            new SrcComment());
1111    :}
1112    ;
1113
1114SrcAnnotation annotation
1115    = annotation_tok
1116      class_modification
1117    {:
1118        annotationTok = null;
1119        return new SrcParseAnnotation(class_modification);
1120    :}
1121    ;
1122
1123Symbol annotation_tok
1124    = ANNOTATION
1125    {:
1126        if (annotationTok != null) {
1127            getReport().syntaxError(ANNOTATION);
1128        }
1129        annotationTok = ANNOTATION;
1130        return new Symbol(ANNOTATION);
1131    :}
1132    ;
1133
1134SrcAbstractEquation abstract_equation
1135    = exp.left
1136      EQUALS
1137      exp.right
1138      comment
1139      SEMICOLON
1140    {:
1141        return new SrcEquation(comment, left, right);
1142    :}
1143    | if_equation
1144      SEMICOLON
1145    {:
1146        return if_equation;
1147    :}
1148    | for_clause_e
1149      SEMICOLON
1150    {:
1151        return for_clause_e;
1152    :}
1153    | when_equation
1154      SEMICOLON
1155    {:
1156        return when_equation;
1157    :}
1158    | CONNECT
1159      LPAREN
1160      access.a
1161      COMMA
1162      access.b
1163      RPAREN
1164      comment
1165      SEMICOLON
1166    {:
1167        return new SrcConnectClause(comment, a, b);
1168    :}
1169    | LPAREN
1170      function_call_left_list
1171      RPAREN
1172      EQUALS
1173      function_call
1174      comment
1175      SEMICOLON
1176    {:
1177        return new SrcFunctionCallEquation(comment, function_call_left_list, function_call);
1178    :}
1179    | function_call
1180      comment
1181      SEMICOLON
1182    {:
1183        return new SrcFunctionCallEquation(comment, new List(), function_call);
1184    :}
1185    ;
1186
1187List function_call_left_list
1188    = function_call_left.a
1189      COMMA
1190      function_call_left.b
1191    {:
1192        return new List().add(a).add(b);
1193    :}
1194    | function_call_left_list
1195      COMMA
1196      function_call_left
1197    {:
1198        return function_call_left_list.add(function_call_left);
1199    :}
1200    ;
1201
1202SrcFunctionCallLeft function_call_left
1203    = /* blank */  {: return new SrcFunctionCallLeft(); :}
1204    | access       {: return new SrcFunctionCallLeft(new Opt(access)); :}
1205    ;
1206
1207SrcForClauseE for_clause_e
1208    = FOR
1209      for_indices
1210      LOOP
1211      abstract_equation*
1212      END_FOR
1213      comment
1214    {:
1215        return new SrcForClauseE(comment, for_indices,abstract_equation);
1216    :}
1217    ;
1218
1219
1220List for_indices
1221    = for_index
1222    {:
1223        return new List().add(for_index);
1224    :}
1225    | for_indices
1226      COMMA
1227      for_index
1228    {:
1229        for_indices.add(for_index);
1230        return for_indices;
1231    :}
1232    ;
1233
1234SrcForIndex for_index
1235    = for_index_decl for_in_exp?
1236    {:
1237        SrcForIndex f = new SrcForIndex(
1238            false,
1239            false,
1240            false,
1241            false,
1242            false,
1243            new Opt(),
1244            new Opt(new SrcIndexParameter()),
1245            new Opt(),
1246            new SrcNamedAccess("Integer"),
1247            new Opt(),
1248            new List(for_index_decl),
1249            new Opt(),
1250            new SrcComment(),
1251            for_in_exp);
1252        return f;
1253    :}
1254    ;
1255
1256SrcForIndexDecl for_index_decl
1257    = id_decl
1258    {:
1259        return new SrcForIndexDecl(
1260            id_decl,
1261            new Opt(),
1262            new Opt(),
1263            new Opt(),
1264            new SrcComment());
1265    :}
1266    ;
1267
1268SrcExp for_in_exp
1269    = IN exp.e    {: return e; :}
1270    ;
1271
1272SrcWhenEquation when_equation
1273    = WHEN
1274      exp.test
1275      THEN
1276      abstract_equation*
1277      else_when_equation?
1278      END_WHEN
1279      comment
1280    {:
1281        return new SrcWhenEquation(comment,
1282                                abstract_equation,
1283                                test,
1284                                else_when_equation);
1285    :}
1286    ;
1287
1288SrcWhenEquation else_when_equation
1289    = ELSEWHEN
1290      exp.test
1291      THEN
1292      abstract_equation*
1293      else_when_equation?
1294    {:
1295        return new SrcWhenEquation(new SrcComment(),
1296                                abstract_equation,
1297                                test,
1298                                else_when_equation);
1299    :}
1300  ;
1301
1302SrcIfEquation if_equation
1303    = IF
1304      exp.test
1305      THEN
1306      abstract_equation*
1307      else_if_equation?
1308      END_IF
1309      comment
1310    {:
1311        return new SrcIfEquation(comment,
1312                              abstract_equation,
1313                              test,
1314                              else_if_equation);
1315    :}
1316    ;
1317
1318SrcIfWhenElseEquation else_if_equation
1319    = ELSEIF
1320      exp.test
1321      THEN
1322      abstract_equation*
1323      else_if_equation?
1324    {:
1325        return new SrcIfEquation(new SrcComment(),
1326                              abstract_equation,
1327                              test,
1328                              else_if_equation);
1329    :}
1330    | ELSE
1331      abstract_equation*
1332    {:
1333        return new SrcElseEquation(new SrcComment(),
1334                                abstract_equation);
1335    :}
1336    ;
1337
1338
1339SrcStatement statement
1340    = access.left ASSIGN exp.right comment SEMICOLON
1341                                      {: return new SrcAssignStmt(comment, left, right); :}
1342    | function_call_stmt SEMICOLON    {: return function_call_stmt; :}
1343    | BREAK comment SEMICOLON         {: return new SrcBreakStmt(comment); :}
1344    | RETURN comment SEMICOLON        {: return new SrcReturnStmt(comment); :}
1345    | if_stmt SEMICOLON               {: return if_stmt; :}
1346    | when_stmt SEMICOLON             {: return when_stmt; :}
1347    | for_stmt SEMICOLON              {: return for_stmt; :}
1348    | while_stmt SEMICOLON            {: return while_stmt; :}
1349    | error                           {: return new SrcBadStatement(); :}
1350    ;
1351
1352SrcFunctionCallStmt function_call_stmt =
1353    LPAREN function_call_stmt_left_list RPAREN ASSIGN function_call comment 
1354                           {: return new SrcFunctionCallStmt(comment, function_call_stmt_left_list, function_call); :}
1355  | function_call comment  {: return new SrcFunctionCallStmt(comment, new List(), function_call); :}
1356  ;
1357
1358List function_call_stmt_left_list
1359    = function_call_left
1360    {:
1361        return new List().add(function_call_left);
1362    :}
1363    | function_call_stmt_left_list
1364      COMMA
1365      function_call_left
1366    {:
1367        return function_call_stmt_left_list.add(function_call_left);
1368    :}
1369    ;
1370
1371SrcIfStmt if_stmt =
1372    IF if_clause_list else_stmts END_IF comment {: return new SrcIfStmt(comment, if_clause_list, new Opt(else_stmts)); :}
1373  | IF if_clause_list END_IF comment {: return new SrcIfStmt(comment, if_clause_list, new Opt()); :}
1374  ; 
1375
1376List if_clause_list =
1377    if_clause                      {: return new List().add(if_clause); :}
1378  | if_clause_list else_if_clause  {: return if_clause_list.add(else_if_clause); :}
1379  ;
1380
1381SrcIfClause if_clause =
1382  exp THEN statement*  {: return new SrcIfClause(exp, statement); :}
1383  ;
1384
1385SrcIfClause else_if_clause =
1386  ELSEIF if_clause  {: return if_clause; :}
1387  ;
1388
1389SrcElseClause else_stmts =
1390  ELSE statement*  {: return new SrcElseClause(statement); :}
1391  ;
1392
1393SrcWhenStmt when_stmt =
1394  WHEN when_clause_list END_WHEN comment {: return new SrcWhenStmt(comment, when_clause_list); :}
1395  ; 
1396
1397List when_clause_list =
1398    when_clause                        {: return new List().add(when_clause); :}
1399  | when_clause_list else_when_clause  {: return when_clause_list.add(else_when_clause); :}
1400  ;
1401
1402SrcWhenClause when_clause =
1403  exp THEN statement*  {: return new SrcWhenClause(exp, statement); :}
1404  ;
1405
1406SrcWhenClause else_when_clause =
1407  ELSEWHEN exp THEN statement*  {: return new SrcWhenClause(exp, statement); :}
1408  ;
1409
1410SrcForStmt for_stmt =
1411  FOR for_indices LOOP statement* END_FOR comment 
1412                         {: return new SrcForStmt(comment, for_indices, statement); :}
1413  ;
1414
1415SrcWhileStmt while_stmt =
1416  WHILE exp LOOP statement* END_WHILE comment  {: return new SrcWhileStmt(comment, exp, statement); :}
1417  ;
1418 
1419SrcExp exp =
1420  simple_expression {: return simple_expression; :}
1421  | if_exp           {: return if_exp; :}
1422  ;
1423
1424SrcIfExp if_exp =
1425  IF exp.ifexp THEN exp.thenexp else_if_exp
1426                {: return new SrcIfExp(ifexp, thenexp, else_if_exp); :}
1427  ; 
1428
1429SrcExp else_if_exp =
1430   ELSEIF exp.ifexp THEN exp.thenexp else_if_exp
1431                {: return new SrcIfExp(ifexp, thenexp, else_if_exp); :}
1432 | ELSE exp   {: return exp; :}
1433  ;
1434
1435SrcExp simple_expression =
1436    log_exp
1437        {: return log_exp; :}
1438  | log_exp.l1 COLON log_exp.l2
1439        {: SrcRangeExp r = new SrcRangeExp();
1440           r.addSrcExp(l1);
1441           r.addSrcExp(l2);
1442           return r; :}
1443  | log_exp.l1 COLON log_exp.l2 COLON log_exp.l3
1444        {: SrcRangeExp r = new SrcRangeExp();
1445           r.addSrcExp(l1);
1446           r.addSrcExp(l2);
1447           r.addSrcExp(l3);
1448           return r; :}
1449  ;
1450
1451SrcExp log_exp =
1452  log_exp.a OR log_exp.b {: return new SrcOrExp(a,b); :} 
1453  | log_exp.a AND log_exp.b {: return new SrcAndExp(a,b); :} 
1454  | NOT relation.a {: return new SrcNotExp(a); :} 
1455  | relation {: return relation; :}
1456;
1457
1458SrcExp relation =
1459  artm_exp.a LT artm_exp.b {: return new SrcLtExp(a,b); :}
1460  | artm_exp.a LEQ artm_exp.b {: return new SrcLeqExp(a,b); :}
1461  | artm_exp.a GT artm_exp.b {: return new SrcGtExp(a,b); :}
1462  | artm_exp.a GEQ artm_exp.b {: return new SrcGeqExp(a,b); :}
1463  | artm_exp.a EQ artm_exp.b {: return new SrcEqExp(a,b); :}
1464  | artm_exp.a NEQ artm_exp.b {: return new SrcNeqExp(a,b); :}
1465  | artm_exp.a {: return a; :} 
1466  ;
1467 
1468 
1469  SrcExp artm_exp =
1470   additive_exp {: return additive_exp; :}
1471   ;
1472
1473  SrcExp additive_exp =
1474     multiplicative_exp.e    {: return e; :}
1475   | additive_exp.e1 PLUS multiplicative_exp.e2      {: return new SrcAddExp(e1, e2); :}
1476   | additive_exp.e1 MINUS multiplicative_exp.e2     {: return new SrcSubExp(e1, e2); :}
1477   | additive_exp.e1 DOTPLUS multiplicative_exp.e2   {: return new SrcDotAddExp(e1, e2); :}
1478   | additive_exp.e1 DOTMINUS multiplicative_exp.e2  {: return new SrcDotSubExp(e1, e2); :}
1479   ;
1480
1481  SrcExp multiplicative_exp =
1482     unary_exp.e                                     {: return e; :}
1483   | multiplicative_exp.e1 MULT unary_exp.e2     {: return new SrcMulExp(e1, e2); :}
1484   | multiplicative_exp.e1 DIV unary_exp.e2      {: return new SrcDivExp(e1, e2); :}
1485   | multiplicative_exp.e1 DOTMULT unary_exp.e2  {: return new SrcDotMulExp(e1, e2); :}
1486   | multiplicative_exp.e1 DOTDIV unary_exp.e2   {: return new SrcDotDivExp(e1, e2); :}
1487   ;
1488
1489
1490SrcExp unary_exp =
1491   pow_exp          {: return pow_exp; :}
1492   | MINUS unary_exp       {: return new SrcNegExp(unary_exp); :}
1493   | PLUS unary_exp        {: formattingRecorder.addItem(FormattingType.NON_BREAKING_WHITESPACE, "+", PLUS);
1494                              return unary_exp; :}
1495   ;
1496
1497SrcExp pow_exp =
1498    primary {:return primary; :}
1499    | primary.a POW primary.e    {: return new SrcPowExp(a,e); :}
1500    | primary.a DOTPOW primary.e {: return new SrcDotPowExp(a,e); :}
1501    ;
1502
1503SrcExp primary =       
1504   UNSIGNED_NUMBER.n    {: return new SrcRealLitExp(n); :}
1505  | UNSIGNED_INTEGER.n    {: return new SrcIntegerLitExp(n); :}
1506  | TRUE                {: return new SrcBooleanLitExpTrue(); :}
1507  | FALSE                {: return new SrcBooleanLitExpFalse(); :}
1508  | STRING.s               {: return new SrcStringLitExp(s); :}
1509  | access_expression   {: return access_expression; :}
1510  | der_expression      {: return der_expression; :}
1511  | LPAREN exp.a RPAREN {: return new SrcParExp(a); :}
1512  | function_call        {: return function_call; :}
1513  | LBRACK matrix RBRACK {: return matrix; :}
1514  | LBRACE function_arguments RBRACE {: return new SrcArrayConstructor(function_arguments); :}
1515  | TIME                {: return new SrcTimeExp(); :}
1516  | END                 {: return new SrcEndExp(); :}
1517  ;
1518
1519SrcFunctionCall function_call
1520    = access
1521      LPAREN
1522      function_arguments?
1523      RPAREN
1524    {:
1525        return new SrcFunctionCall(access, function_arguments);
1526    :}
1527    ;
1528
1529SrcPartialFunctionCall partial_function_call
1530    = FUNCTION
1531      access
1532      LPAREN
1533      function_arguments_named?
1534      RPAREN
1535    {:
1536        return new SrcPartialFunctionCall(access, function_arguments_named);
1537    :}
1538    | FUNCTION
1539      access
1540    {:
1541        return new SrcPartialFunctionCall(access, new Opt());
1542    :}
1543    ;
1544
1545SrcFunctionArguments function_arguments =
1546    exp FOR for_indices               {: List arg_list_f = new List().add(new SrcIterExp(exp, for_indices));
1547                                         return new SrcFunctionArguments(arg_list_f, new List()); :}
1548  | arg_list_p                        {: return new SrcFunctionArguments(arg_list_p, new List()); :} 
1549  | arg_list_p COMMA named_arguments  {: return new SrcFunctionArguments(arg_list_p, named_arguments); :}
1550  | function_arguments_named
1551  ;
1552 
1553SrcFunctionArguments function_arguments_named =
1554  named_arguments {: return new SrcFunctionArguments(new List(), named_arguments); :}
1555  ;
1556 
1557List named_arguments =
1558    named_argument                       {: return new List().add(named_argument); :}
1559  | named_arguments COMMA named_argument {: return named_arguments.add(named_argument); :}
1560  ;
1561 
1562SrcExp function_argument_exp =
1563 exp                               {: return exp; :}
1564 | partial_function_call          {: return partial_function_call; :} 
1565 ;
1566 
1567SrcNamedArgument named_argument =
1568  named_argument_id EQUALS function_argument_exp {: return new SrcNamedArgument(named_argument_id,function_argument_exp); :}
1569  ;
1570
1571SrcAccess named_argument_id =
1572  ID.id {: return new SrcNamedAccess(id); :}
1573  ;
1574
1575SrcMatrix matrix =
1576    matrix_row                   {: return new SrcMatrix(new List().add(matrix_row)); :}
1577  | matrix SEMICOLON matrix_row  {: matrix.addRow(matrix_row);
1578                                    return matrix; :}     
1579  ; 
1580 
1581SrcMatrixRow matrix_row =
1582    exp                   {: return new SrcMatrixRow(new List().add(exp)); :}
1583  | matrix_row COMMA exp  {: matrix_row.addSrcExp(exp);
1584                             return matrix_row; :}
1585  ;
1586 
1587List arg_list =
1588                        {: return new List(); :}
1589  | exp                 {: return new List().add(exp); :}
1590  | arg_list COMMA exp  {: arg_list.add(exp);
1591                           return arg_list; :}
1592  ;
1593 
1594List arg_list_p =
1595  function_argument_exp                   {: return new List().add(function_argument_exp); :}
1596  | arg_list_p COMMA function_argument_exp  {: return arg_list_p.add(function_argument_exp); :}
1597  ;
1598 
1599SrcComment comment =
1600  string_comment?  annotation?     {: return new SrcComment(string_comment,annotation); :}
1601  ;
1602 
1603SrcStringComment string_comment =
1604  string_comment_exp    {: return new SrcStringComment(string_comment_exp); :}
1605  ;
1606
1607SrcExp string_comment_exp
1608  = string     
1609  | string_comment_exp PLUS string {: return new SrcAddExp(string_comment_exp, string); :}
1610  ;
1611
1612 SrcStringLitExp string =
1613  STRING.s  {: return new SrcStringLitExp(s); :}
1614  ;
1615
1616 SrcIdDecl id_decl =
1617   ID.id   {: return new SrcIdDecl(id); :}
1618 ;
1619
1620SrcAccessExp access_expression
1621    = access {: return new SrcAccessExp(access); :}
1622    ;
1623
1624SrcDerExp der_expression
1625    = DER LPAREN exp RPAREN  {: return new SrcDerExp(exp); :}
1626    ;
1627
1628SrcAccess access
1629    = access_loc      {: return access_loc; :}
1630    | DOT access_loc  {: return new SrcGlobalAccess(access_loc); :}
1631    ;
1632
1633SrcAccess access_loc
1634    = access_single
1635    | access_dot
1636    ;
1637
1638SrcDot access_dot
1639    = access_single.a
1640      DOT
1641      access_single.b
1642    {:
1643        return new SrcDot(new List(a, b));
1644    :}
1645    | access_dot
1646      DOT
1647      access_single
1648    {:
1649        access_dot.addSrcAccess(access_single);
1650        return access_dot;
1651    :}
1652    ;
1653
1654SrcNamedAccess access_single
1655    = access_single_array
1656    | access_single_scalar
1657    ;
1658
1659SrcArrayAccess access_single_array
1660    = ID.id array_subscripts  {: return new SrcArrayAccess(id, array_subscripts); :}
1661    ;
1662
1663SrcNamedAccess access_single_scalar
1664    = ID.id  {: return new SrcNamedAccess(id); :}
1665    ;
1666
1667
1668SrcAccess access_scalar
1669    = access_scalar_loc      {: return access_scalar_loc; :}
1670    | DOT access_scalar_loc  {: return new SrcGlobalAccess(access_scalar_loc); :}
1671    ;
1672
1673SrcAccess access_scalar_loc
1674    = access_scalar_dot
1675    | access_single_scalar
1676    ;
1677
1678SrcDot access_scalar_dot
1679    = access_single_scalar.a
1680      DOT
1681      access_single_scalar.b
1682    {:
1683        return new SrcDot(new List(a, b));
1684    :}
1685    | access_scalar_dot
1686      DOT
1687      access_single_scalar
1688    {:
1689        access_scalar_dot.addSrcAccess(access_single_scalar);
1690        return access_scalar_dot;
1691    :}
1692    ;
1693
1694SrcEndDecl end_decl
1695    = END_ID
1696    {:
1697        String value = (String) END_ID.value;
1698        String id = value.substring(3, value.length()).trim();
1699        return new SrcEndDecl(id);
1700    :}
1701    ;
Note: See TracBrowser for help on using the repository browser.