|
1 /* A Bison parser, made by GNU Bison 2.3. */ |
|
2 |
|
3 /* Skeleton interface for Bison LALR(1) parsers in C++ |
|
4 |
|
5 Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. |
|
6 |
|
7 This program is free software; you can redistribute it and/or modify |
|
8 it under the terms of the GNU General Public License as published by |
|
9 the Free Software Foundation; either version 2, or (at your option) |
|
10 any later version. |
|
11 |
|
12 This program is distributed in the hope that it will be useful, |
|
13 but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
15 GNU General Public License for more details. |
|
16 |
|
17 You should have received a copy of the GNU General Public License |
|
18 along with this program; if not, write to the Free Software |
|
19 Foundation, Inc., 51 Franklin Street, Fifth Floor, |
|
20 Boston, MA 02110-1301, USA. */ |
|
21 |
|
22 /* As a special exception, you may create a larger work that contains |
|
23 part or all of the Bison parser skeleton and distribute that work |
|
24 under terms of your choice, so long as that work isn't itself a |
|
25 parser generator using the skeleton or a modified version thereof |
|
26 as a parser skeleton. Alternatively, if you modify or redistribute |
|
27 the parser skeleton itself, you may (at your option) remove this |
|
28 special exception, which will cause the skeleton and the resulting |
|
29 Bison output files to be licensed under the GNU General Public |
|
30 License without this special exception. |
|
31 |
|
32 This special exception was added by the Free Software Foundation in |
|
33 version 2.2 of Bison. */ |
|
34 |
|
35 /* C++ LALR(1) parser skeleton written by Akim Demaille. */ |
|
36 |
|
37 #ifndef PARSER_HEADER_H |
|
38 # define PARSER_HEADER_H |
|
39 |
|
40 #include <string> |
|
41 #include <iostream> |
|
42 #include "stack.hh" |
|
43 |
|
44 namespace yy |
|
45 { |
|
46 class position; |
|
47 class location; |
|
48 } |
|
49 |
|
50 /* First part of user declarations. */ |
|
51 #line 25 "json_parser.yy" |
|
52 |
|
53 #include "parser_p.h" |
|
54 #include "json_scanner.h" |
|
55 #include "qjson_debug.h" |
|
56 |
|
57 #include <QtCore/QByteArray> |
|
58 #include <QtCore/QMap> |
|
59 #include <QtCore/QString> |
|
60 #include <QtCore/QVariant> |
|
61 |
|
62 class JSonScanner; |
|
63 |
|
64 namespace QJson { |
|
65 class Parser; |
|
66 } |
|
67 |
|
68 #define YYERROR_VERBOSE 1 |
|
69 |
|
70 |
|
71 /* Line 303 of lalr1.cc. */ |
|
72 #line 73 "json_parser.hh" |
|
73 |
|
74 #include "location.hh" |
|
75 |
|
76 /* Enabling traces. */ |
|
77 #ifndef YYDEBUG |
|
78 # define YYDEBUG 1 |
|
79 #endif |
|
80 |
|
81 /* Enabling verbose error messages. */ |
|
82 #ifdef YYERROR_VERBOSE |
|
83 # undef YYERROR_VERBOSE |
|
84 # define YYERROR_VERBOSE 1 |
|
85 #else |
|
86 # define YYERROR_VERBOSE 1 |
|
87 #endif |
|
88 |
|
89 /* Enabling the token table. */ |
|
90 #ifndef YYTOKEN_TABLE |
|
91 # define YYTOKEN_TABLE 0 |
|
92 #endif |
|
93 |
|
94 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
|
95 If N is 0, then set CURRENT to the empty location which ends |
|
96 the previous symbol: RHS[0] (always defined). */ |
|
97 |
|
98 #ifndef YYLLOC_DEFAULT |
|
99 # define YYLLOC_DEFAULT(Current, Rhs, N) \ |
|
100 do { \ |
|
101 if (N) \ |
|
102 { \ |
|
103 (Current).begin = (Rhs)[1].begin; \ |
|
104 (Current).end = (Rhs)[N].end; \ |
|
105 } \ |
|
106 else \ |
|
107 { \ |
|
108 (Current).begin = (Current).end = (Rhs)[0].end; \ |
|
109 } \ |
|
110 } while (false) |
|
111 #endif |
|
112 |
|
113 namespace yy |
|
114 { |
|
115 |
|
116 /// A Bison parser. |
|
117 class json_parser |
|
118 { |
|
119 public: |
|
120 /// Symbol semantic values. |
|
121 #ifndef YYSTYPE |
|
122 typedef int semantic_type; |
|
123 #else |
|
124 typedef YYSTYPE semantic_type; |
|
125 #endif |
|
126 /// Symbol locations. |
|
127 typedef location location_type; |
|
128 /// Tokens. |
|
129 struct token |
|
130 { |
|
131 /* Tokens. */ |
|
132 enum yytokentype { |
|
133 END = 0, |
|
134 CURLY_BRACKET_OPEN = 1, |
|
135 CURLY_BRACKET_CLOSE = 2, |
|
136 SQUARE_BRACKET_OPEN = 3, |
|
137 SQUARE_BRACKET_CLOSE = 4, |
|
138 COLON = 5, |
|
139 COMMA = 6, |
|
140 MINUS = 7, |
|
141 DOT = 8, |
|
142 DIGIT = 9, |
|
143 E = 10, |
|
144 TRUE_VAL = 11, |
|
145 FALSE_VAL = 12, |
|
146 NULL_VAL = 13, |
|
147 QUOTMARKOPEN = 14, |
|
148 QUOTMARKCLOSE = 15, |
|
149 STRING = 16 |
|
150 }; |
|
151 |
|
152 }; |
|
153 /// Token type. |
|
154 typedef token::yytokentype token_type; |
|
155 |
|
156 /// Build a parser object. |
|
157 json_parser (QJson::ParserPrivate* driver_yyarg); |
|
158 virtual ~json_parser (); |
|
159 |
|
160 /// Parse. |
|
161 /// \returns 0 iff parsing succeeded. |
|
162 virtual int parse (); |
|
163 |
|
164 /// The current debugging stream. |
|
165 std::ostream& debug_stream () const; |
|
166 /// Set the current debugging stream. |
|
167 void set_debug_stream (std::ostream &); |
|
168 |
|
169 /// Type for debugging levels. |
|
170 typedef int debug_level_type; |
|
171 /// The current debugging level. |
|
172 debug_level_type debug_level () const; |
|
173 /// Set the current debugging level. |
|
174 void set_debug_level (debug_level_type l); |
|
175 |
|
176 private: |
|
177 /// Report a syntax error. |
|
178 /// \param loc where the syntax error is found. |
|
179 /// \param msg a description of the syntax error. |
|
180 virtual void error (const location_type& loc, const std::string& msg); |
|
181 |
|
182 /// Generate an error message. |
|
183 /// \param state the state where the error occurred. |
|
184 /// \param tok the look-ahead token. |
|
185 virtual std::string yysyntax_error_ (int yystate, int tok); |
|
186 |
|
187 #if YYDEBUG |
|
188 /// \brief Report a symbol value on the debug stream. |
|
189 /// \param yytype The token type. |
|
190 /// \param yyvaluep Its semantic value. |
|
191 /// \param yylocationp Its location. |
|
192 virtual void yy_symbol_value_print_ (int yytype, |
|
193 const semantic_type* yyvaluep, |
|
194 const location_type* yylocationp); |
|
195 /// \brief Report a symbol on the debug stream. |
|
196 /// \param yytype The token type. |
|
197 /// \param yyvaluep Its semantic value. |
|
198 /// \param yylocationp Its location. |
|
199 virtual void yy_symbol_print_ (int yytype, |
|
200 const semantic_type* yyvaluep, |
|
201 const location_type* yylocationp); |
|
202 #endif /* ! YYDEBUG */ |
|
203 |
|
204 |
|
205 /// State numbers. |
|
206 typedef int state_type; |
|
207 /// State stack type. |
|
208 typedef stack<state_type> state_stack_type; |
|
209 /// Semantic value stack type. |
|
210 typedef stack<semantic_type> semantic_stack_type; |
|
211 /// location stack type. |
|
212 typedef stack<location_type> location_stack_type; |
|
213 |
|
214 /// The state stack. |
|
215 state_stack_type yystate_stack_; |
|
216 /// The semantic value stack. |
|
217 semantic_stack_type yysemantic_stack_; |
|
218 /// The location stack. |
|
219 location_stack_type yylocation_stack_; |
|
220 |
|
221 /// Internal symbol numbers. |
|
222 typedef unsigned char token_number_type; |
|
223 /* Tables. */ |
|
224 /// For a state, the index in \a yytable_ of its portion. |
|
225 static const signed char yypact_[]; |
|
226 static const signed char yypact_ninf_; |
|
227 |
|
228 /// For a state, default rule to reduce. |
|
229 /// Unless\a yytable_ specifies something else to do. |
|
230 /// Zero means the default is an error. |
|
231 static const unsigned char yydefact_[]; |
|
232 |
|
233 static const signed char yypgoto_[]; |
|
234 static const signed char yydefgoto_[]; |
|
235 |
|
236 /// What to do in a state. |
|
237 /// \a yytable_[yypact_[s]]: what to do in state \a s. |
|
238 /// - if positive, shift that token. |
|
239 /// - if negative, reduce the rule which number is the opposite. |
|
240 /// - if zero, do what YYDEFACT says. |
|
241 static const unsigned char yytable_[]; |
|
242 static const signed char yytable_ninf_; |
|
243 |
|
244 static const unsigned char yycheck_[]; |
|
245 |
|
246 /// For a state, its accessing symbol. |
|
247 static const unsigned char yystos_[]; |
|
248 |
|
249 /// For a rule, its LHS. |
|
250 static const unsigned char yyr1_[]; |
|
251 /// For a rule, its RHS length. |
|
252 static const unsigned char yyr2_[]; |
|
253 |
|
254 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
|
255 /// For a symbol, its name in clear. |
|
256 static const char* const yytname_[]; |
|
257 #endif |
|
258 |
|
259 #if YYERROR_VERBOSE |
|
260 /// Convert the symbol name \a n to a form suitable for a diagnostic. |
|
261 virtual std::string yytnamerr_ (const char *n); |
|
262 #endif |
|
263 |
|
264 #if YYDEBUG |
|
265 /// A type to store symbol numbers and -1. |
|
266 typedef signed char rhs_number_type; |
|
267 /// A `-1'-separated list of the rules' RHS. |
|
268 static const rhs_number_type yyrhs_[]; |
|
269 /// For each rule, the index of the first RHS symbol in \a yyrhs_. |
|
270 static const unsigned char yyprhs_[]; |
|
271 /// For each rule, its source line number. |
|
272 static const unsigned char yyrline_[]; |
|
273 /// For each scanner token number, its symbol number. |
|
274 static const unsigned short int yytoken_number_[]; |
|
275 /// Report on the debug stream that the rule \a r is going to be reduced. |
|
276 virtual void yy_reduce_print_ (int r); |
|
277 /// Print the state stack on the debug stream. |
|
278 virtual void yystack_print_ (); |
|
279 #endif |
|
280 |
|
281 /// Convert a scanner token number \a t to a symbol number. |
|
282 token_number_type yytranslate_ (int t); |
|
283 |
|
284 /// \brief Reclaim the memory associated to a symbol. |
|
285 /// \param yymsg Why this token is reclaimed. |
|
286 /// \param yytype The symbol type. |
|
287 /// \param yyvaluep Its semantic value. |
|
288 /// \param yylocationp Its location. |
|
289 inline void yydestruct_ (const char* yymsg, |
|
290 int yytype, |
|
291 semantic_type* yyvaluep, |
|
292 location_type* yylocationp); |
|
293 |
|
294 /// Pop \a n symbols the three stacks. |
|
295 inline void yypop_ (unsigned int n = 1); |
|
296 |
|
297 /* Constants. */ |
|
298 static const int yyeof_; |
|
299 /* LAST_ -- Last index in TABLE_. */ |
|
300 static const int yylast_; |
|
301 static const int yynnts_; |
|
302 static const int yyempty_; |
|
303 static const int yyfinal_; |
|
304 static const int yyterror_; |
|
305 static const int yyerrcode_; |
|
306 static const int yyntokens_; |
|
307 static const unsigned int yyuser_token_number_max_; |
|
308 static const token_number_type yyundef_token_; |
|
309 |
|
310 /* Debugging. */ |
|
311 int yydebug_; |
|
312 std::ostream* yycdebug_; |
|
313 |
|
314 |
|
315 /* User arguments. */ |
|
316 QJson::ParserPrivate* driver; |
|
317 }; |
|
318 } |
|
319 |
|
320 |
|
321 #endif /* ! defined PARSER_HEADER_H */ |