/* utl2idl.cpp
*
* UTL2IDL Tool translates the Service Description of a device to IDL interface.
*
* Owner: Guru
*
* Copyright 1986-2000 Microsoft Corporation, All Rights Reserved.
*/

#include "pch.h"
#pragma hdrstop

#include <msxml2.h>

#include "stdio.h"
#include "Rpcdce.h"

#define MAXSTRLEN 2048
#define MAXSTATEVARIABLES 1024
#define MAXALLOWEDRETVAL  1
#define XMLSTATEVARIABLETAG  "stateVariable"

#define CHECKHR(x) {hr = x; if (FAILED(hr)) {callAbort();}}
#define CHECKHRTRACE(x,ERRORMSG) { hr = x ; if ( FAILED(hr) ) { TraceError(ERRORMSG,hr);/*HrPrintError(ERRORMSG,hr);*/ return hr ;} }
#define CHECKNULL(x,ERRORMSG) { if ( x == NULL ) { hr = E_FAIL; TraceError(ERRORMSG,hr);/*HrPrintError(ERRORMSG,hr);*/ return hr ; }}

#define SAFERELEASE(p) {if (p) {(p)->Release(); p = NULL;}}

// struct definition for XML to IDL DataType mapping
typedef struct {
        BSTR m_XMLDataType ;
        BSTR m_IDLDataType ;
} DTMAPPING ;

// struct definition for maintaing State Variables and its DataType
typedef struct {
        BSTR m_StVarName ;
        BSTR m_StVarType ;
} STATEVARIABLE ;

typedef STATEVARIABLE* PSTATEVARIABLE;

typedef struct {
    STATEVARIABLE **rgStateVariable ;
    long cStVars ;
} STATEVARIABLEINFO ;


STATEVARIABLEINFO g_StateVariableInfo ;

PCWSTR g_pszOutFileName = NULL;
PCWSTR g_pszInputFileName = NULL ;
HANDLE g_hOutFileHandle = NULL;
char g_pszdumpStr[MAXSTRLEN];

unsigned long g_methodID = 0 ;

// XML to IDL DataType Mapping
// XML datatypes are sorted in ascending order

static CONST DTMAPPING g_dataTypeConvtTable[] =
{
    {OLESTR("bin.base64"),OLESTR("SAFEARRAY")}, // check this data type
    {OLESTR("bin.hex"),OLESTR("SAFEARRAY")},
    {OLESTR("boolean"),OLESTR("VARIANT_BOOL")},
    {OLESTR("char"),OLESTR("wchar_t")},
    {OLESTR("date"),OLESTR("DATE")},
    {OLESTR("dateTime"),OLESTR("DATE")},
    {OLESTR("dateTime.tz"),OLESTR("DATE")},
    {OLESTR("fixed.14.4"),OLESTR("CY")},
    {OLESTR("float"),OLESTR("float")},
    {OLESTR("i1"),OLESTR("char")},
    {OLESTR("i2"),OLESTR("short")},
    {OLESTR("i4"),OLESTR("long")},
    {OLESTR("int"),OLESTR("long")},
    {OLESTR("number"),OLESTR("BSTR")},
    {OLESTR("r4"),OLESTR("float")},
    {OLESTR("r8"),OLESTR("double")},
    {OLESTR("string"),OLESTR("BSTR")},
    {OLESTR("time"),OLESTR("DATE")},
    {OLESTR("time.tz"),OLESTR("DATE")},
    {OLESTR("ui1"),OLESTR("unsigned char")},
    {OLESTR("ui2"),OLESTR("unsigned short")},
    {OLESTR("ui4"),OLESTR("unsigned long")},
    {OLESTR("uri"),OLESTR("BSTR")},
    {OLESTR("uuid"),OLESTR("BSTR")}
} ;

HRESULT HrInit(IXMLDOMDocument *pXDMDoc)
{
	HRESULT hr = S_OK;
	long cNumStateVariables = 0 ;
	BSTR bstrStVar = NULL;
	IXMLDOMNodeList *pXDNLStVars = NULL;

	bstrStVar = SysAllocString(OLESTR("stateVariable"));

	if( bstrStVar )
	{
		CHECKHRTRACE(pXDMDoc->getElementsByTagName(bstrStVar,&pXDNLStVars),"HrInit() :" );
    	CHECKHRTRACE(pXDNLStVars->get_length(&cNumStateVariables),"HrInit() : get_length() Failed");
		g_StateVariableInfo.rgStateVariable = new PSTATEVARIABLE[cNumStateVariables];
    	g_StateVariableInfo.cStVars = 0 ;
	}
    else 
    	hr = E_FAIL;
    
	return hr;
}

/*
* Function:    HrPrintError()
*
* Description:  Helper function to print errors
*
* Arguments:  [in] char* - error msg
*             [in] HRESULT
*
* Returns:    HRESULT
*/
HRESULT HrPrintError(char *err, HRESULT hr ) 
{
	fprintf(stderr,"Error - %s\n",err);
    return hr ;
}

// Aborts the program
void callAbort()
{

	DWORD pLen = 0;

    printf("ERROR: Aborting !!\n");
    sprintf(g_pszdumpStr,"// UTL2IDL generation failed !!\r\n");
    WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL);
    CloseHandle(g_hOutFileHandle);
    CoUninitialize();
    exit(0);
}

