1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 #include <precomp.h> 29 #include <s2_luidl/cx_idlco.hxx> 30 31 32 // NOT FULLY DECLARED SERVICES 33 #include <s2_luidl/cx_sub.hxx> 34 #include <s2_dsapi/cx_dsapi.hxx> 35 #include <tools/tkpchars.hxx> 36 #include <tokens/tkpstam2.hxx> 37 #include <s2_luidl/tk_ident.hxx> 38 #include <s2_luidl/tk_keyw.hxx> 39 #include <s2_luidl/tk_punct.hxx> 40 #include <s2_luidl/tokrecv.hxx> 41 #include <x_parse2.hxx> 42 43 44 namespace csi 45 { 46 namespace uidl 47 { 48 49 50 const intt C_nCppInitialNrOfStati = 400; 51 const intt C_nStatusSize = 128; 52 53 54 55 const uintt nF_fin_Error = 1; 56 const uintt nF_fin_Ignore = 2; 57 const uintt nF_fin_Identifier = 3; 58 const uintt nF_fin_Keyword = 4; 59 const uintt nF_fin_Punctuation = 5; 60 const uintt nF_fin_EOL = 6; 61 const uintt nF_fin_EOF = 7; 62 63 const uintt nF_goto_MLDocu = 10; 64 const uintt nF_goto_SLDocu = 11; 65 const uintt nF_goto_MLComment = 12; 66 const uintt nF_goto_SLComment = 13; 67 const uintt nF_goto_Praeprocessor = 14; 68 const uintt nF_goto_Assignment = 15; 69 70 71 72 const UINT16 nTok_bty_any = 100 + TokBuiltInType::bty_any; 73 const UINT16 nTok_bty_boolean = 100 + TokBuiltInType::bty_boolean; 74 const UINT16 nTok_bty_byte = 100 + TokBuiltInType::bty_byte; 75 const UINT16 nTok_bty_char = 100 + TokBuiltInType::bty_char; 76 const UINT16 nTok_bty_double = 100 + TokBuiltInType::bty_double; 77 const UINT16 nTok_bty_hyper = 100 + TokBuiltInType::bty_hyper; 78 const UINT16 nTok_bty_long = 100 + TokBuiltInType::bty_long; 79 const UINT16 nTok_bty_short = 100 + TokBuiltInType::bty_short; 80 const UINT16 nTok_bty_string = 100 + TokBuiltInType::bty_string; 81 const UINT16 nTok_bty_void = 100 + TokBuiltInType::bty_void; 82 const UINT16 nTok_bty_ellipse = 100 + TokBuiltInType::bty_ellipse; 83 84 const UINT16 nTok_tmod_unsigned = 200 + TokTypeModifier::tmod_unsigned; 85 const UINT16 nTok_tmod_sequence = 200 + TokTypeModifier::tmod_sequence; 86 87 const UINT16 nTok_ph_in = 250 + TokParameterHandling::ph_in; 88 const UINT16 nTok_ph_out = 250 + TokParameterHandling::ph_out; 89 const UINT16 nTok_ph_inout = 250 + TokParameterHandling::ph_inout; 90 91 const UINT16 nTok_mt_attribute = 300 + TokMetaType::mt_attribute; 92 const UINT16 nTok_mt_constants = 300 + TokMetaType::mt_constants; 93 const UINT16 nTok_mt_enum = 300 + TokMetaType::mt_enum; 94 const UINT16 nTok_mt_exception = 300 + TokMetaType::mt_exception; 95 const UINT16 nTok_mt_ident = 300 + TokMetaType::mt_ident; 96 const UINT16 nTok_mt_interface = 300 + TokMetaType::mt_interface; 97 const UINT16 nTok_mt_module = 300 + TokMetaType::mt_module; 98 const UINT16 nTok_mt_property = 300 + TokMetaType::mt_property; 99 const UINT16 nTok_mt_service = 300 + TokMetaType::mt_service; 100 const UINT16 nTok_mt_singleton = 300 + TokMetaType::mt_singleton; 101 const UINT16 nTok_mt_struct = 300 + TokMetaType::mt_struct; 102 const UINT16 nTok_mt_typedef = 300 + TokMetaType::mt_typedef; 103 const UINT16 nTok_mt_uik = 300 + TokMetaType::mt_uik; 104 105 const UINT16 nTok_ste_bound = 400 + TokStereotype::ste_bound; 106 const UINT16 nTok_ste_constrained = 400 + TokStereotype::ste_constrained; 107 const UINT16 nTok_ste_const = 400 + TokStereotype::ste_const; 108 const UINT16 nTok_ste_maybeambiguous = 400 + TokStereotype::ste_maybeambiguous; 109 const UINT16 nTok_ste_maybedefault = 400 + TokStereotype::ste_maybedefault; 110 const UINT16 nTok_ste_maybevoid = 400 + TokStereotype::ste_maybevoid; 111 const UINT16 nTok_ste_oneway = 400 + TokStereotype::ste_oneway; 112 const UINT16 nTok_ste_optional = 400 + TokStereotype::ste_optional; 113 const UINT16 nTok_ste_readonly = 400 + TokStereotype::ste_readonly; 114 const UINT16 nTok_ste_removable = 400 + TokStereotype::ste_removable; 115 const UINT16 nTok_ste_virtual = 400 + TokStereotype::ste_virtual; 116 const UINT16 nTok_ste_transient = 400 + TokStereotype::ste_transient; 117 const UINT16 nTok_ste_published = 400 + TokStereotype::ste_published; 118 119 const UINT16 nTok_raises = 501; 120 const UINT16 nTok_needs = 502; 121 const UINT16 nTok_observes = 503; 122 123 const UINT16 nTok_assignment = 550; 124 125 const UINT16 nTok_ignore = 600; 126 const UINT16 nTok_none_MLCommentBegin = 601; 127 const UINT16 nTok_none_SLCommentBegin = 602; 128 const UINT16 nTok_none_MLDocuBegin = 603; 129 const UINT16 nTok_none_SLDocuBegin = 604; 130 const UINT16 nTok_none_PraeprocessorBegin = 605; 131 132 133 const UINT16 nTok_punct_BracketOpen = 700 + TokPunctuation::BracketOpen; 134 const UINT16 nTok_punct_BracketClose = 700 + TokPunctuation::BracketClose; 135 const UINT16 nTok_punct_ArrayBracketOpen = 700 + TokPunctuation::ArrayBracketOpen; 136 const UINT16 nTok_punct_ArrayBracketClose = 700 + TokPunctuation::ArrayBracketClose; 137 const UINT16 nTok_punct_CurledBracketOpen = 700 + TokPunctuation::CurledBracketOpen; 138 const UINT16 nTok_punct_CurledBracketClose = 700 + TokPunctuation::CurledBracketClose; 139 const UINT16 nTok_punct_Semicolon = 700 + TokPunctuation::Semicolon; 140 const UINT16 nTok_punct_Colon = 700 + TokPunctuation::Colon; 141 const UINT16 nTok_punct_DoubleColon = 700 + TokPunctuation::DoubleColon; 142 const UINT16 nTok_punct_Comma = 700 + TokPunctuation::Comma; 143 const UINT16 nTok_punct_Minus = 700 + TokPunctuation::Minus; 144 const UINT16 nTok_punct_Fullstop = 700 + TokPunctuation::Fullstop; 145 const UINT16 nTok_punct_Lesser = 700 + TokPunctuation::Lesser; 146 const UINT16 nTok_punct_Greater = 700 + TokPunctuation::Greater; 147 148 const UINT16 nTok_EOL = 801; 149 const UINT16 nTok_EOF = 802; 150 151 152 153 Context_UidlCode::Context_UidlCode( Token_Receiver & o_rReceiver, 154 DYN TkpDocuContext & let_drContext_Docu ) 155 : aStateMachine(C_nStatusSize,C_nCppInitialNrOfStati), 156 pReceiver(&o_rReceiver), 157 pDocuContext(&let_drContext_Docu), 158 dpContext_MLComment(0), 159 dpContext_SLComment(0), 160 dpContext_Preprocessor(0), 161 dpContext_Assignment(0), 162 pNewToken(0), 163 pFollowUpContext(0) 164 { 165 dpContext_MLComment = new Context_MLComment(o_rReceiver,*this), 166 dpContext_SLComment = new Context_SLComment(o_rReceiver,*this), 167 dpContext_Preprocessor = new Context_Praeprocessor(o_rReceiver,*this), 168 dpContext_Assignment = new Context_Assignment(o_rReceiver,*this), 169 170 pDocuContext->SetParentContext(*this,"*/"); 171 SetupStateMachine(); 172 } 173 174 Context_UidlCode::~Context_UidlCode() 175 { 176 } 177 178 void 179 Context_UidlCode::ReadCharChain( CharacterSource & io_rText ) 180 { 181 pNewToken = 0; 182 183 UINT16 nTokenId = 0; 184 StmBoundsStatu2 & rBound = aStateMachine.GetCharChain(nTokenId, io_rText); 185 186 // !!! 187 // The order of the next two lines is essential, because 188 // pFollowUpContext may be changed by PerformStatusFunction() also, 189 // which then MUST override the previous assignment. 190 pFollowUpContext = rBound.FollowUpContext(); 191 PerformStatusFunction(rBound.StatusFunctionNr(), nTokenId, io_rText); 192 } 193 194 bool 195 Context_UidlCode::PassNewToken() 196 { 197 if (pNewToken) 198 { 199 pReceiver->Receive(*pNewToken.Release()); 200 return true; 201 } 202 return false; 203 } 204 205 TkpContext & 206 Context_UidlCode::FollowUpContext() 207 { 208 csv_assert(pFollowUpContext != 0); 209 return *pFollowUpContext; 210 } 211 212 void 213 Context_UidlCode::PerformStatusFunction( uintt i_nStatusSignal, 214 UINT16 i_nTokenId, 215 CharacterSource & io_rText ) 216 { 217 switch (i_nStatusSignal) 218 { 219 case nF_fin_Error: 220 // KORR_FUTURE 221 throw X_AutodocParser(X_AutodocParser::x_InvalidChar); 222 // no break, because of throw 223 case nF_fin_Ignore: 224 pNewToken = 0; 225 io_rText.CutToken(); 226 break; 227 case nF_fin_Identifier: 228 pNewToken = new TokIdentifier(io_rText.CutToken()); 229 break; 230 case nF_fin_Keyword: 231 io_rText.CutToken(); 232 switch ( i_nTokenId / 50 ) 233 { 234 case 2: 235 pNewToken = new TokBuiltInType(i_nTokenId - 100); 236 break; 237 case 4: 238 pNewToken = new TokTypeModifier(i_nTokenId - 200); 239 break; 240 case 5: 241 pNewToken = new TokParameterHandling(i_nTokenId - 250); 242 break; 243 case 6: 244 pNewToken = new TokMetaType(i_nTokenId - 300); 245 break; 246 case 8: 247 pNewToken = new TokStereotype(i_nTokenId - 400); 248 break; 249 case 10: 250 switch (i_nTokenId-500) 251 { 252 case 1: 253 pNewToken = new TokRaises; 254 break; 255 case 2: 256 pNewToken = new TokNeeds; 257 break; 258 case 3: 259 pNewToken = new TokObserves; 260 break; 261 default: 262 csv_assert(false); 263 } 264 break; 265 default: 266 csv_assert(false); 267 } // end switch ( i_nTokenId / 50 ) 268 break; 269 case nF_fin_Punctuation: 270 io_rText.CutToken(); 271 if (i_nTokenId == nTok_punct_DoubleColon) 272 pNewToken = new TokNameSeparator; 273 else 274 pNewToken = new TokPunctuation(i_nTokenId - 700); 275 break; 276 case nF_fin_EOL: 277 io_rText.CutToken(); 278 pNewToken = new Tok_EOL; 279 pReceiver->Increment_CurLine(); 280 break; 281 case nF_fin_EOF: 282 pNewToken = new Tok_EOF; 283 break; 284 case nF_goto_MLDocu: 285 while ( io_rText.CurChar() == '*') 286 io_rText.MoveOn(); 287 io_rText.CutToken(); 288 pDocuContext->SetMode_IsMultiLine(true); 289 break; 290 case nF_goto_SLDocu: 291 io_rText.CutToken(); 292 pDocuContext->SetMode_IsMultiLine(false); 293 break; 294 case nF_goto_MLComment: 295 break; 296 case nF_goto_SLComment: 297 break; 298 case nF_goto_Praeprocessor: 299 break; 300 case nF_goto_Assignment: 301 break; 302 default: 303 csv_assert(false); 304 } // end switch (i_nStatusSignal) 305 } 306 307 void 308 Context_UidlCode::SetupStateMachine() 309 { 310 // Besondere Array-Stati (kein Tokenabschluss oder Kontextwechsel): 311 // const INT16 top = 0; // Top-Status 312 const INT16 wht = 1; // Whitespace-�berlese-Status 313 const INT16 bez = 2; // Bezeichner-lese-Status 314 315 // Tokenfinish-Stati: 316 const INT16 finErr = 3; 317 const INT16 finIgn = 4; 318 const INT16 finBez = 5; 319 const INT16 finKeyw = 6; 320 const INT16 finPunct = 7; 321 const INT16 finEOL = 8; 322 const INT16 finEOF = 9; 323 324 // Kontextwechsel-Stati: 325 const INT16 gotoMld = 10; 326 const INT16 gotoSld = 11; 327 const INT16 gotoMlc = 12; 328 const INT16 gotoSlc = 13; 329 const INT16 gotoPrp = 14; 330 const INT16 gotoAsg = 15; 331 332 // Konstanten zur Benutzung in der Tabelle: 333 const INT16 err = finErr; 334 const INT16 fbz = finBez; 335 const INT16 fig = finIgn; 336 const INT16 fof = finEOF; 337 // const INT16 fkw = finKeyw; 338 // const INT16 fpc = finPunct; 339 340 /// Die '0'en werden spaeter durch AddToken() ersetzt. 341 342 const INT16 A_nTopStatus[C_nStatusSize] = 343 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 344 {fof,err,err,err,err,err,err,err,err,wht, 0,wht,wht, 0,err,err, 345 err,err,err,err,err,err,err,err,err,err,fof,err,err,err,err,err, // 16 ... 346 wht,err,wht, 0,err,err,err,err, 0, 0,err,err, 0, 0, 0,err, 347 bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,err,err,err,err,err,err, // 48 ... 348 err,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 349 bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 0,err, 0,err,bez, // 80 ... 350 err,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 351 bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 0,err, 0,err,err, // 112 ... 352 }; 353 354 const INT16 A_nWhitespaceStatus[C_nStatusSize] = 355 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 356 {fof,err,err,err,err,err,err,err,err,wht,fig,wht,wht,fig,err,err, 357 err,err,err,err,err,err,err,err,err,err,fof,err,err,err,err,err, // 16 ... 358 wht,fig,wht,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig, 359 fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig, // 48 ... 360 fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig, 361 fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig, // 80 ... 362 fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig, 363 fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,fig,err // 112 ... 364 }; 365 366 const INT16 A_nBezeichnerStatus[C_nStatusSize] = 367 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 368 {fbz,err,err,err,err,err,err,err,err,fbz,fbz,fbz,fbz,fbz,err,err, 369 err,err,err,err,err,err,err,err,err,err,fbz,err,err,err,err,err, // 16 ... 370 fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz, 371 bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,fbz,fbz, // 48 ... 372 fbz,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 373 bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,bez, // 80 ... 374 fbz,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 375 bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,err // 112 ... 376 }; 377 378 const INT16 A_nPunctDefStatus[C_nStatusSize] = 379 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 380 {err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, 381 err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, // 16 ... 382 err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, 383 err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, // 48 ... 384 err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, 385 err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, // 80 ... 386 err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err, 387 err,err,err,err,err,err,err,err,err,err,err,err,err,err,err,err // 112 ... 388 }; 389 390 const INT16 A_nKeywordDefStatus[C_nStatusSize] = 391 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 392 {fbz,err,err,err,err,err,err,err,err,fbz,fbz,fbz,fbz,fbz,err,err, 393 err,err,err,err,err,err,err,err,err,err,fbz,err,err,err,err,err, // 16 ... 394 fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz,fbz, 395 bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,fbz,fbz, // 48 ... 396 fbz,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 397 bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,bez, // 80 ... 398 fbz,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez, 399 bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,bez,fbz,fbz,fbz,fbz,err // 112 ... 400 }; 401 402 DYN StmArrayStatu2 * dpStatusTop 403 = new StmArrayStatu2( C_nStatusSize, A_nTopStatus, 0, true); 404 DYN StmArrayStatu2 * dpStatusWhite 405 = new StmArrayStatu2( C_nStatusSize, A_nWhitespaceStatus, 0, true); 406 DYN StmArrayStatu2 * dpStatusBez 407 = new StmArrayStatu2( C_nStatusSize, A_nBezeichnerStatus, 0, true); 408 409 DYN StmBoundsStatu2 * dpBst_finErr 410 = new StmBoundsStatu2( *this, TkpContext_Null2_(), nF_fin_Error, true ); 411 DYN StmBoundsStatu2 * dpBst_finIgn 412 = new StmBoundsStatu2( *this, *this, nF_fin_Ignore, true ); 413 DYN StmBoundsStatu2 * dpBst_finBez 414 = new StmBoundsStatu2( *this, *this, nF_fin_Identifier, true ); 415 DYN StmBoundsStatu2 * dpBst_finKeyw 416 = new StmBoundsStatu2( *this, *this, nF_fin_Keyword, false ); 417 DYN StmBoundsStatu2 * dpBst_finPunct 418 = new StmBoundsStatu2( *this, *this, nF_fin_Punctuation, false ); 419 DYN StmBoundsStatu2 * dpBst_finEOL 420 = new StmBoundsStatu2( *this, *this, nF_fin_EOL, false ); 421 DYN StmBoundsStatu2 * dpBst_finEOF 422 = new StmBoundsStatu2( *this, TkpContext_Null2_(), nF_fin_EOF, false ); 423 424 DYN StmBoundsStatu2 * dpBst_gotoMld 425 = new StmBoundsStatu2( *this, *pDocuContext, nF_goto_MLDocu, false ); 426 DYN StmBoundsStatu2 * dpBst_gotoSld 427 = new StmBoundsStatu2( *this, *pDocuContext, nF_goto_SLDocu, false ); 428 DYN StmBoundsStatu2 * dpBst_gotoMlc 429 = new StmBoundsStatu2( *this, *dpContext_MLComment, nF_goto_MLComment, false ); 430 DYN StmBoundsStatu2 * dpBst_gotoSlc 431 = new StmBoundsStatu2( *this, *dpContext_SLComment, nF_goto_SLComment, false ); 432 DYN StmBoundsStatu2 * dpBst_gotoPrp 433 = new StmBoundsStatu2( *this, *dpContext_Preprocessor, nF_goto_Praeprocessor, false ); 434 DYN StmBoundsStatu2 * dpBst_gotoAsg 435 = new StmBoundsStatu2( *this, *dpContext_Assignment, nF_goto_Assignment, false ); 436 437 // dpMain aufbauen: 438 aStateMachine.AddStatus(dpStatusTop); 439 440 aStateMachine.AddStatus(dpStatusWhite); 441 aStateMachine.AddStatus(dpStatusBez); 442 443 aStateMachine.AddStatus(dpBst_finErr); 444 aStateMachine.AddStatus(dpBst_finIgn); 445 aStateMachine.AddStatus(dpBst_finBez); 446 aStateMachine.AddStatus(dpBst_finKeyw); 447 aStateMachine.AddStatus(dpBst_finPunct); 448 aStateMachine.AddStatus(dpBst_finEOL); 449 aStateMachine.AddStatus(dpBst_finEOF); 450 451 aStateMachine.AddStatus(dpBst_gotoMld); 452 aStateMachine.AddStatus(dpBst_gotoSld); 453 aStateMachine.AddStatus(dpBst_gotoMlc); 454 aStateMachine.AddStatus(dpBst_gotoSlc); 455 aStateMachine.AddStatus(dpBst_gotoPrp); 456 aStateMachine.AddStatus(dpBst_gotoAsg); 457 458 aStateMachine.AddToken("any", nTok_bty_any, A_nKeywordDefStatus, finKeyw); 459 aStateMachine.AddToken("attribute", nTok_mt_attribute, A_nKeywordDefStatus, finKeyw); 460 aStateMachine.AddToken("boolean", nTok_bty_boolean, A_nKeywordDefStatus, finKeyw); 461 aStateMachine.AddToken("bound", nTok_ste_bound, A_nKeywordDefStatus, finKeyw); 462 aStateMachine.AddToken("byte", nTok_bty_byte, A_nKeywordDefStatus, finKeyw); 463 aStateMachine.AddToken("char", nTok_bty_char, A_nKeywordDefStatus, finKeyw); 464 aStateMachine.AddToken("const", nTok_ste_const, A_nKeywordDefStatus, finKeyw); 465 aStateMachine.AddToken("constants", nTok_mt_constants, A_nKeywordDefStatus, finKeyw); 466 aStateMachine.AddToken("constrained", 467 nTok_ste_constrained, A_nKeywordDefStatus, finKeyw); 468 aStateMachine.AddToken("double", nTok_bty_double, A_nKeywordDefStatus, finKeyw); 469 aStateMachine.AddToken("enum", nTok_mt_enum, A_nKeywordDefStatus, finKeyw); 470 aStateMachine.AddToken("exception", nTok_mt_exception, A_nKeywordDefStatus, finKeyw); 471 aStateMachine.AddToken("hyper", nTok_bty_hyper, A_nKeywordDefStatus, finKeyw); 472 aStateMachine.AddToken("ident", nTok_mt_ident, A_nKeywordDefStatus, finKeyw); 473 aStateMachine.AddToken("in", nTok_ph_in, A_nKeywordDefStatus, finKeyw); 474 aStateMachine.AddToken("inout", nTok_ph_inout, A_nKeywordDefStatus, finKeyw); 475 aStateMachine.AddToken("interface", nTok_mt_interface, A_nKeywordDefStatus, finKeyw); 476 aStateMachine.AddToken("long", nTok_bty_long, A_nKeywordDefStatus, finKeyw); 477 aStateMachine.AddToken("maybeambiguous", 478 nTok_ste_maybeambiguous,A_nKeywordDefStatus, finKeyw); 479 aStateMachine.AddToken("maybedefault", 480 nTok_ste_maybedefault, A_nKeywordDefStatus, finKeyw); 481 aStateMachine.AddToken("maybevoid", nTok_ste_maybevoid, A_nKeywordDefStatus, finKeyw); 482 aStateMachine.AddToken("module", nTok_mt_module, A_nKeywordDefStatus, finKeyw); 483 aStateMachine.AddToken("needs", nTok_needs, A_nKeywordDefStatus, finKeyw); 484 aStateMachine.AddToken("observes", nTok_observes, A_nKeywordDefStatus, finKeyw); 485 aStateMachine.AddToken("oneway", nTok_ste_oneway, A_nKeywordDefStatus, finKeyw); 486 aStateMachine.AddToken("optional", nTok_ste_optional, A_nKeywordDefStatus, finKeyw); 487 aStateMachine.AddToken("out", nTok_ph_out, A_nKeywordDefStatus, finKeyw); 488 aStateMachine.AddToken("property", nTok_mt_property, A_nKeywordDefStatus, finKeyw); 489 aStateMachine.AddToken("published", nTok_ste_published, A_nKeywordDefStatus, finKeyw); 490 aStateMachine.AddToken("raises", nTok_raises, A_nKeywordDefStatus, finKeyw); 491 aStateMachine.AddToken("readonly", nTok_ste_readonly, A_nKeywordDefStatus, finKeyw); 492 aStateMachine.AddToken("removable", nTok_ste_removable, A_nKeywordDefStatus, finKeyw); 493 aStateMachine.AddToken("sequence", nTok_tmod_sequence, A_nKeywordDefStatus, finKeyw); 494 aStateMachine.AddToken("service", nTok_mt_service, A_nKeywordDefStatus, finKeyw); 495 aStateMachine.AddToken("short", nTok_bty_short, A_nKeywordDefStatus, finKeyw); 496 aStateMachine.AddToken("singleton", nTok_mt_singleton, A_nKeywordDefStatus, finKeyw); 497 aStateMachine.AddToken("string", nTok_bty_string, A_nKeywordDefStatus, finKeyw); 498 aStateMachine.AddToken("struct", nTok_mt_struct, A_nKeywordDefStatus, finKeyw); 499 aStateMachine.AddToken("transient", nTok_ste_transient, A_nKeywordDefStatus, finKeyw); 500 aStateMachine.AddToken("typedef", nTok_mt_typedef, A_nKeywordDefStatus, finKeyw); 501 aStateMachine.AddToken("uik", nTok_mt_uik, A_nKeywordDefStatus, finKeyw); 502 aStateMachine.AddToken("unsigned", nTok_tmod_unsigned, A_nKeywordDefStatus, finKeyw); 503 aStateMachine.AddToken("virtual", nTok_ste_virtual, A_nKeywordDefStatus, finKeyw); 504 aStateMachine.AddToken("void", nTok_bty_void, A_nKeywordDefStatus, finKeyw); 505 aStateMachine.AddToken("...", nTok_bty_ellipse, A_nPunctDefStatus, finKeyw); 506 507 aStateMachine.AddToken("=", nTok_assignment, A_nPunctDefStatus, gotoAsg); 508 509 aStateMachine.AddToken("(", nTok_punct_BracketOpen, A_nPunctDefStatus, finPunct); 510 aStateMachine.AddToken(")", nTok_punct_BracketClose,A_nPunctDefStatus, finPunct); 511 aStateMachine.AddToken("[", nTok_punct_ArrayBracketOpen, 512 A_nPunctDefStatus, finIgn); 513 aStateMachine.AddToken("]", nTok_punct_ArrayBracketClose, 514 A_nPunctDefStatus, finIgn); 515 aStateMachine.AddToken("{", nTok_punct_CurledBracketOpen, 516 A_nPunctDefStatus, finPunct); 517 aStateMachine.AddToken("}", nTok_punct_CurledBracketClose, 518 A_nPunctDefStatus, finPunct); 519 aStateMachine.AddToken("<", nTok_punct_Lesser, A_nPunctDefStatus, finPunct); 520 aStateMachine.AddToken(">", nTok_punct_Greater, A_nPunctDefStatus, finPunct); 521 aStateMachine.AddToken(";", nTok_punct_Semicolon, A_nPunctDefStatus, finPunct); 522 aStateMachine.AddToken(":", nTok_punct_Colon, A_nPunctDefStatus, finPunct); 523 aStateMachine.AddToken("::", nTok_punct_DoubleColon, A_nPunctDefStatus, finPunct); 524 aStateMachine.AddToken(",", nTok_punct_Comma, A_nPunctDefStatus, finPunct); 525 aStateMachine.AddToken("-", nTok_punct_Minus, A_nPunctDefStatus, finPunct); 526 aStateMachine.AddToken(".", nTok_punct_Fullstop, A_nPunctDefStatus, finPunct); 527 aStateMachine.AddToken("/**", nTok_none_MLDocuBegin, A_nPunctDefStatus, gotoMld); 528 aStateMachine.AddToken("///", nTok_none_SLDocuBegin, A_nPunctDefStatus, gotoSld); 529 aStateMachine.AddToken("/*", nTok_none_MLCommentBegin, 530 A_nPunctDefStatus, gotoMlc); 531 aStateMachine.AddToken("//", nTok_none_SLCommentBegin, 532 A_nPunctDefStatus, gotoSlc); 533 aStateMachine.AddToken("/**/", nTok_ignore, A_nPunctDefStatus, finIgn); 534 aStateMachine.AddToken("#", nTok_none_PraeprocessorBegin, 535 A_nPunctDefStatus, gotoPrp); 536 aStateMachine.AddToken("\r\n", nTok_EOL, A_nPunctDefStatus, finEOL); 537 aStateMachine.AddToken("\r", nTok_EOL, A_nPunctDefStatus, finEOL); 538 aStateMachine.AddToken("\n", nTok_EOL, A_nPunctDefStatus, finEOL); 539 aStateMachine.AddToken("\n\r", nTok_EOL, A_nPunctDefStatus, finEOL); 540 }; 541 542 543 } // namespace uidl 544 } // namespace csi 545 546