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.
 
 
 
 
 
 

1146 lines
28 KiB

/*****************************************************************************/
/** Microsoft LAN Manager **/
/** Copyright(c) Microsoft Corp., 1987-1999 **/
/*****************************************************************************/
/*****************************************************************************
File : gramutil.cxx
Title : grammar utility routines
Description : contains associated routines for the grammar (pass 1)
History :
05-Aug-1991 VibhasC Created
*****************************************************************************/
#pragma warning ( disable : 4514 4710 )
/****************************************************************************
* include files
***************************************************************************/
#include "nulldefs.h"
extern "C" {
#include <stdio.h>
#include <ctype.h>
#include <string.h>
}
#include "lextable.hxx"
#include "allnodes.hxx"
#include "gramutil.hxx"
#include "filehndl.hxx"
#include "idict.hxx"
#include "control.hxx"
#include "cmdana.hxx"
/****************************************************************************
* external data
***************************************************************************/
extern CMD_ARG * pCommand;
extern class _nfa_info * pImportCntrl;
extern pre_type_db * pPreAllocTypes;
extern SymTable * pBaseSymTbl;
extern node_error * pErrorTypeNode;
extern short CompileMode;
extern node_e_attr * pErrorAttrNode;
extern CCONTROL * pCompiler;
extern LexTable * pMidlLexTable;
extern IINFODICT * pInterfaceInfoDict;
extern short ImportLevel;
extern node_e_status_t * pError_status_t;
extern IDICT * pInterfaceDict;
/****************************************************************************
* external functions
***************************************************************************/
extern char * GetTypeName( short );
extern STATUS_T GetBaseTypeNode( node_skl **, short, short, short);
extern ATTRLIST GenerateFieldAttribute(ATTR_T, expr_list *);
extern char * GetExpectedSyntax( char *, short );
extern int GetExpectedChar( short );
extern void CheckGlobalNamesClash( SymKey );
extern void NormalizeString( char* szSrc, char* szNrm );
/****************************************************************************
* local functions
***************************************************************************/
/****************************************************************************
* local definitions
***************************************************************************/
//
// the parse stack
//
lextype_t yyv[YYMAXDEPTH]; /* where the values are stored */
short yys[YYMAXDEPTH]; /* the parse stack */
struct pre_init
{
unsigned short TypeSpec;
NODE_T NodeType;
ATTR_T Attr; // signed or unsigned
ATTR_T Attr2; // __w64
char * pSymName;
};
struct pre_init PreInitArray[ PRE_TYPE_DB_SIZE ] =
{
{ /** float **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_UNDEF, TYPE_FLOAT, ATT_NONE )
,NODE_FLOAT
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"float"
}
,{ /** double **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_UNDEF, TYPE_DOUBLE, ATT_NONE )
,NODE_DOUBLE
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"double"
}
,{ /** __float80 **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_UNDEF, TYPE_FLOAT80, ATT_NONE )
,NODE_FLOAT80
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"__float80"
}
,{ /** __float128 **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_UNDEF, TYPE_FLOAT128, ATT_NONE )
,NODE_FLOAT128
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"__float128"
}
,{ /** signed hyper **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_HYPER, TYPE_INT, ATT_NONE )
,NODE_HYPER
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"hyper"
}
,{ /** unsigned hyper **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_HYPER, TYPE_INT, ATT_NONE )
,NODE_HYPER
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"hyper"
}
,{ /** signed int32 **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_INT32, TYPE_INT, ATT_NONE )
,NODE_INT32
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"__int32"
}
,{ /** unsigned int32 **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_INT32, TYPE_INT, ATT_NONE )
,NODE_INT32
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"__int32"
}
,{ /** signed int3264 **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_INT3264, TYPE_INT, ATT_NONE )
,NODE_INT3264
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"__int3264"
}
,{ /** unsigned int3264 **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_INT3264, TYPE_INT, ATT_NONE )
,NODE_INT3264
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"__int3264"
}
,{ /** signed int64 **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_INT64, TYPE_INT, ATT_NONE )
,NODE_INT64
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"__int64"
}
,{ /** unsigned int64 **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_INT64, TYPE_INT, ATT_NONE )
,NODE_INT64
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"__int64"
}
,{ /** signed int128 **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_INT128, TYPE_INT, ATT_NONE )
,NODE_INT128
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"__int128"
}
,{ /** unsigned int128 **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_INT128, TYPE_INT, ATT_NONE )
,NODE_INT128
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"__int128"
}
,{ /** signed long **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_LONG, TYPE_INT, ATT_NONE )
,NODE_LONG
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"long"
}
,{ /** unsigned long **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_LONG, TYPE_INT, ATT_NONE )
,NODE_LONG
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"long"
}
,{ /** signed int **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_UNDEF, TYPE_INT, ATT_NONE )
,NODE_INT
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"int"
}
,{ /** unsigned int **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_UNDEF, TYPE_INT, ATT_NONE )
,NODE_INT
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"int"
}
,{ /** __w64 signed long **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_LONG, TYPE_INT, ATT_W64 )
,NODE_LONG
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_W64
,"long"
}
,{ /** __w64 unsigned long **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_LONG, TYPE_INT, ATT_W64 )
,NODE_LONG
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_W64
,"long"
}
,{ /** __w64 signed int **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_UNDEF, TYPE_INT, ATT_W64 )
,NODE_INT
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_W64
,"int"
}
,{ /** __w64 unsigned int **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_UNDEF, TYPE_INT, ATT_W64 )
,NODE_INT
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_W64
,"int"
}
,{ /** signed short **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_SHORT, TYPE_INT, ATT_NONE )
,NODE_SHORT
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"short"
}
,{ /** unsigned short **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_SHORT, TYPE_INT, ATT_NONE )
,NODE_SHORT
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"short"
}
,{ /** signed small **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_SMALL, TYPE_INT, ATT_NONE )
,NODE_SMALL
,(ATTR_T)ATTR_SIGNED
,(ATTR_T)ATTR_NONE
,"small"
}
,{ /** small **//** NOTE : SMALL W/O SIGN IS A SPECIAL HACK FOR THE BACKEND **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_SMALL, TYPE_INT, ATT_NONE )
,NODE_SMALL
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"small"
}
,{ /** unsigned small **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_SMALL, TYPE_INT, ATT_NONE )
,NODE_SMALL
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"small"
}
,{ /** signed char **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_CHAR, TYPE_INT, ATT_NONE )
,NODE_CHAR
,(ATTR_T)ATTR_SIGNED
,(ATTR_T)ATTR_NONE
,"char"
}
,{ /** plain char **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_CHAR, TYPE_INT, ATT_NONE )
,NODE_CHAR
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"char"
}
,{ /** unsigned char **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_CHAR, TYPE_INT, ATT_NONE )
,NODE_CHAR
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"char"
}
,{ /** boolean **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_UNDEF, TYPE_BOOLEAN, ATT_NONE )
,NODE_BOOLEAN
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"boolean"
}
,{ /** byte **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_UNDEF, TYPE_BYTE, ATT_NONE )
,NODE_BYTE
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"byte"
}
,{ /** void **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_UNDEF, TYPE_VOID, ATT_NONE )
,NODE_VOID
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"void"
}
,{ /** handle_t **/
MAKE_TYPE_SPEC( SIGN_UNDEF, SIZE_UNDEF, TYPE_HANDLE_T, ATT_NONE )
,NODE_HANDLE_T
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"handle_t"
}
,{ /** signed long long **/
MAKE_TYPE_SPEC( SIGN_SIGNED, SIZE_LONGLONG, TYPE_INT, ATT_NONE )
,NODE_LONGLONG
,(ATTR_T)ATTR_NONE
,(ATTR_T)ATTR_NONE
,"long long"
}
,{ /** unsigned long **/
MAKE_TYPE_SPEC( SIGN_UNSIGNED, SIZE_LONGLONG, TYPE_INT, ATT_NONE )
,NODE_LONGLONG
,(ATTR_T)ATTR_UNSIGNED
,(ATTR_T)ATTR_NONE
,"long long"
}
};
/*****************************************************************************/
SIBLING_LIST
SIBLING_LIST::Add( named_node * pNewNode )
{
if (pTail == NULL)
{
return Init( pNewNode );
};
if ( pNewNode )
{
named_node * pHead = (named_node *) pTail->GetSibling();
pNewNode->SetSibling( pHead );
pTail->SetSibling(pNewNode);
pTail = pNewNode;
};
return *this;
};
SIBLING_LIST
SIBLING_LIST::Merge( SIBLING_LIST & NewList )
{
if (NewList.pTail == NULL)
{
return *this;
};
if ( pTail != NULL )
{
named_node * tmp = (named_node *)
NewList.pTail->GetSibling();
NewList.pTail->SetSibling( pTail->GetSibling());
pTail->SetSibling(tmp);
};
pTail = NewList.pTail;
return *this;
};
named_node *
SIBLING_LIST::Linearize()
{
named_node * pHead;
if (pTail == NULL)
{
pHead = NULL;
}
else
{
pHead = (named_node *) pTail->GetSibling();
pTail->SetSibling( (named_node *) NULL);
};
return pHead;
};
void
SIBLING_LIST::AddAttributes( ATTRLIST & AList )
{
named_node * pCur;
ATTRLIST pClone;
// for each of the node_skl nodes, apply the ATTRLIST
if ( pTail == NULL) return;
pCur = pTail->GetSibling();
// this traversal skips the last node on the list;
// that one gets the original list added.
while (pCur != pTail)
{
// clone attr list
// apply to pCur
pClone = AList.Clone();
pCur->AddAttributes( AList );
pCur = pCur->GetSibling();
}
pCur->AddAttributes( AList );
}
/*****************************************************************************/
/*** ParseError ************************************************************
* Purpose : format and report parsing errors
* Input :
* Output :
* Notes : errors will be reported many times. This is one localised place
* : for the RpcError Call
***************************************************************************/
void
ParseError(
STATUS_T Err,
char * pSuffix )
{
char * pFileName;
short Line;
short Col;
char TempBuf[512 + 50];
char * pBuffer;
ErrorInfo ErrStats( Err );
if ( !ErrStats.IsRelevant() )
return;
pImportCntrl->GetCurrentInputDetails( &pFileName, &Line, &Col);
if (pSuffix)
{
strcpy( TempBuf, ": " );
strcat( TempBuf, pSuffix );
pBuffer = TempBuf;
}
else
{
pBuffer = "";
}
ErrStats.ReportError(pFileName, Line, pBuffer);
}
void
SyntaxError(
STATUS_T Err,
short State )
{
#define NEAR_STRING (" near ")
#define STRLEN_OF_NEAR_STRING (6)
extern char *tokptr_G;
char * pTemp;
short len = (short) strlen( tokptr_G );
char * pBuffer = new char[
512 +
STRLEN_OF_NEAR_STRING +
len + 2 +
1 ];
#ifndef NO_GOOD_ERRORS
if( Err == BENIGN_SYNTAX_ERROR )
{
GetExpectedSyntax( pBuffer, State );
strcat( pBuffer, NEAR_STRING );
strcat( pBuffer, "\"" );
strcat( pBuffer, tokptr_G );
strcat( pBuffer, "\"" );
pTemp = pBuffer;
}
else
pTemp = (char *)0;
ParseError( Err, pTemp );
#else // NO_GOOD_ERRORS
strcpy( pBuffer, "syntax error" );
ParseError( Err, pBuffer );
#endif // NO_GOOD_ERRORS
delete pBuffer;
}
/*** BaseTypeSpecAnalysis *************************************************
* Purpose : to check for valid base type specification
* Input : pointer to already collected specs, new base type spec
* Output : modified collected specs
* Notes :
***************************************************************************/
void
BaseTypeSpecAnalysis(
struct _type_ana *pType,
short NewBaseType )
{
char TempBuf[ 50 ];
if( pType->BaseType == TYPE_PIPE )
return;
if( (pType->BaseType != TYPE_UNDEF) && (NewBaseType != TYPE_UNDEF) )
{
sprintf(TempBuf,", ignoring %s", GetTypeName(NewBaseType));
ParseError(BENIGN_SYNTAX_ERROR, TempBuf);
}
if(NewBaseType != TYPE_UNDEF)
pType->BaseType = NewBaseType;
}
/**************************************************************************
* routines for the pre_type_db class
**************************************************************************/
/*** pre_type_db *********************************************************
* Purpose : constructor for pre-allocated type data base
* Input : nothing
* Output :
* Notes : inits the prellocated types data base. This routine exist mainly
* : because static preallocation was giving a problem. If that is
* : solved, remove this
**************************************************************************/
pre_type_db::pre_type_db (void)
{
named_node * pNode;
int i = 0;
struct _pre_type * pPreType = &TypeDB[ 0 ];
struct pre_init * pInitCur = PreInitArray;
while( i < PRE_TYPE_DB_SIZE )
{
pPreType->TypeSpec = pInitCur->TypeSpec;
pPreType->pPreAlloc = pNode = new node_base_type(
pInitCur->NodeType,
pInitCur->Attr );
if ( pInitCur->Attr2 == ATTR_W64 )
{
pNode->GetModifiers().SetModifier( pInitCur->Attr2 );
}
pNode->SetSymName( pInitCur->pSymName );
pInitCur++;
pPreType++;
++i;
}
}
/*** GetPreAllocType ******************************************************
* Purpose : to search for a preallocated base type node, whose type
* : spec is provided
* Input : pointer to the resultant base node
* Output : STATUS_OK if all is well, error otherwise
* Notes :
**************************************************************************/
STATUS_T
pre_type_db::GetPreAllocType(
node_skl ** ppNode,
unsigned short TypeSpec )
{
int i = 0;
if( GET_TYPE( TypeSpec ) == TYPE_PIPE )
{
(*ppNode) = pErrorTypeNode;
return STATUS_OK;
}
while(i < sizeof(TypeDB) / sizeof(struct _pre_type) )
{
if( TypeDB[i].TypeSpec == TypeSpec )
{
(*ppNode) = TypeDB[i].pPreAlloc;
return STATUS_OK;
}
++i;
}
return SYNTAX_ERROR;
}
/****************************************************************************
* nested symbol table access support
***************************************************************************/
nsa::nsa( void )
{
SymTable * pSymTable = new GlobalSymTable;
CurrentLevel = 0;
InsertHead( (void *)pSymTable );
}
STATUS_T
nsa::PushSymLevel(
SymTable **ppSymTable )
{
STATUS_T Status;
SymTable *pSymTable = new SymTable;
CurrentLevel++;
Status = InsertHead( (void *)pSymTable);
*ppSymTable = pSymTable;
return Status;
}
STATUS_T
nsa::PopSymLevel(
SymTable **ppSymTable )
{
if(CurrentLevel == 0)
return I_ERR_SYMTABLE_UNDERFLOW;
CurrentLevel--;
RemoveHead();
return GetCurrent( (void **)ppSymTable );
}
short
nsa::GetCurrentLevel( void )
{
return CurrentLevel;
}
SymTable *
nsa::GetCurrentSymbolTable()
{
SymTable *pSymbolTable;
GetCurrent( (void **)&pSymbolTable );
return pSymbolTable;
}
/****************************************************************************
* nested symbol table access support
***************************************************************************/
void
IINFODICT::StartNewInterface()
{
IINFO * pInfo = new IINFO;
pInfo->fLocal = FALSE;
pInfo->InterfacePtrAttribute = ATTR_NONE;
pInfo->pInterfaceNode = NULL;
pInfo->CurrentTagNumber = 1;
pInfo->fPtrDefErrorReported = 0;
pInfo->fPtrWarningIssued = FALSE;
pInfo->IntfKey = CurrentIntfKey;
Push( (IDICTELEMENT) pInfo );
}
BOOL
IINFODICT::IsPtrWarningIssued()
{
IINFO * pInfo = (IINFO *)GetTop();
return pInfo->fPtrWarningIssued;
}
void
IINFODICT::SetPtrWarningIssued()
{
IINFO * pInfo = (IINFO *)GetTop();
pInfo->fPtrWarningIssued = TRUE;
}
void
IINFODICT::EndNewInterface()
{
IINFO * pInfo = (IINFO *)GetTop();
delete pInfo;
Pop();
pInfo = (IINFO *) GetTop();
if ( pInfo )
CurrentIntfKey = pInfo->IntfKey;
}
void
IINFODICT::SetInterfacePtrAttribute(
ATTR_T A )
{
IINFO * pInfo = (IINFO *)GetTop();
pInfo->InterfacePtrAttribute = A;
if( ImportLevel == 0 ) BaseInterfacePtrAttribute = A;
}
void
IINFODICT::SetInterfaceLocal()
{
IINFO * pInfo = (IINFO *)GetTop();
pInfo->fLocal = TRUE;
if( ImportLevel == 0 ) fBaseLocal = TRUE;
}
void
IINFODICT::SetInterfaceNode(
node_interface * p )
{
IINFO * pInfo = (IINFO *)GetTop();
pInfo->pInterfaceNode = p;
if( ImportLevel == 0 ) pBaseInterfaceNode = p;
CurrentIntfKey = (unsigned short) pInterfaceDict->AddElement( p );
pInfo->IntfKey = CurrentIntfKey;
}
void
IINFODICT::IncrementCurrentTagNumber()
{
IINFO * pInfo = (IINFO *)GetTop();
pInfo->CurrentTagNumber++;
}
ATTR_T
IINFODICT::GetInterfacePtrAttribute()
{
IINFO * pInfo = (IINFO *)GetTop();
return pInfo->InterfacePtrAttribute;
}
ATTR_T
IINFODICT::GetBaseInterfacePtrAttribute()
{
return BaseInterfacePtrAttribute;
}
BOOL
IINFODICT::IsInterfaceLocal()
{
IINFO * pInfo = (IINFO *)GetTop();
return pInfo->fLocal;
}
node_interface *
IINFODICT::GetInterfaceNode()
{
IINFO * pInfo = (IINFO *)GetTop();
return pInfo->pInterfaceNode;
}
short
IINFODICT::GetCurrentTagNumber()
{
IINFO * pInfo = (IINFO *)GetTop();
return pInfo->CurrentTagNumber;
}
void
IINFODICT::SetPtrDefErrorReported()
{
IINFO * pInfo = (IINFO *) GetTop();
pInfo->fPtrDefErrorReported = 1;
}
BOOL
IINFODICT::IsPtrDefErrorReported()
{
IINFO * pInfo = (IINFO *) GetTop();
return (BOOL) (pInfo->fPtrDefErrorReported == 1);
}
/****************************************************************************
* utility functions
***************************************************************************/
char *
GetTypeName(
short Type )
{
char *p;
switch(Type)
{
case TYPE_INT: p = "\"int\""; break;
case TYPE_FLOAT: p = "\"float\""; break;
case TYPE_DOUBLE: p = "\"double\""; break;
case TYPE_FLOAT80: p = "\"__float80\""; break;
case TYPE_FLOAT128: p = "\"__float128\""; break;
case TYPE_VOID: p = "\"void\""; break;
case TYPE_BOOLEAN: p = "\"boolean\""; break;
case TYPE_HANDLE_T: p = "\"handle_t\""; break;
default: p = ""; break;
}
return p;
}
STATUS_T
GetBaseTypeNode(
node_skl ** ppNode,
short TypeSign,
short TypeSize,
short BaseType,
short TypeAttrib)
{
STATUS_T uStatus = STATUS_OK;
if( pPreAllocTypes->GetPreAllocType(
ppNode,
(unsigned short)MAKE_TYPE_SPEC(TypeSign,TypeSize,BaseType,TypeAttrib)) != STATUS_OK)
{
// this should never happen
MIDL_ASSERT( FALSE );
*ppNode = (node_skl *)new node_error;
}
return uStatus;
}
STATUS_T
GetBaseTypeNode(
node_skl ** ppNode,
struct _type_ana Type)
{
STATUS_T uStatus = STATUS_OK;
if( pPreAllocTypes->GetPreAllocType(
ppNode,
(unsigned short)MAKE_TYPE_SPEC(Type.TypeSign,Type.TypeSize,Type.BaseType, Type.TypeAttrib)) != STATUS_OK)
{
// this should never happen
*ppNode = (node_skl *) NULL;
}
return uStatus;
}
#define TEMPNAME ("__MIDL_")
#define TEMP_NAME_LENGTH (7)
#define INTF_ADDITION ("itf_")
#define INTF_ADDITION_LENGTH (4)
#define LENGTH_OF_1_UNDERSCORE (1)
char *
GenTempName()
{
static short NameCounter = 0;
char TempBuf[ TEMP_NAME_LENGTH + 4 + 1 ];
sprintf(TempBuf, "%s%.4d", TEMPNAME, NameCounter++);
return pMidlLexTable->LexInsert( TempBuf );
}
char *
GenIntfName()
{
static short NameCounter = 0;
char TempBuf[ TEMP_NAME_LENGTH + INTF_ADDITION_LENGTH + 4 + 1 + _MAX_PATH ];
char FileBase[_MAX_PATH];
char dbcsFileBase[_MAX_PATH*2];
pCommand->GetInputFileNameComponents(NULL, NULL, FileBase, NULL );
// account for spaces and DBCS chars.
NormalizeString( FileBase, dbcsFileBase );
sprintf(TempBuf, "%s%s%s_%.4d",
TEMPNAME,
INTF_ADDITION,
dbcsFileBase,
NameCounter++);
return pMidlLexTable->LexInsert( TempBuf );
}
char *
GenCompName()
{
char* pCurrentInterfaceName = pInterfaceInfoDict->GetInterfaceName();
short Length = (short) strlen(pCurrentInterfaceName);
char* pBuffer;
char* pTemp;
short CurrentTagNumber;
pBuffer = new char[ TEMP_NAME_LENGTH + // __MIDL_
Length + // intface name
LENGTH_OF_1_UNDERSCORE + // _
4 + // temp number
1 ]; // term. zero.
CurrentTagNumber = pInterfaceInfoDict->GetCurrentTagNumber();
sprintf( pBuffer, "%s%s_%.4d", TEMPNAME, pCurrentInterfaceName, CurrentTagNumber );
pInterfaceInfoDict->IncrementCurrentTagNumber();
pTemp = pMidlLexTable->LexInsert( pBuffer );
delete pBuffer;
return pTemp;
}
BOOL
IsTempName(
char *pName )
{
return !(strncmp( pName, TEMPNAME , TEMP_NAME_LENGTH ) );
}
void
ApplyAttributes(
named_node * pNode,
ATTRLIST & attrs )
{
if( attrs )
{
pNode->SetAttributes(attrs);
}
}
/****************************************************************************
This routine exists to share code for setting up the field attribute nodes
****************************************************************************/
ATTRLIST
GenerateFieldAttribute(
ATTR_T NodeType,
expr_list * pExprList )
{
node_base_attr * pAttr = 0;
expr_node * pExpr = 0;
ATTRLIST AList;
AList.MakeAttrList();
/**
** we delibrately dont set the bits in the summary attribute 'cause
** these bits will get set in the set attribute anyways for the
** field attributes
**/
if(pExprList != (expr_list *)NULL)
{
pExprList->Init();
while( pExprList->GetNext( (void **)&pExpr ) == STATUS_OK)
{
switch(NodeType)
{
case ATTR_FIRST:
case ATTR_LAST:
case ATTR_LENGTH:
case ATTR_SIZE:
case ATTR_MIN:
case ATTR_MAX:
pAttr = new size_attr( pExpr, NodeType );
break;
default:
//this should never happen
MIDL_ASSERT(FALSE && "Attribute not supported");
break;
}
AList.SetPeer( pAttr );
}
}
delete pExprList;
AList.Reverse();
return AList;
}
/****************************************************************************
SearchTag:
This routine provides a means of searching the global symbol space for
struct/union tags, and enums. These share the same name space but we want to
keep the symbol table identity of enums, struct tags etc separate. so
we need to search for all of these separately when verifying that a tag
has really not been seen before.
This routine returns:
1. (node_skl *)NULL if NO struct/union/enum was defined by that name
2. node_skl * if the a definition was found for what you are looking
for.
3. (node_skl *) error type node if a definition was found, but it is
not what you are looking for.
****************************************************************************/
node_skl *
SearchTag(
char * pName,
NAME_T Tag )
{
node_skl * pNode;
NAME_T MyTag;
SymKey SKey( pName, MyTag = NAME_TAG );
/**
** Has it been declared as a struct ?
**/
if ( (pNode = pBaseSymTbl->SymSearch(SKey) ) == 0 )
{
/**
** not a tag - maybe enum / union
**/
SKey.SetKind( MyTag = NAME_ENUM );
if ( (pNode = pBaseSymTbl->SymSearch(SKey) ) == 0 )
{
/**
** not a enum maybe union
**/
SKey.SetKind( MyTag = NAME_UNION );
if ( (pNode = pBaseSymTbl->SymSearch(SKey) ) == 0 )
return (node_skl *)NULL;
}
}
/**
** search was sucessful. Check whether this was what you were looking
** for. If it is , it means we found a definition of the symbol. If not
** then we found a definition all right, but it is of a different entity.
** The routine can find this out by verifying that the typenode returned
** was an error type node or not
**/
return (MyTag == Tag ) ? pNode : pErrorTypeNode;
}
/****************************************************************************
SetPredefinedTypes:
Set up predefined types for the midl compiler. The predefined types
are error_status_t and wchar_t( the latter dependent on compile mode )
****************************************************************************/
void
SetPredefinedTypes()
{
char * pName = 0;
node_e_status_t * pNew = new node_e_status_t;
node_def_fe * pDef = new node_def_fe( pName = pNew->GetSymName(), pNew );
// set global version
pError_status_t = pNew;
// the typedef of error_status_t in the symbol table
SymKey SKey( pName, NAME_DEF);
pBaseSymTbl->SymInsert(SKey, (SymTable *)NULL, pDef );
//
// we always predefine wchar_t and report the error to the user. If
// we dont enter wchar_t in the predefined types, then we get all
// kinds of syntax and error recovery errors which could be confusing
// in this context. We therefore explicitly give an error on wchar_t.
//
node_wchar_t * pNew2 = new node_wchar_t;
pDef = new node_def_fe( pName = pNew2->GetSymName(), pNew2 );
// the typedef of wchar_t in the symbol table
SKey.SetString( pName );
pBaseSymTbl->SymInsert(SKey, (SymTable *)NULL, pDef );
}
//
// We check for a proc/typedef/member/param/tag/enum/label name already defined
// as an identifier. Only if the identifier is one which will be turned into
// a #define, do we report an error. However, it is not worth it to check if
// an identifier is used as a name because in any case we will not be able to
// check for clashes with field / param names since they are at a lower than
// global, symbol table scope. Generally checking if the name of a member etc
// is already defined as an id which will be turned into a #define should be
// enough.
//
void
CheckGlobalNamesClash(
SymKey SKeyOfSymbolBeingDefined )
{
NAME_T NT = SKeyOfSymbolBeingDefined.GetKind();
char * pName = SKeyOfSymbolBeingDefined.GetString();
SymKey SKey;
SKey.SetString( pName );
switch( NT )
{
case NAME_PROC:
case NAME_MEMBER:
case NAME_TAG:
case NAME_DEF:
case NAME_LABEL:
case NAME_ENUM:
node_id * pID;
SKey.SetKind( NAME_ID );
if ( ( pID = (node_id *) pBaseSymTbl->SymSearch( SKey ) ) != 0 )
{
BOOL fWillBeAHashDefine = !pID->FInSummary( ATTR_EXTERN ) &&
!pID->FInSummary( ATTR_STATIC ) &&
pID->GetInitList();
if( fWillBeAHashDefine )
ParseError( NAME_ALREADY_USED, pName );
}
break;
case NAME_ID:
#if 0
SKey.SetKind( NAME_PROC );
if( !pBaseSymTbl->SymSearch( SKey ) )
{
SKey.SetKind( NAME_TAG );
if( !pBaseSymTbl->SymSearch( SKey ) )
{
SKey.SetKind( NAME_DEF );
if( !pBaseSymTbl->SymSearch( SKey ) )
{
SKey.SetKind( NAME_LABEL );
if( !pBaseSymTbl->SymSearch( SKey ) )
{
SKey.SetKind( NAME_ENUM );
if( !pBaseSymTbl->SymSearch( SKey ) )
break;
}
}
}
}
ParseError( NAME_CLASH_WITH_CONST_ID, pName );
break;
#endif // 0
default:
break;
}
}