1*78bc99aaSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*78bc99aaSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*78bc99aaSAndrew Rist * or more contributor license agreements. See the NOTICE file
5*78bc99aaSAndrew Rist * distributed with this work for additional information
6*78bc99aaSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*78bc99aaSAndrew Rist * to you under the Apache License, Version 2.0 (the
8*78bc99aaSAndrew Rist * "License"); you may not use this file except in compliance
9*78bc99aaSAndrew Rist * with the License. You may obtain a copy of the License at
10*78bc99aaSAndrew Rist *
11*78bc99aaSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*78bc99aaSAndrew Rist *
13*78bc99aaSAndrew Rist * Unless required by applicable law or agreed to in writing,
14*78bc99aaSAndrew Rist * software distributed under the License is distributed on an
15*78bc99aaSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*78bc99aaSAndrew Rist * KIND, either express or implied. See the License for the
17*78bc99aaSAndrew Rist * specific language governing permissions and limitations
18*78bc99aaSAndrew Rist * under the License.
19*78bc99aaSAndrew Rist *
20*78bc99aaSAndrew Rist *************************************************************/
21cdf0e10cSrcweir
22cdf0e10cSrcweir #include <precomp.h>
23cdf0e10cSrcweir #include "cx_c_std.hxx"
24cdf0e10cSrcweir
25cdf0e10cSrcweir
26cdf0e10cSrcweir // NOT FULLY DECLARED SERVICES
27cdf0e10cSrcweir #include "all_toks.hxx"
28cdf0e10cSrcweir #include "cx_c_pp.hxx"
29cdf0e10cSrcweir #include "cx_c_sub.hxx"
30cdf0e10cSrcweir #include <tools/tkpchars.hxx>
31cdf0e10cSrcweir #include <tokens/tkpstama.hxx>
32cdf0e10cSrcweir #include <x_parse.hxx>
33cdf0e10cSrcweir #include "c_dealer.hxx"
34cdf0e10cSrcweir
35cdf0e10cSrcweir
36cdf0e10cSrcweir namespace cpp {
37cdf0e10cSrcweir
38cdf0e10cSrcweir
39cdf0e10cSrcweir const intt C_nCppInitialNrOfStati = 600;
40cdf0e10cSrcweir const intt C_nStatusSize = 128;
41cdf0e10cSrcweir
42cdf0e10cSrcweir
43cdf0e10cSrcweir
44cdf0e10cSrcweir const uintt nF_fin_Error = 1;
45cdf0e10cSrcweir const uintt nF_fin_CreateWithoutText = 2;
46cdf0e10cSrcweir const uintt nF_fin_CreateWithText = 3;
47cdf0e10cSrcweir const uintt nF_fin_Ignore = 4;
48cdf0e10cSrcweir const uintt nF_fin_EOL = 5;
49cdf0e10cSrcweir const uintt nF_fin_EOF = 6;
50cdf0e10cSrcweir const uintt nF_fin_Bezeichner = 7;
51cdf0e10cSrcweir
52cdf0e10cSrcweir const uintt nF_goto_Preprocessor = 10;
53cdf0e10cSrcweir const uintt nF_goto_Comment = 11;
54cdf0e10cSrcweir const uintt nF_goto_Docu = 12;
55cdf0e10cSrcweir const uintt nF_goto_Const = 13;
56cdf0e10cSrcweir const uintt nF_goto_UnblockMacro = 14;
57cdf0e10cSrcweir
58cdf0e10cSrcweir // Token create functions for the state machine:
TCF_Identifier(const char * text)59cdf0e10cSrcweir DYN TextToken * TCF_Identifier(const char * text) { return new Tok_Identifier(text); }
60cdf0e10cSrcweir
TCF_operator(const char *)61cdf0e10cSrcweir DYN TextToken * TCF_operator(const char *) { return new Tok_operator; }
TCF_class(const char *)62cdf0e10cSrcweir DYN TextToken * TCF_class(const char *) { return new Tok_class; }
TCF_struct(const char *)63cdf0e10cSrcweir DYN TextToken * TCF_struct(const char *) { return new Tok_struct; }
TCF_union(const char *)64cdf0e10cSrcweir DYN TextToken * TCF_union(const char *) { return new Tok_union; }
TCF_enum(const char *)65cdf0e10cSrcweir DYN TextToken * TCF_enum(const char *) { return new Tok_enum; }
TCF_typedef(const char *)66cdf0e10cSrcweir DYN TextToken * TCF_typedef(const char *) { return new Tok_typedef; }
TCF_public(const char *)67cdf0e10cSrcweir DYN TextToken * TCF_public(const char *) { return new Tok_public; }
TCF_protected(const char *)68cdf0e10cSrcweir DYN TextToken * TCF_protected(const char *) { return new Tok_protected; }
TCF_private(const char *)69cdf0e10cSrcweir DYN TextToken * TCF_private(const char *) { return new Tok_private; }
TCF_template(const char *)70cdf0e10cSrcweir DYN TextToken * TCF_template(const char *) { return new Tok_template; }
TCF_virtual(const char *)71cdf0e10cSrcweir DYN TextToken * TCF_virtual(const char *) { return new Tok_virtual; }
TCF_friend(const char *)72cdf0e10cSrcweir DYN TextToken * TCF_friend(const char *) { return new Tok_friend; }
TCF_Tilde(const char *)73cdf0e10cSrcweir DYN TextToken * TCF_Tilde(const char *) { return new Tok_Tilde; }
TCF_const(const char *)74cdf0e10cSrcweir DYN TextToken * TCF_const(const char *) { return new Tok_const; }
TCF_volatile(const char *)75cdf0e10cSrcweir DYN TextToken * TCF_volatile(const char *) { return new Tok_volatile; }
TCF_extern(const char *)76cdf0e10cSrcweir DYN TextToken * TCF_extern(const char *) { return new Tok_extern; }
TCF_static(const char *)77cdf0e10cSrcweir DYN TextToken * TCF_static(const char *) { return new Tok_static; }
TCF_mutable(const char *)78cdf0e10cSrcweir DYN TextToken * TCF_mutable(const char *) { return new Tok_mutable; }
TCF_register(const char *)79cdf0e10cSrcweir DYN TextToken * TCF_register(const char *) { return new Tok_register; }
TCF_inline(const char *)80cdf0e10cSrcweir DYN TextToken * TCF_inline(const char *) { return new Tok_inline; }
TCF_explicit(const char *)81cdf0e10cSrcweir DYN TextToken * TCF_explicit(const char *) { return new Tok_explicit; }
TCF_namespace(const char *)82cdf0e10cSrcweir DYN TextToken * TCF_namespace(const char *) { return new Tok_namespace; }
TCF_using(const char *)83cdf0e10cSrcweir DYN TextToken * TCF_using(const char *) { return new Tok_using; }
TCF_throw(const char *)84cdf0e10cSrcweir DYN TextToken * TCF_throw(const char *) { return new Tok_throw; }
TCF_SwBracketOpen(const char *)85cdf0e10cSrcweir DYN TextToken * TCF_SwBracketOpen(const char *) { return new Tok_SwBracket_Left; }
TCF_SwBracketClose(const char *)86cdf0e10cSrcweir DYN TextToken * TCF_SwBracketClose(const char *) { return new Tok_SwBracket_Right; }
TCF_ArBracketOpen(const char *)87cdf0e10cSrcweir DYN TextToken * TCF_ArBracketOpen(const char *) { return new Tok_ArrayBracket_Left; }
TCF_ArBracketClose(const char *)88cdf0e10cSrcweir DYN TextToken * TCF_ArBracketClose(const char *) { return new Tok_ArrayBracket_Right; }
TCF_BracketOpen(const char *)89cdf0e10cSrcweir DYN TextToken * TCF_BracketOpen(const char *) { return new Tok_Bracket_Left; }
TCF_BracketClose(const char *)90cdf0e10cSrcweir DYN TextToken * TCF_BracketClose(const char *) { return new Tok_Bracket_Right; }
TCF_DblColon(const char *)91cdf0e10cSrcweir DYN TextToken * TCF_DblColon(const char *) { return new Tok_DoubleColon; }
TCF_Semikolon(const char *)92cdf0e10cSrcweir DYN TextToken * TCF_Semikolon(const char *) { return new Tok_Semicolon; }
TCF_Komma(const char *)93cdf0e10cSrcweir DYN TextToken * TCF_Komma(const char *) { return new Tok_Comma; }
TCF_Colon(const char *)94cdf0e10cSrcweir DYN TextToken * TCF_Colon(const char *) { return new Tok_Colon; }
TCF_Zuweisung(const char *)95cdf0e10cSrcweir DYN TextToken * TCF_Zuweisung(const char *) { return new Tok_Assign; }
TCF_Smaller(const char *)96cdf0e10cSrcweir DYN TextToken * TCF_Smaller(const char *) { return new Tok_Less; }
TCF_Bigger(const char *)97cdf0e10cSrcweir DYN TextToken * TCF_Bigger(const char *) { return new Tok_Greater; }
TCF_Stern(const char *)98cdf0e10cSrcweir DYN TextToken * TCF_Stern(const char *) { return new Tok_Asterix; }
TCF_Ampersand(const char *)99cdf0e10cSrcweir DYN TextToken * TCF_Ampersand(const char *) { return new Tok_AmpersAnd; }
TCF_Ellipse(const char *)100cdf0e10cSrcweir DYN TextToken * TCF_Ellipse(const char *) { return new Tok_Ellipse; }
TCF_typename(const char *)101cdf0e10cSrcweir DYN TextToken * TCF_typename(const char *) { return new Tok_typename; }
102cdf0e10cSrcweir
103cdf0e10cSrcweir // Operators
TCF_Operator(const char * text)104cdf0e10cSrcweir DYN TextToken * TCF_Operator(const char * text) { return new Tok_Operator(text); }
105cdf0e10cSrcweir
TCF_BuiltInType(const char * text)106cdf0e10cSrcweir DYN TextToken * TCF_BuiltInType(const char * text) { return new Tok_BuiltInType(text); }
TCF_TypeModifier(const char * text)107cdf0e10cSrcweir DYN TextToken * TCF_TypeModifier(const char * text) { return new Tok_TypeSpecializer(text); }
108cdf0e10cSrcweir
TCF_Eof(const char *)109cdf0e10cSrcweir DYN TextToken * TCF_Eof(const char *) { return new Tok_Eof; }
110cdf0e10cSrcweir
111cdf0e10cSrcweir
112cdf0e10cSrcweir
Context_CppStd(DYN autodoc::TkpDocuContext & let_drContext_Docu)113cdf0e10cSrcweir Context_CppStd::Context_CppStd( DYN autodoc::TkpDocuContext & let_drContext_Docu )
114cdf0e10cSrcweir : Cx_Base(0),
115cdf0e10cSrcweir aStateMachine(C_nStatusSize,C_nCppInitialNrOfStati),
116cdf0e10cSrcweir pDocuContext(&let_drContext_Docu),
117cdf0e10cSrcweir pContext_Comment(0),
118cdf0e10cSrcweir pContext_Preprocessor(0),
119cdf0e10cSrcweir pContext_ConstString(0),
120cdf0e10cSrcweir pContext_ConstChar(0),
121cdf0e10cSrcweir pContext_ConstNumeric(0),
122cdf0e10cSrcweir pContext_UnblockMacro(0)
123cdf0e10cSrcweir {
124cdf0e10cSrcweir pDocuContext->SetParentContext(*this,"*/");
125cdf0e10cSrcweir
126cdf0e10cSrcweir pContext_Comment = new Context_Comment(*this);
127cdf0e10cSrcweir pContext_Preprocessor = new Context_Preprocessor(*this);
128cdf0e10cSrcweir pContext_ConstString = new Context_ConstString(*this);
129cdf0e10cSrcweir pContext_ConstChar = new Context_ConstChar(*this);
130cdf0e10cSrcweir pContext_ConstNumeric = new Context_ConstNumeric(*this);
131cdf0e10cSrcweir pContext_UnblockMacro = new Context_UnblockMacro(*this);
132cdf0e10cSrcweir
133cdf0e10cSrcweir SetupStateMachine();
134cdf0e10cSrcweir }
135cdf0e10cSrcweir
~Context_CppStd()136cdf0e10cSrcweir Context_CppStd::~Context_CppStd()
137cdf0e10cSrcweir {
138cdf0e10cSrcweir }
139cdf0e10cSrcweir
140cdf0e10cSrcweir void
ReadCharChain(CharacterSource & io_rText)141cdf0e10cSrcweir Context_CppStd::ReadCharChain( CharacterSource & io_rText )
142cdf0e10cSrcweir {
143cdf0e10cSrcweir SetNewToken(0);
144cdf0e10cSrcweir
145cdf0e10cSrcweir TextToken::F_CRTOK fTokenCreateFunction = 0;
146cdf0e10cSrcweir StmBoundsStatus & rBound = aStateMachine.GetCharChain(fTokenCreateFunction, io_rText);
147cdf0e10cSrcweir
148cdf0e10cSrcweir // !!!
149cdf0e10cSrcweir // The order of the next two lines is essential, because
150cdf0e10cSrcweir // pFollowUpContext may be changed by PerformStatusFunction() also,
151cdf0e10cSrcweir // which then MUST override the previous assignment.
152cdf0e10cSrcweir SetFollowUpContext(rBound.FollowUpContext());
153cdf0e10cSrcweir PerformStatusFunction(rBound.StatusFunctionNr(), fTokenCreateFunction, io_rText);
154cdf0e10cSrcweir }
155cdf0e10cSrcweir
156cdf0e10cSrcweir void
AssignDealer(Distributor & o_rDealer)157cdf0e10cSrcweir Context_CppStd::AssignDealer( Distributor & o_rDealer )
158cdf0e10cSrcweir {
159cdf0e10cSrcweir Cx_Base::AssignDealer(o_rDealer);
160cdf0e10cSrcweir
161cdf0e10cSrcweir pDocuContext->AssignDealer(o_rDealer);
162cdf0e10cSrcweir pContext_Comment->AssignDealer(o_rDealer);
163cdf0e10cSrcweir pContext_Preprocessor->AssignDealer(o_rDealer);
164cdf0e10cSrcweir pContext_ConstString->AssignDealer(o_rDealer);
165cdf0e10cSrcweir pContext_ConstChar->AssignDealer(o_rDealer);
166cdf0e10cSrcweir pContext_ConstNumeric->AssignDealer(o_rDealer);
167cdf0e10cSrcweir pContext_UnblockMacro->AssignDealer(o_rDealer);
168cdf0e10cSrcweir }
169cdf0e10cSrcweir
170cdf0e10cSrcweir void
PerformStatusFunction(uintt i_nStatusSignal,F_CRTOK i_fTokenCreateFunction,CharacterSource & io_rText)171cdf0e10cSrcweir Context_CppStd::PerformStatusFunction( uintt i_nStatusSignal,
172cdf0e10cSrcweir F_CRTOK i_fTokenCreateFunction,
173cdf0e10cSrcweir CharacterSource & io_rText )
174cdf0e10cSrcweir {
175cdf0e10cSrcweir switch (i_nStatusSignal)
176cdf0e10cSrcweir {
177cdf0e10cSrcweir case nF_fin_CreateWithoutText:
178cdf0e10cSrcweir io_rText.CutToken();
179cdf0e10cSrcweir csv_assert(i_fTokenCreateFunction != 0);
180cdf0e10cSrcweir SetNewToken( (*i_fTokenCreateFunction)(0) );
181cdf0e10cSrcweir break;
182cdf0e10cSrcweir case nF_fin_CreateWithText:
183cdf0e10cSrcweir csv_assert(i_fTokenCreateFunction != 0);
184cdf0e10cSrcweir SetNewToken( (*i_fTokenCreateFunction)(io_rText.CutToken()) );
185cdf0e10cSrcweir break;
186cdf0e10cSrcweir case nF_fin_Ignore:
187cdf0e10cSrcweir io_rText.CutToken();
188cdf0e10cSrcweir SetNewToken(0);
189cdf0e10cSrcweir break;
190cdf0e10cSrcweir case nF_fin_EOL:
191cdf0e10cSrcweir io_rText.CutToken();
192cdf0e10cSrcweir SetNewToken(0);
193cdf0e10cSrcweir Dealer().Deal_Eol();
194cdf0e10cSrcweir break;
195cdf0e10cSrcweir case nF_fin_EOF:
196cdf0e10cSrcweir io_rText.CutToken();
197cdf0e10cSrcweir SetNewToken( TCF_Eof(0) );
198cdf0e10cSrcweir break;
199cdf0e10cSrcweir case nF_fin_Bezeichner:
200cdf0e10cSrcweir SetNewToken( TCF_Identifier(io_rText.CutToken()) );
201cdf0e10cSrcweir break;
202cdf0e10cSrcweir
203cdf0e10cSrcweir case nF_goto_Preprocessor:
204cdf0e10cSrcweir io_rText.CutToken();
205cdf0e10cSrcweir SetNewToken(0);
206cdf0e10cSrcweir break;
207cdf0e10cSrcweir case nF_goto_Comment:
208cdf0e10cSrcweir SetNewToken(0);
209cdf0e10cSrcweir pContext_Comment->SetMode_IsMultiLine( io_rText.CutToken()[1] == '*' );
210cdf0e10cSrcweir break;
211cdf0e10cSrcweir case nF_goto_Docu:
212cdf0e10cSrcweir SetNewToken(0);
213cdf0e10cSrcweir pDocuContext->SetMode_IsMultiLine( io_rText.CutToken()[1] == '*' );
214cdf0e10cSrcweir break;
215cdf0e10cSrcweir case nF_goto_Const:
216cdf0e10cSrcweir SetNewToken(0);
217cdf0e10cSrcweir break;
218cdf0e10cSrcweir case nF_goto_UnblockMacro:
219cdf0e10cSrcweir SetNewToken(0);
220cdf0e10cSrcweir break;
221cdf0e10cSrcweir
222cdf0e10cSrcweir case nF_fin_Error:
223cdf0e10cSrcweir default:
224cdf0e10cSrcweir {
225cdf0e10cSrcweir char cCC = io_rText.CurChar();
226cdf0e10cSrcweir String sCurChar( &cCC, 1 );
227cdf0e10cSrcweir throw X_Parser( X_Parser::x_InvalidChar, sCurChar, String::Null_(), 0 );
228cdf0e10cSrcweir }
229cdf0e10cSrcweir } // end switch (i_nStatusSignal)
230cdf0e10cSrcweir }
231cdf0e10cSrcweir
232cdf0e10cSrcweir void
SetupStateMachine()233cdf0e10cSrcweir Context_CppStd::SetupStateMachine()
234cdf0e10cSrcweir {
235cdf0e10cSrcweir // Besondere Array-Stati (kein Tokenabschluss oder Kontextwechsel):
236cdf0e10cSrcweir // const INT16 top = 0; // Top-Status
237cdf0e10cSrcweir const INT16 wht = 1; // Whitespace-�berlese-Status
238cdf0e10cSrcweir const INT16 bez = 2; // Bezeichner-lese-Status
239cdf0e10cSrcweir
240cdf0e10cSrcweir // Tokenfinish-Stati:
241cdf0e10cSrcweir const INT16 finError = 3;
242cdf0e10cSrcweir const INT16 finIgnore = 4;
243cdf0e10cSrcweir const INT16 finBezeichner = 5;
244cdf0e10cSrcweir const INT16 finKeyword = 6;
245cdf0e10cSrcweir const INT16 finPunctuation = 7;
246cdf0e10cSrcweir const INT16 finBiType = 8;
247cdf0e10cSrcweir const INT16 finTypeModifier = 9;
248cdf0e10cSrcweir const INT16 finEOL = 10;
249cdf0e10cSrcweir const INT16 finEOF = 11;
250cdf0e10cSrcweir
251cdf0e10cSrcweir // Kontextwechsel-Stati:
252cdf0e10cSrcweir const INT16 gotoComment = 12;
253cdf0e10cSrcweir const INT16 gotoDocu = 13;
254cdf0e10cSrcweir const INT16 gotoPreprocessor = 14;
255cdf0e10cSrcweir const INT16 gotoConstString = 15;
256cdf0e10cSrcweir const INT16 gotoConstChar = 16;
257cdf0e10cSrcweir const INT16 gotoConstNumeric = 17;
258cdf0e10cSrcweir const INT16 gotoUnblockMacro = 18;
259cdf0e10cSrcweir
260cdf0e10cSrcweir // Abbreviations to be used in status tables:
261cdf0e10cSrcweir const INT16 err = finError;
262cdf0e10cSrcweir const INT16 fig = finIgnore;
263cdf0e10cSrcweir const INT16 fbz = finBezeichner;
264cdf0e10cSrcweir const INT16 fof = finEOF;
265cdf0e10cSrcweir const INT16 cst = gotoConstString;
266cdf0e10cSrcweir const INT16 cch = gotoConstChar;
267cdf0e10cSrcweir const INT16 cnr = gotoConstNumeric;
268cdf0e10cSrcweir
269cdf0e10cSrcweir
270cdf0e10cSrcweir /// Zeros - '0' - will be replaced by AddToken().
271cdf0e10cSrcweir
272cdf0e10cSrcweir const INT16 A_nTopStatus[C_nStatusSize] =
273cdf0e10cSrcweir // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
274cdf0e10cSrcweir {fof,err,err,err,err,err,err,err,err,wht, 0,wht,wht, 0,err,err,
275cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,fof,err,err,err,err,err, // 16 ...
276cdf0e10cSrcweir wht, 0,cst, 0,err, 0, 0,cch, 0, 0, 0, 0, 0, 0, 0, 0,
277cdf0e10cSrcweir cnr,cnr,cnr,cnr,cnr,cnr,cnr,cnr,cnr,cnr, 0, 0, 0, 0, 0, 0, // 48 ...
278cdf0e10cSrcweir 0,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,
279cdf0e10cSrcweir bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 0, 0, 0, 0,bez, // 80 ...
280cdf0e10cSrcweir 0,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,
281cdf0e10cSrcweir bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 0, 0, 0, 0,err, // 80 ...
282cdf0e10cSrcweir };
283cdf0e10cSrcweir
284cdf0e10cSrcweir const INT16 A_nWhitespaceStatus[C_nStatusSize] =
285cdf0e10cSrcweir // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
286cdf0e10cSrcweir {fof,err,err,err,err,err,err,err,err,wht,fig,wht,wht,fig,err,err,
287cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,fof,err,err,err,err,err, // 16 ...
288cdf0e10cSrcweir wht,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,
289cdf0e10cSrcweir fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig, // 48 ...
290cdf0e10cSrcweir fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,
291cdf0e10cSrcweir fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig, // 80 ...
292cdf0e10cSrcweir fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,
293cdf0e10cSrcweir fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,err
294cdf0e10cSrcweir };
295cdf0e10cSrcweir
296cdf0e10cSrcweir const INT16 A_nBezeichnerStatus[C_nStatusSize] =
297cdf0e10cSrcweir // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
298cdf0e10cSrcweir {fbz,err,err,err,err,err,err,err,err,fbz,fbz,fbz,fbz,fbz,err,err,
299cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,fbz,err,err,err,err,err, // 16 ...
300cdf0e10cSrcweir fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,
301cdf0e10cSrcweir bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,fbz,fbz, // 48 ...
302cdf0e10cSrcweir fbz,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,
303cdf0e10cSrcweir bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,bez, // 80 ...
304cdf0e10cSrcweir fbz,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,
305cdf0e10cSrcweir bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,err
306cdf0e10cSrcweir };
307cdf0e10cSrcweir
308cdf0e10cSrcweir
309cdf0e10cSrcweir const INT16 A_nOperatorDefStatus[C_nStatusSize] =
310cdf0e10cSrcweir // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
311cdf0e10cSrcweir {err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,
312cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, // 16 ...
313cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,
314cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, // 48 ...
315cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,
316cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, // 80 ...
317cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,
318cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err
319cdf0e10cSrcweir };
320cdf0e10cSrcweir
321cdf0e10cSrcweir const INT16 A_nBezDefStatus[C_nStatusSize] =
322cdf0e10cSrcweir // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
323cdf0e10cSrcweir {fbz,err,err,err,err,err,err,err,err,fbz,fbz,fbz,fbz,fbz,err,err,
324cdf0e10cSrcweir err,err,err,err,err,err,err,err,err,err,fbz,err,err,err,err,err, // 16 ...
325cdf0e10cSrcweir fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,
326cdf0e10cSrcweir bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,fbz,fbz, // 48 ...
327cdf0e10cSrcweir fbz,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,
328cdf0e10cSrcweir bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,bez, // 80 ...
329cdf0e10cSrcweir fbz,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,
330cdf0e10cSrcweir bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,err
331cdf0e10cSrcweir };
332cdf0e10cSrcweir
333cdf0e10cSrcweir DYN StmArrayStatus * dpStatusTop
334cdf0e10cSrcweir = new StmArrayStatus( C_nStatusSize, A_nTopStatus, 0, true);
335cdf0e10cSrcweir DYN StmArrayStatus * dpStatusWhite
336cdf0e10cSrcweir = new StmArrayStatus( C_nStatusSize, A_nWhitespaceStatus, 0, true);
337cdf0e10cSrcweir DYN StmArrayStatus * dpStatusBez
338cdf0e10cSrcweir = new StmArrayStatus( C_nStatusSize, A_nBezeichnerStatus, TCF_Identifier, true);
339cdf0e10cSrcweir
340cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_finError
341cdf0e10cSrcweir = new StmBoundsStatus( *this, TkpContext::Null_(), nF_fin_Error, true );
342cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_finIgnore
343cdf0e10cSrcweir = new StmBoundsStatus( *this, *this, nF_fin_Ignore, true );
344cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_finBezeichner
345cdf0e10cSrcweir = new StmBoundsStatus( *this, *this, nF_fin_Bezeichner, true );
346cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_finKeyword
347cdf0e10cSrcweir = new StmBoundsStatus( *this, *this, nF_fin_CreateWithoutText, false );
348cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_finPunctuation
349cdf0e10cSrcweir = new StmBoundsStatus( *this, *this, nF_fin_CreateWithText, false );
350cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_finBiType
351cdf0e10cSrcweir = new StmBoundsStatus( *this, *this, nF_fin_CreateWithText, false );
352cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_finTypeModifier
353cdf0e10cSrcweir = new StmBoundsStatus( *this, *this, nF_fin_CreateWithText, false );
354cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_finEOL
355cdf0e10cSrcweir = new StmBoundsStatus( *this, *this, nF_fin_EOL, false );
356cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_finEOF
357cdf0e10cSrcweir = new StmBoundsStatus( *this, TkpContext::Null_(), nF_fin_EOF, false );
358cdf0e10cSrcweir
359cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_gotoComment
360cdf0e10cSrcweir = new StmBoundsStatus( *this, *pContext_Comment, nF_goto_Comment, false );
361cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_gotoDocu
362cdf0e10cSrcweir = new StmBoundsStatus( *this, *pDocuContext, nF_goto_Docu, false );
363cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_gotoPreprocessor
364cdf0e10cSrcweir = new StmBoundsStatus( *this, *pContext_Preprocessor, nF_goto_Preprocessor, false );
365cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_gotoConstString
366cdf0e10cSrcweir = new StmBoundsStatus( *this, *pContext_ConstString, nF_goto_Const, false );
367cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_gotoConstChar
368cdf0e10cSrcweir = new StmBoundsStatus( *this, *pContext_ConstChar, nF_goto_Const, false );
369cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_gotoConstNumeric
370cdf0e10cSrcweir = new StmBoundsStatus( *this, *pContext_ConstNumeric, nF_goto_Const, false );
371cdf0e10cSrcweir DYN StmBoundsStatus * dpBst_gotoUnblockMacro
372cdf0e10cSrcweir = new StmBoundsStatus( *this, *pContext_UnblockMacro, nF_goto_UnblockMacro, false );
373cdf0e10cSrcweir
374cdf0e10cSrcweir // dpMain aufbauen:
375cdf0e10cSrcweir aStateMachine.AddStatus(dpStatusTop);
376cdf0e10cSrcweir
377cdf0e10cSrcweir aStateMachine.AddStatus(dpStatusWhite);
378cdf0e10cSrcweir aStateMachine.AddStatus(dpStatusBez);
379cdf0e10cSrcweir
380cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_finError);
381cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_finIgnore);
382cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_finBezeichner);
383cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_finKeyword);
384cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_finPunctuation);
385cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_finBiType);
386cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_finTypeModifier);
387cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_finEOL);
388cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_finEOF);
389cdf0e10cSrcweir
390cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_gotoComment);
391cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_gotoDocu);
392cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_gotoPreprocessor);
393cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_gotoConstString);
394cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_gotoConstChar);
395cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_gotoConstNumeric);
396cdf0e10cSrcweir aStateMachine.AddStatus(dpBst_gotoUnblockMacro);
397cdf0e10cSrcweir
398cdf0e10cSrcweir // Identifier
399cdf0e10cSrcweir
400cdf0e10cSrcweir // Keywords and other unique Tokens
401cdf0e10cSrcweir aStateMachine.AddToken("operator",TCF_operator,A_nBezDefStatus,finKeyword);
402cdf0e10cSrcweir aStateMachine.AddToken("class",TCF_class,A_nBezDefStatus,finKeyword);
403cdf0e10cSrcweir aStateMachine.AddToken("struct",TCF_struct,A_nBezDefStatus,finKeyword);
404cdf0e10cSrcweir aStateMachine.AddToken("union",TCF_union,A_nBezDefStatus,finKeyword);
405cdf0e10cSrcweir aStateMachine.AddToken("enum",TCF_enum,A_nBezDefStatus,finKeyword);
406cdf0e10cSrcweir aStateMachine.AddToken("typedef",TCF_typedef,A_nBezDefStatus,finKeyword);
407cdf0e10cSrcweir aStateMachine.AddToken("public",TCF_public,A_nBezDefStatus,finKeyword);
408cdf0e10cSrcweir aStateMachine.AddToken("protected",TCF_protected,A_nBezDefStatus,finKeyword);
409cdf0e10cSrcweir aStateMachine.AddToken("private",TCF_private,A_nBezDefStatus,finKeyword);
410cdf0e10cSrcweir aStateMachine.AddToken("template",TCF_template,A_nBezDefStatus,finKeyword);
411cdf0e10cSrcweir aStateMachine.AddToken("virtual",TCF_virtual,A_nBezDefStatus,finKeyword);
412cdf0e10cSrcweir aStateMachine.AddToken("friend",TCF_friend,A_nBezDefStatus,finKeyword);
413cdf0e10cSrcweir aStateMachine.AddToken("~",TCF_Tilde,A_nOperatorDefStatus,finKeyword);
414cdf0e10cSrcweir aStateMachine.AddToken("const",TCF_const,A_nBezDefStatus,finKeyword);
415cdf0e10cSrcweir aStateMachine.AddToken("volatile",TCF_volatile,A_nBezDefStatus,finKeyword);
416cdf0e10cSrcweir aStateMachine.AddToken("extern",TCF_extern,A_nBezDefStatus,finKeyword);
417cdf0e10cSrcweir aStateMachine.AddToken("static",TCF_static,A_nBezDefStatus,finKeyword);
418cdf0e10cSrcweir aStateMachine.AddToken("mutable",TCF_mutable,A_nBezDefStatus,finKeyword);
419cdf0e10cSrcweir aStateMachine.AddToken("register",TCF_register,A_nBezDefStatus,finKeyword);
420cdf0e10cSrcweir aStateMachine.AddToken("inline",TCF_inline,A_nBezDefStatus,finKeyword);
421cdf0e10cSrcweir aStateMachine.AddToken("explicit",TCF_explicit,A_nBezDefStatus,finKeyword);
422cdf0e10cSrcweir aStateMachine.AddToken("namespace",TCF_namespace,A_nBezDefStatus,finKeyword);
423cdf0e10cSrcweir aStateMachine.AddToken("using",TCF_using,A_nBezDefStatus,finKeyword);
424cdf0e10cSrcweir aStateMachine.AddToken("throw",TCF_throw,A_nBezDefStatus,finKeyword);
425cdf0e10cSrcweir aStateMachine.AddToken("{",TCF_SwBracketOpen,A_nOperatorDefStatus,finKeyword);
426cdf0e10cSrcweir aStateMachine.AddToken("}",TCF_SwBracketClose,A_nOperatorDefStatus,finKeyword);
427cdf0e10cSrcweir aStateMachine.AddToken("[",TCF_ArBracketOpen,A_nOperatorDefStatus,finKeyword);
428cdf0e10cSrcweir aStateMachine.AddToken("]",TCF_ArBracketClose,A_nOperatorDefStatus,finKeyword);
429cdf0e10cSrcweir aStateMachine.AddToken("(",TCF_BracketOpen,A_nOperatorDefStatus,finKeyword);
430cdf0e10cSrcweir aStateMachine.AddToken(")",TCF_BracketClose,A_nOperatorDefStatus,finKeyword);
431cdf0e10cSrcweir aStateMachine.AddToken("::",TCF_DblColon,A_nOperatorDefStatus,finKeyword);
432cdf0e10cSrcweir aStateMachine.AddToken(";",TCF_Semikolon,A_nOperatorDefStatus,finKeyword);
433cdf0e10cSrcweir aStateMachine.AddToken(",",TCF_Komma,A_nOperatorDefStatus,finKeyword);
434cdf0e10cSrcweir aStateMachine.AddToken(":",TCF_Colon,A_nOperatorDefStatus,finKeyword);
435cdf0e10cSrcweir aStateMachine.AddToken("=",TCF_Zuweisung,A_nOperatorDefStatus,finKeyword);
436cdf0e10cSrcweir aStateMachine.AddToken("<",TCF_Smaller,A_nOperatorDefStatus,finKeyword);
437cdf0e10cSrcweir aStateMachine.AddToken(">",TCF_Bigger,A_nOperatorDefStatus,finKeyword);
438cdf0e10cSrcweir aStateMachine.AddToken("*",TCF_Stern,A_nOperatorDefStatus,finKeyword);
439cdf0e10cSrcweir aStateMachine.AddToken("&",TCF_Ampersand,A_nOperatorDefStatus,finKeyword);
440cdf0e10cSrcweir aStateMachine.AddToken("...",TCF_Ellipse,A_nOperatorDefStatus,finKeyword);
441cdf0e10cSrcweir aStateMachine.AddToken("typename",TCF_typename,A_nOperatorDefStatus,finKeyword);
442cdf0e10cSrcweir
443cdf0e10cSrcweir // Operators
444cdf0e10cSrcweir aStateMachine.AddToken("==",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
445cdf0e10cSrcweir aStateMachine.AddToken("!=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
446cdf0e10cSrcweir aStateMachine.AddToken("<=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
447cdf0e10cSrcweir aStateMachine.AddToken(">=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
448cdf0e10cSrcweir aStateMachine.AddToken("&&",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
449cdf0e10cSrcweir aStateMachine.AddToken("||",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
450cdf0e10cSrcweir aStateMachine.AddToken("!",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
451cdf0e10cSrcweir aStateMachine.AddToken("new",TCF_Operator,A_nBezDefStatus,finPunctuation);
452cdf0e10cSrcweir aStateMachine.AddToken("delete",TCF_Operator,A_nBezDefStatus,finPunctuation);
453cdf0e10cSrcweir aStateMachine.AddToken("sizeof",TCF_Operator,A_nBezDefStatus,finPunctuation);
454cdf0e10cSrcweir aStateMachine.AddToken("typeid",TCF_Operator,A_nBezDefStatus,finPunctuation);
455cdf0e10cSrcweir aStateMachine.AddToken("+",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
456cdf0e10cSrcweir aStateMachine.AddToken("-",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
457cdf0e10cSrcweir aStateMachine.AddToken("/",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
458cdf0e10cSrcweir aStateMachine.AddToken("%",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
459cdf0e10cSrcweir aStateMachine.AddToken("^",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
460cdf0e10cSrcweir aStateMachine.AddToken("|",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
461cdf0e10cSrcweir aStateMachine.AddToken("<<",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
462cdf0e10cSrcweir aStateMachine.AddToken(">>",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
463cdf0e10cSrcweir aStateMachine.AddToken(".",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
464cdf0e10cSrcweir aStateMachine.AddToken("->",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
465cdf0e10cSrcweir aStateMachine.AddToken("?",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
466cdf0e10cSrcweir aStateMachine.AddToken("+=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
467cdf0e10cSrcweir aStateMachine.AddToken("-=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
468cdf0e10cSrcweir aStateMachine.AddToken("*=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
469cdf0e10cSrcweir aStateMachine.AddToken("/=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
470cdf0e10cSrcweir aStateMachine.AddToken("%=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
471cdf0e10cSrcweir aStateMachine.AddToken("&=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
472cdf0e10cSrcweir aStateMachine.AddToken("|=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
473cdf0e10cSrcweir aStateMachine.AddToken("^=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
474cdf0e10cSrcweir aStateMachine.AddToken("<<=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
475cdf0e10cSrcweir aStateMachine.AddToken(">>=",TCF_Operator,A_nOperatorDefStatus,finPunctuation);
476cdf0e10cSrcweir
477cdf0e10cSrcweir // Builtin types
478cdf0e10cSrcweir aStateMachine.AddToken("char", TCF_BuiltInType, A_nBezDefStatus, finBiType);
479cdf0e10cSrcweir aStateMachine.AddToken("short", TCF_BuiltInType, A_nBezDefStatus, finBiType);
480cdf0e10cSrcweir aStateMachine.AddToken("int", TCF_BuiltInType, A_nBezDefStatus, finBiType);
481cdf0e10cSrcweir aStateMachine.AddToken("long", TCF_BuiltInType, A_nBezDefStatus, finBiType);
482cdf0e10cSrcweir aStateMachine.AddToken("float", TCF_BuiltInType, A_nBezDefStatus, finBiType);
483cdf0e10cSrcweir aStateMachine.AddToken("double",TCF_BuiltInType, A_nBezDefStatus, finBiType);
484cdf0e10cSrcweir aStateMachine.AddToken("wchar_t",TCF_BuiltInType, A_nBezDefStatus, finBiType);
485cdf0e10cSrcweir aStateMachine.AddToken("size_t",TCF_BuiltInType, A_nBezDefStatus, finBiType);
486cdf0e10cSrcweir
487cdf0e10cSrcweir // Type modifiers
488cdf0e10cSrcweir aStateMachine.AddToken("signed", TCF_TypeModifier, A_nBezDefStatus, finTypeModifier);
489cdf0e10cSrcweir aStateMachine.AddToken("unsigned", TCF_TypeModifier, A_nBezDefStatus, finTypeModifier);
490cdf0e10cSrcweir
491cdf0e10cSrcweir // To ignore
492cdf0e10cSrcweir aStateMachine.AddToken("auto", 0, A_nBezDefStatus, finIgnore);
493cdf0e10cSrcweir aStateMachine.AddToken("_cdecl", 0, A_nBezDefStatus, finIgnore);
494cdf0e10cSrcweir aStateMachine.AddToken("__cdecl", 0, A_nBezDefStatus, finIgnore);
495cdf0e10cSrcweir aStateMachine.AddToken("__stdcall", 0, A_nBezDefStatus, finIgnore);
496cdf0e10cSrcweir aStateMachine.AddToken("__fastcall",0, A_nBezDefStatus, finIgnore);
497cdf0e10cSrcweir aStateMachine.AddToken("/**/", 0, A_nOperatorDefStatus,finIgnore);
498cdf0e10cSrcweir
499cdf0e10cSrcweir // Context changers
500cdf0e10cSrcweir aStateMachine.AddToken("#", 0, A_nOperatorDefStatus, gotoPreprocessor);
501cdf0e10cSrcweir aStateMachine.AddToken("#undef",0, A_nOperatorDefStatus, gotoPreprocessor);
502cdf0e10cSrcweir aStateMachine.AddToken("#unblock-",
503cdf0e10cSrcweir 0, A_nOperatorDefStatus, gotoUnblockMacro);
504cdf0e10cSrcweir aStateMachine.AddToken("/*", 0, A_nOperatorDefStatus, gotoComment);
505cdf0e10cSrcweir aStateMachine.AddToken("//", 0, A_nOperatorDefStatus, gotoComment);
506cdf0e10cSrcweir aStateMachine.AddToken("/**", 0, A_nOperatorDefStatus, gotoDocu);
507cdf0e10cSrcweir aStateMachine.AddToken("///", 0, A_nOperatorDefStatus, gotoDocu);
508cdf0e10cSrcweir
509cdf0e10cSrcweir // Line ends
510cdf0e10cSrcweir // regular
511cdf0e10cSrcweir aStateMachine.AddToken("\r\n", 0, A_nOperatorDefStatus, finEOL);
512cdf0e10cSrcweir aStateMachine.AddToken("\n", 0, A_nOperatorDefStatus, finEOL);
513cdf0e10cSrcweir aStateMachine.AddToken("\r", 0, A_nOperatorDefStatus, finEOL);
514cdf0e10cSrcweir // To ignore in some cases(may be only at preprocessor?), but
515cdf0e10cSrcweir // linecount has to be incremented.
516cdf0e10cSrcweir aStateMachine.AddToken("\\\r\n",0, A_nOperatorDefStatus, finEOL);
517cdf0e10cSrcweir aStateMachine.AddToken("\\\n", 0, A_nOperatorDefStatus, finEOL);
518cdf0e10cSrcweir aStateMachine.AddToken("\\\r", 0, A_nOperatorDefStatus, finEOL);
519cdf0e10cSrcweir };
520cdf0e10cSrcweir
521cdf0e10cSrcweir
522cdf0e10cSrcweir } // namespace cpp
523cdf0e10cSrcweir
524