// Error report helper function
HRESULT HrReportError(IXMLDOMParseError *pXMLError)
{
    long line, linePos;
    LONG errorCode;
    BSTR pBURL, pBReason;
    HRESULT hr;

    CHECKHR(pXMLError->get_line(&line));
    CHECKHR(pXMLError->get_linepos(&linePos));
    CHECKHR(pXMLError->get_errorCode(&errorCode));
    CHECKHR(pXMLError->get_url(&pBURL));
    CHECKHR(pXMLError->get_reason(&pBReason));

    fprintf(stderr, "%S", pBReason);
    if (line > 0)
    {
        fprintf(stderr, "Error on line %d, position %d in \"%S\".\n",
              line, linePos, pBURL);
    }

    SysFreeString(pBURL);
    SysFreeString(pBReason);

    return E_FAIL;
}


HRESULT HrGetElementValue(IXMLDOMNode *pXDNNode , VARIANT **vNodeValue ) 
{
    IXMLDOMNode *pXDNCldNode ;

    HRESULT hr = S_OK ;

    CHECKHRTRACE(pXDNNode->get_firstChild(&pXDNCldNode),"HrGetElementValue() : failed");
    CHECKHRTRACE(pXDNCldNode->get_nodeValue(*vNodeValue),"HrGetElementValue() : failed");

    return hr ;
}

HRESULT HrGenEnumTags(IXMLDOMDocument *pXDMDoc, PCWSTR pszEnumName) 
{
        HRESULT hr = S_OK ;
        IXMLDOMNodeList *pXDNLStVarTable = NULL ;
        IXMLDOMNode *pXDNStVarNode = NULL ;
        IXMLDOMNodeList *pXDNLActionList = NULL ;
        IXMLDOMNode *pXDNActionListNode = NULL ;

        IXMLDOMNodeList *pXDNLAllStVars = NULL ;
        IXMLDOMNode *pXDNStVar = NULL ;
        long nLen = 0 ;
        BSTR pszbStVarName = SysAllocString(OLESTR("serviceStateTable"));

        IXMLDOMNodeList *pXDNLAllActions = NULL ;
        IXMLDOMNode *pXDNAction = NULL ;
        BSTR pszActionName = SysAllocString(OLESTR("actionList"));
       
        BOOL first = true ;
        DWORD pLen = 0 ;
        WCHAR *pszwTmpName = new WCHAR[wcslen(pszEnumName) + 1];
        if ( pszwTmpName == NULL )
                callAbort();
        wcscpy(pszwTmpName,pszEnumName);

        CHECKHRTRACE(pXDMDoc->getElementsByTagName(pszbStVarName,&pXDNLStVarTable),"HrGenEnumTags() : failed");
        CHECKHRTRACE(pXDNLStVarTable->get_item(0,&pXDNStVarNode),"HrGenEnumTags() : failed");
        CHECKNULL(pXDNStVarNode,"HrGenEnumTags() : failed");

        CHECKHRTRACE(pXDNStVarNode->selectNodes(OLESTR("stateVariable/name"),&pXDNLAllStVars),"HrGenEnumTags() : failed");
        CHECKHRTRACE(pXDNLAllStVars->get_length(&nLen),"HrGenEnumTags() : failed");

        sprintf(g_pszdumpStr,"typedef [v1_enum] enum %S_DISPIDS\r\n{\r\n\t",_wcsupr((wchar_t *)pszwTmpName));
        CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenEnumTags() : Write to File failed");

        for( int i = 0 ; i < nLen ; i++ ) 
        {
         	VARIANT vNodeName ;
            VARIANT *pvName = NULL ;
            VariantInit(&vNodeName);
            pvName = &vNodeName ;

            CHECKHRTRACE(pXDNLAllStVars->get_item(i,&pXDNStVar),"HrGenEnumTags() : failed");
            CHECKHRTRACE(HrGetElementValue(pXDNStVar,&pvName),"HrGenEnumTags() : failed");

            sprintf(g_pszdumpStr," DISPID_%S",_wcsupr(V_BSTR(&vNodeName)));
            CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenEnumTags() : Write to File failed");
            if ( first ) 
            {
            	sprintf(g_pszdumpStr," = 1");
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenEnumTags() : Write to File failed");
                first = false ;
            }
            if ( i < nLen-1 ) 
            {
            	sprintf(g_pszdumpStr,",\r\n\t");
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenEnumTags() : Write to File failed");
            }
            VariantClear(&vNodeName);
        }

	    CHECKHRTRACE(pXDMDoc->getElementsByTagName(pszActionName,&pXDNLActionList),"HrGenEnumTags() : failed");
        CHECKHRTRACE(pXDNLActionList->get_item(0,&pXDNActionListNode),"HrGenEnumTags() : failed");
        nLen = 0 ;
        if ( pXDNActionListNode ) 
        {
        	CHECKNULL(pXDNActionListNode,"HrGenEnumTags() : failed");
        	CHECKHRTRACE(pXDNActionListNode->selectNodes(OLESTR("action/name"),&pXDNLAllActions),"HrGenEnumTags() : 4 failed");
           	CHECKHRTRACE(pXDNLAllActions->get_length(&nLen),"HrGenEnumTags() : failed");
        }
        if ( nLen ) 
        {
        	sprintf(g_pszdumpStr,",\r\n\t");
            CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenEnumTags() : Write to File failed");
        }
        for( int i = 0 ; i < nLen ; i++ ) 
        {
            VARIANT vActionName ;
            VARIANT *pvActName = NULL ;
            VariantInit(&vActionName);
            pvActName = &vActionName;

            CHECKHRTRACE(pXDNLAllActions->get_item(i,&pXDNAction),"HrGenEnumTags() : failed");
            CHECKHRTRACE(HrGetElementValue(pXDNAction,&pvActName),"HrGenEnumTags() : failed");

            sprintf(g_pszdumpStr," DISPID_%S",_wcsupr(V_BSTR(&vActionName)));
            CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenEnumTags() : Write to File failed");
            if ( first ) 
            {
            	sprintf(g_pszdumpStr," = 1");
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenEnumTags() : Write to File failed");
                first = false ;
            }
            if ( i < nLen-1 ) 
            {
            	sprintf(g_pszdumpStr,",\r\n\t");
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenEnumTags() : Write to File failed");
            }
            VariantClear(&vActionName);
        }
        sprintf(g_pszdumpStr,"\r\n\r\n} %S_DISPIDS;\r\n\r\n",_wcsupr((wchar_t *)pszwTmpName));
        CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenEnumTags() : Write to File failed");
       
        delete pszwTmpName ;
        SysFreeString(pszActionName);
        SysFreeString(pszbStVarName);

        return hr ;
}


