| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_idlc.hxx" |
| #include <idlc/errorhandler.hxx> |
| #include <idlc/astinterface.hxx> |
| |
| using namespace ::rtl; |
| |
| static const sal_Char* errorCodeToMessage(ErrorCode eCode) |
| { |
| switch (eCode) |
| { |
| case EIDL_NONE: |
| return "all is fine "; |
| case EIDL_SYNTAX_ERROR: |
| return ""; |
| case EIDL_REDEF: |
| return "illegal redefinition "; |
| case EIDL_REDEF_SCOPE: |
| return "illegal redefinition in scope "; |
| case EIDL_DEF_USE: |
| return "redefinition after use, "; |
| case EIDL_MULTIPLE_BRANCH: |
| return "union with duplicate branch label "; |
| case EIDL_COERCION_FAILURE: |
| return "coercion failure "; |
| case EIDL_SCOPE_CONFLICT: |
| return "definition scope is different than fwd declare scope, "; |
| case EIDL_ONEWAY_CONFLICT: |
| return "oneway operation with OUT|INOUT parameters or raises exceptions, "; |
| case EIDL_DISC_TYPE: |
| return "union with illegal discriminator type, "; |
| case EIDL_LABEL_TYPE: |
| return "label type incompatible with union discriminator type, "; |
| case EIDL_ILLEGAL_ADD: |
| return "illegal add operation, "; |
| case EIDL_ILLEGAL_USE: |
| return "illegal type used in expression, "; |
| case EIDL_ILLEGAL_RAISES: |
| return "non-exception type in raises(..) clause, "; |
| case EIDL_CANT_INHERIT: |
| return "cannot inherit "; |
| case EIDL_LOOKUP_ERROR: |
| return "error in lookup of symbol: "; |
| case EIDL_INHERIT_FWD_ERROR: |
| return ""; |
| case EIDL_CONSTANT_EXPECTED: |
| return "constant expected: "; |
| case EIDL_NAME_CASE_ERROR: |
| return "identifier used with two differing spellings: "; |
| case EIDL_ENUM_VAL_EXPECTED: |
| return "enumerator expected: "; |
| case EIDL_ENUM_VAL_NOT_FOUND: |
| return "enumerator by this name not defined: "; |
| case EIDL_EVAL_ERROR: |
| return "expression evaluation error: "; |
| case EIDL_AMBIGUOUS: |
| return "ambiguous definition: "; |
| case EIDL_DECL_NOT_DEFINED: |
| return "forward declared but never defined: "; |
| case EIDL_FWD_DECL_LOOKUP: |
| return ""; |
| case EIDL_RECURSIVE_TYPE: |
| return "illegal recursive use of type: "; |
| case EIDL_NONVOID_ONEWAY: |
| return "non-void return type in oneway operation: "; |
| case EIDL_NOT_A_TYPE: |
| return "specified symbol is not a type: "; |
| case EIDL_TYPE_NOT_VALID: |
| return "specified type is not valid in this context: "; |
| case EIDL_INTERFACEMEMBER_LOOKUP: |
| return "error in lookup of symbol, expected interface is not defined and no forward exists: "; |
| case EIDL_SERVICEMEMBER_LOOKUP: |
| return "error in lookup of symbol, expected service is not defined: "; |
| case EIDL_TYPE_IDENT_CONFLICT: |
| return "type and parameter/member name are equal: "; |
| case EIDL_ONEWAY_RAISE_CONFLICT: |
| return "oneway operation cannot raises exceptions: "; |
| case EIDL_WRONGATTRIBUTEFLAG: |
| return "the used flag is not valid in this context: "; |
| case EIDL_DEFINED_ATTRIBUTEFLAG: |
| return "flag is already set: "; |
| case EIDL_WRONGATTRIBUTEKEYWORD: |
| return "keyword not allowed: "; |
| case EIDL_MISSINGATTRIBUTEKEYWORD: |
| return "missing keyword: "; |
| case EIDL_BAD_ATTRIBUTE_FLAGS: |
| return |
| "the 'attribute' flag is mandatory, and only the 'bound' and" |
| " 'readonly' optional flags are accepted: "; |
| case EIDL_OPTIONALEXPECTED: |
| return "only the 'optional' flag is accepted: "; |
| case EIDL_MIXED_INHERITANCE: |
| return "interface inheritance declarations cannot appear in both an" |
| " interface's header and its body"; |
| case EIDL_DOUBLE_INHERITANCE: |
| return |
| "interface is (directly or indirectly) inherited more than once: "; |
| case EIDL_DOUBLE_MEMBER: |
| return |
| "member is (directly or indirectly) declared more than once: "; |
| case EIDL_CONSTRUCTOR_PARAMETER_NOT_IN: |
| return |
| "a service constructor parameter may not be an out or inout" |
| " parameter"; |
| case EIDL_CONSTRUCTOR_REST_PARAMETER_NOT_FIRST: |
| return |
| "no parameters may precede a rest parameter in a service" |
| " constructor"; |
| case EIDL_REST_PARAMETER_NOT_LAST: |
| return "no parameters may follow a rest parameter"; |
| case EIDL_REST_PARAMETER_NOT_ANY: |
| return "a rest parameter must be of type any"; |
| case EIDL_METHOD_HAS_REST_PARAMETER: |
| return "a rest parameter may not be used on an interface method"; |
| case EIDL_READONLY_ATTRIBUTE_SET_EXCEPTIONS: |
| return "a readonly attribute may not have a setter raises clause"; |
| case EIDL_UNSIGNED_TYPE_ARGUMENT: |
| return "an unsigned type cannot be used as a type argument"; |
| case EIDL_WRONG_NUMBER_OF_TYPE_ARGUMENTS: |
| return |
| "the number of given type arguments does not match the expected" |
| " number of type parameters"; |
| case EIDL_INSTANTIATED_STRUCT_TYPE_TYPEDEF: |
| return |
| "an instantiated polymorphic struct type cannot be used in a" |
| " typedef"; |
| case EIDL_IDENTICAL_TYPE_PARAMETERS: |
| return "two type parameters have the same name"; |
| case EIDL_STRUCT_TYPE_TEMPLATE_WITH_BASE: |
| return "a polymorphic struct type template may not have a base type"; |
| case EIDL_PUBLISHED_FORWARD: |
| return |
| "a published forward declaration of an interface type cannot be" |
| " followed by an unpublished declaration of that type"; |
| case EIDL_PUBLISHED_USES_UNPUBLISHED: |
| return |
| "an unpublished entity cannot be used in the declaration of a" |
| " published entity: "; |
| case EIDL_SIMILAR_CONSTRUCTORS: |
| return "two constructors have identical lists of parameter types"; |
| } |
| return "unknown errror"; |
| } |
| |
| static const sal_Char* warningCodeToMessage(WarningCode wCode) |
| { |
| switch (wCode) |
| { |
| case WIDL_EXPID_CONFLICT: |
| return "exception id conflict: "; |
| case WIDL_REQID_CONFLICT: |
| return "request id conflict: "; |
| case WIDL_INHERIT_IDCONFLICT: |
| return "request id conflict in inheritance tree: "; |
| case WIDL_TYPE_IDENT_CONFLICT: |
| return "type and parameter|member name are equal: "; |
| case WIDL_WRONG_NAMING_CONV: |
| return "type or identifier doesn't fulfill the UNO naming convention: "; |
| } |
| return "unkown warning"; |
| } |
| |
| static const sal_Char* parseStateToMessage(ParseState state) |
| { |
| switch (state) |
| { |
| case PS_NoState: |
| return "Statement can not be parsed"; |
| case PS_TypeDeclSeen: |
| return "Malformed type declaration"; |
| case PS_ConstantDeclSeen: |
| return "Malformed const declaration"; |
| case PS_ExceptionDeclSeen: |
| return "Malformed exception declaration"; |
| case PS_InterfaceDeclSeen: |
| return "Malformed interface declaration"; |
| case PS_ServiceDeclSeen: |
| return "Malformed servicve declaration"; |
| case PS_ModuleDeclSeen: |
| return "Malformed module declaration"; |
| case PS_AttributeDeclSeen: |
| return "Malformed attribute declaration"; |
| case PS_PropertyDeclSeen: |
| return "Malformed property declaration"; |
| case PS_OperationDeclSeen: |
| return "Malformed operation declaration"; |
| case PS_InterfaceInheritanceDeclSeen: |
| return "Malformed interface inheritance declaration"; |
| case PS_ConstantsDeclSeen: |
| return "Malformed constants declaration"; |
| case PS_ServiceSeen: |
| return "Missing service identifier following SERVICE keyword"; |
| case PS_ServiceIDSeen: |
| return "Missing '{' or illegal syntax following service identifier"; |
| case PS_ServiceSqSeen: |
| return "Illegal syntax following service '{' opener"; |
| case PS_ServiceBodySeen: |
| return "Illegal syntax following service '}' closer"; |
| case PS_ServiceMemberSeen: |
| return "Illegal syntax following service member declaration"; |
| case PS_ServiceIFHeadSeen: |
| return "Illegal syntax following header of an interface member"; |
| case PS_ServiceSHeadSeen: |
| return "Illegal syntax following header of an service member"; |
| case PS_ModuleSeen: |
| return "Missing module identifier following MODULE keyword"; |
| case PS_ModuleIDSeen: |
| return "Missing '{' or illegal syntax following module identifier"; |
| case PS_ModuleSqSeen: |
| return "Illegal syntax following module '{' opener"; |
| case PS_ModuleQsSeen: |
| return "Illegal syntax following module '}' closer"; |
| case PS_ModuleBodySeen: |
| return "Illegal syntax following module export(s)"; |
| case PS_ConstantsSeen: |
| return "Missing constants identifier following CONSTANTS keyword"; |
| case PS_ConstantsIDSeen: |
| return "Missing '{' or illegal syntax following constants identifier"; |
| case PS_ConstantsSqSeen: |
| return "Illegal syntax following module '{' opener"; |
| case PS_ConstantsQsSeen: |
| return "Illegal syntax following module '}' closer"; |
| case PS_ConstantsBodySeen: |
| return "Illegal syntax following constants export(s)"; |
| case PS_InterfaceSeen: |
| return "Missing interface identifier following INTERFACE keyword"; |
| case PS_InterfaceIDSeen: |
| return "Illegal syntax following interface identifier"; |
| case PS_InterfaceHeadSeen: |
| return "Illegal syntax following interface head"; |
| case PS_InheritSpecSeen: |
| return "Missing '{' or illegal syntax following inheritance spec"; |
| case PS_ForwardDeclSeen: |
| return "Missing ';' following forward interface declaration"; |
| case PS_InterfaceSqSeen: |
| return "Illegal syntax following interface '{' opener"; |
| case PS_InterfaceQsSeen: |
| return "Illegal syntax following interface '}' closer"; |
| case PS_InterfaceBodySeen: |
| return "Illegal syntax following interface export(s)"; |
| case PS_InheritColonSeen: |
| return "Illegal syntax following ':' starting inheritance list"; |
| case PS_SNListCommaSeen: |
| return "Found illegal scoped name in scoped name list"; |
| case PS_ScopedNameSeen: |
| return "Missing ',' following scoped name in scoped name list"; |
| case PS_SN_IDSeen: |
| return "Illegal component in scoped name"; |
| case PS_ScopeDelimSeen: |
| return "Illegal component in scoped name following '::'"; |
| case PS_ConstSeen: |
| return "Missing type or illegal syntax following CONST keyword"; |
| case PS_ConstTypeSeen: |
| return "Missing identifier or illegal syntax following const type"; |
| case PS_ConstIDSeen: |
| return "Missing '=' or illegal syntax after const identifier"; |
| case PS_ConstAssignSeen: |
| return "Missing value expr or illegal syntax following '='"; |
| case PS_ConstExprSeen: |
| return "Missing ';' or illegal syntax following value expr in const"; |
| case PS_TypedefSeen: |
| return "Missing type or illegal syntax following TYPEDEF keyword"; |
| case PS_TypeSpecSeen: |
| return "Missing declarators or illegal syntax following type spec"; |
| case PS_DeclaratorsSeen: |
| return "Illegal syntax following declarators in TYPEDEF declaration"; |
| case PS_StructSeen: |
| return "Missing struct identifier following STRUCT keyword"; |
| case PS_StructHeaderSeen: |
| return "Missing '{' or illegal syntax following struct inheritance spec"; |
| case PS_StructIDSeen: |
| return "Missing '{' or illegal syntax following struct identifier"; |
| case PS_StructSqSeen: |
| return "Illegal syntax following struct '{' opener"; |
| case PS_StructQsSeen: |
| return "Illegal syntax following struct '}' closer"; |
| case PS_StructBodySeen: |
| return "Illegal syntax following struct member(s)"; |
| case PS_MemberTypeSeen: |
| return "Illegal syntax or missing identifier following member type"; |
| case PS_MemberDeclsSeen: |
| return "Illegal syntax following member declarator(s)"; |
| case PS_MemberDeclsCompleted: |
| return "Missing ',' between member decls of same type(?)"; |
| case PS_UnionSeen: |
| return "Missing identifier following UNION keyword"; |
| case PS_UnionIDSeen: |
| return "Illegal syntax following union identifier"; |
| case PS_SwitchSeen: |
| return "Illegal syntax following SWITCH keyword"; |
| case PS_SwitchOpenParSeen: |
| return "Illegal syntax following '(' in switch in union"; |
| case PS_SwitchTypeSeen: |
| return "Illegal syntax following type decl in switch in union"; |
| case PS_SwitchCloseParSeen: |
| return "Missing union '{' opener"; |
| case PS_UnionSqSeen: |
| return "Illegal syntax following union '{' opener"; |
| case PS_UnionQsSeen: |
| return "Illegal syntax following union '}' closer"; |
| case PS_DefaultSeen: |
| return "Illegal syntax or missing ':' following DEFAULT keyword"; |
| case PS_UnionLabelSeen: |
| return "Illegal syntax following branch label in union"; |
| case PS_LabelColonSeen: |
| return "Illegal syntax following ':' in branch label in union"; |
| case PS_LabelExprSeen: |
| return "Illegal syntax following label expression in union"; |
| case PS_UnionElemSeen: |
| case PS_UnionElemCompleted: |
| return "Illegal syntax following union element"; |
| case PS_CaseSeen: |
| return "Illegal syntax following CASE keyword in union"; |
| case PS_UnionElemTypeSeen: |
| return "Illegal syntax following type decl in union element"; |
| case PS_UnionElemDeclSeen: |
| return "Illegal syntax following declarator in union element"; |
| case PS_UnionBodySeen: |
| return "Illegal syntax following union body statement(s)"; |
| case PS_EnumSeen: |
| return "Illegal syntax or missing identifier following ENUM keyword"; |
| case PS_EnumIDSeen: |
| return "Illegal syntax or missing '{' following enum identifier"; |
| case PS_EnumSqSeen: |
| return "Illegal syntax following enum '{' opener"; |
| case PS_EnumQsSeen: |
| return "Illegal syntax following enum '}' closer"; |
| case PS_EnumBodySeen: |
| return "Illegal syntax following enum enumerator(s)"; |
| case PS_EnumCommaSeen: |
| return "Illegal syntax or missing identifier following ',' in enum"; |
| case PS_SequenceSeen: |
| return "Illegal syntax or missing '<' following SEQUENCE keyword"; |
| case PS_SequenceSqSeen: |
| return "Illegal syntax or missing type following '<' in sequence"; |
| case PS_SequenceQsSeen: |
| return "Illegal syntax following '>' in sequence"; |
| case PS_SequenceTypeSeen: |
| return "Illegal syntax following sequence type declaration"; |
| case PS_ArrayIDSeen: |
| return "Illegal syntax or missing dimensions after array identifier"; |
| case PS_ArrayCompleted: |
| return "Illegal syntax after array declaration"; |
| case PS_DimSqSeen: |
| return "Illegal syntax or missing size expr after '[' in array declaration"; |
| case PS_DimQsSeen: |
| return "Illegal syntax after ']' in array declaration"; |
| case PS_DimExprSeen: |
| return "Illegal syntax or missing ']' after size expr in array declaration"; |
| case PS_FlagHeaderSeen: |
| return "Illegal syntax after flags"; |
| case PS_AttrSeen: |
| return "Illegal syntax after ATTRIBUTE keyword"; |
| case PS_AttrTypeSeen: |
| return "Illegal syntax after type in attribute declaration"; |
| case PS_AttrCompleted: |
| return "Illegal syntax after attribute declaration"; |
| case PS_ReadOnlySeen: |
| return "Illegal syntax after READONLY keyword"; |
| case PS_OptionalSeen: |
| return "Illegal syntax after OPTIONAL keyword"; |
| case PS_MayBeVoidSeen: |
| return "Illegal syntax after MAYBEVOID keyword"; |
| case PS_BoundSeen: |
| return "Illegal syntax after BOUND keyword"; |
| case PS_ConstrainedSeen: |
| return "Illegal syntax after CONSTRAINED keyword"; |
| case PS_TransientSeen: |
| return "Illegal syntax after TRANSIENT keyword"; |
| case PS_MayBeAmbigiousSeen: |
| return "Illegal syntax after MAYBEAMBIGIOUS keyword"; |
| case PS_MayBeDefaultSeen: |
| return "Illegal syntax after MAYBEDEFAULT keyword"; |
| case PS_RemoveableSeen: |
| return "Illegal syntax after REMOVEABLE keyword"; |
| case PS_PropertySeen: |
| return "Illegal syntax after PROPERTY keyword"; |
| case PS_PropertyTypeSeen: |
| return "Illegal syntax after type in property declaration"; |
| case PS_PropertyCompleted: |
| return "Illegal syntax after property declaration"; |
| case PS_ExceptSeen: |
| return "Illegal syntax or missing identifier after EXCEPTION keyword"; |
| case PS_ExceptHeaderSeen: |
| return "Missing '{' or illegal syntax following exception inheritance spec"; |
| case PS_ExceptIDSeen: |
| return "Illegal syntax or missing '{' after exception identifier"; |
| case PS_ExceptSqSeen: |
| return "Illegal syntax after exception '{' opener"; |
| case PS_ExceptQsSeen: |
| return "Illegal syntax after exception '}' closer"; |
| case PS_ExceptBodySeen: |
| return "Illegal syntax after exception member(s)"; |
| case PS_OpHeadSeen: |
| return "Illegasl syntax after operation header"; |
| case PS_OpTypeSeen: |
| return "Illegal syntax or missing identifier after operation type"; |
| case PS_OpIDSeen: |
| return "Illegal syntax or missing '(' after operation identifier"; |
| case PS_OpParsCompleted: |
| return "Illegal syntax after operation parameter list"; |
| case PS_OpCompleted: |
| return "Illegal syntax after operation declaration"; |
| case PS_OpSqSeen: |
| return "Illegal syntax after operation parameter list '(' opener"; |
| case PS_OpQsSeen: |
| return "Illegal syntax after operation parameter list ')' closer"; |
| case PS_OpParCommaSeen: |
| return "Illegal syntax or missing direction in parameter declaration"; |
| case PS_OpParDirSeen: |
| return "Illegal syntax or missing type in parameter declaration"; |
| case PS_OpParTypeSeen: |
| return "Illegal syntax or missing declarator in parameter declaration"; |
| case PS_OpParDeclSeen: |
| return "Illegal syntax following parameter declarator"; |
| case PS_OpOnewaySeen: |
| return "Illegal syntax after ONEWAY keyword"; |
| case PS_RaiseSeen: |
| return "Illegal syntax or missing '(' after RAISES keyword"; |
| case PS_RaiseSqSeen: |
| return "Illegal syntax after RAISES '(' opener"; |
| case PS_RaiseQsSeen: |
| return "Illegal syntax after RAISES ')' closer"; |
| case PS_DeclsCommaSeen: |
| return "Illegal syntax after ',' in declarators list"; |
| case PS_DeclsDeclSeen: |
| return "Illegal syntax after declarator in declarators list"; |
| default: |
| return "no wider described syntax error"; |
| } |
| } |
| |
| static OString flagToString(sal_uInt32 flag) |
| { |
| OString flagStr; |
| if ( (flag & AF_READONLY) == AF_READONLY ) |
| flagStr += "'readonly'"; |
| if ( (flag & AF_OPTIONAL) == AF_OPTIONAL ) |
| flagStr += "'optional'"; |
| if ( (flag & AF_MAYBEVOID) == AF_MAYBEVOID ) |
| flagStr += "'maybevoid'"; |
| if ( (flag & AF_BOUND) == AF_BOUND ) |
| flagStr += "'bound'"; |
| if ( (flag & AF_CONSTRAINED) == AF_CONSTRAINED ) |
| flagStr += "'constrained'"; |
| if ( (flag & AF_TRANSIENT) == AF_TRANSIENT ) |
| flagStr += "'transient'"; |
| if ( (flag & AF_MAYBEAMBIGUOUS) == AF_MAYBEAMBIGUOUS ) |
| flagStr += "'maybeambiguous'"; |
| if ( (flag & AF_MAYBEDEFAULT) == AF_MAYBEDEFAULT ) |
| flagStr += "'maybedefault'"; |
| if ( (flag & AF_REMOVEABLE) == AF_REMOVEABLE ) |
| flagStr += "'removeable'"; |
| if ( (flag & AF_ATTRIBUTE) == AF_ATTRIBUTE ) |
| flagStr += "'attribute'"; |
| if ( (flag & AF_PROPERTY) == AF_PROPERTY ) |
| flagStr += "'property'"; |
| if ( !flagStr.getLength() ) |
| flagStr += "'unknown'"; |
| |
| return flagStr; |
| } |
| |
| static void errorHeader(ErrorCode eCode, sal_Int32 lineNumber) |
| { |
| OString file; |
| if ( idlc()->getFileName() == idlc()->getRealFileName() ) |
| file = idlc()->getMainFileName(); |
| else |
| file = idlc()->getFileName(); |
| |
| fprintf(stderr, "%s(%lu) : %s", file.getStr(), |
| sal::static_int_cast< unsigned long >(lineNumber), |
| errorCodeToMessage(eCode)); |
| } |
| |
| static void errorHeader(ErrorCode eCode) |
| { |
| errorHeader(eCode, idlc()->getLineNumber()); |
| } |
| |
| static void warningHeader(WarningCode wCode) |
| { |
| OString file; |
| if ( idlc()->getFileName() == idlc()->getRealFileName() ) |
| file = idlc()->getMainFileName(); |
| else |
| file = idlc()->getFileName(); |
| |
| fprintf(stderr, "%s(%lu) : WARNING, %s", file.getStr(), |
| sal::static_int_cast< unsigned long >(idlc()->getLineNumber()), |
| warningCodeToMessage(wCode)); |
| } |
| |
| void ErrorHandler::error0(ErrorCode e) |
| { |
| errorHeader(e); |
| fprintf(stderr, "\n"); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::error1(ErrorCode e, AstDeclaration const * d) |
| { |
| errorHeader(e); |
| fprintf(stderr, "'%s'\n", d->getScopedName().getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::error2( |
| ErrorCode e, AstDeclaration const * d1, AstDeclaration const * d2) |
| { |
| errorHeader(e); |
| fprintf(stderr, "'%s', '%s'\n", d1->getScopedName().getStr(), |
| d2->getScopedName().getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::error3(ErrorCode e, AstDeclaration* d1, AstDeclaration* d2, AstDeclaration* d3) |
| { |
| errorHeader(e); |
| fprintf(stderr, "'%s', '%s', '%s'\n", d1->getScopedName().getStr(), |
| d2->getScopedName().getStr(), d3->getScopedName().getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::warning0(WarningCode w, const sal_Char* warningmsg) |
| { |
| if ( idlc()->getOptions()->isValid("-w") || idlc()->getOptions()->isValid("-we") ) { |
| warningHeader(w); |
| fprintf(stderr, "%s\n", warningmsg); |
| } |
| |
| if ( idlc()->getOptions()->isValid("-we") ) |
| idlc()->incErrorCount(); |
| else |
| idlc()->incWarningCount(); |
| } |
| |
| void ErrorHandler::syntaxError(ParseState ps, sal_Int32 lineNumber, const sal_Char* errmsg) |
| { |
| errorHeader(EIDL_SYNTAX_ERROR, lineNumber); |
| fprintf(stderr, "%s: %s\n", parseStateToMessage(ps), errmsg); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::coercionError(AstExpression *pExpr, ExprType et) |
| { |
| errorHeader(EIDL_COERCION_FAILURE); |
| fprintf(stderr, "'%s' to '%s'\n", pExpr->toString().getStr(), |
| exprTypeToString(et)); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::lookupError(const ::rtl::OString& n) |
| { |
| errorHeader(EIDL_LOOKUP_ERROR); |
| fprintf(stderr, "'%s'\n", n.getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::lookupError(ErrorCode e, const ::rtl::OString& n, AstDeclaration* pScope) |
| { |
| errorHeader(e); |
| fprintf(stderr, "'%s' in '%s'\n", n.getStr(), pScope->getFullName().getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::flagError(ErrorCode e, sal_uInt32 flag) |
| { |
| errorHeader(e); |
| fprintf(stderr, "'%s'\n", flagToString(flag).getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::noTypeError(AstDeclaration const * pDecl) |
| { |
| errorHeader(EIDL_NOT_A_TYPE); |
| fprintf(stderr, "'%s'\n", pDecl->getScopedName().getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| namespace { |
| |
| char const * nodeTypeName(NodeType nodeType) { |
| switch (nodeType) { |
| case NT_interface: |
| return "interface"; |
| |
| case NT_exception: |
| return "exception"; |
| |
| case NT_struct: |
| return "struct"; |
| |
| default: |
| return ""; |
| } |
| } |
| |
| } |
| |
| void ErrorHandler::inheritanceError(NodeType nodeType, const OString* name, AstDeclaration* pDecl) |
| { |
| if ( nodeType == NT_interface && |
| (pDecl->getNodeType() == NT_interface) && |
| !((AstInterface*)pDecl)->isDefined() ) |
| { |
| errorHeader(EIDL_INHERIT_FWD_ERROR); |
| fprintf(stderr, "interface '%s' cannot inherit from forward declared interface '%s'\n", |
| name->getStr(), pDecl->getScopedName().getStr()); |
| } else |
| { |
| errorHeader(EIDL_CANT_INHERIT); |
| fprintf(stderr, "%s '%s' from '%s'\n", |
| nodeTypeName(nodeType), name->getStr(), |
| pDecl->getScopedName().getStr()); |
| } |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::forwardLookupError(AstDeclaration* pForward, |
| const ::rtl::OString& name) |
| { |
| errorHeader(EIDL_FWD_DECL_LOOKUP); |
| fprintf(stderr, "trying to look up '%s' in undefined forward declared interface '%s'\n", |
| pForward->getScopedName().getStr(), name.getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::constantExpected(AstDeclaration* pDecl, |
| const ::rtl::OString& name) |
| { |
| errorHeader(EIDL_CONSTANT_EXPECTED); |
| fprintf(stderr, "'%s' is bound to '%s'\n", name.getStr(), pDecl->getScopedName().getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::evalError(AstExpression* pExpr) |
| { |
| errorHeader(EIDL_EVAL_ERROR); |
| fprintf(stderr, "'%s'\n", pExpr->toString().getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::enumValExpected(AstUnion* pUnion) |
| { |
| errorHeader(EIDL_ENUM_VAL_EXPECTED); |
| fprintf(stderr, " union %s\n", pUnion->getLocalName().getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| void ErrorHandler::enumValLookupFailure(AstUnion* pUnion, AstEnum* pEnum, const ::rtl::OString& name) |
| { |
| errorHeader(EIDL_ENUM_VAL_NOT_FOUND); |
| fprintf(stderr, " union %s, enum %s, enumerator %s\n", |
| pUnion->getLocalName().getStr(), |
| pEnum->getLocalName().getStr(), name.getStr()); |
| idlc()->incErrorCount(); |
| } |
| |
| bool ErrorHandler::checkPublished(AstDeclaration const * decl, bool bOptional) { |
| if (idlc()->isPublished() && !decl->isPublished() && !bOptional) { |
| error1(EIDL_PUBLISHED_USES_UNPUBLISHED, decl); |
| return false; |
| } else { |
| return true; |
| } |
| } |
