Changeset 3076


Ignore:
Timestamp:
Apr 27, 2013, 12:19:44 AM (6 years ago)
Author:
ksherdy
Message:

Updated grammar to handle '$'. Added lower bound / upper bound attributes.

Location:
proto/RE
Files:
11 added
1 deleted
14 edited

Legend:

Unmodified
Added
Removed
  • proto/RE/.project

    r2314 r3076  
    11<?xml version="1.0" encoding="UTF-8"?>
    22<projectDescription>
    3         <name>RE</name>
     3        <name>re</name>
    44        <comment></comment>
    55        <projects>
  • proto/RE/input/grammar/re.scatter

    r3074 r3076  
    88// Modified:    04-25-2013              Character-by-character, any character, sos, eos, bounded repetition.
    99//                                                              Context for bounded repetition.
    10 //
     10//
     11// Todo: Verify BackSlash.
    1112
    1213types {}
     
    1516        recognizers {
    1617                Whitespace [IGNORE],
     18                Escape[CHARACTER_ESCAPE]                "\\" "[.]" 1 1,
     19                Escape[HEXADECIMAL_ESCAPE]              "\\x" "0123456789abcdefABCDEF" 2 2 16,
     20                Escape[UNICODE_ESCAPE]                  "\\u" "0123456789abcdefABCDEF" 4 4 16,
    1721                Punctuator,
    1822                Comment [IGNORE] "(?#" ")",
    19                 EndOfInput,                             // must precede Character or loops
    20                 Character [CHARACTER], 
     23                EndOfInput,                                             // must precede CHARACTER
     24                Character [CHARACTER],                  // non-punctuators     
    2125        }
    2226
    2327        tokens { 
    24                 LEFTROUND       "(",    RIGHTROUND              ")",
     28                LEFTROUND       "(",   
     29                RIGHTROUND      ")",
    2530                LEFTSQUARE      "[",     
    26                 LEFTCURLY       "{",    // non standard meta-character
     31                LEFTCURLY       "{",     
    2732
    2833                OR                      "|",
     
    3237               
    3338                ANY             ".",
    34                 SOS             "^",    // start-of-string
    35                 EOS                     "$",    // end-of-string, non-standard, '$' is standard
    36 
    37                 BACKSLASH       "\\",
     39                SOS             "^",   
     40                EOS                     "$",   
     41        //      BACKSLASH       "\\",
    3842        }
    3943}
     
    4246        recognizers {
    4347                Whitespace [IGNORE],
     48                Escape[CHARACTER_ESCAPE]                "\\" "[.]" 1 1,
     49                Escape[HEXADECIMAL_ESCAPE]              "\\x" "0123456789abcdefABCDEF" 2 2 16,
     50                Escape[UNICODE_ESCAPE]                  "\\u" "0123456789abcdefABCDEF" 4 4 16,
    4451                Punctuator,
    45                 Character [CHARACTER], // non meta-characters (punctuators)
    46                 EndOfInput,
     52                EndOfInput,                                             // must precede CHARACTER
     53                Character [CHARACTER],                  // non-punctuators
     54               
    4755        }       
    4856        tokens {
     
    5058                NOT             "^",
    5159                THROUGH         "-",
    52                 BACKSLASH       "\\",
     60        //      BACKSLASH       "\\",
    5361        }
    5462}
     
    6775}
    6876
    69 interfaces {
    70         escapable {boolean isEscape = false;}, //  boolean isHexEscape = false; boolean isUnicodeEscape = false;},
     77interfaces {
    7178        complementable {boolean isComplemented = false;},
    72         repeatable {boolean isRange = false;},
     79        repeatable{boolean isRepeated = true;},
    7380        intValued {int value = 0;},
     81        intRange{int lowerBound = 0; int upperBound = 0;},
    7482}
    7583
    7684nodes {
    77         char {escapable;} [escapedChar characterClassChar characterClassEscapedChar],
    7885        characterClass {complementable;} [],
    7986        lowerBound{intValued;} [],
    8087        upperBound{intValued;} [],
     88        repetitionIndicator{intRange;} [],
    8189        boundedRepetitionIndicator{repeatable;} [],
    8290}
     
    97105        repetition              ʉ → atom (repetitionIndicator | boundedRepetitionIndicator)?; // ↑↑!? ;
    98106       
    99         repetitionIndicator             â†’ OPTIONAL | STAR | PLUS ;
     107        repetitionIndicator →         OPTIONAL {@lowerBound = 0; @upperBound = 1;} |
     108                                                        STAR {@lowerBound = 0; @upperBound = -1;} |
     109                                                        PLUS {@lowerBound = 1; @upperBound = -1;};
    100110                                                       
    101         boundedRepetitionIndicator      → LEFTCURLY◊(boundedRepetition) (lowerBound)? (COMMA {@isRange=true;} (upperBound)? )? RIGHTCURLY◊ ;
    102        
    103         lowerBound              -> INTEGER_CONST {@value = @@value;} ;
    104         upperBound              -> INTEGER_CONST {@value = @@value;} ;                                         
     111        boundedRepetitionIndicator      → LEFTCURLY◊(boundedRepetition) (lowerBound)? (COMMA {@isRepeated=false;} (upperBound)? )? RIGHTCURLY◊ ;
     112        lowerBound              → INTEGER_CONST {@value = @@value;} ;
     113        upperBound              → INTEGER_CONST {@value = @@value;} ;                                         
    105114       
    106115        atom                    ʉ → LEFTROUND re RIGHTROUND | char | characterClass | any | sos | eos ;
    107116       
    108         char                    ʉ → CHARACTER | BACKSLASH escapedChar {@:isEscape = true;} ;
    109     escapedChar         â†’     CHARACTER | LEFTROUND | RIGHTROUND | LEFTSQUARE | LEFTCURLY | COMMA | OR | OPTIONAL | STAR | PLUS | ANY | SOS | EOS | BACKSLASH | LEFTCURLY;
     117        char                    → CHARACTER | CHARACTER_ESCAPE | HEXADECIMAL_ESCAPE | UNICODE_ESCAPE ;
    110118               
    111119        characterClass  →     LEFTSQUARE◊(charClass)
     
    114122                                                RIGHTSQUARE◊ ;
    115123                                         
    116         range                   Ê‰ → characterClassChar (THROUGH↑ characterClassChar)? ;
    117          
    118         characterClassChar                      ʉ → CHARACTER | BACKSLASH characterClassEscapedChar {@:isEscape = true;} ;
    119     characterClassEscapedChar   â†’ CHARACTER | NOT | THROUGH | BACKSLASH | RIGHTSQUARE;
     124        range                   Ê‰ → char (THROUGH↑ char)? ;
    120125
    121126        any                             â†’ ANY ;
    122127        sos                             â†’ SOS ;
    123         eos                             â†’ EOS ;
     128        eos                             â†’ EOS ;
     129       
     130        // backslash            → BACKSLASH ;
    124131}
  • proto/RE/input/test/scratch.re

    r3074 r3076  
    1 ([A-Za-z]awyer|[A-Za-z]inn)[^a-zA-Z]
     1a[^x]{20}b
  • proto/RE/src/ast/BoundedRepetitionIndicatorNode.java

    r3072 r3076  
    1313
    1414public class BoundedRepetitionIndicatorNode extends ASTNode implements RepeatableNodeType {
    15         private boolean isRange = false;
     15        private boolean isRepeated = true;
    1616
    1717
     
    2121        public BoundedRepetitionIndicatorNode(BoundedRepetitionIndicatorNode node) {
    2222                super(node);
    23                 this.isRange = node.isRange;
     23                this.isRepeated = node.isRepeated;
    2424
    2525        }
     
    4040        // attribute accessors
    4141
    42         public boolean getIsRange() {
    43                 return isRange;
     42        public boolean getIsRepeated() {
     43                return isRepeated;
    4444        }
    45         public void setIsRange(boolean _value_) {
    46                 isRange = _value_;
     45        public void setIsRepeated(boolean _value_) {
     46                isRepeated = _value_;
    4747        }
    4848       
     
    5858                        result += ", ";
    5959                }
    60                 result += "isRange = " + isRange + ", ";
     60                result += "isRepeated = " + isRepeated + ", ";
    6161
    6262                if(result.isEmpty()) return result;
  • proto/RE/src/ast/CharNode.java

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

    r3072 r3076  
    1111public interface RepeatableNodeType  {
    1212
    13         public boolean getIsRange();
    14         public void setIsRange(boolean _value_);
     13        public boolean getIsRepeated();
     14        public void setIsRepeated(boolean _value_);
    1515       
    1616
  • proto/RE/src/ast/RepetitionIndicatorNode.java

    r3072 r3076  
    1212
    1313
    14 public class RepetitionIndicatorNode extends ASTNode  {
     14public class RepetitionIndicatorNode extends ASTNode implements IntRangeNodeType {
     15        private int upperBound = 0;
     16        private int lowerBound = 0;
    1517
    1618
     
    2022        public RepetitionIndicatorNode(RepetitionIndicatorNode node) {
    2123                super(node);
     24                this.upperBound = node.upperBound;
     25                this.lowerBound = node.lowerBound;
    2226
    2327        }
     
    3842        // attribute accessors
    3943
     44        public int getUpperBound() {
     45                return upperBound;
     46        }
     47        public void setUpperBound(int _value_) {
     48                upperBound = _value_;
     49        }
     50       
     51        public int getLowerBound() {
     52                return lowerBound;
     53        }
     54        public void setLowerBound(int _value_) {
     55                lowerBound = _value_;
     56        }
     57       
    4058
    4159       
     
    4967                        result += ", ";
    5068                }
     69                result += "upperBound = " + upperBound + ", ";
     70                result += "lowerBound = " + lowerBound + ", ";
    5171
    5272                if(result.isEmpty()) return result;
  • proto/RE/src/lexicalAnalyzer/LexicalType.java

    r3072 r3076  
    99
    1010public enum LexicalType {
     11        CHARACTER_ESCAPE,
    1112        INTEGER_CONST,
     13        HEXADECIMAL_ESCAPE,
    1214        CHARACTER,
    1315        IGNORE,
    1416        NONE,
     17        UNICODE_ESCAPE,
    1518        LEXTANT,
    1619
  • proto/RE/src/lexicalAnalyzer/Lextant.java

    r3075 r3076  
    2020        ANY(".", "main"),
    2121        RIGHTSQUARE("]", "charClass"),
    22         BACKSLASH("\\", "charClass", "\\", "main"),
    2322        OR("|", "main"),
    2423        NOT("^", "charClass"),
  • proto/RE/src/lexicalAnalyzer/Scanner.java

    r3075 r3076  
    7272                return new Scanner(charStream,
    7373                        new WhitespaceTokenRecognizer(charStream, IGNORE),
     74                        new EscapeTokenRecognizer(charStream, CHARACTER_ESCAPE, "\\", "[.]", 1, 1),
     75                        new EscapeTokenRecognizer(charStream, HEXADECIMAL_ESCAPE, "\\x", "0123456789abcdefABCDEF", 2, 2, 16),
     76                        new EscapeTokenRecognizer(charStream, UNICODE_ESCAPE, "\\u", "0123456789abcdefABCDEF", 4, 4, 16),
    7477                        new PunctuatorTokenRecognizer(charStream, LEXTANT, context),
    7578                        new CommentTokenRecognizer(charStream, IGNORE, "(?#", ")"),
     
    8487                return new Scanner(charStream,
    8588                        new WhitespaceTokenRecognizer(charStream, IGNORE),
     89                        new EscapeTokenRecognizer(charStream, CHARACTER_ESCAPE, "\\", "[.]", 1, 1),
     90                        new EscapeTokenRecognizer(charStream, HEXADECIMAL_ESCAPE, "\\x", "0123456789abcdefABCDEF", 2, 2, 16),
     91                        new EscapeTokenRecognizer(charStream, UNICODE_ESCAPE, "\\u", "0123456789abcdefABCDEF", 4, 4, 16),
    8692                        new PunctuatorTokenRecognizer(charStream, LEXTANT, context),
    87                         new CharacterTokenRecognizer(charStream, CHARACTER),
    88                         new EndOfInputTokenRecognizer(charStream, NONE)
     93                        new EndOfInputTokenRecognizer(charStream, NONE),
     94                        new CharacterTokenRecognizer(charStream, CHARACTER)
    8995                );
    9096        }
  • proto/RE/src/lexicalAnalyzer/tokenRecognizers/IdentifierTokenRecognizer.java

    r2311 r3076  
    6666        }
    6767        public static boolean isIdentifierStart(LocatedChar lc) {
    68                 return Character.isJavaIdentifierStart(lc.getCharacter());
     68                return isIdentifierStart(lc.getCharacter());
    6969        }
    7070        public static boolean isIdentifierStart(char c) {
    71                 return Character.isJavaIdentifierStart(c);
     71                return Character.isJavaIdentifierStart(c) && (c != '$');
    7272        }
    7373}
  • proto/RE/src/parser/Parser.java

    r3075 r3076  
    4444        }
    4545        public ASTNode parseStart() {
    46                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    47                         return syntaxErrorNode("start² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
     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¹]");
    4848                }
    4949       
     
    6464         
    6565        public ASTNode parseRe() {
    66                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    67                         return syntaxErrorNode("re² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
     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¹]");
    6868                }
    6969       
     
    8484         
    8585        public ASTNode parseAlternation() {
    86                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    87                         return syntaxErrorNode("alternation² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
     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¹]");
    8888                }
    8989       
     
    113113         
    114114        public ASTNode parseConcatenation() {
    115                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    116                         return syntaxErrorNode("concatenation² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
     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¹]");
    117117                }
    118118       
     
    127127                                allChildren.add(child);
    128128                        }
    129                 } while( nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) );
     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)) );
    130130                if(allowCompression) {
    131131                        return compressIfPossible(result);
     
    135135         
    136136        public ASTNode parseRepetition() {
    137                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    138                         return syntaxErrorNode("repetition² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
     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¹]");
    139139                }
    140140       
     
    181181                if( nowReading.isLextant(Lextant.OPTIONAL) ) {
    182182                        expect(Lextant.OPTIONAL);
     183                        {
     184                                ASTNode temp_1 = result;
     185                                IntRangeNodeType temp_3 = (IntRangeNodeType)temp_1;
     186                                int temp_4 = 0;
     187                                temp_3.setLowerBound( temp_4 );
     188                        }
     189                        {
     190                                ASTNode temp_5 = result;
     191                                IntRangeNodeType temp_7 = (IntRangeNodeType)temp_5;
     192                                int temp_8 = 1;
     193                                temp_7.setUpperBound( temp_8 );
     194                        }
    183195                }
    184196                else if( nowReading.isLextant(Lextant.STAR) ) {
    185197                        expect(Lextant.STAR);
     198                        {
     199                                ASTNode temp_9 = result;
     200                                IntRangeNodeType temp_11 = (IntRangeNodeType)temp_9;
     201                                int temp_12 = 0;
     202                                temp_11.setLowerBound( temp_12 );
     203                        }
     204                        {
     205                                ASTNode temp_13 = result;
     206                                IntRangeNodeType temp_15 = (IntRangeNodeType)temp_13;
     207                                int temp_16 = -1;
     208                                temp_15.setUpperBound( temp_16 );
     209                        }
    186210                }
    187211                else if( nowReading.isLextant(Lextant.PLUS) ) {
    188212                        expect(Lextant.PLUS);
     213                        {
     214                                ASTNode temp_17 = result;
     215                                IntRangeNodeType temp_19 = (IntRangeNodeType)temp_17;
     216                                int temp_20 = 1;
     217                                temp_19.setLowerBound( temp_20 );
     218                        }
     219                        {
     220                                ASTNode temp_21 = result;
     221                                IntRangeNodeType temp_23 = (IntRangeNodeType)temp_21;
     222                                int temp_24 = -1;
     223                                temp_23.setUpperBound( temp_24 );
     224                        }
    189225                }
    190226                if(allowCompression) {
     
    215251                        expect(Lextant.COMMA);
    216252                        {
    217                                 ASTNode temp_1 = result;
    218                                 RepeatableNodeType temp_3 = (RepeatableNodeType)temp_1;
    219                                 boolean temp_4 = true;
    220                                 temp_3.setIsRange( temp_4 );
     253                                ASTNode temp_25 = result;
     254                                RepeatableNodeType temp_27 = (RepeatableNodeType)temp_25;
     255                                boolean temp_28 = false;
     256                                temp_27.setIsRepeated( temp_28 );
    221257                        }
    222258                        if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    250286                readToken();
    251287                {
    252                         ASTNode temp_5 = result;
    253                         IntValuedNodeType temp_7 = (IntValuedNodeType)temp_5;
    254                         IntConstantToken temp_10 = (IntConstantToken)previouslyRead;
    255                         int temp_9 = temp_10.getValue();
    256                         temp_7.setValue( temp_9 );
     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 );
    257293                }
    258294                if(allowCompression) {
     
    276312                readToken();
    277313                {
    278                         ASTNode temp_11 = result;
    279                         IntValuedNodeType temp_13 = (IntValuedNodeType)temp_11;
    280                         IntConstantToken temp_16 = (IntConstantToken)previouslyRead;
    281                         int temp_15 = temp_16.getValue();
    282                         temp_13.setValue( temp_15 );
     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 );
    283319                }
    284320                if(allowCompression) {
     
    289325         
    290326        public ASTNode parseAtom() {
    291                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    292                         return syntaxErrorNode("atom² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
     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¹]");
    293329                }
    294330       
     
    306342                        expect(Lextant.RIGHTROUND);
    307343                }
    308                 else if( nowReading.isLextant(Lextant.BACKSLASH) || (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
     344                else if( (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE)) ) {
    309345                        {
    310346                                ASTNode child = parseChar();
     
    348384         
    349385        public ASTNode parseChar() {
    350                 if( !(nowReading.isLextant(Lextant.BACKSLASH) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    351                         return syntaxErrorNode("char² [BACKSLASH¹, CHARACTER¹]");
     386                if( !((nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
     387                        return syntaxErrorNode("char² [CHARACTER¹, CHARACTER_ESCAPE¹, HEXADECIMAL_ESCAPE¹, UNICODE_ESCAPE¹]");
    352388                }
    353389       
     
    362398                        readToken();
    363399                }
    364                 else if( nowReading.isLextant(Lextant.BACKSLASH) ) {
    365                         expect(Lextant.BACKSLASH);
    366                         {
    367                                 ASTNode child = parseEscapedChar();
    368                                 result.appendChild(child);
    369                                 allChildren.add(child);
    370                         }
    371                         {
    372                                 ASTNode temp_17 = allChildren.revGet(0);
    373                                 EscapableNodeType temp_19 = (EscapableNodeType)temp_17;
    374                                 boolean temp_20 = true;
    375                                 temp_19.setIsEscape( temp_20 );
    376                         }
    377                 }
    378                 if(allowCompression) {
    379                         return compressIfPossible(result);
    380                 }
    381                 return result;
    382         }
    383          
    384         public ASTNode parseEscapedChar() {
    385                 if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.COMMA, Lextant.EOS, Lextant.LEFTCURLY, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.OPTIONAL, Lextant.OR, Lextant.PLUS, Lextant.RIGHTROUND, Lextant.SOS, Lextant.STAR) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    386                         return syntaxErrorNode("escapedChar² [ANY¹, BACKSLASH¹, CHARACTER¹, COMMA¹, EOS¹, LEFTCURLY¹, LEFTROUND¹, LEFTSQUARE¹, OPTIONAL¹, OR¹, PLUS¹, RIGHTROUND¹, SOS¹, STAR¹]");
    387                 }
    388        
    389                 boolean allowCompression = true;
    390                 ASTNode result = new CharNode(nowReading);
    391                 result.setProductionTag(12);
    392                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    393                 if( (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
    394                         if( !(nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
    395                                 return syntaxErrorNode("CHARACTER");
     400                else if( (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) ) {
     401                        if( !(nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) ) {
     402                                return syntaxErrorNode("CHARACTER_ESCAPE");
    396403                        }
    397404                        readToken();
    398405                }
    399                 else if( nowReading.isLextant(Lextant.LEFTROUND) ) {
    400                         expect(Lextant.LEFTROUND);
    401                 }
    402                 else if( nowReading.isLextant(Lextant.RIGHTROUND) ) {
    403                         expect(Lextant.RIGHTROUND);
    404                 }
    405                 else if( nowReading.isLextant(Lextant.LEFTSQUARE) ) {
    406                         expect(Lextant.LEFTSQUARE);
    407                 }
    408                 else if( nowReading.isLextant(Lextant.LEFTCURLY) ) {
    409                         expect(Lextant.LEFTCURLY);
    410                 }
    411                 else if( nowReading.isLextant(Lextant.COMMA) ) {
    412                         expect(Lextant.COMMA);
    413                 }
    414                 else if( nowReading.isLextant(Lextant.OR) ) {
    415                         expect(Lextant.OR);
    416                 }
    417                 else if( nowReading.isLextant(Lextant.OPTIONAL) ) {
    418                         expect(Lextant.OPTIONAL);
    419                 }
    420                 else if( nowReading.isLextant(Lextant.STAR) ) {
    421                         expect(Lextant.STAR);
    422                 }
    423                 else if( nowReading.isLextant(Lextant.PLUS) ) {
    424                         expect(Lextant.PLUS);
    425                 }
    426                 else if( nowReading.isLextant(Lextant.ANY) ) {
    427                         expect(Lextant.ANY);
    428                 }
    429                 else if( nowReading.isLextant(Lextant.SOS) ) {
    430                         expect(Lextant.SOS);
    431                 }
    432                 else if( nowReading.isLextant(Lextant.EOS) ) {
    433                         expect(Lextant.EOS);
    434                 }
    435                 else if( nowReading.isLextant(Lextant.BACKSLASH) ) {
    436                         expect(Lextant.BACKSLASH);
    437                 }
    438                 else if( nowReading.isLextant(Lextant.LEFTCURLY) ) {
    439                         expect(Lextant.LEFTCURLY);
     406                else if( (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) ) {
     407                        if( !(nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) ) {
     408                                return syntaxErrorNode("HEXADECIMAL_ESCAPE");
     409                        }
     410                        readToken();
     411                }
     412                else if( (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE)) ) {
     413                        if( !(nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE)) ) {
     414                                return syntaxErrorNode("UNICODE_ESCAPE");
     415                        }
     416                        readToken();
    440417                }
    441418                if(allowCompression) {
     
    452429                boolean allowCompression = true;
    453430                ASTNode result = new CharacterClassNode(nowReading);
    454                 result.setProductionTag(13);
     431                result.setProductionTag(12);
    455432                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    456433                lexController.pushTo("charClass");
     
    459436                        expect(Lextant.NOT);
    460437                        {
    461                                 ASTNode temp_21 = result;
    462                                 ComplementableNodeType temp_23 = (ComplementableNodeType)temp_21;
    463                                 boolean temp_24 = true;
    464                                 temp_23.setIsComplemented( temp_24 );
    465                         }
    466                 }
    467                 while( nowReading.isLextant(Lextant.BACKSLASH) || (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
     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                }
     444                while( (nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE)) ) {
    468445                        {
    469446                                ASTNode child = parseRange();
     
    481458         
    482459        public ASTNode parseRange() {
    483                 if( !(nowReading.isLextant(Lextant.BACKSLASH) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    484                         return syntaxErrorNode("range² [BACKSLASH¹, CHARACTER¹]");
     460                if( !((nowReading.isLexicalType(LexicalType.CHARACTER)) || (nowReading.isLexicalType(LexicalType.CHARACTER_ESCAPE)) || (nowReading.isLexicalType(LexicalType.HEXADECIMAL_ESCAPE)) || (nowReading.isLexicalType(LexicalType.UNICODE_ESCAPE))) ) {
     461                        return syntaxErrorNode("range² [CHARACTER¹, CHARACTER_ESCAPE¹, HEXADECIMAL_ESCAPE¹, UNICODE_ESCAPE¹]");
    485462                }
    486463       
    487464                boolean allowCompression = true;
    488465                ASTNode result = new RangeNode(nowReading);
    489                 result.setProductionTag(14);
     466                result.setProductionTag(13);
    490467                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    491468                {
    492                         ASTNode child = parseCharacterClassChar();
     469                        ASTNode child = parseChar();
    493470                        result.appendChild(child);
    494471                        allChildren.add(child);
     
    498475                        expect(Lextant.THROUGH);
    499476                        {
    500                                 ASTNode child = parseCharacterClassChar();
     477                                ASTNode child = parseChar();
    501478                                result.appendChild(child);
    502479                                allChildren.add(child);
     
    505482                if(allowCompression) {
    506483                        return compressIfPossible(result);
    507                 }
    508                 return result;
    509         }
    510          
    511         public ASTNode parseCharacterClassChar() {
    512                 if( !(nowReading.isLextant(Lextant.BACKSLASH) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    513                         return syntaxErrorNode("characterClassChar² [BACKSLASH¹, CHARACTER¹]");
    514                 }
    515        
    516                 boolean allowCompression = true;
    517                 ASTNode result = new CharNode(nowReading);
    518                 result.setProductionTag(15);
    519                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    520                 if( (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
    521                         if( !(nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
    522                                 return syntaxErrorNode("CHARACTER");
    523                         }
    524                         readToken();
    525                 }
    526                 else if( nowReading.isLextant(Lextant.BACKSLASH) ) {
    527                         expect(Lextant.BACKSLASH);
    528                         {
    529                                 ASTNode child = parseCharacterClassEscapedChar();
    530                                 result.appendChild(child);
    531                                 allChildren.add(child);
    532                         }
    533                         {
    534                                 ASTNode temp_25 = allChildren.revGet(0);
    535                                 EscapableNodeType temp_27 = (EscapableNodeType)temp_25;
    536                                 boolean temp_28 = true;
    537                                 temp_27.setIsEscape( temp_28 );
    538                         }
    539                 }
    540                 if(allowCompression) {
    541                         return compressIfPossible(result);
    542                 }
    543                 return result;
    544         }
    545          
    546         public ASTNode parseCharacterClassEscapedChar() {
    547                 if( !(nowReading.isLextant(Lextant.BACKSLASH, Lextant.NOT, Lextant.RIGHTSQUARE, Lextant.THROUGH) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    548                         return syntaxErrorNode("characterClassEscapedChar² [BACKSLASH¹, CHARACTER¹, NOT¹, RIGHTSQUARE¹, THROUGH¹]");
    549                 }
    550        
    551                 boolean allowCompression = true;
    552                 ASTNode result = new CharNode(nowReading);
    553                 result.setProductionTag(16);
    554                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    555                 if( (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
    556                         if( !(nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
    557                                 return syntaxErrorNode("CHARACTER");
    558                         }
    559                         readToken();
    560                 }
    561                 else if( nowReading.isLextant(Lextant.NOT) ) {
    562                         expect(Lextant.NOT);
    563                 }
    564                 else if( nowReading.isLextant(Lextant.THROUGH) ) {
    565                         expect(Lextant.THROUGH);
    566                 }
    567                 else if( nowReading.isLextant(Lextant.BACKSLASH) ) {
    568                         expect(Lextant.BACKSLASH);
    569                 }
    570                 else if( nowReading.isLextant(Lextant.RIGHTSQUARE) ) {
    571                         expect(Lextant.RIGHTSQUARE);
    572                 }
    573                 if(allowCompression) {
    574                         return result;
    575484                }
    576485                return result;
     
    584493                boolean allowCompression = true;
    585494                ASTNode result = new AnyNode(nowReading);
    586                 result.setProductionTag(17);
     495                result.setProductionTag(14);
    587496                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    588497                expect(Lextant.ANY);
     
    600509                boolean allowCompression = true;
    601510                ASTNode result = new SosNode(nowReading);
    602                 result.setProductionTag(18);
     511                result.setProductionTag(15);
    603512                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    604513                expect(Lextant.SOS);
     
    616525                boolean allowCompression = true;
    617526                ASTNode result = new EosNode(nowReading);
    618                 result.setProductionTag(19);
     527                result.setProductionTag(16);
    619528                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    620529                expect(Lextant.EOS);
  • proto/RE/src/tokens/CharacterToken.java

    r2311 r3076  
    1111import inputHandler.TextLocation;
    1212
    13 public class CharacterToken extends TokenImp {
     13public class CharacterToken extends TokenImp  implements IntValuedToken {
    1414        protected CharacterToken(LexicalType type, TextLocation location, String lexeme) {
    1515                super(type, location, lexeme.intern());
     
    2121        }
    2222
    23 
     23        public int getValue() {
     24                return (int)(getLexeme().charAt(0));
     25        }
     26       
    2427        @Override
    2528        protected String rawString() {
  • proto/RE/src/tokens/IntConstantToken.java

    r2311 r3076  
    1111import inputHandler.TextLocation;
    1212
    13 public class IntConstantToken extends TokenImp {
     13public class IntConstantToken extends TokenImp implements IntValuedToken {
    1414        protected int value;
    1515       
Note: See TracChangeset for help on using the changeset viewer.