windows-nt-4.0/private/rpc/midl20/codegen/filecls.cxx

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Copyright (c) 1989 Microsoft Corporation

 Module Name:

 	filecls.hxx

 Abstract:

	Code generation methods for file cg classes.

 Notes:


 History:

 	Sep-01-1993		VibhasC		Created.

 ----------------------------------------------------------------------------*/

/****************************************************************************
 *	include files
 ***************************************************************************/
#include "becls.hxx"
#pragma hdrstop

/****************************************************************************
 *	local definitions
 ***************************************************************************/

/****************************************************************************
 *	local data
 ***************************************************************************/

/****************************************************************************
 *	externs
 ***************************************************************************/
extern CMD_ARG * pCommand;

extern BOOL                     IsTempName( char * );

/****************************************************************************/

void
CG_FILE::CheckForHeadingToken(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit standard block comment file heading portion.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM				*	pStream		= pCCB->GetStream();

	if ( pCCB->IsReparsingCurrentFile() )
		{
		MIDL_TOKEN			FoundToken;

		((RW_ISTREAM *) pStream)->SaveToNextMidlToken( FoundToken );
		if ( FoundToken.GetTokenType() != FILE_HEADING_TOKEN )
			{
			assert(!"expecting file heading token" );
			}
		}

	pStream->EmitToken( MIDL_TOKEN( FILE_HEADING_TOKEN ) );
	pStream->NewLine();
}

void
CG_FILE::EmitStandardHeadingBlock(
	CCB	*	pCCB,
	char *	CommentStr )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit standard block comment file heading portion.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->NewLine();
	
	if ( CommentStr )
		pStream->Write( CommentStr );
	else
		pStream->Write( "/*" );

	pStream->Write(" File created by MIDL compiler version ");
	pStream->Write( GetCompilerVersion() );
	if ( CommentStr == 0 )
		pStream->Write(" */");

	pStream->NewLine();

	if ( CommentStr )
		pStream->Write( CommentStr );
	else
		pStream->Write( "/*" );

	pStream->Write(" at ");
	pStream->Write( GetCompileTime() );
	if ( CommentStr == 0 )
		pStream->Write(" */");
	pStream->NewLine();

    // Emit command line switches information.

    pCommand->EmitConfirm( pStream );

    if ( pCCB->IsReparsingCurrentFile() )
		{
		MIDL_TOKEN			FoundToken;

		((RW_ISTREAM *) pStream)->DiscardToNextMidlToken( FoundToken );
		if ( FoundToken.GetTokenType() != FILE_HEADING_TOKEN )
			{
			assert(!"expecting file heading token" );
			}
		}

	pStream->EmitToken( MIDL_TOKEN( FILE_HEADING_TOKEN ) );
	pStream->NewLine();

}

void
CG_FILE::EmitFormatStringTypedefs(
    CCB      *  pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Emit dummy #defines with sizes for the format string structs,
    then emit typedefs for the type and proc format string structs.
    Sets the context position in the file node for later use.

 Arguments:
    
    pCCB        - a pointer to the code generation control block.

 Notes:

    The typedefs are going to be fixed later by a call to
    EmitFixupFormatStringTpedefs. This is needed for ANSI.
    The dummies would work for ANSI non-compliant code.

--------------------------------------------------------------------------*/
{
    ISTREAM  *  pStream    = pCCB->GetStream();

    pStream->NewLine(2);
    pStream->Write( "#define TYPE_FORMAT_STRING_SIZE   " );
    SetTypeSizeContextPosition( pStream->GetCurrentPosition() );
    pStream->Write( "                                  " );
    pStream->NewLine();

    pStream->Write( "#define PROC_FORMAT_STRING_SIZE   " );
    SetProcSizeContextPosition( pStream->GetCurrentPosition() );
    pStream->Write( "                                  " );

    if (pCommand->IsHookOleEnabled())
    {
        pStream->NewLine();
        pStream->Write( "#define LOCAL_TYPE_FORMAT_STRING_SIZE   " );
        SetLocalTypeSizeContextPosition( pStream->GetCurrentPosition() );
        pStream->Write( "                                  " );
        pStream->NewLine();

        pStream->Write( "#define LOCAL_PROC_FORMAT_STRING_SIZE   " );
        SetLocalProcSizeContextPosition( pStream->GetCurrentPosition() );
        pStream->Write( "                                  " );
    }
    pStream->NewLine(2);

    pStream->Write( "typedef struct _" FORMAT_STRING_TYPE_NAME );
    pStream->IndentInc();
    pStream->NewLine();
    pStream->Write( "{" );
    pStream->NewLine();
    pStream->Write( "short          Pad;" );
    pStream->NewLine();
    pStream->Write( "unsigned char  Format[ TYPE_FORMAT_STRING_SIZE ];" );
    pStream->NewLine();
    pStream->Write( "} " FORMAT_STRING_TYPE_NAME ";" );
    pStream->IndentDec();
    pStream->NewLine(2);

    pStream->Write( "typedef struct _" PROC_FORMAT_STRING_TYPE_NAME );
    pStream->IndentInc();
    pStream->NewLine();
    pStream->Write( "{" );
    pStream->NewLine();
    pStream->Write( "short          Pad;" );
    pStream->NewLine();
    pStream->Write( "unsigned char  Format[ PROC_FORMAT_STRING_SIZE ];" );
    pStream->NewLine();
    pStream->Write( "} " PROC_FORMAT_STRING_TYPE_NAME ";" );
    pStream->IndentDec();
    pStream->NewLine();

    if (pCommand->IsHookOleEnabled())
    {
        pStream->NewLine();
        pStream->Write( "typedef struct _" LOCAL_FORMAT_STRING_TYPE_NAME );
        pStream->IndentInc();
        pStream->Write( "{" );
        pStream->NewLine();
        pStream->Write( "short          Pad;" );
        pStream->NewLine();
        pStream->Write( "unsigned char  Format[ LOCAL_TYPE_FORMAT_STRING_SIZE ];" );
        pStream->NewLine();
        pStream->Write( "} " LOCAL_FORMAT_STRING_TYPE_NAME ";" );
        pStream->IndentDec();
        pStream->NewLine(2);

        pStream->Write( "typedef struct _" LOCAL_PROC_FORMAT_STRING_TYPE_NAME );
        pStream->IndentInc();
        pStream->NewLine();
        pStream->Write( "{" );
        pStream->NewLine();
        pStream->Write( "short          Pad;" );
        pStream->NewLine();
        pStream->Write( "unsigned char  Format[ LOCAL_PROC_FORMAT_STRING_SIZE ];" );
        pStream->NewLine();
        pStream->Write( "} " LOCAL_PROC_FORMAT_STRING_TYPE_NAME ";" );
        pStream->IndentDec();
        pStream->NewLine();
    }
}

void
CG_FILE::EmitFixupToFormatStringTypedefs(
    CCB      *  pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

    Fixes he dummy #defines emitted by EmitFormatStringTypedefs.

 Arguments:
    
    pCCB        - a pointer to the code generation control block.
    pContext    - a pointer to the position context 

--------------------------------------------------------------------------*/
{
    char        Buffer[20];
    ISTREAM  *  pStream = pCCB->GetStream();

    long EofPosition = pStream->GetCurrentPosition();

    pStream->SetCurrentPosition( GetTypeSizeContextPosition() );
    sprintf( Buffer, "%d",  pCCB->GetFormatString()->GetCurrentOffset() + 1);
    pStream->Write( Buffer );

    pStream->SetCurrentPosition( GetProcSizeContextPosition() );
    sprintf( Buffer, "%d",  pCCB->GetProcFormatString()->GetCurrentOffset() + 1);
    pStream->Write( Buffer );

    if ( pCommand->IsHookOleEnabled() )
        {
        pStream->SetCurrentPosition( GetLocalTypeSizeContextPosition() );
        sprintf( Buffer, "%d",  GetLocalFormatString()->GetCurrentOffset() + 1);
        pStream->Write( Buffer );

        pStream->SetCurrentPosition( GetLocalProcSizeContextPosition() );
        sprintf( Buffer, "%d",  GetLocalProcFormatString()->GetCurrentOffset() + 1);
        pStream->Write( Buffer );
        }

    pStream->SetCurrentPosition( EofPosition );
}


CG_STATUS
CG_SOURCE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Generate code for the source node.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR	I;
	CG_FILE	*	pCG;

	//
	// for all files nodes in this interface, generate code.
	//

	GetMembers( I );

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		pCG->GenCode( pCCB );
		}

	return CG_OK;
}