/*
* Function:    HrgenGUIDHDR()
*
* Description:  Generates the IDL interface Header
*
* Arguments:  [in] PCWSTR - Help String for the interface
*
* Returns:    HRESULT
*/
HRESULT HrgenGUIDHDR(PCWSTR pszHelpStr, BOOL fDual) {
        HRESULT hr = S_OK ;
        UUID pUUID ;
        unsigned char *arUUID ;
        DWORD pLen = 0 ;
        RPC_STATUS status ;

        status = UuidCreate(&pUUID);
        if ( status != RPC_S_OK )
                callAbort();
        status = UuidToString(&pUUID,(unsigned short **)&arUUID);
        if ( status != RPC_S_OK )
                callAbort();

        sprintf(g_pszdumpStr,"[\r\n\t uuid(%S),\r\n\t %S,\r\n\t pointer_default(unique)\r\n]\r\n",arUUID,(fDual)?OLESTR("dual"):OLESTR("oleautomation"));
        CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrgenGUIDHDR() : Write to File failed");

        RpcStringFree((unsigned short **)&arUUID);
        return hr ;
}

/*
* Function:    HrCheckLoad()
*
* Description:  Cheks if the XML document is loaded successfully
*
* Arguments:  [in] IXMLDOMDocument* - XML document handle
*
* Returns:    HRESULT
*/
HRESULT HrCheckLoad(IXMLDOMDocument* pXDMDoc)
{
    IXMLDOMParseError  *pXMLError = NULL;
    LONG errorCode = E_FAIL;
    HRESULT hr;

    CHECKHR(pXDMDoc->get_parseError(&pXMLError));
    CHECKHR(pXMLError->get_errorCode(&errorCode));
    if (errorCode != 0)
    {
        hr = HrReportError(pXMLError);
        SAFERELEASE(pXMLError);
    }
    else
    {
        fprintf(stderr, "XML document loaded successfully\n");
    }

        SAFERELEASE(pXMLError);
    return errorCode;
}

/*
* Function:    HrLoadDocument()
*
* Description:  Loads XML Document
*
* Arguments:  [in] IXMLDOMDocument* - XML document handle
*             [in] BSTR  - the location of XML file
*
* Returns:    HRESULT
*/
HRESULT HrLoadDocument(IXMLDOMDocument *pXDMDoc, BSTR pBURL)
{
    VARIANT         vURL;
    VARIANT_BOOL    vb;
    HRESULT         hr;

    CHECKHR(pXDMDoc->put_async(VARIANT_FALSE));

    // Load xml document from the given URL or file path
    VariantInit(&vURL);
    vURL.vt = VT_BSTR;
    V_BSTR(&vURL) = pBURL;
    CHECKHR(pXDMDoc->load(vURL, &vb));
    CHECKHR(HrCheckLoad(pXDMDoc));

    return hr;
}

/*
* Function:    getRelatedDataType()
*
* Description:  The data types of the action arguments is specified in terms of its related state variable
*             This function gets the data type of the action argument from the related state variable
*
* Arguments:   [in] BSTR  - related state variable
*
* Returns:    [retval] BSTR - data type of the state variable
*                   NULL if there is no corresponding state variable
*/
BSTR getRelatedDataType(BSTR relatedStateVariable ) 
{
	for(int i = 0 ; i < g_StateVariableInfo.cStVars ; i++ ) 
	{ 
    	if( wcscmp(relatedStateVariable,g_StateVariableInfo.rgStateVariable[i]->m_StVarName) == 0 )
        	return SysAllocString(g_StateVariableInfo.rgStateVariable[i]->m_StVarType);
    }
    return NULL ;
}

