wrec/Escapes.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 Escapes_h
  27 #define Escapes_h
  28
  29 #include <wtf/Platform.h>
  30
  31 #if ENABLE(WREC)
  32
  33 #include <wtf/Assertions.h>
  34
  35 namespace JSC { namespace WREC {
  36
  37     class CharacterClass;
  38
  39     class Escape {
  40     public:
  41         enum Type {
  42             PatternCharacter,
  43             CharacterClass,
  44             Backreference,
  45             WordBoundaryAssertion,
  46             Error,
  47         };
  48
  49         Escape(Type type)
  50             : m_type(type)
  51         {
  52         }
  53
  54         Type type() const { return m_type; }
  55
  56     private:
  57         Type m_type;
  58
  59     protected:
  60         // Used by subclasses to store data.
  61         union {
  62             int i;
  63             const WREC::CharacterClass* c;
  64         } m_u;
  65         bool m_invert;
  66     };
  67
  68     class PatternCharacterEscape : public Escape {
  69     public:
  70         static const PatternCharacterEscape& cast(const Escape& escape)
  71         {
  72             ASSERT(escape.type() == PatternCharacter);
  73             return static_cast<const PatternCharacterEscape&>(escape);
  74         }
  75
  76         PatternCharacterEscape(int character)
  77             : Escape(PatternCharacter)
  78         {
  79             m_u.i = character;
  80         }
  81
  82         operator Escape() const { return *this; }
  83
  84         int character() const { return m_u.i; }
  85     };
  86
  87     class CharacterClassEscape : public Escape {
  88     public:
  89         static const CharacterClassEscape& cast(const Escape& escape)
  90         {
  91             ASSERT(escape.type() == CharacterClass);
  92             return static_cast<const CharacterClassEscape&>(escape);
  93         }
  94
  95         CharacterClassEscape(const WREC::CharacterClass& characterClass, bool invert)
  96             : Escape(CharacterClass)
  97         {
  98             m_u.c = &characterClass;
  99             m_invert = invert;
 100         }
 101
 102         operator Escape() { return *this; }
 103
 104         const WREC::CharacterClass& characterClass() const { return *m_u.c; }
 105         bool invert() const { return m_invert; }
 106     };
 107
 108     class BackreferenceEscape : public Escape {
 109     public:
 110         static const BackreferenceEscape& cast(const Escape& escape)
 111         {
 112             ASSERT(escape.type() == Backreference);
 113             return static_cast<const BackreferenceEscape&>(escape);
 114         }
 115
 116         BackreferenceEscape(int subpatternId)
 117             : Escape(Backreference)
 118         {
 119             m_u.i = subpatternId;
 120         }
 121
 122         operator Escape() const { return *this; }
 123
 124         int subpatternId() const { return m_u.i; }
 125     };
 126
 127     class WordBoundaryAssertionEscape : public Escape {
 128     public:
 129         static const WordBoundaryAssertionEscape& cast(const Escape& escape)
 130         {
 131             ASSERT(escape.type() == WordBoundaryAssertion);
 132             return static_cast<const WordBoundaryAssertionEscape&>(escape);
 133         }
 134
 135         WordBoundaryAssertionEscape(bool invert)
 136             : Escape(WordBoundaryAssertion)
 137         {
 138             m_invert = invert;
 139         }
 140
 141         operator Escape() const { return *this; }
 142
 143         bool invert() const { return m_invert; }
 144     };
 145
 146 } } // namespace JSC::WREC
 147
 148 #endif // ENABLE(WREC)
 149
 150 #endif // Escapes_h