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 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_idlc.hxx" 30 #include <idlc/errorhandler.hxx> 31 #include <idlc/astinterface.hxx> 32 33 using namespace ::rtl; 34 35 static const sal_Char* errorCodeToMessage(ErrorCode eCode) 36 { 37 switch (eCode) 38 { 39 case EIDL_NONE: 40 return "all is fine "; 41 case EIDL_SYNTAX_ERROR: 42 return ""; 43 case EIDL_REDEF: 44 return "illegal redefinition "; 45 case EIDL_REDEF_SCOPE: 46 return "illegal redefinition in scope "; 47 case EIDL_DEF_USE: 48 return "redefinition after use, "; 49 case EIDL_MULTIPLE_BRANCH: 50 return "union with duplicate branch label "; 51 case EIDL_COERCION_FAILURE: 52 return "coercion failure "; 53 case EIDL_SCOPE_CONFLICT: 54 return "definition scope is different than fwd declare scope, "; 55 case EIDL_ONEWAY_CONFLICT: 56 return "oneway operation with OUT|INOUT parameters or raises exceptions, "; 57 case EIDL_DISC_TYPE: 58 return "union with illegal discriminator type, "; 59 case EIDL_LABEL_TYPE: 60 return "label type incompatible with union discriminator type, "; 61 case EIDL_ILLEGAL_ADD: 62 return "illegal add operation, "; 63 case EIDL_ILLEGAL_USE: 64 return "illegal type used in expression, "; 65 case EIDL_ILLEGAL_RAISES: 66 return "non-exception type in raises(..) clause, "; 67 case EIDL_CANT_INHERIT: 68 return "cannot inherit "; 69 case EIDL_LOOKUP_ERROR: 70 return "error in lookup of symbol: "; 71 case EIDL_INHERIT_FWD_ERROR: 72 return ""; 73 case EIDL_CONSTANT_EXPECTED: 74 return "constant expected: "; 75 case EIDL_NAME_CASE_ERROR: 76 return "identifier used with two differing spellings: "; 77 case EIDL_ENUM_VAL_EXPECTED: 78 return "enumerator expected: "; 79 case EIDL_ENUM_VAL_NOT_FOUND: 80 return "enumerator by this name not defined: "; 81 case EIDL_EVAL_ERROR: 82 return "expression evaluation error: "; 83 case EIDL_AMBIGUOUS: 84 return "ambiguous definition: "; 85 case EIDL_DECL_NOT_DEFINED: 86 return "forward declared but never defined: "; 87 case EIDL_FWD_DECL_LOOKUP: 88 return ""; 89 case EIDL_RECURSIVE_TYPE: 90 return "illegal recursive use of type: "; 91 case EIDL_NONVOID_ONEWAY: 92 return "non-void return type in oneway operation: "; 93 case EIDL_NOT_A_TYPE: 94 return "specified symbol is not a type: "; 95 case EIDL_TYPE_NOT_VALID: 96 return "specified type is not valid in this context: "; 97 case EIDL_INTERFACEMEMBER_LOOKUP: 98 return "error in lookup of symbol, expected interface is not defined and no forward exists: "; 99 case EIDL_SERVICEMEMBER_LOOKUP: 100 return "error in lookup of symbol, expected service is not defined: "; 101 case EIDL_TYPE_IDENT_CONFLICT: 102 return "type and parameter/member name are equal: "; 103 case EIDL_ONEWAY_RAISE_CONFLICT: 104 return "oneway operation cannot raises exceptions: "; 105 case EIDL_WRONGATTRIBUTEFLAG: 106 return "the used flag is not valid in this context: "; 107 case EIDL_DEFINED_ATTRIBUTEFLAG: 108 return "flag is already set: "; 109 case EIDL_WRONGATTRIBUTEKEYWORD: 110 return "keyword not allowed: "; 111 case EIDL_MISSINGATTRIBUTEKEYWORD: 112 return "missing keyword: "; 113 case EIDL_BAD_ATTRIBUTE_FLAGS: 114 return 115 "the 'attribute' flag is mandatory, and only the 'bound' and" 116 " 'readonly' optional flags are accepted: "; 117 case EIDL_OPTIONALEXPECTED: 118 return "only the 'optional' flag is accepted: "; 119 case EIDL_MIXED_INHERITANCE: 120 return "interface inheritance declarations cannot appear in both an" 121 " interface's header and its body"; 122 case EIDL_DOUBLE_INHERITANCE: 123 return 124 "interface is (directly or indirectly) inherited more than once: "; 125 case EIDL_DOUBLE_MEMBER: 126 return 127 "member is (directly or indirectly) declared more than once: "; 128 case EIDL_CONSTRUCTOR_PARAMETER_NOT_IN: 129 return 130 "a service constructor parameter may not be an out or inout" 131 " parameter"; 132 case EIDL_CONSTRUCTOR_REST_PARAMETER_NOT_FIRST: 133 return 134 "no parameters may precede a rest parameter in a service" 135 " constructor"; 136 case EIDL_REST_PARAMETER_NOT_LAST: 137 return "no parameters may follow a rest parameter"; 138 case EIDL_REST_PARAMETER_NOT_ANY: 139 return "a rest parameter must be of type any"; 140 case EIDL_METHOD_HAS_REST_PARAMETER: 141 return "a rest parameter may not be used on an interface method"; 142 case EIDL_READONLY_ATTRIBUTE_SET_EXCEPTIONS: 143 return "a readonly attribute may not have a setter raises clause"; 144 case EIDL_UNSIGNED_TYPE_ARGUMENT: 145 return "an unsigned type cannot be used as a type argument"; 146 case EIDL_WRONG_NUMBER_OF_TYPE_ARGUMENTS: 147 return 148 "the number of given type arguments does not match the expected" 149 " number of type parameters"; 150 case EIDL_INSTANTIATED_STRUCT_TYPE_TYPEDEF: 151 return 152 "an instantiated polymorphic struct type cannot be used in a" 153 " typedef"; 154 case EIDL_IDENTICAL_TYPE_PARAMETERS: 155 return "two type parameters have the same name"; 156 case EIDL_STRUCT_TYPE_TEMPLATE_WITH_BASE: 157 return "a polymorphic struct type template may not have a base type"; 158 case EIDL_PUBLISHED_FORWARD: 159 return 160 "a published forward declaration of an interface type cannot be" 161 " followed by an unpublished declaration of that type"; 162 case EIDL_PUBLISHED_USES_UNPUBLISHED: 163 return 164 "an unpublished entity cannot be used in the declaration of a" 165 " published entity: "; 166 case EIDL_SIMILAR_CONSTRUCTORS: 167 return "two constructors have identical lists of parameter types"; 168 } 169 return "unknown errror"; 170 } 171 172 static const sal_Char* warningCodeToMessage(WarningCode wCode) 173 { 174 switch (wCode) 175 { 176 case WIDL_EXPID_CONFLICT: 177 return "exception id conflict: "; 178 case WIDL_REQID_CONFLICT: 179 return "request id conflict: "; 180 case WIDL_INHERIT_IDCONFLICT: 181 return "request id conflict in inheritance tree: "; 182 case WIDL_TYPE_IDENT_CONFLICT: 183 return "type and parameter|member name are equal: "; 184 case WIDL_WRONG_NAMING_CONV: 185 return "type or identifier doesn't fulfill the UNO naming convention: "; 186 } 187 return "unkown warning"; 188 } 189 190 static const sal_Char* parseStateToMessage(ParseState state) 191 { 192 switch (state) 193 { 194 case PS_NoState: 195 return "Statement can not be parsed"; 196 case PS_TypeDeclSeen: 197 return "Malformed type declaration"; 198 case PS_ConstantDeclSeen: 199 return "Malformed const declaration"; 200 case PS_ExceptionDeclSeen: 201 return "Malformed exception declaration"; 202 case PS_InterfaceDeclSeen: 203 return "Malformed interface declaration"; 204 case PS_ServiceDeclSeen: 205 return "Malformed servicve declaration"; 206 case PS_ModuleDeclSeen: 207 return "Malformed module declaration"; 208 case PS_AttributeDeclSeen: 209 return "Malformed attribute declaration"; 210 case PS_PropertyDeclSeen: 211 return "Malformed property declaration"; 212 case PS_OperationDeclSeen: 213 return "Malformed operation declaration"; 214 case PS_InterfaceInheritanceDeclSeen: 215 return "Malformed interface inheritance declaration"; 216 case PS_ConstantsDeclSeen: 217 return "Malformed constants declaration"; 218 case PS_ServiceSeen: 219 return "Missing service identifier following SERVICE keyword"; 220 case PS_ServiceIDSeen: 221 return "Missing '{' or illegal syntax following service identifier"; 222 case PS_ServiceSqSeen: 223 return "Illegal syntax following service '{' opener"; 224 case PS_ServiceBodySeen: 225 return "Illegal syntax following service '}' closer"; 226 case PS_ServiceMemberSeen: 227 return "Illegal syntax following service member declaration"; 228 case PS_ServiceIFHeadSeen: 229 return "Illegal syntax following header of an interface member"; 230 case PS_ServiceSHeadSeen: 231 return "Illegal syntax following header of an service member"; 232 case PS_ModuleSeen: 233 return "Missing module identifier following MODULE keyword"; 234 case PS_ModuleIDSeen: 235 return "Missing '{' or illegal syntax following module identifier"; 236 case PS_ModuleSqSeen: 237 return "Illegal syntax following module '{' opener"; 238 case PS_ModuleQsSeen: 239 return "Illegal syntax following module '}' closer"; 240 case PS_ModuleBodySeen: 241 return "Illegal syntax following module export(s)"; 242 case PS_ConstantsSeen: 243 return "Missing constants identifier following CONSTANTS keyword"; 244 case PS_ConstantsIDSeen: 245 return "Missing '{' or illegal syntax following constants identifier"; 246 case PS_ConstantsSqSeen: 247 return "Illegal syntax following module '{' opener"; 248 case PS_ConstantsQsSeen: 249 return "Illegal syntax following module '}' closer"; 250 case PS_ConstantsBodySeen: 251 return "Illegal syntax following constants export(s)"; 252 case PS_InterfaceSeen: 253 return "Missing interface identifier following INTERFACE keyword"; 254 case PS_InterfaceIDSeen: 255 return "Illegal syntax following interface identifier"; 256 case PS_InterfaceHeadSeen: 257 return "Illegal syntax following interface head"; 258 case PS_InheritSpecSeen: 259 return "Missing '{' or illegal syntax following inheritance spec"; 260 case PS_ForwardDeclSeen: 261 return "Missing ';' following forward interface declaration"; 262 case PS_InterfaceSqSeen: 263 return "Illegal syntax following interface '{' opener"; 264 case PS_InterfaceQsSeen: 265 return "Illegal syntax following interface '}' closer"; 266 case PS_InterfaceBodySeen: 267 return "Illegal syntax following interface export(s)"; 268 case PS_InheritColonSeen: 269 return "Illegal syntax following ':' starting inheritance list"; 270 case PS_SNListCommaSeen: 271 return "Found illegal scoped name in scoped name list"; 272 case PS_ScopedNameSeen: 273 return "Missing ',' following scoped name in scoped name list"; 274 case PS_SN_IDSeen: 275 return "Illegal component in scoped name"; 276 case PS_ScopeDelimSeen: 277 return "Illegal component in scoped name following '::'"; 278 case PS_ConstSeen: 279 return "Missing type or illegal syntax following CONST keyword"; 280 case PS_ConstTypeSeen: 281 return "Missing identifier or illegal syntax following const type"; 282 case PS_ConstIDSeen: 283 return "Missing '=' or illegal syntax after const identifier"; 284 case PS_ConstAssignSeen: 285 return "Missing value expr or illegal syntax following '='"; 286 case PS_ConstExprSeen: 287 return "Missing ';' or illegal syntax following value expr in const"; 288 case PS_TypedefSeen: 289 return "Missing type or illegal syntax following TYPEDEF keyword"; 290 case PS_TypeSpecSeen: 291 return "Missing declarators or illegal syntax following type spec"; 292 case PS_DeclaratorsSeen: 293 return "Illegal syntax following declarators in TYPEDEF declaration"; 294 case PS_StructSeen: 295 return "Missing struct identifier following STRUCT keyword"; 296 case PS_StructHeaderSeen: 297 return "Missing '{' or illegal syntax following struct inheritance spec"; 298 case PS_StructIDSeen: 299 return "Missing '{' or illegal syntax following struct identifier"; 300 case PS_StructSqSeen: 301 return "Illegal syntax following struct '{' opener"; 302 case PS_StructQsSeen: 303 return "Illegal syntax following struct '}' closer"; 304 case PS_StructBodySeen: 305 return "Illegal syntax following struct member(s)"; 306 case PS_MemberTypeSeen: 307 return "Illegal syntax or missing identifier following member type"; 308 case PS_MemberDeclsSeen: 309 return "Illegal syntax following member declarator(s)"; 310 case PS_MemberDeclsCompleted: 311 return "Missing ',' between member decls of same type(?)"; 312 case PS_UnionSeen: 313 return "Missing identifier following UNION keyword"; 314 case PS_UnionIDSeen: 315 return "Illegal syntax following union identifier"; 316 case PS_SwitchSeen: 317 return "Illegal syntax following SWITCH keyword"; 318 case PS_SwitchOpenParSeen: 319 return "Illegal syntax following '(' in switch in union"; 320 case PS_SwitchTypeSeen: 321 return "Illegal syntax following type decl in switch in union"; 322 case PS_SwitchCloseParSeen: 323 return "Missing union '{' opener"; 324 case PS_UnionSqSeen: 325 return "Illegal syntax following union '{' opener"; 326 case PS_UnionQsSeen: 327 return "Illegal syntax following union '}' closer"; 328 case PS_DefaultSeen: 329 return "Illegal syntax or missing ':' following DEFAULT keyword"; 330 case PS_UnionLabelSeen: 331 return "Illegal syntax following branch label in union"; 332 case PS_LabelColonSeen: 333 return "Illegal syntax following ':' in branch label in union"; 334 case PS_LabelExprSeen: 335 return "Illegal syntax following label expression in union"; 336 case PS_UnionElemSeen: 337 case PS_UnionElemCompleted: 338 return "Illegal syntax following union element"; 339 case PS_CaseSeen: 340 return "Illegal syntax following CASE keyword in union"; 341 case PS_UnionElemTypeSeen: 342 return "Illegal syntax following type decl in union element"; 343 case PS_UnionElemDeclSeen: 344 return "Illegal syntax following declarator in union element"; 345 case PS_UnionBodySeen: 346 return "Illegal syntax following union body statement(s)"; 347 case PS_EnumSeen: 348 return "Illegal syntax or missing identifier following ENUM keyword"; 349 case PS_EnumIDSeen: 350 return "Illegal syntax or missing '{' following enum identifier"; 351 case PS_EnumSqSeen: 352 return "Illegal syntax following enum '{' opener"; 353 case PS_EnumQsSeen: 354 return "Illegal syntax following enum '}' closer"; 355 case PS_EnumBodySeen: 356 return "Illegal syntax following enum enumerator(s)"; 357 case PS_EnumCommaSeen: 358 return "Illegal syntax or missing identifier following ',' in enum"; 359 case PS_SequenceSeen: 360 return "Illegal syntax or missing '<' following SEQUENCE keyword"; 361 case PS_SequenceSqSeen: 362 return "Illegal syntax or missing type following '<' in sequence"; 363 case PS_SequenceQsSeen: 364 return "Illegal syntax following '>' in sequence"; 365 case PS_SequenceTypeSeen: 366 return "Illegal syntax following sequence type declaration"; 367 case PS_ArrayIDSeen: 368 return "Illegal syntax or missing dimensions after array identifier"; 369 case PS_ArrayCompleted: 370 return "Illegal syntax after array declaration"; 371 case PS_DimSqSeen: 372 return "Illegal syntax or missing size expr after '[' in array declaration"; 373 case PS_DimQsSeen: 374 return "Illegal syntax after ']' in array declaration"; 375 case PS_DimExprSeen: 376 return "Illegal syntax or missing ']' after size expr in array declaration"; 377 case PS_FlagHeaderSeen: 378 return "Illegal syntax after flags"; 379 case PS_AttrSeen: 380 return "Illegal syntax after ATTRIBUTE keyword"; 381 case PS_AttrTypeSeen: 382 return "Illegal syntax after type in attribute declaration"; 383 case PS_AttrCompleted: 384 return "Illegal syntax after attribute declaration"; 385 case PS_ReadOnlySeen: 386 return "Illegal syntax after READONLY keyword"; 387 case PS_OptionalSeen: 388 return "Illegal syntax after OPTIONAL keyword"; 389 case PS_MayBeVoidSeen: 390 return "Illegal syntax after MAYBEVOID keyword"; 391 case PS_BoundSeen: 392 return "Illegal syntax after BOUND keyword"; 393 case PS_ConstrainedSeen: 394 return "Illegal syntax after CONSTRAINED keyword"; 395 case PS_TransientSeen: 396 return "Illegal syntax after TRANSIENT keyword"; 397 case PS_MayBeAmbigiousSeen: 398 return "Illegal syntax after MAYBEAMBIGIOUS keyword"; 399 case PS_MayBeDefaultSeen: 400 return "Illegal syntax after MAYBEDEFAULT keyword"; 401 case PS_RemoveableSeen: 402 return "Illegal syntax after REMOVEABLE keyword"; 403 case PS_PropertySeen: 404 return "Illegal syntax after PROPERTY keyword"; 405 case PS_PropertyTypeSeen: 406 return "Illegal syntax after type in property declaration"; 407 case PS_PropertyCompleted: 408 return "Illegal syntax after property declaration"; 409 case PS_ExceptSeen: 410 return "Illegal syntax or missing identifier after EXCEPTION keyword"; 411 case PS_ExceptHeaderSeen: 412 return "Missing '{' or illegal syntax following exception inheritance spec"; 413 case PS_ExceptIDSeen: 414 return "Illegal syntax or missing '{' after exception identifier"; 415 case PS_ExceptSqSeen: 416 return "Illegal syntax after exception '{' opener"; 417 case PS_ExceptQsSeen: 418 return "Illegal syntax after exception '}' closer"; 419 case PS_ExceptBodySeen: 420 return "Illegal syntax after exception member(s)"; 421 case PS_OpHeadSeen: 422 return "Illegasl syntax after operation header"; 423 case PS_OpTypeSeen: 424 return "Illegal syntax or missing identifier after operation type"; 425 case PS_OpIDSeen: 426 return "Illegal syntax or missing '(' after operation identifier"; 427 case PS_OpParsCompleted: 428 return "Illegal syntax after operation parameter list"; 429 case PS_OpCompleted: 430 return "Illegal syntax after operation declaration"; 431 case PS_OpSqSeen: 432 return "Illegal syntax after operation parameter list '(' opener"; 433 case PS_OpQsSeen: 434 return "Illegal syntax after operation parameter list ')' closer"; 435 case PS_OpParCommaSeen: 436 return "Illegal syntax or missing direction in parameter declaration"; 437 case PS_OpParDirSeen: 438 return "Illegal syntax or missing type in parameter declaration"; 439 case PS_OpParTypeSeen: 440 return "Illegal syntax or missing declarator in parameter declaration"; 441 case PS_OpParDeclSeen: 442 return "Illegal syntax following parameter declarator"; 443 case PS_OpOnewaySeen: 444 return "Illegal syntax after ONEWAY keyword"; 445 case PS_RaiseSeen: 446 return "Illegal syntax or missing '(' after RAISES keyword"; 447 case PS_RaiseSqSeen: 448 return "Illegal syntax after RAISES '(' opener"; 449 case PS_RaiseQsSeen: 450 return "Illegal syntax after RAISES ')' closer"; 451 case PS_DeclsCommaSeen: 452 return "Illegal syntax after ',' in declarators list"; 453 case PS_DeclsDeclSeen: 454 return "Illegal syntax after declarator in declarators list"; 455 default: 456 return "no wider described syntax error"; 457 } 458 } 459 460 static OString flagToString(sal_uInt32 flag) 461 { 462 OString flagStr; 463 if ( (flag & AF_READONLY) == AF_READONLY ) 464 flagStr += "'readonly'"; 465 if ( (flag & AF_OPTIONAL) == AF_OPTIONAL ) 466 flagStr += "'optional'"; 467 if ( (flag & AF_MAYBEVOID) == AF_MAYBEVOID ) 468 flagStr += "'maybevoid'"; 469 if ( (flag & AF_BOUND) == AF_BOUND ) 470 flagStr += "'bound'"; 471 if ( (flag & AF_CONSTRAINED) == AF_CONSTRAINED ) 472 flagStr += "'constrained'"; 473 if ( (flag & AF_TRANSIENT) == AF_TRANSIENT ) 474 flagStr += "'transient'"; 475 if ( (flag & AF_MAYBEAMBIGUOUS) == AF_MAYBEAMBIGUOUS ) 476 flagStr += "'maybeambiguous'"; 477 if ( (flag & AF_MAYBEDEFAULT) == AF_MAYBEDEFAULT ) 478 flagStr += "'maybedefault'"; 479 if ( (flag & AF_REMOVEABLE) == AF_REMOVEABLE ) 480 flagStr += "'removeable'"; 481 if ( (flag & AF_ATTRIBUTE) == AF_ATTRIBUTE ) 482 flagStr += "'attribute'"; 483 if ( (flag & AF_PROPERTY) == AF_PROPERTY ) 484 flagStr += "'property'"; 485 if ( !flagStr.getLength() ) 486 flagStr += "'unknown'"; 487 488 return flagStr; 489 } 490 491 static void errorHeader(ErrorCode eCode, sal_Int32 lineNumber) 492 { 493 OString file; 494 if ( idlc()->getFileName() == idlc()->getRealFileName() ) 495 file = idlc()->getMainFileName(); 496 else 497 file = idlc()->getFileName(); 498 499 fprintf(stderr, "%s(%lu) : %s", file.getStr(), 500 sal::static_int_cast< unsigned long >(lineNumber), 501 errorCodeToMessage(eCode)); 502 } 503 504 static void errorHeader(ErrorCode eCode) 505 { 506 errorHeader(eCode, idlc()->getLineNumber()); 507 } 508 509 static void warningHeader(WarningCode wCode) 510 { 511 OString file; 512 if ( idlc()->getFileName() == idlc()->getRealFileName() ) 513 file = idlc()->getMainFileName(); 514 else 515 file = idlc()->getFileName(); 516 517 fprintf(stderr, "%s(%lu) : WARNING, %s", file.getStr(), 518 sal::static_int_cast< unsigned long >(idlc()->getLineNumber()), 519 warningCodeToMessage(wCode)); 520 } 521 522 void ErrorHandler::error0(ErrorCode e) 523 { 524 errorHeader(e); 525 fprintf(stderr, "\n"); 526 idlc()->incErrorCount(); 527 } 528 529 void ErrorHandler::error1(ErrorCode e, AstDeclaration const * d) 530 { 531 errorHeader(e); 532 fprintf(stderr, "'%s'\n", d->getScopedName().getStr()); 533 idlc()->incErrorCount(); 534 } 535 536 void ErrorHandler::error2( 537 ErrorCode e, AstDeclaration const * d1, AstDeclaration const * d2) 538 { 539 errorHeader(e); 540 fprintf(stderr, "'%s', '%s'\n", d1->getScopedName().getStr(), 541 d2->getScopedName().getStr()); 542 idlc()->incErrorCount(); 543 } 544 545 void ErrorHandler::error3(ErrorCode e, AstDeclaration* d1, AstDeclaration* d2, AstDeclaration* d3) 546 { 547 errorHeader(e); 548 fprintf(stderr, "'%s', '%s', '%s'\n", d1->getScopedName().getStr(), 549 d2->getScopedName().getStr(), d3->getScopedName().getStr()); 550 idlc()->incErrorCount(); 551 } 552 553 void ErrorHandler::warning0(WarningCode w, const sal_Char* warningmsg) 554 { 555 if ( idlc()->getOptions()->isValid("-w") || idlc()->getOptions()->isValid("-we") ) { 556 warningHeader(w); 557 fprintf(stderr, "%s\n", warningmsg); 558 } 559 560 if ( idlc()->getOptions()->isValid("-we") ) 561 idlc()->incErrorCount(); 562 else 563 idlc()->incWarningCount(); 564 } 565 566 void ErrorHandler::syntaxError(ParseState ps, sal_Int32 lineNumber, const sal_Char* errmsg) 567 { 568 errorHeader(EIDL_SYNTAX_ERROR, lineNumber); 569 fprintf(stderr, "%s: %s\n", parseStateToMessage(ps), errmsg); 570 idlc()->incErrorCount(); 571 } 572 573 void ErrorHandler::coercionError(AstExpression *pExpr, ExprType et) 574 { 575 errorHeader(EIDL_COERCION_FAILURE); 576 fprintf(stderr, "'%s' to '%s'\n", pExpr->toString().getStr(), 577 exprTypeToString(et)); 578 idlc()->incErrorCount(); 579 } 580 581 void ErrorHandler::lookupError(const ::rtl::OString& n) 582 { 583 errorHeader(EIDL_LOOKUP_ERROR); 584 fprintf(stderr, "'%s'\n", n.getStr()); 585 idlc()->incErrorCount(); 586 } 587 588 void ErrorHandler::lookupError(ErrorCode e, const ::rtl::OString& n, AstDeclaration* pScope) 589 { 590 errorHeader(e); 591 fprintf(stderr, "'%s' in '%s'\n", n.getStr(), pScope->getFullName().getStr()); 592 idlc()->incErrorCount(); 593 } 594 595 void ErrorHandler::flagError(ErrorCode e, sal_uInt32 flag) 596 { 597 errorHeader(e); 598 fprintf(stderr, "'%s'\n", flagToString(flag).getStr()); 599 idlc()->incErrorCount(); 600 } 601 602 void ErrorHandler::noTypeError(AstDeclaration const * pDecl) 603 { 604 errorHeader(EIDL_NOT_A_TYPE); 605 fprintf(stderr, "'%s'\n", pDecl->getScopedName().getStr()); 606 idlc()->incErrorCount(); 607 } 608 609 namespace { 610 611 char const * nodeTypeName(NodeType nodeType) { 612 switch (nodeType) { 613 case NT_interface: 614 return "interface"; 615 616 case NT_exception: 617 return "exception"; 618 619 case NT_struct: 620 return "struct"; 621 622 default: 623 return ""; 624 } 625 } 626 627 } 628 629 void ErrorHandler::inheritanceError(NodeType nodeType, const OString* name, AstDeclaration* pDecl) 630 { 631 if ( nodeType == NT_interface && 632 (pDecl->getNodeType() == NT_interface) && 633 !((AstInterface*)pDecl)->isDefined() ) 634 { 635 errorHeader(EIDL_INHERIT_FWD_ERROR); 636 fprintf(stderr, "interface '%s' cannot inherit from forward declared interface '%s'\n", 637 name->getStr(), pDecl->getScopedName().getStr()); 638 } else 639 { 640 errorHeader(EIDL_CANT_INHERIT); 641 fprintf(stderr, "%s '%s' from '%s'\n", 642 nodeTypeName(nodeType), name->getStr(), 643 pDecl->getScopedName().getStr()); 644 } 645 idlc()->incErrorCount(); 646 } 647 648 void ErrorHandler::forwardLookupError(AstDeclaration* pForward, 649 const ::rtl::OString& name) 650 { 651 errorHeader(EIDL_FWD_DECL_LOOKUP); 652 fprintf(stderr, "trying to look up '%s' in undefined forward declared interface '%s'\n", 653 pForward->getScopedName().getStr(), name.getStr()); 654 idlc()->incErrorCount(); 655 } 656 657 void ErrorHandler::constantExpected(AstDeclaration* pDecl, 658 const ::rtl::OString& name) 659 { 660 errorHeader(EIDL_CONSTANT_EXPECTED); 661 fprintf(stderr, "'%s' is bound to '%s'\n", name.getStr(), pDecl->getScopedName().getStr()); 662 idlc()->incErrorCount(); 663 } 664 665 void ErrorHandler::evalError(AstExpression* pExpr) 666 { 667 errorHeader(EIDL_EVAL_ERROR); 668 fprintf(stderr, "'%s'\n", pExpr->toString().getStr()); 669 idlc()->incErrorCount(); 670 } 671 672 void ErrorHandler::enumValExpected(AstUnion* pUnion) 673 { 674 errorHeader(EIDL_ENUM_VAL_EXPECTED); 675 fprintf(stderr, " union %s\n", pUnion->getLocalName().getStr()); 676 idlc()->incErrorCount(); 677 } 678 679 void ErrorHandler::enumValLookupFailure(AstUnion* pUnion, AstEnum* pEnum, const ::rtl::OString& name) 680 { 681 errorHeader(EIDL_ENUM_VAL_NOT_FOUND); 682 fprintf(stderr, " union %s, enum %s, enumerator %s\n", 683 pUnion->getLocalName().getStr(), 684 pEnum->getLocalName().getStr(), name.getStr()); 685 idlc()->incErrorCount(); 686 } 687 688 bool ErrorHandler::checkPublished(AstDeclaration const * decl, bool bOptional) { 689 if (idlc()->isPublished() && !decl->isPublished() && !bOptional) { 690 error1(EIDL_PUBLISHED_USES_UNPUBLISHED, decl); 691 return false; 692 } else { 693 return true; 694 } 695 } 696