/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Copyright (c) 1989-1999 Microsoft Corporation Module Name: semantic.cxx Abstract: semantic analysis routines Notes: Author: GregJen Jun-11-1993 Created. Notes: ----------------------------------------------------------------------------*/ // unreferenced inline/local function has been removed #pragma warning ( disable : 4514 ) /**************************************************************************** * include files ***************************************************************************/ #include #include "allnodes.hxx" #include "semantic.hxx" #include "cmdana.hxx" extern "C" { #include } #include "treg.hxx" #include "tlgen.hxx" #include "Pragma.hxx" // #include "attrguid.hxx" BOOL IsOLEAutomationType ( char* ); BOOL IsOLEAutomationCompliant( node_skl* ); node_interface* CloneIFAndSplitMethods ( node_interface* ); node_skl* GetInOnlyParamPairedWithOut ( MEM_ITER& MemParamList ); bool HasCorrelation ( node_skl* ); #define RPC_ASYNC_HANDLE_NAME "PRPC_ASYNC_STATE" #define RPC_ASYNC_STRUCT_NAME "_RPC_ASYNC_STATE" #define OBJECT_ASYNC_HANDLE_NAME "IAsyncManager" #define IS_OLD_INTERPRETER( x ) ( ((x) & OPTIMIZE_INTERPRETER) && !((x) & OPTIMIZE_INTERPRETER_V2) ) #define IsCoclassOrDispKind(x) ( (x) == NODE_DISPINTERFACE || (x) == NODE_COCLASS ) #define IsInterfaceKind(x) ( (x) == NODE_INTERFACE_REFERENCE || (x) == NODE_INTERFACE ) // // This state table defines the rules that govern valid [propput] methods. // namespace PropPut { enum State { NoParam = 0, GeneralParam = 1, Optional = 2, Default = 3, LCID = 4, LastParam = 5, Reject = 6, Accept = 7, }; // Accept = Param* (optional|default)* (param|lcidparam|default) State StateTable[][5] = { // no param regular optional default lcid // ----------------------------------------------------------- {Reject, GeneralParam, Optional, Default, LCID}, // NoParam {Accept, GeneralParam, Optional, Default, LCID}, // GeneralParam {Reject, LastParam, Optional, Default, LCID}, // Optional {Accept, LastParam, Optional, Default, LCID}, // Default {Reject, LastParam, Reject, Reject, Reject}, // LCID {Accept, Reject, Reject, Reject, Reject}, // LastParam {Reject, Reject, Reject, Reject, Reject}, // Reject {Accept, Reject, Reject, Reject, Reject} // Accept }; } /**************************************************************************** * externs ***************************************************************************/ extern BOOL IsTempName( char * ); extern CMD_ARG * pCommand; extern SymTable * pUUIDTable; extern SymTable * pBaseSymTbl; extern TREGISTRY * pCallAsTable; extern BOOL Xxx_Is_Type_OK( node_skl * pType ); extern "C" { #ifndef GUID_DEFINED #define GUID_DEFINED typedef struct _GUID { // size is 16 unsigned long Data1; unsigned short Data2; unsigned short Data3; unsigned char Data4[8]; } GUID; #endif typedef GUID IID; extern const GUID IID_IAdviseSink; extern const GUID IID_IAdviseSink2; extern const GUID IID_IAdviseSinkEx; extern const GUID IID_AsyncIAdviseSink; extern const GUID IID_AsyncIAdviseSink2; // {DE77BA62-517C-11d1-A2DA-0000F8773CE9} static const GUID IID_AsyncIAdviseSinkEx2 = { 0xde77ba62, 0x517c, 0x11d1, { 0xa2, 0xda, 0x0, 0x0, 0xf8, 0x77, 0x3c, 0xe9 } }; }; bool IsAnyIAdviseSinkIID ( GUID& rIID ) { return ( !memcmp( &IID_IAdviseSink, &rIID, sizeof(GUID) ) || !memcmp( &IID_IAdviseSink2, &rIID, sizeof(GUID) ) || !memcmp( &IID_AsyncIAdviseSink, &rIID, sizeof(GUID) ) || !memcmp( &IID_AsyncIAdviseSink2, &rIID, sizeof(GUID) ) // IAdviseSinkEx will be converted to sync interface. || !memcmp( &IID_IAdviseSinkEx, &rIID, sizeof(GUID) ) ); } node_skl* GetIndirectionLevel ( node_skl* pType, unsigned int& nIndirectionLevel ) { if ( pType ) { node_skl* pChild = pType->GetChild(); if ( pChild ) { pType = pChild; NODE_T nodeKind = pType->NodeKind(); if ( nodeKind == NODE_POINTER ) { return GetIndirectionLevel( pType, ++nIndirectionLevel ); } else if ( nodeKind == NODE_INTERFACE ) { return pType; } else { return GetIndirectionLevel( pType, nIndirectionLevel ); } } } return pType; } node_skl* GetNonDefType ( node_skl* pType ) { node_skl* pChild = pType->GetChild(); if ( pChild && pType->NodeKind() == NODE_DEF ) { pType = GetNonDefType( pChild ); } return pType; } void node_skl::SemanticAnalysis( SEM_ANALYSIS_CTXT * ) { MIDL_ASSERT( !"node_skl semantic analysis called" ); } void node_skl::CheckDeclspecAlign( SEM_ANALYSIS_CTXT & MyContext ) { if (GetModifiers().IsModifierSet( ATTR_DECLSPEC_ALIGN ) && MyContext.AnyAncestorBits( IN_LIBRARY ) ) { SemError( this, MyContext, DECLSPEC_ALIGN_IN_LIBRARY, GetSymName() ); } } void node_href::SemanticAnalysis( SEM_ANALYSIS_CTXT * ) { // If this reference hasn't already been expanded, Resolve() will expand it. named_node * pRef = Resolve(); MIDL_ASSERT(pRef || !"node_href::Resolve() failed" ); // NOTE - we might want to just skip this step and simply clear any // remaining attributes. // Presumably, if it came from a type library, it must have // been previously analyzed and found to be correct. // pRef->SemanticAnalysis(pParentCtxt); // pParentCtxt->ClearAttributes(); } void node_forward::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { if ( fBeingAnalyzed ) { return; } fBeingAnalyzed = TRUE; SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); named_node * pRef = ResolveFDecl(); MyContext.ExtractAttribute( ATTR_HELPSTRING ); MyContext.ExtractAttribute( ATTR_DEFAULT ); while(MyContext.ExtractAttribute( ATTR_CUSTOM )); // check for illegal member attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_RETVAL: case MATTR_VARARG: case MATTR_SOURCE: case MATTR_DEFAULTVTABLE: case MATTR_RESTRICTED: case MATTR_OPTIONAL: case MATTR_PREDECLID: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_IMMEDIATEBIND: case MATTR_USESGETLASTERROR: break; case MATTR_REPLACEABLE: default: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } if ( !pRef && MyContext.AnyAncestorBits( IN_RPC ) ) { SemError( this, MyContext, UNRESOLVED_TYPE, GetSymName() ); } if ( pRef && ( pRef->NodeKind() == NODE_HREF )) { // expand the href pRef->SemanticAnalysis( &MyContext ); node_skl* pChild = pRef->GetChild(); if (pChild && pChild->NodeKind() == NODE_INTERFACE) { pRef = new node_interface_reference((node_interface *)pRef->GetChild()); } } // we must go on and process interface references; they will // control any recursing and eliminate the forward reference. if ( pRef ) { pRef->SemanticAnalysis( &MyContext ); node_skl * pParent = pParentCtxt->GetParent(); if ( pParent ) { // if we came from an interface, set the base interface if ( pParent->IsInterfaceOrObject() && pRef->NodeKind() == NODE_INTERFACE_REFERENCE ) { ((node_interface *)pParent)->SetMyBaseInterfaceReference( pRef ); } else // otherwise, probably an interface pointer { pParent->SetChild( pRef ); } } } else { // incomplete types may only be used in certain contexts... MyContext.SetDescendantBits( HAS_INCOMPLETE_TYPE ); } if ( MyContext.FindRecursiveContext( pRef ) ) { MyContext.SetDescendantBits( HAS_RECURSIVE_DEF ); MyContext.SetAncestorBits( IN_RECURSIVE_DEF ); } MyContext.RejectAttributes(); pParentCtxt->ReturnValues( MyContext ); fBeingAnalyzed = FALSE; } // checking the void usage in dispinterface. // currently we only check: // . void is not allowed as property or part of a structure. void node_base_type::CheckVoidUsageInDispinterface( SEM_ANALYSIS_CTXT * pContext ) { SEM_ANALYSIS_CTXT * pCtxt = (SEM_ANALYSIS_CTXT *) pContext->GetParentContext(); node_skl * pCur = pCtxt->GetParent(); BOOL fHasPointer = FALSE; while ( pCur->NodeKind() != NODE_FIELD && pCur->NodeKind() != NODE_PROC ) { if ( pCur->NodeKind() == NODE_POINTER ) fHasPointer = TRUE; else { if ( pCur->NodeKind() != NODE_DEF ) { RpcSemError( this, *pContext, NON_RPC_RTYPE_VOID, NULL ); return; } } pCtxt = (SEM_ANALYSIS_CTXT *) pCtxt->GetParentContext(); pCur = pCtxt->GetParent(); } // This is either a property or part of a structure. if ( pCur->NodeKind() == NODE_FIELD ) { if ( !fHasPointer ) { SemError( this, *pContext, INVALID_VOID_IN_DISPINTERFACE, NULL ); return; } } } void node_base_type::CheckVoidUsage( SEM_ANALYSIS_CTXT * pContext ) { SEM_ANALYSIS_CTXT * pCtxt = (SEM_ANALYSIS_CTXT *) pContext->GetParentContext(); node_skl * pCur = pCtxt->GetParent(); // we assume that we are in an RPC, so we are in the return type // or we are in the param list if (pContext->AnyAncestorBits( IN_FUNCTION_RESULT ) ) { // check up for anything other than def below proc while ( pCur->NodeKind() != NODE_PROC ) { if ( pCur->NodeKind() != NODE_DEF ) { RpcSemError( this, *pContext, NON_RPC_RTYPE_VOID, NULL ); return; } pCtxt = (SEM_ANALYSIS_CTXT *) pCtxt->GetParentContext(); pCur = pCtxt->GetParent(); } return; } // else param list... node_proc * pProc; node_param * pParam; // check up for anything other than def below proc // make sure the proc only has one param while ( pCur->NodeKind() != NODE_PARAM ) { if ( pCur->NodeKind() != NODE_DEF ) { RpcSemError( this, *pContext, NON_RPC_PARAM_VOID, NULL ); return; } pCtxt = (SEM_ANALYSIS_CTXT *) pCtxt->GetParentContext(); pCur = pCtxt->GetParent(); } // now we know the param derives directly from void // assume the proc is the immediate parent of the param pParam = ( node_param * ) pCur; pProc = ( node_proc * ) pCtxt->GetParentContext()->GetParent(); MIDL_ASSERT ( pProc->NodeKind() == NODE_PROC ); if ( ! IsTempName( pParam->GetSymName() ) ) SemError( this, *pContext, VOID_PARAM_WITH_NAME, NULL ); if ( pProc->GetNumberOfArguments() != 1 ) SemError( this, *pContext, VOID_NON_FIRST_PARAM, NULL ); // We know that the parameter is void. // So, chop it off to prevent complications from renaming etc. // and then using in a node_def in ILxlate. pProc->SetFirstMember( NULL ); pProc->SetSibling( NULL ); } void node_base_type::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); CheckContextHandle( MyContext ); CheckDeclspecAlign( MyContext ); // warn about OUT const things if ( FInSummary( ATTR_CONST ) ) { if ( MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) ) RpcSemError( this, MyContext, CONST_ON_OUT_PARAM, NULL ); else if ( MyContext.AnyAncestorBits( IN_FUNCTION_RESULT ) ) RpcSemError( this, MyContext, CONST_ON_RETVAL, NULL ); } while(MyContext.ExtractAttribute(ATTR_CUSTOM)); node_range_attr* pRange = ( node_range_attr* ) MyContext.ExtractAttribute(ATTR_RANGE); MyContext.ExtractAttribute(ATTR_RANGE); if ( pRange ) { if ( pRange->GetMinExpr()->GetValue() > pRange->GetMaxExpr()->GetValue() ) { SemError(this, MyContext, INCORRECT_RANGE_DEFN, 0); } } switch ( NodeKind() ) { case NODE_FLOAT: case NODE_DOUBLE: case NODE_HYPER: case NODE_INT64: case NODE_LONGLONG: if ( pRange ) { SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, 0 ); } break; case NODE_INT3264: if ( MyContext.AnyAncestorBits( IN_LIBRARY ) ) { SemError( this, MyContext, NO_SUPPORT_IN_TLB, 0 ); } if ( pRange && pCommand->Is64BitEnv() ) { SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, 0 ); } break; case NODE_INT: if ( MyContext.AnyAncestorBits( IN_FUNCTION_RESULT ) ) RpcSemError( this, MyContext, NON_RPC_RTYPE_INT, NULL ); else RpcSemError( this, MyContext, NON_RPC_PARAM_INT, NULL ); break; case NODE_INT128: case NODE_FLOAT80: case NODE_FLOAT128: if ( pRange ) { SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, 0 ); } if ( MyContext.AnyAncestorBits( IN_LIBRARY ) ) { SemError( this, MyContext, NO_SUPPORT_IN_TLB, 0 ); } break; case NODE_VOID: MyContext.SetDescendantBits( DERIVES_FROM_VOID ); // if we are in an RPC, then we must be THE return type, // or we must be the sole parameter, which must be tempname'd // (except that void * is allowed in [iid_is] constructs) if (MyContext.AnyAncestorBits( IN_RPC ) && !MyContext.AnyAncestorBits( IN_INTERFACE_PTR ) ) CheckVoidUsage( &MyContext ); if ( MyContext.AnyAncestorBits( IN_DISPINTERFACE ) ) CheckVoidUsageInDispinterface( &MyContext ); break; case NODE_HANDLE_T: MyContext.SetDescendantBits( HAS_HANDLE ); if (MyContext.AnyAncestorBits( IN_PARAM_LIST ) ) { SEM_ANALYSIS_CTXT * pParamCtxt; node_param * pParamNode; pParamCtxt = (SEM_ANALYSIS_CTXT *) pParentCtxt->FindAncestorContext( NODE_PARAM ); pParamNode = (node_param *) pParamCtxt->GetParent(); if ( MyContext.AnyAncestorBits( IN_RPC ) ) pParamNode->HandleKind = HDL_PRIM; if ( MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) && !MyContext.AnyAncestorBits( UNDER_IN_PARAM ) ) RpcSemError( this, MyContext, HANDLE_T_CANNOT_BE_OUT, NULL ); if ( MyContext.AnyAncestorBits( IN_HANDLE ) ) { RpcSemError( this, MyContext, GENERIC_HDL_HANDLE_T, NULL ); } node_skl * pParamBasic = pParamNode->GetBasicType(); if ( pParamBasic->NodeKind() == NODE_POINTER ) { if ( pParamBasic->GetBasicType()->NodeKind() != NODE_HANDLE_T ) RpcSemError( pParamNode, *pParamCtxt, HANDLE_T_NO_TRANSMIT, NULL ); } } break; default: break; } MyContext.RejectAttributes(); pParentCtxt->ReturnValues( MyContext ); }; BOOL node_id::IsConstantString() { // check for *, and const stringable type below node_skl * pBasic = GetBasicType(); if ( pBasic->NodeKind() != NODE_POINTER ) return FALSE; node_skl * pParent = pBasic; node_skl * pChild = pParent->GetChild(); BOOL fConst = FALSE; while ( pChild ) { // if we reached a stringable type, report it's constness if ( pChild->IsStringableType() || ( pChild->NodeKind() == NODE_VOID ) ) { return fConst || pParent->FInSummary( ATTR_CONST ); } // skip only typedefs looking for the base type if ( pChild->NodeKind() != NODE_DEF ) return FALSE; // catch intervening const's if ( pParent->FInSummary( ATTR_CONST ) ) fConst = TRUE; pParent = pChild; pChild = pParent->GetChild(); } return FALSE; } void node_id::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); BOOL fIsConstant; node_constant_attr * pID = (node_constant_attr *) MyContext.ExtractAttribute(ATTR_ID); MyContext.ExtractAttribute(ATTR_HELPCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRINGCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRING); if ( HasCorrelation( this ) ) { MyContext.IncCorrelationCount(); } CheckDeclspecAlign( MyContext ); /* // NishadM: Stricter type checking if ( pID && pID->GetExpr()->AlwaysGetType() ) { if ( !( ( node_base_type*) pID->GetExpr()->GetType() )->IsCompatibleType( ts_FixedPoint ) ) { SemError( this, MyContext, EXPR_INCOMPATIBLE_TYPES, NULL); } } if ( pHC && pHC->GetExpr()->AlwaysGetType() ) { if ( !( ( node_base_type*) pHC->GetExpr()->GetType() )->IsCompatibleType( ts_UnsignedFixedPoint ) ) { SemError( this, MyContext, EXPR_INCOMPATIBLE_TYPES, NULL); } } if ( pHSC && pHSC->GetExpr()->AlwaysGetType() ) { if ( !( ( node_base_type*) pHSC->GetExpr()->GetType() )->IsCompatibleType( ts_UnsignedFixedPoint ) ) { SemError( this, MyContext, EXPR_INCOMPATIBLE_TYPES, NULL); } } */ if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } MyContext.ExtractAttribute(ATTR_HIDDEN); GetChild()->SemanticAnalysis( &MyContext ); fIsConstant = FInSummary( ATTR_CONST ) || IsConstantString() || GetChild()->FInSummary( ATTR_CONST ); if (pID) { SEM_ANALYSIS_CTXT * pIntfCtxt = (SEM_ANALYSIS_CTXT *) MyContext.GetInterfaceContext(); node_interface * pIntf = (node_interface *) pIntfCtxt->GetParent(); if (!pIntf->AddId(pID->GetExpr()->GetValue(), GetSymName())) SemError( this, MyContext, DUPLICATE_IID, NULL); if (fIsConstant) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } } // don't allow instantiation of data if ( GetChild()->NodeKind() != NODE_PROC ) { if ( !FInSummary( ATTR_EXTERN ) && !FInSummary( ATTR_STATIC ) && !fIsConstant ) SemError( this, MyContext, ACTUAL_DECLARATION, NULL ); // error here if dce for extern or static, too if ( !GetInitList() || !fIsConstant ) SemError( this, MyContext, ILLEGAL_OSF_MODE_DECL, NULL ); } if ( pInit ) { EXPR_CTXT InitCtxt( &MyContext ); node_skl * pBasicType = GetBasicType(); node_skl * pInitType = NULL; pInit->ExprAnalyze( &InitCtxt ); if ( InitCtxt.AnyUpFlags( EX_UNSAT_FWD ) ) TypeSemError( this, MyContext, EXPR_NOT_EVALUATABLE, NULL ); pInitType = pInit->GetType(); if ( pInitType && !pInitType->IsBasicType() ) pInitType = pInitType->GetBasicType(); if ( pBasicType && pInitType && pBasicType->IsBasicType() && pInitType->IsBasicType() ) { if ( !((node_base_type *)pBasicType) ->RangeCheck( pInit->GetValue() ) ) TypeSemError( this, MyContext, VALUE_OUT_OF_RANGE, NULL ); } if ( !pInit->IsConstant() ) TypeSemError( this, MyContext, RHS_OF_ASSIGN_NOT_CONST, NULL ); } if ( MyContext.AnyAncestorBits( HAS_OLEAUTOMATION )|| MyContext.AnyAncestorBits( IN_DISPINTERFACE ) ) { if ( !IsOLEAutomationCompliant( this ) ) { SemError(this, MyContext, NOT_OLEAUTOMATION_INTERFACE, NULL); } } // disallow forward references on declarations if ( MyContext.AnyDescendantBits( HAS_INCOMPLETE_TYPE ) ) { if (! MyContext.AnyAncestorBits( IN_LIBRARY )) SemError( this, MyContext, UNDEFINED_SYMBOL, NULL ); MyContext.ClearDescendantBits( HAS_INCOMPLETE_TYPE ); } MyContext.ClearDescendantBits( HAS_RECURSIVE_DEF ); pParentCtxt->ReturnValues( MyContext ); } void node_label::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); while(MyContext.ExtractAttribute(ATTR_CUSTOM)); if ( MyContext.ExtractAttribute(ATTR_IDLDESCATTR) ) { SemError(this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, 0); } if ( MyContext.ExtractAttribute(ATTR_VARDESCATTR) ) { SemError(this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, 0); } if ( MyContext.ExtractAttribute(ATTR_ID) ) { SemError(this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, 0); } MyContext.ExtractAttribute(ATTR_HIDDEN); MyContext.ExtractAttribute( ATTR_HELPSTRING ); MyContext.ExtractAttribute( ATTR_HELPSTRINGCONTEXT ); MyContext.ExtractAttribute( ATTR_HELPCONTEXT ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } // check for illegal member attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_RETVAL: case MATTR_VARARG: case MATTR_SOURCE: case MATTR_DEFAULTVTABLE: case MATTR_RESTRICTED: case MATTR_OPTIONAL: case MATTR_PREDECLID: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_IMMEDIATEBIND: case MATTR_USESGETLASTERROR: break; case MATTR_REPLACEABLE: default: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } if ( HasCorrelation( this ) ) { MyContext.IncCorrelationCount(); } CheckDeclspecAlign( MyContext ); if ( pExpr ) { EXPR_CTXT ExprCtxt( &MyContext ); pExpr->ExprAnalyze( &ExprCtxt ); if ( ExprCtxt.AnyUpFlags( EX_UNSAT_FWD ) ) TypeSemError( this, MyContext, EXPR_NOT_EVALUATABLE, NULL ); } pParentCtxt->ReturnValues( MyContext ); }; #define DIRECT_NONE 0 #define DIRECT_IN 1 #define DIRECT_OUT 2 #define DIRECT_PARTIAL_IGNORE (DIRECT_IN | DIRECT_OUT | 4 ) #define DIRECT_IN_OUT (DIRECT_IN | DIRECT_OUT) void node_param::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); unsigned short Direction = DIRECT_NONE; char * pName = GetSymName(); node_skl * pChild = GetChild(); BOOL NoDirection = FALSE; MyContext.SetAncestorBits( IN_PARAM_LIST ); MyContext.MarkImportantPosition(); while(MyContext.ExtractAttribute(ATTR_CUSTOM)); MyContext.ExtractAttribute(ATTR_IDLDESCATTR); if ( MyContext.ExtractAttribute(ATTR_FLCID) ) { LCID(); } CheckDeclspecAlign( MyContext ); // check for illegal member attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { case MATTR_OPTIONAL: { node_skl * pBase = this; do { pBase = pBase->GetChild()->GetBasicType(); } while (NODE_ARRAY == pBase->NodeKind() || NODE_POINTER == pBase->NodeKind()); if ( !pBase->GetSymName() || ( (0 != _stricmp(pBase->GetSymName(), "tagVARIANT") ) && FNewTypeLib() && ( MyContext.AnyAncestorBits( HAS_OLEAUTOMATION ) || MyContext.AnyAncestorBits( IN_DISPINTERFACE ) ) ) ) { SemError(this, MyContext, INAPPLICABLE_OPTIONAL_ATTRIBUTE, pMA->GetNodeNameString()); } if ( ! MyContext.AnyAncestorBits( IN_LIBRARY ) ) { SemError(this, MyContext, OPTIONAL_OUTSIDE_LIBRARY, NULL); } Optional(); break; } case MATTR_RETVAL: Retval(); break; case MATTR_RESTRICTED: case MATTR_SOURCE: case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_VARARG: case MATTR_DEFAULTVTABLE: case MATTR_PREDECLID: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_USESGETLASTERROR: case MATTR_IMMEDIATEBIND: break; case MATTR_REPLACEABLE: default: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } node_constant_attr * pcaDefaultValue = (node_constant_attr *)MyContext.ExtractAttribute(ATTR_DEFAULTVALUE); if ( pcaDefaultValue ) { // UNDONE: Check that this attribute has a legal default value // We already have an [optional] flag. MIDL should issue a warning // that we shouldn't have both. if ( IsOptional() ) { SemError( this, MyContext, DEFAULTVALUE_WITH_OPTIONAL, 0); } pParentCtxt->SetDescendantBits( HAS_DEFAULT_VALUE ); Optional(); } if ( MyContext.ExtractAttribute(ATTR_IN) ) { pParentCtxt->SetDescendantBits( HAS_IN ); MyContext.SetAncestorBits( UNDER_IN_PARAM ); Direction |= DIRECT_IN; } if ( MyContext.ExtractAttribute(ATTR_OUT) ) { pParentCtxt->SetDescendantBits( HAS_OUT ); MyContext.SetAncestorBits( UNDER_OUT_PARAM ); Direction |= DIRECT_OUT; } if ( MyContext.ExtractAttribute( ATTR_PARTIAL_IGNORE ) ) { pCommand->GetNdrVersionControl().SetHasPartialIgnore(); pParentCtxt->SetDescendantBits( HAS_PARTIAL_IGNORE ); MyContext.SetAncestorBits( UNDER_PARTIAL_IGNORE_PARAM ); if ( !( Direction & DIRECT_IN ) || !( Direction & DIRECT_OUT ) ) { SemError( this, MyContext, PARTIAL_IGNORE_IN_OUT, GetSymName() ); } if ( FInSummary( ATTR_STRING ) && ! ( FInSummary( ATTR_SIZE ) || FInSummary( ATTR_MAX) ) ) { SemError( this, MyContext, UNSIZED_PARTIAL_IGNORE, GetSymName() ); } Direction |= DIRECT_PARTIAL_IGNORE; } if ( IsExtraStatusParam() ) MyContext.SetAncestorBits( UNDER_HIDDEN_STATUS ); // [retval] parameter must be on an [out] parameter and it // must be the last parameter in the list if (IsRetval() && (Direction != DIRECT_OUT || GetSibling() != NULL)) SemError(this, MyContext, INVALID_USE_OF_RETVAL, NULL ); // if the parameter has no IN or OUT, it is an IN parameter by default. // if so, issue a warning message // REVIEW: No warning is being issued. What about hidden status params // which are neither in nor out? if ( (Direction == DIRECT_NONE) && MyContext.AnyAncestorBits( IN_RPC ) ) { NoDirection = TRUE; MyContext.SetAncestorBits( UNDER_IN_PARAM ); Direction |= DIRECT_IN; } // warn about OUT const things if ( ( Direction & DIRECT_OUT ) && FInSummary( ATTR_CONST ) ) RpcSemError( this, MyContext, CONST_ON_OUT_PARAM, NULL ); if ( MyContext.FInSummary(ATTR_HANDLE) ) { HandleKind |= HDL_GEN; fAppliedHere = 1; } if ( MyContext.FInSummary(ATTR_CONTEXT) ) { HandleKind |= HDL_CTXT; fAppliedHere = 1; } if (HandleKind != HDL_NONE) MyContext.SetDescendantBits( HAS_HANDLE | HAS_CONTEXT_HANDLE ); // notice comm and fault statuses; the attributes are extracted by // the error_status_t if ( MyContext.FInSummary( ATTR_COMMSTAT ) ) { Statuses |= STATUS_COMM; } if ( MyContext.FInSummary( ATTR_FAULTSTAT ) ) { Statuses |= STATUS_FAULT; } acf_attr *pDRtag = (acf_attr *) MyContext.ExtractAttribute( ATTR_DRTAG ); acf_attr *pStag = (acf_attr *) MyContext.ExtractAttribute( ATTR_STAG ); acf_attr *pRtag = (acf_attr *) MyContext.ExtractAttribute( ATTR_RTAG ); if ( pDRtag ) { if ( !( Direction & DIRECT_IN ) ) AcfError(pDRtag, this, MyContext, IN_TAG_WITHOUT_IN, NULL); SetHasCSDRTag(); MyContext.SetDescendantBits( HAS_DRTAG ); } if ( pStag ) { if ( !( Direction & DIRECT_IN ) ) AcfError(pStag, this, MyContext, IN_TAG_WITHOUT_IN, NULL); SetHasCSSTag(); MyContext.SetDescendantBits( HAS_STAG ); } if ( pRtag ) { if ( !( Direction & DIRECT_OUT ) ) AcfError(pRtag, this, MyContext, OUT_TAG_WITHOUT_OUT, NULL); SetHasCSRTag(); MyContext.SetDescendantBits( HAS_RTAG ); } acf_attr * pForceAllocate = (acf_attr *) MyContext.ExtractAttribute( ATTR_FORCEALLOCATE ); if ( pForceAllocate ) { // we allow force allocation on [in] and [in,out] parameters. server allocate if ( ! (Direction & DIRECT_IN ) ) AcfError( pForceAllocate, this, MyContext, OUT_ONLY_FORCEALLOCATE, NULL ); MyContext.SetDescendantBits ( HAS_FORCEALLOCATE ); pCommand->GetNdrVersionControl().SetHasForceAllocate(); } pChild->SemanticAnalysis( &MyContext ); // OUT parameters should be pointers or arrays. // Don't use HAS_POINTER or arrays as it may come from a field. if ( ( Direction & DIRECT_PARTIAL_IGNORE ) == DIRECT_PARTIAL_IGNORE ) { node_skl *pPointer = GetNonDefChild(); if ( ( pPointer->NodeKind() != NODE_POINTER ) || MyContext.AnyDescendantBits((DESCENDANT_FLAGS) HAS_PIPE) ) { SemError( this, MyContext, PARTIAL_IGNORE_UNIQUE, NULL ); } node_skl *pPointee = pPointer->GetNonDefChild(); if ( pPointee->IsStructOrUnion() ) if ( ((node_su_base *) pPointee)->HasConformance() ) SemError( this, MyContext, UNSIZED_PARTIAL_IGNORE, NULL ); } else if ( (Direction & DIRECT_OUT) && !( GetNonDefChild()->IsPtrOrArray() || MyContext.AnyDescendantBits((DESCENDANT_FLAGS) HAS_PIPE))) { SemError( this, MyContext, NON_PTR_OUT, NULL ); } if ( pForceAllocate ) { if ( MyContext.AnyDescendantBits((DESCENDANT_FLAGS) HAS_PIPE) ) AcfError( pForceAllocate, this, MyContext, FORCEALLOCATE_ON_PIPE, NULL ); } // if no direction was specified, and we are not just void or a hidden // status parameter, then error if ( NoDirection ) { pParentCtxt->SetDescendantBits( HAS_IN ); if ( !MyContext.AnyDescendantBits( DERIVES_FROM_VOID ) && !IsExtraStatusParam() ) { RpcSemError( this, MyContext, NO_EXPLICIT_IN_OUT_ON_PARAM, NULL ); } } // disallow forward references as union members if ( MyContext.AnyDescendantBits( HAS_INCOMPLETE_TYPE ) ) { if (! MyContext.AnyAncestorBits( IN_LIBRARY )) SemError( this, MyContext, UNDEFINED_SYMBOL, NULL ); MyContext.ClearDescendantBits( HAS_INCOMPLETE_TYPE ); } MyContext.ClearDescendantBits( HAS_RECURSIVE_DEF ); // disallow module as params if ( GetBasicType()->NodeKind() == NODE_MODULE ) { SemError( this, MyContext, DERIVES_FROM_COCLASS_OR_MODULE, 0); } else if (GetBasicType()->NodeKind() == NODE_POINTER) { if (GetBasicType()->GetChild()->NodeKind() == NODE_MODULE ) { SemError( this, MyContext, DERIVES_FROM_COCLASS_OR_MODULE, 0); } } if ( GetBasicType()->NodeKind() == NODE_INTERFACE || GetBasicType()->NodeKind() == NODE_DISPINTERFACE ) { SemError( this, MyContext, INTF_NON_POINTER, 0); } // compound types may not be declared in param lists NODE_T ChildKind = pChild->NodeKind(); if ( ( ChildKind == NODE_ENUM ) || ( ChildKind == NODE_STRUCT ) || ( ChildKind == NODE_UNION ) ) { if ( IsDef() ) SemError( this, MyContext, COMP_DEF_IN_PARAM_LIST, NULL ); } // things not allowed in an RPC if ( MyContext.AnyAncestorBits( IN_RPC | IN_LIBRARY ) ) { if ( strcmp( pName, "..." ) == 0 ) SemError( this, MyContext, PARAM_IS_ELIPSIS, NULL ); if ( IsTempName( pName ) ) RpcSemError( this, MyContext, ABSTRACT_DECL, NULL ); } if ( ( HandleKind != HDL_NONE ) && ( Direction & DIRECT_IN ) ) fBindingParam = TRUE; if ( ( HandleKind == HDL_CTXT ) && MyContext.AnyDescendantBits( HAS_TRANSMIT_AS ) ) RpcSemError( this, MyContext, CTXT_HDL_TRANSMIT_AS, NULL ); if ( MyContext.AnyAncestorBits( HAS_OLEAUTOMATION ) || MyContext.AnyAncestorBits( IN_DISPINTERFACE ) ) { // check the child type instead of NODE_PARAM directly. nt bug #371499 if ( !IsOLEAutomationCompliant( GetBasicType() ) ) { SemError(this, MyContext, NOT_OLEAUTOMATION_INTERFACE, NULL); } } // don't allow functions as params if ( MyContext.AnyDescendantBits( HAS_FUNC ) && MyContext.AllAncestorBits( IN_INTERFACE | IN_RPC ) ) RpcSemError( this, MyContext, BAD_CON_PARAM_FUNC, NULL ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } if ( HasCorrelation( this ) ) { MyContext.IncCorrelationCount(); } if ( ( Direction & DIRECT_OUT ) && MyContext.GetCorrelationCount() ) { MyContext.SetDescendantBits( HAS_CLIENT_CORRELATION ); } if ( ( Direction & DIRECT_IN ) && MyContext.GetCorrelationCount() ) { MyContext.SetDescendantBits( HAS_SERVER_CORRELATION ); } if ( MyContext.AnyAncestorBits( HAS_ASYNCHANDLE ) && MyContext.AnyDescendantBits( (DESCENDANT_FLAGS) HAS_PIPE ) && pChild->GetNonDefSelf()->NodeKind() != NODE_POINTER ) { SemError(this, MyContext, ASYNC_PIPE_BY_REF, GetSymName() ); } // This is completely banned with the new transfer syntax. if ( pCommand->NeedsNDR64Run() ) { if ( MyContext.AnyDescendantBits( HAS_UNSAT_REP_AS ) ) { RpcSemError( this, MyContext, UNSPECIFIED_EMBEDDED_REPRESENT_AS_NOT_SUPPORTED, NULL ); } } pParentCtxt->ReturnValues( MyContext ); } void node_file::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { MEM_ITER MemIter( this ); node_skl * pN; SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); if ( ImportLevel == 0 ) { MyContext.SetAncestorBits( IN_INTERFACE ); } #ifdef ReducedImportSemAnalysis else return; #endif while ( ( pN = MemIter.GetNext() ) != 0 ) { // each interface node gets a fresh context MyContext.SetInterfaceContext( &MyContext ); // allow echo string and midl_grama outside library block, // even in mktyplib compatible mode if ( ( 0 == ImportLevel ) && ( NODE_LIBRARY != pN->NodeKind() ) && ( NODE_ECHO_STRING != pN->NodeKind() ) && ( NODE_MIDL_PRAGMA != pN->NodeKind() ) && ( pCommand->IsSwitchDefined(SWITCH_MKTYPLIB ) ) ) { SEM_ANALYSIS_CTXT DummyContext( pN, &MyContext ); SemError(pN, DummyContext, ILLEGAL_IN_MKTYPLIB_MODE, NULL); } pN->SemanticAnalysis( &MyContext ); }; pParentCtxt->ReturnValues( MyContext ); }; // for fault_status and comm_status #define NOT_SEEN 0 #define SEEN_ON_RETURN 1 #define SEEN_ON_PARAM 2 void node_proc::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { node_param* pN; node_optimize* pOptAttr; acf_attr* pAttr; ATTR_T CallingConv; MEM_ITER MemIter( this ); SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); SEM_ANALYSIS_CTXT* pIntfCtxt = (SEM_ANALYSIS_CTXT *) MyContext.GetInterfaceContext(); node_interface* pIntf = (node_interface *) pIntfCtxt->GetParent(); node_entry_attr* pEntry = NULL; node_base_attr* pAttrAsync = MyContext.ExtractAttribute( ATTR_ASYNC ); unsigned short Faultstat = NOT_SEEN; unsigned short Commstat = NOT_SEEN; unsigned short OpBits = MyContext.GetOperationBits(); BOOL fNoCode = FALSE; BOOL fCode = FALSE; BOOL Skipme = FALSE; BOOL fNonOperation = FALSE; BOOL fEncode = (NULL != MyContext.ExtractAttribute( ATTR_ENCODE )); BOOL fDecode = (NULL != MyContext.ExtractAttribute( ATTR_DECODE )); // Use bitwise or because otherwise the C/C++ compiler will incorrectly // short-circuit the call to ExtractAttribute(ATTR_DECODE). BOOL HasPickle = fEncode | fDecode; BOOL fExpHdlAttr = FALSE; BOOL fMaybe = OpBits & OPERATION_MAYBE; BOOL fMessage = OpBits & OPERATION_MESSAGE; BOOL fBindingFound = FALSE; BOOL fProcIsCallback= (NULL != MyContext.ExtractAttribute( ATTR_CALLBACK )); BOOL fLocal = (NULL != MyContext.ExtractAttribute( ATTR_LOCAL )); BOOL fNotify = (NULL != MyContext.ExtractAttribute( ATTR_NOTIFY )); BOOL fNotifyFlag = (NULL != MyContext.ExtractAttribute( ATTR_NOTIFY_FLAG )); node_skl* pRet = GetReturnType(); NODE_T BasicChildKind = pRet->GetBasicType()->NodeKind(); node_call_as* pCallAs = (node_call_as *) MyContext.ExtractAttribute( ATTR_CALL_AS ); acf_attr* pEnableAllocate = (acf_attr *) MyContext.ExtractAttribute( ATTR_ENABLE_ALLOCATE ); node_constant_attr* pID = (node_constant_attr *) MyContext.ExtractAttribute(ATTR_ID); node_constant_attr* pHC = (node_constant_attr *) MyContext.ExtractAttribute(ATTR_HELPCONTEXT); node_constant_attr* pHSC = (node_constant_attr *) MyContext.ExtractAttribute(ATTR_HELPSTRINGCONTEXT); node_text_attr* pHelpStr = (node_text_attr *) MyContext.ExtractAttribute(ATTR_HELPSTRING); bool fAddExplicitHandle = false; long nAfterLastOptionalParam = 0; node_cs_tag_rtn * pCSTagAttr = (node_cs_tag_rtn *) MyContext.ExtractAttribute( ATTR_CSTAGRTN ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } while(MyContext.ExtractAttribute(ATTR_CUSTOM)); MyContext.ExtractAttribute(ATTR_FUNCDESCATTR); MyContext.ExtractAttribute( ATTR_HIDDEN ); fHasDeny = pCommand->IsSwitchDefined( SWITCH_ROBUST ); if (MyContext.AnyAncestorBits( IN_MODULE )) { pEntry = (node_entry_attr *) MyContext.ExtractAttribute( ATTR_ENTRY ); if (pEntry) { if (pEntry->IsNumeric()) { char * szEntry = (char *)pEntry->GetID(); if ( ((LONG_PTR) szEntry) > 0xFFFF ) { SemError( this, MyContext, BAD_ENTRY_VALUE, NULL); } } else { char * szEntry = pEntry->GetSz(); if ( ((LONG_PTR) szEntry) <= 0xFFFF ) { SemError( this, MyContext, BAD_ENTRY_VALUE, NULL); } } } else { SemError(this, MyContext, BAD_ENTRY_VALUE, NULL); } } bool fBindable = false; bool fPropSomething = false; bool fPropGet = false; int nchSkip = 0; bool fHasVarArg = false; // check for illegal member attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { case MATTR_BINDABLE: fBindable = TRUE; break; case MATTR_PROPGET: nchSkip = 4; fPropSomething = TRUE; fPropGet = TRUE; break; case MATTR_PROPPUT: nchSkip = 4; fPropSomething = TRUE; break; case MATTR_PROPPUTREF: nchSkip = 7; fPropSomething = TRUE; break; case MATTR_VARARG: fHasVarArg = true; break; case MATTR_RESTRICTED: case MATTR_SOURCE: if ( MyContext.AnyAncestorBits( IN_MODULE )) { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_DEFAULTVTABLE: case MATTR_IMMEDIATEBIND: case MATTR_REPLACEABLE: break; case MATTR_READONLY: case MATTR_USESGETLASTERROR: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } case MATTR_RETVAL: case MATTR_OPTIONAL: case MATTR_PREDECLID: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } if (pID) { if (!pIntf->AddId(pID->GetExpr()->GetValue(),GetSymName() + nchSkip)) SemError( this, MyContext, DUPLICATE_IID, NULL); } if (fBindable && !fPropSomething) SemError(this, MyContext, INVALID_USE_OF_BINDABLE, NULL); if ( pEnableAllocate ) pIntf->SetHasProcsWithRpcSs(); fNonOperation = !pParentCtxt->GetParent()->IsInterfaceOrObject(); if ( !GetCallingConvention( CallingConv ) ) SemError( this, MyContext, MULTIPLE_CALLING_CONVENTIONS, NULL ); // locally applied [code] attribute overrides global [nocode] attribute fNoCode = (NULL != MyContext.ExtractAttribute( ATTR_NOCODE )); fCode = (NULL != MyContext.ExtractAttribute( ATTR_CODE )); if ( fCode && fNoCode ) { SemError( this, MyContext, CODE_NOCODE_CONFLICT, NULL ); } fNoCode = fNoCode || pIntfCtxt->FInSummary( ATTR_NOCODE ); fNoCode = !fCode && fNoCode; if ( fNoCode && pCommand->GenerateSStub() ) RpcSemError( this, MyContext, NOCODE_WITH_SERVER_STUBS, NULL ); // do my attribute parsing... fObjectProc = MyContext.ExtractAttribute( ATTR_OBJECT ) || pIntfCtxt->FInSummary( ATTR_OBJECT ); SetObjectProc( fObjectProc ); if ( fObjectProc ) { if ( pCommand->GetEnv() != ENV_WIN32 && pCommand->GetEnv() != ENV_WIN64 && !pCommand->IsSwitchDefined(SWITCH_MKTYPLIB)) { // REVIEW: We can eliminate the warning if object procs can be // in win64. It was necessary for dos, mac, etc. SemError( this, MyContext, OBJECT_PROC_MUST_BE_WIN32, NULL ); } if ( pEnableAllocate ) { AcfError( pEnableAllocate, this, MyContext, INAPPROPRIATE_ON_OBJECT_PROC, NULL ); } if ( HasPickle ) { SemError( this, MyContext, PICKLING_INVALID_IN_OBJECT, NULL ); } } bool fAsync = ( MyContext.AnyAncestorBits( HAS_ASYNCHANDLE ) != 0 ) || ( pAttrAsync != 0 ); if ( fAsync ) { MyContext.SetAncestorBits( HAS_ASYNCHANDLE ); // because we don't support async retry now, we need to issue an // explicit warning about this. if ( pCommand->NeedsNDR64Run() && !pCommand->NeedsNDRRun() ) SemError( this, MyContext, ASYNC_NDR64_ONLY, 0 ); } // check return types for non object proc.s with maybe, message // object proc.s should have HRESULT. This is checked later. if ( ( fMessage || fMaybe ) && !fObjectProc ) { if ( BasicChildKind != NODE_VOID ) { if ( BasicChildKind != NODE_E_STATUS_T ) { SemError( this, MyContext, MAYBE_NO_OUT_RETVALS, NULL ); } else { unsigned long ulCommStat = (unsigned long) ( MyContext.FInSummary(ATTR_COMMSTAT) ? 1 : 0 ), ulFaultStat = (unsigned long) ( MyContext.FInSummary(ATTR_FAULTSTAT) ? 1 : 0); if ( ulCommStat ^ ulFaultStat ) { SemError( this, MyContext, ASYNC_INCORRECT_ERROR_STATUS_T, 0 ); } } } } // check call_as characteristics if ( pCallAs ) { node_proc* pCallType = pCallAs->GetCallAsType(); // if we don't have it yet, search for the call_as target if ( !pCallType ) { // search the proc table for the particular proc SymKey SKey( pCallAs->GetCallAsName(), NAME_PROC ); pCallType = ( node_proc* ) pIntf->GetProcTbl()->SymSearch( SKey ); if ( !pCallType ) { if ( pIntfCtxt->FInSummary( ATTR_OBJECT ) ) AcfError( pCallAs, this, MyContext, CALL_AS_UNSPEC_IN_OBJECT, pCallAs->GetCallAsName() ); } else { pCallAs->SetCallAsType(pCallType); } } // now we should have the call_as type if ( pCallType ) // found the call_as proc { ((node_proc *)pCallType)->fCallAsTarget = TRUE; if ( ( pCallType->NodeKind() != NODE_PROC ) || !pCallType->FInSummary( ATTR_LOCAL ) ) AcfError( pCallAs, this, MyContext, CALL_AS_NON_LOCAL_PROC, pCallType->GetSymName() ); // insert pCallType into pCallAsTable if ( pCallAsTable->IsRegistered( pCallType ) ) // error AcfError( pCallAs, this, MyContext, CALL_AS_USED_MULTIPLE_TIMES, pCallType->GetSymName() ); else pCallAsTable->Register( pCallType ); } SetCallAsType( pCallType ); } // local procs don't add to count Skipme = fLocal; if ( Skipme ) { SemError( this, MyContext, LOCAL_ATTR_ON_PROC, NULL ); } Skipme = Skipme || pIntfCtxt->FInSummary( ATTR_LOCAL ); if ( Skipme ) { MyContext.SetAncestorBits( IN_LOCAL_PROC ); } // do my attribute parsing... // check for the [explicit_handle] attribute fExpHdlAttr = (NULL != MyContext.ExtractAttribute( ATTR_EXPLICIT )); fExpHdlAttr = fExpHdlAttr || pIntfCtxt->FInSummary( ATTR_EXPLICIT ); // we are in an RPC if we are in the main interface, its not local, and // we are not a typedef of a proc... if ( (ImportLevel == 0) && !MyContext.FindAncestorContext( NODE_DEF ) && pIntf && !Skipme ) { MyContext.SetAncestorBits( IN_RPC ); } else { MyContext.ClearAncestorBits( IN_RPC ); } // our optimization is controlled either locally or for the whole interface if ( ( pOptAttr = (node_optimize *) MyContext.ExtractAttribute( ATTR_OPTIMIZE ) ) != 0 ) { SetOptimizationFlags( pOptAttr->GetOptimizationFlags() ); SetOptimizationLevel( pOptAttr->GetOptimizationLevel() ); } else { SetOptimizationFlags( pIntf->GetOptimizationFlags() ); SetOptimizationLevel( pIntf->GetOptimizationLevel() ); } unsigned long fOptimize = GetOptimizationFlags(); if ( fOptimize & OPTIMIZE_INTERPRETER ) { MyContext.SetAncestorBits( IN_INTERPRET ); } HasPickle = HasPickle || pIntfCtxt->FInSummary( ATTR_ENCODE ) || pIntfCtxt->FInSummary( ATTR_DECODE ); if ( HasPickle && pCommand->IsSwitchDefined( SWITCH_ROBUST ) ) { if ( fOptimize & OPTIMIZE_INTERPRETER_V2 ) { pCommand->GetNdrVersionControl().SetHasOicfPickling(); } else { SemError( this, MyContext, ROBUST_PICKLING_NO_OICF, 0 ); } } BOOL HasCommFault = MyContext.FInSummary( ATTR_COMMSTAT ) || MyContext.FInSummary( ATTR_FAULTSTAT ); if ( HasPickle && HasCommFault ) { if ( ! ( fOptimize & OPTIMIZE_INTERPRETER_V2 ) ) { SemError( this, MyContext, COMMFAULT_PICKLING_NO_OICF, 0 ); } } // determine the proc number (local procs don't get a number) if ( !fNonOperation ) { if ( !fLocal ) { if ( fProcIsCallback ) { ProcNum = ( pIntf ->GetCallBackProcCount() )++; RpcSemError( this, MyContext, CALLBACK_NOT_OSF, NULL ); } else { ProcNum = ( pIntf ->GetProcCount() )++; } } // object procs need the procnum set for local procs, too else if ( fObjectProc && fLocal ) { ProcNum = ( pIntf ->GetProcCount() )++; } } else if ( MyContext.AnyAncestorBits( IN_RPC ) ) { RpcSemError( this, MyContext, FUNC_NON_RPC, NULL ); } else // proc not an operation, validate its usage { SEM_ANALYSIS_CTXT * pAbove = (SEM_ANALYSIS_CTXT *) MyContext.FindNonDefAncestorContext(); node_skl * pAboveNode = pAbove->GetParent(); if ( !pAboveNode->IsInterfaceOrObject() ) { if ( pAboveNode->NodeKind() != NODE_POINTER ) { TypeSemError( this, MyContext, FUNC_NON_POINTER, NULL ); } } } if ( MyContext.FInSummary( ATTR_COMMSTAT ) ) Commstat = SEEN_ON_RETURN; if ( MyContext.FInSummary( ATTR_FAULTSTAT ) ) Faultstat = SEEN_ON_RETURN; ////////////////////////////////////// // process the return type (it will eat commstat or faultstat) MyContext.SetAncestorBits( IN_FUNCTION_RESULT ); MyContext.MarkImportantPosition(); // warn about OUT const things if ( FInSummary( ATTR_CONST ) ) RpcSemError( this, MyContext, CONST_ON_RETVAL, NULL ); pRet->SemanticAnalysis( &MyContext ); MyContext.UnMarkImportantPosition(); if ( MyContext.AnyDescendantBits( HAS_UNION | HAS_STRUCT ) && !pCommand->GetNdrVersionControl().AllowIntrepretedComplexReturns() ) { // REVIEW: complex return types work for protocol all and ndr64. // make it work for dce also. if (HasPickle) { if (pCommand->Is64BitEnv()) RpcSemError( this, MyContext, PICKLING_RETVAL_TO_COMPLEX64, NULL ); } else if (ForceNonInterpret()) { RpcSemError( this, MyContext, NON_OI_BIG_RETURN, NULL ); } } else if ( MyContext.AnyDescendantBits( HAS_TOO_BIG_HDL ) ) { if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_BIG_GEN_HDL, NULL ); } else if ( !pCommand->NeedsNDR64Run() && MyContext.AnyDescendantBits( HAS_UNSAT_REP_AS )) { // REVIEW: Another case of an error that has already been caught // elsewhere. Investigate removing this check. if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_UNK_REP_AS, NULL ); } else if ( !pCommand->NeedsNDR64Run() && ( MyContext.AnyDescendantBits( HAS_REPRESENT_AS | HAS_TRANSMIT_AS ) && MyContext.AnyDescendantBits( HAS_ARRAY ) ) ) { if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_XXX_AS_ON_RETURN, NULL ); } else if ( ( BasicChildKind == NODE_INT128 ) || ( BasicChildKind == NODE_FLOAT80 ) || ( BasicChildKind == NODE_FLOAT128 ) ) { if (ForceNonInterpret()) RpcSemError( this, MyContext, RETURNVAL_TOO_COMPLEX_FORCE_OS, NULL ); } else if ( !pCommand->GetNdrVersionControl().AllowIntrepretedComplexReturns() && ( ( ( BasicChildKind == NODE_HYPER ) && !pCommand->Is64BitEnv() ) || ( BasicChildKind == NODE_FLOAT ) || ( BasicChildKind == NODE_DOUBLE ) ) ) { if ( HasPickle ) { if ( fOptimize & OPTIMIZE_INTERPRETER_V2 ) { if ( pCommand->Is64BitEnv() ) { RpcSemError( this, MyContext, PICKLING_RETVAL_TO_COMPLEX64, NULL ); } else if (ForceNonInterpret()) { // For pickling -Os is the same as -Oi RpcSemError( this, MyContext, PICKLING_RETVAL_FORCING_OI, NULL ); } } } else if ( ( fOptimize & OPTIMIZE_INTERPRETER_V2) ) { if ( fObjectProc ) { // Don't switch, generate NT 4.0 guard pCommand->GetNdrVersionControl().SetHasFloatOrDoubleInOi(); } else if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_RETVAL_64BIT, NULL ); } else if ( ( fOptimize & OPTIMIZE_ALL_I1_FLAGS ) ) { if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_RETVAL_64BIT, NULL ); } } else if ( ( CallingConv != ATTR_NONE ) && ( CallingConv != ATTR_STDCALL ) && ( CallingConv != ATTR_CDECL ) && !Skipme ) { if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_WRONG_CALL_CONV, NULL ); } if ( fProcIsCallback ) { if ( MyContext.AnyDescendantBits( HAS_HANDLE) ) RpcSemError( this, MyContext, HANDLES_WITH_CALLBACK, NULL ); if ( fObjectProc ) RpcSemError( this, MyContext, INVALID_ON_OBJECT_PROC, "[callback]" ); } if ( MyContext.AnyDescendantBits( HAS_FULL_PTR ) ) fHasFullPointer = TRUE; // all object methods must return HRESULT (except those of IUnknown and async methods) if ( fObjectProc && !Skipme && !MyContext.AnyDescendantBits( HAS_HRESULT ) ) { if ( !MyContext.AnyAncestorBits( IN_ROOT_CLASS ) && // not IUnknown !fAsync ) // not [async] { RpcSemError( this, MyContext, OBJECT_PROC_NON_HRESULT_RETURN, NULL ); } } ////////////////////////////////////// // process the parameters if ( !pIntf->IsAsyncClone() ) { if ( MyContext.AnyAncestorBits( HAS_ASYNC_UUID ) ) { node_skl* pParam = GetInOnlyParamPairedWithOut( MemIter ); if ( pParam ) { SemError( this, MyContext, ASYNC_INVALID_IN_OUT_PARAM_COMBO, pParam->GetSymName() ); } } } BOOL fParentIsAnyIAdviseSink = MyContext.AnyAncestorBits( IN_IADVISESINK ); BOOL fHasAsyncManager = FALSE; MyContext.ClearAncestorBits( IN_FUNCTION_RESULT ); MyContext.SetAncestorBits( IN_PARAM_LIST ); BOOL fLastParamWasOptional = FALSE; BOOL fHasPipeParam = FALSE; BOOL fHasConfOrVaryingParam = FALSE; BOOL fGenDefaultValueExpr = FALSE; BOOL fHasDRtag = FALSE; BOOL fHasRtag = FALSE; BOOL fHasStag = FALSE; BOOL fHasInCSType = FALSE; BOOL fHasOutCSType = FALSE; node_param* pFirstParamWithDefValue = 0; node_param* pLastParam = 0; node_param* p2LastParam = 0; node_param* p3LastParam = 0; bool fRetval = false; bool fLCID = false; unsigned long ulParamNumber = 0; MemIter.Init(); while ( ( pN = (node_param *) MemIter.GetNext() ) != 0 ) { fOptimize = GetOptimizationFlags(); BasicChildKind = pN->GetBasicType()->NodeKind(); p3LastParam = p2LastParam; p2LastParam = pLastParam; pLastParam = pN; MyContext.ClearAllDescendantBits(); MyContext.ResetCorrelationCount(); pN->SemanticAnalysis( &MyContext ); fRetval = fRetval || pN->IsRetval(); if ( pN->IsLCID() ) { if (BasicChildKind != NODE_LONG) { SemError( this, MyContext, LCID_SHOULD_BE_LONG, 0 ); } if (fLCID) { SemError( this, MyContext, INVALID_USE_OF_LCID, 0 ); } else fLCID = true; } if ( MyContext.AnyDescendantBits( HAS_MULTIDIM_VECTOR ) ) { if ( ForceInterpret2() ) { RpcSemError( this, MyContext, MULTI_DIM_VECTOR, NULL ); } } if ( MyContext.AnyDescendantBits( HAS_PARTIAL_IGNORE ) ) { if ( (fOptimize & OPTIMIZE_INTERPRETER ) ) { if ( ForceInterpret2() ) { RpcSemError( this, MyContext, PARTIAL_IGNORE_NO_OI, NULL ); } } if ( MyContext.AnyAncestorBits( IN_LIBRARY ) ) { SemError( this, MyContext, PARTIAL_IGNORE_IN_TLB, NULL ); } if ( pCommand->IsSwitchDefined( SWITCH_OSF ) ) { SemError( this, MyContext, INVALID_OSF_ATTRIBUTE, "[partial_ignore]" ); } } if ( MyContext.AnyDescendantBits( HAS_SERVER_CORRELATION ) ) { SetHasServerCorr(); IncServerCorrelationCount( MyContext.GetCorrelationCount() ); } if ( MyContext.AnyDescendantBits( HAS_CLIENT_CORRELATION ) ) { SetHasClientCorr(); IncClientCorrelationCount( MyContext.GetCorrelationCount() ); } BOOL fDefaultValue = MyContext.AnyDescendantBits( HAS_DEFAULT_VALUE ); if ( fDefaultValue ) { if ( !pFirstParamWithDefValue ) { pFirstParamWithDefValue = pN; fGenDefaultValueExpr = TRUE; } // can't have defaultvalue in vararg if ( fHasVarArg ) SemError(this, MyContext, NOT_VARARG_COMPATIBLE, 0); } else { // don't generate defaultvalue is c++ header if we have // non-defaultvalue parameter after it. fGenDefaultValueExpr = FALSE; pFirstParamWithDefValue = 0; } if ( MyContext.AnyDescendantBits( HAS_PIPE ) ) { fHasPipeParam = TRUE; node_skl* pBasicType = pN->GetBasicType(); while ( pBasicType && pBasicType->NodeKind() == NODE_POINTER ) { pBasicType = pBasicType->GetChild(); } if ( ( pBasicType->NodeKind() == NODE_INTERFACE_REFERENCE && !fObjectProc ) || ( pBasicType->NodeKind() == NODE_PIPE && fObjectProc ) ) { SemError(this, MyContext, UNIMPLEMENTED_FEATURE, pN->GetSymName() ); } } else if ( MyContext.AnyDescendantBits ( HAS_STRING | HAS_FULL_PTR | HAS_VAR_ARRAY | HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) ) { fHasConfOrVaryingParam = TRUE; } if ( ulParamNumber == 0 ) // first parameter { // if parent interface is is any IAdviseSink ignore [async]. if ( fAsync && fObjectProc ) { unsigned int nIndirection = 0; node_skl* pFType = GetIndirectionLevel ( pN, nIndirection ); // check async handle type if ( nIndirection != 2 ) { if ( !fParentIsAnyIAdviseSink ) { SemError(this, MyContext, OBJECT_ASYNC_NOT_DOUBLE_PTR, pN->GetChild()->GetSymName() ); } } if ( strcmp( pFType->GetSymName(), OBJECT_ASYNC_HANDLE_NAME ) ) { if ( !fParentIsAnyIAdviseSink ) { SemError(this, MyContext, ASYNC_INCORRECT_TYPE, pN->GetChild()->GetSymName() ); } } else { fHasAsyncManager = TRUE; } // flag the first param of an object interface as async handle pN->SetIsAsyncHandleParam(); if ( MyContext.AnyDescendantBits( HAS_OUT ) ) { SemError( this, MyContext, ASYNC_NOT_IN, NULL ); } } // Oicf interpreter cannot handle floats as first param, switch to Os. // This is a non-issue for ORPC because of the 'this' pointer. if ( ! pCommand->NeedsNDR64Run() && ( ( BasicChildKind == NODE_FLOAT ) || ( BasicChildKind == NODE_DOUBLE ) ) ) { if ( ( fOptimize & OPTIMIZE_INTERPRETER_V2) ) { if ( fObjectProc ) { // Don't switch, generate NT 4.0 guard pCommand->GetNdrVersionControl().SetHasFloatOrDoubleInOi(); } else if ( ForceNonInterpret() ) { RpcSemError( this, MyContext, NON_OI_TOPLEVEL_FLOAT, NULL ); } } } } // first parameter // Oi/Oic interpreter cannot handle float params on alpha, switch to Os. if ( ( BasicChildKind == NODE_FLOAT ) || ( BasicChildKind == NODE_DOUBLE ) ) { if ( ! pCommand->NeedsNDR64Run() && ( fOptimize & OPTIMIZE_INTERPRETER ) ) { // Old interpreter, always switch to -Os. if ( !( fOptimize & OPTIMIZE_INTERPRETER_V2 ) ) { if (ForceNonInterpret()) { RpcSemError( this, MyContext, NON_OI_TOPLEVEL_FLOAT, NULL ); } } // For -Oicf, there were no problems for object rpc; check standard else if ( !fObjectProc && ulParamNumber > 0 ) { // For 64b, float and double work for object and standard rpc. // The 32b NT4 engine didn't work for float args in standard rpc. if ( !pCommand->Is64BitEnv() && ( BasicChildKind == NODE_FLOAT ) ) { if (ForceNonInterpret()) { RpcSemError( this, MyContext, NON_OI_TOPLEVEL_FLOAT, NULL ); } } } // For param0 and retval we force above. } } /* parameter sequence of odl: 1. Required parameters (parameters that do not have the defaultvalue or optional attributes), 2. optional parameters with or without the defaultvalue attribute, 3. parameters with the optional attribute and without the defaultvalue attribute, 4. lcid parameter, if any, 5. retval parameter */ if ( pN->IsOptional() ) { fLastParamWasOptional = TRUE; // [in,optional] VARIANT v1, [in] long l1, [in,optional] VARIANT v2 if (nAfterLastOptionalParam > 0) nAfterLastOptionalParam++; // vararg can't coexist with optional parameter. if ( fHasVarArg ) SemError(this, MyContext , NOT_VARARG_COMPATIBLE, 0 ); } else { // If the following parameter after [optional] is either a RetVal or // LCID, we don't fail. The logic between Retval and LCID will be // checked later. if ( fLastParamWasOptional ) { // The only other parameter allowed to come after [optional] // in a propput/propget method is lcid. if ( fPropSomething && !pN->IsLCID() ) nAfterLastOptionalParam++; else if ( (!pN->IsRetval() && !pN->IsLCID()) && FNewTypeLib() ) { // In regular method, we can only have retval and lcid coming // after optional SemError( this, MyContext, OPTIONAL_PARAMS_MUST_BE_LAST, NULL ); } } } if ( ( pAttr = (acf_attr *) pN->GetAttribute( ATTR_COMMSTAT ) ) != 0 ) { if ( !MyContext.AnyDescendantBits( HAS_E_STAT_T ) ) AcfError( pAttr, this, MyContext, INVALID_COMM_STATUS_PARAM, NULL ); if ( Commstat == NOT_SEEN ) Commstat = SEEN_ON_PARAM; else if ( Commstat == SEEN_ON_RETURN ) AcfError( pAttr, this, MyContext, PROC_PARAM_COMM_STATUS, NULL ); else // already on another parameter AcfError( pAttr, this, MyContext, ERROR_STATUS_T_REPEATED, NULL ); } if ( ( pAttr = (acf_attr *) pN->GetAttribute( ATTR_FAULTSTAT ) ) != 0 ) { if ( !MyContext.AnyDescendantBits( HAS_E_STAT_T ) ) AcfError( pAttr, this, MyContext, INVALID_COMM_STATUS_PARAM, NULL ); if ( Faultstat == NOT_SEEN ) Faultstat = SEEN_ON_PARAM; else if ( Faultstat == SEEN_ON_RETURN ) AcfError( pAttr, this, MyContext, PROC_PARAM_FAULT_STATUS, NULL ); else // already on another parameter AcfError( pAttr, this, MyContext, ERROR_STATUS_T_REPEATED, NULL ); } if (MyContext.AnyDescendantBits( HAS_HANDLE) ) fHasExplicitHandle = TRUE; if (MyContext.AnyDescendantBits( HAS_IN ) ) fHasAtLeastOneIn = TRUE; if ( MyContext.AnyDescendantBits( HAS_POINTER ) ) fHasPointer = TRUE; if ( MyContext.AnyDescendantBits( HAS_FULL_PTR ) ) fHasFullPointer = TRUE; if (MyContext.AnyDescendantBits( HAS_OUT) ) { fHasAtLeastOneOut = TRUE; // complain about [out] on [maybe] procs if ( fMaybe ) RpcSemError( this, MyContext, MAYBE_NO_OUT_RETVALS, NULL ); } if (MyContext.AnyDescendantBits( (DESCENDANT_FLAGS) HAS_PIPE )) { #if defined(TARGET_RKK) if ( pCommand->GetTargetSystem() < NT40 ) RpcSemError( this, MyContext, REQUIRES_NT40, NULL ); #endif if (ForceInterpret2()) RpcSemError( this, MyContext, REQUIRES_OI2, NULL ); fHasPipes = TRUE; if ( HasPickle ) RpcSemError( this, MyContext, PIPES_WITH_PICKLING, NULL ); } // handle checks if ( pN->GetHandleKind() != HDL_NONE ) { if ( !fBindingFound ) // first handle seen { // dce only allows in handles as the first param if ( ulParamNumber != 0 ) RpcSemError( this, MyContext, HANDLE_NOT_FIRST, NULL ); // if the first binding handle is out-only, complain if ( !MyContext.AnyDescendantBits( HAS_IN ) && MyContext.AnyDescendantBits( HAS_OUT ) ) { if ( !( MyContext.AnyAncestorBits( HAS_AUTO_HANDLE | HAS_IMPLICIT_HANDLE ) || fExpHdlAttr ) ) { RpcSemError( this, MyContext, BINDING_HANDLE_IS_OUT_ONLY, NULL ); } else if ( fExpHdlAttr ) { fAddExplicitHandle = true; } } else if ( MyContext.AnyDescendantBits( HAS_OUT ) && ( pN->GetHandleKind() == HDL_PRIM ) ) { RpcSemError( this, MyContext, HANDLE_T_CANNOT_BE_OUT, NULL ); } else // plain [in], or [in,out] { fBindingFound = TRUE; MyContext.SetAncestorBits( BINDING_SEEN ); } } else // binding handle after the real one { if ( pN->GetHandleKind() == HDL_PRIM ) RpcSemError( this, MyContext, HANDLE_T_NO_TRANSMIT, NULL ); } } // if it had a handle if ( MyContext.AnyDescendantBits( HAS_TOO_BIG_HDL ) ) { if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_BIG_GEN_HDL, NULL ); } else if ( !pCommand->NeedsNDR64Run() &&MyContext.AnyDescendantBits( HAS_UNSAT_REP_AS ) ) { // This case should have been caught earlier. // REVIEW: Is this still relevant? if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_UNK_REP_AS, NULL ); } else if ( MyContext.AnyDescendantBits( HAS_UNION ) && IS_OLD_INTERPRETER( GetOptimizationFlags() ) ) { node_skl * pNDC = pN->GetNonDefChild(); if (pNDC->NodeKind() != NODE_PIPE && !pNDC->IsPtrOrArray()) { // unions by value but not arrays of unions if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_UNION_PARM, NULL ); } } if ( MyContext.AnyDescendantBits( HAS_DRTAG ) ) fHasDRtag = TRUE; if ( MyContext.AnyDescendantBits( HAS_RTAG ) ) fHasRtag = TRUE; if ( MyContext.AnyDescendantBits( HAS_STAG ) ) fHasStag = TRUE; if ( MyContext.AnyDescendantBits( HAS_IN_CSTYPE ) ) fHasInCSType = TRUE; if ( MyContext.AnyDescendantBits( HAS_OUT_CSTYPE ) ) fHasOutCSType = TRUE; ulParamNumber++; } // end of param list if ( MyContext.AnyDescendantBits( HAS_FORCEALLOCATE ) ) { if ( ! ( GetOptimizationFlags() & OPTIMIZE_INTERPRETER_V2 ) ) SemError( this, MyContext, FORCEALLOCATE_SUPPORTED_IN_OICF_ONLY, NULL ); } if ( fGenDefaultValueExpr ) { bool fReallyGenDefaultValueExpr = true; MemIter.Init(); do { pN = (node_param *) MemIter.GetNext(); } while ( pN != pFirstParamWithDefValue ); do { node_skl* pType = GetNonDefType( pN->GetChild() ); if ( !pType->IsBasicType() && pType->NodeKind() != NODE_POINTER && pType->NodeKind() != NODE_ENUM ) { SemError( this, MyContext, DEFAULTVALUE_NOT_ALLOWED, pN->GetSymName() ); fReallyGenDefaultValueExpr = false; break; } pN->GenDefaultValueExpr(); pN = (node_param *) MemIter.GetNext(); } while ( pN != 0 ); // don't genereate any defaultvalue in c++ header at all if ( !fReallyGenDefaultValueExpr ) { MemIter.Init(); while ( ( pN = (node_param *) MemIter.GetNext() ) != 0 ) { pN->GenDefaultValueExpr( false ); } } } if ( fHasPipeParam && fHasConfOrVaryingParam ) { SemError( this, MyContext, PIPE_INCOMPATIBLE_PARAMS, 0 ); } /////////////////////////////////////////////////////////////////////// if ( fHasExplicitHandle ) { if ( fProcIsCallback ) RpcSemError( this, MyContext, HANDLES_WITH_CALLBACK, NULL ); } if ( !fHasExplicitHandle || fAddExplicitHandle ) { if ( fExpHdlAttr ) { // async handle should be first param, // programmer supplies IAsyncManager in ORPC // MIDL adds PRPC_ASYNC_STATE in RPC // if parent interface is is any IAdviseSink ignore async. if ( fObjectProc && fAsync && fHasAsyncManager ) { AddExplicitHandle( &MyContext, 2 ); } else { // MIDL will add async handle later AddExplicitHandle( &MyContext, 1 ); } } else if ( !(pIntfCtxt->FInSummary( ATTR_IMPLICIT ) ) ) { // no explicit handle, no implicit handle, use auto_handle if ( !fProcIsCallback && MyContext.AnyAncestorBits( IN_RPC ) && !fObjectProc ) { if ( !pIntfCtxt->FInSummary( ATTR_AUTO ) ) RpcSemError( this, MyContext, NO_HANDLE_DEFINED_FOR_PROC, NULL ); } } } if ( fObjectProc || MyContext.AnyAncestorBits( IN_LIBRARY )) { if (fHasExplicitHandle || fExpHdlAttr || MyContext.FInSummary( ATTR_IMPLICIT ) || MyContext.FInSummary( ATTR_AUTO ) || pIntfCtxt->FInSummary( ATTR_AUTO ) || pIntfCtxt->FInSummary( ATTR_IMPLICIT ) || pIntfCtxt->FInSummary( ATTR_EXPLICIT ) ) { SemError( this, MyContext, HANDLES_WITH_OBJECT, NULL ); } } // record whether there are any comm/fault statuses if ( ( Faultstat != NOT_SEEN ) || ( Commstat != NOT_SEEN ) ) { fHasStatuses = TRUE; // [comm_status] and [fault_status] are supported in -Os. Intrepreted // modes are only supported in NT 3.51 or later. Hidden status // params are only supported in interpreted mode post-Win2000. // REVIEW: We can get hidden status params to work for Win2000 by // adding a line to the client stub that zero's the status // before calling the interpreter. if ( GetOptimizationFlags() & OPTIMIZE_ANY_INTERPRETER ) { if ( HasExtraStatusParam() && ( ! ( GetOptimizationFlags() & OPTIMIZE_INTERPRETER_V2 ) || !pCommand->NeedsNDR64Run() ) ) { // invisible fault/comm status are not supported in the V1 // interpreter. Switch to -Os // REVIEW: For now, only support hidden status params in the // V2 interpreter in -protocol all and -protocol ndr64 if (ForceNonInterpret()) RpcSemError( this, MyContext, NON_OI_ERR_STATS, NULL ); } else pCommand->GetNdrVersionControl().SetHasCommFaultStatusInOi12(); } } // record info for statuses on the return type if ( Faultstat == SEEN_ON_RETURN ) RTStatuses |= STATUS_FAULT; if ( Commstat == SEEN_ON_RETURN ) RTStatuses |= STATUS_COMM; if ( fHasPointer && !pCommand->IsSwitchDefined( SWITCH_MS_EXT ) ) pIntf->SetHasProcsWithRpcSs(); if ( ( OpBits & ( OPERATION_MAYBE | OPERATION_BROADCAST | OPERATION_IDEMPOTENT ) ) != 0 && fObjectProc ) { SemError(this, MyContext, ILLEGAL_COMBINATION_OF_ATTRIBUTES, NULL); } // [message] only allowed in ORPC interfaces and RPC procs. if ( fMessage && fObjectProc ) { // [message] applied on proc. SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } if ( MyContext.AnyAncestorBits( HAS_MESSAGE ) ) { // [message] applied on interface. if ( !fObjectProc ) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } fMessage = TRUE; } if ( fMessage ) { if ( OpBits & OPERATION_BROADCAST || OpBits & OPERATION_IDEMPOTENT || OpBits & OPERATION_INPUT_SYNC || fMaybe || fAsync || fProcIsCallback || pCallAs || HasPickle || pHC || pHSC || pID || pHelpStr || MyContext.FInSummary(ATTR_BYTE_COUNT) || MyContext.FInSummary(ATTR_COMMSTAT) || MyContext.FInSummary(ATTR_CONTEXT) || MyContext.FInSummary(ATTR_CUSTOM) || MyContext.FInSummary(ATTR_ENABLE_ALLOCATE) || MyContext.FInSummary(ATTR_ENTRY) || MyContext.FInSummary(ATTR_FAULTSTAT) || MyContext.FInSummary(ATTR_FUNCDESCATTR) || MyContext.FInSummary(ATTR_HIDDEN) || MyContext.FInSummary(ATTR_MEMBER) || MyContext.FInSummary(ATTR_PTR_KIND) || MyContext.FInSummary(ATTR_VARDESCATTR) || MyContext.FInSummary(ATTR_OBJECT) || MyContext.FInSummary(ATTR_TYPEDESCATTR) || MyContext.FInSummary(ATTR_TYPE) ) { SemError(this, MyContext, ILLEGAL_COMBINATION_OF_ATTRIBUTES, NULL); } if ( HasAtLeastOneOut() ) { SemError(this, MyContext, MAYBE_NO_OUT_RETVALS, NULL); } } if ( MyContext.AnyAncestorBits( HAS_OLEAUTOMATION ) ) { char* szRetTypeNonDefName = 0; node_skl* pReturnType = GetReturnType(); if (pReturnType) { szRetTypeNonDefName = pReturnType->GetSymName(); } if ( GetReturnType()->GetBasicType()->NodeKind() != NODE_VOID && ( !szRetTypeNonDefName || _stricmp(szRetTypeNonDefName, "HRESULT") ) ) { SemError(this, MyContext, NOT_OLEAUTOMATION_INTERFACE, NULL); } } if ( fPropSomething && MyContext.AnyAncestorBits( IN_LIBRARY ) ) { // propget can either return the property in an out parameter or // in the return value. if ( fPropGet && !HasAParameter() && !HasReturn() ) { SemError(this, MyContext, INVALID_USE_OF_PROPGET, NULL); } // propput must set the property in a parameter else if ( !fPropGet && !HasAParameter() ) { SemError(this, MyContext, INVALID_USE_OF_PROPPUT, NULL); } } if (MyContext.AnyAncestorBits( (ANCESTOR_FLAGS) IN_DISPINTERFACE ) && !pID) { SemError(this, MyContext, DISPATCH_ID_REQUIRED, NULL); } if ( fAsync ) { if ( fForcedS || pOptAttr || fNotify || HasPickle || fProcIsCallback || fLocal || fCode || fNoCode || fMaybe || fMessage || OpBits & OPERATION_INPUT_SYNC || pIntfCtxt->FInSummary( ATTR_AUTO ) ) { SemError(this, MyContext, ILLEGAL_COMBINATION_OF_ATTRIBUTES, NULL); } // async handle should be first param, // programmer supplies IAsyncManager in ORPC // MIDL adds PRPC_ASYNC_STATE in RPC if ( fObjectProc ) { if ( fHasAsyncManager ) { SetHasAsyncHandle(); } // if parent interface is is any IAdviseSink ignore. if ( !fParentIsAnyIAdviseSink ) { if ( ulParamNumber == 0 ) { SemError( this, MyContext, ASYNC_INCORRECT_TYPE, 0); } pCommand->GetNdrVersionControl().SetHasAsyncHandleRpc(); } } else { AddFullAsyncHandle( &MyContext, 0, RPC_ASYNC_HANDLE_NAME ); if ( pAttrAsync && !pAttrAsync->IsAcfAttr() ) { SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } if ( !pIntfCtxt->FInSummary( ATTR_IMPLICIT ) && !fExpHdlAttr && !fHasExplicitHandle ) { SemError( this, MyContext, ASYNC_INCORRECT_BINDING_HANDLE, 0 ); } pCommand->GetNdrVersionControl().SetHasAsyncHandleRpc(); } if ( pCommand->IsSwitchDefined( SWITCH_OSF ) ) { SemError( this, MyContext, INVALID_OSF_ATTRIBUTE, "[async]" ); } // switch compiler modes if (ForceInterpret2()) { RpcSemError( this, MyContext, ASYNC_REQUIRES_OI2, NULL ); } } // I don't like this complex logic, but unfortunately this is the right logic. It's easier // to code this logic in mktyplib code structure but hard to do it here... if ( fLCID ) { node_param* pLCID; // if there is a [retval], [lcid] must be the second last if ( fRetval) pLCID = p2LastParam; else { if (fPropSomething) { // in propget without a retval, the lcid must be the last. // in propput/propputref, lcid is second last. if (fPropGet) pLCID = pLastParam; else pLCID = p2LastParam; } // lcid should be the last if it's a regular method without propsomething & retval else pLCID = pLastParam; } if ( !pLCID || !pLCID->IsLCID() ) { SemError( this, MyContext, INVALID_USE_OF_LCID, 0 ); } } // we can only have one parameter after optioanl in propput/propget, other than lcid. if ( fLastParamWasOptional && fPropSomething && ( nAfterLastOptionalParam > 1 ) ) SemError(this, MyContext , INVALID_PROP_PARAMS , 0); // Verify that a propput method is valid. // TODO: much of the above code relating to propput/get could be simplified // with state driven logic and is redundent with the code below if ( fPropSomething & !fPropGet ) { using namespace PropPut; State state = NoParam; node_param *pParam; MemIter.Init(); while ( NULL != (pParam = (node_param *) MemIter.GetNext()) ) { if ( pParam->FInSummary( ATTR_DEFAULTVALUE ) ) state = StateTable[state][Default]; else if ( pParam->IsOptional() ) state = StateTable[state][Optional]; else if ( pParam->IsLCID() ) state = StateTable[state][LCID]; else state = StateTable[state][GeneralParam]; } state = StateTable[state][NoParam]; if ( Accept != state ) SemError(this, MyContext , INVALID_PROPPUT , 0); } if ( fHasVarArg ) { // [vararg] [lcid] [retval] // last 0 0 // 2 last last 0 // 2 last 0 last // 3 last 2last last node_param* pVarargParam = fRetval ? ( fLCID ? p3LastParam : p2LastParam ) : ( fLCID ? p2LastParam : pLastParam ); if ( pVarargParam ) { node_skl* pType = pVarargParam->GetChild(); if ( pType->NodeKind() == NODE_POINTER ) { pType = pType->GetChild(); } pType = GetNonDefType( pType ); if ( pType->NodeKind() != NODE_SAFEARRAY || strcmp( GetNonDefType( pType->GetChild() )->GetSymName(), "tagVARIANT" ) ) { SemError( this, MyContext, NOT_VARARG_COMPATIBLE, 0 ); } } else { SemError( this, MyContext, NOT_VARARG_COMPATIBLE, 0 ); } } if ( pIntf->IsAsyncClone() ) { SetHasAsyncUUID(); ForceInterpret2(); } if ( fNotify || fNotifyFlag ) { unsigned short uOpt = GetOptimizationFlags(); if ( !( uOpt & OPTIMIZE_SIZE ) ) { pCommand->GetNdrVersionControl().SetHasInterpretedNotify(); if ( IS_OLD_INTERPRETER(uOpt) ) { if (ForceInterpret2()) RpcSemError( this, MyContext, NON_OI_NOTIFY, NULL ); } } } if ( fHasInCSType && !fHasStag ) SemError( this, MyContext, NO_TAGS_FOR_IN_CSTYPE, 0 ); if ( fHasOutCSType && ( !fHasDRtag || !fHasRtag ) ) SemError( this, MyContext, NO_TAGS_FOR_OUT_CSTYPE, 0 ); if ( fHasInCSType || fHasOutCSType ) { if ( NULL != pCSTagAttr ) SetCSTagRoutine( pCSTagAttr->GetCSTagRoutine() ); else MyContext.SetDescendantBits( HAS_IN_CSTYPE ); } if ( HasPickle && MyContext.AnyDescendantBits( HAS_PARTIAL_IGNORE ) ) { SemError( this, MyContext, PARTIAL_IGNORE_PICKLING, GetSymName() ); } MyContext.SetDescendantBits( HAS_FUNC ); pParentCtxt->ReturnValues( MyContext ); } void node_field::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); BOOL fLastField = ( GetSibling() == NULL ); node_case * pCaseAttr; expr_list * pCaseExprList; expr_node * pCaseExpr; BOOL fHasCases = FALSE; node_su_base * pParent = (node_su_base *) MyContext.GetParentContext()->GetParent(); BOOL fInUnion = ( pParent->NodeKind() == NODE_UNION ); node_switch_type * pSwTypeAttr = ( node_switch_type *) pParent->GetAttribute( ATTR_SWITCH_TYPE ); node_skl * pSwType = NULL; char * pName = GetSymName(); node_constant_attr * pID = (node_constant_attr *) MyContext.ExtractAttribute(ATTR_ID); MyContext.ExtractAttribute(ATTR_HELPCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRINGCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRING); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } while(MyContext.ExtractAttribute(ATTR_CUSTOM)); if ( MyContext.ExtractAttribute(ATTR_IDLDESCATTR) ) { SemError(this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, 0); } if ( MyContext.ExtractAttribute(ATTR_VARDESCATTR) ) { SemError(this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, 0); } MyContext.ExtractAttribute(ATTR_HIDDEN); if ( HasCorrelation( this ) ) { MyContext.IncCorrelationCount(); } CheckDeclspecAlign( MyContext ); if (pID) { SEM_ANALYSIS_CTXT * pIntfCtxt = (SEM_ANALYSIS_CTXT *) MyContext.GetInterfaceContext(); node_interface * pIntf = (node_interface *) pIntfCtxt->GetParent(); if (!pIntf->AddId(pID->GetExpr()->GetValue(), GetSymName())) SemError( this, MyContext, DUPLICATE_IID, NULL); } else { if ( MyContext.AnyAncestorBits( (ANCESTOR_FLAGS) IN_DISPINTERFACE ) && pParent->NodeKind() == NODE_DISPINTERFACE) { SemError(this, MyContext, DISPATCH_ID_REQUIRED, NULL); } } node_entry_attr * pEntry = NULL; // check for illegal member attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_DEFAULTVTABLE: case MATTR_PREDECLID: case MATTR_READONLY: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_IMMEDIATEBIND: case MATTR_REPLACEABLE: break; case MATTR_SOURCE: { char * pAttrName = pMA->GetNodeNameString(); if ( MyContext.AnyAncestorBits( IN_STRUCT | IN_UNION ) ) SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: case MATTR_OPTIONAL: case MATTR_RESTRICTED: case MATTR_RETVAL: case MATTR_VARARG: case MATTR_USESGETLASTERROR: default: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } if (MyContext.AnyAncestorBits( IN_MODULE )) pEntry = (node_entry_attr *) MyContext.ExtractAttribute( ATTR_ENTRY ); if ( pSwTypeAttr ) pSwType = pSwTypeAttr->GetType(); // process all the cases and the default while ( ( pCaseAttr = (node_case *) MyContext.ExtractAttribute( ATTR_CASE ) ) != 0 ) { if ( !fInUnion ) TypeSemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, "[case]" ); fHasCases = TRUE; if ( pSwType ) { pCaseExprList = pCaseAttr->GetExprList(); pCaseExprList->Init(); while ( pCaseExprList->GetPeer( &pCaseExpr ) == STATUS_OK ) { // make sure the expression has the proper type, so sign extension behaves node_skl * pCaseType = pCaseExpr->GetType(); if ( ( !pCaseType ) || ( pCaseType->GetNonDefSelf()->IsBasicType() ) ) { pCaseExpr->SetType( pSwType->GetBasicType() ); } // range/type checks __int64 CaseValue = pCaseExpr->GetValue(); if ( !((node_base_type *)pSwType)->RangeCheck( CaseValue ) ) TypeSemError( this, MyContext, CASE_VALUE_OUT_OF_RANGE, NULL ); } } } if ( MyContext.ExtractAttribute( ATTR_DEFAULT ) ) { if ( !fInUnion ) TypeSemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, "[default]" ); fHasCases = TRUE; } // union fields in an RPC MUST have cases if ( fInUnion && !fHasCases ) RpcSemError( this, MyContext, CASE_LABELS_MISSING_IN_UNION, NULL ); // temp field names valid for: structs/enums/empty arms if ( IsTempName( pName ) ) { NODE_T BaseType = GetBasicType()->NodeKind(); if ( ( BaseType != NODE_UNION ) && ( BaseType != NODE_STRUCT ) && ( BaseType != NODE_ERROR ) ) SemError( GetBasicType(), MyContext, BAD_CON_UNNAMED_FIELD_NO_STRUCT, NULL ); } GetChild()->SemanticAnalysis( &MyContext ); // allow conformant array or struct only as last field, and not in unions! if ( MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) ) { if ( fInUnion ) { RpcSemError( this, MyContext, BAD_CON_UNION_FIELD_CONF , NULL ); } else if (!fLastField ) { SemError( this, MyContext, CONFORMANT_ARRAY_NOT_LAST, NULL ); } } // disallow forward references as members if ( MyContext.AnyDescendantBits( HAS_INCOMPLETE_TYPE ) ) { if (! MyContext.AnyAncestorBits( IN_LIBRARY )) SemError( this, MyContext, UNDEFINED_SYMBOL, NULL ); MyContext.ClearDescendantBits( HAS_INCOMPLETE_TYPE ); } MyContext.ClearDescendantBits( HAS_RECURSIVE_DEF ); // don't allow functions as fields if ( MyContext.AnyDescendantBits( HAS_FUNC ) && MyContext.AllAncestorBits( IN_INTERFACE | IN_RPC ) ) RpcSemError( this, MyContext, BAD_CON_FIELD_FUNC, NULL ); if ( MyContext.AnyDescendantBits( HAS_UNSAT_REP_AS ) ) SetHasUnknownRepAs(); pParentCtxt->ReturnValues( MyContext ); } void node_bitfield::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); CheckDeclspecAlign( MyContext ); RpcSemError( this, MyContext, BAD_CON_BIT_FIELDS, NULL ); if ( MyContext.AnyAncestorBits( IN_PARAM_LIST ) ) { RpcSemError( this, MyContext, NON_RPC_PARAM_BIT_FIELDS, NULL ); } else { RpcSemError( this, MyContext, NON_RPC_RTYPE_BIT_FIELDS, NULL ); } GetChild()->SemanticAnalysis( &MyContext ); node_skl * pType = GetBasicType(); switch ( pType->NodeKind() ) { case NODE_INT: break; case NODE_BOOLEAN: case NODE_SHORT: case NODE_CHAR: case NODE_LONG: case NODE_INT32: case NODE_INT3264: case NODE_INT64: case NODE_INT128: case NODE_HYPER: SemError( this, MyContext, BAD_CON_BIT_FIELD_NON_ANSI, NULL ); break; default: SemError( this, MyContext, BAD_CON_BIT_FIELD_NOT_INTEGRAL, NULL ); break; } // disallow forward references as members if ( MyContext.AnyDescendantBits( HAS_INCOMPLETE_TYPE ) ) { if (! MyContext.AnyAncestorBits( IN_LIBRARY )) SemError( this, MyContext, UNDEFINED_SYMBOL, NULL ); MyContext.ClearDescendantBits( HAS_INCOMPLETE_TYPE ); } MyContext.ClearDescendantBits( HAS_RECURSIVE_DEF ); pParentCtxt->ReturnValues( MyContext ); } void node_su_base::CheckLegalParent(SEM_ANALYSIS_CTXT & MyContext) { WALK_CTXT * pParentCtxt = MyContext.GetParentContext(); node_file * pFile = GetDefiningFile(); if (NULL == pFile) { node_skl * pParent = pParentCtxt->GetParent(); if (NULL == pParent || pParent->NodeKind() == NODE_LIBRARY) SemError( this, MyContext, ILLEGAL_SU_DEFINITION, NULL ); } }; void node_enum::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { MEM_ITER MemIter( this ); node_skl * pN; SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); MyContext.ExtractAttribute( ATTR_V1_ENUM ); while(MyContext.ExtractAttribute(ATTR_CUSTOM)); MyContext.ExtractAttribute(ATTR_TYPEDESCATTR); MyContext.ExtractAttribute(ATTR_HELPCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRINGCONTEXT); MyContext.ExtractAttribute( ATTR_HELPSTRING ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } if ( MyContext.ExtractAttribute(ATTR_IDLDESCATTR) ) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } // check for illegal type attributes node_type_attr * pTA; while ( ( pTA = (node_type_attr *)MyContext.ExtractAttribute(ATTR_TYPE) ) != 0 ) { switch (pTA->GetAttr()) { // acceptable attributes case TATTR_PUBLIC: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } // check for illegal member attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { case MATTR_USESGETLASTERROR: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } CheckDeclspecAlign( MyContext ); node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); // make sure the UUID is unique if ( pGuid ) { node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } if (pCommand->IsSwitchDefined(SWITCH_MKTYPLIB)) CheckLegalParent(MyContext); node_range_attr* pRange = ( node_range_attr* ) MyContext.ExtractAttribute(ATTR_RANGE); if ( pRange ) { if ( pRange->GetMinExpr()->GetValue() > pRange->GetMaxExpr()->GetValue() ) { SemError(this, MyContext, INCORRECT_RANGE_DEFN, 0); } } while ( ( pN = MemIter.GetNext() ) != 0 ) { pN->SemanticAnalysis( &MyContext ); } MyContext.SetDescendantBits( HAS_ENUM ); pParentCtxt->ReturnValues( MyContext ); } // structs are stringable if all the fields are "byte" BOOL node_struct::IsStringableType() { MEM_ITER MemIter( this ); node_skl * pBasic; node_skl * pN; // make sure all the fields are BYTE! with no attributes on the way while ( ( pN = (node_skl *) MemIter.GetNext() ) != 0 ) { pBasic = pN->GetBasicType(); do { if ( pN->HasAttributes() ) return FALSE; pN = pN->GetChild(); } while ( pN != pBasic ); pBasic = pN->GetBasicType(); if ( pBasic && (pBasic->NodeKind() != NODE_BYTE ) ) { return FALSE; } } return TRUE; } void node_struct::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { MEM_ITER MemIter( this ); node_skl * pN; SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); if ( fBeingAnalyzed ) { // if we hit the same node more than once (it can only be through a ptr), // and the ptr type is ref, we flag an error; recursive defn. through a ref ptr. if ( !MyContext.AnyAncestorBits( IN_NON_REF_PTR ) && MyContext.AnyAncestorBits( IN_RPC ) ) { TypeSemError( this, MyContext, RECURSION_THRU_REF, NULL ); } return; } fBeingAnalyzed = TRUE; CheckDeclspecAlign( MyContext ); BOOL fString = (NULL != MyContext.ExtractAttribute( ATTR_STRING )); node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); // make sure the UUID is unique if ( pGuid ) { node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } MyContext.MarkImportantPosition(); MyContext.SetAncestorBits( IN_STRUCT ); // clear NE union flag MyContext.ClearAncestorBits( IN_UNION | IN_NE_UNION ); while(MyContext.ExtractAttribute(ATTR_CUSTOM)); MyContext.ExtractAttribute(ATTR_TYPEDESCATTR); MyContext.ExtractAttribute(ATTR_HELPCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRINGCONTEXT); MyContext.ExtractAttribute( ATTR_HELPSTRING ); if ( MyContext.ExtractAttribute( ATTR_VERSION ) ) { SemError(this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, 0); } if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } // clear member attributes while (MyContext.ExtractAttribute(ATTR_MEMBER)); if (pCommand->IsSwitchDefined(SWITCH_MKTYPLIB)) CheckLegalParent(MyContext); // See if context_handle applied to param reached us if ( CheckContextHandle( MyContext ) ) { MyContext.SetDescendantBits( HAS_HANDLE | HAS_CONTEXT_HANDLE ); } while ( ( pN = MemIter.GetNext() ) != 0 ) { pN->SemanticAnalysis( &MyContext ); if ( MyContext.AnyDescendantBits( HAS_HANDLE ) ) TypeSemError( pN, MyContext, BAD_CON_CTXT_HDL_FIELD, NULL ); } if ( fString && !IsStringableType() ) { TypeSemError( this, MyContext, WRONG_TYPE_IN_STRING_STRUCT, NULL ); } // If a structure has an embedded array of pointers the back end gets // really confused and generates bad pointer layouts. Work around the // problem by forcing the structure to be complex. if ( MyContext.AnyDescendantBits( HAS_VAR_ARRAY | HAS_ARRAYOFPOINTERS ) ) Complexity |= FLD_VAR; if ( MyContext.AnyDescendantBits( HAS_CONF_ARRAY ) ) { Complexity |= FLD_CONF; fHasConformance = 1; } if ( MyContext.AnyDescendantBits( HAS_CONF_VAR_ARRAY ) ) { Complexity |= FLD_CONF_VAR; fHasConformance = 1; } // don't pass up direct conformance characteristic MyContext.ClearDescendantBits( HAS_DIRECT_CONF_OR_VAR ); // disallow direct forward references as struct members if ( MyContext.AnyDescendantBits( HAS_INCOMPLETE_TYPE ) ) { if (! MyContext.AnyAncestorBits( IN_LIBRARY )) SemError( this, MyContext, UNDEFINED_SYMBOL, NULL ); MyContext.ClearDescendantBits( HAS_INCOMPLETE_TYPE ); } MyContext.ClearDescendantBits( HAS_RECURSIVE_DEF ); if ( MyContext.AnyDescendantBits( HAS_POINTER ) ) SetHasAtLeastOnePointer( TRUE ); // save info on complexity for code generation if ( MyContext.AnyDescendantBits( HAS_VAR_ARRAY | HAS_TRANSMIT_AS | HAS_REPRESENT_AS | HAS_INTERFACE_PTR | HAS_MULTIDIM_SIZING | HAS_ARRAY_OF_REF ) ) { Complexity |= FLD_COMPLEX; } if ( pCommand->NeedsNDR64Run() ) { if ( MyContext.AnyDescendantBits( HAS_UNSAT_REP_AS ) ) { RpcSemError( this, MyContext, UNSPECIFIED_EMBEDDED_REPRESENT_AS_NOT_SUPPORTED, NULL ); } } MyContext.ClearDescendantBits( HAS_ARRAY | HAS_MULTIDIM_VECTOR ); MyContext.SetDescendantBits( HAS_STRUCT ); pParentCtxt->ReturnValues( MyContext ); fBeingAnalyzed = FALSE; } // note: this lets HAS_UNION propogate up to any enclosing structs void node_en_struct::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { MEM_ITER MemIter( this ); node_skl * pN; SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); if ( fBeingAnalyzed ) { // if we hit the same node more than once (it can only be through a ptr), // and the ptr type is ref, we flag an error; recursive defn. through a ref ptr. if ( !MyContext.AnyAncestorBits( IN_NON_REF_PTR ) && MyContext.AnyAncestorBits( IN_RPC ) ) { TypeSemError( this, MyContext, RECURSION_THRU_REF, NULL ); } return; } fBeingAnalyzed = TRUE; MyContext.ExtractAttribute(ATTR_HELPCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRINGCONTEXT); MyContext.ExtractAttribute( ATTR_HELPSTRING ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } CheckDeclspecAlign( MyContext ); node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); // make sure the UUID is unique if ( pGuid ) { node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } if (pCommand->IsSwitchDefined(SWITCH_MKTYPLIB)) CheckLegalParent(MyContext); MyContext.SetAncestorBits( IN_STRUCT ); // See if context_handle applied to param reached us if ( CheckContextHandle( MyContext ) ) { MyContext.SetDescendantBits( HAS_HANDLE | HAS_CONTEXT_HANDLE ); } while ( ( pN = MemIter.GetNext() ) != 0 ) { pN->SemanticAnalysis( &MyContext ); }; if ( pCommand->NeedsNDR64Run() ) { if ( MyContext.AnyDescendantBits( HAS_UNSAT_REP_AS ) ) { RpcSemError( this, MyContext, UNSPECIFIED_EMBEDDED_REPRESENT_AS_NOT_SUPPORTED, NULL ); } } if ( MyContext.AnyDescendantBits( HAS_POINTER ) ) SetHasAtLeastOnePointer( TRUE ); pParentCtxt->ReturnValues( MyContext ); fBeingAnalyzed = FALSE; } void node_union::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { MEM_ITER MemIter( this ); node_field * pN; SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); BOOL fEncap = IsEncapsulatedUnion(); node_switch_type * pSwTypeAttr = (node_switch_type *) MyContext.ExtractAttribute( ATTR_SWITCH_TYPE ); node_switch_is * pSwIsAttr = (node_switch_is *) MyContext.ExtractAttribute( ATTR_SWITCH_IS ); BOOL NonEmptyArm = FALSE; BOOL HasCases = FALSE; BOOL HasBadExpr = FALSE; if ( HasCorrelation( this ) ) { MyContext.IncCorrelationCount(); } if (pCommand->IsSwitchDefined(SWITCH_MKTYPLIB)) CheckLegalParent(MyContext); MyContext.ExtractAttribute(ATTR_TYPEDESCATTR); while(MyContext.ExtractAttribute(ATTR_CUSTOM)); MyContext.ExtractAttribute(ATTR_HELPCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRINGCONTEXT); MyContext.ExtractAttribute( ATTR_HELPSTRING ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } if ( MyContext.ExtractAttribute( ATTR_HIDDEN ) ) { SemError(this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, 0); } if ( MyContext.ExtractAttribute( ATTR_VERSION ) ) { SemError(this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, 0); } if ( fBeingAnalyzed ) { // if we hit the same node more than once (it can only be through a ptr), // and the ptr type is ref, we flag an error; recursive defn. through a ref ptr. if ( !MyContext.AnyAncestorBits( IN_NON_REF_PTR ) && MyContext.AnyAncestorBits( IN_RPC ) ) { TypeSemError( this, MyContext, RECURSION_THRU_REF, NULL ); } return; } fBeingAnalyzed = TRUE; CheckDeclspecAlign( MyContext ); if ( pSwIsAttr ) { EXPR_CTXT SwCtxt( &MyContext ); expr_node * pSwIsExpr = pSwIsAttr->GetExpr(); pSwIsExpr->ExprAnalyze( &SwCtxt ); if ( SwCtxt.AnyUpFlags( EX_UNSAT_FWD ) ) { TypeSemError( this, MyContext, ATTRIBUTE_ID_UNRESOLVED, pSwIsAttr->GetNodeNameString() ); HasBadExpr = TRUE; } if ( !SwCtxt.AnyUpFlags( EX_VALUE_INVALID ) ) { TypeSemError( this, MyContext, ATTRIBUTE_ID_MUST_BE_VAR, pSwIsAttr->GetNodeNameString() ); HasBadExpr = TRUE; } } // if they left off the switch_type, take it from the switch_is type if ( !pSwTypeAttr && !fEncap && pSwIsAttr && !HasBadExpr ) { node_skl * pSwIsType = pSwIsAttr->GetSwitchIsType(); MIDL_ASSERT( pSwIsType || !"no type for switch_is expr"); if ( ( pSwIsType->NodeKind() == NODE_FIELD ) || ( pSwIsType->NodeKind() == NODE_PARAM ) ) pSwIsType = pSwIsType->GetChild(); pSwTypeAttr = new node_switch_type( pSwIsType ); SetAttribute( pSwTypeAttr ); } if ( pSwIsAttr && pSwTypeAttr && !HasBadExpr ) { node_skl * pSwIsType = pSwIsAttr->GetSwitchIsType(); node_skl * pSwType = pSwTypeAttr->GetType(); pSwIsType = pSwIsType->GetBasicType(); if ( pSwIsType && pSwIsType->IsBasicType() && pSwType->IsBasicType() ) { if ( !((node_base_type *)pSwType) ->IsAssignmentCompatible( (node_base_type *) pSwIsType ) ) TypeSemError( this, MyContext, SWITCH_TYPE_MISMATCH, NULL ); } if ( !pSwType || !Xxx_Is_Type_OK( pSwType ) ) { TypeSemError( this, MyContext, SWITCH_IS_TYPE_IS_WRONG, pSwType ? pSwType->GetSymName() : NULL ); } if ( !pSwIsType || !Xxx_Is_Type_OK( pSwIsType ) ) { TypeSemError( this, MyContext, SWITCH_IS_TYPE_IS_WRONG, pSwIsType ? pSwIsType->GetSymName() : NULL ); } } // We don't care about local: it can be anything. if ( MyContext.AnyAncestorBits( IN_RPC ) ) { if ( !fEncap && !pSwTypeAttr && !pSwIsAttr ) { if ( MyContext.AnyAncestorBits( IN_PARAM_LIST ) ) RpcSemError( this, MyContext, NON_RPC_UNION, NULL ); else RpcSemError( this, MyContext, NON_RPC_RTYPE_UNION, NULL ); } if ( !fEncap && MyContext.AnyAncestorBits( IN_FUNCTION_RESULT ) && !MyContext.AnyAncestorBits( IN_STRUCT | IN_UNION ) ) RpcSemError( this, MyContext, RETURN_OF_UNIONS_ILLEGAL, NULL ); if ( pSwTypeAttr && !pSwIsAttr ) RpcSemError( this, MyContext, NO_SWITCH_IS, NULL ); } // See if context_handle applied to param reached us if ( CheckContextHandle( MyContext ) ) { MyContext.SetDescendantBits( HAS_HANDLE | HAS_CONTEXT_HANDLE ); } MyContext.MarkImportantPosition(); if ( MyContext.AllAncestorBits( IN_INTERFACE | IN_NE_UNION ) ) { RpcSemError( this, MyContext, NE_UNION_FIELD_NE_UNION, NULL ); } if ( ( MyContext.FindNonDefAncestorContext()->GetParent() ->NodeKind() == NODE_UNION ) && MyContext.AnyAncestorBits( IN_INTERFACE ) ) { RpcSemError( this, MyContext, ARRAY_OF_UNIONS_ILLEGAL, NULL ); } MyContext.SetAncestorBits( IN_UNION | IN_NE_UNION ); MyContext.SetDescendantBits( HAS_UNION ); // eat the union flavor determiner MyContext.ExtractAttribute( ATTR_MS_UNION ); while ( ( pN = (node_field *) MemIter.GetNext() ) != 0 ) { // tbd - put cases into case database... // tbd - check type, range, and duplication pN->SemanticAnalysis( &MyContext ); if ( !NonEmptyArm && !pN->IsEmptyArm() ) NonEmptyArm = TRUE; if ( !HasCases && (pN->FInSummary( ATTR_CASE ) || pN->FInSummary( ATTR_DEFAULT ) ) ) HasCases = TRUE; } // at least one arm should be non-empty if ( !NonEmptyArm ) SemError( this, MyContext, UNION_NO_FIELDS, NULL ); if ( !fEncap && !pSwTypeAttr && !HasCases ) RpcSemError( this, MyContext, BAD_CON_NON_RPC_UNION, NULL ); // disallow forward references as union members if ( MyContext.AnyDescendantBits( HAS_INCOMPLETE_TYPE ) ) { if (! MyContext.AnyAncestorBits( IN_LIBRARY )) SemError( this, MyContext, UNDEFINED_SYMBOL, NULL ); MyContext.ClearDescendantBits( HAS_INCOMPLETE_TYPE ); } MyContext.ClearDescendantBits( HAS_RECURSIVE_DEF ); if ( MyContext.AnyDescendantBits( HAS_POINTER ) ) SetHasAtLeastOnePointer( TRUE ); if ( MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) ) { RpcSemError( this, MyContext, BAD_CON_UNION_FIELD_CONF , NULL ); } if ( pCommand->NeedsNDR64Run() ) { if ( MyContext.AnyDescendantBits( HAS_UNSAT_REP_AS ) ) { RpcSemError( this, MyContext, UNSPECIFIED_EMBEDDED_REPRESENT_AS_NOT_SUPPORTED, NULL ); } } // clear flags not affecting complexity above MyContext.ClearDescendantBits( HAS_POINTER | HAS_CONF_PTR | HAS_VAR_PTR | HAS_CONF_VAR_PTR | HAS_MULTIDIM_SIZING | HAS_MULTIDIM_VECTOR | HAS_ARRAY_OF_REF | HAS_ENUM | HAS_DIRECT_CONF_OR_VAR | HAS_ARRAY | HAS_REPRESENT_AS | HAS_TRANSMIT_AS | HAS_CONF_VAR_ARRAY | HAS_CONF_ARRAY | HAS_VAR_ARRAY ); pParentCtxt->ReturnValues( MyContext ); fBeingAnalyzed = FALSE; } void node_en_union::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { MEM_ITER MemIter( this ); node_field * pN; SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); node_switch_type* pSwTypeAttr = ( node_switch_type* ) MyContext.ExtractAttribute( ATTR_SWITCH_TYPE ); node_skl * pSwType; node_switch_is* pSwIsAttr = ( node_switch_is* ) MyContext.ExtractAttribute( ATTR_SWITCH_IS ); BOOL NonEmptyArm = FALSE; if ( HasCorrelation( this ) ) { MyContext.IncCorrelationCount(); } // gaj - tbd do semantic checks on these attributes MyContext.ExtractAttribute( ATTR_HELPSTRING ); MyContext.ExtractAttribute( ATTR_HELPSTRINGCONTEXT ); MyContext.ExtractAttribute( ATTR_HELPCONTEXT ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); // make sure the UUID is unique if ( pGuid ) { node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } if ( fBeingAnalyzed ) { // if we hit the same node more than once (it can only be through a ptr), // and the ptr type is ref, we flag an error; recursive defn. through a ref ptr. if ( !MyContext.AnyAncestorBits( IN_NON_REF_PTR ) && MyContext.AnyAncestorBits( IN_RPC ) ) { TypeSemError( this, MyContext, RECURSION_THRU_REF, NULL ); } return; } fBeingAnalyzed = TRUE; CheckDeclspecAlign( MyContext ); if ( pSwTypeAttr ) { pSwType = pSwTypeAttr->GetSwitchType(); if ( !pSwType || !Xxx_Is_Type_OK( pSwType ) || pSwType->NodeKind() == NODE_BYTE ) { TypeSemError( this, MyContext, SWITCH_IS_TYPE_IS_WRONG, pSwType ? pSwType->GetSymName() : NULL ); } } if ( pSwIsAttr ) { EXPR_CTXT SwCtxt( &MyContext ); expr_node * pSwIsExpr = pSwIsAttr->GetExpr(); pSwIsExpr->ExprAnalyze( &SwCtxt ); if ( SwCtxt.AnyUpFlags( EX_UNSAT_FWD ) ) TypeSemError( this, MyContext, ATTRIBUTE_ID_UNRESOLVED, pSwIsAttr->GetNodeNameString() ); if ( !SwCtxt.AnyUpFlags( EX_VALUE_INVALID ) ) TypeSemError( this, MyContext, ATTRIBUTE_ID_MUST_BE_VAR, pSwIsAttr->GetNodeNameString() ); } MyContext.MarkImportantPosition(); MyContext.SetAncestorBits( IN_UNION ); MyContext.SetDescendantBits( HAS_UNION ); while ( ( pN = (node_field *) MemIter.GetNext() ) != 0 ) { // tbd - put cases into case database... // tbd - check type, range, and duplication pN->SemanticAnalysis( &MyContext ); if ( !pN->IsEmptyArm() ) NonEmptyArm = TRUE; } // at least one arm should be non-empty if ( !NonEmptyArm ) SemError( this, MyContext, UNION_NO_FIELDS, NULL ); // remember if we have a pointer if ( MyContext.AnyDescendantBits( HAS_POINTER ) ) SetHasAtLeastOnePointer( TRUE ); if ( MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) ) { RpcSemError( this, MyContext, BAD_CON_UNION_FIELD_CONF , NULL ); } // clear flags not affecting complexity above MyContext.ClearDescendantBits( HAS_POINTER | HAS_CONF_PTR | HAS_VAR_PTR | HAS_CONF_VAR_PTR | HAS_MULTIDIM_SIZING | HAS_MULTIDIM_VECTOR | HAS_ARRAY_OF_REF | HAS_ENUM | HAS_DIRECT_CONF_OR_VAR | HAS_ARRAY | HAS_REPRESENT_AS | HAS_TRANSMIT_AS | HAS_CONF_VAR_ARRAY | HAS_CONF_ARRAY | HAS_VAR_ARRAY ); pParentCtxt->ReturnValues( MyContext ); fBeingAnalyzed = FALSE; } void node_def::SemanticAnalysisForTransmit( SEM_ANALYSIS_CTXT * pMyContext, BOOL fPresented ) { if ( fPresented ) { // the presented type may not be conformant. if ( pMyContext->AnyDescendantBits( HAS_VAR_ARRAY | HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) ) TypeSemError( this, *pMyContext, TRANSMIT_TYPE_CONF, NULL ); } else { // transmitted type may not have a pointer. if ( pMyContext->AnyDescendantBits( HAS_POINTER | HAS_INTERFACE_PTR ) ) TypeSemError( this,*pMyContext, TRANSMIT_AS_POINTER, NULL ); // transmitted type may not derive from void if ( pMyContext->AnyDescendantBits( DERIVES_FROM_VOID ) ) TypeSemError( this, *pMyContext, TRANSMIT_AS_VOID, NULL ); } } void node_def::SemanticAnalysisForWireMarshal( SEM_ANALYSIS_CTXT * pMyContext, BOOL fPresented ) { if ( fPresented ) { // We need to check if the presented type is not void; note, void * is ok. } else { // We check only the transmitted type for wire_marshal, user marshal. // // The transmitted type must not have full pointers, since // the app has no mechanism to generate the full pointer ids. // BUG, BUG semantic analysis treats arrays in structures // as pointers. Change to error once the bug is fixed. if ( pMyContext->AnyDescendantBits( HAS_FULL_PTR ) ) TypeSemError( this, *pMyContext, WIRE_HAS_FULL_PTR, NULL); // The wire type must have a fully defined memory size. It cannot be // conformant or conformant varying. Arrays have a problem // in that the app can't marshal the MaxCount, Actual Count, or Offset properly. if ( pMyContext->AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) ) TypeSemError( this, *pMyContext, WIRE_NOT_DEFINED_SIZE, NULL); // transmitted type may not derive from void if ( pMyContext->AnyDescendantBits( DERIVES_FROM_VOID ) ) TypeSemError( this, *pMyContext, TRANSMIT_AS_VOID, NULL ); } } void node_def::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); BOOL fInRpc = MyContext.AnyAncestorBits( IN_RPC ); BOOL fInPresented = MyContext.AnyAncestorBits( IN_PRESENTED_TYPE ); SEM_ANALYSIS_CTXT * pIntfCtxt = (SEM_ANALYSIS_CTXT *) MyContext.GetInterfaceContext(); node_represent_as * pRepresent = (node_represent_as *) MyContext.ExtractAttribute( ATTR_REPRESENT_AS ); node_transmit * pTransmit = (node_transmit *) MyContext.ExtractAttribute( ATTR_TRANSMIT ); node_user_marshal * pUserMarshal = (node_user_marshal *) MyContext.ExtractAttribute( ATTR_USER_MARSHAL ); node_wire_marshal * pWireMarshal = (node_wire_marshal *) MyContext.ExtractAttribute( ATTR_WIRE_MARSHAL ); BOOL fRepMarshal = pRepresent || pUserMarshal; BOOL fXmitMarshal = pTransmit || pWireMarshal; BOOL fEncodeDecode = (NULL != MyContext.ExtractAttribute( ATTR_ENCODE )); MyContext.ExtractAttribute(ATTR_HELPSTRING); MyContext.ExtractAttribute( ATTR_HELPCONTEXT ); MyContext.ExtractAttribute( ATTR_HELPSTRINGCONTEXT ); // Partial ignore may not be used directly on an xmit or rep as. if (MyContext.AnyAncestorBits( UNDER_PARTIAL_IGNORE_PARAM ) && ( fRepMarshal || fXmitMarshal ) ) { SemError( this, MyContext, PARTIAL_IGNORE_UNIQUE, 0 ); } if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } if ( HasCorrelation( this ) ) { MyContext.IncCorrelationCount(); } CheckDeclspecAlign( MyContext ); node_range_attr* pRange = ( node_range_attr* ) MyContext.GetAttribute(ATTR_RANGE); if ( pRange ) { if ( pRange->GetMinExpr()->GetValue() > pRange->GetMaxExpr()->GetValue() ) { SemError(this, MyContext, INCORRECT_RANGE_DEFN, 0); } } BOOL fPropogateChild = TRUE; // propogate direct child info unsigned long ulHandleKind; // check for illegal type attributes node_type_attr * pTA; while ( ( pTA = (node_type_attr *)MyContext.ExtractAttribute(ATTR_TYPE) ) != 0 ) { switch (pTA->GetAttr()) { // acceptable attributes case TATTR_PUBLIC: { break; } // unacceptable attributes case TATTR_LICENSED: case TATTR_OLEAUTOMATION: case TATTR_APPOBJECT: case TATTR_CONTROL: case TATTR_PROXY: case TATTR_DUAL: case TATTR_NONEXTENSIBLE: case TATTR_NONCREATABLE: case TATTR_AGGREGATABLE: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } // check for illegal member attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { case MATTR_RESTRICTED: break; case MATTR_OPTIONAL: case MATTR_RETVAL: case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: case MATTR_VARARG: case MATTR_SOURCE: case MATTR_DEFAULTVTABLE: case MATTR_PREDECLID: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_USESGETLASTERROR: case MATTR_IMMEDIATEBIND: case MATTR_REPLACEABLE: default: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } #if defined(TARGET_RKK) // Checking the release compatibility if ( pCommand->GetTargetSystem() < NT40 ) { if ( pWireMarshal ) SemError( this, MyContext, REQUIRES_NT40, "[wire_marshal]" ); if ( pUserMarshal ) SemError( this, MyContext, REQUIRES_NT40, "[user_marshal]" ); } if ( pCommand->GetTargetSystem() < NT351 ) { if ( fEncodeDecode ) SemError( this, MyContext, REQUIRES_NT351, "[encode,decode]" ); } #endif MyContext.ExtractAttribute(ATTR_TYPEDESCATTR); while(MyContext.ExtractAttribute(ATTR_CUSTOM)); // clear the GUID, VERSION and HIDDEN attributes if set MyContext.ExtractAttribute( ATTR_HIDDEN ); MyContext.ExtractAttribute( ATTR_VERSION ); MyContext.ExtractAttribute( ATTR_HELPCONTEXT); MyContext.ExtractAttribute( ATTR_HELPSTRINGCONTEXT); node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); // make sure the UUID is unique if ( pGuid ) { node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } // get the encode and decode attributes fEncodeDecode |= (NULL != MyContext.ExtractAttribute( ATTR_DECODE )); fEncodeDecode |= pIntfCtxt->FInSummary( ATTR_ENCODE ); fEncodeDecode |= pIntfCtxt->FInSummary( ATTR_DECODE ); if ( fEncodeDecode ) { // only direct children of the interface get these bits if ( !pParentCtxt->GetParent()->IsInterfaceOrObject() ) { fEncodeDecode = FALSE; } else if (MyContext.AnyAncestorBits( IN_OBJECT_INTF ) ) { fEncodeDecode = FALSE; TypeSemError( this, MyContext, PICKLING_INVALID_IN_OBJECT, NULL ); } else { // note that this is an rpc-able interface GetMyInterfaceNode()->SetPickleInterface(); MyContext.SetAncestorBits( IN_RPC ); } SemError( this, MyContext, TYPE_PICKLING_INVALID_IN_OSF, NULL ); BOOL HasV2Optimize = pCommand->GetOptimizationFlags() & OPTIMIZE_INTERPRETER_V2; if ( pCommand->IsSwitchDefined( SWITCH_ROBUST ) ) { if ( HasV2Optimize ) { pCommand->GetNdrVersionControl().SetHasOicfPickling(); } else { SemError( this, MyContext, ROBUST_PICKLING_NO_OICF, 0 ); } } BOOL HasCommFault = MyContext.FInSummary( ATTR_COMMSTAT ) || MyContext.FInSummary( ATTR_FAULTSTAT ); if ( HasCommFault && !HasV2Optimize) { SemError( this, MyContext, COMMFAULT_PICKLING_NO_OICF, 0 ); } } // kind of handle applied right now (HandleKind only set for ones on this // typedef node) if ( FInSummary(ATTR_HANDLE) ) { MyContext.ExtractAttribute( ATTR_HANDLE ); SetHandleKind( HDL_GEN ); } bool fSerialize = MyContext.ExtractAttribute( ATTR_SERIALIZE ) != 0; bool fNoSerialize = MyContext.ExtractAttribute( ATTR_NOSERIALIZE ) != 0; // See if context_handle applied to param reached us if ( FInSummary(ATTR_CONTEXT) ) { if ( ( GetHandleKind() != HDL_NONE ) && ( GetHandleKind() != HDL_CTXT ) ) TypeSemError( this, MyContext, CTXT_HDL_GENERIC_HDL, NULL ); MyContext.ExtractAttribute( ATTR_CONTEXT ); if ( fSerialize && fNoSerialize ) { SemError( this, MyContext, CONFLICTING_ATTRIBUTES, GetSymName() ); } SetHandleKind( HDL_CTXT ); // since the base type is not transmitted, we aren't really // in an rpc after here MyContext.ClearAncestorBits( IN_RPC ); } else { if ( fSerialize || fNoSerialize ) { SemError( this, MyContext, NO_CONTEXT_HANDLE, GetSymName() ); } } ulHandleKind = GetHandleKind(); if ( ulHandleKind != HDL_NONE ) { MyContext.SetAncestorBits( IN_HANDLE ); } // effectively, the presented type is NOT involved in an RPC if ( fXmitMarshal ) { MyContext.ClearAncestorBits( IN_RPC ); MyContext.SetAncestorBits( IN_PRESENTED_TYPE ); if ( MyContext.FInSummary( ATTR_ALLOCATE ) ) AcfError( (acf_attr *) MyContext.ExtractAttribute( ATTR_ALLOCATE ), this, MyContext, ALLOCATE_ON_TRANSMIT_AS, NULL ); if ( GetHandleKind() == HDL_CTXT ) TypeSemError( this, MyContext, TRANSMIT_AS_CTXT_HANDLE, NULL ); } if ( MyContext.ExtractAttribute( ATTR_CSCHAR ) ) { if ( MyContext.AnyAncestorBits( UNDER_IN_PARAM ) ) MyContext.SetDescendantBits( HAS_IN_CSTYPE ); if ( MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) ) MyContext.SetDescendantBits( HAS_OUT_CSTYPE ); } // process the child GetChild()->SemanticAnalysis( &MyContext ); if (pCommand->IsSwitchDefined(SWITCH_MKTYPLIB)) { switch (GetChild()->NodeKind()) { case NODE_STRUCT: case NODE_UNION: case NODE_ENUM: { // This is the 'typedef' part of a 'typedef struct', // 'typedef union', or 'typedef enum' declaration. // Make sure that the type info name is set to the name of the // typedef and not the child. ((node_su_base *)GetChild())->SetTypeInfoName(GetSymName()); } break; } } else { if (GetChild()->GetSymName() && IsTempName(GetChild()->GetSymName())) { // Make sure that at least the [public] attribute is // set on this typedef, forcing this typedef to be put // in a type library if it is referenced from within one. SetAttribute(new node_type_attr(TATTR_PUBLIC)); } } /* yongqu: don't enable this before we read custom data. if ( GetChild()->NodeKind() == NODE_INT3264 ) { SetAttribute( GetCustomAttrINT3264() ); } */ // process all the nasties of transmit_as and wire_marshal if ( fXmitMarshal && !fInPresented && fInRpc ) { SEM_ANALYSIS_CTXT TransmitContext( &MyContext ); // eat the attributes added by the above constructor TransmitContext.ClearAttributes(); // process the transmitted type TransmitContext.SetAncestorBits( IN_TRANSMIT_AS ); if ( pWireMarshal ) TransmitContext.SetAncestorBits( IN_USER_MARSHAL ); TransmitContext.ClearAncestorBits( IN_PRESENTED_TYPE ); if ( fInRpc) TransmitContext.SetAncestorBits( IN_RPC ); if ( pTransmit ) pTransmit->GetType()->SemanticAnalysis( &TransmitContext ); else if ( pWireMarshal ) pWireMarshal->GetType()->SemanticAnalysis( &TransmitContext ); else MIDL_ASSERT(0); if ( pTransmit ) { // check the transmitted type. SemanticAnalysisForTransmit( &TransmitContext, FALSE ); // Check the presented type. SemanticAnalysisForTransmit( &MyContext, TRUE ); } else if ( pWireMarshal ) { // check the transmitted type SemanticAnalysisForWireMarshal( &TransmitContext, FALSE ); // check the presented type SemanticAnalysisForWireMarshal( &MyContext, TRUE ); } else { MIDL_ASSERT(0); } if ( TransmitContext.AnyDescendantBits( HAS_HANDLE ) ) { //gaj TypeSemError( this, MyContext, HANDLE_T_XMIT, NULL ); } if ( TransmitContext.AnyDescendantBits( HAS_TRANSMIT_AS ) ) { TypeSemError( this, MyContext, TRANSMIT_AS_NON_RPCABLE, NULL ); } TransmitContext.SetDescendantBits( HAS_TRANSMIT_AS ); // since the base type is not transmitted, we aren't really // in an rpc after here pParentCtxt->ReturnValues( TransmitContext ); fPropogateChild = FALSE; } // process all the nasties of represent_as and user_marshal if ( fRepMarshal ) { node_represent_as * pRepUser = (pRepresent) ? pRepresent : pUserMarshal ; if ( ulHandleKind == HDL_CTXT ) AcfError( pRepUser, this, MyContext, TRANSMIT_AS_CTXT_HANDLE, NULL ); // process the transmitted type MyContext.SetAncestorBits( IN_REPRESENT_AS ); if ( pUserMarshal ) MyContext.SetAncestorBits( IN_USER_MARSHAL ); pParentCtxt->SetDescendantBits( HAS_REPRESENT_AS ); if ( !pRepUser->GetRepresentationType() ) { pParentCtxt->SetDescendantBits( HAS_UNSAT_REP_AS ); if ( pCommand->NeedsNDR64Run() ) { AcfError( pRepUser, this, MyContext, UNSPECIFIED_REP_OR_UMRSHL_IN_NDR64, NULL ); } } if ( pUserMarshal ) { // Check the transmitted type. SemanticAnalysisForWireMarshal( &MyContext, FALSE ); } else if ( pRepresent ) { // Check the transmitted type. SemanticAnalysisForTransmit( &MyContext, FALSE ); } // since the base type is not transmitted, we aren't really // in an rpc after here } // make checks for encode/decode if ( fEncodeDecode ) { if ( MyContext.AnyDescendantBits( HAS_DIRECT_CONF_OR_VAR ) ) TypeSemError( this, MyContext, ENCODE_CONF_OR_VAR, NULL ); } // process handles if ( ulHandleKind != HDL_NONE) { if ( ulHandleKind == HDL_GEN ) { if ( MyContext.AnyDescendantBits( DERIVES_FROM_VOID ) ) TypeSemError( this, MyContext, GENERIC_HDL_VOID, NULL ); if ( MyContext.AnyDescendantBits( HAS_TRANSMIT_AS ) ) TypeSemError( this, MyContext, GENERIC_HANDLE_XMIT_AS, NULL ); if ( MyContext.AnyAncestorBits( IN_INTERPRET ) && ( GetChild()->GetSize() > (unsigned long)(SIZEOF_MEM_PTR()) ) ) { if ( pCommand->NeedsNDR64Run() ) TypeSemError( this, MyContext, UNSUPPORTED_LARGE_GENERIC_HANDLE, NULL ); else MyContext.SetDescendantBits( HAS_TOO_BIG_HDL ); } } if ( ulHandleKind == HDL_CTXT ) { MyContext.SetDescendantBits( HAS_CONTEXT_HANDLE ); if ( GetBasicType()->NodeKind() != NODE_POINTER ) TypeSemError( this, MyContext, CTXT_HDL_NON_PTR, NULL ); } MyContext.SetDescendantBits( HAS_HANDLE ); WALK_CTXT * pParamCtxt = (SEM_ANALYSIS_CTXT *) MyContext.GetParentContext(); node_param * pParamNode; node_skl * pCurNode; short PtrDepth = 0; // this returns NULL if no appropriate ancestor found while ( pParamCtxt ) { pCurNode = pParamCtxt->GetParent(); if ( pCurNode->NodeKind() == NODE_PARAM ) break; if ( ( pCurNode->NodeKind() == NODE_DEF ) && pCurNode->FInSummary( ATTR_TRANSMIT ) ) { pParamCtxt = NULL; break; } if ( pCurNode->NodeKind() == NODE_POINTER ) { PtrDepth ++; if ( MyContext.AllAncestorBits( IN_RPC | IN_FUNCTION_RESULT ) ) { SemError( this, MyContext, CTXT_HDL_MUST_BE_DIRECT_RETURN, NULL ); pParamCtxt = NULL; break; } } pParamCtxt = (SEM_ANALYSIS_CTXT *)pParamCtxt->GetParentContext(); } pParamNode = (pParamCtxt) ? (node_param *) pParamCtxt->GetParent() : NULL; // stuff handle info into our param node if ( pParamNode ) pParamNode->HandleKind = ulHandleKind; // out context/generic handles must be two levels deep if ( pParamCtxt && MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) && ( PtrDepth < 1 ) ) TypeSemError( this, MyContext, OUT_CONTEXT_GENERIC_HANDLE, NULL ); } if ( IsHResultOrSCode() ) { MyContext.SetDescendantBits( HAS_HRESULT ); } // don't propogate info here from below if we had transmit_as, // it is propogated above... if ( fPropogateChild ) { pParentCtxt->ReturnValues( MyContext ); } // set the DontCallFreeInst flag on the param if ( ( pTransmit || pRepresent ) && fInRpc && MyContext.AllAncestorBits( IN_PARAM_LIST ) && !MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) ) { // look up the context stack. If any non-pointer, non-def found, // set the fDontCallFreeInst flag on the param MarkDontCallFreeInst( &MyContext ); } } // look up the context stack. If any non-pointer, non-def found, // set the fDontCallFreeInst flag on the param void node_def::MarkDontCallFreeInst( SEM_ANALYSIS_CTXT * pCtxt ) { SEM_ANALYSIS_CTXT * pCurCtxt = pCtxt; node_skl * pCurNode; NODE_T Kind; unsigned long MarkIt = 2; for(;;) { pCurCtxt = (SEM_ANALYSIS_CTXT *) pCurCtxt->GetParentContext(); pCurNode = pCurCtxt->GetParent(); Kind = pCurNode->NodeKind(); switch ( Kind ) { case NODE_DEF: case NODE_POINTER: break; case NODE_PARAM: // if we only found defs and pointers, this will // leave it unchanged ((node_param *)pCurNode)->fDontCallFreeInst |= MarkIt; return; default: MarkIt = 1; break; } } } // interface nodes have two entries on the context stack; // one for the interface node, and one for info to pass to // the children void node_interface::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); MEM_ITER MemList( this ); named_node* pN; SEM_ANALYSIS_CTXT ChildCtxt( &MyContext ); BOOL IsLocal = MyContext.FInSummary( ATTR_LOCAL ); BOOL HasGuid = MyContext.FInSummary( ATTR_GUID ); BOOL IsObject = MyContext.FInSummary( ATTR_OBJECT ); BOOL fEncode = MyContext.FInSummary( ATTR_ENCODE ); BOOL fDecode = MyContext.FInSummary( ATTR_DECODE ); BOOL IsPickle = fEncode || fDecode; BOOL HasVersion = MyContext.FInSummary( ATTR_VERSION ); BOOL IsIUnknown = FALSE; BOOL fAuto = MyContext.FInSummary( ATTR_AUTO ); BOOL fCode = MyContext.FInSummary( ATTR_CODE ); BOOL fNoCode = MyContext.FInSummary( ATTR_NOCODE ); fHasMSConfStructAttr = fHasMSConfStructAttr || MyContext.ExtractAttribute( ATTR_MS_CONF_STRUCT ) != 0; node_implicit* pImplicit = ( node_implicit* ) MyContext.GetAttribute( ATTR_IMPLICIT ); acf_attr* pExplicit = ( acf_attr* ) MyContext.GetAttribute( ATTR_EXPLICIT ); node_optimize* pOptAttr = 0; bool fAnalizeAsyncIf = false; node_cs_tag_rtn* pCSTagAttr = 0; // [message] only allowed in ORPC interfaces and RPC procs. node_base_attr* pTemp = MyContext.GetAttribute( ATTR_MESSAGE ); if ( pTemp ) { if ( !IsObject ) { SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pTemp->GetNodeNameString() ); } ChildCtxt.SetAncestorBits( HAS_MESSAGE ); } // process async_uuid before doing anything if ( !IsAsyncClone() ) { node_guid* pAsyncGuid = (node_guid*) MyContext.GetAttribute( ATTR_ASYNCUUID ); if ( pAsyncGuid ) { if ( GetDefiningFile()->GetImportLevel() == 0 ) { pCommand->GetNdrVersionControl().SetHasAsyncUUID(); } ChildCtxt.SetAncestorBits( HAS_ASYNC_UUID ); // async_uuid can only be applied to an object interface. if ( !IsObject || !pBaseIntf ) { SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAsyncGuid->GetNodeNameString() ); } if ( !GetAsyncInterface() ) { // duplicate this interface and split its methods SetAsyncInterface( CloneIFAndSplitMethods( this ) ); if ( GetAsyncInterface() ) { fAnalizeAsyncIf = true; GetAsyncInterface()->SetIsAsyncClone(); } } } } else { // This is the cloned interface, don't clone it again. ChildCtxt.SetAncestorBits( HAS_ASYNC_UUID ); } while( MyContext.ExtractAttribute(ATTR_CUSTOM) ) ; MyContext.ExtractAttribute( ATTR_TYPEDESCATTR ); MyContext.ExtractAttribute( ATTR_HIDDEN ); MyContext.ExtractAttribute( ATTR_VERSION ); MyContext.ExtractAttribute( ATTR_HELPSTRING ); MyContext.ExtractAttribute( ATTR_HELPSTRINGCONTEXT ); MyContext.ExtractAttribute( ATTR_HELPCONTEXT ); MyContext.ExtractAttribute( ATTR_LCID ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } // don't pass the interface attributes down directly... // pass them down elsewhere ChildCtxt.SetInterfaceContext( &MyContext ); // // check the interface attributes // // make sure we only get analyzed once when object interfaces // check their inherited info if ( fSemAnalyzed ) return; fSemAnalyzed = TRUE; #ifdef gajgaj // look for pointer default if ( !FInSummary( ATTR_PTR_KIND ) && MyContext.AnyAncestorBits( IN_INTERFACE ) ) { RpcSemError(this, MyContext, NO_PTR_DEFAULT_ON_INTERFACE, NULL ); } #endif // gajgaj // must have exactly one of [local] or [UUID] if (IsLocal && HasGuid && !IsObject ) { SemError( this, MyContext, UUID_LOCAL_BOTH_SPECIFIED, NULL ); } // object interface error checking if ( IsObject ) { MyContext.SetAncestorBits( IN_OBJECT_INTF ); ChildCtxt.SetAncestorBits( IN_OBJECT_INTF ); if ( HasVersion ) { SemError( this, MyContext, OBJECT_WITH_VERSION, NULL ); } } // make sure the uuid is unique node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); // make sure the UUID is unique if ( pGuid ) { node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } ///////////////////////////////////////////////////////////////////// //Check the base interface if (pBaseIntf) { if ( !IsObject && !MyContext.AnyAncestorBits(IN_LIBRARY)) { SemError( this, MyContext, ILLEGAL_INTERFACE_DERIVATION, NULL ); } ChildCtxt.SetAncestorBits( IN_BASE_CLASS ); pBaseIntf->SemanticAnalysis( &ChildCtxt ); if ( ChildCtxt.AnyDescendantBits( HAS_INCOMPLETE_TYPE ) ) { SemError( pBaseIntf, ChildCtxt, UNRESOLVED_TYPE, pBaseIntf->GetSymName() ); } else { if ( pBaseIntf->NodeKind() != NODE_INTERFACE_REFERENCE && pBaseIntf->NodeKind() != NODE_HREF ) { SemError( this, MyContext, ILLEGAL_BASE_INTERFACE, NULL ); } node_interface* pRealBaseIf = ( ( node_interface_reference* ) pBaseIntf )->GetRealInterface(); // verify the base interface is really an interface. if ( pRealBaseIf == NULL || ( pRealBaseIf->NodeKind() != NODE_INTERFACE && pRealBaseIf->NodeKind() != NODE_DISPINTERFACE ) ) { SemError( this, MyContext, ILLEGAL_BASE_INTERFACE, NULL ); } if ( fAnalizeAsyncIf ) { if ( pBaseIntf->NodeKind() != NODE_INTERFACE_REFERENCE ) { SemError( this, MyContext, ILLEGAL_BASE_INTERFACE, NULL ); } else { node_interface* pRealBaseIf = ( ( node_interface_reference* ) pBaseIntf )->GetRealInterface(); if ( !pRealBaseIf->GetAsyncInterface() && strcmp( pRealBaseIf->GetSymName(), "IUnknown" ) ) { SemError( this, MyContext, ILLEGAL_BASE_INTERFACE, NULL ); } } } if ( pBaseIntf->NodeKind() == NODE_INTERFACE_REFERENCE && HasGuid ) { node_interface* pRealBaseIf = ( ( node_interface_reference* ) pBaseIntf )->GetRealInterface(); if ( pRealBaseIf ) { node_guid * pNodeGuid = (node_guid *) pRealBaseIf->GetAttribute( ATTR_GUID ); if ( pNodeGuid ) { GUID thisGuid; pGuid->GetGuid( thisGuid ); GUID baseIFGuid; pNodeGuid->GetGuid( baseIFGuid ); if ( !IsAnyIAdviseSinkIID( thisGuid ) ) { if ( IsAnyIAdviseSinkIID( baseIFGuid ) ) { SemError( this, MyContext, CANNOT_INHERIT_IADVISESINK, pBaseIntf->GetSymName() ); } } else { ChildCtxt.SetAncestorBits( IN_IADVISESINK ); } } } } } // note that the above deletes intervening forwards ChildCtxt.ClearAncestorBits( IN_BASE_CLASS ); } if ( IsValidRootInterface() ) { ChildCtxt.SetAncestorBits( IN_ROOT_CLASS ); IsIUnknown = TRUE; } if ( IsObject && !pBaseIntf && !IsIUnknown && !MyContext.AnyAncestorBits(IN_LIBRARY)) { SemError( pBaseIntf, MyContext, ILLEGAL_INTERFACE_DERIVATION, NULL ); } // our optimization is controlled either here or for the whole compile if ( IsAsyncClone() ) { SetOptimizationFlags( OPTIMIZE_ALL_I2_FLAGS ); } else { if ( ( pOptAttr = (node_optimize *) GetAttribute( ATTR_OPTIMIZE ) ) != 0 ) { SetOptimizationFlags( pOptAttr->GetOptimizationFlags() ); SetOptimizationLevel( pOptAttr->GetOptimizationLevel() ); } else { SetOptimizationFlags( pCommand->GetOptimizationFlags() ); SetOptimizationLevel( pCommand->GetOptimizationLevel() ); } } if ( MyContext.FInSummary( ATTR_NOCODE ) && pCommand->GenerateSStub() && !pCommand->IsSwitchDefined( SWITCH_MS_EXT ) ) { SemError( this, MyContext, NOCODE_WITH_SERVER_STUBS, NULL ); } if ( IsPickle && pCommand->IsSwitchDefined( SWITCH_ROBUST ) ) { if ( GetOptimizationFlags() & OPTIMIZE_INTERPRETER_V2 ) { pCommand->GetNdrVersionControl().SetHasOicfPickling(); } else { SemError(this, MyContext, ROBUST_PICKLING_NO_OICF, 0); } } BOOL HasCommFault = MyContext.FInSummary( ATTR_COMMSTAT ) || MyContext.FInSummary( ATTR_FAULTSTAT ); if ( HasCommFault ) { if ( ! ( GetOptimizationFlags() & OPTIMIZE_INTERPRETER_V2 ) ) { SemError( this, MyContext, COMMFAULT_PICKLING_NO_OICF, 0 ); } } // mark the interface as a pickle interface if ( IsPickle ) SetPickleInterface(); // default the handle type, if needed if ( !IsObject && !pImplicit && !pExplicit && !fAuto && !IsLocal ) { if ( IsPickleInterface() ) { pExplicit = new acf_attr( ATTR_EXPLICIT ); SetAttribute( pExplicit ); } else { fAuto = TRUE; SetAttribute( new acf_attr( ATTR_AUTO ) ); } } // make sure no pickle w/ auto handle if ( IsPickleInterface() ) { ChildCtxt.SetAncestorBits( IN_ENCODE_INTF ); if ( fAuto ) SemError( this, MyContext, ENCODE_AUTO_HANDLE, NULL ); } // check for handle conflicts if ( ( fAuto && pImplicit ) || ( fAuto && pExplicit ) || ( pImplicit && pExplicit ) ) SemError( this, MyContext, CONFLICTING_INTF_HANDLES, NULL ); if ( pImplicit ) { node_id * pID; node_skl * pType; pImplicit->ImplicitHandleDetails( &pType, &pID ); char* szName = pType->GetNonDefSelf()->GetSymName(); if ( pImplicit->IsHandleTypeDefined() ) { if ( !pType->FInSummary( ATTR_HANDLE ) && strcmp( szName, "handle_t" ) && !pID->FInSummary( ATTR_HANDLE ) ) { SemError( this, MyContext, IMPLICIT_HANDLE_NON_HANDLE, NULL ); } } else { if ( !pID->FInSummary( ATTR_HANDLE ) ) SemError( this, MyContext, IMPLICIT_HDL_ASSUMED_GENERIC, NULL ); } } if ( fAuto ) { ChildCtxt.SetAncestorBits( HAS_AUTO_HANDLE ); } else if ( pExplicit ) { ChildCtxt.SetAncestorBits( HAS_EXPLICIT_HANDLE ); } else if ( pImplicit ) { ChildCtxt.SetAncestorBits( HAS_IMPLICIT_HANDLE ); } // check for illegal type attributes node_type_attr * pTA; BOOL fIsDual = FALSE; while ( ( pTA = (node_type_attr *)MyContext.ExtractAttribute(ATTR_TYPE) ) != 0 ) { switch (pTA->GetAttr()) { // acceptable attributes case TATTR_DUAL: fIsDual = TRUE; // fall through case TATTR_OLEAUTOMATION: HasOLEAutomation(TRUE); break; case TATTR_PROXY: case TATTR_PUBLIC: case TATTR_NONEXTENSIBLE: break; // unacceptable attributes case TATTR_CONTROL: case TATTR_LICENSED: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } case TATTR_APPOBJECT: case TATTR_NONCREATABLE: case TATTR_AGGREGATABLE: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } if (HasOLEAutomation()) { node_interface* pUltimate = 0; node_interface* pIntf = this; STATUS_T ErrorCode = NOT_OLEAUTOMATION_INTERFACE; while ( pIntf ) { pUltimate = pIntf; pIntf = pIntf->GetMyBaseInterface(); if ( !pUltimate->IsValidRootInterface() ) { // pUltimate is not IUnknown. If it is not a IDispatch either, it is not // an oleautomation compliant interface. char* szName = pUltimate->GetSymName(); if ( _stricmp(szName, "IDispatch") == 0 ) { ErrorCode = STATUS_OK; break; } } else { // IUnknown could be OLEAUTOMATION compatible, but not DUAL if ( fIsDual ) ErrorCode = NOT_DUAL_INTERFACE; else ErrorCode = STATUS_OK; break; } } if ( ErrorCode != STATUS_OK ) SemError( this, MyContext, ErrorCode, GetSymName() ); ChildCtxt.SetAncestorBits( HAS_OLEAUTOMATION ); } // check for illegal member attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { case MATTR_RESTRICTED: break; case MATTR_DEFAULTVTABLE: case MATTR_SOURCE: { if ( MyContext.AnyAncestorBits( IN_COCLASS ) ) // [source] and [defaultvtable] are only allowed on // interface's defined as members of coclasses. break; // illegal attribute, so fall through } case MATTR_READONLY: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: case MATTR_OPTIONAL: case MATTR_RETVAL: case MATTR_VARARG: case MATTR_PREDECLID: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_IMMEDIATEBIND: case MATTR_USESGETLASTERROR: case MATTR_REPLACEABLE: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } node_base_attr* pAttrAsync = MyContext.ExtractAttribute( ATTR_ASYNC ); if ( pAttrAsync ) { if ( !pAttrAsync->IsAcfAttr() ) { SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } if ( fCode || fNoCode || IsLocal || pOptAttr || IsObject || HasOLEAutomation() ) { SemError( this, MyContext, ILLEGAL_COMBINATION_OF_ATTRIBUTES, 0 ); } ChildCtxt.SetAncestorBits( HAS_ASYNCHANDLE ); } pCSTagAttr = ( node_cs_tag_rtn *) MyContext.ExtractAttribute( ATTR_CSTAGRTN ); //////////////////////////////////////////////////////////////////////// // process all the children of the interface // while ( ( pN = MemList.GetNext() ) != 0 ) { pN->SemanticAnalysis( &ChildCtxt ); // Set the cs tag routine for the proc if it needs one and doesn't // have one yet if ( NODE_PROC == pN->NodeKind() ) { node_proc *pProc = ( node_proc * ) pN; if ( ChildCtxt.AnyDescendantBits( HAS_IN_CSTYPE | HAS_OUT_CSTYPE ) && ( NULL == pProc->GetCSTagRoutine() ) && ( NULL != pCSTagAttr ) ) { pProc->SetCSTagRoutine( pCSTagAttr->GetCSTagRoutine() ); } } } // make sure we had some rpc-able routines if ( IsObject ) { //UUID must be specified on object procs. if( !HasGuid ) { SemError( this, MyContext, NO_UUID_SPECIFIED, NULL ); } } else if( MyContext.AnyAncestorBits( IN_INTERFACE ) && pCommand->GenerateStubs() && !IsLocal ) { if ( ProcCount == 0 ) { if ( !IsPickleInterface() && !IsObject ) { if (CallBackProcCount == 0 ) { SemError( this, MyContext, NO_REMOTE_PROCS_NO_STUBS, NULL ); } else { SemError( this, MyContext, INTERFACE_ONLY_CALLBACKS, NULL ); } } } else { //UUID must be specified when interface has remote procs. if( !HasGuid ) { SemError( this, MyContext, NO_UUID_SPECIFIED, NULL ); } } } if (pExplicit && MyContext.AnyAncestorBits( IN_LIBRARY )) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, NULL); } if (fCode && fNoCode) { SemError(this, MyContext, CODE_NOCODE_CONFLICT, NULL); } if ( IsObject ) { unsigned short uProcCount = GetProcCount(); if ( GetFileNode() && GetFileNode()->GetImportLevel() > 0 ) { if ( uProcCount > 64 && uProcCount <= 256 ) { pCommand->GetNdrVersionControl().SetHasMoreThan64DelegatedProcs(); } else if ( uProcCount > 256 ) { SemError(this, MyContext, TOO_MANY_DELEGATED_PROCS, NULL); } } // method limits apply only to stubless proxies. /Oicf not /Oi or /Os /* < 32 Windows NT 3.51- 32 - 110 Windows NT 4.0 110 - 512 Windows NT 4.0 SP3 > 512 Windows 2000 */ unsigned short uOpt = GetOptimizationFlags(); if ( GetFileNode() && GetFileNode()->GetImportLevel() == 0 && ( uOpt & OPTIMIZE_STUBLESS_CLIENT ) ) { if ( (uProcCount > 512) && MyContext.AnyAncestorBits(IN_LIBRARY)) { SemError(this, MyContext, TOO_MANY_PROCS, 0); pCommand->GetNdrVersionControl().SetHasNT5VTableSize(); } else if ( (uProcCount > 110) && (uProcCount <= 512) && MyContext.AnyAncestorBits(IN_LIBRARY)) { SemError(this, MyContext, TOO_MANY_PROCS_FOR_NT4, 0); pCommand->GetNdrVersionControl().SetHasNT43VTableSize(); } else if ( uProcCount > 32 && uProcCount <= 110 ) { pCommand->GetNdrVersionControl().SetHasNT4VTableSize(); } } } if ( GetAsyncInterface() && fAnalizeAsyncIf ) { GetAsyncInterface()->SemanticAnalysis( pParentCtxt ); } MyContext.ReturnValues(ChildCtxt); // consume all the interface attributes MyContext.ClearAttributes(); pParentCtxt->ReturnValues( MyContext ); } // a reference to an interface... //Check for ms_ext mode. //Check if the interface has the [object] attribute //if used in an RPC, the parent must be a pointer. void node_interface_reference::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); CheckDeclspecAlign( MyContext ); // see if we are detecting class dependencies if ( MyContext.AnyAncestorBits( IN_BASE_CLASS ) ) { if ( !GetRealInterface()->FInSummary( ATTR_OBJECT ) && !MyContext.AnyAncestorBits(IN_LIBRARY)) { SemError( this, MyContext, ILLEGAL_INTERFACE_DERIVATION, NULL ); } // fetch my interface's BaseInteraceReference named_node * pBaseClass = GetMyBaseInterfaceReference(); if ( pBaseClass ) { if ( MyContext.FindRecursiveContext( pBaseClass ) ) SemError( this, MyContext, CIRCULAR_INTERFACE_DEPENDENCY, NULL); else { // make sure our base class got analyzed SEM_ANALYSIS_CTXT BaseContext( this, &MyContext ); BaseContext.ClearAncestorBits( IN_BASE_CLASS | IN_INTERFACE ); BaseContext.SetInterfaceContext( &BaseContext ); GetRealInterface()->SemanticAnalysis( &BaseContext ); pBaseClass->SemanticAnalysis( &MyContext ); } } else // root base class { if ( !GetRealInterface()->IsValidRootInterface() && !MyContext.AnyAncestorBits(IN_LIBRARY)) SemError( this, MyContext, NOT_VALID_AS_BASE_INTF, NULL ); } } else if ( ( pParentCtxt->GetParent()->NodeKind() == NODE_FORWARD ) && ( pParentCtxt->GetParentContext()->GetParent()->IsInterfaceOrObject() ) ) { // we are an interface forward decl } else // we are at an interface pointer { node_interface * pIntf = GetRealInterface(); if ( !MyContext.AnyAncestorBits( IN_POINTER ) && !MyContext.AnyAncestorBits( IN_LIBRARY )) { SemError( this, MyContext, INTF_NON_POINTER, NULL ); } if ( !pIntf->FInSummary( ATTR_GUID ) ) { SemError( this, MyContext, PTR_INTF_NO_GUID, NULL ); } MyContext.SetDescendantBits( HAS_INTERFACE_PTR ); } pParentCtxt->ReturnValues( MyContext ); return; }; void node_source::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { MEM_ITER MemIter( this ); node_skl * pN; SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); while ( ( pN = MemIter.GetNext() ) != 0 ) { pN->SemanticAnalysis( &MyContext ); } pParentCtxt->ReturnValues( MyContext ); }; void node_pointer::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); PTRTYPE PtrKind = PTR_UNKNOWN; FIELD_ATTR_INFO FAInfo; node_ptr_attr * pPAttr; // pointer attribute node_byte_count * pCountAttr; node_allocate * pAlloc; BOOL fInterfacePtr = (GetChild()->NodeKind() == NODE_INTERFACE_REFERENCE ); BOOL fUnderAPtr = MyContext.AnyAncestorBits( IN_POINTER | IN_ARRAY ); BOOL fIgnore; BOOL fIsSizedPtr = FALSE; // see if we have allocate pAlloc = (node_allocate *) MyContext.ExtractAttribute( ATTR_ALLOCATE ); if ( HasCorrelation( this ) ) { MyContext.IncCorrelationCount(); } CheckDeclspecAlign( MyContext ); //////////////////////////////////////////////////////////////////////// // process pointer attributes BOOL fExplicitPtrAttr = FALSE; PtrKind = MyContext.GetPtrKind( &fExplicitPtrAttr ); if ( PtrKind == PTR_FULL ) { MyContext.SetDescendantBits( HAS_FULL_PTR ); } if ( ( pPAttr = (node_ptr_attr *)MyContext.ExtractAttribute( ATTR_PTR_KIND) ) != 0 ) { TypeSemError( this, MyContext, MORE_THAN_ONE_PTR_ATTR, NULL ); } if ( MyContext.AnyAncestorBits( UNDER_PARTIAL_IGNORE_PARAM ) && ( PtrKind != PTR_UNIQUE ) ) { TypeSemError( this, MyContext, PARTIAL_IGNORE_UNIQUE, NULL ); } MyContext.ClearAncestorBits( UNDER_PARTIAL_IGNORE_PARAM ); // mark this pointer as ref or non-ref. This flag is only valid for the // pointer nodes themselves. if ( PtrKind == PTR_REF ) MyContext.ClearAncestorBits( IN_NON_REF_PTR ); else MyContext.SetAncestorBits( IN_NON_REF_PTR ); // detect top level ref pointer on return type if ( ( PtrKind == PTR_REF ) && MyContext.AllAncestorBits( IN_RPC | IN_FUNCTION_RESULT ) ) { if (MyContext.FindNonDefAncestorContext()->GetParent()->NodeKind() == NODE_PROC ) TypeSemError( this, MyContext, BAD_CON_REF_RT, NULL ); } // unique or full pointer may not be out only if ( ( PtrKind != PTR_REF ) && MyContext.AllAncestorBits( IN_RPC | IN_PARAM_LIST ) && !fUnderAPtr && !MyContext.AnyAncestorBits( UNDER_IN_PARAM | IN_STRUCT | IN_UNION )) TypeSemError( this, MyContext, UNIQUE_FULL_PTR_OUT_ONLY, NULL ); MyContext.SetAncestorBits( IN_POINTER ); // warn about OUT const things if ( FInSummary( ATTR_CONST ) ) { if ( MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) ) RpcSemError( this, MyContext, CONST_ON_OUT_PARAM, NULL ); else if ( MyContext.AnyAncestorBits( IN_FUNCTION_RESULT ) ) RpcSemError( this, MyContext, CONST_ON_RETVAL, NULL ); } // ignore pointers do not need to be rpc-able fIgnore = (NULL != MyContext.ExtractAttribute( ATTR_IGNORE )); if ( fIgnore ) { MyContext.ClearAncestorBits( IN_RPC ); } //////////////////////////////////////////////////////////////////////// // process field attributes // see if we have any field attributes (are conformant or varying) FAInfo.SetControl( TRUE, GetBasicType()->IsPtrOrArray() ); MyContext.ExtractFieldAttributes( &FAInfo ); FAInfo.Validate( &MyContext ); // ptr is conf or varying or conf/varying if ( FAInfo.Kind & FA_CONFORMANT_VARYING ) { fIsSizedPtr = TRUE; } switch ( FAInfo.Kind ) { case FA_NONE: { break; } case FA_STRING: { // string attributes only allowed on char and wchar_t if ( !GetBasicType()->IsStringableType() ) TypeSemError( this, MyContext, STRING_NOT_ON_BYTE_CHAR, NULL ); if ( MyContext.AllAncestorBits( UNDER_OUT_PARAM | IN_PARAM_LIST | IN_RPC ) && !fUnderAPtr && !MyContext.AnyAncestorBits( IN_STRUCT | IN_UNION | UNDER_IN_PARAM ) ) TypeSemError( this, MyContext, DERIVES_FROM_UNSIZED_STRING, NULL ); MyContext.SetDescendantBits( HAS_STRING ); // break; deliberate fall through to case below } case FA_VARYING: { MyContext.SetDescendantBits( HAS_VAR_PTR ); break; } case FA_CONFORMANT: { MyContext.SetDescendantBits( HAS_CONF_PTR ); break; } case FA_CONFORMANT_STRING: { // string attributes only allowed on char and wchar_t if ( !GetBasicType()->IsStringableType() ) TypeSemError( this, MyContext, STRING_NOT_ON_BYTE_CHAR, NULL ); if ( FAInfo.StringKind == STR_BSTRING ) TypeSemError( this, MyContext, BSTRING_NOT_ON_PLAIN_PTR, NULL ); // break; deliberate fall through to case below } case FA_CONFORMANT_VARYING: { MyContext.SetDescendantBits( HAS_CONF_VAR_PTR ); break; } case FA_INTERFACE: { if ( !fInterfacePtr && (GetBasicType()->NodeKind() != NODE_VOID ) ) { TypeSemError( this, MyContext, IID_IS_NON_POINTER, NULL ); } fInterfacePtr = TRUE; break; } default: // string + varying combinations { TypeSemError( this, MyContext, INVALID_SIZE_ATTR_ON_STRING, NULL ); break; } } // tell our children we are constructing an interface pointer if (fInterfacePtr) MyContext.SetAncestorBits( IN_INTERFACE_PTR ); // interface pointer shouldn't have explicit pointer attributes if ( fInterfacePtr && fExplicitPtrAttr && (PtrKind == PTR_FULL || PtrKind == PTR_REF ) ) { TypeSemError( this, MyContext, INTF_EXPLICIT_PTR_ATTR, NULL ); } // Non pipe [out] interface pointers must use double indirection. // However, pipe interface pointers can use only a single indirection. // Note that fInterfacePtr may be true for a void *. if ( fInterfacePtr && MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) && !fUnderAPtr ) { if ( GetChild()->NodeKind() == NODE_INTERFACE_REFERENCE ) TypeSemError( this, MyContext, NON_INTF_PTR_PTR_OUT, NULL ); } if ( MyContext.FInSummary( ATTR_SWITCH_IS ) && ( FAInfo.Kind != FA_NONE) ) TypeSemError( this, MyContext, ARRAY_OF_UNIONS_ILLEGAL, NULL ); // see if a param or return type context attr reached us... bool fSerialize = MyContext.ExtractAttribute( ATTR_SERIALIZE ) != 0; bool fNoSerialize = MyContext.ExtractAttribute( ATTR_NOSERIALIZE ) != 0; if ( MyContext.FInSummary( ATTR_CONTEXT ) ) { if (GetBasicType()->NodeKind() != NODE_POINTER ) { if ( fSerialize && fNoSerialize ) { SemError( this, MyContext, CONFLICTING_ATTRIBUTES, GetSymName() ); } MyContext.ExtractAttribute( ATTR_CONTEXT ); MyContext.SetDescendantBits( HAS_HANDLE | HAS_CONTEXT_HANDLE ); pParentCtxt->SetDescendantBits( HAS_HANDLE | HAS_CONTEXT_HANDLE ); MyContext.ClearAncestorBits( IN_RPC ); if (GetBasicType()->NodeKind() != NODE_VOID ) { TypeSemError( this, MyContext, CONTEXT_HANDLE_VOID_PTR, NULL ); } } } else { if ( fSerialize || fNoSerialize ) { SemError( this, MyContext, NO_CONTEXT_HANDLE, GetSymName() ); } } // see if a byte_count reached us... pCountAttr = (node_byte_count *) MyContext.ExtractAttribute( ATTR_BYTE_COUNT ); if (pCountAttr) { // byte count error checking if ( pCommand->NeedsNDR64Run() ) TypeSemError( this, MyContext, BYTE_COUNT_IN_NDR64, 0 ); node_param * pParam = pCountAttr->GetByteCountParam(); if ( !MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) || MyContext.AnyAncestorBits( UNDER_IN_PARAM ) ) { TypeSemError( this, MyContext, BYTE_COUNT_NOT_OUT_PTR, 0 ); } if ( !pParam || !pParam->FInSummary( ATTR_IN ) || pParam->FInSummary( ATTR_OUT ) ) TypeSemError( this, MyContext, BYTE_COUNT_PARAM_NOT_IN, 0 ); if ( pParam ) { NODE_T nodeKind = pParam->GetBasicType()->NodeKind(); if ( nodeKind < NODE_HYPER || nodeKind > NODE_BYTE ) { SemError( this, MyContext, BYTE_COUNT_PARAM_NOT_INTEGRAL, 0 ); } } if ( !pCommand->IsSwitchDefined( SWITCH_MS_EXT ) ) { SemError( this, MyContext, BYTE_COUNT_INVALID, 0 ); } if ( MyContext.AnyDescendantBits( HAS_CONF_VAR_PTR | HAS_VAR_PTR | HAS_CONF_PTR ) ) { SemError( this, MyContext, BYTE_COUNT_INVALID, 0 ); } } if ( PtrKind == PTR_REF ) { SEM_ANALYSIS_CTXT * pCtxt = (SEM_ANALYSIS_CTXT *) MyContext.FindNonDefAncestorContext(); if ( ( pCtxt->GetParent()->NodeKind() == NODE_FIELD ) && ( pCtxt->GetParentContext()->GetParent()->NodeKind() == NODE_UNION ) ) TypeSemError( this, MyContext, REF_PTR_IN_UNION, NULL ); } MyContext.ClearAncestorBits( IN_UNION | IN_NE_UNION | IN_ARRAY ); //////////////////////////////////////////////////////////////////////// // finally, process the child GetChild()->SemanticAnalysis( &MyContext ); // if the child and this node is a conf and/or varying pointer if ( fIsSizedPtr ) { if ( MyContext.AnyDescendantBits( HAS_SIZED_PTR ) ) { MyContext.SetDescendantBits( HAS_MULTIDIM_VECTOR ); } else { MyContext.SetDescendantBits( HAS_SIZED_PTR ); } } // allocate error checking if ( pAlloc ) { if ( MyContext.AnyDescendantBits( HAS_TRANSMIT_AS | HAS_REPRESENT_AS ) ) { if ( MyContext.AnyAncestorBits( IN_RPC ) ) SemError( this, MyContext, ALLOCATE_ON_TRANSMIT_AS, NULL ); else AcfError( pAlloc, this, MyContext, ALLOCATE_ON_TRANSMIT_AS, NULL ); } if ( MyContext.AnyDescendantBits( HAS_HANDLE ) ) { if ( MyContext.AnyAncestorBits( IN_RPC ) ) SemError( this, MyContext, ALLOCATE_ON_HANDLE, NULL ); else AcfError( pAlloc, this, MyContext, ALLOCATE_ON_HANDLE, NULL ); } // warn about allocate(all_nodes) with [in,out] parameter if ( MyContext.AllAncestorBits( IN_RPC | IN_PARAM_LIST | UNDER_IN_PARAM | UNDER_OUT_PARAM ) && ( pAlloc->GetAllocateDetails() & ALLOCATE_ALL_NODES ) ) { SemError( this, MyContext, ALLOCATE_IN_OUT_PTR, NULL ); } } if ( fInterfacePtr ) MyContext.SetAncestorBits( IN_INTERFACE_PTR ); if ( MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) && !MyContext.AnyDescendantBits( HAS_ARRAY | HAS_TRANSMIT_AS ) && MyContext.AllAncestorBits( IN_RPC | UNDER_OUT_PARAM ) && !MyContext.AnyAncestorBits( UNDER_IN_PARAM | IN_ARRAY | IN_STRUCT | IN_UNION | IN_TRANSMIT_AS | IN_REPRESENT_AS ) && ( PtrKind == PTR_REF ) ) TypeSemError( this, MyContext, DERIVES_FROM_PTR_TO_CONF, NULL ); #if 0 if ( MyContext.AnyDescendantBits( HAS_DIRECT_CONF_OR_VAR ) ) { TypeSemError( this, MyContext, ILLEGAL_CONFORMANT_ARRAY, NULL ); } #endif // incomplete types are OK below a pointer // array characteristics blocked by pointer MyContext.ClearDescendantBits( HAS_INCOMPLETE_TYPE | HAS_RECURSIVE_DEF | HAS_ARRAY | HAS_VAR_ARRAY | HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY | HAS_MULTIDIM_SIZING | HAS_UNION | HAS_STRUCT | HAS_TRANSMIT_AS | HAS_REPRESENT_AS | HAS_UNSAT_REP_AS | HAS_DIRECT_CONF_OR_VAR | HAS_ENUM | HAS_ARRAY_OF_REF | HAS_CONTEXT_HANDLE | HAS_HRESULT ); if ( !fInterfacePtr && !fIgnore ) MyContext.SetDescendantBits( HAS_POINTER ); if ( ( FAInfo.Kind != FA_NONE ) && ( FAInfo.Kind != FA_STRING ) && ( FAInfo.Kind != FA_INTERFACE ) ) MyContext.SetDescendantBits( HAS_DIRECT_CONF_OR_VAR ); if ( ( PtrKind == PTR_REF ) && ( MyContext.FindNonDefAncestorContext() ->GetParent()->NodeKind() == NODE_ARRAY ) ) { MyContext.SetDescendantBits( HAS_ARRAY_OF_REF ); } #ifdef gajgaj if ( (PtrKind != PTR_REF ) && MyContext.AnyDescendantBits( HAS_HANDLE ) && MyContext.AnyAncestorBits( IN_RPC ) ) TypeSemError( this, MyContext, PTR_TO_HDL_UNIQUE_OR_FULL, NULL ); #endif //gajgaj if ( MyContext.AnyDescendantBits( HAS_IN_CSTYPE | HAS_OUT_CSTYPE ) ) { if ( !FAInfo.VerifyOnlySimpleExpression() ) SemError( this, MyContext, CSCHAR_EXPR_MUST_BE_SIMPLE, NULL ); if ( FA_CONFORMANT == FAInfo.Kind ) SemError( this, MyContext, NO_CONFORMANT_CSCHAR, NULL ); if ( MyContext.AnyDescendantBits( HAS_MULTIDIM_SIZING | HAS_MULTIDIM_VECTOR ) ) { SemError( this, MyContext, NO_MULTIDIM_CSCHAR, NULL ); } // We want to propagate the the descendant bits up so that the proc // and interface know the cs stuff is around but we only want to set // the "this is a cs array" flag if it's actually a cs array if ( GetChild()->FInSummary( ATTR_CSCHAR ) ) SetHasCSType(); } SIZE_LENGTH_USAGE usage; if ( HasCSType() ) usage = CSSizeLengthUsage; else usage = NonCSSizeLengthUsage; if ( ! FAInfo.SetExpressionVariableUsage( usage ) ) SemError( this, MyContext, SHARED_CSCHAR_EXPR_VAR, NULL ); pParentCtxt->ReturnValues( MyContext ); } void node_array::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); FIELD_ATTR_INFO FAInfo; PTRTYPE PtrKind = PTR_UNKNOWN; BOOL fArrayParent = MyContext.AnyAncestorBits( IN_ARRAY ); if ( HasCorrelation( this ) ) { MyContext.IncCorrelationCount(); } CheckDeclspecAlign( MyContext ); // See if context_handle applied to param reached us if ( CheckContextHandle( MyContext ) ) { MyContext.SetDescendantBits( HAS_HANDLE | HAS_CONTEXT_HANDLE ); } if ( MyContext.FInSummary( ATTR_SWITCH_IS ) ) TypeSemError( this, MyContext, ARRAY_OF_UNIONS_ILLEGAL, NULL ); //////////////////////////////////////////////////////////////////////// // process pointer attributes PtrKind = MyContext.GetPtrKind(); MIDL_ASSERT( PtrKind != PTR_UNKNOWN ); if ( PtrKind == PTR_FULL ) { MyContext.SetDescendantBits( HAS_FULL_PTR ); } if ( MyContext.ExtractAttribute( ATTR_PTR_KIND) ) TypeSemError( this, MyContext, MORE_THAN_ONE_PTR_ATTR, NULL ); // ref pointer may not be returned if ( ( PtrKind == PTR_REF ) && MyContext.AllAncestorBits( IN_RPC | IN_FUNCTION_RESULT ) ) { if (MyContext.FindNonDefAncestorContext()->GetParent()->NodeKind() == NODE_PROC ) TypeSemError( this, MyContext, BAD_CON_REF_RT, NULL ); } // unique or full pointer may not be out only if ( ( PtrKind != PTR_REF ) && MyContext.AllAncestorBits( IN_RPC | IN_PARAM_LIST ) && !MyContext.AnyAncestorBits( UNDER_IN_PARAM | IN_STRUCT | IN_UNION | IN_ARRAY | IN_POINTER ) ) TypeSemError( this, MyContext, UNIQUE_FULL_PTR_OUT_ONLY, NULL ); MyContext.SetAncestorBits( IN_ARRAY ); // warn about OUT const things if ( FInSummary( ATTR_CONST ) ) { if ( MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) ) RpcSemError( this, MyContext, CONST_ON_OUT_PARAM, NULL ); else if ( MyContext.AnyAncestorBits( IN_FUNCTION_RESULT ) ) RpcSemError( this, MyContext, CONST_ON_RETVAL, NULL ); } ///////////////////////////////////////////////////////////////////////// // process field attributes FAInfo.SetControl( FALSE, GetBasicType()->IsPtrOrArray() ); MyContext.ExtractFieldAttributes( &FAInfo ); FAInfo.Validate( &MyContext, pLowerBound, pUpperBound ); if (MyContext.AnyAncestorBits( IN_LIBRARY )) { if ( FA_NONE != FAInfo.Kind && FA_CONFORMANT != FAInfo.Kind) { // only Fixed size arrays and SAFEARRAYs are allowed in Type Libraries SemError( this, MyContext, NOT_FIXED_ARRAY, NULL ); } } switch ( FAInfo.Kind ) { case FA_NONE: { break; } case FA_STRING: { // string attributes only allowed on char and wchar_t if ( !GetBasicType()->IsStringableType() ) TypeSemError( this, MyContext, STRING_NOT_ON_BYTE_CHAR, NULL ); if ( MyContext.AllAncestorBits( UNDER_OUT_PARAM | IN_PARAM_LIST | IN_RPC ) && !MyContext.AnyAncestorBits( IN_STRUCT | IN_UNION | IN_POINTER | IN_ARRAY | UNDER_IN_PARAM ) ) TypeSemError( this, MyContext, DERIVES_FROM_UNSIZED_STRING, NULL ); if ( FAInfo.StringKind == STR_BSTRING ) TypeSemError( this, MyContext, BSTRING_NOT_ON_PLAIN_PTR, NULL ); // break; deliberate fall through to case below } case FA_VARYING: { MyContext.SetDescendantBits( HAS_VAR_ARRAY ); break; } case FA_CONFORMANT: { MyContext.SetDescendantBits( HAS_CONF_ARRAY ); break; } case FA_CONFORMANT_STRING: { // string attributes only allowed on char and wchar_t if ( !GetBasicType()->IsStringableType() ) TypeSemError( this, MyContext, STRING_NOT_ON_BYTE_CHAR, NULL ); if ( FAInfo.StringKind == STR_BSTRING ) TypeSemError( this, MyContext, BSTRING_NOT_ON_PLAIN_PTR, NULL ); MyContext.SetDescendantBits( HAS_STRING ); // break; deliberate fall through to case below } case FA_CONFORMANT_VARYING: { MyContext.SetDescendantBits( HAS_CONF_VAR_ARRAY ); break; } case FA_INTERFACE: { // gaj - tbd break; } default: // string + varying combinations { TypeSemError( this, MyContext, INVALID_SIZE_ATTR_ON_STRING, NULL ); break; } } // detect things like arrays of conf structs... // if we have an array as an ancestor, and we have conformance, then complain if ( MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) && fArrayParent ) { // see if there are any bad things between us and our parent array SEM_ANALYSIS_CTXT * pCtxt = (SEM_ANALYSIS_CTXT *) pParentCtxt; node_skl * pCur = pCtxt->GetParent(); // check up for anything other than def below proc // make sure the proc only has one param while ( pCur->NodeKind() != NODE_ARRAY ) { if ( pCur->NodeKind() != NODE_DEF ) { SemError( this, MyContext, ILLEGAL_CONFORMANT_ARRAY, NULL ); break; } pCtxt = (SEM_ANALYSIS_CTXT *) pCtxt->GetParentContext(); pCur = pCtxt->GetParent(); } } ////////////////////////////////////////////////////////////// // process the array element GetChild()->SemanticAnalysis( &MyContext ); if ( MyContext.AnyDescendantBits( HAS_PIPE ) ) { SemError( this, MyContext, INVALID_ARRAY_ELEMENT, 0 ); } BOOL IsMultiDim = MyContext.AnyDescendantBits( HAS_ARRAY ); if ( MyContext.AnyDescendantBits( HAS_ARRAY ) && MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY | HAS_VAR_ARRAY ) ) { MyContext.SetDescendantBits( HAS_MULTIDIM_SIZING ); MyContext.SetDescendantBits( HAS_MULTIDIM_VECTOR ); } MyContext.SetDescendantBits( HAS_ARRAY ); if ( NODE_POINTER == GetNonDefChild()->NodeKind() ) MyContext.SetDescendantBits( HAS_ARRAYOFPOINTERS ); // disallow forward references as array elements if ( MyContext.AnyDescendantBits( HAS_INCOMPLETE_TYPE ) ) { if (! MyContext.AnyAncestorBits( IN_LIBRARY )) SemError( this, MyContext, UNDEFINED_SYMBOL, NULL ); MyContext.ClearDescendantBits( HAS_INCOMPLETE_TYPE ); } MyContext.ClearDescendantBits( HAS_RECURSIVE_DEF ); if ( MyContext.AllDescendantBits( HAS_DIRECT_CONF_OR_VAR | HAS_MULTIDIM_SIZING ) && MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) && ( GetChild()->NodeKind() == NODE_DEF ) ) { SemError( this, MyContext, NON_ANSI_MULTI_CONF_ARRAY, NULL ); } MyContext.ClearDescendantBits( HAS_DIRECT_CONF_OR_VAR ); if ( ( FAInfo.Kind != FA_NONE ) && ( FAInfo.Kind != FA_STRING ) && ( FAInfo.Kind != FA_INTERFACE ) ) MyContext.SetDescendantBits( HAS_DIRECT_CONF_OR_VAR ); if ( MyContext.AnyDescendantBits( HAS_POINTER ) ) fHasPointer = TRUE; if ( MyContext.AnyDescendantBits( HAS_HANDLE ) ) TypeSemError( this, MyContext, BAD_CON_CTXT_HDL_ARRAY, NULL ); // don't allow functions as elements if ( MyContext.AnyDescendantBits( HAS_FUNC ) && MyContext.AllAncestorBits( IN_INTERFACE | IN_RPC ) ) TypeSemError( this, MyContext, BAD_CON_ARRAY_FUNC, NULL ); if ( MyContext.AnyDescendantBits( HAS_IN_CSTYPE | HAS_OUT_CSTYPE ) ) { if ( FA_CONFORMANT == FAInfo.Kind ) SemError( this, MyContext, NO_CONFORMANT_CSCHAR, NULL ); if ( IsMultiDim ) SemError( this, MyContext, NO_MULTIDIM_CSCHAR, NULL ); SetHasCSType(); } SIZE_LENGTH_USAGE usage; if ( HasCSType() ) usage = CSSizeLengthUsage; else usage = NonCSSizeLengthUsage; if ( ! FAInfo.SetExpressionVariableUsage( usage ) ) SemError( this, MyContext, SHARED_CSCHAR_EXPR_VAR, NULL ); MyContext.ClearDescendantBits( HAS_STRUCT ); pParentCtxt->ReturnValues( MyContext ); } void node_echo_string::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); pParentCtxt->ReturnValues( MyContext ); }; void node_e_status_t::VerifyParamUsage( SEM_ANALYSIS_CTXT * pCtxt ) { // verify that we are under an OUT-only pointer // or a "hidden" status parameter (only specified in the acf file) if ( pCtxt->AnyAncestorBits( UNDER_IN_PARAM ) || !pCtxt->AnyAncestorBits( UNDER_OUT_PARAM ) ) { if ( !pCtxt->AnyAncestorBits( UNDER_HIDDEN_STATUS ) ) { TypeSemError( this, *pCtxt, E_STAT_T_MUST_BE_PTR_TO_E, NULL ); return; } } SEM_ANALYSIS_CTXT * pCurCtxt = (SEM_ANALYSIS_CTXT *)pCtxt->GetParentContext(); node_skl * pPar = pCurCtxt->GetParent(); unsigned short PtrSeen = 0; NODE_T Kind; while ( ( Kind = pPar->NodeKind() ) != NODE_PARAM ) { switch ( Kind ) { case NODE_POINTER: // count pointers (must see just 1 ) PtrSeen++; break; case NODE_DEF: // skip DEF nodes case NODE_E_STATUS_T: // and the error_status_t node break; default: // error on anything else TypeSemError( this, *pCtxt, E_STAT_T_MUST_BE_PTR_TO_E, NULL ); return; } // advance up the stack pCurCtxt = (SEM_ANALYSIS_CTXT *) pCurCtxt->GetParentContext(); pPar = pCurCtxt->GetParent(); } // complain about wrong number of pointers if ( PtrSeen != 1 ) TypeSemError( this, *pCtxt, E_STAT_T_MUST_BE_PTR_TO_E, NULL ); } void node_e_status_t::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); BOOL fFaultstat = (NULL != MyContext.ExtractAttribute( ATTR_FAULTSTAT )); BOOL fCommstat = (NULL != MyContext.ExtractAttribute( ATTR_COMMSTAT )); MyContext.SetDescendantBits( HAS_E_STAT_T ); CheckDeclspecAlign( MyContext ); // an error status_t can only be: // 1: a parameter return type, or // 2: an [out] only pointer parameter // and it must have at least one of [comm_status] or // [fault_status] applied // make sure parameter is an OUT-only pointer if it has comm/fault_status if ( fFaultstat || fCommstat ) { if ( MyContext.AnyAncestorBits( IN_RPC ) ) { // A proc in an actual remote interface. // Then it must be an appropriate parameter if ( MyContext.AnyAncestorBits( IN_PARAM_LIST ) ) { VerifyParamUsage( &MyContext ); } // or on a return type. else if ( !MyContext.AnyAncestorBits( IN_FUNCTION_RESULT ) ) { TypeSemError( this, MyContext, E_STAT_T_MUST_BE_PTR_TO_E , NULL ); } } if ( MyContext.AnyAncestorBits( IN_ARRAY ) ) TypeSemError( this, MyContext, E_STAT_T_ARRAY_ELEMENT, NULL ); if ( MyContext.AnyAncestorBits( IN_TRANSMIT_AS | IN_REPRESENT_AS ) ) TypeSemError( this, MyContext, TRANSMIT_AS_ON_E_STAT_T, NULL ); if ( MyContext.AnyAncestorBits( IN_STRUCT | IN_UNION ) ) TypeSemError( this, MyContext, BAD_CON_E_STAT_T_FIELD, NULL ); if ( MyContext.AnyAncestorBits( IN_USER_MARSHAL ) ) TypeSemError( this, MyContext, TRANSMIT_AS_ON_E_STAT_T, NULL ); } MyContext.RejectAttributes(); pParentCtxt->ReturnValues( MyContext ); }; void node_error::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); MyContext.RejectAttributes(); CheckDeclspecAlign( MyContext ); pParentCtxt->ReturnValues( MyContext ); }; void node_wchar_t::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); CheckDeclspecAlign( MyContext ); TypeSemError( this, MyContext, WCHAR_T_INVALID_OSF, NULL ); if ( MyContext.AllAncestorBits( IN_PARAM_LIST | IN_RPC ) ) SemError( this, MyContext, WCHAR_T_NEEDS_MS_EXT_TO_RPC, NULL ); MyContext.RejectAttributes(); pParentCtxt->ReturnValues( MyContext ); }; void node_library::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt) { MEM_ITER MemIter(this); SEM_ANALYSIS_CTXT MyContext(this, pParentCtxt); BOOL HasGuid = MyContext.FInSummary( ATTR_GUID ); MyContext.ExtractAttribute(ATTR_HELPSTRING); MyContext.ExtractAttribute(ATTR_HELPCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRINGCONTEXT); MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL); gfCaseSensitive=FALSE; // check for illegal attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { // acceptable attributes case MATTR_RESTRICTED: break; // unacceptable attributes case MATTR_READONLY: case MATTR_SOURCE: case MATTR_DEFAULTVTABLE: case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: case MATTR_OPTIONAL: case MATTR_RETVAL: case MATTR_VARARG: case MATTR_PREDECLID: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_IMMEDIATEBIND: case MATTR_USESGETLASTERROR: case MATTR_REPLACEABLE: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } node_type_attr * pTA; while ( ( pTA = (node_type_attr *)MyContext.ExtractAttribute(ATTR_TYPE) ) != 0 ) { switch (pTA->GetAttr()) { // acceptable attributes case TATTR_CONTROL: break; // unacceptable attributes case TATTR_LICENSED: case TATTR_APPOBJECT: case TATTR_PUBLIC: case TATTR_DUAL: case TATTR_PROXY: case TATTR_NONEXTENSIBLE: case TATTR_OLEAUTOMATION: case TATTR_NONCREATABLE: case TATTR_AGGREGATABLE: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } // make sure the UUID is unique if ( HasGuid ) { node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } else { SemError(this, MyContext, NO_UUID_SPECIFIED, NULL); } node_skl * pN; NODE_T nodeKind; while ( ( pN = MemIter.GetNext() ) != 0 ) { SEM_ANALYSIS_CTXT ChildContext(MyContext); ChildContext.SetInterfaceContext( &MyContext ); ChildContext.SetAncestorBits(IN_LIBRARY); nodeKind = pN->NodeKind(); if ( nodeKind == NODE_PROC ) { SemError( this, MyContext, INVALID_MEMBER, pN->GetSymName() ); } else if ( nodeKind != NODE_MODULE && nodeKind != NODE_DISPINTERFACE && nodeKind != NODE_COCLASS && nodeKind != NODE_INTERFACE && nodeKind != NODE_STRUCT && nodeKind != NODE_UNION && nodeKind != NODE_ENUM && nodeKind != NODE_LABEL && nodeKind != NODE_DEF && nodeKind != NODE_INTERFACE_REFERENCE && nodeKind != NODE_ID && nodeKind != NODE_ECHO_STRING && nodeKind != NODE_FORWARD && nodeKind != NODE_MIDL_PRAGMA ) { SemError(this, MyContext, POSSIBLE_INVALID_MEMBER, pN->GetSymName()); } pN->SemanticAnalysis(&ChildContext); } // consume all the library attributes MyContext.CheckAttributes( ); // MyContext.ReturnValues(ChildContext); pParentCtxt->ReturnValues( MyContext ); gfCaseSensitive=TRUE; } void node_coclass::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt) { // make sure each coclass only gets analyzed once if (fSemAnalyzed) return; fSemAnalyzed = TRUE; MEM_ITER MemIter(this); SEM_ANALYSIS_CTXT MyContext(this, pParentCtxt); while(MyContext.ExtractAttribute(ATTR_CUSTOM)); MyContext.ExtractAttribute(ATTR_TYPEDESCATTR); MyContext.ExtractAttribute( ATTR_HIDDEN ); MyContext.ExtractAttribute( ATTR_VERSION ); MyContext.ExtractAttribute( ATTR_HELPSTRING ); MyContext.ExtractAttribute( ATTR_HELPSTRINGCONTEXT ); MyContext.ExtractAttribute( ATTR_HELPCONTEXT ); MyContext.ExtractAttribute( ATTR_LCID ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } SEM_ANALYSIS_CTXT ChildContext(MyContext); ChildContext.SetInterfaceContext( &MyContext ); // check for illegal attributes node_type_attr * pTA; while ( ( pTA = (node_type_attr *)MyContext.ExtractAttribute(ATTR_TYPE) ) != 0 ) { switch (pTA->GetAttr()) { // acceptable attributes case TATTR_NONCREATABLE: SetNotCreatable(TRUE); break; case TATTR_LICENSED: case TATTR_APPOBJECT: case TATTR_CONTROL: case TATTR_AGGREGATABLE: break; // unacceptable attributes case TATTR_PUBLIC: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } case TATTR_DUAL: case TATTR_PROXY: case TATTR_NONEXTENSIBLE: case TATTR_OLEAUTOMATION: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } // check for illegal attributes node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { // acceptable attributes case MATTR_RESTRICTED: break; // unacceptable attributes case MATTR_READONLY: case MATTR_SOURCE: case MATTR_DEFAULTVTABLE: case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: case MATTR_OPTIONAL: case MATTR_RETVAL: case MATTR_VARARG: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_IMMEDIATEBIND: case MATTR_USESGETLASTERROR: case MATTR_REPLACEABLE: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } BOOL HasGuid = MyContext.FInSummary( ATTR_GUID ); // make sure the UUID is unique if ( HasGuid ) { node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } else { SemError(this, MyContext, NO_UUID_SPECIFIED, NULL); } ChildContext.SetAncestorBits(IN_COCLASS); BOOL fHasDefaultSource = FALSE; BOOL fHasDefaultSink = FALSE; named_node * pN = (named_node *)MemIter.GetNext(); named_node * pNFirstSource = NULL; named_node * pNFirstSink = NULL; while (pN) { BOOL fSource = pN->FMATTRInSummary(MATTR_SOURCE); BOOL fDefaultVtable = pN->FMATTRInSummary(MATTR_DEFAULTVTABLE); if (fSource) { if (NULL == pNFirstSource && !pN->FMATTRInSummary(MATTR_RESTRICTED)) pNFirstSource = pN; } else { if (NULL == pNFirstSink && !pN->FMATTRInSummary(MATTR_RESTRICTED)) pNFirstSink = pN; } if (fDefaultVtable) { if (!fSource) { SemError(this, MyContext, DEFAULTVTABLE_REQUIRES_SOURCE, pN->GetSymName()); } } if (pN->GetAttribute(ATTR_DEFAULT)) { if (fSource) { if (fHasDefaultSource) { SemError(this, MyContext, TWO_DEFAULT_INTERFACES, pN->GetSymName()); } fHasDefaultSource = TRUE; } else { if (fHasDefaultSink) { SemError(this, MyContext, TWO_DEFAULT_INTERFACES, pN->GetSymName()); } fHasDefaultSink = TRUE; } } pN->SemanticAnalysis(&ChildContext); pN = MemIter.GetNext(); } if (!fHasDefaultSink) { if (pNFirstSink) pNFirstSink->SetAttribute(ATTR_DEFAULT); } if (!fHasDefaultSource) { if (pNFirstSource) pNFirstSource->SetAttribute(ATTR_DEFAULT); } MyContext.CheckAttributes( ); MyContext.ReturnValues(ChildContext); pParentCtxt->ReturnValues( MyContext ); } void node_dispinterface::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt) { // make sure each dispinterface gets analyzed only once if (fSemAnalyzed) return; fSemAnalyzed = TRUE; MEM_ITER MemIter(this); SEM_ANALYSIS_CTXT MyContext(this, pParentCtxt); while(MyContext.ExtractAttribute(ATTR_CUSTOM)); MyContext.ExtractAttribute(ATTR_TYPEDESCATTR); MyContext.ExtractAttribute( ATTR_HIDDEN ); MyContext.ExtractAttribute( ATTR_VERSION ); MyContext.ExtractAttribute( ATTR_HELPSTRING ); MyContext.ExtractAttribute( ATTR_HELPSTRINGCONTEXT ); MyContext.ExtractAttribute( ATTR_HELPCONTEXT ); MyContext.ExtractAttribute( ATTR_LCID ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } SEM_ANALYSIS_CTXT ChildContext(MyContext); ChildContext.SetInterfaceContext( &MyContext ); // check for illegal attributes node_type_attr * pTA; while ( ( pTA = (node_type_attr *)MyContext.ExtractAttribute(ATTR_TYPE) ) != 0 ) { switch (pTA->GetAttr()) { // acceptable attributes case TATTR_NONEXTENSIBLE: break; // unacceptable attributes case TATTR_OLEAUTOMATION: case TATTR_PUBLIC: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } case TATTR_PROXY: case TATTR_DUAL: case TATTR_LICENSED: case TATTR_APPOBJECT: case TATTR_CONTROL: case TATTR_NONCREATABLE: case TATTR_AGGREGATABLE: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } node_member_attr * pMA; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { // acceptable attributes case MATTR_RESTRICTED: break; // unacceptable attributes case MATTR_READONLY: case MATTR_SOURCE: case MATTR_DEFAULTVTABLE: case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: case MATTR_OPTIONAL: case MATTR_RETVAL: case MATTR_VARARG: case MATTR_PREDECLID: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_IMMEDIATEBIND: case MATTR_USESGETLASTERROR: case MATTR_REPLACEABLE: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } BOOL HasGuid = MyContext.FInSummary( ATTR_GUID ); // make sure the UUID is unique if ( HasGuid ) { node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } else { SemError(this, MyContext, NO_UUID_SPECIFIED, NULL); } // make sure IDispatch is defined. SymKey SKey("IDispatch", NAME_DEF); pDispatch = pBaseSymTbl->SymSearch(SKey); if (!pDispatch) { // IDispatch is not defined: generate error. SemError(this, MyContext, NO_IDISPATCH, GetSymName()); } else { if (pDispatch->NodeKind() == NODE_INTERFACE_REFERENCE) pDispatch = ((node_interface_reference *)pDispatch)->GetRealInterface(); } ChildContext.SetAncestorBits((ANCESTOR_FLAGS) IN_DISPINTERFACE); node_skl * pN; while ( ( pN = MemIter.GetNext() ) != 0 ) { pN->SemanticAnalysis(&ChildContext); } MyContext.CheckAttributes( ); MyContext.ReturnValues(ChildContext); pParentCtxt->ReturnValues( MyContext ); } void node_module::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt) { // make sure each module gets analyzed only once if (fSemAnalyzed) return; fSemAnalyzed = TRUE; MEM_ITER MemIter(this); SEM_ANALYSIS_CTXT MyContext(this, pParentCtxt); BOOL HasGuid = MyContext.FInSummary( ATTR_GUID ); MyContext.ExtractAttribute(ATTR_DLLNAME); while(MyContext.ExtractAttribute(ATTR_CUSTOM)); MyContext.ExtractAttribute(ATTR_TYPEDESCATTR); MyContext.ExtractAttribute( ATTR_HIDDEN ); MyContext.ExtractAttribute( ATTR_VERSION ); MyContext.ExtractAttribute( ATTR_HELPSTRING ); MyContext.ExtractAttribute( ATTR_HELPSTRINGCONTEXT ); MyContext.ExtractAttribute( ATTR_HELPCONTEXT ); MyContext.ExtractAttribute( ATTR_LCID ); if (MyContext.ExtractAttribute(ATTR_HELPSTRINGDLL)) { SemError(this, MyContext, INAPPLICABLE_ATTRIBUTE, 0); } if ( !MyContext.AnyAncestorBits( IN_LIBRARY ) ) { SemError(this, MyContext, NO_LIBRARY, 0); } SEM_ANALYSIS_CTXT ChildContext(MyContext); ChildContext.SetInterfaceContext( &MyContext ); // make sure the UUID is unique if ( HasGuid ) { node_guid * pGuid = (node_guid *) MyContext.ExtractAttribute( ATTR_GUID ); node_skl* pDuplicate = GetDuplicateGuid( pGuid, pUUIDTable ); if ( pDuplicate ) { SemError(this, MyContext, DUPLICATE_UUID, pDuplicate->GetSymName()); } } // check for illegal attributes node_type_attr * pTA; while ( ( pTA = (node_type_attr *)MyContext.ExtractAttribute(ATTR_TYPE) ) != 0 ) { switch (pTA->GetAttr()) { // acceptable attributes case TATTR_PUBLIC: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, NEWLYFOUND_INAPPLICABLE_ATTRIBUTE, pAttrName); break; } break; // unacceptable attributes case TATTR_OLEAUTOMATION: case TATTR_LICENSED: case TATTR_APPOBJECT: case TATTR_CONTROL: case TATTR_PROXY: case TATTR_DUAL: case TATTR_NONEXTENSIBLE: case TATTR_NONCREATABLE: case TATTR_AGGREGATABLE: { char * pAttrName = pTA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } node_member_attr * pMA; node_member_attr * pUsesGetLastErrorAttr = 0; while ( ( pMA = (node_member_attr *)MyContext.ExtractAttribute(ATTR_MEMBER) ) != 0 ) { switch (pMA->GetAttr()) { // acceptable attributes case MATTR_RESTRICTED: break; case MATTR_USESGETLASTERROR: pUsesGetLastErrorAttr = pMA; break; // unacceptable attributes case MATTR_READONLY: case MATTR_SOURCE: case MATTR_DEFAULTVTABLE: case MATTR_BINDABLE: case MATTR_DISPLAYBIND: case MATTR_DEFAULTBIND: case MATTR_REQUESTEDIT: case MATTR_PROPGET: case MATTR_PROPPUT: case MATTR_PROPPUTREF: case MATTR_OPTIONAL: case MATTR_RETVAL: case MATTR_VARARG: case MATTR_PREDECLID: case MATTR_UIDEFAULT: case MATTR_NONBROWSABLE: case MATTR_DEFAULTCOLLELEM: case MATTR_IMMEDIATEBIND: case MATTR_REPLACEABLE: { char * pAttrName = pMA->GetNodeNameString(); SemError( this, MyContext, INAPPLICABLE_ATTRIBUTE, pAttrName); break; } } } if (pUsesGetLastErrorAttr != 0) { MyContext.Add(pUsesGetLastErrorAttr); } ChildContext.SetAncestorBits(IN_MODULE); node_skl * pN; while ( (pN = MemIter.GetNext() ) != 0 ) { pN->SemanticAnalysis(&ChildContext); } MyContext.CheckAttributes( ); MyContext.ReturnValues(ChildContext); pParentCtxt->ReturnValues( MyContext ); } void node_pipe::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); if (!GetSymName()) { char * pParentName = pParentCtxt->GetParent()->GetSymName(); char * pName = new char [strlen(pParentName) + 6]; // the length of "pipe_" plus terminating null strcpy(pName, "pipe_"); strcat(pName,pParentName); SetSymName(pName); } if ( MyContext.AnyAncestorBits( HAS_ASYNCHANDLE ) && !MyContext.AnyAncestorBits( IN_OBJECT_INTF ) ) { SetGenAsyncPipeFlavor(); } GetChild()->SemanticAnalysis(&MyContext); CheckDeclspecAlign( MyContext ); // Remove the following statement once support for UNIONS within PIPES is provided by the interpreter. if (MyContext.AnyDescendantBits( HAS_UNION )) { // pipe with a UNION RpcSemError(this , MyContext, UNIMPLEMENTED_FEATURE, "pipes can't contain unions" ); } if (MyContext.AnyDescendantBits( HAS_HANDLE | HAS_POINTER | HAS_VAR_ARRAY | HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY | HAS_CONTEXT_HANDLE | HAS_CONF_PTR | HAS_VAR_PTR | HAS_CONF_VAR_PTR | HAS_TRANSMIT_AS | HAS_REPRESENT_AS | HAS_INTERFACE_PTR | HAS_DIRECT_CONF_OR_VAR )) { // All the above are illegal types within a pipe RpcSemError(this, MyContext, ILLEGAL_PIPE_TYPE, NULL ); } MyContext.ClearAncestorBits( IN_UNION | IN_NE_UNION | IN_ARRAY ); if ( MyContext.AnyAncestorBits( IN_ARRAY | IN_UNION | IN_NE_UNION | IN_STRUCT )) TypeSemError( this, MyContext, ILLEGAL_PIPE_EMBEDDING, NULL ); if ( MyContext.AnyAncestorBits( IN_TRANSMIT_AS | IN_REPRESENT_AS | IN_USER_MARSHAL | IN_FUNCTION_RESULT )) TypeSemError( this, MyContext, ILLEGAL_PIPE_CONTEXT, NULL ); if ( MyContext.AnyAncestorBits( IN_ENCODE_INTF )) TypeSemError( this, MyContext, PIPES_WITH_PICKLING, NULL ); if ( MyContext.AnyAncestorBits( IN_OBJECT_INTF ) ) { node_skl* pType = pParentCtxt->GetParent(); if ( pType->GetChild() ) { pType = pType->GetChild(); } } // BUGBUG UNDONE // Basically, a pipe can only be used as a parameter. // Pipe parameters may only be passed by value or by reference. // Need to make sure that /-Os mode isn't enabled (until support // for it has been implemented). // Need to enable /-Oi2 mode for the containing proc if we decide not // to implement /-Oi mode. MyContext.SetDescendantBits( (DESCENDANT_FLAGS) HAS_PIPE ); pParentCtxt->ReturnValues( MyContext ); } void node_safearray::SemanticAnalysis( SEM_ANALYSIS_CTXT * pParentCtxt ) { SEM_ANALYSIS_CTXT MyContext( this, pParentCtxt ); FIELD_ATTR_INFO FAInfo; PTRTYPE PtrKind = PTR_UNKNOWN; BOOL fArrayParent = MyContext.AnyAncestorBits( IN_ARRAY ); // this maintains a reference to LPSAFEARRAY. This is // necessary to generate the appropriate code when // SAFEARRAY(type) construct is used outside the library block char* szSafeArray = "LPSAFEARRAY"; SymKey SKey( szSafeArray, NAME_DEF ); named_node* pSafeArrayNode = pBaseSymTbl->SymSearch( SKey ); if ( pSafeArrayNode == 0 ) { SemError( this, MyContext, UNDEFINED_SYMBOL, szSafeArray ); } else { SetTypeAlias( pSafeArrayNode ); } CheckDeclspecAlign( MyContext ); // See if context_handle applied to param reached us if ( CheckContextHandle( MyContext ) ) { MyContext.SetDescendantBits( HAS_HANDLE | HAS_CONTEXT_HANDLE ); } if ( MyContext.FInSummary( ATTR_SWITCH_IS ) ) TypeSemError( this, MyContext, ARRAY_OF_UNIONS_ILLEGAL, NULL ); // if ( !MyContext.AnyAncestorBits( IN_LIBRARY ) ) // { // SemError(this, MyContext, SAFEARRAY_NOT_SUPPORT_OUTSIDE_TLB, 0); // } //////////////////////////////////////////////////////////////////////// // process pointer attributes PtrKind = MyContext.GetPtrKind(); MIDL_ASSERT( PtrKind != PTR_UNKNOWN ); if ( PtrKind == PTR_FULL ) { MyContext.SetDescendantBits( HAS_FULL_PTR ); } if ( MyContext.ExtractAttribute( ATTR_PTR_KIND) ) TypeSemError( this, MyContext, MORE_THAN_ONE_PTR_ATTR, NULL ); // ref pointer may not be returned if ( ( PtrKind == PTR_REF ) && MyContext.AllAncestorBits( IN_RPC | IN_FUNCTION_RESULT ) ) { if (MyContext.FindNonDefAncestorContext()->GetParent()->NodeKind() == NODE_PROC ) TypeSemError( this, MyContext, BAD_CON_REF_RT, NULL ); } // unique or full pointer may not be out only if ( ( PtrKind != PTR_REF ) && MyContext.AllAncestorBits( IN_RPC | IN_PARAM_LIST ) && !MyContext.AnyAncestorBits( UNDER_IN_PARAM | IN_STRUCT | IN_UNION | IN_ARRAY | IN_POINTER ) ) TypeSemError( this, MyContext, UNIQUE_FULL_PTR_OUT_ONLY, NULL ); MyContext.SetAncestorBits( IN_ARRAY ); // warn about OUT const things if ( FInSummary( ATTR_CONST ) ) { if ( MyContext.AnyAncestorBits( UNDER_OUT_PARAM ) ) RpcSemError( this, MyContext, CONST_ON_OUT_PARAM, NULL ); else if ( MyContext.AnyAncestorBits( IN_FUNCTION_RESULT ) ) RpcSemError( this, MyContext, CONST_ON_RETVAL, NULL ); } ///////////////////////////////////////////////////////////////////////// // process field attributes FAInfo.SetControl( FALSE, GetBasicType()->IsPtrOrArray() ); MyContext.ExtractFieldAttributes( &FAInfo ); switch ( FAInfo.Kind ) { case FA_NONE: { break; } case FA_STRING: { // string attributes only allowed on char and wchar_t if ( !GetBasicType()->IsStringableType() ) TypeSemError( this, MyContext, STRING_NOT_ON_BYTE_CHAR, NULL ); if ( MyContext.AllAncestorBits( UNDER_OUT_PARAM | IN_PARAM_LIST | IN_RPC ) && !MyContext.AnyAncestorBits( IN_STRUCT | IN_UNION | IN_POINTER | IN_ARRAY | UNDER_IN_PARAM ) ) TypeSemError( this, MyContext, DERIVES_FROM_UNSIZED_STRING, NULL ); if ( FAInfo.StringKind == STR_BSTRING ) TypeSemError( this, MyContext, BSTRING_NOT_ON_PLAIN_PTR, NULL ); // break; deliberate fall through to case below } case FA_VARYING: { MyContext.SetDescendantBits( HAS_VAR_ARRAY ); break; } case FA_CONFORMANT: { MyContext.SetDescendantBits( HAS_CONF_ARRAY ); break; } case FA_CONFORMANT_STRING: { // string attributes only allowed on char and wchar_t if ( !GetBasicType()->IsStringableType() ) TypeSemError( this, MyContext, STRING_NOT_ON_BYTE_CHAR, NULL ); if ( FAInfo.StringKind == STR_BSTRING ) TypeSemError( this, MyContext, BSTRING_NOT_ON_PLAIN_PTR, NULL ); // break; deliberate fall through to case below } case FA_CONFORMANT_VARYING: { MyContext.SetDescendantBits( HAS_CONF_VAR_ARRAY ); break; } case FA_INTERFACE: { // gaj - tbd break; } default: // string + varying combinations { TypeSemError( this, MyContext, INVALID_SIZE_ATTR_ON_STRING, NULL ); break; } } // detect things like arrays of conf structs... // if we have an array as an ancestor, and we have conformance, then complain if ( MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) && fArrayParent ) { // see if there are any bad things between us and our parent array SEM_ANALYSIS_CTXT * pCtxt = (SEM_ANALYSIS_CTXT *) pParentCtxt; node_skl * pCur = pCtxt->GetParent(); // check up for anything other than def below proc // make sure the proc only has one param while ( pCur->NodeKind() != NODE_ARRAY ) { if ( pCur->NodeKind() != NODE_DEF ) { SemError( this, MyContext, ILLEGAL_CONFORMANT_ARRAY, NULL ); break; } pCtxt = (SEM_ANALYSIS_CTXT *) pCtxt->GetParentContext(); pCur = pCtxt->GetParent(); } } ////////////////////////////////////////////////////////////// // process the array element GetChild()->SemanticAnalysis( &MyContext ); /* // BSTR has sizeis_ptr, eventhough under variant, and it would be ugly to // hardcode checking variant here. well... if ( MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY | HAS_VAR_ARRAY | HAS_UNSAT_REP_AS | HAS_CONTEXT_HANDLE | HAS_CONF_PTR | HAS_VAR_PTR | HAS_CONF_VAR_PTR | HAS_DIRECT_CONF_OR_VAR | HAS_FUNC | HAS_FULL_PTR | HAS_TOO_BIG_HDL | HAS_MULTIDIM_SIZING | HAS_PIPE | HAS_MULTIDIM_VECTOR | HAS_SIZED_ARRAY | HAS_SIZED_PTR ) ) TypeSemError( this, MyContext, INVALID_SAFEARRAY_ATTRIBUTE, NULL ); */ MyContext.SetDescendantBits( HAS_ARRAY ); // early binding of safearray(interface pointer) doesn't work node_skl * pChild = GetChild()->GetBasicType(); SEM_ANALYSIS_CTXT * pIntfCtxt = (SEM_ANALYSIS_CTXT *) MyContext.GetInterfaceContext(); BOOL fLocal = pIntfCtxt->FInSummary( ATTR_LOCAL ); fLocal |= MyContext.AnyAncestorBits( IN_LOCAL_PROC ); if ( pChild->NodeKind() == NODE_POINTER ) pChild = pChild->GetChild(); if ( IsInterfaceKind( pChild->NodeKind() ) && !MyContext.AnyAncestorBits( IN_LIBRARY ) && !fLocal ) SemError( this, MyContext, SAFEARRAY_IF_OUTSIDE_LIBRARY, NULL ); // disallow forward references as array elements // NOTE- all safearray elements are VARIANTS, we don't really need // to enforce this restriction for safearrays. Besides, enforcing // this restriction breaks some of our test cases. if ( MyContext.AnyDescendantBits( HAS_INCOMPLETE_TYPE ) ) { MyContext.ClearDescendantBits( HAS_INCOMPLETE_TYPE ); } MyContext.ClearDescendantBits( HAS_RECURSIVE_DEF ); if ( MyContext.AllDescendantBits( HAS_DIRECT_CONF_OR_VAR | HAS_MULTIDIM_SIZING ) && MyContext.AnyDescendantBits( HAS_CONF_ARRAY | HAS_CONF_VAR_ARRAY ) && ( GetChild()->NodeKind() == NODE_DEF ) ) { SemError( this, MyContext, NON_ANSI_MULTI_CONF_ARRAY, NULL ); } MyContext.ClearDescendantBits( HAS_DIRECT_CONF_OR_VAR ); if ( ( FAInfo.Kind != FA_NONE ) && ( FAInfo.Kind != FA_STRING ) && ( FAInfo.Kind != FA_INTERFACE ) ) MyContext.SetDescendantBits( HAS_DIRECT_CONF_OR_VAR ); if ( MyContext.AnyDescendantBits( HAS_HANDLE ) ) TypeSemError( this, MyContext, BAD_CON_CTXT_HDL_ARRAY, NULL ); // don't allow functions as elements if ( MyContext.AnyDescendantBits( HAS_FUNC ) && MyContext.AllAncestorBits( IN_INTERFACE | IN_RPC ) ) TypeSemError( this, MyContext, BAD_CON_ARRAY_FUNC, NULL ); // This is a hack to propagate the correct attributes up to the next level. // Unfortunately, semantic analysis does more then just determine // if the *.idl file is legal. It also catches known limitations of the // engine, aids in determining the complexity of the marshaling problem, // and other checks that change the state of the front end which directly // affect the backend. // gracelly handle the error case and the library case. if ( ! pSafeArrayNode | MyContext.AnyAncestorBits( IN_LIBRARY ) ) { // Is this class was used in a proxy, continue to pass up the proxy bits. if ( fInProxy ) { pSafeArrayNode->SemanticAnalysis( pParentCtxt ); return; } MyContext.ClearDescendantBits( HAS_STRUCT ); pParentCtxt->ReturnValues( MyContext ); return; } fInProxy = TRUE; pSafeArrayNode->SemanticAnalysis( pParentCtxt ); }; void node_async_handle::SemanticAnalysis( SEM_ANALYSIS_CTXT* ) { } BOOL IsOLEAutomationType( char* szTypeName ) { BOOL fRet = FALSE; // keep this list sorted! static char* szOLEAutomationTypes[] = { "BSTR", // wchar_t "CURRENCY", // struct "DATE", // double "SCODE", // long "VARIANT", "VARIANT_BOOL", }; int uFirst = 0; int uLast = (sizeof(szOLEAutomationTypes) - 1) / sizeof(char*); int uMid = (uFirst + uLast) / 2; while (uLast >= uFirst && uLast >= 0 && uFirst <= (sizeof(szOLEAutomationTypes) - 1) / sizeof(char*)) { int nCmp = strcmp(szOLEAutomationTypes[uMid], szTypeName); if (nCmp == 0) { fRet = TRUE; break; } else if (nCmp > 0) { uLast = uMid - 1; } else { uFirst = uMid + 1; } uMid = (uFirst + uLast) / 2; } return fRet; } BOOL IsBasicOleAutoKind( NODE_T x) { // NODE_INT128, NODE_FLOAT80, NODE_FLOAT128 is not supported. return ( (x) == NODE_DOUBLE || (x) == NODE_FLOAT || (x) == NODE_INT || (x) == NODE_SHORT || (x) == NODE_LONG || (x) == NODE_CHAR || (x) == NODE_INT32 || (x) == NODE_HYPER || (x) == NODE_INT64 || (x) == NODE_INT3264 || (x) == NODE_BOOLEAN || (x) == NODE_WCHAR_T ); } BOOL IsOLEAutoBasicType ( node_base_type* pNBT ) { NODE_T nodeKind = pNBT->NodeKind(); if ( nodeKind == NODE_CHAR ) { return ( (node_base_type*) pNBT )->IsUnsigned(); } else { return TRUE; } } BOOL IsOLEAutoInterface ( node_interface* pType ) { node_interface* pNodeIf; BOOL fRet = FALSE; // pType may be a node_interface or a node_interaface_reference // "normalize" it. if ( pType->NodeKind() == NODE_INTERFACE_REFERENCE ) { pNodeIf = (( node_interface_reference *) pType )->GetRealInterface(); } else { pNodeIf = pType; } fRet = pNodeIf->HasOLEAutomation(); if ( !fRet ) { // the interface is forward declared, // and has not been analyzed for semantic errors, // it does not have HasOleAutomation flag set. fRet = pNodeIf->FTATTRInSummary( TATTR_OLEAUTOMATION ) || pNodeIf->FTATTRInSummary( TATTR_DUAL ); if ( !fRet ) { // interface may be an IUnknown or an IDispatch and these do not // have HasOleAutomation flag set. fRet = pNodeIf->IsValidRootInterface(); if ( !fRet ) { // It is not IUnknown. If it is not IFont or IDispatch, it is not // an oleautomation compliant interface. char* szIfName = pNodeIf->GetSymName(); fRet = !_stricmp(szIfName, "IDispatch") || !_stricmp(szIfName, "IFontDisp"); } } } return fRet; } BOOL IsOLEAutomationCompliant( node_skl* pParamType ) { if ( pParamType == 0 ) { return FALSE; } BOOL fConforms = FALSE; NODE_T nKind = pParamType->NodeKind(); if ( nKind == NODE_SAFEARRAY || nKind == NODE_HREF || nKind == NODE_POINTER ) { fConforms = IsOLEAutomationCompliant( pParamType->GetChild() ); } else if ( IsInterfaceKind( nKind ) ) { fConforms = IsOLEAutoInterface( (node_interface*) pParamType ); } else if ( IsCoclassOrDispKind( nKind ) || nKind == NODE_ENUM || nKind == NODE_STRUCT || IsBasicOleAutoKind( nKind ) ) { fConforms = TRUE; } else if ( nKind == NODE_DEF ) { node_skl* pChild = pParamType->GetChild(); fConforms = IsOLEAutomationType( pParamType->GetSymName() ) ? TRUE : IsOLEAutomationCompliant( pChild ); } else if ( nKind == NODE_FORWARD ) { node_skl* pChild = ( (node_forward*) pParamType )->ResolveFDecl(); fConforms = ( pChild ) ? IsOLEAutomationCompliant( pChild ) : FALSE; } return fConforms; } bool HasCorrelation( node_skl* pNode ) { if ( pNode->FInSummary( ATTR_SIZE ) || pNode->FInSummary( ATTR_FIRST ) || pNode->FInSummary( ATTR_BYTE_COUNT ) || pNode->FInSummary( ATTR_LAST ) || pNode->FInSummary( ATTR_LENGTH ) || pNode->FInSummary( ATTR_MAX ) || pNode->FInSummary( ATTR_MIN ) || pNode->FInSummary( ATTR_SIZE ) || pNode->FInSummary( ATTR_IID_IS ) || pNode->FInSummary( ATTR_SWITCH_IS ) ) { return true; } return false; } bool node_skl::CheckContextHandle( SEM_ANALYSIS_CTXT& MyContext ) { bool fSerialize = MyContext.ExtractAttribute( ATTR_SERIALIZE ) != 0; bool fNoSerialize = MyContext.ExtractAttribute( ATTR_NOSERIALIZE ) != 0; bool fContextHandle = MyContext.ExtractAttribute( ATTR_CONTEXT ) != 0; // See if context_handle applied to param reached us if ( fContextHandle ) { // not allowed in DCE mode; context handle must be void * TypeSemError( this, MyContext, CONTEXT_HANDLE_VOID_PTR, 0 ); TypeSemError( this, MyContext, CTXT_HDL_NON_PTR, 0 ); } else { if ( fSerialize || fNoSerialize ) { SemError( this, MyContext, NO_CONTEXT_HANDLE, GetSymName() ); } } if ( fSerialize && fNoSerialize ) { SemError( this, MyContext, CONFLICTING_ATTRIBUTES, GetSymName() ); } return fContextHandle; } extern CMessageNumberList GlobalMainMessageNumberList; void node_midl_pragma::SemanticAnalysis( SEM_ANALYSIS_CTXT* ) { ProcessPragma(); } void node_midl_pragma::ProcessPragma() { LONG_PTR ulMsg = 0; m_pMsgList->Init(); while ( m_pMsgList->GetNext( (void**) &ulMsg ) == STATUS_OK ) { if ( m_PragmaType == mp_MessageDisable ) { GlobalMainMessageNumberList.ResetMessageFlag( (long)ulMsg ); } else { GlobalMainMessageNumberList.SetMessageFlag( (long)ulMsg ); } } } void node_decl_guid::SemanticAnalysis( SEM_ANALYSIS_CTXT* ) { }