Bug Summary

File:OMCompiler/Parser/MetaModelica_Lexer.c
Warning:line 3045, 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 : MetaModelica_Lexer.g
5 * - On : 2020-04-28 16:30:01
6 * - for the lexer : MetaModelica_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 "MetaModelica_Lexer.h"
46/* ----------------------------------------- */
47
48
49/** String literals used by MetaModelica_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[] = { 0x61, 0x73, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
56static ANTLR3_UCHAR lit_2[] = { 0x63, 0x61, 0x73, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
57static ANTLR3_UCHAR lit_3[] = { 0x63, 0x6F, 0x6E, 0x74, 0x69, 0x6E, 0x75, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
58static ANTLR3_UCHAR lit_4[] = { 0x65, 0x71, 0x75, 0x61, 0x6C, 0x69, 0x74, 0x79, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
59static ANTLR3_UCHAR lit_5[] = { 0x66, 0x61, 0x69, 0x6C, 0x75, 0x72, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
60static ANTLR3_UCHAR lit_6[] = { 0x67, 0x75, 0x61, 0x72, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
61static ANTLR3_UCHAR lit_7[] = { 0x6C, 0x6F, 0x63, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
62static ANTLR3_UCHAR lit_8[] = { 0x6D, 0x61, 0x74, 0x63, 0x68, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
63static ANTLR3_UCHAR lit_9[] = { 0x6D, 0x61, 0x74, 0x63, 0x68, 0x63, 0x6F, 0x6E, 0x74, 0x69, 0x6E, 0x75, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
64static ANTLR3_UCHAR lit_10[] = { 0x75, 0x6E, 0x69, 0x6F, 0x6E, 0x74, 0x79, 0x70, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
65static ANTLR3_UCHAR lit_11[] = { 0x5F, 0x5F, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
66static ANTLR3_UCHAR lit_12[] = { 0x73, 0x75, 0x62, 0x74, 0x79, 0x70, 0x65, 0x6F, 0x66, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
67static ANTLR3_UCHAR lit_13[] = { 0x3A, 0x3A, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
68static ANTLR3_UCHAR lit_14[] = { 0x74, 0x72, 0x79, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
69static ANTLR3_UCHAR lit_15[] = { 0x65, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
70static ANTLR3_UCHAR lit_16[] = { 0x3C, 0x3D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
71static ANTLR3_UCHAR lit_17[] = { 0x3C, 0x3E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
72static ANTLR3_UCHAR lit_18[] = { 0x3E, 0x3D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
73static ANTLR3_UCHAR lit_19[] = { 0x3D, 0x3D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
74static ANTLR3_UCHAR lit_20[] = { 0x2E, 0x2B, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
75static ANTLR3_UCHAR lit_21[] = { 0x2E, 0x2D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
76static ANTLR3_UCHAR lit_22[] = { 0x2E, 0x2A, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
77static ANTLR3_UCHAR lit_23[] = { 0x2E, 0x2F, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
78static ANTLR3_UCHAR lit_24[] = { 0x2E, 0x5E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
79static ANTLR3_UCHAR lit_25[] = { 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
80static ANTLR3_UCHAR lit_26[] = { 0x69, 0x6D, 0x70, 0x75, 0x72, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
81static ANTLR3_UCHAR lit_27[] = { 0x70, 0x61, 0x72, 0x66, 0x6F, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
82static ANTLR3_UCHAR lit_28[] = { 0x70, 0x61, 0x72, 0x61, 0x6C, 0x6C, 0x65, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
83static ANTLR3_UCHAR lit_29[] = { 0x70, 0x61, 0x72, 0x6C, 0x6F, 0x63, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
84static ANTLR3_UCHAR lit_30[] = { 0x70, 0x61, 0x72, 0x67, 0x6C, 0x6F, 0x62, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
85static ANTLR3_UCHAR lit_31[] = { 0x70, 0x61, 0x72, 0x6B, 0x65, 0x72, 0x6E, 0x65, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
86static ANTLR3_UCHAR lit_32[] = { 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
87
88
89
90
91/* MACROS that hide the C interface implementations from the
92 * generated code, which makes it a little more understandable to the human eye.
93 * I am very much against using C pre-processor macros for function calls and bits
94 * of code as you cannot see what is happening when single stepping in debuggers
95 * and so on. The exception (in my book at least) is for generated code, where you are
96 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
97 * hides some indirect calls, but is always referring to the input stream. This is
98 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
99 * the runtime interfaces without changing the generated code too often, without
100 * confusing the reader of the generated output, who may not wish to know the gory
101 * details of the interface inheritance.
102 */
103
104#define CTXctx ctx
105
106/* Aids in accessing scopes for grammar programmers
107 */
108#undef SCOPE_TYPE
109#undef SCOPE_STACK
110#undef SCOPE_TOP
111#define SCOPE_TYPE(scope)pMetaModelica_Lexer_scope_SCOPE pMetaModelica_Lexer_##scope##_SCOPE
112#define SCOPE_STACK(scope)pMetaModelica_Lexer_scopeStack pMetaModelica_Lexer_##scope##Stack
113#define SCOPE_TOP(scope)ctx->pMetaModelica_Lexer_scopeTop ctx->pMetaModelica_Lexer_##scope##Top
114#define SCOPE_SIZE(scope)ctx->pMetaModelica_Lexer_scopeStack_limit ctx->pMetaModelica_Lexer_##scope##Stack_limit
115#define SCOPE_INSTANCE(scope, i)(ctx->pMetaModelica_Lexer_scopeStack->get(ctx->pMetaModelica_Lexer_scopeStack
,i))
(ctx->SCOPE_STACK(scope)pMetaModelica_Lexer_scopeStack->get(ctx->SCOPE_STACK(scope)pMetaModelica_Lexer_scopeStack,i))
116
117
118/* Macros for accessing things in a lexer
119 */
120#undef LEXERctx->pLexer
121#undef RECOGNIZERctx->pLexer->rec
122#undef RULEMEMOctx->pLexer->rec->state->ruleMemo
123#undef GETCHARINDEX
124#undef GETLINE
125#undef GETCHARPOSITIONINLINE
126#undef EMIT
127#undef EMITNEW
128#undef MATCHC
129#undef MATCHS
130#undef MATCHRANGE
131#undef LTOKENctx->pLexer->rec->state->token
132#undef HASFAILED
133#undef FAILEDFLAGctx->pLexer->rec->state->failed
134#undef INPUTctx->pLexer->input
135#undef STRSTREAMctx->pLexer->input
136#undef LA
137#undef HASEXCEPTION
138#undef EXCEPTIONctx->pLexer->rec->state->exception
139#undef CONSTRUCTEX
140#undef CONSUME
141#undef LRECOVER
142#undef MARK
143#undef REWIND
144#undef REWINDLAST
145#undef BACKTRACKINGctx->pLexer->rec->state->backtracking
146#undef MATCHANY
147#undef MEMOIZE
148#undef HAVEPARSEDRULE
149#undef GETTEXT
150#undef INDEX
151#undef SEEK
152#undef PUSHSTREAM
153#undef POPSTREAM
154#undef SETTEXT
155#undef SETTEXT8
156
157#define LEXERctx->pLexer ctx->pLexer
158#define RECOGNIZERctx->pLexer->rec LEXERctx->pLexer->rec
159#define LEXSTATEctx->pLexer->rec->state RECOGNIZERctx->pLexer->rec->state
160#define TOKSOURCEctx->pLexer->rec->state->tokSource LEXSTATEctx->pLexer->rec->state->tokSource
161#define GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer) LEXERctx->pLexer->getCharIndex(LEXERctx->pLexer)
162#define GETLINE()ctx->pLexer->getLine(ctx->pLexer) LEXERctx->pLexer->getLine(LEXERctx->pLexer)
163#define GETTEXT()ctx->pLexer->getText(ctx->pLexer) LEXERctx->pLexer->getText(LEXERctx->pLexer)
164#define GETCHARPOSITIONINLINE()ctx->pLexer->getCharPositionInLine(ctx->pLexer) LEXERctx->pLexer->getCharPositionInLine(LEXERctx->pLexer)
165#define EMIT()ctx->pLexer->rec->state->type = _type; ctx->pLexer
->emit(ctx->pLexer)
LEXSTATEctx->pLexer->rec->state->type = _type; LEXERctx->pLexer->emit(LEXERctx->pLexer)
166#define EMITNEW(t)ctx->pLexer->emitNew(ctx->pLexer, t) LEXERctx->pLexer->emitNew(LEXERctx->pLexer, t)
167#define MATCHC(c)ctx->pLexer->matchc(ctx->pLexer, c) LEXERctx->pLexer->matchc(LEXERctx->pLexer, c)
168#define MATCHS(s)ctx->pLexer->matchs(ctx->pLexer, s) LEXERctx->pLexer->matchs(LEXERctx->pLexer, s)
169#define MATCHRANGE(c1,c2)ctx->pLexer->matchRange(ctx->pLexer, c1, c2) LEXERctx->pLexer->matchRange(LEXERctx->pLexer, c1, c2)
170#define MATCHANY()ctx->pLexer->matchAny(ctx->pLexer) LEXERctx->pLexer->matchAny(LEXERctx->pLexer)
171#define LTOKENctx->pLexer->rec->state->token LEXSTATEctx->pLexer->rec->state->token
172#define HASFAILED()(ctx->pLexer->rec->state->failed == 1) (LEXSTATEctx->pLexer->rec->state->failed == ANTLR3_TRUE1)
173#define BACKTRACKINGctx->pLexer->rec->state->backtracking LEXSTATEctx->pLexer->rec->state->backtracking
174#define FAILEDFLAGctx->pLexer->rec->state->failed LEXSTATEctx->pLexer->rec->state->failed
175#define INPUTctx->pLexer->input LEXERctx->pLexer->input
176#define STRSTREAMctx->pLexer->input INPUTctx->pLexer->input
177#define ISTREAMctx->pLexer->input->istream INPUTctx->pLexer->input->istream
178#define INDEX()ctx->pLexer->input->istream->index(ctx->pLexer
->input->istream)
ISTREAMctx->pLexer->input->istream->index(ISTREAMctx->pLexer->input->istream)
179#define SEEK(n)ctx->pLexer->input->istream->seek(ctx->pLexer->
input->istream, n)
ISTREAMctx->pLexer->input->istream->seek(ISTREAMctx->pLexer->input->istream, n)
180#define EOF_TOKEN&(ctx->pLexer->rec->state->tokSource->eofToken
)
&(LEXSTATEctx->pLexer->rec->state->tokSource->eofToken)
181#define HASEXCEPTION()(ctx->pLexer->rec->state->error == 1) (LEXSTATEctx->pLexer->rec->state->error == ANTLR3_TRUE1)
182#define EXCEPTIONctx->pLexer->rec->state->exception LEXSTATEctx->pLexer->rec->state->exception
183#define CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
RECOGNIZERctx->pLexer->rec->exConstruct(RECOGNIZERctx->pLexer->rec)
184#define LRECOVER()ctx->pLexer->recover(ctx->pLexer) LEXERctx->pLexer->recover(LEXERctx->pLexer)
185#define MARK()ctx->pLexer->input->istream->mark(ctx->pLexer->
input->istream)
ISTREAMctx->pLexer->input->istream->mark(ISTREAMctx->pLexer->input->istream)
186#define REWIND(m)ctx->pLexer->input->istream->rewind(ctx->pLexer
->input->istream, m)
ISTREAMctx->pLexer->input->istream->rewind(ISTREAMctx->pLexer->input->istream, m)
187#define REWINDLAST()ctx->pLexer->input->istream->rewindLast(ctx->pLexer
->input->istream)
ISTREAMctx->pLexer->input->istream->rewindLast(ISTREAMctx->pLexer->input->istream)
188#define MEMOIZE(ri,si)ctx->pLexer->rec->memoize(ctx->pLexer->rec, ri
, si)
RECOGNIZERctx->pLexer->rec->memoize(RECOGNIZERctx->pLexer->rec, ri, si)
189#define HAVEPARSEDRULE(r)ctx->pLexer->rec->alreadyParsedRule(ctx->pLexer->
rec, r)
RECOGNIZERctx->pLexer->rec->alreadyParsedRule(RECOGNIZERctx->pLexer->rec, r)
190#define PUSHSTREAM(str)ctx->pLexer->pushCharStream(ctx->pLexer, str) LEXERctx->pLexer->pushCharStream(LEXERctx->pLexer, str)
191#define POPSTREAM()ctx->pLexer->popCharStream(ctx->pLexer) LEXERctx->pLexer->popCharStream(LEXERctx->pLexer)
192#define SETTEXT(str)ctx->pLexer->rec->state->text = str LEXSTATEctx->pLexer->rec->state->text = str
193#define SKIP()ctx->pLexer->rec->state->token = &(ctx->pLexer
->rec->state->tokSource->skipToken)
LEXSTATEctx->pLexer->rec->state->token = &(TOKSOURCEctx->pLexer->rec->state->tokSource->skipToken)
194#define USER1ctx->pLexer->rec->state->user1 LEXSTATEctx->pLexer->rec->state->user1
195#define USER2ctx->pLexer->rec->state->user2 LEXSTATEctx->pLexer->rec->state->user2
196#define USER3ctx->pLexer->rec->state->user3 LEXSTATEctx->pLexer->rec->state->user3
197#define CUSTOMctx->pLexer->rec->state->custom LEXSTATEctx->pLexer->rec->state->custom
198#define RULEMEMOctx->pLexer->rec->state->ruleMemo LEXSTATEctx->pLexer->rec->state->ruleMemo
199#define DBGctx->pLexer->rec->debugger RECOGNIZERctx->pLexer->rec->debugger
200
201/* If we have been told we can rely on the standard 8 bit or 16 bit input
202 * stream, then we can define our macros to use the direct pointers
203 * in the input object, which is much faster than indirect calls. This
204 * is really only significant to lexers with a lot of fragment rules (which
205 * do not place LA(1) in a temporary at the moment) and even then
206 * only if there is a lot of input (order of say 1M or so).
207 */
208#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
209
210# ifdef ANTLR3_INLINE_INPUT_ASCII
211
212/* 8 bit "ASCII" (actually any 8 bit character set) */
213
214# define NEXTCHAR ((pANTLR3_UINT8)(INPUTctx->pLexer->input->nextChar))
215# define DATAP ((pANTLR3_UINT8)(INPUTctx->pLexer->input->data))
216
217# else
218
219# define NEXTCHAR ((pANTLR3_UINT16)(INPUTctx->pLexer->input->nextChar))
220# define DATAP ((pANTLR3_UINT16)(INPUTctx->pLexer->input->data))
221
222# endif
223
224# 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)))
225# define CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
\
226{ \
227 if (NEXTCHAR < (DATAP + INPUTctx->pLexer->input->sizeBuf)) \
228 { \
229 INPUTctx->pLexer->input->charPositionInLine++; \
230 if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUTctx->pLexer->input->newlineChar) \
231 { \
232 INPUTctx->pLexer->input->line++; \
233 INPUTctx->pLexer->input->charPositionInLine = 0; \
234 INPUTctx->pLexer->input->currentLine = (void *)(NEXTCHAR + 1); \
235 } \
236 INPUTctx->pLexer->input->nextChar = (void *)(NEXTCHAR + 1); \
237 } \
238}
239
240#else
241
242// Pick up the input character by calling the input stream implementation.
243//
244#define CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
INPUTctx->pLexer->input->istream->consume(INPUTctx->pLexer->input->istream)
245#define LA(n)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, n)
INPUTctx->pLexer->input->istream->_LA(INPUTctx->pLexer->input->istream, n)
246
247#endif
248#define TOKTEXT(tok, txt)tok, (pANTLR3_UINT8)txt tok, (pANTLR3_UINT8)txt
249
250/* The 4 tokens defined below may well clash with your own #defines or token types. If so
251 * then for the present you must use different names for your defines as these are hard coded
252 * in the code generator. It would be better not to use such names internally, and maybe
253 * we can change this in a forthcoming release. I deliberately do not #undef these
254 * here as this will at least give you a redefined error somewhere if they clash.
255 */
256#define UP3 ANTLR3_TOKEN_UP3
257#define DOWN2 ANTLR3_TOKEN_DOWN2
258#define EORANTLR3_TOKEN_EOR ANTLR3_TOKEN_EOR
259#define INVALID0 ANTLR3_TOKEN_INVALID0
260
261
262/* =============================================================================
263 * Functions to create and destroy scopes. First come the rule scopes, followed
264 * by the global declared scopes.
265 */
266
267
268
269/* ============================================================================= */
270
271/* =============================================================================
272 * Start of recognizer
273 */
274
275
276/* Forward declare the locally static matching functions we have generated and any predicate functions.
277 */
278static ANTLR3_INLINE__inline__ void mAS (pMetaModelica_Lexer ctx);
279static ANTLR3_INLINE__inline__ void mCASE (pMetaModelica_Lexer ctx);
280static ANTLR3_INLINE__inline__ void mCONTINUE (pMetaModelica_Lexer ctx);
281static ANTLR3_INLINE__inline__ void mEQUALITY (pMetaModelica_Lexer ctx);
282static ANTLR3_INLINE__inline__ void mFAILURE (pMetaModelica_Lexer ctx);
283static ANTLR3_INLINE__inline__ void mGUARD (pMetaModelica_Lexer ctx);
284static ANTLR3_INLINE__inline__ void mLOCAL (pMetaModelica_Lexer ctx);
285static ANTLR3_INLINE__inline__ void mMATCH (pMetaModelica_Lexer ctx);
286static ANTLR3_INLINE__inline__ void mMATCHCONTINUE (pMetaModelica_Lexer ctx);
287static ANTLR3_INLINE__inline__ void mUNIONTYPE (pMetaModelica_Lexer ctx);
288static ANTLR3_INLINE__inline__ void mALLWILD (pMetaModelica_Lexer ctx);
289static ANTLR3_INLINE__inline__ void mWILD (pMetaModelica_Lexer ctx);
290static ANTLR3_INLINE__inline__ void mSUBTYPEOF (pMetaModelica_Lexer ctx);
291static ANTLR3_INLINE__inline__ void mCOLONCOLON (pMetaModelica_Lexer ctx);
292static ANTLR3_INLINE__inline__ void mMOD (pMetaModelica_Lexer ctx);
293static ANTLR3_INLINE__inline__ void mTRY (pMetaModelica_Lexer ctx);
294static ANTLR3_INLINE__inline__ void mEND_TRY (pMetaModelica_Lexer ctx);
295static ANTLR3_INLINE__inline__ void mEND_MATCH (pMetaModelica_Lexer ctx);
296static ANTLR3_INLINE__inline__ void mEND_MATCHCONTINUE (pMetaModelica_Lexer ctx);
297static ANTLR3_INLINE__inline__ void mSTAR (pMetaModelica_Lexer ctx);
298static ANTLR3_INLINE__inline__ void mMINUS (pMetaModelica_Lexer ctx);
299static ANTLR3_INLINE__inline__ void mPLUS (pMetaModelica_Lexer ctx);
300static ANTLR3_INLINE__inline__ void mLESS (pMetaModelica_Lexer ctx);
301static ANTLR3_INLINE__inline__ void mLESSEQ (pMetaModelica_Lexer ctx);
302static ANTLR3_INLINE__inline__ void mLESSGT (pMetaModelica_Lexer ctx);
303static ANTLR3_INLINE__inline__ void mGREATER (pMetaModelica_Lexer ctx);
304static ANTLR3_INLINE__inline__ void mGREATEREQ (pMetaModelica_Lexer ctx);
305static ANTLR3_INLINE__inline__ void mEQEQ (pMetaModelica_Lexer ctx);
306static ANTLR3_INLINE__inline__ void mPOWER (pMetaModelica_Lexer ctx);
307static ANTLR3_INLINE__inline__ void mSLASH (pMetaModelica_Lexer ctx);
308static ANTLR3_INLINE__inline__ void mPLUS_EW (pMetaModelica_Lexer ctx);
309static ANTLR3_INLINE__inline__ void mMINUS_EW (pMetaModelica_Lexer ctx);
310static ANTLR3_INLINE__inline__ void mSTAR_EW (pMetaModelica_Lexer ctx);
311static ANTLR3_INLINE__inline__ void mSLASH_EW (pMetaModelica_Lexer ctx);
312static ANTLR3_INLINE__inline__ void mPOWER_EW (pMetaModelica_Lexer ctx);
313static ANTLR3_INLINE__inline__ void mSTREAM (pMetaModelica_Lexer ctx);
314static ANTLR3_INLINE__inline__ void mIMPURE (pMetaModelica_Lexer ctx);
315static ANTLR3_INLINE__inline__ void mPARFOR (pMetaModelica_Lexer ctx);
316static ANTLR3_INLINE__inline__ void mT_PARALLEL (pMetaModelica_Lexer ctx);
317static ANTLR3_INLINE__inline__ void mT_LOCAL (pMetaModelica_Lexer ctx);
318static ANTLR3_INLINE__inline__ void mT_GLOBAL (pMetaModelica_Lexer ctx);
319static ANTLR3_INLINE__inline__ void mT_KERNEL (pMetaModelica_Lexer ctx);
320static ANTLR3_INLINE__inline__ void mEND_PARFOR (pMetaModelica_Lexer ctx);
321static ANTLR3_INLINE__inline__ void mTHREADED (pMetaModelica_Lexer ctx);
322static ANTLR3_INLINE__inline__ void mTokens (pMetaModelica_Lexer ctx);
323static void MetaModelica_LexerFree(pMetaModelica_Lexer ctx);
324
325/* =========================================================================
326 * Lexer matching rules end.
327 * =========================================================================
328 */
329
330
331
332static void
333MetaModelica_LexerFree (pMetaModelica_Lexer ctx)
334{
335 // Free the lexers that we delegated to
336 // functions to. NULL the state so we only free it once.
337 //
338 ctx->gBaseModelica_Lexer->pLexer->rec->state = NULL((void*)0);
339 ctx->gBaseModelica_Lexer->free(ctx->gBaseModelica_Lexer); LEXERctx->pLexer->free(LEXERctx->pLexer);
340
341 ANTLR3_FREE(ctx)free ((void *)(ctx));
342}
343
344/** \brief Name of the grammar file that generated this code
345 */
346static const char fileName[] = "MetaModelica_Lexer.g";
347
348/** \brief Return the name of the grammar file that generated this code.
349 */
350static const char * getGrammarFileName()
351{
352 return fileName;
353}
354
355/** \brief Create a new lexer called MetaModelica_Lexer
356 *
357 * \param[in] instream Pointer to an initialized input stream
358 * \return
359 * - Success pMetaModelica_Lexer initialized for the lex start
360 * - Fail NULL
361 */
362ANTLR3_API pMetaModelica_Lexer MetaModelica_LexerNew
363(pANTLR3_INPUT_STREAM instream)
364{
365 // See if we can create a new lexer with the standard constructor
366 //
367 return MetaModelica_LexerNewSSD(instream, NULL((void*)0));
368}
369
370/** \brief Create a new lexer called MetaModelica_Lexer
371 *
372 * \param[in] instream Pointer to an initialized input stream
373 * \param[state] state Previously created shared recognizer stat
374 * \return
375 * - Success pMetaModelica_Lexer initialized for the lex start
376 * - Fail NULL
377 */
378ANTLR3_API pMetaModelica_Lexer MetaModelica_LexerNewSSD
379(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
380{
381 pMetaModelica_Lexer ctx; // Context structure we will build and return
382
383 ctx = (pMetaModelica_Lexer) ANTLR3_CALLOC(1, sizeof(MetaModelica_Lexer))calloc (1, (size_t)(sizeof(MetaModelica_Lexer)));;
384
385 if (ctx == NULL((void*)0))
386 {
387 // Failed to allocate memory for lexer context
388 return NULL((void*)0);
389 }
390
391 /* -------------------------------------------------------------------
392 * Memory for basic structure is allocated, now to fill in
393 * in base ANTLR3 structures. We initialize the function pointers
394 * for the standard ANTLR3 lexer function set, but upon return
395 * from here, the programmer may set the pointers to provide custom
396 * implementations of each function.
397 *
398 * We don't use the macros defined in MetaModelica_Lexer.h here so you can get a sense
399 * of what goes where.
400 */
401
402 /* Create a base lexer, using the supplied input stream
403 */
404 ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT2049, instream, state);
405
406 /* Check that we allocated the memory correctly
407 */
408 if (ctx->pLexer == NULL((void*)0))
409 {
410 ANTLR3_FREE(ctx)free ((void *)(ctx));
411 return NULL((void*)0);
412 }
413 /* Install the implementation of our MetaModelica_Lexer interface
414 */
415 ctx->mAS = mAS;
416 ctx->mCASE = mCASE;
417 ctx->mCONTINUE = mCONTINUE;
418 ctx->mEQUALITY = mEQUALITY;
419 ctx->mFAILURE = mFAILURE;
420 ctx->mGUARD = mGUARD;
421 ctx->mLOCAL = mLOCAL;
422 ctx->mMATCH = mMATCH;
423 ctx->mMATCHCONTINUE = mMATCHCONTINUE;
424 ctx->mUNIONTYPE = mUNIONTYPE;
425 ctx->mALLWILD = mALLWILD;
426 ctx->mWILD = mWILD;
427 ctx->mSUBTYPEOF = mSUBTYPEOF;
428 ctx->mCOLONCOLON = mCOLONCOLON;
429 ctx->mMOD = mMOD;
430 ctx->mTRY = mTRY;
431 ctx->mEND_TRY = mEND_TRY;
432 ctx->mEND_MATCH = mEND_MATCH;
433 ctx->mEND_MATCHCONTINUE = mEND_MATCHCONTINUE;
434 ctx->mSTAR = mSTAR;
435 ctx->mMINUS = mMINUS;
436 ctx->mPLUS = mPLUS;
437 ctx->mLESS = mLESS;
438 ctx->mLESSEQ = mLESSEQ;
439 ctx->mLESSGT = mLESSGT;
440 ctx->mGREATER = mGREATER;
441 ctx->mGREATEREQ = mGREATEREQ;
442 ctx->mEQEQ = mEQEQ;
443 ctx->mPOWER = mPOWER;
444 ctx->mSLASH = mSLASH;
445 ctx->mPLUS_EW = mPLUS_EW;
446 ctx->mMINUS_EW = mMINUS_EW;
447 ctx->mSTAR_EW = mSTAR_EW;
448 ctx->mSLASH_EW = mSLASH_EW;
449 ctx->mPOWER_EW = mPOWER_EW;
450 ctx->mSTREAM = mSTREAM;
451 ctx->mIMPURE = mIMPURE;
452 ctx->mPARFOR = mPARFOR;
453 ctx->mT_PARALLEL = mT_PARALLEL;
454 ctx->mT_LOCAL = mT_LOCAL;
455 ctx->mT_GLOBAL = mT_GLOBAL;
456 ctx->mT_KERNEL = mT_KERNEL;
457 ctx->mEND_PARFOR = mEND_PARFOR;
458 ctx->mTHREADED = mTHREADED;
459 ctx->mTokens = mTokens;
460
461 /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
462 * it will call mTokens() in this generated code, and will pass it the ctx
463 * pointer of this lexer, not the context of the base lexer, so store that now.
464 */
465 ctx->pLexer->ctx = ctx;
466
467 /**Install the token matching function
468 */
469 ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
470
471 ctx->getGrammarFileName = getGrammarFileName;
472 ctx->free = MetaModelica_LexerFree;
473
474 // Initialize the lexers that we are going to delegate some
475 // functions to.
476 //
477 ctx->gBaseModelica_Lexer = MetaModelica_Lexer_BaseModelica_LexerNewSSD(instream, ctx->pLexer->rec->state, ctx);
478
479
480
481 /* Return the newly built lexer to the caller
482 */
483 return ctx;
484}
485
486/* =========================================================================
487 * DFA tables for the lexer
488 */
489/** Static dfa state tables for Cyclic dfa:
490 * 1:1: Tokens : ( AS | CASE | CONTINUE | EQUALITY | FAILURE | GUARD | LOCAL | MATCH | MATCHCONTINUE | UNIONTYPE | ALLWILD | WILD | SUBTYPEOF | COLONCOLON | MOD | TRY | END_TRY | END_MATCH | END_MATCHCONTINUE | STAR | MINUS | PLUS | LESS | LESSEQ | LESSGT | GREATER | GREATEREQ | EQEQ | POWER | SLASH | PLUS_EW | MINUS_EW | STAR_EW | SLASH_EW | POWER_EW | STREAM | IMPURE | PARFOR | T_PARALLEL | T_LOCAL | T_GLOBAL | T_KERNEL | END_PARFOR | THREADED | BaseModelica_Lexer. Tokens );
491 */
492static const ANTLR3_INT32 dfa1_eot[206] =
493 {
494 -1, 25, 25, 25, 25, 25, 25, 25, 25, 37, 25, 25, -1, 25, -1, -1, -1, 45,
495 47, 25, -1, 49, 25, 25, 25, -1, 57, 25, 25, 25, 25, 25, 25, 25, 25, 25,
496 67, -1, 25, 25, -1, 25, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
497 -1, 25, 25, -1, 25, 25, 25, 25, 25, 25, 25, 25, 25, -1, 25, 25, 93, 25,
498 -1, -1, -1, -1, -1, 25, 25, 101, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
499 25, 25, 25, -1, 25, 25, 25, 25, 25, 25, 25, -1, 25, 25, 25, 25, 25, 25,
500 25, 128, 129, 131, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
501 25, 25, 25, -1, -1, 25, -1, 25, 25, 151, 25, 153, 154, 25, 25, 25, 25,
502 25, 25, 161, 25, 25, 164, 25, 25, 25, -1, 25, -1, -1, 25, 25, 25, 25, 173,
503 174, -1, 25, 25, -1, 25, 25, 25, 180, 181, 182, 25, 25, -1, -1, 25, 187,
504 25, 189, 190, -1, -1, -1, 191, 192, 193, 25, -1, 25, -1, -1, -1, -1, -1,
505 25, 25, 25, 25, 25, 201, 25, -1, 25, 25, 205, -1
506 };
507static const ANTLR3_INT32 dfa1_eof[206] =
508 {
509 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
510 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
511 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
512 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
513 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
514 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
515 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
516 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
517 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
518 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
519 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
520 -1, -1, -1, -1, -1, -1, -1, -1
521 };
522static const ANTLR3_INT32 dfa1_min[206] =
523 {
524 9, 115, 97, 110, 97, 117, 111, 97, 110, 48, 116, 58, -1, 104, -1, -1, -1,
525 61, 61, 61, -1, 42, 42, 109, 97, -1, 48, 115, 110, 117, 100, 105, 97, 99,
526 116, 105, 48, -1, 98, 114, -1, 121, 114, -1, -1, -1, -1, -1, -1, -1, -1,
527 -1, -1, -1, -1, 112, 114, -1, 101, 116, 97, 9, 108, 114, 97, 99, 111, -1,
528 116, 101, 48, 101, -1, -1, -1, -1, -1, 117, 97, 48, 105, 108, 9, 9, 9,
529 9, 117, 100, 108, 104, 110, 121, 97, -1, 97, 114, 111, 108, 111, 108, 101,
530 -1, 110, 105, 114, 97, 97, 9, 114, 48, 48, 48, 116, 112, 109, 100, 101,
531 114, 108, 99, 111, 114, 117, 116, 121, 114, 116, 101, -1, -1, 111, -1,
532 121, 101, 48, 101, 48, 48, 101, 97, 98, 110, 101, 121, 48, 102, 99, 48,
533 110, 112, 111, -1, 100, -1, -1, 108, 108, 97, 101, 48, 48, -1, 111, 104,
534 -1, 116, 101, 102, 48, 48, 48, 108, 108, -1, -1, 114, 48, 105, 48, 48,
535 -1, -1, -1, 48, 48, 48, 111, -1, 110, -1, -1, -1, -1, -1, 110, 117, 116,
536 101, 105, 48, 110, -1, 117, 101, 48, -1
537 };
538static const ANTLR3_INT32 dfa1_max[206] =
539 {
540 239, 115, 111, 113, 97, 117, 111, 97, 110, 122, 117, 58, -1, 114, -1, -1,
541 -1, 62, 61, 61, -1, 47, 94, 109, 97, -1, 122, 115, 110, 117, 100, 105,
542 97, 99, 116, 105, 122, -1, 98, 114, -1, 121, 114, -1, -1, -1, -1, -1, -1,
543 -1, -1, -1, -1, -1, -1, 112, 114, -1, 101, 116, 97, 32, 108, 114, 97, 99,
544 111, -1, 116, 101, 122, 101, -1, -1, -1, -1, -1, 117, 108, 122, 105, 108,
545 116, 116, 116, 116, 117, 100, 108, 104, 110, 121, 97, -1, 97, 114, 111,
546 108, 111, 108, 101, -1, 110, 105, 114, 97, 97, 116, 114, 122, 122, 122,
547 116, 112, 109, 100, 101, 114, 108, 99, 111, 114, 117, 116, 121, 114, 116,
548 101, -1, -1, 111, -1, 121, 101, 122, 101, 122, 122, 101, 97, 98, 110, 101,
549 121, 122, 102, 99, 122, 110, 112, 111, -1, 100, -1, -1, 108, 108, 97, 101,
550 122, 122, -1, 111, 104, -1, 116, 101, 102, 122, 122, 122, 108, 108, -1,
551 -1, 114, 122, 105, 122, 122, -1, -1, -1, 122, 122, 122, 111, -1, 110, -1,
552 -1, -1, -1, -1, 110, 117, 116, 101, 105, 122, 110, -1, 117, 101, 122, -1
553 };
554static const ANTLR3_INT32 dfa1_accept[206] =
555 {
556 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 15, -1, 20, 21, 22, -1,
557 -1, -1, 29, -1, -1, -1, -1, 45, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
558 -1, 12, -1, -1, 14, -1, -1, 24, 25, 23, 27, 26, 28, 30, 31, 32, 33, 34,
559 35, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 11, -1, -1, -1, -1,
560 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
561 -1, -1, -1, 16, -1, -1, -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, -1, -1,
562 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
563 -1, -1, 6, 7, -1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
564 -1, -1, -1, -1, -1, -1, 36, -1, 37, 38, -1, -1, -1, -1, -1, -1, 17, -1,
565 -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, 3, 4, -1, -1, -1, -1, -1, 44, 39,
566 40, -1, -1, -1, -1, 18, -1, 10, 13, 41, 42, 43, -1, -1, -1, -1, -1, -1,
567 -1, 9, -1, -1, -1, 19
568 };
569static const ANTLR3_INT32 dfa1_special[206] =
570 {
571 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
572 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
573 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
574 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
575 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
576 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
577 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
578 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
579 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
580 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
581 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
582 -1, -1, -1, -1, -1, -1, -1, -1
583 };
584
585/** Used when there is no transition table entry for a particular state */
586#define dfa1_T_empty((void*)0) NULL((void*)0)
587
588static const ANTLR3_INT32 dfa1_T0[] =
589 {
590 60
591 };static const ANTLR3_INT32 dfa1_T1[] =
592 {
593 81
594 };static const ANTLR3_INT32 dfa1_T2[] =
595 {
596 103
597 };static const ANTLR3_INT32 dfa1_T3[] =
598 {
599 102
600 };static const ANTLR3_INT32 dfa1_T4[] =
601 {
602 122
603 };static const ANTLR3_INT32 dfa1_T5[] =
604 {
605 142
606 };static const ANTLR3_INT32 dfa1_T6[] =
607 {
608 159
609 };static const ANTLR3_INT32 dfa1_T7[] =
610 {
611 126
612 };static const ANTLR3_INT32 dfa1_T8[] =
613 {
614 123
615 };static const ANTLR3_INT32 dfa1_T9[] =
616 {
617 143
618 };static const ANTLR3_INT32 dfa1_T10[] =
619 {
620 160
621 };static const ANTLR3_INT32 dfa1_T11[] =
622 {
623 46
624 };static const ANTLR3_INT32 dfa1_T12[] =
625 {
626 86
627 };static const ANTLR3_INT32 dfa1_T13[] =
628 {
629 108
630 };static const ANTLR3_INT32 dfa1_T14[] =
631 {
632 127
633 };static const ANTLR3_INT32 dfa1_T15[] =
634 {
635 147
636 };static const ANTLR3_INT32 dfa1_T16[] =
637 {
638 40
639 };static const ANTLR3_INT32 dfa1_T17[] =
640 {
641 63
642 };static const ANTLR3_INT32 dfa1_T18[] =
643 {
644 87
645 };static const ANTLR3_INT32 dfa1_T19[] =
646 {
647 109
648 };static const ANTLR3_INT32 dfa1_T20[] =
649 {
650 88
651 };static const ANTLR3_INT32 dfa1_T21[] =
652 {
653 110
654 };static const ANTLR3_INT32 dfa1_T22[] =
655 {
656 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -1, -1, -1, -1, -1, -1, -1, 25,
657 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
658 25, 25, 25, 25, 25, 25, 25, -1, -1, -1, -1, 25, -1, 25, 25, 25, 25, 25,
659 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
660 25, 25, 25
661 };static const ANTLR3_INT32 dfa1_T23[] =
662 {
663 83, 85, -1, -1, 84, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
664 -1, -1, -1, -1, -1, 82, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
665 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
666 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
667 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
668 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 106, -1, -1, 105, -1, -1, -1, 104
669 };static const ANTLR3_INT32 dfa1_T24[] =
670 {
671 148
672 };static const ANTLR3_INT32 dfa1_T25[] =
673 {
674 165
675 };static const ANTLR3_INT32 dfa1_T26[] =
676 {
677 177
678 };static const ANTLR3_INT32 dfa1_T27[] =
679 {
680 188
681 };static const ANTLR3_INT32 dfa1_T28[] =
682 {
683 195
684 };static const ANTLR3_INT32 dfa1_T29[] =
685 {
686 197
687 };static const ANTLR3_INT32 dfa1_T30[] =
688 {
689 199
690 };static const ANTLR3_INT32 dfa1_T31[] =
691 {
692 90
693 };static const ANTLR3_INT32 dfa1_T32[] =
694 {
695 112
696 };static const ANTLR3_INT32 dfa1_T33[] =
697 {
698 132
699 };static const ANTLR3_INT32 dfa1_T34[] =
700 {
701 62
702 };static const ANTLR3_INT32 dfa1_T35[] =
703 {
704 97, -1, -1, -1, -1, 96, 99, -1, -1, -1, 100, 98
705 };static const ANTLR3_INT32 dfa1_T36[] =
706 {
707 149
708 };static const ANTLR3_INT32 dfa1_T37[] =
709 {
710 166
711 };static const ANTLR3_INT32 dfa1_T38[] =
712 {
713 178
714 };static const ANTLR3_INT32 dfa1_T39[] =
715 {
716 33
717 };static const ANTLR3_INT32 dfa1_T40[] =
718 {
719 27, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 28
720 };static const ANTLR3_INT32 dfa1_T41[] =
721 {
722 68
723 };static const ANTLR3_INT32 dfa1_T42[] =
724 {
725 91
726 };static const ANTLR3_INT32 dfa1_T43[] =
727 {
728 113
729 };static const ANTLR3_INT32 dfa1_T44[] =
730 {
731 71
732 };static const ANTLR3_INT32 dfa1_T45[] =
733 {
734 133
735 };static const ANTLR3_INT32 dfa1_T46[] =
736 {
737 150
738 };static const ANTLR3_INT32 dfa1_T47[] =
739 {
740 167
741 };static const ANTLR3_INT32 dfa1_T48[] =
742 {
743 179
744 };static const ANTLR3_INT32 dfa1_T49[] =
745 {
746 146
747 };static const ANTLR3_INT32 dfa1_T50[] =
748 {
749 163
750 };static const ANTLR3_INT32 dfa1_T51[] =
751 {
752 176
753 };static const ANTLR3_INT32 dfa1_T52[] =
754 {
755 59
756 };static const ANTLR3_INT32 dfa1_T53[] =
757 {
758 80
759 };static const ANTLR3_INT32 dfa1_T54[] =
760 {
761 25, -1, -1, -1, -1, 25
762 };static const ANTLR3_INT32 dfa1_T55[] =
763 {
764 83, 85, -1, -1, 84, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
765 -1, -1, -1, -1, -1, 82
766 };static const ANTLR3_INT32 dfa1_T56[] =
767 {
768 56
769 };static const ANTLR3_INT32 dfa1_T57[] =
770 {
771 30, -1, -1, 29
772 };static const ANTLR3_INT32 dfa1_T58[] =
773 {
774 124
775 };static const ANTLR3_INT32 dfa1_T59[] =
776 {
777 31
778 };static const ANTLR3_INT32 dfa1_T60[] =
779 {
780 61
781 };static const ANTLR3_INT32 dfa1_T61[] =
782 {
783 64
784 };static const ANTLR3_INT32 dfa1_T62[] =
785 {
786 83, 107, -1, -1, 84, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
787 -1, -1, -1, -1, -1, 82, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
788 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
789 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
790 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
791 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 106, -1, -1, 105, -1, -1, -1, 104
792 };static const ANTLR3_INT32 dfa1_T63[] =
793 {
794 55
795 };static const ANTLR3_INT32 dfa1_T64[] =
796 {
797 69
798 };static const ANTLR3_INT32 dfa1_T65[] =
799 {
800 92
801 };static const ANTLR3_INT32 dfa1_T66[] =
802 {
803 114
804 };static const ANTLR3_INT32 dfa1_T67[] =
805 {
806 134
807 };static const ANTLR3_INT32 dfa1_T68[] =
808 {
809 48
810 };static const ANTLR3_INT32 dfa1_T69[] =
811 {
812 144
813 };static const ANTLR3_INT32 dfa1_T70[] =
814 {
815 116
816 };static const ANTLR3_INT32 dfa1_T71[] =
817 {
818 136
819 };static const ANTLR3_INT32 dfa1_T72[] =
820 {
821 117
822 };static const ANTLR3_INT32 dfa1_T73[] =
823 {
824 137
825 };static const ANTLR3_INT32 dfa1_T74[] =
826 {
827 78
828 };static const ANTLR3_INT32 dfa1_T75[] =
829 {
830 138
831 };static const ANTLR3_INT32 dfa1_T76[] =
832 {
833 155
834 };static const ANTLR3_INT32 dfa1_T77[] =
835 {
836 169
837 };static const ANTLR3_INT32 dfa1_T78[] =
838 {
839 194
840 };static const ANTLR3_INT32 dfa1_T79[] =
841 {
842 35
843 };static const ANTLR3_INT32 dfa1_T80[] =
844 {
845 196
846 };static const ANTLR3_INT32 dfa1_T81[] =
847 {
848 119
849 };static const ANTLR3_INT32 dfa1_T82[] =
850 {
851 198
852 };static const ANTLR3_INT32 dfa1_T83[] =
853 {
854 139
855 };static const ANTLR3_INT32 dfa1_T84[] =
856 {
857 200
858 };static const ANTLR3_INT32 dfa1_T85[] =
859 {
860 156
861 };static const ANTLR3_INT32 dfa1_T86[] =
862 {
863 202
864 };static const ANTLR3_INT32 dfa1_T87[] =
865 {
866 170
867 };static const ANTLR3_INT32 dfa1_T88[] =
868 {
869 203
870 };static const ANTLR3_INT32 dfa1_T89[] =
871 {
872 204
873 };static const ANTLR3_INT32 dfa1_T90[] =
874 {
875 120
876 };static const ANTLR3_INT32 dfa1_T91[] =
877 {
878 140
879 };static const ANTLR3_INT32 dfa1_T92[] =
880 {
881 157
882 };static const ANTLR3_INT32 dfa1_T93[] =
883 {
884 171
885 };static const ANTLR3_INT32 dfa1_T94[] =
886 {
887 183
888 };static const ANTLR3_INT32 dfa1_T95[] =
889 {
890 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -1, -1, -1, -1, -1, -1, -1, 25,
891 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
892 25, 25, 25, 25, 25, 25, 25, -1, -1, -1, -1, 25, -1, 25, 25, 186, 25, 25,
893 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
894 25, 25, 25
895 };static const ANTLR3_INT32 dfa1_T96[] =
896 {
897 121
898 };static const ANTLR3_INT32 dfa1_T97[] =
899 {
900 65
901 };static const ANTLR3_INT32 dfa1_T98[] =
902 {
903 141
904 };static const ANTLR3_INT32 dfa1_T99[] =
905 {
906 158
907 };static const ANTLR3_INT32 dfa1_T100[] =
908 {
909 89
910 };static const ANTLR3_INT32 dfa1_T101[] =
911 {
912 172
913 };static const ANTLR3_INT32 dfa1_T102[] =
914 {
915 184
916 };static const ANTLR3_INT32 dfa1_T103[] =
917 {
918 111
919 };static const ANTLR3_INT32 dfa1_T104[] =
920 {
921 52, 50, -1, 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
922 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
923 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 54
924 };static const ANTLR3_INT32 dfa1_T105[] =
925 {
926 94
927 };static const ANTLR3_INT32 dfa1_T106[] =
928 {
929 115
930 };static const ANTLR3_INT32 dfa1_T107[] =
931 {
932 135
933 };static const ANTLR3_INT32 dfa1_T108[] =
934 {
935 152
936 };static const ANTLR3_INT32 dfa1_T109[] =
937 {
938 168
939 };static const ANTLR3_INT32 dfa1_T110[] =
940 {
941 77
942 };static const ANTLR3_INT32 dfa1_T111[] =
943 {
944 95
945 };static const ANTLR3_INT32 dfa1_T112[] =
946 {
947 34
948 };static const ANTLR3_INT32 dfa1_T113[] =
949 {
950 125
951 };static const ANTLR3_INT32 dfa1_T114[] =
952 {
953 43, 44
954 };static const ANTLR3_INT32 dfa1_T115[] =
955 {
956 66
957 };static const ANTLR3_INT32 dfa1_T116[] =
958 {
959 25, 25, -1, -1, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
960 -1, -1, -1, -1, -1, 25, 25, 25, -1, 25, 12, 25, 25, 25, 25, 14, 16, 25,
961 15, 22, 21, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 11, 25, 17, 19, 18,
962 -1, -1, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
963 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -1, 25, 20, 9, -1, 1, 25, 2,
964 25, 3, 4, 5, 25, 23, 25, 25, 6, 7, 25, 25, 24, 25, 25, 10, 13, 8, 25, 25,
965 25, 25, 25, 25, 25, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
966 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
967 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
968 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
969 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
970 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
971 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 25
972 };static const ANTLR3_INT32 dfa1_T117[] =
973 {
974 42, -1, -1, -1, -1, -1, -1, -1, -1, -1, 41
975 };static const ANTLR3_INT32 dfa1_T118[] =
976 {
977 70
978 };static const ANTLR3_INT32 dfa1_T119[] =
979 {
980 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -1, -1, -1, -1, -1, -1, -1, 25,
981 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
982 25, 25, 25, 25, 25, 25, 25, -1, -1, -1, -1, 25, -1, 25, 25, 130, 25, 25,
983 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
984 25, 25, 25
985 };static const ANTLR3_INT32 dfa1_T120[] =
986 {
987 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -1, -1, -1, -1, -1, -1, -1, 25,
988 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
989 25, 25, 25, 25, 25, 25, 25, -1, -1, -1, -1, 36, -1, 25, 25, 25, 25, 25,
990 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
991 25, 25, 25
992 };static const ANTLR3_INT32 dfa1_T121[] =
993 {
994 145
995 };static const ANTLR3_INT32 dfa1_T122[] =
996 {
997 162
998 };static const ANTLR3_INT32 dfa1_T123[] =
999 {
1000 175
1001 };static const ANTLR3_INT32 dfa1_T124[] =
1002 {
1003 39, 38
1004 };static const ANTLR3_INT32 dfa1_T125[] =
1005 {
1006 185
1007 };static const ANTLR3_INT32 dfa1_T126[] =
1008 {
1009 32
1010 };static const ANTLR3_INT32 dfa1_T127[] =
1011 {
1012 26
1013 };static const ANTLR3_INT32 dfa1_T128[] =
1014 {
1015 118
1016 };static const ANTLR3_INT32 dfa1_T129[] =
1017 {
1018 58
1019 };static const ANTLR3_INT32 dfa1_T130[] =
1020 {
1021 79
1022 };
1023
1024/* Transition tables are a table of sub tables, with some tables
1025 * reused for efficiency.
1026 */
1027static const ANTLR3_INT32 * const dfa1_transitions[] =
1028{
1029 dfa1_T116, dfa1_T127, dfa1_T40, dfa1_T57, dfa1_T59, dfa1_T126, dfa1_T39,
1030 dfa1_T112, dfa1_T79, dfa1_T120, dfa1_T124, dfa1_T16, dfa1_T_empty((void*)0), dfa1_T117,
1031 dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T114, dfa1_T11, dfa1_T68,
1032 dfa1_T_empty((void*)0), dfa1_T54, dfa1_T104, dfa1_T63, dfa1_T56, dfa1_T_empty((void*)0),
1033 dfa1_T22, dfa1_T129, dfa1_T52, dfa1_T0, dfa1_T60, dfa1_T34, dfa1_T17,
1034 dfa1_T61, dfa1_T97, dfa1_T115, dfa1_T22, dfa1_T_empty((void*)0), dfa1_T41, dfa1_T64,
1035 dfa1_T_empty((void*)0), dfa1_T118, dfa1_T44, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0),
1036 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),
1037 dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T110, dfa1_T74,
1038 dfa1_T_empty((void*)0), dfa1_T130, dfa1_T53, dfa1_T1, dfa1_T55, dfa1_T12, dfa1_T18,
1039 dfa1_T20, dfa1_T100, dfa1_T31, dfa1_T_empty((void*)0), dfa1_T42, dfa1_T65, dfa1_T22,
1040 dfa1_T105, 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),
1041 dfa1_T111, dfa1_T35, dfa1_T22, dfa1_T3, dfa1_T2, dfa1_T23, dfa1_T23,
1042 dfa1_T62, dfa1_T23, dfa1_T13, dfa1_T19, dfa1_T21, dfa1_T103, dfa1_T32,
1043 dfa1_T43, dfa1_T66, dfa1_T_empty((void*)0), dfa1_T106, dfa1_T70, dfa1_T72, dfa1_T128,
1044 dfa1_T81, dfa1_T90, dfa1_T96, dfa1_T_empty((void*)0), dfa1_T4, dfa1_T8, dfa1_T58,
1045 dfa1_T113, dfa1_T7, dfa1_T23, dfa1_T14, dfa1_T22, dfa1_T22, dfa1_T119,
1046 dfa1_T33, dfa1_T45, dfa1_T67, dfa1_T107, dfa1_T71, dfa1_T73, dfa1_T75,
1047 dfa1_T83, dfa1_T91, dfa1_T98, dfa1_T5, dfa1_T9, dfa1_T69, dfa1_T121,
1048 dfa1_T49, dfa1_T15, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T24, dfa1_T_empty((void*)0),
1049 dfa1_T36, dfa1_T46, dfa1_T22, dfa1_T108, dfa1_T22, dfa1_T22, dfa1_T76,
1050 dfa1_T85, dfa1_T92, dfa1_T99, dfa1_T6, dfa1_T10, dfa1_T22, dfa1_T122,
1051 dfa1_T50, dfa1_T22, dfa1_T25, dfa1_T37, dfa1_T47, dfa1_T_empty((void*)0), dfa1_T109,
1052 dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T77, dfa1_T87, dfa1_T93, dfa1_T101,
1053 dfa1_T22, dfa1_T22, dfa1_T_empty((void*)0), dfa1_T123, dfa1_T51, dfa1_T_empty((void*)0),
1054 dfa1_T26, dfa1_T38, dfa1_T48, dfa1_T22, dfa1_T22, dfa1_T22, dfa1_T94,
1055 dfa1_T102, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T125, dfa1_T95, dfa1_T27,
1056 dfa1_T22, dfa1_T22, dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T22,
1057 dfa1_T22, dfa1_T22, dfa1_T78, dfa1_T_empty((void*)0), dfa1_T28, dfa1_T_empty((void*)0),
1058 dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T_empty((void*)0), dfa1_T80, dfa1_T29,
1059 dfa1_T82, dfa1_T30, dfa1_T84, dfa1_T22, dfa1_T86, dfa1_T_empty((void*)0), dfa1_T88,
1060 dfa1_T89, dfa1_T22, dfa1_T_empty((void*)0)
1061};
1062
1063
1064/* Declare tracking structure for Cyclic DFA 1
1065 */
1066static
1067ANTLR3_CYCLIC_DFA cdfa1
1068 = {
1069 1, /* Decision number of this dfa */
1070 /* Which decision this represents: */
1071 (const pANTLR3_UCHAR)"1:1: Tokens : ( AS | CASE | CONTINUE | EQUALITY | FAILURE | GUARD | LOCAL | MATCH | MATCHCONTINUE | UNIONTYPE | ALLWILD | WILD | SUBTYPEOF | COLONCOLON | MOD | TRY | END_TRY | END_MATCH | END_MATCHCONTINUE | STAR | MINUS | PLUS | LESS | LESSEQ | LESSGT | GREATER | GREATEREQ | EQEQ | POWER | SLASH | PLUS_EW | MINUS_EW | STAR_EW | SLASH_EW | POWER_EW | STREAM | IMPURE | PARFOR | T_PARALLEL | T_LOCAL | T_GLOBAL | T_KERNEL | END_PARFOR | THREADED | BaseModelica_Lexer. Tokens );",
1072 (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition, /* Default special state transition function */
1073 antlr3dfaspecialTransition, /* DFA specialTransition is currently just a default function in the runtime */
1074 antlr3dfapredict, /* DFA simulator function is in the runtime */
1075 dfa1_eot, /* EOT table */
1076 dfa1_eof, /* EOF table */
1077 dfa1_min, /* Minimum tokens for each state */
1078 dfa1_max, /* Maximum tokens for each state */
1079 dfa1_accept, /* Accept table */
1080 dfa1_special, /* Special transition states */
1081 dfa1_transitions /* Table of transition tables */
1082
1083 };
1084/* End of Cyclic DFA 1
1085 * ---------------------
1086 */
1087/* =========================================================================
1088 * End of DFA tables for the lexer
1089 */
1090
1091/* =========================================================================
1092 * Functions to match the lexer grammar defined tokens from the input stream
1093 */
1094
1095// Comes from: 45:4: ( 'as' )
1096/** \brief Lexer rule generated by ANTLR3
1097 *
1098 * $ANTLR start AS
1099 *
1100 * Looks to match the characters the constitute the token AS
1101 * from the attached input stream.
1102 *
1103 *
1104 * \remark
1105 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1106 */
1107static ANTLR3_INLINE__inline__
1108void mAS(pMetaModelica_Lexer ctx)
1109{
1110 ANTLR3_UINT32 _type;
1111
1112 _type = AS80;
1113
1114
1115 // MetaModelica_Lexer.g:45:4: ( 'as' )
1116 // MetaModelica_Lexer.g:45:6: 'as'
1117 {
1118 MATCHS(lit_1)ctx->pLexer->matchs(ctx->pLexer, lit_1);
1119 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1120 {
1121 goto ruleASEx;
1122 }
1123
1124
1125
1126 }
1127
1128 LEXSTATEctx->pLexer->rec->state->type = _type;
1129
1130 // This is where rules clean up and exit
1131 //
1132 goto ruleASEx; /* Prevent compiler warnings */
1133 ruleASEx: ;
1134
1135}
1136// $ANTLR end AS
1137
1138// Comes from: 46:6: ( 'case' )
1139/** \brief Lexer rule generated by ANTLR3
1140 *
1141 * $ANTLR start CASE
1142 *
1143 * Looks to match the characters the constitute the token CASE
1144 * from the attached input stream.
1145 *
1146 *
1147 * \remark
1148 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1149 */
1150static ANTLR3_INLINE__inline__
1151void mCASE(pMetaModelica_Lexer ctx)
1152{
1153 ANTLR3_UINT32 _type;
1154
1155 _type = CASE81;
1156
1157
1158 // MetaModelica_Lexer.g:46:6: ( 'case' )
1159 // MetaModelica_Lexer.g:46:8: 'case'
1160 {
1161 MATCHS(lit_2)ctx->pLexer->matchs(ctx->pLexer, lit_2);
1162 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1163 {
1164 goto ruleCASEEx;
1165 }
1166
1167
1168
1169 }
1170
1171 LEXSTATEctx->pLexer->rec->state->type = _type;
1172
1173 // This is where rules clean up and exit
1174 //
1175 goto ruleCASEEx; /* Prevent compiler warnings */
1176 ruleCASEEx: ;
1177
1178}
1179// $ANTLR end CASE
1180
1181// Comes from: 47:10: ( 'continue' )
1182/** \brief Lexer rule generated by ANTLR3
1183 *
1184 * $ANTLR start CONTINUE
1185 *
1186 * Looks to match the characters the constitute the token CONTINUE
1187 * from the attached input stream.
1188 *
1189 *
1190 * \remark
1191 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1192 */
1193static ANTLR3_INLINE__inline__
1194void mCONTINUE(pMetaModelica_Lexer ctx)
1195{
1196 ANTLR3_UINT32 _type;
1197
1198 _type = CONTINUE17;
1199
1200
1201 // MetaModelica_Lexer.g:47:10: ( 'continue' )
1202 // MetaModelica_Lexer.g:47:12: 'continue'
1203 {
1204 MATCHS(lit_3)ctx->pLexer->matchs(ctx->pLexer, lit_3);
1205 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1206 {
1207 goto ruleCONTINUEEx;
1208 }
1209
1210
1211
1212 }
1213
1214 LEXSTATEctx->pLexer->rec->state->type = _type;
1215
1216 // This is where rules clean up and exit
1217 //
1218 goto ruleCONTINUEEx; /* Prevent compiler warnings */
1219 ruleCONTINUEEx: ;
1220
1221}
1222// $ANTLR end CONTINUE
1223
1224// Comes from: 48:10: ( 'equality' )
1225/** \brief Lexer rule generated by ANTLR3
1226 *
1227 * $ANTLR start EQUALITY
1228 *
1229 * Looks to match the characters the constitute the token EQUALITY
1230 * from the attached input stream.
1231 *
1232 *
1233 * \remark
1234 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1235 */
1236static ANTLR3_INLINE__inline__
1237void mEQUALITY(pMetaModelica_Lexer ctx)
1238{
1239 ANTLR3_UINT32 _type;
1240
1241 _type = EQUALITY82;
1242
1243
1244 // MetaModelica_Lexer.g:48:10: ( 'equality' )
1245 // MetaModelica_Lexer.g:48:12: 'equality'
1246 {
1247 MATCHS(lit_4)ctx->pLexer->matchs(ctx->pLexer, lit_4);
1248 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1249 {
1250 goto ruleEQUALITYEx;
1251 }
1252
1253
1254
1255 }
1256
1257 LEXSTATEctx->pLexer->rec->state->type = _type;
1258
1259 // This is where rules clean up and exit
1260 //
1261 goto ruleEQUALITYEx; /* Prevent compiler warnings */
1262 ruleEQUALITYEx: ;
1263
1264}
1265// $ANTLR end EQUALITY
1266
1267// Comes from: 49:9: ( 'failure' )
1268/** \brief Lexer rule generated by ANTLR3
1269 *
1270 * $ANTLR start FAILURE
1271 *
1272 * Looks to match the characters the constitute the token FAILURE
1273 * from the attached input stream.
1274 *
1275 *
1276 * \remark
1277 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1278 */
1279static ANTLR3_INLINE__inline__
1280void mFAILURE(pMetaModelica_Lexer ctx)
1281{
1282 ANTLR3_UINT32 _type;
1283
1284 _type = FAILURE83;
1285
1286
1287 // MetaModelica_Lexer.g:49:9: ( 'failure' )
1288 // MetaModelica_Lexer.g:49:11: 'failure'
1289 {
1290 MATCHS(lit_5)ctx->pLexer->matchs(ctx->pLexer, lit_5);
1291 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1292 {
1293 goto ruleFAILUREEx;
1294 }
1295
1296
1297
1298 }
1299
1300 LEXSTATEctx->pLexer->rec->state->type = _type;
1301
1302 // This is where rules clean up and exit
1303 //
1304 goto ruleFAILUREEx; /* Prevent compiler warnings */
1305 ruleFAILUREEx: ;
1306
1307}
1308// $ANTLR end FAILURE
1309
1310// Comes from: 50:7: ( 'guard' )
1311/** \brief Lexer rule generated by ANTLR3
1312 *
1313 * $ANTLR start GUARD
1314 *
1315 * Looks to match the characters the constitute the token GUARD
1316 * from the attached input stream.
1317 *
1318 *
1319 * \remark
1320 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1321 */
1322static ANTLR3_INLINE__inline__
1323void mGUARD(pMetaModelica_Lexer ctx)
1324{
1325 ANTLR3_UINT32 _type;
1326
1327 _type = GUARD84;
1328
1329
1330 // MetaModelica_Lexer.g:50:7: ( 'guard' )
1331 // MetaModelica_Lexer.g:50:9: 'guard'
1332 {
1333 MATCHS(lit_6)ctx->pLexer->matchs(ctx->pLexer, lit_6);
1334 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1335 {
1336 goto ruleGUARDEx;
1337 }
1338
1339
1340
1341 }
1342
1343 LEXSTATEctx->pLexer->rec->state->type = _type;
1344
1345 // This is where rules clean up and exit
1346 //
1347 goto ruleGUARDEx; /* Prevent compiler warnings */
1348 ruleGUARDEx: ;
1349
1350}
1351// $ANTLR end GUARD
1352
1353// Comes from: 51:7: ( 'local' )
1354/** \brief Lexer rule generated by ANTLR3
1355 *
1356 * $ANTLR start LOCAL
1357 *
1358 * Looks to match the characters the constitute the token LOCAL
1359 * from the attached input stream.
1360 *
1361 *
1362 * \remark
1363 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1364 */
1365static ANTLR3_INLINE__inline__
1366void mLOCAL(pMetaModelica_Lexer ctx)
1367{
1368 ANTLR3_UINT32 _type;
1369
1370 _type = LOCAL85;
1371
1372
1373 // MetaModelica_Lexer.g:51:7: ( 'local' )
1374 // MetaModelica_Lexer.g:51:9: 'local'
1375 {
1376 MATCHS(lit_7)ctx->pLexer->matchs(ctx->pLexer, lit_7);
1377 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1378 {
1379 goto ruleLOCALEx;
1380 }
1381
1382
1383
1384 }
1385
1386 LEXSTATEctx->pLexer->rec->state->type = _type;
1387
1388 // This is where rules clean up and exit
1389 //
1390 goto ruleLOCALEx; /* Prevent compiler warnings */
1391 ruleLOCALEx: ;
1392
1393}
1394// $ANTLR end LOCAL
1395
1396// Comes from: 52:7: ( 'match' )
1397/** \brief Lexer rule generated by ANTLR3
1398 *
1399 * $ANTLR start MATCH
1400 *
1401 * Looks to match the characters the constitute the token MATCH
1402 * from the attached input stream.
1403 *
1404 *
1405 * \remark
1406 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1407 */
1408static ANTLR3_INLINE__inline__
1409void mMATCH(pMetaModelica_Lexer ctx)
1410{
1411 ANTLR3_UINT32 _type;
1412
1413 _type = MATCH86;
1414
1415
1416 // MetaModelica_Lexer.g:52:7: ( 'match' )
1417 // MetaModelica_Lexer.g:52:9: 'match'
1418 {
1419 MATCHS(lit_8)ctx->pLexer->matchs(ctx->pLexer, lit_8);
1420 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1421 {
1422 goto ruleMATCHEx;
1423 }
1424
1425
1426
1427 }
1428
1429 LEXSTATEctx->pLexer->rec->state->type = _type;
1430
1431 // This is where rules clean up and exit
1432 //
1433 goto ruleMATCHEx; /* Prevent compiler warnings */
1434 ruleMATCHEx: ;
1435
1436}
1437// $ANTLR end MATCH
1438
1439// Comes from: 53:15: ( 'matchcontinue' )
1440/** \brief Lexer rule generated by ANTLR3
1441 *
1442 * $ANTLR start MATCHCONTINUE
1443 *
1444 * Looks to match the characters the constitute the token MATCHCONTINUE
1445 * from the attached input stream.
1446 *
1447 *
1448 * \remark
1449 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1450 */
1451static ANTLR3_INLINE__inline__
1452void mMATCHCONTINUE(pMetaModelica_Lexer ctx)
1453{
1454 ANTLR3_UINT32 _type;
1455
1456 _type = MATCHCONTINUE87;
1457
1458
1459 // MetaModelica_Lexer.g:53:15: ( 'matchcontinue' )
1460 // MetaModelica_Lexer.g:53:17: 'matchcontinue'
1461 {
1462 MATCHS(lit_9)ctx->pLexer->matchs(ctx->pLexer, lit_9);
1463 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1464 {
1465 goto ruleMATCHCONTINUEEx;
1466 }
1467
1468
1469
1470 }
1471
1472 LEXSTATEctx->pLexer->rec->state->type = _type;
1473
1474 // This is where rules clean up and exit
1475 //
1476 goto ruleMATCHCONTINUEEx; /* Prevent compiler warnings */
1477 ruleMATCHCONTINUEEx: ;
1478
1479}
1480// $ANTLR end MATCHCONTINUE
1481
1482// Comes from: 54:11: ( 'uniontype' )
1483/** \brief Lexer rule generated by ANTLR3
1484 *
1485 * $ANTLR start UNIONTYPE
1486 *
1487 * Looks to match the characters the constitute the token UNIONTYPE
1488 * from the attached input stream.
1489 *
1490 *
1491 * \remark
1492 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1493 */
1494static ANTLR3_INLINE__inline__
1495void mUNIONTYPE(pMetaModelica_Lexer ctx)
1496{
1497 ANTLR3_UINT32 _type;
1498
1499 _type = UNIONTYPE92;
1500
1501
1502 // MetaModelica_Lexer.g:54:11: ( 'uniontype' )
1503 // MetaModelica_Lexer.g:54:13: 'uniontype'
1504 {
1505 MATCHS(lit_10)ctx->pLexer->matchs(ctx->pLexer, lit_10);
1506 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1507 {
1508 goto ruleUNIONTYPEEx;
1509 }
1510
1511
1512
1513 }
1514
1515 LEXSTATEctx->pLexer->rec->state->type = _type;
1516
1517 // This is where rules clean up and exit
1518 //
1519 goto ruleUNIONTYPEEx; /* Prevent compiler warnings */
1520 ruleUNIONTYPEEx: ;
1521
1522}
1523// $ANTLR end UNIONTYPE
1524
1525// Comes from: 55:9: ( '__' )
1526/** \brief Lexer rule generated by ANTLR3
1527 *
1528 * $ANTLR start ALLWILD
1529 *
1530 * Looks to match the characters the constitute the token ALLWILD
1531 * from the attached input stream.
1532 *
1533 *
1534 * \remark
1535 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1536 */
1537static ANTLR3_INLINE__inline__
1538void mALLWILD(pMetaModelica_Lexer ctx)
1539{
1540 ANTLR3_UINT32 _type;
1541
1542 _type = ALLWILD94;
1543
1544
1545 // MetaModelica_Lexer.g:55:9: ( '__' )
1546 // MetaModelica_Lexer.g:55:11: '__'
1547 {
1548 MATCHS(lit_11)ctx->pLexer->matchs(ctx->pLexer, lit_11);
1549 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1550 {
1551 goto ruleALLWILDEx;
1552 }
1553
1554
1555
1556 }
1557
1558 LEXSTATEctx->pLexer->rec->state->type = _type;
1559
1560 // This is where rules clean up and exit
1561 //
1562 goto ruleALLWILDEx; /* Prevent compiler warnings */
1563 ruleALLWILDEx: ;
1564
1565}
1566// $ANTLR end ALLWILD
1567
1568// Comes from: 56:6: ( '_' )
1569/** \brief Lexer rule generated by ANTLR3
1570 *
1571 * $ANTLR start WILD
1572 *
1573 * Looks to match the characters the constitute the token WILD
1574 * from the attached input stream.
1575 *
1576 *
1577 * \remark
1578 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1579 */
1580static ANTLR3_INLINE__inline__
1581void mWILD(pMetaModelica_Lexer ctx)
1582{
1583 ANTLR3_UINT32 _type;
1584
1585 _type = WILD93;
1586
1587
1588 // MetaModelica_Lexer.g:56:6: ( '_' )
1589 // MetaModelica_Lexer.g:56:8: '_'
1590 {
1591 MATCHC('_')ctx->pLexer->matchc(ctx->pLexer, '_');
1592 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1593 {
1594 goto ruleWILDEx;
1595 }
1596
1597
1598 }
1599
1600 LEXSTATEctx->pLexer->rec->state->type = _type;
1601
1602 // This is where rules clean up and exit
1603 //
1604 goto ruleWILDEx; /* Prevent compiler warnings */
1605 ruleWILDEx: ;
1606
1607}
1608// $ANTLR end WILD
1609
1610// Comes from: 57:11: ( 'subtypeof' )
1611/** \brief Lexer rule generated by ANTLR3
1612 *
1613 * $ANTLR start SUBTYPEOF
1614 *
1615 * Looks to match the characters the constitute the token SUBTYPEOF
1616 * from the attached input stream.
1617 *
1618 *
1619 * \remark
1620 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1621 */
1622static ANTLR3_INLINE__inline__
1623void mSUBTYPEOF(pMetaModelica_Lexer ctx)
1624{
1625 ANTLR3_UINT32 _type;
1626
1627 _type = SUBTYPEOF88;
1628
1629
1630 // MetaModelica_Lexer.g:57:11: ( 'subtypeof' )
1631 // MetaModelica_Lexer.g:57:13: 'subtypeof'
1632 {
1633 MATCHS(lit_12)ctx->pLexer->matchs(ctx->pLexer, lit_12);
1634 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1635 {
1636 goto ruleSUBTYPEOFEx;
1637 }
1638
1639
1640
1641 }
1642
1643 LEXSTATEctx->pLexer->rec->state->type = _type;
1644
1645 // This is where rules clean up and exit
1646 //
1647 goto ruleSUBTYPEOFEx; /* Prevent compiler warnings */
1648 ruleSUBTYPEOFEx: ;
1649
1650}
1651// $ANTLR end SUBTYPEOF
1652
1653// Comes from: 58:12: ( '::' )
1654/** \brief Lexer rule generated by ANTLR3
1655 *
1656 * $ANTLR start COLONCOLON
1657 *
1658 * Looks to match the characters the constitute the token COLONCOLON
1659 * from the attached input stream.
1660 *
1661 *
1662 * \remark
1663 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1664 */
1665static ANTLR3_INLINE__inline__
1666void mCOLONCOLON(pMetaModelica_Lexer ctx)
1667{
1668 ANTLR3_UINT32 _type;
1669
1670 _type = COLONCOLON122;
1671
1672
1673 // MetaModelica_Lexer.g:58:12: ( '::' )
1674 // MetaModelica_Lexer.g:58:14: '::'
1675 {
1676 MATCHS(lit_13)ctx->pLexer->matchs(ctx->pLexer, lit_13);
1677 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1678 {
1679 goto ruleCOLONCOLONEx;
1680 }
1681
1682
1683
1684 }
1685
1686 LEXSTATEctx->pLexer->rec->state->type = _type;
1687
1688 // This is where rules clean up and exit
1689 //
1690 goto ruleCOLONCOLONEx; /* Prevent compiler warnings */
1691 ruleCOLONCOLONEx: ;
1692
1693}
1694// $ANTLR end COLONCOLON
1695
1696// Comes from: 59:5: ( '%' )
1697/** \brief Lexer rule generated by ANTLR3
1698 *
1699 * $ANTLR start MOD
1700 *
1701 * Looks to match the characters the constitute the token MOD
1702 * from the attached input stream.
1703 *
1704 *
1705 * \remark
1706 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1707 */
1708static ANTLR3_INLINE__inline__
1709void mMOD(pMetaModelica_Lexer ctx)
1710{
1711 ANTLR3_UINT32 _type;
1712
1713 _type = MOD123;
1714
1715
1716 // MetaModelica_Lexer.g:59:5: ( '%' )
1717 // MetaModelica_Lexer.g:59:7: '%'
1718 {
1719 MATCHC('%')ctx->pLexer->matchc(ctx->pLexer, '%');
1720 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1721 {
1722 goto ruleMODEx;
1723 }
1724
1725
1726 }
1727
1728 LEXSTATEctx->pLexer->rec->state->type = _type;
1729
1730 // This is where rules clean up and exit
1731 //
1732 goto ruleMODEx; /* Prevent compiler warnings */
1733 ruleMODEx: ;
1734
1735}
1736// $ANTLR end MOD
1737
1738// Comes from: 60:5: ( 'try' )
1739/** \brief Lexer rule generated by ANTLR3
1740 *
1741 * $ANTLR start TRY
1742 *
1743 * Looks to match the characters the constitute the token TRY
1744 * from the attached input stream.
1745 *
1746 *
1747 * \remark
1748 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1749 */
1750static ANTLR3_INLINE__inline__
1751void mTRY(pMetaModelica_Lexer ctx)
1752{
1753 ANTLR3_UINT32 _type;
1754
1755 _type = TRY91;
1756
1757
1758 // MetaModelica_Lexer.g:60:5: ( 'try' )
1759 // MetaModelica_Lexer.g:60:7: 'try'
1760 {
1761 MATCHS(lit_14)ctx->pLexer->matchs(ctx->pLexer, lit_14);
1762 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1763 {
1764 goto ruleTRYEx;
1765 }
1766
1767
1768
1769 }
1770
1771 LEXSTATEctx->pLexer->rec->state->type = _type;
1772
1773 // This is where rules clean up and exit
1774 //
1775 goto ruleTRYEx; /* Prevent compiler warnings */
1776 ruleTRYEx: ;
1777
1778}
1779// $ANTLR end TRY
1780
1781// Comes from: 61:9: ( 'end' EAT_WS_COMMENT 'try' )
1782/** \brief Lexer rule generated by ANTLR3
1783 *
1784 * $ANTLR start END_TRY
1785 *
1786 * Looks to match the characters the constitute the token END_TRY
1787 * from the attached input stream.
1788 *
1789 *
1790 * \remark
1791 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1792 */
1793static ANTLR3_INLINE__inline__
1794void mEND_TRY(pMetaModelica_Lexer ctx)
1795{
1796 ANTLR3_UINT32 _type;
1797
1798 _type = END_TRY90;
1799
1800
1801 // MetaModelica_Lexer.g:61:9: ( 'end' EAT_WS_COMMENT 'try' )
1802 // MetaModelica_Lexer.g:61:11: 'end' EAT_WS_COMMENT 'try'
1803 {
1804 MATCHS(lit_15)ctx->pLexer->matchs(ctx->pLexer, lit_15);
1805 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1806 {
1807 goto ruleEND_TRYEx;
1808 }
1809
1810
1811 /* 61:11: 'end' EAT_WS_COMMENT 'try' */
1812 ctx->gBaseModelica_Lexer->mEAT_WS_COMMENT(ctx->gBaseModelica_Lexer );
1813 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1814 {
1815 goto ruleEND_TRYEx;
1816 }
1817
1818 MATCHS(lit_14)ctx->pLexer->matchs(ctx->pLexer, lit_14);
1819 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1820 {
1821 goto ruleEND_TRYEx;
1822 }
1823
1824
1825
1826 }
1827
1828 LEXSTATEctx->pLexer->rec->state->type = _type;
1829
1830 // This is where rules clean up and exit
1831 //
1832 goto ruleEND_TRYEx; /* Prevent compiler warnings */
1833 ruleEND_TRYEx: ;
1834
1835}
1836// $ANTLR end END_TRY
1837
1838// Comes from: 64:11: ( 'end' EAT_WS_COMMENT 'match' )
1839/** \brief Lexer rule generated by ANTLR3
1840 *
1841 * $ANTLR start END_MATCH
1842 *
1843 * Looks to match the characters the constitute the token END_MATCH
1844 * from the attached input stream.
1845 *
1846 *
1847 * \remark
1848 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1849 */
1850static ANTLR3_INLINE__inline__
1851void mEND_MATCH(pMetaModelica_Lexer ctx)
1852{
1853 ANTLR3_UINT32 _type;
1854
1855 _type = END_MATCH28;
1856
1857
1858 // MetaModelica_Lexer.g:64:11: ( 'end' EAT_WS_COMMENT 'match' )
1859 // MetaModelica_Lexer.g:64:13: 'end' EAT_WS_COMMENT 'match'
1860 {
1861 MATCHS(lit_15)ctx->pLexer->matchs(ctx->pLexer, lit_15);
1862 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1863 {
1864 goto ruleEND_MATCHEx;
1865 }
1866
1867
1868 /* 64:13: 'end' EAT_WS_COMMENT 'match' */
1869 ctx->gBaseModelica_Lexer->mEAT_WS_COMMENT(ctx->gBaseModelica_Lexer );
1870 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1871 {
1872 goto ruleEND_MATCHEx;
1873 }
1874
1875 MATCHS(lit_8)ctx->pLexer->matchs(ctx->pLexer, lit_8);
1876 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1877 {
1878 goto ruleEND_MATCHEx;
1879 }
1880
1881
1882
1883 }
1884
1885 LEXSTATEctx->pLexer->rec->state->type = _type;
1886
1887 // This is where rules clean up and exit
1888 //
1889 goto ruleEND_MATCHEx; /* Prevent compiler warnings */
1890 ruleEND_MATCHEx: ;
1891
1892}
1893// $ANTLR end END_MATCH
1894
1895// Comes from: 65:19: ( 'end' EAT_WS_COMMENT 'matchcontinue' )
1896/** \brief Lexer rule generated by ANTLR3
1897 *
1898 * $ANTLR start END_MATCHCONTINUE
1899 *
1900 * Looks to match the characters the constitute the token END_MATCHCONTINUE
1901 * from the attached input stream.
1902 *
1903 *
1904 * \remark
1905 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1906 */
1907static ANTLR3_INLINE__inline__
1908void mEND_MATCHCONTINUE(pMetaModelica_Lexer ctx)
1909{
1910 ANTLR3_UINT32 _type;
1911
1912 _type = END_MATCHCONTINUE29;
1913
1914
1915 // MetaModelica_Lexer.g:65:19: ( 'end' EAT_WS_COMMENT 'matchcontinue' )
1916 // MetaModelica_Lexer.g:65:21: 'end' EAT_WS_COMMENT 'matchcontinue'
1917 {
1918 MATCHS(lit_15)ctx->pLexer->matchs(ctx->pLexer, lit_15);
1919 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1920 {
1921 goto ruleEND_MATCHCONTINUEEx;
1922 }
1923
1924
1925 /* 65:21: 'end' EAT_WS_COMMENT 'matchcontinue' */
1926 ctx->gBaseModelica_Lexer->mEAT_WS_COMMENT(ctx->gBaseModelica_Lexer );
1927 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1928 {
1929 goto ruleEND_MATCHCONTINUEEx;
1930 }
1931
1932 MATCHS(lit_9)ctx->pLexer->matchs(ctx->pLexer, lit_9);
1933 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1934 {
1935 goto ruleEND_MATCHCONTINUEEx;
1936 }
1937
1938
1939
1940 }
1941
1942 LEXSTATEctx->pLexer->rec->state->type = _type;
1943
1944 // This is where rules clean up and exit
1945 //
1946 goto ruleEND_MATCHCONTINUEEx; /* Prevent compiler warnings */
1947 ruleEND_MATCHCONTINUEEx: ;
1948
1949}
1950// $ANTLR end END_MATCHCONTINUE
1951
1952// Comes from: 69:9: ( '*' )
1953/** \brief Lexer rule generated by ANTLR3
1954 *
1955 * $ANTLR start STAR
1956 *
1957 * Looks to match the characters the constitute the token STAR
1958 * from the attached input stream.
1959 *
1960 *
1961 * \remark
1962 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1963 */
1964static ANTLR3_INLINE__inline__
1965void mSTAR(pMetaModelica_Lexer ctx)
1966{
1967 ANTLR3_UINT32 _type;
1968
1969 _type = STAR143;
1970
1971
1972 // MetaModelica_Lexer.g:69:9: ( '*' )
1973 // MetaModelica_Lexer.g:69:11: '*'
1974 {
1975 MATCHC('*')ctx->pLexer->matchc(ctx->pLexer, '*');
1976 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1977 {
1978 goto ruleSTAREx;
1979 }
1980
1981
1982 }
1983
1984 LEXSTATEctx->pLexer->rec->state->type = _type;
1985
1986 // This is where rules clean up and exit
1987 //
1988 goto ruleSTAREx; /* Prevent compiler warnings */
1989 ruleSTAREx: ;
1990
1991}
1992// $ANTLR end STAR
1993
1994// Comes from: 70:9: ( '-' )
1995/** \brief Lexer rule generated by ANTLR3
1996 *
1997 * $ANTLR start MINUS
1998 *
1999 * Looks to match the characters the constitute the token MINUS
2000 * from the attached input stream.
2001 *
2002 *
2003 * \remark
2004 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2005 */
2006static ANTLR3_INLINE__inline__
2007void mMINUS(pMetaModelica_Lexer ctx)
2008{
2009 ANTLR3_UINT32 _type;
2010
2011 _type = MINUS144;
2012
2013
2014 // MetaModelica_Lexer.g:70:9: ( '-' )
2015 // MetaModelica_Lexer.g:70:11: '-'
2016 {
2017 MATCHC('-')ctx->pLexer->matchc(ctx->pLexer, '-');
2018 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2019 {
2020 goto ruleMINUSEx;
2021 }
2022
2023
2024 }
2025
2026 LEXSTATEctx->pLexer->rec->state->type = _type;
2027
2028 // This is where rules clean up and exit
2029 //
2030 goto ruleMINUSEx; /* Prevent compiler warnings */
2031 ruleMINUSEx: ;
2032
2033}
2034// $ANTLR end MINUS
2035
2036// Comes from: 71:9: ( '+' )
2037/** \brief Lexer rule generated by ANTLR3
2038 *
2039 * $ANTLR start PLUS
2040 *
2041 * Looks to match the characters the constitute the token PLUS
2042 * from the attached input stream.
2043 *
2044 *
2045 * \remark
2046 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2047 */
2048static ANTLR3_INLINE__inline__
2049void mPLUS(pMetaModelica_Lexer ctx)
2050{
2051 ANTLR3_UINT32 _type;
2052
2053 _type = PLUS145;
2054
2055
2056 // MetaModelica_Lexer.g:71:9: ( '+' )
2057 // MetaModelica_Lexer.g:71:11: '+'
2058 {
2059 MATCHC('+')ctx->pLexer->matchc(ctx->pLexer, '+');
2060 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2061 {
2062 goto rulePLUSEx;
2063 }
2064
2065
2066 }
2067
2068 LEXSTATEctx->pLexer->rec->state->type = _type;
2069
2070 // This is where rules clean up and exit
2071 //
2072 goto rulePLUSEx; /* Prevent compiler warnings */
2073 rulePLUSEx: ;
2074
2075}
2076// $ANTLR end PLUS
2077
2078// Comes from: 72:9: ( '<' )
2079/** \brief Lexer rule generated by ANTLR3
2080 *
2081 * $ANTLR start LESS
2082 *
2083 * Looks to match the characters the constitute the token LESS
2084 * from the attached input stream.
2085 *
2086 *
2087 * \remark
2088 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2089 */
2090static ANTLR3_INLINE__inline__
2091void mLESS(pMetaModelica_Lexer ctx)
2092{
2093 ANTLR3_UINT32 _type;
2094
2095 _type = LESS146;
2096
2097
2098 // MetaModelica_Lexer.g:72:9: ( '<' )
2099 // MetaModelica_Lexer.g:72:11: '<'
2100 {
2101 MATCHC('<')ctx->pLexer->matchc(ctx->pLexer, '<');
2102 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2103 {
2104 goto ruleLESSEx;
2105 }
2106
2107
2108 }
2109
2110 LEXSTATEctx->pLexer->rec->state->type = _type;
2111
2112 // This is where rules clean up and exit
2113 //
2114 goto ruleLESSEx; /* Prevent compiler warnings */
2115 ruleLESSEx: ;
2116
2117}
2118// $ANTLR end LESS
2119
2120// Comes from: 73:12: ( '<=' )
2121/** \brief Lexer rule generated by ANTLR3
2122 *
2123 * $ANTLR start LESSEQ
2124 *
2125 * Looks to match the characters the constitute the token LESSEQ
2126 * from the attached input stream.
2127 *
2128 *
2129 * \remark
2130 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2131 */
2132static ANTLR3_INLINE__inline__
2133void mLESSEQ(pMetaModelica_Lexer ctx)
2134{
2135 ANTLR3_UINT32 _type;
2136
2137 _type = LESSEQ147;
2138
2139
2140 // MetaModelica_Lexer.g:73:12: ( '<=' )
2141 // MetaModelica_Lexer.g:73:14: '<='
2142 {
2143 MATCHS(lit_16)ctx->pLexer->matchs(ctx->pLexer, lit_16);
2144 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2145 {
2146 goto ruleLESSEQEx;
2147 }
2148
2149
2150
2151 }
2152
2153 LEXSTATEctx->pLexer->rec->state->type = _type;
2154
2155 // This is where rules clean up and exit
2156 //
2157 goto ruleLESSEQEx; /* Prevent compiler warnings */
2158 ruleLESSEQEx: ;
2159
2160}
2161// $ANTLR end LESSEQ
2162
2163// Comes from: 74:12: ( '<>' )
2164/** \brief Lexer rule generated by ANTLR3
2165 *
2166 * $ANTLR start LESSGT
2167 *
2168 * Looks to match the characters the constitute the token LESSGT
2169 * from the attached input stream.
2170 *
2171 *
2172 * \remark
2173 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2174 */
2175static ANTLR3_INLINE__inline__
2176void mLESSGT(pMetaModelica_Lexer ctx)
2177{
2178 ANTLR3_UINT32 _type;
2179
2180 _type = LESSGT148;
2181
2182
2183 // MetaModelica_Lexer.g:74:12: ( '<>' )
2184 // MetaModelica_Lexer.g:74:14: '<>'
2185 {
2186 MATCHS(lit_17)ctx->pLexer->matchs(ctx->pLexer, lit_17);
2187 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2188 {
2189 goto ruleLESSGTEx;
2190 }
2191
2192
2193
2194 }
2195
2196 LEXSTATEctx->pLexer->rec->state->type = _type;
2197
2198 // This is where rules clean up and exit
2199 //
2200 goto ruleLESSGTEx; /* Prevent compiler warnings */
2201 ruleLESSGTEx: ;
2202
2203}
2204// $ANTLR end LESSGT
2205
2206// Comes from: 75:12: ( '>' )
2207/** \brief Lexer rule generated by ANTLR3
2208 *
2209 * $ANTLR start GREATER
2210 *
2211 * Looks to match the characters the constitute the token GREATER
2212 * from the attached input stream.
2213 *
2214 *
2215 * \remark
2216 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2217 */
2218static ANTLR3_INLINE__inline__
2219void mGREATER(pMetaModelica_Lexer ctx)
2220{
2221 ANTLR3_UINT32 _type;
2222
2223 _type = GREATER149;
2224
2225
2226 // MetaModelica_Lexer.g:75:12: ( '>' )
2227 // MetaModelica_Lexer.g:75:14: '>'
2228 {
2229 MATCHC('>')ctx->pLexer->matchc(ctx->pLexer, '>');
2230 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2231 {
2232 goto ruleGREATEREx;
2233 }
2234
2235
2236 }
2237
2238 LEXSTATEctx->pLexer->rec->state->type = _type;
2239
2240 // This is where rules clean up and exit
2241 //
2242 goto ruleGREATEREx; /* Prevent compiler warnings */
2243 ruleGREATEREx: ;
2244
2245}
2246// $ANTLR end GREATER
2247
2248// Comes from: 76:12: ( '>=' )
2249/** \brief Lexer rule generated by ANTLR3
2250 *
2251 * $ANTLR start GREATEREQ
2252 *
2253 * Looks to match the characters the constitute the token GREATEREQ
2254 * from the attached input stream.
2255 *
2256 *
2257 * \remark
2258 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2259 */
2260static ANTLR3_INLINE__inline__
2261void mGREATEREQ(pMetaModelica_Lexer ctx)
2262{
2263 ANTLR3_UINT32 _type;
2264
2265 _type = GREATEREQ150;
2266
2267
2268 // MetaModelica_Lexer.g:76:12: ( '>=' )
2269 // MetaModelica_Lexer.g:76:14: '>='
2270 {
2271 MATCHS(lit_18)ctx->pLexer->matchs(ctx->pLexer, lit_18);
2272 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2273 {
2274 goto ruleGREATEREQEx;
2275 }
2276
2277
2278
2279 }
2280
2281 LEXSTATEctx->pLexer->rec->state->type = _type;
2282
2283 // This is where rules clean up and exit
2284 //
2285 goto ruleGREATEREQEx; /* Prevent compiler warnings */
2286 ruleGREATEREQEx: ;
2287
2288}
2289// $ANTLR end GREATEREQ
2290
2291// Comes from: 77:10: ( '==' )
2292/** \brief Lexer rule generated by ANTLR3
2293 *
2294 * $ANTLR start EQEQ
2295 *
2296 * Looks to match the characters the constitute the token EQEQ
2297 * from the attached input stream.
2298 *
2299 *
2300 * \remark
2301 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2302 */
2303static ANTLR3_INLINE__inline__
2304void mEQEQ(pMetaModelica_Lexer ctx)
2305{
2306 ANTLR3_UINT32 _type;
2307
2308 _type = EQEQ151;
2309
2310
2311 // MetaModelica_Lexer.g:77:10: ( '==' )
2312 // MetaModelica_Lexer.g:77:12: '=='
2313 {
2314 MATCHS(lit_19)ctx->pLexer->matchs(ctx->pLexer, lit_19);
2315 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2316 {
2317 goto ruleEQEQEx;
2318 }
2319
2320
2321
2322 }
2323
2324 LEXSTATEctx->pLexer->rec->state->type = _type;
2325
2326 // This is where rules clean up and exit
2327 //
2328 goto ruleEQEQEx; /* Prevent compiler warnings */
2329 ruleEQEQEx: ;
2330
2331}
2332// $ANTLR end EQEQ
2333
2334// Comes from: 78:10: ( '^' )
2335/** \brief Lexer rule generated by ANTLR3
2336 *
2337 * $ANTLR start POWER
2338 *
2339 * Looks to match the characters the constitute the token POWER
2340 * from the attached input stream.
2341 *
2342 *
2343 * \remark
2344 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2345 */
2346static ANTLR3_INLINE__inline__
2347void mPOWER(pMetaModelica_Lexer ctx)
2348{
2349 ANTLR3_UINT32 _type;
2350
2351 _type = POWER152;
2352
2353
2354 // MetaModelica_Lexer.g:78:10: ( '^' )
2355 // MetaModelica_Lexer.g:78:12: '^'
2356 {
2357 MATCHC('^')ctx->pLexer->matchc(ctx->pLexer, '^');
2358 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2359 {
2360 goto rulePOWEREx;
2361 }
2362
2363
2364 }
2365
2366 LEXSTATEctx->pLexer->rec->state->type = _type;
2367
2368 // This is where rules clean up and exit
2369 //
2370 goto rulePOWEREx; /* Prevent compiler warnings */
2371 rulePOWEREx: ;
2372
2373}
2374// $ANTLR end POWER
2375
2376// Comes from: 79:10: ( '/' )
2377/** \brief Lexer rule generated by ANTLR3
2378 *
2379 * $ANTLR start SLASH
2380 *
2381 * Looks to match the characters the constitute the token SLASH
2382 * from the attached input stream.
2383 *
2384 *
2385 * \remark
2386 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2387 */
2388static ANTLR3_INLINE__inline__
2389void mSLASH(pMetaModelica_Lexer ctx)
2390{
2391 ANTLR3_UINT32 _type;
2392
2393 _type = SLASH153;
2394
2395
2396 // MetaModelica_Lexer.g:79:10: ( '/' )
2397 // MetaModelica_Lexer.g:79:12: '/'
2398 {
2399 MATCHC('/')ctx->pLexer->matchc(ctx->pLexer, '/');
2400 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2401 {
2402 goto ruleSLASHEx;
2403 }
2404
2405
2406 }
2407
2408 LEXSTATEctx->pLexer->rec->state->type = _type;
2409
2410 // This is where rules clean up and exit
2411 //
2412 goto ruleSLASHEx; /* Prevent compiler warnings */
2413 ruleSLASHEx: ;
2414
2415}
2416// $ANTLR end SLASH
2417
2418// Comes from: 82:9: ( '.+' )
2419/** \brief Lexer rule generated by ANTLR3
2420 *
2421 * $ANTLR start PLUS_EW
2422 *
2423 * Looks to match the characters the constitute the token PLUS_EW
2424 * from the attached input stream.
2425 *
2426 *
2427 * \remark
2428 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2429 */
2430static ANTLR3_INLINE__inline__
2431void mPLUS_EW(pMetaModelica_Lexer ctx)
2432{
2433 ANTLR3_UINT32 _type;
2434
2435 _type = PLUS_EW117;
2436
2437
2438 // MetaModelica_Lexer.g:82:9: ( '.+' )
2439 // MetaModelica_Lexer.g:82:11: '.+'
2440 {
2441 MATCHS(lit_20)ctx->pLexer->matchs(ctx->pLexer, lit_20);
2442 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2443 {
2444 goto rulePLUS_EWEx;
2445 }
2446
2447
2448
2449 }
2450
2451 LEXSTATEctx->pLexer->rec->state->type = _type;
2452
2453 // This is where rules clean up and exit
2454 //
2455 goto rulePLUS_EWEx; /* Prevent compiler warnings */
2456 rulePLUS_EWEx: ;
2457
2458}
2459// $ANTLR end PLUS_EW
2460
2461// Comes from: 83:10: ( '.-' )
2462/** \brief Lexer rule generated by ANTLR3
2463 *
2464 * $ANTLR start MINUS_EW
2465 *
2466 * Looks to match the characters the constitute the token MINUS_EW
2467 * from the attached input stream.
2468 *
2469 *
2470 * \remark
2471 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2472 */
2473static ANTLR3_INLINE__inline__
2474void mMINUS_EW(pMetaModelica_Lexer ctx)
2475{
2476 ANTLR3_UINT32 _type;
2477
2478 _type = MINUS_EW118;
2479
2480
2481 // MetaModelica_Lexer.g:83:10: ( '.-' )
2482 // MetaModelica_Lexer.g:83:12: '.-'
2483 {
2484 MATCHS(lit_21)ctx->pLexer->matchs(ctx->pLexer, lit_21);
2485 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2486 {
2487 goto ruleMINUS_EWEx;
2488 }
2489
2490
2491
2492 }
2493
2494 LEXSTATEctx->pLexer->rec->state->type = _type;
2495
2496 // This is where rules clean up and exit
2497 //
2498 goto ruleMINUS_EWEx; /* Prevent compiler warnings */
2499 ruleMINUS_EWEx: ;
2500
2501}
2502// $ANTLR end MINUS_EW
2503
2504// Comes from: 84:9: ( '.*' )
2505/** \brief Lexer rule generated by ANTLR3
2506 *
2507 * $ANTLR start STAR_EW
2508 *
2509 * Looks to match the characters the constitute the token STAR_EW
2510 * from the attached input stream.
2511 *
2512 *
2513 * \remark
2514 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2515 */
2516static ANTLR3_INLINE__inline__
2517void mSTAR_EW(pMetaModelica_Lexer ctx)
2518{
2519 ANTLR3_UINT32 _type;
2520
2521 _type = STAR_EW119;
2522
2523
2524 // MetaModelica_Lexer.g:84:9: ( '.*' )
2525 // MetaModelica_Lexer.g:84:11: '.*'
2526 {
2527 MATCHS(lit_22)ctx->pLexer->matchs(ctx->pLexer, lit_22);
2528 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2529 {
2530 goto ruleSTAR_EWEx;
2531 }
2532
2533
2534
2535 }
2536
2537 LEXSTATEctx->pLexer->rec->state->type = _type;
2538
2539 // This is where rules clean up and exit
2540 //
2541 goto ruleSTAR_EWEx; /* Prevent compiler warnings */
2542 ruleSTAR_EWEx: ;
2543
2544}
2545// $ANTLR end STAR_EW
2546
2547// Comes from: 85:10: ( './' )
2548/** \brief Lexer rule generated by ANTLR3
2549 *
2550 * $ANTLR start SLASH_EW
2551 *
2552 * Looks to match the characters the constitute the token SLASH_EW
2553 * from the attached input stream.
2554 *
2555 *
2556 * \remark
2557 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2558 */
2559static ANTLR3_INLINE__inline__
2560void mSLASH_EW(pMetaModelica_Lexer ctx)
2561{
2562 ANTLR3_UINT32 _type;
2563
2564 _type = SLASH_EW120;
2565
2566
2567 // MetaModelica_Lexer.g:85:10: ( './' )
2568 // MetaModelica_Lexer.g:85:12: './'
2569 {
2570 MATCHS(lit_23)ctx->pLexer->matchs(ctx->pLexer, lit_23);
2571 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2572 {
2573 goto ruleSLASH_EWEx;
2574 }
2575
2576
2577
2578 }
2579
2580 LEXSTATEctx->pLexer->rec->state->type = _type;
2581
2582 // This is where rules clean up and exit
2583 //
2584 goto ruleSLASH_EWEx; /* Prevent compiler warnings */
2585 ruleSLASH_EWEx: ;
2586
2587}
2588// $ANTLR end SLASH_EW
2589
2590// Comes from: 86:10: ( '.^' )
2591/** \brief Lexer rule generated by ANTLR3
2592 *
2593 * $ANTLR start POWER_EW
2594 *
2595 * Looks to match the characters the constitute the token POWER_EW
2596 * from the attached input stream.
2597 *
2598 *
2599 * \remark
2600 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2601 */
2602static ANTLR3_INLINE__inline__
2603void mPOWER_EW(pMetaModelica_Lexer ctx)
2604{
2605 ANTLR3_UINT32 _type;
2606
2607 _type = POWER_EW121;
2608
2609
2610 // MetaModelica_Lexer.g:86:10: ( '.^' )
2611 // MetaModelica_Lexer.g:86:12: '.^'
2612 {
2613 MATCHS(lit_24)ctx->pLexer->matchs(ctx->pLexer, lit_24);
2614 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2615 {
2616 goto rulePOWER_EWEx;
2617 }
2618
2619
2620
2621 }
2622
2623 LEXSTATEctx->pLexer->rec->state->type = _type;
2624
2625 // This is where rules clean up and exit
2626 //
2627 goto rulePOWER_EWEx; /* Prevent compiler warnings */
2628 rulePOWER_EWEx: ;
2629
2630}
2631// $ANTLR end POWER_EW
2632
2633// Comes from: 89:8: ( 'stream' )
2634/** \brief Lexer rule generated by ANTLR3
2635 *
2636 * $ANTLR start STREAM
2637 *
2638 * Looks to match the characters the constitute the token STREAM
2639 * from the attached input stream.
2640 *
2641 *
2642 * \remark
2643 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2644 */
2645static ANTLR3_INLINE__inline__
2646void mSTREAM(pMetaModelica_Lexer ctx)
2647{
2648 ANTLR3_UINT32 _type;
2649
2650 _type = STREAM79;
2651
2652
2653 // MetaModelica_Lexer.g:89:8: ( 'stream' )
2654 // MetaModelica_Lexer.g:89:10: 'stream'
2655 {
2656 MATCHS(lit_25)ctx->pLexer->matchs(ctx->pLexer, lit_25);
2657 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2658 {
2659 goto ruleSTREAMEx;
2660 }
2661
2662
2663
2664 }
2665
2666 LEXSTATEctx->pLexer->rec->state->type = _type;
2667
2668 // This is where rules clean up and exit
2669 //
2670 goto ruleSTREAMEx; /* Prevent compiler warnings */
2671 ruleSTREAMEx: ;
2672
2673}
2674// $ANTLR end STREAM
2675
2676// Comes from: 92:8: ( 'impure' )
2677/** \brief Lexer rule generated by ANTLR3
2678 *
2679 * $ANTLR start IMPURE
2680 *
2681 * Looks to match the characters the constitute the token IMPURE
2682 * from the attached input stream.
2683 *
2684 *
2685 * \remark
2686 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2687 */
2688static ANTLR3_INLINE__inline__
2689void mIMPURE(pMetaModelica_Lexer ctx)
2690{
2691 ANTLR3_UINT32 _type;
2692
2693 _type = IMPURE49;
2694
2695
2696 // MetaModelica_Lexer.g:92:8: ( 'impure' )
2697 // MetaModelica_Lexer.g:92:10: 'impure'
2698 {
2699 MATCHS(lit_26)ctx->pLexer->matchs(ctx->pLexer, lit_26);
2700 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2701 {
2702 goto ruleIMPUREEx;
2703 }
2704
2705
2706
2707 }
2708
2709 LEXSTATEctx->pLexer->rec->state->type = _type;
2710
2711 // This is where rules clean up and exit
2712 //
2713 goto ruleIMPUREEx; /* Prevent compiler warnings */
2714 ruleIMPUREEx: ;
2715
2716}
2717// $ANTLR end IMPURE
2718
2719// Comes from: 99:8: ( 'parfor' )
2720/** \brief Lexer rule generated by ANTLR3
2721 *
2722 * $ANTLR start PARFOR
2723 *
2724 * Looks to match the characters the constitute the token PARFOR
2725 * from the attached input stream.
2726 *
2727 *
2728 * \remark
2729 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2730 */
2731static ANTLR3_INLINE__inline__
2732void mPARFOR(pMetaModelica_Lexer ctx)
2733{
2734 ANTLR3_UINT32 _type;
2735
2736 _type = PARFOR97;
2737
2738
2739 // MetaModelica_Lexer.g:99:8: ( 'parfor' )
2740 // MetaModelica_Lexer.g:99:10: 'parfor'
2741 {
2742 MATCHS(lit_27)ctx->pLexer->matchs(ctx->pLexer, lit_27);
2743 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2744 {
2745 goto rulePARFOREx;
2746 }
2747
2748
2749
2750 }
2751
2752 LEXSTATEctx->pLexer->rec->state->type = _type;
2753
2754 // This is where rules clean up and exit
2755 //
2756 goto rulePARFOREx; /* Prevent compiler warnings */
2757 rulePARFOREx: ;
2758
2759}
2760// $ANTLR end PARFOR
2761
2762// Comes from: 100:11: ( 'parallel' )
2763/** \brief Lexer rule generated by ANTLR3
2764 *
2765 * $ANTLR start T_PARALLEL
2766 *
2767 * Looks to match the characters the constitute the token T_PARALLEL
2768 * from the attached input stream.
2769 *
2770 *
2771 * \remark
2772 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2773 */
2774static ANTLR3_INLINE__inline__
2775void mT_PARALLEL(pMetaModelica_Lexer ctx)
2776{
2777 ANTLR3_UINT32 _type;
2778
2779 _type = T_PARALLEL98;
2780
2781
2782 // MetaModelica_Lexer.g:100:11: ( 'parallel' )
2783 // MetaModelica_Lexer.g:100:13: 'parallel'
2784 {
2785 MATCHS(lit_28)ctx->pLexer->matchs(ctx->pLexer, lit_28);
2786 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2787 {
2788 goto ruleT_PARALLELEx;
2789 }
2790
2791
2792
2793 }
2794
2795 LEXSTATEctx->pLexer->rec->state->type = _type;
2796
2797 // This is where rules clean up and exit
2798 //
2799 goto ruleT_PARALLELEx; /* Prevent compiler warnings */
2800 ruleT_PARALLELEx: ;
2801
2802}
2803// $ANTLR end T_PARALLEL
2804
2805// Comes from: 101:8: ( 'parlocal' )
2806/** \brief Lexer rule generated by ANTLR3
2807 *
2808 * $ANTLR start T_LOCAL
2809 *
2810 * Looks to match the characters the constitute the token T_LOCAL
2811 * from the attached input stream.
2812 *
2813 *
2814 * \remark
2815 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2816 */
2817static ANTLR3_INLINE__inline__
2818void mT_LOCAL(pMetaModelica_Lexer ctx)
2819{
2820 ANTLR3_UINT32 _type;
2821
2822 _type = T_LOCAL99;
2823
2824
2825 // MetaModelica_Lexer.g:101:8: ( 'parlocal' )
2826 // MetaModelica_Lexer.g:101:10: 'parlocal'
2827 {
2828 MATCHS(lit_29)ctx->pLexer->matchs(ctx->pLexer, lit_29);
2829 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2830 {
2831 goto ruleT_LOCALEx;
2832 }
2833
2834
2835
2836 }
2837
2838 LEXSTATEctx->pLexer->rec->state->type = _type;
2839
2840 // This is where rules clean up and exit
2841 //
2842 goto ruleT_LOCALEx; /* Prevent compiler warnings */
2843 ruleT_LOCALEx: ;
2844
2845}
2846// $ANTLR end T_LOCAL
2847
2848// Comes from: 102:9: ( 'parglobal' )
2849/** \brief Lexer rule generated by ANTLR3
2850 *
2851 * $ANTLR start T_GLOBAL
2852 *
2853 * Looks to match the characters the constitute the token T_GLOBAL
2854 * from the attached input stream.
2855 *
2856 *
2857 * \remark
2858 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2859 */
2860static ANTLR3_INLINE__inline__
2861void mT_GLOBAL(pMetaModelica_Lexer ctx)
2862{
2863 ANTLR3_UINT32 _type;
2864
2865 _type = T_GLOBAL100;
2866
2867
2868 // MetaModelica_Lexer.g:102:9: ( 'parglobal' )
2869 // MetaModelica_Lexer.g:102:11: 'parglobal'
2870 {
2871 MATCHS(lit_30)ctx->pLexer->matchs(ctx->pLexer, lit_30);
2872 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2873 {
2874 goto ruleT_GLOBALEx;
2875 }
2876
2877
2878
2879 }
2880
2881 LEXSTATEctx->pLexer->rec->state->type = _type;
2882
2883 // This is where rules clean up and exit
2884 //
2885 goto ruleT_GLOBALEx; /* Prevent compiler warnings */
2886 ruleT_GLOBALEx: ;
2887
2888}
2889// $ANTLR end T_GLOBAL
2890
2891// Comes from: 103:9: ( 'parkernel' )
2892/** \brief Lexer rule generated by ANTLR3
2893 *
2894 * $ANTLR start T_KERNEL
2895 *
2896 * Looks to match the characters the constitute the token T_KERNEL
2897 * from the attached input stream.
2898 *
2899 *
2900 * \remark
2901 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2902 */
2903static ANTLR3_INLINE__inline__
2904void mT_KERNEL(pMetaModelica_Lexer ctx)
2905{
2906 ANTLR3_UINT32 _type;
2907
2908 _type = T_KERNEL101;
2909
2910
2911 // MetaModelica_Lexer.g:103:9: ( 'parkernel' )
2912 // MetaModelica_Lexer.g:103:11: 'parkernel'
2913 {
2914 MATCHS(lit_31)ctx->pLexer->matchs(ctx->pLexer, lit_31);
2915 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2916 {
2917 goto ruleT_KERNELEx;
2918 }
2919
2920
2921
2922 }
2923
2924 LEXSTATEctx->pLexer->rec->state->type = _type;
2925
2926 // This is where rules clean up and exit
2927 //
2928 goto ruleT_KERNELEx; /* Prevent compiler warnings */
2929 ruleT_KERNELEx: ;
2930
2931}
2932// $ANTLR end T_KERNEL
2933
2934// Comes from: 104:12: ( 'end' EAT_WS_COMMENT 'parfor' )
2935/** \brief Lexer rule generated by ANTLR3
2936 *
2937 * $ANTLR start END_PARFOR
2938 *
2939 * Looks to match the characters the constitute the token END_PARFOR
2940 * from the attached input stream.
2941 *
2942 *
2943 * \remark
2944 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2945 */
2946static ANTLR3_INLINE__inline__
2947void mEND_PARFOR(pMetaModelica_Lexer ctx)
2948{
2949 ANTLR3_UINT32 _type;
2950
2951 _type = END_PARFOR102;
2952
2953
2954 // MetaModelica_Lexer.g:104:12: ( 'end' EAT_WS_COMMENT 'parfor' )
2955 // MetaModelica_Lexer.g:104:14: 'end' EAT_WS_COMMENT 'parfor'
2956 {
2957 MATCHS(lit_15)ctx->pLexer->matchs(ctx->pLexer, lit_15);
2958 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2959 {
2960 goto ruleEND_PARFOREx;
2961 }
2962
2963
2964 /* 104:14: 'end' EAT_WS_COMMENT 'parfor' */
2965 ctx->gBaseModelica_Lexer->mEAT_WS_COMMENT(ctx->gBaseModelica_Lexer );
2966 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2967 {
2968 goto ruleEND_PARFOREx;
2969 }
2970
2971 MATCHS(lit_27)ctx->pLexer->matchs(ctx->pLexer, lit_27);
2972 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2973 {
2974 goto ruleEND_PARFOREx;
2975 }
2976
2977
2978
2979 }
2980
2981 LEXSTATEctx->pLexer->rec->state->type = _type;
2982
2983 // This is where rules clean up and exit
2984 //
2985 goto ruleEND_PARFOREx; /* Prevent compiler warnings */
2986 ruleEND_PARFOREx: ;
2987
2988}
2989// $ANTLR end END_PARFOR
2990
2991// Comes from: 106:10: ( 'threaded' )
2992/** \brief Lexer rule generated by ANTLR3
2993 *
2994 * $ANTLR start THREADED
2995 *
2996 * Looks to match the characters the constitute the token THREADED
2997 * from the attached input stream.
2998 *
2999 *
3000 * \remark
3001 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3002 */
3003static ANTLR3_INLINE__inline__
3004void mTHREADED(pMetaModelica_Lexer ctx)
3005{
3006 ANTLR3_UINT32 _type;
3007
3008 _type = THREADED89;
3009
3010
3011 // MetaModelica_Lexer.g:106:10: ( 'threaded' )
3012 // MetaModelica_Lexer.g:106:12: 'threaded'
3013 {
3014 MATCHS(lit_32)ctx->pLexer->matchs(ctx->pLexer, lit_32);
3015 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3016 {
3017 goto ruleTHREADEDEx;
3018 }
3019
3020
3021
3022 }
3023
3024 LEXSTATEctx->pLexer->rec->state->type = _type;
3025
3026 // This is where rules clean up and exit
3027 //
3028 goto ruleTHREADEDEx; /* Prevent compiler warnings */
3029 ruleTHREADEDEx: ;
3030
3031}
3032// $ANTLR end THREADED
3033
3034/** This is the entry point in to the lexer from an object that
3035 * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM
3036 */
3037static void
3038mTokens(pMetaModelica_Lexer ctx)
3039{
3040 {
3041 // MetaModelica_Lexer.g:1:8: ( AS | CASE | CONTINUE | EQUALITY | FAILURE | GUARD | LOCAL | MATCH | MATCHCONTINUE | UNIONTYPE | ALLWILD | WILD | SUBTYPEOF | COLONCOLON | MOD | TRY | END_TRY | END_MATCH | END_MATCHCONTINUE | STAR | MINUS | PLUS | LESS | LESSEQ | LESSGT | GREATER | GREATEREQ | EQEQ | POWER | SLASH | PLUS_EW | MINUS_EW | STAR_EW | SLASH_EW | POWER_EW | STREAM | IMPURE | PARFOR | T_PARALLEL | T_LOCAL | T_GLOBAL | T_KERNEL | END_PARFOR | THREADED | BaseModelica_Lexer. Tokens )
3042
3043 ANTLR3_UINT32 alt1;
3044
3045 alt1=45;
Value stored to 'alt1' is never read
3046
3047 alt1 = cdfa1.predict(ctx, RECOGNIZERctx->pLexer->rec, ISTREAMctx->pLexer->input->istream, &cdfa1);
3048 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3049 {
3050 goto ruleTokensEx;
3051 }
3052
3053 switch (alt1)
3054 {
3055 case 1:
3056 // MetaModelica_Lexer.g:1:10: AS
3057 {
3058 /* 1:10: AS */
3059 mAS(ctx );
3060 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3061 {
3062 goto ruleTokensEx;
3063 }
3064
3065
3066 }
3067 break;
3068 case 2:
3069 // MetaModelica_Lexer.g:1:13: CASE
3070 {
3071 /* 1:13: CASE */
3072 mCASE(ctx );
3073 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3074 {
3075 goto ruleTokensEx;
3076 }
3077
3078
3079 }
3080 break;
3081 case 3:
3082 // MetaModelica_Lexer.g:1:18: CONTINUE
3083 {
3084 /* 1:18: CONTINUE */
3085 mCONTINUE(ctx );
3086 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3087 {
3088 goto ruleTokensEx;
3089 }
3090
3091
3092 }
3093 break;
3094 case 4:
3095 // MetaModelica_Lexer.g:1:27: EQUALITY
3096 {
3097 /* 1:27: EQUALITY */
3098 mEQUALITY(ctx );
3099 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3100 {
3101 goto ruleTokensEx;
3102 }
3103
3104
3105 }
3106 break;
3107 case 5:
3108 // MetaModelica_Lexer.g:1:36: FAILURE
3109 {
3110 /* 1:36: FAILURE */
3111 mFAILURE(ctx );
3112 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3113 {
3114 goto ruleTokensEx;
3115 }
3116
3117
3118 }
3119 break;
3120 case 6:
3121 // MetaModelica_Lexer.g:1:44: GUARD
3122 {
3123 /* 1:44: GUARD */
3124 mGUARD(ctx );
3125 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3126 {
3127 goto ruleTokensEx;
3128 }
3129
3130
3131 }
3132 break;
3133 case 7:
3134 // MetaModelica_Lexer.g:1:50: LOCAL
3135 {
3136 /* 1:50: LOCAL */
3137 mLOCAL(ctx );
3138 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3139 {
3140 goto ruleTokensEx;
3141 }
3142
3143
3144 }
3145 break;
3146 case 8:
3147 // MetaModelica_Lexer.g:1:56: MATCH
3148 {
3149 /* 1:56: MATCH */
3150 mMATCH(ctx );
3151 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3152 {
3153 goto ruleTokensEx;
3154 }
3155
3156
3157 }
3158 break;
3159 case 9:
3160 // MetaModelica_Lexer.g:1:62: MATCHCONTINUE
3161 {
3162 /* 1:62: MATCHCONTINUE */
3163 mMATCHCONTINUE(ctx );
3164 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3165 {
3166 goto ruleTokensEx;
3167 }
3168
3169
3170 }
3171 break;
3172 case 10:
3173 // MetaModelica_Lexer.g:1:76: UNIONTYPE
3174 {
3175 /* 1:76: UNIONTYPE */
3176 mUNIONTYPE(ctx );
3177 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3178 {
3179 goto ruleTokensEx;
3180 }
3181
3182
3183 }
3184 break;
3185 case 11:
3186 // MetaModelica_Lexer.g:1:86: ALLWILD
3187 {
3188 /* 1:86: ALLWILD */
3189 mALLWILD(ctx );
3190 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3191 {
3192 goto ruleTokensEx;
3193 }
3194
3195
3196 }
3197 break;
3198 case 12:
3199 // MetaModelica_Lexer.g:1:94: WILD
3200 {
3201 /* 1:94: WILD */
3202 mWILD(ctx );
3203 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3204 {
3205 goto ruleTokensEx;
3206 }
3207
3208
3209 }
3210 break;
3211 case 13:
3212 // MetaModelica_Lexer.g:1:99: SUBTYPEOF
3213 {
3214 /* 1:99: SUBTYPEOF */
3215 mSUBTYPEOF(ctx );
3216 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3217 {
3218 goto ruleTokensEx;
3219 }
3220
3221
3222 }
3223 break;
3224 case 14:
3225 // MetaModelica_Lexer.g:1:109: COLONCOLON
3226 {
3227 /* 1:109: COLONCOLON */
3228 mCOLONCOLON(ctx );
3229 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3230 {
3231 goto ruleTokensEx;
3232 }
3233
3234
3235 }
3236 break;
3237 case 15:
3238 // MetaModelica_Lexer.g:1:120: MOD
3239 {
3240 /* 1:120: MOD */
3241 mMOD(ctx );
3242 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3243 {
3244 goto ruleTokensEx;
3245 }
3246
3247
3248 }
3249 break;
3250 case 16:
3251 // MetaModelica_Lexer.g:1:124: TRY
3252 {
3253 /* 1:124: TRY */
3254 mTRY(ctx );
3255 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3256 {
3257 goto ruleTokensEx;
3258 }
3259
3260
3261 }
3262 break;
3263 case 17:
3264 // MetaModelica_Lexer.g:1:128: END_TRY
3265 {
3266 /* 1:128: END_TRY */
3267 mEND_TRY(ctx );
3268 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3269 {
3270 goto ruleTokensEx;
3271 }
3272
3273
3274 }
3275 break;
3276 case 18:
3277 // MetaModelica_Lexer.g:1:136: END_MATCH
3278 {
3279 /* 1:136: END_MATCH */
3280 mEND_MATCH(ctx );
3281 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3282 {
3283 goto ruleTokensEx;
3284 }
3285
3286
3287 }
3288 break;
3289 case 19:
3290 // MetaModelica_Lexer.g:1:146: END_MATCHCONTINUE
3291 {
3292 /* 1:146: END_MATCHCONTINUE */
3293 mEND_MATCHCONTINUE(ctx );
3294 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3295 {
3296 goto ruleTokensEx;
3297 }
3298
3299
3300 }
3301 break;
3302 case 20:
3303 // MetaModelica_Lexer.g:1:164: STAR
3304 {
3305 /* 1:164: STAR */
3306 mSTAR(ctx );
3307 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3308 {
3309 goto ruleTokensEx;
3310 }
3311
3312
3313 }
3314 break;
3315 case 21:
3316 // MetaModelica_Lexer.g:1:169: MINUS
3317 {
3318 /* 1:169: MINUS */
3319 mMINUS(ctx );
3320 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3321 {
3322 goto ruleTokensEx;
3323 }
3324
3325
3326 }
3327 break;
3328 case 22:
3329 // MetaModelica_Lexer.g:1:175: PLUS
3330 {
3331 /* 1:175: PLUS */
3332 mPLUS(ctx );
3333 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3334 {
3335 goto ruleTokensEx;
3336 }
3337
3338
3339 }
3340 break;
3341 case 23:
3342 // MetaModelica_Lexer.g:1:180: LESS
3343 {
3344 /* 1:180: LESS */
3345 mLESS(ctx );
3346 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3347 {
3348 goto ruleTokensEx;
3349 }
3350
3351
3352 }
3353 break;
3354 case 24:
3355 // MetaModelica_Lexer.g:1:185: LESSEQ
3356 {
3357 /* 1:185: LESSEQ */
3358 mLESSEQ(ctx );
3359 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3360 {
3361 goto ruleTokensEx;
3362 }
3363
3364
3365 }
3366 break;
3367 case 25:
3368 // MetaModelica_Lexer.g:1:192: LESSGT
3369 {
3370 /* 1:192: LESSGT */
3371 mLESSGT(ctx );
3372 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3373 {
3374 goto ruleTokensEx;
3375 }
3376
3377
3378 }
3379 break;
3380 case 26:
3381 // MetaModelica_Lexer.g:1:199: GREATER
3382 {
3383 /* 1:199: GREATER */
3384 mGREATER(ctx );
3385 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3386 {
3387 goto ruleTokensEx;
3388 }
3389
3390
3391 }
3392 break;
3393 case 27:
3394 // MetaModelica_Lexer.g:1:207: GREATEREQ
3395 {
3396 /* 1:207: GREATEREQ */
3397 mGREATEREQ(ctx );
3398 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3399 {
3400 goto ruleTokensEx;
3401 }
3402
3403
3404 }
3405 break;
3406 case 28:
3407 // MetaModelica_Lexer.g:1:217: EQEQ
3408 {
3409 /* 1:217: EQEQ */
3410 mEQEQ(ctx );
3411 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3412 {
3413 goto ruleTokensEx;
3414 }
3415
3416
3417 }
3418 break;
3419 case 29:
3420 // MetaModelica_Lexer.g:1:222: POWER
3421 {
3422 /* 1:222: POWER */
3423 mPOWER(ctx );
3424 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3425 {
3426 goto ruleTokensEx;
3427 }
3428
3429
3430 }
3431 break;
3432 case 30:
3433 // MetaModelica_Lexer.g:1:228: SLASH
3434 {
3435 /* 1:228: SLASH */
3436 mSLASH(ctx );
3437 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3438 {
3439 goto ruleTokensEx;
3440 }
3441
3442
3443 }
3444 break;
3445 case 31:
3446 // MetaModelica_Lexer.g:1:234: PLUS_EW
3447 {
3448 /* 1:234: PLUS_EW */
3449 mPLUS_EW(ctx );
3450 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3451 {
3452 goto ruleTokensEx;
3453 }
3454
3455
3456 }
3457 break;
3458 case 32:
3459 // MetaModelica_Lexer.g:1:242: MINUS_EW
3460 {
3461 /* 1:242: MINUS_EW */
3462 mMINUS_EW(ctx );
3463 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3464 {
3465 goto ruleTokensEx;
3466 }
3467
3468
3469 }
3470 break;
3471 case 33:
3472 // MetaModelica_Lexer.g:1:251: STAR_EW
3473 {
3474 /* 1:251: STAR_EW */
3475 mSTAR_EW(ctx );
3476 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3477 {
3478 goto ruleTokensEx;
3479 }
3480
3481
3482 }
3483 break;
3484 case 34:
3485 // MetaModelica_Lexer.g:1:259: SLASH_EW
3486 {
3487 /* 1:259: SLASH_EW */
3488 mSLASH_EW(ctx );
3489 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3490 {
3491 goto ruleTokensEx;
3492 }
3493
3494
3495 }
3496 break;
3497 case 35:
3498 // MetaModelica_Lexer.g:1:268: POWER_EW
3499 {
3500 /* 1:268: POWER_EW */
3501 mPOWER_EW(ctx );
3502 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3503 {
3504 goto ruleTokensEx;
3505 }
3506
3507
3508 }
3509 break;
3510 case 36:
3511 // MetaModelica_Lexer.g:1:277: STREAM
3512 {
3513 /* 1:277: STREAM */
3514 mSTREAM(ctx );
3515 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3516 {
3517 goto ruleTokensEx;
3518 }
3519
3520
3521 }
3522 break;
3523 case 37:
3524 // MetaModelica_Lexer.g:1:284: IMPURE
3525 {
3526 /* 1:284: IMPURE */
3527 mIMPURE(ctx );
3528 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3529 {
3530 goto ruleTokensEx;
3531 }
3532
3533
3534 }
3535 break;
3536 case 38:
3537 // MetaModelica_Lexer.g:1:291: PARFOR
3538 {
3539 /* 1:291: PARFOR */
3540 mPARFOR(ctx );
3541 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3542 {
3543 goto ruleTokensEx;
3544 }
3545
3546
3547 }
3548 break;
3549 case 39:
3550 // MetaModelica_Lexer.g:1:298: T_PARALLEL
3551 {
3552 /* 1:298: T_PARALLEL */
3553 mT_PARALLEL(ctx );
3554 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3555 {
3556 goto ruleTokensEx;
3557 }
3558
3559
3560 }
3561 break;
3562 case 40:
3563 // MetaModelica_Lexer.g:1:309: T_LOCAL
3564 {
3565 /* 1:309: T_LOCAL */
3566 mT_LOCAL(ctx );
3567 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3568 {
3569 goto ruleTokensEx;
3570 }
3571
3572
3573 }
3574 break;
3575 case 41:
3576 // MetaModelica_Lexer.g:1:317: T_GLOBAL
3577 {
3578 /* 1:317: T_GLOBAL */
3579 mT_GLOBAL(ctx );
3580 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3581 {
3582 goto ruleTokensEx;
3583 }
3584
3585
3586 }
3587 break;
3588 case 42:
3589 // MetaModelica_Lexer.g:1:326: T_KERNEL
3590 {
3591 /* 1:326: T_KERNEL */
3592 mT_KERNEL(ctx );
3593 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3594 {
3595 goto ruleTokensEx;
3596 }
3597
3598
3599 }
3600 break;
3601 case 43:
3602 // MetaModelica_Lexer.g:1:335: END_PARFOR
3603 {
3604 /* 1:335: END_PARFOR */
3605 mEND_PARFOR(ctx );
3606 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3607 {
3608 goto ruleTokensEx;
3609 }
3610
3611
3612 }
3613 break;
3614 case 44:
3615 // MetaModelica_Lexer.g:1:346: THREADED
3616 {
3617 /* 1:346: THREADED */
3618 mTHREADED(ctx );
3619 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3620 {
3621 goto ruleTokensEx;
3622 }
3623
3624
3625 }
3626 break;
3627 case 45:
3628 // MetaModelica_Lexer.g:1:355: BaseModelica_Lexer. Tokens
3629 {
3630 /* 1:355: BaseModelica_Lexer. Tokens */
3631 ctx->gBaseModelica_Lexer->mTokens(ctx->gBaseModelica_Lexer );
3632 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3633 {
3634 goto ruleTokensEx;
3635 }
3636
3637
3638 }
3639 break;
3640
3641 }
3642 }
3643
3644
3645 goto ruleTokensEx; /* Prevent compiler warnings */
3646ruleTokensEx: ;
3647}
3648
3649/* =========================================================================
3650 * Lexer matching rules end.
3651 * =========================================================================
3652 */
3653/* End of Lexer code
3654 * ================================================
3655 * ================================================
3656 */
3657
3658
3659/* End of code
3660 * =============================================================================
3661 */