void
CG_CSTUB_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "/* this ALWAYS GENERATED file contains the RPC client stubs */" );
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

CG_STATUS
CG_CSTUB_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Generate code for the file node.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	char		Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
	char		Drive[ _MAX_DRIVE ];
	char		Path[ _MAX_DIR ];
	char		Name[ _MAX_FNAME ];
	char		Ext[ _MAX_EXT ];


	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

    // Set HasStublessProxies and HasOi2 for each interface.

    EvaluateVersionControl();

	EmitFileHeadingBlock( pCCB );

	// Emit the hash includes.
	
	Out_IncludeOfFile( pCCB, STRING_H_INC_FILE_NAME, TRUE );
	pStream->NewLine();
	pStream->Write( ALPHA_IFDEF );
	Out_IncludeOfFile( pCCB, STDARG_H_INC_FILE_NAME, TRUE );
	pStream->NewLine();
	pStream->Write( "#endif");
	pStream->NewLine();

    // rpcssm puts a reference to malloc and free in the stub_c.c.
    // So, we have to emit the appropriate include.
    // In ms_ext when explicit, in osf always, to cover some weird cases.

    while( ITERATOR_GETNEXT( I, pCG ) )
        {
        if ( ( ((CG_INTERFACE *)pCG)->GetUsesRpcSS() || (pCCB->GetMode() == 0) ))
            {
            Out_IncludeOfFile( pCCB, "malloc.h", TRUE );
            break;
            }
        }

	_splitpath( GetHeaderFileName(), Drive, Path, Name, Ext );
	strcpy( Buffer, Name );
	strcat( Buffer, Ext );
	Out_IncludeOfFile( pCCB, Buffer, FALSE );

    EmitFormatStringTypedefs( pCCB );

	//
	// Emit the external variables needed.
	//

	pStream->NewLine();

    //
    // Emit the format string extern declarations.
    //
    Out_TypeFormatStringExtern( pCCB );
    Out_ProcFormatStringExtern( pCCB );
    Out_LocalTypeFormatStringExtern( pCCB );
    Out_LocalProcFormatStringExtern( pCCB );


    pCCB->ClearOptionalExternFlags();

    pCCB->SetFileCG(this);

    //
    // Create a new format string object if it does not yet exist.
    //
    if ( !GetFormatString() )
    {
        SetFormatString(new FORMAT_STRING());
        SetLocalFormatString(new FORMAT_STRING());
    }
    pCCB->SetFormatString( GetFormatString() );

    if ( !GetProcFormatString() )
    {
        SetProcFormatString(new FORMAT_STRING());
        SetLocalProcFormatString(new FORMAT_STRING());
    }
    pCCB->SetProcFormatString( GetProcFormatString() );

	//
	// Send the message to the children to emit code.
	//

	//
	// for all interfaces in this file, generate code.
	//

	ITERATOR_INIT( I );

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_INTERFACE:
    			((CG_INTERFACE *)pCG)->OutputInterfaceIdComment( pCCB );
				((CG_INTERFACE *)pCG)->GenClientStub( pCCB );
				break;

			case ID_CG_OBJECT_INTERFACE:
			case ID_CG_INHERITED_OBJECT_INTERFACE:
				break;
			default:
				break;
			}
		}

    //
    // Output the tables that may be common to several interfaces.
    //
    EmitFixupToFormatStringTypedefs( pCCB );

    pCCB->OutputMultipleInterfaceTables(GetLocalFormatString(), GetLocalProcFormatString());

	return CG_OK;
}

/****************************************************************************
 *	sstub file implementation class.
 ***************************************************************************/


void
CG_SSTUB_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "/* this ALWAYS GENERATED file contains the RPC server stubs */" );
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

CG_STATUS
CG_SSTUB_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Generate code for the file node.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR		*	pCG;
	char		Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
	char		Drive[ _MAX_DRIVE ];
	char		Path[ _MAX_DIR ];
	char		Name[ _MAX_FNAME ];
	char		Ext[ _MAX_EXT ];

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

    // Set HasStublessProxies and HasOi2 for each interface.

    EvaluateVersionControl();

	EmitFileHeadingBlock( pCCB );

	//
	// Emit the hash includes.
	//
	
	Out_IncludeOfFile( pCCB, STRING_H_INC_FILE_NAME, TRUE );
	_splitpath( GetHeaderFileName(), Drive, Path, Name, Ext );
	strcpy( Buffer, Name );
	strcat( Buffer, Ext );
	Out_IncludeOfFile( pCCB, Buffer, FALSE );

    EmitFormatStringTypedefs( pCCB );

	//
	// Emit the external variables needed.
	//

    //
    // Emit the format string extern declarations.
    //
    Out_TypeFormatStringExtern( pCCB );
    Out_ProcFormatStringExtern( pCCB );
    Out_LocalTypeFormatStringExtern( pCCB );
    Out_LocalProcFormatStringExtern( pCCB );

    pCCB->ClearOptionalExternFlags();

    pCCB->SetFileCG(this);

    //
    // Create a new format string object if it does not exist.
    //
    if ( !GetFormatString() )
    {
        SetFormatString(new FORMAT_STRING());
        SetLocalFormatString(new FORMAT_STRING());
    }
    pCCB->SetFormatString( GetFormatString() );

    if ( !GetProcFormatString() )
    {
        SetProcFormatString(new FORMAT_STRING());
        SetLocalProcFormatString(new FORMAT_STRING());
    }
    pCCB->SetProcFormatString( GetProcFormatString() );

	//
	// Send the message to the children to emit code.
	//

	//
	// For all interfaces in this file, generate code.
	//

	PNAME			ContextHandleTypeName = NULL;
	BOOL			GotContextHandle = FALSE;
    BOOL            HasInterpretedProc = FALSE;

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		if ( pCG->GetCGID() == ID_CG_INTERFACE )
			{
            if ( ! ((CG_INTERFACE *)pCG)->HasPicklingStuffOnly() )
                {
                pCCB->SetSkipFormatStreamGeneration( FALSE );

    			((CG_INTERFACE *)pCG)->OutputInterfaceIdComment( pCCB );
    			((CG_INTERFACE *)pCG)->GenServerStub( pCCB );

                if ( ((CG_INTERFACE *)pCG)->HasInterpretedProc() )
                    HasInterpretedProc = TRUE;
                }
			}
		}

    //
    // Output the tables that may be common to several interfaces.
    
	pCCB->SetCodeGenSide( CGSIDE_SERVER );

    //
    // If there was at least one interpreted proc in the interfaces of this
    // file than make sure to turn the optimization bit in the CCB's 
    // OptimOption on.
    //
    EmitFixupToFormatStringTypedefs( pCCB );

    if ( HasInterpretedProc )
        pCCB->SetOptimOption( pCCB->GetOptimOption() | OPTIMIZE_INTERPRETER );

    pCCB->OutputMultipleInterfaceTables(GetLocalFormatString(), GetLocalProcFormatString());

	return CG_OK;
}


