JavaScriptCore/wrec/WRECParser.h

   1 /*
   2  * Copyright (C) 2008 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef Parser_h
  27 #define Parser_h
  28
  29 #include <wtf/Platform.h>
  30
  31 #if ENABLE(WREC)
  32
  33 #include "Escapes.h"
  34 #include "Quantifier.h"
  35 #include "UString.h"
  36 #include "WRECGenerator.h"
  37 #include <wtf/ASCIICType.h>
  38
  39 namespace JSC { namespace WREC {
  40
  41     struct CharacterClass;
  42
  43     class Parser {
  44     typedef Generator::JumpList JumpList;
  45     typedef Generator::ParenthesesType ParenthesesType;
  46
  47     friend class SavedState;
  48
  49     public:
  50         Parser(const UString& pattern, bool ignoreCase, bool multiline)
  51             : m_generator(*this)
  52             , m_data(pattern.data())
  53             , m_size(pattern.size())
  54             , m_ignoreCase(ignoreCase)
  55             , m_multiline(multiline)
  56         {
  57             reset();
  58         }
  59
  60         Generator& generator() { return m_generator; }
  61
  62         bool ignoreCase() const { return m_ignoreCase; }
  63         bool multiline() const { return m_multiline; }
  64
  65         void recordSubpattern() { ++m_numSubpatterns; }
  66         unsigned numSubpatterns() const { return m_numSubpatterns; }
  67
  68         const char* error() const { return m_error; }
  69         const char* syntaxError() const { return m_error == ParenthesesNotSupported ? 0 : m_error; }
  70
  71         void parsePattern(JumpList& failures)
  72         {
  73             reset();
  74
  75             parseDisjunction(failures);
  76
  77             if (peek() != EndOfPattern)
  78                 setError(ParenthesesUnmatched); // Parsing the pattern should fully consume it.
  79         }
  80
  81         void parseDisjunction(JumpList& failures);
  82         void parseAlternative(JumpList& failures);
  83         bool parseTerm(JumpList& failures);
  84         bool parseNonCharacterEscape(JumpList& failures, const Escape&);
  85         bool parseParentheses(JumpList& failures);
  86         bool parseCharacterClass(JumpList& failures);
  87         bool parseCharacterClassQuantifier(JumpList& failures, const CharacterClass& charClass, bool invert);
  88         bool parseBackreferenceQuantifier(JumpList& failures, unsigned subpatternId);
  89
  90     private:
  91         class SavedState {
  92         public:
  93             SavedState(Parser& parser)
  94                 : m_parser(parser)
  95                 , m_index(parser.m_index)
  96             {
  97             }
  98
  99             void restore()
 100             {
 101                 m_parser.m_index = m_index;
 102             }
 103
 104         private:
 105             Parser& m_parser;
 106             unsigned m_index;
 107         };
 108
 109         void reset()
 110         {
 111             m_index = 0;
 112             m_numSubpatterns = 0;
 113             m_error = 0;
 114         }
 115
 116         void setError(const char* error)
 117         {
 118             if (m_error)
 119                 return;
 120             m_error = error;
 121         }
 122
 123         int peek()
 124         {
 125             if (m_index >= m_size)
 126                 return EndOfPattern;
 127             return m_data[m_index];
 128         }
 129
 130         int consume()
 131         {
 132             if (m_index >= m_size)
 133                 return EndOfPattern;
 134             return m_data[m_index++];
 135         }
 136
 137         bool peekIsDigit()
 138         {
 139             return WTF::isASCIIDigit(peek());
 140         }
 141
 142         unsigned peekDigit()
 143         {
 144             ASSERT(peekIsDigit());
 145             return peek() - '0';
 146         }
 147
 148         unsigned consumeDigit()
 149         {
 150             ASSERT(peekIsDigit());
 151             return consume() - '0';
 152         }
 153
 154         unsigned consumeNumber()
 155         {
 156             int n = consumeDigit();
 157             while (peekIsDigit()) {
 158                 n *= 10;
 159                 n += consumeDigit();
 160             }
 161             return n;
 162         }
 163
 164         int consumeHex(int count)
 165         {
 166             int n = 0;
 167             while (count--) {
 168                 if (!WTF::isASCIIHexDigit(peek()))
 169                     return -1;
 170                 n = (n << 4) | WTF::toASCIIHexValue(consume());
 171             }
 172             return n;
 173         }
 174
 175         unsigned consumeOctal()
 176         {
 177             unsigned n = 0;
 178             while (n < 32 && WTF::isASCIIOctalDigit(peek()))
 179                 n = n * 8 + consumeDigit();
 180             return n;
 181         }
 182
 183         ALWAYS_INLINE Quantifier consumeGreedyQuantifier();
 184         Quantifier consumeQuantifier();
 185         Escape consumeEscape(bool inCharacterClass);
 186         ParenthesesType consumeParenthesesType();
 187
 188         static const int EndOfPattern = -1;
 189
 190         // Error messages.
 191         static const char* QuantifierOutOfOrder;
 192         static const char* QuantifierWithoutAtom;
 193         static const char* ParenthesesUnmatched;
 194         static const char* ParenthesesTypeInvalid;
 195         static const char* ParenthesesNotSupported;
 196         static const char* CharacterClassUnmatched;
 197         static const char* CharacterClassOutOfOrder;
 198         static const char* EscapeUnterminated;
 199
 200         Generator m_generator;
 201         const UChar* m_data;
 202         unsigned m_size;
 203         unsigned m_index;
 204         bool m_ignoreCase;
 205         bool m_multiline;
 206         unsigned m_numSubpatterns;
 207         const char* m_error;
 208     };
 209
 210 } } // namespace JSC::WREC
 211
 212 #endif // ENABLE(WREC)
 213
 214 #endif // Parser_h