Changeset 3085 for proto/RE


Ignore:
Timestamp:
Apr 27, 2013, 8:43:00 PM (6 years ago)
Author:
ksherdy
Message:

Updated generated code.

Location:
proto/RE/src
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • proto/RE/src/ast/ASTTransformer.java

    r3072 r3085  
    1616        public ASTNode visit(AnyNode node);
    1717
    18         public ASTNode visit(BoundedRepetitionIndicatorNode node);
    19 
    2018        public ASTNode visit(CharNode node);
    2119
     
    3129
    3230        public ASTNode visit(LowerBoundNode node);
     31
     32        public ASTNode visit(NegatedCharacterClassNode node);
    3333
    3434        public ASTNode visit(RangeNode node);
     
    6363                }
    6464
    65                 public ASTNode visit(BoundedRepetitionIndicatorNode node) {
    66                         return defaultVisit(node);
    67                 }
    68 
    6965                public ASTNode visit(CharNode node) {
    7066                        return defaultVisit(node);
     
    9288
    9389                public ASTNode visit(LowerBoundNode node) {
     90                        return defaultVisit(node);
     91                }
     92
     93                public ASTNode visit(NegatedCharacterClassNode node) {
    9494                        return defaultVisit(node);
    9595                }
  • proto/RE/src/ast/ASTVisitor.java

    r3072 r3085  
    2020        public T visitLeave(AnyNode node, List<T> childResults);
    2121
    22         public void visitEnter(BoundedRepetitionIndicatorNode node);
    23         public T visitLeave(BoundedRepetitionIndicatorNode node, List<T> childResults);
    24 
    2522        public void visitEnter(CharNode node);
    2623        public T visitLeave(CharNode node, List<T> childResults);
     
    4340        public void visitEnter(LowerBoundNode node);
    4441        public T visitLeave(LowerBoundNode node, List<T> childResults);
     42
     43        public void visitEnter(NegatedCharacterClassNode node);
     44        public T visitLeave(NegatedCharacterClassNode node, List<T> childResults);
    4545
    4646        public void visitEnter(RangeNode node);
     
    100100                }
    101101
    102                 public void visitEnter(BoundedRepetitionIndicatorNode node) {
    103                         defaultVisitEnter(node);
    104                 }
    105                 public T visitLeave(BoundedRepetitionIndicatorNode node, List<T> childResults) {
    106                         return defaultVisitLeave(node);
    107                 }
    108 
    109102                public void visitEnter(CharNode node) {
    110103                        defaultVisitEnter(node);
     
    153146                }
    154147                public T visitLeave(LowerBoundNode node, List<T> childResults) {
     148                        return defaultVisitLeave(node);
     149                }
     150
     151                public void visitEnter(NegatedCharacterClassNode node) {
     152                        defaultVisitEnter(node);
     153                }
     154                public T visitLeave(NegatedCharacterClassNode node, List<T> childResults) {
    155155                        return defaultVisitLeave(node);
    156156                }
  • proto/RE/src/ast/CharacterClassNode.java

    r3072 r3085  
    1212
    1313
    14 public class CharacterClassNode extends ASTNode implements ComplementableNodeType {
    15         private boolean isComplemented = false;
     14public class CharacterClassNode extends ASTNode  {
    1615
    1716
     
    2120        public CharacterClassNode(CharacterClassNode node) {
    2221                super(node);
    23                 this.isComplemented = node.isComplemented;
    2422
    2523        }
     
    4038        // attribute accessors
    4139
    42         public boolean getIsComplemented() {
    43                 return isComplemented;
    44         }
    45         public void setIsComplemented(boolean _value_) {
    46                 isComplemented = _value_;
    47         }
    48        
    4940
    5041       
     
    5849                        result += ", ";
    5950                }
    60                 result += "isComplemented = " + isComplemented + ", ";
    6151
    6252                if(result.isEmpty()) return result;
  • proto/RE/src/ast/SimpleVisitor.java

    r3072 r3085  
    1717        public void visit(AnyNode node);
    1818
    19         public void visit(BoundedRepetitionIndicatorNode node);
    20 
    2119        public void visit(CharNode node);
    2220
     
    3230
    3331        public void visit(LowerBoundNode node);
     32
     33        public void visit(NegatedCharacterClassNode node);
    3434
    3535        public void visit(RangeNode node);
     
    6464                }
    6565
    66                 public void visit(BoundedRepetitionIndicatorNode node) {
    67                         defaultVisit(node);
    68                 }
    69 
    7066                public void visit(CharNode node) {
    7167                        defaultVisit(node);
     
    9389
    9490                public void visit(LowerBoundNode node) {
     91                        defaultVisit(node);
     92                }
     93
     94                public void visit(NegatedCharacterClassNode node) {
    9595                        defaultVisit(node);
    9696                }
  • proto/RE/src/ast/VoidVisitor.java

    r3072 r3085  
    1818        public void visitLeave(AnyNode node);
    1919
    20         public void visitEnter(BoundedRepetitionIndicatorNode node);
    21         public void visitLeave(BoundedRepetitionIndicatorNode node);
    22 
    2320        public void visitEnter(CharNode node);
    2421        public void visitLeave(CharNode node);
     
    4138        public void visitEnter(LowerBoundNode node);
    4239        public void visitLeave(LowerBoundNode node);
     40
     41        public void visitEnter(NegatedCharacterClassNode node);
     42        public void visitLeave(NegatedCharacterClassNode node);
    4343
    4444        public void visitEnter(RangeNode node);
     
    9797                }
    9898
    99                 public void visitEnter(BoundedRepetitionIndicatorNode node) {
    100                         defaultVisitEnter(node);
    101                 }
    102                 public void visitLeave(BoundedRepetitionIndicatorNode node) {
    103                         defaultVisitLeave(node);
    104                 }
    105 
    10699                public void visitEnter(CharNode node) {
    107100                        defaultVisitEnter(node);
     
    150143                }
    151144                public void visitLeave(LowerBoundNode node) {
     145                        defaultVisitLeave(node);
     146                }
     147
     148                public void visitEnter(NegatedCharacterClassNode node) {
     149                        defaultVisitEnter(node);
     150                }
     151                public void visitLeave(NegatedCharacterClassNode node) {
    152152                        defaultVisitLeave(node);
    153153                }
  • proto/RE/src/lexicalAnalyzer/Lextant.java

    r3076 r3085  
    1919public enum Lextant {
    2020        ANY(".", "main"),
     21        LEFTSQUARENEGATE("[^", "main"),
    2122        RIGHTSQUARE("]", "charClass"),
    2223        OR("|", "main"),
    23         NOT("^", "charClass"),
    2424        OPTIONAL("?", "main"),
    2525        STAR("*", "main"),
  • proto/RE/src/lexicalAnalyzer/Scanner.java

    r3076 r3085  
    8686               
    8787                return new Scanner(charStream,
    88                         new WhitespaceTokenRecognizer(charStream, IGNORE),
    8988                        new EscapeTokenRecognizer(charStream, CHARACTER_ESCAPE, "\\", "[.]", 1, 1),
    9089                        new EscapeTokenRecognizer(charStream, HEXADECIMAL_ESCAPE, "\\x", "0123456789abcdefABCDEF", 2, 2, 16),
  • proto/RE/src/parser/Parser.java

    r3076 r3085  
    4444        }
    4545        public ASTNode parseStart() {
    46                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
    47                         return syntaxErrorNode("start² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹, UNICODE_ESCAPE¹]");
     46                if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.LEFTSQUARENEGATE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
     47                        return syntaxErrorNode("start² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, LEFTSQUARENEGATE¹, SOS¹, UNICODE_ESCAPE¹]");
    4848                }
    4949       
     
    6464         
    6565        public ASTNode parseRe() {
    66                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
    67                         return syntaxErrorNode("re² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹, UNICODE_ESCAPE¹]");
     66                if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.LEFTSQUARENEGATE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
     67                        return syntaxErrorNode("re² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, LEFTSQUARENEGATE¹, SOS¹, UNICODE_ESCAPE¹]");
    6868                }
    6969       
     
    8484         
    8585        public ASTNode parseAlternation() {
    86                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
    87                         return syntaxErrorNode("alternation² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹, UNICODE_ESCAPE¹]");
     86                if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.LEFTSQUARENEGATE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
     87                        return syntaxErrorNode("alternation² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, LEFTSQUARENEGATE¹, SOS¹, UNICODE_ESCAPE¹]");
    8888                }
    8989       
     
    113113         
    114114        public ASTNode parseConcatenation() {
    115                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
    116                         return syntaxErrorNode("concatenation² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹, UNICODE_ESCAPE¹]");
     115                if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.LEFTSQUARENEGATE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
     116                        return syntaxErrorNode("concatenation² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, LEFTSQUARENEGATE¹, SOS¹, UNICODE_ESCAPE¹]");
    117117                }
    118118       
     
    127127                                allChildren.add(child);
    128128                        }
    129                 } while( nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE)) );
     129                } while( nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.LEFTSQUARENEGATE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE)) );
    130130                if(allowCompression) {
    131131                        return compressIfPossible(result);
     
    135135         
    136136        public ASTNode parseRepetition() {
    137                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
    138                         return syntaxErrorNode("repetition² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹, UNICODE_ESCAPE¹]");
     137                if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.LEFTSQUARENEGATE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
     138                        return syntaxErrorNode("repetition² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, LEFTSQUARENEGATE¹, SOS¹, UNICODE_ESCAPE¹]");
    139139                }
    140140       
     
    236236       
    237237                boolean allowCompression = true;
    238                 ASTNode result = new BoundedRepetitionIndicatorNode(nowReading);
     238                ASTNode result = new RepetitionIndicatorNode(nowReading);
    239239                result.setProductionTag(7);
    240240                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    241241                lexController.pushTo("boundedRepetition");
    242242                expect(Lextant.LEFTCURLY);
    243                 if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    244                         {
    245                                 ASTNode child = parseLowerBound();
    246                                 result.appendChild(child);
    247                                 allChildren.add(child);
    248                         }
     243                {
     244                        ASTNode child = parseLowerBound();
     245                        // node omitted - no result.appendChild(child);
     246                        allChildren.add(child);
     247                }
     248                {
     249                        ASTNode temp_25 = result;
     250                        IntRangeNodeType temp_27 = (IntRangeNodeType)temp_25;
     251                        ASTNode temp_28 = allChildren.revGet(0);
     252                        IntValuedNodeType temp_30 = (IntValuedNodeType)temp_28;
     253                        int temp_29 = temp_30.getValue();
     254                        temp_27.setLowerBound( temp_29 );
    249255                }
    250256                if( nowReading.isLextant(Lextant.COMMA) ) {
    251257                        expect(Lextant.COMMA);
    252258                        {
    253                                 ASTNode temp_25 = result;
    254                                 RepeatableNodeType temp_27 = (RepeatableNodeType)temp_25;
    255                                 boolean temp_28 = false;
    256                                 temp_27.setIsRepeated( temp_28 );
    257                         }
    258                         if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    259                                 {
    260                                         ASTNode child = parseUpperBound();
    261                                         result.appendChild(child);
    262                                         allChildren.add(child);
    263                                 }
     259                                ASTNode child = parseUpperBound();
     260                                // node omitted - no result.appendChild(child);
     261                                allChildren.add(child);
     262                        }
     263                        {
     264                                ASTNode temp_31 = result;
     265                                IntRangeNodeType temp_33 = (IntRangeNodeType)temp_31;
     266                                ASTNode temp_34 = allChildren.revGet(0);
     267                                IntValuedNodeType temp_36 = (IntValuedNodeType)temp_34;
     268                                int temp_35 = temp_36.getValue();
     269                                temp_33.setUpperBound( temp_35 );
     270                        }
     271                }
     272                else if( true ) {
     273                        // epsilon
     274                        {
     275                                ASTNode temp_37 = result;
     276                                IntRangeNodeType temp_39 = (IntRangeNodeType)temp_37;
     277                                ASTNode temp_40 = result;
     278                                IntRangeNodeType temp_42 = (IntRangeNodeType)temp_40;
     279                                int temp_41 = temp_42.getLowerBound();
     280                                temp_39.setUpperBound( temp_41 );
    264281                        }
    265282                }
     
    273290         
    274291        public ASTNode parseLowerBound() {
    275                 if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    276                         return syntaxErrorNode("lowerBound² [INTEGER_CONST¹]");
    277                 }
    278        
    279292                boolean allowCompression = true;
    280293                ASTNode result = new LowerBoundNode(nowReading);
    281294                result.setProductionTag(8);
    282295                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    283                 if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    284                         return syntaxErrorNode("INTEGER_CONST");
    285                 }
    286                 readToken();
    287                 {
    288                         ASTNode temp_29 = result;
    289                         IntValuedNodeType temp_31 = (IntValuedNodeType)temp_29;
    290                         IntValuedToken temp_34 = (IntValuedToken)previouslyRead;
    291                         int temp_33 = temp_34.getValue();
    292                         temp_31.setValue( temp_33 );
     296                if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     297                        if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     298                                return syntaxErrorNode("INTEGER_CONST");
     299                        }
     300                        readToken();
     301                        {
     302                                ASTNode temp_43 = result;
     303                                IntValuedNodeType temp_45 = (IntValuedNodeType)temp_43;
     304                                IntValuedToken temp_48 = (IntValuedToken)previouslyRead;
     305                                int temp_47 = temp_48.getValue();
     306                                temp_45.setValue( temp_47 );
     307                        }
     308                }
     309                else if( true ) {
     310                        // epsilon
     311                        {
     312                                ASTNode temp_49 = result;
     313                                IntValuedNodeType temp_51 = (IntValuedNodeType)temp_49;
     314                                int temp_52 = 0;
     315                                temp_51.setValue( temp_52 );
     316                        }
    293317                }
    294318                if(allowCompression) {
     
    299323         
    300324        public ASTNode parseUpperBound() {
    301                 if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    302                         return syntaxErrorNode("upperBound² [INTEGER_CONST¹]");
    303                 }
    304        
    305325                boolean allowCompression = true;
    306326                ASTNode result = new UpperBoundNode(nowReading);
    307327                result.setProductionTag(9);
    308328                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    309                 if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    310                         return syntaxErrorNode("INTEGER_CONST");
    311                 }
    312                 readToken();
    313                 {
    314                         ASTNode temp_35 = result;
    315                         IntValuedNodeType temp_37 = (IntValuedNodeType)temp_35;
    316                         IntValuedToken temp_40 = (IntValuedToken)previouslyRead;
    317                         int temp_39 = temp_40.getValue();
    318                         temp_37.setValue( temp_39 );
     329                if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     330                        if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     331                                return syntaxErrorNode("INTEGER_CONST");
     332                        }
     333                        readToken();
     334                        {
     335                                ASTNode temp_53 = result;
     336                                IntValuedNodeType temp_55 = (IntValuedNodeType)temp_53;
     337                                IntValuedToken temp_58 = (IntValuedToken)previouslyRead;
     338                                int temp_57 = temp_58.getValue();
     339                                temp_55.setValue( temp_57 );
     340                        }
     341                }
     342                else if( true ) {
     343                        // epsilon
     344                        {
     345                                ASTNode temp_59 = result;
     346                                IntValuedNodeType temp_61 = (IntValuedNodeType)temp_59;
     347                                int temp_62 = -1;
     348                                temp_61.setValue( temp_62 );
     349                        }
    319350                }
    320351                if(allowCompression) {
     
    325356         
    326357        public ASTNode parseAtom() {
    327                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
    328                         return syntaxErrorNode("atom² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹, UNICODE_ESCAPE¹]");
     358                if( !(nowReading.isLextant(Lextant.ANY, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.LEFTSQUARENEGATE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
     359                        return syntaxErrorNode("atom² [ANY¹, CHARACTER¹, CHARACTER_ESCAPE¹, EOS¹, HEXADECIMAL_ESCAPE¹, LEFTROUND¹, LEFTSQUARE¹, LEFTSQUARENEGATE¹, SOS¹, UNICODE_ESCAPE¹]");
    329360                }
    330361       
     
    352383                        {
    353384                                ASTNode child = parseCharacterClass();
     385                                result.appendChild(child);
     386                                allChildren.add(child);
     387                        }
     388                }
     389                else if( nowReading.isLextant(Lextant.LEFTSQUARENEGATE) ) {
     390                        {
     391                                ASTNode child = parseNegatedCharacterClass();
    354392                                result.appendChild(child);
    355393                                allChildren.add(child);
     
    433471                lexController.pushTo("charClass");
    434472                expect(Lextant.LEFTSQUARE);
    435                 if( nowReading.isLextant(Lextant.NOT) ) {
    436                         expect(Lextant.NOT);
    437                         {
    438                                 ASTNode temp_41 = result;
    439                                 ComplementableNodeType temp_43 = (ComplementableNodeType)temp_41;
    440                                 boolean temp_44 = true;
    441                                 temp_43.setIsComplemented( temp_44 );
    442                         }
    443                 }
     473                while( (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE)) ) {
     474                        {
     475                                ASTNode child = parseRange();
     476                                result.appendChild(child);
     477                                allChildren.add(child);
     478                        }
     479                }
     480                lexController.pop();
     481                expect(Lextant.RIGHTSQUARE);
     482                if(allowCompression) {
     483                        return result;
     484                }
     485                return result;
     486        }
     487         
     488        public ASTNode parseNegatedCharacterClass() {
     489                if( !(nowReading.isLextant(Lextant.LEFTSQUARENEGATE)) ) {
     490                        return syntaxErrorNode("negatedCharacterClass² [LEFTSQUARENEGATE¹]");
     491                }
     492       
     493                boolean allowCompression = true;
     494                ASTNode result = new NegatedCharacterClassNode(nowReading);
     495                result.setProductionTag(13);
     496                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     497                lexController.pushTo("charClass");
     498                expect(Lextant.LEFTSQUARENEGATE);
    444499                while( (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE)) ) {
    445500                        {
     
    464519                boolean allowCompression = true;
    465520                ASTNode result = new RangeNode(nowReading);
    466                 result.setProductionTag(13);
     521                result.setProductionTag(14);
    467522                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    468523                {
     
    493548                boolean allowCompression = true;
    494549                ASTNode result = new AnyNode(nowReading);
    495                 result.setProductionTag(14);
     550                result.setProductionTag(15);
    496551                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    497552                expect(Lextant.ANY);
     
    509564                boolean allowCompression = true;
    510565                ASTNode result = new SosNode(nowReading);
    511                 result.setProductionTag(15);
     566                result.setProductionTag(16);
    512567                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    513568                expect(Lextant.SOS);
     
    525580                boolean allowCompression = true;
    526581                ASTNode result = new EosNode(nowReading);
    527                 result.setProductionTag(16);
     582                result.setProductionTag(17);
    528583                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    529584                expect(Lextant.EOS);
Note: See TracChangeset for help on using the changeset viewer.