windows-xp/Source/XPSP1/NT/base/wmi/bmof/bmofio.cpp

/*++

Copyright (c) 1997-1999 Microsoft Corporation

Module Name:

    bmofio.cpp

Abstract:

    Binary mof Win32 subparser for Loc Studio

Author:

    16-Jan-1997 AlanWar

Revision History:

--*/

#if DEBUG_HEAP
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#endif

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <wbemcli.h>
#include "dllcalls.h"
#include "bmfmisc.h"
#include "mrcicode.h"
#include "bmof.h"


ULONG GenerateMofForObj(
    PMOFFILETARGET MofFileTarget,
    CBMOFObj *Obj
    );

//
// Each class has one or more data items that are described by a MOFDATAITEM
// structure.
typedef struct
{
    PWCHAR Name;
    PWCHAR DataType;                // Method return type
    ULONG Flags;                    // Flags, See MOFDI_FLAG_*
    CBMOFQualList * QualifierList;
} METHODPARAMETER, *PMETHODPARAMETER;

// Data item is actually a fixed sized array
#define MOFDI_FLAG_ARRAY        0x00000001

// Data item is an input method parameter
#define MOFDI_FLAG_INPUT_METHOD       0x00000100

// Data item is an output method parameter
#define MOFDI_FLAG_OUTPUT_METHOD      0x00000200

//
// The MOFCLASSINFO structure describes the format of a data block
typedef struct
{
    PWCHAR ReturnDataType;
    ULONG ParamCount;            // Number of wmi data items (properties)
                                  // Array of Property info
    METHODPARAMETER Parameters[1];
} METHODPARAMLIST, *PMETHODPARAMLIST;


//
// Definitions for WmipAlloc/WmipFree. On debug builds we use our own
// heap. Be aware that heap creation is not serialized.
//
#if 0
#if DEBUG_HEAP
PVOID WmiPrivateHeap;

PVOID _stdcall WmipAlloc(ULONG size)
{
    PVOID p = NULL;
    
    if (WmiPrivateHeap == NULL)
    {
        WmiPrivateHeap = RtlCreateHeap(HEAP_GROWABLE | 
                                      HEAP_TAIL_CHECKING_ENABLED |
                                      HEAP_FREE_CHECKING_ENABLED | 
                                      HEAP_DISABLE_COALESCE_ON_FREE,
                                      NULL,
                                      0,
                                      0,
                                      NULL,
                                      NULL);
    }
    
    if (WmiPrivateHeap != NULL)
    {
        p = RtlAllocateHeap(WmiPrivateHeap, 0, size);
        if (p != NULL)
        {
            memset(p, 0, size);
        }
    }
    return(p);
}

void _stdcall WmipFree(PVOID p)
{
    RtlFreeHeap(WmiPrivateHeap, 0, p);
}
#else
PVOID _stdcall WmipAlloc(ULONG size)
{
    return(LocalAlloc(LPTR, size));
}

void _stdcall WmipFree(PVOID p)
{
    LocalFree(p);
}
#endif
#endif

#define WmipAlloc malloc
#define WmipFree free