/*
* Function:    getIDLDataType()
*
* Description:  This functions maps the XML data type to the equivalent IDL data type
*
* Arguments:   [in] BSTR  - XML data type
*
* Returns:    [retval] BSTR - IDL data type
*                   NULL - if the XML data type is invalid
*/
BSTR getIDLDataType(BSTR xmlDataType) 
{
    CONST int nSize = celems(g_dataTypeConvtTable);
    int i ;

    for( i = 0 ; i < nSize ; i++ ) 
    {  
    	if ( _wcsicmp(xmlDataType , g_dataTypeConvtTable[i].m_XMLDataType) == 0 )
        	return g_dataTypeConvtTable[i].m_IDLDataType ;
    }
    return NULL ;
}

// prints the command line usage
void PrintUsage(PCWSTR exe)
{
    fprintf(stderr, "\n\nUsage: %S [<options>] inputfilename [outputfilename] \n",exe);
        fprintf(stderr, "\nOptions are:\n");
        fprintf(stderr,"-i InterfaceName  ..... Input interface name for generating IDL interface\n");
        fprintf(stderr,"-d               ..... Generate dual interface\n");
        fprintf(stderr,"-h HelpString     ..... Input Help String\n\n");
        exit(0);
}

// input file assumed to have extension !!
// if PATH is specified, again prun it !!

// truncates the extension from the input string and creates a new truncated string
WCHAR* PrunFileExt(PCWSTR fileName ) 
{
        WCHAR *rgTmpName = NULL ;
        WCHAR *pFileName = NULL ;

        rgTmpName = new WCHAR[wcslen(fileName)+10] ; // +10 -just in case the file doesn't have extension and we are appending some ext !!
        if ( rgTmpName == NULL )
                callAbort();
        pFileName = wcsrchr(fileName,'\\');

        if ( pFileName == NULL )
        {
        	wcscpy(rgTmpName,fileName);
            pFileName = wcsrchr(rgTmpName,'.');
            if ( pFileName )
            	*pFileName = NULL ;
        }
        else
        {
            wcscpy(rgTmpName,pFileName+1);
            pFileName = wcsrchr(rgTmpName,'.');
            if ( pFileName )
            	*pFileName = NULL ;
        }

        return rgTmpName ;
}

void ValidateString(WCHAR *fileName) 
{
	int nLen ;
	int i;
    nLen = wcslen(fileName);

    for( i=0; i < nLen ; i++ ) 
    {
		switch(fileName[i])
		{
			case '-':
			case '!':
			case '@':
			case '#':
			case '$':
			case '%':
			case '^':
			case '&':
			case '*':
			case '+':
			case ' ':
			case '(':
			case ')':
				fileName[i] = '_' ;
				break;
			default:
				;
		}
    }
    
}
/*
* Function:    HrGenStateVariableIDLFn()
*
* Description:  Generates the propget IDL function for the state variable
*
* Arguments:  [in] IXMLDOMNode* - state variable node
*
* Returns:    HRESULT
*/
HRESULT HrGenStateVariableIDLFn(IXMLDOMNode *pXDNStVar ) 
{
    HRESULT hr = S_OK ;
    VARIANT vName, vDataType ;

    IXMLDOMNodeList *pXDNLchildNodes = NULL  ;
    IXMLDOMNode *pXDNStVarTags= NULL ;
    IXMLDOMNode *pXDNStVarData = NULL ;

    BSTR pszbName = SysAllocString(OLESTR("name"));
    BSTR pszbDataType = SysAllocString(OLESTR("dataType"));
    BSTR pszbNodeName ;
    long lLength ;
    DWORD pLen = 0 ;

    VariantInit(&vName);
    VariantInit(&vDataType);

    CHECKHRTRACE(pXDNStVar->get_childNodes(&pXDNLchildNodes),"HrGenStateVariableFn() - Failed");
    CHECKHRTRACE(pXDNLchildNodes->get_length(&lLength),"HrGenStateVariableFn() - Failed");

    for(int i = 0 ; i < lLength ; i++ ) 
    {
    	CHECKHRTRACE(pXDNLchildNodes->get_item(i,&pXDNStVarTags),"HrGenStateVariableFn() - Failed") ;
        CHECKHRTRACE(pXDNStVarTags->get_firstChild(&pXDNStVarData),"HrGenStateVariableFn() - Failed") ;
        //CHECKNULL(pXDNStVarData,"HrGenStateVariableFn() - XML DataValue Missing");
        CHECKHRTRACE(pXDNStVarTags->get_nodeName(&pszbNodeName), "HrGenStateVariableFn() - Failed");

        if ( wcscmp(pszbNodeName,pszbName) == 0 )
        { // TAGS are case sensitive !!
        	CHECKNULL(pXDNStVarData,"HrGenStateVariableFn() - XML DataValue Missing");
            CHECKHRTRACE(pXDNStVarData->get_nodeValue(&vName),"HrGenStateVariableFn() - Failed");
        }
        else if ( wcscmp(pszbNodeName,pszbDataType) == 0 )
        {
        	CHECKNULL(pXDNStVarData,"HrGenStateVariableFn() - XML DataValue Missing");
            CHECKHRTRACE(pXDNStVarData->get_nodeValue(&vDataType),"HrGenStateVariableFn() - Failed");
        }
        SysFreeString(pszbNodeName);
    }

    BSTR pszbIDLDataType = getIDLDataType(V_BSTR(&vDataType));
    CHECKNULL(pszbIDLDataType,"HrGenStateVariable() : INVALID Data Type");
    g_StateVariableInfo.rgStateVariable[g_StateVariableInfo.cStVars] = new STATEVARIABLE ; // check for error
    CHECKNULL(g_StateVariableInfo.rgStateVariable[g_StateVariableInfo.cStVars],"HrGenStateVariable() : STATEVARIABLE Allocation Failed");
    g_StateVariableInfo.rgStateVariable[g_StateVariableInfo.cStVars]->m_StVarName = SysAllocString(V_BSTR(&vName));
    g_StateVariableInfo.rgStateVariable[g_StateVariableInfo.cStVars]->m_StVarType = SysAllocString(pszbIDLDataType);

    g_StateVariableInfo.cStVars++ ;

    WCHAR *pszwTmp = new WCHAR[wcslen(V_BSTR(&vName))+1] ;
    if ( pszwTmp == NULL )
    	callAbort();
    wcscpy(pszwTmp,V_BSTR(&vName));
    sprintf(g_pszdumpStr,"\t[propget, id(DISPID_%S), helpstring(\"Property %S\")]\r\n\tHRESULT %S(\r\n\t\t[out, retval] %S *p%S);\r\n\r\n",_wcsupr(pszwTmp),V_BSTR(&vName),V_BSTR(&vName),/*V_BSTR(&vDataType)*/pszbIDLDataType , V_BSTR(&vName));
    CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"Write to File failed");

    delete pszwTmp ;
    g_methodID++;
    VariantClear(&vName);
    VariantClear(&vDataType);

    return hr ;
}

