Bug Summary

File:OMEdit/OMEditLIB/Debugger/Parser/GDBMIOutputLexer.c
Warning:line 848, column 9
Value stored to 'alt2' is never read

Annotated Source Code

[?] Use j/k keys for keyboard navigation

1/** \file
2 * This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23
3 *
4 * - From the grammar source file : GDBMIOutput.g
5 * - On : 2020-02-01 17:47:09
6 * - for the lexer : GDBMIOutputLexerLexer *
7 * Editing it, at least manually, is not wise.
8 *
9 * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
10 *
11 *
12*/
13// [The "BSD licence"]
14// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
15// http://www.temporal-wave.com
16// http://www.linkedin.com/in/jimidle
17//
18// All rights reserved.
19//
20// Redistribution and use in source and binary forms, with or without
21// modification, are permitted provided that the following conditions
22// are met:
23// 1. Redistributions of source code must retain the above copyright
24// notice, this list of conditions and the following disclaimer.
25// 2. Redistributions in binary form must reproduce the above copyright
26// notice, this list of conditions and the following disclaimer in the
27// documentation and/or other materials provided with the distribution.
28// 3. The name of the author may not be used to endorse or promote products
29// derived from this software without specific prior written permission.
30//
31// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
32// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
33// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
34// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
35// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
36// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
37// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
38// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
39// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
40// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41
42/* -----------------------------------------
43 * Include the ANTLR3 generated header file.
44 */
45#include "GDBMIOutputLexer.h"
46/* ----------------------------------------- */
47
48
49/** String literals used by GDBMIOutputLexer that we must do things like MATCHS() with.
50 * C will normally just lay down 8 bit characters, and you can use L"xxx" to
51 * get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so
52 * we perform this little trick of defining the literals as arrays of UINT32
53 * and passing in the address of these.
54 */
55static ANTLR3_UCHAR lit_1[] = { 0x7B, 0x7D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
56static ANTLR3_UCHAR lit_2[] = { 0x5B, 0x5D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
57static ANTLR3_UCHAR lit_3[] = { 0x64, 0x6F, 0x6E, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
58static ANTLR3_UCHAR lit_4[] = { 0x72, 0x75, 0x6E, 0x6E, 0x69, 0x6E, 0x67, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
59static ANTLR3_UCHAR lit_5[] = { 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
60static ANTLR3_UCHAR lit_6[] = { 0x65, 0x72, 0x72, 0x6F, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
61static ANTLR3_UCHAR lit_7[] = { 0x65, 0x78, 0x69, 0x74, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
62static ANTLR3_UCHAR lit_8[] = { 0x73, 0x74, 0x6F, 0x70, 0x70, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
63static ANTLR3_UCHAR lit_9[] = { 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x2D, 0x61, 0x64, 0x64, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
64static ANTLR3_UCHAR lit_10[] = { 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x2D, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
65static ANTLR3_UCHAR lit_11[] = { 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x2D, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
66static ANTLR3_UCHAR lit_12[] = { 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
67static ANTLR3_UCHAR lit_13[] = { 0x64, 0x6F, 0x77, 0x6E, 0x6C, 0x6F, 0x61, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
68static ANTLR3_UCHAR lit_14[] = { 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x67, 0x72, 0x6F, 0x75, 0x70, 0x2D, 0x65, 0x78, 0x69, 0x74, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
69static ANTLR3_UCHAR lit_15[] = { 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x2D, 0x65, 0x78, 0x69, 0x74, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
70static ANTLR3_UCHAR lit_16[] = { 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
71static ANTLR3_UCHAR lit_17[] = { 0x6C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x2D, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
72static ANTLR3_UCHAR lit_18[] = { 0x6C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x2D, 0x75, 0x6E, 0x6C, 0x6F, 0x61, 0x64, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
73static ANTLR3_UCHAR lit_19[] = { 0x28, 0x67, 0x64, 0x62, 0x29, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
74
75
76
77
78/* MACROS that hide the C interface implementations from the
79 * generated code, which makes it a little more understandable to the human eye.
80 * I am very much against using C pre-processor macros for function calls and bits
81 * of code as you cannot see what is happening when single stepping in debuggers
82 * and so on. The exception (in my book at least) is for generated code, where you are
83 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
84 * hides some indirect calls, but is always referring to the input stream. This is
85 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
86 * the runtime interfaces without changing the generated code too often, without
87 * confusing the reader of the generated output, who may not wish to know the gory
88 * details of the interface inheritance.
89 */
90
91#define CTXctx ctx
92
93/* Aids in accessing scopes for grammar programmers
94 */
95#undef SCOPE_TYPE
96#undef SCOPE_STACK
97#undef SCOPE_TOP
98#define SCOPE_TYPE(scope)pGDBMIOutputLexer_scope_SCOPE pGDBMIOutputLexer_##scope##_SCOPE
99#define SCOPE_STACK(scope)pGDBMIOutputLexer_scopeStack pGDBMIOutputLexer_##scope##Stack
100#define SCOPE_TOP(scope)ctx->pGDBMIOutputLexer_scopeTop ctx->pGDBMIOutputLexer_##scope##Top
101#define SCOPE_SIZE(scope)ctx->pGDBMIOutputLexer_scopeStack_limit ctx->pGDBMIOutputLexer_##scope##Stack_limit
102#define SCOPE_INSTANCE(scope, i)(ctx->pGDBMIOutputLexer_scopeStack->get(ctx->pGDBMIOutputLexer_scopeStack
,i))
(ctx->SCOPE_STACK(scope)pGDBMIOutputLexer_scopeStack->get(ctx->SCOPE_STACK(scope)pGDBMIOutputLexer_scopeStack,i))
103
104
105/* Macros for accessing things in a lexer
106 */
107#undef LEXERctx->pLexer
108#undef RECOGNIZERctx->pLexer->rec
109#undef RULEMEMOctx->pLexer->rec->state->ruleMemo
110#undef GETCHARINDEX
111#undef GETLINE
112#undef GETCHARPOSITIONINLINE
113#undef EMIT
114#undef EMITNEW
115#undef MATCHC
116#undef MATCHS
117#undef MATCHRANGE
118#undef LTOKENctx->pLexer->rec->state->token
119#undef HASFAILED
120#undef FAILEDFLAGctx->pLexer->rec->state->failed
121#undef INPUTctx->pLexer->input
122#undef STRSTREAMctx->pLexer->input
123#undef LA
124#undef HASEXCEPTION
125#undef EXCEPTIONctx->pLexer->rec->state->exception
126#undef CONSTRUCTEX
127#undef CONSUME
128#undef LRECOVER
129#undef MARK
130#undef REWIND
131#undef REWINDLAST
132#undef BACKTRACKINGctx->pLexer->rec->state->backtracking
133#undef MATCHANY
134#undef MEMOIZE
135#undef HAVEPARSEDRULE
136#undef GETTEXT
137#undef INDEX
138#undef SEEK
139#undef PUSHSTREAM
140#undef POPSTREAM
141#undef SETTEXT
142#undef SETTEXT8
143
144#define LEXERctx->pLexer ctx->pLexer
145#define RECOGNIZERctx->pLexer->rec LEXERctx->pLexer->rec
146#define LEXSTATEctx->pLexer->rec->state RECOGNIZERctx->pLexer->rec->state
147#define TOKSOURCEctx->pLexer->rec->state->tokSource LEXSTATEctx->pLexer->rec->state->tokSource
148#define GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer) LEXERctx->pLexer->getCharIndex(LEXERctx->pLexer)
149#define GETLINE()ctx->pLexer->getLine(ctx->pLexer) LEXERctx->pLexer->getLine(LEXERctx->pLexer)
150#define GETTEXT()ctx->pLexer->getText(ctx->pLexer) LEXERctx->pLexer->getText(LEXERctx->pLexer)
151#define GETCHARPOSITIONINLINE()ctx->pLexer->getCharPositionInLine(ctx->pLexer) LEXERctx->pLexer->getCharPositionInLine(LEXERctx->pLexer)
152#define EMIT()ctx->pLexer->rec->state->type = _type; ctx->pLexer
->emit(ctx->pLexer)
LEXSTATEctx->pLexer->rec->state->type = _type; LEXERctx->pLexer->emit(LEXERctx->pLexer)
153#define EMITNEW(t)ctx->pLexer->emitNew(ctx->pLexer, t) LEXERctx->pLexer->emitNew(LEXERctx->pLexer, t)
154#define MATCHC(c)ctx->pLexer->matchc(ctx->pLexer, c) LEXERctx->pLexer->matchc(LEXERctx->pLexer, c)
155#define MATCHS(s)ctx->pLexer->matchs(ctx->pLexer, s) LEXERctx->pLexer->matchs(LEXERctx->pLexer, s)
156#define MATCHRANGE(c1,c2)ctx->pLexer->matchRange(ctx->pLexer, c1, c2) LEXERctx->pLexer->matchRange(LEXERctx->pLexer, c1, c2)
157#define MATCHANY()ctx->pLexer->matchAny(ctx->pLexer) LEXERctx->pLexer->matchAny(LEXERctx->pLexer)
158#define LTOKENctx->pLexer->rec->state->token LEXSTATEctx->pLexer->rec->state->token
159#define HASFAILED()(ctx->pLexer->rec->state->failed == 1) (LEXSTATEctx->pLexer->rec->state->failed == ANTLR3_TRUE1)
160#define BACKTRACKINGctx->pLexer->rec->state->backtracking LEXSTATEctx->pLexer->rec->state->backtracking
161#define FAILEDFLAGctx->pLexer->rec->state->failed LEXSTATEctx->pLexer->rec->state->failed
162#define INPUTctx->pLexer->input LEXERctx->pLexer->input
163#define STRSTREAMctx->pLexer->input INPUTctx->pLexer->input
164#define ISTREAMctx->pLexer->input->istream INPUTctx->pLexer->input->istream
165#define INDEX()ctx->pLexer->input->istream->index(ctx->pLexer
->input->istream)
ISTREAMctx->pLexer->input->istream->index(ISTREAMctx->pLexer->input->istream)
166#define SEEK(n)ctx->pLexer->input->istream->seek(ctx->pLexer->
input->istream, n)
ISTREAMctx->pLexer->input->istream->seek(ISTREAMctx->pLexer->input->istream, n)
167#define EOF_TOKEN&(ctx->pLexer->rec->state->tokSource->eofToken
)
&(LEXSTATEctx->pLexer->rec->state->tokSource->eofToken)
168#define HASEXCEPTION()(ctx->pLexer->rec->state->error == 1) (LEXSTATEctx->pLexer->rec->state->error == ANTLR3_TRUE1)
169#define EXCEPTIONctx->pLexer->rec->state->exception LEXSTATEctx->pLexer->rec->state->exception
170#define CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
RECOGNIZERctx->pLexer->rec->exConstruct(RECOGNIZERctx->pLexer->rec)
171#define LRECOVER()ctx->pLexer->recover(ctx->pLexer) LEXERctx->pLexer->recover(LEXERctx->pLexer)
172#define MARK()ctx->pLexer->input->istream->mark(ctx->pLexer->
input->istream)
ISTREAMctx->pLexer->input->istream->mark(ISTREAMctx->pLexer->input->istream)
173#define REWIND(m)ctx->pLexer->input->istream->rewind(ctx->pLexer
->input->istream, m)
ISTREAMctx->pLexer->input->istream->rewind(ISTREAMctx->pLexer->input->istream, m)
174#define REWINDLAST()ctx->pLexer->input->istream->rewindLast(ctx->pLexer
->input->istream)
ISTREAMctx->pLexer->input->istream->rewindLast(ISTREAMctx->pLexer->input->istream)
175#define MEMOIZE(ri,si)ctx->pLexer->rec->memoize(ctx->pLexer->rec, ri
, si)
RECOGNIZERctx->pLexer->rec->memoize(RECOGNIZERctx->pLexer->rec, ri, si)
176#define HAVEPARSEDRULE(r)ctx->pLexer->rec->alreadyParsedRule(ctx->pLexer->
rec, r)
RECOGNIZERctx->pLexer->rec->alreadyParsedRule(RECOGNIZERctx->pLexer->rec, r)
177#define PUSHSTREAM(str)ctx->pLexer->pushCharStream(ctx->pLexer, str) LEXERctx->pLexer->pushCharStream(LEXERctx->pLexer, str)
178#define POPSTREAM()ctx->pLexer->popCharStream(ctx->pLexer) LEXERctx->pLexer->popCharStream(LEXERctx->pLexer)
179#define SETTEXT(str)ctx->pLexer->rec->state->text = str LEXSTATEctx->pLexer->rec->state->text = str
180#define SKIP()ctx->pLexer->rec->state->token = &(ctx->pLexer
->rec->state->tokSource->skipToken)
LEXSTATEctx->pLexer->rec->state->token = &(TOKSOURCEctx->pLexer->rec->state->tokSource->skipToken)
181#define USER1ctx->pLexer->rec->state->user1 LEXSTATEctx->pLexer->rec->state->user1
182#define USER2ctx->pLexer->rec->state->user2 LEXSTATEctx->pLexer->rec->state->user2
183#define USER3ctx->pLexer->rec->state->user3 LEXSTATEctx->pLexer->rec->state->user3
184#define CUSTOMctx->pLexer->rec->state->custom LEXSTATEctx->pLexer->rec->state->custom
185#define RULEMEMOctx->pLexer->rec->state->ruleMemo LEXSTATEctx->pLexer->rec->state->ruleMemo
186#define DBGctx->pLexer->rec->debugger RECOGNIZERctx->pLexer->rec->debugger
187
188/* If we have been told we can rely on the standard 8 bit or 16 bit input
189 * stream, then we can define our macros to use the direct pointers
190 * in the input object, which is much faster than indirect calls. This
191 * is really only significant to lexers with a lot of fragment rules (which
192 * do not place LA(1) in a temporary at the moment) and even then
193 * only if there is a lot of input (order of say 1M or so).
194 */
195#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
196
197# ifdef ANTLR3_INLINE_INPUT_ASCII
198
199/* 8 bit "ASCII" (actually any 8 bit character set) */
200
201# define NEXTCHAR ((pANTLR3_UINT8)(INPUTctx->pLexer->input->nextChar))
202# define DATAP ((pANTLR3_UINT8)(INPUTctx->pLexer->input->data))
203
204# else
205
206# define NEXTCHAR ((pANTLR3_UINT16)(INPUTctx->pLexer->input->nextChar))
207# define DATAP ((pANTLR3_UINT16)(INPUTctx->pLexer->input->data))
208
209# endif
210
211# define LA(n)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, n)
((NEXTCHAR + n) > (DATAP + INPUTctx->pLexer->input->sizeBuf) ? ANTLR3_CHARSTREAM_EOF0xFFFFFFFF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))
212# define CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
\
213{ \
214 if (NEXTCHAR < (DATAP + INPUTctx->pLexer->input->sizeBuf)) \
215 { \
216 INPUTctx->pLexer->input->charPositionInLine++; \
217 if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUTctx->pLexer->input->newlineChar) \
218 { \
219 INPUTctx->pLexer->input->line++; \
220 INPUTctx->pLexer->input->charPositionInLine = 0; \
221 INPUTctx->pLexer->input->currentLine = (void *)(NEXTCHAR + 1); \
222 } \
223 INPUTctx->pLexer->input->nextChar = (void *)(NEXTCHAR + 1); \
224 } \
225}
226
227#else
228
229// Pick up the input character by calling the input stream implementation.
230//
231#define CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
INPUTctx->pLexer->input->istream->consume(INPUTctx->pLexer->input->istream)
232#define LA(n)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, n)
INPUTctx->pLexer->input->istream->_LA(INPUTctx->pLexer->input->istream, n)
233
234#endif
235#define TOKTEXT(tok, txt)tok, (pANTLR3_UINT8)txt tok, (pANTLR3_UINT8)txt
236
237/* The 4 tokens defined below may well clash with your own #defines or token types. If so
238 * then for the present you must use different names for your defines as these are hard coded
239 * in the code generator. It would be better not to use such names internally, and maybe
240 * we can change this in a forthcoming release. I deliberately do not #undef these
241 * here as this will at least give you a redefined error somewhere if they clash.
242 */
243#define UP3 ANTLR3_TOKEN_UP3
244#define DOWN2 ANTLR3_TOKEN_DOWN2
245#define EORANTLR3_TOKEN_EOR ANTLR3_TOKEN_EOR
246#define INVALID0 ANTLR3_TOKEN_INVALID0
247
248
249/* =============================================================================
250 * Functions to create and destroy scopes. First come the rule scopes, followed
251 * by the global declared scopes.
252 */
253
254
255
256/* ============================================================================= */
257
258/* =============================================================================
259 * Start of recognizer
260 */
261
262
263/* Forward declare the locally static matching functions we have generated and any predicate functions.
264 */
265static ANTLR3_INLINEinline void mT__19 (pGDBMIOutputLexer ctx);
266static ANTLR3_INLINEinline void mT__20 (pGDBMIOutputLexer ctx);
267static ANTLR3_INLINEinline void mT__21 (pGDBMIOutputLexer ctx);
268static ANTLR3_INLINEinline void mT__22 (pGDBMIOutputLexer ctx);
269static ANTLR3_INLINEinline void mT__23 (pGDBMIOutputLexer ctx);
270static ANTLR3_INLINEinline void mT__24 (pGDBMIOutputLexer ctx);
271static ANTLR3_INLINEinline void mC_STRING (pGDBMIOutputLexer ctx);
272static ANTLR3_INLINEinline void mRESULT_CLASS (pGDBMIOutputLexer ctx);
273static ANTLR3_INLINEinline void mSTRING (pGDBMIOutputLexer ctx);
274static ANTLR3_INLINEinline void mNL (pGDBMIOutputLexer ctx);
275static ANTLR3_INLINEinline void mWS (pGDBMIOutputLexer ctx);
276static ANTLR3_INLINEinline void mTOKEN (pGDBMIOutputLexer ctx);
277static ANTLR3_INLINEinline void mCOMMA (pGDBMIOutputLexer ctx);
278static ANTLR3_INLINEinline void mEOM (pGDBMIOutputLexer ctx);
279static ANTLR3_INLINEinline void mCONSOLE (pGDBMIOutputLexer ctx);
280static ANTLR3_INLINEinline void mTARGET (pGDBMIOutputLexer ctx);
281static ANTLR3_INLINEinline void mLOG (pGDBMIOutputLexer ctx);
282static ANTLR3_INLINEinline void mEXEC (pGDBMIOutputLexer ctx);
283static ANTLR3_INLINEinline void mSTATUS (pGDBMIOutputLexer ctx);
284static ANTLR3_INLINEinline void mNOTIFY (pGDBMIOutputLexer ctx);
285static ANTLR3_INLINEinline void mRESULT (pGDBMIOutputLexer ctx);
286static ANTLR3_INLINEinline void mTokens (pGDBMIOutputLexer ctx);
287static void GDBMIOutputLexerFree(pGDBMIOutputLexer ctx);
288
289/* =========================================================================
290 * Lexer matching rules end.
291 * =========================================================================
292 */
293
294
295
296static void
297GDBMIOutputLexerFree (pGDBMIOutputLexer ctx)
298{
299 LEXERctx->pLexer->free(LEXERctx->pLexer);
300
301 ANTLR3_FREE(ctx)free ((void *)(ctx));
302}
303
304/** \brief Name of the grammar file that generated this code
305 */
306static const char fileName[] = "GDBMIOutput.g";
307
308/** \brief Return the name of the grammar file that generated this code.
309 */
310static const char * getGrammarFileName()
311{
312 return fileName;
313}
314
315/** \brief Create a new lexer called GDBMIOutputLexer
316 *
317 * \param[in] instream Pointer to an initialized input stream
318 * \return
319 * - Success pGDBMIOutputLexer initialized for the lex start
320 * - Fail NULL
321 */
322ANTLR3_API pGDBMIOutputLexer GDBMIOutputLexerNew
323(pANTLR3_INPUT_STREAM instream)
324{
325 // See if we can create a new lexer with the standard constructor
326 //
327 return GDBMIOutputLexerNewSSD(instream, NULL__null);
328}
329
330/** \brief Create a new lexer called GDBMIOutputLexer
331 *
332 * \param[in] instream Pointer to an initialized input stream
333 * \param[state] state Previously created shared recognizer stat
334 * \return
335 * - Success pGDBMIOutputLexer initialized for the lex start
336 * - Fail NULL
337 */
338ANTLR3_API pGDBMIOutputLexer GDBMIOutputLexerNewSSD
339(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
340{
341 pGDBMIOutputLexer ctx; // Context structure we will build and return
342
343 ctx = (pGDBMIOutputLexer) ANTLR3_CALLOC(1, sizeof(GDBMIOutputLexer))calloc (1, (size_t)(sizeof(GDBMIOutputLexer)));;
344
345 if (ctx == NULL__null)
346 {
347 // Failed to allocate memory for lexer context
348 return NULL__null;
349 }
350
351 /* -------------------------------------------------------------------
352 * Memory for basic structure is allocated, now to fill in
353 * in base ANTLR3 structures. We initialize the function pointers
354 * for the standard ANTLR3 lexer function set, but upon return
355 * from here, the programmer may set the pointers to provide custom
356 * implementations of each function.
357 *
358 * We don't use the macros defined in GDBMIOutputLexer.h here so you can get a sense
359 * of what goes where.
360 */
361
362 /* Create a base lexer, using the supplied input stream
363 */
364 ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT2049, instream, state);
365
366 /* Check that we allocated the memory correctly
367 */
368 if (ctx->pLexer == NULL__null)
369 {
370 ANTLR3_FREE(ctx)free ((void *)(ctx));
371 return NULL__null;
372 }
373 /* Install the implementation of our GDBMIOutputLexer interface
374 */
375 ctx->mT__19 = mT__19;
376 ctx->mT__20 = mT__20;
377 ctx->mT__21 = mT__21;
378 ctx->mT__22 = mT__22;
379 ctx->mT__23 = mT__23;
380 ctx->mT__24 = mT__24;
381 ctx->mC_STRING = mC_STRING;
382 ctx->mRESULT_CLASS = mRESULT_CLASS;
383 ctx->mSTRING = mSTRING;
384 ctx->mNL = mNL;
385 ctx->mWS = mWS;
386 ctx->mTOKEN = mTOKEN;
387 ctx->mCOMMA = mCOMMA;
388 ctx->mEOM = mEOM;
389 ctx->mCONSOLE = mCONSOLE;
390 ctx->mTARGET = mTARGET;
391 ctx->mLOG = mLOG;
392 ctx->mEXEC = mEXEC;
393 ctx->mSTATUS = mSTATUS;
394 ctx->mNOTIFY = mNOTIFY;
395 ctx->mRESULT = mRESULT;
396 ctx->mTokens = mTokens;
397
398 /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
399 * it will call mTokens() in this generated code, and will pass it the ctx
400 * pointer of this lexer, not the context of the base lexer, so store that now.
401 */
402 ctx->pLexer->ctx = ctx;
403
404 /**Install the token matching function
405 */
406 ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
407
408 ctx->getGrammarFileName = getGrammarFileName;
409 ctx->free = GDBMIOutputLexerFree;
410
411
412
413
414
415 /* Return the newly built lexer to the caller
416 */
417 return ctx;
418}
419
420
421/* =========================================================================
422 * Functions to match the lexer grammar defined tokens from the input stream
423 */
424
425// Comes from: 7:7: ( '{}' )
426/** \brief Lexer rule generated by ANTLR3
427 *
428 * $ANTLR start T__19
429 *
430 * Looks to match the characters the constitute the token T__19
431 * from the attached input stream.
432 *
433 *
434 * \remark
435 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
436 */
437static ANTLR3_INLINEinline
438void mT__19(pGDBMIOutputLexer ctx)
439{
440 ANTLR3_UINT32 _type;
441
442 _type = T__1919;
443
444
445 // GDBMIOutput.g:7:7: ( '{}' )
446 // GDBMIOutput.g:7:9: '{}'
447 {
448 MATCHS(lit_1)ctx->pLexer->matchs(ctx->pLexer, lit_1);
449 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
450 {
451 goto ruleT__19Ex;
452 }
453
454
455
456 }
457
458 LEXSTATEctx->pLexer->rec->state->type = _type;
459
460 // This is where rules clean up and exit
461 //
462 goto ruleT__19Ex; /* Prevent compiler warnings */
463 ruleT__19Ex: ;
464
465}
466// $ANTLR end T__19
467
468// Comes from: 8:7: ( '{' )
469/** \brief Lexer rule generated by ANTLR3
470 *
471 * $ANTLR start T__20
472 *
473 * Looks to match the characters the constitute the token T__20
474 * from the attached input stream.
475 *
476 *
477 * \remark
478 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
479 */
480static ANTLR3_INLINEinline
481void mT__20(pGDBMIOutputLexer ctx)
482{
483 ANTLR3_UINT32 _type;
484
485 _type = T__2020;
486
487
488 // GDBMIOutput.g:8:7: ( '{' )
489 // GDBMIOutput.g:8:9: '{'
490 {
491 MATCHC('{')ctx->pLexer->matchc(ctx->pLexer, '{');
492 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
493 {
494 goto ruleT__20Ex;
495 }
496
497
498 }
499
500 LEXSTATEctx->pLexer->rec->state->type = _type;
501
502 // This is where rules clean up and exit
503 //
504 goto ruleT__20Ex; /* Prevent compiler warnings */
505 ruleT__20Ex: ;
506
507}
508// $ANTLR end T__20
509
510// Comes from: 9:7: ( '}' )
511/** \brief Lexer rule generated by ANTLR3
512 *
513 * $ANTLR start T__21
514 *
515 * Looks to match the characters the constitute the token T__21
516 * from the attached input stream.
517 *
518 *
519 * \remark
520 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
521 */
522static ANTLR3_INLINEinline
523void mT__21(pGDBMIOutputLexer ctx)
524{
525 ANTLR3_UINT32 _type;
526
527 _type = T__2121;
528
529
530 // GDBMIOutput.g:9:7: ( '}' )
531 // GDBMIOutput.g:9:9: '}'
532 {
533 MATCHC('}')ctx->pLexer->matchc(ctx->pLexer, '}');
534 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
535 {
536 goto ruleT__21Ex;
537 }
538
539
540 }
541
542 LEXSTATEctx->pLexer->rec->state->type = _type;
543
544 // This is where rules clean up and exit
545 //
546 goto ruleT__21Ex; /* Prevent compiler warnings */
547 ruleT__21Ex: ;
548
549}
550// $ANTLR end T__21
551
552// Comes from: 10:7: ( '[]' )
553/** \brief Lexer rule generated by ANTLR3
554 *
555 * $ANTLR start T__22
556 *
557 * Looks to match the characters the constitute the token T__22
558 * from the attached input stream.
559 *
560 *
561 * \remark
562 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
563 */
564static ANTLR3_INLINEinline
565void mT__22(pGDBMIOutputLexer ctx)
566{
567 ANTLR3_UINT32 _type;
568
569 _type = T__2222;
570
571
572 // GDBMIOutput.g:10:7: ( '[]' )
573 // GDBMIOutput.g:10:9: '[]'
574 {
575 MATCHS(lit_2)ctx->pLexer->matchs(ctx->pLexer, lit_2);
576 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
577 {
578 goto ruleT__22Ex;
579 }
580
581
582
583 }
584
585 LEXSTATEctx->pLexer->rec->state->type = _type;
586
587 // This is where rules clean up and exit
588 //
589 goto ruleT__22Ex; /* Prevent compiler warnings */
590 ruleT__22Ex: ;
591
592}
593// $ANTLR end T__22
594
595// Comes from: 11:7: ( '[' )
596/** \brief Lexer rule generated by ANTLR3
597 *
598 * $ANTLR start T__23
599 *
600 * Looks to match the characters the constitute the token T__23
601 * from the attached input stream.
602 *
603 *
604 * \remark
605 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
606 */
607static ANTLR3_INLINEinline
608void mT__23(pGDBMIOutputLexer ctx)
609{
610 ANTLR3_UINT32 _type;
611
612 _type = T__2323;
613
614
615 // GDBMIOutput.g:11:7: ( '[' )
616 // GDBMIOutput.g:11:9: '['
617 {
618 MATCHC('[')ctx->pLexer->matchc(ctx->pLexer, '[');
619 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
620 {
621 goto ruleT__23Ex;
622 }
623
624
625 }
626
627 LEXSTATEctx->pLexer->rec->state->type = _type;
628
629 // This is where rules clean up and exit
630 //
631 goto ruleT__23Ex; /* Prevent compiler warnings */
632 ruleT__23Ex: ;
633
634}
635// $ANTLR end T__23
636
637// Comes from: 12:7: ( ']' )
638/** \brief Lexer rule generated by ANTLR3
639 *
640 * $ANTLR start T__24
641 *
642 * Looks to match the characters the constitute the token T__24
643 * from the attached input stream.
644 *
645 *
646 * \remark
647 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
648 */
649static ANTLR3_INLINEinline
650void mT__24(pGDBMIOutputLexer ctx)
651{
652 ANTLR3_UINT32 _type;
653
654 _type = T__2424;
655
656
657 // GDBMIOutput.g:12:7: ( ']' )
658 // GDBMIOutput.g:12:9: ']'
659 {
660 MATCHC(']')ctx->pLexer->matchc(ctx->pLexer, ']');
661 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
662 {
663 goto ruleT__24Ex;
664 }
665
666
667 }
668
669 LEXSTATEctx->pLexer->rec->state->type = _type;
670
671 // This is where rules clean up and exit
672 //
673 goto ruleT__24Ex; /* Prevent compiler warnings */
674 ruleT__24Ex: ;
675
676}
677// $ANTLR end T__24
678
679// Comes from: 202:10: ( '\"' ( '\\\\' '\"' | ~ ( '\"' | '\\n' | '\\r' ) )* '\"' )
680/** \brief Lexer rule generated by ANTLR3
681 *
682 * $ANTLR start C_STRING
683 *
684 * Looks to match the characters the constitute the token C_STRING
685 * from the attached input stream.
686 *
687 *
688 * \remark
689 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
690 */
691static ANTLR3_INLINEinline
692void mC_STRING(pGDBMIOutputLexer ctx)
693{
694 ANTLR3_UINT32 _type;
695
696 _type = C_STRING14;
697
698
699 // GDBMIOutput.g:202:10: ( '\"' ( '\\\\' '\"' | ~ ( '\"' | '\\n' | '\\r' ) )* '\"' )
700 // GDBMIOutput.g:202:12: '\"' ( '\\\\' '\"' | ~ ( '\"' | '\\n' | '\\r' ) )* '\"'
701 {
702 MATCHC('"')ctx->pLexer->matchc(ctx->pLexer, '"');
703 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
704 {
705 goto ruleC_STRINGEx;
706 }
707
708
709 // GDBMIOutput.g:202:16: ( '\\\\' '\"' | ~ ( '\"' | '\\n' | '\\r' ) )*
710
711 for (;;)
712 {
713 int alt1=3;
714 {
715 /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
716 */
717 int LA1_0 = LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
;
718 if ( (LA1_0 == '\\') )
719 {
720 {
721 /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
722 */
723 int LA1_2 = LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
;
724 if ( (LA1_2 == '"') )
725 {
726 {
727 /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
728 */
729 int LA1_4 = LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
;
730 if ( (((LA1_4 >= 0x0000) && (LA1_4 <= '\t')) || ((LA1_4 >= 0x000B) && (LA1_4 <= '\f')) || ((LA1_4 >= 0x000E) && (LA1_4 <= 0xFFFF))) )
731 {
732 alt1=1;
733 }
734
735
736 else
737 {
738 alt1=2;
739 }
740
741 }
742 }
743 else if ( (((LA1_2 >= 0x0000) && (LA1_2 <= '\t')) || ((LA1_2 >= 0x000B) && (LA1_2 <= '\f')) || ((LA1_2 >= 0x000E) && (LA1_2 <= '!')) || ((LA1_2 >= '#') && (LA1_2 <= 0xFFFF))) )
744 {
745 alt1=2;
746 }
747
748 }
749 }
750 else if ( (((LA1_0 >= 0x0000) && (LA1_0 <= '\t')) || ((LA1_0 >= 0x000B) && (LA1_0 <= '\f')) || ((LA1_0 >= 0x000E) && (LA1_0 <= '!')) || ((LA1_0 >= '#') && (LA1_0 <= '[')) || ((LA1_0 >= ']') && (LA1_0 <= 0xFFFF))) )
751 {
752 alt1=2;
753 }
754
755 }
756 switch (alt1)
757 {
758 case 1:
759 // GDBMIOutput.g:202:17: '\\\\' '\"'
760 {
761 MATCHC('\\')ctx->pLexer->matchc(ctx->pLexer, '\\');
762 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
763 {
764 goto ruleC_STRINGEx;
765 }
766
767 MATCHC('"')ctx->pLexer->matchc(ctx->pLexer, '"');
768 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
769 {
770 goto ruleC_STRINGEx;
771 }
772
773
774 }
775 break;
776 case 2:
777 // GDBMIOutput.g:202:27: ~ ( '\"' | '\\n' | '\\r' )
778 {
779 if ( ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 0x0000) && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '\t')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 0x000B) && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '\f')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 0x000E) && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '!')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= '#') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 0xFFFF)) )
780 {
781 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
782
783 }
784 else
785 {
786 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
787 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
788 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
789
790 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleC_STRINGEx;
791 }
792
793
794 }
795 break;
796
797 default:
798 goto loop1; /* break out of the loop */
799 break;
800 }
801 }
802 loop1: ; /* Jump out to here if this rule does not match */
803
804 MATCHC('"')ctx->pLexer->matchc(ctx->pLexer, '"');
805 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
806 {
807 goto ruleC_STRINGEx;
808 }
809
810
811 }
812
813 LEXSTATEctx->pLexer->rec->state->type = _type;
814
815 // This is where rules clean up and exit
816 //
817 goto ruleC_STRINGEx; /* Prevent compiler warnings */
818 ruleC_STRINGEx: ;
819
820}
821// $ANTLR end C_STRING
822
823// Comes from: 204:14: ( 'done' | 'running' | 'connected' | 'error' | 'exit' | 'stopped' | 'thread-group-added' | 'thread-group-started' | 'thread-group-created' | 'thread-created' | 'download' | 'thread-group-exited' | 'thread-exited' | 'loaded' | 'library-loaded' | 'library-unloaded' )
824/** \brief Lexer rule generated by ANTLR3
825 *
826 * $ANTLR start RESULT_CLASS
827 *
828 * Looks to match the characters the constitute the token RESULT_CLASS
829 * from the attached input stream.
830 *
831 *
832 * \remark
833 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
834 */
835static ANTLR3_INLINEinline
836void mRESULT_CLASS(pGDBMIOutputLexer ctx)
837{
838 ANTLR3_UINT32 _type;
839
840 _type = RESULT_CLASS6;
841
842
843 {
844 // GDBMIOutput.g:204:14: ( 'done' | 'running' | 'connected' | 'error' | 'exit' | 'stopped' | 'thread-group-added' | 'thread-group-started' | 'thread-group-created' | 'thread-created' | 'download' | 'thread-group-exited' | 'thread-exited' | 'loaded' | 'library-loaded' | 'library-unloaded' )
845
846 ANTLR3_UINT32 alt2;
847
848 alt2=16;
Value stored to 'alt2' is never read
849
850 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
851 {
852 case 'd':
853 {
854 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
855 {
856 case 'o':
857 {
858 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
859 {
860 case 'n':
861 {
862 alt2=1;
863 }
864 break;
865 case 'w':
866 {
867 alt2=11;
868 }
869 break;
870
871 default:
872 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
873 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
874 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
875 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
876 EXCEPTIONctx->pLexer->rec->state->exception->state = 8;
877
878
879 goto ruleRESULT_CLASSEx;
880 }
881
882 }
883 break;
884
885 default:
886 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
887 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
888 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
889 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
890 EXCEPTIONctx->pLexer->rec->state->exception->state = 1;
891
892
893 goto ruleRESULT_CLASSEx;
894 }
895
896 }
897 break;
898 case 'r':
899 {
900 alt2=2;
901 }
902 break;
903 case 'c':
904 {
905 alt2=3;
906 }
907 break;
908 case 'e':
909 {
910 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
911 {
912 case 'r':
913 {
914 alt2=4;
915 }
916 break;
917 case 'x':
918 {
919 alt2=5;
920 }
921 break;
922
923 default:
924 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
925 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
926 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
927 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
928 EXCEPTIONctx->pLexer->rec->state->exception->state = 4;
929
930
931 goto ruleRESULT_CLASSEx;
932 }
933
934 }
935 break;
936 case 's':
937 {
938 alt2=6;
939 }
940 break;
941 case 't':
942 {
943 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
944 {
945 case 'h':
946 {
947 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
948 {
949 case 'r':
950 {
951 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
952 {
953 case 'e':
954 {
955 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
956 {
957 case 'a':
958 {
959 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
960 {
961 case 'd':
962 {
963 switch ( LA(7)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 7)
)
964 {
965 case '-':
966 {
967 switch ( LA(8)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 8)
)
968 {
969 case 'g':
970 {
971 switch ( LA(9)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 9)
)
972 {
973 case 'r':
974 {
975 switch ( LA(10)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 10)
)
976 {
977 case 'o':
978 {
979 switch ( LA(11)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 11)
)
980 {
981 case 'u':
982 {
983 switch ( LA(12)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 12)
)
984 {
985 case 'p':
986 {
987 switch ( LA(13)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 13)
)
988 {
989 case '-':
990 {
991 switch ( LA(14)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 14)
)
992 {
993 case 'a':
994 {
995 alt2=7;
996 }
997 break;
998 case 's':
999 {
1000 alt2=8;
1001 }
1002 break;
1003 case 'c':
1004 {
1005 alt2=9;
1006 }
1007 break;
1008 case 'e':
1009 {
1010 alt2=12;
1011 }
1012 break;
1013
1014 default:
1015 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1016 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1017 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1018 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1019 EXCEPTIONctx->pLexer->rec->state->exception->state = 36;
1020
1021
1022 goto ruleRESULT_CLASSEx;
1023 }
1024
1025 }
1026 break;
1027
1028 default:
1029 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1030 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1031 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1032 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1033 EXCEPTIONctx->pLexer->rec->state->exception->state = 35;
1034
1035
1036 goto ruleRESULT_CLASSEx;
1037 }
1038
1039 }
1040 break;
1041
1042 default:
1043 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1044 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1045 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1046 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1047 EXCEPTIONctx->pLexer->rec->state->exception->state = 34;
1048
1049
1050 goto ruleRESULT_CLASSEx;
1051 }
1052
1053 }
1054 break;
1055
1056 default:
1057 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1058 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1059 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1060 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1061 EXCEPTIONctx->pLexer->rec->state->exception->state = 33;
1062
1063
1064 goto ruleRESULT_CLASSEx;
1065 }
1066
1067 }
1068 break;
1069
1070 default:
1071 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1072 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1073 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1074 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1075 EXCEPTIONctx->pLexer->rec->state->exception->state = 30;
1076
1077
1078 goto ruleRESULT_CLASSEx;
1079 }
1080
1081 }
1082 break;
1083
1084 default:
1085 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1086 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1087 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1088 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1089 EXCEPTIONctx->pLexer->rec->state->exception->state = 26;
1090
1091
1092 goto ruleRESULT_CLASSEx;
1093 }
1094
1095 }
1096 break;
1097 case 'c':
1098 {
1099 alt2=10;
1100 }
1101 break;
1102 case 'e':
1103 {
1104 alt2=13;
1105 }
1106 break;
1107
1108 default:
1109 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1110 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1111 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1112 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1113 EXCEPTIONctx->pLexer->rec->state->exception->state = 24;
1114
1115
1116 goto ruleRESULT_CLASSEx;
1117 }
1118
1119 }
1120 break;
1121
1122 default:
1123 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1124 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1125 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1126 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1127 EXCEPTIONctx->pLexer->rec->state->exception->state = 22;
1128
1129
1130 goto ruleRESULT_CLASSEx;
1131 }
1132
1133 }
1134 break;
1135
1136 default:
1137 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1138 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1139 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1140 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1141 EXCEPTIONctx->pLexer->rec->state->exception->state = 20;
1142
1143
1144 goto ruleRESULT_CLASSEx;
1145 }
1146
1147 }
1148 break;
1149
1150 default:
1151 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1152 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1153 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1154 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1155 EXCEPTIONctx->pLexer->rec->state->exception->state = 18;
1156
1157
1158 goto ruleRESULT_CLASSEx;
1159 }
1160
1161 }
1162 break;
1163
1164 default:
1165 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1166 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1167 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1168 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1169 EXCEPTIONctx->pLexer->rec->state->exception->state = 16;
1170
1171
1172 goto ruleRESULT_CLASSEx;
1173 }
1174
1175 }
1176 break;
1177
1178 default:
1179 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1180 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1181 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1182 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1183 EXCEPTIONctx->pLexer->rec->state->exception->state = 11;
1184
1185
1186 goto ruleRESULT_CLASSEx;
1187 }
1188
1189 }
1190 break;
1191
1192 default:
1193 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1194 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1195 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1196 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1197 EXCEPTIONctx->pLexer->rec->state->exception->state = 6;
1198
1199
1200 goto ruleRESULT_CLASSEx;
1201 }
1202
1203 }
1204 break;
1205 case 'l':
1206 {
1207 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
1208 {
1209 case 'o':
1210 {
1211 alt2=14;
1212 }
1213 break;
1214 case 'i':
1215 {
1216 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
1217 {
1218 case 'b':
1219 {
1220 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
1221 {
1222 case 'r':
1223 {
1224 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
1225 {
1226 case 'a':
1227 {
1228 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
1229 {
1230 case 'r':
1231 {
1232 switch ( LA(7)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 7)
)
1233 {
1234 case 'y':
1235 {
1236 switch ( LA(8)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 8)
)
1237 {
1238 case '-':
1239 {
1240 switch ( LA(9)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 9)
)
1241 {
1242 case 'l':
1243 {
1244 alt2=15;
1245 }
1246 break;
1247 case 'u':
1248 {
1249 alt2=16;
1250 }
1251 break;
1252
1253 default:
1254 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1255 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1256 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1257 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1258 EXCEPTIONctx->pLexer->rec->state->exception->state = 29;
1259
1260
1261 goto ruleRESULT_CLASSEx;
1262 }
1263
1264 }
1265 break;
1266
1267 default:
1268 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1269 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1270 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1271 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1272 EXCEPTIONctx->pLexer->rec->state->exception->state = 25;
1273
1274
1275 goto ruleRESULT_CLASSEx;
1276 }
1277
1278 }
1279 break;
1280
1281 default:
1282 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1283 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1284 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1285 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1286 EXCEPTIONctx->pLexer->rec->state->exception->state = 23;
1287
1288
1289 goto ruleRESULT_CLASSEx;
1290 }
1291
1292 }
1293 break;
1294
1295 default:
1296 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1297 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1298 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1299 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1300 EXCEPTIONctx->pLexer->rec->state->exception->state = 21;
1301
1302
1303 goto ruleRESULT_CLASSEx;
1304 }
1305
1306 }
1307 break;
1308
1309 default:
1310 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1311 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1312 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1313 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1314 EXCEPTIONctx->pLexer->rec->state->exception->state = 19;
1315
1316
1317 goto ruleRESULT_CLASSEx;
1318 }
1319
1320 }
1321 break;
1322
1323 default:
1324 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1325 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1326 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1327 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1328 EXCEPTIONctx->pLexer->rec->state->exception->state = 17;
1329
1330
1331 goto ruleRESULT_CLASSEx;
1332 }
1333
1334 }
1335 break;
1336
1337 default:
1338 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1339 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1340 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1341 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1342 EXCEPTIONctx->pLexer->rec->state->exception->state = 13;
1343
1344
1345 goto ruleRESULT_CLASSEx;
1346 }
1347
1348 }
1349 break;
1350
1351 default:
1352 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1353 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1354 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1355 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1356 EXCEPTIONctx->pLexer->rec->state->exception->state = 7;
1357
1358
1359 goto ruleRESULT_CLASSEx;
1360 }
1361
1362 }
1363 break;
1364
1365 default:
1366 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1367 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1368 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1369 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
1370 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
1371
1372
1373 goto ruleRESULT_CLASSEx;
1374 }
1375
1376 switch (alt2)
1377 {
1378 case 1:
1379 // GDBMIOutput.g:205:3: 'done'
1380 {
1381 MATCHS(lit_3)ctx->pLexer->matchs(ctx->pLexer, lit_3);
1382 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1383 {
1384 goto ruleRESULT_CLASSEx;
1385 }
1386
1387
1388
1389 }
1390 break;
1391 case 2:
1392 // GDBMIOutput.g:206:5: 'running'
1393 {
1394 MATCHS(lit_4)ctx->pLexer->matchs(ctx->pLexer, lit_4);
1395 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1396 {
1397 goto ruleRESULT_CLASSEx;
1398 }
1399
1400
1401
1402 }
1403 break;
1404 case 3:
1405 // GDBMIOutput.g:207:5: 'connected'
1406 {
1407 MATCHS(lit_5)ctx->pLexer->matchs(ctx->pLexer, lit_5);
1408 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1409 {
1410 goto ruleRESULT_CLASSEx;
1411 }
1412
1413
1414
1415 }
1416 break;
1417 case 4:
1418 // GDBMIOutput.g:208:5: 'error'
1419 {
1420 MATCHS(lit_6)ctx->pLexer->matchs(ctx->pLexer, lit_6);
1421 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1422 {
1423 goto ruleRESULT_CLASSEx;
1424 }
1425
1426
1427
1428 }
1429 break;
1430 case 5:
1431 // GDBMIOutput.g:209:5: 'exit'
1432 {
1433 MATCHS(lit_7)ctx->pLexer->matchs(ctx->pLexer, lit_7);
1434 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1435 {
1436 goto ruleRESULT_CLASSEx;
1437 }
1438
1439
1440
1441 }
1442 break;
1443 case 6:
1444 // GDBMIOutput.g:210:5: 'stopped'
1445 {
1446 MATCHS(lit_8)ctx->pLexer->matchs(ctx->pLexer, lit_8);
1447 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1448 {
1449 goto ruleRESULT_CLASSEx;
1450 }
1451
1452
1453
1454 }
1455 break;
1456 case 7:
1457 // GDBMIOutput.g:211:5: 'thread-group-added'
1458 {
1459 MATCHS(lit_9)ctx->pLexer->matchs(ctx->pLexer, lit_9);
1460 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1461 {
1462 goto ruleRESULT_CLASSEx;
1463 }
1464
1465
1466
1467 }
1468 break;
1469 case 8:
1470 // GDBMIOutput.g:212:5: 'thread-group-started'
1471 {
1472 MATCHS(lit_10)ctx->pLexer->matchs(ctx->pLexer, lit_10);
1473 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1474 {
1475 goto ruleRESULT_CLASSEx;
1476 }
1477
1478
1479
1480 }
1481 break;
1482 case 9:
1483 // GDBMIOutput.g:213:5: 'thread-group-created'
1484 {
1485 MATCHS(lit_11)ctx->pLexer->matchs(ctx->pLexer, lit_11);
1486 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1487 {
1488 goto ruleRESULT_CLASSEx;
1489 }
1490
1491
1492
1493 }
1494 break;
1495 case 10:
1496 // GDBMIOutput.g:214:5: 'thread-created'
1497 {
1498 MATCHS(lit_12)ctx->pLexer->matchs(ctx->pLexer, lit_12);
1499 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1500 {
1501 goto ruleRESULT_CLASSEx;
1502 }
1503
1504
1505
1506 }
1507 break;
1508 case 11:
1509 // GDBMIOutput.g:215:5: 'download'
1510 {
1511 MATCHS(lit_13)ctx->pLexer->matchs(ctx->pLexer, lit_13);
1512 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1513 {
1514 goto ruleRESULT_CLASSEx;
1515 }
1516
1517
1518
1519 }
1520 break;
1521 case 12:
1522 // GDBMIOutput.g:216:5: 'thread-group-exited'
1523 {
1524 MATCHS(lit_14)ctx->pLexer->matchs(ctx->pLexer, lit_14);
1525 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1526 {
1527 goto ruleRESULT_CLASSEx;
1528 }
1529
1530
1531
1532 }
1533 break;
1534 case 13:
1535 // GDBMIOutput.g:217:5: 'thread-exited'
1536 {
1537 MATCHS(lit_15)ctx->pLexer->matchs(ctx->pLexer, lit_15);
1538 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1539 {
1540 goto ruleRESULT_CLASSEx;
1541 }
1542
1543
1544
1545 }
1546 break;
1547 case 14:
1548 // GDBMIOutput.g:218:5: 'loaded'
1549 {
1550 MATCHS(lit_16)ctx->pLexer->matchs(ctx->pLexer, lit_16);
1551 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1552 {
1553 goto ruleRESULT_CLASSEx;
1554 }
1555
1556
1557
1558 }
1559 break;
1560 case 15:
1561 // GDBMIOutput.g:219:5: 'library-loaded'
1562 {
1563 MATCHS(lit_17)ctx->pLexer->matchs(ctx->pLexer, lit_17);
1564 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1565 {
1566 goto ruleRESULT_CLASSEx;
1567 }
1568
1569
1570
1571 }
1572 break;
1573 case 16:
1574 // GDBMIOutput.g:220:5: 'library-unloaded'
1575 {
1576 MATCHS(lit_18)ctx->pLexer->matchs(ctx->pLexer, lit_18);
1577 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1578 {
1579 goto ruleRESULT_CLASSEx;
1580 }
1581
1582
1583
1584 }
1585 break;
1586
1587 }
1588 }
1589 LEXSTATEctx->pLexer->rec->state->type = _type;
1590
1591 // This is where rules clean up and exit
1592 //
1593 goto ruleRESULT_CLASSEx; /* Prevent compiler warnings */
1594 ruleRESULT_CLASSEx: ;
1595
1596}
1597// $ANTLR end RESULT_CLASS
1598
1599// Comes from: 223:8: ( ( '_' | 'A' .. 'Z' | 'a' .. 'z' ) ( '-' | '_' | 'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' )* )
1600/** \brief Lexer rule generated by ANTLR3
1601 *
1602 * $ANTLR start STRING
1603 *
1604 * Looks to match the characters the constitute the token STRING
1605 * from the attached input stream.
1606 *
1607 *
1608 * \remark
1609 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1610 */
1611static ANTLR3_INLINEinline
1612void mSTRING(pGDBMIOutputLexer ctx)
1613{
1614 ANTLR3_UINT32 _type;
1615
1616 _type = STRING13;
1617
1618
1619 // GDBMIOutput.g:223:8: ( ( '_' | 'A' .. 'Z' | 'a' .. 'z' ) ( '-' | '_' | 'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' )* )
1620 // GDBMIOutput.g:224:3: ( '_' | 'A' .. 'Z' | 'a' .. 'z' ) ( '-' | '_' | 'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' )*
1621 {
1622 if ( ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 'A') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 'Z')) || LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== '_' || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 'a') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 'z')) )
1623 {
1624 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
1625
1626 }
1627 else
1628 {
1629 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1630 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
1631 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
1632
1633 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleSTRINGEx;
1634 }
1635
1636
1637 // GDBMIOutput.g:224:30: ( '-' | '_' | 'A' .. 'Z' | 'a' .. 'z' | '0' .. '9' )*
1638
1639 for (;;)
1640 {
1641 int alt3=2;
1642 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
1643 {
1644 case '-':
1645 case '0':
1646 case '1':
1647 case '2':
1648 case '3':
1649 case '4':
1650 case '5':
1651 case '6':
1652 case '7':
1653 case '8':
1654 case '9':
1655 case 'A':
1656 case 'B':
1657 case 'C':
1658 case 'D':
1659 case 'E':
1660 case 'F':
1661 case 'G':
1662 case 'H':
1663 case 'I':
1664 case 'J':
1665 case 'K':
1666 case 'L':
1667 case 'M':
1668 case 'N':
1669 case 'O':
1670 case 'P':
1671 case 'Q':
1672 case 'R':
1673 case 'S':
1674 case 'T':
1675 case 'U':
1676 case 'V':
1677 case 'W':
1678 case 'X':
1679 case 'Y':
1680 case 'Z':
1681 case '_':
1682 case 'a':
1683 case 'b':
1684 case 'c':
1685 case 'd':
1686 case 'e':
1687 case 'f':
1688 case 'g':
1689 case 'h':
1690 case 'i':
1691 case 'j':
1692 case 'k':
1693 case 'l':
1694 case 'm':
1695 case 'n':
1696 case 'o':
1697 case 'p':
1698 case 'q':
1699 case 'r':
1700 case 's':
1701 case 't':
1702 case 'u':
1703 case 'v':
1704 case 'w':
1705 case 'x':
1706 case 'y':
1707 case 'z':
1708 {
1709 alt3=1;
1710 }
1711 break;
1712
1713 }
1714
1715 switch (alt3)
1716 {
1717 case 1:
1718 // GDBMIOutput.g:
1719 {
1720 if ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== '-' || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= '0') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '9')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 'A') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 'Z')) || LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== '_' || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 'a') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 'z')) )
1721 {
1722 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
1723
1724 }
1725 else
1726 {
1727 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1728 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
1729 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
1730
1731 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleSTRINGEx;
1732 }
1733
1734
1735 }
1736 break;
1737
1738 default:
1739 goto loop3; /* break out of the loop */
1740 break;
1741 }
1742 }
1743 loop3: ; /* Jump out to here if this rule does not match */
1744
1745
1746 }
1747
1748 LEXSTATEctx->pLexer->rec->state->type = _type;
1749
1750 // This is where rules clean up and exit
1751 //
1752 goto ruleSTRINGEx; /* Prevent compiler warnings */
1753 ruleSTRINGEx: ;
1754
1755}
1756// $ANTLR end STRING
1757
1758// Comes from: 227:4: ( ( '\\r' )? '\\n' )
1759/** \brief Lexer rule generated by ANTLR3
1760 *
1761 * $ANTLR start NL
1762 *
1763 * Looks to match the characters the constitute the token NL
1764 * from the attached input stream.
1765 *
1766 *
1767 * \remark
1768 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1769 */
1770static ANTLR3_INLINEinline
1771void mNL(pGDBMIOutputLexer ctx)
1772{
1773 ANTLR3_UINT32 _type;
1774
1775 _type = NL9;
1776
1777
1778 // GDBMIOutput.g:227:4: ( ( '\\r' )? '\\n' )
1779 // GDBMIOutput.g:228:3: ( '\\r' )? '\\n'
1780 {
1781
1782 // GDBMIOutput.g:228:3: ( '\\r' )?
1783 {
1784 int alt4=2;
1785 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
1786 {
1787 case '\r':
1788 {
1789 alt4=1;
1790 }
1791 break;
1792 }
1793
1794 switch (alt4)
1795 {
1796 case 1:
1797 // GDBMIOutput.g:228:4: '\\r'
1798 {
1799 MATCHC('\r')ctx->pLexer->matchc(ctx->pLexer, '\r');
1800 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1801 {
1802 goto ruleNLEx;
1803 }
1804
1805
1806 }
1807 break;
1808
1809 }
1810 }
1811 MATCHC('\n')ctx->pLexer->matchc(ctx->pLexer, '\n');
1812 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1813 {
1814 goto ruleNLEx;
1815 }
1816
1817
1818 }
1819
1820 LEXSTATEctx->pLexer->rec->state->type = _type;
1821
1822 // This is where rules clean up and exit
1823 //
1824 goto ruleNLEx; /* Prevent compiler warnings */
1825 ruleNLEx: ;
1826
1827}
1828// $ANTLR end NL
1829
1830// Comes from: 231:4: ( ( ' ' | '\\t' ) )
1831/** \brief Lexer rule generated by ANTLR3
1832 *
1833 * $ANTLR start WS
1834 *
1835 * Looks to match the characters the constitute the token WS
1836 * from the attached input stream.
1837 *
1838 *
1839 * \remark
1840 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1841 */
1842static ANTLR3_INLINEinline
1843void mWS(pGDBMIOutputLexer ctx)
1844{
1845 ANTLR3_UINT32 _type;
1846
1847 _type = WS8;
1848
1849
1850 // GDBMIOutput.g:231:4: ( ( ' ' | '\\t' ) )
1851 // GDBMIOutput.g:232:3: ( ' ' | '\\t' )
1852 {
1853 if ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== '\t' || LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== ' ' )
1854 {
1855 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
1856
1857 }
1858 else
1859 {
1860 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1861 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
1862 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
1863
1864 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleWSEx;
1865 }
1866
1867
1868 }
1869
1870 LEXSTATEctx->pLexer->rec->state->type = _type;
1871
1872 // This is where rules clean up and exit
1873 //
1874 goto ruleWSEx; /* Prevent compiler warnings */
1875 ruleWSEx: ;
1876
1877}
1878// $ANTLR end WS
1879
1880// Comes from: 235:7: ( ( '0' .. '9' )+ )
1881/** \brief Lexer rule generated by ANTLR3
1882 *
1883 * $ANTLR start TOKEN
1884 *
1885 * Looks to match the characters the constitute the token TOKEN
1886 * from the attached input stream.
1887 *
1888 *
1889 * \remark
1890 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1891 */
1892static ANTLR3_INLINEinline
1893void mTOKEN(pGDBMIOutputLexer ctx)
1894{
1895 ANTLR3_UINT32 _type;
1896
1897 _type = TOKEN4;
1898
1899
1900 // GDBMIOutput.g:235:7: ( ( '0' .. '9' )+ )
1901 // GDBMIOutput.g:236:3: ( '0' .. '9' )+
1902 {
1903 // GDBMIOutput.g:236:3: ( '0' .. '9' )+
1904 {
1905 int cnt5=0;
1906
1907 for (;;)
1908 {
1909 int alt5=2;
1910 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
1911 {
1912 case '0':
1913 case '1':
1914 case '2':
1915 case '3':
1916 case '4':
1917 case '5':
1918 case '6':
1919 case '7':
1920 case '8':
1921 case '9':
1922 {
1923 alt5=1;
1924 }
1925 break;
1926
1927 }
1928
1929 switch (alt5)
1930 {
1931 case 1:
1932 // GDBMIOutput.g:236:4: '0' .. '9'
1933 {
1934 MATCHRANGE('0', '9')ctx->pLexer->matchRange(ctx->pLexer, '0', '9');
1935 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1936 {
1937 goto ruleTOKENEx;
1938 }
1939
1940
1941 }
1942 break;
1943
1944 default:
1945
1946 if ( cnt5 >= 1 )
1947 {
1948 goto loop5;
1949 }
1950 /* mismatchedSetEx()
1951 */
1952 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1953 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_EARLY_EXIT_EXCEPTION5;
1954 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_EARLY_EXIT_NAME"Early exit";
1955
1956
1957 goto ruleTOKENEx;
1958 }
1959 cnt5++;
1960 }
1961 loop5: ; /* Jump to here if this rule does not match */
1962 }
1963
1964 }
1965
1966 LEXSTATEctx->pLexer->rec->state->type = _type;
1967
1968 // This is where rules clean up and exit
1969 //
1970 goto ruleTOKENEx; /* Prevent compiler warnings */
1971 ruleTOKENEx: ;
1972
1973}
1974// $ANTLR end TOKEN
1975
1976// Comes from: 239:7: ( ',' )
1977/** \brief Lexer rule generated by ANTLR3
1978 *
1979 * $ANTLR start COMMA
1980 *
1981 * Looks to match the characters the constitute the token COMMA
1982 * from the attached input stream.
1983 *
1984 *
1985 * \remark
1986 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1987 */
1988static ANTLR3_INLINEinline
1989void mCOMMA(pGDBMIOutputLexer ctx)
1990{
1991 ANTLR3_UINT32 _type;
1992
1993 _type = COMMA7;
1994
1995
1996 // GDBMIOutput.g:239:7: ( ',' )
1997 // GDBMIOutput.g:240:3: ','
1998 {
1999 MATCHC(',')ctx->pLexer->matchc(ctx->pLexer, ',');
2000 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2001 {
2002 goto ruleCOMMAEx;
2003 }
2004
2005
2006 }
2007
2008 LEXSTATEctx->pLexer->rec->state->type = _type;
2009
2010 // This is where rules clean up and exit
2011 //
2012 goto ruleCOMMAEx; /* Prevent compiler warnings */
2013 ruleCOMMAEx: ;
2014
2015}
2016// $ANTLR end COMMA
2017
2018// Comes from: 243:5: ( '(gdb)' )
2019/** \brief Lexer rule generated by ANTLR3
2020 *
2021 * $ANTLR start EOM
2022 *
2023 * Looks to match the characters the constitute the token EOM
2024 * from the attached input stream.
2025 *
2026 *
2027 * \remark
2028 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2029 */
2030static ANTLR3_INLINEinline
2031void mEOM(pGDBMIOutputLexer ctx)
2032{
2033 ANTLR3_UINT32 _type;
2034
2035 _type = EOM18;
2036
2037
2038 // GDBMIOutput.g:243:5: ( '(gdb)' )
2039 // GDBMIOutput.g:244:3: '(gdb)'
2040 {
2041 MATCHS(lit_19)ctx->pLexer->matchs(ctx->pLexer, lit_19);
2042 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2043 {
2044 goto ruleEOMEx;
2045 }
2046
2047
2048
2049 }
2050
2051 LEXSTATEctx->pLexer->rec->state->type = _type;
2052
2053 // This is where rules clean up and exit
2054 //
2055 goto ruleEOMEx; /* Prevent compiler warnings */
2056 ruleEOMEx: ;
2057
2058}
2059// $ANTLR end EOM
2060
2061// Comes from: 247:9: ( '~' )
2062/** \brief Lexer rule generated by ANTLR3
2063 *
2064 * $ANTLR start CONSOLE
2065 *
2066 * Looks to match the characters the constitute the token CONSOLE
2067 * from the attached input stream.
2068 *
2069 *
2070 * \remark
2071 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2072 */
2073static ANTLR3_INLINEinline
2074void mCONSOLE(pGDBMIOutputLexer ctx)
2075{
2076 ANTLR3_UINT32 _type;
2077
2078 _type = CONSOLE15;
2079
2080
2081 // GDBMIOutput.g:247:9: ( '~' )
2082 // GDBMIOutput.g:248:3: '~'
2083 {
2084 MATCHC('~')ctx->pLexer->matchc(ctx->pLexer, '~');
2085 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2086 {
2087 goto ruleCONSOLEEx;
2088 }
2089
2090
2091 }
2092
2093 LEXSTATEctx->pLexer->rec->state->type = _type;
2094
2095 // This is where rules clean up and exit
2096 //
2097 goto ruleCONSOLEEx; /* Prevent compiler warnings */
2098 ruleCONSOLEEx: ;
2099
2100}
2101// $ANTLR end CONSOLE
2102
2103// Comes from: 250:9: ( '@' )
2104/** \brief Lexer rule generated by ANTLR3
2105 *
2106 * $ANTLR start TARGET
2107 *
2108 * Looks to match the characters the constitute the token TARGET
2109 * from the attached input stream.
2110 *
2111 *
2112 * \remark
2113 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2114 */
2115static ANTLR3_INLINEinline
2116void mTARGET(pGDBMIOutputLexer ctx)
2117{
2118 ANTLR3_UINT32 _type;
2119
2120 _type = TARGET16;
2121
2122
2123 // GDBMIOutput.g:250:9: ( '@' )
2124 // GDBMIOutput.g:251:3: '@'
2125 {
2126 MATCHC('@')ctx->pLexer->matchc(ctx->pLexer, '@');
2127 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2128 {
2129 goto ruleTARGETEx;
2130 }
2131
2132
2133 }
2134
2135 LEXSTATEctx->pLexer->rec->state->type = _type;
2136
2137 // This is where rules clean up and exit
2138 //
2139 goto ruleTARGETEx; /* Prevent compiler warnings */
2140 ruleTARGETEx: ;
2141
2142}
2143// $ANTLR end TARGET
2144
2145// Comes from: 253:5: ( '&' )
2146/** \brief Lexer rule generated by ANTLR3
2147 *
2148 * $ANTLR start LOG
2149 *
2150 * Looks to match the characters the constitute the token LOG
2151 * from the attached input stream.
2152 *
2153 *
2154 * \remark
2155 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2156 */
2157static ANTLR3_INLINEinline
2158void mLOG(pGDBMIOutputLexer ctx)
2159{
2160 ANTLR3_UINT32 _type;
2161
2162 _type = LOG17;
2163
2164
2165 // GDBMIOutput.g:253:5: ( '&' )
2166 // GDBMIOutput.g:254:3: '&'
2167 {
2168 MATCHC('&')ctx->pLexer->matchc(ctx->pLexer, '&');
2169 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2170 {
2171 goto ruleLOGEx;
2172 }
2173
2174
2175 }
2176
2177 LEXSTATEctx->pLexer->rec->state->type = _type;
2178
2179 // This is where rules clean up and exit
2180 //
2181 goto ruleLOGEx; /* Prevent compiler warnings */
2182 ruleLOGEx: ;
2183
2184}
2185// $ANTLR end LOG
2186
2187// Comes from: 257:6: ( '*' )
2188/** \brief Lexer rule generated by ANTLR3
2189 *
2190 * $ANTLR start EXEC
2191 *
2192 * Looks to match the characters the constitute the token EXEC
2193 * from the attached input stream.
2194 *
2195 *
2196 * \remark
2197 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2198 */
2199static ANTLR3_INLINEinline
2200void mEXEC(pGDBMIOutputLexer ctx)
2201{
2202 ANTLR3_UINT32 _type;
2203
2204 _type = EXEC10;
2205
2206
2207 // GDBMIOutput.g:257:6: ( '*' )
2208 // GDBMIOutput.g:258:3: '*'
2209 {
2210 MATCHC('*')ctx->pLexer->matchc(ctx->pLexer, '*');
2211 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2212 {
2213 goto ruleEXECEx;
2214 }
2215
2216
2217 }
2218
2219 LEXSTATEctx->pLexer->rec->state->type = _type;
2220
2221 // This is where rules clean up and exit
2222 //
2223 goto ruleEXECEx; /* Prevent compiler warnings */
2224 ruleEXECEx: ;
2225
2226}
2227// $ANTLR end EXEC
2228
2229// Comes from: 260:8: ( '+' )
2230/** \brief Lexer rule generated by ANTLR3
2231 *
2232 * $ANTLR start STATUS
2233 *
2234 * Looks to match the characters the constitute the token STATUS
2235 * from the attached input stream.
2236 *
2237 *
2238 * \remark
2239 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2240 */
2241static ANTLR3_INLINEinline
2242void mSTATUS(pGDBMIOutputLexer ctx)
2243{
2244 ANTLR3_UINT32 _type;
2245
2246 _type = STATUS11;
2247
2248
2249 // GDBMIOutput.g:260:8: ( '+' )
2250 // GDBMIOutput.g:261:3: '+'
2251 {
2252 MATCHC('+')ctx->pLexer->matchc(ctx->pLexer, '+');
2253 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2254 {
2255 goto ruleSTATUSEx;
2256 }
2257
2258
2259 }
2260
2261 LEXSTATEctx->pLexer->rec->state->type = _type;
2262
2263 // This is where rules clean up and exit
2264 //
2265 goto ruleSTATUSEx; /* Prevent compiler warnings */
2266 ruleSTATUSEx: ;
2267
2268}
2269// $ANTLR end STATUS
2270
2271// Comes from: 263:8: ( '=' )
2272/** \brief Lexer rule generated by ANTLR3
2273 *
2274 * $ANTLR start NOTIFY
2275 *
2276 * Looks to match the characters the constitute the token NOTIFY
2277 * from the attached input stream.
2278 *
2279 *
2280 * \remark
2281 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2282 */
2283static ANTLR3_INLINEinline
2284void mNOTIFY(pGDBMIOutputLexer ctx)
2285{
2286 ANTLR3_UINT32 _type;
2287
2288 _type = NOTIFY12;
2289
2290
2291 // GDBMIOutput.g:263:8: ( '=' )
2292 // GDBMIOutput.g:264:3: '='
2293 {
2294 MATCHC('=')ctx->pLexer->matchc(ctx->pLexer, '=');
2295 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2296 {
2297 goto ruleNOTIFYEx;
2298 }
2299
2300
2301 }
2302
2303 LEXSTATEctx->pLexer->rec->state->type = _type;
2304
2305 // This is where rules clean up and exit
2306 //
2307 goto ruleNOTIFYEx; /* Prevent compiler warnings */
2308 ruleNOTIFYEx: ;
2309
2310}
2311// $ANTLR end NOTIFY
2312
2313// Comes from: 267:8: ( '^' )
2314/** \brief Lexer rule generated by ANTLR3
2315 *
2316 * $ANTLR start RESULT
2317 *
2318 * Looks to match the characters the constitute the token RESULT
2319 * from the attached input stream.
2320 *
2321 *
2322 * \remark
2323 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2324 */
2325static ANTLR3_INLINEinline
2326void mRESULT(pGDBMIOutputLexer ctx)
2327{
2328 ANTLR3_UINT32 _type;
2329
2330 _type = RESULT5;
2331
2332
2333 // GDBMIOutput.g:267:8: ( '^' )
2334 // GDBMIOutput.g:268:3: '^'
2335 {
2336 MATCHC('^')ctx->pLexer->matchc(ctx->pLexer, '^');
2337 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2338 {
2339 goto ruleRESULTEx;
2340 }
2341
2342
2343 }
2344
2345 LEXSTATEctx->pLexer->rec->state->type = _type;
2346
2347 // This is where rules clean up and exit
2348 //
2349 goto ruleRESULTEx; /* Prevent compiler warnings */
2350 ruleRESULTEx: ;
2351
2352}
2353// $ANTLR end RESULT
2354
2355/** This is the entry point in to the lexer from an object that
2356 * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM
2357 */
2358static void
2359mTokens(pGDBMIOutputLexer ctx)
2360{
2361 {
2362 // GDBMIOutput.g:1:8: ( T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | C_STRING | RESULT_CLASS | STRING | NL | WS | TOKEN | COMMA | EOM | CONSOLE | TARGET | LOG | EXEC | STATUS | NOTIFY | RESULT )
2363
2364 ANTLR3_UINT32 alt6;
2365
2366 alt6=21;
2367
2368 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
2369 {
2370 case '{':
2371 {
2372 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
2373 {
2374 case '}':
2375 {
2376 alt6=1;
2377 }
2378 break;
2379
2380 default:
2381 alt6=2;}
2382
2383 }
2384 break;
2385 case '}':
2386 {
2387 alt6=3;
2388 }
2389 break;
2390 case '[':
2391 {
2392 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
2393 {
2394 case ']':
2395 {
2396 alt6=4;
2397 }
2398 break;
2399
2400 default:
2401 alt6=5;}
2402
2403 }
2404 break;
2405 case ']':
2406 {
2407 alt6=6;
2408 }
2409 break;
2410 case '"':
2411 {
2412 alt6=7;
2413 }
2414 break;
2415 case 'd':
2416 {
2417 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
2418 {
2419 case 'o':
2420 {
2421 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
2422 {
2423 case 'n':
2424 {
2425 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
2426 {
2427 case 'e':
2428 {
2429 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
2430 {
2431 case '-':
2432 case '0':
2433 case '1':
2434 case '2':
2435 case '3':
2436 case '4':
2437 case '5':
2438 case '6':
2439 case '7':
2440 case '8':
2441 case '9':
2442 case 'A':
2443 case 'B':
2444 case 'C':
2445 case 'D':
2446 case 'E':
2447 case 'F':
2448 case 'G':
2449 case 'H':
2450 case 'I':
2451 case 'J':
2452 case 'K':
2453 case 'L':
2454 case 'M':
2455 case 'N':
2456 case 'O':
2457 case 'P':
2458 case 'Q':
2459 case 'R':
2460 case 'S':
2461 case 'T':
2462 case 'U':
2463 case 'V':
2464 case 'W':
2465 case 'X':
2466 case 'Y':
2467 case 'Z':
2468 case '_':
2469 case 'a':
2470 case 'b':
2471 case 'c':
2472 case 'd':
2473 case 'e':
2474 case 'f':
2475 case 'g':
2476 case 'h':
2477 case 'i':
2478 case 'j':
2479 case 'k':
2480 case 'l':
2481 case 'm':
2482 case 'n':
2483 case 'o':
2484 case 'p':
2485 case 'q':
2486 case 'r':
2487 case 's':
2488 case 't':
2489 case 'u':
2490 case 'v':
2491 case 'w':
2492 case 'x':
2493 case 'y':
2494 case 'z':
2495 {
2496 alt6=9;
2497 }
2498 break;
2499
2500 default:
2501 alt6=8;}
2502
2503 }
2504 break;
2505
2506 default:
2507 alt6=9;}
2508
2509 }
2510 break;
2511 case 'w':
2512 {
2513 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
2514 {
2515 case 'n':
2516 {
2517 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
2518 {
2519 case 'l':
2520 {
2521 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
2522 {
2523 case 'o':
2524 {
2525 switch ( LA(7)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 7)
)
2526 {
2527 case 'a':
2528 {
2529 switch ( LA(8)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 8)
)
2530 {
2531 case 'd':
2532 {
2533 switch ( LA(9)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 9)
)
2534 {
2535 case '-':
2536 case '0':
2537 case '1':
2538 case '2':
2539 case '3':
2540 case '4':
2541 case '5':
2542 case '6':
2543 case '7':
2544 case '8':
2545 case '9':
2546 case 'A':
2547 case 'B':
2548 case 'C':
2549 case 'D':
2550 case 'E':
2551 case 'F':
2552 case 'G':
2553 case 'H':
2554 case 'I':
2555 case 'J':
2556 case 'K':
2557 case 'L':
2558 case 'M':
2559 case 'N':
2560 case 'O':
2561 case 'P':
2562 case 'Q':
2563 case 'R':
2564 case 'S':
2565 case 'T':
2566 case 'U':
2567 case 'V':
2568 case 'W':
2569 case 'X':
2570 case 'Y':
2571 case 'Z':
2572 case '_':
2573 case 'a':
2574 case 'b':
2575 case 'c':
2576 case 'd':
2577 case 'e':
2578 case 'f':
2579 case 'g':
2580 case 'h':
2581 case 'i':
2582 case 'j':
2583 case 'k':
2584 case 'l':
2585 case 'm':
2586 case 'n':
2587 case 'o':
2588 case 'p':
2589 case 'q':
2590 case 'r':
2591 case 's':
2592 case 't':
2593 case 'u':
2594 case 'v':
2595 case 'w':
2596 case 'x':
2597 case 'y':
2598 case 'z':
2599 {
2600 alt6=9;
2601 }
2602 break;
2603
2604 default:
2605 alt6=8;}
2606
2607 }
2608 break;
2609
2610 default:
2611 alt6=9;}
2612
2613 }
2614 break;
2615
2616 default:
2617 alt6=9;}
2618
2619 }
2620 break;
2621
2622 default:
2623 alt6=9;}
2624
2625 }
2626 break;
2627
2628 default:
2629 alt6=9;}
2630
2631 }
2632 break;
2633
2634 default:
2635 alt6=9;}
2636
2637 }
2638 break;
2639
2640 default:
2641 alt6=9;}
2642
2643 }
2644 break;
2645
2646 default:
2647 alt6=9;}
2648
2649 }
2650 break;
2651 case 'r':
2652 {
2653 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
2654 {
2655 case 'u':
2656 {
2657 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
2658 {
2659 case 'n':
2660 {
2661 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
2662 {
2663 case 'n':
2664 {
2665 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
2666 {
2667 case 'i':
2668 {
2669 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
2670 {
2671 case 'n':
2672 {
2673 switch ( LA(7)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 7)
)
2674 {
2675 case 'g':
2676 {
2677 switch ( LA(8)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 8)
)
2678 {
2679 case '-':
2680 case '0':
2681 case '1':
2682 case '2':
2683 case '3':
2684 case '4':
2685 case '5':
2686 case '6':
2687 case '7':
2688 case '8':
2689 case '9':
2690 case 'A':
2691 case 'B':
2692 case 'C':
2693 case 'D':
2694 case 'E':
2695 case 'F':
2696 case 'G':
2697 case 'H':
2698 case 'I':
2699 case 'J':
2700 case 'K':
2701 case 'L':
2702 case 'M':
2703 case 'N':
2704 case 'O':
2705 case 'P':
2706 case 'Q':
2707 case 'R':
2708 case 'S':
2709 case 'T':
2710 case 'U':
2711 case 'V':
2712 case 'W':
2713 case 'X':
2714 case 'Y':
2715 case 'Z':
2716 case '_':
2717 case 'a':
2718 case 'b':
2719 case 'c':
2720 case 'd':
2721 case 'e':
2722 case 'f':
2723 case 'g':
2724 case 'h':
2725 case 'i':
2726 case 'j':
2727 case 'k':
2728 case 'l':
2729 case 'm':
2730 case 'n':
2731 case 'o':
2732 case 'p':
2733 case 'q':
2734 case 'r':
2735 case 's':
2736 case 't':
2737 case 'u':
2738 case 'v':
2739 case 'w':
2740 case 'x':
2741 case 'y':
2742 case 'z':
2743 {
2744 alt6=9;
2745 }
2746 break;
2747
2748 default:
2749 alt6=8;}
2750
2751 }
2752 break;
2753
2754 default:
2755 alt6=9;}
2756
2757 }
2758 break;
2759
2760 default:
2761 alt6=9;}
2762
2763 }
2764 break;
2765
2766 default:
2767 alt6=9;}
2768
2769 }
2770 break;
2771
2772 default:
2773 alt6=9;}
2774
2775 }
2776 break;
2777
2778 default:
2779 alt6=9;}
2780
2781 }
2782 break;
2783
2784 default:
2785 alt6=9;}
2786
2787 }
2788 break;
2789 case 'c':
2790 {
2791 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
2792 {
2793 case 'o':
2794 {
2795 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
2796 {
2797 case 'n':
2798 {
2799 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
2800 {
2801 case 'n':
2802 {
2803 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
2804 {
2805 case 'e':
2806 {
2807 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
2808 {
2809 case 'c':
2810 {
2811 switch ( LA(7)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 7)
)
2812 {
2813 case 't':
2814 {
2815 switch ( LA(8)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 8)
)
2816 {
2817 case 'e':
2818 {
2819 switch ( LA(9)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 9)
)
2820 {
2821 case 'd':
2822 {
2823 switch ( LA(10)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 10)
)
2824 {
2825 case '-':
2826 case '0':
2827 case '1':
2828 case '2':
2829 case '3':
2830 case '4':
2831 case '5':
2832 case '6':
2833 case '7':
2834 case '8':
2835 case '9':
2836 case 'A':
2837 case 'B':
2838 case 'C':
2839 case 'D':
2840 case 'E':
2841 case 'F':
2842 case 'G':
2843 case 'H':
2844 case 'I':
2845 case 'J':
2846 case 'K':
2847 case 'L':
2848 case 'M':
2849 case 'N':
2850 case 'O':
2851 case 'P':
2852 case 'Q':
2853 case 'R':
2854 case 'S':
2855 case 'T':
2856 case 'U':
2857 case 'V':
2858 case 'W':
2859 case 'X':
2860 case 'Y':
2861 case 'Z':
2862 case '_':
2863 case 'a':
2864 case 'b':
2865 case 'c':
2866 case 'd':
2867 case 'e':
2868 case 'f':
2869 case 'g':
2870 case 'h':
2871 case 'i':
2872 case 'j':
2873 case 'k':
2874 case 'l':
2875 case 'm':
2876 case 'n':
2877 case 'o':
2878 case 'p':
2879 case 'q':
2880 case 'r':
2881 case 's':
2882 case 't':
2883 case 'u':
2884 case 'v':
2885 case 'w':
2886 case 'x':
2887 case 'y':
2888 case 'z':
2889 {
2890 alt6=9;
2891 }
2892 break;
2893
2894 default:
2895 alt6=8;}
2896
2897 }
2898 break;
2899
2900 default:
2901 alt6=9;}
2902
2903 }
2904 break;
2905
2906 default:
2907 alt6=9;}
2908
2909 }
2910 break;
2911
2912 default:
2913 alt6=9;}
2914
2915 }
2916 break;
2917
2918 default:
2919 alt6=9;}
2920
2921 }
2922 break;
2923
2924 default:
2925 alt6=9;}
2926
2927 }
2928 break;
2929
2930 default:
2931 alt6=9;}
2932
2933 }
2934 break;
2935
2936 default:
2937 alt6=9;}
2938
2939 }
2940 break;
2941
2942 default:
2943 alt6=9;}
2944
2945 }
2946 break;
2947 case 'e':
2948 {
2949 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
2950 {
2951 case 'r':
2952 {
2953 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
2954 {
2955 case 'r':
2956 {
2957 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
2958 {
2959 case 'o':
2960 {
2961 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
2962 {
2963 case 'r':
2964 {
2965 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
2966 {
2967 case '-':
2968 case '0':
2969 case '1':
2970 case '2':
2971 case '3':
2972 case '4':
2973 case '5':
2974 case '6':
2975 case '7':
2976 case '8':
2977 case '9':
2978 case 'A':
2979 case 'B':
2980 case 'C':
2981 case 'D':
2982 case 'E':
2983 case 'F':
2984 case 'G':
2985 case 'H':
2986 case 'I':
2987 case 'J':
2988 case 'K':
2989 case 'L':
2990 case 'M':
2991 case 'N':
2992 case 'O':
2993 case 'P':
2994 case 'Q':
2995 case 'R':
2996 case 'S':
2997 case 'T':
2998 case 'U':
2999 case 'V':
3000 case 'W':
3001 case 'X':
3002 case 'Y':
3003 case 'Z':
3004 case '_':
3005 case 'a':
3006 case 'b':
3007 case 'c':
3008 case 'd':
3009 case 'e':
3010 case 'f':
3011 case 'g':
3012 case 'h':
3013 case 'i':
3014 case 'j':
3015 case 'k':
3016 case 'l':
3017 case 'm':
3018 case 'n':
3019 case 'o':
3020 case 'p':
3021 case 'q':
3022 case 'r':
3023 case 's':
3024 case 't':
3025 case 'u':
3026 case 'v':
3027 case 'w':
3028 case 'x':
3029 case 'y':
3030 case 'z':
3031 {
3032 alt6=9;
3033 }
3034 break;
3035
3036 default:
3037 alt6=8;}
3038
3039 }
3040 break;
3041
3042 default:
3043 alt6=9;}
3044
3045 }
3046 break;
3047
3048 default:
3049 alt6=9;}
3050
3051 }
3052 break;
3053
3054 default:
3055 alt6=9;}
3056
3057 }
3058 break;
3059 case 'x':
3060 {
3061 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
3062 {
3063 case 'i':
3064 {
3065 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
3066 {
3067 case 't':
3068 {
3069 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
3070 {
3071 case '-':
3072 case '0':
3073 case '1':
3074 case '2':
3075 case '3':
3076 case '4':
3077 case '5':
3078 case '6':
3079 case '7':
3080 case '8':
3081 case '9':
3082 case 'A':
3083 case 'B':
3084 case 'C':
3085 case 'D':
3086 case 'E':
3087 case 'F':
3088 case 'G':
3089 case 'H':
3090 case 'I':
3091 case 'J':
3092 case 'K':
3093 case 'L':
3094 case 'M':
3095 case 'N':
3096 case 'O':
3097 case 'P':
3098 case 'Q':
3099 case 'R':
3100 case 'S':
3101 case 'T':
3102 case 'U':
3103 case 'V':
3104 case 'W':
3105 case 'X':
3106 case 'Y':
3107 case 'Z':
3108 case '_':
3109 case 'a':
3110 case 'b':
3111 case 'c':
3112 case 'd':
3113 case 'e':
3114 case 'f':
3115 case 'g':
3116 case 'h':
3117 case 'i':
3118 case 'j':
3119 case 'k':
3120 case 'l':
3121 case 'm':
3122 case 'n':
3123 case 'o':
3124 case 'p':
3125 case 'q':
3126 case 'r':
3127 case 's':
3128 case 't':
3129 case 'u':
3130 case 'v':
3131 case 'w':
3132 case 'x':
3133 case 'y':
3134 case 'z':
3135 {
3136 alt6=9;
3137 }
3138 break;
3139
3140 default:
3141 alt6=8;}
3142
3143 }
3144 break;
3145
3146 default:
3147 alt6=9;}
3148
3149 }
3150 break;
3151
3152 default:
3153 alt6=9;}
3154
3155 }
3156 break;
3157
3158 default:
3159 alt6=9;}
3160
3161 }
3162 break;
3163 case 's':
3164 {
3165 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
3166 {
3167 case 't':
3168 {
3169 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
3170 {
3171 case 'o':
3172 {
3173 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
3174 {
3175 case 'p':
3176 {
3177 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
3178 {
3179 case 'p':
3180 {
3181 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
3182 {
3183 case 'e':
3184 {
3185 switch ( LA(7)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 7)
)
3186 {
3187 case 'd':
3188 {
3189 switch ( LA(8)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 8)
)
3190 {
3191 case '-':
3192 case '0':
3193 case '1':
3194 case '2':
3195 case '3':
3196 case '4':
3197 case '5':
3198 case '6':
3199 case '7':
3200 case '8':
3201 case '9':
3202 case 'A':
3203 case 'B':
3204 case 'C':
3205 case 'D':
3206 case 'E':
3207 case 'F':
3208 case 'G':
3209 case 'H':
3210 case 'I':
3211 case 'J':
3212 case 'K':
3213 case 'L':
3214 case 'M':
3215 case 'N':
3216 case 'O':
3217 case 'P':
3218 case 'Q':
3219 case 'R':
3220 case 'S':
3221 case 'T':
3222 case 'U':
3223 case 'V':
3224 case 'W':
3225 case 'X':
3226 case 'Y':
3227 case 'Z':
3228 case '_':
3229 case 'a':
3230 case 'b':
3231 case 'c':
3232 case 'd':
3233 case 'e':
3234 case 'f':
3235 case 'g':
3236 case 'h':
3237 case 'i':
3238 case 'j':
3239 case 'k':
3240 case 'l':
3241 case 'm':
3242 case 'n':
3243 case 'o':
3244 case 'p':
3245 case 'q':
3246 case 'r':
3247 case 's':
3248 case 't':
3249 case 'u':
3250 case 'v':
3251 case 'w':
3252 case 'x':
3253 case 'y':
3254 case 'z':
3255 {
3256 alt6=9;
3257 }
3258 break;
3259
3260 default:
3261 alt6=8;}
3262
3263 }
3264 break;
3265
3266 default:
3267 alt6=9;}
3268
3269 }
3270 break;
3271
3272 default:
3273 alt6=9;}
3274
3275 }
3276 break;
3277
3278 default:
3279 alt6=9;}
3280
3281 }
3282 break;
3283
3284 default:
3285 alt6=9;}
3286
3287 }
3288 break;
3289
3290 default:
3291 alt6=9;}
3292
3293 }
3294 break;
3295
3296 default:
3297 alt6=9;}
3298
3299 }
3300 break;
3301 case 't':
3302 {
3303 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
3304 {
3305 case 'h':
3306 {
3307 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
3308 {
3309 case 'r':
3310 {
3311 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
3312 {
3313 case 'e':
3314 {
3315 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
3316 {
3317 case 'a':
3318 {
3319 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
3320 {
3321 case 'd':
3322 {
3323 switch ( LA(7)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 7)
)
3324 {
3325 case '-':
3326 {
3327 switch ( LA(8)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 8)
)
3328 {
3329 case 'g':
3330 {
3331 switch ( LA(9)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 9)
)
3332 {
3333 case 'r':
3334 {
3335 switch ( LA(10)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 10)
)
3336 {
3337 case 'o':
3338 {
3339 switch ( LA(11)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 11)
)
3340 {
3341 case 'u':
3342 {
3343 switch ( LA(12)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 12)
)
3344 {
3345 case 'p':
3346 {
3347 switch ( LA(13)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 13)
)
3348 {
3349 case '-':
3350 {
3351 switch ( LA(14)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 14)
)
3352 {
3353 case 'a':
3354 {
3355 switch ( LA(15)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 15)
)
3356 {
3357 case 'd':
3358 {
3359 switch ( LA(16)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 16)
)
3360 {
3361 case 'd':
3362 {
3363 switch ( LA(17)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 17)
)
3364 {
3365 case 'e':
3366 {
3367 switch ( LA(18)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 18)
)
3368 {
3369 case 'd':
3370 {
3371 switch ( LA(19)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 19)
)
3372 {
3373 case '-':
3374 case '0':
3375 case '1':
3376 case '2':
3377 case '3':
3378 case '4':
3379 case '5':
3380 case '6':
3381 case '7':
3382 case '8':
3383 case '9':
3384 case 'A':
3385 case 'B':
3386 case 'C':
3387 case 'D':
3388 case 'E':
3389 case 'F':
3390 case 'G':
3391 case 'H':
3392 case 'I':
3393 case 'J':
3394 case 'K':
3395 case 'L':
3396 case 'M':
3397 case 'N':
3398 case 'O':
3399 case 'P':
3400 case 'Q':
3401 case 'R':
3402 case 'S':
3403 case 'T':
3404 case 'U':
3405 case 'V':
3406 case 'W':
3407 case 'X':
3408 case 'Y':
3409 case 'Z':
3410 case '_':
3411 case 'a':
3412 case 'b':
3413 case 'c':
3414 case 'd':
3415 case 'e':
3416 case 'f':
3417 case 'g':
3418 case 'h':
3419 case 'i':
3420 case 'j':
3421 case 'k':
3422 case 'l':
3423 case 'm':
3424 case 'n':
3425 case 'o':
3426 case 'p':
3427 case 'q':
3428 case 'r':
3429 case 's':
3430 case 't':
3431 case 'u':
3432 case 'v':
3433 case 'w':
3434 case 'x':
3435 case 'y':
3436 case 'z':
3437 {
3438 alt6=9;
3439 }
3440 break;
3441
3442 default:
3443 alt6=8;}
3444
3445 }
3446 break;
3447
3448 default:
3449 alt6=9;}
3450
3451 }
3452 break;
3453
3454 default:
3455 alt6=9;}
3456
3457 }
3458 break;
3459
3460 default:
3461 alt6=9;}
3462
3463 }
3464 break;
3465
3466 default:
3467 alt6=9;}
3468
3469 }
3470 break;
3471 case 's':
3472 {
3473 switch ( LA(15)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 15)
)
3474 {
3475 case 't':
3476 {
3477 switch ( LA(16)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 16)
)
3478 {
3479 case 'a':
3480 {
3481 switch ( LA(17)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 17)
)
3482 {
3483 case 'r':
3484 {
3485 switch ( LA(18)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 18)
)
3486 {
3487 case 't':
3488 {
3489 switch ( LA(19)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 19)
)
3490 {
3491 case 'e':
3492 {
3493 switch ( LA(20)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 20)
)
3494 {
3495 case 'd':
3496 {
3497 switch ( LA(21)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 21)
)
3498 {
3499 case '-':
3500 case '0':
3501 case '1':
3502 case '2':
3503 case '3':
3504 case '4':
3505 case '5':
3506 case '6':
3507 case '7':
3508 case '8':
3509 case '9':
3510 case 'A':
3511 case 'B':
3512 case 'C':
3513 case 'D':
3514 case 'E':
3515 case 'F':
3516 case 'G':
3517 case 'H':
3518 case 'I':
3519 case 'J':
3520 case 'K':
3521 case 'L':
3522 case 'M':
3523 case 'N':
3524 case 'O':
3525 case 'P':
3526 case 'Q':
3527 case 'R':
3528 case 'S':
3529 case 'T':
3530 case 'U':
3531 case 'V':
3532 case 'W':
3533 case 'X':
3534 case 'Y':
3535 case 'Z':
3536 case '_':
3537 case 'a':
3538 case 'b':
3539 case 'c':
3540 case 'd':
3541 case 'e':
3542 case 'f':
3543 case 'g':
3544 case 'h':
3545 case 'i':
3546 case 'j':
3547 case 'k':
3548 case 'l':
3549 case 'm':
3550 case 'n':
3551 case 'o':
3552 case 'p':
3553 case 'q':
3554 case 'r':
3555 case 's':
3556 case 't':
3557 case 'u':
3558 case 'v':
3559 case 'w':
3560 case 'x':
3561 case 'y':
3562 case 'z':
3563 {
3564 alt6=9;
3565 }
3566 break;
3567
3568 default:
3569 alt6=8;}
3570
3571 }
3572 break;
3573
3574 default:
3575 alt6=9;}
3576
3577 }
3578 break;
3579
3580 default:
3581 alt6=9;}
3582
3583 }
3584 break;
3585
3586 default:
3587 alt6=9;}
3588
3589 }
3590 break;
3591
3592 default:
3593 alt6=9;}
3594
3595 }
3596 break;
3597
3598 default:
3599 alt6=9;}
3600
3601 }
3602 break;
3603
3604 default:
3605 alt6=9;}
3606
3607 }
3608 break;
3609 case 'c':
3610 {
3611 switch ( LA(15)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 15)
)
3612 {
3613 case 'r':
3614 {
3615 switch ( LA(16)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 16)
)
3616 {
3617 case 'e':
3618 {
3619 switch ( LA(17)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 17)
)
3620 {
3621 case 'a':
3622 {
3623 switch ( LA(18)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 18)
)
3624 {
3625 case 't':
3626 {
3627 switch ( LA(19)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 19)
)
3628 {
3629 case 'e':
3630 {
3631 switch ( LA(20)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 20)
)
3632 {
3633 case 'd':
3634 {
3635 switch ( LA(21)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 21)
)
3636 {
3637 case '-':
3638 case '0':
3639 case '1':
3640 case '2':
3641 case '3':
3642 case '4':
3643 case '5':
3644 case '6':
3645 case '7':
3646 case '8':
3647 case '9':
3648 case 'A':
3649 case 'B':
3650 case 'C':
3651 case 'D':
3652 case 'E':
3653 case 'F':
3654 case 'G':
3655 case 'H':
3656 case 'I':
3657 case 'J':
3658 case 'K':
3659 case 'L':
3660 case 'M':
3661 case 'N':
3662 case 'O':
3663 case 'P':
3664 case 'Q':
3665 case 'R':
3666 case 'S':
3667 case 'T':
3668 case 'U':
3669 case 'V':
3670 case 'W':
3671 case 'X':
3672 case 'Y':
3673 case 'Z':
3674 case '_':
3675 case 'a':
3676 case 'b':
3677 case 'c':
3678 case 'd':
3679 case 'e':
3680 case 'f':
3681 case 'g':
3682 case 'h':
3683 case 'i':
3684 case 'j':
3685 case 'k':
3686 case 'l':
3687 case 'm':
3688 case 'n':
3689 case 'o':
3690 case 'p':
3691 case 'q':
3692 case 'r':
3693 case 's':
3694 case 't':
3695 case 'u':
3696 case 'v':
3697 case 'w':
3698 case 'x':
3699 case 'y':
3700 case 'z':
3701 {
3702 alt6=9;
3703 }
3704 break;
3705
3706 default:
3707 alt6=8;}
3708
3709 }
3710 break;
3711
3712 default:
3713 alt6=9;}
3714
3715 }
3716 break;
3717
3718 default:
3719 alt6=9;}
3720
3721 }
3722 break;
3723
3724 default:
3725 alt6=9;}
3726
3727 }
3728 break;
3729
3730 default:
3731 alt6=9;}
3732
3733 }
3734 break;
3735
3736 default:
3737 alt6=9;}
3738
3739 }
3740 break;
3741
3742 default:
3743 alt6=9;}
3744
3745 }
3746 break;
3747 case 'e':
3748 {
3749 switch ( LA(15)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 15)
)
3750 {
3751 case 'x':
3752 {
3753 switch ( LA(16)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 16)
)
3754 {
3755 case 'i':
3756 {
3757 switch ( LA(17)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 17)
)
3758 {
3759 case 't':
3760 {
3761 switch ( LA(18)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 18)
)
3762 {
3763 case 'e':
3764 {
3765 switch ( LA(19)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 19)
)
3766 {
3767 case 'd':
3768 {
3769 switch ( LA(20)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 20)
)
3770 {
3771 case '-':
3772 case '0':
3773 case '1':
3774 case '2':
3775 case '3':
3776 case '4':
3777 case '5':
3778 case '6':
3779 case '7':
3780 case '8':
3781 case '9':
3782 case 'A':
3783 case 'B':
3784 case 'C':
3785 case 'D':
3786 case 'E':
3787 case 'F':
3788 case 'G':
3789 case 'H':
3790 case 'I':
3791 case 'J':
3792 case 'K':
3793 case 'L':
3794 case 'M':
3795 case 'N':
3796 case 'O':
3797 case 'P':
3798 case 'Q':
3799 case 'R':
3800 case 'S':
3801 case 'T':
3802 case 'U':
3803 case 'V':
3804 case 'W':
3805 case 'X':
3806 case 'Y':
3807 case 'Z':
3808 case '_':
3809 case 'a':
3810 case 'b':
3811 case 'c':
3812 case 'd':
3813 case 'e':
3814 case 'f':
3815 case 'g':
3816 case 'h':
3817 case 'i':
3818 case 'j':
3819 case 'k':
3820 case 'l':
3821 case 'm':
3822 case 'n':
3823 case 'o':
3824 case 'p':
3825 case 'q':
3826 case 'r':
3827 case 's':
3828 case 't':
3829 case 'u':
3830 case 'v':
3831 case 'w':
3832 case 'x':
3833 case 'y':
3834 case 'z':
3835 {
3836 alt6=9;
3837 }
3838 break;
3839
3840 default:
3841 alt6=8;}
3842
3843 }
3844 break;
3845
3846 default:
3847 alt6=9;}
3848
3849 }
3850 break;
3851
3852 default:
3853 alt6=9;}
3854
3855 }
3856 break;
3857
3858 default:
3859 alt6=9;}
3860
3861 }
3862 break;
3863
3864 default:
3865 alt6=9;}
3866
3867 }
3868 break;
3869
3870 default:
3871 alt6=9;}
3872
3873 }
3874 break;
3875
3876 default:
3877 alt6=9;}
3878
3879 }
3880 break;
3881
3882 default:
3883 alt6=9;}
3884
3885 }
3886 break;
3887
3888 default:
3889 alt6=9;}
3890
3891 }
3892 break;
3893
3894 default:
3895 alt6=9;}
3896
3897 }
3898 break;
3899
3900 default:
3901 alt6=9;}
3902
3903 }
3904 break;
3905
3906 default:
3907 alt6=9;}
3908
3909 }
3910 break;
3911 case 'c':
3912 {
3913 switch ( LA(9)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 9)
)
3914 {
3915 case 'r':
3916 {
3917 switch ( LA(10)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 10)
)
3918 {
3919 case 'e':
3920 {
3921 switch ( LA(11)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 11)
)
3922 {
3923 case 'a':
3924 {
3925 switch ( LA(12)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 12)
)
3926 {
3927 case 't':
3928 {
3929 switch ( LA(13)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 13)
)
3930 {
3931 case 'e':
3932 {
3933 switch ( LA(14)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 14)
)
3934 {
3935 case 'd':
3936 {
3937 switch ( LA(15)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 15)
)
3938 {
3939 case '-':
3940 case '0':
3941 case '1':
3942 case '2':
3943 case '3':
3944 case '4':
3945 case '5':
3946 case '6':
3947 case '7':
3948 case '8':
3949 case '9':
3950 case 'A':
3951 case 'B':
3952 case 'C':
3953 case 'D':
3954 case 'E':
3955 case 'F':
3956 case 'G':
3957 case 'H':
3958 case 'I':
3959 case 'J':
3960 case 'K':
3961 case 'L':
3962 case 'M':
3963 case 'N':
3964 case 'O':
3965 case 'P':
3966 case 'Q':
3967 case 'R':
3968 case 'S':
3969 case 'T':
3970 case 'U':
3971 case 'V':
3972 case 'W':
3973 case 'X':
3974 case 'Y':
3975 case 'Z':
3976 case '_':
3977 case 'a':
3978 case 'b':
3979 case 'c':
3980 case 'd':
3981 case 'e':
3982 case 'f':
3983 case 'g':
3984 case 'h':
3985 case 'i':
3986 case 'j':
3987 case 'k':
3988 case 'l':
3989 case 'm':
3990 case 'n':
3991 case 'o':
3992 case 'p':
3993 case 'q':
3994 case 'r':
3995 case 's':
3996 case 't':
3997 case 'u':
3998 case 'v':
3999 case 'w':
4000 case 'x':
4001 case 'y':
4002 case 'z':
4003 {
4004 alt6=9;
4005 }
4006 break;
4007
4008 default:
4009 alt6=8;}
4010
4011 }
4012 break;
4013
4014 default:
4015 alt6=9;}
4016
4017 }
4018 break;
4019
4020 default:
4021 alt6=9;}
4022
4023 }
4024 break;
4025
4026 default:
4027 alt6=9;}
4028
4029 }
4030 break;
4031
4032 default:
4033 alt6=9;}
4034
4035 }
4036 break;
4037
4038 default:
4039 alt6=9;}
4040
4041 }
4042 break;
4043
4044 default:
4045 alt6=9;}
4046
4047 }
4048 break;
4049 case 'e':
4050 {
4051 switch ( LA(9)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 9)
)
4052 {
4053 case 'x':
4054 {
4055 switch ( LA(10)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 10)
)
4056 {
4057 case 'i':
4058 {
4059 switch ( LA(11)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 11)
)
4060 {
4061 case 't':
4062 {
4063 switch ( LA(12)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 12)
)
4064 {
4065 case 'e':
4066 {
4067 switch ( LA(13)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 13)
)
4068 {
4069 case 'd':
4070 {
4071 switch ( LA(14)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 14)
)
4072 {
4073 case '-':
4074 case '0':
4075 case '1':
4076 case '2':
4077 case '3':
4078 case '4':
4079 case '5':
4080 case '6':
4081 case '7':
4082 case '8':
4083 case '9':
4084 case 'A':
4085 case 'B':
4086 case 'C':
4087 case 'D':
4088 case 'E':
4089 case 'F':
4090 case 'G':
4091 case 'H':
4092 case 'I':
4093 case 'J':
4094 case 'K':
4095 case 'L':
4096 case 'M':
4097 case 'N':
4098 case 'O':
4099 case 'P':
4100 case 'Q':
4101 case 'R':
4102 case 'S':
4103 case 'T':
4104 case 'U':
4105 case 'V':
4106 case 'W':
4107 case 'X':
4108 case 'Y':
4109 case 'Z':
4110 case '_':
4111 case 'a':
4112 case 'b':
4113 case 'c':
4114 case 'd':
4115 case 'e':
4116 case 'f':
4117 case 'g':
4118 case 'h':
4119 case 'i':
4120 case 'j':
4121 case 'k':
4122 case 'l':
4123 case 'm':
4124 case 'n':
4125 case 'o':
4126 case 'p':
4127 case 'q':
4128 case 'r':
4129 case 's':
4130 case 't':
4131 case 'u':
4132 case 'v':
4133 case 'w':
4134 case 'x':
4135 case 'y':
4136 case 'z':
4137 {
4138 alt6=9;
4139 }
4140 break;
4141
4142 default:
4143 alt6=8;}
4144
4145 }
4146 break;
4147
4148 default:
4149 alt6=9;}
4150
4151 }
4152 break;
4153
4154 default:
4155 alt6=9;}
4156
4157 }
4158 break;
4159
4160 default:
4161 alt6=9;}
4162
4163 }
4164 break;
4165
4166 default:
4167 alt6=9;}
4168
4169 }
4170 break;
4171
4172 default:
4173 alt6=9;}
4174
4175 }
4176 break;
4177
4178 default:
4179 alt6=9;}
4180
4181 }
4182 break;
4183
4184 default:
4185 alt6=9;}
4186
4187 }
4188 break;
4189
4190 default:
4191 alt6=9;}
4192
4193 }
4194 break;
4195
4196 default:
4197 alt6=9;}
4198
4199 }
4200 break;
4201
4202 default:
4203 alt6=9;}
4204
4205 }
4206 break;
4207
4208 default:
4209 alt6=9;}
4210
4211 }
4212 break;
4213
4214 default:
4215 alt6=9;}
4216
4217 }
4218 break;
4219 case 'l':
4220 {
4221 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
4222 {
4223 case 'o':
4224 {
4225 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
4226 {
4227 case 'a':
4228 {
4229 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
4230 {
4231 case 'd':
4232 {
4233 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
4234 {
4235 case 'e':
4236 {
4237 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
4238 {
4239 case 'd':
4240 {
4241 switch ( LA(7)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 7)
)
4242 {
4243 case '-':
4244 case '0':
4245 case '1':
4246 case '2':
4247 case '3':
4248 case '4':
4249 case '5':
4250 case '6':
4251 case '7':
4252 case '8':
4253 case '9':
4254 case 'A':
4255 case 'B':
4256 case 'C':
4257 case 'D':
4258 case 'E':
4259 case 'F':
4260 case 'G':
4261 case 'H':
4262 case 'I':
4263 case 'J':
4264 case 'K':
4265 case 'L':
4266 case 'M':
4267 case 'N':
4268 case 'O':
4269 case 'P':
4270 case 'Q':
4271 case 'R':
4272 case 'S':
4273 case 'T':
4274 case 'U':
4275 case 'V':
4276 case 'W':
4277 case 'X':
4278 case 'Y':
4279 case 'Z':
4280 case '_':
4281 case 'a':
4282 case 'b':
4283 case 'c':
4284 case 'd':
4285 case 'e':
4286 case 'f':
4287 case 'g':
4288 case 'h':
4289 case 'i':
4290 case 'j':
4291 case 'k':
4292 case 'l':
4293 case 'm':
4294 case 'n':
4295 case 'o':
4296 case 'p':
4297 case 'q':
4298 case 'r':
4299 case 's':
4300 case 't':
4301 case 'u':
4302 case 'v':
4303 case 'w':
4304 case 'x':
4305 case 'y':
4306 case 'z':
4307 {
4308 alt6=9;
4309 }
4310 break;
4311
4312 default:
4313 alt6=8;}
4314
4315 }
4316 break;
4317
4318 default:
4319 alt6=9;}
4320
4321 }
4322 break;
4323
4324 default:
4325 alt6=9;}
4326
4327 }
4328 break;
4329
4330 default:
4331 alt6=9;}
4332
4333 }
4334 break;
4335
4336 default:
4337 alt6=9;}
4338
4339 }
4340 break;
4341 case 'i':
4342 {
4343 switch ( LA(3)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 3)
)
4344 {
4345 case 'b':
4346 {
4347 switch ( LA(4)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 4)
)
4348 {
4349 case 'r':
4350 {
4351 switch ( LA(5)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 5)
)
4352 {
4353 case 'a':
4354 {
4355 switch ( LA(6)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 6)
)
4356 {
4357 case 'r':
4358 {
4359 switch ( LA(7)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 7)
)
4360 {
4361 case 'y':
4362 {
4363 switch ( LA(8)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 8)
)
4364 {
4365 case '-':
4366 {
4367 switch ( LA(9)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 9)
)
4368 {
4369 case 'l':
4370 {
4371 switch ( LA(10)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 10)
)
4372 {
4373 case 'o':
4374 {
4375 switch ( LA(11)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 11)
)
4376 {
4377 case 'a':
4378 {
4379 switch ( LA(12)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 12)
)
4380 {
4381 case 'd':
4382 {
4383 switch ( LA(13)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 13)
)
4384 {
4385 case 'e':
4386 {
4387 switch ( LA(14)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 14)
)
4388 {
4389 case 'd':
4390 {
4391 switch ( LA(15)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 15)
)
4392 {
4393 case '-':
4394 case '0':
4395 case '1':
4396 case '2':
4397 case '3':
4398 case '4':
4399 case '5':
4400 case '6':
4401 case '7':
4402 case '8':
4403 case '9':
4404 case 'A':
4405 case 'B':
4406 case 'C':
4407 case 'D':
4408 case 'E':
4409 case 'F':
4410 case 'G':
4411 case 'H':
4412 case 'I':
4413 case 'J':
4414 case 'K':
4415 case 'L':
4416 case 'M':
4417 case 'N':
4418 case 'O':
4419 case 'P':
4420 case 'Q':
4421 case 'R':
4422 case 'S':
4423 case 'T':
4424 case 'U':
4425 case 'V':
4426 case 'W':
4427 case 'X':
4428 case 'Y':
4429 case 'Z':
4430 case '_':
4431 case 'a':
4432 case 'b':
4433 case 'c':
4434 case 'd':
4435 case 'e':
4436 case 'f':
4437 case 'g':
4438 case 'h':
4439 case 'i':
4440 case 'j':
4441 case 'k':
4442 case 'l':
4443 case 'm':
4444 case 'n':
4445 case 'o':
4446 case 'p':
4447 case 'q':
4448 case 'r':
4449 case 's':
4450 case 't':
4451 case 'u':
4452 case 'v':
4453 case 'w':
4454 case 'x':
4455 case 'y':
4456 case 'z':
4457 {
4458 alt6=9;
4459 }
4460 break;
4461
4462 default:
4463 alt6=8;}
4464
4465 }
4466 break;
4467
4468 default:
4469 alt6=9;}
4470
4471 }
4472 break;
4473
4474 default:
4475 alt6=9;}
4476
4477 }
4478 break;
4479
4480 default:
4481 alt6=9;}
4482
4483 }
4484 break;
4485
4486 default:
4487 alt6=9;}
4488
4489 }
4490 break;
4491
4492 default:
4493 alt6=9;}
4494
4495 }
4496 break;
4497 case 'u':
4498 {
4499 switch ( LA(10)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 10)
)
4500 {
4501 case 'n':
4502 {
4503 switch ( LA(11)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 11)
)
4504 {
4505 case 'l':
4506 {
4507 switch ( LA(12)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 12)
)
4508 {
4509 case 'o':
4510 {
4511 switch ( LA(13)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 13)
)
4512 {
4513 case 'a':
4514 {
4515 switch ( LA(14)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 14)
)
4516 {
4517 case 'd':
4518 {
4519 switch ( LA(15)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 15)
)
4520 {
4521 case 'e':
4522 {
4523 switch ( LA(16)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 16)
)
4524 {
4525 case 'd':
4526 {
4527 switch ( LA(17)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 17)
)
4528 {
4529 case '-':
4530 case '0':
4531 case '1':
4532 case '2':
4533 case '3':
4534 case '4':
4535 case '5':
4536 case '6':
4537 case '7':
4538 case '8':
4539 case '9':
4540 case 'A':
4541 case 'B':
4542 case 'C':
4543 case 'D':
4544 case 'E':
4545 case 'F':
4546 case 'G':
4547 case 'H':
4548 case 'I':
4549 case 'J':
4550 case 'K':
4551 case 'L':
4552 case 'M':
4553 case 'N':
4554 case 'O':
4555 case 'P':
4556 case 'Q':
4557 case 'R':
4558 case 'S':
4559 case 'T':
4560 case 'U':
4561 case 'V':
4562 case 'W':
4563 case 'X':
4564 case 'Y':
4565 case 'Z':
4566 case '_':
4567 case 'a':
4568 case 'b':
4569 case 'c':
4570 case 'd':
4571 case 'e':
4572 case 'f':
4573 case 'g':
4574 case 'h':
4575 case 'i':
4576 case 'j':
4577 case 'k':
4578 case 'l':
4579 case 'm':
4580 case 'n':
4581 case 'o':
4582 case 'p':
4583 case 'q':
4584 case 'r':
4585 case 's':
4586 case 't':
4587 case 'u':
4588 case 'v':
4589 case 'w':
4590 case 'x':
4591 case 'y':
4592 case 'z':
4593 {
4594 alt6=9;
4595 }
4596 break;
4597
4598 default:
4599 alt6=8;}
4600
4601 }
4602 break;
4603
4604 default:
4605 alt6=9;}
4606
4607 }
4608 break;
4609
4610 default:
4611 alt6=9;}
4612
4613 }
4614 break;
4615
4616 default:
4617 alt6=9;}
4618
4619 }
4620 break;
4621
4622 default:
4623 alt6=9;}
4624
4625 }
4626 break;
4627
4628 default:
4629 alt6=9;}
4630
4631 }
4632 break;
4633
4634 default:
4635 alt6=9;}
4636
4637 }
4638 break;
4639
4640 default:
4641 alt6=9;}
4642
4643 }
4644 break;
4645
4646 default:
4647 alt6=9;}
4648
4649 }
4650 break;
4651
4652 default:
4653 alt6=9;}
4654
4655 }
4656 break;
4657
4658 default:
4659 alt6=9;}
4660
4661 }
4662 break;
4663
4664 default:
4665 alt6=9;}
4666
4667 }
4668 break;
4669
4670 default:
4671 alt6=9;}
4672
4673 }
4674 break;
4675
4676 default:
4677 alt6=9;}
4678
4679 }
4680 break;
4681
4682 default:
4683 alt6=9;}
4684
4685 }
4686 break;
4687
4688 default:
4689 alt6=9;}
4690
4691 }
4692 break;
4693 case 'A':
4694 case 'B':
4695 case 'C':
4696 case 'D':
4697 case 'E':
4698 case 'F':
4699 case 'G':
4700 case 'H':
4701 case 'I':
4702 case 'J':
4703 case 'K':
4704 case 'L':
4705 case 'M':
4706 case 'N':
4707 case 'O':
4708 case 'P':
4709 case 'Q':
4710 case 'R':
4711 case 'S':
4712 case 'T':
4713 case 'U':
4714 case 'V':
4715 case 'W':
4716 case 'X':
4717 case 'Y':
4718 case 'Z':
4719 case '_':
4720 case 'a':
4721 case 'b':
4722 case 'f':
4723 case 'g':
4724 case 'h':
4725 case 'i':
4726 case 'j':
4727 case 'k':
4728 case 'm':
4729 case 'n':
4730 case 'o':
4731 case 'p':
4732 case 'q':
4733 case 'u':
4734 case 'v':
4735 case 'w':
4736 case 'x':
4737 case 'y':
4738 case 'z':
4739 {
4740 alt6=9;
4741 }
4742 break;
4743 case '\n':
4744 case '\r':
4745 {
4746 alt6=10;
4747 }
4748 break;
4749 case '\t':
4750 case ' ':
4751 {
4752 alt6=11;
4753 }
4754 break;
4755 case '0':
4756 case '1':
4757 case '2':
4758 case '3':
4759 case '4':
4760 case '5':
4761 case '6':
4762 case '7':
4763 case '8':
4764 case '9':
4765 {
4766 alt6=12;
4767 }
4768 break;
4769 case ',':
4770 {
4771 alt6=13;
4772 }
4773 break;
4774 case '(':
4775 {
4776 alt6=14;
4777 }
4778 break;
4779 case '~':
4780 {
4781 alt6=15;
4782 }
4783 break;
4784 case '@':
4785 {
4786 alt6=16;
4787 }
4788 break;
4789 case '&':
4790 {
4791 alt6=17;
4792 }
4793 break;
4794 case '*':
4795 {
4796 alt6=18;
4797 }
4798 break;
4799 case '+':
4800 {
4801 alt6=19;
4802 }
4803 break;
4804 case '=':
4805 {
4806 alt6=20;
4807 }
4808 break;
4809 case '^':
4810 {
4811 alt6=21;
4812 }
4813 break;
4814
4815 default:
4816 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
4817 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
4818 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
4819 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 6;
4820 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
4821
4822
4823 goto ruleTokensEx;
4824 }
4825
4826 switch (alt6)
4827 {
4828 case 1:
4829 // GDBMIOutput.g:1:10: T__19
4830 {
4831 /* 1:10: T__19 */
4832 mT__19(ctx );
4833 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4834 {
4835 goto ruleTokensEx;
4836 }
4837
4838
4839 }
4840 break;
4841 case 2:
4842 // GDBMIOutput.g:1:16: T__20
4843 {
4844 /* 1:16: T__20 */
4845 mT__20(ctx );
4846 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4847 {
4848 goto ruleTokensEx;
4849 }
4850
4851
4852 }
4853 break;
4854 case 3:
4855 // GDBMIOutput.g:1:22: T__21
4856 {
4857 /* 1:22: T__21 */
4858 mT__21(ctx );
4859 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4860 {
4861 goto ruleTokensEx;
4862 }
4863
4864
4865 }
4866 break;
4867 case 4:
4868 // GDBMIOutput.g:1:28: T__22
4869 {
4870 /* 1:28: T__22 */
4871 mT__22(ctx );
4872 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4873 {
4874 goto ruleTokensEx;
4875 }
4876
4877
4878 }
4879 break;
4880 case 5:
4881 // GDBMIOutput.g:1:34: T__23
4882 {
4883 /* 1:34: T__23 */
4884 mT__23(ctx );
4885 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4886 {
4887 goto ruleTokensEx;
4888 }
4889
4890
4891 }
4892 break;
4893 case 6:
4894 // GDBMIOutput.g:1:40: T__24
4895 {
4896 /* 1:40: T__24 */
4897 mT__24(ctx );
4898 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4899 {
4900 goto ruleTokensEx;
4901 }
4902
4903
4904 }
4905 break;
4906 case 7:
4907 // GDBMIOutput.g:1:46: C_STRING
4908 {
4909 /* 1:46: C_STRING */
4910 mC_STRING(ctx );
4911 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4912 {
4913 goto ruleTokensEx;
4914 }
4915
4916
4917 }
4918 break;
4919 case 8:
4920 // GDBMIOutput.g:1:55: RESULT_CLASS
4921 {
4922 /* 1:55: RESULT_CLASS */
4923 mRESULT_CLASS(ctx );
4924 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4925 {
4926 goto ruleTokensEx;
4927 }
4928
4929
4930 }
4931 break;
4932 case 9:
4933 // GDBMIOutput.g:1:68: STRING
4934 {
4935 /* 1:68: STRING */
4936 mSTRING(ctx );
4937 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4938 {
4939 goto ruleTokensEx;
4940 }
4941
4942
4943 }
4944 break;
4945 case 10:
4946 // GDBMIOutput.g:1:75: NL
4947 {
4948 /* 1:75: NL */
4949 mNL(ctx );
4950 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4951 {
4952 goto ruleTokensEx;
4953 }
4954
4955
4956 }
4957 break;
4958 case 11:
4959 // GDBMIOutput.g:1:78: WS
4960 {
4961 /* 1:78: WS */
4962 mWS(ctx );
4963 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4964 {
4965 goto ruleTokensEx;
4966 }
4967
4968
4969 }
4970 break;
4971 case 12:
4972 // GDBMIOutput.g:1:81: TOKEN
4973 {
4974 /* 1:81: TOKEN */
4975 mTOKEN(ctx );
4976 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4977 {
4978 goto ruleTokensEx;
4979 }
4980
4981
4982 }
4983 break;
4984 case 13:
4985 // GDBMIOutput.g:1:87: COMMA
4986 {
4987 /* 1:87: COMMA */
4988 mCOMMA(ctx );
4989 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4990 {
4991 goto ruleTokensEx;
4992 }
4993
4994
4995 }
4996 break;
4997 case 14:
4998 // GDBMIOutput.g:1:93: EOM
4999 {
5000 /* 1:93: EOM */
5001 mEOM(ctx );
5002 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5003 {
5004 goto ruleTokensEx;
5005 }
5006
5007
5008 }
5009 break;
5010 case 15:
5011 // GDBMIOutput.g:1:97: CONSOLE
5012 {
5013 /* 1:97: CONSOLE */
5014 mCONSOLE(ctx );
5015 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5016 {
5017 goto ruleTokensEx;
5018 }
5019
5020
5021 }
5022 break;
5023 case 16:
5024 // GDBMIOutput.g:1:105: TARGET
5025 {
5026 /* 1:105: TARGET */
5027 mTARGET(ctx );
5028 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5029 {
5030 goto ruleTokensEx;
5031 }
5032
5033
5034 }
5035 break;
5036 case 17:
5037 // GDBMIOutput.g:1:112: LOG
5038 {
5039 /* 1:112: LOG */
5040 mLOG(ctx );
5041 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5042 {
5043 goto ruleTokensEx;
5044 }
5045
5046
5047 }
5048 break;
5049 case 18:
5050 // GDBMIOutput.g:1:116: EXEC
5051 {
5052 /* 1:116: EXEC */
5053 mEXEC(ctx );
5054 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5055 {
5056 goto ruleTokensEx;
5057 }
5058
5059
5060 }
5061 break;
5062 case 19:
5063 // GDBMIOutput.g:1:121: STATUS
5064 {
5065 /* 1:121: STATUS */
5066 mSTATUS(ctx );
5067 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5068 {
5069 goto ruleTokensEx;
5070 }
5071
5072
5073 }
5074 break;
5075 case 20:
5076 // GDBMIOutput.g:1:128: NOTIFY
5077 {
5078 /* 1:128: NOTIFY */
5079 mNOTIFY(ctx );
5080 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5081 {
5082 goto ruleTokensEx;
5083 }
5084
5085
5086 }
5087 break;
5088 case 21:
5089 // GDBMIOutput.g:1:135: RESULT
5090 {
5091 /* 1:135: RESULT */
5092 mRESULT(ctx );
5093 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5094 {
5095 goto ruleTokensEx;
5096 }
5097
5098
5099 }
5100 break;
5101
5102 }
5103 }
5104
5105
5106 goto ruleTokensEx; /* Prevent compiler warnings */
5107ruleTokensEx: ;
5108}
5109
5110/* =========================================================================
5111 * Lexer matching rules end.
5112 * =========================================================================
5113 */
5114/* End of Lexer code
5115 * ================================================
5116 * ================================================
5117 */
5118
5119
5120/* End of code
5121 * =============================================================================
5122 */