Bug Summary

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