class GUID_DICTIONARY	: public Dictionary
	{
public:
				GUID_DICTIONARY()
					{
					}

	virtual
	int 		Compare (pUserType p1, pUserType p2)
					{
					INTERNAL_UUID	*	u1	= &( ((CG_INTERFACE *)p1)->GetGuidStrs().Value );
					INTERNAL_UUID	*	u2	= &( ((CG_INTERFACE *)p2)->GetGuidStrs().Value );

					return memcmp( u1, u2, 16 );
					}


	};

void
CG_PROXY_FILE::MakeImplementedInterfacesList(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Make a list of all the interfaces supported by this proxy file
	( non-inherited, non-local interfaces ).

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_INTERFACE		*	pCG;
	CG_ITERATOR				I;
	GUID_DICTIONARY			GuidDict;

	// work directly on the real list
	GetMembers( I );

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		
		if ( pCG->GetCGID() != ID_CG_OBJECT_INTERFACE )
			continue;

		if ( ((CG_OBJECT_INTERFACE*)pCG)->IsLocal()  && !pCommand->IsHookOleEnabled())
			continue;
			
		GuidDict.Dict_Insert( pCG );
			
		}

	GuidDict.Dict_GetList( ImplementedInterfaces );
	GuidDict.Dict_Discard();
}

void
CG_FILE::EvaluateVersionControl()
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Calculates HasStublessProxies and Oi2 flags only through the
    interfaces.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:
 Notes:

----------------------------------------------------------------------------*/
{
    if ( (pCommand->GetOptimizationFlags() & OPTIMIZE_STUBLESS_CLIENT ) ||
          pCommand->GetNdrVersionControl().HasStublessProxies() )
        GetNdrVersionControl().SetHasStublessProxies();

    if ( (pCommand->GetOptimizationFlags() & OPTIMIZE_INTERPRETER_V2 ) ||
          pCommand->GetNdrVersionControl().HasOi2() )
        GetNdrVersionControl().SetHasOi2();

    CG_ITERATOR         I;
    CG_NDR        *     pCG;
    CG_INTERFACE  *     pIntf;

    if( !GetMembers( I ) )
        {
        return;
        }

    while( ITERATOR_GETNEXT( I, pCG ) )
        {
        pIntf = (CG_INTERFACE *)pCG;

        switch(pCG->GetCGID())
            {
            case ID_CG_INTERFACE:
            case ID_CG_INHERITED_OBJECT_INTERFACE:
            case ID_CG_OBJECT_INTERFACE:
                pIntf->EvaluateVersionControl();

                if ( pIntf->HasStublessProxies() )
                    GetNdrVersionControl().SetHasStublessProxies();
                if ( pIntf->GetNdrVersionControl().HasOi2() )
                    GetNdrVersionControl().SetHasOi2();
                break;

            default:
                break;
            }
        }

    if ( GetNdrVersionControl().HasStublessProxies() )
        pCommand->GetNdrVersionControl().SetHasStublessProxies();
    if ( GetNdrVersionControl().HasOi2() )
        pCommand->GetNdrVersionControl().SetHasOi2();
}


void
CG_PROXY_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "/* this ALWAYS GENERATED file contains the proxy stub code */" );
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

CG_STATUS
CG_PROXY_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a proxy file containing the proxies and stubs for 
	the [object] interfaces defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	char		Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
	char		Drive[ _MAX_DRIVE ];
	char		Path[ _MAX_DIR ];
	char		Name[ _MAX_FNAME ];
	char		Ext[ _MAX_EXT ];
	unsigned long index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

    // Set HasStublessProxies and HasOi2 for each interface.

    EvaluateVersionControl();

	EmitFileHeadingBlock( pCCB );

    //
    // Check if midl was invoked with -O1.  This means we can create
    // binaries using stubless proxies (if also compiled -Oi).  These 
    // proxies will not work on 807. 
    //
    if ( GetNdrVersionControl().HasStublessProxies() )
        {
        pStream->NewLine();
        pStream->Write( "#define USE_STUBLESS_PROXY" );

        pStream->NewLine();
        }

	//
	// Emit the hash includes.
	//
	Out_IncludeOfFile( pCCB, "rpcproxy.h", FALSE );

	_splitpath( GetHeaderFileName(), Drive, Path, Name, Ext );
	strcpy( Buffer, Name );
	strcat( Buffer, Ext );
	Out_IncludeOfFile( pCCB, Buffer, FALSE );

    EmitFormatStringTypedefs( pCCB );

	//
	// Emit the external variables needed.
	//

	pStream->NewLine();

	//
	// Emit the format string extern declarations.  
	//
	Out_TypeFormatStringExtern( pCCB );
    Out_ProcFormatStringExtern( pCCB );
	Out_LocalTypeFormatStringExtern( pCCB );
    Out_LocalProcFormatStringExtern( pCCB );

    pCCB->ClearOptionalExternFlags();

	pStream->NewLine();

    pCCB->SetFileCG(this);

    //
    // Create a new format string object if it does not yet exist.
    //
    if ( !GetFormatString() )
    {
        SetFormatString(new FORMAT_STRING());
        SetLocalFormatString(new FORMAT_STRING());
    }
    pCCB->SetFormatString( GetFormatString() );

    if ( !GetProcFormatString() )
    {
        SetProcFormatString(new FORMAT_STRING());
        SetLocalProcFormatString(new FORMAT_STRING());
    }
    pCCB->SetProcFormatString( GetProcFormatString() );

	// make the list of interfaces provided by this proxy file
	MakeImplementedInterfacesList( pCCB );

	//
	// Send the message to the children to emit code.
	//

	//
	// generate code for all [object] interfaces in the IDL file.
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_INTERFACE:
    			((CG_INTERFACE *)pCG)->OutputInterfaceIdComment( pCCB );
				break;
			case ID_CG_INHERITED_OBJECT_INTERFACE:
				{
              	CG_INHERITED_OBJECT_INTERFACE *	pInhObjCG	= 
						( CG_INHERITED_OBJECT_INTERFACE * ) pCG;
              	//
                // Generate format string description for all procs.
                //
                pInhObjCG->OutputInterfaceIdComment( pCCB );
				pInhObjCG->GenCode( pCCB );
				// make no code or tables for local interfaces
				if ( pInhObjCG->IsLocal()  && !pCommand->IsHookOleEnabled())
					break;
 
                //
                // Both of these do nothing right now.  4/25.
                //
				pInhObjCG->GenInterfaceProxy( pCCB, index );
				pInhObjCG->GenInterfaceStub( pCCB, index );
				break;
				}
			case ID_CG_OBJECT_INTERFACE:
				{
				CG_OBJECT_INTERFACE *	pObjCG	= 
									(CG_OBJECT_INTERFACE * ) pCG;

				// make no code or tables for local interfaces
                pObjCG->OutputInterfaceIdComment( pCCB );
				pObjCG->GenCode( pCCB );
				if ( pObjCG->IsLocal() && !pCommand->IsHookOleEnabled())
					break;
				pObjCG->GenInterfaceProxy( pCCB, index );
				pObjCG->GenInterfaceStub( pCCB, index );
                if (pObjCG->IsLocal())
                    break;
				index++;   // index is index in stub/proxy buffer tables
				break;
				}
			default:
				break;
			}
		}

    pCCB->SetSkipFormatStreamGeneration( FALSE );
    
	pStream->NewLine();
	pStream->Write( "#pragma data_seg(\".rdata\")" );
	pStream->NewLine();

    EmitFixupToFormatStringTypedefs( pCCB );

    pCCB->OutputMultipleInterfaceTables(GetLocalFormatString(), GetLocalProcFormatString());

	Out_ProxyFileInfo(pCCB);

	UpdateDLLDataFile( pCCB );
	
	return CG_OK;
}


