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 
Escape(Type type)49         Escape(Type type)
50             : m_type(type)
51         {
52         }
53 
type()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:
cast(const Escape & escape)70         static const PatternCharacterEscape& cast(const Escape& escape)
71         {
72             ASSERT(escape.type() == PatternCharacter);
73             return static_cast<const PatternCharacterEscape&>(escape);
74         }
75 
PatternCharacterEscape(int character)76         PatternCharacterEscape(int character)
77             : Escape(PatternCharacter)
78         {
79             m_u.i = character;
80         }
81 
Escape()82         operator Escape() const { return *this; }
83 
character()84         int character() const { return m_u.i; }
85     };
86 
87     class CharacterClassEscape : public Escape {
88     public:
cast(const Escape & escape)89         static const CharacterClassEscape& cast(const Escape& escape)
90         {
91             ASSERT(escape.type() == CharacterClass);
92             return static_cast<const CharacterClassEscape&>(escape);
93         }
94 
CharacterClassEscape(const WREC::CharacterClass & characterClass,bool invert)95         CharacterClassEscape(const WREC::CharacterClass& characterClass, bool invert)
96             : Escape(CharacterClass)
97         {
98             m_u.c = &characterClass;
99             m_invert = invert;
100         }
101 
Escape()102         operator Escape() { return *this; }
103 
characterClass()104         const WREC::CharacterClass& characterClass() const { return *m_u.c; }
invert()105         bool invert() const { return m_invert; }
106     };
107 
108     class BackreferenceEscape : public Escape {
109     public:
cast(const Escape & escape)110         static const BackreferenceEscape& cast(const Escape& escape)
111         {
112             ASSERT(escape.type() == Backreference);
113             return static_cast<const BackreferenceEscape&>(escape);
114         }
115 
BackreferenceEscape(int subpatternId)116         BackreferenceEscape(int subpatternId)
117             : Escape(Backreference)
118         {
119             m_u.i = subpatternId;
120         }
121 
Escape()122         operator Escape() const { return *this; }
123 
subpatternId()124         int subpatternId() const { return m_u.i; }
125     };
126 
127     class WordBoundaryAssertionEscape : public Escape {
128     public:
cast(const Escape & escape)129         static const WordBoundaryAssertionEscape& cast(const Escape& escape)
130         {
131             ASSERT(escape.type() == WordBoundaryAssertion);
132             return static_cast<const WordBoundaryAssertionEscape&>(escape);
133         }
134 
WordBoundaryAssertionEscape(bool invert)135         WordBoundaryAssertionEscape(bool invert)
136             : Escape(WordBoundaryAssertion)
137         {
138             m_invert = invert;
139         }
140 
Escape()141         operator Escape() const { return *this; }
142 
invert()143         bool invert() const { return m_invert; }
144     };
145 
146 } } // namespace JSC::WREC
147 
148 #endif // ENABLE(WREC)
149 
150 #endif // Escapes_h
151