2011-05-24 Oliver Hunt <oliver@apple.com>
[WebKit-https.git] / Source / JavaScriptCore / parser / Lexer.h
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
4  *  Copyright (C) 2010 Zoltan Herczeg (zherczeg@inf.u-szeged.hu)
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #ifndef Lexer_h
24 #define Lexer_h
25
26 #include "JSParser.h"
27 #include "Lookup.h"
28 #include "ParserArena.h"
29 #include "SourceCode.h"
30 #include <wtf/ASCIICType.h>
31 #include <wtf/AlwaysInline.h>
32 #include <wtf/SegmentedVector.h>
33 #include <wtf/Vector.h>
34 #include <wtf/unicode/Unicode.h>
35
36 namespace JSC {
37
38     class RegExp;
39
40     class Lexer {
41         WTF_MAKE_NONCOPYABLE(Lexer); WTF_MAKE_FAST_ALLOCATED;
42     public:
43         // Character manipulation functions.
44         static bool isWhiteSpace(int character);
45         static bool isLineTerminator(int character);
46         static unsigned char convertHex(int c1, int c2);
47         static UChar convertUnicode(int c1, int c2, int c3, int c4);
48
49         // Functions to set up parsing.
50         void setCode(const SourceCode&, ParserArena&);
51         void setIsReparsing() { m_isReparsing = true; }
52         bool isReparsing() const { return m_isReparsing; }
53
54         // Functions for the parser itself.
55         enum LexType {
56             IgnoreReservedWords = 1, 
57             DontBuildStrings = 2,
58             DontBuildKeywords = 4
59         };
60         JSTokenType lex(JSTokenData* lvalp, JSTokenInfo* llocp, unsigned, bool strictMode);
61         bool nextTokenIsColon();
62         int lineNumber() const { return m_lineNumber; }
63         void setLastLineNumber(int lastLineNumber) { m_lastLineNumber = lastLineNumber; }
64         int lastLineNumber() const { return m_lastLineNumber; }
65         bool prevTerminator() const { return m_terminator; }
66         SourceCode sourceCode(int openBrace, int closeBrace, int firstLine);
67         bool scanRegExp(const Identifier*& pattern, const Identifier*& flags, UChar patternPrefix = 0);
68         bool skipRegExp();
69
70         // Functions for use after parsing.
71         bool sawError() const { return m_error; }
72         void clear();
73         int currentOffset() { return m_code - m_codeStart; }
74         void setOffset(int offset)
75         {
76             m_error = 0;
77             m_code = m_codeStart + offset;
78             m_buffer8.resize(0);
79             m_buffer16.resize(0);
80             // Faster than an if-else sequence
81             m_current = -1;
82             if (LIKELY(m_code < m_codeEnd))
83                 m_current = *m_code;
84         }
85         void setLineNumber(int line)
86         {
87             m_lineNumber = line;
88         }
89
90         SourceProvider* sourceProvider() const { return m_source->provider(); }
91
92     private:
93         friend class JSGlobalData;
94
95         Lexer(JSGlobalData*);
96         ~Lexer();
97
98         void record8(int);
99         void record16(int);
100         void record16(UChar);
101
102         void copyCodeWithoutBOMs();
103
104         ALWAYS_INLINE void shift();
105         ALWAYS_INLINE int peek(int offset);
106         int getUnicodeCharacter();
107         void shiftLineTerminator();
108
109         ALWAYS_INLINE const UChar* currentCharacter() const;
110         ALWAYS_INLINE int currentOffset() const;
111
112         ALWAYS_INLINE const Identifier* makeIdentifier(const UChar* characters, size_t length);
113
114         ALWAYS_INLINE bool lastTokenWasRestrKeyword() const;
115
116         template <bool shouldBuildIdentifiers> ALWAYS_INLINE JSTokenType parseIdentifier(JSTokenData*, unsigned);
117         template <bool shouldBuildStrings> ALWAYS_INLINE bool parseString(JSTokenData* lvalp, bool strictMode);
118         ALWAYS_INLINE void parseHex(double& returnValue);
119         ALWAYS_INLINE bool parseOctal(double& returnValue);
120         ALWAYS_INLINE bool parseDecimal(double& returnValue);
121         ALWAYS_INLINE void parseNumberAfterDecimalPoint();
122         ALWAYS_INLINE bool parseNumberAfterExponentIndicator();
123         ALWAYS_INLINE bool parseMultilineComment();
124
125         static const size_t initialReadBufferCapacity = 32;
126
127         int m_lineNumber;
128         int m_lastLineNumber;
129
130         Vector<char> m_buffer8;
131         Vector<UChar> m_buffer16;
132         bool m_terminator;
133         bool m_delimited; // encountered delimiter like "'" and "}" on last run
134         int m_lastToken;
135
136         const SourceCode* m_source;
137         const UChar* m_code;
138         const UChar* m_codeStart;
139         const UChar* m_codeEnd;
140         bool m_isReparsing;
141         bool m_atLineStart;
142         bool m_error;
143
144         // current and following unicode characters (int to allow for -1 for end-of-file marker)
145         int m_current;
146
147         IdentifierArena* m_arena;
148
149         JSGlobalData* m_globalData;
150
151         const HashTable m_keywordTable;
152     };
153
154     inline bool Lexer::isWhiteSpace(int ch)
155     {
156         return isASCII(ch) ? (ch == ' ' || ch == '\t' || ch == 0xB || ch == 0xC) : (WTF::Unicode::isSeparatorSpace(ch) || ch == 0xFEFF);
157     }
158
159     inline bool Lexer::isLineTerminator(int ch)
160     {
161         return ch == '\r' || ch == '\n' || (ch & ~1) == 0x2028;
162     }
163
164     inline unsigned char Lexer::convertHex(int c1, int c2)
165     {
166         return (toASCIIHexValue(c1) << 4) | toASCIIHexValue(c2);
167     }
168
169     inline UChar Lexer::convertUnicode(int c1, int c2, int c3, int c4)
170     {
171         return (convertHex(c1, c2) << 8) | convertHex(c3, c4);
172     }
173
174 } // namespace JSC
175
176 #endif // Lexer_h