void
CG_COM_METHODS_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	CheckForHeadingToken( pCCB );

	pStream->Write( "/* this USER-ALTERABLE file contains the class methods for COM classes  */" );
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}


/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 COM_METHODS_FILE overall structure:

	<< optional user stuff >>

	< MIDL header comment, always generated>

	//@@MIDL_INCLUDES_LIST()
	<headers>
	//@@MIDL_INCLUDES_LIST_END()

	repeat the below:
	|	//@@MIDL_CLASS( <class> )
	|
	|	repeat the below:
	|	|	//@@MIDL_CLASS_METHODS( <class::interface> )
	|	|
	|	|	repeat the below:
	|	|	|	//@@MIDL_METHOD( <class::method> )
	|	|	|	<function header>
	|	|	|	//@@MIDL_METHOD_BODY( <class::method> )
	|	|	|
	|	//@@MIDL_CLASS_END( class )
	|
	//@@MIDL_CLASS_METHODS_END()

	user changes are preserved outside of :
		the file includes block
		the function headers

	new methods/interfaces/classes have their stuff added at
	the end of their block.

	deleted methods/interfaces/classes are mentioned in added comments and
	ignored.

----------------------------------------------------------------------------*/

CG_STATUS
CG_COM_METHODS_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM server file containing the class factory and class 
	implementation for the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	unsigned long index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	RW_ISTREAM 		Stream( GetFileName(), 4 );
	RW_ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

	if ( Stream.IsTempStream() )
		{
		pCCB->SetReparsingCurrentFile( TRUE );
		}

	EmitFileHeadingBlock( pCCB );

	//
	// Emit the hash includes.
	//
	OutputIncludes( pCCB );

	//
	// Emit the external variables needed.
	//
	pStream->NewLine();
	

	if ( Stream.IsTempStream() )
		{
		ParseAndGenCode( pCCB, pStream );

		}
	else
		{

		//
		// generate code for all com classes in the IDL file.
		//

		while( ITERATOR_GETNEXT( I, pCG ) )
			{
			switch(pCG->GetCGID())
				{
				case ID_CG_INHERITED_OBJECT_INTERFACE:
				case ID_CG_OBJECT_INTERFACE:
		
					if ( ((CG_OBJECT_INTERFACE*)pCG)->IsIUnknown() )
						pCCB->SetIUnknownCG( (CG_IUNKNOWN_OBJECT_INTERFACE *) pCG );
					else if ( !strcmp( pCG->GetSymName(), "IClassFactory" ) )
						pCCB->SetIClassfCG( (CG_OBJECT_INTERFACE *) pCG );
					break;

				case ID_CG_COM_CLASS:
					{
					CG_COM_CLASS	*	pComCG	= ( CG_COM_CLASS * ) pCG;
				
					pComCG->GenComClassServer( pCCB );
					break;
					}

				default:
					break;
				}
			}
		}

	// propogate changes from the tmpfile, if any
	Stream.UpdateOriginalFile();

	pCCB->SetReparsingCurrentFile( FALSE );

	return CG_OK;
}


CG_STATUS
CG_COM_METHODS_FILE::ParseAndGenCode(
	CCB			*	pCCB,
	RW_ISTREAM	*	pStream )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM server file containing the class factory and class 
	implementation for the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	unsigned long index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	//
	// go through the old file, propogating changes and 
	// generating code for new things
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_INHERITED_OBJECT_INTERFACE:
			case ID_CG_OBJECT_INTERFACE:
	
				if ( ((CG_OBJECT_INTERFACE*)pCG)->IsIUnknown() )
					pCCB->SetIUnknownCG( (CG_IUNKNOWN_OBJECT_INTERFACE *) pCG );
				else if ( !strcmp( pCG->GetSymName(), "IClassFactory" ) )
					pCCB->SetIClassfCG( (CG_OBJECT_INTERFACE *) pCG );
				break;

			case ID_CG_COM_CLASS:
				{
				CG_COM_CLASS	*	pComCG	= ( CG_COM_CLASS * ) pCG;
			
				pComCG->ReGenComClassServer( pCCB );
				break;
				}

			default:
				break;
			}
		}

	return CG_OK;
}


void
CG_COM_IUNKNOWN_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "/* this ALWAYS GENERATED file contains the implementations of  */" );
	pStream->NewLine();
	pStream->Write( "/* the IUnknowns and the class factories */" ); 
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

CG_STATUS
CG_COM_IUNKNOWN_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM server file containing the class factory and class 
	implementation for the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	unsigned long index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

	EmitFileHeadingBlock( pCCB );

	Out_IncludeOfFile( pCCB, "rpcunkcf.h", FALSE );
	//
	// Emit the hash includes.
	//
	OutputIncludes( pCCB );

	//
	// Emit the external variables needed.
	//

	pStream->NewLine();
	//
	// generate code for all com classes in the IDL file.
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_INHERITED_OBJECT_INTERFACE:
			case ID_CG_OBJECT_INTERFACE:
		
				if ( ((CG_OBJECT_INTERFACE*)pCG)->IsIUnknown() )
					pCCB->SetIUnknownCG( (CG_IUNKNOWN_OBJECT_INTERFACE *) pCG );
				else if ( !strcmp( pCG->GetSymName(), "IClassFactory" ) )
					pCCB->SetIClassfCG( (CG_OBJECT_INTERFACE *) pCG );
				break;

			case ID_CG_COM_CLASS:
				{
				CG_COM_CLASS	*	pComCG	= ( CG_COM_CLASS * ) pCG;
				
				pComCG->GenComClassIUnknown( pCCB );
				pComCG->GenComClassFactory( pCCB );
				break;
				}
			default:
				break;
			}
		}
	return CG_OK;
}