/*
* Function:    HrProcessStateVariables()
*
* Description:  Process all the state variables form the XML document
*
* Arguments:  [in] IXMLDOMDocument* - Service Description XML document
*
* Returns:    HRESULT
*/
HRESULT HrProcessStateVariables(IXMLDOMDocument *pXDMDoc )
{
	BSTR pBStVar = SysAllocString(OLESTR("stateVariable"));
    IXMLDOMNodeList *pXDNLStVars = NULL;
    IXMLDOMNode *pXDNStVar = NULL;
    long clistLen = 0 ;
    HRESULT hr = S_OK ;

    CHECKHRTRACE(pXDMDoc->getElementsByTagName(pBStVar,&pXDNLStVars),"HrProcessStateVariables() : NoStateVariables");
    CHECKHRTRACE(pXDNLStVars->get_length(&clistLen),"HrProcessStateVariables() : get_length() Failed");
    for( int i = 0 ; i < clistLen ; i++)
    {
    	CHECKHRTRACE(pXDNLStVars->get_item(i,&pXDNStVar),"HrProcessStateVariables() : Failed");
        CHECKHRTRACE(HrGenStateVariableIDLFn(pXDNStVar),"HrProcessStateVariables() : Failed");
    }

    SysFreeString(pBStVar);

    return hr ;
}

