Changeset 3181


Ignore:
Timestamp:
May 23, 2013, 1:56:45 PM (5 years ago)
Author:
ksherdy
Message:

Updated regular expression grammar to correctly order the escape characters recognizers within the context of character classes.

Location:
proto/RE/input
Files:
1 added
1 deleted
1 edited

Legend:

Unmodified
Added
Removed
  • proto/RE/input/grammar/re.scatter

    r3086 r3181  
    11// Ken Herdy
    22//
    3 // Scatter Regular Expression Grammar
     3// Scatter grammar for regular expressions.
    44//
    55// Supports context dependent lexical analysis.
     
    88// 04-25-2013   Character-by-character lexical analysis, any , sos, eos, bounded repetition (all types).
    99// 04-27-2013   Negated character classes.
     10// 05-03-2013   Escaped character recognition (unicode, hex, single character).
    1011//
    1112
     
    1516        recognizers {
    1617                Whitespace [IGNORE],
    17                 Escape[UNICODE_ESCAPE]                  "\\u" "0123456789abcdefABCDEF" 4 4 16,
    18                 Escape[HEXADECIMAL_ESCAPE]              "\\x" "0123456789abcdefABCDEF" 2 2 16,
    19                 Escape[CHARACTER_ESCAPE]                "\\" "[.]" 1 1,
     18                Escape[UNICODE_ESCAPE]                          "\\u" "0123456789abcdefABCDEF" 4 4 16, // prefix, char set, min, max, radix
     19                Escape[HEXADECIMAL_ESCAPE]                  "\\x" "0123456789abcdefABCDEF" 2 2 16,
     20                Escape[CHARACTER_ESCAPE]                        "\\" "[.]" 1 1,
    2021                Punctuator,
    21                 Comment [IGNORE] "(?#" ")",     // comments
    22                 EndOfInput,                                             // must precede CHARACTER
    23                 Character [CHARACTER],                  // non-punctuators     
     22                Comment [IGNORE] "(?#" ")",         // comments
     23                EndOfInput,                         // must precede CHARACTER
     24                Character [CHARACTER],              // non-punctuators 
    2425        }
    2526
    2627        tokens { 
    27                 LEFTROUND       "(",   
    28                 RIGHTROUND      ")",
    29                 LEFTSQUARENEGATE "[^",
    30                 LEFTSQUARE      "[",     
    31                 LEFTCURLY       "{",     
    32 
    33                 OR                      "|",
    34                 OPTIONAL        "?",
    35                 STAR            "*",
    36                 PLUS            "+",
    37                
    38                 ANY             ".",
    39                 SOS             "^",   
    40                 EOS                     "$",   
    41         //      BACKSLASH       "\\",
     28                LEFTROUND         "(",         
     29                RIGHTROUND        ")",
     30                LEFTSQUARENEGATE  "[^",
     31                LEFTSQUARE        "[",   
     32                LEFTCURLY         "{",   
     33                OR                "|",
     34                OPTIONAL          "?",
     35                STAR              "*",
     36                PLUS              "+",
     37                ANY               ".",
     38                SOS               "^", 
     39                EOS               "$", 
     40        //BACKSLASH       "\\",
    4241        }
    4342}
     
    4645        recognizers {
    4746                // Whitespace [IGNORE],                 // POSIX standard
    48                 Escape[CHARACTER_ESCAPE]                "\\" "[.]" 1 1,
    49                 Escape[HEXADECIMAL_ESCAPE]              "\\x" "0123456789abcdefABCDEF" 2 2 16,
    50                 Escape[UNICODE_ESCAPE]                  "\\u" "0123456789abcdefABCDEF" 4 4 16,
     47                Escape[UNICODE_ESCAPE]          "\\u" "0123456789abcdefABCDEF" 4 4 16,
     48                Escape[HEXADECIMAL_ESCAPE]      "\\x" "0123456789abcdefABCDEF" 2 2 16,
     49                Escape[CHARACTER_ESCAPE]        "\\" "[.]" 1 1,
    5150                Punctuator,
    52                 EndOfInput,                                             // must precede CHARACTER
    53                 Character [CHARACTER],                  // non-punctuators
    54                
     51                EndOfInput,                     // must precede CHARACTER
     52                Character [CHARACTER],          // non-punctuators
    5553        }       
    5654        tokens {
    57                 RIGHTSQUARE "]",
    58         //      NOT             "^",
    59                 THROUGH         "-",
    60         //      BACKSLASH       "\\",
     55                RIGHTSQUARE   "]",
     56                THROUGH       "-",
     57            //NOT         "^",
     58            //BACKSLASH   "\\",
    6159        }
    6260}
     
    8684        repetitionIndicator{intRange;} [boundedRepetitionIndicator],
    8785}
    88 //
    89 // to change scanning contexts, use the ◊ operator (in ascii: <> ).
    90 // ◊(contextName) pushes the context on a stack, ◊ with nothing
    91 // following it pops the current context from the stack.
    92 // ◊ works only when applied to a terminal; do not apply to a nonterminal.
    93 // see the production for characterClass below, where everything from
    94 // "◊(charClass)" to "◊" is done in the "charClass" scanning context.
    95 // Note that this means that RIGHTSQUARE must be recognized in the
    96 // "charClass" context.
     86
    9787grammar {
    98         start                   â†’ re ;
    99         re                              ʉ → alternation ;
    100         alternation     Ê‰ → concatenation (OR↑ concatenation)* ;   
    101         concatenation   Ê‰ → repetition+ ;                                           
    102         repetition              ʉ → atom (repetitionIndicator | boundedRepetitionIndicator)?; // ↑↑!? ;
    103        
    104         repetitionIndicator →         OPTIONAL {@lowerBound = 0; @upperBound = 1;} |
    105                                                         STAR {@lowerBound = 0; @upperBound = -1;} |
    106                                                         PLUS {@lowerBound = 1; @upperBound = -1;};
     88        start                       -> re ;
     89        re                                  #-> alternation ;
     90        alternation         #-> concatenation (OR↑ concatenation)* ; 
     91        concatenation       #-> repetition+ ;                                           
     92        repetition                  #-> atom (repetitionIndicator | boundedRepetitionIndicator)?;
     93        repetitionIndicator ->   OPTIONAL {@lowerBound = 0; @upperBound = 1;} |
     94                                                         STAR {@lowerBound = 0; @upperBound = -1;} |
     95                             PLUS {@lowerBound = 1; @upperBound = -1;};
    10796                                                       
    108         boundedRepetitionIndicator      → LEFTCURLY◊(boundedRepetition)
    109                                                                           ( lowerBound!   {@lowerBound = @:value;} )
     97        boundedRepetitionIndicator      -> LEFTCURLY◊ (boundedRepetition)
     98                                                                          ( lowerBound! {@lowerBound = @:value;} )
    11099                                                                          (
    111100                                                                              (COMMA upperBound!   {@upperBound = @:value;}     ) |
    112                                                                               (ε                   {@upperBound = @lowerBound;} )
    113                                                                           )
    114                                                                   RIGHTCURLY◊ ;
     101                                                                              (epsilon             {@upperBound = @lowerBound;} )
     102                                                                          ) RIGHTCURLY◊ ;
    115103                                                                 
    116         lowerBound              → INTEGER_CONST {@value = @@value;} |
    117                                           ε                    {@value = 0;}       ;
    118                                          
    119         upperBound              → INTEGER_CONST {@value = @@value;} |
    120                                           ε                    {@value = -1;}      ;                                           
     104        lowerBound              -> INTEGER_CONST {@value = @@value;} | epsilon {@value = 0;} ;
     105        upperBound              -> INTEGER_CONST {@value = @@value;} | epsilon {@value = -1;} ;                                         
    121106       
    122         atom                    ʉ → LEFTROUND re RIGHTROUND | char | characterClass | negatedCharacterClass | any | sos | eos ;
     107        atom          #-> LEFTROUND re RIGHTROUND |
     108                    char                    |
     109                    characterClass          |
     110                    negatedCharacterClass   |
     111                    any                     |
     112                    sos                     |
     113                    eos ;
    123114       
    124         char                    → CHARACTER | CHARACTER_ESCAPE | HEXADECIMAL_ESCAPE | UNICODE_ESCAPE ;
     115        char              -> CHARACTER           |
     116                         CHARACTER_ESCAPE    |
     117                         HEXADECIMAL_ESCAPE  |
     118                         UNICODE_ESCAPE ;
    125119               
    126         characterClass  →     LEFTSQUARE
    127                                                         ◊(charClass)
    128                                                         range*
    129                                                 RIGHTSQUARE◊ ;
     120        characterClass  ->      LEFTSQUARE
     121                        ◊(charClass) range* RIGHTSQUARE◊ ;
    130122                                               
    131         negatedCharacterClass   â†’     LEFTSQUARENEGATE
    132                                                                         ◊(charClass)
    133                                                                         range*
    134                                                                 RIGHTSQUARE◊ ;                                       
     123        negatedCharacterClass   ->   LEFTSQUARENEGATE
     124                                 â—Š(charClass) range* RIGHTSQUARE◊ ;                                 
    135125                                                                                 
    136         range                   Ê‰ → char (THROUGH↑ char)? ;
     126        range                   #-> char (THROUGH↑ char)? ;
    137127
    138         any                             â†’ ANY ;
    139         sos                             â†’ SOS ;
    140         eos                             â†’ EOS ;
     128        any                             -> ANY ;
     129        sos                             -> SOS ;
     130        eos                             -> EOS ;
    141131       
    142         // backslash            â†’ BACKSLASH ;
     132        // backslash -> BACKSLASH ;
    143133}
Note: See TracChangeset for help on using the changeset viewer.