void
CG_PROXY_DEF_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "; this GENERATED ONCE file contains the contains the exports for the proxy dll  */" );
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB, ";" );
}

CG_STATUS
CG_PROXY_DEF_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM server file containing the class factory and class 
	implementation for the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	unsigned long index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

	EmitFileHeadingBlock( pCCB );

	//
	// Emit the external variables needed.
	//

	pStream->NewLine();
	//
	// generate code for all com classes in the IDL file.
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
#if 0
		switch(pCG->GetCGID())
			{
			case ID_CG_INHERITED_OBJECT_INTERFACE:
			case ID_CG_OBJECT_INTERFACE:
		
				if ( ((CG_OBJECT_INTERFACE*)pCG)->IsIUnknown() )
					pCCB->SetIUnknownCG( (CG_IUNKNOWN_OBJECT_INTERFACE *) pCG );
				else if ( !strcmp( pCG->GetSymName(), "IClassFactory" ) )
					pCCB->SetIClassfCG( (CG_OBJECT_INTERFACE *) pCG );
				break;

			case ID_CG_COM_CLASS:
				{
				CG_COM_CLASS	*	pComCG	= ( CG_COM_CLASS * ) pCG;
				
				pComCG->GenComClassIUnknown( pCCB );
				pComCG->GenComClassFactory( pCCB );
				break;
				}
			default:
				break;
			}
#endif
		}
	return CG_OK;
}


void
CG_DLL_SERVER_DEF_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "; this GENERATED ONCE file contains the contains the implementations of the exports for */" );
	pStream->NewLine();
	pStream->Write( "; the InprocServer32 " );
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB, ";" );
}

CG_STATUS
CG_DLL_SERVER_DEF_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM server file containing the class factory and class 
	implementation for the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	unsigned long 		index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

	EmitFileHeadingBlock( pCCB );

	//
	// Emit the external variables needed.
	//

	//
	// generate code for all com classes in the IDL file.
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_COM_SERVER_DLL:
				{				
				CG_COM_SERVER_DLL	*	pDllCG	= ( CG_COM_SERVER_DLL * ) pCG;
				
				pDllCG->GenDllDefFile( pCCB );
				
				break;
				}
			default:
				break;
			}
		}
	return CG_OK;
}


void
CG_DLL_SERVER_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "/* this ALWAYS GENERATED file contains the implementations of  */" );
	pStream->NewLine();
	pStream->Write( "/* the IUnknowns and the class factories */" ); 
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

CG_STATUS
CG_DLL_SERVER_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM server file containing the class factory and class 
	implementation for the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	unsigned long index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

	EmitFileHeadingBlock( pCCB );

	//
	// Emit the hash includes.
	//
	Out_IncludeOfFile( pCCB, "rpcunkcf.h", FALSE );
	
	pStream->NewLine();
	OutputIncludes( pCCB );

	//
	// Emit the external variables needed.
	//

	pStream->NewLine();
	//
	// generate code for all com classes in the IDL file.
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_COM_SERVER_DLL:
			case ID_CG_COM_SERVER_EXE:
				{				
				pCG->GenCode( pCCB );
				break;
				}
			default:
				break;
			}
		}
	return CG_OK;
}


void
CG_SERVER_REG_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

static STRING_BLOCK	RegHeader =
	{
	"#",
	"# This .reg file is recreated every time a dllserver or exeserver",
	"# is processed by MIDL.  User changes are preserved.",
	"#",
	"# the pathnames should be changed if the executables will not be",
	"# in the system directory",
	"#",
	0
	};

	pStream->Write("REGEDIT");
	
	pStream->NewLine();
	EmitStandardHeadingBlock( pCCB, "#" );
	
	pStream->WriteBlock( RegHeader );

}

CG_STATUS
CG_SERVER_REG_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM server file containing the class factory and class 
	implementation for the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	unsigned long 		index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

	//
	// Emit the external variables needed.
	//

	EmitFileHeadingBlock( pCCB );

	pStream->NewLine();

	//
	// generate code for all com classes in the IDL file.
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
#if 0
		switch(pCG->GetCGID())
			{
			case ID_CG_INHERITED_OBJECT_INTERFACE:
			case ID_CG_OBJECT_INTERFACE:
		
				if ( ((CG_OBJECT_INTERFACE*)pCG)->IsIUnknown() )
					pCCB->SetIUnknownCG( (CG_IUNKNOWN_OBJECT_INTERFACE *) pCG );
				else if ( !strcmp( pCG->GetSymName(), "IClassFactory" ) )
					pCCB->SetIClassfCG( (CG_OBJECT_INTERFACE *) pCG );
				break;

			case ID_CG_COM_CLASS:
				{
				CG_COM_CLASS	*	pComCG	= ( CG_COM_CLASS * ) pCG;
				
				pComCG->GenComClassIUnknown( pCCB );
				pComCG->GenComClassFactory( pCCB );
				break;
				}
			default:
				break;
			}
#endif
		}
	return CG_OK;
}


void
CG_COM_FILE::OutputIncludes(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	output an includes file list to the stream.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	char		Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
	char		Name[ _MAX_FNAME ];
	char		Ext[ _MAX_EXT ];
	ISTREAM	*	pStream		= pCCB->GetStream();
	MIDL_TOKEN	DelimiterToken( START_INCLUDES_TOKEN );

	RW_ISTREAM 	*	pOldStream	=	NULL;

	if ( pCCB->IsReparsingCurrentFile() )
		{
		MIDL_TOKEN			FoundToken;

		pOldStream = (RW_ISTREAM *) pStream;

		pOldStream->SaveToNextMidlToken( FoundToken );
		if ( FoundToken.GetTokenType() != START_INCLUDES_TOKEN )
			{
			assert( 0 );
			}
		}
	else
		pStream->NewLine();

	DelimiterToken.EmitToken( pStream );
	pStream->NewLine();

	if ( GetHeaderFileName() )
		{
		_splitpath( GetHeaderFileName(), NULL, NULL, Name, Ext );
		strcpy( Buffer, Name );
		strcat( Buffer, Ext );
		Out_IncludeOfFile( pCCB, Buffer, FALSE );
		}
	else
		{
		// Include the import files.
		OutputImportIncludes( pCCB );
		}

	pStream->NewLine(2);
	DelimiterToken.SetTokenType( END_INCLUDES_TOKEN );
	DelimiterToken.EmitToken( pStream );

	if ( pCCB->IsReparsingCurrentFile() )
		{
		MIDL_TOKEN			FoundToken;

		pOldStream->DiscardToNextMidlToken( FoundToken );
		if ( FoundToken.GetTokenType() != END_INCLUDES_TOKEN )
			{
			assert( 0 );
			}
		}

}


void
CG_EXE_SERVER_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "/* this ALWAYS GENERATED file contains support routines for the LocalServer32 */" ); 
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