/*
* Function:    HrProcessArguments()
*
* Description:  Parses the argument and generates the arguments for the IDL function
*
* Arguments:  [in] IXMLDOMNode* - argument node
*            [out] BOOL* - indicates if the argument is a return value
*
* Returns:    HRESULT
*/
HRESULT HrProcessArguments(IXMLDOMNode *pXDNArgument, BOOL *fretVal, BSTR *pszbrelDT, BSTR *pszargName ) 
{
        HRESULT hr = S_OK ;
        IXMLDOMNodeList *pXDNLParams = NULL ;
        IXMLDOMNode *pXDNParamNode = NULL ;
        BSTR pszbParamNodeName ;
        VARIANT vargName ;
        VARIANT vargDataType ;
        VARIANT vargDirection ;
        BSTR pszbrelatedDataType = NULL ;
        long nNumParams = 0 ;
        DWORD pLen = 0 ;
        BOOL retVal = false ;

        VariantInit(&vargName);
        VariantInit(&vargDataType);
        VariantInit(&vargDirection);

        CHECKHRTRACE(pXDNArgument->get_childNodes(&pXDNLParams),"HrProcessArguments() : failed");
        CHECKHRTRACE(pXDNLParams->get_length(&nNumParams),"HrProcessArguments() : failed");

        for( int i = 0 ; i < nNumParams ; i++ ) 
        {
        	CHECKHRTRACE(pXDNLParams->get_item(i,&pXDNParamNode),"HrProcessArguments() : failed");
            pszbParamNodeName = NULL ;
            CHECKHRTRACE(pXDNParamNode->get_nodeName(&pszbParamNodeName),"HrProcessArguments() : failed");
            CHECKNULL(pszbParamNodeName,"HrProcessArguments() : INVALID Arguments");

            if ( wcscmp(pszbParamNodeName,OLESTR("name")) == 0) 
            {
            	IXMLDOMNode *pXDNargNameNode = NULL ;
                CHECKHRTRACE(pXDNParamNode->get_firstChild(&pXDNargNameNode),"HrProcessArguments() : failed");
                CHECKNULL( pXDNargNameNode,"HrProcessArguments() : Arguments not specified");
                CHECKHRTRACE(pXDNargNameNode->get_nodeValue(&vargName),"HrProcessArguments() : failed");
            }
            else if ( wcscmp(pszbParamNodeName,OLESTR("relatedStateVariable")) == 0 ) {
            	IXMLDOMNode *pXDNargRelatedNode = NULL ;
                CHECKHRTRACE(pXDNParamNode->get_firstChild(&pXDNargRelatedNode),"HrProcessArguments() : failed");
                CHECKNULL(pXDNargRelatedNode,"HrProcessArguments() : Related StateVariable not specified");
                CHECKHRTRACE(pXDNargRelatedNode->get_nodeValue(&vargDataType),"HrProcessArguments() : failed");
                pszbrelatedDataType = getRelatedDataType(V_BSTR(&vargDataType));
                CHECKNULL(pszbrelatedDataType,"HrProcessArguments() : INVALID Related State Variable") ;
            }
            else if ( wcscmp(pszbParamNodeName,OLESTR("direction")) == 0 ) 
            {
            	IXMLDOMNode *pXDNargDirectionNode = NULL ;
                CHECKHRTRACE(pXDNParamNode->get_firstChild(&pXDNargDirectionNode),"HrProcessArguments() : failed");
                CHECKNULL(pXDNargDirectionNode,"HrProcessArguments() : Direction not specified");
                CHECKHRTRACE(pXDNargDirectionNode->get_nodeValue(&vargDirection),"HrProcessArguments() : failed");

                if ( (_wcsicmp(V_BSTR(&vargDirection),OLESTR("in")) != 0 ) &&
                	(_wcsicmp(V_BSTR(&vargDirection),OLESTR("out")) != 0 ) ) {
                    hr = E_FAIL ;
                    CHECKHRTRACE(hr,"HrProcessArguments() : Direction must be either \"in\" or \"out\"")
                }
            }
            else if ( wcscmp(pszbParamNodeName,OLESTR("retval")) == 0) 
            {
            	retVal = true ;
            }
            else
            	hr = HrPrintError("INVALID XML Document !!", hr );

            SysFreeString(pszbParamNodeName);

      	}

        if ( retVal ) 
        {
        	if ( _wcsicmp(V_BSTR(&vargDirection),OLESTR("in")) == 0 )
        	{
        		hr = HrPrintError("INVALID ARGUMENT DIRECTION", hr);
        		callAbort();
        	}
        	*pszargName = SysAllocString(V_BSTR(&vargName));
            *pszbrelDT = SysAllocString(pszbrelatedDataType);          
        }
        else
        	if ( _wcsicmp(V_BSTR(&vargDirection),OLESTR("out")) == 0 )
        	{
            	sprintf(g_pszdumpStr,"\r\n\t\t[in, %S] %S *p%S",V_BSTR(&vargDirection),pszbrelatedDataType,V_BSTR(&vargName));
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrProcessArguments() : Write to File failed");
            }
            else 
            {
                 sprintf(g_pszdumpStr,"\r\n\t\t[%S] %S %S",V_BSTR(&vargDirection),pszbrelatedDataType,V_BSTR(&vargName));
                 CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrProcessArguments() : Write to File failed");
            }

        SysFreeString(pszbrelatedDataType);
        VariantClear(&vargName);
        VariantClear(&vargDirection);
        VariantClear(&vargDataType);

        *fretVal = retVal ;
        return hr ;
}

/*
* Function:    HrProcessArgumentList()
*
* Description:  Parses all the arguments for a given arguement list
*
* Arguments:  [in] IXMLDOMNode* - argument list node
*
* Returns:    HRESULT
*/

// assumption: the retval must always be specified as the last argument in the XML document
HRESULT HrProcessArgumentList(IXMLDOMNode *pXDNArgsNode ) 
{
        HRESULT hr = S_OK ;
        IXMLDOMNodeList *pXDNLArgsList = NULL ;
        IXMLDOMNode *pXDNArguments = NULL ;
        BSTR pszbrelatedDataType = NULL ;
        BSTR pszbArgName = NULL ;

        long nNumArgs = 0 ;
        BOOL fchkRetVal = false ;
        int cretValCount = 0 ;
        int nretValIndex = 0 ; // do :-initialize correctly
        DWORD pLen = 0 ;

        // multiple return Values not allowed 
        CHECKHRTRACE(pXDNArgsNode->get_childNodes(&pXDNLArgsList),"HrProcessArgumentList() : failed");
        CHECKHRTRACE(pXDNLArgsList->get_length(&nNumArgs),"HrProcessArgumentList() : failed");

        for(int i = 0 ; i < nNumArgs ; i++ ) 
        {
        	CHECKHRTRACE(pXDNLArgsList->get_item(i,&pXDNArguments),"HrProcessArgumentList() : failed");
            CHECKHRTRACE(HrProcessArguments(pXDNArguments,&fchkRetVal,&pszbrelatedDataType,&pszbArgName),"HrProcessArgumentList() : failed") ;
            if ( (i < (nNumArgs-1)) && !fchkRetVal )
            {
            	sprintf(g_pszdumpStr,",");
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrProcessArgumentList() : Write to File failed");
            }
            if ( fchkRetVal ) 
            {
            	fchkRetVal = false ;
                nretValIndex = i ;
                cretValCount++ ;
                if ( cretValCount > MAXALLOWEDRETVAL )
                {
                	HrPrintError("Maximum of 1 retval allowed",hr) ;
                    callAbort();
                }
            }
        }
        if ( cretValCount ) 
        {
                if ( nNumArgs > 1 && nretValIndex < (nNumArgs-1) )
                {
                	sprintf(g_pszdumpStr,",");
                    CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrProcessArgumentList() : Write to File failed");
                }
                sprintf(g_pszdumpStr,"\r\n\t\t[out, retval] %S *p%S",pszbrelatedDataType,pszbArgName);
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrProcessArgumentList() : Write to File failed");
        }

        SysFreeString(pszbrelatedDataType);
        SysFreeString(pszbArgName);
        return hr ;
}

