Bug Summary

File:OMCompiler/Parser/ParModelica_Lexer_BaseModelica_Lexer.c
Warning:line 7360, column 9
Value stored to 'alt17' 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 : BaseModelica_Lexer.g
5 * - On : 2020-02-01 17:31:27
6 * - for the lexer : ParModelica_Lexer_BaseModelica_LexerLexer *
7 * Editing it, at least manually, is not wise.
8 *
9 * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
10 *
11 *
12*/
13// [The "BSD licence"]
14// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
15// http://www.temporal-wave.com
16// http://www.linkedin.com/in/jimidle
17//
18// All rights reserved.
19//
20// Redistribution and use in source and binary forms, with or without
21// modification, are permitted provided that the following conditions
22// are met:
23// 1. Redistributions of source code must retain the above copyright
24// notice, this list of conditions and the following disclaimer.
25// 2. Redistributions in binary form must reproduce the above copyright
26// notice, this list of conditions and the following disclaimer in the
27// documentation and/or other materials provided with the distribution.
28// 3. The name of the author may not be used to endorse or promote products
29// derived from this software without specific prior written permission.
30//
31// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
32// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
33// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
34// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
35// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
36// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
37// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
38// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
39// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
40// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41
42/* -----------------------------------------
43 * Include the ANTLR3 generated header file.
44 */
45#include "ParModelica_Lexer_BaseModelica_Lexer.h"
46/* ----------------------------------------- */
47
48
49/** String literals used by ParModelica_Lexer_BaseModelica_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, 0x6C, 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
56static ANTLR3_UCHAR lit_2[] = { 0x61, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
57static ANTLR3_UCHAR lit_3[] = { 0x26, 0x26, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
58static ANTLR3_UCHAR lit_4[] = { 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
59static ANTLR3_UCHAR lit_5[] = { 0x62, 0x6C, 0x6F, 0x63, 0x6B, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
60static ANTLR3_UCHAR lit_6[] = { 0x63, 0x6C, 0x61, 0x73, 0x73, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
61static ANTLR3_UCHAR lit_7[] = { 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
62static ANTLR3_UCHAR lit_8[] = { 0x63, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x6F, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
63static ANTLR3_UCHAR lit_9[] = { 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
64static ANTLR3_UCHAR lit_10[] = { 0x64, 0x69, 0x73, 0x63, 0x72, 0x65, 0x74, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
65static ANTLR3_UCHAR lit_11[] = { 0x64, 0x65, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
66static ANTLR3_UCHAR lit_12[] = { 0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x75, 0x6E, 0x69, 0x74, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
67static ANTLR3_UCHAR lit_13[] = { 0x65, 0x61, 0x63, 0x68, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
68static ANTLR3_UCHAR lit_14[] = { 0x65, 0x6C, 0x73, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
69static ANTLR3_UCHAR lit_15[] = { 0x65, 0x6C, 0x73, 0x65, 0x69, 0x66, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
70static ANTLR3_UCHAR lit_16[] = { 0x65, 0x6C, 0x73, 0x65, 0x77, 0x68, 0x65, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
71static ANTLR3_UCHAR lit_17[] = { 0x65, 0x6E, 0x75, 0x6D, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
72static ANTLR3_UCHAR lit_18[] = { 0x65, 0x71, 0x75, 0x61, 0x74, 0x69, 0x6F, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
73static ANTLR3_UCHAR lit_19[] = { 0x65, 0x6E, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6C, 0x61, 0x74, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
74static ANTLR3_UCHAR lit_20[] = { 0x65, 0x78, 0x70, 0x61, 0x6E, 0x64, 0x61, 0x62, 0x6C, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
75static ANTLR3_UCHAR lit_21[] = { 0x65, 0x78, 0x74, 0x65, 0x6E, 0x64, 0x73, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
76static ANTLR3_UCHAR lit_22[] = { 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6E, 0x65, 0x64, 0x62, 0x79, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
77static ANTLR3_UCHAR lit_23[] = { 0x65, 0x78, 0x74, 0x65, 0x72, 0x6E, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
78static ANTLR3_UCHAR lit_24[] = { 0x66, 0x61, 0x6C, 0x73, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
79static ANTLR3_UCHAR lit_25[] = { 0x66, 0x69, 0x6E, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
80static ANTLR3_UCHAR lit_26[] = { 0x66, 0x6C, 0x6F, 0x77, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
81static ANTLR3_UCHAR lit_27[] = { 0x66, 0x6F, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
82static ANTLR3_UCHAR lit_28[] = { 0x66, 0x75, 0x6E, 0x63, 0x74, 0x69, 0x6F, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
83static ANTLR3_UCHAR lit_29[] = { 0x69, 0x66, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
84static ANTLR3_UCHAR lit_30[] = { 0x69, 0x6D, 0x70, 0x6F, 0x72, 0x74, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
85static ANTLR3_UCHAR lit_31[] = { 0x69, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
86static ANTLR3_UCHAR lit_32[] = { 0x69, 0x6E, 0x69, 0x74, 0x69, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
87static ANTLR3_UCHAR lit_33[] = { 0x69, 0x6E, 0x6E, 0x65, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
88static ANTLR3_UCHAR lit_34[] = { 0x69, 0x6E, 0x70, 0x75, 0x74, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
89static ANTLR3_UCHAR lit_35[] = { 0x6C, 0x6F, 0x6F, 0x70, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
90static ANTLR3_UCHAR lit_36[] = { 0x6D, 0x6F, 0x64, 0x65, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
91static ANTLR3_UCHAR lit_37[] = { 0x6E, 0x6F, 0x74, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
92static ANTLR3_UCHAR lit_38[] = { 0x6F, 0x75, 0x74, 0x65, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
93static ANTLR3_UCHAR lit_39[] = { 0x6F, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6F, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
94static ANTLR3_UCHAR lit_40[] = { 0x24, 0x6F, 0x76, 0x65, 0x72, 0x6C, 0x6F, 0x61, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
95static ANTLR3_UCHAR lit_41[] = { 0x6F, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
96static ANTLR3_UCHAR lit_42[] = { 0x7C, 0x7C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
97static ANTLR3_UCHAR lit_43[] = { 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
98static ANTLR3_UCHAR lit_44[] = { 0x70, 0x61, 0x63, 0x6B, 0x61, 0x67, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
99static ANTLR3_UCHAR lit_45[] = { 0x70, 0x61, 0x72, 0x61, 0x6D, 0x65, 0x74, 0x65, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
100static ANTLR3_UCHAR lit_46[] = { 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
101static ANTLR3_UCHAR lit_47[] = { 0x70, 0x72, 0x6F, 0x74, 0x65, 0x63, 0x74, 0x65, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
102static ANTLR3_UCHAR lit_48[] = { 0x70, 0x75, 0x62, 0x6C, 0x69, 0x63, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
103static ANTLR3_UCHAR lit_49[] = { 0x72, 0x65, 0x63, 0x6F, 0x72, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
104static ANTLR3_UCHAR lit_50[] = { 0x72, 0x65, 0x64, 0x65, 0x63, 0x6C, 0x61, 0x72, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
105static ANTLR3_UCHAR lit_51[] = { 0x72, 0x65, 0x70, 0x6C, 0x61, 0x63, 0x65, 0x61, 0x62, 0x6C, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
106static ANTLR3_UCHAR lit_52[] = { 0x74, 0x68, 0x65, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
107static ANTLR3_UCHAR lit_53[] = { 0x74, 0x72, 0x75, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
108static ANTLR3_UCHAR lit_54[] = { 0x74, 0x79, 0x70, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
109static ANTLR3_UCHAR lit_55[] = { 0x75, 0x6E, 0x73, 0x69, 0x67, 0x6E, 0x65, 0x64, 0x5F, 0x72, 0x65, 0x61, 0x6C, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
110static ANTLR3_UCHAR lit_56[] = { 0x77, 0x68, 0x65, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
111static ANTLR3_UCHAR lit_57[] = { 0x77, 0x68, 0x69, 0x6C, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
112static ANTLR3_UCHAR lit_58[] = { 0x77, 0x69, 0x74, 0x68, 0x69, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
113static ANTLR3_UCHAR lit_59[] = { 0x72, 0x65, 0x74, 0x75, 0x72, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
114static ANTLR3_UCHAR lit_60[] = { 0x62, 0x72, 0x65, 0x61, 0x6B, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
115static ANTLR3_UCHAR lit_61[] = { 0x3A, 0x3D, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
116static ANTLR3_UCHAR lit_62[] = { 0x6F, 0x70, 0x74, 0x69, 0x6D, 0x69, 0x7A, 0x61, 0x74, 0x69, 0x6F, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
117static ANTLR3_UCHAR lit_63[] = { 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6E, 0x74, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
118static ANTLR3_UCHAR lit_64[] = { 0x66, 0x69, 0x65, 0x6C, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
119static ANTLR3_UCHAR lit_65[] = { 0x6E, 0x6F, 0x6E, 0x66, 0x69, 0x65, 0x6C, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
120static ANTLR3_UCHAR lit_66[] = { 0x69, 0x6E, 0x64, 0x6F, 0x6D, 0x61, 0x69, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
121static ANTLR3_UCHAR lit_67[] = { 0x2F, 0x2F, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
122static ANTLR3_UCHAR lit_68[] = { 0x2F, 0x2A, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
123static ANTLR3_UCHAR lit_69[] = { 0x2A, 0x2F, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
124static ANTLR3_UCHAR lit_70[] = { 0x0D, 0x0A, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
125static ANTLR3_UCHAR lit_71[] = { 0x24, 0x43, 0x6F, 0x64, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
126static ANTLR3_UCHAR lit_72[] = { 0x24, 0x54, 0x79, 0x70, 0x65, 0x4E, 0x61, 0x6D, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
127static ANTLR3_UCHAR lit_73[] = { 0x24, 0x45, 0x78, 0x70, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
128static ANTLR3_UCHAR lit_74[] = { 0x24, 0x61, 0x6E, 0x6E, 0x6F, 0x74, 0x61, 0x74, 0x69, 0x6F, 0x6E, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
129static ANTLR3_UCHAR lit_75[] = { 0x24, 0x56, 0x61, 0x72, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
130static ANTLR3_UCHAR lit_76[] = { 0x65, 0x6E, 0x64, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
131static ANTLR3_UCHAR lit_77[] = { 0x24, 0x63, 0x70, 0x75, 0x54, 0x69, 0x6D, 0x65, ANTLR3_STRING_TERMINATOR0xFFFFFFFF};
132
133
134
135
136/* MACROS that hide the C interface implementations from the
137 * generated code, which makes it a little more understandable to the human eye.
138 * I am very much against using C pre-processor macros for function calls and bits
139 * of code as you cannot see what is happening when single stepping in debuggers
140 * and so on. The exception (in my book at least) is for generated code, where you are
141 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
142 * hides some indirect calls, but is always referring to the input stream. This is
143 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
144 * the runtime interfaces without changing the generated code too often, without
145 * confusing the reader of the generated output, who may not wish to know the gory
146 * details of the interface inheritance.
147 */
148
149#define CTXctx ctx
150
151/* Aids in accessing scopes for grammar programmers
152 */
153#undef SCOPE_TYPE
154#undef SCOPE_STACK
155#undef SCOPE_TOP
156#define SCOPE_TYPE(scope)pParModelica_Lexer_BaseModelica_Lexer_scope_SCOPE pParModelica_Lexer_BaseModelica_Lexer_##scope##_SCOPE
157#define SCOPE_STACK(scope)pParModelica_Lexer_BaseModelica_Lexer_scopeStack pParModelica_Lexer_BaseModelica_Lexer_##scope##Stack
158#define SCOPE_TOP(scope)ctx->pParModelica_Lexer_BaseModelica_Lexer_scopeTop ctx->pParModelica_Lexer_BaseModelica_Lexer_##scope##Top
159#define SCOPE_SIZE(scope)ctx->pParModelica_Lexer_BaseModelica_Lexer_scopeStack_limit ctx->pParModelica_Lexer_BaseModelica_Lexer_##scope##Stack_limit
160#define SCOPE_INSTANCE(scope, i)(ctx->pParModelica_Lexer_BaseModelica_Lexer_scopeStack->
get(ctx->pParModelica_Lexer_BaseModelica_Lexer_scopeStack,
i))
(ctx->SCOPE_STACK(scope)pParModelica_Lexer_BaseModelica_Lexer_scopeStack->get(ctx->SCOPE_STACK(scope)pParModelica_Lexer_BaseModelica_Lexer_scopeStack,i))
161
162
163/* Macros for accessing things in a lexer
164 */
165#undef LEXERctx->pLexer
166#undef RECOGNIZERctx->pLexer->rec
167#undef RULEMEMOctx->pLexer->rec->state->ruleMemo
168#undef GETCHARINDEX
169#undef GETLINE
170#undef GETCHARPOSITIONINLINE
171#undef EMIT
172#undef EMITNEW
173#undef MATCHC
174#undef MATCHS
175#undef MATCHRANGE
176#undef LTOKENctx->pLexer->rec->state->token
177#undef HASFAILED
178#undef FAILEDFLAGctx->pLexer->rec->state->failed
179#undef INPUTctx->pLexer->input
180#undef STRSTREAMctx->pLexer->input
181#undef LA
182#undef HASEXCEPTION
183#undef EXCEPTIONctx->pLexer->rec->state->exception
184#undef CONSTRUCTEX
185#undef CONSUME
186#undef LRECOVER
187#undef MARK
188#undef REWIND
189#undef REWINDLAST
190#undef BACKTRACKINGctx->pLexer->rec->state->backtracking
191#undef MATCHANY
192#undef MEMOIZE
193#undef HAVEPARSEDRULE
194#undef GETTEXT
195#undef INDEX
196#undef SEEK
197#undef PUSHSTREAM
198#undef POPSTREAM
199#undef SETTEXT
200#undef SETTEXT8
201
202#define LEXERctx->pLexer ctx->pLexer
203#define RECOGNIZERctx->pLexer->rec LEXERctx->pLexer->rec
204#define LEXSTATEctx->pLexer->rec->state RECOGNIZERctx->pLexer->rec->state
205#define TOKSOURCEctx->pLexer->rec->state->tokSource LEXSTATEctx->pLexer->rec->state->tokSource
206#define GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer) LEXERctx->pLexer->getCharIndex(LEXERctx->pLexer)
207#define GETLINE()ctx->pLexer->getLine(ctx->pLexer) LEXERctx->pLexer->getLine(LEXERctx->pLexer)
208#define GETTEXT()ctx->pLexer->getText(ctx->pLexer) LEXERctx->pLexer->getText(LEXERctx->pLexer)
209#define GETCHARPOSITIONINLINE()ctx->pLexer->getCharPositionInLine(ctx->pLexer) LEXERctx->pLexer->getCharPositionInLine(LEXERctx->pLexer)
210#define EMIT()ctx->pLexer->rec->state->type = _type; ctx->pLexer
->emit(ctx->pLexer)
LEXSTATEctx->pLexer->rec->state->type = _type; LEXERctx->pLexer->emit(LEXERctx->pLexer)
211#define EMITNEW(t)ctx->pLexer->emitNew(ctx->pLexer, t) LEXERctx->pLexer->emitNew(LEXERctx->pLexer, t)
212#define MATCHC(c)ctx->pLexer->matchc(ctx->pLexer, c) LEXERctx->pLexer->matchc(LEXERctx->pLexer, c)
213#define MATCHS(s)ctx->pLexer->matchs(ctx->pLexer, s) LEXERctx->pLexer->matchs(LEXERctx->pLexer, s)
214#define MATCHRANGE(c1,c2)ctx->pLexer->matchRange(ctx->pLexer, c1, c2) LEXERctx->pLexer->matchRange(LEXERctx->pLexer, c1, c2)
215#define MATCHANY()ctx->pLexer->matchAny(ctx->pLexer) LEXERctx->pLexer->matchAny(LEXERctx->pLexer)
216#define LTOKENctx->pLexer->rec->state->token LEXSTATEctx->pLexer->rec->state->token
217#define HASFAILED()(ctx->pLexer->rec->state->failed == 1) (LEXSTATEctx->pLexer->rec->state->failed == ANTLR3_TRUE1)
218#define BACKTRACKINGctx->pLexer->rec->state->backtracking LEXSTATEctx->pLexer->rec->state->backtracking
219#define FAILEDFLAGctx->pLexer->rec->state->failed LEXSTATEctx->pLexer->rec->state->failed
220#define INPUTctx->pLexer->input LEXERctx->pLexer->input
221#define STRSTREAMctx->pLexer->input INPUTctx->pLexer->input
222#define ISTREAMctx->pLexer->input->istream INPUTctx->pLexer->input->istream
223#define INDEX()ctx->pLexer->input->istream->index(ctx->pLexer
->input->istream)
ISTREAMctx->pLexer->input->istream->index(ISTREAMctx->pLexer->input->istream)
224#define SEEK(n)ctx->pLexer->input->istream->seek(ctx->pLexer->
input->istream, n)
ISTREAMctx->pLexer->input->istream->seek(ISTREAMctx->pLexer->input->istream, n)
225#define EOF_TOKEN&(ctx->pLexer->rec->state->tokSource->eofToken
)
&(LEXSTATEctx->pLexer->rec->state->tokSource->eofToken)
226#define HASEXCEPTION()(ctx->pLexer->rec->state->error == 1) (LEXSTATEctx->pLexer->rec->state->error == ANTLR3_TRUE1)
227#define EXCEPTIONctx->pLexer->rec->state->exception LEXSTATEctx->pLexer->rec->state->exception
228#define CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
RECOGNIZERctx->pLexer->rec->exConstruct(RECOGNIZERctx->pLexer->rec)
229#define LRECOVER()ctx->pLexer->recover(ctx->pLexer) LEXERctx->pLexer->recover(LEXERctx->pLexer)
230#define MARK()ctx->pLexer->input->istream->mark(ctx->pLexer->
input->istream)
ISTREAMctx->pLexer->input->istream->mark(ISTREAMctx->pLexer->input->istream)
231#define REWIND(m)ctx->pLexer->input->istream->rewind(ctx->pLexer
->input->istream, m)
ISTREAMctx->pLexer->input->istream->rewind(ISTREAMctx->pLexer->input->istream, m)
232#define REWINDLAST()ctx->pLexer->input->istream->rewindLast(ctx->pLexer
->input->istream)
ISTREAMctx->pLexer->input->istream->rewindLast(ISTREAMctx->pLexer->input->istream)
233#define MEMOIZE(ri,si)ctx->pLexer->rec->memoize(ctx->pLexer->rec, ri
, si)
RECOGNIZERctx->pLexer->rec->memoize(RECOGNIZERctx->pLexer->rec, ri, si)
234#define HAVEPARSEDRULE(r)ctx->pLexer->rec->alreadyParsedRule(ctx->pLexer->
rec, r)
RECOGNIZERctx->pLexer->rec->alreadyParsedRule(RECOGNIZERctx->pLexer->rec, r)
235#define PUSHSTREAM(str)ctx->pLexer->pushCharStream(ctx->pLexer, str) LEXERctx->pLexer->pushCharStream(LEXERctx->pLexer, str)
236#define POPSTREAM()ctx->pLexer->popCharStream(ctx->pLexer) LEXERctx->pLexer->popCharStream(LEXERctx->pLexer)
237#define SETTEXT(str)ctx->pLexer->rec->state->text = str LEXSTATEctx->pLexer->rec->state->text = str
238#define SKIP()ctx->pLexer->rec->state->token = &(ctx->pLexer
->rec->state->tokSource->skipToken)
LEXSTATEctx->pLexer->rec->state->token = &(TOKSOURCEctx->pLexer->rec->state->tokSource->skipToken)
239#define USER1ctx->pLexer->rec->state->user1 LEXSTATEctx->pLexer->rec->state->user1
240#define USER2ctx->pLexer->rec->state->user2 LEXSTATEctx->pLexer->rec->state->user2
241#define USER3ctx->pLexer->rec->state->user3 LEXSTATEctx->pLexer->rec->state->user3
242#define CUSTOMctx->pLexer->rec->state->custom LEXSTATEctx->pLexer->rec->state->custom
243#define RULEMEMOctx->pLexer->rec->state->ruleMemo LEXSTATEctx->pLexer->rec->state->ruleMemo
244#define DBGctx->pLexer->rec->debugger RECOGNIZERctx->pLexer->rec->debugger
245
246/* If we have been told we can rely on the standard 8 bit or 16 bit input
247 * stream, then we can define our macros to use the direct pointers
248 * in the input object, which is much faster than indirect calls. This
249 * is really only significant to lexers with a lot of fragment rules (which
250 * do not place LA(1) in a temporary at the moment) and even then
251 * only if there is a lot of input (order of say 1M or so).
252 */
253#if defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)
254
255# ifdef ANTLR3_INLINE_INPUT_ASCII
256
257/* 8 bit "ASCII" (actually any 8 bit character set) */
258
259# define NEXTCHAR ((pANTLR3_UINT8)(INPUTctx->pLexer->input->nextChar))
260# define DATAP ((pANTLR3_UINT8)(INPUTctx->pLexer->input->data))
261
262# else
263
264# define NEXTCHAR ((pANTLR3_UINT16)(INPUTctx->pLexer->input->nextChar))
265# define DATAP ((pANTLR3_UINT16)(INPUTctx->pLexer->input->data))
266
267# endif
268
269# 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)))
270# define CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
\
271{ \
272 if (NEXTCHAR < (DATAP + INPUTctx->pLexer->input->sizeBuf)) \
273 { \
274 INPUTctx->pLexer->input->charPositionInLine++; \
275 if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUTctx->pLexer->input->newlineChar) \
276 { \
277 INPUTctx->pLexer->input->line++; \
278 INPUTctx->pLexer->input->charPositionInLine = 0; \
279 INPUTctx->pLexer->input->currentLine = (void *)(NEXTCHAR + 1); \
280 } \
281 INPUTctx->pLexer->input->nextChar = (void *)(NEXTCHAR + 1); \
282 } \
283}
284
285#else
286
287// Pick up the input character by calling the input stream implementation.
288//
289#define CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
INPUTctx->pLexer->input->istream->consume(INPUTctx->pLexer->input->istream)
290#define LA(n)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, n)
INPUTctx->pLexer->input->istream->_LA(INPUTctx->pLexer->input->istream, n)
291
292#endif
293#define TOKTEXT(tok, txt)tok, (pANTLR3_UINT8)txt tok, (pANTLR3_UINT8)txt
294
295/* The 4 tokens defined below may well clash with your own #defines or token types. If so
296 * then for the present you must use different names for your defines as these are hard coded
297 * in the code generator. It would be better not to use such names internally, and maybe
298 * we can change this in a forthcoming release. I deliberately do not #undef these
299 * here as this will at least give you a redefined error somewhere if they clash.
300 */
301#define UP3 ANTLR3_TOKEN_UP3
302#define DOWN2 ANTLR3_TOKEN_DOWN2
303#define EORANTLR3_TOKEN_EOR ANTLR3_TOKEN_EOR
304#define INVALID0 ANTLR3_TOKEN_INVALID0
305
306
307/* =============================================================================
308 * Functions to create and destroy scopes. First come the rule scopes, followed
309 * by the global declared scopes.
310 */
311
312
313
314/* ============================================================================= */
315
316/* =============================================================================
317 * Start of recognizer
318 */
319
320
321/* Forward declare the locally static matching functions we have generated and any predicate functions.
322 */
323static ANTLR3_INLINE__inline__ void mT_ALGORITHM (pParModelica_Lexer_BaseModelica_Lexer ctx);
324static ANTLR3_INLINE__inline__ void mT_AND (pParModelica_Lexer_BaseModelica_Lexer ctx);
325static ANTLR3_INLINE__inline__ void mT_ANNOTATION (pParModelica_Lexer_BaseModelica_Lexer ctx);
326static ANTLR3_INLINE__inline__ void mBLOCK (pParModelica_Lexer_BaseModelica_Lexer ctx);
327static ANTLR3_INLINE__inline__ void mCLASS (pParModelica_Lexer_BaseModelica_Lexer ctx);
328static ANTLR3_INLINE__inline__ void mCONNECT (pParModelica_Lexer_BaseModelica_Lexer ctx);
329static ANTLR3_INLINE__inline__ void mCONNECTOR (pParModelica_Lexer_BaseModelica_Lexer ctx);
330static ANTLR3_INLINE__inline__ void mCONSTANT (pParModelica_Lexer_BaseModelica_Lexer ctx);
331static ANTLR3_INLINE__inline__ void mDISCRETE (pParModelica_Lexer_BaseModelica_Lexer ctx);
332static ANTLR3_INLINE__inline__ void mDER (pParModelica_Lexer_BaseModelica_Lexer ctx);
333static ANTLR3_INLINE__inline__ void mDEFINEUNIT (pParModelica_Lexer_BaseModelica_Lexer ctx);
334static ANTLR3_INLINE__inline__ void mEACH (pParModelica_Lexer_BaseModelica_Lexer ctx);
335static ANTLR3_INLINE__inline__ void mELSE (pParModelica_Lexer_BaseModelica_Lexer ctx);
336static ANTLR3_INLINE__inline__ void mELSEIF (pParModelica_Lexer_BaseModelica_Lexer ctx);
337static ANTLR3_INLINE__inline__ void mELSEWHEN (pParModelica_Lexer_BaseModelica_Lexer ctx);
338static ANTLR3_INLINE__inline__ void mENUMERATION (pParModelica_Lexer_BaseModelica_Lexer ctx);
339static ANTLR3_INLINE__inline__ void mEQUATION (pParModelica_Lexer_BaseModelica_Lexer ctx);
340static ANTLR3_INLINE__inline__ void mENCAPSULATED (pParModelica_Lexer_BaseModelica_Lexer ctx);
341static ANTLR3_INLINE__inline__ void mEXPANDABLE (pParModelica_Lexer_BaseModelica_Lexer ctx);
342static ANTLR3_INLINE__inline__ void mEXTENDS (pParModelica_Lexer_BaseModelica_Lexer ctx);
343static ANTLR3_INLINE__inline__ void mCONSTRAINEDBY (pParModelica_Lexer_BaseModelica_Lexer ctx);
344static ANTLR3_INLINE__inline__ void mEXTERNAL (pParModelica_Lexer_BaseModelica_Lexer ctx);
345static ANTLR3_INLINE__inline__ void mT_FALSE (pParModelica_Lexer_BaseModelica_Lexer ctx);
346static ANTLR3_INLINE__inline__ void mFINAL (pParModelica_Lexer_BaseModelica_Lexer ctx);
347static ANTLR3_INLINE__inline__ void mFLOW (pParModelica_Lexer_BaseModelica_Lexer ctx);
348static ANTLR3_INLINE__inline__ void mFOR (pParModelica_Lexer_BaseModelica_Lexer ctx);
349static ANTLR3_INLINE__inline__ void mFUNCTION (pParModelica_Lexer_BaseModelica_Lexer ctx);
350static ANTLR3_INLINE__inline__ void mIF (pParModelica_Lexer_BaseModelica_Lexer ctx);
351static ANTLR3_INLINE__inline__ void mIMPORT (pParModelica_Lexer_BaseModelica_Lexer ctx);
352static ANTLR3_INLINE__inline__ void mT_IN (pParModelica_Lexer_BaseModelica_Lexer ctx);
353static ANTLR3_INLINE__inline__ void mINITIAL (pParModelica_Lexer_BaseModelica_Lexer ctx);
354static ANTLR3_INLINE__inline__ void mINNER (pParModelica_Lexer_BaseModelica_Lexer ctx);
355static ANTLR3_INLINE__inline__ void mT_INPUT (pParModelica_Lexer_BaseModelica_Lexer ctx);
356static ANTLR3_INLINE__inline__ void mLOOP (pParModelica_Lexer_BaseModelica_Lexer ctx);
357static ANTLR3_INLINE__inline__ void mMODEL (pParModelica_Lexer_BaseModelica_Lexer ctx);
358static ANTLR3_INLINE__inline__ void mT_NOT (pParModelica_Lexer_BaseModelica_Lexer ctx);
359static ANTLR3_INLINE__inline__ void mT_OUTER (pParModelica_Lexer_BaseModelica_Lexer ctx);
360static ANTLR3_INLINE__inline__ void mOPERATOR (pParModelica_Lexer_BaseModelica_Lexer ctx);
361static ANTLR3_INLINE__inline__ void mOVERLOAD (pParModelica_Lexer_BaseModelica_Lexer ctx);
362static ANTLR3_INLINE__inline__ void mT_OR (pParModelica_Lexer_BaseModelica_Lexer ctx);
363static ANTLR3_INLINE__inline__ void mT_OUTPUT (pParModelica_Lexer_BaseModelica_Lexer ctx);
364static ANTLR3_INLINE__inline__ void mT_PACKAGE (pParModelica_Lexer_BaseModelica_Lexer ctx);
365static ANTLR3_INLINE__inline__ void mPARAMETER (pParModelica_Lexer_BaseModelica_Lexer ctx);
366static ANTLR3_INLINE__inline__ void mPARTIAL (pParModelica_Lexer_BaseModelica_Lexer ctx);
367static ANTLR3_INLINE__inline__ void mPROTECTED (pParModelica_Lexer_BaseModelica_Lexer ctx);
368static ANTLR3_INLINE__inline__ void mPUBLIC (pParModelica_Lexer_BaseModelica_Lexer ctx);
369static ANTLR3_INLINE__inline__ void mRECORD (pParModelica_Lexer_BaseModelica_Lexer ctx);
370static ANTLR3_INLINE__inline__ void mREDECLARE (pParModelica_Lexer_BaseModelica_Lexer ctx);
371static ANTLR3_INLINE__inline__ void mREPLACEABLE (pParModelica_Lexer_BaseModelica_Lexer ctx);
372static ANTLR3_INLINE__inline__ void mTHEN (pParModelica_Lexer_BaseModelica_Lexer ctx);
373static ANTLR3_INLINE__inline__ void mT_TRUE (pParModelica_Lexer_BaseModelica_Lexer ctx);
374static ANTLR3_INLINE__inline__ void mTYPE (pParModelica_Lexer_BaseModelica_Lexer ctx);
375static ANTLR3_INLINE__inline__ void mUNSIGNED_REAL (pParModelica_Lexer_BaseModelica_Lexer ctx);
376static ANTLR3_INLINE__inline__ void mWHEN (pParModelica_Lexer_BaseModelica_Lexer ctx);
377static ANTLR3_INLINE__inline__ void mWHILE (pParModelica_Lexer_BaseModelica_Lexer ctx);
378static ANTLR3_INLINE__inline__ void mWITHIN (pParModelica_Lexer_BaseModelica_Lexer ctx);
379static ANTLR3_INLINE__inline__ void mRETURN (pParModelica_Lexer_BaseModelica_Lexer ctx);
380static ANTLR3_INLINE__inline__ void mBREAK (pParModelica_Lexer_BaseModelica_Lexer ctx);
381static ANTLR3_INLINE__inline__ void mDOT (pParModelica_Lexer_BaseModelica_Lexer ctx);
382static ANTLR3_INLINE__inline__ void mLPAR (pParModelica_Lexer_BaseModelica_Lexer ctx);
383static ANTLR3_INLINE__inline__ void mRPAR (pParModelica_Lexer_BaseModelica_Lexer ctx);
384static ANTLR3_INLINE__inline__ void mLBRACK (pParModelica_Lexer_BaseModelica_Lexer ctx);
385static ANTLR3_INLINE__inline__ void mRBRACK (pParModelica_Lexer_BaseModelica_Lexer ctx);
386static ANTLR3_INLINE__inline__ void mLBRACE (pParModelica_Lexer_BaseModelica_Lexer ctx);
387static ANTLR3_INLINE__inline__ void mRBRACE (pParModelica_Lexer_BaseModelica_Lexer ctx);
388static ANTLR3_INLINE__inline__ void mEQUALS (pParModelica_Lexer_BaseModelica_Lexer ctx);
389static ANTLR3_INLINE__inline__ void mASSIGN (pParModelica_Lexer_BaseModelica_Lexer ctx);
390static ANTLR3_INLINE__inline__ void mCOMMA (pParModelica_Lexer_BaseModelica_Lexer ctx);
391static ANTLR3_INLINE__inline__ void mCOLON (pParModelica_Lexer_BaseModelica_Lexer ctx);
392static ANTLR3_INLINE__inline__ void mSEMICOLON (pParModelica_Lexer_BaseModelica_Lexer ctx);
393static ANTLR3_INLINE__inline__ void mOPTIMIZATION (pParModelica_Lexer_BaseModelica_Lexer ctx);
394static ANTLR3_INLINE__inline__ void mCONSTRAINT (pParModelica_Lexer_BaseModelica_Lexer ctx);
395static ANTLR3_INLINE__inline__ void mFIELD (pParModelica_Lexer_BaseModelica_Lexer ctx);
396static ANTLR3_INLINE__inline__ void mNONFIELD (pParModelica_Lexer_BaseModelica_Lexer ctx);
397static ANTLR3_INLINE__inline__ void mINDOMAIN (pParModelica_Lexer_BaseModelica_Lexer ctx);
398static ANTLR3_INLINE__inline__ void mBOM (pParModelica_Lexer_BaseModelica_Lexer ctx);
399static ANTLR3_INLINE__inline__ void mWS (pParModelica_Lexer_BaseModelica_Lexer ctx);
400static ANTLR3_INLINE__inline__ void mLINE_COMMENT (pParModelica_Lexer_BaseModelica_Lexer ctx);
401static ANTLR3_INLINE__inline__ void mML_COMMENT (pParModelica_Lexer_BaseModelica_Lexer ctx);
402static ANTLR3_INLINE__inline__ void mNL (pParModelica_Lexer_BaseModelica_Lexer ctx);
403static ANTLR3_INLINE__inline__ void mCODE (pParModelica_Lexer_BaseModelica_Lexer ctx);
404static ANTLR3_INLINE__inline__ void mCODE_NAME (pParModelica_Lexer_BaseModelica_Lexer ctx);
405static ANTLR3_INLINE__inline__ void mCODE_EXP (pParModelica_Lexer_BaseModelica_Lexer ctx);
406static ANTLR3_INLINE__inline__ void mCODE_ANNOTATION (pParModelica_Lexer_BaseModelica_Lexer ctx);
407static ANTLR3_INLINE__inline__ void mCODE_VAR (pParModelica_Lexer_BaseModelica_Lexer ctx);
408static ANTLR3_INLINE__inline__ void mSTRING (pParModelica_Lexer_BaseModelica_Lexer ctx);
409static ANTLR3_INLINE__inline__ void mSTRING_GUTS (pParModelica_Lexer_BaseModelica_Lexer ctx);
410static ANTLR3_INLINE__inline__ void mSCHAR (pParModelica_Lexer_BaseModelica_Lexer ctx);
411static ANTLR3_INLINE__inline__ void mSESCAPE (pParModelica_Lexer_BaseModelica_Lexer ctx);
412static ANTLR3_INLINE__inline__ void mEAT_WS_COMMENT (pParModelica_Lexer_BaseModelica_Lexer ctx);
413static ANTLR3_INLINE__inline__ void mEND_IF (pParModelica_Lexer_BaseModelica_Lexer ctx);
414static ANTLR3_INLINE__inline__ void mEND_FOR (pParModelica_Lexer_BaseModelica_Lexer ctx);
415static ANTLR3_INLINE__inline__ void mEND_WHEN (pParModelica_Lexer_BaseModelica_Lexer ctx);
416static ANTLR3_INLINE__inline__ void mEND_WHILE (pParModelica_Lexer_BaseModelica_Lexer ctx);
417static ANTLR3_INLINE__inline__ void mEND_IDENT (pParModelica_Lexer_BaseModelica_Lexer ctx);
418static ANTLR3_INLINE__inline__ void mT_END (pParModelica_Lexer_BaseModelica_Lexer ctx);
419static ANTLR3_INLINE__inline__ void mIDENT (pParModelica_Lexer_BaseModelica_Lexer ctx);
420static ANTLR3_INLINE__inline__ void mIDENT2 (pParModelica_Lexer_BaseModelica_Lexer ctx);
421static ANTLR3_INLINE__inline__ void mQIDENT (pParModelica_Lexer_BaseModelica_Lexer ctx);
422static ANTLR3_INLINE__inline__ void mQCHAR (pParModelica_Lexer_BaseModelica_Lexer ctx);
423static ANTLR3_INLINE__inline__ void mNONDIGIT (pParModelica_Lexer_BaseModelica_Lexer ctx);
424static ANTLR3_INLINE__inline__ void mDIGIT (pParModelica_Lexer_BaseModelica_Lexer ctx);
425static ANTLR3_INLINE__inline__ void mEXPONENT (pParModelica_Lexer_BaseModelica_Lexer ctx);
426static ANTLR3_INLINE__inline__ void mUNSIGNED_INTEGER (pParModelica_Lexer_BaseModelica_Lexer ctx);
427static ANTLR3_INLINE__inline__ void mTokens (pParModelica_Lexer_BaseModelica_Lexer ctx);
428static void ParModelica_Lexer_BaseModelica_LexerFree(pParModelica_Lexer_BaseModelica_Lexer ctx);
429
430/* =========================================================================
431 * Lexer matching rules end.
432 * =========================================================================
433 */
434
435
436
437static void
438ParModelica_Lexer_BaseModelica_LexerFree (pParModelica_Lexer_BaseModelica_Lexer ctx)
439{
440 LEXERctx->pLexer->free(LEXERctx->pLexer);
441
442 ANTLR3_FREE(ctx)free ((void *)(ctx));
443}
444
445/** \brief Name of the grammar file that generated this code
446 */
447static const char fileName[] = "BaseModelica_Lexer.g";
448
449/** \brief Return the name of the grammar file that generated this code.
450 */
451static const char * getGrammarFileName()
452{
453 return fileName;
454}
455
456/** \brief Create a new lexer called ParModelica_Lexer_BaseModelica_Lexer
457 *
458 * \param[in] instream Pointer to an initialized input stream
459 * \return
460 * - Success pParModelica_Lexer_BaseModelica_Lexer initialized for the lex start
461 * - Fail NULL
462 */
463ANTLR3_API pParModelica_Lexer_BaseModelica_Lexer ParModelica_Lexer_BaseModelica_LexerNew
464(pANTLR3_INPUT_STREAM instream, pParModelica_Lexer gParModelica_Lexer)
465{
466 // See if we can create a new lexer with the standard constructor
467 //
468 return ParModelica_Lexer_BaseModelica_LexerNewSSD(instream, NULL((void*)0), gParModelica_Lexer);
469}
470
471/** \brief Create a new lexer called ParModelica_Lexer_BaseModelica_Lexer
472 *
473 * \param[in] instream Pointer to an initialized input stream
474 * \param[state] state Previously created shared recognizer stat
475 * \return
476 * - Success pParModelica_Lexer_BaseModelica_Lexer initialized for the lex start
477 * - Fail NULL
478 */
479ANTLR3_API pParModelica_Lexer_BaseModelica_Lexer ParModelica_Lexer_BaseModelica_LexerNewSSD
480(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state, pParModelica_Lexer gParModelica_Lexer)
481{
482 pParModelica_Lexer_BaseModelica_Lexer ctx; // Context structure we will build and return
483
484 ctx = (pParModelica_Lexer_BaseModelica_Lexer) ANTLR3_CALLOC(1, sizeof(ParModelica_Lexer_BaseModelica_Lexer))calloc (1, (size_t)(sizeof(ParModelica_Lexer_BaseModelica_Lexer
)));
;
485
486 if (ctx == NULL((void*)0))
487 {
488 // Failed to allocate memory for lexer context
489 return NULL((void*)0);
490 }
491
492 /* -------------------------------------------------------------------
493 * Memory for basic structure is allocated, now to fill in
494 * in base ANTLR3 structures. We initialize the function pointers
495 * for the standard ANTLR3 lexer function set, but upon return
496 * from here, the programmer may set the pointers to provide custom
497 * implementations of each function.
498 *
499 * We don't use the macros defined in ParModelica_Lexer_BaseModelica_Lexer.h here so you can get a sense
500 * of what goes where.
501 */
502
503 /* Create a base lexer, using the supplied input stream
504 */
505 ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT2049, instream, state);
506
507 /* Check that we allocated the memory correctly
508 */
509 if (ctx->pLexer == NULL((void*)0))
510 {
511 ANTLR3_FREE(ctx)free ((void *)(ctx));
512 return NULL((void*)0);
513 }
514 /* Install the implementation of our ParModelica_Lexer_BaseModelica_Lexer interface
515 */
516 ctx->mT_ALGORITHM = mT_ALGORITHM;
517 ctx->mT_AND = mT_AND;
518 ctx->mT_ANNOTATION = mT_ANNOTATION;
519 ctx->mBLOCK = mBLOCK;
520 ctx->mCLASS = mCLASS;
521 ctx->mCONNECT = mCONNECT;
522 ctx->mCONNECTOR = mCONNECTOR;
523 ctx->mCONSTANT = mCONSTANT;
524 ctx->mDISCRETE = mDISCRETE;
525 ctx->mDER = mDER;
526 ctx->mDEFINEUNIT = mDEFINEUNIT;
527 ctx->mEACH = mEACH;
528 ctx->mELSE = mELSE;
529 ctx->mELSEIF = mELSEIF;
530 ctx->mELSEWHEN = mELSEWHEN;
531 ctx->mENUMERATION = mENUMERATION;
532 ctx->mEQUATION = mEQUATION;
533 ctx->mENCAPSULATED = mENCAPSULATED;
534 ctx->mEXPANDABLE = mEXPANDABLE;
535 ctx->mEXTENDS = mEXTENDS;
536 ctx->mCONSTRAINEDBY = mCONSTRAINEDBY;
537 ctx->mEXTERNAL = mEXTERNAL;
538 ctx->mT_FALSE = mT_FALSE;
539 ctx->mFINAL = mFINAL;
540 ctx->mFLOW = mFLOW;
541 ctx->mFOR = mFOR;
542 ctx->mFUNCTION = mFUNCTION;
543 ctx->mIF = mIF;
544 ctx->mIMPORT = mIMPORT;
545 ctx->mT_IN = mT_IN;
546 ctx->mINITIAL = mINITIAL;
547 ctx->mINNER = mINNER;
548 ctx->mT_INPUT = mT_INPUT;
549 ctx->mLOOP = mLOOP;
550 ctx->mMODEL = mMODEL;
551 ctx->mT_NOT = mT_NOT;
552 ctx->mT_OUTER = mT_OUTER;
553 ctx->mOPERATOR = mOPERATOR;
554 ctx->mOVERLOAD = mOVERLOAD;
555 ctx->mT_OR = mT_OR;
556 ctx->mT_OUTPUT = mT_OUTPUT;
557 ctx->mT_PACKAGE = mT_PACKAGE;
558 ctx->mPARAMETER = mPARAMETER;
559 ctx->mPARTIAL = mPARTIAL;
560 ctx->mPROTECTED = mPROTECTED;
561 ctx->mPUBLIC = mPUBLIC;
562 ctx->mRECORD = mRECORD;
563 ctx->mREDECLARE = mREDECLARE;
564 ctx->mREPLACEABLE = mREPLACEABLE;
565 ctx->mTHEN = mTHEN;
566 ctx->mT_TRUE = mT_TRUE;
567 ctx->mTYPE = mTYPE;
568 ctx->mUNSIGNED_REAL = mUNSIGNED_REAL;
569 ctx->mWHEN = mWHEN;
570 ctx->mWHILE = mWHILE;
571 ctx->mWITHIN = mWITHIN;
572 ctx->mRETURN = mRETURN;
573 ctx->mBREAK = mBREAK;
574 ctx->mDOT = mDOT;
575 ctx->mLPAR = mLPAR;
576 ctx->mRPAR = mRPAR;
577 ctx->mLBRACK = mLBRACK;
578 ctx->mRBRACK = mRBRACK;
579 ctx->mLBRACE = mLBRACE;
580 ctx->mRBRACE = mRBRACE;
581 ctx->mEQUALS = mEQUALS;
582 ctx->mASSIGN = mASSIGN;
583 ctx->mCOMMA = mCOMMA;
584 ctx->mCOLON = mCOLON;
585 ctx->mSEMICOLON = mSEMICOLON;
586 ctx->mOPTIMIZATION = mOPTIMIZATION;
587 ctx->mCONSTRAINT = mCONSTRAINT;
588 ctx->mFIELD = mFIELD;
589 ctx->mNONFIELD = mNONFIELD;
590 ctx->mINDOMAIN = mINDOMAIN;
591 ctx->mBOM = mBOM;
592 ctx->mWS = mWS;
593 ctx->mLINE_COMMENT = mLINE_COMMENT;
594 ctx->mML_COMMENT = mML_COMMENT;
595 ctx->mNL = mNL;
596 ctx->mCODE = mCODE;
597 ctx->mCODE_NAME = mCODE_NAME;
598 ctx->mCODE_EXP = mCODE_EXP;
599 ctx->mCODE_ANNOTATION = mCODE_ANNOTATION;
600 ctx->mCODE_VAR = mCODE_VAR;
601 ctx->mSTRING = mSTRING;
602 ctx->mSTRING_GUTS = mSTRING_GUTS;
603 ctx->mSCHAR = mSCHAR;
604 ctx->mSESCAPE = mSESCAPE;
605 ctx->mEAT_WS_COMMENT = mEAT_WS_COMMENT;
606 ctx->mEND_IF = mEND_IF;
607 ctx->mEND_FOR = mEND_FOR;
608 ctx->mEND_WHEN = mEND_WHEN;
609 ctx->mEND_WHILE = mEND_WHILE;
610 ctx->mEND_IDENT = mEND_IDENT;
611 ctx->mT_END = mT_END;
612 ctx->mIDENT = mIDENT;
613 ctx->mIDENT2 = mIDENT2;
614 ctx->mQIDENT = mQIDENT;
615 ctx->mQCHAR = mQCHAR;
616 ctx->mNONDIGIT = mNONDIGIT;
617 ctx->mDIGIT = mDIGIT;
618 ctx->mEXPONENT = mEXPONENT;
619 ctx->mUNSIGNED_INTEGER = mUNSIGNED_INTEGER;
620 ctx->mTokens = mTokens;
621
622 /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE
623 * it will call mTokens() in this generated code, and will pass it the ctx
624 * pointer of this lexer, not the context of the base lexer, so store that now.
625 */
626 ctx->pLexer->ctx = ctx;
627
628 /**Install the token matching function
629 */
630 ctx->pLexer->mTokens = (void (*) (void *))(mTokens);
631
632 ctx->getGrammarFileName = getGrammarFileName;
633 ctx->free = ParModelica_Lexer_BaseModelica_LexerFree;
634
635
636 // Install the pointers back to lexers that will delegate us to perform certain functions
637 // for them.
638 //
639 ctx->gParModelica_Lexer = gParModelica_Lexer;
640
641
642 /* Return the newly built lexer to the caller
643 */
644 return ctx;
645}
646
647/* =========================================================================
648 * DFA tables for the lexer
649 */
650/** Static dfa state tables for Cyclic dfa:
651 * 1:1: Tokens : ( T_ALGORITHM | T_AND | T_ANNOTATION | BLOCK | CLASS | CONNECT | CONNECTOR | CONSTANT | DISCRETE | DER | DEFINEUNIT | EACH | ELSE | ELSEIF | ELSEWHEN | ENUMERATION | EQUATION | ENCAPSULATED | EXPANDABLE | EXTENDS | CONSTRAINEDBY | EXTERNAL | T_FALSE | FINAL | FLOW | FOR | FUNCTION | IF | IMPORT | T_IN | INITIAL | INNER | T_INPUT | LOOP | MODEL | T_NOT | T_OUTER | OPERATOR | OVERLOAD | T_OR | T_OUTPUT | T_PACKAGE | PARAMETER | PARTIAL | PROTECTED | PUBLIC | RECORD | REDECLARE | REPLACEABLE | THEN | T_TRUE | TYPE | UNSIGNED_REAL | WHEN | WHILE | WITHIN | RETURN | BREAK | DOT | LPAR | RPAR | LBRACK | RBRACK | LBRACE | RBRACE | EQUALS | ASSIGN | COMMA | COLON | SEMICOLON | OPTIMIZATION | CONSTRAINT | FIELD | NONFIELD | INDOMAIN | BOM | WS | LINE_COMMENT | ML_COMMENT | CODE | CODE_NAME | CODE_EXP | CODE_ANNOTATION | CODE_VAR | STRING | END_IF | END_FOR | END_WHEN | END_WHILE | END_IDENT | T_END | IDENT | UNSIGNED_INTEGER );
652 */
653static const ANTLR3_INT32 dfa31_eot[432] =
654 {
655 -1, 36, -1, 36, 36, 36, 36, 36, 36, 36, 36, 36, -1, 36, -1, -1, 36, 36,
656 36, 36, 36, 81, -1, -1, -1, -1, -1, -1, -1, 83, -1, -1, -1, -1, -1, -1,
657 -1, -1, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
658 36, 36, 110, 36, 116, 36, 36, 36, 36, 36, 15, -1, -1, -1, -1, -1, -1, 36,
659 36, 36, 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, -1, 36, 2, 36, 36,
660 36, 36, 36, 36, 147, 36, 36, 36, 36, 36, 157, 36, 36, 36, 36, 36, 36, 36,
661 165, 36, -1, 36, 36, 36, 36, 36, -1, 36, 36, 12, 36, 36, 36, 36, 36, 36,
662 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
663 36, 36, 36, -1, 36, 204, 207, 36, 36, 157, 157, 157, 157, -1, 36, 36, 36,
664 36, 36, 36, 222, -1, 36, 36, 36, 36, 36, 36, 229, 36, 36, 36, 36, 36, 36,
665 36, 36, 36, 36, 36, 36, 36, 36, 36, 245, 246, 247, 36, 249, 36, 36, 36,
666 36, 254, 255, 256, 36, 36, 36, 36, -1, 36, 36, -1, 36, 36, 212, 212, -1,
667 212, 157, 36, 36, 36, 36, 273, 274, 275, -1, 36, 36, 36, 279, 280, 36,
668 -1, 282, 36, 284, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, -1, -1,
669 -1, 36, -1, 298, 36, 36, 36, -1, -1, -1, 36, 36, 36, 36, 36, 307, 36, 36,
670 36, 212, 212, 314, 36, 36, 36, 36, -1, -1, -1, 36, 320, 36, -1, -1, 36,
671 -1, 36, -1, 324, 36, 36, 36, 36, 36, 36, 331, 332, 36, 36, 335, 36, -1,
672 337, 36, 36, 341, 36, 36, 36, 36, -1, 36, 36, 36, 212, 212, 351, -1, 36,
673 36, 354, 36, 36, -1, 357, 36, 36, -1, 36, 36, 362, 36, 364, 36, -1, -1,
674 36, 36, -1, 36, -1, 36, 36, 36, -1, 372, 36, 374, 36, 376, 36, 36, 212,
675 380, -1, 381, 36, -1, 383, 384, -1, 385, 386, 387, 36, -1, 36, -1, 36,
676 36, 36, 36, 394, 36, 396, -1, 36, -1, 36, -1, 36, 36, 402, -1, -1, 36,
677 -1, -1, -1, -1, -1, 36, 405, 406, 407, 36, 36, -1, 410, -1, 36, 412, 413,
678 36, 36, -1, 416, 36, -1, -1, -1, 36, 36, -1, 36, -1, -1, 421, 36, -1, 36,
679 424, 36, 36, -1, 427, 428, -1, 36, 430, -1, -1, 431, -1, -1
680 };
681static const ANTLR3_INT32 dfa31_eof[432] =
682 {
683 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
684 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
685 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
686 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
687 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
688 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
689 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
690 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
691 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
692 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
693 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
694 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
695 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
696 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
697 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
698 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
699 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
700 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
701 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
702 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
703 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
704 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
705 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
706 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
707 };
708static const ANTLR3_INT32 dfa31_min[432] =
709 {
710 9, 108, -1, 108, 108, 101, 97, 97, 102, 111, 111, 111, -1, 112, 67, -1,
711 97, 101, 104, 110, 104, 42, -1, -1, -1, -1, -1, -1, -1, 61, -1, -1, -1,
712 -1, 42, -1, -1, -1, 103, 100, 111, 101, 97, 110, 115, 102, 99, 115, 99,
713 117, 112, 108, 101, 111, 114, 110, 48, 112, 48, 111, 100, 110, 116, 101,
714 48, -1, -1, -1, -1, -1, -1, 99, 111, 98, 99, 101, 117, 112, 115, 101, 116,
715 -1, -1, -1, -1, -1, 111, 48, 111, 99, 97, 115, 110, 99, 48, 105, 104, 101,
716 109, 97, 9, 97, 97, 101, 115, 97, 108, 119, 48, 99, -1, 111, 116, 101,
717 117, 111, -1, 112, 101, 48, 102, 101, 114, 105, 107, 97, 116, 108, 111,
718 101, 108, 117, 110, 101, 101, 105, 110, 108, 104, 114, 116, 107, 107, 115,
719 101, 116, 114, -1, 110, 48, 48, 101, 112, 9, 9, 9, 9, -1, 116, 110, 110,
720 101, 108, 100, 48, -1, 116, 114, 105, 114, 116, 109, 48, 108, 105, 114,
721 117, 97, 109, 97, 109, 105, 101, 105, 114, 99, 97, 114, 48, 48, 48, 103,
722 48, 101, 105, 105, 97, 48, 48, 48, 99, 97, 101, 101, -1, 102, 104, -1,
723 114, 115, 104, 111, -1, 102, 9, 105, 100, 100, 110, 48, 48, 48, -1, 105,
724 116, 97, 48, 48, 97, -1, 48, 101, 48, 116, 116, 105, 103, 101, 97, 99,
725 99, 100, 108, 99, 110, -1, -1, -1, 110, -1, 48, 110, 116, 116, -1, -1,
726 -1, 116, 110, 97, 116, 117, 48, 101, 97, 117, 101, 114, 48, 111, 97, 115,
727 97, -1, -1, -1, 111, 48, 108, -1, -1, 105, -1, 108, -1, 48, 111, 122, 101,
728 116, 108, 116, 48, 48, 97, 101, 48, 101, -1, 48, 104, 105, 48, 116, 105,
729 101, 110, -1, 110, 116, 108, 108, 110, 48, -1, 110, 98, 48, 108, 110, -1,
730 48, 110, 100, -1, 114, 97, 48, 101, 48, 101, -1, -1, 114, 97, -1, 100,
731 -1, 109, 111, 114, -1, 48, 110, 48, 105, 48, 105, 97, 101, 48, -1, 48,
732 108, -1, 48, 48, -1, 48, 48, 48, 116, -1, 114, -1, 100, 101, 98, 95, 48,
733 110, 48, -1, 101, -1, 116, -1, 111, 116, 48, -1, -1, 101, -1, -1, -1, -1,
734 -1, 105, 48, 48, 48, 108, 114, -1, 48, -1, 100, 48, 48, 110, 101, -1, 48,
735 111, -1, -1, -1, 101, 101, -1, 98, -1, -1, 48, 100, -1, 110, 48, 97, 121,
736 -1, 48, 48, -1, 108, 48, -1, -1, 48, -1, -1
737 };
738static const ANTLR3_INT32 dfa31_max[432] =
739 {
740 239, 110, -1, 114, 111, 105, 120, 117, 110, 111, 111, 111, -1, 117, 111,
741 -1, 117, 101, 121, 110, 105, 94, -1, -1, -1, -1, -1, -1, -1, 61, -1, -1,
742 -1, -1, 47, -1, -1, -1, 103, 110, 111, 101, 97, 110, 115, 114, 99, 115,
743 117, 117, 116, 108, 110, 111, 114, 110, 122, 112, 122, 111, 100, 116, 116,
744 116, 122, -1, -1, -1, -1, -1, -1, 114, 111, 98, 116, 101, 117, 112, 115,
745 105, 116, -1, -1, -1, -1, -1, 111, 122, 111, 99, 97, 115, 115, 99, 122,
746 105, 104, 101, 109, 97, 122, 97, 97, 101, 115, 97, 108, 119, 122, 99, -1,
747 111, 116, 101, 117, 111, -1, 112, 101, 122, 102, 112, 114, 105, 107, 116,
748 116, 108, 111, 101, 108, 117, 110, 101, 101, 105, 110, 108, 104, 114, 116,
749 107, 107, 115, 101, 116, 114, -1, 110, 122, 122, 101, 112, 122, 122, 122,
750 122, -1, 116, 110, 114, 101, 108, 100, 122, -1, 116, 114, 105, 114, 116,
751 109, 122, 108, 105, 114, 117, 97, 109, 97, 109, 105, 101, 105, 114, 99,
752 97, 114, 122, 122, 122, 103, 122, 101, 105, 105, 97, 122, 122, 122, 99,
753 114, 101, 101, -1, 102, 104, -1, 114, 115, 104, 111, -1, 102, 122, 105,
754 100, 100, 110, 122, 122, 122, -1, 105, 116, 97, 122, 122, 97, -1, 122,
755 101, 122, 116, 116, 105, 103, 101, 97, 99, 99, 100, 108, 99, 110, -1, -1,
756 -1, 110, -1, 122, 110, 116, 116, -1, -1, -1, 116, 110, 97, 116, 117, 122,
757 101, 97, 117, 105, 114, 122, 111, 97, 115, 97, -1, -1, -1, 111, 122, 108,
758 -1, -1, 105, -1, 108, -1, 122, 111, 122, 101, 116, 108, 116, 122, 122,
759 97, 101, 122, 101, -1, 122, 104, 105, 122, 116, 105, 101, 110, -1, 110,
760 116, 108, 108, 110, 122, -1, 110, 98, 122, 108, 110, -1, 122, 110, 100,
761 -1, 114, 97, 122, 101, 122, 101, -1, -1, 114, 97, -1, 100, -1, 109, 111,
762 114, -1, 122, 110, 122, 105, 122, 105, 97, 101, 122, -1, 122, 108, -1,
763 122, 122, -1, 122, 122, 122, 116, -1, 114, -1, 100, 101, 98, 95, 122, 110,
764 122, -1, 116, -1, 116, -1, 111, 116, 122, -1, -1, 101, -1, -1, -1, -1,
765 -1, 105, 122, 122, 122, 108, 114, -1, 122, -1, 100, 122, 122, 110, 101,
766 -1, 122, 111, -1, -1, -1, 101, 101, -1, 98, -1, -1, 122, 100, -1, 110,
767 122, 97, 121, -1, 122, 122, -1, 108, 122, -1, -1, 122, -1, -1
768 };
769static const ANTLR3_INT32 dfa31_accept[432] =
770 {
771 -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, 36, -1, -1, 40, -1, -1,
772 -1, -1, -1, -1, 60, 61, 62, 63, 64, 65, 66, -1, 68, 70, 76, 77, -1, 85,
773 92, 93, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
774 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 39, 80, 81, 82, 83, 84, -1,
775 -1, -1, -1, -1, -1, -1, -1, -1, -1, 59, 67, 69, 78, 79, -1, -1, -1, -1,
776 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
777 -1, -1, 28, -1, -1, -1, -1, -1, 30, -1, -1, -1, -1, -1, -1, -1, -1, -1,
778 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
779 -1, -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, -1, -1,
780 -1, -1, -1, 26, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
781 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
782 -1, -1, -1, -1, -1, -1, 12, -1, -1, 13, -1, -1, -1, -1, 90, -1, -1, -1,
783 -1, -1, -1, -1, -1, -1, 25, -1, -1, -1, -1, -1, -1, 34, -1, -1, -1, -1,
784 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 50, 51, 52, -1, 54, -1, -1,
785 -1, -1, 4, 58, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
786 -1, -1, 23, 24, 73, -1, -1, -1, 32, 33, -1, 35, -1, 37, -1, -1, -1, -1,
787 -1, -1, -1, -1, -1, -1, -1, -1, -1, 55, -1, -1, -1, -1, -1, -1, -1, -1,
788 14, -1, -1, -1, -1, -1, -1, 86, -1, -1, -1, -1, -1, 29, -1, -1, -1, 41,
789 -1, -1, -1, -1, -1, -1, 46, 47, -1, -1, 57, -1, 56, -1, -1, -1, 6, -1,
790 -1, -1, -1, -1, -1, -1, -1, -1, 87, -1, -1, 20, -1, -1, 31, -1, -1, -1,
791 -1, 42, -1, 44, -1, -1, -1, -1, -1, -1, -1, 8, -1, 9, -1, 15, -1, -1, -1,
792 88, 17, -1, 22, 27, 75, 74, 38, -1, -1, -1, -1, -1, -1, 1, -1, 7, -1, -1,
793 -1, -1, -1, 89, -1, -1, 43, 45, 48, -1, -1, 3, -1, 72, 11, -1, -1, 19,
794 -1, -1, -1, -1, 16, -1, -1, 49, -1, -1, 18, 71, -1, 21, 53
795 };
796static const ANTLR3_INT32 dfa31_special[432] =
797 {
798 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
799 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
800 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
801 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
802 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
803 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
804 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
805 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
806 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
807 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
808 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
809 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
810 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
811 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
812 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
813 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
814 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
815 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
816 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
817 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
818 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
819 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
820 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
821 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
822 };
823
824/** Used when there is no transition table entry for a particular state */
825#define dfa31_T_empty((void*)0) NULL((void*)0)
826
827static const ANTLR3_INT32 dfa31_T0[] =
828 {
829 59
830 };static const ANTLR3_INT32 dfa31_T1[] =
831 {
832 136, -1, -1, -1, 137
833 };static const ANTLR3_INT32 dfa31_T2[] =
834 {
835 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, -1, -1, -1, 36,
836 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
837 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, 36, -1, 36, 36, 36, 36, 36,
838 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
839 36, 36, 36
840 };static const ANTLR3_INT32 dfa31_T3[] =
841 {
842 169
843 };static const ANTLR3_INT32 dfa31_T4[] =
844 {
845 226
846 };static const ANTLR3_INT32 dfa31_T5[] =
847 {
848 60
849 };static const ANTLR3_INT32 dfa31_T6[] =
850 {
851 154, 156, -1, -1, 155, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
852 -1, -1, -1, -1, -1, -1, 153, -1, -1, -1, 212, -1, -1, 212, -1, -1, -1,
853 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
854 -1, -1, -1, -1, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
855 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
856 -1, -1, -1, -1, 212, -1, 212, 212, 212, 212, 212, 211, 212, 212, 213, 212,
857 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 210, 212, 212,
858 212
859 };static const ANTLR3_INT32 dfa31_T7[] =
860 {
861 170
862 };static const ANTLR3_INT32 dfa31_T8[] =
863 {
864 227
865 };static const ANTLR3_INT32 dfa31_T9[] =
866 {
867 117
868 };static const ANTLR3_INT32 dfa31_T10[] =
869 {
870 172
871 };static const ANTLR3_INT32 dfa31_T11[] =
872 {
873 42, -1, -1, 43
874 };static const ANTLR3_INT32 dfa31_T12[] =
875 {
876 118
877 };static const ANTLR3_INT32 dfa31_T13[] =
878 {
879 173
880 };static const ANTLR3_INT32 dfa31_T14[] =
881 {
882 230
883 };static const ANTLR3_INT32 dfa31_T15[] =
884 {
885 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, -1, -1, -1, 36,
886 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
887 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, 36, -1, 36, 36, 36, 36, 36,
888 36, 36, 36, 36, 36, 36, 36, 36, 36, 340, 36, 36, 36, 36, 36, 36, 36, 36,
889 36, 36, 36
890 };static const ANTLR3_INT32 dfa31_T16[] =
891 {
892 232
893 };static const ANTLR3_INT32 dfa31_T17[] =
894 {
895 177
896 };static const ANTLR3_INT32 dfa31_T18[] =
897 {
898 234
899 };static const ANTLR3_INT32 dfa31_T19[] =
900 {
901 286
902 };static const ANTLR3_INT32 dfa31_T20[] =
903 {
904 325
905 };static const ANTLR3_INT32 dfa31_T21[] =
906 {
907 360
908 };static const ANTLR3_INT32 dfa31_T22[] =
909 {
910 200
911 };static const ANTLR3_INT32 dfa31_T23[] =
912 {
913 257
914 };static const ANTLR3_INT32 dfa31_T24[] =
915 {
916 302
917 };static const ANTLR3_INT32 dfa31_T25[] =
918 {
919 233
920 };static const ANTLR3_INT32 dfa31_T26[] =
921 {
922 285
923 };static const ANTLR3_INT32 dfa31_T27[] =
924 {
925 179
926 };static const ANTLR3_INT32 dfa31_T28[] =
927 {
928 236
929 };static const ANTLR3_INT32 dfa31_T29[] =
930 {
931 288
932 };static const ANTLR3_INT32 dfa31_T30[] =
933 {
934 327
935 };static const ANTLR3_INT32 dfa31_T31[] =
936 {
937 237
938 };static const ANTLR3_INT32 dfa31_T32[] =
939 {
940 289
941 };static const ANTLR3_INT32 dfa31_T33[] =
942 {
943 328
944 };static const ANTLR3_INT32 dfa31_T34[] =
945 {
946 363
947 };static const ANTLR3_INT32 dfa31_T35[] =
948 {
949 389
950 };static const ANTLR3_INT32 dfa31_T36[] =
951 {
952 238
953 };static const ANTLR3_INT32 dfa31_T37[] =
954 {
955 290
956 };static const ANTLR3_INT32 dfa31_T38[] =
957 {
958 329
959 };static const ANTLR3_INT32 dfa31_T39[] =
960 {
961 201
962 };static const ANTLR3_INT32 dfa31_T40[] =
963 {
964 126
965 };static const ANTLR3_INT32 dfa31_T41[] =
966 {
967 182
968 };static const ANTLR3_INT32 dfa31_T42[] =
969 {
970 258, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 259
971 };static const ANTLR3_INT32 dfa31_T43[] =
972 {
973 239
974 };static const ANTLR3_INT32 dfa31_T44[] =
975 {
976 291
977 };static const ANTLR3_INT32 dfa31_T45[] =
978 {
979 330
980 };static const ANTLR3_INT32 dfa31_T46[] =
981 {
982 365
983 };static const ANTLR3_INT32 dfa31_T47[] =
984 {
985 390
986 };static const ANTLR3_INT32 dfa31_T48[] =
987 {
988 127
989 };static const ANTLR3_INT32 dfa31_T49[] =
990 {
991 183
992 };static const ANTLR3_INT32 dfa31_T50[] =
993 {
994 240
995 };static const ANTLR3_INT32 dfa31_T51[] =
996 {
997 292
998 };static const ANTLR3_INT32 dfa31_T52[] =
999 {
1000 184
1001 };static const ANTLR3_INT32 dfa31_T53[] =
1002 {
1003 241
1004 };static const ANTLR3_INT32 dfa31_T54[] =
1005 {
1006 293
1007 };static const ANTLR3_INT32 dfa31_T55[] =
1008 {
1009 82
1010 };static const ANTLR3_INT32 dfa31_T56[] =
1011 {
1012 95, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 94
1013 };static const ANTLR3_INT32 dfa31_T57[] =
1014 {
1015 185
1016 };static const ANTLR3_INT32 dfa31_T58[] =
1017 {
1018 242
1019 };static const ANTLR3_INT32 dfa31_T59[] =
1020 {
1021 294
1022 };static const ANTLR3_INT32 dfa31_T60[] =
1023 {
1024 333
1025 };static const ANTLR3_INT32 dfa31_T61[] =
1026 {
1027 366
1028 };static const ANTLR3_INT32 dfa31_T62[] =
1029 {
1030 391
1031 };static const ANTLR3_INT32 dfa31_T63[] =
1032 {
1033 186
1034 };static const ANTLR3_INT32 dfa31_T64[] =
1035 {
1036 243
1037 };static const ANTLR3_INT32 dfa31_T65[] =
1038 {
1039 295
1040 };static const ANTLR3_INT32 dfa31_T66[] =
1041 {
1042 334
1043 };static const ANTLR3_INT32 dfa31_T67[] =
1044 {
1045 367
1046 };static const ANTLR3_INT32 dfa31_T68[] =
1047 {
1048 392
1049 };static const ANTLR3_INT32 dfa31_T69[] =
1050 {
1051 408
1052 };static const ANTLR3_INT32 dfa31_T70[] =
1053 {
1054 418
1055 };static const ANTLR3_INT32 dfa31_T71[] =
1056 {
1057 132
1058 };static const ANTLR3_INT32 dfa31_T72[] =
1059 {
1060 78
1061 };static const ANTLR3_INT32 dfa31_T73[] =
1062 {
1063 188
1064 };static const ANTLR3_INT32 dfa31_T74[] =
1065 {
1066 133
1067 };static const ANTLR3_INT32 dfa31_T75[] =
1068 {
1069 189
1070 };static const ANTLR3_INT32 dfa31_T76[] =
1071 {
1072 134
1073 };static const ANTLR3_INT32 dfa31_T77[] =
1074 {
1075 190
1076 };static const ANTLR3_INT32 dfa31_T78[] =
1077 {
1078 135
1079 };static const ANTLR3_INT32 dfa31_T79[] =
1080 {
1081 191
1082 };static const ANTLR3_INT32 dfa31_T80[] =
1083 {
1084 248
1085 };static const ANTLR3_INT32 dfa31_T81[] =
1086 {
1087 297
1088 };static const ANTLR3_INT32 dfa31_T82[] =
1089 {
1090 336
1091 };static const ANTLR3_INT32 dfa31_T83[] =
1092 {
1093 368
1094 };static const ANTLR3_INT32 dfa31_T84[] =
1095 {
1096 393
1097 };static const ANTLR3_INT32 dfa31_T85[] =
1098 {
1099 409
1100 };static const ANTLR3_INT32 dfa31_T86[] =
1101 {
1102 99, 100, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1103 98
1104 };static const ANTLR3_INT32 dfa31_T87[] =
1105 {
1106 419
1107 };static const ANTLR3_INT32 dfa31_T88[] =
1108 {
1109 425
1110 };static const ANTLR3_INT32 dfa31_T89[] =
1111 {
1112 429
1113 };static const ANTLR3_INT32 dfa31_T90[] =
1114 {
1115 192
1116 };static const ANTLR3_INT32 dfa31_T91[] =
1117 {
1118 193
1119 };static const ANTLR3_INT32 dfa31_T92[] =
1120 {
1121 250
1122 };static const ANTLR3_INT32 dfa31_T93[] =
1123 {
1124 38, -1, 39
1125 };static const ANTLR3_INT32 dfa31_T94[] =
1126 {
1127 138
1128 };static const ANTLR3_INT32 dfa31_T95[] =
1129 {
1130 194
1131 };static const ANTLR3_INT32 dfa31_T96[] =
1132 {
1133 251
1134 };static const ANTLR3_INT32 dfa31_T97[] =
1135 {
1136 299
1137 };static const ANTLR3_INT32 dfa31_T98[] =
1138 {
1139 187
1140 };static const ANTLR3_INT32 dfa31_T99[] =
1141 {
1142 244
1143 };static const ANTLR3_INT32 dfa31_T100[] =
1144 {
1145 296
1146 };static const ANTLR3_INT32 dfa31_T101[] =
1147 {
1148 90
1149 };static const ANTLR3_INT32 dfa31_T102[] =
1150 {
1151 142
1152 };static const ANTLR3_INT32 dfa31_T103[] =
1153 {
1154 198
1155 };static const ANTLR3_INT32 dfa31_T104[] =
1156 {
1157 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, -1, -1, -1, -1, -1, -1,
1158 -1, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
1159 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, -1, -1, -1,
1160 -1, 212, -1, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
1161 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212
1162 };static const ANTLR3_INT32 dfa31_T105[] =
1163 {
1164 178
1165 };static const ANTLR3_INT32 dfa31_T106[] =
1166 {
1167 235
1168 };static const ANTLR3_INT32 dfa31_T107[] =
1169 {
1170 287
1171 };static const ANTLR3_INT32 dfa31_T108[] =
1172 {
1173 326
1174 };static const ANTLR3_INT32 dfa31_T109[] =
1175 {
1176 361
1177 };static const ANTLR3_INT32 dfa31_T110[] =
1178 {
1179 388
1180 };static const ANTLR3_INT32 dfa31_T111[] =
1181 {
1182 404
1183 };static const ANTLR3_INT32 dfa31_T112[] =
1184 {
1185 417
1186 };static const ANTLR3_INT32 dfa31_T113[] =
1187 {
1188 423
1189 };static const ANTLR3_INT32 dfa31_T114[] =
1190 {
1191 163
1192 };static const ANTLR3_INT32 dfa31_T115[] =
1193 {
1194 221
1195 };static const ANTLR3_INT32 dfa31_T116[] =
1196 {
1197 174
1198 };static const ANTLR3_INT32 dfa31_T117[] =
1199 {
1200 231
1201 };static const ANTLR3_INT32 dfa31_T118[] =
1202 {
1203 283
1204 };static const ANTLR3_INT32 dfa31_T119[] =
1205 {
1206 323
1207 };static const ANTLR3_INT32 dfa31_T120[] =
1208 {
1209 359
1210 };static const ANTLR3_INT32 dfa31_T121[] =
1211 {
1212 74
1213 };static const ANTLR3_INT32 dfa31_T122[] =
1214 {
1215 171
1216 };static const ANTLR3_INT32 dfa31_T123[] =
1217 {
1218 228
1219 };static const ANTLR3_INT32 dfa31_T124[] =
1220 {
1221 281
1222 };static const ANTLR3_INT32 dfa31_T125[] =
1223 {
1224 322
1225 };static const ANTLR3_INT32 dfa31_T126[] =
1226 {
1227 358
1228 };static const ANTLR3_INT32 dfa31_T127[] =
1229 {
1230 128, 129, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 130, -1, -1, -1,
1231 131
1232 };static const ANTLR3_INT32 dfa31_T128[] =
1233 {
1234 160
1235 };static const ANTLR3_INT32 dfa31_T129[] =
1236 {
1237 217, -1, -1, -1, 218
1238 };static const ANTLR3_INT32 dfa31_T130[] =
1239 {
1240 124, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 125
1241 };static const ANTLR3_INT32 dfa31_T131[] =
1242 {
1243 45, -1, -1, -1, 44
1244 };static const ANTLR3_INT32 dfa31_T132[] =
1245 {
1246 154, 214, -1, -1, 155, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1247 -1, -1, -1, -1, -1, -1, 153, -1, -1, -1, 212, -1, -1, 212, -1, -1, -1,
1248 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1249 -1, -1, -1, -1, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
1250 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212,
1251 -1, -1, -1, -1, 212, -1, 212, 212, 212, 212, 212, 211, 212, 212, 213, 212,
1252 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 212, 210, 212, 212,
1253 212
1254 };static const ANTLR3_INT32 dfa31_T133[] =
1255 {
1256 46, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 47, -1, 48, -1, -1, 49, -1,
1257 -1, -1, -1, -1, -1, 50
1258 };static const ANTLR3_INT32 dfa31_T134[] =
1259 {
1260 40, -1, -1, -1, -1, -1, 41
1261 };static const ANTLR3_INT32 dfa31_T135[] =
1262 {
1263 97
1264 };static const ANTLR3_INT32 dfa31_T136[] =
1265 {
1266 150
1267 };static const ANTLR3_INT32 dfa31_T137[] =
1268 {
1269 56, -1, -1, -1, -1, -1, -1, 57, 58
1270 };static const ANTLR3_INT32 dfa31_T138[] =
1271 {
1272 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, -1, -1, -1, 36,
1273 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
1274 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, 36, -1, 36, 36, 36, 36, 36,
1275 36, 36, 36, 205, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 206,
1276 36, 36, 36
1277 };static const ANTLR3_INT32 dfa31_T139[] =
1278 {
1279 33, 33, -1, -1, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1280 -1, -1, -1, -1, -1, 33, 12, 35, -1, 14, -1, 2, 36, 22, 23, -1, -1, 30,
1281 -1, 21, 34, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 29, 31, -1, 28, -1,
1282 -1, -1, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
1283 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 24, -1, 25, -1, 36, -1, 1, 3, 4,
1284 5, 6, 7, 36, 36, 8, 36, 36, 9, 10, 11, 13, 16, 36, 17, 36, 18, 19, 36,
1285 20, 36, 36, 36, 26, 15, 27, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 32
1292 };static const ANTLR3_INT32 dfa31_T140[] =
1293 {
1294 268
1295 };static const ANTLR3_INT32 dfa31_T141[] =
1296 {
1297 75, -1, -1, -1, -1, -1, -1, -1, -1, -1, 76, -1, -1, -1, -1, -1, -1, 77
1298 };static const ANTLR3_INT32 dfa31_T142[] =
1299 {
1300 267
1301 };static const ANTLR3_INT32 dfa31_T143[] =
1302 {
1303 313
1304 };static const ANTLR3_INT32 dfa31_T144[] =
1305 {
1306 121
1307 };static const ANTLR3_INT32 dfa31_T145[] =
1308 {
1309 175, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 176
1310 };static const ANTLR3_INT32 dfa31_T146[] =
1311 {
1312 350
1313 };static const ANTLR3_INT32 dfa31_T147[] =
1314 {
1315 86
1316 };static const ANTLR3_INT32 dfa31_T148[] =
1317 {
1318 139
1319 };static const ANTLR3_INT32 dfa31_T149[] =
1320 {
1321 195
1322 };static const ANTLR3_INT32 dfa31_T150[] =
1323 {
1324 252
1325 };static const ANTLR3_INT32 dfa31_T151[] =
1326 {
1327 300
1328 };static const ANTLR3_INT32 dfa31_T152[] =
1329 {
1330 338
1331 };static const ANTLR3_INT32 dfa31_T153[] =
1332 {
1333 369
1334 };static const ANTLR3_INT32 dfa31_T154[] =
1335 {
1336 349
1337 };static const ANTLR3_INT32 dfa31_T155[] =
1338 {
1339 379
1340 };static const ANTLR3_INT32 dfa31_T156[] =
1341 {
1342 140
1343 };static const ANTLR3_INT32 dfa31_T157[] =
1344 {
1345 196
1346 };static const ANTLR3_INT32 dfa31_T158[] =
1347 {
1348 253
1349 };static const ANTLR3_INT32 dfa31_T159[] =
1350 {
1351 301
1352 };static const ANTLR3_INT32 dfa31_T160[] =
1353 {
1354 339
1355 };static const ANTLR3_INT32 dfa31_T161[] =
1356 {
1357 37, 37, -1, 37, -1, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, -1, -1,
1358 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1359 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 37
1360 };static const ANTLR3_INT32 dfa31_T162[] =
1361 {
1362 370
1363 };static const ANTLR3_INT32 dfa31_T163[] =
1364 {
1365 395
1366 };static const ANTLR3_INT32 dfa31_T164[] =
1367 {
1368 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, -1, -1, -1, 36,
1369 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
1370 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, 36, -1, 36, 36, 36, 115, 36,
1371 36, 36, 36, 112, 36, 36, 36, 36, 113, 36, 114, 36, 36, 36, 36, 36, 36,
1372 36, 36, 36, 36
1373 };static const ANTLR3_INT32 dfa31_T165[] =
1374 {
1375 89
1376 };static const ANTLR3_INT32 dfa31_T166[] =
1377 {
1378 141
1379 };static const ANTLR3_INT32 dfa31_T167[] =
1380 {
1381 197
1382 };static const ANTLR3_INT32 dfa31_T168[] =
1383 {
1384 91
1385 };static const ANTLR3_INT32 dfa31_T169[] =
1386 {
1387 143
1388 };static const ANTLR3_INT32 dfa31_T170[] =
1389 {
1390 199
1391 };static const ANTLR3_INT32 dfa31_T171[] =
1392 {
1393 92
1394 };static const ANTLR3_INT32 dfa31_T172[] =
1395 {
1396 144, -1, -1, -1, -1, 145
1397 };static const ANTLR3_INT32 dfa31_T173[] =
1398 {
1399 79, 80
1400 };static const ANTLR3_INT32 dfa31_T174[] =
1401 {
1402 63, -1, 64, -1, -1, 62
1403 };static const ANTLR3_INT32 dfa31_T175[] =
1404 {
1405 371
1406 };static const ANTLR3_INT32 dfa31_T176[] =
1407 {
1408 303
1409 };static const ANTLR3_INT32 dfa31_T177[] =
1410 {
1411 342
1412 };static const ANTLR3_INT32 dfa31_T178[] =
1413 {
1414 180, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1415 -1, 181
1416 };static const ANTLR3_INT32 dfa31_T179[] =
1417 {
1418 93
1419 };static const ANTLR3_INT32 dfa31_T180[] =
1420 {
1421 146
1422 };static const ANTLR3_INT32 dfa31_T181[] =
1423 {
1424 71, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 72,
1425 -1, -1, 73
1426 };static const ANTLR3_INT32 dfa31_T182[] =
1427 {
1428 202
1429 };static const ANTLR3_INT32 dfa31_T183[] =
1430 {
1431 260
1432 };static const ANTLR3_INT32 dfa31_T184[] =
1433 {
1434 305
1435 };static const ANTLR3_INT32 dfa31_T185[] =
1436 {
1437 344
1438 };static const ANTLR3_INT32 dfa31_T186[] =
1439 {
1440 304
1441 };static const ANTLR3_INT32 dfa31_T187[] =
1442 {
1443 343
1444 };static const ANTLR3_INT32 dfa31_T188[] =
1445 {
1446 373
1447 };static const ANTLR3_INT32 dfa31_T189[] =
1448 {
1449 397, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 398
1450 };static const ANTLR3_INT32 dfa31_T190[] =
1451 {
1452 148
1453 };static const ANTLR3_INT32 dfa31_T191[] =
1454 {
1455 203
1456 };static const ANTLR3_INT32 dfa31_T192[] =
1457 {
1458 261
1459 };static const ANTLR3_INT32 dfa31_T193[] =
1460 {
1461 306
1462 };static const ANTLR3_INT32 dfa31_T194[] =
1463 {
1464 345
1465 };static const ANTLR3_INT32 dfa31_T195[] =
1466 {
1467 375
1468 };static const ANTLR3_INT32 dfa31_T196[] =
1469 {
1470 399
1471 };static const ANTLR3_INT32 dfa31_T197[] =
1472 {
1473 96
1474 };static const ANTLR3_INT32 dfa31_T198[] =
1475 {
1476 149
1477 };static const ANTLR3_INT32 dfa31_T199[] =
1478 {
1479 102, -1, -1, -1, 103
1480 };static const ANTLR3_INT32 dfa31_T200[] =
1481 {
1482 262
1483 };static const ANTLR3_INT32 dfa31_T201[] =
1484 {
1485 266
1486 };static const ANTLR3_INT32 dfa31_T202[] =
1487 {
1488 106, -1, -1, -1, -1, -1, -1, -1, -1, 105
1489 };static const ANTLR3_INT32 dfa31_T203[] =
1490 {
1491 263
1492 };static const ANTLR3_INT32 dfa31_T204[] =
1493 {
1494 308
1495 };static const ANTLR3_INT32 dfa31_T205[] =
1496 {
1497 346
1498 };static const ANTLR3_INT32 dfa31_T206[] =
1499 {
1500 51, -1, -1, -1, -1, -1, -1, -1, 52, -1, -1, 53, -1, -1, 54, -1, -1, -1,
1501 -1, -1, 55
1502 };static const ANTLR3_INT32 dfa31_T207[] =
1503 {
1504 151
1505 };static const ANTLR3_INT32 dfa31_T208[] =
1506 {
1507 208
1508 };static const ANTLR3_INT32 dfa31_T209[] =
1509 {
1510 264
1511 };static const ANTLR3_INT32 dfa31_T210[] =
1512 {
1513 309
1514 };static const ANTLR3_INT32 dfa31_T211[] =
1515 {
1516 347
1517 };static const ANTLR3_INT32 dfa31_T212[] =
1518 {
1519 377
1520 };static const ANTLR3_INT32 dfa31_T213[] =
1521 {
1522 400
1523 };static const ANTLR3_INT32 dfa31_T214[] =
1524 {
1525 414
1526 };static const ANTLR3_INT32 dfa31_T215[] =
1527 {
1528 101
1529 };static const ANTLR3_INT32 dfa31_T216[] =
1530 {
1531 158
1532 };static const ANTLR3_INT32 dfa31_T217[] =
1533 {
1534 312, -1, -1, -1, 311
1535 };static const ANTLR3_INT32 dfa31_T218[] =
1536 {
1537 215
1538 };static const ANTLR3_INT32 dfa31_T219[] =
1539 {
1540 269
1541 };static const ANTLR3_INT32 dfa31_T220[] =
1542 {
1543 315
1544 };static const ANTLR3_INT32 dfa31_T221[] =
1545 {
1546 352
1547 };static const ANTLR3_INT32 dfa31_T222[] =
1548 {
1549 152
1550 };static const ANTLR3_INT32 dfa31_T223[] =
1551 {
1552 209
1553 };static const ANTLR3_INT32 dfa31_T224[] =
1554 {
1555 265
1556 };static const ANTLR3_INT32 dfa31_T225[] =
1557 {
1558 310
1559 };static const ANTLR3_INT32 dfa31_T226[] =
1560 {
1561 348
1562 };static const ANTLR3_INT32 dfa31_T227[] =
1563 {
1564 378
1565 };static const ANTLR3_INT32 dfa31_T228[] =
1566 {
1567 401
1568 };static const ANTLR3_INT32 dfa31_T229[] =
1569 {
1570 415
1571 };static const ANTLR3_INT32 dfa31_T230[] =
1572 {
1573 422
1574 };static const ANTLR3_INT32 dfa31_T231[] =
1575 {
1576 159
1577 };static const ANTLR3_INT32 dfa31_T232[] =
1578 {
1579 216
1580 };static const ANTLR3_INT32 dfa31_T233[] =
1581 {
1582 270
1583 };static const ANTLR3_INT32 dfa31_T234[] =
1584 {
1585 316
1586 };static const ANTLR3_INT32 dfa31_T235[] =
1587 {
1588 353
1589 };static const ANTLR3_INT32 dfa31_T236[] =
1590 {
1591 382
1592 };static const ANTLR3_INT32 dfa31_T237[] =
1593 {
1594 403
1595 };static const ANTLR3_INT32 dfa31_T238[] =
1596 {
1597 271
1598 };static const ANTLR3_INT32 dfa31_T239[] =
1599 {
1600 317
1601 };static const ANTLR3_INT32 dfa31_T240[] =
1602 {
1603 154, 156, -1, -1, 155, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1604 -1, -1, -1, -1, -1, -1, 153, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1605 -1, -1, -1, -1, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1,
1606 -1, -1, -1, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
1607 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, -1, -1, -1, -1, 36, -1, 36,
1608 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
1609 36, 36, 36, 36, 36, 36, 36
1610 };static const ANTLR3_INT32 dfa31_T241[] =
1611 {
1612 122, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 123
1613 };static const ANTLR3_INT32 dfa31_T242[] =
1614 {
1615 61
1616 };static const ANTLR3_INT32 dfa31_T243[] =
1617 {
1618 411
1619 };static const ANTLR3_INT32 dfa31_T244[] =
1620 {
1621 420
1622 };static const ANTLR3_INT32 dfa31_T245[] =
1623 {
1624 426
1625 };static const ANTLR3_INT32 dfa31_T246[] =
1626 {
1627 85, -1, -1, -1, -1, 84
1628 };static const ANTLR3_INT32 dfa31_T247[] =
1629 {
1630 272
1631 };static const ANTLR3_INT32 dfa31_T248[] =
1632 {
1633 318
1634 };static const ANTLR3_INT32 dfa31_T249[] =
1635 {
1636 355
1637 };static const ANTLR3_INT32 dfa31_T250[] =
1638 {
1639 66, -1, 68, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 67,
1640 -1, 70, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 69, -1, 36, -1, -1, -1,
1641 -1, -1, -1, -1, -1, -1, -1, -1, 65
1642 };static const ANTLR3_INT32 dfa31_T251[] =
1643 {
1644 104
1645 };static const ANTLR3_INT32 dfa31_T252[] =
1646 {
1647 120, -1, -1, -1, -1, -1, 119
1648 };static const ANTLR3_INT32 dfa31_T253[] =
1649 {
1650 161
1651 };static const ANTLR3_INT32 dfa31_T254[] =
1652 {
1653 219
1654 };static const ANTLR3_INT32 dfa31_T255[] =
1655 {
1656 162
1657 };static const ANTLR3_INT32 dfa31_T256[] =
1658 {
1659 220
1660 };static const ANTLR3_INT32 dfa31_T257[] =
1661 {
1662 107
1663 };static const ANTLR3_INT32 dfa31_T258[] =
1664 {
1665 164
1666 };static const ANTLR3_INT32 dfa31_T259[] =
1667 {
1668 108
1669 };static const ANTLR3_INT32 dfa31_T260[] =
1670 {
1671 109
1672 };static const ANTLR3_INT32 dfa31_T261[] =
1673 {
1674 166
1675 };static const ANTLR3_INT32 dfa31_T262[] =
1676 {
1677 223
1678 };static const ANTLR3_INT32 dfa31_T263[] =
1679 {
1680 276
1681 };static const ANTLR3_INT32 dfa31_T264[] =
1682 {
1683 319
1684 };static const ANTLR3_INT32 dfa31_T265[] =
1685 {
1686 356
1687 };static const ANTLR3_INT32 dfa31_T266[] =
1688 {
1689 111
1690 };static const ANTLR3_INT32 dfa31_T267[] =
1691 {
1692 167
1693 };static const ANTLR3_INT32 dfa31_T268[] =
1694 {
1695 224
1696 };static const ANTLR3_INT32 dfa31_T269[] =
1697 {
1698 277
1699 };static const ANTLR3_INT32 dfa31_T270[] =
1700 {
1701 87, -1, -1, -1, -1, -1, -1, -1, -1, -1, 88
1702 };static const ANTLR3_INT32 dfa31_T271[] =
1703 {
1704 168
1705 };static const ANTLR3_INT32 dfa31_T272[] =
1706 {
1707 225
1708 };static const ANTLR3_INT32 dfa31_T273[] =
1709 {
1710 278
1711 };static const ANTLR3_INT32 dfa31_T274[] =
1712 {
1713 321
1714 };
1715
1716/* Transition tables are a table of sub tables, with some tables
1717 * reused for efficiency.
1718 */
1719static const ANTLR3_INT32 * const dfa31_transitions[] =
1720{
1721 dfa31_T139, dfa31_T93, dfa31_T_empty((void*)0), dfa31_T134, dfa31_T11, dfa31_T131,
1722 dfa31_T133, dfa31_T206, dfa31_T137, dfa31_T0, dfa31_T5, dfa31_T242,
1723 dfa31_T_empty((void*)0), dfa31_T174, dfa31_T250, dfa31_T_empty((void*)0), dfa31_T181, dfa31_T121,
1724 dfa31_T141, dfa31_T72, dfa31_T173, dfa31_T161, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0),
1725 dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0),
1726 dfa31_T55, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0),
1727 dfa31_T246, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T147,
1728 dfa31_T270, dfa31_T165, dfa31_T101, dfa31_T168, dfa31_T171, dfa31_T179,
1729 dfa31_T56, dfa31_T197, dfa31_T135, dfa31_T86, dfa31_T215, dfa31_T199,
1730 dfa31_T251, dfa31_T202, dfa31_T257, dfa31_T259, dfa31_T260, dfa31_T2,
1731 dfa31_T266, dfa31_T164, dfa31_T9, dfa31_T12, dfa31_T252, dfa31_T144,
1732 dfa31_T241, dfa31_T2, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0),
1733 dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T130, dfa31_T40, dfa31_T48, dfa31_T127,
1734 dfa31_T71, dfa31_T74, dfa31_T76, dfa31_T78, dfa31_T1, dfa31_T94, dfa31_T_empty((void*)0),
1735 dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T148,
1736 dfa31_T2, dfa31_T156, dfa31_T166, dfa31_T102, dfa31_T169, dfa31_T172,
1737 dfa31_T180, dfa31_T2, dfa31_T190, dfa31_T198, dfa31_T136, dfa31_T207,
1738 dfa31_T222, dfa31_T240, dfa31_T216, dfa31_T231, dfa31_T128, dfa31_T253,
1739 dfa31_T255, dfa31_T114, dfa31_T258, dfa31_T2, dfa31_T261, dfa31_T_empty((void*)0),
1740 dfa31_T267, dfa31_T271, dfa31_T3, dfa31_T7, dfa31_T122, dfa31_T_empty((void*)0),
1741 dfa31_T10, dfa31_T13, dfa31_T2, dfa31_T116, dfa31_T145, dfa31_T17, dfa31_T105,
1742 dfa31_T27, dfa31_T178, dfa31_T41, dfa31_T49, dfa31_T52, dfa31_T57, dfa31_T63,
1743 dfa31_T98, dfa31_T73, dfa31_T75, dfa31_T77, dfa31_T79, dfa31_T90, dfa31_T91,
1744 dfa31_T95, dfa31_T149, dfa31_T157, dfa31_T167, dfa31_T103, dfa31_T170,
1745 dfa31_T22, dfa31_T39, dfa31_T182, dfa31_T_empty((void*)0), dfa31_T191, dfa31_T2,
1746 dfa31_T138, dfa31_T208, dfa31_T223, dfa31_T6, dfa31_T6, dfa31_T132,
1747 dfa31_T6, dfa31_T_empty((void*)0), dfa31_T218, dfa31_T232, dfa31_T129, dfa31_T254,
1748 dfa31_T256, dfa31_T115, dfa31_T2, dfa31_T_empty((void*)0), dfa31_T262, dfa31_T268,
1749 dfa31_T272, dfa31_T4, dfa31_T8, dfa31_T123, dfa31_T2, dfa31_T14, dfa31_T117,
1750 dfa31_T16, dfa31_T25, dfa31_T18, dfa31_T106, dfa31_T28, dfa31_T31, dfa31_T36,
1751 dfa31_T43, dfa31_T50, dfa31_T53, dfa31_T58, dfa31_T64, dfa31_T99, dfa31_T2,
1752 dfa31_T2, dfa31_T2, dfa31_T80, dfa31_T2, dfa31_T92, dfa31_T96, dfa31_T150,
1753 dfa31_T158, dfa31_T2, dfa31_T2, dfa31_T2, dfa31_T23, dfa31_T42, dfa31_T183,
1754 dfa31_T192, dfa31_T_empty((void*)0), dfa31_T200, dfa31_T203, dfa31_T_empty((void*)0), dfa31_T209,
1755 dfa31_T224, dfa31_T201, dfa31_T142, dfa31_T_empty((void*)0), dfa31_T140, dfa31_T6,
1756 dfa31_T219, dfa31_T233, dfa31_T238, dfa31_T247, dfa31_T2, dfa31_T2,
1757 dfa31_T2, dfa31_T_empty((void*)0), dfa31_T263, dfa31_T269, dfa31_T273, dfa31_T2,
1758 dfa31_T2, dfa31_T124, dfa31_T_empty((void*)0), dfa31_T2, dfa31_T118, dfa31_T2,
1759 dfa31_T26, dfa31_T19, dfa31_T107, dfa31_T29, dfa31_T32, dfa31_T37, dfa31_T44,
1760 dfa31_T51, dfa31_T54, dfa31_T59, dfa31_T65, dfa31_T100, dfa31_T_empty((void*)0),
1761 dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T81, dfa31_T_empty((void*)0), dfa31_T2, dfa31_T97,
1762 dfa31_T151, dfa31_T159, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0),
1763 dfa31_T24, dfa31_T176, dfa31_T186, dfa31_T184, dfa31_T193, dfa31_T2,
1764 dfa31_T204, dfa31_T210, dfa31_T225, dfa31_T217, dfa31_T143, dfa31_T104,
1765 dfa31_T220, dfa31_T234, dfa31_T239, dfa31_T248, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0),
1766 dfa31_T_empty((void*)0), dfa31_T264, dfa31_T2, dfa31_T274, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0),
1767 dfa31_T125, dfa31_T_empty((void*)0), dfa31_T119, dfa31_T_empty((void*)0), dfa31_T2, dfa31_T20,
1768 dfa31_T108, dfa31_T30, dfa31_T33, dfa31_T38, dfa31_T45, dfa31_T2, dfa31_T2,
1769 dfa31_T60, dfa31_T66, dfa31_T2, dfa31_T82, dfa31_T_empty((void*)0), dfa31_T2,
1770 dfa31_T152, dfa31_T160, dfa31_T15, dfa31_T177, dfa31_T187, dfa31_T185,
1771 dfa31_T194, dfa31_T_empty((void*)0), dfa31_T205, dfa31_T211, dfa31_T226, dfa31_T154,
1772 dfa31_T146, dfa31_T104, dfa31_T_empty((void*)0), dfa31_T221, dfa31_T235, dfa31_T2,
1773 dfa31_T249, dfa31_T265, dfa31_T_empty((void*)0), dfa31_T2, dfa31_T126, dfa31_T120,
1774 dfa31_T_empty((void*)0), dfa31_T21, dfa31_T109, dfa31_T2, dfa31_T34, dfa31_T2,
1775 dfa31_T46, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T61, dfa31_T67, dfa31_T_empty((void*)0),
1776 dfa31_T83, dfa31_T_empty((void*)0), dfa31_T153, dfa31_T162, dfa31_T175, dfa31_T_empty((void*)0),
1777 dfa31_T2, dfa31_T188, dfa31_T2, dfa31_T195, dfa31_T2, dfa31_T212, dfa31_T227,
1778 dfa31_T155, dfa31_T104, dfa31_T_empty((void*)0), dfa31_T2, dfa31_T236, dfa31_T_empty((void*)0),
1779 dfa31_T2, dfa31_T2, dfa31_T_empty((void*)0), dfa31_T2, dfa31_T2, dfa31_T2, dfa31_T110,
1780 dfa31_T_empty((void*)0), dfa31_T35, dfa31_T_empty((void*)0), dfa31_T47, dfa31_T62, dfa31_T68,
1781 dfa31_T84, dfa31_T2, dfa31_T163, dfa31_T2, dfa31_T_empty((void*)0), dfa31_T189,
1782 dfa31_T_empty((void*)0), dfa31_T196, dfa31_T_empty((void*)0), dfa31_T213, dfa31_T228, dfa31_T104,
1783 dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T237, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0),
1784 dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T111, dfa31_T2, dfa31_T2,
1785 dfa31_T2, dfa31_T69, dfa31_T85, dfa31_T_empty((void*)0), dfa31_T2, dfa31_T_empty((void*)0),
1786 dfa31_T243, dfa31_T2, dfa31_T2, dfa31_T214, dfa31_T229, dfa31_T_empty((void*)0),
1787 dfa31_T2, dfa31_T112, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T70,
1788 dfa31_T87, dfa31_T_empty((void*)0), dfa31_T244, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0),
1789 dfa31_T2, dfa31_T230, dfa31_T_empty((void*)0), dfa31_T113, dfa31_T2, dfa31_T88,
1790 dfa31_T245, dfa31_T_empty((void*)0), dfa31_T2, dfa31_T2, dfa31_T_empty((void*)0), dfa31_T89,
1791 dfa31_T2, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0), dfa31_T2, dfa31_T_empty((void*)0), dfa31_T_empty((void*)0)
1792};
1793
1794
1795/* Declare tracking structure for Cyclic DFA 31
1796 */
1797static
1798ANTLR3_CYCLIC_DFA cdfa31
1799 = {
1800 31, /* Decision number of this dfa */
1801 /* Which decision this represents: */
1802 (const pANTLR3_UCHAR)"1:1: Tokens : ( T_ALGORITHM | T_AND | T_ANNOTATION | BLOCK | CLASS | CONNECT | CONNECTOR | CONSTANT | DISCRETE | DER | DEFINEUNIT | EACH | ELSE | ELSEIF | ELSEWHEN | ENUMERATION | EQUATION | ENCAPSULATED | EXPANDABLE | EXTENDS | CONSTRAINEDBY | EXTERNAL | T_FALSE | FINAL | FLOW | FOR | FUNCTION | IF | IMPORT | T_IN | INITIAL | INNER | T_INPUT | LOOP | MODEL | T_NOT | T_OUTER | OPERATOR | OVERLOAD | T_OR | T_OUTPUT | T_PACKAGE | PARAMETER | PARTIAL | PROTECTED | PUBLIC | RECORD | REDECLARE | REPLACEABLE | THEN | T_TRUE | TYPE | UNSIGNED_REAL | WHEN | WHILE | WITHIN | RETURN | BREAK | DOT | LPAR | RPAR | LBRACK | RBRACK | LBRACE | RBRACE | EQUALS | ASSIGN | COMMA | COLON | SEMICOLON | OPTIMIZATION | CONSTRAINT | FIELD | NONFIELD | INDOMAIN | BOM | WS | LINE_COMMENT | ML_COMMENT | CODE | CODE_NAME | CODE_EXP | CODE_ANNOTATION | CODE_VAR | STRING | END_IF | END_FOR | END_WHEN | END_WHILE | END_IDENT | T_END | IDENT | UNSIGNED_INTEGER );",
1803 (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition, /* Default special state transition function */
1804 antlr3dfaspecialTransition, /* DFA specialTransition is currently just a default function in the runtime */
1805 antlr3dfapredict, /* DFA simulator function is in the runtime */
1806 dfa31_eot, /* EOT table */
1807 dfa31_eof, /* EOF table */
1808 dfa31_min, /* Minimum tokens for each state */
1809 dfa31_max, /* Maximum tokens for each state */
1810 dfa31_accept, /* Accept table */
1811 dfa31_special, /* Special transition states */
1812 dfa31_transitions /* Table of transition tables */
1813
1814 };
1815/* End of Cyclic DFA 31
1816 * ---------------------
1817 */
1818/* =========================================================================
1819 * End of DFA tables for the lexer
1820 */
1821
1822/* =========================================================================
1823 * Functions to match the lexer grammar defined tokens from the input stream
1824 */
1825
1826// Comes from: 199:13: ( 'algorithm' )
1827/** \brief Lexer rule generated by ANTLR3
1828 *
1829 * $ANTLR start T_ALGORITHM
1830 *
1831 * Looks to match the characters the constitute the token T_ALGORITHM
1832 * from the attached input stream.
1833 *
1834 *
1835 * \remark
1836 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1837 */
1838static ANTLR3_INLINE__inline__
1839void mT_ALGORITHM(pParModelica_Lexer_BaseModelica_Lexer ctx)
1840{
1841 ANTLR3_UINT32 _type;
1842
1843 _type = T_ALGORITHM4;
1844
1845
1846 // BaseModelica_Lexer.g:199:13: ( 'algorithm' )
1847 // BaseModelica_Lexer.g:199:15: 'algorithm'
1848 {
1849 MATCHS(lit_1)ctx->pLexer->matchs(ctx->pLexer, lit_1);
1850 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1851 {
1852 goto ruleT_ALGORITHMEx;
1853 }
1854
1855
1856
1857 }
1858
1859 LEXSTATEctx->pLexer->rec->state->type = _type;
1860
1861 // This is where rules clean up and exit
1862 //
1863 goto ruleT_ALGORITHMEx; /* Prevent compiler warnings */
1864 ruleT_ALGORITHMEx: ;
1865
1866}
1867// $ANTLR end T_ALGORITHM
1868
1869// Comes from: 200:7: ( 'and' | '&&' )
1870/** \brief Lexer rule generated by ANTLR3
1871 *
1872 * $ANTLR start T_AND
1873 *
1874 * Looks to match the characters the constitute the token T_AND
1875 * from the attached input stream.
1876 *
1877 *
1878 * \remark
1879 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1880 */
1881static ANTLR3_INLINE__inline__
1882void mT_AND(pParModelica_Lexer_BaseModelica_Lexer ctx)
1883{
1884 ANTLR3_UINT32 _type;
1885
1886 _type = T_AND5;
1887
1888
1889 {
1890 // BaseModelica_Lexer.g:200:7: ( 'and' | '&&' )
1891
1892 ANTLR3_UINT32 alt1;
1893
1894 alt1=2;
1895
1896 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
1897 {
1898 case 'a':
1899 {
1900 alt1=1;
1901 }
1902 break;
1903 case '&':
1904 {
1905 alt1=2;
1906 }
1907 break;
1908
1909 default:
1910 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
1911 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
1912 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
1913 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 1;
1914 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
1915
1916
1917 goto ruleT_ANDEx;
1918 }
1919
1920 switch (alt1)
1921 {
1922 case 1:
1923 // BaseModelica_Lexer.g:200:9: 'and'
1924 {
1925 MATCHS(lit_2)ctx->pLexer->matchs(ctx->pLexer, lit_2);
1926 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1927 {
1928 goto ruleT_ANDEx;
1929 }
1930
1931
1932
1933 }
1934 break;
1935 case 2:
1936 // BaseModelica_Lexer.g:200:17: '&&'
1937 {
1938 MATCHS(lit_3)ctx->pLexer->matchs(ctx->pLexer, lit_3);
1939 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1940 {
1941 goto ruleT_ANDEx;
1942 }
1943
1944
1945 {
1946
1947 ModelicaParser_lexerError((parser_members*)pthread_getspecific(modelicaParserKey))->
lexerError
= ANTLR3_TRUE1;
1948 c_add_source_message(NULL((void*)0),2, ErrorType_syntax, ErrorLevel_error, "Please use 'and' for logical and since '&&' is not a valid Modelica construct.",
1949 NULL((void*)0), 0, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+1, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+3,
1950 ModelicaParser_readonly((parser_members*)pthread_getspecific(modelicaParserKey))->
readonly
, ModelicaParser_filename_C_testsuiteFriendly((parser_members*)pthread_getspecific(modelicaParserKey))->
filename_C_testsuiteFriendly
);
1951
1952 }
1953
1954 }
1955 break;
1956
1957 }
1958 }
1959 LEXSTATEctx->pLexer->rec->state->type = _type;
1960
1961 // This is where rules clean up and exit
1962 //
1963 goto ruleT_ANDEx; /* Prevent compiler warnings */
1964 ruleT_ANDEx: ;
1965
1966}
1967// $ANTLR end T_AND
1968
1969// Comes from: 206:14: ( 'annotation' )
1970/** \brief Lexer rule generated by ANTLR3
1971 *
1972 * $ANTLR start T_ANNOTATION
1973 *
1974 * Looks to match the characters the constitute the token T_ANNOTATION
1975 * from the attached input stream.
1976 *
1977 *
1978 * \remark
1979 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
1980 */
1981static ANTLR3_INLINE__inline__
1982void mT_ANNOTATION(pParModelica_Lexer_BaseModelica_Lexer ctx)
1983{
1984 ANTLR3_UINT32 _type;
1985
1986 _type = T_ANNOTATION6;
1987
1988
1989 // BaseModelica_Lexer.g:206:14: ( 'annotation' )
1990 // BaseModelica_Lexer.g:206:16: 'annotation'
1991 {
1992 MATCHS(lit_4)ctx->pLexer->matchs(ctx->pLexer, lit_4);
1993 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
1994 {
1995 goto ruleT_ANNOTATIONEx;
1996 }
1997
1998
1999
2000 }
2001
2002 LEXSTATEctx->pLexer->rec->state->type = _type;
2003
2004 // This is where rules clean up and exit
2005 //
2006 goto ruleT_ANNOTATIONEx; /* Prevent compiler warnings */
2007 ruleT_ANNOTATIONEx: ;
2008
2009}
2010// $ANTLR end T_ANNOTATION
2011
2012// Comes from: 207:7: ( 'block' )
2013/** \brief Lexer rule generated by ANTLR3
2014 *
2015 * $ANTLR start BLOCK
2016 *
2017 * Looks to match the characters the constitute the token BLOCK
2018 * from the attached input stream.
2019 *
2020 *
2021 * \remark
2022 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2023 */
2024static ANTLR3_INLINE__inline__
2025void mBLOCK(pParModelica_Lexer_BaseModelica_Lexer ctx)
2026{
2027 ANTLR3_UINT32 _type;
2028
2029 _type = BLOCK7;
2030
2031
2032 // BaseModelica_Lexer.g:207:7: ( 'block' )
2033 // BaseModelica_Lexer.g:207:9: 'block'
2034 {
2035 MATCHS(lit_5)ctx->pLexer->matchs(ctx->pLexer, lit_5);
2036 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2037 {
2038 goto ruleBLOCKEx;
2039 }
2040
2041
2042
2043 }
2044
2045 LEXSTATEctx->pLexer->rec->state->type = _type;
2046
2047 // This is where rules clean up and exit
2048 //
2049 goto ruleBLOCKEx; /* Prevent compiler warnings */
2050 ruleBLOCKEx: ;
2051
2052}
2053// $ANTLR end BLOCK
2054
2055// Comes from: 208:7: ( 'class' )
2056/** \brief Lexer rule generated by ANTLR3
2057 *
2058 * $ANTLR start CLASS
2059 *
2060 * Looks to match the characters the constitute the token CLASS
2061 * from the attached input stream.
2062 *
2063 *
2064 * \remark
2065 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2066 */
2067static ANTLR3_INLINE__inline__
2068void mCLASS(pParModelica_Lexer_BaseModelica_Lexer ctx)
2069{
2070 ANTLR3_UINT32 _type;
2071
2072 _type = CLASS13;
2073
2074
2075 // BaseModelica_Lexer.g:208:7: ( 'class' )
2076 // BaseModelica_Lexer.g:208:9: 'class'
2077 {
2078 MATCHS(lit_6)ctx->pLexer->matchs(ctx->pLexer, lit_6);
2079 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2080 {
2081 goto ruleCLASSEx;
2082 }
2083
2084
2085
2086 }
2087
2088 LEXSTATEctx->pLexer->rec->state->type = _type;
2089
2090 // This is where rules clean up and exit
2091 //
2092 goto ruleCLASSEx; /* Prevent compiler warnings */
2093 ruleCLASSEx: ;
2094
2095}
2096// $ANTLR end CLASS
2097
2098// Comes from: 209:9: ( 'connect' )
2099/** \brief Lexer rule generated by ANTLR3
2100 *
2101 * $ANTLR start CONNECT
2102 *
2103 * Looks to match the characters the constitute the token CONNECT
2104 * from the attached input stream.
2105 *
2106 *
2107 * \remark
2108 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2109 */
2110static ANTLR3_INLINE__inline__
2111void mCONNECT(pParModelica_Lexer_BaseModelica_Lexer ctx)
2112{
2113 ANTLR3_UINT32 _type;
2114
2115 _type = CONNECT14;
2116
2117
2118 // BaseModelica_Lexer.g:209:9: ( 'connect' )
2119 // BaseModelica_Lexer.g:209:11: 'connect'
2120 {
2121 MATCHS(lit_7)ctx->pLexer->matchs(ctx->pLexer, lit_7);
2122 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2123 {
2124 goto ruleCONNECTEx;
2125 }
2126
2127
2128
2129 }
2130
2131 LEXSTATEctx->pLexer->rec->state->type = _type;
2132
2133 // This is where rules clean up and exit
2134 //
2135 goto ruleCONNECTEx; /* Prevent compiler warnings */
2136 ruleCONNECTEx: ;
2137
2138}
2139// $ANTLR end CONNECT
2140
2141// Comes from: 210:11: ( 'connector' )
2142/** \brief Lexer rule generated by ANTLR3
2143 *
2144 * $ANTLR start CONNECTOR
2145 *
2146 * Looks to match the characters the constitute the token CONNECTOR
2147 * from the attached input stream.
2148 *
2149 *
2150 * \remark
2151 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2152 */
2153static ANTLR3_INLINE__inline__
2154void mCONNECTOR(pParModelica_Lexer_BaseModelica_Lexer ctx)
2155{
2156 ANTLR3_UINT32 _type;
2157
2158 _type = CONNECTOR15;
2159
2160
2161 // BaseModelica_Lexer.g:210:11: ( 'connector' )
2162 // BaseModelica_Lexer.g:210:13: 'connector'
2163 {
2164 MATCHS(lit_8)ctx->pLexer->matchs(ctx->pLexer, lit_8);
2165 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2166 {
2167 goto ruleCONNECTOREx;
2168 }
2169
2170
2171
2172 }
2173
2174 LEXSTATEctx->pLexer->rec->state->type = _type;
2175
2176 // This is where rules clean up and exit
2177 //
2178 goto ruleCONNECTOREx; /* Prevent compiler warnings */
2179 ruleCONNECTOREx: ;
2180
2181}
2182// $ANTLR end CONNECTOR
2183
2184// Comes from: 211:10: ( 'constant' )
2185/** \brief Lexer rule generated by ANTLR3
2186 *
2187 * $ANTLR start CONSTANT
2188 *
2189 * Looks to match the characters the constitute the token CONSTANT
2190 * from the attached input stream.
2191 *
2192 *
2193 * \remark
2194 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2195 */
2196static ANTLR3_INLINE__inline__
2197void mCONSTANT(pParModelica_Lexer_BaseModelica_Lexer ctx)
2198{
2199 ANTLR3_UINT32 _type;
2200
2201 _type = CONSTANT16;
2202
2203
2204 // BaseModelica_Lexer.g:211:10: ( 'constant' )
2205 // BaseModelica_Lexer.g:211:12: 'constant'
2206 {
2207 MATCHS(lit_9)ctx->pLexer->matchs(ctx->pLexer, lit_9);
2208 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2209 {
2210 goto ruleCONSTANTEx;
2211 }
2212
2213
2214
2215 }
2216
2217 LEXSTATEctx->pLexer->rec->state->type = _type;
2218
2219 // This is where rules clean up and exit
2220 //
2221 goto ruleCONSTANTEx; /* Prevent compiler warnings */
2222 ruleCONSTANTEx: ;
2223
2224}
2225// $ANTLR end CONSTANT
2226
2227// Comes from: 212:10: ( 'discrete' )
2228/** \brief Lexer rule generated by ANTLR3
2229 *
2230 * $ANTLR start DISCRETE
2231 *
2232 * Looks to match the characters the constitute the token DISCRETE
2233 * from the attached input stream.
2234 *
2235 *
2236 * \remark
2237 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2238 */
2239static ANTLR3_INLINE__inline__
2240void mDISCRETE(pParModelica_Lexer_BaseModelica_Lexer ctx)
2241{
2242 ANTLR3_UINT32 _type;
2243
2244 _type = DISCRETE18;
2245
2246
2247 // BaseModelica_Lexer.g:212:10: ( 'discrete' )
2248 // BaseModelica_Lexer.g:212:12: 'discrete'
2249 {
2250 MATCHS(lit_10)ctx->pLexer->matchs(ctx->pLexer, lit_10);
2251 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2252 {
2253 goto ruleDISCRETEEx;
2254 }
2255
2256
2257
2258 }
2259
2260 LEXSTATEctx->pLexer->rec->state->type = _type;
2261
2262 // This is where rules clean up and exit
2263 //
2264 goto ruleDISCRETEEx; /* Prevent compiler warnings */
2265 ruleDISCRETEEx: ;
2266
2267}
2268// $ANTLR end DISCRETE
2269
2270// Comes from: 213:5: ( 'der' )
2271/** \brief Lexer rule generated by ANTLR3
2272 *
2273 * $ANTLR start DER
2274 *
2275 * Looks to match the characters the constitute the token DER
2276 * from the attached input stream.
2277 *
2278 *
2279 * \remark
2280 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2281 */
2282static ANTLR3_INLINE__inline__
2283void mDER(pParModelica_Lexer_BaseModelica_Lexer ctx)
2284{
2285 ANTLR3_UINT32 _type;
2286
2287 _type = DER19;
2288
2289
2290 // BaseModelica_Lexer.g:213:5: ( 'der' )
2291 // BaseModelica_Lexer.g:213:7: 'der'
2292 {
2293 MATCHS(lit_11)ctx->pLexer->matchs(ctx->pLexer, lit_11);
2294 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2295 {
2296 goto ruleDEREx;
2297 }
2298
2299
2300
2301 }
2302
2303 LEXSTATEctx->pLexer->rec->state->type = _type;
2304
2305 // This is where rules clean up and exit
2306 //
2307 goto ruleDEREx; /* Prevent compiler warnings */
2308 ruleDEREx: ;
2309
2310}
2311// $ANTLR end DER
2312
2313// Comes from: 214:12: ( 'defineunit' )
2314/** \brief Lexer rule generated by ANTLR3
2315 *
2316 * $ANTLR start DEFINEUNIT
2317 *
2318 * Looks to match the characters the constitute the token DEFINEUNIT
2319 * from the attached input stream.
2320 *
2321 *
2322 * \remark
2323 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2324 */
2325static ANTLR3_INLINE__inline__
2326void mDEFINEUNIT(pParModelica_Lexer_BaseModelica_Lexer ctx)
2327{
2328 ANTLR3_UINT32 _type;
2329
2330 _type = DEFINEUNIT20;
2331
2332
2333 // BaseModelica_Lexer.g:214:12: ( 'defineunit' )
2334 // BaseModelica_Lexer.g:214:14: 'defineunit'
2335 {
2336 MATCHS(lit_12)ctx->pLexer->matchs(ctx->pLexer, lit_12);
2337 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2338 {
2339 goto ruleDEFINEUNITEx;
2340 }
2341
2342
2343
2344 }
2345
2346 LEXSTATEctx->pLexer->rec->state->type = _type;
2347
2348 // This is where rules clean up and exit
2349 //
2350 goto ruleDEFINEUNITEx; /* Prevent compiler warnings */
2351 ruleDEFINEUNITEx: ;
2352
2353}
2354// $ANTLR end DEFINEUNIT
2355
2356// Comes from: 215:6: ( 'each' )
2357/** \brief Lexer rule generated by ANTLR3
2358 *
2359 * $ANTLR start EACH
2360 *
2361 * Looks to match the characters the constitute the token EACH
2362 * from the attached input stream.
2363 *
2364 *
2365 * \remark
2366 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2367 */
2368static ANTLR3_INLINE__inline__
2369void mEACH(pParModelica_Lexer_BaseModelica_Lexer ctx)
2370{
2371 ANTLR3_UINT32 _type;
2372
2373 _type = EACH21;
2374
2375
2376 // BaseModelica_Lexer.g:215:6: ( 'each' )
2377 // BaseModelica_Lexer.g:215:8: 'each'
2378 {
2379 MATCHS(lit_13)ctx->pLexer->matchs(ctx->pLexer, lit_13);
2380 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2381 {
2382 goto ruleEACHEx;
2383 }
2384
2385
2386
2387 }
2388
2389 LEXSTATEctx->pLexer->rec->state->type = _type;
2390
2391 // This is where rules clean up and exit
2392 //
2393 goto ruleEACHEx; /* Prevent compiler warnings */
2394 ruleEACHEx: ;
2395
2396}
2397// $ANTLR end EACH
2398
2399// Comes from: 216:6: ( 'else' )
2400/** \brief Lexer rule generated by ANTLR3
2401 *
2402 * $ANTLR start ELSE
2403 *
2404 * Looks to match the characters the constitute the token ELSE
2405 * from the attached input stream.
2406 *
2407 *
2408 * \remark
2409 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2410 */
2411static ANTLR3_INLINE__inline__
2412void mELSE(pParModelica_Lexer_BaseModelica_Lexer ctx)
2413{
2414 ANTLR3_UINT32 _type;
2415
2416 _type = ELSE22;
2417
2418
2419 // BaseModelica_Lexer.g:216:6: ( 'else' )
2420 // BaseModelica_Lexer.g:216:8: 'else'
2421 {
2422 MATCHS(lit_14)ctx->pLexer->matchs(ctx->pLexer, lit_14);
2423 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2424 {
2425 goto ruleELSEEx;
2426 }
2427
2428
2429
2430 }
2431
2432 LEXSTATEctx->pLexer->rec->state->type = _type;
2433
2434 // This is where rules clean up and exit
2435 //
2436 goto ruleELSEEx; /* Prevent compiler warnings */
2437 ruleELSEEx: ;
2438
2439}
2440// $ANTLR end ELSE
2441
2442// Comes from: 217:8: ( 'elseif' )
2443/** \brief Lexer rule generated by ANTLR3
2444 *
2445 * $ANTLR start ELSEIF
2446 *
2447 * Looks to match the characters the constitute the token ELSEIF
2448 * from the attached input stream.
2449 *
2450 *
2451 * \remark
2452 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2453 */
2454static ANTLR3_INLINE__inline__
2455void mELSEIF(pParModelica_Lexer_BaseModelica_Lexer ctx)
2456{
2457 ANTLR3_UINT32 _type;
2458
2459 _type = ELSEIF23;
2460
2461
2462 // BaseModelica_Lexer.g:217:8: ( 'elseif' )
2463 // BaseModelica_Lexer.g:217:10: 'elseif'
2464 {
2465 MATCHS(lit_15)ctx->pLexer->matchs(ctx->pLexer, lit_15);
2466 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2467 {
2468 goto ruleELSEIFEx;
2469 }
2470
2471
2472
2473 }
2474
2475 LEXSTATEctx->pLexer->rec->state->type = _type;
2476
2477 // This is where rules clean up and exit
2478 //
2479 goto ruleELSEIFEx; /* Prevent compiler warnings */
2480 ruleELSEIFEx: ;
2481
2482}
2483// $ANTLR end ELSEIF
2484
2485// Comes from: 218:10: ( 'elsewhen' )
2486/** \brief Lexer rule generated by ANTLR3
2487 *
2488 * $ANTLR start ELSEWHEN
2489 *
2490 * Looks to match the characters the constitute the token ELSEWHEN
2491 * from the attached input stream.
2492 *
2493 *
2494 * \remark
2495 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2496 */
2497static ANTLR3_INLINE__inline__
2498void mELSEWHEN(pParModelica_Lexer_BaseModelica_Lexer ctx)
2499{
2500 ANTLR3_UINT32 _type;
2501
2502 _type = ELSEWHEN24;
2503
2504
2505 // BaseModelica_Lexer.g:218:10: ( 'elsewhen' )
2506 // BaseModelica_Lexer.g:218:12: 'elsewhen'
2507 {
2508 MATCHS(lit_16)ctx->pLexer->matchs(ctx->pLexer, lit_16);
2509 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2510 {
2511 goto ruleELSEWHENEx;
2512 }
2513
2514
2515
2516 }
2517
2518 LEXSTATEctx->pLexer->rec->state->type = _type;
2519
2520 // This is where rules clean up and exit
2521 //
2522 goto ruleELSEWHENEx; /* Prevent compiler warnings */
2523 ruleELSEWHENEx: ;
2524
2525}
2526// $ANTLR end ELSEWHEN
2527
2528// Comes from: 219:13: ( 'enumeration' )
2529/** \brief Lexer rule generated by ANTLR3
2530 *
2531 * $ANTLR start ENUMERATION
2532 *
2533 * Looks to match the characters the constitute the token ENUMERATION
2534 * from the attached input stream.
2535 *
2536 *
2537 * \remark
2538 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2539 */
2540static ANTLR3_INLINE__inline__
2541void mENUMERATION(pParModelica_Lexer_BaseModelica_Lexer ctx)
2542{
2543 ANTLR3_UINT32 _type;
2544
2545 _type = ENUMERATION33;
2546
2547
2548 // BaseModelica_Lexer.g:219:13: ( 'enumeration' )
2549 // BaseModelica_Lexer.g:219:15: 'enumeration'
2550 {
2551 MATCHS(lit_17)ctx->pLexer->matchs(ctx->pLexer, lit_17);
2552 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2553 {
2554 goto ruleENUMERATIONEx;
2555 }
2556
2557
2558
2559 }
2560
2561 LEXSTATEctx->pLexer->rec->state->type = _type;
2562
2563 // This is where rules clean up and exit
2564 //
2565 goto ruleENUMERATIONEx; /* Prevent compiler warnings */
2566 ruleENUMERATIONEx: ;
2567
2568}
2569// $ANTLR end ENUMERATION
2570
2571// Comes from: 220:10: ( 'equation' )
2572/** \brief Lexer rule generated by ANTLR3
2573 *
2574 * $ANTLR start EQUATION
2575 *
2576 * Looks to match the characters the constitute the token EQUATION
2577 * from the attached input stream.
2578 *
2579 *
2580 * \remark
2581 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2582 */
2583static ANTLR3_INLINE__inline__
2584void mEQUATION(pParModelica_Lexer_BaseModelica_Lexer ctx)
2585{
2586 ANTLR3_UINT32 _type;
2587
2588 _type = EQUATION34;
2589
2590
2591 // BaseModelica_Lexer.g:220:10: ( 'equation' )
2592 // BaseModelica_Lexer.g:220:12: 'equation'
2593 {
2594 MATCHS(lit_18)ctx->pLexer->matchs(ctx->pLexer, lit_18);
2595 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2596 {
2597 goto ruleEQUATIONEx;
2598 }
2599
2600
2601
2602 }
2603
2604 LEXSTATEctx->pLexer->rec->state->type = _type;
2605
2606 // This is where rules clean up and exit
2607 //
2608 goto ruleEQUATIONEx; /* Prevent compiler warnings */
2609 ruleEQUATIONEx: ;
2610
2611}
2612// $ANTLR end EQUATION
2613
2614// Comes from: 221:14: ( 'encapsulated' )
2615/** \brief Lexer rule generated by ANTLR3
2616 *
2617 * $ANTLR start ENCAPSULATED
2618 *
2619 * Looks to match the characters the constitute the token ENCAPSULATED
2620 * from the attached input stream.
2621 *
2622 *
2623 * \remark
2624 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2625 */
2626static ANTLR3_INLINE__inline__
2627void mENCAPSULATED(pParModelica_Lexer_BaseModelica_Lexer ctx)
2628{
2629 ANTLR3_UINT32 _type;
2630
2631 _type = ENCAPSULATED35;
2632
2633
2634 // BaseModelica_Lexer.g:221:14: ( 'encapsulated' )
2635 // BaseModelica_Lexer.g:221:16: 'encapsulated'
2636 {
2637 MATCHS(lit_19)ctx->pLexer->matchs(ctx->pLexer, lit_19);
2638 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2639 {
2640 goto ruleENCAPSULATEDEx;
2641 }
2642
2643
2644
2645 }
2646
2647 LEXSTATEctx->pLexer->rec->state->type = _type;
2648
2649 // This is where rules clean up and exit
2650 //
2651 goto ruleENCAPSULATEDEx; /* Prevent compiler warnings */
2652 ruleENCAPSULATEDEx: ;
2653
2654}
2655// $ANTLR end ENCAPSULATED
2656
2657// Comes from: 222:12: ( 'expandable' )
2658/** \brief Lexer rule generated by ANTLR3
2659 *
2660 * $ANTLR start EXPANDABLE
2661 *
2662 * Looks to match the characters the constitute the token EXPANDABLE
2663 * from the attached input stream.
2664 *
2665 *
2666 * \remark
2667 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2668 */
2669static ANTLR3_INLINE__inline__
2670void mEXPANDABLE(pParModelica_Lexer_BaseModelica_Lexer ctx)
2671{
2672 ANTLR3_UINT32 _type;
2673
2674 _type = EXPANDABLE36;
2675
2676
2677 // BaseModelica_Lexer.g:222:12: ( 'expandable' )
2678 // BaseModelica_Lexer.g:222:14: 'expandable'
2679 {
2680 MATCHS(lit_20)ctx->pLexer->matchs(ctx->pLexer, lit_20);
2681 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2682 {
2683 goto ruleEXPANDABLEEx;
2684 }
2685
2686
2687
2688 }
2689
2690 LEXSTATEctx->pLexer->rec->state->type = _type;
2691
2692 // This is where rules clean up and exit
2693 //
2694 goto ruleEXPANDABLEEx; /* Prevent compiler warnings */
2695 ruleEXPANDABLEEx: ;
2696
2697}
2698// $ANTLR end EXPANDABLE
2699
2700// Comes from: 223:9: ( 'extends' )
2701/** \brief Lexer rule generated by ANTLR3
2702 *
2703 * $ANTLR start EXTENDS
2704 *
2705 * Looks to match the characters the constitute the token EXTENDS
2706 * from the attached input stream.
2707 *
2708 *
2709 * \remark
2710 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2711 */
2712static ANTLR3_INLINE__inline__
2713void mEXTENDS(pParModelica_Lexer_BaseModelica_Lexer ctx)
2714{
2715 ANTLR3_UINT32 _type;
2716
2717 _type = EXTENDS37;
2718
2719
2720 // BaseModelica_Lexer.g:223:9: ( 'extends' )
2721 // BaseModelica_Lexer.g:223:11: 'extends'
2722 {
2723 MATCHS(lit_21)ctx->pLexer->matchs(ctx->pLexer, lit_21);
2724 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2725 {
2726 goto ruleEXTENDSEx;
2727 }
2728
2729
2730
2731 }
2732
2733 LEXSTATEctx->pLexer->rec->state->type = _type;
2734
2735 // This is where rules clean up and exit
2736 //
2737 goto ruleEXTENDSEx; /* Prevent compiler warnings */
2738 ruleEXTENDSEx: ;
2739
2740}
2741// $ANTLR end EXTENDS
2742
2743// Comes from: 224:15: ( 'constrainedby' )
2744/** \brief Lexer rule generated by ANTLR3
2745 *
2746 * $ANTLR start CONSTRAINEDBY
2747 *
2748 * Looks to match the characters the constitute the token CONSTRAINEDBY
2749 * from the attached input stream.
2750 *
2751 *
2752 * \remark
2753 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2754 */
2755static ANTLR3_INLINE__inline__
2756void mCONSTRAINEDBY(pParModelica_Lexer_BaseModelica_Lexer ctx)
2757{
2758 ANTLR3_UINT32 _type;
2759
2760 _type = CONSTRAINEDBY38;
2761
2762
2763 // BaseModelica_Lexer.g:224:15: ( 'constrainedby' )
2764 // BaseModelica_Lexer.g:224:17: 'constrainedby'
2765 {
2766 MATCHS(lit_22)ctx->pLexer->matchs(ctx->pLexer, lit_22);
2767 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2768 {
2769 goto ruleCONSTRAINEDBYEx;
2770 }
2771
2772
2773
2774 }
2775
2776 LEXSTATEctx->pLexer->rec->state->type = _type;
2777
2778 // This is where rules clean up and exit
2779 //
2780 goto ruleCONSTRAINEDBYEx; /* Prevent compiler warnings */
2781 ruleCONSTRAINEDBYEx: ;
2782
2783}
2784// $ANTLR end CONSTRAINEDBY
2785
2786// Comes from: 225:10: ( 'external' )
2787/** \brief Lexer rule generated by ANTLR3
2788 *
2789 * $ANTLR start EXTERNAL
2790 *
2791 * Looks to match the characters the constitute the token EXTERNAL
2792 * from the attached input stream.
2793 *
2794 *
2795 * \remark
2796 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2797 */
2798static ANTLR3_INLINE__inline__
2799void mEXTERNAL(pParModelica_Lexer_BaseModelica_Lexer ctx)
2800{
2801 ANTLR3_UINT32 _type;
2802
2803 _type = EXTERNAL39;
2804
2805
2806 // BaseModelica_Lexer.g:225:10: ( 'external' )
2807 // BaseModelica_Lexer.g:225:12: 'external'
2808 {
2809 MATCHS(lit_23)ctx->pLexer->matchs(ctx->pLexer, lit_23);
2810 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2811 {
2812 goto ruleEXTERNALEx;
2813 }
2814
2815
2816
2817 }
2818
2819 LEXSTATEctx->pLexer->rec->state->type = _type;
2820
2821 // This is where rules clean up and exit
2822 //
2823 goto ruleEXTERNALEx; /* Prevent compiler warnings */
2824 ruleEXTERNALEx: ;
2825
2826}
2827// $ANTLR end EXTERNAL
2828
2829// Comes from: 226:9: ( 'false' )
2830/** \brief Lexer rule generated by ANTLR3
2831 *
2832 * $ANTLR start T_FALSE
2833 *
2834 * Looks to match the characters the constitute the token T_FALSE
2835 * from the attached input stream.
2836 *
2837 *
2838 * \remark
2839 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2840 */
2841static ANTLR3_INLINE__inline__
2842void mT_FALSE(pParModelica_Lexer_BaseModelica_Lexer ctx)
2843{
2844 ANTLR3_UINT32 _type;
2845
2846 _type = T_FALSE40;
2847
2848
2849 // BaseModelica_Lexer.g:226:9: ( 'false' )
2850 // BaseModelica_Lexer.g:226:11: 'false'
2851 {
2852 MATCHS(lit_24)ctx->pLexer->matchs(ctx->pLexer, lit_24);
2853 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2854 {
2855 goto ruleT_FALSEEx;
2856 }
2857
2858
2859
2860 }
2861
2862 LEXSTATEctx->pLexer->rec->state->type = _type;
2863
2864 // This is where rules clean up and exit
2865 //
2866 goto ruleT_FALSEEx; /* Prevent compiler warnings */
2867 ruleT_FALSEEx: ;
2868
2869}
2870// $ANTLR end T_FALSE
2871
2872// Comes from: 227:7: ( 'final' )
2873/** \brief Lexer rule generated by ANTLR3
2874 *
2875 * $ANTLR start FINAL
2876 *
2877 * Looks to match the characters the constitute the token FINAL
2878 * from the attached input stream.
2879 *
2880 *
2881 * \remark
2882 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2883 */
2884static ANTLR3_INLINE__inline__
2885void mFINAL(pParModelica_Lexer_BaseModelica_Lexer ctx)
2886{
2887 ANTLR3_UINT32 _type;
2888
2889 _type = FINAL41;
2890
2891
2892 // BaseModelica_Lexer.g:227:7: ( 'final' )
2893 // BaseModelica_Lexer.g:227:9: 'final'
2894 {
2895 MATCHS(lit_25)ctx->pLexer->matchs(ctx->pLexer, lit_25);
2896 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2897 {
2898 goto ruleFINALEx;
2899 }
2900
2901
2902
2903 }
2904
2905 LEXSTATEctx->pLexer->rec->state->type = _type;
2906
2907 // This is where rules clean up and exit
2908 //
2909 goto ruleFINALEx; /* Prevent compiler warnings */
2910 ruleFINALEx: ;
2911
2912}
2913// $ANTLR end FINAL
2914
2915// Comes from: 228:6: ( 'flow' )
2916/** \brief Lexer rule generated by ANTLR3
2917 *
2918 * $ANTLR start FLOW
2919 *
2920 * Looks to match the characters the constitute the token FLOW
2921 * from the attached input stream.
2922 *
2923 *
2924 * \remark
2925 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2926 */
2927static ANTLR3_INLINE__inline__
2928void mFLOW(pParModelica_Lexer_BaseModelica_Lexer ctx)
2929{
2930 ANTLR3_UINT32 _type;
2931
2932 _type = FLOW42;
2933
2934
2935 // BaseModelica_Lexer.g:228:6: ( 'flow' )
2936 // BaseModelica_Lexer.g:228:8: 'flow'
2937 {
2938 MATCHS(lit_26)ctx->pLexer->matchs(ctx->pLexer, lit_26);
2939 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2940 {
2941 goto ruleFLOWEx;
2942 }
2943
2944
2945
2946 }
2947
2948 LEXSTATEctx->pLexer->rec->state->type = _type;
2949
2950 // This is where rules clean up and exit
2951 //
2952 goto ruleFLOWEx; /* Prevent compiler warnings */
2953 ruleFLOWEx: ;
2954
2955}
2956// $ANTLR end FLOW
2957
2958// Comes from: 229:5: ( 'for' )
2959/** \brief Lexer rule generated by ANTLR3
2960 *
2961 * $ANTLR start FOR
2962 *
2963 * Looks to match the characters the constitute the token FOR
2964 * from the attached input stream.
2965 *
2966 *
2967 * \remark
2968 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
2969 */
2970static ANTLR3_INLINE__inline__
2971void mFOR(pParModelica_Lexer_BaseModelica_Lexer ctx)
2972{
2973 ANTLR3_UINT32 _type;
2974
2975 _type = FOR43;
2976
2977
2978 // BaseModelica_Lexer.g:229:5: ( 'for' )
2979 // BaseModelica_Lexer.g:229:7: 'for'
2980 {
2981 MATCHS(lit_27)ctx->pLexer->matchs(ctx->pLexer, lit_27);
2982 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
2983 {
2984 goto ruleFOREx;
2985 }
2986
2987
2988
2989 }
2990
2991 LEXSTATEctx->pLexer->rec->state->type = _type;
2992
2993 // This is where rules clean up and exit
2994 //
2995 goto ruleFOREx; /* Prevent compiler warnings */
2996 ruleFOREx: ;
2997
2998}
2999// $ANTLR end FOR
3000
3001// Comes from: 230:10: ( 'function' )
3002/** \brief Lexer rule generated by ANTLR3
3003 *
3004 * $ANTLR start FUNCTION
3005 *
3006 * Looks to match the characters the constitute the token FUNCTION
3007 * from the attached input stream.
3008 *
3009 *
3010 * \remark
3011 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3012 */
3013static ANTLR3_INLINE__inline__
3014void mFUNCTION(pParModelica_Lexer_BaseModelica_Lexer ctx)
3015{
3016 ANTLR3_UINT32 _type;
3017
3018 _type = FUNCTION44;
3019
3020
3021 // BaseModelica_Lexer.g:230:10: ( 'function' )
3022 // BaseModelica_Lexer.g:230:12: 'function'
3023 {
3024 MATCHS(lit_28)ctx->pLexer->matchs(ctx->pLexer, lit_28);
3025 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3026 {
3027 goto ruleFUNCTIONEx;
3028 }
3029
3030
3031
3032 }
3033
3034 LEXSTATEctx->pLexer->rec->state->type = _type;
3035
3036 // This is where rules clean up and exit
3037 //
3038 goto ruleFUNCTIONEx; /* Prevent compiler warnings */
3039 ruleFUNCTIONEx: ;
3040
3041}
3042// $ANTLR end FUNCTION
3043
3044// Comes from: 231:4: ( 'if' )
3045/** \brief Lexer rule generated by ANTLR3
3046 *
3047 * $ANTLR start IF
3048 *
3049 * Looks to match the characters the constitute the token IF
3050 * from the attached input stream.
3051 *
3052 *
3053 * \remark
3054 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3055 */
3056static ANTLR3_INLINE__inline__
3057void mIF(pParModelica_Lexer_BaseModelica_Lexer ctx)
3058{
3059 ANTLR3_UINT32 _type;
3060
3061 _type = IF46;
3062
3063
3064 // BaseModelica_Lexer.g:231:4: ( 'if' )
3065 // BaseModelica_Lexer.g:231:6: 'if'
3066 {
3067 MATCHS(lit_29)ctx->pLexer->matchs(ctx->pLexer, lit_29);
3068 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3069 {
3070 goto ruleIFEx;
3071 }
3072
3073
3074
3075 }
3076
3077 LEXSTATEctx->pLexer->rec->state->type = _type;
3078
3079 // This is where rules clean up and exit
3080 //
3081 goto ruleIFEx; /* Prevent compiler warnings */
3082 ruleIFEx: ;
3083
3084}
3085// $ANTLR end IF
3086
3087// Comes from: 232:8: ( 'import' )
3088/** \brief Lexer rule generated by ANTLR3
3089 *
3090 * $ANTLR start IMPORT
3091 *
3092 * Looks to match the characters the constitute the token IMPORT
3093 * from the attached input stream.
3094 *
3095 *
3096 * \remark
3097 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3098 */
3099static ANTLR3_INLINE__inline__
3100void mIMPORT(pParModelica_Lexer_BaseModelica_Lexer ctx)
3101{
3102 ANTLR3_UINT32 _type;
3103
3104 _type = IMPORT47;
3105
3106
3107 // BaseModelica_Lexer.g:232:8: ( 'import' )
3108 // BaseModelica_Lexer.g:232:10: 'import'
3109 {
3110 MATCHS(lit_30)ctx->pLexer->matchs(ctx->pLexer, lit_30);
3111 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3112 {
3113 goto ruleIMPORTEx;
3114 }
3115
3116
3117
3118 }
3119
3120 LEXSTATEctx->pLexer->rec->state->type = _type;
3121
3122 // This is where rules clean up and exit
3123 //
3124 goto ruleIMPORTEx; /* Prevent compiler warnings */
3125 ruleIMPORTEx: ;
3126
3127}
3128// $ANTLR end IMPORT
3129
3130// Comes from: 233:6: ( 'in' )
3131/** \brief Lexer rule generated by ANTLR3
3132 *
3133 * $ANTLR start T_IN
3134 *
3135 * Looks to match the characters the constitute the token T_IN
3136 * from the attached input stream.
3137 *
3138 *
3139 * \remark
3140 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3141 */
3142static ANTLR3_INLINE__inline__
3143void mT_IN(pParModelica_Lexer_BaseModelica_Lexer ctx)
3144{
3145 ANTLR3_UINT32 _type;
3146
3147 _type = T_IN48;
3148
3149
3150 // BaseModelica_Lexer.g:233:6: ( 'in' )
3151 // BaseModelica_Lexer.g:233:8: 'in'
3152 {
3153 MATCHS(lit_31)ctx->pLexer->matchs(ctx->pLexer, lit_31);
3154 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3155 {
3156 goto ruleT_INEx;
3157 }
3158
3159
3160
3161 }
3162
3163 LEXSTATEctx->pLexer->rec->state->type = _type;
3164
3165 // This is where rules clean up and exit
3166 //
3167 goto ruleT_INEx; /* Prevent compiler warnings */
3168 ruleT_INEx: ;
3169
3170}
3171// $ANTLR end T_IN
3172
3173// Comes from: 234:9: ( 'initial' )
3174/** \brief Lexer rule generated by ANTLR3
3175 *
3176 * $ANTLR start INITIAL
3177 *
3178 * Looks to match the characters the constitute the token INITIAL
3179 * from the attached input stream.
3180 *
3181 *
3182 * \remark
3183 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3184 */
3185static ANTLR3_INLINE__inline__
3186void mINITIAL(pParModelica_Lexer_BaseModelica_Lexer ctx)
3187{
3188 ANTLR3_UINT32 _type;
3189
3190 _type = INITIAL50;
3191
3192
3193 // BaseModelica_Lexer.g:234:9: ( 'initial' )
3194 // BaseModelica_Lexer.g:234:11: 'initial'
3195 {
3196 MATCHS(lit_32)ctx->pLexer->matchs(ctx->pLexer, lit_32);
3197 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3198 {
3199 goto ruleINITIALEx;
3200 }
3201
3202
3203
3204 }
3205
3206 LEXSTATEctx->pLexer->rec->state->type = _type;
3207
3208 // This is where rules clean up and exit
3209 //
3210 goto ruleINITIALEx; /* Prevent compiler warnings */
3211 ruleINITIALEx: ;
3212
3213}
3214// $ANTLR end INITIAL
3215
3216// Comes from: 235:7: ( 'inner' )
3217/** \brief Lexer rule generated by ANTLR3
3218 *
3219 * $ANTLR start INNER
3220 *
3221 * Looks to match the characters the constitute the token INNER
3222 * from the attached input stream.
3223 *
3224 *
3225 * \remark
3226 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3227 */
3228static ANTLR3_INLINE__inline__
3229void mINNER(pParModelica_Lexer_BaseModelica_Lexer ctx)
3230{
3231 ANTLR3_UINT32 _type;
3232
3233 _type = INNER51;
3234
3235
3236 // BaseModelica_Lexer.g:235:7: ( 'inner' )
3237 // BaseModelica_Lexer.g:235:9: 'inner'
3238 {
3239 MATCHS(lit_33)ctx->pLexer->matchs(ctx->pLexer, lit_33);
3240 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3241 {
3242 goto ruleINNEREx;
3243 }
3244
3245
3246
3247 }
3248
3249 LEXSTATEctx->pLexer->rec->state->type = _type;
3250
3251 // This is where rules clean up and exit
3252 //
3253 goto ruleINNEREx; /* Prevent compiler warnings */
3254 ruleINNEREx: ;
3255
3256}
3257// $ANTLR end INNER
3258
3259// Comes from: 236:9: ( 'input' )
3260/** \brief Lexer rule generated by ANTLR3
3261 *
3262 * $ANTLR start T_INPUT
3263 *
3264 * Looks to match the characters the constitute the token T_INPUT
3265 * from the attached input stream.
3266 *
3267 *
3268 * \remark
3269 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3270 */
3271static ANTLR3_INLINE__inline__
3272void mT_INPUT(pParModelica_Lexer_BaseModelica_Lexer ctx)
3273{
3274 ANTLR3_UINT32 _type;
3275
3276 _type = T_INPUT52;
3277
3278
3279 // BaseModelica_Lexer.g:236:9: ( 'input' )
3280 // BaseModelica_Lexer.g:236:11: 'input'
3281 {
3282 MATCHS(lit_34)ctx->pLexer->matchs(ctx->pLexer, lit_34);
3283 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3284 {
3285 goto ruleT_INPUTEx;
3286 }
3287
3288
3289
3290 }
3291
3292 LEXSTATEctx->pLexer->rec->state->type = _type;
3293
3294 // This is where rules clean up and exit
3295 //
3296 goto ruleT_INPUTEx; /* Prevent compiler warnings */
3297 ruleT_INPUTEx: ;
3298
3299}
3300// $ANTLR end T_INPUT
3301
3302// Comes from: 237:6: ( 'loop' )
3303/** \brief Lexer rule generated by ANTLR3
3304 *
3305 * $ANTLR start LOOP
3306 *
3307 * Looks to match the characters the constitute the token LOOP
3308 * from the attached input stream.
3309 *
3310 *
3311 * \remark
3312 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3313 */
3314static ANTLR3_INLINE__inline__
3315void mLOOP(pParModelica_Lexer_BaseModelica_Lexer ctx)
3316{
3317 ANTLR3_UINT32 _type;
3318
3319 _type = LOOP53;
3320
3321
3322 // BaseModelica_Lexer.g:237:6: ( 'loop' )
3323 // BaseModelica_Lexer.g:237:8: 'loop'
3324 {
3325 MATCHS(lit_35)ctx->pLexer->matchs(ctx->pLexer, lit_35);
3326 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3327 {
3328 goto ruleLOOPEx;
3329 }
3330
3331
3332
3333 }
3334
3335 LEXSTATEctx->pLexer->rec->state->type = _type;
3336
3337 // This is where rules clean up and exit
3338 //
3339 goto ruleLOOPEx; /* Prevent compiler warnings */
3340 ruleLOOPEx: ;
3341
3342}
3343// $ANTLR end LOOP
3344
3345// Comes from: 238:7: ( 'model' )
3346/** \brief Lexer rule generated by ANTLR3
3347 *
3348 * $ANTLR start MODEL
3349 *
3350 * Looks to match the characters the constitute the token MODEL
3351 * from the attached input stream.
3352 *
3353 *
3354 * \remark
3355 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3356 */
3357static ANTLR3_INLINE__inline__
3358void mMODEL(pParModelica_Lexer_BaseModelica_Lexer ctx)
3359{
3360 ANTLR3_UINT32 _type;
3361
3362 _type = MODEL54;
3363
3364
3365 // BaseModelica_Lexer.g:238:7: ( 'model' )
3366 // BaseModelica_Lexer.g:238:9: 'model'
3367 {
3368 MATCHS(lit_36)ctx->pLexer->matchs(ctx->pLexer, lit_36);
3369 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3370 {
3371 goto ruleMODELEx;
3372 }
3373
3374
3375
3376 }
3377
3378 LEXSTATEctx->pLexer->rec->state->type = _type;
3379
3380 // This is where rules clean up and exit
3381 //
3382 goto ruleMODELEx; /* Prevent compiler warnings */
3383 ruleMODELEx: ;
3384
3385}
3386// $ANTLR end MODEL
3387
3388// Comes from: 239:7: ( 'not' | '!' )
3389/** \brief Lexer rule generated by ANTLR3
3390 *
3391 * $ANTLR start T_NOT
3392 *
3393 * Looks to match the characters the constitute the token T_NOT
3394 * from the attached input stream.
3395 *
3396 *
3397 * \remark
3398 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3399 */
3400static ANTLR3_INLINE__inline__
3401void mT_NOT(pParModelica_Lexer_BaseModelica_Lexer ctx)
3402{
3403 ANTLR3_UINT32 _type;
3404
3405 _type = T_NOT55;
3406
3407
3408 {
3409 // BaseModelica_Lexer.g:239:7: ( 'not' | '!' )
3410
3411 ANTLR3_UINT32 alt2;
3412
3413 alt2=2;
3414
3415 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
3416 {
3417 case 'n':
3418 {
3419 alt2=1;
3420 }
3421 break;
3422 case '!':
3423 {
3424 alt2=2;
3425 }
3426 break;
3427
3428 default:
3429 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
3430 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
3431 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
3432 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 2;
3433 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
3434
3435
3436 goto ruleT_NOTEx;
3437 }
3438
3439 switch (alt2)
3440 {
3441 case 1:
3442 // BaseModelica_Lexer.g:239:9: 'not'
3443 {
3444 MATCHS(lit_37)ctx->pLexer->matchs(ctx->pLexer, lit_37);
3445 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3446 {
3447 goto ruleT_NOTEx;
3448 }
3449
3450
3451
3452 }
3453 break;
3454 case 2:
3455 // BaseModelica_Lexer.g:239:17: '!'
3456 {
3457 MATCHC('!')ctx->pLexer->matchc(ctx->pLexer, '!');
3458 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3459 {
3460 goto ruleT_NOTEx;
3461 }
3462
3463 {
3464
3465 ModelicaParser_lexerError((parser_members*)pthread_getspecific(modelicaParserKey))->
lexerError
= ANTLR3_TRUE1;
3466 c_add_source_message(NULL((void*)0),2, ErrorType_syntax, ErrorLevel_error, "Please use 'not' for logical not since '!' is not a valid Modelica construct.",
3467 NULL((void*)0), 0, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+1, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+2,
3468 ModelicaParser_readonly((parser_members*)pthread_getspecific(modelicaParserKey))->
readonly
, ModelicaParser_filename_C_testsuiteFriendly((parser_members*)pthread_getspecific(modelicaParserKey))->
filename_C_testsuiteFriendly
);
3469
3470 }
3471
3472 }
3473 break;
3474
3475 }
3476 }
3477 LEXSTATEctx->pLexer->rec->state->type = _type;
3478
3479 // This is where rules clean up and exit
3480 //
3481 goto ruleT_NOTEx; /* Prevent compiler warnings */
3482 ruleT_NOTEx: ;
3483
3484}
3485// $ANTLR end T_NOT
3486
3487// Comes from: 245:9: ( 'outer' )
3488/** \brief Lexer rule generated by ANTLR3
3489 *
3490 * $ANTLR start T_OUTER
3491 *
3492 * Looks to match the characters the constitute the token T_OUTER
3493 * from the attached input stream.
3494 *
3495 *
3496 * \remark
3497 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3498 */
3499static ANTLR3_INLINE__inline__
3500void mT_OUTER(pParModelica_Lexer_BaseModelica_Lexer ctx)
3501{
3502 ANTLR3_UINT32 _type;
3503
3504 _type = T_OUTER56;
3505
3506
3507 // BaseModelica_Lexer.g:245:9: ( 'outer' )
3508 // BaseModelica_Lexer.g:245:11: 'outer'
3509 {
3510 MATCHS(lit_38)ctx->pLexer->matchs(ctx->pLexer, lit_38);
3511 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3512 {
3513 goto ruleT_OUTEREx;
3514 }
3515
3516
3517
3518 }
3519
3520 LEXSTATEctx->pLexer->rec->state->type = _type;
3521
3522 // This is where rules clean up and exit
3523 //
3524 goto ruleT_OUTEREx; /* Prevent compiler warnings */
3525 ruleT_OUTEREx: ;
3526
3527}
3528// $ANTLR end T_OUTER
3529
3530// Comes from: 246:10: ( 'operator' )
3531/** \brief Lexer rule generated by ANTLR3
3532 *
3533 * $ANTLR start OPERATOR
3534 *
3535 * Looks to match the characters the constitute the token OPERATOR
3536 * from the attached input stream.
3537 *
3538 *
3539 * \remark
3540 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3541 */
3542static ANTLR3_INLINE__inline__
3543void mOPERATOR(pParModelica_Lexer_BaseModelica_Lexer ctx)
3544{
3545 ANTLR3_UINT32 _type;
3546
3547 _type = OPERATOR57;
3548
3549
3550 // BaseModelica_Lexer.g:246:10: ( 'operator' )
3551 // BaseModelica_Lexer.g:246:12: 'operator'
3552 {
3553 MATCHS(lit_39)ctx->pLexer->matchs(ctx->pLexer, lit_39);
3554 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3555 {
3556 goto ruleOPERATOREx;
3557 }
3558
3559
3560
3561 }
3562
3563 LEXSTATEctx->pLexer->rec->state->type = _type;
3564
3565 // This is where rules clean up and exit
3566 //
3567 goto ruleOPERATOREx; /* Prevent compiler warnings */
3568 ruleOPERATOREx: ;
3569
3570}
3571// $ANTLR end OPERATOR
3572
3573// Comes from: 247:10: ( '$overload' )
3574/** \brief Lexer rule generated by ANTLR3
3575 *
3576 * $ANTLR start OVERLOAD
3577 *
3578 * Looks to match the characters the constitute the token OVERLOAD
3579 * from the attached input stream.
3580 *
3581 *
3582 * \remark
3583 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3584 */
3585static ANTLR3_INLINE__inline__
3586void mOVERLOAD(pParModelica_Lexer_BaseModelica_Lexer ctx)
3587{
3588 ANTLR3_UINT32 _type;
3589
3590 _type = OVERLOAD58;
3591
3592
3593 // BaseModelica_Lexer.g:247:10: ( '$overload' )
3594 // BaseModelica_Lexer.g:247:12: '$overload'
3595 {
3596 MATCHS(lit_40)ctx->pLexer->matchs(ctx->pLexer, lit_40);
3597 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3598 {
3599 goto ruleOVERLOADEx;
3600 }
3601
3602
3603
3604 }
3605
3606 LEXSTATEctx->pLexer->rec->state->type = _type;
3607
3608 // This is where rules clean up and exit
3609 //
3610 goto ruleOVERLOADEx; /* Prevent compiler warnings */
3611 ruleOVERLOADEx: ;
3612
3613}
3614// $ANTLR end OVERLOAD
3615
3616// Comes from: 248:6: ( 'or' | '||' )
3617/** \brief Lexer rule generated by ANTLR3
3618 *
3619 * $ANTLR start T_OR
3620 *
3621 * Looks to match the characters the constitute the token T_OR
3622 * from the attached input stream.
3623 *
3624 *
3625 * \remark
3626 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3627 */
3628static ANTLR3_INLINE__inline__
3629void mT_OR(pParModelica_Lexer_BaseModelica_Lexer ctx)
3630{
3631 ANTLR3_UINT32 _type;
3632
3633 _type = T_OR60;
3634
3635
3636 {
3637 // BaseModelica_Lexer.g:248:6: ( 'or' | '||' )
3638
3639 ANTLR3_UINT32 alt3;
3640
3641 alt3=2;
3642
3643 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
3644 {
3645 case 'o':
3646 {
3647 alt3=1;
3648 }
3649 break;
3650 case '|':
3651 {
3652 alt3=2;
3653 }
3654 break;
3655
3656 default:
3657 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
3658 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
3659 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
3660 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 3;
3661 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
3662
3663
3664 goto ruleT_OREx;
3665 }
3666
3667 switch (alt3)
3668 {
3669 case 1:
3670 // BaseModelica_Lexer.g:248:8: 'or'
3671 {
3672 MATCHS(lit_41)ctx->pLexer->matchs(ctx->pLexer, lit_41);
3673 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3674 {
3675 goto ruleT_OREx;
3676 }
3677
3678
3679
3680 }
3681 break;
3682 case 2:
3683 // BaseModelica_Lexer.g:248:15: '||'
3684 {
3685 MATCHS(lit_42)ctx->pLexer->matchs(ctx->pLexer, lit_42);
3686 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3687 {
3688 goto ruleT_OREx;
3689 }
3690
3691
3692 {
3693
3694 ModelicaParser_lexerError((parser_members*)pthread_getspecific(modelicaParserKey))->
lexerError
= ANTLR3_TRUE1;
3695 c_add_source_message(NULL((void*)0),2, ErrorType_syntax, ErrorLevel_error, "Please use 'or' for logical or since '||' is not a valid Modelica construct.",
3696 NULL((void*)0), 0, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+1, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+3,
3697 ModelicaParser_readonly((parser_members*)pthread_getspecific(modelicaParserKey))->
readonly
, ModelicaParser_filename_C_testsuiteFriendly((parser_members*)pthread_getspecific(modelicaParserKey))->
filename_C_testsuiteFriendly
);
3698
3699 }
3700
3701 }
3702 break;
3703
3704 }
3705 }
3706 LEXSTATEctx->pLexer->rec->state->type = _type;
3707
3708 // This is where rules clean up and exit
3709 //
3710 goto ruleT_OREx; /* Prevent compiler warnings */
3711 ruleT_OREx: ;
3712
3713}
3714// $ANTLR end T_OR
3715
3716// Comes from: 254:10: ( 'output' )
3717/** \brief Lexer rule generated by ANTLR3
3718 *
3719 * $ANTLR start T_OUTPUT
3720 *
3721 * Looks to match the characters the constitute the token T_OUTPUT
3722 * from the attached input stream.
3723 *
3724 *
3725 * \remark
3726 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3727 */
3728static ANTLR3_INLINE__inline__
3729void mT_OUTPUT(pParModelica_Lexer_BaseModelica_Lexer ctx)
3730{
3731 ANTLR3_UINT32 _type;
3732
3733 _type = T_OUTPUT61;
3734
3735
3736 // BaseModelica_Lexer.g:254:10: ( 'output' )
3737 // BaseModelica_Lexer.g:254:12: 'output'
3738 {
3739 MATCHS(lit_43)ctx->pLexer->matchs(ctx->pLexer, lit_43);
3740 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3741 {
3742 goto ruleT_OUTPUTEx;
3743 }
3744
3745
3746
3747 }
3748
3749 LEXSTATEctx->pLexer->rec->state->type = _type;
3750
3751 // This is where rules clean up and exit
3752 //
3753 goto ruleT_OUTPUTEx; /* Prevent compiler warnings */
3754 ruleT_OUTPUTEx: ;
3755
3756}
3757// $ANTLR end T_OUTPUT
3758
3759// Comes from: 255:11: ( 'package' )
3760/** \brief Lexer rule generated by ANTLR3
3761 *
3762 * $ANTLR start T_PACKAGE
3763 *
3764 * Looks to match the characters the constitute the token T_PACKAGE
3765 * from the attached input stream.
3766 *
3767 *
3768 * \remark
3769 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3770 */
3771static ANTLR3_INLINE__inline__
3772void mT_PACKAGE(pParModelica_Lexer_BaseModelica_Lexer ctx)
3773{
3774 ANTLR3_UINT32 _type;
3775
3776 _type = T_PACKAGE62;
3777
3778
3779 // BaseModelica_Lexer.g:255:11: ( 'package' )
3780 // BaseModelica_Lexer.g:255:13: 'package'
3781 {
3782 MATCHS(lit_44)ctx->pLexer->matchs(ctx->pLexer, lit_44);
3783 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3784 {
3785 goto ruleT_PACKAGEEx;
3786 }
3787
3788
3789
3790 }
3791
3792 LEXSTATEctx->pLexer->rec->state->type = _type;
3793
3794 // This is where rules clean up and exit
3795 //
3796 goto ruleT_PACKAGEEx; /* Prevent compiler warnings */
3797 ruleT_PACKAGEEx: ;
3798
3799}
3800// $ANTLR end T_PACKAGE
3801
3802// Comes from: 256:11: ( 'parameter' )
3803/** \brief Lexer rule generated by ANTLR3
3804 *
3805 * $ANTLR start PARAMETER
3806 *
3807 * Looks to match the characters the constitute the token PARAMETER
3808 * from the attached input stream.
3809 *
3810 *
3811 * \remark
3812 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3813 */
3814static ANTLR3_INLINE__inline__
3815void mPARAMETER(pParModelica_Lexer_BaseModelica_Lexer ctx)
3816{
3817 ANTLR3_UINT32 _type;
3818
3819 _type = PARAMETER63;
3820
3821
3822 // BaseModelica_Lexer.g:256:11: ( 'parameter' )
3823 // BaseModelica_Lexer.g:256:13: 'parameter'
3824 {
3825 MATCHS(lit_45)ctx->pLexer->matchs(ctx->pLexer, lit_45);
3826 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3827 {
3828 goto rulePARAMETEREx;
3829 }
3830
3831
3832
3833 }
3834
3835 LEXSTATEctx->pLexer->rec->state->type = _type;
3836
3837 // This is where rules clean up and exit
3838 //
3839 goto rulePARAMETEREx; /* Prevent compiler warnings */
3840 rulePARAMETEREx: ;
3841
3842}
3843// $ANTLR end PARAMETER
3844
3845// Comes from: 257:9: ( 'partial' )
3846/** \brief Lexer rule generated by ANTLR3
3847 *
3848 * $ANTLR start PARTIAL
3849 *
3850 * Looks to match the characters the constitute the token PARTIAL
3851 * from the attached input stream.
3852 *
3853 *
3854 * \remark
3855 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3856 */
3857static ANTLR3_INLINE__inline__
3858void mPARTIAL(pParModelica_Lexer_BaseModelica_Lexer ctx)
3859{
3860 ANTLR3_UINT32 _type;
3861
3862 _type = PARTIAL64;
3863
3864
3865 // BaseModelica_Lexer.g:257:9: ( 'partial' )
3866 // BaseModelica_Lexer.g:257:11: 'partial'
3867 {
3868 MATCHS(lit_46)ctx->pLexer->matchs(ctx->pLexer, lit_46);
3869 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3870 {
3871 goto rulePARTIALEx;
3872 }
3873
3874
3875
3876 }
3877
3878 LEXSTATEctx->pLexer->rec->state->type = _type;
3879
3880 // This is where rules clean up and exit
3881 //
3882 goto rulePARTIALEx; /* Prevent compiler warnings */
3883 rulePARTIALEx: ;
3884
3885}
3886// $ANTLR end PARTIAL
3887
3888// Comes from: 258:11: ( 'protected' )
3889/** \brief Lexer rule generated by ANTLR3
3890 *
3891 * $ANTLR start PROTECTED
3892 *
3893 * Looks to match the characters the constitute the token PROTECTED
3894 * from the attached input stream.
3895 *
3896 *
3897 * \remark
3898 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3899 */
3900static ANTLR3_INLINE__inline__
3901void mPROTECTED(pParModelica_Lexer_BaseModelica_Lexer ctx)
3902{
3903 ANTLR3_UINT32 _type;
3904
3905 _type = PROTECTED65;
3906
3907
3908 // BaseModelica_Lexer.g:258:11: ( 'protected' )
3909 // BaseModelica_Lexer.g:258:13: 'protected'
3910 {
3911 MATCHS(lit_47)ctx->pLexer->matchs(ctx->pLexer, lit_47);
3912 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3913 {
3914 goto rulePROTECTEDEx;
3915 }
3916
3917
3918
3919 }
3920
3921 LEXSTATEctx->pLexer->rec->state->type = _type;
3922
3923 // This is where rules clean up and exit
3924 //
3925 goto rulePROTECTEDEx; /* Prevent compiler warnings */
3926 rulePROTECTEDEx: ;
3927
3928}
3929// $ANTLR end PROTECTED
3930
3931// Comes from: 259:8: ( 'public' )
3932/** \brief Lexer rule generated by ANTLR3
3933 *
3934 * $ANTLR start PUBLIC
3935 *
3936 * Looks to match the characters the constitute the token PUBLIC
3937 * from the attached input stream.
3938 *
3939 *
3940 * \remark
3941 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3942 */
3943static ANTLR3_INLINE__inline__
3944void mPUBLIC(pParModelica_Lexer_BaseModelica_Lexer ctx)
3945{
3946 ANTLR3_UINT32 _type;
3947
3948 _type = PUBLIC66;
3949
3950
3951 // BaseModelica_Lexer.g:259:8: ( 'public' )
3952 // BaseModelica_Lexer.g:259:10: 'public'
3953 {
3954 MATCHS(lit_48)ctx->pLexer->matchs(ctx->pLexer, lit_48);
3955 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3956 {
3957 goto rulePUBLICEx;
3958 }
3959
3960
3961
3962 }
3963
3964 LEXSTATEctx->pLexer->rec->state->type = _type;
3965
3966 // This is where rules clean up and exit
3967 //
3968 goto rulePUBLICEx; /* Prevent compiler warnings */
3969 rulePUBLICEx: ;
3970
3971}
3972// $ANTLR end PUBLIC
3973
3974// Comes from: 260:8: ( 'record' )
3975/** \brief Lexer rule generated by ANTLR3
3976 *
3977 * $ANTLR start RECORD
3978 *
3979 * Looks to match the characters the constitute the token RECORD
3980 * from the attached input stream.
3981 *
3982 *
3983 * \remark
3984 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
3985 */
3986static ANTLR3_INLINE__inline__
3987void mRECORD(pParModelica_Lexer_BaseModelica_Lexer ctx)
3988{
3989 ANTLR3_UINT32 _type;
3990
3991 _type = RECORD67;
3992
3993
3994 // BaseModelica_Lexer.g:260:8: ( 'record' )
3995 // BaseModelica_Lexer.g:260:10: 'record'
3996 {
3997 MATCHS(lit_49)ctx->pLexer->matchs(ctx->pLexer, lit_49);
3998 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
3999 {
4000 goto ruleRECORDEx;
4001 }
4002
4003
4004
4005 }
4006
4007 LEXSTATEctx->pLexer->rec->state->type = _type;
4008
4009 // This is where rules clean up and exit
4010 //
4011 goto ruleRECORDEx; /* Prevent compiler warnings */
4012 ruleRECORDEx: ;
4013
4014}
4015// $ANTLR end RECORD
4016
4017// Comes from: 261:11: ( 'redeclare' )
4018/** \brief Lexer rule generated by ANTLR3
4019 *
4020 * $ANTLR start REDECLARE
4021 *
4022 * Looks to match the characters the constitute the token REDECLARE
4023 * from the attached input stream.
4024 *
4025 *
4026 * \remark
4027 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4028 */
4029static ANTLR3_INLINE__inline__
4030void mREDECLARE(pParModelica_Lexer_BaseModelica_Lexer ctx)
4031{
4032 ANTLR3_UINT32 _type;
4033
4034 _type = REDECLARE68;
4035
4036
4037 // BaseModelica_Lexer.g:261:11: ( 'redeclare' )
4038 // BaseModelica_Lexer.g:261:13: 'redeclare'
4039 {
4040 MATCHS(lit_50)ctx->pLexer->matchs(ctx->pLexer, lit_50);
4041 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4042 {
4043 goto ruleREDECLAREEx;
4044 }
4045
4046
4047
4048 }
4049
4050 LEXSTATEctx->pLexer->rec->state->type = _type;
4051
4052 // This is where rules clean up and exit
4053 //
4054 goto ruleREDECLAREEx; /* Prevent compiler warnings */
4055 ruleREDECLAREEx: ;
4056
4057}
4058// $ANTLR end REDECLARE
4059
4060// Comes from: 262:13: ( 'replaceable' )
4061/** \brief Lexer rule generated by ANTLR3
4062 *
4063 * $ANTLR start REPLACEABLE
4064 *
4065 * Looks to match the characters the constitute the token REPLACEABLE
4066 * from the attached input stream.
4067 *
4068 *
4069 * \remark
4070 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4071 */
4072static ANTLR3_INLINE__inline__
4073void mREPLACEABLE(pParModelica_Lexer_BaseModelica_Lexer ctx)
4074{
4075 ANTLR3_UINT32 _type;
4076
4077 _type = REPLACEABLE69;
4078
4079
4080 // BaseModelica_Lexer.g:262:13: ( 'replaceable' )
4081 // BaseModelica_Lexer.g:262:15: 'replaceable'
4082 {
4083 MATCHS(lit_51)ctx->pLexer->matchs(ctx->pLexer, lit_51);
4084 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4085 {
4086 goto ruleREPLACEABLEEx;
4087 }
4088
4089
4090
4091 }
4092
4093 LEXSTATEctx->pLexer->rec->state->type = _type;
4094
4095 // This is where rules clean up and exit
4096 //
4097 goto ruleREPLACEABLEEx; /* Prevent compiler warnings */
4098 ruleREPLACEABLEEx: ;
4099
4100}
4101// $ANTLR end REPLACEABLE
4102
4103// Comes from: 263:6: ( 'then' )
4104/** \brief Lexer rule generated by ANTLR3
4105 *
4106 * $ANTLR start THEN
4107 *
4108 * Looks to match the characters the constitute the token THEN
4109 * from the attached input stream.
4110 *
4111 *
4112 * \remark
4113 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4114 */
4115static ANTLR3_INLINE__inline__
4116void mTHEN(pParModelica_Lexer_BaseModelica_Lexer ctx)
4117{
4118 ANTLR3_UINT32 _type;
4119
4120 _type = THEN70;
4121
4122
4123 // BaseModelica_Lexer.g:263:6: ( 'then' )
4124 // BaseModelica_Lexer.g:263:8: 'then'
4125 {
4126 MATCHS(lit_52)ctx->pLexer->matchs(ctx->pLexer, lit_52);
4127 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4128 {
4129 goto ruleTHENEx;
4130 }
4131
4132
4133
4134 }
4135
4136 LEXSTATEctx->pLexer->rec->state->type = _type;
4137
4138 // This is where rules clean up and exit
4139 //
4140 goto ruleTHENEx; /* Prevent compiler warnings */
4141 ruleTHENEx: ;
4142
4143}
4144// $ANTLR end THEN
4145
4146// Comes from: 264:8: ( 'true' )
4147/** \brief Lexer rule generated by ANTLR3
4148 *
4149 * $ANTLR start T_TRUE
4150 *
4151 * Looks to match the characters the constitute the token T_TRUE
4152 * from the attached input stream.
4153 *
4154 *
4155 * \remark
4156 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4157 */
4158static ANTLR3_INLINE__inline__
4159void mT_TRUE(pParModelica_Lexer_BaseModelica_Lexer ctx)
4160{
4161 ANTLR3_UINT32 _type;
4162
4163 _type = T_TRUE71;
4164
4165
4166 // BaseModelica_Lexer.g:264:8: ( 'true' )
4167 // BaseModelica_Lexer.g:264:10: 'true'
4168 {
4169 MATCHS(lit_53)ctx->pLexer->matchs(ctx->pLexer, lit_53);
4170 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4171 {
4172 goto ruleT_TRUEEx;
4173 }
4174
4175
4176
4177 }
4178
4179 LEXSTATEctx->pLexer->rec->state->type = _type;
4180
4181 // This is where rules clean up and exit
4182 //
4183 goto ruleT_TRUEEx; /* Prevent compiler warnings */
4184 ruleT_TRUEEx: ;
4185
4186}
4187// $ANTLR end T_TRUE
4188
4189// Comes from: 265:6: ( 'type' )
4190/** \brief Lexer rule generated by ANTLR3
4191 *
4192 * $ANTLR start TYPE
4193 *
4194 * Looks to match the characters the constitute the token TYPE
4195 * from the attached input stream.
4196 *
4197 *
4198 * \remark
4199 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4200 */
4201static ANTLR3_INLINE__inline__
4202void mTYPE(pParModelica_Lexer_BaseModelica_Lexer ctx)
4203{
4204 ANTLR3_UINT32 _type;
4205
4206 _type = TYPE72;
4207
4208
4209 // BaseModelica_Lexer.g:265:6: ( 'type' )
4210 // BaseModelica_Lexer.g:265:8: 'type'
4211 {
4212 MATCHS(lit_54)ctx->pLexer->matchs(ctx->pLexer, lit_54);
4213 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4214 {
4215 goto ruleTYPEEx;
4216 }
4217
4218
4219
4220 }
4221
4222 LEXSTATEctx->pLexer->rec->state->type = _type;
4223
4224 // This is where rules clean up and exit
4225 //
4226 goto ruleTYPEEx; /* Prevent compiler warnings */
4227 ruleTYPEEx: ;
4228
4229}
4230// $ANTLR end TYPE
4231
4232// Comes from: 266:15: ( 'unsigned_real' )
4233/** \brief Lexer rule generated by ANTLR3
4234 *
4235 * $ANTLR start UNSIGNED_REAL
4236 *
4237 * Looks to match the characters the constitute the token UNSIGNED_REAL
4238 * from the attached input stream.
4239 *
4240 *
4241 * \remark
4242 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4243 */
4244static ANTLR3_INLINE__inline__
4245void mUNSIGNED_REAL(pParModelica_Lexer_BaseModelica_Lexer ctx)
4246{
4247 ANTLR3_UINT32 _type;
4248
4249 _type = UNSIGNED_REAL73;
4250
4251
4252 // BaseModelica_Lexer.g:266:15: ( 'unsigned_real' )
4253 // BaseModelica_Lexer.g:266:17: 'unsigned_real'
4254 {
4255 MATCHS(lit_55)ctx->pLexer->matchs(ctx->pLexer, lit_55);
4256 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4257 {
4258 goto ruleUNSIGNED_REALEx;
4259 }
4260
4261
4262
4263 }
4264
4265 LEXSTATEctx->pLexer->rec->state->type = _type;
4266
4267 // This is where rules clean up and exit
4268 //
4269 goto ruleUNSIGNED_REALEx; /* Prevent compiler warnings */
4270 ruleUNSIGNED_REALEx: ;
4271
4272}
4273// $ANTLR end UNSIGNED_REAL
4274
4275// Comes from: 267:6: ( 'when' )
4276/** \brief Lexer rule generated by ANTLR3
4277 *
4278 * $ANTLR start WHEN
4279 *
4280 * Looks to match the characters the constitute the token WHEN
4281 * from the attached input stream.
4282 *
4283 *
4284 * \remark
4285 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4286 */
4287static ANTLR3_INLINE__inline__
4288void mWHEN(pParModelica_Lexer_BaseModelica_Lexer ctx)
4289{
4290 ANTLR3_UINT32 _type;
4291
4292 _type = WHEN74;
4293
4294
4295 // BaseModelica_Lexer.g:267:6: ( 'when' )
4296 // BaseModelica_Lexer.g:267:8: 'when'
4297 {
4298 MATCHS(lit_56)ctx->pLexer->matchs(ctx->pLexer, lit_56);
4299 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4300 {
4301 goto ruleWHENEx;
4302 }
4303
4304
4305
4306 }
4307
4308 LEXSTATEctx->pLexer->rec->state->type = _type;
4309
4310 // This is where rules clean up and exit
4311 //
4312 goto ruleWHENEx; /* Prevent compiler warnings */
4313 ruleWHENEx: ;
4314
4315}
4316// $ANTLR end WHEN
4317
4318// Comes from: 268:7: ( 'while' )
4319/** \brief Lexer rule generated by ANTLR3
4320 *
4321 * $ANTLR start WHILE
4322 *
4323 * Looks to match the characters the constitute the token WHILE
4324 * from the attached input stream.
4325 *
4326 *
4327 * \remark
4328 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4329 */
4330static ANTLR3_INLINE__inline__
4331void mWHILE(pParModelica_Lexer_BaseModelica_Lexer ctx)
4332{
4333 ANTLR3_UINT32 _type;
4334
4335 _type = WHILE75;
4336
4337
4338 // BaseModelica_Lexer.g:268:7: ( 'while' )
4339 // BaseModelica_Lexer.g:268:9: 'while'
4340 {
4341 MATCHS(lit_57)ctx->pLexer->matchs(ctx->pLexer, lit_57);
4342 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4343 {
4344 goto ruleWHILEEx;
4345 }
4346
4347
4348
4349 }
4350
4351 LEXSTATEctx->pLexer->rec->state->type = _type;
4352
4353 // This is where rules clean up and exit
4354 //
4355 goto ruleWHILEEx; /* Prevent compiler warnings */
4356 ruleWHILEEx: ;
4357
4358}
4359// $ANTLR end WHILE
4360
4361// Comes from: 269:8: ( 'within' )
4362/** \brief Lexer rule generated by ANTLR3
4363 *
4364 * $ANTLR start WITHIN
4365 *
4366 * Looks to match the characters the constitute the token WITHIN
4367 * from the attached input stream.
4368 *
4369 *
4370 * \remark
4371 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4372 */
4373static ANTLR3_INLINE__inline__
4374void mWITHIN(pParModelica_Lexer_BaseModelica_Lexer ctx)
4375{
4376 ANTLR3_UINT32 _type;
4377
4378 _type = WITHIN76;
4379
4380
4381 // BaseModelica_Lexer.g:269:8: ( 'within' )
4382 // BaseModelica_Lexer.g:269:10: 'within'
4383 {
4384 MATCHS(lit_58)ctx->pLexer->matchs(ctx->pLexer, lit_58);
4385 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4386 {
4387 goto ruleWITHINEx;
4388 }
4389
4390
4391
4392 }
4393
4394 LEXSTATEctx->pLexer->rec->state->type = _type;
4395
4396 // This is where rules clean up and exit
4397 //
4398 goto ruleWITHINEx; /* Prevent compiler warnings */
4399 ruleWITHINEx: ;
4400
4401}
4402// $ANTLR end WITHIN
4403
4404// Comes from: 270:8: ( 'return' )
4405/** \brief Lexer rule generated by ANTLR3
4406 *
4407 * $ANTLR start RETURN
4408 *
4409 * Looks to match the characters the constitute the token RETURN
4410 * from the attached input stream.
4411 *
4412 *
4413 * \remark
4414 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4415 */
4416static ANTLR3_INLINE__inline__
4417void mRETURN(pParModelica_Lexer_BaseModelica_Lexer ctx)
4418{
4419 ANTLR3_UINT32 _type;
4420
4421 _type = RETURN77;
4422
4423
4424 // BaseModelica_Lexer.g:270:8: ( 'return' )
4425 // BaseModelica_Lexer.g:270:10: 'return'
4426 {
4427 MATCHS(lit_59)ctx->pLexer->matchs(ctx->pLexer, lit_59);
4428 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4429 {
4430 goto ruleRETURNEx;
4431 }
4432
4433
4434
4435 }
4436
4437 LEXSTATEctx->pLexer->rec->state->type = _type;
4438
4439 // This is where rules clean up and exit
4440 //
4441 goto ruleRETURNEx; /* Prevent compiler warnings */
4442 ruleRETURNEx: ;
4443
4444}
4445// $ANTLR end RETURN
4446
4447// Comes from: 271:7: ( 'break' )
4448/** \brief Lexer rule generated by ANTLR3
4449 *
4450 * $ANTLR start BREAK
4451 *
4452 * Looks to match the characters the constitute the token BREAK
4453 * from the attached input stream.
4454 *
4455 *
4456 * \remark
4457 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4458 */
4459static ANTLR3_INLINE__inline__
4460void mBREAK(pParModelica_Lexer_BaseModelica_Lexer ctx)
4461{
4462 ANTLR3_UINT32 _type;
4463
4464 _type = BREAK78;
4465
4466
4467 // BaseModelica_Lexer.g:271:7: ( 'break' )
4468 // BaseModelica_Lexer.g:271:9: 'break'
4469 {
4470 MATCHS(lit_60)ctx->pLexer->matchs(ctx->pLexer, lit_60);
4471 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4472 {
4473 goto ruleBREAKEx;
4474 }
4475
4476
4477
4478 }
4479
4480 LEXSTATEctx->pLexer->rec->state->type = _type;
4481
4482 // This is where rules clean up and exit
4483 //
4484 goto ruleBREAKEx; /* Prevent compiler warnings */
4485 ruleBREAKEx: ;
4486
4487}
4488// $ANTLR end BREAK
4489
4490// Comes from: 277:5: ( '.' )
4491/** \brief Lexer rule generated by ANTLR3
4492 *
4493 * $ANTLR start DOT
4494 *
4495 * Looks to match the characters the constitute the token DOT
4496 * from the attached input stream.
4497 *
4498 *
4499 * \remark
4500 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4501 */
4502static ANTLR3_INLINE__inline__
4503void mDOT(pParModelica_Lexer_BaseModelica_Lexer ctx)
4504{
4505 ANTLR3_UINT32 _type;
4506
4507 _type = DOT105;
4508
4509
4510 // BaseModelica_Lexer.g:277:5: ( '.' )
4511 // BaseModelica_Lexer.g:277:7: '.'
4512 {
4513 MATCHC('.')ctx->pLexer->matchc(ctx->pLexer, '.');
4514 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4515 {
4516 goto ruleDOTEx;
4517 }
4518
4519
4520 }
4521
4522 LEXSTATEctx->pLexer->rec->state->type = _type;
4523
4524 // This is where rules clean up and exit
4525 //
4526 goto ruleDOTEx; /* Prevent compiler warnings */
4527 ruleDOTEx: ;
4528
4529}
4530// $ANTLR end DOT
4531
4532// Comes from: 278:6: ( '(' )
4533/** \brief Lexer rule generated by ANTLR3
4534 *
4535 * $ANTLR start LPAR
4536 *
4537 * Looks to match the characters the constitute the token LPAR
4538 * from the attached input stream.
4539 *
4540 *
4541 * \remark
4542 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4543 */
4544static ANTLR3_INLINE__inline__
4545void mLPAR(pParModelica_Lexer_BaseModelica_Lexer ctx)
4546{
4547 ANTLR3_UINT32 _type;
4548
4549 _type = LPAR106;
4550
4551
4552 // BaseModelica_Lexer.g:278:6: ( '(' )
4553 // BaseModelica_Lexer.g:278:8: '('
4554 {
4555 MATCHC('(')ctx->pLexer->matchc(ctx->pLexer, '(');
4556 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4557 {
4558 goto ruleLPAREx;
4559 }
4560
4561
4562 }
4563
4564 LEXSTATEctx->pLexer->rec->state->type = _type;
4565
4566 // This is where rules clean up and exit
4567 //
4568 goto ruleLPAREx; /* Prevent compiler warnings */
4569 ruleLPAREx: ;
4570
4571}
4572// $ANTLR end LPAR
4573
4574// Comes from: 279:6: ( ')' )
4575/** \brief Lexer rule generated by ANTLR3
4576 *
4577 * $ANTLR start RPAR
4578 *
4579 * Looks to match the characters the constitute the token RPAR
4580 * from the attached input stream.
4581 *
4582 *
4583 * \remark
4584 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4585 */
4586static ANTLR3_INLINE__inline__
4587void mRPAR(pParModelica_Lexer_BaseModelica_Lexer ctx)
4588{
4589 ANTLR3_UINT32 _type;
4590
4591 _type = RPAR107;
4592
4593
4594 // BaseModelica_Lexer.g:279:6: ( ')' )
4595 // BaseModelica_Lexer.g:279:8: ')'
4596 {
4597 MATCHC(')')ctx->pLexer->matchc(ctx->pLexer, ')');
4598 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4599 {
4600 goto ruleRPAREx;
4601 }
4602
4603
4604 }
4605
4606 LEXSTATEctx->pLexer->rec->state->type = _type;
4607
4608 // This is where rules clean up and exit
4609 //
4610 goto ruleRPAREx; /* Prevent compiler warnings */
4611 ruleRPAREx: ;
4612
4613}
4614// $ANTLR end RPAR
4615
4616// Comes from: 280:8: ( '[' )
4617/** \brief Lexer rule generated by ANTLR3
4618 *
4619 * $ANTLR start LBRACK
4620 *
4621 * Looks to match the characters the constitute the token LBRACK
4622 * from the attached input stream.
4623 *
4624 *
4625 * \remark
4626 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4627 */
4628static ANTLR3_INLINE__inline__
4629void mLBRACK(pParModelica_Lexer_BaseModelica_Lexer ctx)
4630{
4631 ANTLR3_UINT32 _type;
4632
4633 _type = LBRACK108;
4634
4635
4636 // BaseModelica_Lexer.g:280:8: ( '[' )
4637 // BaseModelica_Lexer.g:280:10: '['
4638 {
4639 MATCHC('[')ctx->pLexer->matchc(ctx->pLexer, '[');
4640 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4641 {
4642 goto ruleLBRACKEx;
4643 }
4644
4645
4646 }
4647
4648 LEXSTATEctx->pLexer->rec->state->type = _type;
4649
4650 // This is where rules clean up and exit
4651 //
4652 goto ruleLBRACKEx; /* Prevent compiler warnings */
4653 ruleLBRACKEx: ;
4654
4655}
4656// $ANTLR end LBRACK
4657
4658// Comes from: 281:8: ( ']' )
4659/** \brief Lexer rule generated by ANTLR3
4660 *
4661 * $ANTLR start RBRACK
4662 *
4663 * Looks to match the characters the constitute the token RBRACK
4664 * from the attached input stream.
4665 *
4666 *
4667 * \remark
4668 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4669 */
4670static ANTLR3_INLINE__inline__
4671void mRBRACK(pParModelica_Lexer_BaseModelica_Lexer ctx)
4672{
4673 ANTLR3_UINT32 _type;
4674
4675 _type = RBRACK109;
4676
4677
4678 // BaseModelica_Lexer.g:281:8: ( ']' )
4679 // BaseModelica_Lexer.g:281:10: ']'
4680 {
4681 MATCHC(']')ctx->pLexer->matchc(ctx->pLexer, ']');
4682 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4683 {
4684 goto ruleRBRACKEx;
4685 }
4686
4687
4688 }
4689
4690 LEXSTATEctx->pLexer->rec->state->type = _type;
4691
4692 // This is where rules clean up and exit
4693 //
4694 goto ruleRBRACKEx; /* Prevent compiler warnings */
4695 ruleRBRACKEx: ;
4696
4697}
4698// $ANTLR end RBRACK
4699
4700// Comes from: 282:8: ( '{' )
4701/** \brief Lexer rule generated by ANTLR3
4702 *
4703 * $ANTLR start LBRACE
4704 *
4705 * Looks to match the characters the constitute the token LBRACE
4706 * from the attached input stream.
4707 *
4708 *
4709 * \remark
4710 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4711 */
4712static ANTLR3_INLINE__inline__
4713void mLBRACE(pParModelica_Lexer_BaseModelica_Lexer ctx)
4714{
4715 ANTLR3_UINT32 _type;
4716
4717 _type = LBRACE110;
4718
4719
4720 // BaseModelica_Lexer.g:282:8: ( '{' )
4721 // BaseModelica_Lexer.g:282:10: '{'
4722 {
4723 MATCHC('{')ctx->pLexer->matchc(ctx->pLexer, '{');
4724 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4725 {
4726 goto ruleLBRACEEx;
4727 }
4728
4729
4730 }
4731
4732 LEXSTATEctx->pLexer->rec->state->type = _type;
4733
4734 // This is where rules clean up and exit
4735 //
4736 goto ruleLBRACEEx; /* Prevent compiler warnings */
4737 ruleLBRACEEx: ;
4738
4739}
4740// $ANTLR end LBRACE
4741
4742// Comes from: 283:8: ( '}' )
4743/** \brief Lexer rule generated by ANTLR3
4744 *
4745 * $ANTLR start RBRACE
4746 *
4747 * Looks to match the characters the constitute the token RBRACE
4748 * from the attached input stream.
4749 *
4750 *
4751 * \remark
4752 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4753 */
4754static ANTLR3_INLINE__inline__
4755void mRBRACE(pParModelica_Lexer_BaseModelica_Lexer ctx)
4756{
4757 ANTLR3_UINT32 _type;
4758
4759 _type = RBRACE111;
4760
4761
4762 // BaseModelica_Lexer.g:283:8: ( '}' )
4763 // BaseModelica_Lexer.g:283:10: '}'
4764 {
4765 MATCHC('}')ctx->pLexer->matchc(ctx->pLexer, '}');
4766 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4767 {
4768 goto ruleRBRACEEx;
4769 }
4770
4771
4772 }
4773
4774 LEXSTATEctx->pLexer->rec->state->type = _type;
4775
4776 // This is where rules clean up and exit
4777 //
4778 goto ruleRBRACEEx; /* Prevent compiler warnings */
4779 ruleRBRACEEx: ;
4780
4781}
4782// $ANTLR end RBRACE
4783
4784// Comes from: 284:8: ( '=' )
4785/** \brief Lexer rule generated by ANTLR3
4786 *
4787 * $ANTLR start EQUALS
4788 *
4789 * Looks to match the characters the constitute the token EQUALS
4790 * from the attached input stream.
4791 *
4792 *
4793 * \remark
4794 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4795 */
4796static ANTLR3_INLINE__inline__
4797void mEQUALS(pParModelica_Lexer_BaseModelica_Lexer ctx)
4798{
4799 ANTLR3_UINT32 _type;
4800
4801 _type = EQUALS112;
4802
4803
4804 // BaseModelica_Lexer.g:284:8: ( '=' )
4805 // BaseModelica_Lexer.g:284:10: '='
4806 {
4807 MATCHC('=')ctx->pLexer->matchc(ctx->pLexer, '=');
4808 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4809 {
4810 goto ruleEQUALSEx;
4811 }
4812
4813
4814 }
4815
4816 LEXSTATEctx->pLexer->rec->state->type = _type;
4817
4818 // This is where rules clean up and exit
4819 //
4820 goto ruleEQUALSEx; /* Prevent compiler warnings */
4821 ruleEQUALSEx: ;
4822
4823}
4824// $ANTLR end EQUALS
4825
4826// Comes from: 285:8: ( ':=' )
4827/** \brief Lexer rule generated by ANTLR3
4828 *
4829 * $ANTLR start ASSIGN
4830 *
4831 * Looks to match the characters the constitute the token ASSIGN
4832 * from the attached input stream.
4833 *
4834 *
4835 * \remark
4836 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4837 */
4838static ANTLR3_INLINE__inline__
4839void mASSIGN(pParModelica_Lexer_BaseModelica_Lexer ctx)
4840{
4841 ANTLR3_UINT32 _type;
4842
4843 _type = ASSIGN113;
4844
4845
4846 // BaseModelica_Lexer.g:285:8: ( ':=' )
4847 // BaseModelica_Lexer.g:285:10: ':='
4848 {
4849 MATCHS(lit_61)ctx->pLexer->matchs(ctx->pLexer, lit_61);
4850 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4851 {
4852 goto ruleASSIGNEx;
4853 }
4854
4855
4856
4857 }
4858
4859 LEXSTATEctx->pLexer->rec->state->type = _type;
4860
4861 // This is where rules clean up and exit
4862 //
4863 goto ruleASSIGNEx; /* Prevent compiler warnings */
4864 ruleASSIGNEx: ;
4865
4866}
4867// $ANTLR end ASSIGN
4868
4869// Comes from: 286:7: ( ',' )
4870/** \brief Lexer rule generated by ANTLR3
4871 *
4872 * $ANTLR start COMMA
4873 *
4874 * Looks to match the characters the constitute the token COMMA
4875 * from the attached input stream.
4876 *
4877 *
4878 * \remark
4879 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4880 */
4881static ANTLR3_INLINE__inline__
4882void mCOMMA(pParModelica_Lexer_BaseModelica_Lexer ctx)
4883{
4884 ANTLR3_UINT32 _type;
4885
4886 _type = COMMA114;
4887
4888
4889 // BaseModelica_Lexer.g:286:7: ( ',' )
4890 // BaseModelica_Lexer.g:286:9: ','
4891 {
4892 MATCHC(',')ctx->pLexer->matchc(ctx->pLexer, ',');
4893 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4894 {
4895 goto ruleCOMMAEx;
4896 }
4897
4898
4899 }
4900
4901 LEXSTATEctx->pLexer->rec->state->type = _type;
4902
4903 // This is where rules clean up and exit
4904 //
4905 goto ruleCOMMAEx; /* Prevent compiler warnings */
4906 ruleCOMMAEx: ;
4907
4908}
4909// $ANTLR end COMMA
4910
4911// Comes from: 287:7: ( ':' )
4912/** \brief Lexer rule generated by ANTLR3
4913 *
4914 * $ANTLR start COLON
4915 *
4916 * Looks to match the characters the constitute the token COLON
4917 * from the attached input stream.
4918 *
4919 *
4920 * \remark
4921 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4922 */
4923static ANTLR3_INLINE__inline__
4924void mCOLON(pParModelica_Lexer_BaseModelica_Lexer ctx)
4925{
4926 ANTLR3_UINT32 _type;
4927
4928 _type = COLON115;
4929
4930
4931 // BaseModelica_Lexer.g:287:7: ( ':' )
4932 // BaseModelica_Lexer.g:287:9: ':'
4933 {
4934 MATCHC(':')ctx->pLexer->matchc(ctx->pLexer, ':');
4935 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4936 {
4937 goto ruleCOLONEx;
4938 }
4939
4940
4941 }
4942
4943 LEXSTATEctx->pLexer->rec->state->type = _type;
4944
4945 // This is where rules clean up and exit
4946 //
4947 goto ruleCOLONEx; /* Prevent compiler warnings */
4948 ruleCOLONEx: ;
4949
4950}
4951// $ANTLR end COLON
4952
4953// Comes from: 288:11: ( ';' )
4954/** \brief Lexer rule generated by ANTLR3
4955 *
4956 * $ANTLR start SEMICOLON
4957 *
4958 * Looks to match the characters the constitute the token SEMICOLON
4959 * from the attached input stream.
4960 *
4961 *
4962 * \remark
4963 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
4964 */
4965static ANTLR3_INLINE__inline__
4966void mSEMICOLON(pParModelica_Lexer_BaseModelica_Lexer ctx)
4967{
4968 ANTLR3_UINT32 _type;
4969
4970 _type = SEMICOLON116;
4971
4972
4973 // BaseModelica_Lexer.g:288:11: ( ';' )
4974 // BaseModelica_Lexer.g:288:13: ';'
4975 {
4976 MATCHC(';')ctx->pLexer->matchc(ctx->pLexer, ';');
4977 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
4978 {
4979 goto ruleSEMICOLONEx;
4980 }
4981
4982
4983 }
4984
4985 LEXSTATEctx->pLexer->rec->state->type = _type;
4986
4987 // This is where rules clean up and exit
4988 //
4989 goto ruleSEMICOLONEx; /* Prevent compiler warnings */
4990 ruleSEMICOLONEx: ;
4991
4992}
4993// $ANTLR end SEMICOLON
4994
4995// Comes from: 294:14: ( 'optimization' )
4996/** \brief Lexer rule generated by ANTLR3
4997 *
4998 * $ANTLR start OPTIMIZATION
4999 *
5000 * Looks to match the characters the constitute the token OPTIMIZATION
5001 * from the attached input stream.
5002 *
5003 *
5004 * \remark
5005 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5006 */
5007static ANTLR3_INLINE__inline__
5008void mOPTIMIZATION(pParModelica_Lexer_BaseModelica_Lexer ctx)
5009{
5010 ANTLR3_UINT32 _type;
5011
5012 _type = OPTIMIZATION95;
5013
5014
5015 // BaseModelica_Lexer.g:294:14: ( 'optimization' )
5016 // BaseModelica_Lexer.g:294:16: 'optimization'
5017 {
5018 MATCHS(lit_62)ctx->pLexer->matchs(ctx->pLexer, lit_62);
5019 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5020 {
5021 goto ruleOPTIMIZATIONEx;
5022 }
5023
5024
5025 {
5026 if (!optimica_enabled()(((parser_members*)pthread_getspecific(modelicaParserKey))->
flags&1<<5)
) _type = IDENT124;
5027 }
5028
5029 }
5030
5031 LEXSTATEctx->pLexer->rec->state->type = _type;
5032
5033 // This is where rules clean up and exit
5034 //
5035 goto ruleOPTIMIZATIONEx; /* Prevent compiler warnings */
5036 ruleOPTIMIZATIONEx: ;
5037
5038}
5039// $ANTLR end OPTIMIZATION
5040
5041// Comes from: 295:12: ( 'constraint' )
5042/** \brief Lexer rule generated by ANTLR3
5043 *
5044 * $ANTLR start CONSTRAINT
5045 *
5046 * Looks to match the characters the constitute the token CONSTRAINT
5047 * from the attached input stream.
5048 *
5049 *
5050 * \remark
5051 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5052 */
5053static ANTLR3_INLINE__inline__
5054void mCONSTRAINT(pParModelica_Lexer_BaseModelica_Lexer ctx)
5055{
5056 ANTLR3_UINT32 _type;
5057
5058 _type = CONSTRAINT96;
5059
5060
5061 // BaseModelica_Lexer.g:295:12: ( 'constraint' )
5062 // BaseModelica_Lexer.g:295:14: 'constraint'
5063 {
5064 MATCHS(lit_63)ctx->pLexer->matchs(ctx->pLexer, lit_63);
5065 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5066 {
5067 goto ruleCONSTRAINTEx;
5068 }
5069
5070
5071 {
5072 if (!optimica_enabled()(((parser_members*)pthread_getspecific(modelicaParserKey))->
flags&1<<5)
) _type = IDENT124;
5073 }
5074
5075 }
5076
5077 LEXSTATEctx->pLexer->rec->state->type = _type;
5078
5079 // This is where rules clean up and exit
5080 //
5081 goto ruleCONSTRAINTEx; /* Prevent compiler warnings */
5082 ruleCONSTRAINTEx: ;
5083
5084}
5085// $ANTLR end CONSTRAINT
5086
5087// Comes from: 304:7: ( 'field' )
5088/** \brief Lexer rule generated by ANTLR3
5089 *
5090 * $ANTLR start FIELD
5091 *
5092 * Looks to match the characters the constitute the token FIELD
5093 * from the attached input stream.
5094 *
5095 *
5096 * \remark
5097 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5098 */
5099static ANTLR3_INLINE__inline__
5100void mFIELD(pParModelica_Lexer_BaseModelica_Lexer ctx)
5101{
5102 ANTLR3_UINT32 _type;
5103
5104 _type = FIELD103;
5105
5106
5107 // BaseModelica_Lexer.g:304:7: ( 'field' )
5108 // BaseModelica_Lexer.g:304:9: 'field'
5109 {
5110 MATCHS(lit_64)ctx->pLexer->matchs(ctx->pLexer, lit_64);
5111 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5112 {
5113 goto ruleFIELDEx;
5114 }
5115
5116
5117 {
5118 if (!pdemodelica_enabled()(((parser_members*)pthread_getspecific(modelicaParserKey))->
flags&1<<8)
) _type = IDENT124;
5119 }
5120
5121 }
5122
5123 LEXSTATEctx->pLexer->rec->state->type = _type;
5124
5125 // This is where rules clean up and exit
5126 //
5127 goto ruleFIELDEx; /* Prevent compiler warnings */
5128 ruleFIELDEx: ;
5129
5130}
5131// $ANTLR end FIELD
5132
5133// Comes from: 305:10: ( 'nonfield' )
5134/** \brief Lexer rule generated by ANTLR3
5135 *
5136 * $ANTLR start NONFIELD
5137 *
5138 * Looks to match the characters the constitute the token NONFIELD
5139 * from the attached input stream.
5140 *
5141 *
5142 * \remark
5143 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5144 */
5145static ANTLR3_INLINE__inline__
5146void mNONFIELD(pParModelica_Lexer_BaseModelica_Lexer ctx)
5147{
5148 ANTLR3_UINT32 _type;
5149
5150 _type = NONFIELD125;
5151
5152
5153 // BaseModelica_Lexer.g:305:10: ( 'nonfield' )
5154 // BaseModelica_Lexer.g:305:12: 'nonfield'
5155 {
5156 MATCHS(lit_65)ctx->pLexer->matchs(ctx->pLexer, lit_65);
5157 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5158 {
5159 goto ruleNONFIELDEx;
5160 }
5161
5162
5163 {
5164 if (!pdemodelica_enabled()(((parser_members*)pthread_getspecific(modelicaParserKey))->
flags&1<<8)
) _type = IDENT124;
5165 }
5166
5167 }
5168
5169 LEXSTATEctx->pLexer->rec->state->type = _type;
5170
5171 // This is where rules clean up and exit
5172 //
5173 goto ruleNONFIELDEx; /* Prevent compiler warnings */
5174 ruleNONFIELDEx: ;
5175
5176}
5177// $ANTLR end NONFIELD
5178
5179// Comes from: 306:10: ( 'indomain' )
5180/** \brief Lexer rule generated by ANTLR3
5181 *
5182 * $ANTLR start INDOMAIN
5183 *
5184 * Looks to match the characters the constitute the token INDOMAIN
5185 * from the attached input stream.
5186 *
5187 *
5188 * \remark
5189 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5190 */
5191static ANTLR3_INLINE__inline__
5192void mINDOMAIN(pParModelica_Lexer_BaseModelica_Lexer ctx)
5193{
5194 ANTLR3_UINT32 _type;
5195
5196 _type = INDOMAIN104;
5197
5198
5199 // BaseModelica_Lexer.g:306:10: ( 'indomain' )
5200 // BaseModelica_Lexer.g:306:12: 'indomain'
5201 {
5202 MATCHS(lit_66)ctx->pLexer->matchs(ctx->pLexer, lit_66);
5203 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5204 {
5205 goto ruleINDOMAINEx;
5206 }
5207
5208
5209 {
5210 if (!pdemodelica_enabled()(((parser_members*)pthread_getspecific(modelicaParserKey))->
flags&1<<8)
) _type = IDENT124;
5211 }
5212
5213 }
5214
5215 LEXSTATEctx->pLexer->rec->state->type = _type;
5216
5217 // This is where rules clean up and exit
5218 //
5219 goto ruleINDOMAINEx; /* Prevent compiler warnings */
5220 ruleINDOMAINEx: ;
5221
5222}
5223// $ANTLR end INDOMAIN
5224
5225// Comes from: 312:5: ( '\\u00EF' '\\u00BB' '\\u00BF' )
5226/** \brief Lexer rule generated by ANTLR3
5227 *
5228 * $ANTLR start BOM
5229 *
5230 * Looks to match the characters the constitute the token BOM
5231 * from the attached input stream.
5232 *
5233 *
5234 * \remark
5235 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5236 */
5237static ANTLR3_INLINE__inline__
5238void mBOM(pParModelica_Lexer_BaseModelica_Lexer ctx)
5239{
5240 ANTLR3_UINT32 _type;
5241
5242 _type = BOM8;
5243
5244
5245 // BaseModelica_Lexer.g:312:5: ( '\\u00EF' '\\u00BB' '\\u00BF' )
5246 // BaseModelica_Lexer.g:312:7: '\\u00EF' '\\u00BB' '\\u00BF'
5247 {
5248 MATCHC(0x00EF)ctx->pLexer->matchc(ctx->pLexer, 0x00EF);
5249 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5250 {
5251 goto ruleBOMEx;
5252 }
5253
5254 MATCHC(0x00BB)ctx->pLexer->matchc(ctx->pLexer, 0x00BB);
5255 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5256 {
5257 goto ruleBOMEx;
5258 }
5259
5260 MATCHC(0x00BF)ctx->pLexer->matchc(ctx->pLexer, 0x00BF);
5261 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5262 {
5263 goto ruleBOMEx;
5264 }
5265
5266
5267 }
5268
5269 LEXSTATEctx->pLexer->rec->state->type = _type;
5270
5271 // This is where rules clean up and exit
5272 //
5273 goto ruleBOMEx; /* Prevent compiler warnings */
5274 ruleBOMEx: ;
5275
5276}
5277// $ANTLR end BOM
5278
5279// Comes from: 314:4: ( ( ' ' | '\\t' | NL )+ )
5280/** \brief Lexer rule generated by ANTLR3
5281 *
5282 * $ANTLR start WS
5283 *
5284 * Looks to match the characters the constitute the token WS
5285 * from the attached input stream.
5286 *
5287 *
5288 * \remark
5289 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5290 */
5291static ANTLR3_INLINE__inline__
5292void mWS(pParModelica_Lexer_BaseModelica_Lexer ctx)
5293{
5294 ANTLR3_UINT32 _type;
5295
5296 _type = WS127;
5297
5298
5299 // BaseModelica_Lexer.g:314:4: ( ( ' ' | '\\t' | NL )+ )
5300 // BaseModelica_Lexer.g:314:6: ( ' ' | '\\t' | NL )+
5301 {
5302 // BaseModelica_Lexer.g:314:6: ( ' ' | '\\t' | NL )+
5303 {
5304 int cnt4=0;
5305
5306 for (;;)
5307 {
5308 int alt4=4;
5309 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
5310 {
5311 case ' ':
5312 {
5313 alt4=1;
5314 }
5315 break;
5316 case '\t':
5317 {
5318 alt4=2;
5319 }
5320 break;
5321 case '\n':
5322 case '\r':
5323 {
5324 alt4=3;
5325 }
5326 break;
5327
5328 }
5329
5330 switch (alt4)
5331 {
5332 case 1:
5333 // BaseModelica_Lexer.g:314:8: ' '
5334 {
5335 MATCHC(' ')ctx->pLexer->matchc(ctx->pLexer, ' ');
5336 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5337 {
5338 goto ruleWSEx;
5339 }
5340
5341
5342 }
5343 break;
5344 case 2:
5345 // BaseModelica_Lexer.g:314:14: '\\t'
5346 {
5347 MATCHC('\t')ctx->pLexer->matchc(ctx->pLexer, '\t');
5348 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5349 {
5350 goto ruleWSEx;
5351 }
5352
5353
5354 }
5355 break;
5356 case 3:
5357 // BaseModelica_Lexer.g:314:21: NL
5358 {
5359 /* 314:21: NL */
5360 mNL(ctx );
5361 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5362 {
5363 goto ruleWSEx;
5364 }
5365
5366
5367 }
5368 break;
5369
5370 default:
5371
5372 if ( cnt4 >= 1 )
5373 {
5374 goto loop4;
5375 }
5376 /* mismatchedSetEx()
5377 */
5378 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
5379 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_EARLY_EXIT_EXCEPTION5;
5380 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_EARLY_EXIT_NAME"Early exit";
5381
5382
5383 goto ruleWSEx;
5384 }
5385 cnt4++;
5386 }
5387 loop4: ; /* Jump to here if this rule does not match */
5388 }
5389 {
5390 LEXSTATEctx->pLexer->rec->state->channel=HIDDEN99;
5391 }
5392
5393 }
5394
5395 LEXSTATEctx->pLexer->rec->state->type = _type;
5396
5397 // This is where rules clean up and exit
5398 //
5399 goto ruleWSEx; /* Prevent compiler warnings */
5400 ruleWSEx: ;
5401
5402}
5403// $ANTLR end WS
5404
5405// Comes from: 318:5: ( '//' ( (~ ( '\\r' | '\\n' ) )* ) ( NL | EOF ) )
5406/** \brief Lexer rule generated by ANTLR3
5407 *
5408 * $ANTLR start LINE_COMMENT
5409 *
5410 * Looks to match the characters the constitute the token LINE_COMMENT
5411 * from the attached input stream.
5412 *
5413 *
5414 * \remark
5415 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5416 */
5417static ANTLR3_INLINE__inline__
5418void mLINE_COMMENT(pParModelica_Lexer_BaseModelica_Lexer ctx)
5419{
5420 ANTLR3_UINT32 _type;
5421
5422 _type = LINE_COMMENT128;
5423
5424
5425 // BaseModelica_Lexer.g:318:5: ( '//' ( (~ ( '\\r' | '\\n' ) )* ) ( NL | EOF ) )
5426 // BaseModelica_Lexer.g:318:7: '//' ( (~ ( '\\r' | '\\n' ) )* ) ( NL | EOF )
5427 {
5428 MATCHS(lit_67)ctx->pLexer->matchs(ctx->pLexer, lit_67);
5429 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5430 {
5431 goto ruleLINE_COMMENTEx;
5432 }
5433
5434
5435 // BaseModelica_Lexer.g:318:12: ( (~ ( '\\r' | '\\n' ) )* )
5436 // BaseModelica_Lexer.g:318:14: (~ ( '\\r' | '\\n' ) )*
5437 {
5438
5439 // BaseModelica_Lexer.g:318:14: (~ ( '\\r' | '\\n' ) )*
5440
5441 for (;;)
5442 {
5443 int alt5=2;
5444 {
5445 /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
5446 */
5447 int LA5_0 = LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
;
5448 if ( (((LA5_0 >= 0x0000) && (LA5_0 <= '\t')) || ((LA5_0 >= 0x000B) && (LA5_0 <= '\f')) || ((LA5_0 >= 0x000E) && (LA5_0 <= 0xFFFF))) )
5449 {
5450 alt5=1;
5451 }
5452
5453 }
5454 switch (alt5)
5455 {
5456 case 1:
5457 // BaseModelica_Lexer.g:318:14: ~ ( '\\r' | '\\n' )
5458 {
5459 if ( ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 0x0000) && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '\t')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 0x000B) && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '\f')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 0x000E) && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 0xFFFF)) )
5460 {
5461 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
5462
5463 }
5464 else
5465 {
5466 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
5467 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
5468 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
5469
5470 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleLINE_COMMENTEx;
5471 }
5472
5473
5474 }
5475 break;
5476
5477 default:
5478 goto loop5; /* break out of the loop */
5479 break;
5480 }
5481 }
5482 loop5: ; /* Jump out to here if this rule does not match */
5483
5484
5485 }
5486
5487
5488 // BaseModelica_Lexer.g:318:30: ( NL | EOF )
5489 {
5490 int alt6=2;
5491 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
5492 {
5493 case '\n':
5494 case '\r':
5495 {
5496 alt6=1;
5497 }
5498 break;
5499
5500 default:
5501 alt6=2;}
5502
5503 switch (alt6)
5504 {
5505 case 1:
5506 // BaseModelica_Lexer.g:318:31: NL
5507 {
5508 /* 318:31: NL */
5509 mNL(ctx );
5510 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5511 {
5512 goto ruleLINE_COMMENTEx;
5513 }
5514
5515
5516 }
5517 break;
5518 case 2:
5519 // BaseModelica_Lexer.g:318:34: EOF
5520 {
5521 MATCHC(ANTLR3_CHARSTREAM_EOF)ctx->pLexer->matchc(ctx->pLexer, 0xFFFFFFFF);
5522 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5523 {
5524 goto ruleLINE_COMMENTEx;
5525 }
5526
5527
5528 }
5529 break;
5530
5531 }
5532 }
5533 {
5534 LEXSTATEctx->pLexer->rec->state->channel=HIDDEN99;
5535 }
5536
5537 }
5538
5539 LEXSTATEctx->pLexer->rec->state->type = _type;
5540
5541 // This is where rules clean up and exit
5542 //
5543 goto ruleLINE_COMMENTEx; /* Prevent compiler warnings */
5544 ruleLINE_COMMENTEx: ;
5545
5546}
5547// $ANTLR end LINE_COMMENT
5548
5549// Comes from: 322:5: ( '/*' ( options {greedy=false; } : . )* '*/' )
5550/** \brief Lexer rule generated by ANTLR3
5551 *
5552 * $ANTLR start ML_COMMENT
5553 *
5554 * Looks to match the characters the constitute the token ML_COMMENT
5555 * from the attached input stream.
5556 *
5557 *
5558 * \remark
5559 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5560 */
5561static ANTLR3_INLINE__inline__
5562void mML_COMMENT(pParModelica_Lexer_BaseModelica_Lexer ctx)
5563{
5564 ANTLR3_UINT32 _type;
5565
5566 _type = ML_COMMENT129;
5567
5568
5569 // BaseModelica_Lexer.g:322:5: ( '/*' ( options {greedy=false; } : . )* '*/' )
5570 // BaseModelica_Lexer.g:322:9: '/*' ( options {greedy=false; } : . )* '*/'
5571 {
5572 MATCHS(lit_68)ctx->pLexer->matchs(ctx->pLexer, lit_68);
5573 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5574 {
5575 goto ruleML_COMMENTEx;
5576 }
5577
5578
5579
5580 // BaseModelica_Lexer.g:322:14: ( options {greedy=false; } : . )*
5581
5582 for (;;)
5583 {
5584 int alt7=2;
5585 {
5586 /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
5587 */
5588 int LA7_0 = LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
;
5589 if ( (LA7_0 == '*') )
5590 {
5591 {
5592 /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
5593 */
5594 int LA7_1 = LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
;
5595 if ( (LA7_1 == '/') )
5596 {
5597 alt7=2;
5598 }
5599 else if ( (((LA7_1 >= 0x0000) && (LA7_1 <= '.')) || ((LA7_1 >= '0') && (LA7_1 <= 0xFFFF))) )
5600 {
5601 alt7=1;
5602 }
5603
5604 }
5605 }
5606 else if ( (((LA7_0 >= 0x0000) && (LA7_0 <= ')')) || ((LA7_0 >= '+') && (LA7_0 <= 0xFFFF))) )
5607 {
5608 alt7=1;
5609 }
5610
5611 }
5612 switch (alt7)
5613 {
5614 case 1:
5615 // BaseModelica_Lexer.g:322:41: .
5616 {
5617 MATCHANY()ctx->pLexer->matchAny(ctx->pLexer);
5618 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5619 {
5620 goto ruleML_COMMENTEx;
5621 }
5622
5623
5624 }
5625 break;
5626
5627 default:
5628 goto loop7; /* break out of the loop */
5629 break;
5630 }
5631 }
5632 loop7: ; /* Jump out to here if this rule does not match */
5633
5634 MATCHS(lit_69)ctx->pLexer->matchs(ctx->pLexer, lit_69);
5635 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5636 {
5637 goto ruleML_COMMENTEx;
5638 }
5639
5640
5641 {
5642 LEXSTATEctx->pLexer->rec->state->channel=HIDDEN99;
5643 }
5644
5645 }
5646
5647 LEXSTATEctx->pLexer->rec->state->type = _type;
5648
5649 // This is where rules clean up and exit
5650 //
5651 goto ruleML_COMMENTEx; /* Prevent compiler warnings */
5652 ruleML_COMMENTEx: ;
5653
5654}
5655// $ANTLR end ML_COMMENT
5656
5657// Comes from: 326:3: ( '\\r\\n' | '\\n' | '\\r' )
5658/** \brief Lexer rule generated by ANTLR3
5659 *
5660 * $ANTLR start NL
5661 *
5662 * Looks to match the characters the constitute the token NL
5663 * from the attached input stream.
5664 *
5665 *
5666 * \remark
5667 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5668 */
5669static ANTLR3_INLINE__inline__
5670void mNL(pParModelica_Lexer_BaseModelica_Lexer ctx)
5671{
5672 ANTLR3_UINT32 _type;
5673
5674
5675 {
5676 // BaseModelica_Lexer.g:326:3: ( '\\r\\n' | '\\n' | '\\r' )
5677
5678 ANTLR3_UINT32 alt8;
5679
5680 alt8=3;
5681
5682 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
5683 {
5684 case '\r':
5685 {
5686 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
5687 {
5688 case '\n':
5689 {
5690 alt8=1;
5691 }
5692 break;
5693
5694 default:
5695 alt8=3;}
5696
5697 }
5698 break;
5699 case '\n':
5700 {
5701 alt8=2;
5702 }
5703 break;
5704
5705 default:
5706 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
5707 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
5708 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
5709 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 8;
5710 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
5711
5712
5713 goto ruleNLEx;
5714 }
5715
5716 switch (alt8)
5717 {
5718 case 1:
5719 // BaseModelica_Lexer.g:326:5: '\\r\\n'
5720 {
5721 MATCHS(lit_70)ctx->pLexer->matchs(ctx->pLexer, lit_70);
5722 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5723 {
5724 goto ruleNLEx;
5725 }
5726
5727
5728
5729 }
5730 break;
5731 case 2:
5732 // BaseModelica_Lexer.g:326:14: '\\n'
5733 {
5734 MATCHC('\n')ctx->pLexer->matchc(ctx->pLexer, '\n');
5735 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5736 {
5737 goto ruleNLEx;
5738 }
5739
5740
5741 }
5742 break;
5743 case 3:
5744 // BaseModelica_Lexer.g:326:21: '\\r'
5745 {
5746 MATCHC('\r')ctx->pLexer->matchc(ctx->pLexer, '\r');
5747 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5748 {
5749 goto ruleNLEx;
5750 }
5751
5752
5753 }
5754 break;
5755
5756 }
5757 }
5758
5759
5760 // This is where rules clean up and exit
5761 //
5762 goto ruleNLEx; /* Prevent compiler warnings */
5763 ruleNLEx: ;
5764
5765}
5766// $ANTLR end NL
5767
5768// Comes from: 329:6: ( '$Code' )
5769/** \brief Lexer rule generated by ANTLR3
5770 *
5771 * $ANTLR start CODE
5772 *
5773 * Looks to match the characters the constitute the token CODE
5774 * from the attached input stream.
5775 *
5776 *
5777 * \remark
5778 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5779 */
5780static ANTLR3_INLINE__inline__
5781void mCODE(pParModelica_Lexer_BaseModelica_Lexer ctx)
5782{
5783 ANTLR3_UINT32 _type;
5784
5785 _type = CODE9;
5786
5787
5788 // BaseModelica_Lexer.g:329:6: ( '$Code' )
5789 // BaseModelica_Lexer.g:329:8: '$Code'
5790 {
5791 MATCHS(lit_71)ctx->pLexer->matchs(ctx->pLexer, lit_71);
5792 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5793 {
5794 goto ruleCODEEx;
5795 }
5796
5797
5798
5799 }
5800
5801 LEXSTATEctx->pLexer->rec->state->type = _type;
5802
5803 // This is where rules clean up and exit
5804 //
5805 goto ruleCODEEx; /* Prevent compiler warnings */
5806 ruleCODEEx: ;
5807
5808}
5809// $ANTLR end CODE
5810
5811// Comes from: 330:11: ( '$TypeName' )
5812/** \brief Lexer rule generated by ANTLR3
5813 *
5814 * $ANTLR start CODE_NAME
5815 *
5816 * Looks to match the characters the constitute the token CODE_NAME
5817 * from the attached input stream.
5818 *
5819 *
5820 * \remark
5821 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5822 */
5823static ANTLR3_INLINE__inline__
5824void mCODE_NAME(pParModelica_Lexer_BaseModelica_Lexer ctx)
5825{
5826 ANTLR3_UINT32 _type;
5827
5828 _type = CODE_NAME11;
5829
5830
5831 // BaseModelica_Lexer.g:330:11: ( '$TypeName' )
5832 // BaseModelica_Lexer.g:330:13: '$TypeName'
5833 {
5834 MATCHS(lit_72)ctx->pLexer->matchs(ctx->pLexer, lit_72);
5835 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5836 {
5837 goto ruleCODE_NAMEEx;
5838 }
5839
5840
5841
5842 }
5843
5844 LEXSTATEctx->pLexer->rec->state->type = _type;
5845
5846 // This is where rules clean up and exit
5847 //
5848 goto ruleCODE_NAMEEx; /* Prevent compiler warnings */
5849 ruleCODE_NAMEEx: ;
5850
5851}
5852// $ANTLR end CODE_NAME
5853
5854// Comes from: 331:10: ( '$Exp' )
5855/** \brief Lexer rule generated by ANTLR3
5856 *
5857 * $ANTLR start CODE_EXP
5858 *
5859 * Looks to match the characters the constitute the token CODE_EXP
5860 * from the attached input stream.
5861 *
5862 *
5863 * \remark
5864 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5865 */
5866static ANTLR3_INLINE__inline__
5867void mCODE_EXP(pParModelica_Lexer_BaseModelica_Lexer ctx)
5868{
5869 ANTLR3_UINT32 _type;
5870
5871 _type = CODE_EXP10;
5872
5873
5874 // BaseModelica_Lexer.g:331:10: ( '$Exp' )
5875 // BaseModelica_Lexer.g:331:12: '$Exp'
5876 {
5877 MATCHS(lit_73)ctx->pLexer->matchs(ctx->pLexer, lit_73);
5878 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5879 {
5880 goto ruleCODE_EXPEx;
5881 }
5882
5883
5884
5885 }
5886
5887 LEXSTATEctx->pLexer->rec->state->type = _type;
5888
5889 // This is where rules clean up and exit
5890 //
5891 goto ruleCODE_EXPEx; /* Prevent compiler warnings */
5892 ruleCODE_EXPEx: ;
5893
5894}
5895// $ANTLR end CODE_EXP
5896
5897// Comes from: 332:17: ( '$annotation' )
5898/** \brief Lexer rule generated by ANTLR3
5899 *
5900 * $ANTLR start CODE_ANNOTATION
5901 *
5902 * Looks to match the characters the constitute the token CODE_ANNOTATION
5903 * from the attached input stream.
5904 *
5905 *
5906 * \remark
5907 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5908 */
5909static ANTLR3_INLINE__inline__
5910void mCODE_ANNOTATION(pParModelica_Lexer_BaseModelica_Lexer ctx)
5911{
5912 ANTLR3_UINT32 _type;
5913
5914 _type = CODE_ANNOTATION130;
5915
5916
5917 // BaseModelica_Lexer.g:332:17: ( '$annotation' )
5918 // BaseModelica_Lexer.g:332:19: '$annotation'
5919 {
5920 MATCHS(lit_74)ctx->pLexer->matchs(ctx->pLexer, lit_74);
5921 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5922 {
5923 goto ruleCODE_ANNOTATIONEx;
5924 }
5925
5926
5927
5928 }
5929
5930 LEXSTATEctx->pLexer->rec->state->type = _type;
5931
5932 // This is where rules clean up and exit
5933 //
5934 goto ruleCODE_ANNOTATIONEx; /* Prevent compiler warnings */
5935 ruleCODE_ANNOTATIONEx: ;
5936
5937}
5938// $ANTLR end CODE_ANNOTATION
5939
5940// Comes from: 333:10: ( '$Var' )
5941/** \brief Lexer rule generated by ANTLR3
5942 *
5943 * $ANTLR start CODE_VAR
5944 *
5945 * Looks to match the characters the constitute the token CODE_VAR
5946 * from the attached input stream.
5947 *
5948 *
5949 * \remark
5950 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5951 */
5952static ANTLR3_INLINE__inline__
5953void mCODE_VAR(pParModelica_Lexer_BaseModelica_Lexer ctx)
5954{
5955 ANTLR3_UINT32 _type;
5956
5957 _type = CODE_VAR12;
5958
5959
5960 // BaseModelica_Lexer.g:333:10: ( '$Var' )
5961 // BaseModelica_Lexer.g:333:12: '$Var'
5962 {
5963 MATCHS(lit_75)ctx->pLexer->matchs(ctx->pLexer, lit_75);
5964 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
5965 {
5966 goto ruleCODE_VAREx;
5967 }
5968
5969
5970
5971 }
5972
5973 LEXSTATEctx->pLexer->rec->state->type = _type;
5974
5975 // This is where rules clean up and exit
5976 //
5977 goto ruleCODE_VAREx; /* Prevent compiler warnings */
5978 ruleCODE_VAREx: ;
5979
5980}
5981// $ANTLR end CODE_VAR
5982
5983// Comes from: 335:8: ( '\"' STRING_GUTS '\"' )
5984/** \brief Lexer rule generated by ANTLR3
5985 *
5986 * $ANTLR start STRING
5987 *
5988 * Looks to match the characters the constitute the token STRING
5989 * from the attached input stream.
5990 *
5991 *
5992 * \remark
5993 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
5994 */
5995static ANTLR3_INLINE__inline__
5996void mSTRING(pParModelica_Lexer_BaseModelica_Lexer ctx)
5997{
5998 ANTLR3_UINT32 _type;
5999 pANTLR3_COMMON_TOKEN STRING_GUTS1;
6000
6001
6002 STRING_GUTS1 = NULL((void*)0);
6003
6004 _type = STRING132;
6005
6006
6007 // BaseModelica_Lexer.g:335:8: ( '\"' STRING_GUTS '\"' )
6008 // BaseModelica_Lexer.g:335:10: '\"' STRING_GUTS '\"'
6009 {
6010 MATCHC('"')ctx->pLexer->matchc(ctx->pLexer, '"');
6011 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6012 {
6013 goto ruleSTRINGEx;
6014 }
6015
6016 /* 335:10: '\"' STRING_GUTS '\"' */
6017 {
6018 ANTLR3_MARKER STRING_GUTS1Start1180 = GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer);
6019 mSTRING_GUTS(ctx );
6020 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6021 {
6022 goto ruleSTRINGEx;
6023 }
6024
6025 STRING_GUTS1 = LEXSTATEctx->pLexer->rec->state->tokFactory->newToken(LEXSTATEctx->pLexer->rec->state->tokFactory);
6026 STRING_GUTS1->setType(STRING_GUTS1, ANTLR3_TOKEN_INVALID0);
6027 STRING_GUTS1->setStartIndex(STRING_GUTS1, STRING_GUTS1Start1180);
6028 STRING_GUTS1->setStopIndex(STRING_GUTS1, GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer)-1);
6029 STRING_GUTS1->input = INPUTctx->pLexer->input;
6030 }
6031 MATCHC('"')ctx->pLexer->matchc(ctx->pLexer, '"');
6032 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6033 {
6034 goto ruleSTRINGEx;
6035 }
6036
6037 {
6038
6039 pANTLR3_STRING text = (STRING_GUTS1->getText(STRING_GUTS1));
6040 char *res = 0;
6041 if (*text->chars) {
6042 res = (char*) SystemImpl__iconv((const char*)text->chars,ModelicaParser_encoding((parser_members*)pthread_getspecific(modelicaParserKey))->
encoding
,"UTF-8",0);
6043 if (!*res) {
6044 const char *strs[2];
6045 signed char buf[76];
6046 int len, i;
6047 res = (char*) SystemImpl__iconv__ascii((const char*)text->chars);
6048 len = strlen((const char*)res);
6049 /* Avoid printing huge strings */
6050 if (len > 75) {
6051 len = 72;
6052 buf[len+0] = '.';
6053 buf[len+1] = '.';
6054 buf[len+2] = '.';
6055 buf[len+3] = '\0';
6056 } else {
6057 buf[len] = '\0';
6058 }
6059 for (i=0;i<len;i++) {
6060 /* Don't break lines in the printed error-message */
6061 if (res[i] == '\n' || res[i] == '\r') {
6062 buf[i] = ' ';
6063 } else {
6064 buf[i] = res[i];
6065 }
6066 }
6067 strs[0] = (const char*) buf;
6068 strs[1] = ModelicaParser_encoding((parser_members*)pthread_getspecific(modelicaParserKey))->
encoding
;
6069 c_add_source_message(NULL((void*)0),2, ErrorType_syntax, ErrorLevel_warning, "The file was not encoded in %s:\n \"%s\".\n"
6070 " Defaulting to 7-bit ASCII with unknown characters replaced by '?'.\n"
6071 " To change encoding when loading a file: loadFile(encoding=\"ISO-XXXX-YY\").\n"
6072 " To change it in a package: add a file package.encoding at the top-level.\n"
6073 " Note: The Modelica Language Specification only allows files encoded in UTF-8.",
6074 strs, 2, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+1, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+len+1,
6075 ModelicaParser_readonly((parser_members*)pthread_getspecific(modelicaParserKey))->
readonly
, ModelicaParser_filename_C_testsuiteFriendly((parser_members*)pthread_getspecific(modelicaParserKey))->
filename_C_testsuiteFriendly
);
6076 text->set8(text,res);
6077 /* ModelicaParser_lexerError = ANTLR3_TRUE; */
6078 } else if (strcmp(ModelicaParser_encoding((parser_members*)pthread_getspecific(modelicaParserKey))->
encoding
,"UTF-8")!=0) {
6079 text->set8(text,res);
6080 }
6081 }
6082 SETTEXT(text)ctx->pLexer->rec->state->text = text;
6083
6084 }
6085
6086 }
6087
6088 LEXSTATEctx->pLexer->rec->state->type = _type;
6089
6090 // This is where rules clean up and exit
6091 //
6092 goto ruleSTRINGEx; /* Prevent compiler warnings */
6093 ruleSTRINGEx: ;
6094
6095 STRING_GUTS1 = NULL((void*)0);
6096
6097}
6098// $ANTLR end STRING
6099
6100// Comes from: 384:12: ( ( SCHAR | SESCAPE )* )
6101/** \brief Lexer rule generated by ANTLR3
6102 *
6103 * $ANTLR start STRING_GUTS
6104 *
6105 * Looks to match the characters the constitute the token STRING_GUTS
6106 * from the attached input stream.
6107 *
6108 *
6109 * \remark
6110 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
6111 */
6112static ANTLR3_INLINE__inline__
6113void mSTRING_GUTS(pParModelica_Lexer_BaseModelica_Lexer ctx)
6114{
6115 ANTLR3_UINT32 _type;
6116
6117
6118 // BaseModelica_Lexer.g:384:12: ( ( SCHAR | SESCAPE )* )
6119 // BaseModelica_Lexer.g:384:14: ( SCHAR | SESCAPE )*
6120 {
6121
6122 // BaseModelica_Lexer.g:384:14: ( SCHAR | SESCAPE )*
6123
6124 for (;;)
6125 {
6126 int alt9=3;
6127 {
6128 /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)
6129 */
6130 int LA9_0 = LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
;
6131 if ( (((LA9_0 >= 0x0000) && (LA9_0 <= '!')) || ((LA9_0 >= '#') && (LA9_0 <= '[')) || ((LA9_0 >= ']') && (LA9_0 <= 0xFFFF))) )
6132 {
6133 alt9=1;
6134 }
6135 else if ( (LA9_0 == '\\') )
6136 {
6137 alt9=2;
6138 }
6139
6140 }
6141 switch (alt9)
6142 {
6143 case 1:
6144 // BaseModelica_Lexer.g:384:15: SCHAR
6145 {
6146 /* 384:15: SCHAR */
6147 mSCHAR(ctx );
6148 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6149 {
6150 goto ruleSTRING_GUTSEx;
6151 }
6152
6153
6154 }
6155 break;
6156 case 2:
6157 // BaseModelica_Lexer.g:384:23: SESCAPE
6158 {
6159 /* 384:23: SESCAPE */
6160 mSESCAPE(ctx );
6161 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6162 {
6163 goto ruleSTRING_GUTSEx;
6164 }
6165
6166
6167 }
6168 break;
6169
6170 default:
6171 goto loop9; /* break out of the loop */
6172 break;
6173 }
6174 }
6175 loop9: ; /* Jump out to here if this rule does not match */
6176
6177
6178 }
6179
6180
6181
6182 // This is where rules clean up and exit
6183 //
6184 goto ruleSTRING_GUTSEx; /* Prevent compiler warnings */
6185 ruleSTRING_GUTSEx: ;
6186
6187}
6188// $ANTLR end STRING_GUTS
6189
6190// Comes from: 388:7: ( NL | ~ ( '\\r' | '\\n' | '\\\\' | '\"' ) )
6191/** \brief Lexer rule generated by ANTLR3
6192 *
6193 * $ANTLR start SCHAR
6194 *
6195 * Looks to match the characters the constitute the token SCHAR
6196 * from the attached input stream.
6197 *
6198 *
6199 * \remark
6200 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
6201 */
6202static ANTLR3_INLINE__inline__
6203void mSCHAR(pParModelica_Lexer_BaseModelica_Lexer ctx)
6204{
6205 ANTLR3_UINT32 _type;
6206
6207
6208 {
6209 // BaseModelica_Lexer.g:388:7: ( NL | ~ ( '\\r' | '\\n' | '\\\\' | '\"' ) )
6210
6211 ANTLR3_UINT32 alt10;
6212
6213 alt10=2;
6214
6215
6216 {
6217 int LA10_0 = LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
;
6218 if ( (LA10_0 == '\n' || LA10_0 == '\r') )
6219 {
6220 alt10=1;
6221 }
6222 else if ( (((LA10_0 >= 0x0000) && (LA10_0 <= '\t')) || ((LA10_0 >= 0x000B) && (LA10_0 <= '\f')) || ((LA10_0 >= 0x000E) && (LA10_0 <= '!')) || ((LA10_0 >= '#') && (LA10_0 <= '[')) || ((LA10_0 >= ']') && (LA10_0 <= 0xFFFF))) )
6223 {
6224 alt10=2;
6225 }
6226 else
6227 {
6228
6229 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
6230 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
6231 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
6232 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 10;
6233 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
6234
6235
6236 goto ruleSCHAREx;
6237 }
6238 }
6239 switch (alt10)
6240 {
6241 case 1:
6242 // BaseModelica_Lexer.g:388:9: NL
6243 {
6244 /* 388:9: NL */
6245 mNL(ctx );
6246 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6247 {
6248 goto ruleSCHAREx;
6249 }
6250
6251
6252 }
6253 break;
6254 case 2:
6255 // BaseModelica_Lexer.g:388:14: ~ ( '\\r' | '\\n' | '\\\\' | '\"' )
6256 {
6257 if ( ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 0x0000) && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '\t')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 0x000B) && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '\f')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 0x000E) && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '!')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= '#') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '[')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= ']') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 0xFFFF)) )
6258 {
6259 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
6260
6261 }
6262 else
6263 {
6264 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
6265 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
6266 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
6267
6268 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleSCHAREx;
6269 }
6270
6271
6272 }
6273 break;
6274
6275 }
6276 }
6277
6278
6279 // This is where rules clean up and exit
6280 //
6281 goto ruleSCHAREx; /* Prevent compiler warnings */
6282 ruleSCHAREx: ;
6283
6284}
6285// $ANTLR end SCHAR
6286
6287// Comes from: 391:9: (esc= '\\\\' ( '\\\\' | '\"' | '\\'' | '?' | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' | ) )
6288/** \brief Lexer rule generated by ANTLR3
6289 *
6290 * $ANTLR start SESCAPE
6291 *
6292 * Looks to match the characters the constitute the token SESCAPE
6293 * from the attached input stream.
6294 *
6295 *
6296 * \remark
6297 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
6298 */
6299static ANTLR3_INLINE__inline__
6300void mSESCAPE(pParModelica_Lexer_BaseModelica_Lexer ctx)
6301{
6302 ANTLR3_UINT32 _type;
6303 ANTLR3_UINT32 esc;
6304
6305
6306
6307 // BaseModelica_Lexer.g:391:9: (esc= '\\\\' ( '\\\\' | '\"' | '\\'' | '?' | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' | ) )
6308 // BaseModelica_Lexer.g:391:11: esc= '\\\\' ( '\\\\' | '\"' | '\\'' | '?' | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' | )
6309 {
6310 esc = LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
;
6311 MATCHC('\\')ctx->pLexer->matchc(ctx->pLexer, '\\');
6312 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6313 {
6314 goto ruleSESCAPEEx;
6315 }
6316
6317
6318 // BaseModelica_Lexer.g:391:20: ( '\\\\' | '\"' | '\\'' | '?' | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' | )
6319 {
6320 int alt11=12;
6321 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
6322 {
6323 case '\\':
6324 {
6325 alt11=1;
6326 }
6327 break;
6328 case '"':
6329 {
6330 alt11=2;
6331 }
6332 break;
6333 case '\'':
6334 {
6335 alt11=3;
6336 }
6337 break;
6338 case '?':
6339 {
6340 alt11=4;
6341 }
6342 break;
6343 case 'a':
6344 {
6345 alt11=5;
6346 }
6347 break;
6348 case 'b':
6349 {
6350 alt11=6;
6351 }
6352 break;
6353 case 'f':
6354 {
6355 alt11=7;
6356 }
6357 break;
6358 case 'n':
6359 {
6360 alt11=8;
6361 }
6362 break;
6363 case 'r':
6364 {
6365 alt11=9;
6366 }
6367 break;
6368 case 't':
6369 {
6370 alt11=10;
6371 }
6372 break;
6373 case 'v':
6374 {
6375 alt11=11;
6376 }
6377 break;
6378
6379 default:
6380 alt11=12;}
6381
6382 switch (alt11)
6383 {
6384 case 1:
6385 // BaseModelica_Lexer.g:391:21: '\\\\'
6386 {
6387 MATCHC('\\')ctx->pLexer->matchc(ctx->pLexer, '\\');
6388 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6389 {
6390 goto ruleSESCAPEEx;
6391 }
6392
6393
6394 }
6395 break;
6396 case 2:
6397 // BaseModelica_Lexer.g:391:28: '\"'
6398 {
6399 MATCHC('"')ctx->pLexer->matchc(ctx->pLexer, '"');
6400 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6401 {
6402 goto ruleSESCAPEEx;
6403 }
6404
6405
6406 }
6407 break;
6408 case 3:
6409 // BaseModelica_Lexer.g:391:34: '\\''
6410 {
6411 MATCHC('\'')ctx->pLexer->matchc(ctx->pLexer, '\'');
6412 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6413 {
6414 goto ruleSESCAPEEx;
6415 }
6416
6417
6418 }
6419 break;
6420 case 4:
6421 // BaseModelica_Lexer.g:391:41: '?'
6422 {
6423 MATCHC('?')ctx->pLexer->matchc(ctx->pLexer, '?');
6424 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6425 {
6426 goto ruleSESCAPEEx;
6427 }
6428
6429
6430 }
6431 break;
6432 case 5:
6433 // BaseModelica_Lexer.g:391:47: 'a'
6434 {
6435 MATCHC('a')ctx->pLexer->matchc(ctx->pLexer, 'a');
6436 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6437 {
6438 goto ruleSESCAPEEx;
6439 }
6440
6441
6442 }
6443 break;
6444 case 6:
6445 // BaseModelica_Lexer.g:391:53: 'b'
6446 {
6447 MATCHC('b')ctx->pLexer->matchc(ctx->pLexer, 'b');
6448 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6449 {
6450 goto ruleSESCAPEEx;
6451 }
6452
6453
6454 }
6455 break;
6456 case 7:
6457 // BaseModelica_Lexer.g:391:59: 'f'
6458 {
6459 MATCHC('f')ctx->pLexer->matchc(ctx->pLexer, 'f');
6460 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6461 {
6462 goto ruleSESCAPEEx;
6463 }
6464
6465
6466 }
6467 break;
6468 case 8:
6469 // BaseModelica_Lexer.g:391:65: 'n'
6470 {
6471 MATCHC('n')ctx->pLexer->matchc(ctx->pLexer, 'n');
6472 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6473 {
6474 goto ruleSESCAPEEx;
6475 }
6476
6477
6478 }
6479 break;
6480 case 9:
6481 // BaseModelica_Lexer.g:391:71: 'r'
6482 {
6483 MATCHC('r')ctx->pLexer->matchc(ctx->pLexer, 'r');
6484 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6485 {
6486 goto ruleSESCAPEEx;
6487 }
6488
6489
6490 }
6491 break;
6492 case 10:
6493 // BaseModelica_Lexer.g:391:77: 't'
6494 {
6495 MATCHC('t')ctx->pLexer->matchc(ctx->pLexer, 't');
6496 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6497 {
6498 goto ruleSESCAPEEx;
6499 }
6500
6501
6502 }
6503 break;
6504 case 11:
6505 // BaseModelica_Lexer.g:391:83: 'v'
6506 {
6507 MATCHC('v')ctx->pLexer->matchc(ctx->pLexer, 'v');
6508 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6509 {
6510 goto ruleSESCAPEEx;
6511 }
6512
6513
6514 }
6515 break;
6516 case 12:
6517 // BaseModelica_Lexer.g:392:3:
6518 {
6519 {
6520
6521 char chars[2] = {LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
,'\0'};
6522 const char *str = chars;
6523 int len = strlen((char*)LEXERctx->pLexer->getText(LEXERctx->pLexer)->chars);
6524 c_add_source_message(NULL((void*)0),2, ErrorType_syntax, ErrorLevel_warning, "Lexer treating \\ as \\\\, since \\%s is not a valid Modelica escape sequence.",
6525 &str, 1, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+1, LEXSTATEctx->pLexer->rec->state->tokenStartLine, LEXSTATEctx->pLexer->rec->state->tokenStartCharPositionInLine+len+1,
6526 ModelicaParser_readonly((parser_members*)pthread_getspecific(modelicaParserKey))->
readonly
, ModelicaParser_filename_C_testsuiteFriendly((parser_members*)pthread_getspecific(modelicaParserKey))->
filename_C_testsuiteFriendly
);
6527
6528 }
6529
6530 }
6531 break;
6532
6533 }
6534 }
6535
6536 }
6537
6538
6539
6540 // This is where rules clean up and exit
6541 //
6542 goto ruleSESCAPEEx; /* Prevent compiler warnings */
6543 ruleSESCAPEEx: ;
6544
6545}
6546// $ANTLR end SESCAPE
6547
6548// Comes from: 402:16: ( ( WS )+ )
6549/** \brief Lexer rule generated by ANTLR3
6550 *
6551 * $ANTLR start EAT_WS_COMMENT
6552 *
6553 * Looks to match the characters the constitute the token EAT_WS_COMMENT
6554 * from the attached input stream.
6555 *
6556 *
6557 * \remark
6558 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
6559 */
6560static ANTLR3_INLINE__inline__
6561void mEAT_WS_COMMENT(pParModelica_Lexer_BaseModelica_Lexer ctx)
6562{
6563 ANTLR3_UINT32 _type;
6564
6565
6566 // BaseModelica_Lexer.g:402:16: ( ( WS )+ )
6567 // BaseModelica_Lexer.g:402:18: ( WS )+
6568 {
6569 // BaseModelica_Lexer.g:402:18: ( WS )+
6570 {
6571 int cnt12=0;
6572
6573 for (;;)
6574 {
6575 int alt12=2;
6576 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
6577 {
6578 case '\t':
6579 case '\n':
6580 case '\r':
6581 case ' ':
6582 {
6583 alt12=1;
6584 }
6585 break;
6586
6587 }
6588
6589 switch (alt12)
6590 {
6591 case 1:
6592 // BaseModelica_Lexer.g:402:19: WS
6593 {
6594 /* 402:19: WS */
6595 mWS(ctx );
6596 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6597 {
6598 goto ruleEAT_WS_COMMENTEx;
6599 }
6600
6601
6602 }
6603 break;
6604
6605 default:
6606
6607 if ( cnt12 >= 1 )
6608 {
6609 goto loop12;
6610 }
6611 /* mismatchedSetEx()
6612 */
6613 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
6614 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_EARLY_EXIT_EXCEPTION5;
6615 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_EARLY_EXIT_NAME"Early exit";
6616
6617
6618 goto ruleEAT_WS_COMMENTEx;
6619 }
6620 cnt12++;
6621 }
6622 loop12: ; /* Jump to here if this rule does not match */
6623 }
6624 {
6625 LEXSTATEctx->pLexer->rec->state->channel=ANTLR3_TOKEN_DEFAULT_CHANNEL0;
6626 }
6627
6628 }
6629
6630
6631
6632 // This is where rules clean up and exit
6633 //
6634 goto ruleEAT_WS_COMMENTEx; /* Prevent compiler warnings */
6635 ruleEAT_WS_COMMENTEx: ;
6636
6637}
6638// $ANTLR end EAT_WS_COMMENT
6639
6640// Comes from: 404:8: ( 'end' EAT_WS_COMMENT 'if' )
6641/** \brief Lexer rule generated by ANTLR3
6642 *
6643 * $ANTLR start END_IF
6644 *
6645 * Looks to match the characters the constitute the token END_IF
6646 * from the attached input stream.
6647 *
6648 *
6649 * \remark
6650 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
6651 */
6652static ANTLR3_INLINE__inline__
6653void mEND_IF(pParModelica_Lexer_BaseModelica_Lexer ctx)
6654{
6655 ANTLR3_UINT32 _type;
6656
6657 _type = END_IF27;
6658
6659
6660 // BaseModelica_Lexer.g:404:8: ( 'end' EAT_WS_COMMENT 'if' )
6661 // BaseModelica_Lexer.g:404:10: 'end' EAT_WS_COMMENT 'if'
6662 {
6663 MATCHS(lit_76)ctx->pLexer->matchs(ctx->pLexer, lit_76);
6664 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6665 {
6666 goto ruleEND_IFEx;
6667 }
6668
6669
6670 /* 404:10: 'end' EAT_WS_COMMENT 'if' */
6671 mEAT_WS_COMMENT(ctx );
6672 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6673 {
6674 goto ruleEND_IFEx;
6675 }
6676
6677 MATCHS(lit_29)ctx->pLexer->matchs(ctx->pLexer, lit_29);
6678 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6679 {
6680 goto ruleEND_IFEx;
6681 }
6682
6683
6684
6685 }
6686
6687 LEXSTATEctx->pLexer->rec->state->type = _type;
6688
6689 // This is where rules clean up and exit
6690 //
6691 goto ruleEND_IFEx; /* Prevent compiler warnings */
6692 ruleEND_IFEx: ;
6693
6694}
6695// $ANTLR end END_IF
6696
6697// Comes from: 405:9: ( 'end' EAT_WS_COMMENT 'for' )
6698/** \brief Lexer rule generated by ANTLR3
6699 *
6700 * $ANTLR start END_FOR
6701 *
6702 * Looks to match the characters the constitute the token END_FOR
6703 * from the attached input stream.
6704 *
6705 *
6706 * \remark
6707 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
6708 */
6709static ANTLR3_INLINE__inline__
6710void mEND_FOR(pParModelica_Lexer_BaseModelica_Lexer ctx)
6711{
6712 ANTLR3_UINT32 _type;
6713
6714 _type = END_FOR25;
6715
6716
6717 // BaseModelica_Lexer.g:405:9: ( 'end' EAT_WS_COMMENT 'for' )
6718 // BaseModelica_Lexer.g:405:11: 'end' EAT_WS_COMMENT 'for'
6719 {
6720 MATCHS(lit_76)ctx->pLexer->matchs(ctx->pLexer, lit_76);
6721 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6722 {
6723 goto ruleEND_FOREx;
6724 }
6725
6726
6727 /* 405:11: 'end' EAT_WS_COMMENT 'for' */
6728 mEAT_WS_COMMENT(ctx );
6729 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6730 {
6731 goto ruleEND_FOREx;
6732 }
6733
6734 MATCHS(lit_27)ctx->pLexer->matchs(ctx->pLexer, lit_27);
6735 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6736 {
6737 goto ruleEND_FOREx;
6738 }
6739
6740
6741
6742 }
6743
6744 LEXSTATEctx->pLexer->rec->state->type = _type;
6745
6746 // This is where rules clean up and exit
6747 //
6748 goto ruleEND_FOREx; /* Prevent compiler warnings */
6749 ruleEND_FOREx: ;
6750
6751}
6752// $ANTLR end END_FOR
6753
6754// Comes from: 406:10: ( 'end' EAT_WS_COMMENT 'when' )
6755/** \brief Lexer rule generated by ANTLR3
6756 *
6757 * $ANTLR start END_WHEN
6758 *
6759 * Looks to match the characters the constitute the token END_WHEN
6760 * from the attached input stream.
6761 *
6762 *
6763 * \remark
6764 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
6765 */
6766static ANTLR3_INLINE__inline__
6767void mEND_WHEN(pParModelica_Lexer_BaseModelica_Lexer ctx)
6768{
6769 ANTLR3_UINT32 _type;
6770
6771 _type = END_WHEN30;
6772
6773
6774 // BaseModelica_Lexer.g:406:10: ( 'end' EAT_WS_COMMENT 'when' )
6775 // BaseModelica_Lexer.g:406:12: 'end' EAT_WS_COMMENT 'when'
6776 {
6777 MATCHS(lit_76)ctx->pLexer->matchs(ctx->pLexer, lit_76);
6778 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6779 {
6780 goto ruleEND_WHENEx;
6781 }
6782
6783
6784 /* 406:12: 'end' EAT_WS_COMMENT 'when' */
6785 mEAT_WS_COMMENT(ctx );
6786 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6787 {
6788 goto ruleEND_WHENEx;
6789 }
6790
6791 MATCHS(lit_56)ctx->pLexer->matchs(ctx->pLexer, lit_56);
6792 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6793 {
6794 goto ruleEND_WHENEx;
6795 }
6796
6797
6798
6799 }
6800
6801 LEXSTATEctx->pLexer->rec->state->type = _type;
6802
6803 // This is where rules clean up and exit
6804 //
6805 goto ruleEND_WHENEx; /* Prevent compiler warnings */
6806 ruleEND_WHENEx: ;
6807
6808}
6809// $ANTLR end END_WHEN
6810
6811// Comes from: 407:11: ( 'end' EAT_WS_COMMENT 'while' )
6812/** \brief Lexer rule generated by ANTLR3
6813 *
6814 * $ANTLR start END_WHILE
6815 *
6816 * Looks to match the characters the constitute the token END_WHILE
6817 * from the attached input stream.
6818 *
6819 *
6820 * \remark
6821 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
6822 */
6823static ANTLR3_INLINE__inline__
6824void mEND_WHILE(pParModelica_Lexer_BaseModelica_Lexer ctx)
6825{
6826 ANTLR3_UINT32 _type;
6827
6828 _type = END_WHILE31;
6829
6830
6831 // BaseModelica_Lexer.g:407:11: ( 'end' EAT_WS_COMMENT 'while' )
6832 // BaseModelica_Lexer.g:407:13: 'end' EAT_WS_COMMENT 'while'
6833 {
6834 MATCHS(lit_76)ctx->pLexer->matchs(ctx->pLexer, lit_76);
6835 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6836 {
6837 goto ruleEND_WHILEEx;
6838 }
6839
6840
6841 /* 407:13: 'end' EAT_WS_COMMENT 'while' */
6842 mEAT_WS_COMMENT(ctx );
6843 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6844 {
6845 goto ruleEND_WHILEEx;
6846 }
6847
6848 MATCHS(lit_57)ctx->pLexer->matchs(ctx->pLexer, lit_57);
6849 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6850 {
6851 goto ruleEND_WHILEEx;
6852 }
6853
6854
6855
6856 }
6857
6858 LEXSTATEctx->pLexer->rec->state->type = _type;
6859
6860 // This is where rules clean up and exit
6861 //
6862 goto ruleEND_WHILEEx; /* Prevent compiler warnings */
6863 ruleEND_WHILEEx: ;
6864
6865}
6866// $ANTLR end END_WHILE
6867
6868// Comes from: 408:11: ( 'end' EAT_WS_COMMENT ( IDENT2 | QIDENT | CODE ) )
6869/** \brief Lexer rule generated by ANTLR3
6870 *
6871 * $ANTLR start END_IDENT
6872 *
6873 * Looks to match the characters the constitute the token END_IDENT
6874 * from the attached input stream.
6875 *
6876 *
6877 * \remark
6878 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
6879 */
6880static ANTLR3_INLINE__inline__
6881void mEND_IDENT(pParModelica_Lexer_BaseModelica_Lexer ctx)
6882{
6883 ANTLR3_UINT32 _type;
6884 pANTLR3_COMMON_TOKEN IDENT22;
6885 pANTLR3_COMMON_TOKEN QIDENT3;
6886 pANTLR3_COMMON_TOKEN CODE4;
6887
6888
6889 IDENT22 = NULL((void*)0);
6890 QIDENT3 = NULL((void*)0);
6891 CODE4 = NULL((void*)0);
6892
6893 _type = END_IDENT26;
6894
6895
6896 // BaseModelica_Lexer.g:408:11: ( 'end' EAT_WS_COMMENT ( IDENT2 | QIDENT | CODE ) )
6897 // BaseModelica_Lexer.g:408:13: 'end' EAT_WS_COMMENT ( IDENT2 | QIDENT | CODE )
6898 {
6899 MATCHS(lit_76)ctx->pLexer->matchs(ctx->pLexer, lit_76);
6900 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6901 {
6902 goto ruleEND_IDENTEx;
6903 }
6904
6905
6906 /* 408:13: 'end' EAT_WS_COMMENT ( IDENT2 | QIDENT | CODE ) */
6907 mEAT_WS_COMMENT(ctx );
6908 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
6909 {
6910 goto ruleEND_IDENTEx;
6911 }
6912
6913
6914 // BaseModelica_Lexer.g:409:5: ( IDENT2 | QIDENT | CODE )
6915 {
6916 int alt13=3;
6917 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
6918 {
6919 case 'A':
6920 case 'B':
6921 case 'C':
6922 case 'D':
6923 case 'E':
6924 case 'F':
6925 case 'G':
6926 case 'H':
6927 case 'I':
6928 case 'J':
6929 case 'K':
6930 case 'L':
6931 case 'M':
6932 case 'N':
6933 case 'O':
6934 case 'P':
6935 case 'Q':
6936 case 'R':
6937 case 'S':
6938 case 'T':
6939 case 'U':
6940 case 'V':
6941 case 'W':
6942 case 'X':
6943 case 'Y':
6944 case 'Z':
6945 case '_':
6946 case 'a':
6947 case 'b':
6948 case 'c':
6949 case 'd':
6950 case 'e':
6951 case 'f':
6952 case 'g':
6953 case 'h':
6954 case 'i':
6955 case 'j':
6956 case 'k':
6957 case 'l':
6958 case 'm':
6959 case 'n':
6960 case 'o':
6961 case 'p':
6962 case 'q':
6963 case 'r':
6964 case 's':
6965 case 't':
6966 case 'u':
6967 case 'v':
6968 case 'w':
6969 case 'x':
6970 case 'y':
6971 case 'z':
6972 {
6973 alt13=1;
6974 }
6975 break;
6976 case '$':
6977 {
6978 switch ( LA(2)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 2)
)
6979 {
6980 case 'c':
6981 {
6982 alt13=1;
6983 }
6984 break;
6985 case 'C':
6986 {
6987 alt13=3;
6988 }
6989 break;
6990
6991 default:
6992 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
6993 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
6994 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
6995 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 13;
6996 EXCEPTIONctx->pLexer->rec->state->exception->state = 2;
6997
6998
6999 goto ruleEND_IDENTEx;
7000 }
7001
7002 }
7003 break;
7004 case '\'':
7005 {
7006 alt13=2;
7007 }
7008 break;
7009
7010 default:
7011 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
7012 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
7013 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
7014 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 13;
7015 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
7016
7017
7018 goto ruleEND_IDENTEx;
7019 }
7020
7021 switch (alt13)
7022 {
7023 case 1:
7024 // BaseModelica_Lexer.g:409:7: IDENT2
7025 {
7026 /* 409:7: IDENT2 */
7027 {
7028 ANTLR3_MARKER IDENT22Start1383 = GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer);
7029 mIDENT2(ctx );
7030 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7031 {
7032 goto ruleEND_IDENTEx;
7033 }
7034
7035 IDENT22 = LEXSTATEctx->pLexer->rec->state->tokFactory->newToken(LEXSTATEctx->pLexer->rec->state->tokFactory);
7036 IDENT22->setType(IDENT22, ANTLR3_TOKEN_INVALID0);
7037 IDENT22->setStartIndex(IDENT22, IDENT22Start1383);
7038 IDENT22->setStopIndex(IDENT22, GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer)-1);
7039 IDENT22->input = INPUTctx->pLexer->input;
7040 }
7041 {
7042 SETTEXT((IDENT22->getText(IDENT22)))ctx->pLexer->rec->state->text = (IDENT22->getText
(IDENT22))
;
7043 }
7044
7045 }
7046 break;
7047 case 2:
7048 // BaseModelica_Lexer.g:410:7: QIDENT
7049 {
7050 /* 410:7: QIDENT */
7051 {
7052 ANTLR3_MARKER QIDENT3Start1393 = GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer);
7053 mQIDENT(ctx );
7054 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7055 {
7056 goto ruleEND_IDENTEx;
7057 }
7058
7059 QIDENT3 = LEXSTATEctx->pLexer->rec->state->tokFactory->newToken(LEXSTATEctx->pLexer->rec->state->tokFactory);
7060 QIDENT3->setType(QIDENT3, ANTLR3_TOKEN_INVALID0);
7061 QIDENT3->setStartIndex(QIDENT3, QIDENT3Start1393);
7062 QIDENT3->setStopIndex(QIDENT3, GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer)-1);
7063 QIDENT3->input = INPUTctx->pLexer->input;
7064 }
7065 {
7066 SETTEXT((QIDENT3->getText(QIDENT3)))ctx->pLexer->rec->state->text = (QIDENT3->getText
(QIDENT3))
;
7067 }
7068
7069 }
7070 break;
7071 case 3:
7072 // BaseModelica_Lexer.g:411:7: CODE
7073 {
7074 /* 411:7: CODE */
7075 {
7076 ANTLR3_MARKER CODE4Start1403 = GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer);
7077 mCODE(ctx );
7078 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7079 {
7080 goto ruleEND_IDENTEx;
7081 }
7082
7083 CODE4 = LEXSTATEctx->pLexer->rec->state->tokFactory->newToken(LEXSTATEctx->pLexer->rec->state->tokFactory);
7084 CODE4->setType(CODE4, ANTLR3_TOKEN_INVALID0);
7085 CODE4->setStartIndex(CODE4, CODE4Start1403);
7086 CODE4->setStopIndex(CODE4, GETCHARINDEX()ctx->pLexer->getCharIndex(ctx->pLexer)-1);
7087 CODE4->input = INPUTctx->pLexer->input;
7088 }
7089 {
7090 SETTEXT((CODE4->getText(CODE4)))ctx->pLexer->rec->state->text = (CODE4->getText
(CODE4))
;
7091 }
7092
7093 }
7094 break;
7095
7096 }
7097 }
7098
7099 }
7100
7101 LEXSTATEctx->pLexer->rec->state->type = _type;
7102
7103 // This is where rules clean up and exit
7104 //
7105 goto ruleEND_IDENTEx; /* Prevent compiler warnings */
7106 ruleEND_IDENTEx: ;
7107
7108 IDENT22 = NULL((void*)0);
7109 QIDENT3 = NULL((void*)0);
7110 CODE4 = NULL((void*)0);
7111
7112}
7113// $ANTLR end END_IDENT
7114
7115// Comes from: 414:7: ( 'end' ( EAT_WS_COMMENT )? )
7116/** \brief Lexer rule generated by ANTLR3
7117 *
7118 * $ANTLR start T_END
7119 *
7120 * Looks to match the characters the constitute the token T_END
7121 * from the attached input stream.
7122 *
7123 *
7124 * \remark
7125 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
7126 */
7127static ANTLR3_INLINE__inline__
7128void mT_END(pParModelica_Lexer_BaseModelica_Lexer ctx)
7129{
7130 ANTLR3_UINT32 _type;
7131
7132 _type = T_END32;
7133
7134
7135 // BaseModelica_Lexer.g:414:7: ( 'end' ( EAT_WS_COMMENT )? )
7136 // BaseModelica_Lexer.g:414:9: 'end' ( EAT_WS_COMMENT )?
7137 {
7138 MATCHS(lit_76)ctx->pLexer->matchs(ctx->pLexer, lit_76);
7139 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7140 {
7141 goto ruleT_ENDEx;
7142 }
7143
7144
7145
7146 // BaseModelica_Lexer.g:414:15: ( EAT_WS_COMMENT )?
7147 {
7148 int alt14=2;
7149 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
7150 {
7151 case '\t':
7152 case '\n':
7153 case '\r':
7154 case ' ':
7155 {
7156 alt14=1;
7157 }
7158 break;
7159 }
7160
7161 switch (alt14)
7162 {
7163 case 1:
7164 // BaseModelica_Lexer.g:414:15: EAT_WS_COMMENT
7165 {
7166 /* 414:15: EAT_WS_COMMENT */
7167 mEAT_WS_COMMENT(ctx );
7168 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7169 {
7170 goto ruleT_ENDEx;
7171 }
7172
7173
7174 }
7175 break;
7176
7177 }
7178 }
7179
7180 }
7181
7182 LEXSTATEctx->pLexer->rec->state->type = _type;
7183
7184 // This is where rules clean up and exit
7185 //
7186 goto ruleT_ENDEx; /* Prevent compiler warnings */
7187 ruleT_ENDEx: ;
7188
7189}
7190// $ANTLR end T_END
7191
7192// Comes from: 416:7: ( QIDENT | IDENT2 )
7193/** \brief Lexer rule generated by ANTLR3
7194 *
7195 * $ANTLR start IDENT
7196 *
7197 * Looks to match the characters the constitute the token IDENT
7198 * from the attached input stream.
7199 *
7200 *
7201 * \remark
7202 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
7203 */
7204static ANTLR3_INLINE__inline__
7205void mIDENT(pParModelica_Lexer_BaseModelica_Lexer ctx)
7206{
7207 ANTLR3_UINT32 _type;
7208
7209 _type = IDENT124;
7210
7211
7212 {
7213 // BaseModelica_Lexer.g:416:7: ( QIDENT | IDENT2 )
7214
7215 ANTLR3_UINT32 alt15;
7216
7217 alt15=2;
7218
7219 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
7220 {
7221 case '\'':
7222 {
7223 alt15=1;
7224 }
7225 break;
7226 case '$':
7227 case 'A':
7228 case 'B':
7229 case 'C':
7230 case 'D':
7231 case 'E':
7232 case 'F':
7233 case 'G':
7234 case 'H':
7235 case 'I':
7236 case 'J':
7237 case 'K':
7238 case 'L':
7239 case 'M':
7240 case 'N':
7241 case 'O':
7242 case 'P':
7243 case 'Q':
7244 case 'R':
7245 case 'S':
7246 case 'T':
7247 case 'U':
7248 case 'V':
7249 case 'W':
7250 case 'X':
7251 case 'Y':
7252 case 'Z':
7253 case '_':
7254 case 'a':
7255 case 'b':
7256 case 'c':
7257 case 'd':
7258 case 'e':
7259 case 'f':
7260 case 'g':
7261 case 'h':
7262 case 'i':
7263 case 'j':
7264 case 'k':
7265 case 'l':
7266 case 'm':
7267 case 'n':
7268 case 'o':
7269 case 'p':
7270 case 'q':
7271 case 'r':
7272 case 's':
7273 case 't':
7274 case 'u':
7275 case 'v':
7276 case 'w':
7277 case 'x':
7278 case 'y':
7279 case 'z':
7280 {
7281 alt15=2;
7282 }
7283 break;
7284
7285 default:
7286 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
7287 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
7288 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
7289 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 15;
7290 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
7291
7292
7293 goto ruleIDENTEx;
7294 }
7295
7296 switch (alt15)
7297 {
7298 case 1:
7299 // BaseModelica_Lexer.g:416:9: QIDENT
7300 {
7301 /* 416:9: QIDENT */
7302 mQIDENT(ctx );
7303 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7304 {
7305 goto ruleIDENTEx;
7306 }
7307
7308
7309 }
7310 break;
7311 case 2:
7312 // BaseModelica_Lexer.g:416:18: IDENT2
7313 {
7314 /* 416:18: IDENT2 */
7315 mIDENT2(ctx );
7316 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7317 {
7318 goto ruleIDENTEx;
7319 }
7320
7321
7322 }
7323 break;
7324
7325 }
7326 }
7327 LEXSTATEctx->pLexer->rec->state->type = _type;
7328
7329 // This is where rules clean up and exit
7330 //
7331 goto ruleIDENTEx; /* Prevent compiler warnings */
7332 ruleIDENTEx: ;
7333
7334}
7335// $ANTLR end IDENT
7336
7337// Comes from: 419:8: ( NONDIGIT ( NONDIGIT | DIGIT )* | '$cpuTime' )
7338/** \brief Lexer rule generated by ANTLR3
7339 *
7340 * $ANTLR start IDENT2
7341 *
7342 * Looks to match the characters the constitute the token IDENT2
7343 * from the attached input stream.
7344 *
7345 *
7346 * \remark
7347 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
7348 */
7349static ANTLR3_INLINE__inline__
7350void mIDENT2(pParModelica_Lexer_BaseModelica_Lexer ctx)
7351{
7352 ANTLR3_UINT32 _type;
7353
7354
7355 {
7356 // BaseModelica_Lexer.g:419:8: ( NONDIGIT ( NONDIGIT | DIGIT )* | '$cpuTime' )
7357
7358 ANTLR3_UINT32 alt17;
7359
7360 alt17=2;
Value stored to 'alt17' is never read
7361
7362 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
7363 {
7364 case 'A':
7365 case 'B':
7366 case 'C':
7367 case 'D':
7368 case 'E':
7369 case 'F':
7370 case 'G':
7371 case 'H':
7372 case 'I':
7373 case 'J':
7374 case 'K':
7375 case 'L':
7376 case 'M':
7377 case 'N':
7378 case 'O':
7379 case 'P':
7380 case 'Q':
7381 case 'R':
7382 case 'S':
7383 case 'T':
7384 case 'U':
7385 case 'V':
7386 case 'W':
7387 case 'X':
7388 case 'Y':
7389 case 'Z':
7390 case '_':
7391 case 'a':
7392 case 'b':
7393 case 'c':
7394 case 'd':
7395 case 'e':
7396 case 'f':
7397 case 'g':
7398 case 'h':
7399 case 'i':
7400 case 'j':
7401 case 'k':
7402 case 'l':
7403 case 'm':
7404 case 'n':
7405 case 'o':
7406 case 'p':
7407 case 'q':
7408 case 'r':
7409 case 's':
7410 case 't':
7411 case 'u':
7412 case 'v':
7413 case 'w':
7414 case 'x':
7415 case 'y':
7416 case 'z':
7417 {
7418 alt17=1;
7419 }
7420 break;
7421 case '$':
7422 {
7423 alt17=2;
7424 }
7425 break;
7426
7427 default:
7428 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
7429 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
7430 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
7431 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 17;
7432 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
7433
7434
7435 goto ruleIDENT2Ex;
7436 }
7437
7438 switch (alt17)
7439 {
7440 case 1:
7441 // BaseModelica_Lexer.g:419:10: NONDIGIT ( NONDIGIT | DIGIT )*
7442 {
7443 /* 419:10: NONDIGIT ( NONDIGIT | DIGIT )* */
7444 mNONDIGIT(ctx );
7445 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7446 {
7447 goto ruleIDENT2Ex;
7448 }
7449
7450
7451 // BaseModelica_Lexer.g:419:19: ( NONDIGIT | DIGIT )*
7452
7453 for (;;)
7454 {
7455 int alt16=2;
7456 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
7457 {
7458 case '0':
7459 case '1':
7460 case '2':
7461 case '3':
7462 case '4':
7463 case '5':
7464 case '6':
7465 case '7':
7466 case '8':
7467 case '9':
7468 case 'A':
7469 case 'B':
7470 case 'C':
7471 case 'D':
7472 case 'E':
7473 case 'F':
7474 case 'G':
7475 case 'H':
7476 case 'I':
7477 case 'J':
7478 case 'K':
7479 case 'L':
7480 case 'M':
7481 case 'N':
7482 case 'O':
7483 case 'P':
7484 case 'Q':
7485 case 'R':
7486 case 'S':
7487 case 'T':
7488 case 'U':
7489 case 'V':
7490 case 'W':
7491 case 'X':
7492 case 'Y':
7493 case 'Z':
7494 case '_':
7495 case 'a':
7496 case 'b':
7497 case 'c':
7498 case 'd':
7499 case 'e':
7500 case 'f':
7501 case 'g':
7502 case 'h':
7503 case 'i':
7504 case 'j':
7505 case 'k':
7506 case 'l':
7507 case 'm':
7508 case 'n':
7509 case 'o':
7510 case 'p':
7511 case 'q':
7512 case 'r':
7513 case 's':
7514 case 't':
7515 case 'u':
7516 case 'v':
7517 case 'w':
7518 case 'x':
7519 case 'y':
7520 case 'z':
7521 {
7522 alt16=1;
7523 }
7524 break;
7525
7526 }
7527
7528 switch (alt16)
7529 {
7530 case 1:
7531 // BaseModelica_Lexer.g:
7532 {
7533 if ( ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= '0') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '9')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 'A') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 'Z')) || LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== '_' || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 'a') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 'z')) )
7534 {
7535 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
7536
7537 }
7538 else
7539 {
7540 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
7541 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
7542 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
7543
7544 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleIDENT2Ex;
7545 }
7546
7547
7548 }
7549 break;
7550
7551 default:
7552 goto loop16; /* break out of the loop */
7553 break;
7554 }
7555 }
7556 loop16: ; /* Jump out to here if this rule does not match */
7557
7558
7559 }
7560 break;
7561 case 2:
7562 // BaseModelica_Lexer.g:419:41: '$cpuTime'
7563 {
7564 MATCHS(lit_77)ctx->pLexer->matchs(ctx->pLexer, lit_77);
7565 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7566 {
7567 goto ruleIDENT2Ex;
7568 }
7569
7570
7571
7572 }
7573 break;
7574
7575 }
7576 }
7577
7578
7579 // This is where rules clean up and exit
7580 //
7581 goto ruleIDENT2Ex; /* Prevent compiler warnings */
7582 ruleIDENT2Ex: ;
7583
7584}
7585// $ANTLR end IDENT2
7586
7587// Comes from: 422:8: ( '\\'' ( QCHAR | SESCAPE ) ( QCHAR | SESCAPE )* '\\'' )
7588/** \brief Lexer rule generated by ANTLR3
7589 *
7590 * $ANTLR start QIDENT
7591 *
7592 * Looks to match the characters the constitute the token QIDENT
7593 * from the attached input stream.
7594 *
7595 *
7596 * \remark
7597 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
7598 */
7599static ANTLR3_INLINE__inline__
7600void mQIDENT(pParModelica_Lexer_BaseModelica_Lexer ctx)
7601{
7602 ANTLR3_UINT32 _type;
7603
7604
7605 // BaseModelica_Lexer.g:422:8: ( '\\'' ( QCHAR | SESCAPE ) ( QCHAR | SESCAPE )* '\\'' )
7606 // BaseModelica_Lexer.g:423:10: '\\'' ( QCHAR | SESCAPE ) ( QCHAR | SESCAPE )* '\\''
7607 {
7608 MATCHC('\'')ctx->pLexer->matchc(ctx->pLexer, '\'');
7609 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7610 {
7611 goto ruleQIDENTEx;
7612 }
7613
7614
7615 // BaseModelica_Lexer.g:423:15: ( QCHAR | SESCAPE )
7616 {
7617 int alt18=2;
7618 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
7619 {
7620 case ' ':
7621 case '!':
7622 case '#':
7623 case '$':
7624 case '%':
7625 case '&':
7626 case '(':
7627 case ')':
7628 case '*':
7629 case '+':
7630 case ',':
7631 case '-':
7632 case '.':
7633 case '/':
7634 case '0':
7635 case '1':
7636 case '2':
7637 case '3':
7638 case '4':
7639 case '5':
7640 case '6':
7641 case '7':
7642 case '8':
7643 case '9':
7644 case ':':
7645 case ';':
7646 case '<':
7647 case '=':
7648 case '>':
7649 case '?':
7650 case '@':
7651 case 'A':
7652 case 'B':
7653 case 'C':
7654 case 'D':
7655 case 'E':
7656 case 'F':
7657 case 'G':
7658 case 'H':
7659 case 'I':
7660 case 'J':
7661 case 'K':
7662 case 'L':
7663 case 'M':
7664 case 'N':
7665 case 'O':
7666 case 'P':
7667 case 'Q':
7668 case 'R':
7669 case 'S':
7670 case 'T':
7671 case 'U':
7672 case 'V':
7673 case 'W':
7674 case 'X':
7675 case 'Y':
7676 case 'Z':
7677 case '[':
7678 case ']':
7679 case '^':
7680 case '_':
7681 case 'a':
7682 case 'b':
7683 case 'c':
7684 case 'd':
7685 case 'e':
7686 case 'f':
7687 case 'g':
7688 case 'h':
7689 case 'i':
7690 case 'j':
7691 case 'k':
7692 case 'l':
7693 case 'm':
7694 case 'n':
7695 case 'o':
7696 case 'p':
7697 case 'q':
7698 case 'r':
7699 case 's':
7700 case 't':
7701 case 'u':
7702 case 'v':
7703 case 'w':
7704 case 'x':
7705 case 'y':
7706 case 'z':
7707 case '{':
7708 case '|':
7709 case '}':
7710 case '~':
7711 {
7712 alt18=1;
7713 }
7714 break;
7715 case '\\':
7716 {
7717 alt18=2;
7718 }
7719 break;
7720
7721 default:
7722 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
7723 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
7724 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
7725 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 18;
7726 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
7727
7728
7729 goto ruleQIDENTEx;
7730 }
7731
7732 switch (alt18)
7733 {
7734 case 1:
7735 // BaseModelica_Lexer.g:423:16: QCHAR
7736 {
7737 /* 423:16: QCHAR */
7738 mQCHAR(ctx );
7739 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7740 {
7741 goto ruleQIDENTEx;
7742 }
7743
7744
7745 }
7746 break;
7747 case 2:
7748 // BaseModelica_Lexer.g:423:24: SESCAPE
7749 {
7750 /* 423:24: SESCAPE */
7751 mSESCAPE(ctx );
7752 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7753 {
7754 goto ruleQIDENTEx;
7755 }
7756
7757
7758 }
7759 break;
7760
7761 }
7762 }
7763
7764 // BaseModelica_Lexer.g:423:33: ( QCHAR | SESCAPE )*
7765
7766 for (;;)
7767 {
7768 int alt19=3;
7769 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
7770 {
7771 case ' ':
7772 case '!':
7773 case '#':
7774 case '$':
7775 case '%':
7776 case '&':
7777 case '(':
7778 case ')':
7779 case '*':
7780 case '+':
7781 case ',':
7782 case '-':
7783 case '.':
7784 case '/':
7785 case '0':
7786 case '1':
7787 case '2':
7788 case '3':
7789 case '4':
7790 case '5':
7791 case '6':
7792 case '7':
7793 case '8':
7794 case '9':
7795 case ':':
7796 case ';':
7797 case '<':
7798 case '=':
7799 case '>':
7800 case '?':
7801 case '@':
7802 case 'A':
7803 case 'B':
7804 case 'C':
7805 case 'D':
7806 case 'E':
7807 case 'F':
7808 case 'G':
7809 case 'H':
7810 case 'I':
7811 case 'J':
7812 case 'K':
7813 case 'L':
7814 case 'M':
7815 case 'N':
7816 case 'O':
7817 case 'P':
7818 case 'Q':
7819 case 'R':
7820 case 'S':
7821 case 'T':
7822 case 'U':
7823 case 'V':
7824 case 'W':
7825 case 'X':
7826 case 'Y':
7827 case 'Z':
7828 case '[':
7829 case ']':
7830 case '^':
7831 case '_':
7832 case 'a':
7833 case 'b':
7834 case 'c':
7835 case 'd':
7836 case 'e':
7837 case 'f':
7838 case 'g':
7839 case 'h':
7840 case 'i':
7841 case 'j':
7842 case 'k':
7843 case 'l':
7844 case 'm':
7845 case 'n':
7846 case 'o':
7847 case 'p':
7848 case 'q':
7849 case 'r':
7850 case 's':
7851 case 't':
7852 case 'u':
7853 case 'v':
7854 case 'w':
7855 case 'x':
7856 case 'y':
7857 case 'z':
7858 case '{':
7859 case '|':
7860 case '}':
7861 case '~':
7862 {
7863 alt19=1;
7864 }
7865 break;
7866 case '\\':
7867 {
7868 alt19=2;
7869 }
7870 break;
7871
7872 }
7873
7874 switch (alt19)
7875 {
7876 case 1:
7877 // BaseModelica_Lexer.g:423:34: QCHAR
7878 {
7879 /* 423:34: QCHAR */
7880 mQCHAR(ctx );
7881 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7882 {
7883 goto ruleQIDENTEx;
7884 }
7885
7886
7887 }
7888 break;
7889 case 2:
7890 // BaseModelica_Lexer.g:423:42: SESCAPE
7891 {
7892 /* 423:42: SESCAPE */
7893 mSESCAPE(ctx );
7894 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7895 {
7896 goto ruleQIDENTEx;
7897 }
7898
7899
7900 }
7901 break;
7902
7903 default:
7904 goto loop19; /* break out of the loop */
7905 break;
7906 }
7907 }
7908 loop19: ; /* Jump out to here if this rule does not match */
7909
7910 MATCHC('\'')ctx->pLexer->matchc(ctx->pLexer, '\'');
7911 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
7912 {
7913 goto ruleQIDENTEx;
7914 }
7915
7916
7917 }
7918
7919
7920
7921 // This is where rules clean up and exit
7922 //
7923 goto ruleQIDENTEx; /* Prevent compiler warnings */
7924 ruleQIDENTEx: ;
7925
7926}
7927// $ANTLR end QIDENT
7928
7929// Comes from: 426:7: ( ( DIGIT | NONDIGIT | '!' | '#' | '$' | '%' | '&' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | ':' | ';' | '<' | '>' | '=' | '?' | '@' | '[' | ']' | '^' | '{' | '}' | '|' | '~' | ' ' ) )
7930/** \brief Lexer rule generated by ANTLR3
7931 *
7932 * $ANTLR start QCHAR
7933 *
7934 * Looks to match the characters the constitute the token QCHAR
7935 * from the attached input stream.
7936 *
7937 *
7938 * \remark
7939 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
7940 */
7941static ANTLR3_INLINE__inline__
7942void mQCHAR(pParModelica_Lexer_BaseModelica_Lexer ctx)
7943{
7944 ANTLR3_UINT32 _type;
7945
7946
7947 // BaseModelica_Lexer.g:426:7: ( ( DIGIT | NONDIGIT | '!' | '#' | '$' | '%' | '&' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | ':' | ';' | '<' | '>' | '=' | '?' | '@' | '[' | ']' | '^' | '{' | '}' | '|' | '~' | ' ' ) )
7948 // BaseModelica_Lexer.g:426:10: ( DIGIT | NONDIGIT | '!' | '#' | '$' | '%' | '&' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | ':' | ';' | '<' | '>' | '=' | '?' | '@' | '[' | ']' | '^' | '{' | '}' | '|' | '~' | ' ' )
7949 {
7950 if ( ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= ' ') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '!')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= '#') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '&')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= '(') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '[')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= ']') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '_')) || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 'a') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= '~')) )
7951 {
7952 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
7953
7954 }
7955 else
7956 {
7957 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
7958 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
7959 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
7960
7961 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleQCHAREx;
7962 }
7963
7964
7965 }
7966
7967
7968
7969 // This is where rules clean up and exit
7970 //
7971 goto ruleQCHAREx; /* Prevent compiler warnings */
7972 ruleQCHAREx: ;
7973
7974}
7975// $ANTLR end QCHAR
7976
7977// Comes from: 430:10: ( ( '_' | 'a' .. 'z' | 'A' .. 'Z' ) )
7978/** \brief Lexer rule generated by ANTLR3
7979 *
7980 * $ANTLR start NONDIGIT
7981 *
7982 * Looks to match the characters the constitute the token NONDIGIT
7983 * from the attached input stream.
7984 *
7985 *
7986 * \remark
7987 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
7988 */
7989static ANTLR3_INLINE__inline__
7990void mNONDIGIT(pParModelica_Lexer_BaseModelica_Lexer ctx)
7991{
7992 ANTLR3_UINT32 _type;
7993
7994
7995 // BaseModelica_Lexer.g:430:10: ( ( '_' | 'a' .. 'z' | 'A' .. 'Z' ) )
7996 // BaseModelica_Lexer.g:430:14: ( '_' | 'a' .. 'z' | 'A' .. 'Z' )
7997 {
7998 if ( ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 'A') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 'Z')) || LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== '_' || ((LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
>= 'a') && (LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
<= 'z')) )
7999 {
8000 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
8001
8002 }
8003 else
8004 {
8005 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
8006 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
8007 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
8008
8009 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleNONDIGITEx;
8010 }
8011
8012
8013 }
8014
8015
8016
8017 // This is where rules clean up and exit
8018 //
8019 goto ruleNONDIGITEx; /* Prevent compiler warnings */
8020 ruleNONDIGITEx: ;
8021
8022}
8023// $ANTLR end NONDIGIT
8024
8025// Comes from: 433:7: ( '0' .. '9' )
8026/** \brief Lexer rule generated by ANTLR3
8027 *
8028 * $ANTLR start DIGIT
8029 *
8030 * Looks to match the characters the constitute the token DIGIT
8031 * from the attached input stream.
8032 *
8033 *
8034 * \remark
8035 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
8036 */
8037static ANTLR3_INLINE__inline__
8038void mDIGIT(pParModelica_Lexer_BaseModelica_Lexer ctx)
8039{
8040 ANTLR3_UINT32 _type;
8041
8042
8043 // BaseModelica_Lexer.g:433:7: ( '0' .. '9' )
8044 // BaseModelica_Lexer.g:434:3: '0' .. '9'
8045 {
8046 MATCHRANGE('0', '9')ctx->pLexer->matchRange(ctx->pLexer, '0', '9');
8047 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
8048 {
8049 goto ruleDIGITEx;
8050 }
8051
8052
8053 }
8054
8055
8056
8057 // This is where rules clean up and exit
8058 //
8059 goto ruleDIGITEx; /* Prevent compiler warnings */
8060 ruleDIGITEx: ;
8061
8062}
8063// $ANTLR end DIGIT
8064
8065// Comes from: 438:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( DIGIT )+ )
8066/** \brief Lexer rule generated by ANTLR3
8067 *
8068 * $ANTLR start EXPONENT
8069 *
8070 * Looks to match the characters the constitute the token EXPONENT
8071 * from the attached input stream.
8072 *
8073 *
8074 * \remark
8075 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
8076 */
8077static ANTLR3_INLINE__inline__
8078void mEXPONENT(pParModelica_Lexer_BaseModelica_Lexer ctx)
8079{
8080 ANTLR3_UINT32 _type;
8081
8082
8083 // BaseModelica_Lexer.g:438:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( DIGIT )+ )
8084 // BaseModelica_Lexer.g:439:3: ( 'e' | 'E' ) ( '+' | '-' )? ( DIGIT )+
8085 {
8086 if ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== 'E' || LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== 'e' )
8087 {
8088 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
8089
8090 }
8091 else
8092 {
8093 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
8094 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
8095 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
8096
8097 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleEXPONENTEx;
8098 }
8099
8100
8101 // BaseModelica_Lexer.g:439:13: ( '+' | '-' )?
8102 {
8103 int alt20=2;
8104 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
8105 {
8106 case '+':
8107 case '-':
8108 {
8109 alt20=1;
8110 }
8111 break;
8112 }
8113
8114 switch (alt20)
8115 {
8116 case 1:
8117 // BaseModelica_Lexer.g:
8118 {
8119 if ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== '+' || LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
== '-' )
8120 {
8121 CONSUME()ctx->pLexer->input->istream->consume(ctx->pLexer
->input->istream)
;
8122
8123 }
8124 else
8125 {
8126 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
8127 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_MISMATCHED_SET_EXCEPTION4;
8128 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_MISMATCHED_SET_NAME"Mismatched set";
8129
8130 LRECOVER()ctx->pLexer->recover(ctx->pLexer); goto ruleEXPONENTEx;
8131 }
8132
8133
8134 }
8135 break;
8136
8137 }
8138 }
8139 // BaseModelica_Lexer.g:439:26: ( DIGIT )+
8140 {
8141 int cnt21=0;
8142
8143 for (;;)
8144 {
8145 int alt21=2;
8146 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
8147 {
8148 case '0':
8149 case '1':
8150 case '2':
8151 case '3':
8152 case '4':
8153 case '5':
8154 case '6':
8155 case '7':
8156 case '8':
8157 case '9':
8158 {
8159 alt21=1;
8160 }
8161 break;
8162
8163 }
8164
8165 switch (alt21)
8166 {
8167 case 1:
8168 // BaseModelica_Lexer.g:439:27: DIGIT
8169 {
8170 /* 439:27: DIGIT */
8171 mDIGIT(ctx );
8172 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
8173 {
8174 goto ruleEXPONENTEx;
8175 }
8176
8177
8178 }
8179 break;
8180
8181 default:
8182
8183 if ( cnt21 >= 1 )
8184 {
8185 goto loop21;
8186 }
8187 /* mismatchedSetEx()
8188 */
8189 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
8190 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_EARLY_EXIT_EXCEPTION5;
8191 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_EARLY_EXIT_NAME"Early exit";
8192
8193
8194 goto ruleEXPONENTEx;
8195 }
8196 cnt21++;
8197 }
8198 loop21: ; /* Jump to here if this rule does not match */
8199 }
8200
8201 }
8202
8203
8204
8205 // This is where rules clean up and exit
8206 //
8207 goto ruleEXPONENTEx; /* Prevent compiler warnings */
8208 ruleEXPONENTEx: ;
8209
8210}
8211// $ANTLR end EXPONENT
8212
8213// Comes from: 443:18: ( ( DIGIT )+ ( '.' ( DIGIT )* )? ( EXPONENT )? | ( '.' ) ( ( DIGIT )+ ( EXPONENT )? | ( ( '+' ) | ( '-' ) | ( '*' ) | ( '/' ) | ( '^' ) )? ) )
8214/** \brief Lexer rule generated by ANTLR3
8215 *
8216 * $ANTLR start UNSIGNED_INTEGER
8217 *
8218 * Looks to match the characters the constitute the token UNSIGNED_INTEGER
8219 * from the attached input stream.
8220 *
8221 *
8222 * \remark
8223 * - lexer->error == ANTLR3_TRUE if an exception was thrown.
8224 */
8225static ANTLR3_INLINE__inline__
8226void mUNSIGNED_INTEGER(pParModelica_Lexer_BaseModelica_Lexer ctx)
8227{
8228 ANTLR3_UINT32 _type;
8229
8230 _type = UNSIGNED_INTEGER142;
8231
8232
8233 {
8234 // BaseModelica_Lexer.g:443:18: ( ( DIGIT )+ ( '.' ( DIGIT )* )? ( EXPONENT )? | ( '.' ) ( ( DIGIT )+ ( EXPONENT )? | ( ( '+' ) | ( '-' ) | ( '*' ) | ( '/' ) | ( '^' ) )? ) )
8235
8236 ANTLR3_UINT32 alt30;
8237
8238 alt30=2;
8239
8240 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
8241 {
8242 case '0':
8243 case '1':
8244 case '2':
8245 case '3':
8246 case '4':
8247 case '5':
8248 case '6':
8249 case '7':
8250 case '8':
8251 case '9':
8252 {
8253 alt30=1;
8254 }
8255 break;
8256 case '.':
8257 {
8258 alt30=2;
8259 }
8260 break;
8261
8262 default:
8263 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
8264 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION3;
8265 EXCEPTIONctx->pLexer->rec->state->exception->message = (void *)"";
8266 EXCEPTIONctx->pLexer->rec->state->exception->decisionNum = 30;
8267 EXCEPTIONctx->pLexer->rec->state->exception->state = 0;
8268
8269
8270 goto ruleUNSIGNED_INTEGEREx;
8271 }
8272
8273 switch (alt30)
8274 {
8275 case 1:
8276 // BaseModelica_Lexer.g:444:5: ( DIGIT )+ ( '.' ( DIGIT )* )? ( EXPONENT )?
8277 {
8278 // BaseModelica_Lexer.g:444:5: ( DIGIT )+
8279 {
8280 int cnt22=0;
8281
8282 for (;;)
8283 {
8284 int alt22=2;
8285 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
8286 {
8287 case '0':
8288 case '1':
8289 case '2':
8290 case '3':
8291 case '4':
8292 case '5':
8293 case '6':
8294 case '7':
8295 case '8':
8296 case '9':
8297 {
8298 alt22=1;
8299 }
8300 break;
8301
8302 }
8303
8304 switch (alt22)
8305 {
8306 case 1:
8307 // BaseModelica_Lexer.g:444:6: DIGIT
8308 {
8309 /* 444:6: DIGIT */
8310 mDIGIT(ctx );
8311 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
8312 {
8313 goto ruleUNSIGNED_INTEGEREx;
8314 }
8315
8316
8317 }
8318 break;
8319
8320 default:
8321
8322 if ( cnt22 >= 1 )
8323 {
8324 goto loop22;
8325 }
8326 /* mismatchedSetEx()
8327 */
8328 CONSTRUCTEX()ctx->pLexer->rec->exConstruct(ctx->pLexer->rec
)
;
8329 EXCEPTIONctx->pLexer->rec->state->exception->type = ANTLR3_EARLY_EXIT_EXCEPTION5;
8330 EXCEPTIONctx->pLexer->rec->state->exception->name = (void *)ANTLR3_EARLY_EXIT_NAME"Early exit";
8331
8332
8333 goto ruleUNSIGNED_INTEGEREx;
8334 }
8335 cnt22++;
8336 }
8337 loop22: ; /* Jump to here if this rule does not match */
8338 }
8339
8340 // BaseModelica_Lexer.g:444:14: ( '.' ( DIGIT )* )?
8341 {
8342 int alt24=2;
8343 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
8344 {
8345 case '.':
8346 {
8347 alt24=1;
8348 }
8349 break;
8350 }
8351
8352 switch (alt24)
8353 {
8354 case 1:
8355 // BaseModelica_Lexer.g:444:15: '.' ( DIGIT )*
8356 {
8357 MATCHC('.')ctx->pLexer->matchc(ctx->pLexer, '.');
8358 if (HASEXCEPTION()(ctx->pLexer->rec->state->error == 1))
8359 {
8360 goto ruleUNSIGNED_INTEGEREx;
8361 }
8362
8363
8364 // BaseModelica_Lexer.g:444:19: ( DIGIT )*
8365
8366 for (;;)
8367 {
8368 int alt23=2;
8369 switch ( LA(1)ctx->pLexer->input->istream->_LA(ctx->pLexer->
input->istream, 1)
)
8370 {
8371 case '0':
8372 case '1':
8373 case '2':
8374 case '3':
8375 case '4':
8376 case '5':
8377 case '6':
8378 case '7':
8379 case '8':
8380 case '9':
8381 {
8382 alt23=1;
8383 }
8384 break;
8385
8386 }
8387
8388 switch (alt23)
8389 {
8390 case 1:
8391 // BaseModelica_Lexer.g:444:20: DIGIT
8392 {
8393 /* 444:20: DIGIT */
8394 mDIGIT(ctx );
8395