CG_STATUS
CG_EXE_SERVER_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM server file containing the class factory and class 
	implementation for the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	unsigned long index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

	EmitFileHeadingBlock( pCCB );

	Out_IncludeOfFile( pCCB, "rpcunkcf.h", FALSE );
	//
	// Emit the hash includes.
	//
	OutputIncludes( pCCB );

	//
	// Emit the external variables needed.
	//

	pStream->NewLine();
	//
	// generate code for all com classes in the IDL file.
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_COM_SERVER_DLL:
			case ID_CG_COM_SERVER_EXE:
				{				
				pCG->GenCode( pCCB );
				break;
				}
			default:
				break;
			}
		}
	return CG_OK;
}


void
CG_EXE_SERVER_MAIN_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "/* this GENERATED ONCE file contains support routines for the LocalServer32 */" ); 
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

CG_STATUS
CG_EXE_SERVER_MAIN_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM server file containing the class factory and class 
	implementation for the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR			I;
	CG_NDR			*	pCG;
	unsigned long index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	ISTREAM 	Stream( GetFileName(), 4 );
	ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

	EmitFileHeadingBlock( pCCB );

	Out_IncludeOfFile( pCCB, "rpcunkcf.h", FALSE );
	//
	// Emit the hash includes.
	//
	OutputIncludes( pCCB );

	//
	// Emit the external variables needed.
	//

	pStream->NewLine();
	//
	// generate code for all com classes in the IDL file.
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
#if 0
		switch(pCG->GetCGID())
			{
			case ID_CG_INHERITED_OBJECT_INTERFACE:
			case ID_CG_OBJECT_INTERFACE:
		
				if ( ((CG_OBJECT_INTERFACE*)pCG)->IsIUnknown() )
					pCCB->SetIUnknownCG( (CG_IUNKNOWN_OBJECT_INTERFACE *) pCG );
				else if ( !strcmp( pCG->GetSymName(), "IClassFactory" ) )
					pCCB->SetIClassfCG( (CG_OBJECT_INTERFACE *) pCG );
				break;

			case ID_CG_COM_CLASS:
				{
				CG_COM_CLASS	*	pComCG	= ( CG_COM_CLASS * ) pCG;
				
				pComCG->GenComClassIUnknown( pCCB );
				pComCG->GenComClassFactory( pCCB );
				break;
				}
			default:
				break;
			}
#endif
		}
	return CG_OK;
}


void
CG_TEST_CLIENT_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "/* this GENERATED ONCE file contains the example test client for the interfaces in the COM class */" ); 
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

CG_STATUS
CG_TEST_CLIENT_FILE::GenCode(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

	Generate a COM test client file to create a COM object, and invoke all
	the methods of the COM classes defined in the IDL file.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	CG_OK	if all is well, error otherwise.
	
 Notes:

----------------------------------------------------------------------------*/
{
#if 0
	ITERATOR			I;
	CG_NDR			*	pCG;
	char		Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
	char		Drive[ _MAX_DRIVE ];
	char		Path[ _MAX_DIR ];
	char		Name[ _MAX_FNAME ];
	char		Ext[ _MAX_EXT ];
	ITERATOR	ProcList;
	ISTREAM *	pStream;
	unsigned long index = 0;

	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	pStream = new ISTREAM( (char *) GetFileName(), 4 );
	pCCB->SetStream(pStream);

	EmitFileHeadingBlock( pCCB );

	//
	// Emit the hash includes.
	//
	Out_IncludeOfFile( pCCB, "rpcproxy.h", FALSE );

	_splitpath( GetHeaderFileName(), Drive, Path, Name, Ext );
	strcpy( Buffer, Name );
	strcat( Buffer, Ext );
	Out_IncludeOfFile( pCCB, Buffer, FALSE );

    EmitFormatStringTypedefs( pCCB );

	//
	// Emit the external variables needed.
	//

	pStream->NewLine();

	//
	// Emit the format string extern declarations.  
	//
	Out_TypeFormatStringExtern( pCCB );
    Out_ProcFormatStringExtern( pCCB );
    Out_LocalTypeFormatStringExtern( pCCB );
    Out_LocalProcFormatStringExtern( pCCB );

    pCCB->ClearOptionalExternFlags();

	pStream->NewLine();

    pCCB->SetFileCG(this);

    //
    // Create a new format string object if it does not yet exist.
    //
    if ( !GetFormatString() )
    {
        SetFormatString(new FORMAT_STRING());
        SetLocalFormatString(new FORMAT_STRING());
    }
    pCCB->SetFormatString( GetFormatString() );

    if ( !GetProcFormatString() )
    {
        SetProcFormatString(new FORMAT_STRING());
        SetLocalProcFormatString(new FORMAT_STRING());
    }
    pCCB->SetProcFormatString( GetProcFormatString() );

	//
	// Send the message to the children to emit code.
	//

	//
	// generate code for all [object] interfaces in the IDL file.
	//

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_INTERFACE:
				break;
			case ID_CG_INHERITED_OBJECT_INTERFACE:
              //
                // Generate format string description for all procs.
                //
				((CG_INHERITED_OBJECT_INTERFACE *)pCG)->GenCode( pCCB );
				// make no code or tables for local interfaces
				if ( ((CG_INHERITED_OBJECT_INTERFACE*)pCG)->IsLocal() )
					break;
 
                //
                // Both of these do nothing right now.  4/25.
                //
				((CG_INHERITED_OBJECT_INTERFACE *)pCG)->
                        GenInterfaceProxy( pCCB, index );
				((CG_INHERITED_OBJECT_INTERFACE *)pCG)->
                        GenInterfaceStub( pCCB, index );
				break;
			case ID_CG_OBJECT_INTERFACE:
				// make no code or tables for local interfaces
				((CG_OBJECT_INTERFACE *)pCG)->GenCode( pCCB );
				if ( ((CG_OBJECT_INTERFACE*)pCG)->IsLocal() )
					break;
				((CG_OBJECT_INTERFACE *)pCG)->GenInterfaceProxy( pCCB, index );
				((CG_OBJECT_INTERFACE *)pCG)->GenInterfaceStub( pCCB, index );
				index++;   // index is index in stub/proxy buffer tables
				break;
			default:
				break;
			}
		}

    EmitFixupToFormatStringTypedefs( pCCB );

    pCCB->SetSkipFormatStreamGeneration( FALSE );
    pCCB->OutputMultipleInterfaceTables();

	Out_ProxyFileInfo(pCCB);

	UpdateDLLDataFile( pCCB );
#endif // 0	
	return CG_OK;
}


void
CG_HDR_FILE::OutputImportIncludes(
	CCB		*	pCCB)
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Generate the header file.

 Arguments:

 	pCCB	- The code gen controller block.
	
 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ITERATOR	*		pImpList	= GetImportList();
	node_file	*		pIFile;
	ISTREAM		*		pStream		= pCCB->GetStream();
	char		Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
	char		Drive[ _MAX_DRIVE ];
	char		Path[ _MAX_DIR ];
	char		Name[ _MAX_FNAME ];
	char		Ext[ _MAX_EXT ];

	if( pImpList && pImpList->NonNull() )
		{
		
		pStream->NewLine();
		pStream->Write( "/* header files for imported files */" );
		
		pImpList->Init();
		while( ITERATOR_GETNEXT( (*pImportList), pIFile ) )
			{
			pStream->NewLine();
			// if this was specified with ACF include, print out as is
			if ( pIFile->IsAcfInclude() )
				sprintf( Buffer, "#include \"%s\"", pIFile->GetSymName() );
			else if ( pIFile->HasComClasses() )
				{
				_splitpath( pIFile->GetSymName(), Drive, Path, Name, Ext );
				sprintf( Buffer, "#include \"%s_d.h\"", Name );
				}
			else
				{
				_splitpath( pIFile->GetSymName(), Drive, Path, Name, Ext );
				sprintf( Buffer, "#include \"%s.h\"", Name );
				}
			pStream->Write( Buffer );
			}
		
		pStream->NewLine();
		}
}