/*
* Function:    HrProcessAction()
*
* Description:  Parses each action node and generates the IDL action functions
*
* Arguments:  [in] IXMLDOMNode* - action node
*
* Returns:    HRESULT
*/
HRESULT HrProcessAction(IXMLDOMNode *pXDNAction) 
{
        HRESULT hr = S_OK ;
        VARIANT vActionName ;
        IXMLDOMNode *pXDNActionNode = NULL ;
        IXMLDOMNode *pXDNArgsNode = NULL ;
        IXMLDOMNode *pXDNActionNameNode = NULL ;
        DWORD pLen = 0 ;

        VariantInit(&vActionName);

        CHECKHRTRACE(pXDNAction->selectSingleNode(OLESTR("name"),&pXDNActionNode),"HrProcessAction() : failed");
        CHECKNULL(pXDNActionNode,"HrProcessAction() : Not able to retrieve Action Node");
        CHECKHRTRACE(pXDNAction->selectSingleNode(OLESTR("argumentList"),&pXDNArgsNode),"HrProcessAction() : failed");
       
        CHECKHRTRACE(pXDNActionNode->get_firstChild(&pXDNActionNameNode),"HrProcessAction() : failed");
        CHECKNULL(pXDNActionNameNode,"HrProcessAction() : Not able to retrieve Action Name");
        CHECKHRTRACE(pXDNActionNameNode->get_nodeValue(&vActionName),"HrProcessAction() : failed");

        WCHAR *pszwTmp = new WCHAR[wcslen(V_BSTR(&vActionName))+1] ;
        if ( pszwTmp == NULL )
                callAbort();
        wcscpy(pszwTmp,V_BSTR(&vActionName));
        sprintf(g_pszdumpStr,"\r\n\t[ id(DISPID_%S), helpstring(\"Method %S\")]\r\n",_wcsupr(pszwTmp),V_BSTR(&vActionName));
        CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrProcessAction() : Write to File failed");
        delete pszwTmp ;
        g_methodID++;

        if ( pXDNArgsNode == NULL ) 
        {
                sprintf(g_pszdumpStr,"\tHRESULT %S();\r\n",V_BSTR(&vActionName));
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrProcessAction() : Write to File failed");
        }
        else
        {
                sprintf(g_pszdumpStr,"\tHRESULT %S(",V_BSTR(&vActionName));
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrProcessAction() : Write to File failed");
                CHECKHRTRACE(HrProcessArgumentList(pXDNArgsNode),"HrProcessAction() : failed");
             
                sprintf(g_pszdumpStr,");\r\n");
                CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrProcessAction() : Write to File failed");
        }

        VariantClear(&vActionName);

        return hr ;
}

/*
* Function:    HrProcessActionList()
*
* Description:  Parses action list and generates the IDL functions
*
* Arguments:  [in] IXMLDOMNode* - action list node
*
* Returns:    HRESULT
*/
HRESULT HrProcessActionList(IXMLDOMDocument *pXDMDoc ) 
{
        BSTR pBAction = SysAllocString(OLESTR("action"));
        IXMLDOMNodeList *pXDNLActionList = NULL;
        IXMLDOMNode *pXDNActionItem = NULL;
        long clistLen = 0 ;
        HRESULT hr = S_OK ;

        // can be with out actions 
        CHECKHRTRACE(pXDMDoc->getElementsByTagName(pBAction,&pXDNLActionList),"HrProcessActionList(): NoActions");
        CHECKHRTRACE(pXDNLActionList->get_length(&clistLen),"HrProcessActionList() : failed");
        for( int i = 0 ; i < clistLen ; i++)
        {
        	pXDNLActionList->get_item(i,&pXDNActionItem);
            CHECKHRTRACE(HrProcessAction(pXDNActionItem),"HrProcessActionList() : failed") ;
        }

        SysFreeString(pBAction);

        return hr ;

}


/*
* Function:    HrGenIDLInterface()
*
* Description:  Parses the XML document and generates the IDL interface for the Service Description in XML
*
* Arguments:  [in] IXMLDOMDocument* - XML Service Description Document
*            [in] PCWSTR - HelpString for the interface
*            [in] PCWSTR - Interface name for the Service Description
* Returns:    HRESULT
*/
HRESULT HrGenIDLInterface(IXMLDOMDocument *pXDMDoc, PCWSTR pszHelpString, PCWSTR pszInterfaceName, BOOL fDual )
{
        HRESULT hr = S_OK ;
        DWORD pLen = 0 ;

        
        CHECKHRTRACE(HrgenGUIDHDR(pszHelpString,fDual),"HrGenIDLInterface() : failed");

        sprintf(g_pszdumpStr,"interface IUPnPService_%S%S : %S {\r\n",pszInterfaceName,fDual?OLESTR("Dual"):L"",fDual?OLESTR("IDispatch"):OLESTR("IUnknown"));
        CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenIDLInterface() : Write to File failed");

        CHECKHRTRACE(HrProcessStateVariables(pXDMDoc),"HrGenIDLInterface() : failed");

        CHECKHRTRACE(HrProcessActionList(pXDMDoc),"HrGenIDLInterface() : failed");

        sprintf(g_pszdumpStr,"};\r\n");
        CHECKNULL(WriteFile(g_hOutFileHandle,g_pszdumpStr,strlen(g_pszdumpStr),&pLen,NULL),"HrGenIDLInterface() : Write to File failed");
       
        return hr ;
}

