archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/inetcore/mshtml/btools/pdlparse/parser.cxx

9190 lines
329 KiB
Raw Blame History

extern BOOL gbWin16Mode;
UINT CPDLParser::CountTags ( TokenDescriptor *tokdesc )
{
UINT uCount;
TagDescriptor *pTagDescriptor;
for ( uCount = 0, pTagDescriptor = tokdesc -> Tags ; pTagDescriptor -> szTag != NULL;
uCount++, pTagDescriptor++ );
return uCount;
}
CPDLParser::CPDLParser()
{
fpHComPlusFile = NULL;
fpCComPlusFile = NULL;
fpHDLFile = NULL;
fpHeaderFile = NULL;
fpIDLFile = NULL;
fpLOGFile = NULL;
fpHTMFile = NULL;
fpHTMIndexFile = NULL;
fpDISPIDFile = NULL;
fpMaxLenFile = NULL;
pRuntimeList = new CTokenList;
pDynamicTypeList = new CTokenList;
pDynamicEventTypeList = new CTokenList;
Init();
}
void
CPDLParser::SplitTag ( char *pStr, int nLen, char **pTag, int *pnTagLen,
char **pValue, int *pnValueLen )
{
*pTag = pStr;
for ( *pnTagLen = 0 ; *pnTagLen < nLen ; pStr++, (*pnTagLen)++ )
{
if ( *pStr == ':' )
{
*pValue = pStr + 1;
*pnValueLen = nLen - *pnTagLen -1;
return;
}
}
*pnValueLen = 0;
}
BOOL
CPDLParser::LookupToken ( LPCSTR pTokenName, int nTokenLen,
TokenDescriptor **ppTokenDescriptor, DESCRIPTOR_TYPE *pnTokenDes )
{
INT i;
for ( i = 0 ;
i < NUM_DESCRIPTOR_TYPES ; i++ )
{
if (strlen(AllDescriptors[i]->szTokenName) == (UINT)nTokenLen &&
!_strnicmp(AllDescriptors[i]->szTokenName, pTokenName, nTokenLen))
{
*ppTokenDescriptor = AllDescriptors [ i ];
*pnTokenDes = (DESCRIPTOR_TYPE)i;
return TRUE;
}
}
return FALSE;
}
BOOL CPDLParser::GetElem ( char **pStr,
char **pElem,
int *pnLen,
BOOL fBreakOnOpenParenthesis, /* = FALSE */
BOOL fBreakOnCloseParenthesis, /* = FALSE */
BOOL fBreakOnCommas /* = FALSE */ )
{
*pnLen = 0;
while ( isspace ( **pStr ) )
{
(*pStr)++;
}
*pElem = *pStr;
if (( fBreakOnOpenParenthesis && **pStr == ')' ) ||
( fBreakOnCloseParenthesis && **pStr == '(' ) ||
(fBreakOnCommas && **pStr == ',' ))
{
(*pnLen)++;
(*pStr)++;
goto Cleanup;
}
while ( **pStr && !isspace ( **pStr ))
{
if (( fBreakOnOpenParenthesis && **pStr == ')' ) ||
( fBreakOnCloseParenthesis && **pStr == '(' ) ||
(fBreakOnCommas && **pStr == ',' ))
{
// Break but leave the pStr pointing at the bracket - we'll pick it up in the
// next call
break;
}
// Convert curly braces to parens
if (**pStr == '{')
**pStr = '(';
else if (**pStr == '}')
**pStr = ')';
(*pnLen)++;
(*pStr)++;
}
Cleanup:
return *pnLen == 0 ? FALSE : TRUE;
}
BOOL CPDLParser::ParseInputFile ( BOOL fDebugging )
{
BOOL fReturn = TRUE;
DESCRIPTOR_TYPE nThisDescriptor;
char szLineBuffer [ MAX_LINE_LEN+1 ];
char szErrorText [ MAX_LINE_LEN+1 ];
char *pStr = szLineBuffer;
char *pElem; int nElemLen;
TokenDescriptor *pThisDescriptor;
Token *pNewToken;
Token *pParentToken = NULL;
BOOL fGotParentToken = FALSE;
CString szType;
fprintf ( fpLOGFile, "Parsing input file\n" );
for(;;)
{
if ( !GetStdInLine ( szLineBuffer, sizeof ( szLineBuffer ) ) )
break;
pStr = szLineBuffer;
fprintf ( fpLOGFile, "Read Line:%s\n", szLineBuffer );
// Get the type e..g. enum, eval etc.
if ( !GetElem ( &pStr, &pElem, &nElemLen ) )
{
// Couldn't get the name
fprintf ( fpLOGFile, "Skipping\n" );
continue;
}
if ( !LookupToken ( pElem, nElemLen, &pThisDescriptor, &nThisDescriptor ) )
{
fprintf ( fpLOGFile, "Unknown token\n" );
continue;
}
fprintf ( fpLOGFile, "Processing a %s declaration\n",
(LPCSTR)AllDescriptors [ nThisDescriptor ] -> szTokenName );
// If it's a child token and we haven't got a parent
if ( !pThisDescriptor->fIsParentToken &&
!fGotParentToken )
{
ReportError ( "Child Token Without Parent\n" );
goto error;
}
if ( pThisDescriptor->fIsParentToken )
{
fGotParentToken = TRUE;
}
INT nTag;
char *pTag; char *pValue;
int nTagLen; int nValueLen;
BOOL fVarArg = FALSE;
if ( nThisDescriptor == TYPE_METHOD )
{
// Look for optional vararg first
if ( !GetElem ( &pStr, &pElem, &nElemLen ) )
{
// Couldn't get the return type
continue;
}
if ( ! ( pNewToken = pParentToken -> AddChildToken ( nThisDescriptor ) ) )
{
ReportError ( "Memory Allocation Error\n" );
goto error;
}
if ( !pNewToken->TagValues.AddTag ( METHOD_RETURNTYPE, pElem, nElemLen ) )
{
ReportError ( "Memory Allocation Error\n" );
goto error;
}
// Name is next
if ( !GetElem ( &pStr, &pElem, &nElemLen ) )
{
// Couldn't get the name
continue;
}
if ( !pNewToken->TagValues.AddTag ( METHOD_NAME, pElem, nElemLen ) )
{
ReportError ( "Memory Allocation Error\n" );
goto error;
}
// Methods need special handling due to the parameter list
// Put all tokens before the "(" in the TagValues
// Treat each arg in the param list as a unique token and add
// to the pArgList for this token
// Put all the tokens after the ")" in the TagValues
// We allow either a comma-seperated arg list, but if we
// don't get commas we break the arg intelligently
//
UINT bInParams = FALSE;
BOOL bCreatedArgToken = FALSE;
Token *pCurrentToken;
TokenDescriptor *pDescriptor = pThisDescriptor;
pCurrentToken = pNewToken;
fVarArg = FALSE;
// Set the fBreakOnParenthesis Flag to make parenthis stop GetElem
while ( GetElem ( &pStr, &pElem, &nElemLen, TRUE, TRUE, TRUE ) )
{
if ( nElemLen == 1 && *pElem == '(' )
{
if ( bInParams )
{
sprintf ( szErrorText, "Syntax Error %s On %s\n", pStr, szLineBuffer );
ReportError ( szErrorText );
goto error;
}
bInParams = TRUE;
// Switch to method arg descriptor
pDescriptor = &MethodArgDescriptor;
}
else if ( nElemLen == 1 && *pElem == ')' )
{
if ( !bInParams )
{
sprintf ( szErrorText, "Syntax Error %s On %s\n", pStr, szLineBuffer );
ReportError ( szErrorText );
goto error;
}
bInParams = FALSE;
// Switch back to method descriptor
pDescriptor = pThisDescriptor;
pCurrentToken = pNewToken;
}
else if ( nElemLen == 1 && *pElem == ',' )
{
// Reset flag so new arg token gets created for next arg
bCreatedArgToken = FALSE;
}
else
{
// Split out the prefix:value
SplitTag ( pElem, nElemLen, &pTag, &nTagLen,
&pValue, &nValueLen );
// Match the tag
if ( !pDescriptor->LookupTagName ( pTag, nTagLen, &nTag ) )
{
pTag [ nTagLen ] = '\0';
sprintf ( szErrorText, "Unknown tag: %s On %s\n", pTag, szLineBuffer );
ReportError ( szErrorText );
goto error;
}
// If we've already got an entry for this tag, and we've seen
// at least the arg tag, start a new arg
if ( bInParams && pCurrentToken -> IsSet ( METHODARG_ARGNAME ) &&
( nTag == METHODARG_IN || nTag == METHODARG_OUT ) &&
( pCurrentToken -> IsSet ( METHODARG_IN ) ||
pCurrentToken -> IsSet ( METHODARG_IN ) ) )
{
// Start a new arg
bCreatedArgToken = FALSE;
}
if ( bInParams && bCreatedArgToken == FALSE )
{
// Create the arg list if needed
pCurrentToken = pNewToken -> AddChildToken ( TYPE_METHOD_ARG );
if ( pCurrentToken == NULL )
{
ReportError ( "Memory allocation error\n" );
goto error;
}
bCreatedArgToken = TRUE;
}
// Add the tag either to the main method token array or to the current
// arg 's array
if ( !pCurrentToken->TagValues.AddTag ( nTag, pValue, nValueLen ) )
{
ReportError ( "Memory allocation error\n" );
goto error;
}
// Last argument a SAFEARRAY, if so then vararg
fVarArg = (strncmp(pValue, "SAFEARRAY(VARIANT)", 18) == 0);
}
// method is a vararg because last parameter is a safearray.
if ( fVarArg && !pNewToken->TagValues.AddTag ( METHOD_VARARG, "vararg", 6 ) )
{
ReportError ( "Memory allocation error\n" );
goto error;
}
}
}
else if ( nThisDescriptor == TYPE_REFPROP || nThisDescriptor == TYPE_REFMETHOD )
{
// Now get the Class::Name & split it out
if ( !GetElem ( &pStr, &pElem, &nElemLen ) )
{
// Couldn't get the name
continue;
}
// Split out the prefix:value
SplitTag ( pElem, nElemLen, &pTag, &nTagLen,
&pValue, &nValueLen );
pNewToken = pParentToken -> AddChildToken ( nThisDescriptor );
if ( pNewToken == NULL )
{
ReportError ( "Memory Allocation Error\n" );
goto error;
}
if ( !pNewToken->TagValues.AddTag (
(nThisDescriptor == TYPE_REFPROP) ? (INT)REFPROP_CLASSNAME : (INT)REFMETHOD_CLASSNAME,
pTag, nTagLen ) )
{
ReportError ( "Memory Allocation Error\n" );
goto error;
}
if ( !pNewToken->TagValues.AddTag (
nThisDescriptor == TYPE_REFPROP ? (INT)REFPROP_PROPERTYNAME : (INT)REFMETHOD_METHODNAME,
pValue, nValueLen ) )
{
ReportError ( "Memory Allocation Error\n" );
goto error;
}
}
else
{
// Now get the name
if ( !GetElem ( &pStr, &pElem, &nElemLen ) )
{
// Couldn't get the name
continue;
}
// If it's a child token, add it to the runtime list, else add it as a child
// of the current parent
if ( pThisDescriptor->fIsParentToken )
{
pNewToken = pRuntimeList -> AddNewToken ( nThisDescriptor );
pParentToken = pNewToken;
}
else
{
pNewToken = pParentToken -> AddChildToken ( nThisDescriptor );
}
if ( pNewToken == NULL )
{
ReportError ( "Memory Allocation Error\n" );
goto error;
}
// First tag is always the name
if ( !pNewToken->TagValues.AddTag ( NAME_TAG, pElem, nElemLen ) )
{
ReportError ( "Memory Allocation Error\n" );
goto error;
}
// Split out all the token:value pairs
while ( GetElem ( &pStr, &pElem, &nElemLen ) )
{
// Split out the prefix:value
SplitTag ( pElem, nElemLen, &pTag, &nTagLen,
&pValue, &nValueLen );
// Match the tag
if ( !pThisDescriptor->LookupTagName ( pTag, nTagLen, &nTag ) )
{
pTag [ nTagLen ] = '\0';
sprintf ( szErrorText, "Unknown tag: %s On %s\n", pTag, szLineBuffer );
ReportError ( szErrorText );
goto error;
}
if ( !pNewToken->TagValues.AddTag ( nTag, pValue, nValueLen ) )
{
ReportError ( "Memory Allocation Error\n" );
goto error;
}
}
}
// Perform any cleanup
switch ( nThisDescriptor )
{
case TYPE_EVAL:
// For enums we calculate and store in the token the enum mask
// We also number the enum values sequentialy
pNewToken -> CalculateEnumMask ( pParentToken );
break;
case TYPE_ENUM:
// Add data types to the dynamic type array
szType = pNewToken -> GetTagValue ( ENUM_NAME );
AddType ( szType, "Enum" );
AddEventType ( szType, "VTS_I4" );
szType += "*";
AddEventType ( szType, "VTS_PI4" );
break;
case TYPE_CLASS:
case TYPE_INTERFACE:
case TYPE_EVENT:
szType = pNewToken -> GetTagValue ( NAME_TAG );
szType += "*";
AddType ( szType, "object" );
AddEventType ( szType, "VTS_DISPATCH" );
szType += "*";
AddType ( szType, "object" );
AddEventType ( szType, "VTS_DISPATCH" );
break;
}
}
// Add an IUnknown to make implicit ref's match up
pNewToken = pRuntimeList -> AddNewToken ( TYPE_INTERFACE );
pNewToken->TagValues.AddTag ( INTERFACE_NAME, "IUnknown", -1 );
// Add an IDispatch to make implicit ref's match up
pNewToken = pRuntimeList -> AddNewToken ( TYPE_INTERFACE );
pNewToken->TagValues.AddTag ( INTERFACE_NAME, "IDispatch", -1 );
pNewToken = pRuntimeList -> AddNewToken ( TYPE_EVENT );
pNewToken->TagValues.AddTag ( EVENT_NAME, "IDispatch", -1 );
// Patch up the refprops & refmethods
if ( !PatchInterfaceRefTypes() )
{
goto error;
}
// Patch Properties that are of object type
if ( !PatchPropertyTypes() )
{
goto error;
}
if ( !PatchInterfaces() )
{
goto error;
}
goto cleanup;
error:
fReturn = FALSE;
cleanup:
return fReturn;
}
BOOL CPDLParser::PatchInterfaceRefTypes ( void )
{
CTokenListWalker WholeTree ( pRuntimeList );
Token *pChildToken;
Token *pInterfaceToken;
CString szClassName;
// For each RefProp or Refmethod, we replace the arg list with a copy of the referenced property/method
// and change the type of the ref'd item appropriatly
while ( pInterfaceToken = WholeTree.GetNext( TYPE_INTERFACE ) )
{
CTokenListWalker ChildList ( pInterfaceToken );
while ( pChildToken = ChildList.GetNext() )
{
if ( pChildToken -> GetType() == TYPE_REFPROP )
{
szClassName = pChildToken -> GetTagValue ( REFPROP_CLASSNAME );
if ( !CloneToken ( pChildToken, TYPE_PROPERTY,
REFPROP_CLASSNAME, REFPROP_PROPERTYNAME ) )
{
char szErrorText [ MAX_LINE_LEN+1 ];
sprintf ( szErrorText, "Interface %s Invalid RefProp %s:%s\n" ,
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ),
pChildToken -> GetTagValue ( REFPROP_CLASSNAME ),
pChildToken -> GetTagValue ( REFPROP_PROPERTYNAME ) );
ReportError ( szErrorText );
return FALSE;
}
// Remember the class that was refprop'd.
pChildToken -> AddTag ( PROPERTY_REFDTOCLASS, (LPCSTR)szClassName );
}
else if ( pChildToken -> GetType() == TYPE_REFMETHOD )
{
szClassName = pChildToken -> GetTagValue ( REFMETHOD_CLASSNAME );
if ( !CloneToken ( pChildToken, TYPE_METHOD,
REFMETHOD_CLASSNAME, REFMETHOD_METHODNAME ) )
{
char szErrorText [ MAX_LINE_LEN+1 ];
sprintf ( szErrorText, "Interface %s Invalid RefMethod %s:%s\n" ,
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ),
pChildToken -> GetTagValue ( REFMETHOD_CLASSNAME ),
pChildToken -> GetTagValue ( REFMETHOD_METHODNAME ) );
ReportError ( szErrorText );
return FALSE;
}
// Remember the class that was refprop'd.
pChildToken -> AddTag ( METHOD_REFDTOCLASS, (LPCSTR)szClassName );
}
}
}
return TRUE;
}
BOOL CPDLParser::CloneToken ( Token *pChildToken, DESCRIPTOR_TYPE Type, INT nClassName, INT nTagName )
{
CTokenListWalker SubTree ( pRuntimeList );
Token *pRefdClassToken;
Token *pRefdChild;
pRefdClassToken = SubTree.GetNext( TYPE_CLASS, pChildToken -> GetTagValue ( nClassName ) );
if ( pRefdClassToken == NULL )
{
// Couldn't find the refd class
return FALSE;
}
// Found the refd class, find the refd property
CTokenListWalker RefdChildList ( pRefdClassToken );
pRefdChild = RefdChildList.GetNext ( Type,
pChildToken -> GetTagValue ( nTagName ) );
if ( pRefdChild == NULL )
{
// Couldn't find the refd property
return FALSE;
}
else
{
pChildToken -> Clone ( pRefdChild );
}
return TRUE;
}
BOOL CPDLParser::GetTypeDetails ( char *szTypeName, CString& szHandler, CString &szFnPrefix,
StorageType *pStorageType /* = NULL */ )
{
if ( !LookupType ( szTypeName, szHandler, szFnPrefix, pStorageType ) )
return FALSE;
return TRUE;
}
BOOL CPDLParser::IsSpecialProperty(Token *pClassToken)
{
CString szInterf;
Token *pInterf;
szInterf = pClassToken->GetTagValue(CLASS_INTERFACE);
pInterf = FindInterface(szInterf);
if (pInterf)
return (PrimaryTearoff(pInterf) || pInterf->IsSet(INTERFACE_ABSTRACT));
else
return TRUE;
}
BOOL CPDLParser::GeneratePropMethodImplementation ( void )
{
Token *pClassToken;
Token *pChildToken;
CString szFnPrefix;
CString szHandler;
CString szOffsetOf;
CString szAType;
CString szHandlerArgs;
char szErrorText [ MAX_LINE_LEN+1 ];
// Only generate def's for this file
CTokenListWalker TokenList ( pRuntimeList, _pszPDLFileName );
// Generate propdescs for every property token in every class ( in this file )
while ( pClassToken = TokenList.GetNext( TYPE_CLASS ) )
{
if (!IsSpecialProperty(pClassToken))
{
fprintf ( fpHDLFile, "\n// Property get/set method implementation for class %s\n", (LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ) );
fprintf ( fpHDLFile, "\n" );
CTokenListWalker ChildList ( pClassToken );
while ( pChildToken = ChildList.GetNext() )
{
if ( pChildToken->nType == TYPE_METHOD ||
pChildToken->nType == TYPE_IMPLEMENTS ||
pChildToken -> IsSet ( PROPERTY_ABSTRACT ) ||
pChildToken -> IsSet ( PROPERTY_BASEIMPLEMENTATION ) )
{
continue;
}
// If propdesc for nameOnly then we wont need a handler for this property
// another property that matches this will do the handling.
if ( _stricmp(pChildToken->GetTagValue(PROPERTY_NOPROPDESC), "nameonly") == 0 )
continue;
if ( !GetTypeDetails ( pChildToken->GetTagValue ( PROPERTY_TYPE ),
szHandler, szFnPrefix ) )
{
sprintf ( szErrorText ,"Invalid Type:%s in Class:%s Property:%s\n",
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_TYPE ),
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
if ( pChildToken -> IsSet ( PROPERTY_CAA ) )
{
szOffsetOf = "(GetAttrArray())";
}
else
{
szOffsetOf = "(this)";
}
szAType = pChildToken->GetTagValue ( PROPERTY_ATYPE );
// Generate set implementation
if ( pChildToken -> IsSet ( PROPERTY_SET ) )
{
szHandlerArgs = "HANDLEPROP_SET | HANDLEPROP_AUTOMATION | (PROPTYPE_VARIANT << 16)";
GenerateMethodImp ( pClassToken, pChildToken, TRUE,
szHandler, szHandlerArgs, szOffsetOf, szAType );
}
// Generate Get implementation
if ( pChildToken -> IsSet ( PROPERTY_GET ) )
{
szHandlerArgs = "HANDLEPROP_AUTOMATION | (PROPTYPE_VARIANT << 16)";
GenerateMethodImp ( pClassToken, pChildToken, FALSE,
szHandler, szHandlerArgs, szOffsetOf, szAType );
}
}
}
fprintf ( fpHDLFile, "\n" );
// Whip thru all tearoffs.
Token *pLastTearoff = NULL;
BOOL fMostDerivedOnly;
while ((pLastTearoff = NextTearoff((LPCSTR)pClassToken->GetTagValue(CLASS_NAME), pLastTearoff)))
{
LPSTR szInterface = (LPSTR)pLastTearoff->GetTagValue(TEAROFF_INTERFACE);
// If the tearoff is the primary interface of the coclass then we'll
// not stack the derived interfaces but generate separate
fMostDerivedOnly = (_stricmp(szInterface, (LPSTR)pClassToken->GetTagValue(CLASS_INTERFACE)) == 0 &&
_stricmp(szInterface, "IHTMLDocument2"));
if ( !GenerateTearoffTable(pClassToken, pLastTearoff, szInterface, fMostDerivedOnly))
return FALSE;
}
}
return TRUE;
}
BOOL CPDLParser::FindTearoffMethod(Token *pTearoff, LPCSTR pszTearoffMethod, LPSTR pszUseTearoff)
{
Token *pChildToken;
CTokenListWalker ChildList(pTearoff);
while (pChildToken = ChildList.GetNext())
{
if (pChildToken->GetType() == TYPE_TEAROFFMETHOD)
{
if (strcmp((LPCSTR)pChildToken->GetTagValue(TEAROFFMETHOD_NAME),
pszTearoffMethod) == 0)
{
// Check if there is a class name in the method, if it is then
// extract it explicity.
strcpy(pszUseTearoff, (LPCSTR)pChildToken->GetTagValue(TEAROFFMETHOD_MAPTO));
return TRUE;
}
}
}
// Call the super:: implementation except for the primary tearoff the base
// implementation of each method if not specified is the current class.
strcpy(pszUseTearoff, pTearoff->IsSet(TEAROFF_BASEIMPL) ?
(LPCSTR)pTearoff->GetTagValue(TEAROFF_BASEIMPL) : "");
strcat(pszUseTearoff, pszTearoffMethod);
return FALSE;
}
// We exploit the Linker's Case insensitive feature to do Tearoffs in Win16.
// This function takes a Tearoff Method and generates a name that is different
// in case from the Real Tearoff Method. We have to follow certain rules so that
// the compiler doesn't complain about undefined symbols and the linker puts in
// the correct address anyhow.
void GenerateWin16TearoffName(LPSTR szWin16Name, LPSTR pszTearoffMethod, LPSTR szClassName = NULL)
{
strcpy(szWin16Name, pszTearoffMethod);
// if the Tearoff has a put_ or get_ prefix then we capitalize the PUT_
// or GET_
if ( !strncmp(szWin16Name, "put_", 4) )
{
strncpy(szWin16Name, "PUT_", 4);
return;
}
if ( !strncmp(szWin16Name, "get_", 4) )
{
strncpy(szWin16Name, "GET_", 4);
return;
}
// Check if there is a class name in the method, if it is super
// then let it be else extract that and copy it to szClassName.
char *p = strstr(szWin16Name, "::");
if ( p && strncmp(szWin16Name, "super::",7) )
{
strcpy(pszTearoffMethod, p+2);
if ( szClassName )
{
*p = '\0';
strcpy(szClassName, szWin16Name);
}
strcpy(szWin16Name, pszTearoffMethod);
}
// lower case the name.
_strlwr(szWin16Name);
// make sure the generated name is different from the original one.
if ( !strcmp( pszTearoffMethod, szWin16Name) )
{
char *p = strstr(szWin16Name, "::");
// Ok, the Method name is all lower case, so we upper case the
// name after the First char. We also need to skip past the Class Name
// if any. Upper casing the whole name gave some other problems.
if ( p != NULL )
_strupr(p+2);
else
_strupr(szWin16Name+1);
}
}
BOOL CPDLParser::GenerateTearoffTable ( Token *pClassToken, Token *pTearoff, LPCSTR pszInterface, BOOL fMostDerived )
{
fprintf ( fpHDLFile, "// Tear-off table for class %s\n",
pClassToken -> GetTagValue ( CLASS_NAME ) );
if (IsSpecialTearoff(pTearoff))
{
fprintf ( fpHDLFile, "BEGIN_TEAROFF_TABLE_PROPDESC(%s, %s)\n",
pClassToken -> GetTagValue ( CLASS_NAME ),
pszInterface );
}
else
{
fprintf ( fpHDLFile, "BEGIN_TEAROFF_TABLE(%s, %s)\n",
pClassToken -> GetTagValue ( CLASS_NAME ),
pszInterface );
}
// Walk the interface heirarchy, starting at this classes primary
// interface, generate a fn table for each interface encountered
// started with IDispatch methods above. Generate methods in interface order - deepest
// first
if ( !GenerateTearOffMethods ( pClassToken -> GetTagValue ( CLASS_NAME ), pTearoff, pszInterface, fMostDerived) )
return FALSE;
fprintf ( fpHDLFile, "END_TEAROFF_TABLE()\n\n" );
return TRUE;
}
Token *CPDLParser::GetSuperClassTokenPtr ( Token *pClassToken )
{
Token *pSuperToken = NULL;
if ( pClassToken -> IsSet ( CLASS_SUPER ) )
{
CTokenListWalker WholeList ( pRuntimeList );
pSuperToken = WholeList.GetNext ( TYPE_CLASS,
pClassToken -> GetTagValue ( CLASS_SUPER ) );
}
return pSuperToken;
}
BOOL CPDLParser::HasClassGotProperties ( Token *pClassToken )
{
Token *pSuperClass;
CTokenListWalker PropList ( pClassToken );
if ( PropList.GetNext ( TYPE_PROPERTY ) )
return TRUE;
else
{
pSuperClass = GetSuperClassTokenPtr ( pClassToken );
if ( pSuperClass )
return HasClassGotProperties ( pSuperClass );
else
return FALSE;
}
}
BOOL CPDLParser::PrimaryTearoff (Token *pInterface)
{
return !pInterface->IsSet(INTERFACE_NOPRIMARYTEAROFF);
}
Token * CPDLParser::NextTearoff (LPCSTR szClassname, Token *pLastTearoff /*= NULL*/)
{
CTokenListWalker ThisFilesList(pRuntimeList, _pszPDLFileName);
Token *pTearoffToken;
BOOL fNextOne = FALSE;
while (pTearoffToken = ThisFilesList.GetNext(TYPE_TEAROFF))
{
if (_stricmp(szClassname, (LPSTR)pTearoffToken->GetTagValue(TEAROFF_NAME)) == 0)
{
// The correct class.
if (pLastTearoff)
{
// Return this one.
if (!fNextOne)
{
fNextOne = pLastTearoff == pTearoffToken;
continue; // Get the next and then stop.
}
}
break;
}
}
return pTearoffToken;
}
Token* CPDLParser::FindTearoff (LPCSTR szClassname, LPCSTR szInterface)
{
Token *pLastTearoff = NULL;
while (pLastTearoff = NextTearoff(szClassname, pLastTearoff))
{
if (!_stricmp(szInterface, (LPSTR)pLastTearoff->GetTagValue(TEAROFF_INTERFACE)))
{
break;
}
}
return pLastTearoff;
}
BOOL CPDLParser::GenerateClassIncludes (void)
{
Token *pClassToken;
CTokenListWalker ThisFilesList(pRuntimeList, _pszPDLFileName);
// Walk the class statments for this file only
fprintf(fpLOGFile, "*** Looking for \"%s\"\n",_pszPDLFileName);
while (pClassToken = ThisFilesList.GetNext(TYPE_CLASS))
{
LPCSTR szClassname = (LPCSTR)pClassToken->GetTagValue(CLASS_NAME);
fprintf(fpHDLFile, "#ifdef _%s_\n\n", szClassname);
// Write out inline cached get helpers
fprintf(fpHDLFile,
"\n// Cascaded Property get method prototypes for class %s\n\npublic:\n",
szClassname);
GenerateGetAAXPrototypes(pClassToken);
fprintf(fpHDLFile,
"\n// Property get/set method declarations for class %s\n",
szClassname);
// Always add a propdesc declaration for non-abstract classes, remember
// abstract class haven't got a propertydesc array.
// TODO: TerryLu - Need to add code here to handle the shared keyword
if ((!pClassToken->IsSet(CLASS_ABSTRACT)) ||
(_stricmp(pClassToken->GetTagValue(CLASS_NAME), "CElement") == 0))
{
if(_stricmp(pClassToken->GetTagValue(CLASS_NAME), "CElement") != 0)
{
fprintf(fpHDLFile,
" static const HDLDESC %s::s_apHdlDescs;\n",
szClassname);
}
fprintf(fpHDLFile,
" static const CAssocVTable * const s_AssocVTablePtr[];\n");
fprintf(fpHDLFile,
" static const CAssocArrayVTable s_StringTable;\n");
fprintf(fpHDLFile,
" static const CPtrBagVTableAggregate s_StringTableAggregate;\n");
if(_stricmp(pClassToken->GetTagValue(CLASS_NAME), "COmWindowProxy") == 0)
{
fprintf(fpHDLFile, "static const VTABLEDESC * const COmWindowProxy::s_COmWindowProxyDocument;\n");
}
}
CString szInterface;
Token *pInterface;
BOOL fOk;
Token *pTearoff = NULL;
while ((pTearoff = NextTearoff(szClassname, pTearoff)))
{
szInterface = pTearoff->GetTagValue(TEAROFF_INTERFACE);
pInterface = FindInterface(szInterface);
if (pInterface)
{
CTokenListWalker ChildList(pInterface);
Token *pChildToken = ChildList.GetNext();
if (pChildToken)
{
fOk = FALSE;
do
{
if (pChildToken->GetType() == TYPE_PROPERTY && !pChildToken->IsSet(PROPERTY_ABSTRACT) && !pChildToken->IsSet(PROPERTY_BASEIMPLEMENTATION))
{
fOk = TRUE;
break;
}
} while (pChildToken = ChildList.GetNext());
if (fOk)
{
fprintf(fpHDLFile, " static const PROPERTYDESC * const %s::s_ppropdescsInVtblOrder%s [];\n",
szClassname, (LPSTR)pTearoff->GetTagValue(TEAROFF_INTERFACE));
}
}
}
}
// Generate a CPC if, we have an eventset && it is unique to us
if ( IsUniqueCPC ( pClassToken ) )
{
fprintf(fpHDLFile,
" static const CONNECTION_POINT_INFO %s::s_acpi[];\n",
szClassname);
}
GeneratePropMethodDecl(pClassToken);
if (pClassToken->IsSet(CLASS_EVENTS))
{
if (!GenerateEventFireDecl(pClassToken))
{
return FALSE;
}
}
// Whip thru all tearoffs.
Token *pLastTearoff = NULL;
while ((pLastTearoff = NextTearoff(szClassname, pLastTearoff)))
{
// Need static tearoff table decl
if (IsSpecialTearoff(pLastTearoff))
{
fprintf(fpHDLFile, " DECLARE_TEAROFF_TABLE_PROPDESC(%s)\n",
pLastTearoff->GetTagValue(TEAROFF_INTERFACE));
}
else
{
fprintf(fpHDLFile, " DECLARE_TEAROFF_TABLE(%s)\n",
pLastTearoff->GetTagValue(TEAROFF_INTERFACE));
}
}
GenerateThunkContext(pClassToken);
fprintf(fpHDLFile, "\n#endif // _%s_\n\n", szClassname);
fprintf(fpHDLFile, "#undef _%s_\n\n", szClassname);
}
return TRUE;
}
// Work out if this class has a unique connection point info structure -
// or can we use its super ??
BOOL CPDLParser::IsUniqueCPC ( Token *pClassToken )
{
BOOL fDoIt = FALSE;
Token *pClass;
CString szSuperClass, szThisEvents, szThatEvents;
if ( !pClassToken->IsSet(CLASS_NOCPC) && pClassToken->IsSet ( CLASS_EVENTS ) )
{
szThisEvents = pClassToken->GetTagValue(CLASS_EVENTS);
fDoIt = TRUE;
for ( pClass = pClassToken ; pClass ; )
{
if ( pClass->IsSet ( CLASS_SUPER ) )
{
szSuperClass = pClass -> GetTagValue ( CLASS_SUPER );
pClass = FindClass ( szSuperClass );
if ( pClass && pClass->IsSet ( CLASS_EVENTS ) && !pClass->IsSet(CLASS_NOCPC) )
{
szThatEvents = pClass->GetTagValue(CLASS_EVENTS);
if ( szThatEvents == szThisEvents )
{
// Do we have non-primary events #1 and is the super non-primary events
// the same as ours? If not, then we are unique.
if (pClassToken->IsSet(CLASS_NONPRIMARYEVENTS1))
{
szThisEvents = pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS1);
szThatEvents = pClass->GetTagValue(CLASS_NONPRIMARYEVENTS1);
if (szThatEvents != szThisEvents)
{
// We're unique.
break;
}
// Do we have non-primary events #2 and is the super non-primary events
// the same as ours? If not, then we are unique.
if (pClassToken->IsSet(CLASS_NONPRIMARYEVENTS2))
{
szThisEvents = pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS2);
szThatEvents = pClass->GetTagValue(CLASS_NONPRIMARYEVENTS2);
if (szThatEvents != szThisEvents)
{
// We're unique.
break;
}
// Do we have non-primary events #3 and is the super non-primary events
// the same as ours? If not, then we are unique.
if (pClassToken->IsSet(CLASS_NONPRIMARYEVENTS3))
{
szThisEvents = pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS3);
szThatEvents = pClass->GetTagValue(CLASS_NONPRIMARYEVENTS3);
if (szThatEvents != szThisEvents)
{
// We're unique.
break;
}
// Do we have non-primary events #4 and is the super non-primary events
// the same as ours? If not, then we are unique.
if (pClassToken->IsSet(CLASS_NONPRIMARYEVENTS4))
{
szThisEvents = pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS4);
szThatEvents = pClass->GetTagValue(CLASS_NONPRIMARYEVENTS4);
if (szThatEvents != szThisEvents)
{
// We're unique.
break;
}
}
}
}
// else fall through to below which set's fDoIt to FALSE.
}
fDoIt = FALSE;
break;
}
break;
}
}
else
break;
}
}
return fDoIt;
}
BOOL CPDLParser::GenerateEventFireDecl ( Token *pClassToken )
{
Token *pEventToken;
fprintf ( fpHDLFile, "// Event fire method declarations for events %s\n",
pClassToken -> GetTagValue ( CLASS_EVENTS ) );
// Find the event declaration
CTokenListWalker WholeList ( pRuntimeList ) ;
pEventToken = WholeList.GetNext ( TYPE_EVENT, pClassToken -> GetTagValue ( CLASS_EVENTS ) );
if ( pEventToken == NULL )
{
return FALSE;
}
return GenerateEventDecl ( pClassToken, pEventToken );
}
BOOL CPDLParser::IsElementEvent(Token *pEventInterface)
{
CTokenListWalker WholeList(pRuntimeList);
CString szEvent;
CString szElementEvent;
if (!pEventInterface)
return FALSE;
szEvent = pEventInterface->GetTagValue(EVENT_NAME);
if (_stricmp((LPCSTR)szEvent, "HTMLObjectElementEvents") == 0)
return TRUE;
szElementEvent = "HTMLElementEvents";
while (pEventInterface)
{
if (szElementEvent == szEvent)
return TRUE;
szEvent = pEventInterface->GetTagValue(EVENT_SUPER);
WholeList.Reset();
pEventInterface = WholeList.GetNext(TYPE_EVENT, szEvent);
}
return FALSE;
}
BOOL CPDLParser::GenerateEventDecl ( Token *pClassToken, Token *pEventToken )
{
/* TLL: Don't spit out any arguments. Currently the only argument for event is eventObject which is computed
Token *pArgToken;
*/
Token *pChildToken;
char szErrorText [ MAX_LINE_LEN+1 ];
CTokenListWalker ChildList ( pEventToken );
CString szNameUpper;
CString szNameLower;
BOOL fDocEvents = (_stricmp(pClassToken->GetTagValue(CLASS_EVENTS), "HTMLDocumentEvents") == 0) ||
(_stricmp(pClassToken->GetTagValue(CLASS_EVENTS), "HTMLProtectedElementEvents") == 0) ||
(_stricmp(pClassToken->GetTagValue(CLASS_EVENTS), "HTMLNamespaceEvents") == 0);
BOOL fWindowEvents = _stricmp(pClassToken->GetTagValue(CLASS_EVENTS), "HTMLWindowEvents") == 0;
BOOL fElementEvents = !fDocEvents && !fWindowEvents && IsElementEvent(pEventToken);
while ( pChildToken = ChildList.GetNext() )
{
if (!fElementEvents && !fDocEvents && !fWindowEvents &&
(_stricmp(pClassToken->GetTagValue(CLASS_EVENTS), "DWebBridgeEvents") != 0))
{
sprintf ( szErrorText, "Need to modify GenerateEventDecl() in parser.cpp to pass in Doc ptr to FireEvent for class:%s\n",
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME) );
ReportError ( szErrorText );
return FALSE;
}
if ( pChildToken -> GetType() == TYPE_METHOD &&
!pChildToken -> IsSet ( METHOD_ABSTRACT ) )
{
szNameUpper = pChildToken -> GetTagValue ( METHOD_NAME );
szNameLower = szNameUpper;
szNameUpper.ToUpper();
if (!FindEventProp(pClassToken, (LPCSTR)szNameLower))
continue;
// Method
fprintf ( fpHDLFile, " %s Fire_%s(",
pChildToken->IsSet(METHOD_CANCELABLE) ? "BOOL" : "void",
pChildToken -> GetTagValue ( METHOD_NAME ) );
CTokenListWalker ArgListWalker ( pChildToken );
BOOL fFirst = TRUE;
/* TLL: Don't spit out any arguments. Currently the only argument for event is eventObject which is computed
while ( pArgToken = ArgListWalker.GetNext() )
{
if ( !fFirst )
fprintf ( fpHDLFile, "," );
fprintf ( fpHDLFile, "%s %s",
(LPCSTR)pArgToken -> GetTagValue ( METHODARG_TYPE ),
(LPCSTR)pArgToken -> GetTagValue ( METHODARG_ARGNAME ));
fFirst = FALSE;
}
*/
if ( pChildToken->IsSet(METHOD_BUBBLING) )
{
if ( !fFirst )
fprintf ( fpHDLFile, "," );
fprintf ( fpHDLFile, "CTreeNode * pNodeContext = NULL");
fprintf ( fpHDLFile, ", long lSubDivision = -1");
}
fprintf ( fpHDLFile, ")\n {\n " );
if ( pChildToken->IsSet(METHOD_CANCELABLE) )
{
fprintf ( fpHDLFile, "return !!" );
}
if (fElementEvents)
{
fprintf(fpHDLFile, "FireEvent(&s_propdesc%s%s%s",
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME),
(LPCSTR)szNameLower,
pChildToken->IsSet(METHOD_BUBBLING) ? ", TRUE, pNodeContext, lSubDivision" : "");
}
else
{
fprintf(fpHDLFile, "FireEvent(%sDISPID_EVMETH_%s, DISPID_EVPROP_%s, _T(\"%s\")",
fDocEvents ? "Doc(), " : (fWindowEvents ? "_pDoc, " : ""),
(LPCSTR)szNameUpper,
(LPCSTR)szNameUpper,
(LPCSTR)szNameLower+2);
}
/* TLL: Don't spit out any arguments. Currently the only argument for event is eventObject which is computed
ArgListWalker.Reset();
if ( ArgListWalker.GetTokenCount() > 0 )
{
while ( pArgToken = ArgListWalker.GetNext() )
{
// Locate the vts type for this type
CString szVTSType;
if ( !LookupEventType ( szVTSType, pArgToken -> GetTagValue ( METHODARG_TYPE ) ) )
{
sprintf ( szErrorText, "Unknown Type %s in %s::Fire%s event declaration\n",
(LPCSTR) pArgToken -> GetTagValue ( METHODARG_TYPE ),
pEventToken -> GetTagValue ( EVENT_NAME ),
pChildToken -> GetTagValue ( METHOD_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
fprintf ( fpHDLFile, " %s", (LPCSTR)szVTSType );
fFirst = FALSE;
}
ArgListWalker.Reset();
while ( pArgToken = ArgListWalker.GetNext() )
{
fprintf ( fpHDLFile, ", %s",
pArgToken -> GetTagValue ( METHODARG_ARGNAME ) );
}
}
else
{
fprintf ( fpHDLFile, " VTS_NONE" );
}
*/
fprintf ( fpHDLFile, ");\n }\n" );
}
else if ( pChildToken -> GetType() == TYPE_PROPERTY )
{
// Property in event set - should never happen if we
// check the child/parent relationships at parse time
sprintf ( szErrorText, "events %s - invalid to have a property in event set\n",
(LPCSTR)pClassToken -> GetTagValue ( EVENT_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
}
return TRUE;
}
LPCSTR CPDLParser::ConvertType(LPCSTR szType, BOOL fComPlus /* = FALSE*/, LPSTR pCPString /* = 0*/, BOOL *pfInterfaceFound /* = 0*/)
{
if (!fComPlus)
{
if (_stricmp(szType, "SAFEARRAY(VARIANT)") == 0)
return("SAFEARRAY*");
else
return(szType);
}
else
{
BOOL fInterfFound;
if (!pfInterfaceFound)
{
pfInterfaceFound = &fInterfFound;
}
*pfInterfaceFound = FALSE;
if (_stricmp(szType, "BSTR") == 0)
return("String");
else if (_stricmp(szType, "VARIANT_BOOL") == 0)
return("Boolean");
else if (_stricmp(szType, "VARIANT") == 0)
return("Variant");
else if (_stricmp(szType, "IDispatch") == 0 || _stricmp(szType, "IUnknown") == 0)
return("Object");
else if (_stricmp(szType, "SAFEARRAY(VARIANT)") == 0)
return("String"); // ***TLL*** COM+: Need to make it a safearray
else if (pCPString)
{
CString pInterf;
pInterf = szType;
if (FindInterface(pInterf))
{
strcpy(pCPString, szType);
strcat(pCPString, "COMPLUS");
*pfInterfaceFound = TRUE;
return 0;
}
else
{
return(szType);
}
}
else
return(szType);
}
}
void CPDLParser::GeneratePropMethodDecl ( Token *pClassToken )
{
CTokenListWalker ChildList ( pClassToken );
CString szProp;
Token *pArgToken;
Token *pChildToken;
char szContextThunk[] = "ContextThunk_";
LPCSTR pCtxt;
while ( pChildToken = ChildList.GetNext() )
{
char szTemp[256];
LPSTR pMethodName;
BOOL fNameOnly;
fNameOnly = _stricmp(pChildToken->GetTagValue(METHOD_NOPROPDESC), "nameonly") == 0;
if ( pChildToken -> GetType() == TYPE_METHOD && !fNameOnly )
{
// Method
fprintf ( fpHDLFile, " " );
if ( pChildToken -> IsSet ( METHOD_VIRTUAL ) )
{
//fprintf ( fpHDLFile, "virtual " );
fprintf ( fpHDLFile, "DECLARE_TEAROFF_METHOD_(" );
}
else
fprintf ( fpHDLFile, "NV_DECLARE_TEAROFF_METHOD_(" );
pMethodName = pChildToken->IsSet(METHOD_SZINTERFACEEXPOSE) ?
(LPSTR)pChildToken->GetTagValue(METHOD_SZINTERFACEEXPOSE) :
(LPSTR)pChildToken->GetTagValue(METHOD_NAME);
GenerateWin16TearoffName(szTemp, pMethodName);
pCtxt = pChildToken->IsSet(METHOD_THUNKCONTEXT) ||
pChildToken->IsSet(METHOD_THUNKNODECONTEXT)
? szContextThunk : "";
//fprintf ( fpHDLFile, "%s STDMETHODCALLTYPE %s(",
fprintf ( fpHDLFile, "%s, %s%s, %s, (",
pChildToken -> GetTagValue ( METHOD_RETURNTYPE ),
pCtxt, pMethodName, szTemp );
CTokenListWalker ArgListWalker ( pChildToken );
BOOL fFirst = TRUE;
while ( pArgToken = ArgListWalker.GetNext() )
{
if ( !fFirst )
fprintf ( fpHDLFile, "," );
fprintf ( fpHDLFile, "%s %s",
ConvertType((LPCSTR)pArgToken -> GetTagValue ( METHODARG_TYPE )),
(LPCSTR)pArgToken -> GetTagValue ( METHODARG_ARGNAME ) );
fFirst = FALSE;
}
fprintf ( fpHDLFile, "));\n" );
}
else
{
fNameOnly = _stricmp(pChildToken->GetTagValue(PROPERTY_NOPROPDESC), "nameonly") == 0;
// Base has provided prototoype
if ( pChildToken -> IsSet ( PROPERTY_BASEIMPLEMENTATION )
|| (!pChildToken->IsSet(PROPERTY_ABSTRACT) && IsSpecialProperty(pClassToken))
)
{
continue;
}
// Property
szProp = "";
// Through the index/indextype & index1/indextype1 pdl tags
// you can provide up to two additional args for the property definition
if ( pChildToken -> IsSet ( PROPERTY_INDEX ) )
{
szProp += pChildToken -> GetTagValue ( PROPERTY_INDEXTYPE );
szProp += " ";
szProp += pChildToken -> GetTagValue ( PROPERTY_INDEX );
}
if ( pChildToken -> IsSet ( PROPERTY_INDEX1 ) )
{
if ( szProp [ 0 ] != '\0' )
szProp += ",";
szProp += pChildToken -> GetTagValue ( PROPERTY_INDEXTYPE1 );
szProp += " ";
szProp += pChildToken -> GetTagValue ( PROPERTY_INDEX1 );
}
if ( szProp [ 0 ] != '\0' )
szProp += ",";
pMethodName = pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pChildToken->GetTagValue(PROPERTY_NAME);
pCtxt = pChildToken->IsSet(PROPERTY_THUNKCONTEXT) ||
pChildToken->IsSet(PROPERTY_THUNKNODECONTEXT)
? szContextThunk : "";
if ( pChildToken -> IsSet ( PROPERTY_SET ) && !fNameOnly )
{
fprintf ( fpHDLFile, " " );
if ( pChildToken -> IsSet ( PROPERTY_VIRTUAL ) )
{
fprintf ( fpHDLFile, "DECLARE_TEAROFF_METHOD(%sput_%s, PUT_%s, (%s%s v));\n",
pCtxt,
pMethodName,
pMethodName,
(LPCSTR)szProp,
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_ATYPE ));
}
else
{
fprintf ( fpHDLFile, "NV_DECLARE_TEAROFF_METHOD(%sput_%s, PUT_%s, (%s%s v));\n",
pCtxt,
pMethodName,
pMethodName,
(LPCSTR)szProp,
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_ATYPE ));
}
}
if ( pChildToken -> IsSet ( PROPERTY_GET ) && !fNameOnly)
{
fprintf ( fpHDLFile, " " );
if ( pChildToken -> IsSet ( PROPERTY_VIRTUAL ) )
{
fprintf ( fpHDLFile, "DECLARE_TEAROFF_METHOD(%sget_%s, GET_%s, (%s%s*p));\n",
pCtxt,
pMethodName,
pMethodName,
(LPCSTR)szProp,
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_ATYPE ));
}
else
{
fprintf ( fpHDLFile, "NV_DECLARE_TEAROFF_METHOD(%sget_%s, GET_%s, (%s%s*p));\n",
pCtxt,
pMethodName,
pMethodName,
(LPCSTR)szProp,
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_ATYPE ));
}
}
}
}
}
BOOL CPDLParser::IsStoredAsString( Token *pChildToken )
{
CString szJunk1, szJunk2;
StorageType stHowStored;
GetTypeDetails ( pChildToken->GetTagValue ( PROPERTY_TYPE ),
szJunk1, szJunk2, &stHowStored );
return stHowStored == STORAGETYPE_STRING ? TRUE : FALSE;
}
void CPDLParser::GenerateGetAAXPrototypes ( Token *pClassToken )
{
CTokenListWalker ChildList ( pClassToken );
Token *pChildToken;
if ( pClassToken -> IsSet ( CLASS_NOAAMETHODS ) )
return;
while ( pChildToken = ChildList.GetNext() )
{
// Generate a GetAA prototype even if the automation Get method is not generated
if ( pChildToken -> GetType() != TYPE_METHOD &&
pChildToken -> IsSet ( PROPERTY_CAA ) &&
_stricmp(pChildToken->GetTagValue(PROPERTY_NOPROPDESC), "nameonly"))
{
BOOL fIsString = IsStoredAsString(pChildToken);
//setaahr method
if (pChildToken -> IsSet ( PROPERTY_SETAAHR ) )
{
fprintf ( fpHDLFile, " HRESULT SetAA%s(%s);\n",
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_NAME ),
(LPCSTR)(fIsString?"LPCTSTR": (LPCSTR)pChildToken -> GetTagValue ( PROPERTY_TYPE ) )
);
}
//get method. If the property refers to a cascaded format - don't generate a GetAA - this would just
// encourage mis-use. Always want to force use of GetCascadedXX variant
if ( !pChildToken -> IsSet ( PROPERTY_CASCADED ) ||
pChildToken -> IsSet ( PROPERTY_GETAA ) )
{
fprintf ( fpHDLFile, " %s GetAA%s() const;\n",
(LPCSTR)(fIsString?"LPCTSTR":(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_TYPE )),
(LPCSTR)(pChildToken->GetTagValue ( PROPERTY_NAME )) );
}
}
}
}
void CPDLParser::GenerateGetAAXImplementations( Token *pClassToken )
{
CTokenListWalker ChildList ( pClassToken );
Token *pChildToken;
if ( pClassToken -> IsSet ( CLASS_NOAAMETHODS ) )
return;
while ( pChildToken = ChildList.GetNext() )
{
// Generate a GetAA prototype even if the automation Get method is not generated
if ( pChildToken -> GetType() != TYPE_METHOD &&
pChildToken -> IsSet ( PROPERTY_CAA ) &&
_stricmp(pChildToken->GetTagValue(PROPERTY_NOPROPDESC), "nameonly"))
{
BOOL fIsString = IsStoredAsString(pChildToken);
//setaahr method
if (pChildToken -> IsSet ( PROPERTY_SETAAHR ) )
{
if (!strcmp((LPCSTR)pChildToken ->GetTagValue(PROPERTY_TYPE), "VARIANT_BOOL"))
{
fprintf ( fpHDLFile, "HRESULT %s::SetAA%s(VARIANT_BOOL pv)\n{\n DWORD dwTemp = pv;\n RRETURN( THR( CAttrArray::SetSimple(GetAttrArray(), &s_propdesc%s%s.a, dwTemp) ) );\n}\n",
(LPCSTR)pClassToken -> GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_NAME ),
(LPCSTR)pClassToken -> GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_NAME )
);
}
else
{
fprintf ( fpHDLFile, "HRESULT %s::SetAA%s(%s pv)\n{\n RRETURN( THR( CAttrArray::Set%s(GetAttrArray(), &s_propdesc%s%s.a, %spv) ) );\n}\n",
(LPCSTR)pClassToken -> GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_NAME ),
(LPCSTR)( fIsString?"LPCTSTR":(LPCSTR)pChildToken ->GetTagValue(PROPERTY_TYPE) ),
(LPCSTR)(fIsString?"String":"Simple"),
(LPCSTR)pClassToken -> GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_NAME ),
(LPCSTR)(fIsString?"":"*(DWORD*) &")
);
}
}
//get method. Don't generate a GetAA - they already have a GetCascadedX
if ( !pChildToken -> IsSet ( PROPERTY_CASCADED ) ||
pChildToken -> IsSet ( PROPERTY_GETAA ) )
{
Token *pExposeToken = NULL;
CString szClass;
if (pChildToken -> IsSet ( PROPERTY_NOPROPDESC ))
{
pExposeToken = FindMatchingEntryWOPropDesc(pClassToken, pChildToken);
}
if (!pExposeToken)
pExposeToken = pChildToken;
if (strlen( pExposeToken -> GetTagValue ( PROPERTY_REFDTOCLASS )))
szClass = pExposeToken -> GetTagValue ( PROPERTY_REFDTOCLASS );
else
szClass = (LPCSTR)pClassToken -> GetTagValue ( CLASS_NAME );
#ifdef UNIX // IEUNIX: On Unix, converting DWORD* to short* would cause value changed. So we cast it from DWORD to short.
if (!fIsString)
{
LPCSTR pPropType = (LPCSTR)pChildToken->GetTagValue( PROPERTY_TYPE);
if ( !_stricmp(pPropType , "short") || !_stricmp(pPropType, "WORD") || !_stricmp(pPropType, "BYTE") )
{
fprintf ( fpHDLFile, "%s %s::GetAA%s() const \n{\n DWORD v;\n CAttrArray::FindSimple( *GetAttrArray(), &s_propdesc%s%s.a, &v);\n return (%s)v;\n}\n",
pPropType,
(LPCSTR)pClassToken -> GetTagValue ( CLASS_NAME ),
(LPCSTR)(pChildToken->GetTagValue ( PROPERTY_NAME )),
(LPCSTR)szClass,
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_NAME ),
pPropType );
continue;
}
}
#endif
fprintf ( fpHDLFile, "%s %s::GetAA%s() const \n{\n %s v;\n CAttrArray::Find%s( *GetAttrArray(), &s_propdesc%s%s.a, &v);\n return *(%s*)&v;\n}\n",
(LPCSTR)(fIsString?"LPCTSTR":(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_TYPE )),
(LPCSTR)pClassToken -> GetTagValue ( CLASS_NAME ),
(LPCSTR)(pChildToken->GetTagValue ( PROPERTY_NAME )) ,
(LPCSTR)(fIsString?"LPCTSTR":"DWORD" ),
(LPCSTR)(fIsString?"String":"Simple"),
(LPCSTR)szClass,
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_NAME ),
(LPCSTR)(fIsString?"LPCTSTR":(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_TYPE ) ) );
}
}
}
}
BOOL CPDLParser::GenerateIDispatchTearoff ( LPCSTR szClassName, Token *pTearoff, LPCSTR pszInterface, BOOL fMostDerived)
{
char szTearoffMethod[128];
char szTemp[128];
fprintf ( fpHDLFile, " // IDispatch methods\n");
FindTearoffMethod(pTearoff, "GetTypeInfoCount", szTearoffMethod);
GenerateWin16TearoffName(szTemp, szTearoffMethod);
fprintf ( fpHDLFile, " TEAROFF_METHOD(%s, %s, %s, (unsigned int *))\n",
szClassName, szTearoffMethod, szTemp);
FindTearoffMethod(pTearoff, "GetTypeInfo", szTearoffMethod);
GenerateWin16TearoffName(szTemp, szTearoffMethod);
fprintf ( fpHDLFile, " TEAROFF_METHOD(%s, %s, %s, (unsigned int, unsigned long, ITypeInfo **))\n",
szClassName, szTearoffMethod, szTemp);
FindTearoffMethod(pTearoff, "GetIDsOfNames", szTearoffMethod);
GenerateWin16TearoffName(szTemp, szTearoffMethod);
fprintf ( fpHDLFile, " TEAROFF_METHOD(%s, %s, %s, (REFIID, LPOLESTR *, unsigned int, LCID, DISPID *))\n",
szClassName, szTearoffMethod, szTemp);
{
CString szIHTMLElement, szInterface;
szIHTMLElement = "IHTMLElement";
szInterface = pszInterface;
if(!FindTearoffMethod(pTearoff, "Invoke", szTearoffMethod) &&
IsSuperInterface(szIHTMLElement, FindInterface(szInterface)))
{
strcpy(szTearoffMethod, pTearoff->IsSet(TEAROFF_BASEIMPL) ?
(LPCSTR)pTearoff->GetTagValue(TEAROFF_BASEIMPL) : "");
strcat(szTearoffMethod, "ContextThunk_Invoke");
}
}
GenerateWin16TearoffName(szTemp, szTearoffMethod);
fprintf ( fpHDLFile, " TEAROFF_METHOD(%s, %s, %s, (DISPID, REFIID, LCID, WORD, DISPPARAMS *, VARIANT *, EXCEPINFO *, unsigned int *))\n",
szClassName, szTearoffMethod, szTemp);
return TRUE;
}
BOOL CPDLParser::IsSpecialTearoff(Token *pTearoff)
{
CString szInterface;
Token *pInterface;
Token *pChildToken;
szInterface = pTearoff->GetTagValue(TEAROFF_INTERFACE);
pInterface = FindInterface(szInterface);
if (!pInterface || pInterface->IsSet(INTERFACE_ABSTRACT))
return FALSE;
CTokenListWalker ChildList(pInterface);
pChildToken = ChildList.GetNext();
if (pChildToken)
{
do
{
if (pChildToken->GetType() == TYPE_PROPERTY && !pChildToken->IsSet(PROPERTY_ABSTRACT) && !pChildToken->IsSet(PROPERTY_BASEIMPLEMENTATION))
{
return TRUE;
}
} while (pChildToken = ChildList.GetNext());
}
return FALSE;
}
BOOL CPDLParser::FindTearoffProperty(Token *pPropertyToken, LPSTR szTearoffMethod,
LPSTR szTearOffClassName, LPSTR szPropArgs, BOOL fPropGet)
{
if (pPropertyToken->IsSet(PROPERTY_ABSTRACT) || pPropertyToken->IsSet(PROPERTY_BASEIMPLEMENTATION))
return FALSE;
strcpy(szTearoffMethod, fPropGet ? "get_" : "put_");
strcpy(szPropArgs, fPropGet ? "void" : (LPCSTR)pPropertyToken->GetTagValue(PROPERTY_ATYPE));
strcpy(szTearOffClassName, "CBase");
if (!strcmp(pPropertyToken->GetTagValue(PROPERTY_ATYPE), "VARIANT"))
{
if (fPropGet)
{
strcat(szTearoffMethod, "Property");
}
else if (pPropertyToken->IsSet(PROPERTY_DATAEVENT))
strcat(szTearoffMethod, "DataEvent");
else
strcat(szTearoffMethod, "Variant");
}
else if (!strcmp(pPropertyToken->GetTagValue(PROPERTY_ATYPE), "BSTR"))
{
if (!strcmp(pPropertyToken->GetTagValue(PROPERTY_TYPE), "url"))
{
strcat(szTearoffMethod, "Url");
strcpy(szPropArgs, (LPCSTR)pPropertyToken->GetTagValue(PROPERTY_ATYPE));
}
else if (!strcmp(pPropertyToken->GetTagValue(PROPERTY_TYPE), "CStyleComponent"))
{
strcat(szTearoffMethod, "StyleComponent");
strcpy(szPropArgs, (LPCSTR)pPropertyToken->GetTagValue(PROPERTY_ATYPE));
}
else
strcat(szTearoffMethod, (fPropGet ? "Property" : "String"));
}
else if (!strcmp(pPropertyToken->GetTagValue(PROPERTY_ATYPE), "VARIANT_BOOL"))
strcat(szTearoffMethod, (fPropGet ? "Property" : "Bool"));
else if (!strcmp(pPropertyToken->GetTagValue(PROPERTY_ATYPE), "long"))
strcat(szTearoffMethod, fPropGet ? "Property" : "Long");
else if (!strcmp(pPropertyToken->GetTagValue(PROPERTY_ATYPE), "short"))
strcat(szTearoffMethod, fPropGet ? "Property" : "Short");
else
{
char szError[124];
sprintf(szError, "%s: This property of new type needs a function prototype (in cdbase.hxx) and a body defn. in (baseprop.cxx)",
(LPCSTR)pPropertyToken->GetTagValue(PROPERTY_NAME));
ReportError (szError);
return FALSE;
}
return TRUE;
}
BOOL CPDLParser::GeneratePropDescsInVtblOrder(Token *pClassToken, int *pNumVtblPropDescs)
{
CString szPrimaryInterf;
CString szInterface;
LPCSTR szClassName = pClassToken->GetTagValue(CLASS_NAME);
BOOL fOk;
BOOL fNameOnly;
int i = 0, j;
szPrimaryInterf = pClassToken->GetTagValue(CLASS_INTERFACE);
Token *pPrimaryInterf = FindInterface(szPrimaryInterf);
Token *pInterface;
Token *pChildToken;
Token *apInterface[5];
*pNumVtblPropDescs = 0;
Token *pTearoff = NULL;
while ((pTearoff = NextTearoff(szClassName, pTearoff)))
{
szInterface = pTearoff->GetTagValue(TEAROFF_INTERFACE);
pInterface = FindInterface(szInterface);
if (!pInterface || pInterface->IsSet(INTERFACE_ABSTRACT))
continue;
i = 0;
apInterface[i++] = pInterface;
while (i < 5 && apInterface[i-1]->IsSet(INTERFACE_SUPER) &&
_stricmp(apInterface[i-1]->GetTagValue(INTERFACE_SUPER), "IDispatch") &&
_stricmp(apInterface[i-1]->GetTagValue(INTERFACE_SUPER), "IUnknown"))
{
szInterface = apInterface[i-1]->GetTagValue(INTERFACE_SUPER);
apInterface[i++] = FindInterface(szInterface);
}
if (i >= 5)
{
ReportError("Super Chain More than 5, Need to increase limit in PdlParser");
return FALSE;
}
fOk = FALSE;
CTokenListWalker ChildList(pInterface);
pChildToken = ChildList.GetNext();
if (pChildToken)
{
do
{
if (pChildToken->GetType() == TYPE_PROPERTY && !pChildToken->IsSet(PROPERTY_ABSTRACT) && !pChildToken->IsSet(PROPERTY_BASEIMPLEMENTATION))
{
fOk = TRUE;
break;
}
} while (pChildToken = ChildList.GetNext());
if (fOk)
{
fprintf(fpHDLFile, "\nconst PROPERTYDESC * const %s::s_ppropdescsInVtblOrder%s[] = {\n", szClassName,
(LPSTR)pTearoff->GetTagValue(TEAROFF_INTERFACE));
for (j = i-1; j >= 0; j--)
{
pInterface = apInterface[j];
CTokenListWalker ChildLst(pInterface);
pChildToken = ChildLst.GetNext();
do
{
char szErrorText[MAX_LINE_LEN + 1];
Token *pExposeToken = NULL;
if (pChildToken->GetType() == TYPE_METHOD)
{
if (pChildToken->IsSet(METHOD_NOPROPDESC))
{
fNameOnly = _stricmp(pChildToken->GetTagValue(METHOD_NOPROPDESC), "nameonly") == 0;
pExposeToken = FindMatchingEntryWOPropDesc(pClassToken, pChildToken, fNameOnly);
if (!pExposeToken)
{
sprintf(szErrorText,
"Function member marked as nopropdesc can not find exact signature match in new interface:%s in Class:%s\n",
(LPCSTR)pChildToken->GetTagValue(METHOD_NAME),
szClassName);
ReportError(szErrorText);
return FALSE;
}
}
else
pExposeToken = pChildToken;
fprintf(fpHDLFile, " (PROPERTYDESC *)&s_methdesc%s%s,\n", pExposeToken->GetTagValue((int)METHOD_REFDTOCLASS), pExposeToken->GetTagValue(METHOD_NAME));
if (pPrimaryInterf == pInterface)
(*pNumVtblPropDescs)++;
}
else
{
if (pChildToken->IsSet(PROPERTY_SET) || pChildToken->IsSet(PROPERTY_GET))
{
BOOL fDoAgain = TRUE;
DoAgain:
if (pChildToken->IsSet(PROPERTY_NOPROPDESC))
{
fNameOnly = _stricmp(pChildToken->GetTagValue(PROPERTY_NOPROPDESC), "nameonly") == 0;
pExposeToken = FindMatchingEntryWOPropDesc(pClassToken, pChildToken, fNameOnly);
if (!pExposeToken)
{
sprintf(szErrorText,
"Function member marked as nopropdesc can not find exact signature match in new interface:%s in Class:%s\n",
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME),
szClassName);
ReportError(szErrorText);
return FALSE;
}
}
else
pExposeToken = pChildToken;
pExposeToken = pExposeToken ? pExposeToken : pChildToken;
fprintf(fpHDLFile, " (const PROPERTYDESC *)&s_propdesc%s%s,\n",
pExposeToken->GetTagValue((int)PROPERTY_REFDTOCLASS),
pExposeToken->GetTagValue(PROPERTY_NAME));
if (pPrimaryInterf == pInterface)
(*pNumVtblPropDescs)++;
// If property is getter and setter both then generate another propdesc (but just once).
if (fDoAgain && pChildToken->IsSet(PROPERTY_SET) && pChildToken->IsSet(PROPERTY_GET))
{
fDoAgain = FALSE;
goto DoAgain;
}
}
}
} while (pChildToken = ChildLst.GetNext());
}
fprintf(fpHDLFile, "};\n\n");
}
}
}
return TRUE;
}
BOOL CPDLParser::GenerateTearOffMethods (LPCSTR szClassName, Token *pTearoff, LPCSTR szInterfaceName, BOOL fMostDerived)
{
Token *pInterfaceToken;
Token *pChildToken;
char szText[MAX_LINE_LEN+1];
CTokenListWalker WholeList(pRuntimeList);
#if 0
if (strcmp(_pszPDLFileName, "div.pdl") == 0 || strcmp(szInterfaceName, "IHTMLDivElement") == 0)
__asm { int 3 };
#endif
// Find the interface decl
do
{
pInterfaceToken = WholeList.GetNext(TYPE_INTERFACE, szInterfaceName);
if (pInterfaceToken == NULL)
{
// if the deepest is IDispatch output that tearoff
if (_stricmp(szInterfaceName, "IDispatch"))
{
// but IUnknowns are OK so return true
if (_stricmp(szInterfaceName, "IUnknown"))
{
// its something we don't recognise so output error msg
sprintf(szText, "interface:%s unknown\n", (LPCSTR)szInterfaceName);
ReportError(szText);
return FALSE;
}
else
return TRUE;
}
else
{
return GenerateIDispatchTearoff(szClassName, pTearoff, szInterfaceName, fMostDerived);
}
}
} while (!pInterfaceToken->IsSet(INTERFACE_GUID));
// If we only want most derived then we're done otherwise continue recursing.
if (!fMostDerived)
{
// Generate the interfaces super tear off methods first
if (pInterfaceToken->IsSet(INTERFACE_SUPER))
{
GenerateTearOffMethods(szClassName, pTearoff, pInterfaceToken->GetTagValue(INTERFACE_SUPER));
}
}
else
{
// fMostDerived is only set for the primary interface, which we don't want stacked ontop of its
// derivations. so all we want to do is dump in the dispatch and go on.
GenerateIDispatchTearoff(szClassName, pTearoff, szInterfaceName, fMostDerived);
}
// generate the fn prototypes cast to generic fn pts in the
// tearoff table
CTokenListWalker ChildList(pInterfaceToken);
CString szProp;
Token *pArgToken;
fprintf ( fpHDLFile, " // %s methods\n", szInterfaceName);
while (pChildToken = ChildList.GetNext())
{
char szTemp[256];
char szTearOffClassName[256];
char szContextThunk[] = "ContextThunk_";
LPCSTR pCtxt;
if (pChildToken->GetType() == TYPE_METHOD)
{
CTokenListWalker ArgListWalker(pChildToken);
BOOL fFirstArg = TRUE;
char szTearoffMethod[128];
LPCSTR pMethodName;
pMethodName = pChildToken->IsSet(METHOD_SZINTERFACEEXPOSE) ?
(LPSTR)pChildToken->GetTagValue(METHOD_SZINTERFACEEXPOSE) :
(LPSTR)pChildToken->GetTagValue(METHOD_NAME);
FindTearoffMethod(pTearoff,
pMethodName,
szTearoffMethod);
strcpy(szTearOffClassName, szClassName);
GenerateWin16TearoffName(szTemp, szTearoffMethod, szTearOffClassName);
pCtxt = pChildToken->IsSet(METHOD_THUNKCONTEXT) ||
pChildToken->IsSet(METHOD_THUNKNODECONTEXT)
? szContextThunk : "";
// Method
fprintf(fpHDLFile, " TEAROFF_METHOD(%s, %s%s, %s, (", szTearOffClassName, pCtxt, szTearoffMethod, szTemp);
// All automated methods MUST have an HRESULT for the return type.
if (_stricmp("HRESULT", (LPCSTR)pChildToken->GetTagValue(METHOD_RETURNTYPE)))
{
ReportError("Automated method must have HRESULT for return value\n");
return FALSE;
}
// Output each argument.
while (pArgToken = ArgListWalker.GetNext())
{
if (!fFirstArg)
fprintf(fpHDLFile, ",");
fprintf(fpHDLFile, "%s", ConvertType((LPCSTR)pArgToken->GetTagValue(METHODARG_TYPE)));
fFirstArg = FALSE;
}
fprintf(fpHDLFile, "))\n");
}
else
{
char szPropName[128];
char szTearoffMethod[128];
char szPropArgs[64];
LPCSTR pMethodName;
// Property
szProp = "";
pMethodName = pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pChildToken->GetTagValue(PROPERTY_NAME);
// Through the index/indextype & index1/indextype1 pdl tags
// you can provide up to two additional args for the property definition
pChildToken->AddParam(szProp, PROPERTY_INDEX, pChildToken->GetTagValue(PROPERTY_INDEXTYPE));
pChildToken->AddParam(szProp, PROPERTY_INDEX1, pChildToken->GetTagValue(PROPERTY_INDEXTYPE1));
if (szProp[0] != '\0')
szProp += ",";
pCtxt = pChildToken->IsSet(PROPERTY_THUNKCONTEXT) ||
pChildToken->IsSet(PROPERTY_THUNKNODECONTEXT)
? szContextThunk : "";
if ( pChildToken->IsSet(PROPERTY_SET))
{
strcpy(szPropName, "put_");
strcat(szPropName, pMethodName);
if (FindTearoffMethod(pTearoff, szPropName, szTearoffMethod))
{
strcpy(szPropArgs, (LPCSTR)pChildToken->GetTagValue(PROPERTY_ATYPE));
strcpy(szTearOffClassName, szClassName);
}
else if (!FindTearoffProperty(pChildToken, szTearoffMethod, szTearOffClassName, szPropArgs, FALSE))
{
FindTearoffMethod(pTearoff, szPropName, szTearoffMethod);
strcpy(szPropArgs, (LPCSTR)pChildToken->GetTagValue(PROPERTY_ATYPE));
strcpy(szTearOffClassName, szClassName);
}
GenerateWin16TearoffName(szTemp, szTearoffMethod, szTearOffClassName);
fprintf(fpHDLFile, " TEAROFF_METHOD(%s, %s%s, %s, (%s%s)) // property set_%s\n",
szTearOffClassName,
pCtxt,
szTearoffMethod,
szTemp,
(LPCSTR)szProp,
(LPCSTR)szPropArgs,
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME));
}
if (pChildToken->IsSet(PROPERTY_GET))
{
strcpy(szPropName, "get_");
strcat(szPropName, pMethodName);
if (FindTearoffMethod(pTearoff, szPropName, szTearoffMethod))
{
strcpy(szPropArgs, (LPCSTR)pChildToken->GetTagValue(PROPERTY_ATYPE));
strcpy(szTearOffClassName, szClassName);
}
else if (!FindTearoffProperty(pChildToken, szTearoffMethod, szTearOffClassName, szPropArgs, TRUE))
{
FindTearoffMethod(pTearoff, szPropName, szTearoffMethod);
strcpy(szPropArgs, (LPCSTR)pChildToken->GetTagValue(PROPERTY_ATYPE));
strcpy(szTearOffClassName, szClassName);
}
GenerateWin16TearoffName(szTemp, szTearoffMethod, szTearOffClassName);
fprintf(fpHDLFile, " TEAROFF_METHOD(%s, %s%s, %s, (%s%s *)) // property get_%s\n",
szTearOffClassName,
pCtxt,
szTearoffMethod,
szTemp,
(LPCSTR)szProp,
(LPCSTR)szPropArgs,
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME));
}
}
}
return TRUE;
}
void CPDLParser::GenerateMethodImp ( Token *pClassToken,
Token *pChildToken, BOOL fIsSet, CString &szHandler,
CString &szHandlerArgs, CString &szOffsetOf, CString &szAType )
{
#if COLLECT_STATISTICS==1
// Collect statistics on total property code turds.
CollectStatistic(NUM_PROPTURDS, GetStatistic(NUM_PROPTURDS) + 1);
#endif
char *szHandlerMethodPrefix;
char *szAutomationMethodPrefix;
if ( fIsSet )
{
szHandlerMethodPrefix = "Set";
szAutomationMethodPrefix = "put_";
}
else
{
szHandlerMethodPrefix = "Get";
szAutomationMethodPrefix = "get_";
}
// Allow enums with an ATYPE of BSTR to be automated with the string handler
if ( szHandler == "Enum" && szAType == "BSTR" )
{
szHandler = "EnumString";
#if COLLECT_STATISTICS==1
// Collect statistics on number of enum code turds.
CollectStatistic(NUM_EMUMTURDS, GetStatistic(NUM_EMUMTURDS) + 1);
#endif
}
fprintf ( fpHDLFile,
"STDMETHODIMP %s::%s%s(%s%s)\n{\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)szAutomationMethodPrefix,
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)szAType,
fIsSet ? " v" : " * p" );
if ( pChildToken -> IsSet ( PROPERTY_PRECALLFUNCTION ) )
{
CString szfn;
szfn = pChildToken -> GetTagValue ( PROPERTY_PRECALLFUNCTION ) ;
// Give the super a chance to reject the call
fprintf ( fpHDLFile, " HRESULT hr;\n" );
if ( szfn == "super" )
{
fprintf ( fpHDLFile, " hr = super::%s%s(%s);\n",
szAutomationMethodPrefix,
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_PRECALLFUNCTION ),
fIsSet ? "v" : "p" );
}
else
{
fprintf ( fpHDLFile, " hr = %s%s(%s);\n",
szAutomationMethodPrefix,
(LPCSTR)szfn,
fIsSet ? "v" : "p" );
}
fprintf ( fpHDLFile, " if ( hr )\n return hr;\n" );
}
if ( fIsSet && pChildToken -> IsSet ( PROPERTY_SETDESIGNMODE ) )
{
fprintf ( fpHDLFile, " if ( !IsDesignMode() )\n return SetErrorInfo(CTL_E_SETNOTSUPPORTEDATRUNTIME);\n" );
}
if ( szAType == "VARIANT" )
{
fprintf ( fpHDLFile, " return SetErrorInfo(s_propdesc%s%s.a.Handle%sProperty(%s, %s, this, CVOID_CAST%s));\n}\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)szHandler,
(LPCSTR)szHandlerArgs,
fIsSet ? "&v" : "p",
(LPCSTR)szOffsetOf );
}
else if ( pChildToken -> IsSet ( PROPERTY_SUBOBJECT ) )
{
fprintf ( fpHDLFile, " return %s::CreateSubObject ( GetElementPtr(), (PROPERTYDESC *)&s_propdesc%s%s,\n ",
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_SUBOBJECT ),
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ));
if ( pChildToken -> IsSet ( PROPERTY_PARAM1 ) )
{
fprintf ( fpHDLFile, "%s, ",
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_PARAM1 ) );
}
fprintf ( fpHDLFile, "p );\n}\n" );
}
else
{
if ( szHandler == "Num" || szHandler == "Enum" )
{
fprintf ( fpHDLFile," return s_propdesc%s%s.b.%sNumberProperty(%s, this, CVOID_CAST%s);\n}\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)szHandlerMethodPrefix,
fIsSet ? "v" : "p",
(LPCSTR)szOffsetOf );
}
else
{
fprintf ( fpHDLFile, " return s_propdesc%s%s.b.%s%sProperty(%s, this, CVOID_CAST%s);\n}\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)szHandlerMethodPrefix,
(LPCSTR)szHandler,
fIsSet ? "v" : "p",
(LPCSTR)szOffsetOf );
}
}
}
void CPDLParser::GenerateCPPEnumDefs ( void )
{
Token *pToken;
char *pEValText;
// Only generate def's for this file
CTokenListWalker TokenList ( pRuntimeList, _pszPDLFileName );
fprintf ( fpHDLFile, "\n#ifndef _PROPDESCS_EXTERNAL\n\n" );
// Generate propdescs for every property token in every class ( in this file )
while ( pToken = TokenList.GetNext( TYPE_ENUM ) )
{
fprintf ( fpHDLFile, "EXTERN_C const ENUMDESC s_enumdesc%s = \n{ %u, %u, {\n",
pToken->GetTagValue ( ENUM_NAME ) ,
pToken->GetChildTokenCount(),
pToken->uEnumMask );
CTokenListWalker ChildList ( pToken );
while ( pToken = ChildList.GetNext() )
{
// If a string is specified use it
if ( pToken->IsSet ( EVAL_STRING ) )
{
pEValText = pToken->GetTagValue ( EVAL_STRING );
}
else
{
pEValText = pToken->GetTagValue ( EVAL_NAME );
}
fprintf ( fpHDLFile, " { _T(\"%s\"),%s},\n",
pEValText,
pToken->GetTagValue ( EVAL_VALUE ) );
}
fprintf ( fpHDLFile, "} };\n\n" );
}
fprintf ( fpHDLFile, "#endif // _PROPDESCS_EXTERNAL\n" );
}
void CPDLParser::GenerateInterfaceDISPIDs ( void )
{
Token *pInterfaceToken;
Token *pChildToken;
CString szName;
// Generate DISPID's for all interface methods that are not
// ref'd to a class
// Only generate def's for this file
CTokenListWalker TokenList ( pRuntimeList, _pszPDLFileName );
while ( pInterfaceToken = TokenList.GetNext( TYPE_INTERFACE ) )
{
szName = pInterfaceToken->GetTagValue ( INTERFACE_NAME );
if ( szName == "IDispatch" )
continue;
fprintf ( fpHDLFile, "// DISPIDs for class%s\n\n",
(LPCSTR)pInterfaceToken->GetTagValue ( INTERFACE_NAME ) );
CTokenListWalker ChildList ( pInterfaceToken );
while ( pChildToken = ChildList.GetNext() )
{
if ( pChildToken -> GetType() == TYPE_METHOD &&
!strlen( pChildToken -> GetTagValue ( METHOD_REFDTOCLASS ) ) &&
pChildToken -> IsSet ( METHOD_DISPID ) )
{
Token *pChildMatch = NULL;
CString szClassName;
Token *pClass;
szClassName = pInterfaceToken -> GetTagValue( METHOD_REFDTOCLASS );
pClass = FindClass ( szClassName );
if (pClass)
{
if (pChildToken->IsSet(METHOD_NOPROPDESC))
{
pChildMatch = FindMatchingEntryWOPropDesc(pClass, pChildToken);
}
}
if (!pChildMatch)
pChildMatch = pChildToken;
fprintf ( fpHDLFile, "#define DISPID_%s_%s %s\n",
(LPCSTR)pInterfaceToken->GetTagValue ( INTERFACE_NAME ),
(LPCSTR)pChildMatch->GetTagValue ( METHOD_NAME ),
(LPCSTR)pChildMatch->GetTagValue ( METHOD_DISPID ) );
}
}
}
}
void CPDLParser::GenerateEventDISPIDs ( FILE *fp, BOOL fPutDIID )
{
Token *pEventToken;
Token *pChildToken;
CString szName,szDISPName;
int i,nLength;
BOOL fPutComment;
// Generate DISPID's for all interface methods that are not
// ref'd to a class
// Only generate def's for this file
CTokenListWalker TokenList ( pRuntimeList, _pszPDLFileName );
while ( pEventToken = TokenList.GetNext( TYPE_EVENT ) )
{
szName = pEventToken->GetTagValue ( EVENT_NAME );
if ( szName == "IDispatch" || szName == "IUnknown" )
continue;
szName.ToUpper();
fPutComment = FALSE;
CTokenListWalker ChildList ( pEventToken );
while ( pChildToken = ChildList.GetNext() )
{
if ( pChildToken -> GetType() == TYPE_METHOD &&
!strlen( pChildToken -> GetTagValue ( METHOD_REFDTOCLASS ) ) &&
pChildToken -> IsSet ( METHOD_DISPID ) )
{
if ( !fPutComment )
{
fprintf ( fp, "// DISPIDs for event set %s\n\n",
(LPCSTR)pEventToken->GetTagValue ( EVENT_NAME ) );
fPutComment = TRUE;
}
szDISPName = pChildToken->GetTagValue ( METHOD_NAME );
szDISPName.ToUpper();
fprintf ( fp, "#define DISPID_%s_%s ",
(LPCSTR)szName,
(LPCSTR)szDISPName );
for ( i = 0, nLength = max ( 0, 49-szDISPName.Length()-szName.Length() ); i < nLength ; i++ )
{
fprintf ( fp, " " );
}
fprintf ( fp, "%s\n",
(LPCSTR)pChildToken->GetTagValue ( METHOD_DISPID ) );
}
}
if ( fPutDIID )
{
fprintf ( fp, "\nEXTERN_C const GUID DIID_%s;\n",
pEventToken->GetTagValue ( EVENT_NAME ));
}
if ( fPutComment )
fprintf ( fp, "\n" );
}
}
void CPDLParser::GenerateExternalInterfaceDISPIDs ( void )
{
Token *pInterfaceToken;
Token *pChildToken;
CString szName,szDISPName;
int i,nLength;
BOOL fPutComment;
// Generate DISPID's for all interface methods that are not
// ref'd to a class
// Only generate def's for this file
CTokenListWalker TokenList ( pRuntimeList, _pszPDLFileName );
while ( pInterfaceToken = TokenList.GetNext( TYPE_INTERFACE ) )
{
szName = pInterfaceToken->GetTagValue ( INTERFACE_NAME );
if ( szName == "IDispatch" || szName == "IUnknown" )
continue;
szName.ToUpper();
fPutComment = FALSE;
CTokenListWalker ChildList ( pInterfaceToken );
while ( pChildToken = ChildList.GetNext() )
{
Token *pChildMatch = NULL;
CString szClassName;
Token *pClass;
if ( !fPutComment )
{
fprintf ( fpDISPIDFile, "// DISPIDs for interface %s\n\n",
(LPCSTR)pInterfaceToken->GetTagValue ( INTERFACE_NAME ) );
fPutComment = TRUE;
}
if ( pChildToken -> GetType() == TYPE_METHOD )
{
szDISPName = pChildToken->GetTagValue ( METHOD_NAME );
szClassName = pChildToken -> GetTagValue( METHOD_REFDTOCLASS );
pClass = FindClass ( szClassName );
if (pClass)
{
if (pChildToken->IsSet(METHOD_NOPROPDESC))
{
if (pChildToken->IsSet(METHOD_SZINTERFACEEXPOSE))
szDISPName = pChildToken->GetTagValue(METHOD_SZINTERFACEEXPOSE);
pChildMatch = FindMatchingEntryWOPropDesc(pClass, pChildToken);
}
}
if (!pChildMatch)
pChildMatch = pChildToken;
}
else
{
// Property
szDISPName = pChildToken->GetTagValue ( PROPERTY_NAME );
szClassName = pChildToken -> GetTagValue( PROPERTY_REFDTOCLASS );
pClass = FindClass ( szClassName );
if (pClass)
{
if (pChildToken->IsSet(PROPERTY_NOPROPDESC))
{
if (pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE))
szDISPName = pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE);
pChildMatch = FindMatchingEntryWOPropDesc(pClass, pChildToken);
}
}
if (!pChildMatch)
pChildMatch = pChildToken;
}
szDISPName.ToUpper();
fprintf ( fpDISPIDFile, "#define DISPID_%s_%s ",
(LPCSTR)szName,
(LPCSTR)szDISPName );
for ( i = 0, nLength = max ( 0, 49-szDISPName.Length()-szName.Length() ); i < nLength ; i++ )
{
fprintf ( fpDISPIDFile, " " );
}
fprintf ( fpDISPIDFile, "%s\n",
(LPCSTR)pChildMatch->GetTagValue ( PROPERTY_DISPID ) );
}
if ( fPutComment )
fprintf ( fpDISPIDFile, "\n" );
}
}
void CPDLParser::GenerateClassDISPIDs ( void )
{
Token *pClassToken;
Token *pChildToken;
CString szCoClassName;
// Only generate def's for this file
CTokenListWalker TokenList ( pRuntimeList, _pszPDLFileName );
// Generate propdescs for every property token in every class ( in this file )
while ( pClassToken = TokenList.GetNext( TYPE_CLASS ) )
{
fprintf ( fpHDLFile, "// DISPIDs for class %s\n\n", (LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ) );
if ( pClassToken -> IsSet ( CLASS_GUID ) )
{
pClassToken -> GetTagValueOrDefault ( szCoClassName,
CLASS_COCLASSNAME, pClassToken -> GetTagValue ( CLASS_NAME ) );
fprintf ( fpHDLFile, "EXTERN_C const GUID CLSID_%s;\n",
(LPCSTR)szCoClassName );
}
CTokenListWalker ChildList ( pClassToken );
while ( pChildToken = ChildList.GetNext() )
{
Token *pChildMatch = pChildToken;
if ( pChildMatch->nType == TYPE_PROPERTY && pChildMatch->IsSet ( PROPERTY_DISPID ) )
{
if (pChildMatch->IsSet(PROPERTY_NOPROPDESC))
{
pChildMatch = FindMatchingEntryWOPropDesc(pClassToken, pChildMatch);
if (!pChildMatch)
pChildMatch = pChildToken;
}
fprintf ( fpHDLFile, "#define DISPID_%s_%s %s\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildMatch->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)pChildMatch->GetTagValue ( PROPERTY_DISPID ) );
}
else if ( pChildMatch->nType == TYPE_METHOD && pChildMatch->IsSet ( METHOD_DISPID ) )
{
if (pChildMatch->IsSet(METHOD_NOPROPDESC))
{
pChildMatch = FindMatchingEntryWOPropDesc(pClassToken, pChildMatch);
if (!pChildMatch)
pChildMatch = pChildToken;
}
fprintf ( fpHDLFile, "#define DISPID_%s_%s %s\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChildMatch->GetTagValue ( METHOD_NAME ),
(LPCSTR)pChildMatch->GetTagValue ( METHOD_DISPID ) );
}
}
}
}
void CPDLParser::GeneratePropdescExtern ( Token *pClassToken, BOOL fRecurse )
{
Token *pChild;
Token *pSuperClassToken;
CTokenListWalker ChildList ( pClassToken );
// Add the supers definitions first. Recurse to the super of this super!!
// Notice that the fRecurse if used by abstract classes to only extern the
// PropertyDesc which are generated for the actual class.
pSuperClassToken = fRecurse ? GetSuperClassTokenPtr ( pClassToken ) : NULL;
if ( pSuperClassToken )
GeneratePropdescExtern ( pSuperClassToken );
// Don't generate any EXTERN_C for abstract class reference. The EXTERN_C
// is only in the hdl that contains both the PROPERTYDESC the EXTERN_C for
// the abstract class (e.g., bodyroot.hdl).
if ( fRecurse && pClassToken -> IsSet ( CLASS_ABSTRACT ) )
return;
fprintf ( fpHeaderFile, "\n#ifndef _%s_PROPDESCS_\n", pClassToken -> GetTagValue ( CLASS_NAME ) );
// Walk the super class propdescs looking for properties
while ( pChild = ChildList.GetNext() )
{
if ( pChild->GetType() == TYPE_PROPERTY )
{
StorageType stHowStored;
CString szHandler;
CString szFnPrefix;
szHandler = "";
szFnPrefix = "";
// Check for missing handler later
GetTypeDetails ( pChild->GetTagValue ( PROPERTY_TYPE ),
szHandler, szFnPrefix, &stHowStored );
if ( !ComputePROPDESC_STRUCT ( fpHeaderFile, pClassToken, pChild, szHandler, szFnPrefix ) )
return; // Bad error reported...leave
fprintf ( fpHeaderFile, " s_propdesc%s%s;\n",
pClassToken -> GetTagValue ( CLASS_NAME ),
pChild -> GetTagValue ( PROPERTY_NAME ) );
}
else if ( pChild->GetType() == TYPE_METHOD )
{
fprintf ( fpHeaderFile, "EXTERN_C const PROPERTYDESC_METHOD s_methdesc%s%s;\n",
pClassToken -> GetTagValue ( CLASS_NAME ),
pChild -> GetTagValue ( METHOD_NAME ) );
}
}
fprintf ( fpHeaderFile, "\n#endif\n" );
}
BOOL CPDLParser::GeneratePropdescReference ( Token *pClassToken,
BOOL fDerivedClass,
PropdescInfo *pPI,
int *pnPI,
BOOL &bHookToCElement,
int *pnSharedEntries )
{
Token *pChild;
if (!pClassToken)
return TRUE;
CTokenListWalker ChildList ( pClassToken );
// If the class superclass if CElement, we want to hook to CElement's hash table
// If this is not the case, we want to do what we used to do and repeat
// the super class properties in the subclasses.
if(GetSuperClassTokenPtr ( pClassToken ) &&
(strcmp(GetSuperClassTokenPtr ( pClassToken ) ->GetTagValue ( CLASS_NAME ),
"CElement") == 0))
{
bHookToCElement = TRUE;
}
if ( !GeneratePropdescReference ( GetSuperClassTokenPtr ( pClassToken ),
FALSE, pPI, pnPI,
bHookToCElement, pnSharedEntries ) )
{
return FALSE;
}
if (fDerivedClass)
{
ChildList.Reset();
}
// Walk the super class propdescs looking for properties
while ( pChild = ChildList.GetNext() )
{
if ( pChild->GetType() == TYPE_PROPERTY )
{
if ( !pChild->IsSet ( PROPERTY_INTERNAL ) && !pChild->IsSet ( PROPERTY_ABSTRACT ) &&
!pChild->IsSet( PROPERTY_NOPROPDESC ) &&
(!pChild->IsSet ( PROPERTY_NOPERSIST ) ||
( pChild->IsSet ( PROPERTY_NOPERSIST ) && pClassToken->IsSet( CLASS_KEEPNOPERSIST ) ) ) )
{
if(bHookToCElement && (strcmp(pClassToken -> GetTagValue ( CLASS_NAME ), "CElement") == 0))
{
*pnSharedEntries += 1;
}
else
{
pPI[*pnPI].Set(pClassToken -> GetTagValue ( CLASS_NAME ),
pChild -> GetTagValue ( PROPERTY_NAME ) ,
fDerivedClass,
pChild->GetTagValue ( PROPERTY_SZATTRIBUTE ),
PDLPARSE_BELONGSTOPARSE);
*pnPI += 1;
}
}
}
}
return TRUE;
}
BOOL CPDLParser::GenerateCPC ( Token *pThisClassToken)
{
if ( IsUniqueCPC ( pThisClassToken ) )
{
fprintf ( fpHDLFile, "\nconst CONNECTION_POINT_INFO %s::s_acpi[] = {\n",
pThisClassToken -> GetTagValue ( CLASS_NAME ) );
fprintf ( fpHDLFile, " CPI_ENTRY(IID_IPropertyNotifySink, DISPID_A_PROPNOTIFYSINK)\n" );
fprintf ( fpHDLFile, " CPI_ENTRY(DIID_%s, DISPID_A_EVENTSINK)\n",
pThisClassToken->GetTagValue( CLASS_EVENTS ) );
if (pThisClassToken->IsSet(CLASS_NONPRIMARYEVENTS1))
{
fprintf(fpHDLFile, " CPI_ENTRY(DIID_%s, DISPID_A_EVENTSINK)\n",
pThisClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS1));
}
if (pThisClassToken->IsSet(CLASS_NONPRIMARYEVENTS2))
{
fprintf(fpHDLFile, " CPI_ENTRY(DIID_%s, DISPID_A_EVENTSINK)\n",
pThisClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS2));
}
if (pThisClassToken->IsSet(CLASS_NONPRIMARYEVENTS3))
{
fprintf(fpHDLFile, " CPI_ENTRY(DIID_%s, DISPID_A_EVENTSINK)\n",
pThisClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS3));
}
if (pThisClassToken->IsSet(CLASS_NONPRIMARYEVENTS4))
{
fprintf(fpHDLFile, " CPI_ENTRY(DIID_%s, DISPID_A_EVENTSINK)\n",
pThisClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS4));
}
fprintf ( fpHDLFile, " CPI_ENTRY(IID_ITridentEventSink, DISPID_A_EVENTSINK)\n" );
fprintf ( fpHDLFile, " CPI_ENTRY(IID_IDispatch, DISPID_A_EVENTSINK)\n" );
fprintf ( fpHDLFile, " CPI_ENTRY_NULL\n};\n" );
}
return TRUE;
}
#ifdef COMPLUS_SHIM
void
CPDLParser::GenComPlusInheritance (Token *pClass, CString & inheritanceCStr)
{
// Any other interface to expose in the coclass which is part of the primary
// interface?
CString primaryInterfCStr;
CTokenListWalker ChildWalker(pClass);
Token *pChildToken;
BOOL fFirstInterf;
// Get the primary interface, if one exists.
if (pClass->IsSet(CLASS_INTERFACE))
{
primaryInterfCStr = pClass->GetTagValue(CLASS_INTERFACE);
inheritanceCStr = "public ICOMCookie, public ";
inheritanceCStr += primaryInterfCStr;
inheritanceCStr += "COMPLUS";
fFirstInterf = FALSE;
}
else
{
inheritanceCStr = "";
fFirstInterf = TRUE;
}
while (pChildToken = ChildWalker.GetNext())
{
if (pChildToken->GetType() == TYPE_IMPLEMENTS)
{
Token *pInterf;
CString szInterface;
szInterface = pChildToken->GetTagValue(IMPLEMENTS_NAME);
pInterf = FindInterface(szInterface);
if (pInterf)
{
// Is the interface a local one if not then don't check, we
// only need to check where interfaces are actually used.
if (FindInterfaceLocally(szInterface))
{
// If the super isn't specified and it's not a primary interface
// then error the super is required for non-primary interfaces.
if (_stricmp((LPSTR)pClass->GetTagValue(CLASS_INTERFACE),
(LPSTR)pInterf->GetTagValue(INTERFACE_NAME)) &&
!pInterf->IsSet(INTERFACE_SUPER) &&
!IsPrimaryInterface(szInterface))
{
char szErrorText [ MAX_LINE_LEN+1 ];
sprintf(szErrorText, "Interface %s missing super key.\n",
(LPSTR)pInterf->GetTagValue(INTERFACE_NAME));
ReportError(szErrorText);
return;
}
}
// If an implements is a primary interface then don't inherit again we did that at the beginning.
if (primaryInterfCStr != szInterface)
{
if (fFirstInterf)
{
fFirstInterf = FALSE;
}
else
{
inheritanceCStr += ",";
}
inheritanceCStr += " public ";
inheritanceCStr += pInterf->GetTagValue(INTERFACE_NAME);
inheritanceCStr += "COMPLUS";
}
}
}
}
}
#endif // COMPLUS_SHIM
void
CPDLParser::GenerateVTableArray (Token *pThisClassToken, BOOL *pbHashTableExists )
{
Token *pDerivedClass;
PropdescInfo rgPI[400]; // Max. number of method/prop for interface.
int nPI = 0;
UINT uVTblIndex = 0;
CString szInterf;
Token *pInterf;
BOOL bHookToCElement = FALSE;
int nSharedEntries = 0;
*pbHashTableExists = FALSE;
// Abstract classes don't need the vtable unless they name is CElement
// TODO: Terry, Implement the shared keywork here.
if ( (pThisClassToken->IsSet ( CLASS_ABSTRACT )) &&
(_stricmp(pThisClassToken->GetTagValue(CLASS_NAME), "CElement") != 0))
return;
pDerivedClass = pThisClassToken;
GetInterf:
szInterf = pDerivedClass->GetTagValue(CLASS_INTERFACE);
// If no interface then use the super to find an interface.
if (!szInterf.Length())
{
CString szClass;
szClass = pDerivedClass -> GetTagValue ( CLASS_SUPER );
pDerivedClass = FindClass(szClass);
if (!pDerivedClass)
ReportError ( "Unknown class\n" );
goto GetInterf;
}
pInterf = FindInterface(szInterf);
if (pInterf || strcmp((LPCSTR)szInterf, "IDispatch") == 0)
{
#ifdef COMPLUS_SHIM
// ***TLL*** COM+: Not spitting COM+ proxies for internal.pdl and mshtmext.pdl need to do, shouldn't special case.
BOOL fInternalPDL = (_stricmp(_pszPDLFileName, "internal.pdl") == 0) || (_stricmp(_pszPDLFileName, "mshtmext.pdl") == 0);
// Do we have a real coclass w/ a real GUID?
if (pThisClassToken->IsSet(CLASS_GUID) &&
pThisClassToken->IsSet(CLASS_INTERFACE) && !fInternalPDL)
{
// Then let's do some COM+ work...
CString inheritDecl;
CString szClassName;
if (pThisClassToken->IsSet(CLASS_COCLASSNAME))
szClassName = pThisClassToken->GetTagValue(CLASS_COCLASSNAME);
else
szClassName = pThisClassToken->GetTagValue(CLASS_NAME);
// Window needs some special processing as this is how unmanaged code hooks to
// managed code.
if (szClassName == "HTMLWindow2")
{
fprintf(fpHComPlusFile, "[managed, com, uuid={FF6BF9BB-FF1B-348D-8C21-CE642A866E7F}] __interface ICOMPLUSHookWindow\n");
fprintf(fpHComPlusFile, "{\n");
fprintf(fpHComPlusFile, "public:\n");
fprintf(fpHComPlusFile, "\tvoid Init(unsigned int myThis);\n");
fprintf(fpHComPlusFile, "};\n\n");
}
// COM+ managed code:
fprintf(fpHComPlusFile, "[managed, coclass");
if (szClassName == "HTMLWindow2")
{
fprintf(fpHComPlusFile, " , uuid={D66BF9BF-FF1B-348D-8C21-CE642A866E7F}");
}
fprintf(fpHComPlusFile, "] class %sCOMPLUS", (LPCSTR)szClassName);
GenComPlusInheritance(pThisClassToken, inheritDecl);
if (inheritDecl.Length())
{
fprintf(fpHComPlusFile, " : %s", (LPCSTR)inheritDecl);
if (szClassName == "HTMLWindow2")
{
fprintf(fpHComPlusFile, ", private ICOMPLUSHookWindow");
}
fprintf(fpHComPlusFile, "\n{\n");
}
else
{
fprintf(fpHComPlusFile, "\n{\n");
}
fprintf(fpHComPlusFile, "private:\n");
fprintf(fpHComPlusFile, "\tunsigned int\t_myThis;\n\n");
fprintf(fpHComPlusFile, "public:\n");
fprintf(fpHComPlusFile, "\t%sCOMPLUS (unsigned int myThis)\n\t\t{ _myThis = myThis; }\n\n", (LPCSTR)szClassName);
fprintf(fpHComPlusFile, "\tunsigned int getCOMCookie()\n\t\t{ return _myThis; }\n\n");
if (szClassName == "HTMLWindow2")
{
fprintf(fpHComPlusFile, "\tHTMLWindow2COMPLUS ()\n");
fprintf(fpHComPlusFile, "\t\t{ _myThis = 0; }\n\n");
fprintf(fpHComPlusFile, "\tvoid Init(unsigned int myThis)\n\t\t{ _myThis = myThis; }\n\n");
}
}
#endif // COMPLUS_SHIM
CVTableHash VTableHash; // Special hashtable that aids in spitting out the hash table
// Add the parser properties to the PropdescInfo array
if(!GeneratePropdescReference(pThisClassToken, TRUE, rgPI, &nPI, bHookToCElement, &nSharedEntries ))
ReportError("Error Storing PropDescs in PROPDESC array in HashTable");
// Add the OM properties and methods to the PropdescInfo array
if (pInterf)
{
ComputeVTable( pThisClassToken,
pInterf,
FALSE,
rgPI,
&nPI,
&uVTblIndex,
&VTableHash,
bHookToCElement);
}
#ifdef COMPLUS_SHIM
if (pThisClassToken->IsSet(CLASS_GUID) &&
pThisClassToken->IsSet(CLASS_INTERFACE) && !fInternalPDL)
{
fprintf(fpHComPlusFile, "};\n\n\n");
}
#endif // COMPLUS_SHIM
// Number of entries in vtable array.
*pbHashTableExists = bHookToCElement || (nPI > 0);
// Write out the "style" mini-propdesc array if we are dealing with
// the element class. The reason we do this is because a parser and OM
// propdesc (both of which are different) resolve to the same entry in
// the hash table. Hence, we have to make a hack and have the name resolve
// to an array of propdescs.
if(strcmp(pThisClassToken->GetTagValue(CLASS_NAME), "CElement") == 0)
{
fprintf(fpHDLFile, "static const PROPERTYDESC *s_propdescCElementStyleArray [ ] = \n"
"{\n"
" (PROPERTYDESC *)&s_propdescCElementstyle,\n"
" (PROPERTYDESC *)&s_propdescCElementstyle_Str\n"
"};\n");
}
else if(strcmp(pThisClassToken->GetTagValue(CLASS_NAME), "CInput") == 0)
{
fprintf(fpHDLFile, "static const PROPERTYDESC *s_propdescCInputCheckedArray [ ] = \n"
"{\n"
" (PROPERTYDESC *)&s_propdescCInputchecked,\n"
" (PROPERTYDESC *)&s_propdescCInputdefaultChecked\n"
"};\n");
}
// Write out the hash table
// Convert the class to a Unicode string so that it works correctly
// with the hash table, which is Unicode.
WCHAR strUnicode[256];
int retVal =
MultiByteToWideChar(CP_ACP, 0, pThisClassToken->GetTagValue(CLASS_NAME),
256,
strUnicode, 256);
if(retVal == 0)
{
ReportError("Error: Unable to convert classname to a Unicode string");
return;
}
if(VTableHash.GetHashTableLength() > 1024)
{
ReportError("Error: Hash table size has grown beyond 10K. Find more bits!");
return;
}
if(VTableHash.ToFile(fpHDLFile,
strUnicode,
nSharedEntries) != S_OK)
{
ReportError("Error: Unable to write out hashtable");
return;
}
// Write out the Hash Table Aggregate
fprintf(fpHDLFile,
"const CPtrBagVTableAggregate %s::s_StringTableAggregate = {\n"
" {\n", pThisClassToken->GetTagValue(CLASS_NAME));
if(bHookToCElement)
fprintf(fpHDLFile, " (CPtrBagVTable *)&CElement::s_StringTable,\n");
// Every class aggregates to itself.
fprintf(fpHDLFile,
" (CPtrBagVTable *)&%s::s_StringTable,\n"
" NULL\n"
" }\n"
"};\n", pThisClassToken->GetTagValue(CLASS_NAME));
// Store away a special cache for the document
if(_stricmp(pThisClassToken->GetTagValue(CLASS_NAME), "COmWindowProxy") == 0)
{
DWORD index;
if(!VTableHash.GetIndex(_T("document"), &index))
{
ReportError("The document must exist in the COmWindowProxy");
return;
}
fprintf(fpHDLFile, "const VTABLEDESC * const COmWindowProxy::s_COmWindowProxyDocument = &s_AssocVTableCOmWindowProxy%d._VTableDesc;\n", index);
}
}
else
{
char szErrorText [ MAX_LINE_LEN+1 ];
sprintf( szErrorText, "Unknown interface %s\n", (LPCSTR) szInterf );
ReportError ( szErrorText );
}
}
void
CPDLParser::SortPropDescInfo (PropdescInfo *pPI, int cPDI)
{
int x, y, cc;
PropdescInfo pd;
//sort em
for (x = 0; x < cPDI - 1; ++x)
{
for (y = x; y < cPDI; ++y)
{
cc = _stricmp( pPI[x]._szSortKey, pPI[y]._szSortKey ); // API caveat
if (cc > 0)
{
memcpy(&pd, pPI + x, sizeof(pd));
memcpy(pPI + x, pPI + y, sizeof(pd));
memcpy(pPI + y, &pd, sizeof(pd));
}
}
}
}
BOOL
CPDLParser::ComputeVTable ( Token *pClass,
Token *pInterface,
BOOL fDerived,
PropdescInfo *pPI,
int *piPI,
UINT *pUVTblIdx,
CVTableHash *pVTableHash,
BOOL &bHookToCElement,
BOOL fNonPrimaryTearoff/*= FALSE*/ )
{
CString szSuperInterf;
Token *pChildToken;
int cFuncs = 0;
BOOL fProperty = FALSE;
int idxIIDPrimaryTearoff = -1;
int idxIID;
CString szInterface;
// Compute if this interface on the class is a primary interface tearoff.
if (!fNonPrimaryTearoff)
{
Token *pTearoff;
pTearoff = FindTearoff(pClass->GetTagValue(CLASS_NAME), pInterface->GetTagValue(INTERFACE_NAME));
if (pTearoff)
{
CString szInterface;
Token *pInterfaceToken;
szInterface = pTearoff->GetTagValue(TEAROFF_INTERFACE);
pInterfaceToken = FindInterface(szInterface);
// If primary interface is not derived from IDispatch then this
// interface and all derived interfaces (vtable layout) are separated
// not concatenated.
LPSTR szSuperPrimaryInterf = pInterfaceToken->GetTagValue(INTERFACE_SUPER);
if (szSuperPrimaryInterf && *szSuperPrimaryInterf)
fNonPrimaryTearoff = ((_stricmp(szSuperPrimaryInterf, "IDispatch") ||
(_stricmp(pClass->GetTagValue(CLASS_NAME), "CElement") == 0)));
else
{
fNonPrimaryTearoff = FALSE;
}
}
}
szInterface = pInterface->GetTagValue(INTERFACE_NAME);
// We want classes which have their primary interface IHTMLElement
// and are derived from CElement to hook to CElement
if((szInterface == "IHTMLElement") &&
(_stricmp(pClass->GetTagValue(CLASS_NAME), "CElement") != 0))
{
bHookToCElement = TRUE;
}
else
{
idxIID = FindAndAddIIDs(szInterface);
if (idxIID == -1)
{
ReportError("Problem with IID adding.\n");
return FALSE;
}
if (fNonPrimaryTearoff)
idxIIDPrimaryTearoff = idxIID;
szSuperInterf = pInterface->GetTagValue(INTERFACE_SUPER);
if (szSuperInterf && *szSuperInterf && szSuperInterf != "IDispatch")
{
Token *pSuperInterf;
pSuperInterf = FindInterface(szSuperInterf);
if (!pSuperInterf)
return FALSE;
if (!ComputeVTable(pClass,
pSuperInterf,
TRUE,
pPI,
piPI,
pUVTblIdx,
pVTableHash,
bHookToCElement,
fNonPrimaryTearoff))
return FALSE;
}
CTokenListWalker ChildList ( pInterface );
while ( pChildToken = ChildList.GetNext() )
{
UINT uIIDnVTbl;
cFuncs = 0;
if ( pChildToken -> GetType() == TYPE_PROPERTY )
{
fProperty = TRUE;
cFuncs = pChildToken -> IsSet ( PROPERTY_GET ) ? 1 : 0;
cFuncs += (pChildToken -> IsSet ( PROPERTY_SET ) ? 1 : 0);
if (pChildToken->IsSet(PROPERTY_NOPROPDESC))
goto AddInVTable;
}
else if ( pChildToken -> GetType() == TYPE_METHOD )
{
fProperty = FALSE;
cFuncs = 1;
if (pChildToken->IsSet(METHOD_NOPROPDESC))
goto AddInVTable;
}
else
{
ReportError ( "Unknown token type in ComputeVTable.\n" );
return FALSE;
}
// Compute vtable offset. If primary interface is a tearoff then set
// the offset and the idx into the IID table. Note, all indexes start
// at 1 (zero is reserved to imply classdesc primary interface).
uIIDnVTbl = fNonPrimaryTearoff ? (((idxIIDPrimaryTearoff + 1) << 8) | *pUVTblIdx) : *pUVTblIdx;
pPI[*piPI].SetVTable(pChildToken -> GetTagValue ( fProperty ? (int)PROPERTY_REFDTOCLASS : (int)METHOD_REFDTOCLASS ),
pChildToken -> GetTagValue ( fProperty ? (int)PROPERTY_NAME : (int)METHOD_NAME ),
FALSE, // Unused.
pChildToken -> GetTagValue ( PROPERTY_SZATTRIBUTE ),
uIIDnVTbl | PDLPARSE_BELONGSTOOM, // Computed IID/VTable where iidIdx might be zero for the primary interface.
fProperty,
idxIID, // Index of interface
pChildToken);
(*piPI)++;
AddInVTable:
(*pUVTblIdx) += cFuncs;
}
}
// Each derived interface of the primary tearoff is separated not a straight
// derivation.
if (fNonPrimaryTearoff && _stricmp(szInterface, "IHTMLDocument"))
*pUVTblIdx = 0;
// Top most interface?
if ( !fDerived )
{
// Now check for any other interfaces mentioned in the as implements in
// the class it is exposed in the coclass, that interface is a
// separately supported interface.
CTokenListWalker ChildWalker(pClass);
Token *pChildToken;
CString szInterface;
Token *pInterfToken;
while (pChildToken = ChildWalker.GetNext())
{
if (pChildToken->GetType() == TYPE_IMPLEMENTS)
{
*pUVTblIdx = 0; // implements always starts at 0 vtable offset.
szInterface = pChildToken->GetTagValue(IMPLEMENTS_NAME);
if(_stricmp(pInterface->GetTagValue(INTERFACE_NAME), szInterface) == 0)
continue;
// TODO: TerryLu - Need to add code here to recongize and handle
// shares. Currently, we hardcode the following interfaces
// as once which are shared and implemented by CElement directly
if (szInterface == "IHTMLElement6")
{
ReportError ( "Need to Add IHTMLElement6 in parser.cxx(ComputeVTable())" );
return FALSE;
}
if ( ((szInterface == "IHTMLElement") ||
(szInterface == "IHTMLElement2") ||
(szInterface == "IHTMLElement3") ||
(szInterface == "IHTMLElement4") ||
(szInterface == "IHTMLElement5") ) &&
((_stricmp(pClass->GetTagValue(CLASS_NAME), "CElement") != 0)) )
{
bHookToCElement = TRUE;
continue;
}
pInterfToken = FindInterface(szInterface);
if (pInterfToken)
{
if (!ComputeVTable(pClass,
pInterfToken,
TRUE,
pPI,
piPI,
pUVTblIdx,
pVTableHash,
bHookToCElement,
TRUE))
return FALSE;
}
}
}
// Output the vtable interface sorted by name.
for (int iVTbl = 0; iVTbl < *piPI; iVTbl++)
{
PropdescInfo *pPrevPropdescInfo;
// Convert the sort key to unicode since the HashTable is in Unicode
WCHAR strUnicode[256];
int retVal =
MultiByteToWideChar(CP_ACP, 0, pPI[iVTbl]._szSortKey,
256,
strUnicode, 256);
if(retVal == 0)
{
ReportError("Unable to convert class name to Unicode");
return FALSE;
}
// Change the style property to point to a special array
// of PropertyDescs if we are dealing with the CElement class
if((_stricmp(pPI[iVTbl]._szSortKey, "style") == 0) &&
(_stricmp(pClass->GetTagValue(CLASS_NAME), "CElement") == 0))
{
pPI[iVTbl]._szPropName = "StyleArray";
pPI[iVTbl]._uVTblIndex |= PDLPARSE_PROPDESCARRAY;
pPI[iVTbl]._uVTblIndex |= PDLPARSE_BELONGSTOBOTH;
}
else if((_stricmp(pPI[iVTbl]._szSortKey, "checked") == 0) &&
(_stricmp(pClass->GetTagValue(CLASS_NAME), "CInput") == 0))
// Change the checked property to point to a special array
// of PropertyDescs if we are dealing with the CInput class
{
pPI[iVTbl]._szPropName = "CheckedArray";
pPI[iVTbl]._uVTblIndex |= PDLPARSE_PROPDESCARRAY;
pPI[iVTbl]._uVTblIndex |= PDLPARSE_BELONGSTOBOTH;
}
// If the hash table entry was already set by the parser,
// make it a shared entry by the parser and OM.
pPrevPropdescInfo = (PropdescInfo *)pVTableHash->GetCi(strUnicode);
if(pPrevPropdescInfo)
{
// We cannot have two different properties map to the same name
// unless they are ones we already know about
if((_stricmp(pPrevPropdescInfo->_szPropName, pPI[iVTbl]._szPropName) != 0) &&
(_stricmp(pPI[iVTbl]._szSortKey, "checked") != 0) &&
(_stricmp(pPI[iVTbl]._szSortKey, "style") != 0))
{
ReportError("We cannot have two different properties map to the same name");
return FALSE;
}
pPI[iVTbl]._uVTblIndex |= PDLPARSE_BELONGSTOBOTH;
}
// Set the entry in the hash table
if(pVTableHash->SetCi(strUnicode,
&pPI[iVTbl]) != S_OK)
{
ReportError("Error: Unable to add Hash entry to table");
return FALSE;
}
#ifdef COMPLUS_SHIM
// ***TLL*** COM+: Not spitting COM+ proxies for internal.pdl and mshtmext.pdl need to do, shouldn't special case.
BOOL fInternalPDL = (_stricmp(_pszPDLFileName, "internal.pdl") == 0) || (_stricmp(_pszPDLFileName, "mshtmext.pdl") == 0);
// Output COM+ code, only real classes are exposed.
if (pClass->IsSet(CLASS_GUID) && pClass->IsSet(CLASS_INTERFACE) && !fInternalPDL)
{
GenComPlusDeclarations(pClass, pPI + iVTbl);
}
#endif // COMPLUS_SHIM
}
}
return TRUE;
}
#ifdef COMPLUS_SHIM
void
CPDLParser::GenComPlusMethodsInInterfaces(Token *pInterfaceToken, Token *pClass /* =NULL */)
{
Token *pChildToken;
CString szMethodName;
CString szPropertyName;
CString argCStr;
CString resultCStr;
CTokenListWalker ChildWalker(pInterfaceToken);
while (pChildToken = ChildWalker.GetNext())
{
if (pChildToken->GetType() == TYPE_METHOD)
{
// ***TLL*** Need to handle vararg arguments. [METHOD_VARARG]
if (pChildToken->IsSet(METHOD_NOPROPDESC) &&
pChildToken->IsSet(METHOD_SZINTERFACEEXPOSE))
{
szMethodName = pChildToken->GetTagValue(METHOD_SZINTERFACEEXPOSE);
}
else
{
szMethodName = pChildToken->GetTagValue(METHOD_NAME);
}
if (GenComPlusArgumentSignature(pChildToken, resultCStr, argCStr))
{
fprintf(fpHComPlusFile, "\t%s %s %s;\n",
(LPCSTR)resultCStr,
(LPCSTR)szMethodName,
(LPCSTR)argCStr);
}
}
else // Property
{
if (pChildToken->IsSet(PROPERTY_NOPROPDESC) &&
pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE))
{
szPropertyName = pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE);
}
else
{
szPropertyName = pChildToken->GetTagValue(PROPERTY_NAME);
}
if (pChildToken->IsSet(PROPERTY_SET))
{
// ***TLL*** COM+: What happens to displaybind, bindable, hidden, restricted, nonbrowsable, source.
if (GenComPlusArgumentSignature(pChildToken, resultCStr, argCStr, SetProperty))
{
fprintf(fpHComPlusFile, "\t%s %s %s;\n",
(LPCSTR)resultCStr,
(LPCSTR)szPropertyName,
(LPCSTR)argCStr);
}
}
if (pChildToken->IsSet(PROPERTY_GET))
{
// ***TLL*** COM+: What happens to displaybind, bindable, hidden, restricted, nonbrowsable, source.
if (GenComPlusArgumentSignature(pChildToken, resultCStr, argCStr, GetProperty))
{
fprintf(fpHComPlusFile, "\t%s %s %s;\n",
(LPCSTR)resultCStr,
(LPCSTR)szPropertyName,
(LPCSTR)argCStr);
}
}
}
}
}
void
CPDLParser::GenComPlusInterfaces(Token *pInterfaceToken, char* pszSuper)
{
CString szInterf;
Token *pSuperInterf;
#if 0
if (_stricmp("IHTMLStyle", pInterfaceToken->GetTagValue(NAME_TAG)) == 0)
__asm { int 3 };
#endif
if (!PrimaryTearoff(pInterfaceToken) && (!pszSuper || !*pszSuper))
ReportError("COM+: Interfaces w/o tearoff need super:IDispatch\n");
// ***TLL*** COM+: For now don't expose any IUnknown derived classes.
if (_stricmp(pszSuper, "IUnknown") == 0)
return;
// Is the super derived from IUnknown?
szInterf = pszSuper;
pSuperInterf = FindInterface(szInterf);
if (pSuperInterf)
{
if (_stricmp(pSuperInterf->GetTagValue(INTERFACE_SUPER), "IUnknown") == 0)
return;
}
// ***TLL*** End of comment section
if (pInterfaceToken->IsSet(INTERFACE_CUSTOM) && pszSuper && *pszSuper)
{
fprintf(fpHComPlusFile, "[managed, com] interface %sCOMPLUS : public ICOMCookie, public %sCOMPLUS\n{\npublic:\n",
pInterfaceToken->GetTagValue(NAME_TAG),
pszSuper);
}
else
{
if (PrimaryTearoff(pInterfaceToken))
{
fprintf(fpHComPlusFile, "[managed, com] interface %sCOMPLUS : public ICOMCookie \n{\npublic:\n",
pInterfaceToken->GetTagValue(NAME_TAG));
}
else
{
if (strcmp("IDispatch", pszSuper) == 0)
{
fprintf(fpHComPlusFile, "[managed, com] interface %sCOMPLUS : public ICOMCookie \n{\npublic:\n",
pInterfaceToken->GetTagValue(NAME_TAG));
}
else
{
fprintf(fpHComPlusFile, "[managed, com] interface %sCOMPLUS : public ICOMCookie, public %sCOMPLUS \n{\npublic:\n",
pInterfaceToken->GetTagValue(NAME_TAG), pszSuper);
}
}
}
// Fill in methods of interface:
GenComPlusMethodsInInterfaces(pInterfaceToken);
fprintf(fpHComPlusFile, "};\n\n");
}
void
CPDLParser::GenComPlusESI()
{
CTokenListWalker ThisFileList(pRuntimeList, _pszPDLFileName);
Token * pInterfaceToken;
Token * pEnumToken;
Token * pStructToken;
//
// Generate all the event interfaces
//
ThisFileList.Reset();
while (pInterfaceToken = ThisFileList.GetNext(TYPE_EVENT))
{
if (!pInterfaceToken->IsSet(EVENT_ABSTRACT) &&
pInterfaceToken->IsSet(EVENT_GUID))
{
// TODO: ***TLL*** Need to spit out event interfaces.
}
}
//
// Generate all the enumerators.
//
ThisFileList.Reset();
while (pEnumToken = ThisFileList.GetNext(TYPE_ENUM))
{
// TODO: ***TLL*** Need to spit out enums.
}
//
// Generate all the structs
//
ThisFileList.Reset();
while (pStructToken = ThisFileList.GetNext(TYPE_STRUCT))
{
// TODO: ***TLL*** Need to spit out structs.
}
//
// Generate all the non-abstract interfaces.
//
ThisFileList.Reset();
while ( pInterfaceToken = ThisFileList.GetNext(TYPE_INTERFACE))
{
if (!pInterfaceToken->IsSet(INTERFACE_ABSTRACT) &&
pInterfaceToken->IsSet(INTERFACE_GUID))
{
GenComPlusInterfaces(pInterfaceToken, pInterfaceToken->GetTagValue(INTERFACE_SUPER));
}
else if (!pInterfaceToken->IsSet(INTERFACE_ABSTRACT) &&
!pInterfaceToken->IsSet(INTERFACE_GUID))
{
// Generate a forward declare
CString szInterfaceName;
szInterfaceName = pInterfaceToken->GetTagValue(INTERFACE_NAME);
if (szInterfaceName != "IDispatch" && szInterfaceName != "IUnknown")
{
fprintf(fpHComPlusFile, "interface %sCOMPLUS;\n", pInterfaceToken->GetTagValue(NAME_TAG));
}
}
}
}
BOOL
CPDLParser::GenComPlusArgumentSignature(Token *pMethod, CString & resultCStr, CString & argCStr, PropertyType propType /* = NotProperty */)
{
BOOL fNameOnly;
LPCSTR pSimpleType;
char pComPlusType[128];
BOOL fRet = FALSE; // Assume don't want to expose method/property
resultCStr = "";
argCStr = "";
fNameOnly = _stricmp(pMethod->GetTagValue(METHOD_NOPROPDESC), "nameonly") == 0;
if (pMethod->GetType() == TYPE_METHOD && !fNameOnly)
{
CTokenListWalker ArgListWalker(pMethod);
BOOL fResultFound = FALSE;
CString szAutomationType;
Token *pArgToken;
int cAType;
while (pArgToken = ArgListWalker.GetNext())
{
if (pArgToken->IsSet(METHODARG_RETURNVALUE))
{
szAutomationType = pArgToken->IsSet(METHODARG_ATYPE) ?
pArgToken->GetTagValue(METHODARG_ATYPE) :
pArgToken->GetTagValue(METHODARG_TYPE);
cAType = szAutomationType.Length();
if (cAType && szAutomationType[cAType - 2] == '*')
{
szAutomationType.PutChar(cAType - 2, '\0');
}
else if (cAType && szAutomationType[cAType - 1] == '*')
{
szAutomationType.PutChar(cAType - 1, '\0');
}
#if 0
if (szAutomationType == "IHTMLControlElement")
__asm {int 3};
#endif
pSimpleType = ConvertType(szAutomationType, TRUE, &pComPlusType[0]);
resultCStr = pSimpleType ? pSimpleType : pComPlusType;
fResultFound = TRUE;
}
}
if (!fResultFound)
{
resultCStr = "void";
}
BOOL fFirst = TRUE;
int idx = 1;
char buffer[40];
argCStr = "(";
ArgListWalker.Reset();
while (pArgToken = ArgListWalker.GetNext())
{
if (!pArgToken->IsSet(METHODARG_RETURNVALUE))
{
if (!fFirst)
{
argCStr += ", ";
}
szAutomationType = pArgToken->GetTagValue(METHODARG_TYPE);
cAType = szAutomationType.Length();
if (cAType && szAutomationType[cAType - 1] == '*')
{
szAutomationType.PutChar(cAType - 1, '\0');
}
pSimpleType = ConvertType(szAutomationType, TRUE, &pComPlusType[0]);
argCStr += pSimpleType ? pSimpleType : pComPlusType;
argCStr += " param";
_itoa(idx++, buffer, 10);
argCStr += buffer;
}
fFirst = FALSE;
}
argCStr += ")";
fRet = TRUE;
}
else
{
// Property
CString szAutomationType;
int cAType;
fNameOnly = _stricmp(pMethod->GetTagValue(PROPERTY_NOPROPDESC), "nameonly") == 0;
szAutomationType = pMethod->GetTagValue(PROPERTY_ATYPE);
cAType = szAutomationType.Length();
if (szAutomationType[cAType - 1] == '*')
{
szAutomationType.PutChar(cAType - 1, '\0');
}
pSimpleType = ConvertType(szAutomationType, TRUE, &pComPlusType[0]);
if (propType == SetProperty && !fNameOnly )
{
resultCStr = "void";
argCStr = "(";
argCStr += pSimpleType ? pSimpleType : pComPlusType;
argCStr += " param1)";
fRet = TRUE;
}
if (propType == GetProperty && !fNameOnly)
{
resultCStr = pSimpleType ? pSimpleType : pComPlusType;
argCStr = "()";
fRet = TRUE;
}
}
return fRet;
}
void
CPDLParser::GenComPlusDeclarations(Token *pClass, PropdescInfo *pPI)
{
BOOL fNameOnly;
LPCSTR pSimpleType;
char pComPlusType[128];
int uIIDIdx;
int uVTblIdx;
CString szClassName;
szClassName = pClass->IsSet(CLASS_COCLASSNAME) ? pClass->GetTagValue(CLASS_COCLASSNAME) : pClass->GetTagValue(CLASS_NAME);
#if 0
//if (pPI->_pToken->GetType() == TYPE_METHOD && _stricmp("fireEvent", (LPSTR)pPI->_pToken->GetTagValue(METHOD_NAME)) == 0)
if (pPI->_pToken->GetType() == TYPE_PROPERTY && _stricmp("bookmarks", (LPSTR)pPI->_pToken->GetTagValue(PROPERTY_NAME)) == 0)
__asm {int 3};
#endif
uIIDIdx = pPI->_uIIDIndex + 1; // zero is reserved for error.
uVTblIdx = (((pPI->_uVTblIndex & 0x00ff) + 7) * 4);
fNameOnly = _stricmp(pPI->_pToken->GetTagValue(METHOD_NOPROPDESC), "nameonly") == 0;
if (pPI->_pToken->GetType() == TYPE_METHOD && !fNameOnly)
{
CTokenListWalker ArgListWalker(pPI->_pToken);
BOOL fResultFound = FALSE;
CString szAutomationType;
Token *pArgToken;
int cAType;
CString szTypesSig;
CString szArgsType;
int cArgs = 0;
int cRequiredArgs = 0;
char *pDefaultParams[MAX_ARGS] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
char *pDefaultStrParams[MAX_ARGS] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
BOOL fBSTRArg;
BOOL fVARIANTArg;
BOOL fObjectReturn = FALSE;
ParamType objectParam[MAX_ARGS] = { CPDLParser::None, CPDLParser::None, CPDLParser::None, CPDLParser::None, CPDLParser::None, CPDLParser::None, CPDLParser::None, CPDLParser::None };
while (pArgToken = ArgListWalker.GetNext())
{
if (pArgToken->IsSet(METHODARG_RETURNVALUE))
{
szAutomationType = pArgToken->IsSet(METHODARG_ATYPE) ?
pArgToken->GetTagValue(METHODARG_ATYPE) :
pArgToken->GetTagValue(METHODARG_TYPE);
cAType = szAutomationType.Length();
if (cAType && szAutomationType[cAType - 2] == '*')
{
szAutomationType.PutChar(cAType - 2, '\0');
fObjectReturn = szAutomationType != "Variant";
}
else if (cAType && szAutomationType[cAType - 1] == '*')
{
szAutomationType.PutChar(cAType - 1, '\0');
fObjectReturn = szAutomationType != "Variant";
}
pSimpleType = ConvertType(szAutomationType, TRUE, &pComPlusType[0]);
if (pSimpleType)
{
// IUknown or IDispatch return value is an unsigned int from CPThunks
if (_stricmp(pSimpleType, "Object") != 0)
{
// VARIANT_BOOL, int's, etc. returned are not objects.
fObjectReturn = FALSE;
}
}
fprintf(fpCComPlusFile, "%s\n", pSimpleType ? pSimpleType : pComPlusType);
if (!pSimpleType)
{
if (_stricmp(pComPlusType, "Object") == 0)
{
strcpy(pComPlusType, "unsigned int");
}
}
fprintf(fpHComPlusFile, "\t%s ", pSimpleType ? pSimpleType : pComPlusType);
fResultFound = TRUE;
}
}
if (!fResultFound)
{
fprintf(fpHComPlusFile, "\tvoid ");
fprintf(fpCComPlusFile, "void\n");
}
fprintf(fpCComPlusFile, "%sCOMPLUS::", (LPCSTR)szClassName);
// Method
fprintf(fpHComPlusFile, "\t%s (", pPI->_pToken->IsSet(METHOD_SZINTERFACEEXPOSE) ?
(LPSTR)pPI->_pToken->GetTagValue(METHOD_SZINTERFACEEXPOSE) :
(LPSTR)pPI->_pToken->GetTagValue(METHOD_NAME));
fprintf(fpCComPlusFile, "%s (", pPI->_pToken->IsSet(METHOD_SZINTERFACEEXPOSE) ?
(LPSTR)pPI->_pToken->GetTagValue(METHOD_SZINTERFACEEXPOSE) :
(LPSTR)pPI->_pToken->GetTagValue(METHOD_NAME));
BOOL fFirst = TRUE;
int idx = 1;
BOOL fAnyDynamicCasts = FALSE;
ArgListWalker.Reset();
while (pArgToken = ArgListWalker.GetNext())
{
if (!pArgToken->IsSet(METHODARG_RETURNVALUE))
{
if (!fFirst)
{
fprintf(fpHComPlusFile, ", ");
fprintf(fpCComPlusFile, ", ");
}
szAutomationType = pArgToken->GetTagValue(METHODARG_TYPE);
cAType = szAutomationType.Length();
if (cAType && szAutomationType[cAType - 1] == '*')
{
szAutomationType.PutChar(cAType - 1, '\0');
if (szAutomationType == "IUnknown" || szAutomationType == "IDispatch")
{
objectParam[idx - 1] = CPDLParser::AnyObject;
}
else if (szAutomationType != "Variant")
{
objectParam[idx - 1] = CPDLParser::Object;
}
}
pSimpleType = ConvertType(szAutomationType, TRUE, &pComPlusType[0]);
if (pSimpleType)
{
// IUknown or IDispatch return value is an unsigned int from CPThunks
if (_stricmp(pSimpleType, "Object") != 0)
{
// VARIANT_BOOL, int's, etc. returned are not objects.
objectParam[idx - 1] = CPDLParser::None;
}
}
fprintf(fpHComPlusFile, "%s param%i", pSimpleType ? pSimpleType : pComPlusType, idx);
fprintf(fpCComPlusFile, "%s param%i", pSimpleType ? pSimpleType : pComPlusType, idx++);
}
fFirst = FALSE;
}
fprintf(fpHComPlusFile, ");\n");
fprintf(fpCComPlusFile, ")\n");
fprintf(fpCComPlusFile, "{\n");
if (BuildMethodSignature(pPI->_pToken,
szTypesSig,
szArgsType,
fBSTRArg,
fVARIANTArg,
cArgs,
cRequiredArgs,
pDefaultParams,
pDefaultStrParams))
{
CString szFullSignature;
BOOL fAtLeastOne = FALSE;
int i;
if (fObjectReturn)
{
fprintf(fpCComPlusFile, "\tunsigned int myPDispatch;\n\n");
}
for (i = 0; i < cArgs; i++)
{
if (objectParam[i] & CPDLParser::GenericObject)
{
fprintf(fpCComPlusFile, "\tICOMCookie tempParam%i = dynamic_cast<ICOMCookie>(param%i);\n", i + 1, i + 1);
fAtLeastOne = TRUE;
}
}
if (fAtLeastOne)
{
fprintf(fpCComPlusFile, "\n");
}
// If no return value then set the retVal to void.
if (!szTypesSig[0])
{
szTypesSig = "void";
}
// If no arguments then set the argList to void.
if (!szArgsType[0])
{
szArgsType = "_void";
}
szTypesSig += szArgsType;
MakeSignature("Method", szTypesSig, szFullSignature);
if (fResultFound)
{
fprintf(fpCComPlusFile, "\t%s", fObjectReturn ? "myPDispatch = " : "return ");
}
else
{
fprintf(fpCComPlusFile, "\t");
}
fprintf(fpCComPlusFile, "CPThunks::COMPLUS_%s(_myThis, %i, %i", (LPCSTR)szFullSignature, uIIDIdx, uVTblIdx);
for (i = 0; i < cArgs; i++)
{
if (objectParam[i] & CPDLParser::GenericObject)
{
fprintf(fpCComPlusFile, ", tempParam%i.getCOMCookie()", i + 1);
}
else if (objectParam[i] & CPDLParser::Object)
{
fprintf(fpCComPlusFile, ", param%i.getCOMCookie()", i + 1);
}
else
{
fprintf(fpCComPlusFile, ", param%i", i + 1);
}
}
fprintf(fpCComPlusFile, ");\n");
}
if (fObjectReturn)
{
// ***TLL*** COM+: Need to create class for return value. For now just return 0.
// Should be something like "return new HTMLDOMNodeCOMPLUS(myPDispatch)" where HTMLDOMNodeCOMPLUS
// is a COM+ class.
if (fObjectReturn)
{
fprintf(fpCComPlusFile, "\n");
}
fprintf(fpCComPlusFile, "\treturn 0;\n");
}
fprintf(fpCComPlusFile, "}\n\n");
}
else
{
// Property
CString szAutomationType;
int cAType;
ParamType propertyParam = CPDLParser::None;
BOOL fInterfaceFound;
fNameOnly = _stricmp(pPI->_pToken->GetTagValue(PROPERTY_NOPROPDESC), "nameonly") == 0;
szAutomationType = pPI->_pToken->GetTagValue(PROPERTY_ATYPE);
cAType = szAutomationType.Length();
if (szAutomationType[cAType - 1] == '*')
{
szAutomationType.PutChar(cAType - 1, '\0');
}
if (cAType && szAutomationType[cAType - 1] == '*')
{
szAutomationType.PutChar(cAType - 1, '\0');
if (szAutomationType == "IUnknown" || szAutomationType == "IDispatch")
{
propertyParam = CPDLParser::AnyObject;
}
else if (szAutomationType != "Variant")
{
propertyParam = CPDLParser::Object;
}
}
pSimpleType = ConvertType(szAutomationType, TRUE, &pComPlusType[0], &fInterfaceFound);
if (pSimpleType)
{
// IUknown or IDispatch return value is an unsigned int from CPThunks
if (_stricmp(pSimpleType, "Object") != 0)
{
// VARIANT_BOOL, int's, etc. returned are not objects.
propertyParam = CPDLParser::None;
}
}
if (pPI->_pToken->IsSet(PROPERTY_SET) && !fNameOnly )
{
fprintf(fpHComPlusFile, "\tvoid\t%s (%s param1);\n",
pPI->_pToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_NAME),
pSimpleType ? pSimpleType : pComPlusType);
fprintf(fpCComPlusFile, "void\n%sCOMPLUS::%s (%s param1)\n",
(LPCSTR)szClassName,
pPI->_pToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_NAME),
pSimpleType ? pSimpleType : pComPlusType);
fprintf(fpCComPlusFile, "{\n");
if (pSimpleType)
{
if (_stricmp(pSimpleType, "String") == 0)
{
fprintf(fpCComPlusFile, "\tCPThunks::COMPLUS_S_String(_myThis, %i, %i, param1);\n", uIIDIdx, uVTblIdx);
}
else if (_stricmp(pSimpleType, "Object") == 0 )
{
fprintf(fpCComPlusFile, "\tunsigned int tempParam1 = dynamic_cast<ICOMCookie>(param1).getCOMCookie();\n");
fprintf(fpCComPlusFile, "\tCPThunks::COMPLUS_S_IDispatchp(_myThis, %i, %i, tempParam1);\n", pSimpleType, uIIDIdx, uVTblIdx);
}
else
{
fprintf(fpCComPlusFile, "\tCPThunks::COMPLUS_S_%s(_myThis, %i, %i, param1);\n", pSimpleType, uIIDIdx, uVTblIdx);
}
}
else if (fInterfaceFound)
{
fprintf(fpCComPlusFile, "\tCPThunks::COMPLUS_S_IDispatchp(_myThis, %i, %i, param1.getCOMCookie());\n", uIIDIdx, uVTblIdx);
}
else
{
fprintf(fpCComPlusFile, "\tCPThunks::COMPLUS_S_%s(_myThis, %i, %i, param1);\n", pComPlusType, uIIDIdx, uVTblIdx);
}
fprintf(fpCComPlusFile, "}\n\n");
}
if (pPI->_pToken->IsSet(PROPERTY_GET) && !fNameOnly)
{
fprintf(fpHComPlusFile, "\t%s\t%s ();\n",
pSimpleType ? pSimpleType : pComPlusType,
pPI->_pToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_NAME));
fprintf(fpCComPlusFile, "%s\n%sCOMPLUS::%s ()\n",
pSimpleType ? pSimpleType : pComPlusType,
(LPCSTR)szClassName,
pPI->_pToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_NAME));
fprintf(fpCComPlusFile, "{\n");
if (pSimpleType)
{
if (_stricmp(pSimpleType, "String") == 0)
{
fprintf(fpCComPlusFile, "\treturn CPThunks::COMPLUS_G_String(_myThis, %i, %i);\n", uIIDIdx, uVTblIdx + 1);
}
else if (_stricmp(pSimpleType, "Object") == 0)
{
// return IUnknown or IDispatch (not a qualified interface like IHTMLnnnnn).
fprintf(fpCComPlusFile, "\tunsigned int\tmyPDispatch;\n\n");
fprintf(fpCComPlusFile, "\tmyPDispatch = CPThunks::COMPLUS_G_%s(_myThis, %i, %i);\n", pSimpleType, uIIDIdx, uVTblIdx + 1);
//TODO: ***TLL*** COM+: Hook up document property of Window. Need generic mechanism here.
if (_stricmp((LPCSTR)szClassName, "HTMLWindow2") == 0)
{
if (_stricmp(pPI->_pToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_NAME),
"document") == 0)
{
fprintf(fpCComPlusFile, "return new HTMLDocumentCOMPLUS(myPDispatch);\n");
fprintf(fpCComPlusFile, "//"); // comment the next return spit out
}
}
// TODO: ***TLL*** COM+: Need to return (coclass) object stuffed myPDispatch. Remove return 0; and used below commented out line.
fprintf(fpCComPlusFile, "\treturn 0;\n");
// fprintf(fpCComPlusFile, "\treturn new %s(myPDispatch);\n", pComPlusType);
}
else
{
fprintf(fpCComPlusFile, "\treturn CPThunks::COMPLUS_G_%s(_myThis, %i, %i);\n", pSimpleType, uIIDIdx, uVTblIdx + 1);
}
}
else if (_stricmp(pComPlusType, "Variant") == 0)
{
fprintf(fpCComPlusFile, "\tunsigned int\tmyPVariant;\n\n");
fprintf(fpCComPlusFile, "\tmyPVariant = CPThunks::COMPLUS_G_%s(_myThis, %i, %i);\n\n", "VARIANT", uIIDIdx, uVTblIdx + 1);
fprintf(fpCComPlusFile, "\treturn new Variant(myPVariant);\n");
}
else
{
fprintf(fpCComPlusFile, "\tunsigned int\tmyPDispatch;\n\n");
fprintf(fpCComPlusFile, "\tmyPDispatch = CPThunks::COMPLUS_G_%s(_myThis, %i, %i);\n\n", "Object", uIIDIdx, uVTblIdx + 1);
//TODO: ***TLL*** COM+: Hook up document property of Window. Need generic mechanism here.
if (_stricmp((LPCSTR)szClassName, "HTMLWindow2") == 0)
{
if (_stricmp(pPI->_pToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pPI->_pToken->GetTagValue(PROPERTY_NAME),
"document") == 0)
{
fprintf(fpCComPlusFile, "return new HTMLDocumentCOMPLUS(myPDispatch);\n");
fprintf(fpCComPlusFile, "//"); // comment the next return spit out
}
}
// ***TLL*** COM+: Need to return (coclass) object stuffed myPDispatch. Remove return 0; and used below commented out line.
fprintf(fpCComPlusFile, "\treturn 0;\n");
// fprintf(fpCComPlusFile, "\treturn new %s(myPDispatch);\n", pComPlusType);
}
fprintf(fpCComPlusFile, "}\n\n");
}
}
}
#endif // COMPLUS_SHIM
BOOL
CPDLParser::ComputePROPDESC_STRUCT ( FILE *fp, Token *pClassToken, Token *pChild, CString & szHandler, CString & szFnPrefix )
{
char szErrorText [ MAX_LINE_LEN+1 ];
fprintf ( fp, "EXTERN_C const " );
if ( !pChild->IsSet ( PROPERTY_ABSTRACT ) && szHandler == "Num" || szHandler == "Enum" || szHandler == "UnitValue" )
{
// Numeric Handlers
if ( pChild->IsSet ( PROPERTY_GETSETMETHODS ) )
{
fprintf ( fp, "PROPERTYDESC_NUMPROP_GETSET" );
}
else if ( pChild->IsSet ( PROPERTY_ABSTRACT ) )
{
fprintf ( fp, "PROPERTYDESC_NUMPROP_ABSTRACT" );
}
else if ( pChild->IsSet ( PROPERTY_ENUMREF ) )
{
fprintf ( fp, "PROPERTYDESC_NUMPROP_ENUMREF" );
}
else
{
fprintf ( fp, "PROPERTYDESC_NUMPROP" );
}
}
else
{
// BASIC PROP PARAM Structure
if ( pChild->IsSet ( PROPERTY_GETSETMETHODS ) )
{
if ( szFnPrefix == "" )
{
sprintf ( szErrorText, "Invalid Type:%s in Class:%s Property:%s\n",
(LPCSTR)pChild->GetTagValue ( PROPERTY_TYPE ),
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME),
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
fprintf ( fp, "PROPERTYDESC_%s_GETSET", (LPCSTR)szFnPrefix );
}
else if ( pChild->IsSet ( PROPERTY_ABSTRACT ) )
{
fprintf ( fp, "PROPERTYDESC_BASIC_ABSTRACT" );
}
else
{
fprintf ( fp, "PROPERTYDESC_BASIC" );
}
}
return TRUE;
}
Token * CPDLParser::FindEnum ( Token *pChild )
{
// Get the enum mask from the enum named by PROPERTY_TYPE
CTokenListWalker WholeList ( pRuntimeList );
return WholeList.GetNext ( TYPE_ENUM, pChild->GetTagValue ( PROPERTY_TYPE ) );
}
char * CPDLParser::MapTypeToIDispatch ( CString & szType )
{
CString szHandler;
CString szFnPrefix;
char szStrType[255];
strcpy(szStrType, (LPCSTR)szType);
if (GetTypeDetails (szStrType, szHandler, szFnPrefix, NULL) && (szHandler == "object"))
{
int cSz = szType.Length();
if (szType[cSz - 1] == '*' && szType[cSz - 2] == '*')
{
// is it an IUnknown or an IDispatch?
if (_strnicmp(szType, "IUnknown", cSz-2)==0)
return "IUnknownpp";
else
return "IDispatchpp";
}
else if (szType[cSz - 1] == '*')
{
// is it an IUnknown or an IDispatch?
if (_strnicmp(szType, "IUnknown",cSz-1)==0)
return "IUnknownp";
else
return "IDispatchp";
}
}
return NULL;
}
Token * CPDLParser::FindEventMethod(Token *pClassToken, LPCSTR szEvent)
{
Token *pChildToken;
CTokenListWalker WholeList(pRuntimeList);
WholeList.Reset();
Token *pEventToken = WholeList.GetNext(TYPE_EVENT, pClassToken->GetTagValue(CLASS_EVENTS));
if (pEventToken)
{
CTokenListWalker ChildList(pEventToken);
while (pChildToken = ChildList.GetNext())
{
if (_stricmp(pChildToken->GetTagValue(METHOD_NAME), szEvent) == 0)
return pChildToken;
}
}
WholeList.Reset();
pEventToken = WholeList.GetNext(TYPE_EVENT, pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS1));
if (!pEventToken)
return NULL;
{
CTokenListWalker ChildList(pEventToken);
while (pChildToken = ChildList.GetNext())
{
if (_stricmp(pChildToken->GetTagValue(METHOD_NAME), szEvent) == 0)
return pChildToken;
}
}
WholeList.Reset();
pEventToken = WholeList.GetNext(TYPE_EVENT, pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS2));
if (!pEventToken)
return NULL;
{
CTokenListWalker ChildList(pEventToken);
while (pChildToken = ChildList.GetNext())
{
if (_stricmp(pChildToken->GetTagValue(METHOD_NAME), szEvent) == 0)
return pChildToken;
}
}
WholeList.Reset();
pEventToken = WholeList.GetNext(TYPE_EVENT, pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS3));
if (!pEventToken)
return NULL;
{
CTokenListWalker ChildList(pEventToken);
while (pChildToken = ChildList.GetNext())
{
if (_stricmp(pChildToken->GetTagValue(METHOD_NAME), szEvent) == 0)
return pChildToken;
}
}
WholeList.Reset();
pEventToken = WholeList.GetNext(TYPE_EVENT, pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS4));
if (!pEventToken)
return NULL;
{
CTokenListWalker ChildList(pEventToken);
while (pChildToken = ChildList.GetNext())
{
if (_stricmp(pChildToken->GetTagValue(METHOD_NAME), szEvent) == 0)
return pChildToken;
}
}
return NULL;
}
Token * CPDLParser::FindEventProp(Token *pClassToken, LPCSTR szEvent)
{
Token *pChild;
CTokenListWalker ChildList ( pClassToken );
while ( pChild = ChildList.GetNext() )
{
if ( pChild->nType == TYPE_PROPERTY &&
pChild->IsSet(PROPERTY_SCRIPTLET) &&
_stricmp(pChild->GetTagValue(PROPERTY_NAME), szEvent) == 0 )
return pChild;
}
return NULL;
}
BOOL CPDLParser::ComputeProperty ( Token *pClassToken, Token *pChild )
{
CString szClass;
CString szHandler;
CString szFnPrefix;
CString szHTMLName;
char szExposedName [ MAX_LINE_LEN+1 ];
CString szdwFlags;
CString szNotPresentDefault;
CString szNotAssignedDefault;
CString szUpperName;
CString szDispid;
char szErrorText [ MAX_LINE_LEN+1 ];
StorageType stHowStored;
const CCachedAttrArrayInfo *pCAAI = NULL;
BOOL fNumericHandler;
CString szVTDef;
CString szPropSignature;
CString szPropVT;
Token *pEnumType;
Token *pEventChild = NULL;
char chCustomInvokeIdx[128];
char *pDispatchType;
CString szPreText,szPostText;
CString szMemberDesc;
szPreText = "_T(";
szPostText = ")";
pEnumType = FindEnum ( pChild );
if ( pEnumType )
{
// Generic enumerator property handler, the propDesc has the enumerator
// type.
szPropVT = "PropEnum";
}
else
{
char *pWS;
szPropVT = pChild->GetTagValue ( PROPERTY_ATYPE );
// Remove any underscores in the type name.
while ((pWS = szPropVT.FindChar('_')))
{
while (*pWS = *(pWS + 1))
pWS++;
*pWS = '\0';
}
}
// Should this type be mapped to IDispatch?
pDispatchType = MapTypeToIDispatch ( szPropVT );
if (pDispatchType)
{
szPropVT = pDispatchType;
}
szClass = pClassToken->GetTagValue ( CLASS_NAME );
szUpperName = pChild->GetTagValue ( PROPERTY_NAME );
szUpperName.ToUpper();
szHandler = "";
szFnPrefix = "";
// Check for missing handler later
GetTypeDetails ( pChild->GetTagValue ( PROPERTY_TYPE ),
szHandler, szFnPrefix, &stHowStored );
CString szPropParamDesc;
szdwFlags = pChild->GetTagValue ( PROPERTY_DWFLAGS );
if ( pChild->IsSet ( PROPERTY_GETSETMETHODS ) )
{
szPropParamDesc = "PROPPARAM_GETMFHandler | PROPPARAM_SETMFHandler";
szPropSignature = "GS";
}
else if ( pChild->IsSet ( PROPERTY_MEMBER ) )
{
szPropParamDesc = "PROPPARAM_MEMBER";
}
else
{
szPropParamDesc = "";
}
if ( pChild->IsSet ( PROPERTY_GET ) )
{
szPropSignature = "G";
if ( szPropParamDesc [ 0 ] )
szPropParamDesc += " | ";
szPropParamDesc += "PROPPARAM_INVOKEGet";
}
if ( pChild->IsSet ( PROPERTY_SET ) )
{
szPropSignature += "S";
if ( szPropParamDesc [ 0 ] )
szPropParamDesc += " | ";
szPropParamDesc += "PROPPARAM_INVOKESet";
}
if (!szPropSignature[0])
{
szPropSignature = "GS";
if ( szPropParamDesc [ 0 ] )
szPropParamDesc += " | ";
szPropParamDesc += "PROPPARAM_INVOKEGet | PROPPARAM_INVOKESet";
}
// Write out the function signature for this property.
if ( !FindAndAddSignature ( szPropSignature, szPropVT, &chCustomInvokeIdx[0] ) )
return FALSE;
if ( pChild->IsSet ( PROPERTY_PPFLAGS ))
{
szPropParamDesc += " | ";
szPropParamDesc += pChild->GetTagValue ( PROPERTY_PPFLAGS );
}
if ( pChild->IsSet ( PROPERTY_NOPERSIST ) )
{
szPropParamDesc += " | PROPPARAM_NOPERSIST";
}
if ( pChild->IsSet ( PROPERTY_INVALIDASNOASSIGN ) )
{
szPropParamDesc += " | PROPPARAM_INVALIDASNOASSIGN";
}
if ( pChild->IsSet ( PROPERTY_CUSTOMENUM ) )
{
szPropParamDesc += " | PROPPARAM_CUSTOMENUM ";
}
if ( pChild->IsSet ( PROPERTY_NOTPRESENTASDEFAULT ) )
{
szPropParamDesc += " | PROPPARAM_NOTPRESENTASDEFAULT";
}
if ( pChild->IsSet ( PROPERTY_HIDDEN ) )
{
szPropParamDesc += " | PROPPARAM_HIDDEN";
}
if ( pChild->IsSet ( PROPERTY_RESTRICTED ) )
{
szPropParamDesc += " | PROPPARAM_RESTRICTED";
}
if ( pChild->IsSet ( PROPERTY_CAA ) )
{
szDispid = pChild->GetTagValue( PROPERTY_DISPID );
pCAAI = GetCachedAttrArrayInfo(szDispid);
szPropParamDesc += " | PROPPARAM_ATTRARRAY ";
#if 0
if (pCAAI->szPPFlags)
{
szPropParamDesc += " | ";
szPropParamDesc += pCAAI->szPPFlags;
}
if (pCAAI->szLMinBitMask)
{
pChild->AddTag( PROPERTY_MIN , pCAAI->szLMinBitMask );
}
#endif
}
if ( pChild->IsSet ( PROPERTY_MINOUT ) )
{
szPropParamDesc += " | PROPPARAM_MINOUT";
}
if ( pChild->IsSet ( PROPERTY_SETDESIGNMODE ) )
{
szPropParamDesc += " | PROPPARAM_READONLYATRUNTIME";
}
// If we're processing a property that applies to a CF/PF/SF/FF, mark it here
// this helps us optimize the apply process. Only properties with a DISPID that
// matches our apply table, can be applied
if ( pCAAI && pCAAI->szDispId != NULL )
{
szPropParamDesc += " | PROPPARAM_STYLISTIC_PROPERTY";
}
if ( pChild -> IsSet ( PROPERTY_SCRIPTLET ) )
{
szPropParamDesc += " | PROPPARAM_SCRIPTLET";
pEventChild = FindEventMethod(pClassToken, pChild->GetTagValue(PROPERTY_NAME));
if (pEventChild)
{
if (pEventChild->IsSet(METHOD_CANCELABLE))
{
szPropParamDesc += " | PROPPARAM_CANCELABLE";
}
if (pEventChild->IsSet(METHOD_BUBBLING))
{
szPropParamDesc += " | PROPPARAM_BUBBLING";
}
}
else if (!pChild->IsSet(PROPERTY_NOPROPDESC) && !pChild->IsSet(PROPERTY_BASEIMPLEMENTATION))
{
sprintf ( szErrorText, "Unexpected Error:Event prop:%s in Class:%s not found in any Events interface defn.\n",
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME) );
ReportError ( szErrorText );
return FALSE;
}
}
szMemberDesc = "";
if ( pChild->IsSet ( PROPERTY_CAA ) )
{
if ( pCAAI->dwFlags & CCSSF_CLEARCACHES )
{
// Always add dwFlags:ELEMCHNG_CLEARCACHES for these properties
if ( szdwFlags [0] )
{
szdwFlags += "|";
}
else
{
szdwFlags = "";
}
szdwFlags+="ELEMCHNG_CLEARCACHES";
}
if ( pCAAI->dwFlags & CCSSF_CLEARFF )
{
// Always add dwFlags:ELEMCHNG_CLEARFF for these properties
if ( szdwFlags [0] )
{
szdwFlags += "|";
}
else
{
szdwFlags = "";
}
szdwFlags+="ELEMCHNG_CLEARFF";
}
if ( pCAAI->dwFlags & CCSSF_REMEASURECONTENTS )
{
// Always add dwFlags:ELEMCHNG_REMEASURECONTENTS for these properties
if ( szdwFlags [0] )
{
szdwFlags += "|";
}
else
{
szdwFlags = "";
}
szdwFlags+="ELEMCHNG_REMEASURECONTENTS";
}
if ( pCAAI->dwFlags & CCSSF_REMEASUREALLCONTENTS )
{
// Always add dwFlags:ELEMCHNG_REMEASURECONTENTS for these properties
if ( szdwFlags [0] )
{
szdwFlags += "|";
}
else
{
szdwFlags = "";
}
szdwFlags+="ELEMCHNG_REMEASUREALLCONTENTS";
}
if ( pCAAI->dwFlags & CCSSF_REMEASUREINPARENT )
{
// Always add dwFlags:ELEMCHNG_REMEASUREINPARENT for these properties
if ( szdwFlags [0] )
{
szdwFlags += "|";
}
else
{
szdwFlags = "";
}
szdwFlags+="ELEMCHNG_REMEASUREINPARENT";
}
if ( pCAAI->dwFlags & CCSSF_SIZECHANGED )
{
// Always add dwFlags:ELEMCHNG_SIZECHANGED for these properties
if ( szdwFlags [0] )
{
szdwFlags += "|";
}
else
{
szdwFlags = "";
}
szdwFlags+="ELEMCHNG_SIZECHANGED";
}
}
else if ( pChild->IsSet ( PROPERTY_MEMBER ) )
{
// On the object
szMemberDesc = szClass;
szMemberDesc += ", ";
szMemberDesc += pChild->GetTagValue ( PROPERTY_MEMBER );
}
if ( pChild -> IsSet ( PROPERTY_ACCESSIBILITYSTATE) )
{
// we should only allow this on properties that can be set,
if ( ! ( pChild->IsSet ( PROPERTY_SET ) ) )
{
ReportError ( "Accessibility State can only be applied to r/w properties\n" );
return FALSE;
}
if ( szdwFlags [ 0 ] )
{
szdwFlags += "|";
}
szdwFlags += "ELEMCHNG_ACCESSIBILITY";
}
if ( pChild -> IsSet ( PROPERTY_UPDATECOLLECTION ) )
{
if ( szdwFlags [ 0 ] )
{
szdwFlags += "|";
}
szdwFlags += "ELEMCHNG_UPDATECOLLECTION";
}
if ( pChild -> IsSet ( PROPERTY_CLEARCACHES ) )
{
if ( szdwFlags [ 0 ] )
{
szdwFlags += "|";
}
szdwFlags += "ELEMCHNG_CLEARCACHES";
}
if ( pChild -> IsSet ( PROPERTY_STYLEPROP ) )
{
if ( szPropParamDesc [ 0 ] )
szPropParamDesc += " | ";
szPropParamDesc += "PROPPARAM_STYLESHEET_PROPERTY";
}
if ( pChild -> IsSet ( PROPERTY_DONTUSENOTASSIGN ) )
{
if ( szPropParamDesc [ 0 ] )
szPropParamDesc += " | ";
szPropParamDesc += "PROPPARAM_DONTUSENOTASSIGNED";
}
if ( pChild -> IsSet ( PROPERTY_RESIZE ) )
{
if ( szdwFlags [ 0 ] )
{
szdwFlags += "|";
}
szdwFlags += "ELEMCHNG_SIZECHANGED";
}
if ( pChild -> IsSet ( PROPERTY_REMEASURE ) )
{
if ( szdwFlags [ 0 ] )
{
szdwFlags += "|";
}
szdwFlags += "ELEMCHNG_REMEASURECONTENTS";
}
if ( pChild -> IsSet ( PROPERTY_REMEASUREALL ) )
{
if ( szdwFlags [ 0 ] )
{
szdwFlags += "|";
}
szdwFlags += "ELEMCHNG_REMEASUREALLCONTENTS";
}
if ( pChild -> IsSet ( PROPERTY_SITEREDRAW ) )
{
if ( szdwFlags [ 0 ] )
{
szdwFlags += "|";
}
szdwFlags += "ELEMCHNG_SITEREDRAW";
}
char szPropertyDesc [ MAX_LINE_LEN+1 ] ;
pChild -> GetTagValueOrDefault ( szNotPresentDefault, PROPERTY_NOTPRESENTDEFAULT, "0" );
if ( pChild->IsSet( PROPERTY_NOTPRESENTDEFAULT ) && szHandler == "String")
{
szNotPresentDefault = szPreText + szNotPresentDefault;
szNotPresentDefault += szPostText;
}
else if ( szHandler == "Color" && szNotPresentDefault == "0" )
{
// This is a nasty little hack to make for colors
szNotPresentDefault = "-1";
}
// If there's a not assigned default, use it, else use the not present default
pChild -> GetTagValueOrDefault ( szNotAssignedDefault, PROPERTY_NOTSETDEFAULT,
(LPCSTR)szNotPresentDefault );
if ( pChild->IsSet( PROPERTY_NOTSETDEFAULT ) && szHandler == "String")
{
szNotAssignedDefault = szPreText + szNotAssignedDefault;
szNotAssignedDefault += szPostText;
}
else if ( szHandler == "Color" && szNotAssignedDefault == "0" )
{
szNotAssignedDefault = "-1";
}
// szAttribute spevcifies the html name of the property, if not specified the
// property name itself is used.
if ( pChild -> IsSet ( PROPERTY_SZATTRIBUTE ) )
{
szHTMLName = pChild -> GetTagValue ( PROPERTY_SZATTRIBUTE );
sprintf ( (LPSTR) szExposedName,
"_T(\"%s\")",
pChild->GetTagValue ( PROPERTY_NAME ) );
}
else
{
szHTMLName = pChild -> GetTagValue ( PROPERTY_NAME );
strcpy(szExposedName, "NULL");
}
// If the propdesc has a member specified generate a full propdesc
// By setting abstract: AND member: the propdesc can be used for validation
// ( e.g. UnitMeasurement sub-object )
if ( pChild->IsSet ( PROPERTY_ABSTRACT ) && !pChild->IsSet ( PROPERTY_MEMBER ) )
{
// Generate a minimal propdesc, this is how IDispatchEx traverses
// attributes and properties.
sprintf ( (LPSTR) szPropertyDesc,
" s_propdesc%s%s = \n{\n NULL, _T(\"%s\"), %s, (ULONG_PTR)%s, (ULONG_PTR)%s,\n {",
(LPCSTR)szClass,
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)szHTMLName,
(LPCSTR)szExposedName,
(LPCSTR)szNotPresentDefault,
(LPCSTR)szNotAssignedDefault);
}
else
{
// If you're gonna set up a handler, better be a valid one
if ( szHandler == "" )
{
sprintf ( szErrorText, "Invalid Type:%s in Class:%s Property:%s\n",
(LPCSTR)pChild->GetTagValue ( PROPERTY_TYPE ),
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME),
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
char szTempBuf[MAX_LINE_LEN+1];
sprintf ( (LPSTR) szTempBuf, " s_propdesc%s%s =\n{\n#ifdef WIN16\n (PFN_HANDLEPROPERTY)&PROPERTYDESC::handle%sproperty, _T(\"%s\"), %s, (ULONG_PTR)%s, (ULONG_PTR)%s,\n#else\n",
(LPCSTR)szClass,
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)szHandler,
(LPCSTR)szHTMLName,
(LPCSTR)szExposedName,
(LPCSTR)szNotPresentDefault,
(LPCSTR)szNotAssignedDefault);
sprintf ( (LPSTR) szPropertyDesc, "%s PROPERTYDESC::Handle%sProperty, _T(\"%s\"), %s, (ULONG_PTR)%s,(ULONG_PTR)%s,\n#endif\n {", szTempBuf,
(LPCSTR)szHandler,
(LPCSTR)szHTMLName,
(LPCSTR)szExposedName,
(LPCSTR)szNotPresentDefault,
(LPCSTR)szNotAssignedDefault);
}
if ( !ComputePROPDESC_STRUCT ( fpHDLFile, pClassToken, pChild, szHandler, szFnPrefix) )
return FALSE; // Bad error reported...leave
if ( !szdwFlags [ 0 ] )
szdwFlags = "0";
fNumericHandler = FALSE;
if ( !pChild->IsSet ( PROPERTY_ABSTRACT ) && szHandler == "Num" || szHandler == "Enum" || szHandler == "UnitValue" )
{
// Numeric Handlers
fNumericHandler = TRUE;
fprintf ( fpHDLFile, "%s\n {", szPropertyDesc );
if ( szHandler == "Enum" )
{
szPropParamDesc += " | PROPPARAM_ENUM";
}
else if ( pChild -> IsSet ( PROPERTY_ENUMREF ) )
{
// A number with one or more enums
szPropParamDesc += " | PROPPARAM_ENUM | PROPPARAM_ANUMBER";
}
pChild -> GetTagValueOrDefault ( szDispid, PROPERTY_DISPID, "0" );
if ((strcmp(pChild->GetTagValue(PROPERTY_ATYPE), "BSTR") == 0 || strcmp(pChild->GetTagValue(PROPERTY_ATYPE), "VARIANT") == 0) &&
((pChild->IsSet(PROPERTY_CAA) || pChild->IsSet(PROPERTY_SET)) && !pChild->IsSet(PROPERTY_INTERNAL)) ||
(!pChild->IsSet(PROPERTY_CAA) && !pChild->IsSet(PROPERTY_SET) && !pChild->IsSet(PROPERTY_GET)))
{
if (!pChild->IsSet(PROPERTY_MAXSTRLEN))
{
char szErrorText [ MAX_LINE_LEN+1 ];
// Dispid not specified this is an error all methods should be accessible
// from automation.
sprintf ( szErrorText, "maxstrlen required for property: %s::%s in %s.\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
}
else if (pChild->IsSet(PROPERTY_MAXSTRLEN))
{
char szErrorText [ MAX_LINE_LEN+1 ];
// Dispid not specified this is an error all methods should be accessible
// from automation.
sprintf ( szErrorText, "maxstrlen NOT required for property: %s::%s in %s.\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
fprintf ( fpHDLFile, "\n %s, %s, %s, %s, %s \n },",
(LPCSTR)szPropParamDesc,
(LPCSTR)szDispid,
(LPCSTR)szdwFlags,
(LPCSTR)&chCustomInvokeIdx[0],
pChild->IsSet(PROPERTY_MAXSTRLEN) ? (LPCSTR)pChild->GetTagValue(PROPERTY_MAXSTRLEN) : "0");
if (fpMaxLenFile && pChild->IsSet(PROPERTY_MAXSTRLEN))
{
fprintf ( fpMaxLenFile, "%s::%s %s\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)pChild->GetTagValue(PROPERTY_MAXSTRLEN) );
}
if ( pChild->IsSet ( PROPERTY_ABSTRACT ) )
{
fprintf ( fpHDLFile, "\n 0, 0" );
}
else
{
if ( !pChild->IsSet ( PROPERTY_VT ) )
{
CString szAType;
szAType = pChild->GetTagValue ( PROPERTY_ATYPE );
if ( szAType == "short" || szAType == "VARIANT_BOOL" )
szVTDef = "VT_I2";
else
szVTDef = "VT_I4";
}
else
{
szVTDef = pChild->GetTagValue ( PROPERTY_VT );
}
if ( pChild -> IsSet ( PROPERTY_GETSETMETHODS ) )
{
fprintf ( fpHDLFile, "\n %s, 0",
(LPCSTR)szVTDef );
}
else if ( pChild -> IsSet ( PROPERTY_CAA ) )
{
fprintf ( fpHDLFile, "\n %s, sizeof(DWORD)",
(LPCSTR)szVTDef );
}
else
{
fprintf ( fpHDLFile, "\n %s, SIZE_OF(%s)",
(LPCSTR)szVTDef, (LPCSTR)szMemberDesc );
}
}
// Fill in the min/max values
// If it's an enum, the min value is a ptr to the enum desc structure
if ( szHandler == "Enum" )
{
if ( pChild->IsSet ( PROPERTY_ABSTRACT ) )
{
fprintf ( fpHDLFile, ", 0, 0,\n" );
}
else
{
// Get the enum mask from the enum named by PROPERTY_TYPE
CTokenListWalker WholeList ( pRuntimeList );
Token *pEnumToken = WholeList.GetNext ( TYPE_ENUM, pChild->GetTagValue ( PROPERTY_TYPE ) );
CString szMin;
pChild->GetTagValueOrDefault ( szMin, PROPERTY_MIN, "0" );
if ( pEnumToken == NULL )
{
sprintf ( szErrorText,
"unknown enum type %s\n",pChild->GetTagValue ( PROPERTY_TYPE ) );
ReportError ( szErrorText );
return FALSE;
}
fprintf ( fpHDLFile, ", %s, (LONG_PTR)&s_enumdesc%s,\n",
(LPCSTR)szMin, pChild->GetTagValue ( PROPERTY_TYPE ) );
}
}
else
{
CString szMax;
CString szMin;
pChild->GetTagValueOrDefault ( szMin, PROPERTY_MIN, "LONG_MIN" );
pChild->GetTagValueOrDefault ( szMax, PROPERTY_MAX, "LONG_MAX" );
fprintf ( fpHDLFile, ", %s, %s,\n", (LPCSTR)szMin, (LPCSTR)szMax );
}
}
else
{
fprintf ( fpHDLFile, "%s\n ", szPropertyDesc );
pChild -> GetTagValueOrDefault ( szDispid, PROPERTY_DISPID, "0" );
if ((strcmp(pChild->GetTagValue(PROPERTY_ATYPE), "BSTR") == 0 || strcmp(pChild->GetTagValue(PROPERTY_ATYPE), "VARIANT") == 0) &&
((pChild->IsSet(PROPERTY_CAA) || pChild->IsSet(PROPERTY_SET)) && !pChild->IsSet(PROPERTY_INTERNAL)) ||
(!pChild->IsSet(PROPERTY_CAA) && !pChild->IsSet(PROPERTY_SET) && !pChild->IsSet(PROPERTY_GET)))
{
if (!pChild->IsSet(PROPERTY_MAXSTRLEN))
{
char szErrorText [ MAX_LINE_LEN+1 ];
// Dispid not specified this is an error all methods should be accessible
// from automation.
sprintf ( szErrorText, "maxstrlen required for property: %s::%s in %s.\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
}
else if (pChild->IsSet(PROPERTY_MAXSTRLEN))
{
char szErrorText [ MAX_LINE_LEN+1 ];
// Dispid not specified this is an error all methods should be accessible
// from automation.
sprintf ( szErrorText, "maxstrlen NOT required for property: %s::%s in %s.\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
fprintf ( fpHDLFile, " %s, %s, %s, %s, %s \n",
(LPCSTR)szPropParamDesc,
(LPCSTR)szDispid,
(LPCSTR)szdwFlags,
(LPCSTR)&chCustomInvokeIdx[0],
pChild->IsSet(PROPERTY_MAXSTRLEN) ? (LPCSTR)pChild->GetTagValue(PROPERTY_MAXSTRLEN) : "0");
if (fpMaxLenFile && pChild->IsSet(PROPERTY_MAXSTRLEN))
{
fprintf ( fpMaxLenFile, "%s::%s %s\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( PROPERTY_NAME ),
(LPCSTR)pChild->GetTagValue(PROPERTY_MAXSTRLEN) );
}
}
fprintf ( fpHDLFile, " }," );
if (pEventChild && pChild->IsSet(PROPERTY_SCRIPTLET))
{
fprintf(fpHDLFile, "\n (DWORD_PTR)%s", pEventChild->GetTagValue(METHOD_DISPID));
}
else if ( pChild->IsSet ( PROPERTY_GETSETMETHODS ) )
{
fprintf ( fpHDLFile, "\n PROPERTY_METHOD(%s, GET, %s, Get%s, GET%s)," ,
(LPCSTR)szFnPrefix,
(LPCSTR)szClass, (LPCSTR)pChild->GetTagValue ( PROPERTY_GETSETMETHODS ),
(LPCSTR)pChild->GetTagValue ( PROPERTY_GETSETMETHODS ));
fprintf ( fpHDLFile, "\n PROPERTY_METHOD(%s, SET, %s, Set%s, SET%s)" ,
(LPCSTR)szFnPrefix,
(LPCSTR)szClass, (LPCSTR)pChild->GetTagValue ( PROPERTY_GETSETMETHODS ),
(LPCSTR)pChild->GetTagValue ( PROPERTY_GETSETMETHODS ));
}
else if ( pChild->IsSet ( PROPERTY_ABSTRACT ) )
{
}
else if ( szMemberDesc [ 0 ] )
{
fprintf ( fpHDLFile, "\n offsetof(%s)",
(LPCSTR)szMemberDesc );
}
if ( fNumericHandler && pChild->IsSet ( PROPERTY_ENUMREF ) &&
!pChild->IsSet ( PROPERTY_ABSTRACT ) )
{
CTokenListWalker WholeList ( pRuntimeList );
Token *pEnumToken = WholeList.GetNext ( TYPE_ENUM,
pChild->GetTagValue ( PROPERTY_ENUMREF ) );
if ( pEnumToken == NULL )
{
sprintf ( szErrorText,
"unknown enum type %s\n",pChild->GetTagValue ( PROPERTY_ENUMREF ) );
ReportError ( szErrorText );
return FALSE;
}
if ( !szMemberDesc [ 0 ] )
{
fprintf ( fpHDLFile, "\n 0, &s_enumdesc%s",
pChild->GetTagValue ( PROPERTY_ENUMREF ) );
}
else
{
fprintf ( fpHDLFile, "\n &s_enumdesc%s",
pChild->GetTagValue ( PROPERTY_ENUMREF ) );
}
}
fprintf ( fpHDLFile, "\n};\n\n" );
return TRUE;
}
BOOL CPDLParser::BuildMethodSignature(Token *pChild,
CString &szTypesSig,
CString &szArgsType,
BOOL &fBSTRArg,
BOOL &fVARIANTArg,
int &cArgs,
int &cRequiredArgs,
char *pDefaultParams[MAX_ARGS],
char *pDefaultStrParams[MAX_ARGS])
{
Token *pArgToken;
CTokenListWalker ArgListWalker(pChild);
char *pDispatchType;
char szErrorText [ MAX_LINE_LEN+1 ];
cArgs = 0;
cRequiredArgs = 0;
fBSTRArg = FALSE;
fVARIANTArg = FALSE;
// Loop thru all arguments.
while ( (pArgToken = ArgListWalker.GetNext()) != NULL &&
pArgToken -> GetType () == TYPE_METHOD_ARG )
{
fBSTRArg |= (strcmp(pArgToken->GetTagValue(METHODARG_TYPE), "BSTR") == 0);
fVARIANTArg |= (!pArgToken->IsSet(METHODARG_OUT) && (strcmp(pArgToken->GetTagValue(METHODARG_TYPE), "VARIANT") == 0 || strcmp(pArgToken->GetTagValue(METHODARG_TYPE), "VARIANT*") == 0));
// Looking for a return value.
if ( pArgToken -> IsSet ( METHODARG_RETURNVALUE ) )
{
char *pWS;
szTypesSig = pArgToken -> GetTagValue ( METHODARG_TYPE );
// Remove any underscores in the type name.
while ((pWS = szTypesSig.FindChar('_')))
{
while (*pWS = *(pWS + 1))
pWS++;
*pWS = '\0';
}
// Should this type be mapped to IDispatch?
pDispatchType = MapTypeToIDispatch ( szTypesSig );
if (pDispatchType)
{
szTypesSig = pDispatchType;
}
}
else
{
CString szArg;
char *pWS;
if ( pArgToken->IsSet ( METHODARG_OPTIONAL ) )
{
// little o + zero + little o, prepended to the type signals
// the type is optional.
szArg = "o0o";
}
if ( pArgToken -> IsSet ( METHODARG_DEFAULTVALUE ) )
{
// Signal default.
szArg = "oDo";
if (cArgs >= MAX_ARGS)
{
sprintf ( szErrorText, "PDL parser can only handle upto 8 parameters (increase MAX_ARGS) %s in file %s.\n",
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
// Currently I only handle 2 types of default values numbers and
// strings. If any other appear then I'll need to add those as
// well.
if ( strcmp (pArgToken -> GetTagValue ( METHODARG_TYPE ), "BSTR") == 0)
{
if (pDefaultStrParams)
pDefaultStrParams[cArgs] = pArgToken -> GetTagValue ( METHODARG_DEFAULTVALUE );
}
else if (pDefaultParams)
{
pDefaultParams[cArgs] = pArgToken -> GetTagValue ( METHODARG_DEFAULTVALUE );
}
}
else
{
// If not optional and not defaultValue then the argument is
// required and no defaults could have appeared in between.
if ( !pArgToken->IsSet ( METHODARG_OPTIONAL ) )
{
// Insure that once a default argument is hit all arguments from
// that point to the last argument im the function are either
// defaultValue or optional.
if (cRequiredArgs != cArgs)
{
sprintf ( szErrorText, "Default arguments must be contiguous to last argument %s in file %s.\n",
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
// Arguments without a defaultValue/optional are required args.
// Unless the argument is a safe array than any number of
// arguments can be specified 0 to n arguments
if (strcmp((LPCSTR)(pArgToken -> GetTagValue(METHODARG_TYPE)), "SAFEARRAY(VARIANT)") != 0)
// Not a safearray so it's a required argument.
cRequiredArgs++;
}
}
szArg += pArgToken -> GetTagValue ( METHODARG_TYPE );
if (szArg == "oDoVARIANT")
{
sprintf ( szErrorText, "Default arguments cannot be VARIANT %s in file %s.\n",
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
if ( pArgToken->IsSet ( METHODARG_OPTIONAL ) &&
!(szArg == "o0oVARIANT" || szArg == "o0oVARIANT*") )
{
sprintf ( szErrorText, "Optional arguments can ONLY be VARIANT or VARIANT* %s in file %s.\n",
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
// Should this type be mapped to IDispatch?
pDispatchType = MapTypeToIDispatch ( szArg );
if (pDispatchType)
{
// Remap to IDispatch* or IDispatch**
szArg = pDispatchType;
}
cArgs++;
// Remove any underscores in the type name.
while ((pWS = szArg.FindChar('_')))
{
while (*pWS = *(pWS + 1))
pWS++;
*pWS = '\0';
}
szArgsType += "_";
szArgsType += (LPCSTR)szArg;
}
}
return TRUE;
}
BOOL CPDLParser::ComputeMethod ( Token *pClassToken, Token *pChild )
{
CString szTypesSig;
CString szArgsType;
CString szDispid;
CTokenListWalker ArgListWalker ( pChild );
char chCustomInvokeIdx[128];
int cArgs = 0;
int cRequiredArgs = 0;
char szErrorText [ MAX_LINE_LEN+1 ];
char *pDefaultParams[MAX_ARGS] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
char *pDefaultStrParams[MAX_ARGS] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
BOOL fBSTRArg;
BOOL fVARIANTArg;
if (!BuildMethodSignature(pChild,
szTypesSig,
szArgsType,
fBSTRArg,
fVARIANTArg,
cArgs,
cRequiredArgs,
pDefaultParams,
pDefaultStrParams))
return FALSE;
// Any default values?
if (cArgs != cRequiredArgs)
{
int i;
// Spit out any default string constants.
for ( i = cRequiredArgs; i < cArgs; i++)
{
if ( pDefaultStrParams[i] )
{
fprintf ( fpHDLFile, "const TCHAR s_strDef%s%s%i[] = _T(%s);\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ),
i - cRequiredArgs,
pDefaultStrParams[i] );
}
}
fprintf ( fpHDLFile, "const DEFAULTARGDESC s_defArg%s%s =\n{\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ) );
// Spit out the all of all default constants
for ( i = cRequiredArgs; i < cArgs; i++)
{
if ( pDefaultStrParams[i] )
{
fprintf ( fpHDLFile, " (DWORD_PTR)s_strDef%s%s%i,\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ),
i - cRequiredArgs );
}
else
{
fprintf ( fpHDLFile, " (DWORD_PTR)%s,\n", pDefaultParams[i] ? pDefaultParams[i] : "\"\"" );
}
}
fprintf ( fpHDLFile, "};\n" );
}
// If no return value then set the retVal to void.
if (!szTypesSig[0])
{
szTypesSig = "void";
}
// If no arguments then set the argList to void.
if (!szArgsType[0])
{
szArgsType = "_void";
}
szTypesSig += szArgsType;
szDispid = pChild->GetTagValue(METHOD_DISPID);
if (szDispid[0])
{
// Write out the function signature for this method
// only do this if a dispid exists. Methods without dispid
// are not accessible through automation.
if ( !FindAndAddSignature ( "Method", szTypesSig, &chCustomInvokeIdx[0] ) )
return FALSE;
}
fprintf ( fpHDLFile, "EXTERN_C const PROPERTYDESC_METHOD s_methdesc%s%s = \n{\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ));
fprintf ( fpHDLFile, " NULL, NULL, _T(\"%s\"), (ULONG)0, (ULONG)0,\n {\n",
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ));
if (!szDispid[0])
{
// Dispid not specified this is an error all methods should be accessible
// from automation.
sprintf ( szErrorText, "DISPID required for method: %s::%s in %s.\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
if (fBSTRArg || fVARIANTArg)
{
if (!pChild->IsSet(METHOD_MAXSTRLEN))
{
// Dispid not specified this is an error all methods should be accessible
// from automation.
sprintf ( szErrorText, "maxstrlen required for method: %s::%s in %s.\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
}
else if (pChild->IsSet(METHOD_MAXSTRLEN))
{
// Dispid not specified this is an error all methods should be accessible
// from automation.
sprintf ( szErrorText, "maxstrlen NOT required for method: %s::%s in %s.\n",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ),
_pszPDLFileName );
ReportError ( szErrorText );
return FALSE;
}
fprintf ( fpHDLFile, " %s, %s, 0, %s, %s\n },\n ",
pChild->IsSet(METHOD_RESTRICTED) ? "PROPPARAM_RESTRICTED" : "0",
(LPCSTR)szDispid,
(LPCSTR)&chCustomInvokeIdx[0],
pChild->IsSet(METHOD_MAXSTRLEN) ? (LPCSTR)pChild->GetTagValue(METHOD_MAXSTRLEN) : "0");
if (fpMaxLenFile && pChild->IsSet(METHOD_MAXSTRLEN))
{
fprintf ( fpMaxLenFile, "%s::%s %s\n",
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME),
(LPCSTR)pChild->GetTagValue(METHOD_NAME),
(LPCSTR)pChild->GetTagValue(METHOD_MAXSTRLEN) );
}
if ( cArgs != cRequiredArgs )
{
fprintf ( fpHDLFile, "&s_defArg%s%s, ",
(LPCSTR)pClassToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pChild->GetTagValue ( METHOD_NAME ) );
}
else
{
fprintf ( fpHDLFile, "NULL, " );
}
fprintf ( fpHDLFile, "%i, %i\n};\n\n",
cArgs,
cRequiredArgs );
return TRUE;
}
BOOL CPDLParser::GeneratePROPDESCs ( void )
{
Token *pClassToken;
Token *pChild;
// Only generate def's for this file
CTokenListWalker TokenList ( pRuntimeList, _pszPDLFileName );
// Generate propdescs for every property token in every class ( in this file )
while ( pClassToken = TokenList.GetNext( TYPE_CLASS ) )
{
fprintf ( fpHDLFile, "\n" );
CTokenListWalker ChildList ( pClassToken );
// if ( pClassToken -> IsSet ( CLASS_ABSTRACT ) )
// {
// fprintf ( fpHDLFile, "\n#ifndef _PROPDESCS_EXTERNAL\n" );
// }
fprintf ( fpHDLFile, "\n#define _%s_PROPDESCS_\n", pClassToken -> GetTagValue ( CLASS_NAME ) );
// Walk the super class propdescs looking for properties
while ( pChild = ChildList.GetNext() )
{
if ( pChild->nType == TYPE_PROPERTY &&
_stricmp(pChild->GetTagValue(PROPERTY_NOPROPDESC), "nameonly") != 0 )
{
if ( !ComputeProperty ( pClassToken, pChild ) )
return FALSE;
}
else if ( pChild->nType == TYPE_METHOD && !pChild->IsSet(METHOD_NOPROPDESC))
{
if (!ComputeMethod(pClassToken, pChild) )
return FALSE;
}
else
{
continue;
}
}
if (fpMaxLenFile)
fprintf(fpMaxLenFile, "\n");
}
return TRUE;
}
void CPDLParser::GenerateThunkContext ( Token *pClassToken )
{
CTokenListWalker ChildList (pClassToken);
Token *pChildToken;
while (pChildToken = ChildList.GetNext())
{
if( (pChildToken->GetType() == TYPE_METHOD && pChildToken->IsSet(METHOD_THUNKCONTEXT)) ||
(pChildToken->GetType() == TYPE_PROPERTY && pChildToken->IsSet(PROPERTY_THUNKCONTEXT)) )
{
GenerateSingleThunkContextPrototype(pClassToken, pChildToken, FALSE);
}
if( (pChildToken->GetType() == TYPE_METHOD && pChildToken->IsSet(METHOD_THUNKNODECONTEXT)) ||
(pChildToken->GetType() == TYPE_PROPERTY && pChildToken->IsSet(PROPERTY_THUNKNODECONTEXT)) )
{
GenerateSingleThunkContextPrototype(pClassToken, pChildToken, TRUE);
}
}
}
void CPDLParser::GenerateSingleThunkContextPrototype ( Token *pClassToken, Token * pChildToken, BOOL fNodeContext )
{
CString szProp;
Token *pArgToken;
if (pChildToken->GetType() == TYPE_METHOD)
{
CTokenListWalker ArgListWalker(pChildToken);
BOOL fFirst = TRUE;
fprintf(fpHDLFile, " STDMETHODIMP %s(", (LPCSTR)pChildToken->GetTagValue(METHOD_NAME));
while (pArgToken = ArgListWalker.GetNext())
{
if (!fFirst)
fprintf(fpHDLFile, ",");
fprintf(fpHDLFile, "%s %s",
ConvertType((LPCSTR)pArgToken->GetTagValue ( METHODARG_TYPE )),
(LPCSTR)pArgToken -> GetTagValue ( METHODARG_ARGNAME ) );
fFirst = FALSE;
}
if(fNodeContext)
{
fprintf(fpHDLFile, "%sCTreeNode *pNode);\n", fFirst?"":",");
}
else
{
fprintf(fpHDLFile, "%sTEAROFF_THUNK*ptt);\n", fFirst?"":",");
}
}
else
{
if (pChildToken->IsSet(PROPERTY_SET))
{
fprintf(fpHDLFile, " STDMETHODIMP set_%s(%s v, %s);\n",
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME),
(LPCSTR)pChildToken -> GetTagValue(PROPERTY_ATYPE),
fNodeContext?"CTreeNode *pNode":"TEAROFF_THUNK *ptt");
}
if (pChildToken->IsSet(PROPERTY_GET))
{
fprintf(fpHDLFile, " STDMETHODIMP get_%s(%s *p, %s);\n",
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME),
(LPCSTR)pChildToken -> GetTagValue(PROPERTY_ATYPE),
fNodeContext?"CTreeNode *pNode":"TEAROFF_THUNK *ptt");
}
}
}
void CPDLParser::GenerateThunkContextImplemenation ( Token *pClassToken )
{
CTokenListWalker ChildList (pClassToken);
Token *pChildToken;
while (pChildToken = ChildList.GetNext())
{
if( (pChildToken->GetType() == TYPE_METHOD && pChildToken->IsSet(METHOD_THUNKCONTEXT)) ||
(pChildToken->GetType() == TYPE_PROPERTY && pChildToken->IsSet(PROPERTY_THUNKCONTEXT)) )
{
GenerateSingleThunkContextImplementation(pClassToken, pChildToken, FALSE);
}
if( (pChildToken->GetType() == TYPE_METHOD && pChildToken->IsSet(METHOD_THUNKNODECONTEXT)) ||
(pChildToken->GetType() == TYPE_PROPERTY && pChildToken->IsSet(PROPERTY_THUNKNODECONTEXT)) )
{
GenerateSingleThunkContextImplementation(pClassToken, pChildToken, TRUE);
}
}
}
void CPDLParser::GenerateSingleThunkContextImplementation ( Token *pClassToken, Token * pChildToken, BOOL fNodeContext )
{
CString szProp;
Token *pArgToken;
fprintf(fpHDLFile, "#ifdef USE_STACK_SPEW\n#pragma check_stack(off)\n#endif\n");
if (pChildToken->GetType() == TYPE_METHOD)
{
CTokenListWalker ArgListWalker(pChildToken);
BOOL fFirst = TRUE;
fprintf(fpHDLFile, "STDMETHODIMP %s::ContextThunk_%s(",
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME),
(LPCSTR)pChildToken->GetTagValue(METHOD_NAME));
while (pArgToken = ArgListWalker.GetNext())
{
if (!fFirst)
fprintf(fpHDLFile, ",");
fprintf(fpHDLFile, "%s %s",
ConvertType((LPCSTR)pArgToken->GetTagValue ( METHODARG_TYPE )),
(LPCSTR)pArgToken -> GetTagValue ( METHODARG_ARGNAME ) );
fFirst = FALSE;
}
if(fNodeContext)
{
fprintf(fpHDLFile, ")\n"
"{\n"
" CTreeNode* pNode;\n"
" CONTEXTTHUNK_SETTREENODE\n"
" return %s(", (LPCSTR)pChildToken->GetTagValue(METHOD_NAME));
}
else
{
fprintf(fpHDLFile, ")\n"
"{\n"
" TEAROFF_THUNK* ptt;\n"
" CONTEXTTHUNK_SETTEAROFFTHUNK\n"
" return %s(", (LPCSTR)pChildToken->GetTagValue(METHOD_NAME));
}
fFirst = TRUE;
ArgListWalker.Reset();
while (pArgToken = ArgListWalker.GetNext())
{
if (!fFirst)
fprintf(fpHDLFile, ",");
fprintf(fpHDLFile, "%s",
(LPCSTR)pArgToken -> GetTagValue(METHODARG_ARGNAME));
fFirst = FALSE;
}
fprintf(fpHDLFile, "%s%s);\n}\n", fFirst?"":",", fNodeContext?"pNode":"ptt");
}
else
{
if (pChildToken->IsSet(PROPERTY_SET))
{
fprintf(fpHDLFile,
"STDMETHODIMP %s::ContextThunk_set_%s(%s v)\n"
"{\n%s return set_%s(v,%s);\n}\n",
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME),
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME),
(LPCSTR)pChildToken->GetTagValue(PROPERTY_ATYPE),
fNodeContext
? " CTreeNode* pNode;\n"
" CONTEXTTHUNK_SETTREENODE\n"
: " TEAROFF_THUNK* ptt;\n"
" CONTEXTTHUNK_SETCONTEXTTHUNK\n",
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME),
fNodeContext ? "pNode" : "ptt");
}
if (pChildToken->IsSet(PROPERTY_GET))
{
fprintf(fpHDLFile,
"STDMETHODIMP %s::ContextThunk_get_%s(%s *p)\n"
"{\n%s return get_%s(p,%s);\n}\n",
(LPCSTR)pClassToken->GetTagValue(CLASS_NAME),
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME),
(LPCSTR)pChildToken->GetTagValue(PROPERTY_ATYPE),
fNodeContext
? " CTreeNode* pNode;\n"
" CONTEXTTHUNK_SETTREENODE\n"
: " TEAROFF_THUNK* ptt;\n"
" CONTEXTTHUNK_SETCONTEXTTHUNK\n",
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME),
fNodeContext ? "pNode" : "ptt");
}
}
fprintf(fpHDLFile, "#ifdef USE_STACK_SPEW\n#pragma check_stack(on)\n#endif\n");
}
BOOL CPDLParser::GenerateHDLFile ( void )
{
Token *pClassToken;
BOOL bHashTableExists;
int numVTblPropDescs;
CTokenListWalker ThisFilesList ( pRuntimeList, _pszPDLFileName );
fprintf ( fpHDLFile, "\n" );
fprintf ( fpHDLFile, "// %s.hdl\n", _pszOutputFileRoot );
fprintf ( fpHDLFile, "\n" );
fprintf ( fpHDLFile, "#ifdef _hxx_\n" );
fprintf ( fpHDLFile, "\n" );
fprintf ( fpHDLFile, "#include \"%s.h\"\n", _pszOutputFileRoot );
fprintf ( fpHDLFile, "\n" );
// Generate the DISPID's, one for each member of each class
fprintf ( fpLOGFile, "Generating DISPID's...\n" );
GenerateClassDISPIDs();
GenerateInterfaceDISPIDs();
GenerateEventDISPIDs( fpHDLFile, TRUE );
fprintf ( fpHDLFile, "\n" );
fprintf ( fpHDLFile, "#endif _hxx_\n" );
fprintf ( fpHDLFile, "\n" );
fprintf ( fpHDLFile, "#undef _hxx_\n" );
fprintf ( fpHDLFile, "\n" );
fprintf ( fpHDLFile, "#ifdef _cxx_\n" );
fprintf ( fpHDLFile, "\n" );
// Generate the enum definitions
fprintf ( fpLOGFile, "Generating CPP Enum Defs...\n" );
GenerateCPPEnumDefs();
// Generate the property descriptors
fprintf ( fpLOGFile, "Generating PROPDESC's...\n" );
if ( !GeneratePROPDESCs() )
goto Error;
#ifdef COMPLUS_SHIM
// ***TLL*** COM+: Not spitting COM+ proxies for internal.pdl and mshtmext.pdl need to do, shouldn't special case.
if ((_stricmp(_pszPDLFileName, "internal.pdl") != 0) && (_stricmp(_pszPDLFileName, "mshtmext.pdl") != 0))
{
GenComPlusESI(); // Output any local interfaces for COM+
}
#endif // COMPLUS_SHIM
// For each TYPE_CLASS in this file generate a propdesc array and vtable
// array for the class.
while ( pClassToken = ThisFilesList.GetNext( TYPE_CLASS ) )
{
// Generate propdescs for every property token in every class ( in this file )
fprintf ( fpLOGFile, "Generating PROPDESC Arrays...\n" );
if ( !GenerateCPC( pClassToken ) )
goto Error;
// Generate the vtable array for classes in this file
fprintf ( fpLOGFile, "Generating VTable Arrays...\n" );
GenerateVTableArray(pClassToken, &bHashTableExists);
// Generate the propdesc array in vtable order for classes in this file
fprintf ( fpLOGFile, "Generating propdesc Arrays in vtbl order...\n" );
GeneratePropDescsInVtblOrder(pClassToken, &numVTblPropDescs);
// Abstract classes don't have propdesc arrays or vtable arrays.
if ( !pClassToken -> IsSet ( CLASS_ABSTRACT ) )
{
fprintf ( fpHDLFile, "\nconst HDLDESC %s::s_apHdlDescs = { ",
pClassToken -> GetTagValue ( CLASS_NAME ) );
// Store the Mondo DISPID int he HDLDesc so we can find it for GetTypeInfo
if ( HasMondoDispInterface ( pClassToken ) )
{
CString szDispName;
// Map to mondo dispinterface as default dispatch interface.
szDispName = (pClassToken->IsSet(CLASS_COCLASSNAME)) ?
pClassToken->GetTagValue (CLASS_COCLASSNAME) :
pClassToken->GetTagValue(CLASS_NAME);
fprintf ( fpHDLFile, " &DIID_Disp%s,", (LPCSTR)szDispName );
}
else
{
fprintf ( fpHDLFile, " NULL," );
}
if ( bHashTableExists )
{
fprintf ( fpHDLFile, "&%s::s_StringTableAggregate, ",
pClassToken -> GetTagValue ( CLASS_NAME ) );
}
else
{
fprintf ( fpHDLFile, "NULL, ");
}
if ( numVTblPropDescs )
{
fprintf ( fpHDLFile, "%s::s_ppropdescsInVtblOrder%s};\n",
pClassToken->GetTagValue(CLASS_NAME), pClassToken->GetTagValue(CLASS_INTERFACE) );
}
else
{
fprintf ( fpHDLFile, "NULL};\n" );
}
}
}
fprintf ( fpLOGFile, "Generating Property Methods...\n" );
if ( !GeneratePropMethodImplementation() )
goto Error;
fprintf ( fpLOGFile, "Generating Cascaded Property Method Implementations...\n" );
fprintf ( fpHDLFile, "// Cascaded Property get method implementations\n\n" );
ThisFilesList.Reset();
while ( pClassToken = ThisFilesList.GetNext( TYPE_CLASS ) )
{
GenerateGetAAXImplementations(pClassToken);
GenerateThunkContextImplemenation(pClassToken);
}
fprintf ( fpHDLFile, "\n" );
fprintf ( fpHDLFile, "#endif _cxx_\n" );
fprintf ( fpHDLFile, "\n" );
fprintf ( fpHDLFile, "#undef _cxx_\n" );
fprintf ( fpHDLFile, "\n" );
fprintf ( fpLOGFile, "Generating Class Includes...\n" );
if ( !GenerateClassIncludes() )
goto Error;
return TRUE;
Error:
return FALSE;
}
FILE *OpenMaxlengthFile(LPCSTR pszPDLFileName, LPCSTR pszOutputPath)
{
char chMaxLenFileName[255];
FILE *fpMaxLenFile = NULL;
BOOL fOpenNew = TRUE;
strcpy(chMaxLenFileName, pszOutputPath);
strcat(chMaxLenFileName, FILENAME_SEPARATOR_STR "maxlen.txt");
fpMaxLenFile = fopen(chMaxLenFileName, "r");
if (fpMaxLenFile)
{
char chMarker[6];
if (fread(chMarker, sizeof(char), 5, fpMaxLenFile))
{
if (!_stricmp(chMarker, "XXXXX"))
{
fOpenNew = FALSE;
}
}
fclose(fpMaxLenFile);
}
if (fOpenNew)
{
fpMaxLenFile = fopen(chMaxLenFileName, "w");
if (fpMaxLenFile)
{
fprintf(fpMaxLenFile, "XXXXX Key Value Glossary:\n");
fprintf(fpMaxLenFile, "-------------------------------\n");
fprintf(fpMaxLenFile, "pdlUrlLen = 4096 // url strings\n");
fprintf(fpMaxLenFile, "pdlToken = 128 // strings that really are some form of a token\n");
fprintf(fpMaxLenFile, "pdlLength = 128 // strings that really are numeric lengths\n");
fprintf(fpMaxLenFile, "pdlColor = 128 // strings that really are color values\n");
fprintf(fpMaxLenFile, "pdlNoLimit = 0xFFFF // strings that have no limit on their max lengths\n");
fprintf(fpMaxLenFile, "pdlEvent = pdlNoLimit // strings that could be assigned to onfoo event properties\n\n");
fprintf(fpMaxLenFile, "MAX LENGTH CONSTANTS FOR OM PROPERTIES AND METHODS\n");
fprintf(fpMaxLenFile, "-----------------------------------------------------------------------------------\n\n");
}
}
else
{
fpMaxLenFile = fopen(chMaxLenFileName, "a");
}
return fpMaxLenFile;
}
int
CPDLParser::Parse ( char *szInputFile,
char *szOutputFileRoot,
char *szPDLFileName,
char *szOutputPath,
BOOL fDebugging )
{
#if 0
if (strcmp(szPDLFileName, "iframe.pdl") == 0)
__asm {int 3};
#endif
int nReturnCode = 0;
char szFileName [ MAX_PATH+1 ];
char szErrorText [ MAX_LINE_LEN+1 ];
#ifdef COMPLUS_SHIM
BOOL fWriteHeader = FALSE;
#endif
_pszPDLFileName = szPDLFileName;
_pszOutputFileRoot = szOutputFileRoot;
_pszInputFile = szInputFile;
_pszOutputPath = szOutputPath;
fpMaxLenFile = OpenMaxlengthFile(szPDLFileName, szOutputPath);
// Read the input file a line at a time, for each line tokenise and
// parse
strcpy ( szFileName, szOutputPath );
strcat ( szFileName, "LOG" );
fpLOGFile = fopen ( szFileName, "w" );
if ( !fpLOGFile )
{
printf ( szErrorText, "Can't open log file %s\n", szFileName );
ReportError ( szErrorText );
goto error;
}
fprintf ( fpLOGFile, "InputBuffer = %s\n", szInputFile );
fprintf ( fpLOGFile, "OuputFileRoot = %s\n", szOutputFileRoot );
fprintf ( fpLOGFile, "PDLFileName = %s\n", szPDLFileName );
fprintf ( fpLOGFile, "LogFileName =% s\n", szFileName );
// All files open and raring to go....
if ( !ParseInputFile ( fDebugging ) )
{
goto error;
}
// Create the HDL File
strcpy ( szFileName, szOutputFileRoot );
strcat ( szFileName, ".hdl" );
fpHDLFile = fopen ( szFileName, "w" );
if ( !fpHDLFile )
{
printf ( szErrorText, "Can't open HDL output file %s\n", szFileName );
ReportError ( szErrorText );
goto error;
}
#ifdef COMPLUS_SHIM
// Create the COM+ header file
strcpy ( szFileName, _pszOutputPath );
strcat ( szFileName, "\\" );
strcat ( szFileName, "MSProxy.h" );
fpHComPlusFile = fopen ( szFileName, "r" );
if (!fpHComPlusFile)
{
fWriteHeader = TRUE;
}
else
{
fclose(fpHComPlusFile);
}
fpHComPlusFile = fopen ( szFileName, "a" );
if ( !fpHComPlusFile )
{
printf ( szErrorText, "Can't open COM+ output file %s\n", szFileName );
ReportError ( szErrorText );
goto error;
}
// Only write the header first time through not when each PDL is parsed.
if (fWriteHeader)
{
fprintf(fpHComPlusFile, "[managed, com] __interface ICOMCookie\n");
fprintf(fpHComPlusFile, "{\n");
fprintf(fpHComPlusFile, "public:\n");
fprintf(fpHComPlusFile, "\tunsigned int getCOMCookie();\n");
fprintf(fpHComPlusFile, "};\n\n");
}
// Create the COM+ source file
strcpy ( szFileName, _pszOutputPath );
strcat ( szFileName, "\\" );
strcat ( szFileName, "MSProxy.cpp" );
fpCComPlusFile = fopen ( szFileName, "r" );
if (!fpCComPlusFile)
{
fWriteHeader = TRUE;
}
else
{
fclose(fpCComPlusFile);
}
fpCComPlusFile = fopen ( szFileName, "a" );
if ( !fpCComPlusFile )
{
printf ( szErrorText, "Can't open COM+ output file %s\n", szFileName );
ReportError ( szErrorText );
goto error;
}
// Only write the header first time through not when each PDL is parsed.
if (fWriteHeader)
{
fprintf(fpCComPlusFile, "#import <MSCorLib.dll>\n\n");
fprintf(fpCComPlusFile, "// Some types COM+ doesn't know remapped.\n");
fprintf(fpCComPlusFile, "#define LONG long\n\n");
fprintf(fpCComPlusFile, "#include \"MSProxy.h\"\n");
fprintf(fpCComPlusFile, "#include \"TComPlus.hxx\"\n\n\n");
}
#endif // COMPLUS_SHIM
// Create the IDL File
strcpy ( szFileName, szOutputFileRoot );
strcat ( szFileName, ".idl" );
fpIDLFile = fopen ( szFileName, "w" );
if ( !fpIDLFile )
{
printf ( szErrorText, "Can't open IDL output file %s\n", szFileName );
ReportError ( szErrorText );
goto error;
}
// Create the external Header file for the SDK users
// Create the HDL File
strcpy ( szFileName, szOutputFileRoot );
strcat ( szFileName, ".h" ); // For now
fpHeaderFile = fopen ( szFileName, "w" );
if ( !fpHeaderFile )
{
printf ( szErrorText, "Can't open Header output file %s\n", szFileName );
ReportError ( szErrorText );
goto error;
}
// Create the external DISPIDs file for the SDK users
strcpy ( szFileName, szOutputFileRoot );
strcat ( szFileName, ".dsp" ); // For now
fpDISPIDFile = fopen ( szFileName, "w" );
if ( !fpDISPIDFile )
{
printf ( szErrorText, "Can't open DISPID output file %s\n", szFileName );
ReportError ( szErrorText );
goto error;
}
// Create function signatures required for the custom OLEAutomation invoke.
if ( !LoadSignatures (szOutputPath) )
{
ReportError ( "Signature file missing" );
goto error;
}
#if COLLECT_STATISTICS==1
LoadStatistics (szOutputPath);
#endif
// Parsed Successfully - generate HDL file
if ( !GenerateHDLFile () )
{
printf ( szErrorText, "Can't create HDL output file %s%s.hdl\n",
szOutputFileRoot, szFileName );
ReportError ( szErrorText );
goto error;
}
strcpy ( szFileName, szOutputFileRoot );
strcat ( szFileName, ".idl" ); // For now hxx
if ( !GenerateIDLFile( szFileName ) )
{
printf ( szErrorText, "Can't create IDL file %s\n", szFileName );
ReportError ( szErrorText );
goto error;
}
// Generate the .H file with just enums & interface decls in
GenerateHeaderFile();
// Generate the external DISPID's file
GenerateExternalInterfaceDISPIDs();
GenerateEventDISPIDs ( fpDISPIDFile, FALSE );
// Create/Open the HTML index file
strcpy ( szFileName, szOutputPath );
strcat ( szFileName, FILENAME_SEPARATOR_STR "AllIndex.htm" );
fpHTMIndexFile = fopen ( szFileName, "a+" );
/* rgardner - commented out for now - not very up-to-date or useful any more
// Create the HTM File
strcpy ( szFileName, szOutputFileRoot );
strcat ( szFileName, ".htm" );
fpHTMFile = fopen ( szFileName, "w" );
if ( !GenerateHTMFile( ) )
{
printf ( szErrorText, "Can't create HTM file %s\n", szFileName );
ReportError ( szErrorText );
goto error;
}
*/
// Update the signature file is any changes.
if (!SaveSignatures( szOutputPath ))
{
ReportError ( "Signature file save problem." );
goto error;
}
#if COLLECT_STATISTICS==1
SaveStatistics (szOutputPath);
#endif
goto cleanup;
error:
if ( nReturnCode == 0 )
nReturnCode = 1;
cleanup:
return nReturnCode;
}
#if COLLECT_STATISTICS==1
void CPDLParser::LoadStatistics ( char *pszOutputPath )
{
BOOL bRetVal;
char *buffer = NULL;
CString szFileName;
FILE *fpStatFile = NULL;
szFileName = pszOutputPath;
szFileName += FILENAME_SEPARATOR_STR "stats.dat";
fpStatFile = fopen ( szFileName, "r" );
if ( !fpStatFile )
{
char chInitFuncSig[2] = { '\0', '\0' };
fpStatFile = fopen ( szFileName, "w+");
if ( !fpStatFile )
{
ReportError ( "Can't create statistics file" );
goto error;
}
fwrite ( chInitFuncSig, 1, sizeof(chInitFuncSig), fpStatFile );
}
if ( fseek( fpStatFile, 0, SEEK_END ) == 0 )
{
fpos_t pos;
if ( fgetpos( fpStatFile, &pos ) == 0 )
{
int i = 0;
int cLines;
buffer = new char[pos];
if (buffer == NULL)
goto error;
fseek( fpStatFile, 0, SEEK_SET );
if ( fread ( buffer, 1, pos, fpStatFile ) != pos )
goto error;
// Intialize to 0.
for (i = 0; i < MAX_STATS; i++)
rgcStats[i] = 0;
// Populate the statics array.
i = 0;
cLines = 0;
while ( buffer[i] || buffer[i + 1] )
{
int cStr = strlen(buffer + i);
rgcStats[cLines] = atol(buffer + i);
cLines ++;
i += cStr + 1;
}
}
}
bRetVal = TRUE;
cleanup:
delete buffer;
fclose ( fpStatFile );
return;
error:
bRetVal = FALSE;
goto cleanup;
}
void CPDLParser::SaveStatistics ( char *pszOutputPath )
{
//DebugBreak();
BOOL bRetVal = TRUE;
if (rgcStats)
{
int i;
CString szFileName;
FILE *fpStatFile = NULL;
char buffer[32];
szFileName = pszOutputPath;
szFileName += FILENAME_SEPARATOR_STR "stats.dat";
fpStatFile = fopen ( szFileName, "w" );
// Write array to file.
if ( fseek( fpStatFile, 0, SEEK_SET ) != 0 )
return;
i = 0;
while (i < MAX_STATS)
{
sprintf( buffer, "%i", rgcStats[i] );
fwrite ( buffer, 1, strlen(buffer) + 1, fpStatFile );
i++;
}
// Double NULL at the end.
buffer[0] = '\0';
buffer[1] = '\0';
fwrite ( &buffer, 1, 2, fpStatFile );
fclose(fpStatFile);
}
return;
}
#endif
void CPDLParser::RemoveSignatures()
{
if (rgszSignatures)
{
int i = cSignatures;
while (i--)
delete [] rgszSignatures[i];
delete [] rgszSignatures;
rgszSignatures = NULL;
}
if (rgszIIDs)
{
int i = cIIDs;
while (i--)
delete [] rgszIIDs[i];
delete [] rgszIIDs;
rgszIIDs = NULL;
}
}
BOOL CPDLParser::LoadSignatures ( char *pszOutputPath )
{
BOOL bRetVal;
char *buffer = NULL;
CString szFileName;
FILE *fpSigFile = NULL;
rgszSignatures = NULL;
cOnFileSignatures = 0;
cOnFileIIDs = 0;
cSignatures = 0;
cIIDs = 0;
szFileName = pszOutputPath;
szFileName += FILENAME_SEPARATOR_STR "funcsig.dat";
/*
if (strcmp(_pszPDLFileName, "select.pdl") == 0 || strcmp(_pszPDLFileName, "header.pdl") == 0)
__asm { int 3 };
*/
fpSigFile = fopen ( szFileName, "rb" );
if ( !fpSigFile )
{
char chInitFuncSig[6] = { '\0', '\0', '\0', '\0', '\0', '\0' };
fpSigFile = fopen ( szFileName, "w+");
if ( !fpSigFile )
{
ReportError ( "Can't create function signature file" );
goto error;
}
fwrite ( chInitFuncSig, 1, sizeof(chInitFuncSig), fpSigFile );
}
if ( fseek( fpSigFile, 0, SEEK_END ) == 0 )
{
fpos_t pos;
if ( fgetpos( fpSigFile, &pos ) == 0 )
{
int i = 0;
int cLines;
buffer = new char[pos];
if (buffer == NULL)
goto error;
fseek( fpSigFile, 0, SEEK_SET );
fread ( buffer, 1, pos, fpSigFile );
// Number of entries for each signatures and IIDs
cOnFileSignatures = buffer[0] & 0x000000ff; // First byte is # signature
cOnFileIIDs = buffer[1] & 0x000000ff; // 2nd byte is # IIDs
// Pre-allocate the signature array.
rgszSignatures = new char *[cOnFileSignatures + 1];
if ( !rgszSignatures )
goto error;
// Pre-allocate the IIDs array.
rgszIIDs = new char *[cOnFileIIDs + 1];
if ( !rgszIIDs )
goto error;
// Intialize to NULL for error handling.
for (i = 0; i <= cOnFileSignatures; i++)
rgszSignatures[i] = NULL;
cSignatures = cOnFileSignatures;
for (i = 0; i <= cOnFileIIDs; i++)
rgszIIDs[i] = NULL;
cIIDs = cOnFileIIDs;
// Populate the signature array.
i = 4;
cLines = 0;
while ( cLines != cSignatures )
{
int cStr = strlen(buffer + i);
rgszSignatures[cLines] = new char[cStr + 1];
if (!rgszSignatures[cLines])
goto error;
strcpy(rgszSignatures[cLines], buffer + i);
cLines ++;
i += cStr + 1;
}
// Populate the IIDs array.
cLines = 0;
while ( cLines != cIIDs )
{
int cStr = strlen(buffer + i);
rgszIIDs[cLines] = new char[cStr + 1];
if (!rgszIIDs[cLines])
goto error;
strcpy(rgszIIDs[cLines], buffer + i);
cLines ++;
i += cStr + 1;
}
}
}
bRetVal = TRUE;
cleanup:
fclose ( fpSigFile );
return bRetVal;
error:
delete [] buffer;
RemoveSignatures();
bRetVal = FALSE;
goto cleanup;
}
BOOL CPDLParser::SaveSignatures ( char *pszOutputPath )
{
if (rgszSignatures || rgszIIDs)
{
if (cOnFileSignatures != cSignatures || cOnFileIIDs != cIIDs)
{
int i;
CString szFileName;
FILE *fpSigFile = NULL;
char cHeaderFuncSig[4] = { '\0', '\0', '\0', '\0' };
szFileName = pszOutputPath;
szFileName += FILENAME_SEPARATOR_STR "funcsig.dat";
fpSigFile = fopen ( szFileName, "wb" );
// Write array to file.
if ( fseek( fpSigFile, 0, SEEK_SET ) != 0 )
return FALSE;
// Write out the header on count of each type.
cHeaderFuncSig[0] = (char)cSignatures;
cHeaderFuncSig[1] = (char)cIIDs;
fwrite ( cHeaderFuncSig, 1, sizeof(cHeaderFuncSig), fpSigFile );
i = 0;
while (i < cSignatures)
{
if ( rgszSignatures[i] )
{
fwrite ( rgszSignatures[i], 1, strlen(rgszSignatures[i]) + 1, fpSigFile );
}
i++;
}
i = 0;
while (i < cIIDs)
{
if ( rgszIIDs[i] )
{
fwrite ( rgszIIDs[i], 1, strlen(rgszIIDs[i]) + 1, fpSigFile );
}
i++;
}
// Write out extra zero to mark end of file.
cHeaderFuncSig[0] = '\0';
fwrite ( cHeaderFuncSig, 1, 1, fpSigFile );
fclose(fpSigFile);
}
// Dispose of signature array (IIDs is disposed of too).
RemoveSignatures();
}
return TRUE;
}
void
CPDLParser::MakeSignature (LPCSTR szType, LPCSTR szSignature, CString & szLookup)
{
char *szWork;
// Any empty string for type or signature is an error.
if (!szType[0] || !szSignature[0])
{
return;
}
// Replace all * with p (e.g., BSTR * is BSTRP and long * is longP).
while ((szWork = strchr(szSignature, '*')) != NULL)
*szWork = 'p';
// Replace all ( with P.
while ((szWork = strchr(szSignature, '(')) != NULL)
*szWork = 'P';
// Replace all ) with P.
while ((szWork = strchr(szSignature, ')')) != NULL)
*szWork = 'P';
szLookup = szType;
szLookup += "_";
szLookup += szSignature;
}
BOOL CPDLParser::FindAndAddSignature ( LPCSTR szType, LPCSTR szSignature, LPSTR pszInvokeMethod )
{
BOOL bRetVal = NULL;
CString szLookup;
char **rgNewArray = NULL;
if (pszInvokeMethod && rgszSignatures)
{
strcpy( pszInvokeMethod, "ERROR in PDLParse: No custom invoke method");
MakeSignature(szType, szSignature, szLookup);
// Look for the signature
for (int i = 0; i < cSignatures; i++)
{
if ( strcmp ( rgszSignatures[i], szLookup ) == 0 )
{
goto success;
}
}
// If not found then add this signature.
cSignatures++;
rgNewArray = new char *[cSignatures + 1]; // Take into account the NULL at end.
if (!rgNewArray)
goto cleanup;
memcpy(rgNewArray, rgszSignatures, sizeof(char *) * cSignatures);
rgNewArray[cSignatures - 1] = new char[szLookup.Length() + 1];
strcpy(rgNewArray[cSignatures - 1], szLookup);
rgNewArray[cSignatures] = NULL;
delete rgszSignatures;
rgszSignatures = rgNewArray;
success:
strcpy(pszInvokeMethod, "IDX_");
strcat(pszInvokeMethod, (LPCSTR)szLookup);
bRetVal = TRUE;
}
cleanup:
return bRetVal;
}
int CPDLParser::FindAndAddIIDs ( CString szInterface )
{
char **rgNewArray = NULL;
// Any empty string interface name is an error.
if (szInterface.Length() == 0)
return -1; // Error.
// Look for the signature
for (int i = 0; i < cIIDs; i++)
{
if ( strcmp ( rgszIIDs[i], (LPCSTR)szInterface ) == 0 )
{
goto success;
}
}
// If not found then add this IID.
cIIDs++;
rgNewArray = new char *[cIIDs + 1]; // Take into account the NULL at end.
if (!rgNewArray)
return -1;
memcpy(rgNewArray, rgszIIDs, sizeof(char *) * cIIDs);
rgNewArray[cIIDs - 1] = new char[szInterface.Length() + 1];
strcpy(rgNewArray[cIIDs - 1], (LPCSTR)szInterface);
rgNewArray[cIIDs] = NULL;
delete rgszIIDs;
rgszIIDs = rgNewArray;
success:
return i;
}
BOOL CPDLParser::GenerateIDLFile ( char *szFileName )
{
CTokenListWalker ThisFileList ( pRuntimeList, _pszPDLFileName );
Token * pInterfaceToken;
Token * pClassToken;
Token * pEnumToken;
Token * pStructToken;
ThisFileList.Reset();
while ( pInterfaceToken = ThisFileList.GetNext ( TYPE_EVENT ) )
{
if ( !pInterfaceToken -> IsSet ( EVENT_ABSTRACT ) &&
pInterfaceToken -> IsSet ( EVENT_GUID ) )
{
GenerateIDLInterfaceDecl ( pInterfaceToken,
pInterfaceToken -> GetTagValue ( EVENT_GUID ),
pInterfaceToken -> GetTagValue ( EVENT_SUPER ) );
}
}
ThisFileList.Reset();
while (pEnumToken = ThisFileList.GetNext(TYPE_ENUM))
{
GenerateIncludeEnum(pEnumToken, FALSE, fpIDLFile);
}
//
// Generate all the structs
//
ThisFileList.Reset();
while (pStructToken = ThisFileList.GetNext(TYPE_STRUCT))
{
GenerateStruct(pStructToken, fpIDLFile);
}
ThisFileList.Reset();
while ( pInterfaceToken = ThisFileList.GetNext ( TYPE_INTERFACE ) )
{
if ( !pInterfaceToken -> IsSet ( INTERFACE_ABSTRACT ) &&
pInterfaceToken -> IsSet ( INTERFACE_GUID ) )
{
GenerateIDLInterfaceDecl ( pInterfaceToken,
pInterfaceToken -> GetTagValue ( INTERFACE_GUID ),
pInterfaceToken -> GetTagValue ( INTERFACE_SUPER ) );
}
else if ( !pInterfaceToken -> IsSet ( INTERFACE_ABSTRACT ) &&
!pInterfaceToken -> IsSet ( INTERFACE_GUID ) )
{
// Generate a forward declare
CString szInterfaceName;
szInterfaceName = pInterfaceToken -> GetTagValue ( INTERFACE_NAME );
if ( szInterfaceName != "IDispatch" &&
szInterfaceName != "IUnknown" )
{
fprintf ( fpIDLFile, "interface %s;\n",
pInterfaceToken -> GetTagValue ( NAME_TAG ) );
}
}
}
ThisFileList.Reset();
while (pClassToken = ThisFileList.GetNext(TYPE_CLASS))
{
CTokenListWalker ChildWalker(pClassToken);
Token *pChildToken;
int cImplements = 0;
// Find out how many implements are in the class.
while (pChildToken = ChildWalker.GetNext())
{
if (pChildToken->GetType() == TYPE_IMPLEMENTS)
{
cImplements++;
}
}
// Any class with more than one implements needs a mondodispid to be specified.
if (pClassToken->IsSet(CLASS_GUID) && cImplements && !pClassToken->IsSet(CLASS_MONDOGUID))
{
char szErrorText [ MAX_LINE_LEN+1 ];
sprintf(szErrorText,
"class: %s needs a mondoguid when implements are specified for a coclass.\n",
pClassToken->GetTagValue(CLASS_NAME));
ReportError(szErrorText);
return FALSE;
}
// Generate non-dual dispinterface? This is determined by the mondoguid
// keyword being used int the class. If this guid is specified then
// we'll generate the mondodisp interface is use it as the default
// dispatch interface for the coclass.
if (pClassToken->IsSet(CLASS_MONDOGUID))
{
LPSTR pMondoGUID;
CString szInterface;
szInterface = pClassToken->GetTagValue(CLASS_INTERFACE);
pInterfaceToken = FindInterface(szInterface);
pMondoGUID = pClassToken->GetTagValue(CLASS_MONDOGUID);
// If we have a GUID then the dispinterface GUID must be in the
// range 0x3050f500 to 0x3050f5a0
if (pMondoGUID[0] != '3' ||
pMondoGUID[1] != '0' ||
pMondoGUID[2] != '5' ||
pMondoGUID[3] != '0' ||
pMondoGUID[4] != 'f' ||
pMondoGUID[5] != '5' ||
!((pMondoGUID[6] >= '0' &&
pMondoGUID[6] <= '9') ||
pMondoGUID[6] == 'a') ||
!((pMondoGUID[7] >= '0' &&
pMondoGUID[7] <= '9') ||
(pMondoGUID[7] >= 'a' &&
pMondoGUID[7] <= 'f')))
{
char szErrorText [ MAX_LINE_LEN+1 ];
sprintf(szErrorText,
"The mondoguid must be in the range 0x3050f500 to 0x3050f5a0 for class: %s\n",
pClassToken->GetTagValue(CLASS_NAME));
ReportError(szErrorText);
return FALSE;
}
// Generate the default dispinterface
GenerateIDLInterfaceDecl(pInterfaceToken,
pMondoGUID,
pInterfaceToken->GetTagValue(INTERFACE_SUPER),
TRUE,
pClassToken);
}
if ( pClassToken-> IsSet(CLASS_GUID) &&
pClassToken->IsSet(CLASS_INTERFACE))
{
GenerateCoClassDecl(pClassToken);
}
}
return TRUE;
}
void CPDLParser::GenerateIDLInterfaceDecl (Token *pInterfaceToken,
char *pszGUID,
char *pszSuper,
BOOL fDispInterface/*= FALSE*/,
Token *pClassToken/*= NULL*/)
{
BOOL fImplements = FALSE;
if ( pInterfaceToken -> GetType() == TYPE_EVENT )
{
fprintf ( fpIDLFile, "[\n hidden,\n" );
fprintf ( fpIDLFile, " uuid(%s)\n]\ndispinterface %s\n{",
pszGUID, pInterfaceToken -> GetTagValue ( NAME_TAG ) );
fprintf ( fpIDLFile, "\nproperties:\nmethods:\n" );
}
else
{
if (fDispInterface)
{
fprintf ( fpIDLFile, "[\n hidden,\n" );
fprintf ( fpIDLFile, " uuid(%s)\n]\ndispinterface Disp%s\n{\nproperties:\nmethods:\n",
pszGUID,
pClassToken->IsSet(CLASS_COCLASSNAME) ?
pClassToken->GetTagValue(CLASS_COCLASSNAME) :
pClassToken->GetTagValue(CLASS_NAME));
}
else
{
if (!PrimaryTearoff(pInterfaceToken) && (!pszSuper || !*pszSuper))
ReportError ( "Interfaces w/o tearoff need super:IDispatch\n" );
if (pInterfaceToken->IsSet(INTERFACE_CUSTOM) &&
pszSuper &&
*pszSuper)
{
fprintf(fpIDLFile, "[\n object,\n pointer_default(unique),\n" );
fprintf ( fpIDLFile, " uuid(%s)\n]\ninterface %s : %s\n{\n",
pszGUID,
pInterfaceToken -> GetTagValue ( NAME_TAG ),
pszSuper);
}
else
{
fprintf ( fpIDLFile, "[\n odl,\n oleautomation,\n dual,\n" );
fprintf ( fpIDLFile, " uuid(%s)\n]\ninterface %s : %s\n{\n",
pszGUID,
pInterfaceToken -> GetTagValue ( NAME_TAG ),
(PrimaryTearoff(pInterfaceToken) && _stricmp(pszSuper, "IHTMLDocument")) ? "IDispatch" : pszSuper);
}
}
}
// Any implements in the class if so then we want the order of the mongo dispinterface to be decided
// by the order of the implements and not the super chain.
if (fDispInterface)
{
CTokenListWalker ChildWalker(pClassToken);
Token *pChildToken;
while (pChildToken = ChildWalker.GetNext())
{
fImplements = pChildToken->GetType() == TYPE_IMPLEMENTS;
if (fImplements)
break;
}
}
// Use the super chain for mongo dispinterface?
if (!fImplements)
// Yes.
GenerateMkTypelibDecl(pInterfaceToken, fDispInterface, pClassToken);
// Any other interfaces exposed in the coclass which are not part of the
// primary interface chain? Look for implements keyword.
if (fDispInterface)
{
CTokenListWalker ChildWalker(pClassToken);
Token *pChildToken;
CString szInterface;
Token *pInterfToken;
while (pChildToken = ChildWalker.GetNext())
{
if (pChildToken->GetType() == TYPE_IMPLEMENTS)
{
szInterface = pChildToken->GetTagValue(IMPLEMENTS_NAME);
pInterfToken = FindInterface(szInterface);
if (pInterfToken)
{
GenerateMkTypelibDecl(pInterfToken, fDispInterface, pClassToken);
}
}
}
}
fprintf(fpIDLFile, "};\n");
}
void CPDLParser::ComputePropType ( Token *pPropertyToken,
CString &szProp, BOOL fComment )
{
char szText [ MAX_LINE_LEN+1 ];
szProp = "";
// Through the index/indextype & index1/indextype1 pdl tags
// you can provide up to two additional args for the property definition
sprintf ( szText, fComment ? "/* [in] */ %s %s" : "[in] %s %s",
pPropertyToken -> GetTagValue ( PROPERTY_INDEXTYPE ),
pPropertyToken -> GetTagValue ( PROPERTY_INDEX ) );
pPropertyToken -> AddParam ( szProp, PROPERTY_INDEX, szText );
sprintf ( szText, fComment ? "/* [in] */ %s %s" : "[in] %s %s",
pPropertyToken -> GetTagValue ( PROPERTY_INDEXTYPE1 ),
pPropertyToken -> GetTagValue ( PROPERTY_INDEX1 ));
pPropertyToken -> AddParam ( szProp, PROPERTY_INDEX1, szText );
if ( szProp [ 0 ] != '\0' )
szProp += ",";
}
void CPDLParser::GenerateMkTypelibDecl ( Token *pInterfaceToken, BOOL fDispInterface/* = FALSE*/, Token *pClass /* =NULL */)
{
Token *pChildToken;
Token *pArgToken;
CString szArg;
CString szProp;
CString szAutomationType;
BOOL fFirst;
CString szInterfaceName,szMethodName,szPropertyName;
CTokenListWalker ChildWalker ( pInterfaceToken );
if ( pInterfaceToken -> GetType() == TYPE_EVENT &&
pInterfaceToken -> IsSet ( EVENT_SUPER ) )
{
CTokenListWalker WholeList(pRuntimeList);
Token *pSuperEvent = WholeList.GetNext ( TYPE_EVENT,
pInterfaceToken -> GetTagValue ( EVENT_SUPER ) );
if ( pSuperEvent )
GenerateMkTypelibDecl ( pSuperEvent );
}
// Special non-dual dispinterface for the default when the primary interface
// is a tearoff.
if (fDispInterface)
{
Token *pSuperIntf;
CString szInterface;
szInterface = pInterfaceToken->GetTagValue(INTERFACE_SUPER);
pSuperIntf = FindInterface(szInterface);
if (pSuperIntf)
GenerateMkTypelibDecl(pSuperIntf, fDispInterface, pClass);
}
szInterfaceName = pInterfaceToken->GetTagValue ( INTERFACE_NAME );
szInterfaceName.ToUpper();
while ( pChildToken = ChildWalker.GetNext() )
{
if ( pChildToken -> GetType() == TYPE_METHOD )
{
// if nopropdesc is set, then this method doesn't
// participate in the typelib/mondo interface. this happens
// when the method exists in a base class/interface as well.
if ( pChildToken->IsSet(METHOD_NOPROPDESC) && fDispInterface)
continue;
// Does the property name exist in another interface then the primary
// interface had better have the override. Otherwise, it's an error
// MIDL will not allow overloading names.
if (fDispInterface && pClass)
{
CString szPrimaryInterface;
Token *pPriInterf;
Token *pExclusiveMember;
szPrimaryInterface = pClass->GetTagValue(CLASS_INTERFACE);
pPriInterf = FindInterface(szPrimaryInterface);
// If working on non-primary interface make sure the method isn't overloaded on
// the primary, if so it better be marked exclusive.
if (_strcmpi(szInterfaceName, szPrimaryInterface))
{
pExclusiveMember = FindMethodInInterfaceWOPropDesc(pPriInterf, pChildToken, TRUE);
if (pExclusiveMember)
{
char szErrorText [ MAX_LINE_LEN+1 ];
if (pExclusiveMember->IsSet(METHOD_EXCLUSIVETOSCRIPT))
continue;
// Overloaded method -- illegal.
sprintf(szErrorText, "method %s:%s is overloaded - illegal.\n",
(LPCSTR)pClass->GetTagValue(CLASS_NAME),
(LPCSTR)pExclusiveMember->GetTagValue(METHOD_NAME));
ReportError(szErrorText);
return;
}
}
}
if ( pChildToken -> IsSet ( METHOD_VARARG) )
{
fprintf ( fpIDLFile, " [vararg");
}
else
{
fprintf ( fpIDLFile, " [");
}
szMethodName = pChildToken -> GetTagValue ( METHOD_NAME );
if (pChildToken->IsSet(METHOD_NOPROPDESC))
{
if (pChildToken->IsSet(METHOD_SZINTERFACEEXPOSE))
szMethodName = pChildToken->GetTagValue(METHOD_SZINTERFACEEXPOSE);
}
szMethodName.ToUpper();
if ( pChildToken -> IsSet ( METHOD_DISPID ) )
{
fprintf ( fpIDLFile, "%sid(DISPID_%s_%s)",
pChildToken -> IsSet ( METHOD_VARARG ) ? "," : "",
(LPCSTR)szInterfaceName, (LPCSTR)szMethodName );
}
CTokenListWalker ArgListWalker ( pChildToken );
if (pChildToken->IsSet(METHOD_NOPROPDESC) &&
pChildToken->IsSet(METHOD_SZINTERFACEEXPOSE))
{
szMethodName = pChildToken->GetTagValue(METHOD_SZINTERFACEEXPOSE);
}
else
{
szMethodName = pChildToken->GetTagValue(METHOD_NAME);
}
if (fDispInterface)
{
szAutomationType = "void";
while ( pArgToken = ArgListWalker.GetNext() )
{
if (pArgToken->IsSet(METHODARG_RETURNVALUE))
{
szAutomationType = pArgToken->IsSet(METHODARG_ATYPE ) ?
pArgToken->GetTagValue(METHODARG_ATYPE) :
pArgToken->GetTagValue(METHODARG_TYPE);
}
// If the last character is a pointer then the pointer
// should be removed because that is for dual C++ style
// interface. DispInterface doesn't need the retval
// specified as a parameter hence the need for
// HRESULT funcName(BOOL*) instead of BOOL funcName ().
int iSzLength = szAutomationType.Length();
if (iSzLength && szAutomationType[iSzLength - 1] == '*')
{
char szTypeNoPtr[MAX_LINE_LEN+1];
strncpy(szTypeNoPtr, szAutomationType, iSzLength - 1);
szTypeNoPtr[iSzLength - 1] = '\0';
szAutomationType = szTypeNoPtr;
}
}
fprintf ( fpIDLFile, "] %s %s(",
(LPCSTR)szAutomationType,
(LPCSTR)szMethodName );
ArgListWalker.Reset();
}
else
{
fprintf ( fpIDLFile, "] %s %s(",
pChildToken -> GetTagValue ( METHOD_RETURNTYPE ),
(LPCSTR)szMethodName );
}
fFirst = TRUE;
while ( pArgToken = ArgListWalker.GetNext() )
{
if (!(fDispInterface && pArgToken->IsSet(METHODARG_RETURNVALUE)))
{
szArg = "";
if ( !fFirst )
fprintf ( fpIDLFile, "," );
#ifndef WIN16_PARSER
pArgToken -> AddParamStr ( szArg, METHODARG_DEFAULTVALUE, "defaultvalue(%s)" );
#endif
pArgToken -> AddParam ( szArg, METHODARG_OPTIONAL, "optional" );
pArgToken -> AddParam ( szArg, METHODARG_RETURNVALUE, "retval" );
pArgToken -> AddParam ( szArg, METHODARG_IN, "in" );
pArgToken -> AddParam ( szArg, METHODARG_OUT, "out" );
fprintf ( fpIDLFile, "[%s] %s %s",
(LPCSTR)szArg,
// Fixing a bug in the old code
// Should really get the atype - allow the type if atype not set
pArgToken -> IsSet ( METHODARG_ATYPE ) ?
pArgToken -> GetTagValue ( METHODARG_ATYPE ) :
pArgToken -> GetTagValue ( METHODARG_TYPE ),
pArgToken -> GetTagValue ( METHODARG_ARGNAME ) );
fFirst = FALSE;
}
}
fprintf ( fpIDLFile, ");\n" );
}
else // Property
{
ComputePropType ( pChildToken, szProp, FALSE );
szAutomationType = pChildToken -> GetTagValue ( PROPERTY_ATYPE );
// if nopropdesc is set, then this property doesn't
// participate in the typelib/mondo interface. this happens
// when the property exists in a base class/interface as well.
if (pChildToken->IsSet(PROPERTY_NOPROPDESC) && fDispInterface)
continue;
// Does the property name exist in another interface then the primary
// interface had better have the override. Otherwise, it's an error
// MIDL will not allow overloading names.
if (fDispInterface && pClass)
{
CString szPrimaryInterface;
Token *pPriInterf;
Token *pExclusiveMember;
szPrimaryInterface = pClass->GetTagValue(CLASS_INTERFACE);
pPriInterf = FindInterface(szPrimaryInterface);
// If working on non-primary interface make sure the property isn't overloaded on
// the primary, if so it better be marked exclusive.
if (_strcmpi(szInterfaceName, szPrimaryInterface))
{
pExclusiveMember = FindMethodInInterfaceWOPropDesc(pPriInterf, pChildToken, TRUE);
if (pExclusiveMember)
{
char szErrorText [ MAX_LINE_LEN+1 ];
if (pExclusiveMember->IsSet(PROPERTY_EXCLUSIVETOSCRIPT))
continue;
// Overloaded method -- illegal.
sprintf(szErrorText, "property %s:%s is overloaded - illegal.\n",
(LPCSTR)pClass->GetTagValue(CLASS_NAME),
(LPCSTR)pExclusiveMember->GetTagValue(PROPERTY_NAME));
ReportError(szErrorText);
return;
}
}
}
if ( pChildToken -> IsSet ( PROPERTY_SET ) )
{
#if COLLECT_STATISTICS==1
// Collect statistics on total number of property sets.
CollectStatistic(NUM_SETPROPERTY, GetStatistic(NUM_SETPROPERTY) + 1);
if (FindEnum ( pChildToken ))
CollectStatistic(NUM_SETENUMS, GetStatistic(NUM_SETENUMS) + 1);
#endif
// If it's an object valued property, generate a propputref,
// otherwise generate a propput
//
if ( pChildToken -> IsSet ( PROPERTY_OBJECT ) )
{
szArg = " [propputref";
}
else
{
szArg = " [propput";
}
if ( pChildToken -> IsSet ( PROPERTY_DISPID ) )
{
szArg += ", id(DISPID_";
szPropertyName = pChildToken->GetTagValue(PROPERTY_NAME);
if (pChildToken->IsSet(PROPERTY_NOPROPDESC))
{
if (pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE))
szPropertyName = pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE);
}
szPropertyName.ToUpper();
szArg += (LPCSTR)szInterfaceName;
szArg += "_";
szArg += (LPCSTR)szPropertyName;
szArg += ")";
}
pChildToken -> AddParam ( szArg, PROPERTY_DISPLAYBIND, "displaybind" );
pChildToken -> AddParam ( szArg, PROPERTY_BINDABLE, "bindable" );
pChildToken -> AddParam ( szArg, PROPERTY_HIDDEN, "hidden" );
pChildToken -> AddParam ( szArg, PROPERTY_RESTRICTED, "restricted" );
#ifndef WIN16_PARSER
pChildToken -> AddParam ( szArg, PROPERTY_NONBROWSABLE, "nonbrowsable" );
#endif
pChildToken -> AddParam ( szArg, PROPERTY_SOURCE, "source" );
if (pChildToken->IsSet(PROPERTY_NOPROPDESC) &&
pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE))
{
szPropertyName = pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE);
}
else
{
szPropertyName = pChildToken->GetTagValue(PROPERTY_NAME);
}
if (fDispInterface)
{
fprintf ( fpIDLFile, "%s] void %s(%s%s v);\n",
(LPCSTR)szArg, (LPCSTR)szPropertyName,
(LPCSTR)szProp, (LPCSTR)szAutomationType );
}
else
{
fprintf ( fpIDLFile, "%s] HRESULT %s(%s[in] %s v);\n",
(LPCSTR)szArg, (LPCSTR)szPropertyName,
(LPCSTR)szProp, (LPCSTR)szAutomationType );
}
}
if ( pChildToken -> IsSet ( PROPERTY_GET ) )
{
#if COLLECT_STATISTICS==1
// Collect statistics on total number of property sets.
CollectStatistic(NUM_GETPROPERTY, GetStatistic(NUM_GETPROPERTY) + 1);
if (FindEnum ( pChildToken ))
CollectStatistic(NUM_GETENUMS, GetStatistic(NUM_GETENUMS) + 1);
#endif
szArg = " [propget";
szArg += ", id(DISPID_";
szPropertyName = pChildToken->GetTagValue(PROPERTY_NAME);
if (pChildToken->IsSet(PROPERTY_NOPROPDESC))
{
if (pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE))
szPropertyName = pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE);
}
szPropertyName.ToUpper();
szArg += (LPCSTR)szInterfaceName;
szArg += "_";
szArg += (LPCSTR)szPropertyName;
szArg += ")";
pChildToken -> AddParam ( szArg, PROPERTY_DISPLAYBIND, "displaybind" );
pChildToken -> AddParam ( szArg, PROPERTY_BINDABLE, "bindable" );
pChildToken -> AddParam ( szArg, PROPERTY_HIDDEN, "hidden" );
pChildToken -> AddParam ( szArg, PROPERTY_RESTRICTED, "restricted" );
#ifndef WIN16_PARSER
pChildToken -> AddParam ( szArg, PROPERTY_NONBROWSABLE, "nonbrowsable" );
#endif
pChildToken -> AddParam ( szArg, PROPERTY_SOURCE, "source" );
if (pChildToken->IsSet(PROPERTY_NOPROPDESC) &&
pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE))
{
szPropertyName = pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE);
}
else
{
szPropertyName = pChildToken->GetTagValue(PROPERTY_NAME);
}
if (fDispInterface)
{
fprintf ( fpIDLFile, "%s] %s %s();\n",
(LPCSTR)szArg,
(LPCSTR)szAutomationType,
(LPCSTR)szPropertyName);
}
else
{
fprintf ( fpIDLFile, "%s] HRESULT %s(%s[retval, out] %s * p);\n",
(LPCSTR)szArg, (LPCSTR)szPropertyName,
(LPCSTR)szProp, (LPCSTR)szAutomationType );
}
}
}
}
}
void CPDLParser::GenerateMidlInterfaceDecl ( Token *pInterfaceToken, char *pszGUID,
char *pszSuper )
{
Token *pChildToken;
Token *pArgToken;
CString szArg;
CString szProp;
BOOL fFirst;
if ( pInterfaceToken -> GetType() == TYPE_EVENT )
return;
fprintf ( fpIDLFile, "[\n local,\n object,\n pointer_default(unique),\n" );
fprintf ( fpIDLFile, " uuid(%s)\n]\ninterface %s : %s\n{\n",
pInterfaceToken -> GetTagValue ( INTERFACE_GUID ),
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ),
pInterfaceToken -> GetTagValue ( INTERFACE_SUPER ) );
CTokenListWalker ChildWalker ( pInterfaceToken );
while ( pChildToken = ChildWalker.GetNext() )
{
if ( pChildToken -> GetType() == TYPE_METHOD )
{
fprintf ( fpIDLFile, " %s %s(",
pChildToken -> GetTagValue ( METHOD_RETURNTYPE ),
pChildToken -> GetTagValue ( METHOD_NAME ) );
fFirst = TRUE;
CTokenListWalker ArgListWalker ( pChildToken );
while ( pArgToken = ArgListWalker.GetNext() )
{
szArg = "";
if ( !fFirst )
fprintf ( fpIDLFile, "," );
pArgToken -> AddParam ( szArg, METHODARG_IN, "in" );
pArgToken -> AddParam ( szArg, METHODARG_OUT, "out" );
fprintf ( fpIDLFile, "[%s] %s %s", (LPCSTR)szArg,
// Fixing a bug in the old code
// Should realy get the atype - allow the type if atype not set
pArgToken -> IsSet ( METHODARG_ATYPE ) ?
pArgToken -> GetTagValue ( METHODARG_ATYPE ) :
pArgToken -> GetTagValue ( METHODARG_TYPE ),
pArgToken -> GetTagValue ( METHODARG_ARGNAME ) );
fFirst = FALSE;
}
fprintf ( fpIDLFile, ");\n" );
}
else
{
// Property
ComputePropType ( pChildToken, szProp, FALSE );
if ( pChildToken -> IsSet ( PROPERTY_SET ))
{
fprintf ( fpIDLFile, " HRESULT put_%s(%s [in] %s v);\n",
(LPCSTR)pChildToken -> GetTagValue ( PROPERTY_NAME ),
(LPCSTR)szProp,
pChildToken -> GetTagValue ( PROPERTY_ATYPE) );
}
if ( pChildToken -> IsSet ( PROPERTY_GET ))
{
fprintf ( fpIDLFile,
" HRESULT get_%s(%s[out] %s * p);\n",
pChildToken -> GetTagValue ( PROPERTY_NAME ),
(LPCSTR)szProp,
pChildToken -> GetTagValue ( PROPERTY_ATYPE));
}
}
}
fprintf ( fpIDLFile, "}\n" );
}
BOOL CPDLParser::HasMondoDispInterface ( Token *pClassToken )
{
CTokenListWalker ChildWalker(pClassToken);
Token *pChildToken;
int cImplements = 0;
// Find out how many implements are in the class.
while (pChildToken = ChildWalker.GetNext())
{
if (pChildToken->GetType() == TYPE_IMPLEMENTS)
{
cImplements++;
}
}
// Any class with more than one implements a guid and a mondoguid will have
// a mondo dispinterface.
return (pClassToken->IsSet(CLASS_GUID) && cImplements && pClassToken->IsSet(CLASS_MONDOGUID));
}
void CPDLParser::GenerateCoClassDecl ( Token *pClassToken )
{
CString szName;
CString szDispName;
CString szInterfSuper;
BOOL fHasMondoDispInterface;
BOOL fElement = FALSE;
if (pClassToken->IsSet(CLASS_COCLASSNAME))
szName = pClassToken->GetTagValue(CLASS_COCLASSNAME);
else
szName = pClassToken->GetTagValue(CLASS_NAME);
fprintf(fpIDLFile, "[\n %suuid(%s)\n]\n",
pClassToken->IsSet(CLASS_CONTROL) ? "control,\n " : "",
pClassToken->GetTagValue(CLASS_GUID));
fprintf(fpIDLFile, "coclass %s\n{\n", (LPCSTR)szName );
fHasMondoDispInterface = HasMondoDispInterface(pClassToken);
if (fHasMondoDispInterface)
{
// Map to mondo dispinterface as default dispatch interface.
szDispName = (pClassToken->IsSet(CLASS_COCLASSNAME)) ?
pClassToken->GetTagValue (CLASS_COCLASSNAME) :
pClassToken->GetTagValue(CLASS_NAME);
}
else
{
// Map to the primary interface as default dispatch interface.
szDispName = pClassToken->GetTagValue(CLASS_INTERFACE);
}
fprintf(fpIDLFile, " [default] %sinterface %s%s;\n",
fHasMondoDispInterface ? "disp" : "",
fHasMondoDispInterface ? "Disp" : "",
(LPCSTR)szDispName);
if (pClassToken->IsSet(CLASS_EVENTS))
{
fprintf(fpIDLFile, " [source, default] dispinterface %s;\n",
pClassToken->GetTagValue(CLASS_EVENTS));
}
if (pClassToken->IsSet(CLASS_NONPRIMARYEVENTS1))
{
fprintf(fpIDLFile, " [source] dispinterface %s;\n",
pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS1));
}
if (pClassToken->IsSet(CLASS_NONPRIMARYEVENTS2))
{
fprintf(fpIDLFile, " [source] dispinterface %s;\n",
pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS2));
}
if (pClassToken->IsSet(CLASS_NONPRIMARYEVENTS3))
{
fprintf(fpIDLFile, " [source] dispinterface %s;\n",
pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS3));
}
if (pClassToken->IsSet(CLASS_NONPRIMARYEVENTS4))
{
fprintf(fpIDLFile, " [source] dispinterface %s;\n",
pClassToken->GetTagValue(CLASS_NONPRIMARYEVENTS4));
}
// Any other interface to expose in the coclass which is part of the primary
// interface?
CTokenListWalker ChildWalker(pClassToken);
Token *pChildToken;
while (pChildToken = ChildWalker.GetNext())
{
if (pChildToken->GetType() == TYPE_IMPLEMENTS)
{
Token *pInterf;
CString szInterface;
if (!fElement)
fElement = !_stricmp((LPSTR)pChildToken->GetTagValue(IMPLEMENTS_NAME), "IHTMLElement");
szInterface = pChildToken->GetTagValue(IMPLEMENTS_NAME);
pInterf = FindInterface(szInterface);
if (pInterf)
{
// Is the interface a local one if not then don't check, we
// only need to check where interfaces are actually used.
if (FindInterfaceLocally(szInterface))
{
// If the super isn't specified and it's not a primary interface
// then error the super is required for non-primary interfaces.
if (_stricmp((LPSTR)pClassToken->GetTagValue(CLASS_INTERFACE),
(LPSTR)pInterf->GetTagValue(INTERFACE_NAME)) &&
!pInterf->IsSet(INTERFACE_SUPER) &&
!IsPrimaryInterface(szInterface))
{
char szErrorText [ MAX_LINE_LEN+1 ];
sprintf(szErrorText, "Interface %s missing super key.\n",
(LPSTR)pInterf->GetTagValue(INTERFACE_NAME));
ReportError(szErrorText);
return;
}
}
fprintf(fpIDLFile, " interface %s;\n",
(LPCSTR)pInterf->GetTagValue(INTERFACE_NAME));
}
}
}
fprintf(fpIDLFile, "};\n");
fprintf(fpIDLFile, "cpp_quote(\"EXTERN_C const GUID CLSID_%s;\")\n",
pClassToken->GetTagValue(CLASS_NAME));
if (!pClassToken->IsSet(CLASS_EVENTS) && fElement)
{
char szErrorText [ MAX_LINE_LEN+1 ];
sprintf(szErrorText, "Class %s missing events key.\n", pClassToken->GetTagValue(CLASS_NAME));
ReportError(szErrorText);
return;
}
}
void CPDLParser::GenerateEnumDescIDL ( Token *pEnumToken )
{
Token *pEvalToken;
CString szName;
fprintf ( fpIDLFile, "\ntypedef [uuid(%s)] enum _%s {\n" ,
pEnumToken -> GetTagValue ( ENUM_GUID ),
pEnumToken -> GetTagValue ( ENUM_NAME ) );
CTokenListWalker EvalChildList ( pEnumToken );
while ( pEvalToken = EvalChildList.GetNext() )
{
if ( pEvalToken -> IsSet ( EVAL_ODLNAME ) )
{
szName = pEvalToken -> GetTagValue ( EVAL_ODLNAME );
}
else
{
szName = pEnumToken -> GetTagValue ( ENUM_NAME );
szName += pEvalToken -> GetTagValue ( EVAL_NAME );
}
fprintf ( fpIDLFile, " [helpstring(\"%s\")] %s = %s,\n",
pEvalToken -> IsSet ( EVAL_STRING ) ?
pEvalToken -> GetTagValue ( EVAL_STRING ) :
pEvalToken -> GetTagValue ( EVAL_NAME ),
(LPCSTR)szName,
pEvalToken -> GetTagValue ( EVAL_VALUE ) );
}
fprintf ( fpIDLFile, "}%s;\n",
pEnumToken -> GetTagValue ( ENUM_NAME ) );
}
void CPDLParser::ReportError ( LPCSTR szErrorString )
{
printf ( "%s(0) : error PDL0000: %s", _pszPDLFileName, szErrorString);
fprintf ( fpLOGFile, "%s(0) : error PDL0000: %s", _pszPDLFileName, szErrorString );
}
void CPDLParser::GenerateHeaderFile ( void )
{
CTokenListWalker ThisFileList ( pRuntimeList, _pszPDLFileName );
Token *pImportToken;
Token *pInterfaceToken;
Token *pClassToken;
Token *pEnumToken;
Token *pStructToken;
char *pStr;
CString szCoClassName;
char szName [ MAX_LINE_LEN+1 ];
CString szInterfaceName;
strcpy ( szName, _pszPDLFileName );
pStr = strstr ( szName, "." );
if ( pStr )
*pStr = '\0';
_strlwr ( szName );
fprintf ( fpHeaderFile, "#ifndef __%s_h__\n", szName );
fprintf ( fpHeaderFile, "#define __%s_h__\n\n", szName );
fprintf ( fpHeaderFile, "/* Forward Declarations */\n" );
fprintf ( fpHeaderFile, "\nstruct ENUMDESC;\n" );
// For each import, generate a .h include
while ( pImportToken = ThisFileList.GetNext ( TYPE_IMPORT ) )
{
fprintf ( fpHeaderFile, "\n/* header files for imported files */\n" );
GenerateIncludeStatement ( pImportToken );
}
ThisFileList.Reset();
// Forward define all the interfaces so we can have defined them in any order
while ( pInterfaceToken = ThisFileList.GetNext ( TYPE_INTERFACE ) )
{
szInterfaceName = pInterfaceToken -> GetTagValue ( INTERFACE_NAME );
if ( szInterfaceName != "IDispatch" &&
szInterfaceName != "IUnknown" )
{
fprintf ( fpHeaderFile, "\n#ifndef __%s_FWD_DEFINED__\n",
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ) );
fprintf ( fpHeaderFile, "#define __%s_FWD_DEFINED__\n",
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ) );
fprintf ( fpHeaderFile, "typedef interface %s %s;\n",
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ),
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ) ) ;
fprintf ( fpHeaderFile, "#endif /* __%s_FWD_DEFINED__ */\n",
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ) );
}
}
//
// Generate all the enums
//
ThisFileList.Reset();
while ( pEnumToken = ThisFileList.GetNext ( TYPE_ENUM ) )
{
GenerateIncludeEnum(pEnumToken, TRUE);
}
//
// Generate all the structs
//
ThisFileList.Reset();
while (pStructToken = ThisFileList.GetNext(TYPE_STRUCT))
{
GenerateStruct(pStructToken, fpHeaderFile);
}
ThisFileList.Reset();
// For each interface generate an extern for the GUID &
// an interface decl
while ( pInterfaceToken = ThisFileList.GetNext ( TYPE_INTERFACE ) )
{
szInterfaceName = pInterfaceToken -> GetTagValue ( INTERFACE_NAME );
if ( szInterfaceName != "IDispatch" &&
szInterfaceName != "IUnknown" &&
!pInterfaceToken -> IsSet ( INTERFACE_ABSTRACT ) &&
pInterfaceToken -> IsSet ( INTERFACE_GUID ) )
{
GenerateIncludeInterface ( pInterfaceToken );
}
}
ThisFileList.Reset();
// For each class with a GUID, generate a GUID ref
while ( pClassToken = ThisFileList.GetNext ( TYPE_CLASS ) )
{
if ( pClassToken -> IsSet ( CLASS_GUID ) &&
!pClassToken -> IsSet ( CLASS_ABSTRACT ) )
{
pClassToken -> GetTagValueOrDefault ( szCoClassName,
CLASS_COCLASSNAME, pClassToken -> GetTagValue ( CLASS_NAME ) );
fprintf ( fpHeaderFile, "\n\nEXTERN_C const GUID GUID_%s;\n\n",
pClassToken -> GetTagValue ( CLASS_COCLASSNAME ) );
if ( HasMondoDispInterface ( pClassToken ) )
{
CString szDispName;
// Map to mondo dispinterface as default dispatch interface.
szDispName = (pClassToken->IsSet(CLASS_COCLASSNAME)) ?
pClassToken->GetTagValue (CLASS_COCLASSNAME) :
pClassToken->GetTagValue(CLASS_NAME);
fprintf(fpHeaderFile, "\n\nEXTERN_C const GUID DIID_Disp%s;\n\n",
(LPCSTR)szDispName);
}
}
// Also generate extern definitions for all propdescs in this file
GeneratePropdescExtern ( pClassToken, FALSE /* Don't recurse */ );
}
fprintf ( fpHeaderFile, "\n\n#endif /*__%s_h__*/\n\n", szName );
}
void CPDLParser::GenerateIncludeStatement ( Token *pImportToken )
{
char szText [ MAX_LINE_LEN+1 ];
char *pStr;
strcpy ( szText, pImportToken -> GetTagValue ( IMPORT_NAME ) );
if ( pStr = strstr ( szText, "." ) )
{
strcpy ( pStr, ".h" );
}
else
{
strcat ( szText, ".h" );
}
fprintf ( fpHeaderFile, "#include \"%s\"\n", szText );
}
void CPDLParser::GenerateIncludeInterface ( Token *pInterfaceToken )
{
// Only generate the C++ Form
Token *pChildToken;
Token *pArgToken;
CString szArg;
CString szProp;
BOOL fFirst;
CString szSuper;
if ( pInterfaceToken -> GetType() == TYPE_EVENT )
return;
fprintf ( fpHeaderFile, "\n#ifndef __%s_INTERFACE_DEFINED__\n",
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ) );
fprintf ( fpHeaderFile, "\n#define __%s_INTERFACE_DEFINED__\n",
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ) );
fprintf ( fpHeaderFile, "\nEXTERN_C const IID IID_%s;\n\n",
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ) );
if (pInterfaceToken->IsSet(INTERFACE_CUSTOM) ||
!PrimaryTearoff(pInterfaceToken) ||
!_stricmp((LPCSTR)pInterfaceToken->GetTagValue(INTERFACE_NAME), "IHTMLDocument2"))
{
szSuper = pInterfaceToken->GetTagValue(INTERFACE_SUPER);
}
fprintf(fpHeaderFile, "\nMIDL_INTERFACE(\"%s\")\n%s : public %s\n{\npublic:\n",
pInterfaceToken->GetTagValue(INTERFACE_GUID),
pInterfaceToken->GetTagValue(INTERFACE_NAME),
((LPCSTR)szSuper && *(LPCSTR)szSuper) ? (LPCSTR)szSuper : "IDispatch");
CTokenListWalker ChildWalker ( pInterfaceToken );
while ( pChildToken = ChildWalker.GetNext() )
{
if ( pChildToken -> GetType() == TYPE_METHOD )
{
fprintf ( fpHeaderFile, " virtual %s STDMETHODCALLTYPE %s(\n ",
pChildToken -> GetTagValue ( METHOD_RETURNTYPE ),
pChildToken->IsSet(METHOD_SZINTERFACEEXPOSE) ?
pChildToken->GetTagValue(METHOD_SZINTERFACEEXPOSE) :
pChildToken->GetTagValue(METHOD_NAME));
fFirst = TRUE;
CTokenListWalker ArgListWalker ( pChildToken );
while ( pArgToken = ArgListWalker.GetNext() )
{
if ( !fFirst )
fprintf ( fpHeaderFile, "," );
szArg = "";
pArgToken -> AddParam ( szArg, METHODARG_IN, "in" );
pArgToken -> AddParam ( szArg, METHODARG_OUT, "out" );
fprintf ( fpHeaderFile, "/* [%s] */ %s %s", (LPCSTR)szArg,
// Fixing a bug in the old code
// Should realy get the atype - allow the type if atype not set
ConvertType(pArgToken -> IsSet ( METHODARG_ATYPE ) ?
pArgToken -> GetTagValue ( METHODARG_ATYPE ) :
pArgToken -> GetTagValue ( METHODARG_TYPE )),
pArgToken -> GetTagValue ( METHODARG_ARGNAME ) );
fFirst = FALSE;
}
fprintf ( fpHeaderFile, ") = 0;\n\n" );
}
else
{
// Property
ComputePropType(pChildToken, szProp, TRUE);
if ( pChildToken -> IsSet ( PROPERTY_SET ))
{
fprintf ( fpHeaderFile, " virtual HRESULT STDMETHODCALLTYPE put_%s(\n %s /* [in] */ %s v) = 0;\n\n",
pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pChildToken->GetTagValue(PROPERTY_NAME),
(LPCSTR)szProp,
pChildToken -> GetTagValue ( PROPERTY_ATYPE));
}
if ( pChildToken -> IsSet ( PROPERTY_GET ))
{
fprintf ( fpHeaderFile,
" virtual HRESULT STDMETHODCALLTYPE get_%s(\n %s /* [out] */ %s * p) = 0;\n\n",
pChildToken->IsSet(PROPERTY_SZINTERFACEEXPOSE) ?
(LPSTR)pChildToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE) :
(LPSTR)pChildToken->GetTagValue(PROPERTY_NAME),
(LPCSTR)szProp,
pChildToken -> GetTagValue ( PROPERTY_ATYPE) );
}
}
}
fprintf ( fpHeaderFile, "};\n\n" );
fprintf ( fpHeaderFile, "#endif /* __%s_INTERFACE_DEFINED__ */\n\n",
pInterfaceToken -> GetTagValue ( INTERFACE_NAME ) );
}
void CPDLParser::GenerateIncludeEnum(
Token *pEnumToken, BOOL fSpitExtern, FILE *pFile)
{
Token *pEvalToken;
if (!pFile)
{
pFile = fpHeaderFile;
}
fprintf(pFile, "typedef enum _%s\n{\n" ,
pEnumToken -> GetTagValue ( ENUM_NAME ) );
CTokenListWalker EvalChildList ( pEnumToken );
while ( pEvalToken = EvalChildList.GetNext() )
{
fprintf(pFile, " %s%s = %s,\n",
pEnumToken -> GetTagValue(ENUM_PREFIX),
pEvalToken -> GetTagValue(EVAL_NAME),
pEvalToken -> GetTagValue(EVAL_VALUE));
}
// Add an _Max for the MAC build - apparently the mac needs
// this to indicate that it's an integer
fprintf(pFile, " %s_Max = 2147483647L\n",
pEnumToken -> GetTagValue ( ENUM_NAME ) );
fprintf(pFile, "} %s;\n\n",
pEnumToken -> GetTagValue ( ENUM_NAME ) );
if (fSpitExtern)
{
// Generate an EXTERN from the enum descriptor so other hdls only have to include
// the .h file.
fprintf(pFile, "\nEXTERN_C const ENUMDESC s_enumdesc%s;\n\n",
pEnumToken->GetTagValue ( ENUM_NAME ) );
}
}
void
CPDLParser::GenerateStruct(Token *pStructToken, FILE *pFile)
{
Token *pMemberToken;
fprintf(pFile, "typedef struct _%s\n{\n" ,
pStructToken->GetTagValue(STRUCT_NAME));
CTokenListWalker ChildList(pStructToken);
while (pMemberToken = ChildList.GetNext())
{
fprintf(pFile, " %s %s;\n",
pMemberToken->GetTagValue(STRUCTMEMBER_TYPE),
pMemberToken->GetTagValue(STRUCTMEMBER_NAME));
}
fprintf(pFile, "} %s;\n\n",
pStructToken->GetTagValue(STRUCT_NAME));
}
BOOL CPDLParser::AddType ( LPCSTR szTypeName, LPCSTR szHandler )
{
Token *pTypeToken = pDynamicTypeList->AddNewToken ( (DESCRIPTOR_TYPE)TYPE_DATATYPE );
if ( pTypeToken == NULL )
return FALSE;
if ( !pTypeToken->AddTag ( DATATYPE_NAME, szTypeName ) )
return FALSE;
return pTypeToken->AddTag ( DATATYPE_HANDLER, szHandler );
}
BOOL CPDLParser::AddEventType ( LPCSTR szTypeName, LPCSTR szVTSType )
{
Token *pTypeToken = pDynamicEventTypeList->AddNewToken ( (DESCRIPTOR_TYPE)TYPE_DATATYPE );
if ( pTypeToken == NULL )
return FALSE;
if ( !pTypeToken->AddTag ( DATATYPE_NAME, szTypeName ) )
return FALSE;
return pTypeToken->AddTag ( DATATYPE_HANDLER, szVTSType );
}
BOOL CPDLParser::LookupType ( LPCSTR szTypeName, CString &szIntoString,
CString &szFnPrefix, StorageType *pStorageType /* = NULL */ )
{
Token *pTypeToken;
UINT uIndex;
// Look in the static array first
if ( ( uIndex = szIntoString.Lookup ( DataTypes, szTypeName ) ) != (UINT)-1 )
{
if ( pStorageType )
{
*pStorageType = DataTypes [ uIndex ].stStorageType;
szFnPrefix = DataTypes [ uIndex ].szMethodFnPrefix;
}
return TRUE;
}
// Look finaly in the dynamic array
CTokenListWalker TypeList ( pDynamicTypeList );
if ( pTypeToken = TypeList.GetNext ( (DESCRIPTOR_TYPE)TYPE_DATATYPE, szTypeName ) )
{
szIntoString = pTypeToken->GetTagValue ( DATATYPE_HANDLER );
if ( pStorageType )
{
// In the dynamic array are either enums iface ptrs or class ptrs
// All can be stored in a DWORD, so ...
*pStorageType = STORAGETYPE_NUMBER;
}
return TRUE;
}
else
{
return FALSE;
}
}
BOOL CPDLParser::LookupEventType ( CString &szIntoString, LPCSTR szTypeName )
{
Token *pTypeToken;
// Look in the static array first
if ( szIntoString.Lookup ( vt, szTypeName ) != (UINT)-1 )
{
return TRUE;
}
// Look finaly in the dynamic array
CTokenListWalker TypeList ( pDynamicEventTypeList );
if ( pTypeToken = TypeList.GetNext ( (DESCRIPTOR_TYPE)TYPE_DATATYPE, szTypeName ) )
{
szIntoString = pTypeToken->GetTagValue ( DATATYPE_HANDLER );
return TRUE;
}
else
{
return FALSE;
}
}
UINT uProps [] =
{
PROPERTY_MEMBER,
PROPERTY_ABSTRACT,
PROPERTY_GETSETMETHODS,
PROPERTY_CAA,
PROPERTY_SUBOBJECT
};
// Legal combinations of properties
static struct
{
UINT uID1;
UINT uID2;
UINT uID3;
UINT uMask;
} PropertyCheck [] =
{
{ PROPERTY_MEMBER, (UINT)-1,(UINT)-1 },
{ PROPERTY_SUBOBJECT, (UINT)-1 ,(UINT)-1 },
{ PROPERTY_SUBOBJECT, PROPERTY_MEMBER,(UINT)-1 },
{ PROPERTY_GETSETMETHODS, (UINT)-1,(UINT)-1 },
{ PROPERTY_ABSTRACT, (UINT)-1,(UINT)-1},
{ PROPERTY_CAA, (UINT)-1,(UINT)-1 },
{ PROPERTY_SUBOBJECT, PROPERTY_CAA,(UINT)-1 },
};
void CPDLParser::Init ( void )
{
UINT i,j;
for ( i = 0 ; i < ARRAY_SIZE ( PropertyCheck ) ; i++ )
{
PropertyCheck [ i ].uMask = 0;
for ( j = 0 ; j < ARRAY_SIZE ( uProps ) ; j++ )
{
if ( PropertyCheck [ i ].uID1 == uProps [ j ] )
{
PropertyCheck [ i ].uMask |= 1<<j;
}
else if ( PropertyCheck [ i ].uID2 == uProps [ j ] )
{
PropertyCheck [ i ].uMask |= 1<<j;
}
else if ( PropertyCheck [ i ].uID3 == uProps [ j ] )
{
PropertyCheck [ i ].uMask |= 1<<j;
}
}
}
}
BOOL CPDLParser::PatchPropertyTypes ( void )
{
// For each property declaration, set the object flag if the
// Handler for the type is object
CTokenListWalker WholeList ( pRuntimeList );
Token *pToken;
Token *pChildToken;
CString szHandler;
CString szFnPrefix;
CString szAType;
CString szName;
BOOL fMatched;
char szErrorText [ MAX_LINE_LEN+1 ];
UINT i;
UINT uMask;
while ( pToken = WholeList.GetNext() )
{
if ( pToken -> GetType() == TYPE_EVENT ||
pToken -> GetType() == TYPE_CLASS ||
pToken -> GetType() == TYPE_INTERFACE )
{
if ( pToken -> GetType() == TYPE_CLASS )
{
// Has it got a super, if so is it referenced
if ( pToken -> IsSet ( CLASS_SUPER ) )
{
CTokenListWalker AllList ( pRuntimeList );
if ( !AllList.GetNext ( TYPE_CLASS, pToken -> GetTagValue ( CLASS_SUPER ) ) )
{
sprintf ( szErrorText, "Class %s References unknown super:%s\n",
(LPCSTR)pToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pToken->GetTagValue ( CLASS_SUPER ) );
ReportError ( szErrorText );
return FALSE;
}
}
if ( pToken -> IsSet ( CLASS_INTERFACE ) )
{
CTokenListWalker AllList ( pRuntimeList );
if ( !AllList.GetNext ( TYPE_INTERFACE, pToken -> GetTagValue ( CLASS_INTERFACE ) ) )
{
sprintf ( szErrorText, "Class %s References unknown interface:%s\n",
(LPCSTR)pToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pToken->GetTagValue ( CLASS_INTERFACE ) );
ReportError ( szErrorText );
return FALSE;
}
}
if ( pToken -> IsSet ( CLASS_EVENTS ) )
{
CTokenListWalker AllList ( pRuntimeList );
if ( !AllList.GetNext ( TYPE_EVENT, pToken -> GetTagValue ( CLASS_EVENTS ) ) )
{
sprintf ( szErrorText, "Class %s References unknown events:%s\n",
(LPCSTR)pToken->GetTagValue ( CLASS_NAME ),
(LPCSTR)pToken->GetTagValue ( CLASS_EVENTS ) );
ReportError ( szErrorText );
return FALSE;
}
}
// If you have an event set , you must have a coclass
if ( pToken -> IsSet ( CLASS_EVENTS ) && !pToken -> IsSet ( CLASS_ABSTRACT ) &&
!pToken -> IsSet ( CLASS_GUID ) )
{
sprintf ( szErrorText, "Non abstract class %s has an event set but no GUID\n",
(LPCSTR)pToken->GetTagValue ( CLASS_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
}
else if ( pToken -> GetType() == TYPE_INTERFACE )
{
if ( pToken -> IsSet ( INTERFACE_SUPER ) )
{
CTokenListWalker AllList ( pRuntimeList );
if ( !AllList.GetNext ( TYPE_INTERFACE, pToken -> GetTagValue ( INTERFACE_SUPER ) ) )
{
sprintf ( szErrorText, "Interface %s References unknown super:%s\n",
(LPCSTR)pToken->GetTagValue ( INTERFACE_NAME ),
(LPCSTR)pToken->GetTagValue ( INTERFACE_SUPER ) );
ReportError ( szErrorText );
return FALSE;
}
}
}
else if ( pToken -> GetType() == TYPE_EVENT )
{
if ( pToken -> IsSet ( EVENT_SUPER ) )
{
CTokenListWalker AllList ( pRuntimeList );
if ( !AllList.GetNext ( TYPE_EVENT, pToken -> GetTagValue ( EVENT_SUPER ) ) )
{
sprintf ( szErrorText, "Events %s References unknown super:%s\n",
(LPCSTR)pToken->GetTagValue ( EVENT_NAME ),
(LPCSTR)pToken->GetTagValue ( EVENT_SUPER ) );
ReportError ( szErrorText );
return FALSE;
}
}
}
CTokenListWalker ChildList ( pToken );
while ( pChildToken = ChildList.GetNext() )
{
if ( pChildToken -> GetType() == TYPE_PROPERTY )
{
// If the Type field is not set, which it won't be for many
// abstract properties, set it to the ATYPE. We still
// need the type to determine if the property is an object value
// property
if ( !pChildToken -> IsSet ( PROPERTY_TYPE ) )
{
pChildToken -> AddTag ( PROPERTY_TYPE,
pChildToken -> GetTagValue ( PROPERTY_ATYPE ) );
}
if ( !LookupType ( pChildToken -> GetTagValue ( PROPERTY_TYPE ),
szHandler, szFnPrefix ) )
{
// Seeing as we don't use the handler for abstract types, we
// allow the lookup to fail
if ( !pChildToken -> IsSet ( PROPERTY_ABSTRACT ) )
{
sprintf ( szErrorText, "Invalid Type:%s in %s Property:%s\n",
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_TYPE ),
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
}
// Currently we insist that you automate enums as BSTR's
szAType = pChildToken->GetTagValue ( PROPERTY_ATYPE );
if ( szHandler == "Enum" && szAType != "BSTR" )
{
sprintf ( szErrorText, "You must set atype:BSTR for an enum property %s : Property:%s\n",
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
if ( szHandler == "Color" && szAType != "VARIANT" )
{
sprintf ( szErrorText, "You must set atype:VARIANT for an type:CColorValue property %s : Property:%s\n",
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
if ( szHandler == "object" &&
!pChildToken -> IsSet ( PROPERTY_OBJECT ) )
{
pChildToken -> Set ( PROPERTY_OBJECT );
}
// Object valued properties must always be abstract because we don't have
// the notion of an "ObjectHandler"
if ( pChildToken -> IsSet ( PROPERTY_OBJECT ) &&
!pChildToken -> IsSet ( PROPERTY_ABSTRACT ) )
{
sprintf ( szErrorText, "Object Type Property %s:%s MUST be abstract\n",
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
for ( i = 0, uMask = 0 ; i < ARRAY_SIZE ( uProps ) ; i++ )
{
if ( pChildToken -> IsSet ( uProps [ i ] ) )
{
uMask |= 1<<i;
}
}
for ( i = 0, fMatched = FALSE;
i < ARRAY_SIZE ( PropertyCheck ); i++ )
{
if ( PropertyCheck [ i ].uMask == uMask )
{
fMatched = TRUE;
}
}
if ( !fMatched )
{
sprintf ( szErrorText, "Invalid combination of member/method/abstract/caa on %s:%s\n",
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
// Subobject MUST have a GET and MUST NOT have a SET
if ( pChildToken -> IsSet ( PROPERTY_SUBOBJECT ) &&
( !pChildToken -> IsSet ( PROPERTY_GET ) || pChildToken -> IsSet ( PROPERTY_SET ) ) )
{
sprintf ( szErrorText, "Invalid combination of subobject/get/set on %s:%s\n",
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
// DISPLAYBIND Always implies BINDABLE - so always set it
if ( pChildToken -> IsSet ( PROPERTY_DISPLAYBIND ) &&
!pChildToken -> IsSet ( PROPERTY_BINDABLE ) )
{
pChildToken -> Set ( PROPERTY_BINDABLE );
}
// For now we limit the enum: type to atypre:VARIANT,
if ( pChildToken -> IsSet ( PROPERTY_ENUMREF ) )
{
if ( szAType != "VARIANT" )
{
sprintf ( szErrorText, "Invalid combination of atype/enum on %s:%s\n",
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
}
// Set an internal flag if the property cascades - saves looking this up later
if ( pChildToken -> IsSet ( PROPERTY_CAA ) )
{
const CCachedAttrArrayInfo *pCCAAI = GetCachedAttrArrayInfo( (LPCSTR)pChildToken -> GetTagValue ( PROPERTY_DISPID ) );
if ( pCCAAI->szDispId != NULL )
{
pChildToken -> Set ( PROPERTY_CASCADED );
}
}
if ( !pChildToken -> IsSet ( PROPERTY_DISPID ) )
{
sprintf ( szErrorText, "Missing compulsory attribute 'dispid' on %s:%s\n",
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( PROPERTY_NAME ) );
ReportError ( szErrorText );
}
// SETATDESIGNTIME augments regular set
if ( pChildToken -> IsSet ( PROPERTY_SETDESIGNMODE ) )
{
pChildToken -> Set ( PROPERTY_SET );
}
}
else if ( pChildToken -> GetType() == TYPE_METHOD )
{
Token *pArgToken;
// For each method arg check
// that type is VARIANT if a optional tag is specified
CTokenListWalker ArgListWalker ( pChildToken );
while ( pArgToken = ArgListWalker.GetNext() )
{
szAType = pArgToken->GetTagValue ( METHODARG_TYPE );
if ( pArgToken->IsSet ( METHODARG_OPTIONAL ) &&
!(szAType == "VARIANT" || szAType == "VARIANT*") )
{
// MIDL will let this through but you'd never be able to
// set the default
sprintf ( szErrorText, "Method arg type must be VARIANT with optional: tag on %s:%s\n",
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( METHOD_NAME ) );
ReportError ( szErrorText );
return FALSE;
}
if ( LookupType ( pArgToken -> GetTagValue ( METHODARG_TYPE ),
szHandler, szFnPrefix ) )
{
if (szHandler == "Enum" &&
!(pToken->GetType() == TYPE_INTERFACE &&
pToken->IsSet(INTERFACE_CUSTOM)))
{
sprintf ( szErrorText, "You must set type:BSTR for an enum %s Method:%s arg:%s\n",
(LPCSTR)pToken->GetTagValue ( NAME_TAG ),
(LPCSTR)pChildToken->GetTagValue ( METHOD_NAME ),
(LPCSTR)pArgToken->GetTagValue ( METHODARG_ARGNAME ) );
ReportError ( szErrorText );
return FALSE;
}
}
}
}
}
}
}
return TRUE;
}
//
// Patch up all interfaces which are not a primary default interfaces tearoff
// and mark as such (NOPRIMARY). Classes marked as NOPRIMARY will be derived
// from the inheritance chain instead of being derived from IDispatch.
//
BOOL
CPDLParser::PatchInterfaces ()
{
CTokenListWalker ThisFilesList(pRuntimeList, _pszPDLFileName);
Token *pClassToken;
Token *pInterf;
while (pClassToken = ThisFilesList.GetNext(TYPE_CLASS))
{
CString szInterface;
szInterface = pClassToken->GetTagValue(CLASS_INTERFACE);
if (!FindTearoff(pClassToken->GetTagValue(CLASS_NAME),
(LPCSTR)szInterface))
{
CString szInterfSuper;
pInterf = FindInterface(szInterface);
while (pInterf)
{
pInterf->Set(INTERFACE_NOPRIMARYTEAROFF);
szInterfSuper = pInterf->GetTagValue(INTERFACE_SUPER);
pInterf = FindInterface(szInterfSuper);
}
}
}
return TRUE;
}
const CCachedAttrArrayInfo*
CPDLParser::GetCachedAttrArrayInfo( LPCSTR szDispId )
{
CCachedAttrArrayInfo *pCCAAI = rgCachedAttrArrayInfo;
while (pCCAAI->szDispId)
{
if (0==strcmp(szDispId, pCCAAI->szDispId))
return pCCAAI;
++pCCAAI;
}
//This is means it is not applied to a XF structure
return pCCAAI;
}
BOOL CPDLParser::GenerateHTMFile ()
{
Token *pToken;
CTokenListWalker WholeList ( pRuntimeList );
CTokenListWalker ThisFilesList ( pRuntimeList, _pszPDLFileName );
fprintf ( fpHTMFile, "<HTML>\n" );
fprintf ( fpHTMFile, "<HEAD>\n" );
fprintf ( fpHTMFile, "<TITLE>Interface Documentation from %s</TITLE>\n", _pszPDLFileName );
fprintf ( fpHTMFile, "</HEAD>\n" );
fprintf ( fpHTMFile, "<BODY>\n" );
fprintf ( fpHTMFile, "<P>\n" );
while ( pToken = ThisFilesList.GetNext ( TYPE_ENUM ) )
{
if ( !pToken -> IsSet ( ENUM_HIDDEN ))
{
fprintf ( fpHTMFile, "<B><U>Enumerations:</U></B> %s\n",
pToken->GetTagValue ( ENUM_NAME ) );
fprintf ( fpHTMFile, "<P>\n" );
fprintf ( fpHTMFile, "<TABLE WIDTH=70%%>\n" );
fprintf ( fpHTMFile, "<TR>\n" );
fprintf ( fpHTMFile, "<TH WIDTH=50%% ALIGN=\"Left\">Name</TH>\n" );
fprintf ( fpHTMFile, "<TH WIDTH=25%% ALIGN=\"Center\">String</TH>\n" );
fprintf ( fpHTMFile, "</TR>\n" );
GenerateEnumHTM ( pToken,
pToken -> IsSet ( ENUM_PREFIX ) ?
pToken->GetTagValue ( ENUM_PREFIX ) :
pToken->GetTagValue ( ENUM_NAME ) ); // sort enums
fprintf ( fpHTMFile, "</TABLE>\n" );
fprintf ( fpHTMFile, "<P>\n" );
}
}
// Output interface documentation
ThisFilesList.Reset();
while ( (pToken = ThisFilesList.GetNext ( TYPE_INTERFACE )) )
{
if (_stricmp("IUnknown", pToken->GetTagValue ( INTERFACE_NAME )) &&
_stricmp("IDispatch", pToken->GetTagValue ( INTERFACE_NAME )) )
{
char achFilePrefix[100];
strcpy (achFilePrefix, _pszPDLFileName);
char *pDot = strchr(achFilePrefix, '.');
if (pDot) {
*pDot = '\0';
}
else {
strcpy(achFilePrefix, "badpdl");
}
fprintf ( fpHTMIndexFile, "<A NAME=\"Index_Interface_%s\">Interface: <A HREF=\"%s.htm#Interface_%s\">%s</A><BR>\n",
pToken->GetTagValue ( INTERFACE_NAME ),
achFilePrefix, pToken->GetTagValue ( INTERFACE_NAME ),
pToken->GetTagValue ( INTERFACE_NAME ));
fprintf ( fpHTMFile, "<P>\n" );
fprintf ( fpHTMFile, "<A NAME=\"Interface_%s\">\n", pToken->GetTagValue ( INTERFACE_NAME ) );
fprintf ( fpHTMFile, "<TABLE>\n" );
fprintf ( fpHTMFile, "<TR><TD><H1>Interface</H1></TD>"
"<TR><TD><B>%s</B></TD><TD> GUID: </TD><TD>%s</TD></TR>"
"<TR><TD>inherits from interface</TD></TR>"
"<TR><TD><B><A HREF=\"AllIndex.htm#Index_Interface_%s\">%s</A></B></TD></TR>\n"
"</TABLE>\n",
pToken->GetTagValue ( INTERFACE_NAME ),
pToken->GetTagValue ( INTERFACE_GUID ),
pToken->GetTagValue ( INTERFACE_SUPER ),
pToken->GetTagValue ( INTERFACE_SUPER ) );
fprintf ( fpHTMFile, "<P>\n" );
fprintf ( fpHTMFile, "<HR>\n" );
fprintf ( fpHTMFile, "<H2>Properties</H2>\n" );
fprintf ( fpHTMFile, "<TABLE>\n" );
fprintf ( fpHTMFile, "<TR>" );
fprintf ( fpHTMFile, "<TH>Name</TH>" );
fprintf ( fpHTMFile, "<TH>AType</TH>" );
fprintf ( fpHTMFile, "<TH>DISPID</TH>" );
fprintf ( fpHTMFile, "<TH>G</TH>" );
fprintf ( fpHTMFile, "<TH>S</TH>" );
fprintf ( fpHTMFile, "<TH>DT</TH>" );
fprintf ( fpHTMFile, "<TH>Default</TH>" );
fprintf ( fpHTMFile, "<TH>Min</TH>" );
fprintf ( fpHTMFile, "<TH>Max</TH>" );
fprintf ( fpHTMFile, "</TR>\n" );
GenerateInterfacePropertiesHTM ( pToken ); // sort attributes
fprintf ( fpHTMFile, "</TABLE>" );
fprintf ( fpHTMFile, "<H2>Methods</H2>\n" );
fprintf ( fpHTMFile, "<TABLE BORDER=1>\n" );
fprintf ( fpHTMFile, "<TR>" );
fprintf ( fpHTMFile, "<TH>Ret. Name</TH>" );
fprintf ( fpHTMFile, "<TH>Name</TH>" );
fprintf ( fpHTMFile, "<TH>Param Dir</TH>" );
fprintf ( fpHTMFile, "<TH>Param Type</TH>" );
fprintf ( fpHTMFile, "<TH>Param Name</TH>" );
fprintf ( fpHTMFile, "<TH>Default Value</TH>" );
fprintf ( fpHTMFile, "<TH>Optional</TH>" );
fprintf ( fpHTMFile, "<TH>Ret. Type</TH>" );
fprintf ( fpHTMFile, "</TR>\n" );
GenerateInterfaceMethodHTM ( pToken ); // sort attributes
fprintf ( fpHTMFile, "</TABLE>" );
}
}
// Output eventset documentation
ThisFilesList.Reset();
while ( (pToken = ThisFilesList.GetNext ( TYPE_EVENT )) )
{
if (_stricmp("IDispatch", pToken->GetTagValue ( INTERFACE_NAME )) )
{
char achFilePrefix[100];
strcpy (achFilePrefix, _pszPDLFileName);
char *pDot = strchr(achFilePrefix, '.');
if (pDot) {
*pDot = '\0';
}
else {
strcpy(achFilePrefix, "badpdl");
}
fprintf ( fpHTMIndexFile, "<A NAME=\"Index_Eventset_%s\">Eventset: <A HREF=\"%s.htm#Eventset_%s\">%s</A><BR>\n",
pToken->GetTagValue ( EVENT_NAME ),
achFilePrefix, pToken->GetTagValue ( EVENT_NAME ),
pToken->GetTagValue ( EVENT_NAME ));
fprintf ( fpHTMFile, "<BR><BR>\n" );
fprintf ( fpHTMFile, "<A NAME=\"Eventset_%s\">\n", pToken->GetTagValue ( EVENT_NAME ) );
fprintf ( fpHTMFile, "<TABLE>\n" );
fprintf ( fpHTMFile, "<TR><TD><H1>Event Set</H1></TD>"
"<TR><TD><B>%s</B></TD><TD> GUID: </TD><TD>%s</TD></TR>"
"<TR><TD>inherits from event set</TD></TR>"
"<TR><TD><B><A HREF=\"AllIndex.htm#Index_Eventset_%s\">%s</A></B></TD></TR>\n"
"</TABLE>\n",
pToken->GetTagValue ( EVENT_NAME ),
pToken->GetTagValue ( EVENT_GUID ),
pToken->GetTagValue ( EVENT_SUPER ),
pToken->GetTagValue ( EVENT_SUPER ) );
fprintf ( fpHTMFile, "<HR>\n" );
fprintf ( fpHTMFile, "<H2>Methods</H2>\n" );
fprintf ( fpHTMFile, "<TABLE BORDER=1>\n" );
fprintf ( fpHTMFile, "<TR>" );
fprintf ( fpHTMFile, "<TH>Ret. Name</TH>" );
fprintf ( fpHTMFile, "<TH>Name</TH>" );
fprintf ( fpHTMFile, "<TH>DISPID</TH>" );
fprintf ( fpHTMFile, "<TH>Cancelable</TH>" );
fprintf ( fpHTMFile, "<TH>Bubbling</TH>" );
fprintf ( fpHTMFile, "<TH>Param Dir</TH>" );
fprintf ( fpHTMFile, "<TH>Param Type</TH>" );
fprintf ( fpHTMFile, "<TH>Param Name</TH>" );
fprintf ( fpHTMFile, "<TH>Default Value</TH>" );
fprintf ( fpHTMFile, "<TH>Optional</TH>" );
fprintf ( fpHTMFile, "<TH>Ret. Type</TH>" );
fprintf ( fpHTMFile, "</TR>\n" );
GenerateEventMethodHTM ( pToken ); // sort attributes
fprintf ( fpHTMFile, "</TABLE>" );
}
}
fprintf ( fpHTMFile, "</BODY>\n");
fprintf ( fpHTMFile, "</HTML>\n");
return TRUE;
}
void CPDLParser::GenerateArg ( Token *pArgToken )
{
if ( ! pArgToken -> IsSet ( METHODARG_RETURNVALUE ) )
{
fprintf ( fpHTMFile, "&nbsp[%s] %s %s",
pArgToken -> IsSet ( METHODARG_OUT ) ? "out" : "in",
pArgToken -> GetTagValue ( METHODARG_TYPE ),
pArgToken -> GetTagValue ( METHODARG_ARGNAME ) );
if ( pArgToken -> IsSet ( METHODARG_DEFAULTVALUE ) )
{
fprintf ( fpHTMFile, "=%s",
pArgToken -> GetTagValue ( METHODARG_DEFAULTVALUE ) );
}
if ( pArgToken -> IsSet ( METHODARG_OPTIONAL ) )
{
fprintf ( fpHTMFile, " [optional]" );
}
}
}
void CPDLParser::GenerateInterfaceArg ( Token *pArgToken )
{
if ( ! pArgToken -> IsSet ( METHODARG_RETURNVALUE ) )
{
fprintf ( fpHTMFile, "<TD>%s</TD><TD>%s</TD><TD>%s</TD>",
pArgToken -> IsSet ( METHODARG_OUT ) ? "out" : "in",
pArgToken -> GetTagValue ( METHODARG_TYPE ),
pArgToken -> GetTagValue ( METHODARG_ARGNAME ) );
fprintf ( fpHTMFile, "<TD>%s</TD><TD>%s</TD>",
pArgToken -> IsSet ( METHODARG_DEFAULTVALUE ) ?
(pArgToken -> GetTagValue ( METHODARG_DEFAULTVALUE )) : "",
pArgToken -> IsSet ( METHODARG_OPTIONAL) ?
"Y" : "N" );
}
}
void CPDLParser::GenerateMethodHTM ( Token *pIntfToken )
{
CTokenListWalker *pChildList;
Token *pChildToken;
Token *pArgToken;
int cArgs;
CString szSuper;
CTokenListWalker *ptlw = NULL;
pChildList = new CTokenListWalker ( pIntfToken );
szSuper = pIntfToken->GetTagValue ( INTERFACE_SUPER );
do
{
while ( pChildToken = pChildList -> GetNext() )
{
CString szRetValArg;
CString szRetValType;
CTokenListWalker ArgListWalker ( pChildToken );
cArgs = 0;
// Loop thru all arguments.
while ( (pArgToken = ArgListWalker.GetNext()) != NULL &&
pArgToken -> GetType () == TYPE_METHOD_ARG )
{
// Looking for a return value.
if ( pArgToken -> IsSet ( METHODARG_RETURNVALUE ) )
{
// If a return value exist then get the argument name.
szRetValArg = pArgToken -> GetTagValue (
pArgToken -> IsSet ( METHODARG_ARGNAME ) ?
METHODARG_ARGNAME : METHODARG_RETURNVALUE );
szRetValType = pArgToken -> GetTagValue ( METHODARG_TYPE );
}
else
{
cArgs++;
}
}
if ( strlen ( szRetValArg ) )
{
fprintf ( fpHTMFile, "<TR><TD>%s = <I>object.</I><B>%s</B>",
(LPCSTR)szRetValArg,
pChildToken -> GetTagValue ( METHOD_NAME ) );
}
else
{
fprintf ( fpHTMFile, "<TR><TD><I>object.</I><B>%s</B>",
pChildToken -> GetTagValue ( METHOD_NAME ) );
}
int cArgIndex = 0;
ArgListWalker.Reset ( );
while ( ( pArgToken = ArgListWalker.GetNext ( ) ) != NULL &&
pArgToken -> GetType () == TYPE_METHOD_ARG )
{
if ( ! pArgToken -> IsSet ( METHODARG_RETURNVALUE ) )
{
if (cArgIndex == 0)
{
switch (cArgs)
{
case 0:
fprintf ( fpHTMFile, "<TD>( )</TD>\n" );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
break;
case 1:
fprintf ( fpHTMFile, "<TD>(" );
GenerateArg( pArgToken );
fprintf ( fpHTMFile, "&nbsp)</TD>\n" );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
break;
default:
fprintf ( fpHTMFile, "<TD>(" );
GenerateArg( pArgToken );
fprintf ( fpHTMFile, ",</TD>\n" );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
break;
}
}
else
{
if (cArgIndex > 1)
{
fprintf ( fpHTMFile, ",</TD></TR>\n" );
}
fprintf ( fpHTMFile, "<TR><TD></TD><TD>&nbsp" );
GenerateArg( pArgToken );
}
cArgIndex++;
}
}
if ( cArgIndex == 0 )
{
fprintf ( fpHTMFile, "<TD>( )</TD>\n" );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
}
else if ( cArgIndex > 1 )
{
fprintf ( fpHTMFile, ")</TD></TR>\n" );
}
fprintf ( fpHTMFile, "<TR>&nbsp</TR>" );
}
// Get inherited interface.
if ( strlen ( szSuper ) )
{
if (ptlw == NULL)
{
ptlw = new CTokenListWalker ( pRuntimeList, _pszPDLFileName );
}
else
{
ptlw->Reset();
}
TryAgain:
pIntfToken = ptlw->GetNext ( TYPE_INTERFACE, szSuper );
if (pIntfToken)
{
szSuper = pIntfToken->GetTagValue ( INTERFACE_SUPER );
delete pChildList;
pChildList = new CTokenListWalker ( pIntfToken );
}
else
{
if ( !ptlw->IsGenericWalker ( ) )
{
delete ptlw;
ptlw = new CTokenListWalker ( pRuntimeList );
goto TryAgain;
}
}
}
else
{
break;
}
} while (pIntfToken);
delete pChildList;
delete ptlw;
}
void CPDLParser::GenerateInterfaceMethodHTM ( Token *pIntfToken )
{
CTokenListWalker *pChildList;
Token *pChildToken;
Token *pArgToken;
int cArgs;
CString szSuper;
pChildList = new CTokenListWalker ( pIntfToken );
szSuper = pIntfToken->GetTagValue ( INTERFACE_SUPER );
while ( pChildToken = pChildList -> GetNext() )
{
CString szRetValArg;
CString szRetValType;
CTokenListWalker ArgListWalker ( pChildToken );
cArgs = 0;
// Loop thru all arguments.
while ( (pArgToken = ArgListWalker.GetNext()) != NULL &&
pArgToken -> GetType () == TYPE_METHOD_ARG )
{
// Looking for a return value.
if ( pArgToken -> IsSet ( METHODARG_RETURNVALUE ) )
{
// If a return value exist then get the argument name.
szRetValArg = pArgToken -> GetTagValue (
pArgToken -> IsSet ( METHODARG_ARGNAME ) ?
METHODARG_ARGNAME : METHODARG_RETURNVALUE );
szRetValType = pArgToken -> GetTagValue ( METHODARG_TYPE );
}
else
{
cArgs++;
}
}
if ( strlen ( szRetValArg ) )
{
fprintf ( fpHTMFile, "<TR><TD>%s</TD><TD><I>object.</I><B>%s</B></TD>",
(LPCSTR)szRetValArg,
pChildToken -> GetTagValue ( METHOD_NAME ) );
}
else
{
fprintf ( fpHTMFile, "<TR><TD></TD><TD><I>object.</I><B>%s</B></TD>",
pChildToken -> GetTagValue ( METHOD_NAME ) );
}
int cArgIndex = 0;
ArgListWalker.Reset ( );
while ( ( pArgToken = ArgListWalker.GetNext ( ) ) != NULL &&
pArgToken -> GetType () == TYPE_METHOD_ARG )
{
if ( ! pArgToken -> IsSet ( METHODARG_RETURNVALUE ) )
{
if (cArgIndex == 0)
{
switch (cArgs)
{
case 0:
fprintf ( fpHTMFile, "<TD></TD><TD></TD><TD></TD><TD></TD><TD></TD> <!-- 1 -->" );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
break;
default:
GenerateInterfaceArg( pArgToken );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
break;
}
}
else
{
if (cArgIndex > 1)
{
fprintf ( fpHTMFile, "</TR> <!-- Hello -->\n" );
}
fprintf ( fpHTMFile, "<TR><TD></TD><TD></TD>" );
GenerateInterfaceArg( pArgToken );
}
cArgIndex++;
}
}
if ( cArgIndex == 0 )
{
fprintf ( fpHTMFile, "<TD></TD><TD></TD><TD></TD><TD></TD><TD></TD> <!-- 2 -->" );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
}
else if ( cArgIndex > 1 )
{
fprintf ( fpHTMFile, "</TR> <!-- 3 -->\n" );
}
fprintf ( fpHTMFile, "<TR></TR>" );
}
delete pChildList;
}
void CPDLParser::GenerateEventMethodHTM ( Token *pIntfToken )
{
CTokenListWalker *pChildList;
Token *pChildToken;
Token *pArgToken;
int cArgs;
CString szSuper;
pChildList = new CTokenListWalker ( pIntfToken );
szSuper = pIntfToken->GetTagValue ( INTERFACE_SUPER );
while ( pChildToken = pChildList -> GetNext() )
{
CString szRetValArg;
CString szRetValType;
CTokenListWalker ArgListWalker ( pChildToken );
cArgs = 0;
// Loop thru all arguments.
while ( (pArgToken = ArgListWalker.GetNext()) != NULL &&
pArgToken -> GetType () == TYPE_METHOD_ARG )
{
// Looking for a return value.
if ( pArgToken -> IsSet ( METHODARG_RETURNVALUE ) )
{
// If a return value exist then get the argument name.
szRetValArg = pArgToken -> GetTagValue (
pArgToken -> IsSet ( METHODARG_ARGNAME ) ?
METHODARG_ARGNAME : METHODARG_RETURNVALUE );
szRetValType = pArgToken -> GetTagValue ( METHODARG_TYPE );
}
else
{
cArgs++;
}
}
if ( strlen ( szRetValArg ) )
{
fprintf ( fpHTMFile, "<TR><TD>%s</TD><TD><I>object.</I><B>%s</B></TD>",
(LPCSTR)szRetValArg,
pChildToken -> GetTagValue ( METHOD_NAME ) );
}
else
{
fprintf ( fpHTMFile, "<TR><TD></TD><TD><I>object.</I><B>%s</B></TD>",
pChildToken -> GetTagValue ( METHOD_NAME ) );
}
fprintf ( fpHTMFile, "<TD>%s</TD><TD>%s</TD><TD>%s</TD>",
pChildToken->IsSet(METHOD_DISPID) ? pChildToken->GetTagValue ( METHOD_DISPID ) : "",
pChildToken->IsSet(METHOD_CANCELABLE) ? "Y" : "N",
pChildToken->IsSet(METHOD_BUBBLING) ? "Y" : "N" );
int cArgIndex = 0;
ArgListWalker.Reset ( );
while ( ( pArgToken = ArgListWalker.GetNext ( ) ) != NULL &&
pArgToken -> GetType () == TYPE_METHOD_ARG )
{
if ( ! pArgToken -> IsSet ( METHODARG_RETURNVALUE ) )
{
if (cArgIndex == 0)
{
switch (cArgs)
{
case 0:
fprintf ( fpHTMFile, "<TD></TD><TD></TD><TD></TD><TD></TD><TD></TD> <!-- 1 -->" );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
break;
default:
GenerateInterfaceArg( pArgToken );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
break;
}
}
else
{
if (cArgIndex > 1)
{
fprintf ( fpHTMFile, "</TR> <!-- Hello -->\n" );
}
fprintf ( fpHTMFile, "<TR><TD></TD><TD></TD><TD></TD><TD></TD><TD></TD>" );
GenerateInterfaceArg( pArgToken );
}
cArgIndex++;
}
}
if ( cArgIndex == 0 )
{
fprintf ( fpHTMFile, "<TD></TD><TD></TD><TD></TD><TD></TD><TD></TD> <!-- 2 -->" );
fprintf ( fpHTMFile, "<TD ALIGN=\"Center\">%s</TD>\n",
(LPCSTR)szRetValType );
fprintf ( fpHTMFile, "</TR>\n" );
}
else if ( cArgIndex > 1 )
{
fprintf ( fpHTMFile, "</TR> <!-- 3 -->\n" );
}
fprintf ( fpHTMFile, "<TR></TR>" );
}
delete pChildList;
}
void CPDLParser::GenerateEnumHTM ( Token *pClassToken, char *pEnumPrefix )
{
CTokenListWalker ChildList ( pClassToken );
Token *pChildToken;
CString szStringValue;
while ( pChildToken = ChildList.GetNext() )
{
if ( pChildToken -> GetType() == TYPE_EVAL )
{
fprintf ( fpHTMFile, "<TR>\n<TD>%s%s</TD><TD ALIGN=\"Center\">\"%s\"</TD>",
pEnumPrefix,
pChildToken -> GetTagValue ( EVAL_NAME ),
pChildToken -> IsSet ( EVAL_STRING ) ?
pChildToken -> GetTagValue ( EVAL_STRING ) :
pChildToken -> GetTagValue ( EVAL_NAME ) );
fprintf ( fpHTMFile, "</TR>\n");
}
}
}
void CPDLParser::GeneratePropertiesHTM ( Token *pIntfToken, BOOL fAttributes )
{
CTokenListWalker *pChildList;
Token *pChildToken;
CString szSuper;
CTokenListWalker *ptlw = NULL;
pChildList = new CTokenListWalker ( pIntfToken );
szSuper = pIntfToken->GetTagValue ( INTERFACE_SUPER );
do
{
while ( pChildToken = pChildList->GetNext() )
{
// Attributes are only properties which are not abstract and the
// ppflags is not PROPPARAM_NOTHTML.
if ( pChildToken -> GetType () == TYPE_PROPERTY &&
fAttributes == (
!pChildToken -> IsSet ( PROPERTY_ABSTRACT ) &&
pChildToken -> IsSet ( PROPERTY_NOPERSIST ) ) )
{
if (fAttributes)
{
fprintf ( fpHTMFile, "<TR><TD>%s</TD><TD>%s</TD><TD>%s</TD>",
pChildToken -> GetTagValue (
pChildToken -> IsSet ( PROPERTY_SZATTRIBUTE ) ?
PROPERTY_SZATTRIBUTE : PROPERTY_NAME ),
pChildToken -> GetTagValue ( PROPERTY_NAME ),
pChildToken -> GetTagValue ( PROPERTY_ATYPE ) );
}
else
{
fprintf ( fpHTMFile, "<TR><TD>%s</TD><TD>%s</TD>",
pChildToken -> GetTagValue ( PROPERTY_NAME ),
pChildToken -> GetTagValue ( PROPERTY_ATYPE ) );
}
fprintf ( fpHTMFile, "<TD>%s</TD>",
pChildToken -> IsSet ( PROPERTY_NOTPRESENTDEFAULT ) ?
pChildToken -> GetTagValue ( PROPERTY_NOTPRESENTDEFAULT ) :
"" );
fprintf ( fpHTMFile, "<TD>%s</TD>",
pChildToken -> IsSet ( PROPERTY_MIN ) ?
pChildToken -> GetTagValue ( PROPERTY_MIN ) :
"" );
fprintf ( fpHTMFile, "<TD>%s</TD>",
pChildToken -> IsSet ( PROPERTY_MAX ) ?
pChildToken -> GetTagValue ( PROPERTY_MAX ) :
"" );
if ( pChildToken -> IsSet ( PROPERTY_SET ) &&
pChildToken -> IsSet ( PROPERTY_GET ) )
{
fprintf ( fpHTMFile, "<TD>R/W</TD>" );
}
else if ( pChildToken -> IsSet ( PROPERTY_GET ) )
{
fprintf ( fpHTMFile, "<TD>R/O</TD>" );
}
else
{
fprintf ( fpHTMFile, "<TD>W/O</TD>" );
}
fprintf ( fpHTMFile,
pChildToken -> IsSet ( PROPERTY_SETDESIGNMODE ) ?
"<TD>R/W</TD>" : "<TD>R/O</TD>" );
fprintf ( fpHTMFile, "</TR>\n" );
}
}
// Get inherited interface.
if ( strlen ( szSuper ) )
{
if (ptlw == NULL)
{
ptlw = new CTokenListWalker ( pRuntimeList, _pszPDLFileName );
}
else
{
ptlw->Reset();
}
TryAgain:
pIntfToken = ptlw->GetNext ( TYPE_INTERFACE, szSuper );
if (pIntfToken)
{
szSuper = pIntfToken->GetTagValue ( INTERFACE_SUPER );
delete pChildList;
pChildList = new CTokenListWalker ( pIntfToken );
}
else
{
if ( !ptlw->IsGenericWalker ( ) )
{
delete ptlw;
ptlw = new CTokenListWalker ( pRuntimeList );
goto TryAgain;
}
}
}
else
{
break;
}
} while (pIntfToken);
delete pChildList;
delete ptlw;
}
#define GET_TAG_VALUE(pToken, value) (pToken->IsSet(value) ? pToken->GetTagValue(value) : "")
void CPDLParser::GenerateInterfacePropertiesHTM ( Token *pIntfToken )
{
CTokenListWalker *pChildList;
Token *pChildToken;
CString szSuper;
pChildList = new CTokenListWalker ( pIntfToken );
szSuper = pIntfToken->GetTagValue ( INTERFACE_SUPER );
while ( pChildToken = pChildList->GetNext() )
{
if ( pChildToken -> GetType () == TYPE_PROPERTY )
{
fprintf ( fpHTMFile, "<TR>" );
fprintf ( fpHTMFile, "<TD>%s</TD>", GET_TAG_VALUE(pChildToken, PROPERTY_NAME) );
fprintf ( fpHTMFile, "<TD>%s</TD>", GET_TAG_VALUE(pChildToken, PROPERTY_ATYPE) );
fprintf ( fpHTMFile, "<TD>%s</TD>", GET_TAG_VALUE(pChildToken, PROPERTY_DISPID) );
fprintf ( fpHTMFile, "<TD>%s</TD>", pChildToken->IsSet(PROPERTY_GET) ? "Y" : "N" );
fprintf ( fpHTMFile, "<TD>%s</TD>", pChildToken->IsSet(PROPERTY_SET) ? "Y" : "N" );
fprintf ( fpHTMFile, "<TD>%s</TD>", pChildToken->IsSet(PROPERTY_SETDESIGNMODE) ? "Y" : "N" );
fprintf ( fpHTMFile, "<TD>%s</TD>", pChildToken->IsSet(PROPERTY_NOTPRESENTDEFAULT) ? pChildToken->GetTagValue(PROPERTY_NOTPRESENTDEFAULT) : "" );
fprintf ( fpHTMFile, "<TD>%s</TD>", pChildToken->IsSet(PROPERTY_MIN) ? pChildToken->GetTagValue(PROPERTY_MIN) : "" );
fprintf ( fpHTMFile, "<TD>%s</TD>", pChildToken->IsSet(PROPERTY_MAX) ? pChildToken->GetTagValue(PROPERTY_MAX) : "" );
fprintf ( fpHTMFile, "</TR>\n" );
}
}
delete pChildList;
}
#undef GET_TAG_VALUE
Token* CPDLParser::FindInterface (CString szInterfaceMatch)
{
CTokenListWalker WholeTree ( pRuntimeList );
Token *pInterfaceToken;
WholeTree.Reset();
while ( pInterfaceToken = WholeTree.GetNext ( TYPE_INTERFACE ) )
{
CString szInterface;
if ( !pInterfaceToken -> IsSet ( INTERFACE_ABSTRACT ) &&
pInterfaceToken -> IsSet ( INTERFACE_GUID ) )
{
szInterface = pInterfaceToken -> GetTagValue ( INTERFACE_NAME );
if (szInterface == szInterfaceMatch)
{
return pInterfaceToken;
}
}
}
return NULL;
}
// Only interfaces defined in this file.
Token* CPDLParser::FindInterfaceLocally (CString szInterfaceMatch)
{
CTokenListWalker TokenList ( pRuntimeList, _pszPDLFileName );
Token *pInterfaceToken;
TokenList.Reset();
while ( pInterfaceToken = TokenList.GetNext ( TYPE_INTERFACE ) )
{
CString szInterface;
if ( !pInterfaceToken -> IsSet ( INTERFACE_ABSTRACT ) &&
pInterfaceToken -> IsSet ( INTERFACE_GUID ) )
{
szInterface = pInterfaceToken -> GetTagValue ( INTERFACE_NAME );
if (szInterface == szInterfaceMatch)
{
return pInterfaceToken;
}
}
}
return NULL;
}
BOOL CPDLParser::IsPrimaryInterface(CString szInterface)
{
CTokenListWalker TokenList ( pRuntimeList, _pszPDLFileName );
Token *pClassToken;
TokenList.Reset();
while ( pClassToken = TokenList.GetNext ( TYPE_CLASS ) )
{
if (!_stricmp((LPSTR)pClassToken->GetTagValue(CLASS_INTERFACE),
szInterface))
return TRUE;
}
return FALSE;
}
Token* CPDLParser::FindClass (CString szClassMatch)
{
CTokenListWalker WholeTree ( pRuntimeList );
Token *pClassToken;
WholeTree.Reset();
while ( pClassToken = WholeTree.GetNext ( TYPE_CLASS ) )
{
CString szClass;
szClass = pClassToken -> GetTagValue ( CLASS_NAME );
if (szClass == szClassMatch)
{
return pClassToken;
}
}
return NULL;
}
Token * CPDLParser::IsSuperInterface( CString szSuper, Token * pInterface )
{
Token *pInterfaceToken;
CString szInterface;
if(!pInterface)
return NULL;
szInterface = pInterface->GetTagValue(INTERFACE_NAME);
pInterfaceToken = pInterface;
while ( pInterfaceToken )
{
if (szSuper == szInterface)
return pInterfaceToken;
szInterface = pInterfaceToken->GetTagValue(INTERFACE_SUPER);
pInterfaceToken = FindInterface(szInterface);
}
return NULL;
}
Token *
CPDLParser::FindMatchingEntryWOPropDesc(Token *pClass, Token *pToFindToken, BOOL fNameMatchOnly)
{
CTokenListWalker ChildWalker(pClass);
Token *pChildToken;
CString szInterface;
Token *pInterfToken;
Token *pFuncToken = NULL;
while (pChildToken = ChildWalker.GetNext())
{
if (pChildToken->GetType() == TYPE_IMPLEMENTS)
{
szInterface = pChildToken->GetTagValue(IMPLEMENTS_NAME);
pInterfToken = FindInterface(szInterface);
if (pInterfToken)
{
pFuncToken = FindMethodInInterfaceWOPropDesc(pInterfToken, pToFindToken, fNameMatchOnly);
if (pFuncToken)
break; // Found a match...
}
}
}
return pFuncToken;
}
Token*
CPDLParser::FindMethodInInterfaceWOPropDesc(Token *pInterface, Token *pToFindToken, BOOL fNameMatchOnly)
{
CTokenListWalker ChildList(pInterface);
Token *pChildToken = NULL;
while (pChildToken = ChildList.GetNext())
{
if (pChildToken->GetType() == pToFindToken->GetType())
{
if (pChildToken->GetType() == TYPE_METHOD && !pChildToken->IsSet(METHOD_NOPROPDESC))
{
CString szMethodName;
if (pToFindToken->IsSet(METHOD_NOPROPDESC) &&
pToFindToken->IsSet(METHOD_SZINTERFACEEXPOSE))
{
szMethodName = pToFindToken->GetTagValue(METHOD_SZINTERFACEEXPOSE);
}
else
{
szMethodName = pToFindToken->GetTagValue(METHOD_NAME);
}
if (!strcmp((LPCSTR)szMethodName,
(LPCSTR)pChildToken->GetTagValue(METHOD_NAME)))
{
CString szTypesSig;
CString szArgsType;
CString szFindTypesSig;
CString szFindArgsType;
BOOL fIgnore;
int cIgnore;
// If we only need a name match then we're done.
if (fNameMatchOnly)
break;
if (!BuildMethodSignature(pChildToken,
szTypesSig,
szArgsType,
fIgnore,
fIgnore,
cIgnore,
cIgnore))
return NULL;
if (!BuildMethodSignature(pToFindToken,
szFindTypesSig,
szFindArgsType,
fIgnore,
fIgnore,
cIgnore,
cIgnore))
return NULL;
// Exact signature match then use it.
if (!strcmp(szTypesSig, szFindTypesSig) &&
!strcmp(szArgsType, szFindArgsType))
break;
}
}
else if (pChildToken->GetType() == TYPE_PROPERTY && !pChildToken->IsSet(PROPERTY_NOPROPDESC))
{
CString szPropertyName;
if (pToFindToken->IsSet(PROPERTY_NOPROPDESC) &&
pToFindToken->IsSet(PROPERTY_SZINTERFACEEXPOSE))
{
szPropertyName = pToFindToken->GetTagValue(PROPERTY_SZINTERFACEEXPOSE);
}
else
{
szPropertyName = pToFindToken->GetTagValue(PROPERTY_NAME);
}
if (!strcmp((LPCSTR)szPropertyName,
(LPCSTR)pChildToken->GetTagValue(PROPERTY_NAME)))
{
// If we only need a name match then we're done.
if (fNameMatchOnly)
break;
// If both are properties and the types are similar or an
// enum then the signature is the same we found a match.
if ((pChildToken->IsSet(PROPERTY_GETSETMETHODS) == pToFindToken->IsSet(PROPERTY_GETSETMETHODS)) &&
(pChildToken->IsSet(PROPERTY_MEMBER) == pToFindToken->IsSet(PROPERTY_MEMBER)) &&
(pChildToken->IsSet(PROPERTY_GET) == pToFindToken->IsSet(PROPERTY_GET)) &&
(pChildToken->IsSet(PROPERTY_SET) == pToFindToken->IsSet(PROPERTY_SET)))
{
if (!strcmp((LPCSTR)pChildToken->GetTagValue(PROPERTY_ATYPE),
(LPCSTR)pToFindToken->GetTagValue(PROPERTY_ATYPE)))
break;
if (FindEnum(pChildToken) && FindEnum(pToFindToken))
break;
}
}
}
}
}
return pChildToken;
}