void
CG_HDR_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	pStream->Write( "/* this ALWAYS GENERATED file contains the definitions for the interfaces */" ); 
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

void OutputInterfaceForwards(
	ISTREAM  * pStream,
	CG_ITERATOR & I )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Generate the forwards section of the header file.

 Arguments:

 	pCCB	- The code gen controller block.
	I		- an iterator for the nodes to process
	
 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_INTERFACE *	pCG;
	char *			pszInterfaceName;

	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_INTERFACE:
			case ID_CG_INHERITED_OBJECT_INTERFACE:
				break;

			case ID_CG_OBJECT_INTERFACE:
			case ID_CG_DISPINTERFACE:
				pszInterfaceName = pCG->GetType()->GetSymName();

				pStream->NewLine();

				// put out the interface guards
				pStream->Write("\n#ifndef __");
				pStream->Write( pszInterfaceName );
				pStream->Write( "_FWD_DEFINED__\n" );

				pStream->Write( "#define __");
				pStream->Write( pszInterfaceName );
				pStream->Write( "_FWD_DEFINED__\n" );

				// put out the forward definition
				pStream->Write("typedef interface ");
				pStream->Write(pszInterfaceName);
				pStream->Write(' ');
				pStream->Write(pszInterfaceName);
				pStream->Write(';');

				// put out the trailing interface guard
				pStream->Write( "\n#endif \t/* __");
				pStream->Write( pszInterfaceName );
				pStream->Write( "_FWD_DEFINED__ */\n" );

				break;

			case ID_CG_LIBRARY:
				{
				CG_ITERATOR	Inner;
				if ( pCG->GetMembers( Inner ) )
				    {
					OutputInterfaceForwards( pStream, Inner );
				    }

				break;
				}
			default:
				break;
			}
		}
}


CG_STATUS
CG_HDR_FILE::GenCode(
	CCB		*	pCCB)
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Generate the header file.

 Arguments:

 	pCCB	- The code gen controller block.
	
 Return Value:

 	CG_OK	if all is well.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		Stream( GetFileName(), 4 );
	ISTREAM	*	pStream	= pCCB->SetStream( &Stream );
	CG_ITERATOR	I;
	CG_INTERFACE *	pCG;
	char *			pszInterfaceName;
	BOOL			fHasPickle	= FALSE;
	BOOL			fHasObject	= FALSE;
	char		Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
	char		Drive[ _MAX_DRIVE ];
	char		Path[ _MAX_DIR ];
	char		Name[ _MAX_FNAME ];
	char		Ext[ _MAX_EXT ];



	if( !GetMembers( I ) )
		{
		return CG_OK;
		}

	EmitFileHeadingBlock( pCCB );
	
	// Include standard files.

	pStream->Write( "#include \"rpc.h\"\n#include \"rpcndr.h\"\n" );

	// If there is at least one pickle interface, emit the include
	// of midles.h

    while( ITERATOR_GETNEXT( I, pCG ) )
	    {
        if ( pCG->HasPicklingStuff() )
            {
            fHasPickle = TRUE;
            }
		if ( pCG->IsObject() )
			{
			fHasObject = TRUE;
			}
	    }

	if ( fHasPickle )
		{
        pStream->Write( "#include \"midles.h\"\n" );
		}

	if ( fHasObject )
		{
		pStream->Write( "#ifndef COM_NO_WINDOWS_H\n");
        pStream->Write( "#include \"windows.h\"\n#include \"ole2.h\"\n" );
		pStream->Write( "#endif /*COM_NO_WINDOWS_H*/\n");
		}

	// extract the name and the extension to create the ifdefs

	_splitpath( GetFileName(), Drive, Path, Name, Ext );

	// Write out the #ifndefs and #defines
	pStream->NewLine();
	sprintf( Buffer,
			 "#ifndef __%s_%s__\n#define __%s_%s__",
			 Name,
			 &Ext[1],			// skip the "." in the extension
			 Name,
			 &Ext[1]			// skip the "." in the extension
		   );

	pStream->Write( Buffer );

	// Write out the cplusplus guard.

	pStream->NewLine( 2 );

	pStream->Write( "#ifdef __cplusplus\nextern \"C\"{\n#endif " );
	pStream->NewLine();

	//Generate forward declarations for object interfaces.
	pStream->NewLine();
	pStream->Write("/* Forward Declarations */ ");
	I.Init();
	OutputInterfaceForwards( pStream, I );
	pStream->NewLine();

	// Include the import files.
	OutputImportIncludes( pCCB );

	pStream->NewLine();

	pStream->Write(
		 "void __RPC_FAR * __RPC_USER MIDL_user_allocate(size_t);" );
	pStream->NewLine();
	pStream->Write(
		 "void __RPC_USER MIDL_user_free( void __RPC_FAR * ); " );

	pStream->NewLine();

	//
	// For all interfaces in this file, generate code.
	//

	I.Init();
	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_INTERFACE:
			case ID_CG_OBJECT_INTERFACE:
			case ID_CG_LIBRARY:
				pCG->GenHeader( pCCB );
			case ID_CG_COM_CLASS:
			case ID_CG_INHERITED_OBJECT_INTERFACE:
			default:
				break;
			}
		}

	// put out all the prototypes that are only needed once
	OutputMultipleInterfacePrototypes( pCCB );

	// print out the closing endifs.
	// first the cplusplus stuff.

	pStream->Write( "#ifdef __cplusplus\n}\n#endif\n" );
	
	// The endif for the file name ifndef

	pStream->NewLine();

	pStream->Write( "#endif" );
	pStream->NewLine();
	pStream->Close();

	return CG_OK;
}

void
CG_HDR_FILE::OutputMultipleInterfacePrototypes(
	CCB		*	pCCB )

