7883efed225022c0206b78640b5a71789d9cea52
[WebKit-https.git] / Source / JavaScriptCore / parser / ParserError.h
1 /*
2  * Copyright (C) 2013 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 #pragma once
27
28 #include "Error.h"
29 #include "ErrorHandlingScope.h"
30 #include "ExceptionHelpers.h"
31 #include "ParserTokens.h"
32 #include <wtf/text/WTFString.h>
33
34 namespace JSC {
35
36 class ParserError {
37 public:
38     enum SyntaxErrorType {
39         SyntaxErrorNone,
40         SyntaxErrorIrrecoverable,
41         SyntaxErrorUnterminatedLiteral,
42         SyntaxErrorRecoverable
43     };
44
45     enum ErrorType {
46         ErrorNone,
47         StackOverflow,
48         EvalError,
49         OutOfMemory,
50         SyntaxError
51     };
52
53     ParserError()
54         : m_type(ErrorNone)
55         , m_syntaxErrorType(SyntaxErrorNone)
56     {
57     }
58     
59     explicit ParserError(ErrorType type)
60         : m_type(type)
61         , m_syntaxErrorType(SyntaxErrorNone)
62     {
63     }
64
65     ParserError(ErrorType type, SyntaxErrorType syntaxError, JSToken token)
66         : m_token(token)
67         , m_type(type)
68         , m_syntaxErrorType(syntaxError)
69     {
70     }
71
72     ParserError(ErrorType type, SyntaxErrorType syntaxError, JSToken token, const String& msg, int line)
73         : m_token(token)
74         , m_message(msg)
75         , m_line(line)
76         , m_type(type)
77         , m_syntaxErrorType(syntaxError)
78     {
79     }
80
81     bool isValid() const { return m_type != ErrorNone; }
82     SyntaxErrorType syntaxErrorType() const { return m_syntaxErrorType; }
83     const JSToken& token() const { return m_token; }
84     const String& message() const { return m_message; }
85     int line() const { return m_line; }
86
87     JSObject* toErrorObject(
88         JSGlobalObject* globalObject, const SourceCode& source, 
89         int overrideLineNumber = -1)
90     {
91         ExecState* exec = globalObject->globalExec();
92         switch (m_type) {
93         case ErrorNone:
94             return nullptr;
95         case SyntaxError:
96             return addErrorInfo(
97                 exec, 
98                 createSyntaxError(exec, m_message), 
99                 overrideLineNumber == -1 ? m_line : overrideLineNumber, source);
100         case EvalError:
101             return createSyntaxError(exec, m_message);
102         case StackOverflow: {
103             ErrorHandlingScope errorScope(globalObject->vm());
104             return createStackOverflowError(exec);
105         }
106         case OutOfMemory:
107             return createOutOfMemoryError(exec);
108         }
109         CRASH();
110         return nullptr;
111     }
112
113 private:
114     JSToken m_token;
115     String m_message;
116     int m_line { -1 };
117     ErrorType m_type;
118     SyntaxErrorType m_syntaxErrorType;
119 };
120
121 } // namespace JSC
122
123 namespace WTF {
124
125 inline void printInternal(PrintStream& out, JSC::ParserError::SyntaxErrorType type)
126 {
127     switch (type) {
128     case JSC::ParserError::SyntaxErrorNone:
129         out.print("SyntaxErrorNone");
130         return;
131     case JSC::ParserError::SyntaxErrorIrrecoverable:
132         out.print("SyntaxErrorIrrecoverable");
133         return;
134     case JSC::ParserError::SyntaxErrorUnterminatedLiteral:
135         out.print("SyntaxErrorUnterminatedLiteral");
136         return;
137     case JSC::ParserError::SyntaxErrorRecoverable:
138         out.print("SyntaxErrorRecoverable");
139         return;
140     }
141     
142     RELEASE_ASSERT_NOT_REACHED();
143 }
144
145 inline void printInternal(PrintStream& out, JSC::ParserError::ErrorType type)
146 {
147     switch (type) {
148     case JSC::ParserError::ErrorNone:
149         out.print("ErrorNone");
150         return;
151     case JSC::ParserError::StackOverflow:
152         out.print("StackOverflow");
153         return;
154     case JSC::ParserError::EvalError:
155         out.print("EvalError");
156         return;
157     case JSC::ParserError::OutOfMemory:
158         out.print("OutOfMemory");
159         return;
160     case JSC::ParserError::SyntaxError:
161         out.print("SyntaxError");
162         return;
163     }
164     
165     RELEASE_ASSERT_NOT_REACHED();
166 }
167
168 } // namespace WTF