//
// Definitions for WmipAssert
//
#if DBG
#define WmipAssert(x) if (! (x) ) { \
    WmipDebugPrint(("BMOFLocParser Assertion: "#x" at %s %d\n", __FILE__, __LINE__)); \
    DebugBreak(); }
#else
#define WmipAssert(x)
#endif


//
// WmipDebugPrint definitions
//
#if DBG
#define WmipDebugPrint(x) WmiDebugPrint x

VOID
WmiDebugPrint(
    PCHAR DebugMessage,
    ...
    )
/*++

Routine Description:

    Debug print for properties pages - stolen from classpnp\class.c

Arguments:

    Debug print level between 0 and 3, with 3 being the most verbose.

Return Value:

    None

--*/

{
    #define DEBUG_BUFFER_LENGTH 512
    static CHAR WmiBuffer[DEBUG_BUFFER_LENGTH];

    va_list ap;

    va_start(ap, DebugMessage);

    _vsnprintf(WmiBuffer, DEBUG_BUFFER_LENGTH, DebugMessage, ap);

    OutputDebugStringA(WmiBuffer);

    va_end(ap);

} // end WmiDebugPrint()


#else
#define WmipDebugPrint(x)
#endif


ULONG AnsiToUnicode(
    LPCSTR pszA,
    LPWSTR *ppszW
    )
/*++

Routine Description:

    Convert Ansi string into its Unicode equivalent

Arguments:

    pszA is ansi string to convert

    *ppszW on entry has a pointer to a unicode string into which the answer
        is written. If NULL on entry then a buffer is allocated and  returned
    in it.

Return Value:

    Error code

--*/
{
    ULONG cCharacters;
    ULONG Status;
    ULONG cbUnicodeUsed;

    //
    // If input is null then just return the same.
    if (pszA == NULL)
    {
        *ppszW = NULL;
        return(ERROR_SUCCESS);
    }

    //
    // Determine the count of characters needed for Unicode string
    cCharacters = MultiByteToWideChar(CP_ACP, 0, pszA, -1, NULL, 0);

    if (cCharacters == 0)
    {
        *ppszW = NULL;
        return(GetLastError());
    }

    // Convert to Unicode
    cbUnicodeUsed = MultiByteToWideChar(CP_ACP, 0, pszA, -1, *ppszW, cCharacters);
    
    if (0 == cbUnicodeUsed)
    {
        Status = GetLastError();
        return(Status);
    }

    return(ERROR_SUCCESS);
}

ULONG AppendFileToFile(
    TCHAR *DestFile,
    TCHAR *SrcFile
    )
{
    #define READ_BLOCK_SIZE 0x8000
    
    HANDLE DestHandle, SrcHandle;
    ULONG BytesRead, BytesWritten;
    PUCHAR Buffer;
    BOOL b;
    ULONG Status = ERROR_SUCCESS;

    Buffer = (PUCHAR)WmipAlloc(READ_BLOCK_SIZE);
    if (Buffer != NULL)
    {
        DestHandle = CreateFile(DestFile,
                                GENERIC_READ | GENERIC_WRITE,
                                0,
                                NULL,
                                OPEN_EXISTING,
                                FILE_ATTRIBUTE_NORMAL,
                                NULL);
        if (DestHandle != INVALID_HANDLE_VALUE)
        {
            SrcHandle = CreateFile(SrcFile,
                                   GENERIC_READ,
                                   0,
                                   NULL,
                                   OPEN_EXISTING,
                                   FILE_ATTRIBUTE_NORMAL,
                                   NULL);
            if (SrcHandle != INVALID_HANDLE_VALUE)
            {
                b = SetFilePointer(DestHandle,
                                   0,
                                   NULL,
                                   FILE_END);
                if (b)
                {
                    do
                    {
                        b = ReadFile(SrcHandle,
                                     Buffer,
                                     READ_BLOCK_SIZE,
                                     &BytesRead,
                                     NULL);
                        if (b)
                        {
                            b = WriteFile(DestHandle,
                                          Buffer,
                                          BytesRead,
                                          &BytesWritten,
                                          NULL);
                            if (!b)
                            {                           
                                Status = GetLastError();
                                break;
                            } else if (BytesWritten != BytesRead) {
                                Status = ERROR_BAD_LENGTH;
                                break;
                            }
                        } else { 
                            Status = GetLastError();
                            break;
                        }
                    } while (BytesRead == READ_BLOCK_SIZE);
                } else {
                    Status = GetLastError();
                }
                CloseHandle(SrcHandle);
            } else {
                Status = GetLastError();
            }
            CloseHandle(DestHandle);
        } else {
            Status = GetLastError();
        }
        WmipFree(Buffer);
    } else {
        Status = ERROR_NOT_ENOUGH_MEMORY;
    }
    return(Status); 
}

BOOLEAN ConvertMofToBmf(
    TCHAR *MofFile,
    TCHAR *EnglishMofFile,
    TCHAR *BmfFile
    )
{
    WBEM_COMPILE_STATUS_INFO info;
    SCODE sc;
    LONG OptionFlags, ClassFlags, InstanceFlags;
    PWCHAR NameSpace;
    WCHAR MofFileStatic[MAX_PATH];
    WCHAR BmfFileStatic[MAX_PATH];
    PWCHAR BmfFileW, MofFileW;
    BOOLEAN Success;
    ULONG Status;

    if (*EnglishMofFile != 0)
    {
        Status = AppendFileToFile(MofFile, EnglishMofFile);
        if (Status != ERROR_SUCCESS)
        {
            return(FALSE);
        }
    }
    
#if 0
    OutputDebugString(MofFile);
    OutputDebugString("\n");
    DebugBreak();
#endif  
    
    NameSpace = L"";
    OptionFlags = 0;
    ClassFlags = 0;
    InstanceFlags = 0;

    MofFileW = MofFileStatic;
    Status = AnsiToUnicode(MofFile, &MofFileW);

    if ((Status == ERROR_SUCCESS) &&
        (MofFileW != NULL))
    {
        BmfFileW = BmfFileStatic;
        Status = AnsiToUnicode(BmfFile, &BmfFileW);

        if ((Status == ERROR_SUCCESS) &&
            (BmfFileW != NULL))
        {
            sc = CreateBMOFViaDLL( MofFileW,
                                   BmfFileW,
                                   NameSpace,
                                   OptionFlags,
                                   ClassFlags,
                                   InstanceFlags,
                                   &info);
            Success = (sc == S_OK);
        } else {
            Success = FALSE;
        }
    } else {
        Success = FALSE;
    }
    
    return(Success);
}

ULONG FilePrintVaList(
    HANDLE FileHandle,
    WCHAR *Format,
    va_list pArg
    )
{
    WCHAR Buffer[8192];
    ULONG Size, Written;
    ULONG Status;

    Size = _vsnwprintf(Buffer, sizeof(Buffer)/sizeof(WCHAR), Format, pArg);
    if (WriteFile(FileHandle,
                       Buffer,
                       Size * sizeof(WCHAR),
                       &Written,
                       NULL))
    {
        Status = ERROR_SUCCESS;
    } else {
        Status = GetLastError();
    }

    return(Status);
}

ULONG FilePrint(
    PMOFFILETARGET MofFileTarget,
    WCHAR *Format,
    ...
    )
{
    ULONG Status;
    va_list pArg;

    va_start(pArg, Format);
    Status = FilePrintVaList(MofFileTarget->MofHandle, Format, pArg);

    if ((MofFileTarget->WriteToEnglish) &&
        (Status == ERROR_SUCCESS) &&
        (MofFileTarget->EnglishMofHandle != NULL))
    {
        Status = FilePrintVaList(MofFileTarget->EnglishMofHandle, Format, pArg);
    }
    
    return(Status);
}

ULONG FilePrintToHandle(
    HANDLE FileHandle,
    WCHAR *Format,
    ...
    )
{
    ULONG Status;
    va_list pArg;

    va_start(pArg, Format);
    Status = FilePrintVaList(FileHandle, Format, pArg);

    return(Status);
}


ULONG WmipDecompressBuffer(
    IN PUCHAR CompressedBuffer,
    OUT PUCHAR *UncompressedBuffer,
    OUT ULONG *UncompressedSize
    )
/*++

Routine Description:

    This routine will decompress a compressed MOF blob into a buffer
    that can be used to interpert the blob.

Arguments:

    CompressedBuffer points at the compressed MOF blob

    *UncompressedBuffer returns with a pointer to the uncompressed
        MOF blob

Return Value:

    ERROR_SUCCESS or an error code

--*/
{
    PBMOFCOMPRESSEDHEADER CompressedHeader = (PBMOFCOMPRESSEDHEADER)CompressedBuffer;
    BYTE *Buffer;
    ULONG Status;

    if ((CompressedHeader->Signature != BMOF_SIG) ||
        (CompressedHeader->CompressionType != 1))
    {
        // TODO: LocStudio message
        WmipDebugPrint(("WMI: Invalid compressed mof header\n"));
        Status = ERROR_INVALID_PARAMETER;
    } else {
        Buffer = (BYTE *)WmipAlloc(CompressedHeader->UncompressedSize);
        if (Buffer == NULL)
        {
            Status = ERROR_NOT_ENOUGH_MEMORY;
        } else {
            *UncompressedSize = Mrci1Decompress(&CompressedHeader->Buffer[0],
                                               CompressedHeader->CompressedSize,
                                               Buffer,
                                               CompressedHeader->UncompressedSize);

            if (*UncompressedSize != CompressedHeader->UncompressedSize)
            {
                // TODO: LocStudioMessage
                WmipDebugPrint(("WMI: Invalid compressed mof buffer\n"));
                WmipFree(Buffer);
                Status = ERROR_INVALID_PARAMETER;
            } else {
                *UncompressedBuffer = Buffer;
                Status = ERROR_SUCCESS;
            }
        }
    }
    return(Status);
}

ULONG WmipFindMofQualifier(
    CBMOFQualList *QualifierList,
    LPCWSTR QualifierName,
    DWORD *QualifierType,
    DWORD *NumberElements,
    PVOID QualifierValueBuffer
    )
/*++

Routine Description:

    This routine will find a MOF qualifier within the qualifier list passed,
    ensure that its type matches the type requested and return the qualifier's
    value

Arguments:

    QualifierList is the MOF qualifier list

    QualifierName is the name of the qualifier to search for

    *QualifierType on entry has the qualifier type being searched for. On exit
        it has the actual qualifier type for the qualifier value. If on entry
        *QualifierType is 0xffffffff then any qualifier type is acceptable

    *NumberElements returns the number of elements in the array if the result
        of the qualifier is an array

    QualifierValueBuffer points to a buffer that returns the value of the
        qualifier. If the qualifier is a simple type (int or int64) then
        the value is returned in the buffer. If qualifier value is a string
        then a pointer to the string is returned in the buffer

Return Value:

    ERROR_SUCCESS or a WMI Mof error code (see wmiump.h)

--*/
{
    CBMOFDataItem MofDataItem;
    ULONG Status;
    PUCHAR List, ListPtr;
    ULONG BaseTypeSize;
    LONG ElementCount;
    LONG i;

    if (QualifierList == NULL)
    {
        return(ERROR_FILE_NOT_FOUND);
    }
    
    if (FindQual(QualifierList, (PWCHAR)QualifierName, &MofDataItem))
    {
        if ((*QualifierType != 0xffffffff) &&
            (MofDataItem.m_dwType != *QualifierType))
        {
            Status = ERROR_INVALID_PARAMETER;
        }

        if (MofDataItem.m_dwType & VT_ARRAY)
        {
            if (MofDataItem.m_dwType == (VT_BSTR | VT_ARRAY))
            {
                BaseTypeSize = sizeof(PWCHAR);
            } else {
                BaseTypeSize = iTypeSize(MofDataItem.m_dwType);
            }

            ElementCount = GetNumElements(&MofDataItem, 0);
            if (NumberElements != NULL)
            {
                *NumberElements = ElementCount;
            }

            if (ElementCount != -1)
            {
               List = (PUCHAR)WmipAlloc(ElementCount * BaseTypeSize);
               if (List != NULL)
               {
                   ListPtr = List;
                   for (i = 0; i < ElementCount; i++)
                   {
                       if ((GetData(&MofDataItem,
                                   (BYTE *)ListPtr,
                                   &i)) == 0)
                       {
                           WmipFree(List);
                           Status = ERROR_INVALID_PARAMETER;
                           return(Status);
                       }
                       ListPtr += BaseTypeSize;
                   }
                   Status = ERROR_SUCCESS;
                   *QualifierType = MofDataItem.m_dwType;
                   *((PVOID *)QualifierValueBuffer) = List;
               } else {
                   Status = ERROR_NOT_ENOUGH_MEMORY;
               }
			}
        } else {
            if (GetData(&MofDataItem, (BYTE *)QualifierValueBuffer, 0) == 0)
            {
                Status = ERROR_INVALID_PARAMETER;
            } else {
                *QualifierType = MofDataItem.m_dwType;
                Status = ERROR_SUCCESS;
            }
        }
    } else {
        Status = ERROR_FILE_NOT_FOUND;
    }
    return(Status);
}

ULONG WmipFindProperty(
    CBMOFObj * ClassObject,
    WCHAR * PropertyName,
    CBMOFDataItem *MofPropertyData,
    DWORD *ValueType,
    PVOID ValueBuffer
    )
/*++

Routine Description:

    This routine will find a named property within a class object

Arguments:

    ClassObject is the class object in which to search

    PropertyName is the name of the property to search for

    MofPropertyData returns with the property data

    *ValueType on entry has the property data type being searched for. On exit
        it has the actual qualifier type for the qualifier value. If on entry
        *ValueType is 0xffffffff then any data type is acceptable

    ValueBuffer points to a buffer that returns the value of the
        property. If the property is a simple type (int or int64) then
        the value is returned in the buffer. If qualifier value is a string
        then a pointer to the string is returned in the buffer

Return Value:

    ERROR_SUCCESS or a WMI Mof error code (see wmiump.h)

--*/
{
    ULONG Status;

    if (FindProp(ClassObject, PropertyName, MofPropertyData))
    {
        if ((*ValueType != 0xffffffff) &&
            (MofPropertyData->m_dwType != *ValueType))
        {
            Status = ERROR_INVALID_PARAMETER;
        }

        if (GetData(MofPropertyData, (BYTE *)ValueBuffer, 0) == 0)
        {
            Status = ERROR_INVALID_PARAMETER;
        } else {
            *ValueType = MofPropertyData->m_dwType;
            Status = ERROR_SUCCESS;
        }
    } else {
        Status = ERROR_FILE_NOT_FOUND;
    }
    return(Status);
}

PWCHAR AddSlashesToString(
    PWCHAR SlashedNamespace,
    PWCHAR Namespace
    )
{
    PWCHAR Return = SlashedNamespace;
    
    //
    // MOF likes the namespace paths to be C-style, that is to have a
    // '\\' instad of a '\'. So whereever we see a '\', we insert a
    // second one
    //
    while (*Namespace != 0)
    {
        if (*Namespace == L'\\')
        {
            *SlashedNamespace++ = L'\\';
        }
        *SlashedNamespace++ = *Namespace++;
    }
    *SlashedNamespace = 0;
    
    return(Return);
}


ULONG GenerateDataValueFromVariant(
    PMOFFILETARGET MofFileTarget,
    VARIANT *var
    )
{
    SCODE sc;
    VARIANT vTemp;
    ULONG Status;
    PWCHAR String;

    //
    // Uninitialized data will have a VT_NULL type.
    //
    if (var->vt == VT_NULL)
    {
        return(ERROR_SUCCESS);
    }

    //
    // String types can just be dumped.
    //
    if (var->vt == VT_BSTR)
    {
        String = (PWCHAR)WmipAlloc(((wcslen(var->bstrVal)) *
                                    sizeof(WCHAR) * 2) + sizeof(WCHAR));
        if (String != NULL)
        {       
            Status = FilePrint(MofFileTarget,
                           L"\"%ws\"",
                           AddSlashesToString(String, var->bstrVal));
            WmipFree(String);
        } else {
            Status = ERROR_NOT_ENOUGH_MEMORY;
        }
        return(Status);
    }

    //
    // References need to be maintained
    //
    if (var->vt == (VT_BSTR | VT_BYREF))
    {
        String = (PWCHAR)WmipAlloc(((wcslen(var->bstrVal)) *
                                    sizeof(WCHAR) * 2) + sizeof(WCHAR));
        if (String != NULL)
        {       
            Status = FilePrint(MofFileTarget,
                           L"$%ws",
                           AddSlashesToString(String, var->bstrVal));
            WmipFree(String);
        } else {
            Status = ERROR_NOT_ENOUGH_MEMORY;
        }
        return(Status);
    }

	
    //
    // Embedded classes, so recurse in to display the contents of it
    //
    if (var->vt == VT_UNKNOWN)
    {
        CBMOFObj * pObj;
        
        WmipDebugPrint(("BMOFLocParser: Data is an embeeded object %p\n",
                        var));        
        pObj = (CBMOFObj *)var->bstrVal;
        Status = GenerateMofForObj(MofFileTarget,
                                   pObj);
        return(Status);
     }

    if (var->vt == VT_BOOL)
    {
        if (var->boolVal)
        {
            Status = FilePrint(MofFileTarget, L"%ws", L"TRUE");
        } else {
            Status = FilePrint(MofFileTarget, L"%ws", L"FALSE");
        }
        return(Status);
    }
    
    //
    // For non string data, convert the infomation to a bstr and display it.
    //
    VariantInit(&vTemp);
    sc = VariantChangeTypeEx(&vTemp, var,0,0, VT_BSTR);
    if (sc == S_OK)
    {
        Status = FilePrint(MofFileTarget,
                           L"%ws",
                           vTemp.bstrVal);
        VariantClear(&vTemp);
    } else {
        Status = sc;        
    }
    
    return(Status);
}

ULONG GenerateDataValue(
    PMOFFILETARGET MofFileTarget,
    CBMOFDataItem *Item
    )
{
    DWORD Type, SimpleType;
    long NumDim, i;
    long FirstDim;
    VARIANT var;
    BOOLEAN FirstIndex;
    ULONG Status = ERROR_SUCCESS;

    //
    // Determine the data type and clear out the variant
    //
    Type = Item->m_dwType;
    SimpleType = Type & ~VT_ARRAY; 
    memset((void *)&var.lVal, 0, 8);

    NumDim = GetNumDimensions(Item);
  
    if (NumDim == 0)    
    {
        //
        // handle the simple scalar case.  Note that uninitialized properties
        // will not have data.
        //
        if(GetData(Item, (BYTE *)&(var.lVal), NULL))
        {
            var.vt = (VARTYPE)SimpleType;
            Status = GenerateDataValueFromVariant(MofFileTarget,
                                                  &var);

            if (var.vt == VT_BSTR)
            {
               BMOFFree(var.bstrVal);
            }
        }
    } else if (NumDim == 1) {
        //
        // For the array case, just loop getting each element.
        // Start by getting the number of elements
        //
        FirstDim = GetNumElements(Item, 0);
        
		Status = ERROR_SUCCESS;

        FirstIndex = TRUE;
        
        for (i = 0; (i < FirstDim) && (Status == ERROR_SUCCESS); i++)
        {
            if (! FirstIndex)
            {
                FilePrint(MofFileTarget,
                          L", ");
            } else {
                FirstIndex = FALSE;
            }
            
            if (GetData(Item, (BYTE *)&(var.lVal), &i))
            {
                var.vt = (VARTYPE)SimpleType;
                Status = GenerateDataValueFromVariant(MofFileTarget,
                                                      &var);

               if(var.vt == VT_BSTR)
               {
                  BMOFFree(var.bstrVal);
               }
            }
        }
    } else {
        //
        // Currently undefined and multidimension arrays are not
        // supported.
        //
        WmipDebugPrint(("BMOFLocParser: Multi dimensional arrays not supported\n"));
        WmipAssert(FALSE);
        Status = ERROR_INVALID_PARAMETER;
    }

    return(Status);
}

#define MAX_FLAVOR_TEXT_SIZE MAX_PATH

WCHAR *FlavorToText(
    WCHAR *ClassFlagsText,
    ULONG ClassFlags
    )
{
    PWCHAR CommaText;

    //
    // TODO: FInd any undocumented flavors
    //

    
    CommaText = L"";    
    *ClassFlagsText = 0;

    if (ClassFlags & FlavorAmended)
    {
        //
        // since this is the first if, we can assume that a , would
        // never be needed
        //
        wcscat(ClassFlagsText, L"amended");
        CommaText = L",";
    }

    if (ClassFlags & FlavorDisableOverride)
    {
        wcscat(ClassFlagsText, CommaText);
        wcscat(ClassFlagsText, L"DisableOverride");
        CommaText = L",";
    }

    if (ClassFlags & FlavorToSubclass)
    {
        wcscat(ClassFlagsText, CommaText);
        wcscat(ClassFlagsText, L"ToSubclass");
        CommaText = L",";
    }

    if (ClassFlags & FlavorToInstance)
    {
        wcscat(ClassFlagsText, CommaText);
        wcscat(ClassFlagsText, L"ToInstance");
        CommaText = L",";
    }

    WmipAssert(*ClassFlagsText != 0);

    WmipDebugPrint(("BmofLocParser:        Flavor : %ws\n", ClassFlagsText));

    return(ClassFlagsText); 
}


ULONG GenerateQualifierList(
    PMOFFILETARGET MofFileTarget,
    CBMOFQualList * QualifierList,
    BOOLEAN SkipId
    )
{
    WCHAR *Name = NULL;
    CBMOFDataItem Item;
    BOOLEAN FirstQualifier;
    WCHAR OpenChar, CloseChar;
    ULONG Status = ERROR_SUCCESS;
    ULONG Flavor = 0;
    WCHAR s[MAX_FLAVOR_TEXT_SIZE];

    FirstQualifier = TRUE;
    ResetQualList(QualifierList);

    while ((Status == ERROR_SUCCESS) &&
           (NextQualEx(QualifierList,
                       &Name,
                       &Item,
                       &Flavor,
                       MofFileTarget->UncompressedBlob)))
    {
        //
        // TODO: if this is a mofcomp generated qualifier then we want
        // to ignore it
        //
        if (_wcsicmp(Name, L"CIMTYPE") == 0)
        {
            // must skip CIMTYPE qualifier
            continue;
        }

        if ((SkipId)  && _wcsicmp(Name, L"ID") == 0)
        {
            // If we want to skip the ID qualifier then do so
            continue;
        }
        
        if (FirstQualifier)
        {
            Status = FilePrint(MofFileTarget,
                               L"[");
            FirstQualifier = FALSE; 
        } else {
            Status = FilePrint(MofFileTarget,
                               L",\r\n ");
        }

        if (Status == ERROR_SUCCESS)
        {
            //
            // Arrays use {} to enclose the value of the qualifier
            // while scalers use ()
            //
            if (Item.m_dwType & VT_ARRAY)
            {
                OpenChar = L'{';
                CloseChar = L'}';
            } else {
                OpenChar = L'(';
                CloseChar = L')';
            }

            Status = FilePrint(MofFileTarget,
                               L"%ws%wc",
                               Name, OpenChar);

            if (Status == ERROR_SUCCESS)
            {
                Status = GenerateDataValue(MofFileTarget,
                                           &Item);

                if (Status == ERROR_SUCCESS)
                {
                    Status = FilePrint(MofFileTarget,
                                       L"%wc",
                                       CloseChar);
                    if ((Status == ERROR_SUCCESS) && (Flavor != 0))
                    {
                        Status = FilePrint(MofFileTarget,
                                           L": %ws",
                                           FlavorToText(s, Flavor));
                    }
                }
            }
        }
        
        BMOFFree(Name);
        Flavor = 0;
    }

    if ((Status == ERROR_SUCCESS) && ! FirstQualifier)
    {
        //
        // if we had generated qualifiers then we need a closing ]
        //
        Status = FilePrint(MofFileTarget,
                           L"]\r\n");
    }
    return(Status);
}

PWCHAR GeneratePropertyName(
    PWCHAR StringPtr
    )
{
    #define ObjectTextLen  ( ((sizeof(L"object:") / sizeof(WCHAR)) - 1) )
    PWCHAR PropertyType;
    
    //
    // If CIMTYPE begins with object: then it is an embedded object
    // and we need to skip the object: in the MOF generation
    //
    if (_wcsnicmp(StringPtr, L"object:", ObjectTextLen) == 0)
    {
        PropertyType = StringPtr + ObjectTextLen;
    } else {
        PropertyType = StringPtr;
    }
    return(PropertyType);
}

ULONG GenerateProperty(
    PMOFFILETARGET MofFileTarget,
    PWCHAR PropertyName,
    BOOLEAN IsInstance,
    CBMOFQualList * QualifierList,
    CBMOFDataItem *Property
    )
{
    DWORD QualifierType;
    WCHAR *StringPtr;
    ULONG Status;
    PWCHAR ArraySuffix;
    PWCHAR PropertyType;
    PWCHAR ArrayText;

    QualifierType = VT_BSTR;
    Status = WmipFindMofQualifier(QualifierList,
                                  L"CIMTYPE",
                                  &QualifierType,
                                  NULL,
                                  (PVOID)&StringPtr);

    if (IsInstance)
    {
        //
        // Property is within an instance definition
        //
        Status = FilePrint(MofFileTarget,
                           L"%ws = ",
                           PropertyName);

        if (Status == ERROR_SUCCESS)
        {
            if (Property->m_dwType & VT_ARRAY)
            {
                //
                // use {} around arrays
                //
                Status = FilePrint(MofFileTarget,
                                   L"{ ");
                ArrayText = L"};";
            } else if (Property->m_dwType == VT_UNKNOWN) {
                ArrayText = L"";
            } else {
                ArrayText = L";";               
            }
            
            if (Status == ERROR_SUCCESS)
            {
                Status = GenerateDataValue(MofFileTarget,
                                           Property);
                if (Status == ERROR_SUCCESS)
                {
                    Status = FilePrint(MofFileTarget,
                                           L"%ws\r\n",
                                           ArrayText);
                }
            }
        }        
    } else {
        //
        // Property is within a class definition, so just worry about
        // defining it.
        //
        if (Status == ERROR_SUCCESS)
        {
            PropertyType = GeneratePropertyName(StringPtr);
        
            if (Property->m_dwType & VT_ARRAY)
            {
                ArraySuffix = L"[]";
            } else {
                ArraySuffix = L"";
            }

            WmipDebugPrint(("BmofLocParser:      %ws %ws%ws\n",
                               PropertyType,
                               PropertyName,
                               ArraySuffix));
                            
            Status = FilePrint(MofFileTarget,
                               L"%ws %ws%ws;\r\n",
                               PropertyType,
                               PropertyName,
                               ArraySuffix);
            BMOFFree(StringPtr);
        }
    }

    return(Status);
}

ULONG GetDataItemCount(
    CBMOFObj * ClassObject,
    PWCHAR QualifierToFind
    )
/*++

Routine Description:

    This routine will count the number of WMI data items in the class and
    the total number of properties in the class.

Arguments:

    ClassObject is class for which we count the number of data items

    *TotalCount returns the total number of properties

Return Value:

    Count of methods

--*/
{
    CBMOFQualList *PropQualifierList;
    CBMOFDataItem MofPropertyData;
    DWORD QualifierType;
    ULONG Counter = 0;
    WCHAR *PropertyName;
    ULONG Status;
    ULONG Index;

    ResetObj(ClassObject);
    while (NextProp(ClassObject, &PropertyName, &MofPropertyData))
    {
        PropQualifierList = GetPropQualList(ClassObject, PropertyName);
        if (PropQualifierList != NULL)
        {
            //
            // Get the id of the property so we know it order in class
            QualifierType = VT_I4;
            Status = WmipFindMofQualifier(PropQualifierList,
                                          QualifierToFind,
                                          &QualifierType,
                                          NULL,
                                          (PVOID)&Index);
            if (Status == ERROR_SUCCESS)
            {
                Counter++;
            }
        }
        BMOFFree(PropertyName);
    }

    return(Counter);
}


ULONG ParseMethodInOutObject(
    CBMOFObj *ClassObject,
    PMETHODPARAMLIST ParamList,
    ULONG DataItemCount
)
/*++

Routine Description:

    This routine will parse a class object that is either the in or out
    parameters for a method.

Arguments:

    ClassObject is the in or out parameter class object to parse

    ClassInfo returns updated with information from ClassObject

    DataItemCount is the number of data items in the ClassInfo

Return Value:

    ERROR_SUCCESS or a WMI Mof error code (see wmiump.h)

--*/
{
    ULONG Status;
    CBMOFDataItem MofPropertyData;
    PWCHAR PropertyName = NULL;
    ULONG Index;
    PMETHODPARAMETER MethodParam;
    CBMOFQualList *QualifierList = NULL;
    DWORD QualifierType;
    short BooleanValue;
    PWCHAR StringPtr;

    ResetObj(ClassObject);
    while (NextProp(ClassObject, &PropertyName, &MofPropertyData))
    {
        QualifierList = GetPropQualList(ClassObject, PropertyName);
        if (QualifierList != NULL)
        {

            //
            // Get the id of the property so we know its order in class
            //
            QualifierType = VT_I4;
            Status = WmipFindMofQualifier(QualifierList,
                                              L"Id",
                                              &QualifierType,
                                              NULL,
                                              (PVOID)&Index);
            if (Status == ERROR_SUCCESS)
            {
                //
                // Method ids are 0 based
                //
                if (Index < DataItemCount)
                {
                    //
                    // Valid data item id, make sure it already isn't
                    // in use. Note that we could have the same property
                    // be in both the in and the out class objects
                    //
                    MethodParam = &ParamList->Parameters[Index];

                    //
                    // If there is already an existing qualifier list
                    // attached then we free it and tag the new
                    // qualifier list to the parameter. Both lists
                    // should have all of the non [in] / [out]
                    // qualifiers
                    //
                    if (MethodParam->QualifierList != NULL)
                    {
                        BMOFFree(MethodParam->QualifierList);
                    }
                    MethodParam->QualifierList = QualifierList;

                    //
                    // See if this is an input, output or both
                    //
                    QualifierType = VT_BOOL;
                    Status = WmipFindMofQualifier(QualifierList,
                                              L"in",
                                              &QualifierType,
                                              NULL,
                                              (PVOID)&BooleanValue);
                    if ((Status == ERROR_SUCCESS) && BooleanValue)
                    {
                        MethodParam->Flags |= MOFDI_FLAG_INPUT_METHOD;
                    }

                    QualifierType = VT_BOOL;
                    Status = WmipFindMofQualifier(QualifierList,
                                              L"out",
                                              &QualifierType,
                                              NULL,
                                              (PVOID)&BooleanValue);
                    if ((Status == ERROR_SUCCESS) && BooleanValue)
                    {
                        MethodParam->Flags |= MOFDI_FLAG_OUTPUT_METHOD;
                    }


                    //
                    // If there is already a name and its the same as
                    // ours then free the old name and use the new one.
                    // If the names are different then we have a binary
                    // mof error
                    //
                    if (MethodParam->Name != NULL)
                    {
                        if (wcscmp(MethodParam->Name, PropertyName) != 0)
                        {
                            //
                            // id already in use, but a different name
                            //
                            BMOFFree(PropertyName);
                            Status = ERROR_FILE_NOT_FOUND;
                            goto done;
                        } else {
                            //
                            // This is a duplicate so just free up the
                            // memory used and decrement the total
                            // count of parameters in the list. The
                            // data obtained the last time should still
                            // be valid
                            //
                            ParamList->ParamCount--;
                            BMOFFree(PropertyName);
                            continue;
                        }
                    }

                    MethodParam->Name = PropertyName;

                    //
                    // Now figure out the data type for the parameter
                    // and the array status
                    //
                    if (MofPropertyData.m_dwType & VT_ARRAY)
                    {
                        MethodParam->Flags |= MOFDI_FLAG_ARRAY;
                    }

                    QualifierType = VT_BSTR;
                    Status = WmipFindMofQualifier(QualifierList,
                                                  L"CIMTYPE",
                                                  &QualifierType,
                                                  NULL,
                                                  (PVOID)&StringPtr);

                    if (Status == ERROR_SUCCESS)
                    {
                        MethodParam->DataType = StringPtr;
                    }
                                                            
                } else {
                    //
                    // Method ID qualifier is out of range
                    //
                    BMOFFree(QualifierList);
                    Status = ERROR_FILE_NOT_FOUND;
                    goto done;
                }
            } else {
                //
                // Check if this is the special ReturnValue parameter
                // on the output parameter object. If so extract the
                // return type, otherwise flag an error in the binary
                // mof
                //
                if (_wcsicmp(L"ReturnValue", PropertyName) == 0)
                {
                    QualifierType = VT_BSTR;
                    Status = WmipFindMofQualifier(QualifierList,
                                                  L"CIMTYPE",
                                                  &QualifierType,
                                                  NULL,
                                                  (PVOID)&StringPtr);

                    if (Status == ERROR_SUCCESS)
                    {
                        BMOFFree(ParamList->ReturnDataType);
                        ParamList->ReturnDataType = StringPtr;
                    }
                    
                } else {
                    Status = ERROR_FILE_NOT_FOUND;
                    goto done;
                }
                BMOFFree(PropertyName);
                BMOFFree(QualifierList);
            }
        } else {
            BMOFFree(PropertyName);
        }
    }

done:

    return(Status);
}


ULONG ParseMethodParameterObjects(
    IN CBMOFObj *InObject,
    IN CBMOFObj *OutObject,
    OUT PMETHODPARAMLIST *MethodParamList
    )
/*++

Routine Description:

    This routine will parse the in and out method parameter obejcts to create
    a MOFCLASSINFO that describes the method call.

Arguments:

    InObject is the object with the input parameters

    OutObject is the object with the output parameters

    *ClassInfo returns with the class info for the method call

Return Value:

    ERROR_SUCCESS or a WMI Mof error code (see wmiump.h)

--*/
{
    PMETHODPARAMLIST ParamList;
    ULONG Status;
    ULONG DataItemCount;
    ULONG InItemCount, OutItemCount;
    ULONG Size;
    PMETHODPARAMETER MethodParameter;
    PWCHAR StringPtr;

    Status = ERROR_SUCCESS;
    
    if (InObject != NULL)
    {
        ResetObj(InObject);
        InItemCount = GetDataItemCount(InObject, L"Id");
    } else {
        InItemCount = 0;
    }

    if (OutObject != NULL)
    {
        ResetObj(OutObject);
        OutItemCount = GetDataItemCount(OutObject, L"Id");
    } else {
        OutItemCount = 0;
    }

    DataItemCount = InItemCount + OutItemCount;

    Size = sizeof(METHODPARAMLIST) + DataItemCount * sizeof(METHODPARAMETER);
    ParamList = (PMETHODPARAMLIST)WmipAlloc(Size);
    if (ParamList == NULL)
    {
        return(ERROR_NOT_ENOUGH_MEMORY);
    }

    //
    // Get the essential information to fill in the parameter list
    memset(ParamList, 0, Size);
    ParamList->ParamCount = DataItemCount;

    StringPtr = (PWCHAR)BMOFAlloc( sizeof(L"void") + sizeof(WCHAR) );
    if (StringPtr != NULL)
    {
        wcscpy(StringPtr, L"void");
        ParamList->ReturnDataType = StringPtr;
    } else {
        BMOFFree(ParamList);
        return(ERROR_NOT_ENOUGH_MEMORY);
    }
    
    //
    // Parse the input parameter class object
    //
    if (InObject != NULL)
    {
        Status = ParseMethodInOutObject(InObject,
                                        ParamList,
                                        DataItemCount);
    } else {
        Status = ERROR_SUCCESS;
    }
    
    if (Status == ERROR_SUCCESS)
    {
        if (OutObject != NULL)
        {
            //
            // Parse the output parameter class object
            //
            Status = ParseMethodInOutObject(OutObject,
                                            ParamList,
                                            DataItemCount);
        }
    }

    *MethodParamList = ParamList;

    return(Status);
}


ULONG ParseMethodParameters(
    CBMOFDataItem *MofMethodData,
    PMETHODPARAMLIST *MethodParamList
)
{
    ULONG Status = ERROR_SUCCESS;
    CBMOFObj *InObject;
    CBMOFObj *OutObject;
    LONG i;
    ULONG NumberDimensions;
    ULONG NumberElements;
    VARIANT InVar, OutVar;
    DWORD SimpleType;

    *MethodParamList = NULL;
    
    SimpleType = MofMethodData->m_dwType & ~VT_ARRAY & ~VT_BYREF;

    NumberDimensions = GetNumDimensions(MofMethodData);
    if (NumberDimensions > 0)
    {
        NumberElements = GetNumElements(MofMethodData, 0);
        WmipAssert(NumberDimensions == 1);
        WmipAssert((NumberElements == 1) || (NumberElements == 2));

        i = 0;
        memset((void *)&InVar.lVal, 0, 8);

        if (GetData(MofMethodData, (BYTE *)&(InVar.lVal), &i))
        {
            InObject = (CBMOFObj *)InVar.bstrVal;
            InVar.vt = (VARTYPE)SimpleType;
            WmipAssert(InVar.vt ==  VT_UNKNOWN);

            if (NumberElements == 2)
            {
                i = 1;
                memset((void *)&OutVar.lVal, 0, 8);
                if (GetData(MofMethodData, (BYTE *)&(OutVar.lVal), &i))
                {
                    OutVar.vt = (VARTYPE)SimpleType;
                    WmipAssert(OutVar.vt ==  VT_UNKNOWN);
                    OutObject = (CBMOFObj *)OutVar.bstrVal;
                } else {
                    Status = ERROR_FILE_NOT_FOUND;
                }
            } else {
                OutObject = NULL;
            }
        } else {
            Status = ERROR_FILE_NOT_FOUND;
        }
    } else {
        InObject = NULL;
        OutObject = NULL;
    }

    if (Status == ERROR_SUCCESS)
    {
        Status = ParseMethodParameterObjects(InObject,
                                                 OutObject,
                                                 MethodParamList);
    }

    return(Status);
}



ULONG GenerateMethod(
    PMOFFILETARGET MofFileTarget,
    PWCHAR MethodName,
    BOOLEAN IsInstance,
    CBMOFQualList * QualifierList,
    CBMOFDataItem *Method
    )                    
{
    ULONG Status;
    PMETHODPARAMLIST MethodList;
    ULONG i;
    PWCHAR ArraySuffix;
    PMETHODPARAMETER MethodParam;
    
    Status = ParseMethodParameters(Method,
                                   &MethodList);

    if (Status == ERROR_SUCCESS)
    {
        Status = FilePrint(MofFileTarget,
                           L"%ws %ws( ",
                           GeneratePropertyName(MethodList->ReturnDataType),
                           MethodName);

        if (Status == ERROR_SUCCESS)
        {
            for (i = 0;
                 ((Status == ERROR_SUCCESS) &&
                  (i < MethodList->ParamCount));
                 i++)
            {
                if (i != 0)
                {
                    Status = FilePrint(MofFileTarget,
                                       L"\r\n,");
                }

                if (Status == ERROR_SUCCESS)
                {
                    MethodParam = &MethodList->Parameters[i];
                    Status = GenerateQualifierList(MofFileTarget,
                                                   MethodParam->QualifierList,
                                                   TRUE);
                    if (Status == ERROR_SUCCESS)
                    {
                        if (MethodParam->Flags & MOFDI_FLAG_ARRAY)
                        {
                            ArraySuffix = L"[]";
                        } else {
                            ArraySuffix = L"";
                        }
                        
                        Status = FilePrint(MofFileTarget,
                                           L"%ws %ws%ws",
                                           GeneratePropertyName(MethodParam->DataType),
                                           MethodParam->Name,
                                           ArraySuffix);
                    }
                }
            }
        }

        if (Status == ERROR_SUCCESS)
        {
            Status = FilePrint(MofFileTarget,
                      L");\r\n");
        }       
    }

    //
    // Free all memory used to build method parameter list
    //
    if (MethodList != NULL)
    {       
        for (i = 0; i < MethodList->ParamCount; i++)
        {
            MethodParam = &MethodList->Parameters[i];
        
            if (MethodParam->QualifierList != NULL)
            {
                BMOFFree(MethodParam->QualifierList);
            }

            if (MethodParam->Name != NULL)
            {
                BMOFFree(MethodParam->Name);
            }
        
            if (MethodParam->DataType != NULL)
            {
                BMOFFree(MethodParam->DataType);
            }
        }
    
        if (MethodList->ReturnDataType != NULL)
        {
            BMOFFree(MethodList->ReturnDataType);
        }
    
        WmipFree(MethodList);
    }
        
    return(Status);
}

ULONG GenerateMofForObj(
    PMOFFILETARGET MofFileTarget,
    CBMOFObj *Obj
    )
{
    CBMOFQualList * QualifierList;
    CBMOFDataItem Property, Method;
    WCHAR *Name = NULL;
    ULONG Status;
    BOOLEAN IsInstance;
    DWORD ObjType;
    PWCHAR Text;
    CBMOFDataItem MofPropertyData;
    PWCHAR SuperClass, Separator;
    PWCHAR EmptyString = L"";
    ULONG DataType;
    PWCHAR Alias, AliasSeparator;
            
    //
    // First display the class qualifier list
    //
    QualifierList = GetQualList(Obj);
    if(QualifierList != NULL)
    {
        Status = GenerateQualifierList(MofFileTarget,
                                       QualifierList,
                                       FALSE);
        BMOFFree(QualifierList);

        if (Status != ERROR_SUCCESS)
        {
            return(Status);
        }
    }
    
    //
    // Now determine if this is a class or instance and display the class name
    //
    ObjType = GetType(Obj);
    switch (ObjType)
    {
        case MofObjectTypeClass:
        {
            IsInstance = FALSE;
            Text = L"class";
            break;
        }

        case MofObjectTypeInstance:
        {
            IsInstance = TRUE;
            Text = L"instance of";
            break;
        }

        default:
        {
            WmipDebugPrint(("BMOFLocParser: Unknown class object type 0x%x\n",
                            ObjType));
            WmipAssert(FALSE);
            return(ERROR_INVALID_PARAMETER);
        }
    }

    //
    // See if there is a superclass, that is if this class was derrived
    // from another
    //
    DataType = VT_BSTR;
    Status = WmipFindProperty(Obj,
                              L"__SUPERCLASS",
                              &MofPropertyData,
                              &DataType,
                              (PVOID)&SuperClass);
    switch (Status)
    {
        case ERROR_SUCCESS:
        {
            //
            // This class is derrived from another
            //
            Separator = L":";
            break;
        }

        case ERROR_FILE_NOT_FOUND:
        {
            //
            // This class is not derrived from another
            //
            SuperClass = EmptyString;
            Separator = EmptyString;
            break;
        }


        default:
        {
            //
            // Something is wrong, return an error
            //
            return(Status);
        }
    }


    //
    // See if there is an alias defined for this class
    //
    DataType = VT_BSTR;
    Status = WmipFindProperty(Obj,
                              L"__ALIAS",
                              &MofPropertyData,
                              &DataType,
                              (PVOID)&Alias);
    switch (Status)
    {
        case ERROR_SUCCESS:
        {
            //
            // This class is derrived from another
            //
            AliasSeparator = L" as $";
            break;
        }

        case ERROR_FILE_NOT_FOUND:
        {
            //
            // This class is not derrived from another
            //
            Alias = EmptyString;
            AliasSeparator = EmptyString;
            break;
        }


        default:
        {
            //
            // Something is wrong, return an error
            //
            return(Status);
        }
    }
    
    
    
    if (GetName(Obj, &Name))
    {
        WmipDebugPrint(("BmofLocParser: Parsing -> %ws %ws %ws %ws\n",
                  Text,
                  Name,
                  Separator,
                  SuperClass));
                        
        Status = FilePrint(MofFileTarget,
                  L"%ws %ws %ws %ws%ws%ws\r\n{\r\n",
                  Text,
                  Name,
                  Separator,
                  SuperClass,
                  AliasSeparator,
                  Alias);
        BMOFFree(Name);
    } else {
        Status = ERROR_INVALID_PARAMETER;
    }

    if (SuperClass != EmptyString)
    {
        BMOFFree(SuperClass);
    }
    
    //
    // Now generate each property and its qualifiers
    //
    ResetObj(Obj);
    
    while ((Status == ERROR_SUCCESS) && (NextProp(Obj, &Name, &Property)))
    {
        //
        // Ignore any system property, that is, all those that begin
        // with __
        //
        if ( (Name[0] == L'_') && (Name[1] == L'_') )
        {
            WmipDebugPrint(("BmofLocParser:      Skipping system property %ws\n",
                            Name));
            BMOFFree(Name);
            continue;
        }
        
        QualifierList = GetPropQualList(Obj, Name);
        if (QualifierList != NULL)
        {
            Status = GenerateQualifierList(MofFileTarget,
                                           QualifierList,
                                           FALSE);
        }
            
        if (Status == ERROR_SUCCESS)
        {
            WmipDebugPrint(("BmofLocParser:      Parsing property %ws\n",
                            Name));
            Status = GenerateProperty(MofFileTarget,
                                      Name,
                                      IsInstance,
                                      QualifierList,
                                      &Property);
        }

        if (QualifierList != NULL)
        {
            BMOFFree(QualifierList);
        }

        BMOFFree(Name);
    }
    
    //
    // Next we generate all of the methods and their qualifiers
    //
    while ((Status == ERROR_SUCCESS) && (NextMeth(Obj, &Name, &Method)))
    {
        QualifierList = GetMethQualList(Obj, Name);
        if (QualifierList != NULL)
        {
            Status = GenerateQualifierList(MofFileTarget,
                                           QualifierList,
                                           FALSE);
        }

        if (Status == ERROR_SUCCESS)
        {               
            WmipDebugPrint(("BmofLocParser:      Parsing method %ws\n",
                            Name));
            Status = GenerateMethod(MofFileTarget,
                                    Name,
                                    IsInstance,
                                    QualifierList,
                                    &Method);
        }

        if (QualifierList != NULL)
        {
            BMOFFree(QualifierList);
        }

        BMOFFree(Name);
    }

    if (Status == ERROR_SUCCESS)
    {
        //
        // Closing brace for class definition
        //
        Status = FilePrint(MofFileTarget,
                           L"};\r\n\r\n");
    }

    return(Status);
}

PWCHAR MakeClassInstanceFlagsText(
    PWCHAR ClassFlagsText,
    ULONG ClassFlags
    )
{
    PWCHAR CommaText;

    //
    // TODO: FInd any undocumented flags
    //

    
    CommaText = L"";    
    *ClassFlagsText = 0;

    if (ClassFlags & 1)
    {
        //
        // since this is the first if, we can assume that a , would
        // never be needed
        //
        wcscat(ClassFlagsText, L"\"updateonly\"");
        CommaText = L",";
    }

    if (ClassFlags & 2)
    {
        wcscat(ClassFlagsText, CommaText);
        wcscat(ClassFlagsText, L"\"createonly\"");
        CommaText = L",";
    }

    if (ClassFlags & 32)
    {
        wcscat(ClassFlagsText, CommaText);
        wcscat(ClassFlagsText, L"\"safeupdate\"");
        CommaText = L",";
    }

    if (ClassFlags & 64)
    {
        wcscat(ClassFlagsText, CommaText);
        wcscat(ClassFlagsText, L"\"forceupdate\"");
        CommaText = L",";
    }

    WmipAssert(*ClassFlagsText != 0);
    
    return(ClassFlagsText);
}

ULONG WatchClassInstanceFlags(
    PMOFFILETARGET MofFileTarget,
    CBMOFObj *Obj,
    PWCHAR ClassName,
    PWCHAR PragmaName,
    LONG *Flags
)
{
    ULONG Status;
    LONG NewFlags;
    WCHAR FlagsText[MAX_PATH];
    ULONG DataType;
    CBMOFDataItem Property;
    
    DataType = VT_I4;
    Status = WmipFindProperty(Obj,
                              ClassName,
                              &Property,
                              &DataType,
                              &NewFlags);
        
    if (Status == ERROR_SUCCESS)
    {   
        if (*Flags != NewFlags)
        {
            //
            // Flags have just appeared or
            // changed so spit out a #pragma
            //
            WmipDebugPrint(("BmofLocParser: %ws changed to %ws\n",
                            PragmaName,
                               MakeClassInstanceFlagsText(FlagsText,
                                                          NewFlags)));
                            
            Status = FilePrint(MofFileTarget,
                               L"\r\n#pragma %ws(%ws)\r\n\r\n",
                               PragmaName,
                               MakeClassInstanceFlagsText(FlagsText,
                                                          NewFlags));
            *Flags = NewFlags;
        }
                        
    } else if (Status == ERROR_FILE_NOT_FOUND) {
        Status = ERROR_SUCCESS;
    }
    
    return(Status);
}

ULONG WatchForEnglishMof(
    PMOFFILETARGET MofFileTarget,
    PWCHAR Namespace,
    ULONG ClassFlags,
    CBMOFObj *Obj
    )
{
    WCHAR *Name = NULL;
    WCHAR *NamespaceName = NULL;
    ULONG DataType;
    CBMOFDataItem MofPropertyData;
    ULONG Status;
    WCHAR s[MAX_PATH];
    
    //
    // We are looking for an instance of __namespace
    //
    if (GetName(Obj, &Name))
    {
        if ( (GetType(Obj) == MofObjectTypeInstance) &&
             (_wcsicmp(Name, L"__namespace") == 0) )          
        {
            //
            // Now if we are dropping down to a namespace that ends in
            // ms_409 then that means we have an english amendment and
            // want to make a copy of it. Otherwise we want to stop
            // making copies. We determine the namespace we are
            // creating by looking at the value of the name property.
            //
            DataType = VT_BSTR;
            Status = WmipFindProperty(Obj,
                                      L"name",
                                      &MofPropertyData,
                                      &DataType,
                                      (PVOID)&NamespaceName);
            if (Status == ERROR_SUCCESS)
            {
                if (_wcsicmp(NamespaceName, L"ms_409") == 0)
                {
                    //
                    // moving to the english locale, so start writing
                    // english
                    //
                    MofFileTarget->WriteToEnglish = TRUE;
                    Status = FilePrintToHandle(MofFileTarget->EnglishMofHandle,
                                       L"\r\n\r\n"
                                       L"#pragma classflags(%d)\r\n"
                                       L"#pragma namespace(\"%ws\")\r\n",
                                       ClassFlags,
                                       AddSlashesToString(s, Namespace));
                                       
                } else {
                    //
                    // moving to a different locale, so stop writing
                    // english
                    //
                    MofFileTarget->WriteToEnglish = FALSE;
                }
                BMOFFree(NamespaceName);
            } else if (Status == ERROR_FILE_NOT_FOUND) {
                //
                // Did not find the property we wanted. Not a good
                // thing, but not fatal.
                //
                Status = ERROR_SUCCESS;
            }
        } else {
            Status = ERROR_SUCCESS;
        }
        
        BMOFFree(Name);
    } else {
        Status = ERROR_SUCCESS;
    }
    return(Status);
}

BOOLEAN ConvertBmfToMof(
    PUCHAR BinaryMofData,
    TCHAR *MofFile,
    TCHAR *EnglishMofFile
    )
{
    HANDLE FileHandle;
    ULONG Status;
    CBMOFObjList *ObjList;
    CBMOFObj *Obj;
    PUCHAR UncompressedBmof;
    ULONG UncompressedBmofSize;
    WCHAR Namespace[MAX_PATH];
    PWCHAR NewNamespace;
    ULONG DataType;
    CBMOFDataItem Property;
    LONG ClassFlags, InstanceFlags;
    WCHAR w;
    MOFFILETARGET MofFileTarget;
    
    //
    // First thing is to try to create the output files in which we will
    // generate the unicode MOF text
    //
    FileHandle = CreateFile(MofFile,
                                GENERIC_READ | GENERIC_WRITE,
                                0,
                                NULL,
                                CREATE_ALWAYS,
                                FILE_ATTRIBUTE_NORMAL,
                                NULL);

    if (FileHandle != INVALID_HANDLE_VALUE)
    {
        //
        // Now open english mof file
        //
        if (*EnglishMofFile != 0)
        {
            MofFileTarget.EnglishMofHandle = CreateFile(EnglishMofFile,
                                GENERIC_READ | GENERIC_WRITE,
                                0,
                                NULL,
                                CREATE_ALWAYS,
                                FILE_ATTRIBUTE_NORMAL,
                                NULL);
        } else {
            MofFileTarget.EnglishMofHandle = NULL;
        }

        if (MofFileTarget.EnglishMofHandle != INVALID_HANDLE_VALUE)
        {
            //
            // Initialize the mof file target information
            //
            MofFileTarget.MofHandle = FileHandle;
            MofFileTarget.WriteToEnglish = FALSE;
            
            //
            // Write magic header that signifies that this is a unicode
            // file
            //
            w = 0xfeff;
            Status = FilePrintToHandle(FileHandle,
                               L"%wc",
                               w);
            
            if (Status == ERROR_SUCCESS)
            {       
                //
                // Uncompress the binary mof data so that we can work with it
                //
                Status = WmipDecompressBuffer(BinaryMofData,
                                              &UncompressedBmof,
                                              &UncompressedBmofSize);
                
                if (Status == ERROR_SUCCESS)
                {
                    WmipDebugPrint(("BmofLocParser: %s uncompressed to %d bytes\n",
                                    MofFile, UncompressedBmofSize));
                    WmipAssert(UncompressedBmof != NULL);
                    MofFileTarget.UncompressedBlob = UncompressedBmof;
                    
                    //
                    // We start in the root\default namespace by default
                    //
                    wcscpy(Namespace, L"root\\default");
                    
                    ClassFlags = 0;
                    InstanceFlags = 0;
                    
                    //
                    // Create the binary mof object list and related structures
                    // so that we can later enumerate over them and
                    // reconstitute them back into unicode text
                    //
                    ObjList = CreateObjList(UncompressedBmof);
                    if(ObjList != NULL)
                    {
                        ResetObjList(ObjList);
                        
                        while ((Obj = NextObj(ObjList)) &&
                               (Status == ERROR_SUCCESS))
                        {

                            //
                            // Watch for a new namespace instance and
                            // see if we are create an instance for
                            // "\\\\.\\root\\wmi\\ms_409". If so then
                            // turn on writing to the english mof,
                            // otherwise turn it off
                            //
                            if (MofFileTarget.EnglishMofHandle != NULL)
                            {
                                Status = WatchForEnglishMof(&MofFileTarget,
                                                        Namespace,
                                                        ClassFlags,
                                                        Obj);
                            }

                            if (Status == ERROR_SUCCESS)
                            {
                                //
                                // Watch for change in namespace and if so then
                                // spit out a #pragma namespace to track it
                                //
                                DataType = VT_BSTR;
                                Status = WmipFindProperty(Obj,
                                    L"__NAMESPACE",
                                    &Property,
                                    &DataType,
                                    (PVOID)&NewNamespace);
                            }
                            
                            if (Status == ERROR_SUCCESS)
                            {
                                if (_wcsicmp(Namespace, NewNamespace) != 0)
                                {
                                    //
                                    // Namespace has changed, spit out a
                                    // #pragma
                                    //
                                    WmipDebugPrint(("BmofLocParser: Switching from namespace %ws to %ws\n",
                                        Namespace, NewNamespace));
                                
                                    Status = FilePrint(&MofFileTarget,
                                        L"\r\n#pragma namespace(\"%ws\")\r\n\r\n",
                                        AddSlashesToString(Namespace, NewNamespace));
                                    wcscpy(Namespace, NewNamespace);
                                }
                                BMOFFree(NewNamespace);                        
                            } else if (Status == ERROR_FILE_NOT_FOUND) {
                                Status = ERROR_SUCCESS;
                            }
                            
                            //
                            // Watch for change in classflags
                            //
                            if (Status == ERROR_SUCCESS)
                            {
                                Status = WatchClassInstanceFlags(&MofFileTarget,
                                    Obj,
                                    L"__ClassFlags",
                                    L"Classflags",
                                    &ClassFlags);
                            }
                            
                            //
                            // Watch for change in instance flags
                            //
                            if (Status == ERROR_SUCCESS)
                            {
                                Status = WatchClassInstanceFlags(&MofFileTarget,
                                    Obj,
                                    L"__InstanceFlags",
                                    L"Instanceflags",
                                    &InstanceFlags);
                            }
                            
                            
                            //
                            // Generate mof for this object
                            //
                            if (Status == ERROR_SUCCESS)
                            {
                                Status = GenerateMofForObj(&MofFileTarget,
                                    Obj);
                            }
                            BMOFFree(Obj);
                        }
                        
                        BMOFFree(ObjList);
                    } else {
                        // TODO: LocStudio message
                        Status = ERROR_INVALID_PARAMETER;
                    }
                    
                    WmipFree(UncompressedBmof);
                }
            }
            
            CloseHandle(FileHandle);
            if (MofFileTarget.EnglishMofHandle != NULL)
            {
                CloseHandle(MofFileTarget.EnglishMofHandle);                
            }
            
            if (Status != ERROR_SUCCESS)
            {
                //
                // There was some error generating the MOF text and we are
                // going to return a failure. Make sure to clean up any
                // temporary file created
                //
                WmipDebugPrint(("BmofLocParser: BMF parsing returns error %d\n",
                                Status));
#if 0               
                DebugBreak();
#endif              
                
                DeleteFile(MofFile);
                DeleteFile(EnglishMofFile);
            }

        } else {
            CloseHandle(FileHandle);
            DeleteFile(MofFile);
			Status = GetLastError();
        }
    } else {
        Status = GetLastError();
    }
    
    return((Status == ERROR_SUCCESS) ? TRUE : FALSE);
}