{
	ITERATOR		I;
	ISTREAM		*	pStream		= pCCB->GetStream();

	pStream->NewLine();
	pStream->Write("/* Additional Prototypes for ALL interfaces */");
	pStream->NewLine();

    if( pCCB->GetListOfGenHdlTypes( I ) )
        {
        Out_GenHdlPrototypes( pCCB, I );
        }

    if( pCCB->GetListOfCtxtHdlTypes( I ) )
        {
        Out_CtxtHdlPrototypes( pCCB, I );
        }

    if( pCCB->GetListOfPresentedTypes( I ) )
        {
        Out_TransmitAsPrototypes( pCCB, I );
        }

    if( pCCB->GetListOfRepAsWireTypes( I ) )
        {
        Out_RepAsPrototypes( pCCB, I );
        }

    if( pCCB->GetQuadrupleDictionary()->GetListOfItems( I ) )
        {
        Out_UserMarshalPrototypes( pCCB, I );
        }

    if( pCCB->GetListOfTypeAlignSizeTypes( I ) )
        {
        Out_TypeAlignSizePrototypes( pCCB, I );
        }

    if( pCCB->GetListOfTypeEncodeTypes( I ) )
        {
        Out_TypeEncodePrototypes( pCCB, I );
        }

    if( pCCB->GetListOfTypeDecodeTypes( I ) )
        {
        Out_TypeDecodePrototypes( pCCB, I );
        }

    if( pCCB->GetListOfTypeFreeTypes( I ) )
        {
        Out_TypeFreePrototypes( pCCB, I );
        }

    if ( pCCB->GetListOfCallAsRoutines( I ) )
        {
        Out_CallAsProxyPrototypes( pCCB, I );
        }

	if ( pCCB->GetListOfCallAsRoutines( I ) )
		{
		Out_CallAsServerPrototypes( pCCB, I );
		}

    if( pCCB->GetListOfNotifyRoutines( I ) )
        {
        Out_NotifyPrototypes( pCCB, I, FALSE );  // without flags
        }

    if( pCCB->GetListOfNotifyFlagRoutines( I ) )
        {
        Out_NotifyPrototypes( pCCB, I, TRUE );   // with flags
        }

	pStream->NewLine();
	pStream->Write("/* end of Additional Prototypes */");
	pStream->NewLine( 2 );

}


void
CG_COM_HDR_FILE::EmitFileHeadingBlock(
	CCB	*	pCCB )
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Emit block comment file heading.

 Arguments:
	
 	pCCB	- a pointer to the code generation control block.

 Return Value:

 	none.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	CheckForHeadingToken( pCCB );

	pStream->Write( "/* this USER-ALTERABLE file contains the definition of COM classes */" ); 
	pStream->NewLine(2);

	EmitStandardHeadingBlock( pCCB );
}

void
CG_COM_HDR_FILE::EmitIncludesBlock(
	CCB		*	pCCB)
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Generate the header file includes block.

 Arguments:

 	pCCB	- The code gen controller block.
	
 Return Value:

 	CG_OK	if all is well.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();
	char		Buffer[ _MAX_DRIVE + _MAX_DIR + _MAX_FNAME + _MAX_EXT + 1 ];
	char		Drive[ _MAX_DRIVE ];
	char		Path[ _MAX_DIR ];
	char		Name[ _MAX_FNAME ];
	char		Ext[ _MAX_EXT ];
	BOOL		fReParse	= pCCB->IsReparsingCurrentFile();
	MIDL_TOKEN	Token( START_INCLUDES_TOKEN );

	if ( fReParse )
		{
		MIDL_TOKEN			FoundToken;

		((RW_ISTREAM *) pStream)->SaveToNextMidlToken( FoundToken );
		if ( FoundToken.GetTokenType() != START_INCLUDES_TOKEN )
			{
			assert(!"expecting includes token" );
			}
		}
	else
		pStream->NewLine();

	pStream->EmitToken( Token );

	pStream->NewLine();
	pStream->Write( "/* the standard includes */" );

	// Include standard files.

	pStream->NewLine();
	pStream->Write( "#include \"rpc.h\"\n#include \"rpcndr.h\"\n#include \"rpcunkcf.h\"\n" );


	pStream->NewLine();
	pStream->Write( "#ifndef COM_NO_WINDOWS_H\n");
    pStream->Write( "#include \"windows.h\"\n#include \"ole2.h\"\n" );
	pStream->Write( "#endif /*COM_NO_WINDOWS_H*/\n");

	// tbd - do the include of the plain header

	// extract the name and the extension to create the ifdefs

	_splitpath( GetFileName(), Drive, Path, Name, Ext );

	// Write out the #ifndefs and #defines
	pStream->NewLine();
	sprintf( Buffer,
			 "#ifndef __%s_%s__\n#define __%s_%s__",
			 Name,
			 &Ext[1],			// skip the "." in the extension
			 Name,
			 &Ext[1]			// skip the "." in the extension
		   );

	pStream->Write( Buffer );

	if ( GetPlainHdrName() )
		{
		_splitpath( GetPlainHdrName(), Drive, Path, Name, Ext );

		pStream->NewLine(2);
		pStream->Write( "#include \"" );
		pStream->Write( Name );
		if ( Ext[0] ) 
			{
			pStream->Write( Ext );
			}
		pStream->Write( "\"" );
		pStream->NewLine();
		}
	else
		{
		pStream->NewLine(2);
		// Include the import files.
		OutputImportIncludes( pCCB );
		}

	if ( fReParse )
		{
		MIDL_TOKEN			FoundToken;

		((RW_ISTREAM *) pStream)->DiscardToNextMidlToken( FoundToken );
		if ( FoundToken.GetTokenType() != END_INCLUDES_TOKEN )
			{
			assert(!"expecting includes token" );
			}
		}
	
	pStream->NewLine();
	Token.SetTokenType( END_INCLUDES_TOKEN );
	pStream->EmitToken( Token );
	pStream->NewLine( ( fReParse ) ? 1 : 2 );


}

void
CG_COM_HDR_FILE::EmitClosingBlock(
	CCB		*	pCCB)
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Generate the header file includes block.

 Arguments:

 	pCCB	- The code gen controller block.
	
 Return Value:

 	CG_OK	if all is well.
	
 Notes:

----------------------------------------------------------------------------*/
{
	ISTREAM		*	pStream	= pCCB->GetStream();

	// print out the closing endifs.
	// The endif for the file name ifndef

	pStream->NewLine();

	pStream->Write( "#endif" );
	pStream->NewLine();

}


CG_STATUS
CG_COM_HDR_FILE::GenCode(
	CCB		*	pCCB)
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 Routine Description:

 	Generate the header file.

 Arguments:

 	pCCB	- The code gen controller block.
	
 Return Value:

 	CG_OK	if all is well.
	
 Notes:

----------------------------------------------------------------------------*/
{
	CG_ITERATOR	I;
	CG_INTERFACE *	pCG;
	BOOL			fHasPlainHeader	= FALSE;


	RW_ISTREAM 		Stream( GetFileName(), 4 );
	RW_ISTREAM *	pStream		= &Stream;

	pCCB->SetStream(pStream);

	if ( Stream.IsTempStream() )
		{
		pCCB->SetReparsingCurrentFile( TRUE );
		}


	EmitFileHeadingBlock( pCCB );

	EmitIncludesBlock( pCCB );

	//
	// For all com classes in this file, generate code.
	//

	GetMembers( I );

	I.Init();
	while( ITERATOR_GETNEXT( I, pCG ) )
		{
		switch(pCG->GetCGID())
			{
			case ID_CG_COM_CLASS:
				pCG->GenHeader( pCCB );
			case ID_CG_OBJECT_INTERFACE:
			case ID_CG_INTERFACE:
			case ID_CG_INHERITED_OBJECT_INTERFACE:
			default:
				break;
			}
		}

	EmitClosingBlock( pCCB );

	// propogate changes from the tmpfile, if any
	Stream.UpdateOriginalFile();

	pCCB->SetReparsingCurrentFile( FALSE );

	return CG_OK;
}