// Creates a new file for generating IDL interfaces
HANDLE CreateIDLFile() 
{

    HANDLE hOutFile ;
    hOutFile = CreateFile(g_pszOutFileName,GENERIC_WRITE,NULL,NULL,CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
    while ( hOutFile == INVALID_HANDLE_VALUE ) {
        printf("\n\t The file %S already exists !!\n\t Do you want to OVERWRITE ? [y/n] : ",g_pszOutFileName);
        wchar_t wch ;
        while( ( (wch = towlower(getwchar()) )  != 'y' ) && (wch != 'n') ) 
        {
                fflush(stdout);
                printf("\n\t The file %S already exists !!\n\t Do you want to OVERWRITE ? [y/n] : ",g_pszOutFileName);
        }
        if ( wch == 'y' )
                hOutFile = CreateFile(g_pszOutFileName,GENERIC_WRITE,NULL,NULL,CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        else
                callAbort();
    }

    return hOutFile ;
}


/*
* Function:    wmain()
*
* Description:  utl2idl.cpp main function. parses the command line arguments and loads the XML document
*                         Generates the IDL interface from the XML DOM document which has the service description
*             Usage: utl3idl.exe [<options> SpecName] inputfilename [outputfilename]
*             The input file is required.
*                         Options:
*               -i - specify the interface name
*               -h - specify the helpstring.
*
* Arguments:  [i] int - argc
*             [i] PCWSTR - argv[]
* Returns:    int
*/

EXTERN_C
int
__cdecl
wmain ( IN INT     argc,
          IN PCWSTR argv[])
{

HRESULT hr = S_OK;
    IXMLDOMDocument *pXDMDoc = NULL;
    IXMLDOMNode *pXDNNode = NULL;
    BSTR pBURL = NULL;
    PCWSTR pszHelpString = NULL ;
    PCWSTR pszInterfaceName = NULL ;
    int i;
    BOOL fIName = false ;
    BOOL fDual = false ;
    DWORD pLen = 0 ;

    g_StateVariableInfo.cStVars = 0 ;

    CHECKHR(CoInitialize(NULL));

    // Create an empty XML document
    CHECKHR(CoCreateInstance(CLSID_DOMDocument30, NULL, CLSCTX_INPROC_SERVER,
                                IID_IXMLDOMDocument, (void**)&pXDMDoc));

    if (argc == 1)
    {
        PrintUsage(argv[0]);
    }

    i = 1 ;
    while ( i < argc )
    {
        PCWSTR arg = argv[i];
        if ((arg[0] == '-') || (arg[0] == '/'))
        {
            switch (arg[1])
            {
            case 'i':
                fIName = true;
                i++ ;
                pszInterfaceName = argv[i++] ;
                break;
            case 'h':
                i++;
                pszHelpString = argv[i++] ;
                break;
            case 'd':
                fDual = true ;
                i++;
                break ;
            case '?':
            	PrintUsage(argv[0]);
            	break;
            default:
                PrintUsage(argv[0]);
            }
        }
        else
        {
            g_pszInputFileName = arg ;
            i++;
            if ( i < argc )
                g_pszOutFileName = argv[i] ;
            i++ ;
            break ;
        }
    }
    if ( (g_pszInputFileName != NULL) && (g_pszOutFileName != NULL) )
    {
        if ( wcscmp(g_pszInputFileName,g_pszOutFileName) == 0 )
	    {
		    fprintf(stderr,"\nERROR - Input and Output file must be different\n");
		    PrintUsage(argv[0]) ;
	    }
    }
    // assumes a .xml extension !! change it to generic
    if ( g_pszInputFileName == NULL )
    	PrintUsage(argv[0]) ;
    if ( g_pszOutFileName == NULL ) 
    {
       	g_pszOutFileName = PrunFileExt(g_pszInputFileName) ;
        wcscat((WCHAR *)g_pszOutFileName,L".idl");
    }
    if ( pszHelpString == NULL )
        pszHelpString = PrunFileExt(g_pszInputFileName) ;
    if ( pszInterfaceName == NULL ) 
    {
        pszInterfaceName = PrunFileExt(g_pszInputFileName) ;
        ValidateString((WCHAR*)pszInterfaceName);
    }

    pBURL = SysAllocString(g_pszInputFileName);
    hr = HrLoadDocument(pXDMDoc, pBURL);
    if(hr == S_OK ) 
    {
    	HrInit(pXDMDoc);
    	g_hOutFileHandle = CreateIDLFile();
    	CHECKHR(HrGenEnumTags(pXDMDoc,pszInterfaceName));
    	CHECKHR(HrGenIDLInterface(pXDMDoc,pszHelpString, pszInterfaceName,fDual));
    	printf("\n\tTranslation Done. Check %S file\n",g_pszOutFileName);
    	SAFERELEASE(pXDMDoc);
    }
	
    SAFERELEASE(pXDMDoc);
    // free file names !!!!
    CloseHandle(g_hOutFileHandle);
    CoUninitialize();

}