Bug Summary

File:OMCompiler/Parser/ParModelica_Lexer.c
Warning:line 1775, column 9
Value stored to 'alt1' 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 : ParModelica_Lexer.g
5 * - On : 2020-02-01 17:31:26
6 * - for the lexer : ParModelica_LexerLexer *
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 "ParModelica_Lexer.h"
46/* ----------------------------------------- */
47
48
49/** String literals used by ParModelica_Lexer 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[] = { 0x70, 0x61, 0x72, 0x66, 0x6F, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
56static ANTLR3_UCHAR lit_2[] = { 0x70, 0x61, 0x72, 0x61, 0x6C, 0x6C, 0x65, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
57static ANTLR3_UCHAR lit_3[] = { 0x70, 0x61, 0x72, 0x6C, 0x6F, 0x63, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
58static ANTLR3_UCHAR lit_4[] = { 0x70, 0x61, 0x72, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
59static ANTLR3_UCHAR lit_5[] = { 0x70, 0x61, 0x72, 0x6B, 0x65, 0x72, 0x6E, 0x65, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
60static ANTLR3_UCHAR lit_6[] = { 0x65, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
61static ANTLR3_UCHAR lit_7[] = { 0x3C, 0x3D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
62static ANTLR3_UCHAR lit_8[] = { 0x3C, 0x3E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
63static ANTLR3_UCHAR lit_9[] = { 0x3E, 0x3D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
64static ANTLR3_UCHAR lit_10[] = { 0x3D, 0x3D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
65static ANTLR3_UCHAR lit_11[] = { 0x2E, 0x2B, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
66static ANTLR3_UCHAR lit_12[] = { 0x2E, 0x2D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
67static ANTLR3_UCHAR lit_13[] = { 0x2E, 0x2A, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
68static ANTLR3_UCHAR lit_14[] = { 0x2E, 0x2F, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
69static ANTLR3_UCHAR lit_15[] = { 0x2E, 0x5E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
70static ANTLR3_UCHAR lit_16[] = { 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
71static ANTLR3_UCHAR lit_17[] = { 0x69, 0x6D, 0x70, 0x75, 0x72, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
72
73
74
75
76/* MACROS that hide the C interface implementations from the
77 * generated code, which makes it a little more understandable to the human eye.
78 * I am very much against using C pre-processor macros for function calls and bits
79 * of code as you cannot see what is happening when single stepping in debuggers
80 * and so on. The exception (in my book at least) is for generated code, where you are
81 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
82 * hides some indirect calls, but is always referring to the input stream. This is
83 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
84 * the runtime interfaces without changing the generated code too often, without
85 * confusing the reader of the generated output, who may not wish to know the gory
86 * details of the interface inheritance.
87 */
88
89#define CTXctx ctx
90
91/* Aids in accessing scopes for grammar programmers
92 */
93#undef SCOPE_TYPE
94#undef SCOPE_STACK
95#undef SCOPE_TOP
96#define SCOPE_TYPE(scope)pParModelica_Lexer_scope_SCOPE pParModelica_Lexer_##scope##_SCOPE
97#define SCOPE_STACK(scope)pParModelica_Lexer_scopeStack pParModelica_Lexer_##scope##Stack
98#define SCOPE_TOP(scope)ctx->pParModelica_Lexer_scopeTop ctx->pParModelica_Lexer_##scope##Top
99#define SCOPE_SIZE(scope)ctx->pParModelica_Lexer_scopeStack_limit ctx->pParModelica_Lexer_##scope##Stack_limit
100#define SCOPE_INSTANCE(scope, i)(ctx->pParModelica_Lexer_scopeStack->get(ctx->pParModelica_Lexer_scopeStack
,i))
(ctx->SCOPE_STACK(scope)pParModelica_Lexer_scopeStack->get(ctx->SCOPE_STACK(scope)pParModelica_Lexer_scopeStack,i))
101
102
103/* Macros for accessing things in a lexer
104 */
105#undef LEXERctx->pLexer
106#undef RECOGNIZERctx->pLexer->rec
107#undef RULEMEMOctx->pLexer->rec->state->ruleMemo
108#undef GETCHARINDEX
109#undef GETLINE
110#undef GETCHARPOSITIONINLINE
111#undef EMIT
112#undef EMITNEW
113#undef MATCHC
114#undef MATCHS
115#undef MATCHRANGE
116#undef LTOKENctx->pLexer->rec->state->token
117#undef HASFAILED
118#undef FAILEDFLAGctx->pLexer->rec->state->failed
119#undef INPUTctx->pLexer->input
120#undef STRSTREAMctx->pLexer->input
121#undef LA
122#undef HASEXCEPTION
123#undef EXCEPTIONctx->pLexer->rec->state->exception
124#undef CONSTRUCTEX
125#undef CONSUME
126#undef LRECOVER
127#undef MARK
128#undef REWIND
129#undef REWINDLAST
130#undef BACKTRACKINGctx->pLexer->rec->state->backtracking
131#undef MATCHANY
132#undef MEMOIZE
133#undef HAVEPARSEDRULE
134#undef GETTEXT
135#undef INDEX
136#undef SEEK
137#undef PUSHSTREAM
138#undef POPSTREAM
139#undef SETTEXT
140#undef SETTEXT8
141
142#define LEXERctx->pLexer ctx->pLexer
143#define RECOGNIZERctx->pLexer->rec LEXERctx->pLexer->rec
144#define LEXSTATEctx->pLexer->rec->state RECOGNIZERctx->pLexer->rec->state
145#define TOKSOURCEctx->pLexer->rec->state->tokSource LEXSTATEctx->pLexer->rec->state->tokSource
146#define GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer) LEXERctx->pLexer->getCharIndex(LEXERctx->pLexer)
147#define GETLINE()ctx->pLexer->getLine(ctx->pLexer) LEXERctx->pLexer->getLine(LEXERctx->pLexer)
148#define GETTEXT()ctx->pLexer->getText(ctx->pLexer) LEXERctx->pLexer->getText(LEXERctx->pLexer)
149#define GETCHARPOSITIONINLINE()ctx->pLexer->getCharPositionInLine(ctx->pLexer) LEXERctx->pLexer->getCharPositionInLine(LEXERctx->pLexer)
150#define EMIT()ctx->pLexer->rec->state->type = _type; ctx->pLexer
->emit(ctx->pLexer)
LEXSTATEctx->pLexer->rec->state->type = _type; LEXERctx->pLexer->emit(LEXERctx->pLexer)
151#define EMITNEW(t)ctx->pLexer->emitNew(ctx->pLexer, t) LEXERctx->pLexer->emitNew(LEXERctx->pLexer, t)
152#define MATCHC(c)ctx->pLexer->matchc(ctx->pLexer, c) LEXERctx->pLexer->matchc(LEXERctx->pLexer, c)
153#define MATCHS(s)ctx->pLexer->matchs(ctx->pLexer, s) LEXERctx->pLexer->matchs(LEXERctx->pLexer, s)
154#define MATCHRANGE(c1,c2)ctx->pLexer->matchRange(ctx->pLexer, c1, c2) LEXERctx->pLexer->matchRange(LEXERctx->pLexer, c1, c2)
155#define MATCHANY()ctx->pLexer->matchAny(ctx->pLexer) LEXERctx->pLexer->matchAny(LEXERctx->pLexer)
156#define LTOKENctx->pLexer->rec->state->token LEXSTATEctx->pLexer->rec->state->token
157#define HASFAILED()(ctx->pLexer->rec->state->failed == 1) (LEXSTATEctx->pLexer->rec->state->failed == ANTLR3_TRUE1)
158#define BACKTRACKINGctx->pLexer->rec->state->backtracking LEXSTATEctx->pLexer->rec->state->backtracking
159#define FAILEDFLAGctx->pLexer->rec->state->failed LEXSTATEctx->pLexer->rec->state->failed
160#define INPUTctx->pLexer->input LEXERctx->pLexer->input
161#define STRSTREAMctx->pLexer->input INPUTctx->pLexer->input
162#define ISTREAMctx->pLexer->input->istream INPUTctx->pLexer->input->istream
163#define INDEX()ctx->pLexer->input->istream->index(ctx->pLexer
->input->istream)
ISTREAMctx->pLexer->input->istream->index(ISTREAMctx->pLexer->input->istream)
164#define SEEK(n)ctx->pLexer->input->istream->seek(ctx->pLexer->
input->istream, n)
ISTREAMctx->pLexer->input->istream->seek(ISTREAMctx->pLexer->input->istream, n)
165#define EOF_TOKEN&(ctx->pLexer->rec->state->tokSource->eofToken
)
&(LEXSTATEctx->pLexer->rec->state->tokSource->eofToken)
166#define HASEXCEPTION()(ctx->pLexer->rec->state->error == 1) (LEXSTATEctx->pLexer->rec->state->error == ANTLR3_TRUE1)
167#define EXCEPTIONctx->pLexer->rec->state->exception LEXSTATEctx->pLexer->rec->state->exception
168#define CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
RECOGNIZERctx->pLexer->rec->exConstruct(RECOGNIZERctx->pLexer->rec)
169#define LRECOVER()ctx->pLexer->recover(ctx->pLexer) LEXERctx->pLexer->recover(LEXERctx->pLexer)
170#define MARK()ctx->pLexer->input->istream->mark(ctx->pLexer->
input->istream)
ISTREAMctx->pLexer->input->istream->mark(ISTREAMctx->pLexer->input->istream)
171#define REWIND(m)ctx->pLexer->input->istream->rewind(ctx->pLexer
->input->istream, m)
ISTREAMctx->pLexer->input->istream->rewind(ISTREAMctx->pLexer->input->istream, m)
172#define REWINDLAST()ctx->pLexer->input->istream->rewindLast(ctx->pLexer
->input->istream)
ISTREAMctx->pLexer->input->istream->rewindLast(ISTREAMctx->pLexer->input->istream)
173#define MEMOIZE(ri,si)ctx->pLexer->rec->memoize(ctx->pLexer->rec, ri
, si)
RECOGNIZERctx->pLexer->rec->memoize(RECOGNIZERctx->pLexer->rec, ri, si)
174#define HAVEPARSEDRULE(r)ctx->pLexer->rec->alreadyParsedRule(ctx->pLexer->
rec, r)
RECOGNIZERctx->pLexer->rec->alreadyParsedRule(RECOGNIZERctx->pLexer->rec, r)
175#define PUSHSTREAM(str)ctx->pLexer->pushCharStream(ctx->pLexer, str) LEXERctx->pLexer->pushCharStream(LEXERctx->pLexer, str)
176#define POPSTREAM()ctx->pLexer->popCharStream(ctx->pLexer) LEXERctx->pLexer->popCharStream(LEXERctx->pLexer)
177#define SETTEXT(str)ctx->pLexer->rec->state->text = str LEXSTATEctx->pLexer->rec->state->text = str
178#define SKIP()ctx->pLexer->rec->state->token = &(ctx->pLexer
->rec->state->tokSource->skipToken)
LEXSTATEctx->pLexer->rec->state->token = &(TOKSOURCEctx->pLexer->rec->state->tokSource->skipToken)
179#define USER1ctx->pLexer->rec->state->user1 LEXSTATEctx->pLexer->rec->state->user1
180#define USER2ctx->pLexer->rec->state->user2 LEXSTATEctx->pLexer->rec->state->user2
181#define USER3ctx->pLexer->rec->state->user3 LEXSTATEctx->pLexer->rec->state->user3
182#define CUSTOMctx->pLexer->rec->state->custom LEXSTATEctx->pLexer->rec->state->custom
183#define RULEMEMOctx->pLexer->rec->state->ruleMemo LEXSTATEctx->pLexer->rec->state->ruleMemo
184#define DBGctx->pLexer->rec->debugger RECOGNIZERctx->pLexer->rec->debugger
185
186/* If we have been told we can rely on the standard 8 bit or 16 bit input
187 * stream, then we can define our macros to use the direct pointers
188 * in the input object, which is much faster than indirect calls. This
189 * is really only significant to lexers with a lot of fragment rules (which
190 * do not place LA(1) in a temporary at the moment) and even then
191 * only if there is a lot of input (order of say 1M or so).
192 */
193#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
194
195# ifdef ANTLR3_INLINE_INPUT_ASCII
196
197/* 8 bit "ASCII" (actually any 8 bit character set) */
198
199# define NEXTCHAR ((pANTLR3_UINT8)(INPUTctx->pLexer->input->nextChar))
200# define DATAP ((pANTLR3_UINT8)(INPUTctx->pLexer->input->data))
201
202# else
203
204# define NEXTCHAR ((pANTLR3_UINT16)(INPUTctx->pLexer->input->nextChar))
205# define DATAP ((pANTLR3_UINT16)(INPUTctx->pLexer->input->data))
206
207# endif
208
209# 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)))
210# define CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
\
211{ \
212 if (NEXTCHAR < (DATAP + INPUTctx->pLexer->input->sizeBuf)) \
213 { \
214 INPUTctx->pLexer->input->charPositionInLine++; \
215 if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUTctx->pLexer->input->newlineChar) \
216 { \
217 INPUTctx->pLexer->input->line++; \
218 INPUTctx->pLexer->input->charPositionInLine = 0; \
219 INPUTctx->pLexer->input->currentLine = (void *)(NEXTCHAR + 1); \
220 } \
221 INPUTctx->pLexer->input->nextChar = (void *)(NEXTCHAR + 1); \
222 } \
223}
224
225#else
226
227// Pick up the input character by calling the input stream implementation.
228//
229#define CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
INPUTctx->pLexer->input->istream->consume(INPUTctx->pLexer->input->istream)
230#define LA(n)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, n)
INPUTctx->pLexer->input->istream->_LA(INPUTctx->pLexer->input->istream, n)
231
232#endif
233#define TOKTEXT(tok, txt)tok, (pANTLR3_UINT8)txt tok, (pANTLR3_UINT8)txt
234
235/* The 4 tokens defined below may well clash with your own #defines or token types. If so
236 * then for the present you must use different names for your defines as these are hard coded
237 * in the code generator. It would be better not to use such names internally, and maybe
238 * we can change this in a forthcoming release. I deliberately do not #undef these
239 * here as this will at least give you a redefined error somewhere if they clash.
240 */
241#define UP3 ANTLR3_TOKEN_UP3
242#define DOWN2 ANTLR3_TOKEN_DOWN2
243#define EORANTLR3_TOKEN_EOR ANTLR3_TOKEN_EOR
244#define INVALID0 ANTLR3_TOKEN_INVALID0
245
246
247/* =============================================================================
248 * Functions to create and destroy scopes. First come the rule scopes, followed
249 * by the global declared scopes.
250 */
251
252
253
254/* ============================================================================= */
255
256/* =============================================================================
257 * Start of recognizer
258 */
259
260
261/* Forward declare the locally static matching functions we have generated and any predicate functions.
262 */
263static ANTLR3_INLINE__inline__ void mPARFOR (pParModelica_Lexer ctx);
264static ANTLR3_INLINE__inline__ void mT_PARALLEL (pParModelica_Lexer ctx);
265static ANTLR3_INLINE__inline__ void mT_LOCAL (pParModelica_Lexer ctx);
266static ANTLR3_INLINE__inline__ void mT_GLOBAL (pParModelica_Lexer ctx);
267static ANTLR3_INLINE__inline__ void mT_KERNEL (pParModelica_Lexer ctx);
268static ANTLR3_INLINE__inline__ void mEND_PARFOR (pParModelica_Lexer ctx);
269static ANTLR3_INLINE__inline__ void mSTAR (pParModelica_Lexer ctx);
270static ANTLR3_INLINE__inline__ void mMINUS (pParModelica_Lexer ctx);
271static ANTLR3_INLINE__inline__ void mPLUS (pParModelica_Lexer ctx);
272static ANTLR3_INLINE__inline__ void mLESS (pParModelica_Lexer ctx);
273static ANTLR3_INLINE__inline__ void mLESSEQ (pParModelica_Lexer ctx);
274static ANTLR3_INLINE__inline__ void mLESSGT (pParModelica_Lexer ctx);
275static ANTLR3_INLINE__inline__ void mGREATER (pParModelica_Lexer ctx);
276static ANTLR3_INLINE__inline__ void mGREATEREQ (pParModelica_Lexer ctx);
277static ANTLR3_INLINE__inline__ void mEQEQ (pParModelica_Lexer ctx);
278static ANTLR3_INLINE__inline__ void mPOWER (pParModelica_Lexer ctx);
279static ANTLR3_INLINE__inline__ void mSLASH (pParModelica_Lexer ctx);
280static ANTLR3_INLINE__inline__ void mPLUS_EW (pParModelica_Lexer ctx);
281static ANTLR3_INLINE__inline__ void mMINUS_EW (pParModelica_Lexer ctx);
282static ANTLR3_INLINE__inline__ void mSTAR_EW (pParModelica_Lexer ctx);
283static ANTLR3_INLINE__inline__ void mSLASH_EW (pParModelica_Lexer ctx);
284static ANTLR3_INLINE__inline__ void mPOWER_EW (pParModelica_Lexer ctx);
285static ANTLR3_INLINE__inline__ void mSTREAM (pParModelica_Lexer ctx);
286static ANTLR3_INLINE__inline__ void mIMPURE (pParModelica_Lexer ctx);
287static ANTLR3_INLINE__inline__ void mTokens (pParModelica_Lexer ctx);
288static void ParModelica_LexerFree(pParModelica_Lexer ctx);
289
290/* =========================================================================
291 * Lexer matching rules end.
292 * =========================================================================
293 */
294
295
296
297static void
298ParModelica_LexerFree (pParModelica_Lexer ctx)
299{
300 // Free the lexers that we delegated to
301 // functions to. NULL the state so we only free it once.
302 //
303 ctx->gBaseModelica_Lexer->pLexer->rec->state = NULL((void*)0);
304 ctx->gBaseModelica_Lexer->free(ctx->gBaseModelica_Lexer); LEXERctx->pLexer->free(LEXERctx->pLexer);
305
306 ANTLR3_FREE(ctx)free ((void *)(ctx));
307}
308
309/** \brief Name of the grammar file that generated this code
310 */
311static const char fileName[] = "ParModelica_Lexer.g";
312
313/** \brief Return the name of the grammar file that generated this code.
314 */
315static const char * getGrammarFileName()
316{
317 return fileName;
318}
319
320/** \brief Create a new lexer called ParModelica_Lexer
321 *
322 * \param[in] instream Pointer to an initialized input stream
323 * \return
324 * - Success pParModelica_Lexer initialized for the lex start
325 * - Fail NULL
326 */
327ANTLR3_API pParModelica_Lexer ParModelica_LexerNew
328(pANTLR3_INPUT_STREAM instream)
329{
330 // See if we can create a new lexer with the standard constructor
331 //
332 return ParModelica_LexerNewSSD(instream, NULL((void*)0));
333}
334
335/** \brief Create a new lexer called ParModelica_Lexer
336 *
337 * \param[in] instream Pointer to an initialized input stream
338 * \param[state] state Previously created shared recognizer stat
339 * \return
340 * - Success pParModelica_Lexer initialized for the lex start
341 * - Fail NULL
342 */
343ANTLR3_API pParModelica_Lexer ParModelica_LexerNewSSD
344(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
345{
346 pParModelica_Lexer ctx; // Context structure we will build and return
347
348 ctx = (pParModelica_Lexer) ANTLR3_CALLOC(1, sizeof(ParModelica_Lexer))calloc (1, (size_t)(sizeof(ParModelica_Lexer)));;
349
350 if (ctx == NULL((void*)0))
351 {
352 // Failed to allocate memory for lexer context
353 return NULL((void*)0);
354 }
355
356 /* -------------------------------------------------------------------
357 * Memory for basic structure is allocated, now to fill in
358 * in base ANTLR3 structures. We initialize the function pointers
359 * for the standard ANTLR3 lexer function set, but upon return
360 * from here, the programmer may set the pointers to provide custom
361 * implementations of each function.
362 *
363 * We don't use the macros defined in ParModelica_Lexer.h here so you can get a sense
364 * of what goes where.
365 */
366
367 /* Create a base lexer, using the supplied input stream
368 */
369 ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT2049, instream, state);
370
371 /* Check that we allocated the memory correctly
372 */
373 if (ctx->pLexer == NULL((void*)0))
374 {
375 ANTLR3_FREE(ctx)free ((void *)(ctx));
376 return NULL((void*)0);
377 }
378 /* Install the implementation of our ParModelica_Lexer interface
379 */
380 ctx->mPARFOR = mPARFOR;
381 ctx->mT_PARALLEL = mT_PARALLEL;
382 ctx->mT_LOCAL = mT_LOCAL;
383 ctx->mT_GLOBAL = mT_GLOBAL;
384 ctx->mT_KERNEL = mT_KERNEL;
385 ctx->mEND_PARFOR = mEND_PARFOR;
386 ctx->mSTAR = mSTAR;
387 ctx->mMINUS = mMINUS;
388 ctx->mPLUS = mPLUS;
389 ctx->mLESS = mLESS;
390 ctx->mLESSEQ = mLESSEQ;
391 ctx->mLESSGT = mLESSGT;
392 ctx->mGREATER = mGREATER;
393 ctx->mGREATEREQ = mGREATEREQ;
394 ctx->mEQEQ = mEQEQ;
395 ctx->mPOWER = mPOWER;
396 ctx->mSLASH = mSLASH;
397 ctx->mPLUS_EW = mPLUS_EW;
398 ctx->mMINUS_EW = mMINUS_EW;
399 ctx->mSTAR_EW = mSTAR_EW;
400 ctx->mSLASH_EW = mSLASH_EW;
401 ctx->mPOWER_EW = mPOWER_EW;
402 ctx->mSTREAM = mSTREAM;
403 ctx->mIMPURE = mIMPURE;
404 ctx->mTokens = mTokens;
405
406 /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
407 * it will call mTokens() in this generated code, and will pass it the ctx
408 * pointer of this lexer, not the context of the base lexer, so store that now.
409 */
410 ctx->pLexer->ctx = ctx;
411
412 /**Install the token matching function
413 */
414 ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
415
416 ctx->getGrammarFileName = getGrammarFileName;
417 ctx->free = ParModelica_LexerFree;
418
419 // Initialize the lexers that we are going to delegate some
420 // functions to.
421 //
422 ctx->gBaseModelica_Lexer = ParModelica_Lexer_BaseModelica_LexerNewSSD(instream, ctx->pLexer->rec->state, ctx);
423
424
425
426 /* Return the newly built lexer to the caller
427 */
428 return ctx;
429}
430
431/* =========================================================================
432 * DFA tables for the lexer
433 */
434/** Static dfa state tables for Cyclic dfa:
435 * 1:1: Tokens : ( PARFOR | T_PARALLEL | T_LOCAL | T_GLOBAL | T_KERNEL | END_PARFOR | STAR | MINUS | PLUS | LESS | LESSEQ | LESSGT | GREATER | GREATEREQ | EQEQ | POWER | SLASH | PLUS_EW | MINUS_EW | STAR_EW | SLASH_EW | POWER_EW | STREAM | IMPURE | BaseModelica_Lexer. Tokens );
436 */
437static const ANTLR3_INT32 dfa1_eot[90] =
438 {
439 -1, 14, 14, -1, -1, -1, 19, 21, 14, -1, 23, 14, 14, 14, -1, 14, 14, -1,
440 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 14, 14, 14, 14, -1, -1, -1,
441 -1, -1, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
442 14, 14, 14, 14, 14, 14, 68, 14, 14, 14, 14, 14, 74, 75, -1, 14, 14, 14,
443 14, 14, -1, -1, 81, 82, 14, 14, 14, -1, -1, 86, 87, 14, -1, -1, 89, -1
444 };
445static const ANTLR3_INT32 dfa1_eof[90] =
446 {
447 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
448 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
449 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
450 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
451 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
452 };
453static const ANTLR3_INT32 dfa1_min[90] =
454 {
455 9, 97, 110, -1, -1, -1, 61, 61, 61, -1, 42, 42, 116, 109, -1, 114, 100,
456 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 114, 112, 97, 9, -1, -1,
457 -1, -1, -1, 101, 117, 111, 108, 111, 108, 101, 9, 9, 9, 9, 97, 114, 114,
458 108, 99, 111, 114, 97, 9, 109, 101, 48, 101, 97, 98, 110, 114, 48, 48,
459 -1, 108, 108, 97, 101, 102, -1, -1, 48, 48, 108, 108, 111, -1, -1, 48,
460 48, 114, -1, -1, 48, -1
461 };
462static const ANTLR3_INT32 dfa1_max[90] =
463 {
464 239, 97, 110, -1, -1, -1, 62, 61, 61, -1, 47, 94, 116, 109, -1, 114, 100,
465 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 114, 112, 108, 32, -1,
466 -1, -1, -1, -1, 101, 117, 111, 108, 111, 108, 101, 112, 112, 112, 112,
467 97, 114, 114, 108, 99, 111, 114, 97, 112, 109, 101, 122, 101, 97, 98, 110,
468 114, 122, 122, -1, 108, 108, 97, 101, 102, -1, -1, 122, 122, 108, 108,
469 111, -1, -1, 122, 122, 114, -1, -1, 122, -1
470 };
471static const ANTLR3_INT32 dfa1_accept[90] =
472 {
473 -1, -1, -1, 7, 8, 9, -1, -1, -1, 16, -1, -1, -1, -1, 25, -1, -1, 11, 12,
474 10, 14, 13, 15, 17, 18, 19, 20, 21, 22, -1, -1, -1, -1, 18, 19, 20, 21,
475 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
476 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1,
477 -1, 23, 24, -1, -1, -1, -1, -1, 2, 3, -1, -1, -1, 4, 5, -1, 6
478 };
479static const ANTLR3_INT32 dfa1_special[90] =
480 {
481 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
482 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
483 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
484 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
485 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
486 };
487
488/** Used when there is no transition table entry for a particular state */
489#define dfa1_T_empty((void*)0) NULL((void*)0)
490
491static const ANTLR3_INT32 dfa1_T0[] =
492 {
493 46, 48, -1, -1, 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
494 -1, -1, -1, -1, -1, 45, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
495 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
496 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
497 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
498 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 56
499 };static const ANTLR3_INT32 dfa1_T1[] =
500 {
501 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -1, -1, -1, -1, -1, -1, -1, 14,
502 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
503 14, 14, 14, 14, 14, 14, 14, -1, -1, -1, -1, 14, -1, 14, 14, 14, 14, 14,
504 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
505 14, 14, 14
506 };static const ANTLR3_INT32 dfa1_T2[] =
507 {
508 29
509 };static const ANTLR3_INT32 dfa1_T3[] =
510 {
511 20
512 };static const ANTLR3_INT32 dfa1_T4[] =
513 {
514 30
515 };static const ANTLR3_INT32 dfa1_T5[] =
516 {
517 14, -1, -1, -1, -1, 14
518 };static const ANTLR3_INT32 dfa1_T6[] =
519 {
520 41, -1, -1, -1, -1, 40, 43, -1, -1, -1, 44, 42
521 };static const ANTLR3_INT32 dfa1_T7[] =
522 {
523 31
524 };static const ANTLR3_INT32 dfa1_T8[] =
525 {
526 73
527 };static const ANTLR3_INT32 dfa1_T9[] =
528 {
529 80
530 };static const ANTLR3_INT32 dfa1_T10[] =
531 {
532 85
533 };static const ANTLR3_INT32 dfa1_T11[] =
534 {
535 88
536 };static const ANTLR3_INT32 dfa1_T12[] =
537 {
538 51
539 };static const ANTLR3_INT32 dfa1_T13[] =
540 {
541 60
542 };static const ANTLR3_INT32 dfa1_T14[] =
543 {
544 14, 14, -1, -1, 14, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
545 -1, -1, -1, -1, -1, 14, 14, 14, -1, 14, -1, 14, 14, 14, 14, 3, 5, 14, 4,
546 11, 10, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 6, 8, 7, -1, -1,
547 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
548 14, 14, 14, 14, 14, 14, 14, 14, 14, -1, 14, 9, 14, -1, 14, 14, 14, 14,
549 2, 14, 14, 14, 13, 14, 14, 14, 14, 14, 14, 1, 14, 14, 12, 14, 14, 14, 14,
550 14, 14, 14, 14, 14, 14, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
551 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
552 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
553 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
554 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
555 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
556 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 14
557 };static const ANTLR3_INT32 dfa1_T15[] =
558 {
559 61
560 };static const ANTLR3_INT32 dfa1_T16[] =
561 {
562 69
563 };static const ANTLR3_INT32 dfa1_T17[] =
564 {
565 76
566 };static const ANTLR3_INT32 dfa1_T18[] =
567 {
568 38
569 };static const ANTLR3_INT32 dfa1_T19[] =
570 {
571 22
572 };static const ANTLR3_INT32 dfa1_T20[] =
573 {
574 49
575 };static const ANTLR3_INT32 dfa1_T21[] =
576 {
577 58
578 };static const ANTLR3_INT32 dfa1_T22[] =
579 {
580 46, 48, -1, -1, 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
581 -1, -1, -1, -1, -1, 45
582 };static const ANTLR3_INT32 dfa1_T23[] =
583 {
584 66
585 };static const ANTLR3_INT32 dfa1_T24[] =
586 {
587 53
588 };static const ANTLR3_INT32 dfa1_T25[] =
589 {
590 62
591 };static const ANTLR3_INT32 dfa1_T26[] =
592 {
593 70
594 };static const ANTLR3_INT32 dfa1_T27[] =
595 {
596 77
597 };static const ANTLR3_INT32 dfa1_T28[] =
598 {
599 59
600 };static const ANTLR3_INT32 dfa1_T29[] =
601 {
602 67
603 };static const ANTLR3_INT32 dfa1_T30[] =
604 {
605 46, 57, -1, -1, 47, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
606 -1, -1, -1, -1, -1, 45, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
607 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
608 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
609 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
610 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 56
611 };static const ANTLR3_INT32 dfa1_T31[] =
612 {
613 52
614 };static const ANTLR3_INT32 dfa1_T32[] =
615 {
616 54
617 };static const ANTLR3_INT32 dfa1_T33[] =
618 {
619 63
620 };static const ANTLR3_INT32 dfa1_T34[] =
621 {
622 71
623 };static const ANTLR3_INT32 dfa1_T35[] =
624 {
625 78
626 };static const ANTLR3_INT32 dfa1_T36[] =
627 {
628 83
629 };static const ANTLR3_INT32 dfa1_T37[] =
630 {
631 15
632 };static const ANTLR3_INT32 dfa1_T38[] =
633 {
634 17, 18
635 };static const ANTLR3_INT32 dfa1_T39[] =
636 {
637 55
638 };static const ANTLR3_INT32 dfa1_T40[] =
639 {
640 64
641 };static const ANTLR3_INT32 dfa1_T41[] =
642 {
643 72
644 };static const ANTLR3_INT32 dfa1_T42[] =
645 {
646 79
647 };static const ANTLR3_INT32 dfa1_T43[] =
648 {
649 26, 24, -1, 25, -1, 27, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
650 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
651 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 28
652 };static const ANTLR3_INT32 dfa1_T44[] =
653 {
654 84
655 };static const ANTLR3_INT32 dfa1_T45[] =
656 {
657 39
658 };static const ANTLR3_INT32 dfa1_T46[] =
659 {
660 50
661 };static const ANTLR3_INT32 dfa1_T47[] =
662 {
663 16
664 };static const ANTLR3_INT32 dfa1_T48[] =
665 {
666 32
667 };static const ANTLR3_INT32 dfa1_T49[] =
668 {
669 65
670 };
671
672/* Transition tables are a table of sub tables, with some tables
673 * reused for efficiency.
674 */
675static const ANTLR3_INT32 * const dfa1_transitions[] =
676{
677 dfa1_T14, dfa1_T37, dfa1_T47, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0),
678 dfa1_T38, dfa1_T3, dfa1_T19, dfa1_T_empty((void*)0), dfa1_T5, dfa1_T43, dfa1_T2,
679 dfa1_T4, dfa1_T_empty((void*)0), dfa1_T7, dfa1_T48, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0),
680 dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0),
681 dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0),
682 dfa1_T18, dfa1_T45, dfa1_T6, dfa1_T22, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0),
683 dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T20, dfa1_T46, dfa1_T12, dfa1_T31,
684 dfa1_T24, dfa1_T32, dfa1_T39, dfa1_T0, dfa1_T0, dfa1_T30, dfa1_T0, dfa1_T21,
685 dfa1_T28, dfa1_T13, dfa1_T15, dfa1_T25, dfa1_T33, dfa1_T40, dfa1_T49,
686 dfa1_T0, dfa1_T23, dfa1_T29, dfa1_T1, dfa1_T16, dfa1_T26, dfa1_T34,
687 dfa1_T41, dfa1_T8, dfa1_T1, dfa1_T1, dfa1_T_empty((void*)0), dfa1_T17, dfa1_T27,
688 dfa1_T35, dfa1_T42, dfa1_T9, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T1, dfa1_T1,
689 dfa1_T36, dfa1_T44, dfa1_T10, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T1, dfa1_T1,
690 dfa1_T11, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T1, dfa1_T_empty((void*)0)
691};
692
693
694/* Declare tracking structure for Cyclic DFA 1
695 */
696static
697ANTLR3_CYCLIC_DFA cdfa1
698 = {
699 1, /* Decision number of this dfa */
700 /* Which decision this represents: */
701 (const pANTLR3_UCHAR)"1:1: Tokens : ( PARFOR | T_PARALLEL | T_LOCAL | T_GLOBAL | T_KERNEL | END_PARFOR | STAR | MINUS | PLUS | LESS | LESSEQ | LESSGT | GREATER | GREATEREQ | EQEQ | POWER | SLASH | PLUS_EW | MINUS_EW | STAR_EW | SLASH_EW | POWER_EW | STREAM | IMPURE | BaseModelica_Lexer. Tokens );",
702 (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition, /* Default special state transition function */
703 antlr3dfaspecialTransition, /* DFA specialTransition is currently just a default function in the runtime */
704 antlr3dfapredict, /* DFA simulator function is in the runtime */
705 dfa1_eot, /* EOT table */
706 dfa1_eof, /* EOF table */
707 dfa1_min, /* Minimum tokens for each state */
708 dfa1_max, /* Maximum tokens for each state */
709 dfa1_accept, /* Accept table */
710 dfa1_special, /* Special transition states */
711 dfa1_transitions /* Table of transition tables */
712
713 };
714/* End of Cyclic DFA 1
715 * ---------------------
716 */
717/* =========================================================================
718 * End of DFA tables for the lexer
719 */
720
721/* =========================================================================
722 * Functions to match the lexer grammar defined tokens from the input stream
723 */
724
725// Comes from: 40:8: ( 'parfor' )
726/** \brief Lexer rule generated by ANTLR3
727 *
728 * $ANTLR start PARFOR
729 *
730 * Looks to match the characters the constitute the token PARFOR
731 * from the attached input stream.
732 *
733 *
734 * \remark
735 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
736 */
737static ANTLR3_INLINE__inline__
738void mPARFOR(pParModelica_Lexer ctx)
739{
740 ANTLR3_UINT32 _type;
741
742 _type = PARFOR97;
743
744
745 // ParModelica_Lexer.g:40:8: ( 'parfor' )
746 // ParModelica_Lexer.g:40:10: 'parfor'
747 {
748 MATCHS(lit_1)ctx->pLexer->matchs(ctx->pLexer, lit_1);
749 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
750 {
751 goto rulePARFOREx;
752 }
753
754
755
756 }
757
758 LEXSTATEctx->pLexer->rec->state->type = _type;
759
760 // This is where rules clean up and exit
761 //
762 goto rulePARFOREx; /* Prevent compiler warnings */
763 rulePARFOREx: ;
764
765}
766// $ANTLR end PARFOR
767
768// Comes from: 41:11: ( 'parallel' )
769/** \brief Lexer rule generated by ANTLR3
770 *
771 * $ANTLR start T_PARALLEL
772 *
773 * Looks to match the characters the constitute the token T_PARALLEL
774 * from the attached input stream.
775 *
776 *
777 * \remark
778 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
779 */
780static ANTLR3_INLINE__inline__
781void mT_PARALLEL(pParModelica_Lexer ctx)
782{
783 ANTLR3_UINT32 _type;
784
785 _type = T_PARALLEL98;
786
787
788 // ParModelica_Lexer.g:41:11: ( 'parallel' )
789 // ParModelica_Lexer.g:41:13: 'parallel'
790 {
791 MATCHS(lit_2)ctx->pLexer->matchs(ctx->pLexer, lit_2);
792 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
793 {
794 goto ruleT_PARALLELEx;
795 }
796
797
798
799 }
800
801 LEXSTATEctx->pLexer->rec->state->type = _type;
802
803 // This is where rules clean up and exit
804 //
805 goto ruleT_PARALLELEx; /* Prevent compiler warnings */
806 ruleT_PARALLELEx: ;
807
808}
809// $ANTLR end T_PARALLEL
810
811// Comes from: 42:8: ( 'parlocal' )
812/** \brief Lexer rule generated by ANTLR3
813 *
814 * $ANTLR start T_LOCAL
815 *
816 * Looks to match the characters the constitute the token T_LOCAL
817 * from the attached input stream.
818 *
819 *
820 * \remark
821 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
822 */
823static ANTLR3_INLINE__inline__
824void mT_LOCAL(pParModelica_Lexer ctx)
825{
826 ANTLR3_UINT32 _type;
827
828 _type = T_LOCAL99;
829
830
831 // ParModelica_Lexer.g:42:8: ( 'parlocal' )
832 // ParModelica_Lexer.g:42:10: 'parlocal'
833 {
834 MATCHS(lit_3)ctx->pLexer->matchs(ctx->pLexer, lit_3);
835 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
836 {
837 goto ruleT_LOCALEx;
838 }
839
840
841
842 }
843
844 LEXSTATEctx->pLexer->rec->state->type = _type;
845
846 // This is where rules clean up and exit
847 //
848 goto ruleT_LOCALEx; /* Prevent compiler warnings */
849 ruleT_LOCALEx: ;
850
851}
852// $ANTLR end T_LOCAL
853
854// Comes from: 43:9: ( 'parglobal' )
855/** \brief Lexer rule generated by ANTLR3
856 *
857 * $ANTLR start T_GLOBAL
858 *
859 * Looks to match the characters the constitute the token T_GLOBAL
860 * from the attached input stream.
861 *
862 *
863 * \remark
864 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
865 */
866static ANTLR3_INLINE__inline__
867void mT_GLOBAL(pParModelica_Lexer ctx)
868{
869 ANTLR3_UINT32 _type;
870
871 _type = T_GLOBAL100;
872
873
874 // ParModelica_Lexer.g:43:9: ( 'parglobal' )
875 // ParModelica_Lexer.g:43:11: 'parglobal'
876 {
877 MATCHS(lit_4)ctx->pLexer->matchs(ctx->pLexer, lit_4);
878 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
879 {
880 goto ruleT_GLOBALEx;
881 }
882
883
884
885 }
886
887 LEXSTATEctx->pLexer->rec->state->type = _type;
888
889 // This is where rules clean up and exit
890 //
891 goto ruleT_GLOBALEx; /* Prevent compiler warnings */
892 ruleT_GLOBALEx: ;
893
894}
895// $ANTLR end T_GLOBAL
896
897// Comes from: 44:9: ( 'parkernel' )
898/** \brief Lexer rule generated by ANTLR3
899 *
900 * $ANTLR start T_KERNEL
901 *
902 * Looks to match the characters the constitute the token T_KERNEL
903 * from the attached input stream.
904 *
905 *
906 * \remark
907 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
908 */
909static ANTLR3_INLINE__inline__
910void mT_KERNEL(pParModelica_Lexer ctx)
911{
912 ANTLR3_UINT32 _type;
913
914 _type = T_KERNEL101;
915
916
917 // ParModelica_Lexer.g:44:9: ( 'parkernel' )
918 // ParModelica_Lexer.g:44:11: 'parkernel'
919 {
920 MATCHS(lit_5)ctx->pLexer->matchs(ctx->pLexer, lit_5);
921 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
922 {
923 goto ruleT_KERNELEx;
924 }
925
926
927
928 }
929
930 LEXSTATEctx->pLexer->rec->state->type = _type;
931
932 // This is where rules clean up and exit
933 //
934 goto ruleT_KERNELEx; /* Prevent compiler warnings */
935 ruleT_KERNELEx: ;
936
937}
938// $ANTLR end T_KERNEL
939
940// Comes from: 45:12: ( 'end' EAT_WS_COMMENT 'parfor' )
941/** \brief Lexer rule generated by ANTLR3
942 *
943 * $ANTLR start END_PARFOR
944 *
945 * Looks to match the characters the constitute the token END_PARFOR
946 * from the attached input stream.
947 *
948 *
949 * \remark
950 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
951 */
952static ANTLR3_INLINE__inline__
953void mEND_PARFOR(pParModelica_Lexer ctx)
954{
955 ANTLR3_UINT32 _type;
956
957 _type = END_PARFOR102;
958
959
960 // ParModelica_Lexer.g:45:12: ( 'end' EAT_WS_COMMENT 'parfor' )
961 // ParModelica_Lexer.g:45:14: 'end' EAT_WS_COMMENT 'parfor'
962 {
963 MATCHS(lit_6)ctx->pLexer->matchs(ctx->pLexer, lit_6);
964 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
965 {
966 goto ruleEND_PARFOREx;
967 }
968
969
970 /* 45:14: 'end' EAT_WS_COMMENT 'parfor' */
971 ctx->gBaseModelica_Lexer->mEAT_WS_COMMENT(ctx->gBaseModelica_Lexer );
972 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
973 {
974 goto ruleEND_PARFOREx;
975 }
976
977 MATCHS(lit_1)ctx->pLexer->matchs(ctx->pLexer, lit_1);
978 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
979 {
980 goto ruleEND_PARFOREx;
981 }
982
983
984
985 }
986
987 LEXSTATEctx->pLexer->rec->state->type = _type;
988
989 // This is where rules clean up and exit
990 //
991 goto ruleEND_PARFOREx; /* Prevent compiler warnings */
992 ruleEND_PARFOREx: ;
993
994}
995// $ANTLR end END_PARFOR
996
997// Comes from: 49:12: ( '*' )
998/** \brief Lexer rule generated by ANTLR3
999 *
1000 * $ANTLR start STAR
1001 *
1002 * Looks to match the characters the constitute the token STAR
1003 * from the attached input stream.
1004 *
1005 *
1006 * \remark
1007 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1008 */
1009static ANTLR3_INLINE__inline__
1010void mSTAR(pParModelica_Lexer ctx)
1011{
1012 ANTLR3_UINT32 _type;
1013
1014 _type = STAR143;
1015
1016
1017 // ParModelica_Lexer.g:49:12: ( '*' )
1018 // ParModelica_Lexer.g:49:14: '*'
1019 {
1020 MATCHC('*')ctx->pLexer->matchc(ctx->pLexer, '*');
1021 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1022 {
1023 goto ruleSTAREx;
1024 }
1025
1026
1027 }
1028
1029 LEXSTATEctx->pLexer->rec->state->type = _type;
1030
1031 // This is where rules clean up and exit
1032 //
1033 goto ruleSTAREx; /* Prevent compiler warnings */
1034 ruleSTAREx: ;
1035
1036}
1037// $ANTLR end STAR
1038
1039// Comes from: 50:12: ( '-' )
1040/** \brief Lexer rule generated by ANTLR3
1041 *
1042 * $ANTLR start MINUS
1043 *
1044 * Looks to match the characters the constitute the token MINUS
1045 * from the attached input stream.
1046 *
1047 *
1048 * \remark
1049 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1050 */
1051static ANTLR3_INLINE__inline__
1052void mMINUS(pParModelica_Lexer ctx)
1053{
1054 ANTLR3_UINT32 _type;
1055
1056 _type = MINUS144;
1057
1058
1059 // ParModelica_Lexer.g:50:12: ( '-' )
1060 // ParModelica_Lexer.g:50:14: '-'
1061 {
1062 MATCHC('-')ctx->pLexer->matchc(ctx->pLexer, '-');
1063 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1064 {
1065 goto ruleMINUSEx;
1066 }
1067
1068
1069 }
1070
1071 LEXSTATEctx->pLexer->rec->state->type = _type;
1072
1073 // This is where rules clean up and exit
1074 //
1075 goto ruleMINUSEx; /* Prevent compiler warnings */
1076 ruleMINUSEx: ;
1077
1078}
1079// $ANTLR end MINUS
1080
1081// Comes from: 51:12: ( '+' )
1082/** \brief Lexer rule generated by ANTLR3
1083 *
1084 * $ANTLR start PLUS
1085 *
1086 * Looks to match the characters the constitute the token PLUS
1087 * from the attached input stream.
1088 *
1089 *
1090 * \remark
1091 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1092 */
1093static ANTLR3_INLINE__inline__
1094void mPLUS(pParModelica_Lexer ctx)
1095{
1096 ANTLR3_UINT32 _type;
1097
1098 _type = PLUS145;
1099
1100
1101 // ParModelica_Lexer.g:51:12: ( '+' )
1102 // ParModelica_Lexer.g:51:14: '+'
1103 {
1104 MATCHC('+')ctx->pLexer->matchc(ctx->pLexer, '+');
1105 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1106 {
1107 goto rulePLUSEx;
1108 }
1109
1110
1111 }
1112
1113 LEXSTATEctx->pLexer->rec->state->type = _type;
1114
1115 // This is where rules clean up and exit
1116 //
1117 goto rulePLUSEx; /* Prevent compiler warnings */
1118 rulePLUSEx: ;
1119
1120}
1121// $ANTLR end PLUS
1122
1123// Comes from: 52:12: ( '<' )
1124/** \brief Lexer rule generated by ANTLR3
1125 *
1126 * $ANTLR start LESS
1127 *
1128 * Looks to match the characters the constitute the token LESS
1129 * from the attached input stream.
1130 *
1131 *
1132 * \remark
1133 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1134 */
1135static ANTLR3_INLINE__inline__
1136void mLESS(pParModelica_Lexer ctx)
1137{
1138 ANTLR3_UINT32 _type;
1139
1140 _type = LESS146;
1141
1142
1143 // ParModelica_Lexer.g:52:12: ( '<' )
1144 // ParModelica_Lexer.g:52:14: '<'
1145 {
1146 MATCHC('<')ctx->pLexer->matchc(ctx->pLexer, '<');
1147 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1148 {
1149 goto ruleLESSEx;
1150 }
1151
1152
1153 }
1154
1155 LEXSTATEctx->pLexer->rec->state->type = _type;
1156
1157 // This is where rules clean up and exit
1158 //
1159 goto ruleLESSEx; /* Prevent compiler warnings */
1160 ruleLESSEx: ;
1161
1162}
1163// $ANTLR end LESS
1164
1165// Comes from: 53:12: ( '<=' )
1166/** \brief Lexer rule generated by ANTLR3
1167 *
1168 * $ANTLR start LESSEQ
1169 *
1170 * Looks to match the characters the constitute the token LESSEQ
1171 * from the attached input stream.
1172 *
1173 *
1174 * \remark
1175 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1176 */
1177static ANTLR3_INLINE__inline__
1178void mLESSEQ(pParModelica_Lexer ctx)
1179{
1180 ANTLR3_UINT32 _type;
1181
1182 _type = LESSEQ147;
1183
1184
1185 // ParModelica_Lexer.g:53:12: ( '<=' )
1186 // ParModelica_Lexer.g:53:14: '<='
1187 {
1188 MATCHS(lit_7)ctx->pLexer->matchs(ctx->pLexer, lit_7);
1189 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1190 {
1191 goto ruleLESSEQEx;
1192 }
1193
1194
1195
1196 }
1197
1198 LEXSTATEctx->pLexer->rec->state->type = _type;
1199
1200 // This is where rules clean up and exit
1201 //
1202 goto ruleLESSEQEx; /* Prevent compiler warnings */
1203 ruleLESSEQEx: ;
1204
1205}
1206// $ANTLR end LESSEQ
1207
1208// Comes from: 54:12: ( '<>' )
1209/** \brief Lexer rule generated by ANTLR3
1210 *
1211 * $ANTLR start LESSGT
1212 *
1213 * Looks to match the characters the constitute the token LESSGT
1214 * from the attached input stream.
1215 *
1216 *
1217 * \remark
1218 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1219 */
1220static ANTLR3_INLINE__inline__
1221void mLESSGT(pParModelica_Lexer ctx)
1222{
1223 ANTLR3_UINT32 _type;
1224
1225 _type = LESSGT148;
1226
1227
1228 // ParModelica_Lexer.g:54:12: ( '<>' )
1229 // ParModelica_Lexer.g:54:14: '<>'
1230 {
1231 MATCHS(lit_8)ctx->pLexer->matchs(ctx->pLexer, lit_8);
1232 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1233 {
1234 goto ruleLESSGTEx;
1235 }
1236
1237
1238
1239 }
1240
1241 LEXSTATEctx->pLexer->rec->state->type = _type;
1242
1243 // This is where rules clean up and exit
1244 //
1245 goto ruleLESSGTEx; /* Prevent compiler warnings */
1246 ruleLESSGTEx: ;
1247
1248}
1249// $ANTLR end LESSGT
1250
1251// Comes from: 55:12: ( '>' )
1252/** \brief Lexer rule generated by ANTLR3
1253 *
1254 * $ANTLR start GREATER
1255 *
1256 * Looks to match the characters the constitute the token GREATER
1257 * from the attached input stream.
1258 *
1259 *
1260 * \remark
1261 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1262 */
1263static ANTLR3_INLINE__inline__
1264void mGREATER(pParModelica_Lexer ctx)
1265{
1266 ANTLR3_UINT32 _type;
1267
1268 _type = GREATER149;
1269
1270
1271 // ParModelica_Lexer.g:55:12: ( '>' )
1272 // ParModelica_Lexer.g:55:14: '>'
1273 {
1274 MATCHC('>')ctx->pLexer->matchc(ctx->pLexer, '>');
1275 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1276 {
1277 goto ruleGREATEREx;
1278 }
1279
1280
1281 }
1282
1283 LEXSTATEctx->pLexer->rec->state->type = _type;
1284
1285 // This is where rules clean up and exit
1286 //
1287 goto ruleGREATEREx; /* Prevent compiler warnings */
1288 ruleGREATEREx: ;
1289
1290}
1291// $ANTLR end GREATER
1292
1293// Comes from: 56:12: ( '>=' )
1294/** \brief Lexer rule generated by ANTLR3
1295 *
1296 * $ANTLR start GREATEREQ
1297 *
1298 * Looks to match the characters the constitute the token GREATEREQ
1299 * from the attached input stream.
1300 *
1301 *
1302 * \remark
1303 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1304 */
1305static ANTLR3_INLINE__inline__
1306void mGREATEREQ(pParModelica_Lexer ctx)
1307{
1308 ANTLR3_UINT32 _type;
1309
1310 _type = GREATEREQ150;
1311
1312
1313 // ParModelica_Lexer.g:56:12: ( '>=' )
1314 // ParModelica_Lexer.g:56:14: '>='
1315 {
1316 MATCHS(lit_9)ctx->pLexer->matchs(ctx->pLexer, lit_9);
1317 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1318 {
1319 goto ruleGREATEREQEx;
1320 }
1321
1322
1323
1324 }
1325
1326 LEXSTATEctx->pLexer->rec->state->type = _type;
1327
1328 // This is where rules clean up and exit
1329 //
1330 goto ruleGREATEREQEx; /* Prevent compiler warnings */
1331 ruleGREATEREQEx: ;
1332
1333}
1334// $ANTLR end GREATEREQ
1335
1336// Comes from: 57:12: ( '==' )
1337/** \brief Lexer rule generated by ANTLR3
1338 *
1339 * $ANTLR start EQEQ
1340 *
1341 * Looks to match the characters the constitute the token EQEQ
1342 * from the attached input stream.
1343 *
1344 *
1345 * \remark
1346 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1347 */
1348static ANTLR3_INLINE__inline__
1349void mEQEQ(pParModelica_Lexer ctx)
1350{
1351 ANTLR3_UINT32 _type;
1352
1353 _type = EQEQ151;
1354
1355
1356 // ParModelica_Lexer.g:57:12: ( '==' )
1357 // ParModelica_Lexer.g:57:14: '=='
1358 {
1359 MATCHS(lit_10)ctx->pLexer->matchs(ctx->pLexer, lit_10);
1360 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1361 {
1362 goto ruleEQEQEx;
1363 }
1364
1365
1366
1367 }
1368
1369 LEXSTATEctx->pLexer->rec->state->type = _type;
1370
1371 // This is where rules clean up and exit
1372 //
1373 goto ruleEQEQEx; /* Prevent compiler warnings */
1374 ruleEQEQEx: ;
1375
1376}
1377// $ANTLR end EQEQ
1378
1379// Comes from: 58:12: ( '^' )
1380/** \brief Lexer rule generated by ANTLR3
1381 *
1382 * $ANTLR start POWER
1383 *
1384 * Looks to match the characters the constitute the token POWER
1385 * from the attached input stream.
1386 *
1387 *
1388 * \remark
1389 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1390 */
1391static ANTLR3_INLINE__inline__
1392void mPOWER(pParModelica_Lexer ctx)
1393{
1394 ANTLR3_UINT32 _type;
1395
1396 _type = POWER152;
1397
1398
1399 // ParModelica_Lexer.g:58:12: ( '^' )
1400 // ParModelica_Lexer.g:58:14: '^'
1401 {
1402 MATCHC('^')ctx->pLexer->matchc(ctx->pLexer, '^');
1403 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1404 {
1405 goto rulePOWEREx;
1406 }
1407
1408
1409 }
1410
1411 LEXSTATEctx->pLexer->rec->state->type = _type;
1412
1413 // This is where rules clean up and exit
1414 //
1415 goto rulePOWEREx; /* Prevent compiler warnings */
1416 rulePOWEREx: ;
1417
1418}
1419// $ANTLR end POWER
1420
1421// Comes from: 59:12: ( '/' )
1422/** \brief Lexer rule generated by ANTLR3
1423 *
1424 * $ANTLR start SLASH
1425 *
1426 * Looks to match the characters the constitute the token SLASH
1427 * from the attached input stream.
1428 *
1429 *
1430 * \remark
1431 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1432 */
1433static ANTLR3_INLINE__inline__
1434void mSLASH(pParModelica_Lexer ctx)
1435{
1436 ANTLR3_UINT32 _type;
1437
1438 _type = SLASH153;
1439
1440
1441 // ParModelica_Lexer.g:59:12: ( '/' )
1442 // ParModelica_Lexer.g:59:14: '/'
1443 {
1444 MATCHC('/')ctx->pLexer->matchc(ctx->pLexer, '/');
1445 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1446 {
1447 goto ruleSLASHEx;
1448 }
1449
1450
1451 }
1452
1453 LEXSTATEctx->pLexer->rec->state->type = _type;
1454
1455 // This is where rules clean up and exit
1456 //
1457 goto ruleSLASHEx; /* Prevent compiler warnings */
1458 ruleSLASHEx: ;
1459
1460}
1461// $ANTLR end SLASH
1462
1463// Comes from: 62:9: ( '.+' )
1464/** \brief Lexer rule generated by ANTLR3
1465 *
1466 * $ANTLR start PLUS_EW
1467 *
1468 * Looks to match the characters the constitute the token PLUS_EW
1469 * from the attached input stream.
1470 *
1471 *
1472 * \remark
1473 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1474 */
1475static ANTLR3_INLINE__inline__
1476void mPLUS_EW(pParModelica_Lexer ctx)
1477{
1478 ANTLR3_UINT32 _type;
1479
1480 _type = PLUS_EW117;
1481
1482
1483 // ParModelica_Lexer.g:62:9: ( '.+' )
1484 // ParModelica_Lexer.g:62:11: '.+'
1485 {
1486 MATCHS(lit_11)ctx->pLexer->matchs(ctx->pLexer, lit_11);
1487 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1488 {
1489 goto rulePLUS_EWEx;
1490 }
1491
1492
1493
1494 }
1495
1496 LEXSTATEctx->pLexer->rec->state->type = _type;
1497
1498 // This is where rules clean up and exit
1499 //
1500 goto rulePLUS_EWEx; /* Prevent compiler warnings */
1501 rulePLUS_EWEx: ;
1502
1503}
1504// $ANTLR end PLUS_EW
1505
1506// Comes from: 63:10: ( '.-' )
1507/** \brief Lexer rule generated by ANTLR3
1508 *
1509 * $ANTLR start MINUS_EW
1510 *
1511 * Looks to match the characters the constitute the token MINUS_EW
1512 * from the attached input stream.
1513 *
1514 *
1515 * \remark
1516 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1517 */
1518static ANTLR3_INLINE__inline__
1519void mMINUS_EW(pParModelica_Lexer ctx)
1520{
1521 ANTLR3_UINT32 _type;
1522
1523 _type = MINUS_EW118;
1524
1525
1526 // ParModelica_Lexer.g:63:10: ( '.-' )
1527 // ParModelica_Lexer.g:63:12: '.-'
1528 {
1529 MATCHS(lit_12)ctx->pLexer->matchs(ctx->pLexer, lit_12);
1530 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1531 {
1532 goto ruleMINUS_EWEx;
1533 }
1534
1535
1536
1537 }
1538
1539 LEXSTATEctx->pLexer->rec->state->type = _type;
1540
1541 // This is where rules clean up and exit
1542 //
1543 goto ruleMINUS_EWEx; /* Prevent compiler warnings */
1544 ruleMINUS_EWEx: ;
1545
1546}
1547// $ANTLR end MINUS_EW
1548
1549// Comes from: 64:9: ( '.*' )
1550/** \brief Lexer rule generated by ANTLR3
1551 *
1552 * $ANTLR start STAR_EW
1553 *
1554 * Looks to match the characters the constitute the token STAR_EW
1555 * from the attached input stream.
1556 *
1557 *
1558 * \remark
1559 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1560 */
1561static ANTLR3_INLINE__inline__
1562void mSTAR_EW(pParModelica_Lexer ctx)
1563{
1564 ANTLR3_UINT32 _type;
1565
1566 _type = STAR_EW119;
1567
1568
1569 // ParModelica_Lexer.g:64:9: ( '.*' )
1570 // ParModelica_Lexer.g:64:11: '.*'
1571 {
1572 MATCHS(lit_13)ctx->pLexer->matchs(ctx->pLexer, lit_13);
1573 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1574 {
1575 goto ruleSTAR_EWEx;
1576 }
1577
1578
1579
1580 }
1581
1582 LEXSTATEctx->pLexer->rec->state->type = _type;
1583
1584 // This is where rules clean up and exit
1585 //
1586 goto ruleSTAR_EWEx; /* Prevent compiler warnings */
1587 ruleSTAR_EWEx: ;
1588
1589}
1590// $ANTLR end STAR_EW
1591
1592// Comes from: 65:10: ( './' )
1593/** \brief Lexer rule generated by ANTLR3
1594 *
1595 * $ANTLR start SLASH_EW
1596 *
1597 * Looks to match the characters the constitute the token SLASH_EW
1598 * from the attached input stream.
1599 *
1600 *
1601 * \remark
1602 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1603 */
1604static ANTLR3_INLINE__inline__
1605void mSLASH_EW(pParModelica_Lexer ctx)
1606{
1607 ANTLR3_UINT32 _type;
1608
1609 _type = SLASH_EW120;
1610
1611
1612 // ParModelica_Lexer.g:65:10: ( './' )
1613 // ParModelica_Lexer.g:65:12: './'
1614 {
1615 MATCHS(lit_14)ctx->pLexer->matchs(ctx->pLexer, lit_14);
1616 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1617 {
1618 goto ruleSLASH_EWEx;
1619 }
1620
1621
1622
1623 }
1624
1625 LEXSTATEctx->pLexer->rec->state->type = _type;
1626
1627 // This is where rules clean up and exit
1628 //
1629 goto ruleSLASH_EWEx; /* Prevent compiler warnings */
1630 ruleSLASH_EWEx: ;
1631
1632}
1633// $ANTLR end SLASH_EW
1634
1635// Comes from: 66:10: ( '.^' )
1636/** \brief Lexer rule generated by ANTLR3
1637 *
1638 * $ANTLR start POWER_EW
1639 *
1640 * Looks to match the characters the constitute the token POWER_EW
1641 * from the attached input stream.
1642 *
1643 *
1644 * \remark
1645 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1646 */
1647static ANTLR3_INLINE__inline__
1648void mPOWER_EW(pParModelica_Lexer ctx)
1649{
1650 ANTLR3_UINT32 _type;
1651
1652 _type = POWER_EW121;
1653
1654
1655 // ParModelica_Lexer.g:66:10: ( '.^' )
1656 // ParModelica_Lexer.g:66:12: '.^'
1657 {
1658 MATCHS(lit_15)ctx->pLexer->matchs(ctx->pLexer, lit_15);
1659 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1660 {
1661 goto rulePOWER_EWEx;
1662 }
1663
1664
1665
1666 }
1667
1668 LEXSTATEctx->pLexer->rec->state->type = _type;
1669
1670 // This is where rules clean up and exit
1671 //
1672 goto rulePOWER_EWEx; /* Prevent compiler warnings */
1673 rulePOWER_EWEx: ;
1674
1675}
1676// $ANTLR end POWER_EW
1677
1678// Comes from: 69:8: ( 'stream' )
1679/** \brief Lexer rule generated by ANTLR3
1680 *
1681 * $ANTLR start STREAM
1682 *
1683 * Looks to match the characters the constitute the token STREAM
1684 * from the attached input stream.
1685 *
1686 *
1687 * \remark
1688 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1689 */
1690static ANTLR3_INLINE__inline__
1691void mSTREAM(pParModelica_Lexer ctx)
1692{
1693 ANTLR3_UINT32 _type;
1694
1695 _type = STREAM79;
1696
1697
1698 // ParModelica_Lexer.g:69:8: ( 'stream' )
1699 // ParModelica_Lexer.g:69:10: 'stream'
1700 {
1701 MATCHS(lit_16)ctx->pLexer->matchs(ctx->pLexer, lit_16);
1702 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1703 {
1704 goto ruleSTREAMEx;
1705 }
1706
1707
1708
1709 }
1710
1711 LEXSTATEctx->pLexer->rec->state->type = _type;
1712
1713 // This is where rules clean up and exit
1714 //
1715 goto ruleSTREAMEx; /* Prevent compiler warnings */
1716 ruleSTREAMEx: ;
1717
1718}
1719// $ANTLR end STREAM
1720
1721// Comes from: 70:8: ( 'impure' )
1722/** \brief Lexer rule generated by ANTLR3
1723 *
1724 * $ANTLR start IMPURE
1725 *
1726 * Looks to match the characters the constitute the token IMPURE
1727 * from the attached input stream.
1728 *
1729 *
1730 * \remark
1731 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1732 */
1733static ANTLR3_INLINE__inline__
1734void mIMPURE(pParModelica_Lexer ctx)
1735{
1736 ANTLR3_UINT32 _type;
1737
1738 _type = IMPURE49;
1739
1740
1741 // ParModelica_Lexer.g:70:8: ( 'impure' )
1742 // ParModelica_Lexer.g:70:10: 'impure'
1743 {
1744 MATCHS(lit_17)ctx->pLexer->matchs(ctx->pLexer, lit_17);
1745 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1746 {
1747 goto ruleIMPUREEx;
1748 }
1749
1750
1751
1752 }
1753
1754 LEXSTATEctx->pLexer->rec->state->type = _type;
1755
1756 // This is where rules clean up and exit
1757 //
1758 goto ruleIMPUREEx; /* Prevent compiler warnings */
1759 ruleIMPUREEx: ;
1760
1761}
1762// $ANTLR end IMPURE
1763
1764/** This is the entry point in to the lexer from an object that
1765 * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM
1766 */
1767static void
1768mTokens(pParModelica_Lexer ctx)
1769{
1770 {
1771 // ParModelica_Lexer.g:1:8: ( PARFOR | T_PARALLEL | T_LOCAL | T_GLOBAL | T_KERNEL | END_PARFOR | STAR | MINUS | PLUS | LESS | LESSEQ | LESSGT | GREATER | GREATEREQ | EQEQ | POWER | SLASH | PLUS_EW | MINUS_EW | STAR_EW | SLASH_EW | POWER_EW | STREAM | IMPURE | BaseModelica_Lexer. Tokens )
1772
1773 ANTLR3_UINT32 alt1;
1774
1775 alt1=25;
Value stored to 'alt1' is never read
1776
1777 alt1 = cdfa1.predict(ctx, RECOGNIZERctx->pLexer->rec, ISTREAMctx->pLexer->input->istream, &cdfa1);
1778 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1779 {
1780 goto ruleTokensEx;
1781 }
1782
1783 switch (alt1)
1784 {
1785 case 1:
1786 // ParModelica_Lexer.g:1:10: PARFOR
1787 {
1788 /* 1:10: PARFOR */
1789 mPARFOR(ctx );
1790 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1791 {
1792 goto ruleTokensEx;
1793 }
1794
1795
1796 }
1797 break;
1798 case 2:
1799 // ParModelica_Lexer.g:1:17: T_PARALLEL
1800 {
1801 /* 1:17: T_PARALLEL */
1802 mT_PARALLEL(ctx );
1803 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1804 {
1805 goto ruleTokensEx;
1806 }
1807
1808
1809 }
1810 break;
1811 case 3:
1812 // ParModelica_Lexer.g:1:28: T_LOCAL
1813 {
1814 /* 1:28: T_LOCAL */
1815 mT_LOCAL(ctx );
1816 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1817 {
1818 goto ruleTokensEx;
1819 }
1820
1821
1822 }
1823 break;
1824 case 4:
1825 // ParModelica_Lexer.g:1:36: T_GLOBAL
1826 {
1827 /* 1:36: T_GLOBAL */
1828 mT_GLOBAL(ctx );
1829 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1830 {
1831 goto ruleTokensEx;
1832 }
1833
1834
1835 }
1836 break;
1837 case 5:
1838 // ParModelica_Lexer.g:1:45: T_KERNEL
1839 {
1840 /* 1:45: T_KERNEL */
1841 mT_KERNEL(ctx );
1842 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1843 {
1844 goto ruleTokensEx;
1845 }
1846
1847
1848 }
1849 break;
1850 case 6:
1851 // ParModelica_Lexer.g:1:54: END_PARFOR
1852 {
1853 /* 1:54: END_PARFOR */
1854 mEND_PARFOR(ctx );
1855 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1856 {
1857 goto ruleTokensEx;
1858 }
1859
1860
1861 }
1862 break;
1863 case 7:
1864 // ParModelica_Lexer.g:1:65: STAR
1865 {
1866 /* 1:65: STAR */
1867 mSTAR(ctx );
1868 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1869 {
1870 goto ruleTokensEx;
1871 }
1872
1873
1874 }
1875 break;
1876 case 8:
1877 // ParModelica_Lexer.g:1:70: MINUS
1878 {
1879 /* 1:70: MINUS */
1880 mMINUS(ctx );
1881 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1882 {
1883 goto ruleTokensEx;
1884 }
1885
1886
1887 }
1888 break;
1889 case 9:
1890 // ParModelica_Lexer.g:1:76: PLUS
1891 {
1892 /* 1:76: PLUS */
1893 mPLUS(ctx );
1894 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1895 {
1896 goto ruleTokensEx;
1897 }
1898
1899
1900 }
1901 break;
1902 case 10:
1903 // ParModelica_Lexer.g:1:81: LESS
1904 {
1905 /* 1:81: LESS */
1906 mLESS(ctx );
1907 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1908 {
1909 goto ruleTokensEx;
1910 }
1911
1912
1913 }
1914 break;
1915 case 11:
1916 // ParModelica_Lexer.g:1:86: LESSEQ
1917 {
1918 /* 1:86: LESSEQ */
1919 mLESSEQ(ctx );
1920 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1921 {
1922 goto ruleTokensEx;
1923 }
1924
1925
1926 }
1927 break;
1928 case 12:
1929 // ParModelica_Lexer.g:1:93: LESSGT
1930 {
1931 /* 1:93: LESSGT */
1932 mLESSGT(ctx );
1933 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1934 {
1935 goto ruleTokensEx;
1936 }
1937
1938
1939 }
1940 break;
1941 case 13:
1942 // ParModelica_Lexer.g:1:100: GREATER
1943 {
1944 /* 1:100: GREATER */
1945 mGREATER(ctx );
1946 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1947 {
1948 goto ruleTokensEx;
1949 }
1950
1951
1952 }
1953 break;
1954 case 14:
1955 // ParModelica_Lexer.g:1:108: GREATEREQ
1956 {
1957 /* 1:108: GREATEREQ */
1958 mGREATEREQ(ctx );
1959 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1960 {
1961 goto ruleTokensEx;
1962 }
1963
1964
1965 }
1966 break;
1967 case 15:
1968 // ParModelica_Lexer.g:1:118: EQEQ
1969 {
1970 /* 1:118: EQEQ */
1971 mEQEQ(ctx );
1972 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1973 {
1974 goto ruleTokensEx;
1975 }
1976
1977
1978 }
1979 break;
1980 case 16:
1981 // ParModelica_Lexer.g:1:123: POWER
1982 {
1983 /* 1:123: POWER */
1984 mPOWER(ctx );
1985 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1986 {
1987 goto ruleTokensEx;
1988 }
1989
1990
1991 }
1992 break;
1993 case 17:
1994 // ParModelica_Lexer.g:1:129: SLASH
1995 {
1996 /* 1:129: SLASH */
1997 mSLASH(ctx );
1998 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1999 {
2000 goto ruleTokensEx;
2001 }
2002
2003
2004 }
2005 break;
2006 case 18:
2007 // ParModelica_Lexer.g:1:135: PLUS_EW
2008 {
2009 /* 1:135: PLUS_EW */
2010 mPLUS_EW(ctx );
2011 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2012 {
2013 goto ruleTokensEx;
2014 }
2015
2016
2017 }
2018 break;
2019 case 19:
2020 // ParModelica_Lexer.g:1:143: MINUS_EW
2021 {
2022 /* 1:143: MINUS_EW */
2023 mMINUS_EW(ctx );
2024 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2025 {
2026 goto ruleTokensEx;
2027 }
2028
2029
2030 }
2031 break;
2032 case 20:
2033 // ParModelica_Lexer.g:1:152: STAR_EW
2034 {
2035 /* 1:152: STAR_EW */
2036 mSTAR_EW(ctx );
2037 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2038 {
2039 goto ruleTokensEx;
2040 }
2041
2042
2043 }
2044 break;
2045 case 21:
2046 // ParModelica_Lexer.g:1:160: SLASH_EW
2047 {
2048 /* 1:160: SLASH_EW */
2049 mSLASH_EW(ctx );
2050 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2051 {
2052 goto ruleTokensEx;
2053 }
2054
2055
2056 }
2057 break;
2058 case 22:
2059 // ParModelica_Lexer.g:1:169: POWER_EW
2060 {
2061 /* 1:169: POWER_EW */
2062 mPOWER_EW(ctx );
2063 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2064 {
2065 goto ruleTokensEx;
2066 }
2067
2068
2069 }
2070 break;
2071 case 23:
2072 // ParModelica_Lexer.g:1:178: STREAM
2073 {
2074 /* 1:178: STREAM */
2075 mSTREAM(ctx );
2076 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2077 {
2078 goto ruleTokensEx;
2079 }
2080
2081
2082 }
2083 break;
2084 case 24:
2085 // ParModelica_Lexer.g:1:185: IMPURE
2086 {
2087 /* 1:185: IMPURE */
2088 mIMPURE(ctx );
2089 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2090 {
2091 goto ruleTokensEx;
2092 }
2093
2094
2095 }
2096 break;
2097 case 25:
2098 // ParModelica_Lexer.g:1:192: BaseModelica_Lexer. Tokens
2099 {
2100 /* 1:192: BaseModelica_Lexer. Tokens */
2101 ctx->gBaseModelica_Lexer->mTokens(ctx->gBaseModelica_Lexer );
2102 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2103 {
2104 goto ruleTokensEx;
2105 }
2106
2107
2108 }
2109 break;
2110
2111 }
2112 }
2113
2114
2115 goto ruleTokensEx; /* Prevent compiler warnings */
2116ruleTokensEx: ;
2117}
2118
2119/* =========================================================================
2120 * Lexer matching rules end.
2121 * =========================================================================
2122 */
2123/* End of Lexer code
2124 * ================================================
2125 * ================================================
2126 */
2127
2128
2129/* End of code
2130 * =============================================================================
2131 */