Open sourcing ILASM

[tfs-changeset: 1555681]

45 files changed, 22812 insertions, 0 deletions

diff --git a/src/dlls/mscorpe/.gitmirrorall b/src/dlls/mscorpe/.gitmirrorall
new file mode 100644
index 0000000000..9ee5c57b99
--- /dev/null
+++ b/src/dlls/mscorpe/.gitmirrorall
@@ -0,0 +1 @@
+This folder will be mirrored by the Git-TFS Mirror recursively.
\ No newline at end of file
diff --git a/src/dlls/mscorpe/Native.rc b/src/dlls/mscorpe/Native.rc
new file mode 100644
index 0000000000..1711906807
--- /dev/null
+++ b/src/dlls/mscorpe/Native.rc
@@ -0,0 +1,9 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft .NET Runtime PE File Generator\0"
+
+#include <fxver.h>
+#include <fxver.rc>
diff --git a/src/dlls/mscorpe/ceefilegenwriter.cpp b/src/dlls/mscorpe/ceefilegenwriter.cpp
new file mode 100644
index 0000000000..867512d068
--- /dev/null
+++ b/src/dlls/mscorpe/ceefilegenwriter.cpp
@@ -0,0 +1,2022 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+// Derived class from CCeeGen which handles writing out
+// the exe. All references to PEWriter pulled out of CCeeGen,
+// and moved here
+//
+//
+
+#include "stdafx.h"
+
+#include <string.h>
+#include <limits.h>
+
+#include "corerror.h"
+#include "stubs.h"
+#include <posterror.h>
+#include <shlwapi.h>
+
+// Globals.
+HINSTANCE       g_hThisInst;            // This library.
+
+
+#ifdef EMIT_FIXUPS
+
+// Emitted PEFIXUP structure looks like this
+struct PEFIXUP
+{
+   WORD  wType;
+   WORD  wSpare;
+   DWORD rva;
+   DWORD rvaTarget;
+};
+
+// Following structure is used to store the reloc information which
+// will be used at UpdateFixups time to get the final data from the section
+// bytes to update the fixup information.
+//
+struct DBG_FIXUP
+{
+   WORD  wType;
+   WORD  wSpare;
+
+   union
+   {
+      DWORD rva;
+      unsigned offset;
+   };
+
+   union
+   {
+      DWORD rvaTarget;
+      CeeSection * sectionSource;
+   };
+};
+
+enum
+{
+   IMAGE_REL_I386_DIR24NB          = 0x0081,   // 24-bit base relative
+   IMAGE_REL_I386_FILEPOS          = 0x0082,   // 32-bit file relative
+                                               // all other relocation types are
+                                               // in winnt.h, for some reason
+                                               // this one is missing
+   IMAGE_REL_I386_DIR30NB          = 0x0083,   // 30-bit base relative
+};
+
+#endif // EMIT_FIXUPS
+
+// Get the Symbol entry given the head and a 0-based index
+inline IMAGE_SYMBOL* GetSymbolEntry(IMAGE_SYMBOL* pHead, SIZE_T idx)
+{
+    return (IMAGE_SYMBOL*) (((BYTE*) pHead) + IMAGE_SIZEOF_SYMBOL * idx);
+}
+
+#ifdef EnC_SUPPORTED
+#define ENC_DELTA_HACK
+#endif
+
+#ifdef ENC_DELTA_HACK
+    BOOL g_EnCMode = FALSE;
+#endif
+
+//*****************************************************************************
+// To get a new instance, call CreateNewInstance() or CreateNewInstanceEx() instead of new
+//*****************************************************************************
+
+HRESULT CeeFileGenWriter::CreateNewInstance(CCeeGen *pCeeFileGenFrom,
+                                            CeeFileGenWriter* & pGenWriter,
+                                            DWORD createFlags)
+{
+    return CreateNewInstanceEx(pCeeFileGenFrom, pGenWriter, createFlags);
+}
+
+//
+// Seed file is used as the base file. The new file data will be "appended" to the seed file
+//
+
+HRESULT CeeFileGenWriter::CreateNewInstanceEx(CCeeGen *pCeeFileGenFrom,
+                                              CeeFileGenWriter* & pGenWriter,
+                                              DWORD createFlags,
+                                              LPCWSTR seedFileName)
+{
+    HRESULT hr = S_OK;
+    ULONG preallocatedOffset = 0;
+    NewHolder<PEWriter> pPEWriter(NULL);
+    NewHolder<CeeFileGenWriter> pPrivateGenWriter;
+    CeeSection *corHeaderSection = NULL;
+
+    pPrivateGenWriter = new (nothrow) CeeFileGenWriter;
+    if (pPrivateGenWriter == NULL)
+        IfFailGo(E_OUTOFMEMORY);
+
+    pPEWriter = new (nothrow) PEWriter;
+    if (pPEWriter == NULL)
+        IfFailGo(E_OUTOFMEMORY);
+
+    //workaround
+    //What's really the correct thing to be doing here?
+    //HRESULT hr = pPEWriter->Init(pCeeFileGenFrom ? pCeeFileGenFrom->getPESectionMan() : NULL);
+    hr = pPEWriter->Init(NULL, createFlags, seedFileName);
+    IfFailGo(hr);
+
+    //Create the general PEWriter.
+    pPrivateGenWriter->m_peSectionMan = pPEWriter;
+    hr = pPrivateGenWriter->Init(); // base class member to finish init
+    IfFailGo(hr);
+
+    if (!seedFileName) // Use base file's preferred base (if present)
+    {
+        if (pPEWriter->isPE32())
+        {
+            pPrivateGenWriter->setImageBase((DWORD) CEE_IMAGE_BASE_32);   // use same default as linker
+        }
+        else
+        {
+            pPrivateGenWriter->setImageBase64((ULONGLONG) CEE_IMAGE_BASE_64); // use same default as linker
+        }
+    }
+
+    pPrivateGenWriter->setSubsystem(IMAGE_SUBSYSTEM_WINDOWS_CUI, CEE_IMAGE_SUBSYSTEM_MAJOR_VERSION, CEE_IMAGE_SUBSYSTEM_MINOR_VERSION);
+
+    if (pPEWriter->createCorMainStub())
+    {
+        hr = pPrivateGenWriter->allocateIAT(); // so the IAT goes out first
+        IfFailGo(hr);
+    }
+
+    hr = pPrivateGenWriter->allocateCorHeader();   // get COR header near front
+    IfFailGo(hr);
+
+#if 0 // Need to add this if we want to propagate the old COM+ header
+    if (seedFileName)
+    {
+        memcpy(m_corHeader, baseFileDecoder->ntHeaders32()->corHeader, sizeof(IMAGE_COR20_HEADER));
+    }
+#endif
+
+    //If we were passed a CCeeGen at the beginning, copy it's data now.
+    if (pCeeFileGenFrom) {
+        pCeeFileGenFrom->cloneInstance((CCeeGen*)pPrivateGenWriter);
+    }
+   
+    hr = pPrivateGenWriter->getSectionCreate(".text0", sdExecute, &corHeaderSection);
+    IfFailGo(hr);
+    preallocatedOffset = corHeaderSection->dataLen();
+    
+
+    // set il RVA to be after the preallocated sections
+    pPEWriter->setIlRva(preallocatedOffset);
+
+#ifdef EMIT_FIXUPS
+    if (createFlags & ICEE_CREATE_FILE_EMIT_FIXUPS)
+    {
+        pPrivateGenWriter->setEmitFixups();
+    }
+#endif
+
+    pPEWriter.SuppressRelease();
+    pPrivateGenWriter.SuppressRelease();
+    pGenWriter = pPrivateGenWriter;
+
+ErrExit:
+    return hr;
+} // HRESULT CeeFileGenWriter::CreateNewInstance()
+
+CeeFileGenWriter::CeeFileGenWriter() // ctor is protected
+{
+    m_outputFileName = NULL;
+    m_resourceFileName = NULL;
+    m_dllSwitch = false;
+    m_objSwitch = false;
+    m_libraryName = NULL;
+    m_libraryGuid = GUID_NULL;
+
+    m_entryPoint = 0;
+    m_comImageFlags = COMIMAGE_FLAGS_ILONLY;    // ceegen PEs don't have native code
+    m_iatOffset = 0;
+    m_dllCount = 0;
+
+    m_dwMacroDefinitionSize = 0;
+    m_dwMacroDefinitionRVA = NULL;
+
+    m_dwManifestSize = 0;
+    m_dwManifestRVA = NULL;
+
+    m_dwStrongNameSize = 0;
+    m_dwStrongNameRVA = NULL;
+
+    m_dwVTableSize = 0;
+    m_dwVTableRVA = NULL;
+
+    m_iDataDlls = NULL;
+
+    m_linked = false;
+    m_fixed = false;
+
+#ifdef EMIT_FIXUPS
+
+    m_fEmitFixups = false;
+    m_fFixupsUpdated = false;
+    m_sectionFixups = NULL;
+    m_pDebugDir = NULL;
+
+#endif
+
+#ifdef ENC_DELTA_HACK
+    // for EnC we want the RVA to be right at the front of the IL stream
+    WCHAR szFileName[256];
+    DWORD len = WszGetEnvironmentVariable(L"COMP_ENC_EMIT", szFileName, NumItems(szFileName));
+    if (len > 0)
+        g_EnCMode = TRUE;
+#endif
+
+} // CeeFileGenWriter::CeeFileGenWriter()
+
+//*****************************************************************************
+// Cleanup
+//*****************************************************************************
+HRESULT CeeFileGenWriter::Cleanup() // virtual
+{
+    ((PEWriter *)m_peSectionMan)->Cleanup();  // call derived cleanup
+    delete m_peSectionMan;
+    m_peSectionMan = NULL; // so base class won't delete
+
+    delete[] m_outputFileName;
+    delete[] m_resourceFileName;
+
+    if (m_iDataDlls) {
+        for (int i=0; i < m_dllCount; i++) {
+            if (m_iDataDlls[i].m_methodName)
+                delete[] m_iDataDlls[i].m_methodName;
+        }
+        delete[] m_iDataDlls;
+    }
+
+    return CCeeGen::Cleanup();
+} // HRESULT CeeFileGenWriter::Cleanup()
+
+HRESULT CeeFileGenWriter::EmitMacroDefinitions(void *pData, DWORD cData)
+{
+    // OBSOLETE
+    m_dwMacroDefinitionSize = 0;
+
+    return S_OK;
+} // HRESULT CeeFileGenWriter::EmitMacroDefinitions()
+
+HRESULT CeeFileGenWriter::link()
+{
+    HRESULT hr = checkForErrors();
+    if (! SUCCEEDED(hr))
+        return hr;
+
+#ifdef EMIT_FIXUPS
+
+    // The fixups describe each relocation.  Each fixup contains the relocation's
+    // type, source RVA, and target RVA.  Since the reloc target can be filled
+    // in after the relocation creation, the fixup target RVA discovery needs to
+    // be deferred.
+    // At this point all bytes should be filled in, ensuring that the final
+    // target information is available.
+    // UpdateFixups is called at this point to discover the final relocation target info.
+    //
+    hr = UpdateFixups();
+    if (! SUCCEEDED(hr))
+        return hr;
+
+#endif
+
+    // Don't set this if SetManifestEntry was not called - zapper sets the
+    // resource directory explicitly
+    if (m_dwManifestSize != 0)
+    {
+        m_corHeader->Resources.VirtualAddress = VAL32(m_dwManifestRVA);
+        m_corHeader->Resources.Size = VAL32(m_dwManifestSize);
+    }
+
+    if (m_dwStrongNameSize != 0)
+    {
+        m_corHeader->StrongNameSignature.VirtualAddress = VAL32(m_dwStrongNameRVA);
+        m_corHeader->StrongNameSignature.Size = VAL32(m_dwStrongNameSize);
+    }
+
+    if (m_dwVTableSize != 0)
+    {
+        m_corHeader->VTableFixups.VirtualAddress = VAL32(m_dwVTableRVA);
+        m_corHeader->VTableFixups.Size = VAL32(m_dwVTableSize);
+    }
+
+    unsigned characteristicsMask = IMAGE_FILE_EXECUTABLE_IMAGE;
+
+    if (getPEWriter().isPE32())
+        characteristicsMask |= IMAGE_FILE_32BIT_MACHINE;
+    if (!getPEWriter().isPE32())
+        characteristicsMask |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
+
+    getPEWriter().setCharacteristics(characteristicsMask);
+
+    m_corHeader->cb = VAL32(sizeof(IMAGE_COR20_HEADER));
+    m_corHeader->MajorRuntimeVersion = VAL16(COR_VERSION_MAJOR);
+    m_corHeader->MinorRuntimeVersion = VAL16(COR_VERSION_MINOR);
+    if (m_dllSwitch)
+        getPEWriter().setCharacteristics(IMAGE_FILE_DLL);
+    if (m_objSwitch)
+        getPEWriter().clearCharacteristics(IMAGE_FILE_DLL | IMAGE_FILE_EXECUTABLE_IMAGE);
+    m_corHeader->Flags = VAL32(m_comImageFlags);
+    IMAGE_COR20_HEADER_FIELD(*m_corHeader, EntryPointToken) = VAL32(m_entryPoint);
+    _ASSERTE(TypeFromToken(m_entryPoint) == mdtMethodDef || m_entryPoint == mdTokenNil ||
+             TypeFromToken(m_entryPoint) == mdtFile);
+    setDirectoryEntry(getCorHeaderSection(), IMAGE_DIRECTORY_ENTRY_COMHEADER, sizeof(IMAGE_COR20_HEADER), m_corHeaderOffset);
+
+    if ((m_comImageFlags & COMIMAGE_FLAGS_IL_LIBRARY) == 0
+        && !m_linked && !m_objSwitch)
+    {
+        hr = emitExeMain();
+        if (FAILED(hr))
+            return hr;
+
+        hr = emitResourceSection();
+        if (FAILED(hr))
+            return hr;
+    }
+
+    m_linked = true;
+
+    IfFailRet(getPEWriter().link());
+
+    return S_OK;
+} // HRESULT CeeFileGenWriter::link()
+
+
+HRESULT CeeFileGenWriter::fixup()
+{
+    HRESULT hr;
+
+    m_fixed = true;
+
+    if (!m_linked)
+        IfFailRet(link());
+
+    CeeGenTokenMapper *pMapper = getTokenMapper();
+
+    // Apply token remaps if there are any.
+    if (! m_fTokenMapSupported && pMapper != NULL) {
+        IMetaDataImport *pImport;
+        hr = pMapper->GetMetaData(&pImport);
+        _ASSERTE(SUCCEEDED(hr));
+        hr = MapTokens(pMapper, pImport);
+        pImport->Release();
+
+    }
+
+    // remap the entry point if entry point token has been moved
+    if (pMapper != NULL && !m_objSwitch)
+    {
+        mdToken tk = m_entryPoint;
+        pMapper->HasTokenMoved(tk, tk);
+        IMAGE_COR20_HEADER_FIELD(*m_corHeader, EntryPointToken) = VAL32(tk);
+    }
+
+    IfFailRet(getPEWriter().fixup(pMapper));
+
+    return S_OK;
+} // HRESULT CeeFileGenWriter::fixup()
+
+HRESULT CeeFileGenWriter::generateImage(void **ppImage)
+{
+    HRESULT hr = S_OK;
+    LPWSTR outputFileName = NULL;
+
+    HANDLE hThreadToken = NULL;
+    // Impersonation is only supported on Win2k and above. 
+    if (!OpenThreadToken(GetCurrentThread(), TOKEN_READ | TOKEN_IMPERSONATE, TRUE, &hThreadToken)) 
+    {
+        if (GetLastError() != ERROR_NO_TOKEN) 
+        {
+            _ASSERTE(!"Failed to get thread token!");
+            return HRESULT_FROM_GetLastError();
+        }
+    }
+    
+    if (hThreadToken != NULL) 
+    {
+        if (!RevertToSelf()) 
+        {
+            _ASSERTE(!"Failed to revert impersonation!");
+            CloseHandle(hThreadToken);
+            return HRESULT_FROM_GetLastError();
+        }                
+    }
+
+#ifdef ENC_DELTA_HACK
+    // fixups break because we've set the base RVA to 0 for the delta stream
+    if (! g_EnCMode)
+#endif
+        if (!m_fixed)
+            IfFailGo(fixup());
+
+    outputFileName = m_outputFileName;
+
+    if (! outputFileName && ppImage == NULL) {
+        if (m_comImageFlags & COMIMAGE_FLAGS_IL_LIBRARY)
+            outputFileName = L"output.ill";
+        else if (m_dllSwitch)
+            outputFileName = L"output.dll";
+        else if (m_objSwitch)
+            outputFileName = L"output.obj";
+        else
+            outputFileName = L"output.exe";
+    }
+
+    // output file name and ppImage are mutually exclusive
+    _ASSERTE((NULL == outputFileName && ppImage != NULL) || (outputFileName != NULL && NULL == ppImage));
+
+    if (outputFileName != NULL)
+        IfFailGo(getPEWriter().write(outputFileName));
+    else
+        IfFailGo(getPEWriter().write(ppImage));
+
+ErrExit:
+    if (hThreadToken != NULL) 
+    {
+        BOOL success = SetThreadToken(NULL, hThreadToken);
+        CloseHandle(hThreadToken);
+    
+        if (!success) 
+        {
+            _ASSERTE(!"Failed to reimpersonate!");
+            hr = HRESULT_FROM_GetLastError();
+        }
+    }
+    return hr;
+} // HRESULT CeeFileGenWriter::generateImage()
+
+HRESULT CeeFileGenWriter::setOutputFileName(__in LPWSTR fileName)
+{
+    if (m_outputFileName)
+        delete[] m_outputFileName;
+    int len = lstrlenW(fileName) + 1;
+    m_outputFileName = (LPWSTR)new (nothrow) WCHAR[len];
+    TESTANDRETURN(m_outputFileName!=NULL, E_OUTOFMEMORY);
+    wcscpy_s(m_outputFileName, len, fileName);
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setOutputFileName()
+
+HRESULT CeeFileGenWriter::setResourceFileName(__in LPWSTR fileName)
+{
+    if (m_resourceFileName)
+        delete[] m_resourceFileName;
+    int len = lstrlenW(fileName) + 1;
+    m_resourceFileName = (LPWSTR)new (nothrow) WCHAR[len];
+    TESTANDRETURN(m_resourceFileName!=NULL, E_OUTOFMEMORY);
+    wcscpy_s(m_resourceFileName, len, fileName);
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setResourceFileName()
+
+HRESULT CeeFileGenWriter::setLibraryName(__in LPWSTR libraryName)
+{
+    if (m_libraryName)
+        delete[] m_libraryName;
+    int len = lstrlenW(libraryName) + 1;
+    m_libraryName = (LPWSTR)new (nothrow) WCHAR[len];
+    TESTANDRETURN(m_libraryName != NULL, E_OUTOFMEMORY);
+    wcscpy_s(m_libraryName, len, libraryName);
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setLibraryName()
+
+HRESULT CeeFileGenWriter::setLibraryGuid(__in LPWSTR libraryGuid)
+{
+    return IIDFromString(libraryGuid, &m_libraryGuid);
+} // HRESULT CeeFileGenWriter::setLibraryGuid()
+
+HRESULT CeeFileGenWriter::emitLibraryName(IMetaDataEmit *emitter)
+{
+    HRESULT hr;
+    IfFailRet(emitter->SetModuleProps(m_libraryName));
+
+    // Set the GUID as a custom attribute, if it is not NULL_GUID.
+    if (m_libraryGuid != GUID_NULL)
+    {
+        static COR_SIGNATURE _SIG[] = INTEROP_GUID_SIG;
+        mdTypeRef tr;
+        mdMemberRef mr;
+        WCHAR wzGuid[40];
+        BYTE  rgCA[50];
+        IfFailRet(emitter->DefineTypeRefByName(mdTypeRefNil, INTEROP_GUID_TYPE_W, &tr));
+        IfFailRet(emitter->DefineMemberRef(tr, L".ctor", _SIG, sizeof(_SIG), &mr));
+        StringFromGUID2(m_libraryGuid, wzGuid, lengthof(wzGuid));
+        memset(rgCA, 0, sizeof(rgCA));
+        // Tag is 0x0001
+        rgCA[0] = 1;
+        // Length of GUID string is 36 characters.
+        rgCA[2] = 0x24;
+        // Convert 36 characters, skipping opening {, into 3rd byte of buffer.
+        WszWideCharToMultiByte(CP_ACP,0, wzGuid+1,36, reinterpret_cast<char*>(&rgCA[3]),36, 0,0);
+        hr = emitter->DefineCustomAttribute(1,mr,rgCA,41,0);
+    }
+    return (hr);
+} // HRESULT CeeFileGenWriter::emitLibraryName()
+
+HRESULT CeeFileGenWriter::setImageBase(size_t imageBase)
+{
+    _ASSERTE(getPEWriter().isPE32());
+        getPEWriter().setImageBase32((DWORD)imageBase);
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setImageBase()
+
+HRESULT CeeFileGenWriter::setImageBase64(ULONGLONG imageBase)
+{
+    _ASSERTE(!getPEWriter().isPE32());
+    getPEWriter().setImageBase64(imageBase);
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setImageBase64()
+
+HRESULT CeeFileGenWriter::setFileAlignment(ULONG fileAlignment)
+{
+    getPEWriter().setFileAlignment(fileAlignment);
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setFileAlignment()
+
+HRESULT CeeFileGenWriter::setSubsystem(DWORD subsystem, DWORD major, DWORD minor)
+{
+    getPEWriter().setSubsystem(subsystem, major, minor);
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setSubsystem()
+
+HRESULT CeeFileGenWriter::checkForErrors()
+{
+    if (TypeFromToken(m_entryPoint) == mdtMethodDef) {
+        if (m_dllSwitch) {
+            //current spec would need to check the binary sig of the entry point method
+        }
+        return S_OK;
+    }
+    return S_OK;
+} // HRESULT CeeFileGenWriter::checkForErrors()
+
+HRESULT CeeFileGenWriter::getMethodRVA(ULONG codeOffset, ULONG *codeRVA)
+{
+    _ASSERTE(codeRVA);
+#ifdef ENC_DELTA_HACK
+    // for EnC we want the RVA to be right be relative to the front of the delta IL stream rather
+    // than take into account the .text section and the cor header as we would for a real PE file
+    if (g_EnCMode)
+        *codeRVA = codeOffset;
+    else
+#endif
+        *codeRVA = getPEWriter().getIlRva() + codeOffset;
+    return S_OK;
+} // HRESULT CeeFileGenWriter::getMethodRVA()
+
+HRESULT CeeFileGenWriter::setDirectoryEntry(CeeSection &section, ULONG entry, ULONG size, ULONG offset)
+{
+    return getPEWriter().setDirectoryEntry((PEWriterSection*)(&section.getImpl()), entry, size, offset);
+} // HRESULT CeeFileGenWriter::setDirectoryEntry()
+
+HRESULT CeeFileGenWriter::getFileTimeStamp(DWORD *pTimeStamp)
+{
+    return getPEWriter().getFileTimeStamp(pTimeStamp);
+} // HRESULT CeeFileGenWriter::getFileTimeStamp()
+
+HRESULT CeeFileGenWriter::setAddrReloc(UCHAR *instrAddr, DWORD value)
+{
+    *(DWORD *)instrAddr = VAL32(value);
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setAddrReloc()
+
+HRESULT CeeFileGenWriter::addAddrReloc(CeeSection &thisSection, UCHAR *instrAddr, DWORD offset, CeeSection *targetSection)
+{
+    if (!targetSection) {
+        thisSection.addBaseReloc(offset, srRelocHighLow);
+    } else {
+        thisSection.addSectReloc(offset, *targetSection, srRelocHighLow);
+    }
+    return S_OK;
+} // HRESULT CeeFileGenWriter::addAddrReloc()
+
+// create CorExeMain and import directory into .text and the .iat into .data
+//
+// The structure of the import directory information is as follows, but it is not contiguous in
+// section. All the r/o data goes into the .text section and the iat array (which the loader
+// updates with the imported addresses) goes into the .data section because WINCE needs it to be writable.
+//
+//    struct IData {
+//      // one for each DLL, terminating in NULL
+//      IMAGE_IMPORT_DESCRIPTOR iid[];
+//      // import lookup table: a set of entries for the methods of each DLL,
+//      // terminating each set with NULL
+//      IMAGE_THUNK_DATA32/64 ilt[];
+//      // hint/name table: an set of entries for each method of each DLL wiht
+//      // no terminating entry
+//      struct {
+//          WORD Hint;
+//          // null terminated string
+//          BYTE Name[];
+//      } ibn;      // Hint/name table
+//      // import address table: a set of entries for the methods of each DLL,
+//      // terminating each set with NULL
+//      IMAGE_THUNK_DATA32/64 iat[];
+//      // one for each DLL, null terminated strings
+//      BYTE DllName[];
+//  };
+//
+
+// IAT must be first in its section, so have code here to allocate it up front
+// prior to knowing other info such as if dll or not. This won't work if have > 1
+// function imported, but we'll burn that bridge when we get to it.
+HRESULT CeeFileGenWriter::allocateIAT()
+{
+    m_dllCount = 1;
+    m_iDataDlls = new (nothrow) IDataDllInfo[m_dllCount];
+    if (m_iDataDlls == NULL) {
+        return E_OUTOFMEMORY;
+    }
+    memset(m_iDataDlls, '\0', m_dllCount * sizeof(IDataDllInfo));
+    m_iDataDlls[0].m_name = "mscoree.dll";
+    m_iDataDlls[0].m_numMethods = 1;
+    m_iDataDlls[0].m_methodName = new (nothrow) const char*[m_iDataDlls[0].m_numMethods];
+    if (! m_iDataDlls[0].m_methodName) {
+        return E_OUTOFMEMORY;
+    }
+    m_iDataDlls[0].m_methodName[0] = NULL;
+
+    int iDataSizeIAT = 0;
+
+    for (int i=0; i < m_dllCount; i++) {
+        m_iDataDlls[i].m_iatOffset = iDataSizeIAT;
+        iDataSizeIAT += (m_iDataDlls[i].m_numMethods + 1)
+                      * (getPEWriter().isPE32() ? sizeof(IMAGE_THUNK_DATA32)
+                                                : sizeof(IMAGE_THUNK_DATA64));
+    }
+
+    HRESULT hr = getSectionCreate(".text0", sdExecute, &m_iDataSectionIAT);
+    TESTANDRETURNHR(hr);
+    m_iDataOffsetIAT = m_iDataSectionIAT->dataLen();
+    _ASSERTE(m_iDataOffsetIAT == 0);
+    m_iDataIAT = m_iDataSectionIAT->getBlock(iDataSizeIAT);
+    if (! m_iDataIAT) {
+        return E_OUTOFMEMORY;
+    }
+    memset(m_iDataIAT, '\0', iDataSizeIAT);
+
+    // Don't set the IAT directory entry yet, since we may not actually end up doing
+    // an emitExeMain.
+
+    return S_OK;
+} // HRESULT CeeFileGenWriter::allocateIAT()
+
+HRESULT CeeFileGenWriter::emitExeMain()
+{
+    if (m_dllCount == 0)
+        return S_OK;
+
+    // Note: code later on in this method assumes that mscoree.dll is at
+    // index m_iDataDlls[0], with CorDllMain or CorExeMain at method[0]
+
+    _ASSERTE(getPEWriter().createCorMainStub());
+
+    if (m_dllSwitch) {
+        m_iDataDlls[0].m_methodName[0] = "_CorDllMain";
+    } else {
+        m_iDataDlls[0].m_methodName[0] = "_CorExeMain";
+    }
+
+    // IMAGE_IMPORT_DESCRIPTOR on PE/PE+ must be 4-byte or 8-byte aligned
+    int align     = (getPEWriter().isPE32()) ? 4 : 8;
+    int curOffset = getTextSection().dataLen();
+
+    int diff = ((curOffset + align -1) & ~(align-1)) - curOffset;
+    if (diff)
+    {
+        char* pDiff = getTextSection().getBlock(diff);
+        if (NULL==pDiff) return E_OUTOFMEMORY;
+        memset(pDiff,0,diff);
+    }
+
+    int iDataSizeRO = (m_dllCount + 1) * sizeof(IMAGE_IMPORT_DESCRIPTOR);
+    CeeSection &iDataSectionRO = getTextSection();
+    int iDataOffsetRO = iDataSectionRO.dataLen();
+    int iDataSizeIAT = 0;
+    int i;
+    for (i=0; i < m_dllCount; i++) {
+        m_iDataDlls[i].m_iltOffset = iDataSizeRO + iDataSizeIAT;
+        iDataSizeIAT += (m_iDataDlls[i].m_numMethods + 1)
+                      * (getPEWriter().isPE32() ? sizeof(IMAGE_THUNK_DATA32)
+                                                : sizeof(IMAGE_THUNK_DATA64));
+    }
+
+    iDataSizeRO += iDataSizeIAT;
+
+    for (i=0; i < m_dllCount; i++) {
+        int delta = (iDataSizeRO + iDataOffsetRO) % 16;
+        // make sure is on a 16-byte offset
+        if (delta != 0)
+            iDataSizeRO += (16 - delta);
+        _ASSERTE((iDataSizeRO + iDataOffsetRO) % 16 == 0);
+        m_iDataDlls[i].m_ibnOffset = iDataSizeRO;
+        for (int j=0; j < m_iDataDlls[i].m_numMethods; j++) {
+            int nameLen = (int)(strlen(m_iDataDlls[i].m_methodName[j]) + 1);
+            iDataSizeRO += sizeof(WORD) + nameLen + nameLen%2;
+        }
+    }
+    for (i=0; i < m_dllCount; i++) {
+        m_iDataDlls[i].m_nameOffset = iDataSizeRO;
+        iDataSizeRO += (int)(strlen(m_iDataDlls[i].m_name) + 2);
+    }
+
+    char *iDataRO = iDataSectionRO.getBlock(iDataSizeRO);
+
+    if (!iDataRO) return E_OUTOFMEMORY;
+
+    memset(iDataRO, '\0', iDataSizeRO);
+
+    setDirectoryEntry(iDataSectionRO, IMAGE_DIRECTORY_ENTRY_IMPORT, iDataSizeRO, iDataOffsetRO);
+
+    IMAGE_IMPORT_DESCRIPTOR *iid = (IMAGE_IMPORT_DESCRIPTOR *)iDataRO;
+    for (i=0; i < m_dllCount; i++) {
+
+        // fill in the import descriptors for each DLL
+        IMAGE_IMPORT_DESC_FIELD(iid[i], OriginalFirstThunk) = VAL32((ULONG)(m_iDataDlls[i].m_iltOffset + iDataOffsetRO));
+        iid[i].Name = VAL32(m_iDataDlls[i].m_nameOffset + iDataOffsetRO);
+        iid[i].FirstThunk = VAL32((ULONG)(m_iDataDlls[i].m_iatOffset + m_iDataOffsetIAT));
+
+        iDataSectionRO.addSectReloc(
+            (unsigned)(iDataOffsetRO + (char *)(&IMAGE_IMPORT_DESC_FIELD(iid[i], OriginalFirstThunk)) - iDataRO), iDataSectionRO, srRelocAbsolute);
+        iDataSectionRO.addSectReloc(
+            (unsigned)(iDataOffsetRO + (char *)(&iid[i].Name) - iDataRO), iDataSectionRO, srRelocAbsolute);
+        iDataSectionRO.addSectReloc(
+            (unsigned)(iDataOffsetRO + (char *)(&iid[i].FirstThunk) - iDataRO), *m_iDataSectionIAT, srRelocAbsolute);
+
+        if (getPEWriter().isPE32())
+        {
+        // now fill in the import lookup table for each DLL
+            IMAGE_THUNK_DATA32 *ilt = (IMAGE_THUNK_DATA32*) (iDataRO + m_iDataDlls[i].m_iltOffset);
+            IMAGE_THUNK_DATA32 *iat = (IMAGE_THUNK_DATA32*) (m_iDataIAT + m_iDataDlls[i].m_iatOffset);
+
+            int ibnOffset = m_iDataDlls[i].m_ibnOffset;
+            for (int j=0; j < m_iDataDlls[i].m_numMethods; j++)
+            {
+                ilt[j].u1.AddressOfData = VAL32((ULONG)(ibnOffset + iDataOffsetRO));
+                iat[j].u1.AddressOfData = VAL32((ULONG)(ibnOffset + iDataOffsetRO));
+    
+                iDataSectionRO.addSectReloc( (unsigned)(iDataOffsetRO + (char *)(&ilt[j].u1.AddressOfData) - iDataRO),
+                                                iDataSectionRO, srRelocAbsolute);
+                m_iDataSectionIAT->addSectReloc( (unsigned)(m_iDataOffsetIAT + (char *)(&iat[j].u1.AddressOfData) - m_iDataIAT),
+                                                    iDataSectionRO, srRelocAbsolute);
+                int nameLen = (int)(strlen(m_iDataDlls[i].m_methodName[j]) + 1);
+                memcpy(iDataRO + ibnOffset + offsetof(IMAGE_IMPORT_BY_NAME, Name),
+                                        m_iDataDlls[i].m_methodName[j], nameLen);
+                ibnOffset += sizeof(WORD) + nameLen + nameLen%2;
+            }
+        }
+        else
+        {
+            // now fill in the import lookup table for each DLL
+            IMAGE_THUNK_DATA64 *ilt = (IMAGE_THUNK_DATA64*) (iDataRO + m_iDataDlls[i].m_iltOffset);
+            IMAGE_THUNK_DATA64 *iat = (IMAGE_THUNK_DATA64*) (m_iDataIAT + m_iDataDlls[i].m_iatOffset);
+
+            int ibnOffset = m_iDataDlls[i].m_ibnOffset;
+            for (int j=0; j < m_iDataDlls[i].m_numMethods; j++)
+            {
+                ilt[j].u1.AddressOfData = VAL64((ULONG)(ibnOffset + iDataOffsetRO));
+                iat[j].u1.AddressOfData = VAL64((ULONG)(ibnOffset + iDataOffsetRO));
+
+                iDataSectionRO.addSectReloc( (unsigned)(iDataOffsetRO + (char *)(&ilt[j].u1.AddressOfData) - iDataRO),
+                                             iDataSectionRO, srRelocAbsolute);
+                m_iDataSectionIAT->addSectReloc( (unsigned)(m_iDataOffsetIAT + (char *)(&iat[j].u1.AddressOfData) - m_iDataIAT),
+                                                 iDataSectionRO, srRelocAbsolute);
+                int nameLen = (int)(strlen(m_iDataDlls[i].m_methodName[j]) + 1);
+                memcpy(iDataRO + ibnOffset + offsetof(IMAGE_IMPORT_BY_NAME, Name),
+                       m_iDataDlls[i].m_methodName[j], nameLen);
+                ibnOffset += sizeof(WORD) + nameLen + nameLen%2;
+            }
+        }
+
+        // now fill in the import lookup table for each DLL
+        strcpy_s(iDataRO + m_iDataDlls[i].m_nameOffset, 
+                 iDataSizeRO - m_iDataDlls[i].m_nameOffset,
+                 m_iDataDlls[i].m_name);
+
+    } // end of for loop i < m_dllCount
+
+
+    if (getPEWriter().isI386())
+    {
+        // Put the entry point code into the PE file
+        unsigned entryPointOffset = getTextSection().dataLen();
+        int iatOffset = (int) (entryPointOffset + (m_dllSwitch ? CorDllMainX86IATOffset : CorExeMainX86IATOffset));
+        align = 4;    // x86 fixups must be 4-byte aligned
+
+        // The IAT offset must be aligned because fixup is applied to it.
+        diff = ((iatOffset + align -1) & ~(align-1)) - iatOffset;
+        if (diff)
+        {
+            char* pDiff = getTextSection().getBlock(diff);
+            if(NULL==pDiff) return E_OUTOFMEMORY;
+            memset(pDiff,0,diff);
+            entryPointOffset += diff;
+        }
+        _ASSERTE((getTextSection().dataLen() + (m_dllSwitch ? CorDllMainX86IATOffset : CorExeMainX86IATOffset)) % align == 0);
+
+        getPEWriter().setEntryPointTextOffset(entryPointOffset);
+        if (m_dllSwitch)
+        {
+            UCHAR *dllMainBuf = (UCHAR*)getTextSection().getBlock(sizeof(DllMainX86Template));
+            if(dllMainBuf==NULL) return E_OUTOFMEMORY;
+            memcpy(dllMainBuf, DllMainX86Template, sizeof(DllMainX86Template));
+            //mscoree.dll
+            setAddrReloc(dllMainBuf+CorDllMainX86IATOffset, m_iDataDlls[0].m_iatOffset + m_iDataOffsetIAT);
+            addAddrReloc(getTextSection(), dllMainBuf, entryPointOffset+CorDllMainX86IATOffset, m_iDataSectionIAT);
+        }
+        else
+        {
+            UCHAR *exeMainBuf = (UCHAR*)getTextSection().getBlock(sizeof(ExeMainX86Template));
+            if(exeMainBuf==NULL) return E_OUTOFMEMORY;
+            memcpy(exeMainBuf, ExeMainX86Template, sizeof(ExeMainX86Template));
+            //mscoree.dll
+            setAddrReloc(exeMainBuf+CorExeMainX86IATOffset, m_iDataDlls[0].m_iatOffset + m_iDataOffsetIAT);
+            addAddrReloc(getTextSection(), exeMainBuf, entryPointOffset+CorExeMainX86IATOffset, m_iDataSectionIAT);
+        }
+    }
+    else if (getPEWriter().isAMD64())
+    {
+        // Put the entry point code into the PE file
+        unsigned entryPointOffset = getTextSection().dataLen();
+        int iatOffset = (int) (entryPointOffset + (m_dllSwitch ? CorDllMainAMD64IATOffset : CorExeMainAMD64IATOffset));
+        align = 16;    // AMD64 fixups must be 8-byte aligned
+
+        // The IAT offset must be aligned because fixup is applied to it.
+        diff = ((iatOffset + align -1) & ~(align-1)) - iatOffset;
+        if (diff)
+        {
+            char* pDiff = getTextSection().getBlock(diff);
+            if(NULL==pDiff) return E_OUTOFMEMORY;
+            memset(pDiff,0,diff);
+            entryPointOffset += diff;
+        }
+        _ASSERTE((getTextSection().dataLen() + (m_dllSwitch ? CorDllMainAMD64IATOffset : CorExeMainAMD64IATOffset)) % align == 0);
+        
+        getPEWriter().setEntryPointTextOffset(entryPointOffset);
+        if (m_dllSwitch)
+        {
+            UCHAR *dllMainBuf = (UCHAR*)getTextSection().getBlock(sizeof(DllMainAMD64Template));
+            if(dllMainBuf==NULL) return E_OUTOFMEMORY;
+            memcpy(dllMainBuf, DllMainAMD64Template, sizeof(DllMainAMD64Template));
+            //mscoree.dll
+            setAddrReloc(dllMainBuf+CorDllMainAMD64IATOffset, m_iDataDlls[0].m_iatOffset + m_iDataOffsetIAT);
+            addAddrReloc(getTextSection(), dllMainBuf, entryPointOffset+CorDllMainAMD64IATOffset, m_iDataSectionIAT);
+        }
+        else
+        {
+            UCHAR *exeMainBuf = (UCHAR*)getTextSection().getBlock(sizeof(ExeMainAMD64Template));
+            if(exeMainBuf==NULL) return E_OUTOFMEMORY;
+            memcpy(exeMainBuf, ExeMainAMD64Template, sizeof(ExeMainAMD64Template));
+            //mscoree.dll
+            setAddrReloc(exeMainBuf+CorExeMainAMD64IATOffset, m_iDataDlls[0].m_iatOffset + m_iDataOffsetIAT);
+            addAddrReloc(getTextSection(), exeMainBuf, entryPointOffset+CorExeMainAMD64IATOffset, m_iDataSectionIAT);
+        }
+    }
+    else if (getPEWriter().isIA64())
+    {
+        // Must have a PE+ PE64 file
+        //_ASSERTE(!getPEWriter().isPE32());
+
+        // Put the entry point code into the PE+ file
+        curOffset = getTextSection().dataLen();
+        align = 16;       // instructions on ia64 must be 16-byte aligned
+
+        // The entry point address be aligned
+        diff = ((curOffset + align -1) & ~(align-1)) - curOffset;
+        if (diff)
+        {
+            char* pDiff = getTextSection().getBlock(diff);
+            if(NULL==pDiff) return E_OUTOFMEMORY;
+            memset(pDiff,0,diff);
+        }
+
+        unsigned entryPointOffset = getTextSection().dataLen();
+
+        if (m_dllSwitch)
+        {
+            UCHAR *dllMainBuf = (UCHAR*)getTextSection().getBlock(sizeof(DllMainIA64Template));
+            if (dllMainBuf==NULL) return E_OUTOFMEMORY;
+            memcpy(dllMainBuf, DllMainIA64Template, sizeof(DllMainIA64Template));
+        }
+        else
+        {
+            UCHAR *exeMainBuf = (UCHAR*)getTextSection().getBlock(sizeof(ExeMainIA64Template));
+            if (exeMainBuf==NULL) return E_OUTOFMEMORY;
+            memcpy(exeMainBuf, ExeMainIA64Template, sizeof(ExeMainIA64Template));
+        }
+
+        // Put the entry point function pointer into the PE file
+        unsigned entryPlabelOffset = getTextSection().dataLen();
+        getPEWriter().setEntryPointTextOffset(entryPlabelOffset);
+
+        UCHAR * entryPtr = (UCHAR*)getTextSection().getBlock(sizeof(ULONGLONG));
+        UCHAR * gpPtr    = (UCHAR*)getTextSection().getBlock(sizeof(ULONGLONG));
+
+        memset(entryPtr,0,sizeof(ULONGLONG));
+        memset(gpPtr,0,sizeof(ULONGLONG));
+
+        setAddrReloc(entryPtr, entryPointOffset);
+        addAddrReloc(getTextSection(), entryPtr, entryPlabelOffset, &getTextSection());
+
+        setAddrReloc(gpPtr, m_iDataDlls[0].m_iatOffset + m_iDataOffsetIAT);
+        addAddrReloc(getTextSection(), gpPtr, entryPlabelOffset+8, m_iDataSectionIAT);
+    }
+    else
+    {
+        _ASSERTE(!"Unknown target machine");
+    }
+
+    // Now set our IAT entry since we're using the IAT
+    setDirectoryEntry(*m_iDataSectionIAT, IMAGE_DIRECTORY_ENTRY_IAT, iDataSizeIAT, m_iDataOffsetIAT);
+
+    return S_OK;
+} // HRESULT CeeFileGenWriter::emitExeMain()
+
+// Like CreateProcess(), but waits for execution to finish
+// Returns true if successful, false on failure.
+// dwExitCode set to process' exitcode
+
+HRESULT CopySystemDirectory(__in WCHAR* pPath,
+                            __out_ecount_part(cchBuffer, *pdwLength) LPWSTR pbuffer, 
+                            DWORD  cchBuffer,
+                            __out DWORD* pdwLength)
+{
+    if (pdwLength == NULL)
+        return E_POINTER;
+
+    HRESULT hr = S_OK;
+    if(pPath == NULL) 
+        return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
+
+    SIZE_T dwPath = wcslen(pPath);
+    LPWSTR pSep = wcsrchr(pPath, L'\\');
+    if(pSep) {
+        dwPath = (DWORD)(pSep-pPath+1);
+        pPath[dwPath] = L'\0';
+    }
+
+    dwPath++; // Add back in the null
+    *pdwLength = (DWORD)dwPath;
+    if(dwPath > cchBuffer || pbuffer == NULL)
+        hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+    else {
+        CopyMemory(pbuffer, 
+                   pPath,
+                   dwPath*sizeof(WCHAR));
+    }
+    return hr;
+}
+
+HRESULT GetClrSystemDirectory(__out_ecount_part(cchBuffer, *pdwLength) LPWSTR pbuffer, 
+                             DWORD  cchBuffer,
+                             __out DWORD* pdwLength)
+{
+    HRESULT hr = S_OK;
+
+    if(pdwLength == NULL)
+        return E_POINTER;
+
+    WCHAR pPath[MAX_PATH];
+    DWORD dwPath = MAX_PATH;
+    
+
+    _ASSERTE (g_hThisInst);
+
+    dwPath = WszGetModuleFileName(g_hThisInst, pPath, dwPath);
+    if(dwPath == 0)
+    {
+        hr = HRESULT_FROM_GetLastErrorNA();
+        return (hr);
+    }
+    else 
+        return CopySystemDirectory(pPath, pbuffer, cchBuffer, pdwLength);
+}
+
+
+BOOL RunProcess(LPCWSTR tempResObj, LPCWSTR pszFilename, DWORD* pdwExitCode, PEWriter &pewriter)
+{
+    BOOL fSuccess = FALSE;
+
+    PROCESS_INFORMATION pi;
+
+    DWORD cchSystemDir = MAX_PATH + 1;
+    DWORD dwLen;
+    WCHAR wszSystemDir[MAX_PATH + 1];
+    if (FAILED(GetClrSystemDirectory(wszSystemDir, cchSystemDir, &dwLen)))
+        return FALSE;
+
+    WCHAR* wzMachine;
+    if(pewriter.isIA64())
+        wzMachine = L"IA64";
+    else if(pewriter.isAMD64())
+        wzMachine = L"AMD64";
+    else if(pewriter.isARM())
+        wzMachine = L"ARM";
+    else
+        wzMachine = L"IX86";
+
+    // Res file, so convert it
+    StackSString ssCmdLine;
+
+    LPWSTR ext = PathFindExtension(pszFilename);
+    if(*ext == NULL)
+    {
+        ssCmdLine.Printf(L"%scvtres.exe /NOLOGO /READONLY /MACHINE:%s \"/OUT:%s\" \"%s.\"",
+                    wszSystemDir,
+                    wzMachine,
+                    tempResObj,
+                    pszFilename);
+    }
+    else
+    {
+        ssCmdLine.Printf(L"%scvtres.exe /NOLOGO /READONLY /MACHINE:%s \"/OUT:%s\" \"%s\"",
+                    wszSystemDir,
+                    wzMachine,
+                    tempResObj,
+                    pszFilename);
+    }
+
+    STARTUPINFOW start;
+    ZeroMemory(&start, sizeof(start));
+    start.cb = sizeof(start);
+    start.dwFlags = STARTF_USESHOWWINDOW;
+    start.wShowWindow = SW_HIDE;
+
+    fSuccess = WszCreateProcess(
+                                NULL,
+                                ssCmdLine.GetUnicode(),
+                                NULL,
+                                NULL,
+                                true,
+                                0,
+                                0,
+                                NULL,
+                                &start,
+                                &pi);
+
+    // If process runs, wait for it to finish
+    if (fSuccess) {
+        WaitForSingleObject(pi.hProcess, INFINITE);
+
+        GetExitCodeProcess(pi.hProcess, pdwExitCode);
+
+        CloseHandle(pi.hProcess);
+
+        CloseHandle(pi.hThread);
+    }
+    return fSuccess;
+} // BOOL RunProcess()
+
+// Ensure that pszFilename is an object file (not just a binary resource)
+// If we convert, then return obj filename in pszTempFilename
+HRESULT ConvertResource(const WCHAR * pszFilename, __in_ecount(cchTempFilename) WCHAR *pszTempFilename, size_t cchTempFilename, PEWriter &pewriter)
+{
+    HANDLE hFile = WszCreateFile(pszFilename, GENERIC_READ,
+        FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+// failure
+    if (!hFile || (hFile == INVALID_HANDLE_VALUE))
+    {
+        //dbprintf("Can't find resource files:%S\n", pszFilename);
+        return HRESULT_FROM_GetLastError();
+    }
+
+// Read first 4 bytes. If they're all 0, we have a win32 .res file which must be
+// converted. (So call CvtRes.exe). Else it's an obj file.
+
+    DWORD dwCount = -1;
+    DWORD dwData  = -1;
+
+    BOOL fRet = ReadFile(hFile,
+                    &dwData,
+                    4,
+                    &dwCount,
+                    NULL
+    );
+
+    CloseHandle(hFile);
+
+    if (!fRet) {
+        //dbprintf("Invalid resource file:%S\n", pszFilename);
+        return HRESULT_FROM_GetLastError();
+    }
+
+    if (dwData != 0)
+    {
+        return S_OK;
+    }
+
+    WCHAR tempResObj[MAX_PATH+1];
+    WCHAR tempResPath[MAX_PATH+1];
+
+    // Create the temp file where the temp path is at rather than where the application is at.
+    if (!WszGetTempPath(MAX_PATH, tempResPath))
+    {
+        return HRESULT_FROM_GetLastError();
+    }
+
+    if (!WszGetTempFileName(tempResPath, L"RES", 0, tempResObj))
+    {
+        //dbprintf("GetTempFileName failed\n");
+        return HRESULT_FROM_GetLastError();
+    }
+
+    DWORD dwExitCode;
+    fRet = RunProcess(tempResObj, pszFilename, &dwExitCode, pewriter);
+
+    if (!fRet)
+    {   // Couldn't run cvtres.exe
+        return PostError(CEE_E_CVTRES_NOT_FOUND);
+    }
+    else if (dwExitCode != 0)
+    {   // CvtRes.exe ran, but failed
+        return HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+    }
+    else
+    {   // Conversion succesful, so return filename.
+        wcscpy_s(pszTempFilename, cchTempFilename, tempResObj);
+    }
+ 
+    return S_OK;
+} // HRESULT ConvertResource()
+
+
+
+// This function reads a resource file and emits it into the generated PE file.
+// 1. We can only link resources in obj format. Must convert from .res to .obj
+// with CvtRes.exe.
+// 2. Must touch up all COFF relocs from .rsrc$01 (resource header) to .rsrc$02
+// (resource raw data)
+HRESULT CeeFileGenWriter::emitResourceSection()
+{
+    if (m_resourceFileName == NULL)
+        return S_OK;
+
+    // Make sure szResFileName is an obj, not just a .res; change name if we convert
+    WCHAR szTempFileName[MAX_PATH+1];
+    szTempFileName[0] = L'\0';
+    HRESULT hr = ConvertResource(m_resourceFileName, szTempFileName,
+                                 MAX_PATH+1, getPEWriter());
+    if (FAILED(hr)) return hr;
+
+    // Filename may change (if we convert .res to .obj), so have floating pointer
+    const WCHAR* szResFileName;
+    if (*szTempFileName)
+        szResFileName = szTempFileName;
+    else
+        szResFileName = m_resourceFileName;
+
+    _ASSERTE(szResFileName);
+
+    // read the resource file and spit it out in the .rsrc section
+
+    HANDLE hFile = INVALID_HANDLE_VALUE;
+    HANDLE hMap = NULL;
+    IMAGE_FILE_HEADER *hMod = NULL;
+    SIZE_T cbFileSize;
+    const BYTE *pbStartOfMappedMem;
+    IMAGE_SECTION_HEADER *rsrc[2] = { NULL, NULL };
+
+    S_SIZE_T cbTotalSizeOfRawData;
+
+    hr = S_OK;
+
+    WIN_PAL_TRY
+    {
+        // create a mapped view of the .res file
+        hFile = WszCreateFile(szResFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+        if (hFile == INVALID_HANDLE_VALUE)
+        {
+            //dbprintf("Resource file %S not found\n", szResFileName);
+            hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+            goto lDone;
+        }
+
+        // Grab the file size for verification checks.
+        {
+            DWORD dwFileSizeHigh;
+            DWORD dwFileSize = SafeGetFileSize(hFile, &dwFileSizeHigh);
+            if (dwFileSize == (DWORD)(-1))
+            {
+                hr = HRESULT_FROM_GetLastError();
+                goto lDone;
+            }
+
+            // Since we intend to memory map this file, the size of the file can not need 64 bits to represent!
+            if (dwFileSizeHigh != 0)
+            {
+                hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+                goto lDone;
+            }
+
+            cbFileSize = static_cast<SIZE_T>(dwFileSize);
+        }
+
+        hMap = WszCreateFileMapping(hFile, 0, PAGE_READONLY, 0, 0, NULL);
+
+        if (hMap == NULL)
+        {
+            //dbprintf("Invalid .res file: %S\n", szResFileName);
+            hr = HRESULT_FROM_GetLastError();
+            goto lDone;
+        }
+
+        pbStartOfMappedMem = reinterpret_cast<const BYTE *>(MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0));
+
+        // test failure conditions
+        if (pbStartOfMappedMem == NULL)
+        {
+            //dbprintf("Invalid .res file: %S:Can't get header\n", szResFileName);
+            hr = HRESULT_FROM_GetLastError();
+            goto lDone;
+        }
+
+        // Check that the file contains an IMAGE_FILE_HEADER structure.
+        if (IMAGE_SIZEOF_FILE_HEADER > cbFileSize)
+        {
+            hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+            goto lDone;
+        }
+
+        hMod = (IMAGE_FILE_HEADER*) pbStartOfMappedMem;
+
+        if (VAL16(hMod->SizeOfOptionalHeader) != 0)
+        {
+            //dbprintf("Invalid .res file: %S:Illegal optional header\n", szResFileName);
+            hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND); // GetLastError() = 0 since API worked.
+            goto lDone;
+        }
+
+        // Scan all section headers and grab .rsrc$01 and .rsrc$02
+        {
+            // First section is directly after header
+            SIZE_T cSections = static_cast<SIZE_T>(VAL16(hMod->NumberOfSections));
+            SIZE_T cbStartOfSections = IMAGE_SIZEOF_FILE_HEADER;
+            S_SIZE_T cbEndOfSections(S_SIZE_T(cbStartOfSections) +
+                                     (S_SIZE_T(cSections) * S_SIZE_T(IMAGE_SIZEOF_SECTION_HEADER)));
+
+            // Check that all sections are within the bounds of the mapped file.
+            if (cbEndOfSections.IsOverflow() ||
+                cbEndOfSections.Value() > cbFileSize)
+            {
+                hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+                goto lDone;
+            }
+
+            {
+                IMAGE_SECTION_HEADER *pSection =
+                    (IMAGE_SECTION_HEADER *)(pbStartOfMappedMem + cbStartOfSections);
+                IMAGE_SECTION_HEADER *pSectionEnd = pSection + cSections;
+
+                for (; pSection < pSectionEnd; pSection++)
+                {
+                    if (strcmp(".rsrc$01", (char *)pSection->Name) == 0)
+                    {
+                        rsrc[0] = pSection;
+                    }
+                    else if (strcmp(".rsrc$02", (char *)pSection->Name) == 0)
+                    {
+                        rsrc[1] = pSection;
+                    }
+                }
+            }
+        }
+
+        // If we don't have both resources, fail.
+        if (!rsrc[0] || !rsrc[1])
+        {
+            //dbprintf("Invalid .res file: %S: Missing sections .rsrc$01 or .rsrc$02\n", szResFileName);
+            hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+            goto lDone;
+        }
+
+        // Verify the resource data starts and sizes
+        {
+            cbTotalSizeOfRawData = S_SIZE_T(0);
+
+            for (int i = 0; i < 2; i++)
+            {
+                S_SIZE_T cbStartOfResourceData(static_cast<SIZE_T>(VAL32(rsrc[i]->PointerToRawData)));
+                S_SIZE_T cbSizeOfResourceData(static_cast<SIZE_T>(VAL32(rsrc[i]->SizeOfRawData)));
+                S_SIZE_T cbEndOfResourceData(cbStartOfResourceData + cbSizeOfResourceData);
+
+                if (cbEndOfResourceData.IsOverflow() ||
+                    cbEndOfResourceData.Value() > cbFileSize)
+                {
+                    hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+                    goto lDone;
+                }
+
+                cbTotalSizeOfRawData += cbSizeOfResourceData;
+            }
+
+            // Check that the total raw data doesn't overflow.
+            if (cbTotalSizeOfRawData.IsOverflow() ||
+                cbTotalSizeOfRawData.Value() > cbFileSize)
+            {
+                hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+                goto lDone;
+            }
+        }
+
+        PESection *rsrcSection;
+        hr = getPEWriter().getSectionCreate(".rsrc", sdReadOnly, &rsrcSection);
+        if (FAILED(hr)) goto lDone;
+
+        rsrcSection->directoryEntry(IMAGE_DIRECTORY_ENTRY_RESOURCE);
+        char *data = rsrcSection->getBlock(static_cast<unsigned>(cbTotalSizeOfRawData.Value()), 8);
+        if(data == NULL)
+        {
+            hr = E_OUTOFMEMORY;
+            goto lDone;
+        }
+
+        // Copy resource header
+        memcpy(data, (char *)hMod + VAL32(rsrc[0]->PointerToRawData), VAL32(rsrc[0]->SizeOfRawData));
+
+        // Map all the relocs in .rsrc$01 using the reloc and symbol tables in the COFF object.,
+        SIZE_T            cReloc        = 0;         // Total number of relocs
+        IMAGE_RELOCATION *pReloc        = NULL;      // Reloc table start
+
+        SIZE_T            cSymbol       = 0;         // Total number of symbols
+        IMAGE_SYMBOL     *pSymbolTable  = NULL;      // Symbol table start
+
+        {
+            // Check that the relocations and symbols lie within the resource
+            cReloc = VAL16(rsrc[0]->NumberOfRelocations);
+            SIZE_T cbStartOfRelocations = static_cast<SIZE_T>(VAL32(rsrc[0]->PointerToRelocations));
+            S_SIZE_T cbEndOfRelocations(S_SIZE_T(cbStartOfRelocations) +
+                                        (S_SIZE_T(cReloc) * S_SIZE_T(sizeof(IMAGE_RELOCATION))));
+
+
+            // Verify the number of symbols fit into the resource.
+            cSymbol = static_cast<SIZE_T>(VAL32(hMod->NumberOfSymbols));
+            SIZE_T cbStartOfSymbolTable = static_cast<SIZE_T>(VAL32(hMod->PointerToSymbolTable));
+            S_SIZE_T cbEndOfSymbolTable(S_SIZE_T(cbStartOfSymbolTable) +
+                                        (S_SIZE_T(cSymbol) * S_SIZE_T(IMAGE_SIZEOF_SYMBOL)));
+
+            if (cbEndOfRelocations.IsOverflow() ||
+                cbEndOfRelocations.Value() > cbFileSize ||
+                cbEndOfSymbolTable.IsOverflow() ||
+                cbEndOfSymbolTable.Value() > cbFileSize)
+            {
+                hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+                goto lDone;
+            }
+
+            pReloc = (IMAGE_RELOCATION *)(pbStartOfMappedMem + cbStartOfRelocations);
+            pSymbolTable = (IMAGE_SYMBOL *)(pbStartOfMappedMem + cbStartOfSymbolTable);
+        }
+
+        _ASSERTE(pReloc != NULL && pSymbolTable != NULL);
+
+        for(SIZE_T iReloc = 0; iReloc < cReloc; iReloc++, pReloc++)
+        {
+            // Ensure this is a valid reloc
+            {
+                S_SIZE_T cbRelocEnd = S_SIZE_T(VAL32(pReloc->VirtualAddress)) + S_SIZE_T(sizeof(DWORD));
+                if (cbRelocEnd.IsOverflow() || 
+                    cbRelocEnd.Value() > static_cast<SIZE_T>(VAL32(rsrc[0]->SizeOfRawData)))
+                {
+                    hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+                    goto lDone;
+                }
+            }
+
+            // index into symbol table, provides address into $02
+            DWORD iSymbol = VAL32(pReloc->SymbolTableIndex);
+
+            // Make sure the index is in range
+            if (iSymbol >= cSymbol)
+            {
+                hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+                goto lDone;
+            }
+
+            IMAGE_SYMBOL* pSymbolEntry = GetSymbolEntry(pSymbolTable, iSymbol);
+
+            // Ensure the symbol entry is valid for a resource.
+            if ((pSymbolEntry->StorageClass != IMAGE_SYM_CLASS_STATIC) ||
+                (VAL16(pSymbolEntry->Type) != IMAGE_SYM_TYPE_NULL) ||
+                (VAL16(pSymbolEntry->SectionNumber) != 3)) // 3rd section is .rsrc$02
+            {
+                //dbprintf("Invalid .res file: %S:Illegal symbol entry\n", szResFileName);
+                hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+                goto lDone;
+            }
+
+            // Ensure that RVA is valid address (inside rsrc[1])
+            if (VAL32(pSymbolEntry->Value) >= VAL32(rsrc[1]->SizeOfRawData))
+            {
+                //dbprintf("Invalid .res file: %S:Illegal rva into .rsrc$02\n", szResFileName);
+                hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+                goto lDone;
+            }
+
+            DWORD dwOffsetInRsrc2 = VAL32(pSymbolEntry->Value) + VAL32(rsrc[0]->SizeOfRawData);
+
+            // Create reloc
+            *(DWORD*)(data + VAL32(pReloc->VirtualAddress)) = VAL32(dwOffsetInRsrc2);
+            rsrcSection->addSectReloc(pReloc->VirtualAddress, rsrcSection, srRelocAbsolute);
+        }
+
+        // Copy $02 (resource raw) data
+        memcpy(data+VAL32(rsrc[0]->SizeOfRawData), 
+            (char *)hMod + VAL32(rsrc[1]->PointerToRawData), 
+            VAL32(rsrc[1]->SizeOfRawData));
+
+lDone: ;
+    }
+    WIN_PAL_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+    {
+        //dbprintf("Exception occured manipulating .res file %S\n", szResFileName);
+        hr = HRESULT_FROM_WIN32(ERROR_RESOURCE_DATA_NOT_FOUND);
+    }
+    WIN_PAL_ENDTRY
+
+    if (hMod != NULL)
+        UnmapViewOfFile(hMod);
+    if (hMap != NULL)
+        CloseHandle(hMap);
+    if (hFile != INVALID_HANDLE_VALUE)
+        CloseHandle(hFile);
+    if (szResFileName == szTempFileName)
+        // delete temporary file if we created one
+        WszDeleteFile(szResFileName);
+
+    return hr;
+} // HRESULT CeeFileGenWriter::emitResourceSection()
+
+HRESULT CeeFileGenWriter::setManifestEntry(ULONG size, ULONG offset)
+{
+    if (offset)
+        m_dwManifestRVA = offset;
+    else {
+        CeeSection TextSection = getTextSection();
+        getMethodRVA(TextSection.dataLen() - size, &m_dwManifestRVA);
+    }
+
+    m_dwManifestSize = size;
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setManifestEntry()
+
+HRESULT CeeFileGenWriter::setStrongNameEntry(ULONG size, ULONG offset)
+{
+    m_dwStrongNameRVA = offset;
+    m_dwStrongNameSize = size;
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setStrongNameEntry()
+
+HRESULT CeeFileGenWriter::setVTableEntry64(ULONG size, void* ptr)
+{
+    if (ptr && size)
+    {
+        void * pv;
+        CeeSection TextSection = getTextSection();
+        // make it DWORD-aligned
+        ULONG L = TextSection.dataLen();
+        if((L &= ((ULONG)sizeof(DWORD)-1)))
+        {
+            L = (ULONG)sizeof(DWORD) - L;
+            if((pv = TextSection.getBlock(L)))
+                memset(pv,0,L);
+            else
+                return E_OUTOFMEMORY;
+        }
+        getMethodRVA(TextSection.dataLen(), &m_dwVTableRVA);
+        if((pv = TextSection.getBlock(size)))
+        {
+            memcpy(pv,ptr,size);
+        }
+        else
+            return E_OUTOFMEMORY;
+        m_dwVTableSize = size;
+    }
+
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setVTableEntry()
+
+HRESULT CeeFileGenWriter::setVTableEntry(ULONG size, ULONG offset)
+{
+    return setVTableEntry64(size,(void*)(ULONG_PTR)offset);
+} // HRESULT CeeFileGenWriter::setVTableEntry()
+
+HRESULT CeeFileGenWriter::setEnCRvaBase(ULONG dataBase, ULONG rdataBase)
+{
+    setEnCMode();
+    getPEWriter().setEnCRvaBase(dataBase, rdataBase);
+    return S_OK;
+} // HRESULT CeeFileGenWriter::setEnCRvaBase()
+
+HRESULT CeeFileGenWriter::computeSectionOffset(CeeSection &section, __in char *ptr,
+                                               unsigned *offset)
+{
+    *offset = section.computeOffset(ptr);
+
+    return S_OK;
+} // HRESULT CeeFileGenWriter::computeSectionOffset()
+
+HRESULT CeeFileGenWriter::computeOffset(__in char *ptr,
+                                        CeeSection **pSection, unsigned *offset)
+{
+    TESTANDRETURNPOINTER(pSection);
+
+    CeeSection **s = m_sections;
+    CeeSection **sEnd = s + m_numSections;
+    while (s < sEnd)
+    {
+        if ((*s)->containsPointer(ptr))
+        {
+            *pSection = *s;
+            *offset = (*s)->computeOffset(ptr);
+
+            return S_OK;
+        }
+        s++;
+    }
+
+    return E_FAIL;
+} // HRESULT CeeFileGenWriter::computeOffset()
+
+HRESULT CeeFileGenWriter::getCorHeader(IMAGE_COR20_HEADER **ppHeader)
+{
+    *ppHeader = m_corHeader;
+    return S_OK;
+} // HRESULT CeeFileGenWriter::getCorHeader()
+
+
+#ifdef EMIT_FIXUPS
+
+HRESULT CeeFileGenWriter::InitFixupSection()
+{
+    if (!m_fEmitFixups)
+    {
+       return(E_UNEXPECTED);
+    }
+
+    HRESULT hr;
+
+    hr = getSectionCreate(".fixups",
+                           IMAGE_SCN_CNT_INITIALIZED_DATA  | IMAGE_SCN_MEM_READ,
+                           &m_sectionFixups);
+    if (SUCCEEDED(hr))
+    {
+       size_t cbDebugDir = sizeof(IMAGE_DEBUG_DIRECTORY);
+       hr = GetSectionBlock(m_sectionFixups, (ULONG) cbDebugDir, 32, (void **) &m_pDebugDir);
+       if (SUCCEEDED(hr))
+       {
+          memset(m_pDebugDir, 0, cbDebugDir);
+          m_pDebugDir->Type = IMAGE_DEBUG_TYPE_FIXUP;
+          m_fFixupsUpdated = false;
+
+          return(S_OK);
+       }
+    }
+
+    m_pDebugDir = NULL;
+    m_sectionFixups = NULL;
+    m_fEmitFixups = false;
+
+    return(E_FAIL);
+
+} // HRESULT CeeFileGenWriter::InitFixupSection()
+
+HRESULT CeeFileGenWriter::addFixup(CeeSection& sectionSource, unsigned offset, CeeSectionRelocType relocType, CeeSection * psectionTarget, CeeSectionRelocExtra *extra)
+{
+   if (!m_fEmitFixups)
+   {
+      return(S_OK);
+   }
+
+   _ASSERTE(sizeof(DBG_FIXUP) == sizeof(PEFIXUP));
+   _ASSERTE(m_fFixupsUpdated == false);
+
+   DBG_FIXUP * pfixup;
+
+   if (m_sectionFixups == NULL)
+   {
+      HRESULT hr = InitFixupSection();
+      if (FAILED(hr))
+      {
+         return(hr);
+      }
+
+      // The fixup section begins with a IMAGE_DEBUG_DIRECTORY containing a
+      // IMAGE_DEBUG_TYPE_FIXUP directory entry, which describes the array
+      // of fixups which follows it.
+
+      // The very first item of this array is aligned on a 32 bit boundary.
+      // All other fixup entries follow unaligned.
+      pfixup = (DBG_FIXUP *) m_sectionFixups->getBlock(sizeof(DBG_FIXUP), 32);
+      TESTANDRETURN(pfixup != NULL, E_OUTOFMEMORY);
+
+      // Initialize the IMAGE_DEBUG_TYPE_FIXUP entry relocations
+#ifdef _WIN64
+      _ASSERTE(!"Base relocs are not yet implemented for 64-bit");
+      m_pDebugDir->AddressOfRawData = 0; // @ToDo: srRelocAbsolutePtr can't take a 64-bit address
+#else
+      m_pDebugDir->AddressOfRawData = (size_t) pfixup;
+      m_sectionFixups->addSectReloc(offsetof(IMAGE_DEBUG_DIRECTORY, AddressOfRawData), *m_sectionFixups, srRelocAbsolutePtr);
+#endif
+
+      m_pDebugDir->PointerToRawData = m_sectionFixups->computeOffset((char *) pfixup);
+
+      m_sectionFixups->addSectReloc(offsetof(IMAGE_DEBUG_DIRECTORY, PointerToRawData), *m_sectionFixups, srRelocFilePos);
+
+      unsigned offsetDir = m_sectionFixups->computeOffset((char *) m_pDebugDir);
+      setDirectoryEntry(*m_sectionFixups, IMAGE_DIRECTORY_ENTRY_DEBUG, sizeof(IMAGE_DEBUG_DIRECTORY), offsetDir);
+
+#ifdef TEST_EMIT_FIXUPS
+      TestEmitFixups();
+#endif
+   }
+   else
+   {
+      pfixup = (DBG_FIXUP *) m_sectionFixups->getBlock(sizeof(DBG_FIXUP), 1);
+      TESTANDRETURN(pfixup != NULL, E_OUTOFMEMORY);
+   }
+
+   // Save off the relocation information for use later.  The relocation's
+   // target information can be filled in later.
+   // The relocation target info is not always immediately available, so it needs
+   // to be extracted later, during the link phase.  For now the relocation info
+   // is stored so the target can be extracted at link time in the UpdateFixups
+   // function.
+   //
+   unsigned offsetFixup = m_sectionFixups->computeOffset((char *) pfixup);
+   pfixup->wSpare = 0;
+   pfixup->wType = relocType;
+   _ASSERTE(pfixup->wType == relocType);
+   pfixup->offset = offset;
+   pfixup->sectionSource = &sectionSource;
+
+   m_pDebugDir->SizeOfData += sizeof(DBG_FIXUP);
+
+   // Add a relocation for the fixup's source RVA field, (no fixup on this reloc)
+   m_sectionFixups->addSectReloc(offsetFixup + offsetof(DBG_FIXUP, rva), sectionSource, srRelocAbsolutePtr);
+
+   // Add a relocation for the fixup's target RVA field.  Correct target extracted
+   // later in UpdateFixups, (no fixup on this reloc)
+   CeeSectionRelocType tgtRelocType;
+
+   switch (relocType)
+   {
+      case srRelocMapToken:
+         // not an RVA
+         tgtRelocType = srRelocMapToken;
+         break;
+
+      case srRelocFilePos:
+         tgtRelocType = srRelocFilePos;
+         break;
+
+      case srRelocHighAdj:
+         tgtRelocType = srRelocHighAdj;
+         break;
+
+      default:
+         tgtRelocType = (relocType & srRelocPtr) ? srRelocAbsolutePtr : srRelocAbsolute;
+         break;
+   }
+
+   if (psectionTarget != NULL)
+   {
+      m_sectionFixups->addSectReloc(offsetFixup + offsetof(DBG_FIXUP, rvaTarget), *psectionTarget, tgtRelocType, extra);
+   }
+   else
+   {
+      m_sectionFixups->addBaseReloc(offsetFixup + offsetof(DBG_FIXUP, rvaTarget), tgtRelocType, extra);
+   }
+
+   return(S_OK);
+} // HRESULT CeeFileGenWriter::addFixup()
+
+HRESULT CeeFileGenWriter::UpdateFixups()
+{
+   // This method extracts the correct relocation target.  See addFixup method.
+
+   if (!m_fEmitFixups || m_fFixupsUpdated)
+   {
+      return(S_OK);
+   }
+   m_fFixupsUpdated = true; // prevent UpdateFixups from being called again.
+
+   size_t cfixups = m_pDebugDir->SizeOfData / sizeof(DBG_FIXUP);
+   _ASSERT(m_pDebugDir->SizeOfData % sizeof(DBG_FIXUP) == 0);
+   unsigned ibFixup = m_pDebugDir->PointerToRawData;
+
+   for (size_t idx = 0; idx < cfixups; idx++, ibFixup += sizeof(DBG_FIXUP))
+   {
+      DBG_FIXUP * pfixup = (DBG_FIXUP *) m_sectionFixups->computePointer(ibFixup);
+      CeeSection * sectionSource = pfixup->sectionSource;
+      CeeSectionRelocType relocType = (CeeSectionRelocType) pfixup->wType;
+      unsigned offset = pfixup->offset;
+
+      // Get current data for replacing fixup contents
+      const DWORD * pdw = (DWORD *) sectionSource->computePointer(offset);
+      pfixup->rva = (DWORD) (UINT_PTR) pdw;
+      pfixup->rvaTarget = *pdw;
+
+      switch (relocType)
+      {
+#ifdef _X86_
+      case srRelocAbsolute:
+          // Emitted bytes: RVA, offset relative to image base
+          // reloc src contains target offset relative to target section
+          if ((*pdw & 0xFF000000) == 0)
+          {
+              pfixup->wType = IMAGE_REL_I386_DIR32NB;
+          }
+          else
+          {
+              // MethodDesc::Fixup function creates a 24 bit RVA, where the
+              // high byte of the DWORD stores the flag value: METHOD_NEEDS_PRESTUB_RUN_FLAG.
+              // work around it by converting the type to 24 bits here
+              pfixup->wType = IMAGE_REL_I386_DIR24NB;
+              pfixup->rvaTarget = *pdw & 0x00FFFFFF;
+          }
+          break;
+
+      case srRelocAbsolutePtr:
+          // Emitted bytes: RVA, offset relative to image base
+          // reloc src contains target pointer
+          pfixup->wType = IMAGE_REL_I386_DIR32NB;
+          break;
+          
+      case srRelocHighLow:
+          // Emitted bytes: full address of target
+          // reloc src contains target offset relative to target section
+          pfixup->wType = IMAGE_REL_I386_DIR32;
+          break;
+          
+      case srRelocHighLowPtr:
+          // Emitted bytes: full address of target
+          // reloc src contains target pointer
+          pfixup->wType = IMAGE_REL_I386_DIR32;
+          break;
+          
+      case srRelocRelative:
+          // Emitted bytes: value of reloc tgt - (reloc source + sizeof(DWORD))
+          // reloc src contains offset relative to target section, minus sizeof(DWORD)
+          // the reloc type for pFixup->rvaTarget is srRelocAbsolute
+          // so contents of pFixup->rvaTarget need to be offset Target + sizeof(DWORD)
+          // which is offset Target == Source contents + sizeof(DWORD) == *pdw + sizeof(DWORD)
+          pfixup->wType = IMAGE_REL_I386_REL32;
+          pfixup->rvaTarget = *pdw + sizeof(DWORD);
+          break;
+          
+      case srRelocRelativePtr:
+          // Emitted bytes: value of reloc tgt - (reloc source + sizeof(DWORD))
+          // reloc src contains disp, disp = pTarget - (pSource + sizeof(DWORD))
+          // the reloc type for pFixup->rvaTarget is srRelocAbsolutePtr
+          // so contents of pFixup->rvaTarget need to be pTarget
+          // which is pTarget == pSource + sizeof(DWORD) + disp == pdw + 4 + *pdw
+          pfixup->wType = IMAGE_REL_I386_REL32;
+          pfixup->rvaTarget = (int) (INT_PTR) pdw + sizeof(DWORD) + (int) *pdw;
+          break;
+          
+      case srRelocMapToken:
+          // Emitted bytes: contents of reloc source unchanged.
+          // reloc src contains token value
+          pfixup->wType = IMAGE_REL_I386_TOKEN;
+          break;
+
+#elif defined(_AMD64_)
+          /*
+          //
+          // X86-64 relocations
+          //
+          IMAGE_REL_AMD64_ABSOLUTE        0x0000  // Reference is absolute, no relocation is necessary
+          IMAGE_REL_AMD64_ADDR64          0x0001  // 64-bit address (VA).
+          IMAGE_REL_AMD64_ADDR32          0x0002  // 32-bit address (VA).
+          IMAGE_REL_AMD64_ADDR32NB        0x0003  // 32-bit address w/o image base (RVA).
+          IMAGE_REL_AMD64_REL32           0x0004  // 32-bit relative address from byte following reloc
+          IMAGE_REL_AMD64_REL32_1         0x0005  // 32-bit relative address from byte distance 1 from reloc
+          IMAGE_REL_AMD64_REL32_2         0x0006  // 32-bit relative address from byte distance 2 from reloc
+          IMAGE_REL_AMD64_REL32_3         0x0007  // 32-bit relative address from byte distance 3 from reloc
+          IMAGE_REL_AMD64_REL32_4         0x0008  // 32-bit relative address from byte distance 4 from reloc
+          IMAGE_REL_AMD64_REL32_5         0x0009  // 32-bit relative address from byte distance 5 from reloc
+          IMAGE_REL_AMD64_SECTION         0x000A  // Section index
+          IMAGE_REL_AMD64_SECREL          0x000B  // 32 bit offset from base of section containing target
+          IMAGE_REL_AMD64_SECREL7         0x000C  // 7 bit unsigned offset from base of section containing target
+          IMAGE_REL_AMD64_TOKEN           0x000D  // 32 bit metadata token
+          IMAGE_REL_AMD64_SREL32          0x000E  // 32 bit signed span-dependent value emitted into object
+          IMAGE_REL_AMD64_PAIR            0x000F
+          IMAGE_REL_AMD64_SSPAN32         0x0010  // 32 bit signed span-dependent value applied at link time
+          */
+      case srRelocAbsolute:
+          // Emitted bytes: RVA, offset relative to image base
+          pfixup->wType = IMAGE_REL_AMD64_ADDR32NB;
+          break;
+          
+      case srRelocAbsolutePtr:
+          // Emitted bytes: RVA, offset relative to image base
+          // reloc src contains target pointer
+          pfixup->wType = IMAGE_REL_AMD64_ADDR32NB;
+          break;
+          
+      case srRelocDir64Ptr:
+          // Emitted bytes: full address of target
+          // reloc src contains target pointer
+          pfixup->wType = IMAGE_REL_IA64_DIR64;
+          break;
+          
+      case srRelocMapToken:
+          // Emitted bytes: contents of reloc source unchanged.
+          // reloc src contains token value
+          pfixup->wType = IMAGE_REL_AMD64_TOKEN;
+          break;
+#endif
+      case srRelocFilePos:
+          // Emitted bytes: offset relative to start of file, differs from RVA.
+          pfixup->wType = IMAGE_REL_I386_FILEPOS;
+          break;
+
+      case srRelocAbsoluteTagged:
+            pfixup->wType = IMAGE_REL_I386_DIR30NB;
+            pfixup->rvaTarget = (*pdw & ~0x80000001) >> 1;
+          break;
+
+      case srRelocHighAdj:
+          // Emitted bytes: 2 part relocation, with high part adjusted by constant.
+          pfixup->wType = IMAGE_REL_BASED_HIGHADJ;
+          break;
+
+      default:
+          _ASSERTE(!"Unknown relocation type");
+          return(E_UNEXPECTED);
+          break;
+      }
+   }
+
+   return(S_OK);
+
+} // HRESULT CeeFileGenWriter::UpdateFixups()
+
+
+HRESULT CeeFileGenWriter::setEmitFixups()
+{
+   m_fEmitFixups = true;
+   return(S_OK);
+
+} // HRESULT CeeFileGenWriter::setEmitFixups()
+
+#ifdef TEST_EMIT_FIXUPS
+
+HRESULT CeeFileGenWriter::TestEmitFixups()
+{
+   HRESULT hr;
+   // Test fixups
+
+   CeeSection * testSection;
+   hr = getSectionCreate(".test",
+                          IMAGE_SCN_CNT_INITIALIZED_DATA  | IMAGE_SCN_MEM_READ,
+                          &testSection);
+   if (SUCCEEDED(hr))
+   {
+      struct FixupEntry
+      {
+         char sz[18];
+         DWORD wTargets[8];
+      };
+
+      struct FixupTypes
+      {
+         char *               pszType;
+         CeeSectionRelocType  relocType;
+      };
+
+      FixupTypes rgTypes[] =
+      {
+         { "srRelocAbsolute   ", srRelocAbsolute      },
+         { "srRelocAbsolutePtr", srRelocAbsolutePtr   },
+         { "srRelocHighLow    ", srRelocHighLow       },
+         { "srRelocHighLowPtr ", srRelocHighLowPtr    },
+      // { "srRelocRelative   ", srRelocRelative      },
+      // { "srRelocRelativePtr", srRelocRelativePtr   },
+         { "srRelocMapToken   ", srRelocMapToken      },
+      // { "srRelocFilePos    ", srRelocFilePos       },
+      // { "srRelocHighAdj    ", srRelocHighAdj       },
+      };
+
+      const size_t cFixups = sizeof(rgTypes) / sizeof(rgTypes[0]);
+
+      DWORD * pdwTargets[20];
+
+      // Target Blocks:
+
+      for (size_t idx = 0; idx < cFixups; idx++)
+      {
+         hr = GetSectionBlock(testSection, sizeof(DWORD), 1, (void **) &pdwTargets[idx]);
+         _ASSERTE(SUCCEEDED(hr));
+
+         DWORD * pdw = pdwTargets[idx];
+         *pdw = idx;
+      }
+
+      for (size_t idxType = 0; idxType < cFixups; idxType++)
+      {
+         // Fixup Entries
+         FixupEntry * pEntry;
+         hr = GetSectionBlock(testSection, sizeof(FixupEntry), 1, (void **) &pEntry);
+         _ASSERTE(SUCCEEDED(hr));
+
+         memset(pEntry, 0, sizeof(FixupEntry));
+         strcpy_s(pEntry->sz, sizeof(pEntry->sz), rgTypes[idxType].pszType);
+
+         size_t ibBlock = testSection->computeOffset((char *) pEntry);
+
+         for (size_t idx = 0; idx < cFixups; idx++)
+         {
+            size_t ibFixup = ((size_t) &pEntry->wTargets[idx]) - (size_t) pEntry;
+
+            switch (rgTypes[idxType].relocType)
+            {
+               case srRelocAbsolute:
+                 pEntry->wTargets[idx] = idx * sizeof(DWORD);
+                 break;
+
+               case srRelocAbsolutePtr:
+                 pEntry->wTargets[idx] = (DWORD) pdwTargets[idx];
+                 break;
+
+               case srRelocHighLow:
+                 pEntry->wTargets[idx] = idx * sizeof(DWORD);
+                 break;
+
+               case srRelocHighLowPtr:
+                 pEntry->wTargets[idx] = (DWORD) pdwTargets[idx];
+                 break;
+
+               case srRelocRelative:
+                 pEntry->wTargets[idx] = idx;
+                 break;
+
+               case srRelocRelativePtr:
+               {
+                 size_t ibTgt = (size_t) pdwTargets[idx];
+                 size_t ibSrc = ((size_t) &pEntry->wTargets[idx]) + sizeof(DWORD);
+                 pEntry->wTargets[idx] = (DWORD)( ibTgt - ibSrc );
+                 ibFixup += sizeof(DWORD); // offset needs to point at end of DWORD
+                 break;
+               }
+
+               case srRelocHighAdj:
+                 pEntry->wTargets[idx] = idx * sizeof(DWORD);
+                 break;
+
+               case srRelocMapToken:
+                 pEntry->wTargets[idx] = idx * sizeof(DWORD);
+                 break;
+
+               case srRelocFilePos:
+                 pEntry->wTargets[idx] = idx * sizeof(DWORD);
+                 break;
+            }
+
+            addFixup(*testSection, ibBlock + ibFixup, rgTypes[idxType].relocType, testSection);
+            testSection->addSectReloc(ibBlock + ibFixup, *testSection, rgTypes[idxType].relocType);
+         }
+      }
+   }
+
+   return(S_OK);
+}
+#endif // TEST_EMIT_FIXUPS
+#endif // EMIT_FIXUPS
+
+#ifndef FEATURE_MERGE_JIT_AND_ENGINE
+
+//*****************************************************************************
+// Handle lifetime of loaded library.
+//*****************************************************************************
+extern "C"
+BOOL WINAPI DllMain(HANDLE hInstance, DWORD dwReason, LPVOID lpReserved)
+{
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+        {   // Save the module handle.
+            g_hThisInst = (HINSTANCE)hInstance;
+            DisableThreadLibraryCalls((HMODULE)hInstance);
+        }
+        break;
+    case DLL_PROCESS_DETACH:
+        break;
+    }
+
+    return (true);
+} // BOOL WINAPI DllMain()
+
+
+HINSTANCE GetModuleInst()
+{
+    return (g_hThisInst);
+} // HINSTANCE GetModuleInst()
+
+#endif //FEATURE_MERGE_JIT_AND_ENGINE
diff --git a/src/dlls/mscorpe/ceefilegenwritertokens.cpp b/src/dlls/mscorpe/ceefilegenwritertokens.cpp
new file mode 100644
index 0000000000..b8d5ac0d83
--- /dev/null
+++ b/src/dlls/mscorpe/ceefilegenwritertokens.cpp
@@ -0,0 +1,265 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//*****************************************************************************
+// CeeFileGenWriterTokens.cpp
+//
+// This code will walk the byte codes for all methods before they are saved
+// to disk and apply the token fix-ups if they have moved.
+//
+//*****************************************************************************
+#include "stdafx.h"
+#include "ceegen.h"
+#define DECLARE_DATA
+#include "../../ildasm/dasmenum.hpp"
+#define MAX_CLASSNAME_LENGTH    1024
+
+//********** Locals. **********************************************************
+OPCODE DecodeOpcode(const BYTE *pCode, DWORD *pdwLen);
+
+
+
+//********** Code. ************************************************************
+
+
+//*****************************************************************************
+// Method bodies are kept in the text section.  The meta data contains the
+// RVA of each method body in the image.  The TextSection object contains the
+// actual raw bytes where the method bodies are located.  This code will
+// determine the raw offset of each method based on the RVA kept in the meta
+// data.
+//*****************************************************************************
+
+HRESULT CeeFileGenWriter::MapTokens(
+    CeeGenTokenMapper *pMapper,
+    IMetaDataImport *pImport)
+{
+    mdTypeDef   td;
+    mdMethodDef md;
+    ULONG       count;
+    ULONG       MethodRVA;
+    ULONG       codeOffset;
+    ULONG       BaseRVA;
+    DWORD       dwFlags;
+    DWORD       iFlags;
+    HCORENUM    hTypeDefs = 0, hEnum = 0;
+    WCHAR       rcwName[MAX_CLASSNAME_LENGTH];
+    HRESULT     hr;
+    CeeSection  TextSection = getTextSection();
+
+    // Ask for the base RVA of the first method in the stream.  All other
+    // method RVA's are >= that value, and will give us the raw offset required.
+
+    hr = getMethodRVA(0, &BaseRVA);
+    _ASSERTE(SUCCEEDED(hr));
+    // do globals first
+    while ((hr = pImport->EnumMethods(&hEnum, mdTokenNil, &md, 1, &count)) == S_OK)
+    {
+        hr = pImport->GetMethodProps(md, NULL,
+                    rcwName, lengthof(rcwName), NULL,
+                    &dwFlags, NULL, NULL,
+                    &MethodRVA, &iFlags);
+        _ASSERTE(SUCCEEDED(hr));
+
+        if (MethodRVA == 0 || ((IsMdAbstract(dwFlags) || IsMiInternalCall(iFlags)) ||
+                                   (! IsMiIL(iFlags) && ! IsMiOPTIL(iFlags))))
+            continue;
+
+        // The raw offset of the method is the RVA in the image minus
+        // the first method in the text section.
+        codeOffset = MethodRVA - BaseRVA;
+        hr = MapTokensForMethod(pMapper,
+                    (BYTE *) TextSection.computePointer(codeOffset),
+                    rcwName);
+        if (FAILED(hr))
+            goto ErrExit;
+    }
+    if (hEnum) pImport->CloseEnum(hEnum);
+    hEnum = 0;
+
+    while ((hr = pImport->EnumTypeDefs(&hTypeDefs, &td, 1, &count)) == S_OK)
+    {
+        while ((hr = pImport->EnumMethods(&hEnum, td, &md, 1, &count)) == S_OK)
+        {
+            hr = pImport->GetMethodProps(md, NULL,
+                        rcwName, lengthof(rcwName), NULL,
+                        &dwFlags, NULL, NULL,
+                        &MethodRVA, &iFlags);
+            _ASSERTE(SUCCEEDED(hr));
+
+            if (MethodRVA == 0 || ((IsMdAbstract(dwFlags) || IsMiInternalCall(iFlags)) ||
+                                   (! IsMiIL(iFlags) && ! IsMiOPTIL(iFlags))))
+                continue;
+
+
+            // The raw offset of the method is the RVA in the image minus
+            // the first method in the text section.
+            codeOffset = MethodRVA - BaseRVA;
+            hr = MapTokensForMethod(pMapper,
+                        (BYTE *) TextSection.computePointer(codeOffset),
+                        rcwName);
+            if (FAILED(hr))
+                goto ErrExit;
+        }
+
+        if (hEnum) pImport->CloseEnum(hEnum);
+        hEnum = 0;
+    }
+
+ErrExit:
+    if (hTypeDefs) pImport->CloseEnum(hTypeDefs);
+    if (hEnum) pImport->CloseEnum(hEnum);
+    return (hr);
+}
+
+
+//*****************************************************************************
+// This method will walk the byte codes of an IL method looking for tokens.
+// For each token found, it will check to see if it has been moved, and if
+// so, apply the new token value in its place.
+//*****************************************************************************
+HRESULT CeeFileGenWriter::MapTokensForMethod(
+    CeeGenTokenMapper *pMapper,
+    BYTE        *pCode,
+    LPCWSTR     szMethodName)
+{
+    mdToken     tkTo;
+    DWORD       PC;
+
+    COR_ILMETHOD_DECODER method((COR_ILMETHOD*) pCode);
+
+    // If compressed IL is being emitted, this routine will have no idea how to walk the tokens,
+    // so don't do it
+    if (m_dwMacroDefinitionSize != 0)
+        return S_OK;
+
+    pCode = const_cast<BYTE*>(method.Code);
+
+    PC = 0;
+    while (PC < method.GetCodeSize())
+    {
+        DWORD   Len;
+        DWORD   i;
+        OPCODE  instr;
+
+        instr = DecodeOpcode(&pCode[PC], &Len);
+
+        if (instr == CEE_COUNT)
+        {
+            _ASSERTE(0 && "Instruction decoding error\n");
+            return E_FAIL;
+        }
+
+
+        PC += Len;
+
+        switch (OpcodeInfo[instr].Type)
+        {
+            DWORD tk;
+
+            default:
+            {
+                _ASSERTE(0 && "Unknown instruction\n");
+                return E_FAIL;
+            }
+
+            case InlineNone:
+            break;
+
+            case ShortInlineI:
+            case ShortInlineVar:
+            case ShortInlineBrTarget:
+            PC++;
+            break;
+
+            case InlineVar:
+            PC += 2;
+            break;
+
+            case InlineI:
+            case ShortInlineR:
+            case InlineBrTarget:
+            case InlineRVA:
+            PC += 4;
+            break;
+
+            case InlineI8:
+            case InlineR:
+            PC += 8;
+            break;
+
+            case InlinePhi:
+                {
+                    DWORD cases = pCode[PC];
+                    PC += 2 * cases + 1;
+                    break;
+                }
+
+            case InlineSwitch:
+            {
+                DWORD cases = pCode[PC] + (pCode[PC+1] << 8) + (pCode[PC+2] << 16) + (pCode[PC+3] << 24);
+
+                PC += 4;
+                for (i = 0; i < cases; i++)
+                {
+                    PC += 4;
+                }
+
+                // skip bottom of loop which prints szString
+                continue;
+            }
+
+            case InlineTok:
+            case InlineSig:
+            case InlineMethod:
+            case InlineField:
+            case InlineType:
+            case InlineString:
+            {
+                tk = GET_UNALIGNED_VAL32(&pCode[PC]);
+
+                if (pMapper->HasTokenMoved(tk, tkTo))
+                {
+                    SET_UNALIGNED_VAL32(&pCode[PC], tkTo);
+                }
+
+                PC += 4;
+                break;
+            }
+        }
+    }
+
+    return S_OK;
+}
+
+
+
+
+OPCODE DecodeOpcode(const BYTE *pCode, DWORD *pdwLen)
+{
+    OPCODE opcode;
+
+    *pdwLen = 1;
+    opcode = OPCODE(pCode[0]);
+    switch(opcode) {
+        case CEE_PREFIX1:
+            opcode = OPCODE(pCode[1] + 256);
+            if (opcode < 0 || opcode >= CEE_COUNT)
+                opcode = CEE_COUNT;
+            *pdwLen = 2;
+            break;
+        case CEE_PREFIXREF:
+        case CEE_PREFIX2:
+        case CEE_PREFIX3:
+        case CEE_PREFIX4:
+        case CEE_PREFIX5:
+        case CEE_PREFIX6:
+        case CEE_PREFIX7:
+            *pdwLen = 3;
+            return CEE_COUNT;
+        default:
+            break;
+        }
+    return opcode;
+}
diff --git a/src/dlls/mscorpe/dirs.proj b/src/dlls/mscorpe/dirs.proj
new file mode 100644
index 0000000000..46bb0ce64d
--- /dev/null
+++ b/src/dlls/mscorpe/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+    <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.props" />
+
+    <!--The following projects will build during PHASE 1-->
+  <PropertyGroup>
+    <BuildInPhaseDefault>false</BuildInPhaseDefault>
+    <BuildInPhase1>true</BuildInPhase1>
+  </PropertyGroup>
+    <ItemGroup Condition="'$(BuildExePhase)' == '1'">
+        <ProjectFile Include="mscorpe\mscorpe.nativeproj" />
+        <ProjectFile Include="mscorpehost\mscorpehost.nativeproj" />
+    </ItemGroup>
+
+    <Import Project="$(_NTDRIVE)$(_NTROOT)\tools\Microsoft.DevDiv.Traversal.targets" />
+</Project>
diff --git a/src/dlls/mscorpe/iceefilegen.cpp b/src/dlls/mscorpe/iceefilegen.cpp
new file mode 100644
index 0000000000..d41dcfd779
--- /dev/null
+++ b/src/dlls/mscorpe/iceefilegen.cpp
@@ -0,0 +1,733 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+// ===========================================================================
+//  File: CEEGEN.CPP
+// ===========================================================================
+#include "stdafx.h"
+#include "iceefilegen.h"
+#include "ceefilegenwriter.h"
+
+#ifdef EnC_SUPPORTED
+#define ENC_DELTA_HACK
+#endif
+
+#ifdef ENC_DELTA_HACK
+extern BOOL g_EnCMode;
+#endif
+
+// Deprecated
+//****************************************************************************
+    HRESULT ICeeFileGen::EmitMethod ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::EmitSignature ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::SetEntryClassToken ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::GetEntryClassToken ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::SetEntryPointDescr ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::GetEntryPointDescr ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::SetEntryPointFlags ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::GetEntryPointFlags ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::CreateSig ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::AddSigArg ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::SetSigReturnType ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::SetSigCallingConvention ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+    HRESULT ICeeFileGen::DeleteSig ()
+    {
+        _ASSERTE("Deprecated" && 0);
+        return (E_FAIL);
+    }
+//****************************************************************************
+
+EXTERN_C HRESULT __stdcall CreateICeeFileGen(ICeeFileGen** pCeeFileGen)
+{
+    if (!pCeeFileGen)
+        return E_POINTER;
+    
+    ICeeFileGen *gen = new (nothrow) ICeeFileGen();
+    IfNullRet(gen);
+   
+    *pCeeFileGen = gen;
+    return S_OK;
+}
+
+EXTERN_C HRESULT __stdcall DestroyICeeFileGen(ICeeFileGen** pCeeFileGen)
+{
+    if (!pCeeFileGen)
+        return E_POINTER;
+    delete *pCeeFileGen;
+    *pCeeFileGen = NULL;
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::CreateCeeFile (HCEEFILE *ceeFile)
+{
+    return CreateCeeFileEx(ceeFile, ICEE_CREATE_FILE_PURE_IL);
+}
+
+HRESULT ICeeFileGen::CreateCeeFileEx (HCEEFILE *ceeFile, DWORD createFlags)
+{
+    return CreateCeeFileEx2(ceeFile, createFlags, NULL);
+}
+
+//
+// Seed file is used as the base file. The new file data will be "appended" to the seed file
+//
+
+HRESULT ICeeFileGen::CreateCeeFileEx2 (HCEEFILE *ceeFile, DWORD createFlags, LPCWSTR seedFileName)
+{
+    if (!ceeFile)
+        return E_POINTER;
+    
+    CeeFileGenWriter *gen = NULL;
+    HRESULT hr;
+    IfFailRet(CeeFileGenWriter::CreateNewInstanceEx(NULL, gen, createFlags, seedFileName));
+    TESTANDRETURN(gen != NULL, E_OUTOFMEMORY);
+    *ceeFile = gen;
+
+#ifdef ENC_DELTA_HACK
+    // for EnC we want the RVA to be right be relative to the front of the delta IL stream rather
+    // than take into account the .text section and the cor header as we would for a real PE file
+    // However, the RVA must be non-zero, so just stick a dword on the front to push it out.
+    if (g_EnCMode)
+    {
+        CeeSection *sec = &gen->getIlSection();
+        sec->getBlock(sizeof(DWORD), sizeof(DWORD));
+    } 
+#endif
+
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::CreateCeeFileFromICeeGen(ICeeGen *pICeeGen, HCEEFILE *ceeFile, DWORD createFlags)
+{
+    if (!ceeFile)
+        return E_POINTER;
+    CCeeGen *genFrom = reinterpret_cast<CCeeGen*>(pICeeGen);
+    CeeFileGenWriter *gen = NULL;
+    if (FAILED(CeeFileGenWriter::CreateNewInstance(genFrom, gen, createFlags))) return FALSE;
+    TESTANDRETURN(gen != NULL, E_OUTOFMEMORY);
+    *ceeFile = gen;
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::DestroyCeeFile(HCEEFILE *ceeFile)
+{
+    if (!ceeFile)
+        return E_POINTER;
+    if (!*ceeFile)
+        return E_POINTER;
+
+    CeeFileGenWriter **gen = reinterpret_cast<CeeFileGenWriter**>(ceeFile);
+    (*gen)->Cleanup();
+    delete *gen;
+    *ceeFile = NULL;
+    return S_OK;
+}
+
+// 
+
+HRESULT ICeeFileGen::GetRdataSection (HCEEFILE ceeFile, HCEESECTION *section)
+{
+    TESTANDRETURNPOINTER(section);
+    TESTANDRETURNARG(ceeFile != 0);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    *section = &gen->getStringSection();
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::GetIlSection (HCEEFILE ceeFile, HCEESECTION *section)
+{
+    TESTANDRETURNPOINTER(section);
+    TESTANDRETURNARG(ceeFile != 0);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    *section = &gen->getIlSection();
+    return S_OK;
+}
+
+
+HRESULT ICeeFileGen::GetSectionCreate (HCEEFILE ceeFile, const char *name, DWORD flags,
+                                                        HCEESECTION *section)
+{
+    TESTANDRETURNPOINTER(section);
+    TESTANDRETURNARG(ceeFile != 0);
+    TESTANDRETURNPOINTER(name);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    CeeSection **ceeSection = reinterpret_cast<CeeSection**>(section);
+
+    HRESULT hr = gen->getSectionCreate(name, flags, ceeSection);
+
+    return hr;
+}
+
+HRESULT ICeeFileGen::SetDirectoryEntry(HCEEFILE ceeFile, HCEESECTION section, ULONG num, ULONG size, ULONG offset)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(section);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    CeeSection &sec = *(reinterpret_cast<CeeSection*>(section));
+    return(gen->setDirectoryEntry(sec, num, size, offset));
+}
+
+HRESULT ICeeFileGen::GetSectionDataLen (HCEESECTION section, ULONG *dataLen)
+{
+    TESTANDRETURNPOINTER(section);
+    TESTANDRETURNPOINTER(dataLen);
+
+    CeeSection *sec = reinterpret_cast<CeeSection*>(section);
+    *dataLen = sec->dataLen();
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::GetSectionRVA (HCEESECTION section, ULONG *rva)
+{
+    TESTANDRETURNPOINTER(section);
+    TESTANDRETURNPOINTER(rva);
+
+    CeeSection *sec = reinterpret_cast<CeeSection*>(section);
+    *rva = sec->getBaseRVA();
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::GetSectionBlock (HCEESECTION section, ULONG len,
+                            ULONG align, void **ppBytes)
+{
+    TESTANDRETURNPOINTER(section);
+    TESTANDRETURNPOINTER(ppBytes);
+
+    CeeSection *sec = reinterpret_cast<CeeSection*>(section);
+    void *bytes = sec->getBlock(len, align);
+    TESTANDRETURN(bytes != NULL, E_OUTOFMEMORY);
+    *ppBytes = bytes;
+
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::TruncateSection (HCEESECTION section, ULONG len)
+{
+    _ASSERTE(!"This is an obsolete function!");
+    return E_NOTIMPL;
+}
+
+HRESULT ICeeFileGen::AddSectionReloc (HCEESECTION section, ULONG offset, HCEESECTION relativeTo, CeeSectionRelocType relocType)
+{
+    TESTANDRETURNPOINTER(section);
+
+    CeeSection *sec = reinterpret_cast<CeeSection*>(section);
+    CeeSection *relSec = reinterpret_cast<CeeSection*>(relativeTo);
+
+    if (relSec)
+    {
+#ifdef EMIT_FIXUPS
+        CeeFileGenWriter * gen = reinterpret_cast<CeeFileGenWriter*>(&sec->ceeFile());
+        HRESULT hr = gen->addFixup(*sec, offset, relocType, relSec);
+        if (FAILED(hr))
+        {
+           return(hr);
+        }
+#endif
+        return(sec->addSectReloc(offset, *relSec, relocType));
+    }
+    else
+    {
+#ifdef EMIT_FIXUPS
+        CeeFileGenWriter * gen = reinterpret_cast<CeeFileGenWriter*>(&sec->ceeFile());
+        HRESULT hr = gen->addFixup(*sec, offset, relocType);
+        if (FAILED(hr))
+        {
+           return(hr);
+        }
+#endif
+        return(sec->addBaseReloc(offset, relocType));
+    }
+}
+
+HRESULT ICeeFileGen::SetSectionDirectoryEntry(HCEESECTION section, ULONG num)
+{
+    TESTANDRETURNPOINTER(section);
+
+    printf("Warning: deprecated method. Use SetDirectoryEntry instead\n");
+    CeeSection *sec = reinterpret_cast<CeeSection*>(section);
+    return(sec->directoryEntry(num));
+}
+
+HRESULT ICeeFileGen::SetOutputFileName (HCEEFILE ceeFile, __in LPWSTR outputFileName)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(outputFileName);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->setOutputFileName(outputFileName));
+}
+
+__success(return == S_OK) HRESULT ICeeFileGen::GetOutputFileName (HCEEFILE ceeFile, __out LPWSTR *outputFileName)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(outputFileName);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    TESTANDRETURNPOINTER(outputFileName);
+    *outputFileName = gen->getOutputFileName();
+    return S_OK;
+}
+
+
+HRESULT ICeeFileGen::SetResourceFileName (HCEEFILE ceeFile, __in LPWSTR resourceFileName)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(resourceFileName);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->setResourceFileName(resourceFileName));
+}
+
+__success(return == S_OK)
+HRESULT ICeeFileGen::GetResourceFileName (HCEEFILE ceeFile, __out LPWSTR *resourceFileName)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(resourceFileName);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    TESTANDRETURNPOINTER(resourceFileName);
+    *resourceFileName = gen->getResourceFileName();
+    return S_OK;
+}
+
+
+HRESULT ICeeFileGen::SetImageBase(HCEEFILE ceeFile, size_t imageBase)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    gen->setImageBase(imageBase);
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::SetImageBase64(HCEEFILE ceeFile, ULONGLONG imageBase)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    gen->setImageBase64(imageBase);
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::SetFileAlignment(HCEEFILE ceeFile, ULONG fileAlignment)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    gen->setFileAlignment(fileAlignment);
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::SetSubsystem(HCEEFILE ceeFile, DWORD subsystem, DWORD major, DWORD minor)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    gen->setSubsystem(subsystem, major, minor);
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::GetIMapTokenIface(HCEEFILE ceeFile, IMetaDataEmit *emitter, IUnknown **pIMapToken)
+{
+    _ASSERTE(!"This is an obsolete function!");
+    return E_NOTIMPL;
+}
+
+HRESULT ICeeFileGen::EmitMetaData (HCEEFILE ceeFile, IMetaDataEmit *emitter,
+                                                                mdScope scopeE)
+{
+    _ASSERTE(!"This is an obsolete function!");
+    return E_NOTIMPL;
+}
+
+HRESULT ICeeFileGen::EmitLibraryName (HCEEFILE ceeFile, IMetaDataEmit *emitter,
+                                                                mdScope scopeE)
+{
+    _ASSERTE(!"This is an obsolete function!");
+    return E_NOTIMPL;
+}
+
+HRESULT ICeeFileGen::GetMethodRVA(HCEEFILE ceeFile, ULONG codeOffset, ULONG *codeRVA)
+{
+    TESTANDRETURNARG(ceeFile != 0);
+    TESTANDRETURNPOINTER(codeRVA);
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    gen->getMethodRVA(codeOffset, codeRVA);
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::EmitString(HCEEFILE ceeFile, __in LPWSTR strValue, ULONG *strRef)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->getStringSection().getEmittedStringRef(strValue, strRef));
+}
+
+HRESULT ICeeFileGen::LinkCeeFile (HCEEFILE ceeFile)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->link();
+}
+
+HRESULT ICeeFileGen::FixupCeeFile (HCEEFILE ceeFile)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->fixup();
+}
+
+HRESULT ICeeFileGen::GetHeaderInfo (HCEEFILE ceeFile, PIMAGE_NT_HEADERS *ppNtHeaders, PIMAGE_SECTION_HEADER *ppSections, ULONG *pNumSections)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    gen->getPEWriter().getHeaderInfo(ppNtHeaders, ppSections, pNumSections);
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::GenerateCeeFile (HCEEFILE ceeFile)
+{
+    SO_NOT_MAINLINE_FUNCTION;
+
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->generateImage(NULL);     // NULL means don't write in-memory buffer, uses outputFileName
+}
+
+// GenerateCeeMemoryImage - returns in ppImage an in-memory PE image allocated by CoTaskMemAlloc()
+// the caller is responsible for calling CoTaskMemFree on this memory image
+HRESULT ICeeFileGen::GenerateCeeMemoryImage (HCEEFILE ceeFile, void **ppImage)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(ppImage);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->generateImage(ppImage);
+}
+
+HRESULT ICeeFileGen::SetEntryPoint(HCEEFILE ceeFile, mdMethodDef method)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->setEntryPoint(method);
+}
+
+HRESULT ICeeFileGen::GetEntryPoint(HCEEFILE ceeFile, mdMethodDef *method)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    TESTANDRETURNPOINTER(method);
+    *method = gen->getEntryPoint();
+    return S_OK;
+}
+
+
+HRESULT ICeeFileGen::SetComImageFlags (HCEEFILE ceeFile, DWORD mask)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->setComImageFlags(mask);
+}
+
+HRESULT ICeeFileGen::ClearComImageFlags (HCEEFILE ceeFile, DWORD mask)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->clearComImageFlags(mask);
+}
+
+HRESULT ICeeFileGen::GetComImageFlags (HCEEFILE ceeFile, DWORD *mask)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    TESTANDRETURNPOINTER(mask);
+    *mask = gen->getComImageFlags();
+    return S_OK;
+}
+
+
+HRESULT ICeeFileGen::SetDllSwitch (HCEEFILE ceeFile, BOOL dllSwitch)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->setDllSwitch(dllSwitch==TRUE));
+}
+
+HRESULT ICeeFileGen::GetDllSwitch (HCEEFILE ceeFile, BOOL *dllSwitch)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    TESTANDRETURNPOINTER(dllSwitch);
+    *dllSwitch = gen->getDllSwitch();
+    return S_OK;
+}
+
+HRESULT ICeeFileGen::SetObjSwitch (HCEEFILE ceeFile, BOOL objSwitch)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->setObjSwitch(objSwitch==TRUE));
+}
+
+HRESULT ICeeFileGen::GetObjSwitch (HCEEFILE ceeFile, BOOL *objSwitch)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    TESTANDRETURNPOINTER(objSwitch);
+    *objSwitch = gen->getObjSwitch();
+    return S_OK;
+}
+
+
+HRESULT ICeeFileGen::SetLibraryName (HCEEFILE ceeFile, __in LPWSTR LibraryName)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(LibraryName);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->setLibraryName(LibraryName));
+}
+
+HRESULT ICeeFileGen::SetLibraryGuid (HCEEFILE ceeFile, __in LPWSTR LibraryGuid)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(LibraryGuid);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->setLibraryGuid(LibraryGuid));
+}
+
+__success(return == S_OK) HRESULT ICeeFileGen::GetLibraryName (HCEEFILE ceeFile, __out LPWSTR *LibraryName)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(LibraryName);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    *LibraryName = gen->getLibraryName();
+    return S_OK;
+}
+
+
+
+HRESULT ICeeFileGen::EmitMetaDataEx (HCEEFILE ceeFile, IMetaDataEmit *emitter)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(emitter);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->emitMetaData(emitter));
+}
+
+HRESULT ICeeFileGen::EmitMetaDataAt (HCEEFILE ceeFile, IMetaDataEmit *emitter, HCEESECTION section, DWORD offset, BYTE* buffer, unsigned buffLen)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(emitter);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    CeeSection* sec = reinterpret_cast<CeeSection*>(section);
+
+    return(gen->emitMetaData(emitter, sec, offset, buffer, buffLen));
+}
+
+HRESULT ICeeFileGen::EmitLibraryNameEx (HCEEFILE ceeFile, IMetaDataEmit *emitter)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(emitter);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->emitLibraryName(emitter));
+}
+
+HRESULT ICeeFileGen::GetIMapTokenIfaceEx(HCEEFILE ceeFile, IMetaDataEmit *emitter, IUnknown **pIMapToken)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(pIMapToken);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->getMapTokenIface(pIMapToken);
+}
+
+HRESULT ICeeFileGen::AddNotificationHandler(HCEEFILE ceeFile,
+                                            IUnknown *pHandler)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(pHandler);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->addNotificationHandler(pHandler);
+}
+
+HRESULT ICeeFileGen::EmitMacroDefinitions(HCEEFILE ceeFile, void *pData, DWORD cData)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->EmitMacroDefinitions(pData, cData);
+}
+
+HRESULT ICeeFileGen::SetManifestEntry(HCEEFILE ceeFile, ULONG size, ULONG offset)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->setManifestEntry(size, offset);
+}
+
+HRESULT ICeeFileGen::SetStrongNameEntry(HCEEFILE ceeFile, ULONG size, ULONG offset)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->setStrongNameEntry(size, offset);
+}
+
+HRESULT ICeeFileGen::ComputeSectionOffset(HCEESECTION section, __in char *ptr,
+										  unsigned *offset)
+{
+    TESTANDRETURNPOINTER(section);
+
+    CeeSection &sec = *(reinterpret_cast<CeeSection*>(section));
+
+	*offset = sec.computeOffset(ptr);
+
+	return S_OK;
+}
+
+__success(return == S_OK)
+HRESULT ICeeFileGen::ComputeSectionPointer(HCEESECTION section, ULONG offset,
+										  __out char **ptr)
+{
+    TESTANDRETURNPOINTER(section);
+
+    CeeSection &sec = *(reinterpret_cast<CeeSection*>(section));
+
+	*ptr = sec.computePointer(offset);
+
+	return S_OK;
+}
+
+HRESULT ICeeFileGen::ComputeOffset(HCEEFILE ceeFile, __in char *ptr,
+								   HCEESECTION *pSection, unsigned *offset)
+{
+    TESTANDRETURNPOINTER(pSection);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+
+	CeeSection *section;
+
+	HRESULT hr = gen->computeOffset(ptr, &section, offset);
+
+	if (SUCCEEDED(hr))
+		*pSection = reinterpret_cast<HCEESECTION>(section);
+
+	return hr;
+}
+
+HRESULT ICeeFileGen::SetEnCRVABase(HCEEFILE ceeFile, ULONG dataBase, ULONG rdataBase)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->setEnCRvaBase(dataBase, rdataBase);
+}
+
+HRESULT ICeeFileGen::GetCorHeader(HCEEFILE ceeFile,
+								  IMAGE_COR20_HEADER **header)
+{
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+	return gen->getCorHeader(header);
+}
+
+HRESULT ICeeFileGen::SetVTableEntry(HCEEFILE ceeFile, ULONG size, ULONG offset)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->setVTableEntry(size, offset);
+}
+
+HRESULT ICeeFileGen::SetVTableEntry64(HCEEFILE ceeFile, ULONG size, void* ptr)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return gen->setVTableEntry64(size, ptr);
+}
+
+HRESULT ICeeFileGen::GetFileTimeStamp (HCEEFILE ceeFile, DWORD *pTimeStamp)
+{
+    TESTANDRETURNPOINTER(ceeFile);
+    TESTANDRETURNPOINTER(pTimeStamp);
+
+    CeeFileGenWriter *gen = reinterpret_cast<CeeFileGenWriter*>(ceeFile);
+    return(gen->getFileTimeStamp(pTimeStamp));
+}
+
diff --git a/src/dlls/mscorpe/mscorpe/mscorpe.def b/src/dlls/mscorpe/mscorpe/mscorpe.def
new file mode 100644
index 0000000000..61cb90375f
--- /dev/null
+++ b/src/dlls/mscorpe/mscorpe/mscorpe.def
@@ -0,0 +1,11 @@
+;
+; Copyright (c) Microsoft. All rights reserved.
+; Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+;
+; mscorpe.def for mscorpe.dll (a simple wrapper around real implementation mscorpehost.dll - see 
+; file:wrapper.cpp for more details)
+; PE file generator in EE
+
+EXPORTS
+     CreateICeeFileGen
+     DestroyICeeFileGen
diff --git a/src/dlls/mscorpe/mscorpe/mscorpe.nativeproj b/src/dlls/mscorpe/mscorpe/mscorpe.nativeproj
new file mode 100644
index 0000000000..526cf6088b
--- /dev/null
+++ b/src/dlls/mscorpe/mscorpe/mscorpe.nativeproj
@@ -0,0 +1,46 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="dogfood">
+
+    <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.props" />
+
+    <PropertyGroup>
+        <NoCrt>true</NoCrt>
+        <LinkUseCMT>true</LinkUseCMT>
+        <UserIncludes>
+            $(UserIncludes);
+            .
+        </UserIncludes>
+        <CDefines>$(CDefines);__TODO_PORT_TO_WRAPPERS__;UNICODE</CDefines>
+        <OutputName>mscorpe</OutputName>
+        <FileToMarkForSigning>$(BinariesDirectory)\$(OutputName).dll</FileToMarkForSigning>
+        <OutputLibPath>$(IntermediateOutputDirectory)</OutputLibPath>
+        <DllDef>$(OutputName).def</DllDef>
+        <TargetType>DYNLINK</TargetType>
+        <LinkSubsystem>windows</LinkSubsystem>
+        <PogoOptimized>true</PogoOptimized>
+        <DllEntryPoint>_DllMainCRTStartup</DllEntryPoint>
+        <Win32DllLibs>$(ClrLibPath)\utilcodestaticnohost.lib</Win32DllLibs>
+        <UseMsvcrt>false</UseMsvcrt>
+        <NoLinkGdi32>true</NoLinkGdi32>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <TargetLib Include="$(SdkLibPath)\mscoree.lib" />
+        <TargetLib Include="$(SdkLibPath)\oleaut32.lib" />
+        <TargetLib Include="$(SdkLibPath)\uuid.lib" />
+        <TargetLib Include="$(SdkLibPath)\kernel32.lib" />
+        <TargetLib Include="$(SdkLibPath)\advapi32.lib" />
+        <TargetLib Include="$(SdkLibPath)\user32.lib" />
+        <TargetLib Include="$(SdkLibPath)\shlwapi.lib" />
+        <ProjectReference Include="$(ClrSrcDirectory)utilcode\staticnohost\staticnohost.nativeproj"/>
+    </ItemGroup>
+    
+    <ItemGroup>
+        <RCResourceFile Include="..\Native.rc" />
+    </ItemGroup>
+    
+    <ItemGroup>
+        <CppCompile Include="wrapper.cpp" />
+    </ItemGroup>
+
+    <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
+</Project>
diff --git a/src/dlls/mscorpe/mscorpe/wrapper.cpp b/src/dlls/mscorpe/mscorpe/wrapper.cpp
new file mode 100644
index 0000000000..c5822cd127
--- /dev/null
+++ b/src/dlls/mscorpe/mscorpe/wrapper.cpp
@@ -0,0 +1,150 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+// 
+// File: wrapper.cpp
+// 
+
+// 
+// This file implements a simple wrapper DLL (mscorpe.dll) which calls properly into mscorpehost.dll.
+// It exists because of compatibility with 1.x/2.0 apps running on CLR 4.0+. Such older apps could pass 
+// full path to LoadLibrary() Windows API and get this DLL.
+// 
+// Noone in CLR should ever try to load this DLL directly (using LoadLibrary API). Note that hosting APIs 
+// and PInvoke redirect mscorpe.dll to mscorpehost.dll automatically.
+// 
+
+#include <MscorpeSxSWrapper.h>
+
+#include <mscoree.h>
+#include <metahost.h>
+
+// Globals
+HINSTANCE g_hThisInst;  // This library.
+
+//*****************************************************************************
+// Handle lifetime of loaded library.
+//*****************************************************************************
+extern "C"
+BOOL WINAPI 
+DllMain(
+    HINSTANCE hInstance, 
+    DWORD     dwReason, 
+    LPVOID    lpReserved)
+{
+    switch (dwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+        {   // Save the module handle.
+            g_hThisInst = hInstance;
+            DisableThreadLibraryCalls((HMODULE)hInstance);
+        }
+        break;
+    case DLL_PROCESS_DETACH:
+        break;
+    }
+
+    return TRUE;
+} // DllMain
+
+// Implementation for utilcode
+HINSTANCE 
+GetModuleInst()
+{
+    return g_hThisInst;
+} // GetModuleInst
+
+// Load correct SxS version of mscorpe.dll and initialize it (uses shim).
+HRESULT 
+LoadMscorpe(HMODULE * phModule)
+{
+    HRESULT hr = S_OK;
+    ICLRMetaHost *    pMetaHost = NULL;
+    ICLRRuntimeInfo * pCLRRuntimeInfo = NULL;
+    
+    // Get full DLL path
+    WCHAR wszPath[_MAX_PATH];
+    DWORD dwLength = GetModuleFileName((HMODULE)g_hThisInst, wszPath, NumItems(wszPath));
+    
+    if ((dwLength == 0) || 
+        ((dwLength == NumItems(wszPath)) && 
+         (GetLastError() == ERROR_INSUFFICIENT_BUFFER)))
+    {
+        IfFailGo(CLR_E_SHIM_RUNTIMELOAD);
+    }
+    
+    // Find start of '\mscorpe.dll'
+    LPWSTR wszSeparator = wcsrchr(wszPath, L'\\');
+    if (wszSeparator == NULL)
+    {
+        IfFailGo(CLR_E_SHIM_RUNTIMELOAD);
+    }
+    // Check the name of this DLL
+    _ASSERTE(_wcsicmp(wszSeparator, L"\\mscorpe.dll") == 0);
+    // Remove the DLL name
+    *wszSeparator = 0;
+
+    // Find start of last directory name (\<version>),
+    // C:\Windows\Microsoft.NET\Framework\[[v4.0.12345]]\mscorpe.dll
+    LPWSTR wszLastDirectoryName = wcsrchr(wszPath, L'\\');
+    if (wszLastDirectoryName == NULL)
+    {
+        IfFailGo(CLR_E_SHIM_RUNTIMELOAD);
+    }
+    LPWSTR wszVersion = wszLastDirectoryName + 1;
+    
+    IfFailGo(CLRCreateInstance(
+        CLSID_CLRMetaHost, 
+        IID_ICLRMetaHost, 
+        reinterpret_cast<LPVOID *>(&pMetaHost)));
+    
+    IfFailGo(pMetaHost->GetRuntime(
+        wszVersion, 
+        IID_ICLRRuntimeInfo, 
+        reinterpret_cast<LPVOID *>(&pCLRRuntimeInfo)));
+    
+    // Shim will load correct SxS version of mscorpe.dll and will initialize it
+    IfFailGo(pCLRRuntimeInfo->LoadLibrary(
+        L"mscorpe.dll", 
+        phModule));
+    
+ErrExit:
+    if (pMetaHost != NULL)
+    {
+        pMetaHost->Release();
+        pMetaHost = NULL;
+    }
+    if (pCLRRuntimeInfo != NULL)
+    {
+        pCLRRuntimeInfo->Release();
+        pCLRRuntimeInfo = NULL;
+    }
+    
+    if (FAILED(hr))
+    {
+        *phModule = NULL;
+    }
+    
+    return hr;
+} // LoadMscorpe
+
+// SxS wrapper of mscorpe.dll entrypoints
+typedef MscorpeSxSWrapper<LoadMscorpe> MscorpeSxS;
+
+// Export of 'original' 1.x/2.0 mscorpe.dll
+EXTERN_C 
+HRESULT __stdcall 
+CreateICeeFileGen(
+    ICeeFileGen ** ppCeeFileGen)
+{
+    return MscorpeSxS::CreateICeeFileGen(ppCeeFileGen);
+}
+
+// Export of 'original' 1.x/2.0 mscorpe.dll
+EXTERN_C 
+HRESULT __stdcall 
+DestroyICeeFileGen(ICeeFileGen ** ppCeeFileGen)
+{
+    return MscorpeSxS::DestroyICeeFileGen(ppCeeFileGen);
+}
diff --git a/src/dlls/mscorpe/mscorpehost/mscorpehost.def b/src/dlls/mscorpe/mscorpehost/mscorpehost.def
new file mode 100644
index 0000000000..e10fc1b682
--- /dev/null
+++ b/src/dlls/mscorpe/mscorpehost/mscorpehost.def
@@ -0,0 +1,12 @@
+;
+; Copyright (c) Microsoft. All rights reserved.
+; Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+;
+; PeWriter.def for PeWriter.dll
+; PE file generator in EE
+
+EXPORTS
+     CreateICeeFileGen
+     DestroyICeeFileGen
+     InitializeSxS
+
diff --git a/src/dlls/mscorpe/mscorpehost/mscorpehost.nativeproj b/src/dlls/mscorpe/mscorpehost/mscorpehost.nativeproj
new file mode 100644
index 0000000000..45af39f38b
--- /dev/null
+++ b/src/dlls/mscorpe/mscorpehost/mscorpehost.nativeproj
@@ -0,0 +1,68 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="dogfood">
+    <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.props" />
+
+    <PropertyGroup>
+        <LibCLib>$(ClrCrtLib)</LibCLib>
+        <OutputName>mscorpehost</OutputName>
+        <FileToMarkForSigning>$(BinariesDirectory)\$(OutputName).dll</FileToMarkForSigning>
+        <OutputLibPath>$(IntermediateOutputDirectory)</OutputLibPath>
+        <DllDef>$(OutputName).def</DllDef>
+        <TargetType>DYNLINK</TargetType>
+        <PCHHeader>stdafx.h</PCHHeader>
+        <EnableCxxPCHHeaders>true</EnableCxxPCHHeaders>
+        <PCHCompile>..\stdafx.cpp</PCHCompile>   
+        <UserIncludes>
+            $(UserIncludes);
+            .;
+            ../../vm
+        </UserIncludes>
+        <CDefines>$(CDefines);__TODO_PORT_TO_WRAPPERS__;UNICODE</CDefines>
+        <LinkSubsystem>windows</LinkSubsystem>
+        <PogoOptimized>true</PogoOptimized>
+        <DllEntryPoint>_DllMainCRTStartup</DllEntryPoint>  
+        <ExtDelayImpLib>false</ExtDelayImpLib>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <LinkDelayLoad Condition="'$(LinkDelayLoad)'!=''">$(LinkDelayLoad);</LinkDelayLoad>
+        <LinkDelayLoad>$(LinkDelayLoad)ole32.dll</LinkDelayLoad>
+    </PropertyGroup>
+    
+    <ItemGroup>
+        <CppCompile Include="..\utilcodeinit.cpp" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <LinkPreCrtLibs Include="$(ClrLibPath)\utilcode.lib">
+            <ProjectReference>$(ClrSrcDirectory)utilcode\dyncrt\dyncrt.nativeproj</ProjectReference>
+        </LinkPreCrtLibs>
+
+        <TargetLib Include="$(SdkLibPath)\mscoree.lib" />
+        <TargetLib Include="$(ClrLibPath)\ceefgen.lib">
+            <ProjectReference>$(ClrSrcDirectory)md\ceefilegen\ceefgen.nativeproj</ProjectReference>
+        </TargetLib>
+        <TargetLib Include="$(ClrLibPath)\delayimp.lib">
+            <ProjectReference>$(ClrSrcDirectory)delayimp\delayimp.nativeproj</ProjectReference>
+        </TargetLib>
+        <TargetLib Include="$(SdkLibPath)\ole32.lib" />
+        <TargetLib Include="$(SdkLibPath)\oleaut32.lib" />
+        <TargetLib Include="$(SdkLibPath)\uuid.lib" />
+        <TargetLib Include="$(SdkLibPath)\kernel32.lib" />
+        <TargetLib Include="$(SdkLibPath)\advapi32.lib" />
+        <TargetLib Include="$(SdkLibPath)\user32.lib" />
+        <TargetLib Include="$(SdkLibPath)\shlwapi.lib" />
+    </ItemGroup>
+    
+    <ItemGroup>
+        <RCResourceFile Include="..\Native.rc" />
+    </ItemGroup>
+    
+    <ItemGroup>
+        <CppCompile Include="..\ICeeFileGen.cpp" />
+        <CppCompile Include="..\CeeFileGenWriter.cpp" />
+        <CppCompile Include="..\PEWriter.cpp" />
+        <CppCompile Include="..\CeeFileGenWriterTokens.cpp" />
+    </ItemGroup>
+    
+    <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
+</Project>
diff --git a/src/dlls/mscorpe/pewriter.cpp b/src/dlls/mscorpe/pewriter.cpp
new file mode 100644
index 0000000000..7494ad9d3d
--- /dev/null
+++ b/src/dlls/mscorpe/pewriter.cpp
@@ -0,0 +1,2401 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+#include "stdafx.h"
+
+#include "blobfetcher.h"
+#include "pedecoder.h"
+
+#ifdef _DEBUG
+#define LOGGING
+#endif
+
+#ifdef LOGGING
+#include "log.h"
+
+static const char* const RelocName[] = {
+    "Absolute", "Unk1",    "Unk2",    "HighLow", "Unk4", "MapToken",
+    "Relative", "FilePos", "CodeRel", "Movl64",  "Dir64", "PcRel25", "PcRel64",
+    "AbsTag" };
+static const char RelocSpaces[] = "        ";
+
+static INT64 s_minPcRel25;
+static INT64 s_maxPcRel25;
+#endif
+
+#ifdef EnC_SUPPORTED
+#define ENC_DELTA_HACK
+#endif
+
+    /* This is the stub program that says it can't be run in DOS mode */
+    /* it is x86 specific, but so is dos so I suppose that is OK */
+static const unsigned char x86StubPgm[] = {
+    0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c, 0xcd, 0x21, 0x54, 0x68,
+    0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f,
+    0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
+    0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x0d, 0x0d, 0x0a, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+    /* number of pad bytes to make 'len' bytes align to 'align' */
+inline static unsigned roundUp(unsigned len, unsigned align) {
+    return((len + align-1) & ~(align-1));
+}
+
+inline static unsigned padLen(unsigned len, unsigned align) {
+    return(roundUp(len, align) - len);
+}
+
+inline static bool isExeOrDll(IMAGE_NT_HEADERS* ntHeaders) {
+    return ((ntHeaders->FileHeader.Characteristics & VAL16(IMAGE_FILE_EXECUTABLE_IMAGE)) != 0);
+}
+
+#ifndef IMAGE_DLLCHARACTERISTICS_NO_SEH
+#define IMAGE_DLLCHARACTERISTICS_NO_SEH 0x400
+#endif
+
+#ifndef IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE
+#define IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE   0x0040
+#endif
+
+#ifndef IMAGE_DLLCHARACTERISTICS_NX_COMPAT
+#define IMAGE_DLLCHARACTERISTICS_NX_COMPAT      0x0100
+#endif
+
+#define COPY_AND_ADVANCE(target, src, size) { \
+                            ::memcpy((void *) (target), (const void *) (src), (size)); \
+                            (char *&) (target) += (size); }
+
+/******************************************************************/
+int __cdecl relocCmp(const void* a_, const void* b_) {
+
+    const PESectionReloc* a = (const PESectionReloc*) a_;
+    const PESectionReloc* b = (const PESectionReloc*) b_;
+    return (a->offset > b->offset ? 1 : (a->offset == b->offset ? 0 : -1));
+}
+
+PERelocSection::PERelocSection(PEWriterSection *pBaseReloc)
+{
+   section = pBaseReloc;
+   relocPage = (unsigned) -1;
+   relocSize = 0;
+   relocSizeAddr = NULL;
+   pages = 0;
+
+#ifdef _DEBUG
+   lastRVA = 0;
+#endif
+}
+
+void PERelocSection::AddBaseReloc(unsigned rva, int type, unsigned short highAdj)
+{
+#ifdef _DEBUG
+    // Guarantee that we're adding relocs in strict increasing order.
+    _ASSERTE(rva > lastRVA);
+    lastRVA = rva;
+#endif
+
+    if (relocPage != (rva & ~0xFFF)) {
+        if (relocSizeAddr) {
+            if ((relocSize & 1) == 1) {     // pad to an even number
+                short *ps = (short*) section->getBlock(2);
+                if(ps) {
+                    *ps = 0;
+                    relocSize++;
+                }
+            }
+            *relocSizeAddr = VAL32(relocSize*2 + sizeof(IMAGE_BASE_RELOCATION));
+        }
+        IMAGE_BASE_RELOCATION* base = (IMAGE_BASE_RELOCATION*) section->getBlock(sizeof(IMAGE_BASE_RELOCATION));
+        if(base) {
+            relocPage = (rva & ~0xFFF);
+            relocSize = 0;
+            base->VirtualAddress = VAL32(relocPage);
+            // Size needs to be fixed up when we know it - save address here
+            relocSizeAddr = &base->SizeOfBlock;
+            pages++;
+        }
+    }
+
+    relocSize++;
+    unsigned short* offset = (unsigned short*) section->getBlock(2);
+    if(offset) {
+        *offset = VAL16((rva & 0xFFF) | (type << 12));
+    }
+}
+
+void PERelocSection::Finish(bool isPE32)
+{
+    // fixup the last reloc block (if there was one)
+    if (relocSizeAddr) {
+        if ((relocSize & 1) == 1) {     // pad to an even number
+            short* psh = (short*) section->getBlock(2);
+            if(psh)
+            {
+                *psh = 0;
+                relocSize++;
+            }
+        }
+        *relocSizeAddr = VAL32(relocSize*2 + sizeof(IMAGE_BASE_RELOCATION));
+    }
+}
+
+#define GET_UNALIGNED_INT32(_ptr)     ((INT32) GET_UNALIGNED_VAL32(_ptr))
+
+static inline HRESULT SignedFitsIn31Bits(INT64 immediate)
+{
+    INT64 hiBits = immediate >> 31;
+    if ((hiBits == 0) || (hiBits == -1))
+    {
+        return S_OK;
+    }
+    else
+    {
+        return E_FAIL;
+    }
+}
+
+static inline HRESULT UnsignedFitsIn32Bits(UINT64 immediate)
+{
+    UINT64 hiBits = immediate >> 32;
+    if (hiBits == 0)
+    {
+        return S_OK;
+    }
+    else
+    {
+        return E_FAIL;
+    }
+}
+
+static inline HRESULT AddOvf_RVA(DWORD& a, DWORD b)
+{
+    DWORD r = a + b; 
+    if (r < a)  // Check for overflow
+        return E_FAIL;
+    a = r;
+    return S_OK;
+}
+
+static inline HRESULT AddOvf_S_U32(INT64 & a, unsigned int b)
+{
+    INT64 r = a + b;
+    if (r < a)  // Check for overflow
+        return E_FAIL;
+    a = r;
+    return S_OK;
+}
+
+static inline HRESULT AddOvf_S_S32(INT64 & a, int b)
+{
+    INT64 r = a + b;
+    if ( ((r >= a) && (b >= 0)) ||
+         ((r <  a) && (b <  0))    )
+    {
+        a = r;
+        return S_OK;
+    }
+    return E_FAIL;
+}
+
+static inline HRESULT AddOvf_U_U32(UINT64 & a, unsigned int b)
+{
+    UINT64 r = a + b;
+    if (r < a)  // Check for overflow
+        return E_FAIL;
+    a = r;
+    return S_OK;
+}
+
+static inline HRESULT AddOvf_U_U(UINT64 & a, UINT64 b)
+{
+    UINT64 r = a + b;
+    if (r < a)  // Check for overflow
+        return E_FAIL;
+    a = r;
+    return S_OK;
+}
+
+static inline HRESULT SubOvf_S_U32(INT64 & a, unsigned int b)
+{
+    INT64 r = a - b;
+    if (r > a)  // Check for overflow
+        return E_FAIL;
+    a = r;
+    return S_OK;
+}
+
+static inline HRESULT SubOvf_S_U(INT64 & a, UINT64 b)
+{
+    INT64 r = a - b;
+    if (r > a)  // Check for overflow
+        return E_FAIL;
+    a = r;
+    return S_OK;
+}
+
+static inline HRESULT SubOvf_U_U32(UINT64 & a, unsigned int b)
+{
+    UINT64 r = a - b;
+    if (r > a)  // Check for overflow
+        return E_FAIL;
+    a = r;
+    return S_OK;
+}
+
+/* subtract two unsigned pointers yeilding a signed pointer sized int */
+static inline HRESULT SubOvf_U_U(INT64 & r, UINT64 a, UINT64 b)
+{
+    r = a - b;
+    if ( ((a >= b) && (r >= 0))  ||
+         ((a <  b) && (r <  0)))
+    {
+        return S_OK;
+    }
+    return E_FAIL;
+}
+
+
+/******************************************************************/
+/* apply the relocs for this section.
+*/
+
+HRESULT PEWriterSection::applyRelocs(IMAGE_NT_HEADERS  *  pNtHeaders,
+                                     PERelocSection    *  pBaseRelocSection,
+                                     CeeGenTokenMapper *  pTokenMapper,
+                                     DWORD                dataRvaBase,
+                                     DWORD                rdataRvaBase,
+                                     DWORD                codeRvaBase)
+{
+    HRESULT hr;
+
+    _ASSERTE(pBaseRelocSection); // need section to write relocs
+
+#ifdef LOGGING
+    // Ensure that if someone adds a value to CeeSectionRelocType in cor.h,
+    // that they also add an entry to RelocName.
+    static_assert_no_msg(NumItems(RelocName) == srRelocSentinel);
+#ifdef _DEBUG
+    for (unsigned int i = 0; i < srRelocSentinel; i++)
+    {
+        _ASSERTE(strlen(RelocName[i]) <= strlen(RelocSpaces));
+    }
+#endif // _DEBUG
+#endif // LOGGING
+
+    if (m_relocCur == m_relocStart)
+        return S_OK;
+
+    bool isPE32 = (pNtHeaders->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR32_MAGIC));
+
+#ifdef LOGGING
+    LOG((LF_ZAP, LL_INFO100000,
+         "APPLYING section relocs for section %s start RVA = 0x%x\n",
+         m_name, m_baseRVA));
+#endif
+
+    UINT64 imageBase = isPE32 ? VAL32(((IMAGE_NT_HEADERS32 *) pNtHeaders)->OptionalHeader.ImageBase)
+                              : VAL64(((IMAGE_NT_HEADERS64 *) pNtHeaders)->OptionalHeader.ImageBase);
+
+    // sort them to make the baseRelocs pretty
+    qsort(m_relocStart, (m_relocCur - m_relocStart), sizeof(PESectionReloc), relocCmp);
+
+    for (PESectionReloc * cur = m_relocStart; cur < m_relocCur; cur++)
+    {
+        _ASSERTE((cur->offset + 4) <= m_blobFetcher.GetDataLen());
+
+        int    curType      = cur->type;
+        DWORD  curOffset    = cur->offset;
+        bool   isRelocPtr   = ((curType & srRelocPtr) != 0);
+        bool   noBaseBaseReloc = ((curType & srNoBaseReloc) != 0);
+        UINT64 targetOffset = 0;
+        int    slotNum      = 0;
+        INT64  oldStarPos;
+
+        // If cur->section is NULL then this is a pointer outside the module. 
+        bool externalAddress = (cur->section == NULL);
+
+        curType &= ~(srRelocPtr | srNoBaseReloc);
+
+        /* If we see any srRelocHighLow's in a PE64 file we convert them into DIR64 relocs */
+        if (!isPE32 && (curType == srRelocHighLow))
+            curType = srRelocDir64;
+
+        /* If we have an IA64 instruction fixup then extract the slot number and adjust curOffset */
+        if ((curType == srRelocIA64PcRel25) || (curType == srRelocIA64Imm64) || (curType == srRelocIA64PcRel64))
+        {
+            _ASSERTE((curOffset & 0x3) == 0);
+            slotNum = (curOffset & 0xf) >> 2;
+            curOffset &= ~0xf;
+        }
+
+        DWORD curRVA = m_baseRVA;    // RVA in the PE image of the reloc site
+        IfFailRet(AddOvf_RVA(curRVA, curOffset));
+        DWORD UNALIGNED * pos = (DWORD *) m_blobFetcher.ComputePointer(curOffset);
+
+        PREFIX_ASSUME(pos != NULL);
+
+#ifdef LOGGING
+        LOG((LF_ZAP, LL_INFO1000000,
+             "   Reloc %s%s%s at %-7s+%04x (RVA=%08x) at" FMT_ADDR,
+             RelocName[curType], (isRelocPtr) ? "Ptr" : "   ",
+             &RelocSpaces[strlen(RelocName[curType])],
+             m_name, curOffset, curRVA, DBG_ADDR(pos)));
+#endif
+        //
+        // 'pos' is the site of the reloc
+        // Compute 'targetOffset' from pointer if necessary
+        //
+
+        if (isRelocPtr)
+        {
+            // Calculate the value of ptr to pass to computeOffset
+            char * ptr = (char *) pos;
+            
+            if (curType == srRelocRelative) {
+                // 
+                // Here we add sizeof(int) because we need to calculate 
+                // ptr as the true call target address (x86 pc-rel)
+                // We need to true call target address since pass it
+                // to computeOffset and this function would fall if
+                // the address we pass is before the start of a section
+                // 
+                oldStarPos   = (SSIZE_T) ptr;
+                IfFailRet(AddOvf_S_S32(oldStarPos, GET_UNALIGNED_INT32(pos)));
+                IfFailRet(AddOvf_S_U32(oldStarPos, sizeof(int)));
+                ptr          = (char *) oldStarPos;
+                targetOffset = externalAddress ? (size_t) ptr
+                                               : cur->section->computeOffset(ptr);
+                // We subtract off the four bytes that we added previous
+                // since the code below depends upon this
+                IfFailRet(SubOvf_U_U32(targetOffset, sizeof(int)));
+                IfFailRet(UnsignedFitsIn32Bits(targetOffset));  // Check for overflow
+                SET_UNALIGNED_VAL32(pos, targetOffset);
+            }
+            else if (curType == srRelocIA64Imm64) {
+                _ASSERTE(slotNum == 1);
+                ptr = (char *) ((intptr_t) GetIA64Imm64((UINT64 *) ptr));
+                oldStarPos   = (SSIZE_T) ptr;
+                targetOffset = externalAddress ? (size_t) ptr
+                                               : cur->section->computeOffset(ptr);
+                _ASSERTE(!isPE32);
+                PutIA64Imm64((UINT64 *)pos, targetOffset);
+            }
+            else if (curType == srRelocIA64PcRel64) {
+                _ASSERTE(slotNum == 1);
+                ptr = (char *) ((intptr_t) GetIA64Rel64((UINT64 *) ptr));
+                oldStarPos   = (SSIZE_T) ptr;
+                targetOffset = externalAddress ? (size_t) ptr
+                                               : cur->section->computeOffset(ptr);
+                _ASSERTE(!isPE32);
+                PutIA64Rel64((UINT64 *)pos, targetOffset);
+            }
+            else {
+                _ASSERTE(curType != srRelocIA64PcRel25);
+                ptr = (char *) GET_UNALIGNED_VALPTR(ptr);
+                oldStarPos   = (SSIZE_T) ptr;
+                targetOffset = externalAddress ? (size_t) ptr
+                                               : cur->section->computeOffset(ptr);
+                IfFailRet(UnsignedFitsIn32Bits(targetOffset));  // Check for overflow
+                SET_UNALIGNED_VAL32(pos, targetOffset);
+                /* Zero the upper 32-bits for a machine with 64-bit pointers */
+                if (!isPE32)
+                    SET_UNALIGNED_VAL32(pos+1, 0);
+            }
+        }
+#ifdef LOGGING
+        else
+        {
+            if (curType == srRelocIA64PcRel25)
+            {
+                oldStarPos = GetIA64Rel25((UINT64 *) pos, slotNum);
+            }
+            else
+            {
+                if (curType == srRelocIA64PcRel64)
+                {
+                    _ASSERTE(slotNum == 1);
+                    oldStarPos = GetIA64Rel64((UINT64 *) pos);
+                }
+                else if (curType == srRelocIA64Imm64)
+                {
+                    oldStarPos = GetIA64Imm64((UINT64 *)pos);
+                }
+                else
+                {
+                    oldStarPos = GET_UNALIGNED_VAL32(pos);
+                }
+            }
+        }
+#endif
+
+        //
+        // 'targetOffset' has now been computed. Write out the appropriate value.
+        // Record base relocs as necessary.
+        //
+
+        bool  fBaseReloc = false;
+        bool  fNeedBrl   = false;
+        INT64 newStarPos = 0; // oldStarPos gets updated to newStarPos
+
+        if (curType == srRelocAbsolute || curType == srRelocAbsoluteTagged) {
+            _ASSERTE(!externalAddress);
+
+            newStarPos = GET_UNALIGNED_INT32(pos);
+
+            if (curType == srRelocAbsoluteTagged)
+                newStarPos = (newStarPos & ~0x80000001) >> 1;
+
+            if (rdataRvaBase > 0 && ! strcmp((const char *)(cur->section->m_name), ".rdata"))
+                IfFailRet(AddOvf_S_U32(newStarPos, rdataRvaBase));
+            else if (dataRvaBase > 0 && ! strcmp((const char *)(cur->section->m_name), ".data"))
+                IfFailRet(AddOvf_S_U32(newStarPos, dataRvaBase));
+            else
+                IfFailRet(AddOvf_S_U32(newStarPos, cur->section->m_baseRVA));
+
+            if (curType == srRelocAbsoluteTagged)
+                newStarPos = (newStarPos << 1) | 0x80000001;
+
+            SET_UNALIGNED_VAL32(pos, newStarPos);
+        }
+        else if (curType == srRelocMapToken)
+        {
+            mdToken newToken;
+            if (pTokenMapper != NULL && pTokenMapper->HasTokenMoved((mdToken)GET_UNALIGNED_VAL32(pos), newToken)) {
+                // we have a mapped token
+                SET_UNALIGNED_VAL32(pos, newToken);
+            }
+            newStarPos = GET_UNALIGNED_VAL32(pos);
+        }
+        else if (curType == srRelocFilePos)
+        {
+            _ASSERTE(!externalAddress);
+            newStarPos = GET_UNALIGNED_VAL32(pos);
+            IfFailRet(AddOvf_S_U32(newStarPos, cur->section->m_filePos));
+            SET_UNALIGNED_VAL32(pos, newStarPos);
+        }
+        else if (curType == srRelocRelative)
+        {
+            if (externalAddress) {
+#if defined(_AMD64_)
+                newStarPos = GET_UNALIGNED_INT32(pos);
+#else  // x86
+                UINT64 targetAddr = GET_UNALIGNED_VAL32(pos);
+                IfFailRet(SubOvf_U_U(newStarPos, targetAddr, imageBase));
+#endif
+            }
+            else {
+                newStarPos = GET_UNALIGNED_INT32(pos);
+                IfFailRet(AddOvf_S_U32(newStarPos, cur->section->m_baseRVA));
+            }
+            IfFailRet(SubOvf_S_U32(newStarPos, curRVA));
+            IfFailRet(SignedFitsIn31Bits(newStarPos));  // Check for overflow
+            SET_UNALIGNED_VAL32(pos, newStarPos);
+        }
+        else if (curType == srRelocCodeRelative)
+        {
+            newStarPos = GET_UNALIGNED_INT32(pos);
+            IfFailRet(SubOvf_S_U32(newStarPos, codeRvaBase));
+            if (externalAddress)
+                IfFailRet(SubOvf_S_U(newStarPos, imageBase));
+            else
+                IfFailRet(AddOvf_S_U32(newStarPos, cur->section->m_baseRVA));
+            IfFailRet(SignedFitsIn31Bits(newStarPos));  // Check for overflow
+            SET_UNALIGNED_VAL32(pos, newStarPos);
+            
+        }
+        else if (curType == srRelocIA64PcRel25)
+        {
+            _ASSERTE((m_baseRVA & 15) == 0);
+            _ASSERTE((cur->section->m_baseRVA & 15) == 0);
+
+            newStarPos = GetIA64Rel25((UINT64 *) pos, slotNum);
+            IfFailRet(SubOvf_S_U32(newStarPos, curRVA));
+            if (externalAddress)
+                IfFailRet(SubOvf_S_U(newStarPos, imageBase));
+            else
+                IfFailRet(AddOvf_S_U32(newStarPos, cur->section->m_baseRVA));
+
+            INT64 hiBits = newStarPos >> 24;
+            
+            _ASSERTE((hiBits==0) || (hiBits==-1));
+            
+            IfFailRet(AddOvf_S_U32(newStarPos, GetIA64Rel25((UINT64 *) pos, slotNum)));
+
+            hiBits = newStarPos >> 24;
+            
+            _ASSERTE((hiBits==0) || (hiBits==-1));
+            
+            INT32 delta32 = (INT32) newStarPos;
+
+            PutIA64Rel25((UINT64 *) pos, slotNum, delta32);
+
+            _ASSERTE(GetIA64Rel25((UINT64 *) pos, slotNum) == delta32);
+
+#ifdef LOGGING
+            if (newStarPos < s_minPcRel25)
+                s_minPcRel25 = newStarPos;
+            if (newStarPos > s_maxPcRel25)
+                s_maxPcRel25 = newStarPos;
+#endif
+        }
+        else if (curType == srRelocIA64PcRel64)
+        {
+            _ASSERTE((m_baseRVA & 15) == 0);
+            _ASSERTE(slotNum == 1);
+
+            newStarPos = GetIA64Rel64((UINT64 *) pos);
+            IfFailRet(SubOvf_S_U32(newStarPos, m_baseRVA));
+            
+            if (externalAddress)
+                IfFailRet(SubOvf_S_U(newStarPos, imageBase));
+            else
+            {
+                _ASSERTE((cur->section->m_baseRVA & 15) == 0);
+                IfFailRet(AddOvf_S_U32(newStarPos, cur->section->m_baseRVA));
+            }
+
+            INT64 hiBits = newStarPos >> 24;
+
+            fNeedBrl = (hiBits != 0) && (hiBits != -1);
+
+            /* Can we convert the brl.call into a br.call? */
+            if (!fNeedBrl)
+            {
+                INT32 delta32 = (INT32) newStarPos;
+
+                UINT64  temp0 = ((UINT64 *) pos)[0];
+                UINT64  temp1 = ((UINT64 *) pos)[1];
+#ifdef _DEBUG
+                //
+                // make certain we're decoding a brl opcode, with template 4 or 5
+                //
+                UINT64  templa = (temp0 >>  0) & 0x1f;
+                UINT64  opcode = (temp1 >> 60) & 0xf;
+
+                _ASSERTE(((opcode == 0xC) || (opcode == 0xD)) &&
+                         ((templa == 0x4) || (templa == 0x5)));
+#endif
+                const UINT64 mask0 = UI64(0x00003FFFFFFFFFE1);
+                const UINT64 mask1 = UI64(0x7700000FFF800000);
+
+                /* Clear all bits used as part of the slot1 and slot2 */
+                temp0 &= mask0;   // opcode becomes 4 or 5
+                temp1 &= mask1;
+
+                temp0 |= 0x10;    // template becomes 0x10 or 0x11
+                temp1 |= 0x200;   // slot 1 becomes nop.i
+
+                ((UINT64 *) pos)[0] = temp0;
+                ((UINT64 *) pos)[1] = temp1;
+
+                PutIA64Rel25((UINT64 *) pos, 2, delta32);
+                _ASSERTE(GetIA64Rel25((UINT64 *) pos, 2) == delta32);
+            }
+            else
+            {
+                PutIA64Rel64((UINT64 *) pos, newStarPos);
+                _ASSERTE(GetIA64Rel64((UINT64 *) pos) == newStarPos);
+            }
+        }
+        else if (curType == srRelocHighLow)
+        {
+            _ASSERTE(isPE32);
+
+            // we have a 32-bit value at pos
+            UINT64 value = GET_UNALIGNED_VAL32(pos);
+
+            if (!externalAddress)
+            {
+                IfFailRet(AddOvf_U_U32(value, cur->section->m_baseRVA));
+                IfFailRet(AddOvf_U_U(value, imageBase));
+            }
+
+            IfFailRet(UnsignedFitsIn32Bits(value));  // Check for overflow
+            SET_UNALIGNED_VAL32(pos, value);
+
+            newStarPos = value;
+
+            fBaseReloc = true;
+        }
+        else if (curType == srRelocDir64)
+        {
+            _ASSERTE(!isPE32);
+
+            // we have a 64-bit value at pos
+            UINT64 UNALIGNED * p_value = (UINT64 *) pos;
+            targetOffset = *p_value;
+
+            if (!externalAddress)
+            {
+                // The upper bits of targetOffset must be zero
+                IfFailRet(UnsignedFitsIn32Bits(targetOffset));            
+
+                IfFailRet(AddOvf_U_U32(targetOffset, cur->section->m_baseRVA));
+                IfFailRet(AddOvf_U_U(targetOffset, imageBase));
+            }
+
+            *p_value   = targetOffset;
+            newStarPos = targetOffset;
+            fBaseReloc = true;
+        }
+        else if (curType == srRelocIA64Imm64)
+        {
+            _ASSERTE(!isPE32);
+            _ASSERTE((curRVA & 15) == 0);       // This reloc should be 16-byte aligned
+
+            // we have a 64-bit value encoded in the instruction at pos
+            targetOffset = GetIA64Imm64((UINT64 *)pos);
+
+            if (!externalAddress)
+            {
+                // The upper bits of targetOffset must be zero
+                IfFailRet(UnsignedFitsIn32Bits(targetOffset));            
+            
+                IfFailRet(AddOvf_U_U32(targetOffset, cur->section->m_baseRVA));
+                IfFailRet(AddOvf_U_U(targetOffset, imageBase));
+            }
+
+            PutIA64Imm64((UINT64 *)pos, targetOffset);
+            newStarPos = targetOffset;
+            fBaseReloc = true;
+        }
+        else
+        {
+            _ASSERTE(!"Unknown Relocation type");
+        }
+
+        if (fBaseReloc && !noBaseBaseReloc)
+        {
+            pBaseRelocSection->AddBaseReloc(curRVA, curType);
+        }
+
+#ifdef LOGGING
+        const char* sectionName;
+
+        if (externalAddress)
+        {
+            sectionName = "external";
+        }
+        else
+        {
+            sectionName = cur->section->m_name;
+        }
+
+        LOG((LF_ZAP, LL_INFO1000000,
+             "to %-7s+%04x, old =" FMT_ADDR "new =" FMT_ADDR "%s%s\n",
+             sectionName, targetOffset,
+             DBG_ADDR(oldStarPos), DBG_ADDR(newStarPos),
+             fBaseReloc ? "(BASE RELOC)" : "",
+             fNeedBrl   ? "(BRL)"        : ""  ));
+#endif
+
+    }
+    return S_OK;
+}
+
+/******************************************************************/
+
+PESeedSection::PESeedSection(PEDecoder * peDecoder,
+                             IMAGE_SECTION_HEADER * seedSection)
+  : PEWriterSection((const char *)seedSection->Name,
+              VAL32(seedSection->Characteristics),
+              VAL32(seedSection->SizeOfRawData),
+              0),
+    m_pSeedFileDecoder(peDecoder),
+    m_pSeedSectionHeader(seedSection)
+{
+    m_baseRVA = VAL32(seedSection->VirtualAddress);
+}
+
+HRESULT  PESeedSection::write(HANDLE file) {
+    ULONG sizeOfSection = VAL32(m_pSeedSectionHeader->SizeOfRawData);
+    LPCVOID sectionData = PBYTE(m_pSeedFileDecoder->GetBase()) + m_pSeedSectionHeader->PointerToRawData;
+
+    DWORD dwWritten = 0;
+    if (!WriteFile(file, sectionData, sizeOfSection, &dwWritten, NULL)) {
+        return HRESULT_FROM_GetLastError();
+    }
+    _ASSERTE(dwWritten == sizeOfSection);
+    return S_OK;
+}
+
+unsigned PESeedSection::writeMem(void ** pMem) {
+    ULONG sizeOfSection = VAL32(m_pSeedSectionHeader->SizeOfRawData);
+    LPCVOID sectionData = PBYTE(m_pSeedFileDecoder->GetBase()) + m_pSeedSectionHeader->PointerToRawData;
+
+    COPY_AND_ADVANCE(*pMem, sectionData, sizeOfSection);
+    return sizeOfSection;
+}
+
+/******************************************************************/
+HRESULT PEWriter::Init(PESectionMan *pFrom, DWORD createFlags, LPCWSTR seedFileName)
+{
+    if (pFrom)
+        *(PESectionMan*)this = *pFrom;
+    else {
+        HRESULT hr = PESectionMan::Init();
+        if (FAILED(hr))
+            return hr;
+    }
+    time_t now;
+    time(&now);
+
+#ifdef LOGGING
+    InitializeLogging();
+#endif
+
+    // Save the timestamp so that we can give it out if someone needs
+    // it.
+    m_peFileTimeStamp = (DWORD) now;
+
+    // We must be creating either a PE32 or a PE64 file
+    if (createFlags & ICEE_CREATE_FILE_PE64)
+    {
+        m_ntHeaders     = (IMAGE_NT_HEADERS *) new (nothrow) IMAGE_NT_HEADERS64;
+        m_ntHeadersSize = sizeof(IMAGE_NT_HEADERS64);
+
+        if (!m_ntHeaders) return E_OUTOFMEMORY;
+        memset(m_ntHeaders, 0, m_ntHeadersSize);
+
+        m_ntHeaders->OptionalHeader.Magic = VAL16(IMAGE_NT_OPTIONAL_HDR64_MAGIC);
+        m_ntHeaders->FileHeader.SizeOfOptionalHeader = VAL16(sizeof(IMAGE_OPTIONAL_HEADER64));
+    }
+    else
+    {
+        _ASSERTE(createFlags & ICEE_CREATE_FILE_PE32);
+        m_ntHeaders     = (IMAGE_NT_HEADERS *) new (nothrow) IMAGE_NT_HEADERS32;
+        m_ntHeadersSize = sizeof(IMAGE_NT_HEADERS32);
+
+        if (!m_ntHeaders) return E_OUTOFMEMORY;
+        memset(m_ntHeaders, 0, m_ntHeadersSize);
+
+        m_ntHeaders->OptionalHeader.Magic = VAL16(IMAGE_NT_OPTIONAL_HDR32_MAGIC);
+        m_ntHeaders->FileHeader.SizeOfOptionalHeader = VAL16(sizeof(IMAGE_OPTIONAL_HEADER32));
+    }
+
+    // Record whether we should create the CorExeMain and CorDllMain stubs
+    m_createCorMainStub = ((createFlags & ICEE_CREATE_FILE_CORMAIN_STUB) != 0);
+
+    // We must have a valid target machine selected
+    if ((createFlags & ICEE_CREATE_MACHINE_MASK) == ICEE_CREATE_MACHINE_I386)
+    {
+        m_ntHeaders->FileHeader.Machine = VAL16(IMAGE_FILE_MACHINE_I386);
+    }
+    else if ((createFlags & ICEE_CREATE_MACHINE_MASK) == ICEE_CREATE_MACHINE_IA64)
+    {
+        m_ntHeaders->FileHeader.Machine = VAL16(IMAGE_FILE_MACHINE_IA64);
+    }
+    else if ((createFlags & ICEE_CREATE_MACHINE_MASK) == ICEE_CREATE_MACHINE_AMD64)
+    {
+        m_ntHeaders->FileHeader.Machine = VAL16(IMAGE_FILE_MACHINE_AMD64);
+    }
+    else if ((createFlags & ICEE_CREATE_MACHINE_MASK) == ICEE_CREATE_MACHINE_ARM)
+    {
+        m_ntHeaders->FileHeader.Machine = VAL16(IMAGE_FILE_MACHINE_ARMNT);
+
+        // The OS loader already knows how to initialize pure managed assemblies and we have no legacy OS
+        // support to worry about on ARM so don't ever create the stub for ARM binaries.
+        m_createCorMainStub = false;
+    }
+    else
+    {
+        _ASSERTE(!"Invalid target machine");
+    }
+
+    cEntries = IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR + 1;
+    pEntries = new (nothrow) directoryEntry[cEntries];
+    if (pEntries == NULL) return E_OUTOFMEMORY;
+    memset(pEntries, 0, sizeof(*pEntries) * cEntries);
+
+    m_ntHeaders->Signature                       = VAL32(IMAGE_NT_SIGNATURE);
+    m_ntHeaders->FileHeader.TimeDateStamp        = VAL32((ULONG) now);
+    m_ntHeaders->FileHeader.Characteristics      = VAL16(0);
+
+    if (createFlags & ICEE_CREATE_FILE_STRIP_RELOCS)
+    {
+        m_ntHeaders->FileHeader.Characteristics |= VAL16(IMAGE_FILE_RELOCS_STRIPPED);
+    }
+    
+    // Linker version should be consistent with current VC level
+    m_ntHeaders->OptionalHeader.MajorLinkerVersion  = 11;
+    m_ntHeaders->OptionalHeader.MinorLinkerVersion  = 0;
+
+    m_ntHeaders->OptionalHeader.SectionAlignment    = VAL32(IMAGE_NT_OPTIONAL_HDR_SECTION_ALIGNMENT);
+    m_ntHeaders->OptionalHeader.FileAlignment       = VAL32(0);
+    m_ntHeaders->OptionalHeader.AddressOfEntryPoint = VAL32(0);
+
+    m_ntHeaders->OptionalHeader.MajorOperatingSystemVersion = VAL16(4);
+    m_ntHeaders->OptionalHeader.MinorOperatingSystemVersion = VAL16(0);
+
+    m_ntHeaders->OptionalHeader.MajorImageVersion     = VAL16(0);
+    m_ntHeaders->OptionalHeader.MinorImageVersion     = VAL16(0);
+    m_ntHeaders->OptionalHeader.MajorSubsystemVersion = VAL16(4);
+    m_ntHeaders->OptionalHeader.MinorSubsystemVersion = VAL16(0);
+    m_ntHeaders->OptionalHeader.Win32VersionValue     = VAL32(0);
+    m_ntHeaders->OptionalHeader.Subsystem             = VAL16(0);
+    m_ntHeaders->OptionalHeader.DllCharacteristics    = VAL16(0);
+    m_ntHeaders->OptionalHeader.CheckSum              = VAL32(0);
+    setDllCharacteristics(IMAGE_DLLCHARACTERISTICS_NO_SEH |
+                          IMAGE_DLLCHARACTERISTICS_NX_COMPAT |
+                          IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE |
+                          IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE);
+
+    if (isPE32())
+    {
+        IMAGE_NT_HEADERS32*  p_ntHeaders32 = ntHeaders32();
+        p_ntHeaders32->OptionalHeader.ImageBase             = VAL32(CEE_IMAGE_BASE_32);
+        p_ntHeaders32->OptionalHeader.SizeOfStackReserve    = VAL32(0x100000);
+        p_ntHeaders32->OptionalHeader.SizeOfStackCommit     = VAL32(0x1000);
+        p_ntHeaders32->OptionalHeader.SizeOfHeapReserve     = VAL32(0x100000);
+        p_ntHeaders32->OptionalHeader.SizeOfHeapCommit      = VAL32(0x1000);
+        p_ntHeaders32->OptionalHeader.LoaderFlags           = VAL32(0);
+        p_ntHeaders32->OptionalHeader.NumberOfRvaAndSizes   = VAL32(16);
+    }
+    else
+    {
+        IMAGE_NT_HEADERS64*  p_ntHeaders64 = ntHeaders64();
+        // FIX what are the correct values for PE+ (64-bit) ?
+        p_ntHeaders64->OptionalHeader.ImageBase             = VAL64(CEE_IMAGE_BASE_64);
+        p_ntHeaders64->OptionalHeader.SizeOfStackReserve    = VAL64(0x400000);
+        p_ntHeaders64->OptionalHeader.SizeOfStackCommit     = VAL64(0x4000);
+        p_ntHeaders64->OptionalHeader.SizeOfHeapReserve     = VAL64(0x100000);
+        p_ntHeaders64->OptionalHeader.SizeOfHeapCommit      = VAL64(0x2000);
+        p_ntHeaders64->OptionalHeader.LoaderFlags           = VAL32(0);
+        p_ntHeaders64->OptionalHeader.NumberOfRvaAndSizes   = VAL32(16);
+    }
+
+    m_ilRVA = (DWORD) -1;
+    m_dataRvaBase = 0;
+    m_rdataRvaBase = 0;
+    m_codeRvaBase = 0;
+    m_encMode = FALSE;
+
+    virtualPos = 0;
+    filePos = 0;
+    reloc = NULL;
+    strtab = NULL;
+    headers = NULL;
+    headersEnd = NULL;
+
+    m_file = INVALID_HANDLE_VALUE;
+
+    //
+    // Seed file
+    //
+
+    m_hSeedFile = INVALID_HANDLE_VALUE;
+    m_hSeedFileMap = INVALID_HANDLE_VALUE;
+    m_pSeedFileDecoder = NULL;
+    m_iSeedSections = 0;
+    m_pSeedSectionToAdd = NULL;
+
+    if (seedFileName)
+    {
+        HandleHolder hFile (WszCreateFile(seedFileName,
+                                     GENERIC_READ,
+                                     FILE_SHARE_READ,
+                                     NULL,
+                                     OPEN_EXISTING,
+                                     FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
+                                     NULL));
+
+        if (hFile == INVALID_HANDLE_VALUE)
+            return HRESULT_FROM_GetLastError();
+
+        MapViewHolder hMapFile (WszCreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL));
+        DWORD dwFileLen = SafeGetFileSize(hFile, 0);
+        if (dwFileLen == 0xffffffff)
+            return HRESULT_FROM_GetLastError();
+
+        if (hMapFile == NULL)
+            return HRESULT_FROM_GetLastError();
+
+        BYTE * baseFileView = (BYTE*) MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
+
+        PEDecoder * pPEDecoder = new (nothrow) PEDecoder(baseFileView, (COUNT_T)dwFileLen);
+        if (pPEDecoder == NULL) return E_OUTOFMEMORY;
+        
+        if (pPEDecoder->Has32BitNTHeaders())
+        {
+            if ((createFlags & ICEE_CREATE_FILE_PE32) == 0)
+                return E_FAIL;
+
+            setImageBase32(DWORD(size_t(pPEDecoder->GetPreferredBase())));
+        }
+        else
+        {
+            if ((createFlags & ICEE_CREATE_FILE_PE64) == 0)
+                return E_FAIL;
+
+            setImageBase64(UINT64((intptr_t) pPEDecoder->GetPreferredBase()));
+        }
+
+        setFileAlignment   (VAL32(pPEDecoder->GetFileAlignment()));
+        setSectionAlignment(VAL32(pPEDecoder->GetSectionAlignment()));
+
+        hFile.SuppressRelease();
+        hMapFile.SuppressRelease();
+        
+        m_hSeedFile = hFile;
+        m_hSeedFileMap = hMapFile;
+        m_pSeedFileDecoder = pPEDecoder;
+
+#ifdef  _WIN64       
+        m_pSeedFileNTHeaders = pPEDecoder->GetNTHeaders64();
+#else
+        m_pSeedFileNTHeaders = pPEDecoder->GetNTHeaders32();
+#endif
+
+        // Add the seed sections
+
+        m_pSeedSections = m_pSeedFileDecoder->FindFirstSection();
+
+        m_pSeedSectionToAdd = m_pSeedSections;
+        m_iSeedSections = m_pSeedFileDecoder->GetNumberOfSections();
+
+        for (unsigned i = 0; i < m_iSeedSections; m_pSeedSectionToAdd++, i++) {
+            PESection * dummy;
+            getSectionCreate((const char *)(m_pSeedSectionToAdd->Name),
+                VAL32(m_pSeedSectionToAdd->Characteristics),
+                &dummy);
+        }
+
+        m_pSeedSectionToAdd = NULL;
+    }
+
+    return S_OK;
+}
+
+/******************************************************************/
+HRESULT PEWriter::Cleanup() {
+
+    if (m_hSeedFile != INVALID_HANDLE_VALUE)
+    {
+        CloseHandle(m_hSeedFile);
+        CloseHandle(m_hSeedFileMap);
+        delete m_pSeedFileDecoder;
+    }
+
+    if (isPE32())
+    {
+        delete ntHeaders32();
+    }
+    else
+    {
+        delete ntHeaders64();
+    }
+
+    if (headers != NULL)
+        delete [] headers;
+
+    if (pEntries != NULL)
+        delete [] pEntries;
+
+    return PESectionMan::Cleanup();
+}
+
+PESection* PEWriter::getSection(const char* name)
+{
+    int     len = (int)strlen(name);
+
+    // the section name can be at most 8 characters including the null.
+    if (len < 8)
+        len++;
+    else
+        len = 8;
+
+    // dbPrintf(("looking for section %s\n", name));
+    // Skip over the seed sections
+
+    for(PESection** cur = sectStart+m_iSeedSections; cur < sectCur; cur++) {
+        // dbPrintf(("searching section %s\n", (*cur)->m_ame));
+        if (strncmp((*cur)->m_name, name, len) == 0) {
+            // dbPrintf(("found section %s\n", (*cur)->m_name));
+            return(*cur);
+        }
+    }
+    return(0);
+}
+
+HRESULT PEWriter::newSection(const char* name, PESection **section,
+                            unsigned flags, unsigned estSize,
+                            unsigned estRelocs)
+{
+    if (m_pSeedSectionToAdd) {
+        _ASSERTE(strcmp((const char *)(m_pSeedSectionToAdd->Name), name) == 0 &&
+            VAL32(m_pSeedSectionToAdd->Characteristics) == flags);
+
+        PESeedSection * ret = new (nothrow) PESeedSection(m_pSeedFileDecoder, m_pSeedSectionToAdd);
+        *section = ret;
+        TESTANDRETURNMEMORY(ret);
+        return S_OK;
+    }
+
+    PEWriterSection * ret = new (nothrow) PEWriterSection(name, flags, estSize, estRelocs);
+    *section = ret;
+    TESTANDRETURNMEMORY(ret);
+    return S_OK;
+}
+
+ULONG PEWriter::getIlRva()
+{
+    // assume that pe optional header is less than size of section alignment. So this
+    // gives out the rva for the .text section, which is merged after the .text0 section
+    // This is verified in debug build when actually write out the file
+    _ASSERTE(m_ilRVA > 0);
+    return m_ilRVA;
+}
+
+void PEWriter::setIlRva(ULONG offset)
+{
+    // assume that pe optional header is less than size of section alignment. So this
+    // gives out the rva for the .text section, which is merged after the .text0 section
+    // This is verified in debug build when actually write out the file
+    m_ilRVA = roundUp(VAL32(m_ntHeaders->OptionalHeader.SectionAlignment) + offset, SUBSECTION_ALIGN);
+}
+
+HRESULT PEWriter::setDirectoryEntry(PEWriterSection *section, ULONG entry, ULONG size, ULONG offset)
+{
+    if (entry >= cEntries)
+    {
+        USHORT cNewEntries = (USHORT)max((ULONG)cEntries * 2, entry + 1);
+
+        if (cNewEntries <= cEntries) return E_OUTOFMEMORY;  // Integer overflow
+        if (cNewEntries <= entry) return E_OUTOFMEMORY;  // Integer overflow
+
+        directoryEntry *pNewEntries = new (nothrow) directoryEntry [ cNewEntries ];
+        if (pNewEntries == NULL) return E_OUTOFMEMORY;
+
+        CopyMemory(pNewEntries, pEntries, cEntries * sizeof(*pNewEntries));
+        ZeroMemory(pNewEntries + cEntries, (cNewEntries - cEntries) * sizeof(*pNewEntries));
+
+        delete [] pEntries;
+        pEntries = pNewEntries;
+        cEntries = cNewEntries;
+    }
+
+    pEntries[entry].section = section;
+    pEntries[entry].offset = offset;
+    pEntries[entry].size = size;
+    return S_OK;
+}
+
+void PEWriter::setEnCRvaBase(ULONG dataBase, ULONG rdataBase)
+{
+    m_dataRvaBase = dataBase;
+    m_rdataRvaBase = rdataBase;
+    m_encMode = TRUE;
+}
+
+//-----------------------------------------------------------------------------
+// These 2 write functions must be implemented here so that they're in the same
+// .obj file as whoever creates the FILE struct. We can't pass a FILE struct
+// across a dll boundary and use it.
+//-----------------------------------------------------------------------------
+
+HRESULT PEWriterSection::write(HANDLE file)
+{
+    return m_blobFetcher.Write(file);
+}
+
+//-----------------------------------------------------------------------------
+// Write out the section to the stream
+//-----------------------------------------------------------------------------
+HRESULT CBlobFetcher::Write(HANDLE file)
+{
+// Must write out each pillar (including idx = m_nIndexUsed), one after the other
+    unsigned idx;
+    for(idx = 0; idx <= m_nIndexUsed; idx ++) {
+        if (m_pIndex[idx].GetDataLen() > 0)
+        {
+            ULONG length = m_pIndex[idx].GetDataLen();
+            DWORD dwWritten = 0;
+            if (!WriteFile(file, m_pIndex[idx].GetRawDataStart(), length, &dwWritten, NULL))
+            {
+                return HRESULT_FROM_GetLastError();
+            }
+            _ASSERTE(dwWritten == length);
+        }
+    }
+
+    return S_OK;
+}
+
+
+//-----------------------------------------------------------------------------
+// These 2 write functions must be implemented here so that they're in the same
+// .obj file as whoever creates the FILE struct. We can't pass a FILE struct
+// across a dll boundary  and use it.
+//-----------------------------------------------------------------------------
+
+unsigned PEWriterSection::writeMem(void **ppMem)
+{
+    HRESULT hr;
+    hr = m_blobFetcher.WriteMem(ppMem);
+    _ASSERTE(SUCCEEDED(hr));
+
+    return m_blobFetcher.GetDataLen();
+}
+
+//-----------------------------------------------------------------------------
+// Write out the section to memory
+//-----------------------------------------------------------------------------
+HRESULT CBlobFetcher::WriteMem(void **ppMem)
+{
+    char **ppDest = (char **)ppMem;
+    // Must write out each pillar (including idx = m_nIndexUsed), one after the other
+    unsigned idx;
+    for(idx = 0; idx <= m_nIndexUsed; idx ++) {
+        if (m_pIndex[idx].GetDataLen() > 0)
+        {
+            // WARNING: macro - must enclose in curly braces
+            COPY_AND_ADVANCE(*ppDest, m_pIndex[idx].GetRawDataStart(), m_pIndex[idx].GetDataLen());
+        }
+    }
+
+    return S_OK;
+}
+
+/******************************************************************/
+
+//
+// Intermediate table to sort to help determine section order
+//
+struct entry {
+    const char *    name;       // full name of the section
+    unsigned char   nameLength; // length of the text part of the name
+    signed char     index;      // numeral value at the end of the name; -1 if none
+    unsigned short  arrayIndex; // index of section within sectStart[]
+};
+
+class SectionNameSorter : protected CQuickSort<entry>
+{
+    entry *             m_entries;
+    PEWriterSection **  m_sections;
+    unsigned            m_count;
+    unsigned            m_seedCount;
+
+  public:
+    SectionNameSorter(entry *entries, PEWriterSection ** sections, int count, unsigned seedSections)
+      : CQuickSort<entry>(entries, count),
+        m_entries(entries),
+        m_sections(sections),
+        m_count(unsigned(count)),
+        m_seedCount(seedSections)
+    {}
+
+    // Sorts the entries according to alphabetical + numerical order
+
+    int Compare(entry *first, entry *second)
+    {
+        PEWriterSection * firstSection = m_sections[first->arrayIndex];
+        PEWriterSection * secondSection = m_sections[second->arrayIndex];
+
+        // Seed sections are always at the start, in the order they were
+        // added to the PEWriter
+
+        if (firstSection->isSeedSection() || secondSection->isSeedSection()) {
+            if (firstSection->isSeedSection() && secondSection->isSeedSection())
+                return first->arrayIndex - second->arrayIndex;
+
+            return firstSection->isSeedSection() ? -1 : 1;
+        }
+
+        // Sort the names
+
+        int lenDiff = first->nameLength - second->nameLength;
+        int smallerLen;
+        if (lenDiff < 0)
+            smallerLen = first->nameLength;
+        else
+            smallerLen = second->nameLength;
+
+        int result = strncmp(first->name, second->name, smallerLen);
+
+        if (result != 0)
+            return result;
+        else
+        {
+            if (lenDiff != 0)
+                return lenDiff;
+            else
+                return (int)(first->index - second->index);
+        }
+    }
+
+    int SortSections()
+    {
+        Sort();
+
+        entry * ePrev = m_entries;
+        entry * e = ePrev + 1;
+        int iSections = 1; // First section is obviously unique
+
+        for (unsigned i = 1; i < m_count; i++, ePrev = e, e++) {
+
+            // Seed sections should stay at the front
+            _ASSERTE(i >= m_seedCount || i == e->arrayIndex);
+
+            if (!m_sections[ePrev->arrayIndex]->isSeedSection() &&
+                (ePrev->nameLength == e->nameLength) &&
+                strncmp(ePrev->name, e->name, e->nameLength) == 0)
+            {
+                continue;
+            }
+
+            iSections++;
+        }
+
+        return iSections;
+    }
+};
+
+#define SectionIndex    IMAGE_SECTION_HEADER::VirtualAddress
+#define FirstEntryIndex IMAGE_SECTION_HEADER::SizeOfRawData
+
+HRESULT PEWriter::linkSortSections(entry * entries,
+                                   unsigned * piEntries,
+                                   unsigned * piUniqueSections)
+{
+    //
+    // Preserve current section order as much as possible, but apply the following
+    // rules:
+    //  - sections named "xxx#" are collated into a single PE section "xxx".
+    //      The contents of the CeeGen sections are sorted according to numerical
+    //      order & made contiguous in the PE section
+    //  - "text" always comes first in the file
+    //  - empty sections receive no PE section
+    //
+
+    bool ExeOrDll = isExeOrDll(m_ntHeaders);
+
+    entry *e = entries;
+    for (PEWriterSection **cur = getSectStart(); cur < getSectCur(); cur++) {
+
+        //
+        // Throw away any old headers we've used.
+        //
+
+        (*cur)->m_header = NULL;
+
+        //
+        // Don't allocate PE data for 0 length sections
+        //
+
+        if ((*cur)->dataLen() == 0)
+            continue;
+
+        //
+        // Special case: omit "text0" from obj's
+        //
+
+        if (!ExeOrDll && strcmp((*cur)->m_name, ".text0") == 0)
+            continue;
+
+        e->name = (*cur)->m_name;
+
+        //
+        // Now find the end of the text part of the section name, and
+        // calculate the numeral (if any) at the end
+        //
+
+        _ASSERTE(strlen(e->name) < UCHAR_MAX);
+        const char *p = e->name + strlen(e->name);
+        int index = 0; // numeral at the end of the section name
+        int placeValue = 1;
+        if (isdigit(p[-1]))
+        {
+            while (--p > e->name)
+            {
+                if (!isdigit(*p))
+                    break;
+                index += ((*p - '0') * placeValue);
+                placeValue *= 10;
+            }
+            p++;
+
+            //
+            // Special case: put "xxx" after "xxx0" and before "xxx1"
+            //
+
+            if (index == 0)
+                index = -1;
+        }
+
+        _ASSERTE(index == -1 || index == atoi(p));
+
+        e->nameLength = (unsigned char)(p - e->name);
+        e->index = index;
+        e->arrayIndex = (unsigned short)(cur - getSectStart());
+        e++;
+    }
+
+    //
+    // Sort the entries according to alphabetical + numerical order
+    //
+
+    SectionNameSorter sorter(entries, getSectStart(), int(e - entries), m_iSeedSections);
+    *piUniqueSections = sorter.SortSections();
+
+    *piEntries = unsigned(e - entries);
+
+    return S_OK;
+}
+
+class HeaderSorter : public CQuickSort<IMAGE_SECTION_HEADER>
+{
+  public:
+    HeaderSorter(IMAGE_SECTION_HEADER *headers, int count)
+      : CQuickSort<IMAGE_SECTION_HEADER>(headers, count) {}
+
+    int Compare(IMAGE_SECTION_HEADER *first, IMAGE_SECTION_HEADER *second)
+    {
+        // IMAGE_SECTION_HEADER::VirtualAddress/SectionIndex contains the
+        // index of the section
+        return VAL32(first->SectionIndex) - VAL32(second->SectionIndex);
+    }
+};
+
+HRESULT PEWriter::linkSortHeaders(entry * entries, unsigned iEntries, unsigned iUniqueSections)
+{
+    if (headers != NULL)
+        delete [] headers;
+    
+    // 1 extra for .reloc
+    S_UINT32 cUniqueSectionsAllocated = S_UINT32(iUniqueSections) + S_UINT32(1);
+    if (cUniqueSectionsAllocated.IsOverflow())
+    {
+        return COR_E_OVERFLOW;
+    }
+    headers = new (nothrow) IMAGE_SECTION_HEADER[cUniqueSectionsAllocated.Value()];
+    TESTANDRETURNMEMORY(headers);
+    
+    memset(headers, 0, sizeof(*headers) * cUniqueSectionsAllocated.Value());
+    
+    entry *ePrev = NULL;
+    IMAGE_SECTION_HEADER *h = headers - 1;
+    
+    //
+    // Store the sorting index
+    //
+
+    entry * entriesEnd = entries + iEntries;
+
+    for (entry * e = entries ; e < entriesEnd; e++)
+    {
+        if (ePrev != NULL
+            && !getSectStart()[ePrev->arrayIndex]->isSeedSection()
+            && e->nameLength == ePrev->nameLength
+            && strncmp(e->name, ePrev->name, e->nameLength) == 0)
+        {
+            //
+            // This section has the same name as the previous section, and
+            // will be collapsed with the previous section.
+            // Just update the (common) header information
+            //
+
+            if (e->arrayIndex < ePrev->arrayIndex)
+            {
+                //
+                // Use the smaller of the indices of e and ePrev
+                //
+                h->SectionIndex = VAL32(VAL32(h->SectionIndex) - (e->arrayIndex - ePrev->arrayIndex));
+            }
+
+            // Store an approximation of the size of the section temporarily
+            h->Misc.VirtualSize =  VAL32(VAL32(h->Misc.VirtualSize) + getSectStart()[e->arrayIndex]->dataLen());
+        }
+        else
+        {
+            // Grab a new header
+
+            h++;
+
+            strncpy_s((char *) h->Name, sizeof(h->Name), e->name, e->nameLength);
+
+            setSectionIndex(h, e->arrayIndex);
+
+            // Store the entry index in this field temporarily
+            h->FirstEntryIndex = VAL32((DWORD)(e - entries));
+
+            // Store an approximation of the size of the section temporarily
+            h->Misc.VirtualSize = VAL32(getSectStart()[e->arrayIndex]->dataLen());
+        }
+        ePrev = e;
+    }
+
+    headersEnd = ++h;
+
+    _ASSERTE(headers + iUniqueSections == headersEnd);
+
+    //
+    // Sort the entries according to alphabetical + numerical order
+    //
+
+    HeaderSorter headerSorter(headers, int(iUniqueSections));
+
+    headerSorter.Sort();
+
+    return S_OK;
+} // PEWriter::linkSortHeaders
+
+HRESULT PEWriter::linkPlaceSections(entry * entries, unsigned iEntries)
+{
+    entry * entriesEnd = entries + iEntries;
+
+    for (IMAGE_SECTION_HEADER * h = headers; h < headersEnd; h++)
+    {
+        // Get to the first entry corresponding to this section header
+
+        entry * e = entries + VAL32(h->FirstEntryIndex);
+        PEWriterSection *s = getSectStart()[e->arrayIndex];
+
+        if (s->isSeedSection()) {
+            virtualPos = s->getBaseRVA();
+        }
+
+        h->VirtualAddress = VAL32(virtualPos);
+        h->PointerToRawData = VAL32(filePos);
+
+        s->m_baseRVA = virtualPos;
+        s->m_filePos = filePos;
+        s->m_header = h;
+        h->Characteristics = VAL32(s->m_flags);
+
+#ifdef LOGGING
+        LOG((LF_ZAP, LL_INFO10,
+             "   Section %-7s RVA=%08x, Length=%08x, FilePos=%08x\n",
+             s->m_name, s->m_baseRVA, s->dataLen(), s->m_filePos));
+#endif
+
+        unsigned dataSize = s->dataLen();
+
+        // Find all the other entries corresponding to this section header
+
+        PEWriterSection *sPrev = s;
+        entry * ePrev = e;
+        while (++e < entriesEnd)
+        {
+           if (e->nameLength != ePrev->nameLength
+               || strncmp(e->name, ePrev->name, e->nameLength) != 0)
+               break;
+
+           s = getSectStart()[e->arrayIndex];
+           _ASSERTE(s->m_flags == VAL32(h->Characteristics));
+
+           sPrev->m_filePad = padLen(dataSize, SUBSECTION_ALIGN);
+           dataSize = roundUp(dataSize, SUBSECTION_ALIGN);
+
+           s->m_baseRVA = virtualPos + dataSize;
+           s->m_filePos = filePos + dataSize;
+           s->m_header = h;
+           sPrev = s;
+
+           dataSize += s->dataLen();
+
+#ifdef LOGGING
+           LOG((LF_ZAP, LL_INFO10,
+                "   Section %-7s RVA=%08x, Length=%08x, FilePos=%08x\n",
+                s->m_name, s->m_baseRVA, s->dataLen(), s->m_filePos));
+#endif
+
+           ePrev = e;
+        }
+
+        h->Misc.VirtualSize = VAL32(dataSize);
+
+        sPrev->m_filePad = padLen(dataSize, VAL32(m_ntHeaders->OptionalHeader.FileAlignment));
+        dataSize = roundUp(dataSize, VAL32(m_ntHeaders->OptionalHeader.FileAlignment));
+        h->SizeOfRawData = VAL32(dataSize);
+        filePos += dataSize;
+
+        dataSize = roundUp(dataSize, VAL32(m_ntHeaders->OptionalHeader.SectionAlignment));
+        virtualPos += dataSize;
+    }
+
+    return S_OK;
+}
+
+void PEWriter::setSectionIndex(IMAGE_SECTION_HEADER * h, unsigned sectionIndex) {
+
+    if (getSectStart()[sectionIndex]->isSeedSection()) {
+        h->SectionIndex = VAL32(sectionIndex);
+        return;
+    }
+
+    //
+    // Reserve some dummy "array index" values for special sections
+    // at the start of the image (after the seed sections)
+    //
+
+    static const char * const SpecialNames[] = { ".text", ".cormeta", NULL };
+    enum { SPECIAL_NAMES_COUNT = NumItems(SpecialNames) };
+
+    for (const char * const * s = SpecialNames; /**/; s++)
+    {
+        if (*s == 0)
+        {
+            h->SectionIndex = VAL32(sectionIndex + SPECIAL_NAMES_COUNT);
+            break;
+        }
+        else if (strcmp((char *) h->Name, *s) == 0)
+        {
+            h->SectionIndex = VAL32(m_iSeedSections + DWORD(s - SpecialNames));
+            break;
+        }
+        s++;
+    }
+
+}
+
+
+HRESULT PEWriter::link() {
+
+    //
+    // NOTE:
+    // link() can be called more than once!  This is because at least one compiler
+    // (the prejitter) needs to know the base addresses of some segments before it
+    // builds others. It's up to the caller to insure the layout remains the same
+    // after changes are made, though.
+    //
+
+    //
+    // Assign base addresses to all sections, and layout & merge PE sections
+    //
+
+    bool ExeOrDll = isExeOrDll(m_ntHeaders);
+
+    //
+    // Collate by name & sort by index
+    //
+
+    // First collect all information into entries[]
+
+    int sectCount = getSectCount();
+    entry *entries = (entry *) _alloca(sizeof(entry) * sectCount);
+
+    unsigned iUniqueSections, iEntries;
+    HRESULT hr;
+    IfFailRet(linkSortSections(entries, &iEntries, &iUniqueSections));
+
+    //
+    // Now, allocate a header for each unique section name.
+    // Also record the minimum section index for each section
+    // so we can preserve order as much as possible.
+    //
+
+    IfFailRet(linkSortHeaders(entries, iEntries, iUniqueSections));
+
+    //
+    // If file alignment is not zero, it must have been set through
+    //  setFileAlignment(), in which case we leave it untouched
+    //
+
+    if( VAL32(0) == m_ntHeaders->OptionalHeader.FileAlignment )
+    {
+        //
+        // Figure out what file alignment to use.
+        //
+
+        unsigned RoundUpVal;
+
+        if (ExeOrDll)
+        {
+            RoundUpVal = 0x0200;
+        }
+        else
+        {
+            // Don't bother padding for objs
+            RoundUpVal = 4;
+        }
+
+        m_ntHeaders->OptionalHeader.FileAlignment = VAL32(RoundUpVal);
+    }
+
+    //
+    // Now, assign a section header & location to each section
+    //
+
+    if (ExeOrDll)
+    {
+        iUniqueSections++; // One more for .reloc
+        filePos = sizeof(IMAGE_DOS_HEADER)+sizeof(x86StubPgm) + m_ntHeadersSize;
+    }
+    else
+    {
+        filePos = sizeof(IMAGE_FILE_HEADER);
+    }
+
+    m_ntHeaders->FileHeader.NumberOfSections = VAL16(iUniqueSections);
+
+    filePos += iUniqueSections * sizeof(IMAGE_SECTION_HEADER);
+    filePos  = roundUp(filePos, VAL32(m_ntHeaders->OptionalHeader.FileAlignment));
+
+    m_ntHeaders->OptionalHeader.SizeOfHeaders = VAL32(filePos);
+
+    virtualPos = roundUp(filePos, VAL32(m_ntHeaders->OptionalHeader.SectionAlignment));
+
+    if (m_hSeedFile != INVALID_HANDLE_VALUE) {
+        // We do not support relocating/sliding down the seed sections
+        if (filePos > VAL32(m_pSeedSections->VirtualAddress) ||
+            virtualPos > VAL32(m_pSeedSections->VirtualAddress))
+           return E_FAIL;
+
+        if (virtualPos < VAL32(m_pSeedSections->VirtualAddress)) {
+            virtualPos = VAL32(m_pSeedSections->VirtualAddress);
+        }
+    }
+
+    // Now finally assign RVAs to the sections
+
+    IfFailRet(linkPlaceSections(entries, iEntries));
+
+    return S_OK;
+}
+
+#undef SectionIndex
+#undef FirstEntryIndex
+
+
+class SectionRVASorter : public CQuickSort<PEWriterSection*>
+{
+    public:
+        SectionRVASorter(PEWriterSection **elts, SSIZE_T count)
+          : CQuickSort<PEWriterSection*>(elts, count) {}
+
+        int Compare(PEWriterSection **e1, PEWriterSection **e2)
+        {
+            return (*e1)->getBaseRVA() - (*e2)->getBaseRVA();
+        }
+};
+
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
+#endif
+HRESULT PEWriter::fixup(CeeGenTokenMapper *pMapper)
+{
+    HRESULT hr;
+
+    bool ExeOrDll = isExeOrDll(m_ntHeaders);
+    const unsigned RoundUpVal = VAL32(m_ntHeaders->OptionalHeader.FileAlignment);
+
+    if(ExeOrDll)
+    {
+        //
+        // Apply manual relocation for entry point field
+        //
+
+        PESection *textSection;
+        IfFailRet(getSectionCreate(".text", 0, &textSection));
+
+        if (m_ntHeaders->OptionalHeader.AddressOfEntryPoint != VAL32(0))
+            m_ntHeaders->OptionalHeader.AddressOfEntryPoint = VAL32(VAL32(m_ntHeaders->OptionalHeader.AddressOfEntryPoint) + textSection->m_baseRVA);
+
+        //
+        // Apply normal relocs
+        //
+
+        IfFailRet(getSectionCreate(".reloc", sdReadOnly | IMAGE_SCN_MEM_DISCARDABLE,
+                                   (PESection **) &reloc));
+        reloc->m_baseRVA = virtualPos;
+        reloc->m_filePos = filePos;
+        reloc->m_header = headersEnd++;
+        strcpy_s((char *)reloc->m_header->Name, sizeof(reloc->m_header->Name),
+                 ".reloc");
+        reloc->m_header->Characteristics = VAL32(reloc->m_flags);
+        reloc->m_header->VirtualAddress = VAL32(virtualPos);
+        reloc->m_header->PointerToRawData = VAL32(filePos);
+
+#ifdef _DEBUG
+        if (m_encMode)
+            printf("Applying relocs for .rdata section with RVA %x\n", m_rdataRvaBase);
+#endif
+
+        //
+        // Sort the sections by RVA
+        //
+
+        CQuickArray<PEWriterSection *> sections;
+
+        SIZE_T count = getSectCur() - getSectStart();
+        IfFailRet(sections.ReSizeNoThrow(count));
+        UINT i = 0;
+        PEWriterSection **cur;
+        for(cur = getSectStart(); cur < getSectCur(); cur++, i++)
+            sections[i] = *cur;
+
+        SectionRVASorter sorter(sections.Ptr(), sections.Size());
+
+        sorter.Sort();
+
+        PERelocSection relocSection(reloc);
+
+        cur = sections.Ptr();
+        PEWriterSection **curEnd = cur + sections.Size();
+        while (cur < curEnd)
+        {
+            IfFailRet((*cur)->applyRelocs(m_ntHeaders, 
+                                          &relocSection, 
+                                          pMapper, 
+                                          m_dataRvaBase, 
+                                          m_rdataRvaBase, 
+                                          m_codeRvaBase));
+            cur++;
+        }
+
+        relocSection.Finish(isPE32());
+        reloc->m_header->Misc.VirtualSize = VAL32(reloc->dataLen());
+
+        // Strip the reloc section if the flag is set
+        if (m_ntHeaders->FileHeader.Characteristics & VAL16(IMAGE_FILE_RELOCS_STRIPPED))
+        {
+            reloc->m_header->Misc.VirtualSize = VAL32(0);
+        }
+
+        reloc->m_header->SizeOfRawData = VAL32(roundUp(VAL32(reloc->m_header->Misc.VirtualSize), RoundUpVal));
+        reloc->m_filePad = padLen(VAL32(reloc->m_header->Misc.VirtualSize), RoundUpVal);
+        filePos += VAL32(reloc->m_header->SizeOfRawData);
+        virtualPos += roundUp(VAL32(reloc->m_header->Misc.VirtualSize),
+                              VAL32(m_ntHeaders->OptionalHeader.SectionAlignment));
+
+        if (reloc->m_header->Misc.VirtualSize == VAL32(0))
+        {
+            //
+            // Omit reloc section from section list.  (It will
+            // still be there but the loader won't see it - this
+            // only works because we've allocated it as the last
+            // section.)
+            //
+            m_ntHeaders->FileHeader.NumberOfSections = VAL16(VAL16(m_ntHeaders->FileHeader.NumberOfSections) - 1);
+        }
+        else
+        {
+            IMAGE_DATA_DIRECTORY * pRelocDataDirectory;
+            //
+            // Put reloc address in header
+            //
+            if (isPE32())
+            {
+                pRelocDataDirectory = &(ntHeaders32()->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC]);
+            }
+            else
+            {
+                pRelocDataDirectory = &(ntHeaders64()->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC]);
+            }
+
+            pRelocDataDirectory->VirtualAddress = reloc->m_header->VirtualAddress;
+            pRelocDataDirectory->Size           = reloc->m_header->Misc.VirtualSize;
+        }
+
+        // compute ntHeader fields that depend on the sizes of other things
+        for(IMAGE_SECTION_HEADER *h = headersEnd-1; h >= headers; h--) {    // go backwards, so first entry takes precedence
+            if (h->Characteristics & VAL32(IMAGE_SCN_CNT_CODE)) {
+                m_ntHeaders->OptionalHeader.BaseOfCode = h->VirtualAddress;
+                m_ntHeaders->OptionalHeader.SizeOfCode =
+                    VAL32(VAL32(m_ntHeaders->OptionalHeader.SizeOfCode) + VAL32(h->SizeOfRawData));
+            }
+            if (h->Characteristics & VAL32(IMAGE_SCN_CNT_INITIALIZED_DATA)) {
+                if (isPE32())
+                {
+                    ntHeaders32()->OptionalHeader.BaseOfData = h->VirtualAddress;
+                }
+                m_ntHeaders->OptionalHeader.SizeOfInitializedData =
+                    VAL32(VAL32(m_ntHeaders->OptionalHeader.SizeOfInitializedData) + VAL32(h->SizeOfRawData));
+            }
+            if (h->Characteristics & VAL32(IMAGE_SCN_CNT_UNINITIALIZED_DATA)) {
+                m_ntHeaders->OptionalHeader.SizeOfUninitializedData =
+                    VAL32(VAL32(m_ntHeaders->OptionalHeader.SizeOfUninitializedData) + VAL32(h->SizeOfRawData));
+            }
+        }
+
+        int index;
+        IMAGE_DATA_DIRECTORY * pCurDataDirectory;
+
+        // go backwards, so first entry takes precedence
+        for(cur = getSectCur()-1; getSectStart() <= cur; --cur)
+        {
+            index = (*cur)->getDirEntry();
+
+            // Is this a valid directory entry
+            if (index > 0)
+            {
+                if (isPE32())
+                {
+                    _ASSERTE((unsigned)(index) < VAL32(ntHeaders32()->OptionalHeader.NumberOfRvaAndSizes));
+
+                    pCurDataDirectory = &(ntHeaders32()->OptionalHeader.DataDirectory[index]);
+                }
+                else
+                {
+                    _ASSERTE((unsigned)(index) < VAL32(ntHeaders64()->OptionalHeader.NumberOfRvaAndSizes));
+
+                    pCurDataDirectory = &(ntHeaders64()->OptionalHeader.DataDirectory[index]);
+                }
+
+                pCurDataDirectory->VirtualAddress = VAL32((*cur)->m_baseRVA);
+                pCurDataDirectory->Size           = VAL32((*cur)->dataLen());
+            }
+        }
+
+        // handle the directory entries specified using the file.
+        for (index=0; index < cEntries; index++)
+        {
+            if (pEntries[index].section)
+            {
+                PEWriterSection *section = pEntries[index].section;
+                _ASSERTE(pEntries[index].offset < section->dataLen());
+
+                if (isPE32())
+                    pCurDataDirectory = &(ntHeaders32()->OptionalHeader.DataDirectory[index]);
+                else
+                    pCurDataDirectory = &(ntHeaders64()->OptionalHeader.DataDirectory[index]);
+
+                pCurDataDirectory->VirtualAddress = VAL32(section->m_baseRVA + pEntries[index].offset);
+                pCurDataDirectory->Size           = VAL32(pEntries[index].size);
+            }
+        }
+
+        m_ntHeaders->OptionalHeader.SizeOfImage = VAL32(virtualPos);
+    } // end if(ExeOrDll)
+    else //i.e., if OBJ
+    {
+        //
+        // Clean up note:
+        // I've cleaned up the executable linking path, but the .obj linking
+        // is still a bit strange, what with a "extra" reloc & strtab sections
+        // which are created after the linking step and get treated specially.
+        //
+        reloc = new (nothrow) PEWriterSection(".reloc",
+                                    sdReadOnly | IMAGE_SCN_MEM_DISCARDABLE, 0x4000, 0);
+        if(reloc == NULL) return E_OUTOFMEMORY;
+        strtab = new (nothrow)  PEWriterSection(".strtab",
+                                     sdReadOnly | IMAGE_SCN_MEM_DISCARDABLE, 0x4000, 0); //string table (if any)
+        if(strtab == NULL) return E_OUTOFMEMORY;
+
+        DWORD* TokInSymbolTable = new (nothrow) DWORD[16386];
+        if (TokInSymbolTable == NULL) return E_OUTOFMEMORY;
+
+        m_ntHeaders->FileHeader.SizeOfOptionalHeader = 0;
+        //For each section set VirtualAddress to 0
+        PEWriterSection **cur;
+        for(cur = getSectStart(); cur < getSectCur(); cur++)
+        {
+            IMAGE_SECTION_HEADER* header = (*cur)->m_header;
+            header->VirtualAddress = VAL32(0);
+        }
+        // Go over section relocations and build the Symbol Table, use .reloc section as buffer:
+        DWORD tk=0, rva=0, NumberOfSymbols=0;
+        BOOL  ToRelocTable = FALSE;
+        IMAGE_SYMBOL is;
+        IMAGE_RELOCATION ir;
+        ULONG StrTableLen = 4; //size itself only
+        char* szSymbolName = NULL;
+        char* pch;
+
+        PESection *textSection;
+        getSectionCreate(".text", 0, &textSection);
+
+        for(PESectionReloc* rcur = textSection->m_relocStart; rcur < textSection->m_relocCur; rcur++)
+        {
+            switch(rcur->type)
+            {
+                case 0x7FFA: // Ptr to symbol name
+#ifdef _WIN64
+                    _ASSERTE(!"this is probably broken!!");
+#endif // _WIN64
+                    szSymbolName = (char*)(UINT_PTR)(rcur->offset);
+                    break;
+
+                case 0x7FFC: // Ptr to file name
+                    TokInSymbolTable[NumberOfSymbols++] = 0;
+                    memset(&is,0,sizeof(IMAGE_SYMBOL));
+                    memcpy(is.N.ShortName,".file\0\0\0",8);
+                    is.Value = 0;
+                    is.SectionNumber = VAL16(IMAGE_SYM_DEBUG);
+                    is.Type = VAL16(IMAGE_SYM_DTYPE_NULL);
+                    is.StorageClass = IMAGE_SYM_CLASS_FILE;
+                    is.NumberOfAuxSymbols = 1;
+                    if((pch = reloc->getBlock(sizeof(IMAGE_SYMBOL))))
+                        memcpy(pch,&is,sizeof(IMAGE_SYMBOL));
+                    else return E_OUTOFMEMORY;
+                    TokInSymbolTable[NumberOfSymbols++] = 0;
+                    memset(&is,0,sizeof(IMAGE_SYMBOL));
+#ifdef _WIN64
+                    _ASSERTE(!"this is probably broken!!");
+#endif // _WIN64
+                    strcpy_s((char*)&is,sizeof(is),(char*)(UINT_PTR)(rcur->offset));
+                    if((pch = reloc->getBlock(sizeof(IMAGE_SYMBOL))))
+                        memcpy(pch,&is,sizeof(IMAGE_SYMBOL));
+                    else return E_OUTOFMEMORY;
+#ifdef _WIN64
+                    _ASSERTE(!"this is probably broken!!");
+#endif // _WIN64
+                    delete (char*)(UINT_PTR)(rcur->offset);
+                    ToRelocTable = FALSE;
+                    tk = 0;
+                    szSymbolName = NULL;
+                    break;
+
+                case 0x7FFB: // compid value
+                    TokInSymbolTable[NumberOfSymbols++] = 0;
+                    memset(&is,0,sizeof(IMAGE_SYMBOL));
+                    memcpy(is.N.ShortName,"@comp.id",8);
+                    is.Value = VAL32(rcur->offset);
+                    is.SectionNumber = VAL16(IMAGE_SYM_ABSOLUTE);
+                    is.Type = VAL16(IMAGE_SYM_DTYPE_NULL);
+                    is.StorageClass = IMAGE_SYM_CLASS_STATIC;
+                    is.NumberOfAuxSymbols = 0;
+                    if((pch = reloc->getBlock(sizeof(IMAGE_SYMBOL))))
+                        memcpy(pch,&is,sizeof(IMAGE_SYMBOL));
+                    else return E_OUTOFMEMORY;
+                    ToRelocTable = FALSE;
+                    tk = 0;
+                    szSymbolName = NULL;
+                    break;
+
+                case 0x7FFF: // Token value, def
+                    tk = rcur->offset;
+                    ToRelocTable = FALSE;
+                    break;
+
+                case 0x7FFE: //Token value, ref
+                    tk = rcur->offset;
+                    ToRelocTable = TRUE;
+                    break;
+
+                case 0x7FFD: //RVA value
+                    rva = rcur->offset;
+                    if(tk)
+                    {
+                        // Add to SymbolTable
+                        DWORD i;
+                        for(i = 0; (i < NumberOfSymbols)&&(tk != TokInSymbolTable[i]); i++);
+                        if(i == NumberOfSymbols)
+                        {
+                            if(szSymbolName && *szSymbolName) // Add "extern" symbol and string table entry
+                            {
+                                TokInSymbolTable[NumberOfSymbols++] = 0;
+                                memset(&is,0,sizeof(IMAGE_SYMBOL));
+                                i++; // so reloc record (if generated) points to COM token symbol
+                                is.N.Name.Long = VAL32(StrTableLen);
+                                is.SectionNumber = VAL16(1); //textSection is the first one
+                                is.StorageClass = IMAGE_SYM_CLASS_EXTERNAL;
+                                is.NumberOfAuxSymbols = 0;
+                                is.Value = VAL32(rva);
+                                if(TypeFromToken(tk) == mdtMethodDef)
+                                {
+                                    is.Type = VAL16(0x20); //IMAGE_SYM_DTYPE_FUNCTION;
+                                }
+                                if((pch = reloc->getBlock(sizeof(IMAGE_SYMBOL))))
+                                    memcpy(pch,&is,sizeof(IMAGE_SYMBOL));
+                                else return E_OUTOFMEMORY;
+                                DWORD l = (DWORD)(strlen(szSymbolName)+1); // don't forget zero terminator!
+                                if((pch = reloc->getBlock(1)))
+                                    memcpy(pch,szSymbolName,1);
+                                else return E_OUTOFMEMORY;
+                                delete szSymbolName;
+                                StrTableLen += l;
+                            }
+                            TokInSymbolTable[NumberOfSymbols++] = tk;
+                            memset(&is,0,sizeof(IMAGE_SYMBOL));
+                            sprintf_s((char*)is.N.ShortName,sizeof(is.N.ShortName),"%08X",tk);
+                            is.SectionNumber = VAL16(1); //textSection is the first one
+                            is.StorageClass = 0x6B; //IMAGE_SYM_CLASS_COM_TOKEN;
+                            is.Value = VAL32(rva);
+                            if(TypeFromToken(tk) == mdtMethodDef)
+                            {
+                                is.Type = VAL16(0x20); //IMAGE_SYM_DTYPE_FUNCTION;
+                                //is.NumberOfAuxSymbols = 1;
+                            }
+                            if((pch = reloc->getBlock(sizeof(IMAGE_SYMBOL))))
+                                memcpy(pch,&is,sizeof(IMAGE_SYMBOL));
+                            else return E_OUTOFMEMORY;
+                            if(is.NumberOfAuxSymbols == 1)
+                            {
+                                BYTE dummy[sizeof(IMAGE_SYMBOL)];
+                                memset(dummy,0,sizeof(IMAGE_SYMBOL));
+                                dummy[0] = dummy[2] = 1;
+                                if((pch = reloc->getBlock(sizeof(IMAGE_SYMBOL))))
+                                    memcpy(pch,dummy,sizeof(IMAGE_SYMBOL));
+                                else return E_OUTOFMEMORY;
+                                TokInSymbolTable[NumberOfSymbols++] = 0;
+                            }
+                        }
+                        if(ToRelocTable)
+                        {
+                            IMAGE_SECTION_HEADER* phdr = textSection->m_header;
+                            // Add to reloc table
+                            IMAGE_RELOC_FIELD(ir, VirtualAddress) = VAL32(rva);
+                            ir.SymbolTableIndex = VAL32(i);
+                            ir.Type = VAL16(IMAGE_REL_I386_SECREL);
+                            if(phdr->PointerToRelocations == 0)
+                                phdr->PointerToRelocations = VAL32(VAL32(phdr->PointerToRawData) + VAL32(phdr->SizeOfRawData));
+                            phdr->NumberOfRelocations = VAL32(VAL32(phdr->NumberOfRelocations) + 1);
+                            if((pch = reloc->getBlock(sizeof(IMAGE_RELOCATION))))
+                                memcpy(pch,&is,sizeof(IMAGE_RELOCATION));
+                            else return E_OUTOFMEMORY;
+                        }
+                    }
+                    ToRelocTable = FALSE;
+                    tk = 0;
+                    szSymbolName = NULL;
+                    break;
+
+                default:
+                    break;
+            } //end switch(cur->type)
+        } // end for all relocs
+        // Add string table counter:
+        if((pch = reloc->getBlock(sizeof(ULONG))))
+            memcpy(pch,&StrTableLen,sizeof(ULONG));
+        else return E_OUTOFMEMORY;
+        reloc->m_header->Misc.VirtualSize = VAL32(reloc->dataLen());
+        if(NumberOfSymbols)
+        {
+            // recompute the actual sizes and positions of all the sections
+            filePos = roundUp(VAL16(m_ntHeaders->FileHeader.NumberOfSections) * sizeof(IMAGE_SECTION_HEADER)+
+                              sizeof(IMAGE_FILE_HEADER), RoundUpVal);
+            for(cur = getSectStart(); cur < getSectCur(); cur++)
+            {
+                IMAGE_SECTION_HEADER* header = (*cur)->m_header;
+                header->Misc.VirtualSize = VAL32((*cur)->dataLen());
+                header->VirtualAddress = VAL32(0);
+                header->SizeOfRawData = VAL32(roundUp(VAL32(header->Misc.VirtualSize), RoundUpVal));
+                header->PointerToRawData = VAL32(filePos);
+
+                filePos += VAL32(header->SizeOfRawData);
+            }
+            m_ntHeaders->FileHeader.Machine = VAL16(0xC0EE); //COM+ EE
+            m_ntHeaders->FileHeader.PointerToSymbolTable = VAL32(filePos);
+            m_ntHeaders->FileHeader.NumberOfSymbols = VAL32(NumberOfSymbols);
+            filePos += roundUp(VAL32(reloc->m_header->Misc.VirtualSize)+strtab->dataLen(),RoundUpVal);
+        }
+        delete[] TokInSymbolTable;
+    } //end if OBJ
+
+    const unsigned headerOffset = (unsigned) (ExeOrDll ? sizeof(IMAGE_DOS_HEADER) + sizeof(x86StubPgm) : 0);
+
+    memset(&m_dosHeader, 0, sizeof(IMAGE_DOS_HEADER));
+    m_dosHeader.e_magic = VAL16(IMAGE_DOS_SIGNATURE);
+    m_dosHeader.e_cblp =  VAL16(0x90);              // bytes in last page
+    m_dosHeader.e_cp =  VAL16(3);                   // pages in file
+    m_dosHeader.e_cparhdr =  VAL16(4);              // size of header in paragraphs
+    m_dosHeader.e_maxalloc =   VAL16(0xFFFF);       // maximum extra mem needed
+    m_dosHeader.e_sp =  VAL16(0xB8);                // initial SP value
+    m_dosHeader.e_lfarlc =  VAL16(0x40);            // file offset of relocations
+    m_dosHeader.e_lfanew =  VAL32(headerOffset);    // file offset of NT header!
+
+    return(S_OK);   // SUCCESS
+}
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif
+
+HRESULT PEWriter::Open(__in LPCWSTR fileName)
+{
+    _ASSERTE(m_file == INVALID_HANDLE_VALUE);
+    HRESULT hr = NOERROR;
+
+    m_file = WszCreateFile(fileName,
+                           GENERIC_WRITE,
+                           0, // No sharing.  Was: FILE_SHARE_READ | FILE_SHARE_WRITE,
+                           NULL,
+                           CREATE_ALWAYS,
+                           FILE_ATTRIBUTE_NORMAL,
+                           NULL );
+    if (m_file == INVALID_HANDLE_VALUE)
+        hr = HRESULT_FROM_GetLastErrorNA();
+
+    return hr;
+}
+
+HRESULT PEWriter::Seek(int offset)
+{
+    _ASSERTE(m_file != INVALID_HANDLE_VALUE);
+    if (SetFilePointer(m_file, offset, 0, FILE_BEGIN))
+        return S_OK;
+    else
+        return HRESULT_FROM_GetLastError();
+}
+
+HRESULT PEWriter::Write(const void *data, int size)
+{
+    _ASSERTE(m_file != INVALID_HANDLE_VALUE);
+
+    HRESULT hr = S_OK;
+    DWORD dwWritten = 0;
+    if (size)
+    {
+        CQuickBytes zero;
+        if (data == NULL)
+        {
+            hr = zero.ReSizeNoThrow(size);
+            if (SUCCEEDED(hr))
+            {
+                ZeroMemory(zero.Ptr(), size);
+                data = zero.Ptr();
+            }
+        }
+
+        if (WriteFile(m_file, data, size, &dwWritten, NULL))
+        {
+            _ASSERTE(dwWritten == (DWORD)size);
+        }
+        else
+            hr = HRESULT_FROM_GetLastError();
+    }
+
+    return hr;
+}
+
+HRESULT PEWriter::Pad(int align)
+{
+    DWORD offset = SetFilePointer(m_file, 0, NULL, FILE_CURRENT);
+    int pad = padLen(offset, align);
+    if (pad > 0)
+        return Write(NULL, pad);
+    else
+        return S_FALSE;
+}
+
+HRESULT PEWriter::Close()
+{
+    if (m_file == INVALID_HANDLE_VALUE)
+        return S_OK;
+
+    HRESULT hr;
+    if (CloseHandle(m_file))
+        hr = S_OK;
+    else
+        hr = HRESULT_FROM_GetLastError();
+
+    m_file = INVALID_HANDLE_VALUE;
+
+    return hr;
+}
+
+/******************************************************************/
+HRESULT PEWriter::write(__in const LPWSTR fileName) {
+
+    HRESULT hr;
+
+#ifdef ENC_DELTA_HACK
+    WCHAR szFileName[256];
+    DWORD len = WszGetEnvironmentVariable(L"COMP_ENC_EMIT", szFileName, NumItems(szFileName));
+    _ASSERTE(len < sizeof(szFileName));
+    if (len > 0)
+    {
+        _ASSERTE(!m_pSeedFileDecoder);
+
+        wcscat_s(szFileName, sizeof(szFileName)/sizeof(szFileName[0]), L".dil");
+        HANDLE pDelta = WszCreateFile(szFileName,
+                           GENERIC_WRITE,
+                           FILE_SHARE_READ | FILE_SHARE_WRITE,
+                           NULL,
+                           CREATE_ALWAYS,
+                           FILE_ATTRIBUTE_NORMAL,
+                           NULL );
+        if (pDelta == INVALID_HANDLE_VALUE) {
+            hr = HRESULT_FROM_GetLastError();
+            _ASSERTE(!"failure so open .dil file");
+            goto ErrExit;
+        }
+
+        // write the actual data
+        for (PEWriterSection **cur = getSectStart(); cur < getSectCur(); cur++) {
+            if (strcmp((*cur)->m_name, ".text") == 0)
+            {
+                hr = (*cur)->write(pDelta);
+                CloseHandle(pDelta);
+                pDelta = NULL;
+                if (FAILED(hr))
+                {
+                    _ASSERT(!"failure to write to .dil file");
+                    goto ErrExit;
+                }
+                break;
+            }
+        }
+        PREFIX_ASSUME(!pDelta);
+        return S_OK;
+    }
+#endif
+
+    bool ExeOrDll;
+    unsigned RoundUpVal;
+    ExeOrDll = isExeOrDll(m_ntHeaders);
+    RoundUpVal = VAL32(m_ntHeaders->OptionalHeader.FileAlignment);
+
+    IfFailGo(Open(fileName));
+
+    if(ExeOrDll)
+    {
+        // write the PE headers
+        IfFailGo(Write(&m_dosHeader, sizeof(IMAGE_DOS_HEADER)));
+        IfFailGo(Write(x86StubPgm, sizeof(x86StubPgm)));
+        IfFailGo(Write(m_ntHeaders, m_ntHeadersSize));
+    }
+    else
+    {
+        // write the object file header
+        IfFailGo(Write(&(m_ntHeaders->FileHeader),sizeof(IMAGE_FILE_HEADER)));
+    }
+
+    IfFailGo(Write(headers, (int)(sizeof(IMAGE_SECTION_HEADER)*(headersEnd-headers))));
+
+    IfFailGo(Pad(RoundUpVal));
+
+    // write the actual data
+    for (PEWriterSection **cur = getSectStart(); cur < getSectCur(); cur++) {
+        if ((*cur)->m_header != NULL) {
+            IfFailGo(Seek((*cur)->m_filePos));
+            IfFailGo((*cur)->write(m_file));
+            IfFailGo(Write(NULL, (*cur)->m_filePad));
+        }
+    }
+
+    // writes for an object file
+    if (!ExeOrDll)
+    {
+        // write the relocs section (Does nothing if relocs section is empty)
+        IfFailGo(reloc->write(m_file));
+        //write string table (obj only, empty for exe or dll)
+        IfFailGo(strtab->write(m_file));
+        int lena = padLen(VAL32(reloc->m_header->Misc.VirtualSize)+strtab->dataLen(), RoundUpVal);
+        if (lena > 0)
+            IfFailGo(Write(NULL, lena));
+    }
+
+    return Close();
+
+ ErrExit:
+    Close();
+
+    return hr;
+}
+
+HRESULT PEWriter::write(void ** ppImage)
+{
+    bool ExeOrDll = isExeOrDll(m_ntHeaders);
+    const unsigned RoundUpVal = VAL32(m_ntHeaders->OptionalHeader.FileAlignment);
+    char *pad = (char *) _alloca(RoundUpVal);
+    memset(pad, 0, RoundUpVal);
+
+    size_t lSize = filePos;
+    if (!ExeOrDll)
+    {
+        lSize += reloc->dataLen();
+        lSize += strtab->dataLen();
+        lSize += padLen(VAL32(reloc->m_header->Misc.VirtualSize)+strtab->dataLen(),
+                        RoundUpVal);
+    }
+
+    // allocate the block we are handing back to the caller
+    void * pImage = (void *) ::CoTaskMemAlloc(lSize);
+    if (NULL == pImage)
+    {
+        return E_OUTOFMEMORY;
+    }
+
+    // zero the memory
+    ::memset(pImage, 0, lSize);
+
+    char *pCur = (char *)pImage;
+
+    if(ExeOrDll)
+    {
+        // PE Header
+        COPY_AND_ADVANCE(pCur, &m_dosHeader, sizeof(IMAGE_DOS_HEADER));
+        COPY_AND_ADVANCE(pCur, x86StubPgm, sizeof(x86StubPgm));
+        COPY_AND_ADVANCE(pCur, m_ntHeaders, m_ntHeadersSize);
+    }
+    else
+    {
+        COPY_AND_ADVANCE(pCur, &(m_ntHeaders->FileHeader), sizeof(IMAGE_FILE_HEADER));
+    }
+
+    COPY_AND_ADVANCE(pCur, headers, sizeof(*headers)*(headersEnd - headers));
+
+    // now the sections
+    // write the actual data
+    for (PEWriterSection **cur = getSectStart(); cur < getSectCur(); cur++) {
+        if ((*cur)->m_header != NULL) {
+            unsigned len;
+            pCur = (char*)pImage + (*cur)->m_filePos;
+            len = (*cur)->writeMem((void**)&pCur);
+            _ASSERTE(len == (*cur)->dataLen());
+            COPY_AND_ADVANCE(pCur, pad, (*cur)->m_filePad);
+        }
+    }
+
+    // !!! Need to jump to the right place...
+
+    if (!ExeOrDll)
+    {
+        // now the relocs (exe, dll) or symbol table (obj) (if any)
+        // write the relocs section (Does nothing if relocs section is empty)
+        reloc->writeMem((void **)&pCur);
+
+        //write string table (obj only, empty for exe or dll)
+        strtab->writeMem((void **)&pCur);
+
+        // final pad
+        size_t len = padLen(VAL32(reloc->m_header->Misc.VirtualSize)+strtab->dataLen(), RoundUpVal);
+        if (len > 0)
+        {
+            // WARNING: macro - must enclose in curly braces
+            COPY_AND_ADVANCE(pCur, pad, len);
+        }
+    }
+
+    // make sure we wrote the exact numbmer of bytes expected
+    _ASSERTE(lSize == (size_t) (pCur - (char *)pImage));
+
+    // give pointer to memory image back to caller (who must free with ::CoTaskMemFree())
+    *ppImage = pImage;
+
+    // all done
+    return S_OK;
+}
+
+HRESULT PEWriter::getFileTimeStamp(DWORD *pTimeStamp)
+{
+    if (pTimeStamp)
+        *pTimeStamp = m_peFileTimeStamp;
+
+    return S_OK;
+}
+
+DWORD PEWriter::getImageBase32()
+{
+    _ASSERTE(isPE32());
+    return VAL32(ntHeaders32()->OptionalHeader.ImageBase);
+}
+
+UINT64 PEWriter::getImageBase64()
+{
+    _ASSERTE(!isPE32());
+    return VAL64(ntHeaders64()->OptionalHeader.ImageBase);
+}
+
+void PEWriter::setImageBase32(DWORD imageBase)
+{
+    _ASSERTE(m_hSeedFile == INVALID_HANDLE_VALUE);
+
+    _ASSERTE(isPE32());
+    ntHeaders32()->OptionalHeader.ImageBase = VAL32(imageBase);
+}
+
+void PEWriter::setImageBase64(UINT64 imageBase)
+{
+    _ASSERTE(!isPE32());
+    ntHeaders64()->OptionalHeader.ImageBase = VAL64(imageBase);
+}
+
+void PEWriter::getHeaderInfo(PIMAGE_NT_HEADERS *ppNtHeaders, PIMAGE_SECTION_HEADER *ppSections, ULONG *pNumSections)
+{
+    *ppNtHeaders = m_ntHeaders;
+    *ppSections = headers;
+    *pNumSections = (ULONG)(headersEnd - headers);
+}
diff --git a/src/dlls/mscorpe/pewriter.h b/src/dlls/mscorpe/pewriter.h
new file mode 100644
index 0000000000..67441eee75
--- /dev/null
+++ b/src/dlls/mscorpe/pewriter.h
@@ -0,0 +1,338 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+#ifndef PEWriter_H
+#define PEWriter_H
+
+#include <crtwrap.h>
+
+#include <windows.h>
+
+#include "ceegen.h"
+
+#include "pesectionman.h"
+
+class PEWriter;
+class PEWriterSection;
+class PEDecoder;
+struct entry;
+struct _IMAGE_SECTION_HEADER;
+
+#define SUBSECTION_ALIGN 16
+
+/***************************************************************/
+// PEWriter is derived from PESectionManager. While the base class just
+// manages the sections, PEWriter can actually write them out.
+
+class PEWriter : public PESectionMan
+{
+public:
+
+    // See ICeeFileGen.h for definition of createFlags
+    HRESULT Init(PESectionMan *pFrom, DWORD createFlags, LPCWSTR seedFileName = NULL);
+    HRESULT Cleanup();
+
+    // Finds section with given name.  returns 0 if not found
+    virtual PESection* getSection(const char* name);
+
+    // Create a new section
+    virtual HRESULT newSection(const char* name, PESection **section,
+                        unsigned flags=sdNone, unsigned estSize=0x10000,
+                        unsigned estRelocs=0x100);
+
+    HRESULT link();
+    HRESULT fixup(CeeGenTokenMapper *pMapper);
+    HRESULT write(__in const LPWSTR fileName);
+    HRESULT write(void **ppImage);
+
+    // calling these functions is optional
+    DWORD      getSectionAlignment();
+    void       setSectionAlignment(DWORD);
+    DWORD      getFileAlignment();
+    void       setFileAlignment(DWORD);
+    DWORD      getImageBase32();
+    void       setImageBase32(DWORD);
+    UINT64     getImageBase64();
+    void       setImageBase64(UINT64);
+    void       stripRelocations(bool val);        // default = false
+
+    void getHeaderInfo(PIMAGE_NT_HEADERS *ppNtHeaders, PIMAGE_SECTION_HEADER *ppSections, ULONG *pNumSections);
+
+    // these affect the charactertics in the NT file header
+    void setCharacteristics(unsigned mask);
+    void clearCharacteristics(unsigned mask);
+
+    // these affect the charactertics in the NT optional header
+    void setDllCharacteristics(unsigned mask);
+    void clearDllCharacteristics(unsigned mask);
+
+    // sets the SubSystem field in the optional header
+    void setSubsystem(unsigned subsystem, unsigned major, unsigned minor);
+
+    // specify the entry point as an offset into the text section. The
+    // method will convert into an RVA from the base
+    void setEntryPointTextOffset(unsigned entryPoint);
+
+    HRESULT setDirectoryEntry(PEWriterSection *section, ULONG entry, ULONG size, ULONG offset=0);
+
+
+    // get the RVA for the IL section
+    ULONG getIlRva();
+
+    // set the RVA for the IL section by supplying offset to the IL section
+    void setIlRva(DWORD offset);
+
+    unsigned getSubsystem();
+
+    size_t getImageBase();
+
+    void setEnCRvaBase(ULONG dataBase, ULONG rdataBase);
+
+    HRESULT getFileTimeStamp(DWORD *pTimeStamp);
+
+    IMAGE_NT_HEADERS32* ntHeaders32()    { return (IMAGE_NT_HEADERS32*) m_ntHeaders; }
+    IMAGE_NT_HEADERS64* ntHeaders64()    { return (IMAGE_NT_HEADERS64*) m_ntHeaders; }
+
+    bool isPE32()  // true  -> created a PE  32-bit PE file
+                   // false -> created a PE+ 64-bit PE file
+    { return (m_ntHeaders->OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR32_MAGIC)); }
+
+    bool isI386()  // true  -> target machine is i386
+    { return (m_ntHeaders->FileHeader.Machine == VAL16(IMAGE_FILE_MACHINE_I386)); }
+
+    bool isIA64()  // true  -> target machine is ia64
+    { return (m_ntHeaders->FileHeader.Machine == VAL16(IMAGE_FILE_MACHINE_IA64)); }
+    
+    bool isAMD64()  // true  -> target machine is ia64
+    { return (m_ntHeaders->FileHeader.Machine == VAL16(IMAGE_FILE_MACHINE_AMD64)); }
+
+    bool isARM()  // true  -> target machine is ARM
+    { return (m_ntHeaders->FileHeader.Machine == VAL16(IMAGE_FILE_MACHINE_ARMNT)); }
+
+    bool createCorMainStub() // do we need the CorExeMain/CorDllMain stubs?
+    { return m_createCorMainStub; }
+
+private:
+    DWORD  m_ilRVA;
+    BOOL   m_encMode;
+    ULONG  m_dataRvaBase;
+    ULONG  m_rdataRvaBase;
+    ULONG  m_codeRvaBase;
+    DWORD  m_peFileTimeStamp;
+
+    HANDLE   m_file;
+
+    // "Seed" file information. The new file data will be "appended" to the seed file
+    // These are valid only if m_hSeedFile is valid
+
+    HANDLE              m_hSeedFile;
+    HANDLE              m_hSeedFileMap;
+    PEDecoder *         m_pSeedFileDecoder;
+    IMAGE_NT_HEADERS *  m_pSeedFileNTHeaders;
+    unsigned            m_iSeedSections;
+    IMAGE_SECTION_HEADER*m_pSeedSections;
+    IMAGE_SECTION_HEADER*m_pSeedSectionToAdd; // used only by newSection()
+
+    PEWriterSection **getSectStart() {
+        return (PEWriterSection**)sectStart;
+    }
+
+    PEWriterSection **getSectCur() {
+        return (PEWriterSection**)sectCur;
+    }
+
+    COUNT_T getSectCount() {
+        return COUNT_T(sectCur - sectStart);
+    }
+
+
+    IMAGE_DOS_HEADER    m_dosHeader;
+    IMAGE_NT_HEADERS *  m_ntHeaders;
+    DWORD               m_ntHeadersSize; // Size of IMAGE_NT_HEADERS (not including section headers)
+
+    unsigned            virtualPos;
+    unsigned            filePos;
+
+    PEWriterSection *   reloc;
+    PEWriterSection *   strtab;
+
+    IMAGE_SECTION_HEADER *headers, *headersEnd;
+
+    struct directoryEntry {
+        PEWriterSection *section;
+        ULONG offset;
+        ULONG size;
+    };
+
+    // Directory entries in the file header
+    directoryEntry  *   pEntries;
+    USHORT              cEntries;
+
+    bool   m_createCorMainStub;
+
+    // Helpers for link()
+    HRESULT linkSortSections(entry * entries,
+                             unsigned * piEntries, // OUT
+                             unsigned * piUniqueSections); // OUT
+    HRESULT linkSortHeaders(entry * entries, unsigned iEntries, unsigned iUniqueSections);
+    HRESULT linkPlaceSections(entry * entries, unsigned iEntries);
+    void setSectionIndex(IMAGE_SECTION_HEADER * h, unsigned sectionIndex);
+
+    HRESULT Open(__in LPCWSTR fileName);
+    HRESULT Write(const void *data, int size);
+    HRESULT Seek(int offset);
+    HRESULT Pad(int align);
+    HRESULT Close();
+};
+
+// This class encapsulates emitting the base relocs into the
+// .reloc section of the PE file, for the case where the image
+// does not get loaded at its preferred base address.
+
+class PERelocSection
+{
+ private:
+    PEWriterSection *   section;
+    unsigned            relocPage;
+    unsigned            relocSize;
+    DWORD *             relocSizeAddr;
+    unsigned            pages;
+
+#ifdef _DEBUG
+    unsigned            lastRVA;
+#endif
+
+ public:
+    PERelocSection(PEWriterSection *pBaseReloc);
+    void AddBaseReloc(unsigned rva, int type, unsigned short highAdj=0);
+    void Finish(bool isPE32);
+};
+
+class PEWriterSection : public PESection {
+
+public:
+
+    PEWriterSection(const char* name, unsigned flags,
+                    unsigned estSize, unsigned estRelocs)
+        : PESection(name, flags, estSize, estRelocs)  {}
+
+    virtual HRESULT  applyRelocs(IMAGE_NT_HEADERS *  pNtHeaders,
+                         PERelocSection *    relocSection,
+                         CeeGenTokenMapper * pTokenMapper,
+                         DWORD               rdataRvaBase,
+                         DWORD               dataRvaBase,
+                         DWORD               textRvaBase);
+
+    virtual HRESULT  write      (HANDLE file);
+    virtual unsigned writeMem   (void ** pMem);
+    virtual bool     isSeedSection() { return false; }
+
+};
+
+// This is for sections from the seed file. Their order needs to be maintained and
+// they need to be written to the output file.
+
+class PESeedSection : public PEWriterSection {
+
+public:
+
+    PESeedSection(PEDecoder * peDecoder, IMAGE_SECTION_HEADER * seedSection);
+
+    // PESection methods
+
+    unsigned dataLen() { return m_pSeedSectionHeader->SizeOfRawData; }
+    HRESULT applyRelocs(CeeGenTokenMapper *pTokenMapper) { return S_OK; }
+    char* getBlock(unsigned len, unsigned align) { _ASSERTE(!"PESeedSection"); return NULL; }
+    HRESULT truncate(unsigned newLen) { _ASSERTE(!"PESeedSection"); return E_FAIL; }
+    void writeSectReloc(unsigned val, CeeSection& relativeTo,
+                CeeSectionRelocType reloc,
+                CeeSectionRelocExtra *extra) { _ASSERTE(!"PESeedSection"); return; }
+    HRESULT addSectReloc(unsigned offset, CeeSection& relativeTo,
+                            CeeSectionRelocType reloc,
+                            CeeSectionRelocExtra *extra) { _ASSERTE(!"PESeedSection"); return E_FAIL; }
+    HRESULT addSectReloc(unsigned offset, PESection *relativeTo,
+                            CeeSectionRelocType reloc,
+                            CeeSectionRelocExtra *extra) { _ASSERTE(!"PESeedSection"); return E_FAIL; }
+    HRESULT addBaseReloc(unsigned offset, CeeSectionRelocType reloc,
+                            CeeSectionRelocExtra *extra) { _ASSERTE(!"PESeedSection"); return E_FAIL; }
+//  unsigned char *name();
+//  unsigned flags();
+//  unsigned getBaseRVA();
+    int getDirEntry() { _ASSERTE(!"PESeedSection"); return 0; }
+    HRESULT directoryEntry(unsigned num) { _ASSERTE(!"PESeedSection"); return E_FAIL; }
+    char * computePointer(unsigned offset) const { _ASSERTE(!"PESeedSection"); return NULL; }
+    BOOL containsPointer(__in char *ptr) const { _ASSERTE(!"PESeedSection"); return FALSE; }
+    unsigned computeOffset(__in char *ptr) const { _ASSERTE(!"PESeedSection"); return 0; }
+    HRESULT cloneInstance(PESection *destination) { _ASSERTE(!"PESeedSection"); return E_FAIL; }
+
+    // PEWriterSection
+
+    HRESULT applyRelocs(IMAGE_NT_HEADERS *  pNtHeaders,
+                        PERelocSection *    relocSection,
+                        CeeGenTokenMapper * pTokenMapper,
+                        DWORD               rdataRvaBase,
+                        DWORD               dataRvaBase,
+                        DWORD               textRvaBase) { return S_OK; }
+
+    HRESULT  write(HANDLE file);
+    unsigned writeMem(void ** pMem);
+    bool isSeedSection() { return true; }
+
+protected:
+
+    PEDecoder *             m_pSeedFileDecoder;
+    IMAGE_SECTION_HEADER *  m_pSeedSectionHeader;
+
+};
+
+inline DWORD PEWriter::getSectionAlignment() {
+    return VAL32(m_ntHeaders->OptionalHeader.FileAlignment);
+}
+
+inline void PEWriter::setSectionAlignment(DWORD SectionAlignment) {
+
+    _ASSERTE(m_hSeedFile == INVALID_HANDLE_VALUE);
+    m_ntHeaders->OptionalHeader.SectionAlignment = VAL32(SectionAlignment);
+}
+
+inline DWORD PEWriter::getFileAlignment() {
+    return m_ntHeaders->OptionalHeader.FileAlignment;
+}
+
+inline void PEWriter::setFileAlignment(DWORD fileAlignment) {
+    _ASSERTE(m_hSeedFile == INVALID_HANDLE_VALUE);
+    m_ntHeaders->OptionalHeader.FileAlignment = VAL32(fileAlignment);
+}
+
+inline unsigned PEWriter::getSubsystem() {
+    return VAL16(m_ntHeaders->OptionalHeader.Subsystem);
+}
+
+inline void PEWriter::setSubsystem(unsigned subsystem, unsigned major, unsigned minor) {
+    m_ntHeaders->OptionalHeader.Subsystem = VAL16(subsystem);
+    m_ntHeaders->OptionalHeader.MajorSubsystemVersion = VAL16(major);
+    m_ntHeaders->OptionalHeader.MinorSubsystemVersion = VAL16(minor);
+}
+
+inline void PEWriter::setCharacteristics(unsigned mask) {
+    m_ntHeaders->FileHeader.Characteristics |= VAL16(mask);
+}
+
+inline void PEWriter::clearCharacteristics(unsigned mask) {
+    m_ntHeaders->FileHeader.Characteristics &= VAL16(~mask);
+}
+
+inline void PEWriter::setDllCharacteristics(unsigned mask) {
+    m_ntHeaders->OptionalHeader.DllCharacteristics |= VAL16(mask);
+}
+
+inline void PEWriter::clearDllCharacteristics(unsigned mask) {
+    m_ntHeaders->OptionalHeader.DllCharacteristics &= VAL16(~mask);
+}
+
+inline void PEWriter::setEntryPointTextOffset(unsigned offset) {
+    m_ntHeaders->OptionalHeader.AddressOfEntryPoint = VAL32(offset);
+}
+
+#endif
diff --git a/src/dlls/mscorpe/stdafx.cpp b/src/dlls/mscorpe/stdafx.cpp
new file mode 100644
index 0000000000..9d644a32b1
--- /dev/null
+++ b/src/dlls/mscorpe/stdafx.cpp
@@ -0,0 +1,11 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//*****************************************************************************
+//	stdafx.cpp
+//
+//	Host for precompiled header.
+//
+//*****************************************************************************
+#include "stdafx.h"						// Precompiled header key.
diff --git a/src/dlls/mscorpe/stdafx.h b/src/dlls/mscorpe/stdafx.h
new file mode 100644
index 0000000000..2d34ce2ba6
--- /dev/null
+++ b/src/dlls/mscorpe/stdafx.h
@@ -0,0 +1,25 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//*****************************************************************************
+// stdafx.h
+//
+// Common include file for utility code.
+//*****************************************************************************
+#include <stdlib.h>		// for qsort
+#include <windows.h>
+#include <time.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stddef.h>
+
+#define FEATURE_NO_HOST     // Do not use host interface
+#include <utilcode.h>
+
+#include <corpriv.h>
+
+#include "pewriter.h"
+#include "ceegen.h"
+#include "ceefilegenwriter.h"
+#include "ceesectionstring.h"
diff --git a/src/dlls/mscorpe/stubs.h b/src/dlls/mscorpe/stubs.h
new file mode 100644
index 0000000000..e232591518
--- /dev/null
+++ b/src/dlls/mscorpe/stubs.h
@@ -0,0 +1,170 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//*****************************************************************************
+// Stubs.h
+//
+// This file contains a template for the default entry point stubs of a COM+
+// IL only program.  One can emit these stubs (with some fix-ups) and make
+// the code supplied the entry point value for the image.  The fix-ups will
+// in turn cause mscoree.dll to be loaded and the correct entry point to be
+// called.
+//
+// Note: Although these stubs contain x86 specific code, they are used
+// for all platforms
+//
+//*****************************************************************************
+#ifndef __STUBS_H__
+#define __STUBS_H__
+
+//*****************************************************************************
+// This stub is designed for a x86 Windows application.  It will call the
+// _CorExeMain function in mscoree.dll.  This entry point will in turn load
+// and run the IL program.
+//
+//    jump _CorExeMain();
+//
+// The code jumps to the imported function _CorExeMain using the iat.
+// The address in the template is address of the iat entry which is 
+// fixed up by the loader when the image is paged in.
+//*****************************************************************************
+
+SELECTANY const BYTE ExeMainX86Template[] =
+{
+	// Jump through IAT to _CorExeMain
+	0xFF, 0x25,				// jmp [iat:_CorDllMain entry]
+		0x00, 0x00, 0x00, 0x00,		//   address to replace
+
+};
+
+#define ExeMainX86TemplateSize		sizeof(ExeMainX86Template)
+#define CorExeMainX86IATOffset		2
+
+//*****************************************************************************
+// This stub is designed for a x86 Windows application.  It will call the 
+// _CorDllMain function in mscoree.dll with with the base entry point for
+// the loaded DLL.  This entry point will in turn load and run the IL program.
+//
+//    jump _CorDllMain
+//
+// The code jumps to the imported function _CorExeMain using the iat.
+// The address in the template is address of the iat entry which is 
+// fixed up by the loader when the image is paged in.
+//*****************************************************************************
+
+SELECTANY const BYTE DllMainX86Template[] = 
+{
+	// Jump through IAT to CorDllMain 
+	0xFF, 0x25,				// jmp [iat:_CorDllMain entry]
+		0x00, 0x00, 0x00, 0x00,		//   address to replace
+};
+
+#define DllMainX86TemplateSize		sizeof(DllMainX86Template)
+#define CorDllMainX86IATOffset		2
+
+//*****************************************************************************
+// This stub is designed for a AMD64 Windows application.  It will call the
+// _CorExeMain function in mscoree.dll.  This entry point will in turn load
+// and run the IL program.
+//
+//    mov rax, _CorExeMain();
+//    jmp [rax]
+//
+// The code jumps to the imported function _CorExeMain using the iat.
+// The address in the template is address of the iat entry which is 
+// fixed up by the loader when the image is paged in.
+//*****************************************************************************
+
+SELECTANY const BYTE ExeMainAMD64Template[] =
+{
+	// Jump through IAT to _CorExeMain
+	0x48, 0xA1,				// rex.w rex.b mov rax,[following address]
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,//address of iat:_CorExeMain entry
+    0xFF, 0xE0              // jmp [rax]
+};
+
+#define ExeMainAMD64TemplateSize		sizeof(ExeMainAMD64Template)
+#define CorExeMainAMD64IATOffset		2
+
+//*****************************************************************************
+// This stub is designed for a AMD64 Windows application.  It will call the 
+// _CorDllMain function in mscoree.dll with with the base entry point for
+// the loaded DLL.  This entry point will in turn load and run the IL program.
+//
+//    mov rax, _CorDllMain();
+//    jmp [rax]
+//
+// The code jumps to the imported function _CorDllMain using the iat.
+// The address in the template is address of the iat entry which is 
+// fixed up by the loader when the image is paged in.
+//*****************************************************************************
+
+SELECTANY const BYTE DllMainAMD64Template[] = 
+{
+	// Jump through IAT to CorDllMain 
+	0x48, 0xA1,				// rex.w rex.b mov rax,[following address]
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,//address of iat:_CorDllMain entry
+    0xFF, 0xE0              // jmp [rax]
+};
+
+#define DllMainAMD64TemplateSize		sizeof(DllMainAMD64Template)
+#define CorDllMainAMD64IATOffset		2
+
+//*****************************************************************************
+// This stub is designed for an ia64 Windows application.  It will call the
+// _CorExeMain function in mscoree.dll.  This entry point will in turn load
+// and run the IL program.
+//
+//    jump _CorExeMain();
+//
+// The code jumps to the imported function _CorExeMain using the iat.
+// We set the value of gp to point at the iat table entry for _CorExeMain
+//*****************************************************************************
+
+SELECTANY const BYTE ExeMainIA64Template[] =
+{
+    // ld8    r9  = [gp]    ;;
+    // ld8    r10 = [r9],8
+    // nop.i                ;;
+    // ld8    gp  = [r9]
+    // mov    b6  = r10
+    // br.cond.sptk.few  b6
+    //
+    0x0B, 0x48, 0x00, 0x02, 0x18, 0x10, 0xA0, 0x40, 
+    0x24, 0x30, 0x28, 0x00, 0x00, 0x00, 0x04, 0x00, 
+    0x10, 0x08, 0x00, 0x12, 0x18, 0x10, 0x60, 0x50, 
+    0x04, 0x80, 0x03, 0x00, 0x60, 0x00, 0x80, 0x00
+};
+
+#define ExeMainIA64TemplateSize		sizeof(ExeMainIA64Template)
+
+//*****************************************************************************
+// This stub is designed for an ia64 Windows application.  It will call the 
+// _CorDllMain function in mscoree.dll with with the base entry point for
+// the loaded DLL.  This entry point will in turn load and run the IL program.
+//
+//    jump _CorDllMain
+//
+// The code jumps to the imported function _CorExeMain using the iat.
+// We set the value of gp to point at the iat table entry for _CorExeMain
+//*****************************************************************************
+
+SELECTANY const BYTE DllMainIA64Template[] = 
+{
+    // ld8    r9  = [gp]    ;;
+    // ld8    r10 = [r9],8
+    // nop.i                ;;
+    // ld8    gp  = [r9]
+    // mov    b6  = r10
+    // br.cond.sptk.few  b6
+    //
+    0x0B, 0x48, 0x00, 0x02, 0x18, 0x10, 0xA0, 0x40, 
+    0x24, 0x30, 0x28, 0x00, 0x00, 0x00, 0x04, 0x00, 
+    0x10, 0x08, 0x00, 0x12, 0x18, 0x10, 0x60, 0x50, 
+    0x04, 0x80, 0x03, 0x00, 0x60, 0x00, 0x80, 0x00
+};
+
+#define DllMainIA64TemplateSize		sizeof(DllMainIA64Template)
+
+#endif  // __STUBS_H__
diff --git a/src/dlls/mscorpe/utilcodeinit.cpp b/src/dlls/mscorpe/utilcodeinit.cpp
new file mode 100644
index 0000000000..3c50bb340e
--- /dev/null
+++ b/src/dlls/mscorpe/utilcodeinit.cpp
@@ -0,0 +1,12 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+
+#include "stdafx.h"
+#include <utilcode.h>
+
+EXTERN_C void __stdcall InitializeSxS(CoreClrCallbacks const & callbacks)
+{
+    InitUtilcode(callbacks);
+}
diff --git a/src/ilasm/.gitmirrorall b/src/ilasm/.gitmirrorall
new file mode 100644
index 0000000000..9ee5c57b99
--- /dev/null
+++ b/src/ilasm/.gitmirrorall
@@ -0,0 +1 @@
+This folder will be mirrored by the Git-TFS Mirror recursively.
\ No newline at end of file
diff --git a/src/ilasm/Assembler.h b/src/ilasm/Assembler.h
new file mode 100644
index 0000000000..f3e49148e0
--- /dev/null
+++ b/src/ilasm/Assembler.h
@@ -0,0 +1,1186 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+/************************************************************************/
+/*                           Assembler.h                                */
+/************************************************************************/
+
+#ifndef Assember_h
+#define Assember_h
+
+#define NEW_INLINE_NAMES
+
+#include "binstr.h"
+
+#include "specstrings.h"
+
+#include "asmenum.h"
+#include "asmtemplates.h"
+
+// Disable the "initialization of static local vars is no thread safe" error
+#ifdef _MSC_VER
+#pragma warning(disable : 4640)
+#endif
+
+
+
+#define OUTPUT_BUFFER_SIZE          8192      // initial size of asm code for a single method
+#define OUTPUT_BUFFER_INCREMENT     1024      // size of code buffer increment when it's full
+#define MAX_FILENAME_LENGTH         2048      //256
+#define MAX_SIGNATURE_LENGTH        256       // unused
+#define MAX_LABEL_SIZE              256       //64
+#define MAX_CALL_SIG_SIZE           32        // unused
+#define MAX_SCOPE_LENGTH            _MAX_PATH // follow the RegMeta::SetModuleProps limitation
+
+#define MAX_NAMESPACE_LENGTH        1024      //256    //64
+#define MAX_MEMBER_NAME_LENGTH      1024      //256    //64
+
+#define MAX_INTERFACES_IMPLEMENTED  16        // initial number; extended by 16 when needed
+#define GLOBAL_DATA_SIZE            8192      // initial size of global data buffer
+#define GLOBAL_DATA_INCREMENT       1024      // size of global data buffer increment when it's full
+#define MAX_METHODS                 1024      // unused
+#define MAX_INPUT_LINE_LEN          1024      // unused
+#define MAX_TYPAR                   8
+#define BASE_OBJECT_CLASSNAME   "System.Object"
+#define MAX_MANIFEST_RESOURCES      1024
+
+// Fully-qualified class name separators:
+#define NESTING_SEP     ((char)0xF8)
+
+#define dwUniBuf 16384
+extern WCHAR   wzUniBuf[]; // Unicode conversion global buffer (assem.cpp)
+
+class Class;
+class Method;
+class PermissionDecl;
+class PermissionSetDecl;
+
+unsigned hash(                // defined in assem.cpp
+     __in_ecount(length) const BYTE *k,        /* the key */
+     unsigned  length,   /* the length of the key */
+     unsigned  initval);  /* the previous hash, or an arbitrary value */
+
+struct MemberRefDescriptor
+{
+    mdToken             m_tdClass;
+    Class*              m_pClass;
+    char*               m_szName;
+    DWORD               m_dwName;
+    BinStr*             m_pSigBinStr;
+    mdToken             m_tkResolved;
+};
+typedef FIFO<MemberRefDescriptor> MemberRefDList;
+
+
+struct MethodImplDescriptor
+{
+    mdToken             m_tkImplementedMethod;
+    mdToken             m_tkImplementingMethod;
+    mdToken             m_tkDefiningClass;
+    BOOL                m_fNew;
+};
+typedef FIFO<MethodImplDescriptor> MethodImplDList;
+
+struct LocalMemberRefFixup
+{
+    mdToken tk;
+    size_t  offset;
+    BOOL    m_fNew;
+    LocalMemberRefFixup(mdToken TK, size_t Offset)
+    {
+        tk = TK;
+        offset = Offset;
+        m_fNew = TRUE;
+    }
+};
+typedef FIFO<LocalMemberRefFixup> LocalMemberRefFixupList;
+
+struct CustomDescr
+{
+    mdToken tkType;
+    mdToken tkOwner;
+    mdToken tkInterfacePair; // Needed for InterfaceImpl CA's
+    BinStr* pBlob;
+    CustomDescr(mdToken tko, mdToken tk, BinStr* pblob) { tkType = tk; pBlob = pblob; tkOwner = tko; tkInterfacePair = 0; };
+    CustomDescr(mdToken tk, BinStr* pblob) { tkType = tk; pBlob = pblob; tkOwner = 0; tkInterfacePair = 0;};
+    CustomDescr(CustomDescr* pOrig) { tkType = pOrig->tkType; pBlob = new BinStr(); pBlob->append(pOrig->pBlob); tkOwner = pOrig->tkOwner; tkInterfacePair = pOrig->tkInterfacePair; };
+    ~CustomDescr() { if(pBlob) delete pBlob; };
+};
+typedef FIFO<CustomDescr> CustomDescrList;
+typedef LIFO<CustomDescrList> CustomDescrListStack;
+/**************************************************************************/
+#include "typar.hpp"
+#include "method.hpp"
+#include "iceefilegen.h"
+#include "asmman.hpp"
+
+#include "nvpair.h"
+
+
+typedef enum
+{
+    STATE_OK,
+    STATE_FAIL,
+    STATE_ENDMETHOD,
+    STATE_ENDFILE
+} state_t;
+
+
+class GlobalLabel
+{
+public:
+    LPCUTF8         m_szName;
+    DWORD           m_GlobalOffset; 
+    HCEESECTION     m_Section;
+    unsigned        m_Hash;
+
+    GlobalLabel(LPCUTF8 pszName, DWORD GlobalOffset, HCEESECTION section)
+    {
+        m_GlobalOffset  = GlobalOffset;
+        m_Section       = section;
+        m_szName = pszName;
+        m_Hash = hash((const BYTE*)pszName, (unsigned)strlen(pszName),10);
+    }
+
+    ~GlobalLabel(){ delete [] m_szName; }
+
+    int ComparedTo(GlobalLabel* L)
+    { 
+        return (m_Hash == L->m_Hash) ? strcmp(m_szName, L->m_szName)
+                                     : ((m_Hash > L->m_Hash) ? 1 : -1);
+    }
+
+    //int ComparedTo(GlobalLabel* L) { return strcmp(m_szName,L->m_szName); };
+    //int Compare(char* L) { return strcmp(L, m_szNam); };
+    //char* NameOf() { return m_szName; };
+};
+//typedef SORTEDARRAY<GlobalLabel> GlobalLabelList;
+typedef RBTREE<GlobalLabel> GlobalLabelList;
+//typedef FIFO_INDEXED<GlobalLabel> GlobalLabelList;
+
+class CeeFileGenWriter;
+class CeeSection;
+
+class BinStr;
+
+/************************************************************************/
+/* represents an object that knows how to report errors back to the user */
+
+class ErrorReporter
+{
+public:
+    virtual void error(const char* fmt, ...) = 0;
+    virtual void warn(const char* fmt, ...) = 0;
+    virtual void msg(const char* fmt, ...) = 0; 
+};
+
+/**************************************************************************/
+/* represents a switch table before the lables are bound */
+
+struct Labels {
+    Labels(__in __nullterminated char* aLabel, Labels* aNext, bool aIsLabel) : Label(aLabel), Next(aNext), isLabel(aIsLabel) {}
+    ~Labels() { if(isLabel && Label) delete [] Label; delete Next; }
+        
+    char*       Label;
+    Labels*     Next;
+    bool        isLabel;
+};
+
+/**************************************************************************/
+/* descriptor of the structured exception handling construct  */
+struct SEH_Descriptor
+{
+    DWORD       sehClause;  // catch/filter/finally
+    DWORD       tryFrom;    // start of try block
+    DWORD       tryTo;      // end of try block
+    DWORD       sehHandler; // start of exception handler
+    DWORD       sehHandlerTo; // end of exception handler
+    union {
+        DWORD       sehFilter;  // start of filter block
+        mdTypeRef   cException; // what to catch
+    };
+
+    SEH_Descriptor()
+    {
+        memset(this, 0, sizeof(*this));
+    }
+};
+
+
+typedef LIFO<char> StringStack;
+typedef LIFO<SEH_Descriptor> SEHD_Stack;
+
+typedef FIFO<Method> MethodList;
+//typedef SORTEDARRAY<Method> MethodSortedList;
+typedef FIFO<mdToken> TokenList;
+/**************************************************************************/
+/* The field, event and property descriptor structures            */
+
+struct FieldDescriptor
+{
+    mdTypeDef       m_tdClass;
+    char*           m_szName;
+    DWORD           m_dwName;
+    mdFieldDef      m_fdFieldTok;
+    ULONG           m_ulOffset;
+    char*           m_rvaLabel;         // if field has RVA associated with it, label for it goes here. 
+    BinStr*         m_pbsSig;
+    Class*			m_pClass;
+    BinStr*			m_pbsValue;
+    BinStr*			m_pbsMarshal;
+	PInvokeDescriptor*	m_pPInvoke;
+    CustomDescrList     m_CustomDescrList;
+    DWORD			m_dwAttr;
+    BOOL            m_fNew;
+    // Security attributes
+    PermissionDecl* m_pPermissions;
+    PermissionSetDecl* m_pPermissionSets;
+    FieldDescriptor()  { m_szName = NULL; m_pbsSig = NULL; m_fNew = TRUE; };
+    ~FieldDescriptor() { if(m_szName) delete [] m_szName; if(m_pbsSig) delete m_pbsSig; };
+};
+typedef FIFO<FieldDescriptor> FieldDList;
+
+struct EventDescriptor
+{
+    mdTypeDef           m_tdClass;
+    char*               m_szName;
+    DWORD               m_dwAttr;
+    mdToken             m_tkEventType;
+    mdToken             m_tkAddOn;
+    mdToken             m_tkRemoveOn;
+    mdToken             m_tkFire;
+    TokenList           m_tklOthers;
+    mdEvent             m_edEventTok;
+    BOOL                m_fNew;
+    CustomDescrList     m_CustomDescrList;
+    ~EventDescriptor() { m_tklOthers.RESET(false); };
+};
+typedef FIFO<EventDescriptor> EventDList;
+
+struct PropDescriptor
+{
+    mdTypeDef           m_tdClass;
+    char*               m_szName;
+    DWORD               m_dwAttr;
+    COR_SIGNATURE*      m_pSig;
+    DWORD               m_dwCSig;
+    DWORD               m_dwCPlusTypeFlag;
+    PVOID               m_pValue;
+    DWORD				m_cbValue;
+    mdToken             m_tkSet;
+    mdToken             m_tkGet;
+    TokenList           m_tklOthers;
+    mdProperty          m_pdPropTok;
+    BOOL                m_fNew;
+    CustomDescrList     m_CustomDescrList;
+    ~PropDescriptor() { m_tklOthers.RESET(false); };
+};
+typedef FIFO<PropDescriptor> PropDList;
+
+struct ImportDescriptor
+{
+    char*   szDllName;
+//    char   szDllName[MAX_FILENAME_LENGTH];
+    DWORD  dwDllName;
+    mdModuleRef mrDll;
+    ImportDescriptor(__in __nullterminated char* sz, DWORD l)
+    {
+        if((sz != NULL)&&(l > 0))
+        {
+            szDllName = new char[l+1];
+            if(szDllName != NULL)
+            {
+                memcpy(szDllName,sz,l);
+                szDllName[l] = 0;
+                dwDllName = l;
+            }
+        }
+        else
+        {
+            szDllName = NULL;
+            dwDllName = 0;
+        }
+    };
+    ~ImportDescriptor() { delete [] szDllName; };
+};
+typedef FIFO<ImportDescriptor> ImportList;
+
+
+/**************************************************************************/
+#include "class.hpp"
+typedef LIFO<Class> ClassStack;
+typedef FIFO<Class> ClassList;
+//typedef SORTEDARRAY<Class> ClassHash;
+typedef RBTREE<Class> ClassHash;
+//typedef FIFO_INDEXED<Class> ClassHash;
+
+/**************************************************************************/
+/* Classes to hold lists of security permissions and permission sets. We build
+   these lists as we find security directives in the input stream and drain
+   them every time we see a class or method declaration (to which the
+   security info is attached). */
+
+class PermissionDecl
+{
+public:
+    PermissionDecl(CorDeclSecurity action, mdToken type, NVPair *pairs)
+    {
+        m_Action = action;
+        m_TypeSpec = type;
+        m_pbsBlob = NULL;
+        BuildConstructorBlob(action, pairs);
+        m_Next = NULL;
+    }
+
+    PermissionDecl(CorDeclSecurity action, mdToken type, BinStr* pbsPairs)
+    {
+        m_Action = action;
+        m_TypeSpec = type;
+        
+        m_pbsBlob = new BinStr();
+        m_pbsBlob->appendInt16(VAL16(1));     // prolog 0x01 0x00
+        m_pbsBlob->appendInt32((int)action);  // 4-byte action
+        if(pbsPairs)                          // name-value pairs if any
+        {
+            if(pbsPairs->length() > 2)
+                m_pbsBlob->appendFrom(pbsPairs,2);
+            delete pbsPairs;
+        }
+        if(m_pbsBlob->length() == 6) // no pairs added
+            m_pbsBlob->appendInt16(0);
+        m_Blob = m_pbsBlob->ptr();
+        m_BlobLength = m_pbsBlob->length();
+        m_Next = NULL;
+    }
+
+    ~PermissionDecl()
+    {
+        if(m_pbsBlob) delete m_pbsBlob;
+        else delete [] m_Blob;
+    }
+
+    CorDeclSecurity     m_Action;
+    mdToken             m_TypeSpec;
+    BYTE               *m_Blob;
+    BinStr             *m_pbsBlob;
+    long                m_BlobLength;
+    PermissionDecl     *m_Next;
+
+private:
+    void BuildConstructorBlob(CorDeclSecurity action, NVPair *pairs)
+    {
+        NVPair *p = pairs;
+        int count = 0;
+        int bytes = 8;
+        int length;
+        int i;
+        BYTE *pBlob;
+
+        // Calculate number of name/value pairs and the memory required for the
+        // custom attribute blob.
+        while (p) {
+            BYTE *pVal = (BYTE*)p->Value()->ptr();
+            count++;
+            bytes += 2; // One byte field/property specifier, one byte type code
+
+            length = (int)strlen((const char *)p->Name()->ptr());
+            bytes += CPackedLen::Size(length) + length;
+
+            switch (pVal[0]) {
+            case SERIALIZATION_TYPE_BOOLEAN:
+                bytes += 1;
+                break;
+            case SERIALIZATION_TYPE_I4:
+                bytes += 4;
+                break;
+            case SERIALIZATION_TYPE_STRING:
+                length = (int)strlen((const char *)&pVal[1]);
+                bytes += CPackedLen::Size(length) + length;
+                break;
+            case SERIALIZATION_TYPE_ENUM:
+                length = (int)strlen((const char *)&pVal[1]);
+                bytes += CPackedLen::Size((ULONG)length) + length;
+                bytes += 4;
+                break;
+            }
+            p = p->Next();
+        }
+
+        m_Blob = new BYTE[bytes];
+        if(m_Blob==NULL)
+        {
+            fprintf(stderr,"\nOut of memory!\n");
+            return;
+        }
+
+        m_Blob[0] = 0x01;           // Version
+        m_Blob[1] = 0x00;
+        m_Blob[2] = (BYTE)action;   // Constructor arg (security action code)
+        m_Blob[3] = 0x00;
+        m_Blob[4] = 0x00;
+        m_Blob[5] = 0x00;
+        m_Blob[6] = (BYTE)count;    // Property/field count
+        m_Blob[7] = (BYTE)(count >> 8);
+
+        for (i = 0, pBlob = &m_Blob[8], p = pairs; i < count; i++, p = p->Next()) {
+            BYTE *pVal = (BYTE*)p->Value()->ptr();
+            char *szType;
+
+            // Set field/property setter type.
+            *pBlob++ = SERIALIZATION_TYPE_PROPERTY;
+
+            // Set type code. There's additional info for enums (the enum class
+            // name).
+            *pBlob++ = pVal[0];
+            if (pVal[0] == SERIALIZATION_TYPE_ENUM) {
+                szType = (char *)&pVal[1];
+                length = (int)strlen(szType);
+                pBlob = (BYTE*)CPackedLen::PutLength(pBlob, length);
+                strcpy_s((char *)pBlob, bytes, szType);
+                pBlob += length;
+            }
+
+            // Record the field/property name.
+            length = (int)strlen((const char *)p->Name()->ptr());
+            pBlob = (BYTE*)CPackedLen::PutLength(pBlob, length);
+            strcpy_s((char *)pBlob, bytes-(pBlob-m_Blob), (const char *)p->Name()->ptr());
+            pBlob += length;
+
+            // Record the serialized value.
+            switch (pVal[0]) {
+            case SERIALIZATION_TYPE_BOOLEAN:
+                *pBlob++ = pVal[1];
+                break;
+            case SERIALIZATION_TYPE_I4:
+                *(__int32*)pBlob = *(__int32*)&pVal[1];
+                pBlob += 4;
+                break;
+            case SERIALIZATION_TYPE_STRING:
+                length = (int)strlen((const char *)&pVal[1]);
+                pBlob = (BYTE*)CPackedLen::PutLength(pBlob, length);
+                strcpy_s((char *)pBlob, bytes-(pBlob-m_Blob), (const char *)&pVal[1]);
+                pBlob += length;
+                break;
+            case SERIALIZATION_TYPE_ENUM:
+                length = (int)strlen((const char *)&pVal[1]);
+                // We can have enums with base type of I1, I2 and I4.
+                switch (pVal[1 + length + 1]) {
+                case 1:
+                    *(__int8*)pBlob = *(__int8*)&pVal[1 + length + 2];
+                    pBlob += 1;
+                    break;
+                case 2:
+                    *(__int16*)pBlob = *(__int16*)&pVal[1 + length + 2];
+                    pBlob += 2;
+                    break;
+                case 4:
+                    *(__int32*)pBlob = *(__int32*)&pVal[1 + length + 2];
+                    pBlob += 4;
+                    break;
+                default:
+                    _ASSERTE(!"Invalid enum size");
+                }
+                break;
+            }
+
+        }
+
+        _ASSERTE((pBlob - m_Blob) == bytes);
+
+        m_BlobLength = (long)bytes;
+    }
+};
+
+class PermissionSetDecl
+{
+public:
+    PermissionSetDecl(CorDeclSecurity action, BinStr *value)
+    {
+        m_Action = action;
+        m_Value = value;
+        m_Next = NULL;
+    }
+
+    ~PermissionSetDecl()
+    {
+        delete m_Value;
+    }
+
+    CorDeclSecurity     m_Action;
+    BinStr             *m_Value;
+    PermissionSetDecl  *m_Next;
+};
+
+struct VTFEntry
+{
+    char*   m_szLabel;
+    WORD    m_wCount;
+    WORD    m_wType;
+    VTFEntry(WORD wCount, WORD wType, __in __nullterminated char* szLabel) { m_wCount = wCount; m_wType = wType; m_szLabel = szLabel; }
+    ~VTFEntry() { delete m_szLabel; }
+};
+typedef FIFO<VTFEntry> VTFList;
+
+struct	EATEntry
+{
+	DWORD	dwStubRVA;
+	DWORD	dwOrdinal;
+	char*	szAlias;
+};
+typedef FIFO<EATEntry> EATList;
+
+struct DocWriter
+{
+    char* Name;
+    ISymUnmanagedDocumentWriter* pWriter;
+    DocWriter() { Name=NULL; pWriter=NULL; };
+    ~DocWriter() { delete [] Name; if(pWriter) pWriter->Release();};
+};
+typedef FIFO<DocWriter> DocWriterList;
+/**************************************************************************/
+/* The assembler object does all the code generation (dealing with meta-data)
+   writing a PE file etc etc. But does NOT deal with syntax (that is what
+   AsmParse is for).  Thus the API below is how AsmParse 'controls' the 
+   Assember.  Note that the Assembler object does know about the 
+   AsmParse object (that is Assember is more fundamental than AsmParse) */
+struct Instr
+{
+    int opcode;
+    unsigned linenum;
+	unsigned column;
+    unsigned linenum_end;
+	unsigned column_end;
+    unsigned pc;
+    ISymUnmanagedDocumentWriter* pWriter;
+};
+#define INSTR_POOL_SIZE 16
+
+// For code folding:
+struct MethodBody
+{
+    BinStr* pbsBody;
+    unsigned RVA;
+    BYTE*   pCode;
+};
+typedef FIFO<MethodBody> MethodBodyList;
+
+struct Clockwork
+{
+    DWORD  cBegin;
+    DWORD  cEnd;
+    DWORD  cParsBegin;
+    DWORD  cParsEnd;
+    DWORD  cMDInitBegin;
+    DWORD  cMDInitEnd;
+    DWORD  cMDEmitBegin;
+    DWORD  cMDEmitEnd;
+    DWORD  cMDEmit1;
+    DWORD  cMDEmit2;
+    DWORD  cMDEmit3;
+    DWORD  cMDEmit4;
+    DWORD  cRef2DefBegin;
+    DWORD  cRef2DefEnd;
+    DWORD  cFilegenBegin;
+    DWORD  cFilegenEnd;
+};
+
+struct TypeDefDescr
+{
+    char* m_szName;
+    union
+    {
+        BinStr* m_pbsTypeSpec;
+        CustomDescr* m_pCA;
+    };
+    mdToken m_tkTypeSpec;
+    TypeDefDescr(__in_opt __nullterminated char *pszName, BinStr* pbsTypeSpec, mdToken tkTypeSpec)
+    {
+        m_szName = pszName;
+        m_pbsTypeSpec = pbsTypeSpec;
+        m_tkTypeSpec = tkTypeSpec;
+    };
+    ~TypeDefDescr() { delete [] m_szName; delete m_pbsTypeSpec; };
+    int ComparedTo(TypeDefDescr* T) { return strcmp(m_szName,T->m_szName); };
+    //int Compare(char* T) { return strcmp(T,m_szName); };
+};
+typedef SORTEDARRAY<TypeDefDescr> TypeDefDList;
+
+struct Indx
+{
+    void* table[128];
+    Indx() { memset(table,0,sizeof(table)); };
+    ~Indx()
+    {
+        for(int i = 1; i < 128; i++) delete ((Indx*)(table[i]));
+    };
+    void IndexString(__in_z __in char* psz, void* pkywd)
+    {
+        int i = (int) *psz;
+        if(i == 0)
+            table[0] = pkywd;
+        else
+        {
+            _ASSERTE((i > 0)&&(i <= 127));
+            Indx* pInd = (Indx*)(table[i]);
+            if(pInd == NULL)
+            {
+                pInd = new Indx;
+                _ASSERTE(pInd);
+                table[i] = pInd;
+            }
+            pInd->IndexString(psz+1,pkywd);
+        }
+    }
+    void*  FindString(__in __nullterminated char* psz)
+    {
+        if(*psz > 0)
+        {
+            unsigned char uch = (unsigned char) *psz;
+            if(table[uch] != NULL)
+                return ((Indx*)(table[uch]))->FindString(psz+1); 
+        }
+        else if(*psz == 0) return table[0];
+        return NULL;
+    }
+};
+
+class Assembler {
+public:
+    Assembler();
+    ~Assembler();
+    //--------------------------------------------------------  
+	GlobalLabelList m_lstGlobalLabel;
+	GlobalFixupList m_lstGlobalFixup;
+
+    LabelList       m_lstLabel;
+
+    Class *			m_pModuleClass;
+    ClassList		m_lstClass;
+    ClassHash		m_hshClass;
+
+    Indx            indxKeywords;
+
+    BYTE *  m_pOutputBuffer;
+    BYTE *  m_pCurOutputPos;
+    BYTE *  m_pEndOutputPos;
+
+
+    DWORD   m_CurPC;
+    BOOL    m_fStdMapping;
+    BOOL    m_fDisplayTraceOutput;
+    BOOL    m_fInitialisedMetaData;
+    BOOL    m_fAutoInheritFromObject;
+    BOOL    m_fReportProgress;
+    BOOL    m_fIsMscorlib;
+    BOOL    m_fTolerateDupMethods;
+    BOOL    m_fENCMode;
+    BOOL    m_fOptimize;
+    mdToken m_tkSysObject;
+    mdToken m_tkSysString;
+    mdToken m_tkSysValue;
+    mdToken m_tkSysEnum;
+    BOOL    m_fDidCoInitialise;
+
+    IMetaDataDispenserEx *m_pDisp;
+    IMetaDataEmit2      *m_pEmitter;
+    ICeeFileGen        *m_pCeeFileGen;
+    IMetaDataImport2    *m_pImporter;			// Import interface.
+    HCEEFILE m_pCeeFile;
+    HCEESECTION m_pGlobalDataSection;
+    HCEESECTION m_pILSection;
+    HCEESECTION m_pTLSSection;
+    HCEESECTION m_pCurSection;      // The section EmitData* things go to
+
+    AsmMan*     m_pManifest;
+
+    char    m_szScopeName[MAX_SCOPE_LENGTH];
+    char    *m_szNamespace; //[MAX_NAMESPACE_LENGTH];
+    char    *m_szFullNS; //[MAX_NAMESPACE_LENGTH];
+	unsigned	m_ulFullNSLen;
+
+    WCHAR   *m_wzMetadataVersion;
+
+    StringStack m_NSstack;
+    mdTypeSpec      m_crExtends;
+
+    //    char    m_szExtendsClause[MAX_CLASSNAME_LENGTH];
+
+    // The (resizable) array of "implements" types
+    mdToken   *m_crImplList;
+    int     m_nImplList;
+    int     m_nImplListSize;
+    
+    TyParList       *m_TyParList;
+    
+    Method *m_pCurMethod;
+    Class   *m_pCurClass;
+    ClassStack m_ClassStack; // for nested classes
+    Class   *dummyClass; // for FindCreateClass
+
+    // moved to Class
+    //MethodList  m_MethodList;
+
+    BOOL    m_fCPlusPlus;
+    BOOL    m_fWindowsCE;
+    BOOL    m_fDLL;
+    BOOL    m_fOBJ;
+    BOOL    m_fEntryPointPresent;
+    BOOL    m_fHaveFieldsWithRvas;
+    BOOL    m_fFoldCode;
+    DWORD   m_dwMethodsFolded;
+
+    state_t m_State;
+
+    BinStr* m_pbsMD;
+
+    Instr   m_Instr[INSTR_POOL_SIZE]; // 16
+    inline  Instr* GetInstr() 
+    {
+        int i;
+        for(i=0; (i<INSTR_POOL_SIZE)&&(m_Instr[i].opcode != -1); i++);
+        if(i<INSTR_POOL_SIZE) return &m_Instr[i];
+        report->error("Instruction pool exhausted: source contains invalid instructions\n");
+        return NULL;
+    }
+    // Labels, fixups and IL fixups are defined in Method.hpp,.cpp
+    void AddLabel(DWORD CurPC, __in __nullterminated char *pszName);
+    void AddDeferredFixup(__in __nullterminated char *pszLabel, BYTE *pBytes, DWORD RelativeToPC, BYTE FixupSize);
+    void AddDeferredILFixup(ILFixupType Kind);
+    void AddDeferredILFixup(ILFixupType Kind, GlobalFixup *GFixup);
+    void DoDeferredILFixups(Method* pMethod);
+    BOOL DoFixups(Method* pMethod);
+    //--------------------------------------------------------------------------------
+    void    ClearImplList(void);
+    void    AddToImplList(mdToken);
+    void    ClearBoundList(void);
+    //--------------------------------------------------------------------------------
+    BOOL Init();
+    void ProcessLabel(__in_z __in char *pszName);
+    GlobalLabel *FindGlobalLabel(LPCUTF8 pszName);
+    GlobalFixup *AddDeferredGlobalFixup(__in __nullterminated char *pszLabel, BYTE* reference);
+    //void AddDeferredDescrFixup(__in __nullterminated char *pszLabel);
+    BOOL DoGlobalFixups();
+    BOOL DoDescrFixups();
+    OPCODE DecodeOpcode(const BYTE *pCode, DWORD *pdwLen);
+    BOOL AddMethod(Method *pMethod);
+    void SetTLSSection() { m_pCurSection = m_pTLSSection; }
+    void SetILSection() { m_pCurSection = m_pILSection; }
+    void SetDataSection()       { m_pCurSection = m_pGlobalDataSection; }
+    BOOL EmitMethod(Method *pMethod);
+    BOOL EmitMethodBody(Method* pMethod, BinStr* pbsOut);
+    BOOL EmitClass(Class *pClass);
+    HRESULT CreatePEFile(__in __nullterminated WCHAR *pwzOutputFilename);
+    HRESULT CreateTLSDirectory();
+    HRESULT CreateDebugDirectory();
+    HRESULT InitMetaData();
+    Class *FindCreateClass(__in __nullterminated char *pszFQN);
+    BOOL EmitFieldRef(__in_z __in char *pszArg, int opcode);
+    BOOL EmitSwitchData(__in_z __in char *pszArg);
+    mdToken ResolveClassRef(mdToken tkResScope, __in __nullterminated char *pszClassName, Class** ppClass);
+    mdToken ResolveTypeSpec(BinStr* typeSpec);
+    mdToken GetBaseAsmRef();
+    mdToken GetAsmRef(__in __nullterminated char* szName);
+    mdToken GetModRef(__in __nullterminated char* szName);
+    mdToken GetInterfaceImpl(mdToken tsClass, mdToken tsInterface);
+    char* ReflectionNotation(mdToken tk);
+    HRESULT ConvLocalSig(__in char* localsSig, CQuickBytes* corSig, DWORD* corSigLen, BYTE*& localTypes);
+    DWORD GetCurrentILSectionOffset();
+    BOOL EmitCALLISig(__in char *p);
+    void AddException(DWORD pcStart, DWORD pcEnd, DWORD pcHandler, DWORD pcHandlerTo, mdTypeRef crException, BOOL isFilter, BOOL isFault, BOOL isFinally);
+    state_t CheckLocalTypeConsistancy(int instr, unsigned arg);
+    state_t AddGlobalLabel(__in __nullterminated char *pszName, HCEESECTION section);
+    void SetDLL(BOOL);
+    void SetOBJ(BOOL);
+    void ResetForNextMethod();
+    void ResetLineNumbers();
+    void SetStdMapping(BOOL val = TRUE) { m_fStdMapping = val; };
+
+    //--------------------------------------------------------------------------------
+    BOOL isShort(unsigned instr) { return ((OpcodeInfo[instr].Type & 16) != 0); };
+    unsigned ShortOf(unsigned opcode);
+    void SetErrorReporter(ErrorReporter* aReport) { report = aReport; if(m_pManifest) m_pManifest->SetErrorReporter(aReport); }
+
+    void StartNameSpace(__in __nullterminated char* name);
+    void EndNameSpace();
+    void StartClass(__in __nullterminated char* name, DWORD attr, TyParList *typars);
+    DWORD CheckClassFlagsIfNested(Class* pEncloser, DWORD attr);
+    void AddClass();
+    void EndClass();
+    void StartMethod(__in __nullterminated char* name, BinStr* sig, CorMethodAttr flags, BinStr* retMarshal, DWORD retAttr, TyParList *typars = NULL);
+    void EndMethod();
+
+    void AddField(__inout_z __inout char* name, BinStr* sig, CorFieldAttr flags, __in __nullterminated char* rvaLabel, BinStr* pVal, ULONG ulOffset);
+	BOOL EmitField(FieldDescriptor* pFD);
+    void EmitByte(int val);
+    //void EmitTry(enum CorExceptionFlag kind, char* beginLabel, char* endLabel, char* handleLabel, char* filterOrClass);
+    void EmitMaxStack(unsigned val);
+    void EmitLocals(BinStr* sig);
+    void EmitEntryPoint();
+    void EmitZeroInit();
+    void SetImplAttr(unsigned short attrval);
+
+    // Emits zeros if the buffer parameter is NULL.
+    void EmitData(__in_opt void *buffer, unsigned len);
+
+    void EmitDD(__in __nullterminated char *str);
+    void EmitDataString(BinStr* str);
+
+    void EmitInstrVar(Instr* instr, int var);
+    void EmitInstrVarByName(Instr* instr, __in __nullterminated char* label);
+    void EmitInstrI(Instr* instr, int val);
+    void EmitInstrI8(Instr* instr, __int64* val);
+    void EmitInstrR(Instr* instr, double* val);
+    void EmitInstrBrOffset(Instr* instr, int offset);
+    void EmitInstrBrTarget(Instr* instr, __in __nullterminated char* label);
+    mdToken MakeMemberRef(mdToken typeSpec, __in __nullterminated char* name, BinStr* sig);
+    mdToken MakeMethodSpec(mdToken tkParent, BinStr* sig);
+    void SetMemberRefFixup(mdToken tk, unsigned opcode_len);
+    mdToken MakeTypeRef(mdToken tkResScope, LPCUTF8 szFullName);
+    void EmitInstrStringLiteral(Instr* instr, BinStr* literal, BOOL ConvertToUnicode, BOOL Swap = FALSE);
+    void EmitInstrSig(Instr* instr, BinStr* sig);
+    void EmitInstrSwitch(Instr* instr, Labels* targets);
+    void EmitLabel(__in __nullterminated char* label);
+    void EmitDataLabel(__in __nullterminated char* label);
+
+    unsigned OpcodeLen(Instr* instr); //returns opcode length
+    // Emit just the opcode (no parameters to the instruction stream.
+    void EmitOpcode(Instr* instr);
+
+    // Emit primitive types to the instruction stream.
+    void EmitBytes(BYTE*, unsigned len);
+
+    ErrorReporter* report;
+
+	BOOL EmitFieldsMethods(Class* pClass);
+	BOOL EmitEventsProps(Class* pClass);
+
+    // named args/vars paraphernalia:
+public:
+    void addArgName(__in_opt __nullterminated char *szNewName, BinStr* pbSig, BinStr* pbMarsh, DWORD dwAttr)
+    {
+        if(pbSig && (*(pbSig->ptr()) == ELEMENT_TYPE_VOID))
+            report->error("Illegal use of type 'void'\n");
+        if(m_lastArgName)
+        {
+            m_lastArgName->pNext = new ARG_NAME_LIST(m_lastArgName->nNum+1,szNewName,pbSig,pbMarsh,dwAttr);
+            m_lastArgName = m_lastArgName->pNext;
+        }
+        else
+        {
+            m_lastArgName = new ARG_NAME_LIST(0,szNewName,pbSig,pbMarsh,dwAttr);
+            m_firstArgName = m_lastArgName;
+        }
+    };
+    ARG_NAME_LIST *getArgNameList(void)
+    { ARG_NAME_LIST *pRet = m_firstArgName; m_firstArgName=NULL; m_lastArgName=NULL; return pRet;};
+    // Added because recursive destructor of ARG_NAME_LIST may overflow the system stack
+    void delArgNameList(ARG_NAME_LIST *pFirst)
+    {
+        ARG_NAME_LIST *pArgList=pFirst, *pArgListNext;
+        for(; pArgList; pArgListNext=pArgList->pNext,
+                        delete pArgList, 
+                        pArgList=pArgListNext);
+    };
+
+    ARG_NAME_LIST   *findArg(ARG_NAME_LIST *pFirst, int num)
+    {
+        ARG_NAME_LIST *pAN;
+        for(pAN=pFirst; pAN; pAN = pAN->pNext)
+        {
+            if(pAN->nNum == num) return pAN;
+        }
+        return NULL;
+    };
+    ARG_NAME_LIST *m_firstArgName;
+    ARG_NAME_LIST *m_lastArgName;
+    void ResetArgNameList();
+
+    // Structured exception handling paraphernalia:
+public:
+    SEH_Descriptor  *m_SEHD;    // current descriptor ptr
+    void NewSEHDescriptor(void); //sets m_SEHD
+    void SetTryLabels(__in __nullterminated char * szFrom, __in __nullterminated char *szTo);
+    void SetFilterLabel(__in __nullterminated char *szFilter);
+    void SetCatchClass(mdToken catchClass);
+    void SetHandlerLabels(__in __nullterminated char *szHandlerFrom, __in __nullterminated char *szHandlerTo);
+    void EmitTry(void);         //uses m_SEHD
+
+//private:
+    SEHD_Stack  m_SEHDstack;
+
+    // Events and Properties paraphernalia:
+public:
+    void EndEvent(void);    //emits event definition
+    void EndProp(void);     //emits property definition
+    void ResetEvent(__inout_z __inout char * szName, mdToken typeSpec, DWORD dwAttr);
+    void ResetProp(__inout_z __inout char * szName, BinStr* bsType, DWORD dwAttr, BinStr* bsValue);
+    void SetEventMethod(int MethodCode, mdToken tk);
+    void SetPropMethod(int MethodCode, mdToken tk);
+    BOOL EmitEvent(EventDescriptor* pED);   // impl. in ASSEM.CPP
+    BOOL EmitProp(PropDescriptor* pPD); // impl. in ASSEM.CPP
+    EventDescriptor*    m_pCurEvent;
+    PropDescriptor*     m_pCurProp;
+
+private:
+    MemberRefDList           m_LocalMethodRefDList;
+    MemberRefDList           m_LocalFieldRefDList;
+    LocalMemberRefFixupList  m_LocalMemberRefFixupList;
+    MethodBodyList           m_MethodBodyList;
+    MemberRefDList           m_MethodSpecList;
+public:
+    HRESULT ResolveLocalMemberRefs();
+    HRESULT DoLocalMemberRefFixups();
+    mdToken ResolveLocalMemberRef(mdToken tok);
+
+    // PInvoke paraphernalia
+public:
+    PInvokeDescriptor*  m_pPInvoke;
+    ImportList  m_ImportList;
+    void SetPinvoke(BinStr* DllName, int Ordinal, BinStr* Alias, int Attrs);
+    HRESULT EmitPinvokeMap(mdToken tk, PInvokeDescriptor* pDescr);
+    ImportDescriptor* EmitImport(BinStr* DllName);
+    void EmitImports();
+
+    // Debug metadata paraphernalia
+public:
+    ISymUnmanagedWriter* m_pSymWriter;
+    ISymUnmanagedDocumentWriter* m_pSymDocument;
+    DocWriterList m_DocWriterList;
+    ULONG m_ulCurLine; // set by Parser
+    ULONG m_ulCurColumn; // set by Parser
+    ULONG m_ulLastDebugLine;
+    ULONG m_ulLastDebugColumn;
+    ULONG m_ulLastDebugLineEnd;
+    ULONG m_ulLastDebugColumnEnd;
+    DWORD m_dwIncludeDebugInfo;
+    BOOL  m_fGeneratePDB;
+    char m_szSourceFileName[MAX_FILENAME_LENGTH*3+1];
+    WCHAR m_wzOutputFileName[MAX_FILENAME_LENGTH];
+    WCHAR m_wzSourceFileName[MAX_FILENAME_LENGTH];
+	GUID	m_guidLang;
+	GUID	m_guidLangVendor;
+	GUID	m_guidDoc;
+
+    // Security paraphernalia
+public:
+    void AddPermissionDecl(CorDeclSecurity action, mdToken type, NVPair *pairs)
+    {
+        PermissionDecl *decl = new PermissionDecl(action, type, pairs);
+        if(decl==NULL)
+        {
+            report->error("\nOut of memory!\n");
+            return;
+        }
+        if (m_pCurMethod) {
+            decl->m_Next = m_pCurMethod->m_pPermissions;
+            m_pCurMethod->m_pPermissions = decl;
+        } else if (m_pCurClass) {
+            decl->m_Next = m_pCurClass->m_pPermissions;
+            m_pCurClass->m_pPermissions = decl;
+        } else if (m_pManifest && m_pManifest->m_pAssembly) {
+            decl->m_Next = m_pManifest->m_pAssembly->m_pPermissions;
+            m_pManifest->m_pAssembly->m_pPermissions = decl;
+        } else {
+            report->error("Cannot declare security permissions without the owner\n");
+            delete decl;
+        }
+    };
+
+    void AddPermissionDecl(CorDeclSecurity action, mdToken type, BinStr *pbsPairs)
+    {
+        PermissionDecl *decl = new PermissionDecl(action, type, pbsPairs);
+        if(decl==NULL)
+        {
+            report->error("\nOut of memory!\n");
+            return;
+        }
+        if (m_pCurMethod) {
+            decl->m_Next = m_pCurMethod->m_pPermissions;
+            m_pCurMethod->m_pPermissions = decl;
+        } else if (m_pCurClass) {
+            decl->m_Next = m_pCurClass->m_pPermissions;
+            m_pCurClass->m_pPermissions = decl;
+        } else if (m_pManifest && m_pManifest->m_pAssembly) {
+            decl->m_Next = m_pManifest->m_pAssembly->m_pPermissions;
+            m_pManifest->m_pAssembly->m_pPermissions = decl;
+        } else {
+            report->error("Cannot declare security permissions without the owner\n");
+            delete decl;
+        }
+    };
+
+    void AddPermissionSetDecl(CorDeclSecurity action, BinStr *value)
+    {
+        PermissionSetDecl *decl = new PermissionSetDecl(action, value);
+        if(decl==NULL)
+        {
+            report->error("\nOut of memory!\n");
+            return;
+        }
+        if (m_pCurMethod) {
+            decl->m_Next = m_pCurMethod->m_pPermissionSets;
+            m_pCurMethod->m_pPermissionSets = decl;
+        } else if (m_pCurClass) {
+            decl->m_Next = m_pCurClass->m_pPermissionSets;
+            m_pCurClass->m_pPermissionSets = decl;
+        } else if (m_pManifest && m_pManifest->m_pAssembly) {
+            decl->m_Next = m_pManifest->m_pAssembly->m_pPermissionSets;
+            m_pManifest->m_pAssembly->m_pPermissionSets = decl;
+        } else {
+            report->error("Cannot declare security permission sets without the owner\n");
+            delete decl;
+        }
+    };
+    void EmitSecurityInfo(mdToken           token,
+                          PermissionDecl*   pPermissions,
+                          PermissionSetDecl*pPermissionSets);
+    
+    HRESULT AllocateStrongNameSignature();
+    HRESULT StrongNameSign();
+    BinStr* EncodeSecAttr(__in __nullterminated char* szReflName, BinStr* pbsSecAttrBlob, unsigned nProps);
+
+    // Custom values paraphernalia:
+public:
+    mdToken m_tkCurrentCVOwner;
+    CustomDescrList* m_pCustomDescrList;
+    CustomDescrListStack m_CustomDescrListStack;
+    CustomDescrList  m_CustomDescrList;
+
+    void DefineCV(CustomDescr* pCD)
+    {
+        if(pCD)
+        {
+            ULONG           cTemp = 0;
+            void *          pBlobBody = NULL;
+            mdToken         cv;
+            mdToken tkOwnerType, tkTypeType = TypeFromToken(pCD->tkType);
+
+            if((tkTypeType != 0x99000000)&&(tkTypeType != 0x98000000))
+            {
+                tkOwnerType = TypeFromToken(pCD->tkOwner);
+                if((tkOwnerType != 0x99000000)&&(tkOwnerType != 0x98000000))
+                {
+                    if(pCD->pBlob)
+                    {
+                        pBlobBody = (void *)(pCD->pBlob->ptr());
+                        cTemp = pCD->pBlob->length();
+                    }
+                    if (pCD->tkInterfacePair)
+                    {
+                        pCD->tkOwner = GetInterfaceImpl(pCD->tkOwner, pCD->tkInterfacePair);
+                    }
+                    m_pEmitter->DefineCustomAttribute(pCD->tkOwner,pCD->tkType,pBlobBody,cTemp,&cv);
+				
+                    delete pCD;
+                    return;
+                }
+            }
+            m_CustomDescrList.PUSH(pCD);
+        }
+    };
+    void EmitCustomAttributes(mdToken tok, CustomDescrList* pCDL)
+    {
+        CustomDescr *pCD;
+        if(pCDL == NULL || RidFromToken(tok)==0) return;
+        while((pCD = pCDL->POP()))
+        {
+            pCD->tkOwner = tok;
+            DefineCV(pCD);
+        }
+    };
+
+    void EmitUnresolvedCustomAttributes(); // implementation: writer.cpp
+    // VTable blob (if any)
+public:
+    BinStr *m_pVTable;
+    // Field marshaling
+    BinStr *m_pMarshal;
+    // VTable fixup list
+    VTFList m_VTFList;
+	// Export Address Table entries list
+	EATList m_EATList;
+	HRESULT CreateExportDirectory();
+	DWORD	EmitExportStub(DWORD dwVTFSlotRVA);
+
+    // Method implementation paraphernalia:
+private:
+    MethodImplDList m_MethodImplDList;
+public:
+    void AddMethodImpl(mdToken tkImplementedTypeSpec, __in __nullterminated char* szImplementedName, BinStr* pImplementedSig, 
+                    mdToken tkImplementingTypeSpec, __in_opt __nullterminated char* szImplementingName, BinStr* pImplementingSig);
+    BOOL EmitMethodImpls();
+    // lexical scope handling paraphernalia:
+    void EmitScope(Scope* pSCroot); // struct Scope - see Method.hpp
+    // source file name paraphernalia
+    BOOL m_fSourceFileSet;
+    void SetSourceFileName(__in __nullterminated char* szName);
+    void SetSourceFileName(BinStr* pbsName);
+    // header flags
+    DWORD   m_dwSubsystem;
+    WORD    m_wSSVersionMajor;
+    WORD    m_wSSVersionMinor;
+    DWORD   m_dwComImageFlags;
+	DWORD	m_dwFileAlignment;
+	ULONGLONG	m_stBaseAddress;
+    size_t  m_stSizeOfStackReserve;
+    DWORD   m_dwCeeFileFlags;
+    WORD    m_wMSVmajor;
+    WORD    m_wMSVminor;
+    BOOL    m_fAppContainer;
+    BOOL    m_fHighEntropyVA;
+
+    // Former globals
+    WCHAR *m_wzResourceFile;
+    WCHAR *m_wzKeySourceName;
+    bool OnErrGo;
+    void SetCodePage(unsigned val) { g_uCodePage = val; };
+    Clockwork* bClock;
+    void SetClock(Clockwork* val) { bClock = val; };
+    // ENC paraphernalia
+    HRESULT InitMetaDataForENC(__in __nullterminated WCHAR* wzOrigFileName);
+    BOOL EmitFieldsMethodsENC(Class* pClass);
+    BOOL EmitEventsPropsENC(Class* pClass);
+    HRESULT CreateDeltaFiles(__in __nullterminated WCHAR *pwzOutputFilename);
+
+    // Syntactic sugar paraphernalia
+private:
+    TypeDefDList m_TypeDefDList;
+public:
+    void AddTypeDef(BinStr* pbsTypeSpec, __in_z __in char* szName)
+    {
+        m_TypeDefDList.PUSH(new TypeDefDescr(szName, pbsTypeSpec, ResolveTypeSpec(pbsTypeSpec)));
+    };
+    void AddTypeDef(mdToken tkTypeSpec, __in_z __in char* szName)
+    {
+        m_TypeDefDList.PUSH(new TypeDefDescr(szName, NULL, tkTypeSpec));
+    };
+    void AddTypeDef(CustomDescr* pCA, __in_z __in char* szName)
+    {
+        TypeDefDescr* pNew = new TypeDefDescr(szName,NULL,mdtCustomAttribute);
+        pNew->m_pCA = pCA;
+        m_TypeDefDList.PUSH(pNew);
+    };
+    TypeDefDescr* FindTypeDef(__in_z __in char* szName)
+    {
+        CHECK_LOCAL_STATIC_VAR(static TypeDefDescr X(NULL, NULL, 0));
+
+        X.m_szName = szName;
+        TypeDefDescr* Y = m_TypeDefDList.FIND(&X);
+        X.m_szName = NULL; // to avoid deletion when X goes out of scope
+        return Y;
+        //return m_TypeDefDList.FIND(szName);
+    };
+    unsigned NumTypeDefs() {return m_TypeDefDList.COUNT();};
+private:
+    HRESULT GetCAName(mdToken tkCA, __out LPWSTR *ppszName);
+    HRESULT GetSignatureKey();
+};
+
+#endif  // Assember_h
+
+#ifdef _MSC_VER
+#pragma warning(default : 4640)
+#endif
+
+
diff --git a/src/ilasm/MscorpeSxS.cpp b/src/ilasm/MscorpeSxS.cpp
new file mode 100644
index 0000000000..c10d772c6b
--- /dev/null
+++ b/src/ilasm/MscorpeSxS.cpp
@@ -0,0 +1,24 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+// 
+// File: MscorpeSxS.cpp
+// 
+
+// 
+// This file defines a wrapper for SxS version of mscorpe.dll (dynamically loaded via shim).
+// 
+#include "ilasmpch.h"
+
+#include "MscorpeSxS.h"
+
+#include <LegacyActivationShim.h>
+
+// Loads mscorpe.dll (uses shim)
+HRESULT 
+LoadMscorpeDll(HMODULE * phModule)
+{
+    // Load SxS version of mscorpe.dll (i.e. mscorpehost.dll) and initialize it
+    return LegacyActivationShim::LoadLibraryShim(L"mscorpe.dll", NULL, NULL, phModule);
+}
diff --git a/src/ilasm/MscorpeSxS.h b/src/ilasm/MscorpeSxS.h
new file mode 100644
index 0000000000..92b15b76da
--- /dev/null
+++ b/src/ilasm/MscorpeSxS.h
@@ -0,0 +1,21 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+// 
+// File: MscorpeSxS.h
+// 
+
+// 
+// This file defines a wrapper for SxS version of mscorpe.dll (dynamically loaded via shim).
+// 
+
+#pragma once
+
+#include <MscorpeSxSWrapper.h>
+
+// Loads mscorpe.dll (uses shim)
+HRESULT LoadMscorpeDll(HMODULE * phModule);
+
+// Wrapper for mscorpe.dll calls
+typedef MscorpeSxSWrapper<LoadMscorpeDll> MscorpeSxS;
diff --git a/src/ilasm/Native.rc b/src/ilasm/Native.rc
new file mode 100644
index 0000000000..41216be0ed
--- /dev/null
+++ b/src/ilasm/Native.rc
@@ -0,0 +1,9 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+
+#define FX_VER_FILEDESCRIPTION_STR "Microsoft .NET Framework IL assembler\0"
+
+#include <fxver.h>
+#include <fxver.rc>
diff --git a/src/ilasm/asmenum.h b/src/ilasm/asmenum.h
new file mode 100644
index 0000000000..b8bd49966e
--- /dev/null
+++ b/src/ilasm/asmenum.h
@@ -0,0 +1,42 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+#ifndef __asmenum_h__
+#define __asmenum_h__
+
+#include "openum.h"
+
+typedef struct
+{
+    char *  pszName;
+    OPCODE  op;
+
+    BYTE    Type;   // Inline0 etc.
+
+    BYTE    Len;    // std mapping
+    BYTE    Std1;
+    BYTE    Std2;
+} opcodeinfo_t;
+
+#ifdef DECLARE_DATA
+opcodeinfo_t OpcodeInfo[] =
+{
+#define OPALIAS(c,s,real) { s, real, 0, 0, 0, 0 },
+#define OPDEF(c,s,pop,push,args,type,l,s1,s2,ctrl) { s, c, args,l,s1,s2 },
+#include "opcode.def"
+#undef OPDEF
+#undef OPALIAS
+};
+
+unsigned  OpcodeInfoLen = sizeof(OpcodeInfo) / sizeof(opcodeinfo_t);
+#else
+extern opcodeinfo_t OpcodeInfo[];
+extern unsigned OpcodeInfoLen;
+#endif
+
+
+
+#endif /* __openum_h__ */
+
+
diff --git a/src/ilasm/asmman.cpp b/src/ilasm/asmman.cpp
new file mode 100644
index 0000000000..c4aa0e51ed
--- /dev/null
+++ b/src/ilasm/asmman.cpp
@@ -0,0 +1,1264 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// asmman.cpp - manifest info handling (implementation of class AsmMan, see asmman.hpp)
+//
+
+//
+#include "ilasmpch.h"
+
+#include "assembler.h"
+#include "strongname.h"
+#include "LegacyActivationShim.h"
+#include <limits.h>
+#include <fusion.h>
+
+extern WCHAR*   pwzInputFiles[];
+
+BinStr* BinStrToUnicode(BinStr* pSource, bool Swap)
+{
+    if(pSource)
+    {
+        pSource->appendInt8(0);
+        BinStr* tmp = new BinStr();
+        char*   pb = (char*)(pSource->ptr());
+        int l=pSource->length(), L = sizeof(WCHAR)*l;
+        if(tmp)
+        {
+            WCHAR*  wz = (WCHAR*)(tmp->getBuff(L));
+            if(wz)
+            {
+                memset(wz,0,L);
+                WszMultiByteToWideChar(g_uCodePage,0,pb,-1,wz,l);
+                tmp->remove(L-(DWORD)wcslen(wz)*sizeof(WCHAR));
+#if BIGENDIAN
+                if (Swap)
+                    SwapStringLength(wz, (DWORD)wcslen(wz));
+#endif
+                delete pSource;
+            }
+            else
+            {
+                delete tmp;
+                tmp = NULL;
+                fprintf(stderr,"\nOut of memory!\n");
+            }
+        }
+        else
+            fprintf(stderr,"\nOut of memory!\n");
+        return tmp;
+    }
+    return NULL;
+}
+
+AsmManFile*         AsmMan::GetFileByName(__in __nullterminated char* szFileName)
+{
+    AsmManFile* ret = NULL;
+    if(szFileName)
+    {
+        //AsmManFile X;
+        //X.szName = szFileName;
+        //ret = m_FileLst.FIND(&X);
+        //X.szName = NULL;
+        for(int i=0; (ret = m_FileLst.PEEK(i))&&strcmp(ret->szName,szFileName); i++);
+    }
+    return ret;
+}
+
+mdToken             AsmMan::GetFileTokByName(__in __nullterminated char* szFileName)
+{
+    AsmManFile* tmp = GetFileByName(szFileName);
+    return(tmp ? tmp->tkTok : mdFileNil);
+}
+
+AsmManComType*          AsmMan::GetComTypeByName(__in_opt __nullterminated char* szComTypeName,
+                                                 __in_opt __nullterminated char* szComEnclosingTypeName)
+{
+    AsmManComType*  ret = NULL;
+    if(szComTypeName)
+    {
+        //AsmManComType X;
+        //X.szName = szComTypeName;
+        //ret = m_ComTypeLst.FIND(&X);
+        //X.szName = NULL;
+        for(int i=0; (ret = m_ComTypeLst.PEEK(i)) != NULL; i++)
+        {
+            if (strcmp(ret->szName, szComTypeName) == 0)
+            {
+                if (ret->szComTypeName == NULL && szComEnclosingTypeName == NULL)
+                {
+                    break;
+                }
+
+                if (ret->szComTypeName != NULL && szComEnclosingTypeName != NULL)
+                {
+                    if (strcmp(ret->szComTypeName, szComEnclosingTypeName) == 0)
+                    {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return ret;
+}
+
+mdToken             AsmMan::GetComTypeTokByName(
+    __in_opt __nullterminated char* szComTypeName,
+    __in_opt __nullterminated char* szComEnclosingTypeName)
+{
+    AsmManComType* tmp = GetComTypeByName(szComTypeName, szComEnclosingTypeName);
+    return(tmp ? tmp->tkTok : mdExportedTypeNil);
+}
+
+AsmManAssembly*     AsmMan::GetAsmRefByName(__in __nullterminated char* szAsmRefName)
+{
+    AsmManAssembly* ret = NULL;
+    if(szAsmRefName)
+    {
+        //AsmManAssembly X;
+        //X.szAlias = szAsmRefName;
+        //ret = m_AsmRefLst.FIND(&X);
+        //X.szAlias = NULL;
+        DWORD L = (DWORD)strlen(szAsmRefName);
+        for(int i=0; (ret = m_AsmRefLst.PEEK(i))&&
+            ((ret->dwAlias != L)||strcmp(ret->szAlias,szAsmRefName)); i++);
+    }
+    return ret;
+}
+mdToken             AsmMan::GetAsmRefTokByName(__in __nullterminated char* szAsmRefName)
+{
+    AsmManAssembly* tmp = GetAsmRefByName(szAsmRefName);
+    return(tmp ? tmp->tkTok : mdAssemblyRefNil);
+}
+//==============================================================================================================
+void    AsmMan::SetModuleName(__inout_opt __nullterminated char* szName)
+{
+    if(m_szScopeName == NULL)    // ignore all duplicate declarations
+    {
+        if(szName && *szName)
+        {
+            ULONG L = (ULONG)strlen(szName);
+            if(L >= MAX_SCOPE_LENGTH)
+            {
+                ((Assembler*)m_pAssembler)->report->warn("Module name too long (%d chars, max.allowed: %d chars), truncated\n",L,MAX_SCOPE_LENGTH-1);
+                szName[MAX_SCOPE_LENGTH-1] = 0;
+            }
+            m_szScopeName = szName;
+            strcpy_s(((Assembler*)m_pAssembler)->m_szScopeName, MAX_SCOPE_LENGTH, szName);
+        }
+    }
+}
+//==============================================================================================================
+// Borrowed from VM\assembly.cpp
+
+HRESULT GetHash(__in LPWSTR moduleName,
+                          ALG_ID iHashAlg,
+                          BYTE** pbCurrentValue,  // should be NULL
+                          DWORD *cbCurrentValue)
+{
+    HRESULT     hr = E_FAIL;
+    HCRYPTPROV  hProv = 0;
+    HCRYPTHASH  hHash = 0;
+    DWORD       dwCount = sizeof(DWORD);
+    PBYTE       pbBuffer = NULL;
+    DWORD       dwBufferLen;
+    HANDLE      hFile = INVALID_HANDLE_VALUE;
+    HANDLE      hMapFile = NULL;
+    
+    hFile = WszCreateFile(moduleName, GENERIC_READ, FILE_SHARE_READ,
+                         0, OPEN_EXISTING, 0, 0);
+    if (hFile == INVALID_HANDLE_VALUE) return E_FAIL;
+
+    dwBufferLen = SafeGetFileSize(hFile,NULL);
+    if (dwBufferLen == 0xffffffff)
+    {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        goto exit;
+    }
+    hMapFile = WszCreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
+    if (hMapFile == NULL) goto exit;
+
+    pbBuffer = (PBYTE) MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
+    if (pbBuffer == NULL) goto exit;
+
+    // No need to late bind this stuff, all these crypto API entry points happen
+    // to live in ADVAPI32.
+
+    if ((!WszCryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) ||
+        (!CryptCreateHash(hProv, iHashAlg, 0, 0, &hHash)) ||
+        (!CryptHashData(hHash, pbBuffer, dwBufferLen, 0)) ||
+        (!CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE *) cbCurrentValue, 
+                            &dwCount, 0))) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        goto exit;
+    }
+
+    *pbCurrentValue = new BYTE[*cbCurrentValue];
+    if (!(*pbCurrentValue)) {
+        hr = E_OUTOFMEMORY;
+        goto exit;
+    }
+
+    if(!CryptGetHashParam(hHash, HP_HASHVAL, *pbCurrentValue, cbCurrentValue, 0)) {
+        hr = HRESULT_FROM_WIN32(GetLastError());
+        delete[] *pbCurrentValue;
+        *pbCurrentValue = 0;
+        goto exit;
+    }
+
+    hr = S_OK;
+
+ exit:
+    if (pbBuffer) UnmapViewOfFile(pbBuffer);
+    if (hMapFile) CloseHandle(hMapFile); 
+    CloseHandle(hFile);
+    if (hHash)
+        CryptDestroyHash(hHash);
+    if (hProv)
+        CryptReleaseContext(hProv, 0);
+
+    return hr;
+}
+//==============================================================================================================
+
+void    AsmMan::AddFile(__in __nullterminated char* szName, DWORD dwAttr, BinStr* pHashBlob)
+{
+    AsmManFile* tmp = GetFileByName(szName);
+    Assembler* pAsm = (Assembler*)m_pAssembler;
+    if(tmp==NULL)
+    {
+        tmp = new AsmManFile;
+        if(tmp==NULL)
+        {
+            pAsm->report->error("\nOut of memory!\n");
+            return;
+        }
+        memset(tmp,0,sizeof(AsmManFile));
+        if((dwAttr & 0x80000000)!=0) pAsm->m_fEntryPointPresent = TRUE;
+        tmp->szName = szName;
+        tmp->dwAttr = dwAttr;
+        tmp->pHash = pHashBlob;
+        tmp->m_fNew = TRUE;
+        m_FileLst.PUSH(tmp);
+        tmp->tkTok = TokenFromRid(m_FileLst.COUNT(),mdtFile);
+    }
+    pAsm->m_tkCurrentCVOwner = 0;
+    if(tmp) pAsm->m_pCustomDescrList = &(tmp->m_CustomDescrList);
+}
+//==============================================================================================================
+
+void    AsmMan::EmitFiles()
+{
+    AsmManFile* tmp;
+    Assembler* pAsm = (Assembler*)m_pAssembler;
+    int i;
+    HRESULT                 hr = S_OK;
+    mdToken tk;
+    for(i = 0; (tmp=m_FileLst.PEEK(i)) != NULL; i++)
+    {
+        BOOL    fEntry = ((tmp->dwAttr & 0x80000000)!=0);
+
+        wzUniBuf[0] = 0;
+
+        BYTE*       pHash=NULL;
+        DWORD       cbHash= 0;
+
+        if(!tmp->m_fNew) continue;
+        tmp->m_fNew = FALSE;
+
+        WszMultiByteToWideChar(g_uCodePage,0,tmp->szName,-1,wzUniBuf,dwUniBuf);
+        if(tmp->pHash==NULL) // if hash not explicitly specified
+        {
+            if(m_pAssembly      // and assembly is defined
+                && m_pAssembly->ulHashAlgorithm) // and hash algorithm is defined...
+            { // then try to compute it
+                if(FAILED(GetHash(wzUniBuf,(ALG_ID)(m_pAssembly->ulHashAlgorithm),&pHash,&cbHash)))
+                {
+                    pHash = NULL;
+                    cbHash = 0;
+                }
+                else
+                {
+                    tmp->pHash = new BinStr(pHash,cbHash);
+                }
+            }
+        }
+        else 
+        {
+            pHash = tmp->pHash->ptr();
+            cbHash = tmp->pHash->length();
+        }
+
+        hr = m_pAsmEmitter->DefineFile(wzUniBuf,
+                                    (const void*)pHash,
+                                    cbHash,
+                                    tmp->dwAttr & 0x7FFFFFFF,
+                                    (mdFile*)&tk);
+        _ASSERTE(tk == tmp->tkTok);
+        if(FAILED(hr)) report->error("Failed to define file '%s': 0x%08X\n",tmp->szName,hr);
+        else
+        {
+            if(fEntry)
+            {
+                if (FAILED(pAsm->m_pCeeFileGen->SetEntryPoint(pAsm->m_pCeeFile, tmp->tkTok)))
+                {
+                    pAsm->report->error("Failed to set external entry point for file '%s'\n",tmp->szName);
+                }
+            }
+            pAsm->EmitCustomAttributes(tmp->tkTok, &(tmp->m_CustomDescrList));
+        }
+    } //end for(i = 0; tmp=m_FileLst.PEEK(i); i++)
+}
+
+void    AsmMan::StartAssembly(__in __nullterminated char* szName, __in_opt __nullterminated char* szAlias, DWORD dwAttr, BOOL isRef)
+{
+    if(!isRef && (0==strcmp(szName,"mscorlib"))) ((Assembler*)m_pAssembler)->m_fIsMscorlib = TRUE;
+    if(!isRef && (m_pAssembly != NULL))
+    {
+        if(strcmp(szName, m_pAssembly->szName))
+            report->error("Multiple assembly declarations\n");
+        // if name is the same, just ignore it
+        m_pCurAsmRef = NULL;
+    }
+    else
+    {
+        if((m_pCurAsmRef = new AsmManAssembly))
+        {
+            memset(m_pCurAsmRef,0,sizeof(AsmManAssembly));
+            m_pCurAsmRef->usVerMajor = (USHORT)0xFFFF;
+            m_pCurAsmRef->usVerMinor = (USHORT)0xFFFF;
+            m_pCurAsmRef->usBuild = (USHORT)0xFFFF;
+            m_pCurAsmRef->usRevision = (USHORT)0xFFFF;
+            m_pCurAsmRef->szName = szName;
+            m_pCurAsmRef->szAlias = szAlias ? szAlias : szName;
+            m_pCurAsmRef->dwAlias = (DWORD)strlen(m_pCurAsmRef->szAlias);
+            m_pCurAsmRef->dwAttr = dwAttr;
+            m_pCurAsmRef->isRef = isRef;
+            m_pCurAsmRef->isAutodetect = FALSE;
+            m_pCurAsmRef->m_fNew = TRUE;
+            if(!isRef) m_pAssembly = m_pCurAsmRef;
+        }
+        else
+            report->error("Failed to allocate AsmManAssembly structure\n");
+    }
+    ((Assembler*)m_pAssembler)->m_tkCurrentCVOwner = 0;
+    ((Assembler*)m_pAssembler)->m_CustomDescrListStack.PUSH(((Assembler*)m_pAssembler)->m_pCustomDescrList);
+    ((Assembler*)m_pAssembler)->m_pCustomDescrList = m_pCurAsmRef ? &(m_pCurAsmRef->m_CustomDescrList) : NULL;
+
+}
+// copied from asmparse.y
+static void corEmitInt(BinStr* buff, unsigned data) 
+{
+    unsigned cnt = CorSigCompressData(data, buff->getBuff(5));
+    buff->remove(5 - cnt);
+}
+
+void AsmMan::EmitDebuggableAttribute(mdToken tkOwner)
+{
+    mdToken tkCA;
+    Assembler* pAsm = (Assembler*)m_pAssembler;
+    mdToken tkTypeSpec, tkMscorlib, tkParamType;
+    BinStr  *pbsSig = new BinStr();
+    BinStr* bsBytes = new BinStr();;
+    char*   szName;
+    tkMscorlib = pAsm->m_fIsMscorlib ? 1 : pAsm->GetBaseAsmRef();
+    tkTypeSpec = pAsm->ResolveClassRef(tkMscorlib,"System.Diagnostics.DebuggableAttribute",NULL);
+
+    EmitAssemblyRefs(); // just in case we gained 'mscorlib' AsmRef in GetAsmRef above
+
+    BOOL fOldStyle = FALSE;
+    if(tkMscorlib == 1)
+        fOldStyle = (m_pAssembly->usVerMajor == 1);
+    else
+    {
+        AsmManAssembly *pAssembly = GetAsmRefByName("mscorlib");
+        _ASSERTE(pAssembly != NULL);
+        PREFIX_ASSUME(pAssembly != NULL);
+        fOldStyle = (pAssembly->usVerMajor == 1);
+    }
+
+    bsBytes->appendInt8(1);
+    bsBytes->appendInt8(0);
+    if(fOldStyle)
+    {
+        pbsSig->appendInt8(IMAGE_CEE_CS_CALLCONV_HASTHIS);
+        corEmitInt(pbsSig,2);
+        pbsSig->appendInt8(ELEMENT_TYPE_VOID);
+        pbsSig->appendInt8(ELEMENT_TYPE_BOOLEAN);
+        pbsSig->appendInt8(ELEMENT_TYPE_BOOLEAN);
+
+        //New to old: 0x101->(true,true),0x03->(true,false),0x103->(true,true)+warning
+        bsBytes->appendInt8(1);
+        bsBytes->appendInt8((pAsm->m_dwIncludeDebugInfo==0x03 ? 0 : 1));
+        if(pAsm->m_dwIncludeDebugInfo == 0x103)
+        {
+            report->warn("\nOption /DEBUG=IMPL is invalid for legacy DebuggableAttribute, /DEBUG used.\n" );
+        }
+    }
+    else
+    {
+        BinStr  bsSigArg;
+        char buffer[80];
+        sprintf_s(buffer,80, 
+                "%s%c%s",
+                "System.Diagnostics.DebuggableAttribute",
+                NESTING_SEP,
+                "DebuggingModes"
+               );
+
+        tkParamType = pAsm->ResolveClassRef(tkMscorlib,buffer, NULL);
+
+        bsSigArg.appendInt8(ELEMENT_TYPE_VALUETYPE);
+
+        unsigned cnt = CorSigCompressToken(tkParamType, bsSigArg.getBuff(5));
+        bsSigArg.remove(5 - cnt);
+
+        pbsSig->appendInt8(IMAGE_CEE_CS_CALLCONV_HASTHIS);
+        corEmitInt(pbsSig,1);
+        pbsSig->appendInt8(ELEMENT_TYPE_VOID);
+        pbsSig->append(&bsSigArg);
+
+        bsBytes->appendInt32(pAsm->m_dwIncludeDebugInfo);
+    }
+    bsBytes->appendInt8(0);
+    bsBytes->appendInt8(0);
+
+    szName = new char[16];
+    strcpy_s(szName,16,".ctor");
+    tkCA = pAsm->MakeMemberRef(tkTypeSpec,szName,pbsSig);
+    pAsm->DefineCV(new CustomDescr(tkOwner,tkCA,bsBytes));
+}
+
+void    AsmMan::EndAssembly()
+{
+    if(m_pCurAsmRef)
+    {
+        if(m_pCurAsmRef->isRef)
+        { // list the assembly ref
+            if(GetAsmRefByName(m_pCurAsmRef->szAlias))
+            {
+                //report->warn("Multiple declarations of Assembly Ref '%s', ignored except the 1st one\n",m_pCurAsmRef->szName);
+                delete m_pCurAsmRef;
+                m_pCurAsmRef = NULL;
+                return;
+            }
+            if(m_pCurAsmRef->isAutodetect)
+            {
+                IAssemblyName* pIAsmName;
+                HRESULT hr;
+                // Convert name to Unicode
+                WszMultiByteToWideChar(g_uCodePage,0,m_pCurAsmRef->szName,-1,wzUniBuf,dwUniBuf);
+                hr = CreateAssemblyNameObject(&pIAsmName,wzUniBuf,CANOF_PARSE_DISPLAY_NAME,NULL);
+                if(SUCCEEDED(hr))
+                {
+                    // set enumeration criteria: what is known about AsmRef (besides name)
+                    if(m_pCurAsmRef->usVerMajor != (USHORT)0xFFFF)
+                        pIAsmName->SetProperty(ASM_NAME_MAJOR_VERSION,&(m_pCurAsmRef->usVerMajor),2);
+                    if(m_pCurAsmRef->usVerMinor != (USHORT)0xFFFF)
+                        pIAsmName->SetProperty(ASM_NAME_MINOR_VERSION,&(m_pCurAsmRef->usVerMinor),2);
+                    if(m_pCurAsmRef->usBuild != (USHORT)0xFFFF)
+                        pIAsmName->SetProperty(ASM_NAME_BUILD_NUMBER,&(m_pCurAsmRef->usBuild),2);
+                    if(m_pCurAsmRef->usRevision != (USHORT)0xFFFF)
+                        pIAsmName->SetProperty(ASM_NAME_REVISION_NUMBER,&(m_pCurAsmRef->usRevision),2);
+                    if(m_pCurAsmRef->pPublicKeyToken)
+                        pIAsmName->SetProperty(ASM_NAME_PUBLIC_KEY_TOKEN,
+                                               m_pCurAsmRef->pPublicKeyToken->ptr(),
+                                               m_pCurAsmRef->pPublicKeyToken->length());
+                    if(m_pCurAsmRef->pLocale)
+                        pIAsmName->SetProperty(ASM_NAME_CULTURE,
+                                               m_pCurAsmRef->pLocale->ptr(),
+                                               m_pCurAsmRef->pLocale->length());
+
+                    // enumerate assemblies
+                    IAssemblyEnum* pIAsmEnum = NULL;
+                    hr = CreateAssemblyEnum(&pIAsmEnum, NULL, pIAsmName, ASM_CACHE_GAC, NULL);
+                    if(SUCCEEDED(hr))
+                    {
+                        IAssemblyName* pIAsmNameFound;
+                        IAssemblyName* pIAsmNameLatestVer = NULL;
+                        ULONGLONG   ullVer=0, ullVerLatest=0;
+                        DWORD  dwVerHi, dwVerLo;
+    
+                        // find the latest and greatest, if any
+                        for(;;)
+                        {
+                            pIAsmNameFound = NULL;
+                            hr = pIAsmEnum->GetNextAssembly(NULL,&pIAsmNameFound,0); 
+                            if(SUCCEEDED(hr) && pIAsmNameFound)
+                            {
+    
+                                pIAsmNameFound->GetVersion(&dwVerHi,&dwVerLo);
+                                ullVer = (ULONGLONG)dwVerHi;
+                                ullVer <<= sizeof(DWORD);
+                                ullVer |= dwVerLo;
+                                if(ullVer > ullVerLatest)
+                                {
+                                    if(pIAsmNameLatestVer)
+                                       pIAsmNameLatestVer->Release(); 
+                                    ullVerLatest = ullVer;
+                                    pIAsmNameLatestVer = pIAsmNameFound;
+                                }
+                                else
+                                    pIAsmNameFound->Release();
+                            }
+                            else break;
+                        }
+                        // if found, fill the gaps
+                        if(pIAsmNameLatestVer)
+                        {
+                            DWORD cbSize=0;
+                            USHORT usDummy=0;
+
+                            if(m_pCurAsmRef->pPublicKeyToken == NULL)
+                            {
+                                cbSize = 1024;
+                                pIAsmNameLatestVer->GetProperty(ASM_NAME_PUBLIC_KEY_TOKEN,
+                                                wzUniBuf, &cbSize);
+                                if(cbSize)
+                                {
+                                    if((m_pCurAsmRef->pPublicKeyToken = new BinStr()))
+                                        memcpy(m_pCurAsmRef->pPublicKeyToken->getBuff(cbSize),
+                                            wzUniBuf, cbSize);
+                                }
+                            }
+    
+                            if(m_pCurAsmRef->usVerMajor == (USHORT)0xFFFF)
+                            {
+                                cbSize = (DWORD)sizeof(WORD);
+                                pIAsmNameLatestVer->GetProperty(ASM_NAME_MAJOR_VERSION,
+                                                &usDummy, &cbSize);
+                                m_pCurAsmRef->usVerMajor = usDummy;
+                            }
+                            if(m_pCurAsmRef->usVerMinor == (USHORT)0xFFFF)
+                            {
+                                cbSize = (DWORD)sizeof(WORD);
+                                pIAsmNameLatestVer->GetProperty(ASM_NAME_MINOR_VERSION,
+                                                &usDummy, &cbSize);
+                                m_pCurAsmRef->usVerMinor = usDummy;
+                            }
+                            if(m_pCurAsmRef->usBuild == (USHORT)0xFFFF)
+                            {
+                                cbSize = (DWORD)sizeof(WORD);
+                                pIAsmNameLatestVer->GetProperty(ASM_NAME_BUILD_NUMBER,
+                                                &usDummy, &cbSize);
+                                m_pCurAsmRef->usBuild = usDummy;
+                            }
+                            if(m_pCurAsmRef->usRevision == (USHORT)0xFFFF)
+                            {
+                                cbSize = (DWORD)sizeof(WORD);
+                                pIAsmNameLatestVer->GetProperty(ASM_NAME_REVISION_NUMBER,
+                                                &usDummy, &cbSize);
+                                m_pCurAsmRef->usRevision = usDummy;
+                            }
+                            
+                            if(m_pCurAsmRef->pLocale == NULL)
+                            {
+                                cbSize = 1024;
+                                pIAsmNameLatestVer->GetProperty(ASM_NAME_CULTURE,
+                                                wzUniBuf, &cbSize);
+
+                                if(cbSize > (DWORD)sizeof(WCHAR))
+                                {
+                                    if((m_pCurAsmRef->pLocale = new BinStr()))
+                                        memcpy(m_pCurAsmRef->pLocale->getBuff(cbSize),
+                                            wzUniBuf, cbSize);
+                                }
+                            }
+                            pIAsmNameLatestVer->Release(); 
+                        }
+                        else
+                            report->warn("Failed to autodetect assembly '%s'\n",m_pCurAsmRef->szName);
+                        // if no assembly found, leave it as is, it might be not a GAC assembly
+    
+                        pIAsmEnum->Release();
+                    }
+                    else
+                        report->error("Failed to enum assemblies %S, hr=0x%08X\n",wzUniBuf,hr);
+                    pIAsmName->Release();
+                }
+                else
+                    report->error("Failed to create assembly name object for %S, hr=0x%08X\n",wzUniBuf,hr);
+            } // end if isAutodetect
+            m_AsmRefLst.PUSH(m_pCurAsmRef);
+            m_pCurAsmRef->tkTok = TokenFromRid(m_AsmRefLst.COUNT(),mdtAssemblyRef);
+        }
+        else
+        {
+            HRESULT                 hr = S_OK;
+            m_pCurAsmRef->tkTok = TokenFromRid(1,mdtAssembly);
+            // Determine the strong name public key. This may have been set
+            // via a directive in the source or from the command line (which
+            // overrides the directive). From the command line we may have
+            // been provided with a file or the name of a CAPI key
+            // container. Either may contain a public key or a full key
+            // pair.
+            if (((Assembler*)m_pAssembler)->m_wzKeySourceName)
+            {
+                // Key file versus container is determined by the first
+                // character of the source ('@' for container).
+                if (*(((Assembler*)m_pAssembler)->m_wzKeySourceName) == L'@')
+                {
+                    // Extract public key from container (works whether
+                    // container has just a public key or an entire key
+                    // pair).
+                    m_sStrongName.m_wzKeyContainer = &((Assembler*)m_pAssembler)->m_wzKeySourceName[1];
+                    if (FAILED(hr = LegacyActivationShim::StrongNameGetPublicKey_HRESULT(
+                        m_sStrongName.m_wzKeyContainer, 
+                        NULL, 
+                        0, 
+                        &m_sStrongName.m_pbPublicKey, 
+                        &m_sStrongName.m_cbPublicKey)))
+                    {
+                        report->error("Failed to extract public key from '%S': 0x%08X\n",m_sStrongName.m_wzKeyContainer,hr);
+                        m_pCurAsmRef = NULL;
+                        return;
+                    }
+                    m_sStrongName.m_fFullSign = TRUE;
+                    m_sStrongName.m_dwPublicKeyAllocated = AsmManStrongName::AllocatedBySNApi;
+                }
+                else
+                {
+                    // Read public key or key pair from file.
+                    HANDLE hFile = WszCreateFile(((Assembler*)m_pAssembler)->m_wzKeySourceName,
+                                                 GENERIC_READ,
+                                                 FILE_SHARE_READ,
+                                                 NULL,
+                                                 OPEN_EXISTING,
+                                                 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
+                                                 NULL);
+                    if(hFile == INVALID_HANDLE_VALUE)
+                    {
+                        hr = GetLastError();
+                        report->error("Failed to open key file '%S': 0x%08X\n",((Assembler*)m_pAssembler)->m_wzKeySourceName,hr);
+                        m_pCurAsmRef = NULL;
+                        return;
+                    }
+
+                    // Determine file size and allocate an appropriate buffer.
+                    m_sStrongName.m_cbPublicKey = SafeGetFileSize(hFile, NULL);
+                    if (m_sStrongName.m_cbPublicKey == 0xffffffff) {
+                        report->error("File size too large\n");
+                        m_pCurAsmRef = NULL;
+                        CloseHandle(hFile);
+                        return;
+                    }
+
+                    m_sStrongName.m_pbPublicKey = new BYTE[m_sStrongName.m_cbPublicKey];
+                    if (m_sStrongName.m_pbPublicKey == NULL) {
+                        report->error("Failed to allocate key buffer\n");
+                        m_pCurAsmRef = NULL;
+                        CloseHandle(hFile);
+                        return;
+                    }
+                    m_sStrongName.m_dwPublicKeyAllocated = AsmManStrongName::AllocatedByNew;
+
+                    // Read the file into the buffer.
+                    DWORD dwBytesRead;
+                    if (!ReadFile(hFile, m_sStrongName.m_pbPublicKey, m_sStrongName.m_cbPublicKey, &dwBytesRead, NULL)) {
+                        hr = GetLastError();
+                        report->error("Failed to read key file '%S': 0x%08X\n",((Assembler*)m_pAssembler)->m_wzKeySourceName,hr);
+                        m_pCurAsmRef = NULL;
+                        CloseHandle(hFile);
+                        return;
+                    }
+
+                    CloseHandle(hFile);
+
+                    // Guess whether we're full or delay signing based on
+                    // whether the blob passed to us looks like a public
+                    // key. (I.e. we may just have copied a full key pair
+                    // into the public key buffer).
+                    if (m_sStrongName.m_cbPublicKey >= sizeof(PublicKeyBlob) &&
+                        (offsetof(PublicKeyBlob, PublicKey) +
+                         ((PublicKeyBlob*)m_sStrongName.m_pbPublicKey)->cbPublicKey) == m_sStrongName.m_cbPublicKey)
+                        m_sStrongName.m_fFullSign = FALSE;
+                    else
+                        m_sStrongName.m_fFullSign = TRUE;
+
+                    // If we really have a key pair, we'll move it into a
+                    // key container so the signing code gets the key pair
+                    // from a consistent place.
+                    if (m_sStrongName.m_fFullSign)
+                    {
+                        m_sStrongName.m_pbPrivateKey = m_sStrongName.m_pbPublicKey;
+                        m_sStrongName.m_cbPrivateKey = m_sStrongName.m_cbPublicKey;
+
+                        m_sStrongName.m_pbPublicKey = NULL;
+                        m_sStrongName.m_cbPublicKey = NULL;
+                        m_sStrongName.m_dwPublicKeyAllocated = AsmManStrongName::NotAllocated;
+
+                        // Retrieve the public key portion as a byte blob.
+                        if (FAILED(hr = LegacyActivationShim::StrongNameGetPublicKey_HRESULT(
+                            NULL, 
+                            m_sStrongName.m_pbPrivateKey, 
+                            m_sStrongName.m_cbPrivateKey, 
+                            &m_sStrongName.m_pbPublicKey, 
+                            &m_sStrongName.m_cbPublicKey)))
+                        {
+                            report->error("Failed to extract public key: 0x%08X\n",hr);
+                            m_pCurAsmRef = NULL;
+                            return;
+                        }
+    
+                        m_sStrongName.m_dwPublicKeyAllocated = AsmManStrongName::AllocatedBySNApi;
+                    }
+                }
+            }
+            else 
+            {
+                if (m_pAssembly->pPublicKey)
+                {
+                    m_sStrongName.m_pbPublicKey = m_pAssembly->pPublicKey->ptr();
+                    m_sStrongName.m_cbPublicKey = m_pAssembly->pPublicKey->length();
+                }
+                else
+                {
+                    m_sStrongName.m_pbPublicKey = NULL;
+                    m_sStrongName.m_cbPublicKey = 0;
+                }
+
+                m_sStrongName.m_wzKeyContainer = NULL;
+                m_sStrongName.m_fFullSign = FALSE;
+                m_sStrongName.m_dwPublicKeyAllocated = AsmManStrongName::NotAllocated;
+            }
+        }
+        m_pCurAsmRef = NULL;
+    }
+    ((Assembler*)m_pAssembler)->m_pCustomDescrList = ((Assembler*)m_pAssembler)->m_CustomDescrListStack.POP();
+}
+
+void    FillAssemblyMetadata(AsmManAssembly *pAsm, ASSEMBLYMETADATA *pmd)
+{
+    pmd->usMajorVersion = pAsm->usVerMajor;
+    pmd->usMinorVersion = pAsm->usVerMinor;
+    pmd->usBuildNumber = pAsm->usBuild;
+    pmd->usRevisionNumber = pAsm->usRevision;
+    if(pmd->usMajorVersion == 0xFFFF) pmd->usMajorVersion = 0;
+    if(pmd->usMinorVersion == 0xFFFF) pmd->usMinorVersion = 0;
+    if(pmd->usBuildNumber == 0xFFFF) pmd->usBuildNumber = 0;
+    if(pmd->usRevisionNumber == 0xFFFF) pmd->usRevisionNumber = 0;
+
+    if(pAsm->pLocale != NULL)
+    {
+        pmd->szLocale = (LPWSTR)(pAsm->pLocale->ptr());
+        pmd->cbLocale = pAsm->pLocale->length()/((ULONG)sizeof(WCHAR));
+    }
+    else
+    {
+        pmd->szLocale = NULL;
+        pmd->cbLocale = 0;
+    }
+
+    pmd->rProcessor = NULL;
+    pmd->rOS = NULL;
+    pmd->ulProcessor = 0;
+    pmd->ulOS = 0;
+}
+
+void    AsmMan::EmitAssemblyRefs()
+{
+    int i;
+    HRESULT                 hr = S_OK;
+    ASSEMBLYMETADATA md;
+    mdToken tk;
+    
+    for(i=0; (m_pCurAsmRef=m_AsmRefLst.PEEK(i)) != NULL; i++)
+    {
+        if(!m_pCurAsmRef->m_fNew) continue;
+        m_pCurAsmRef->m_fNew = FALSE;
+
+        wzUniBuf[0] = 0;
+        FillAssemblyMetadata(m_pCurAsmRef,&md);
+
+        // See if we've got a full public key or the tokenized version (or neither).
+        BYTE *pbPublicKeyOrToken = NULL;
+        DWORD cbPublicKeyOrToken = 0;
+        DWORD dwFlags = m_pCurAsmRef->dwAttr;
+        if (m_pCurAsmRef->pPublicKeyToken)
+        {
+            pbPublicKeyOrToken = m_pCurAsmRef->pPublicKeyToken->ptr();
+            cbPublicKeyOrToken = m_pCurAsmRef->pPublicKeyToken->length();
+            
+        }
+        else if (m_pCurAsmRef->pPublicKey)
+        {
+            pbPublicKeyOrToken = m_pCurAsmRef->pPublicKey->ptr();
+            cbPublicKeyOrToken = m_pCurAsmRef->pPublicKey->length();
+            dwFlags |= afPublicKey;
+        }
+        // Convert name to Unicode
+        WszMultiByteToWideChar(g_uCodePage,0,m_pCurAsmRef->szName,-1,wzUniBuf,dwUniBuf);
+        hr = m_pAsmEmitter->DefineAssemblyRef(       // S_OK or error.
+                    pbPublicKeyOrToken,              // [IN] Public key or token of the assembly.
+                    cbPublicKeyOrToken,              // [IN] Count of bytes in the key or token.
+                    (LPCWSTR)wzUniBuf,               // [IN] Name of the assembly being referenced.
+                    (const ASSEMBLYMETADATA*)&md,    // [IN] Assembly MetaData.
+                    (m_pCurAsmRef->pHashBlob ? (const void*)(m_pCurAsmRef->pHashBlob->ptr()) : NULL),           // [IN] Hash Blob.
+                    (m_pCurAsmRef->pHashBlob ? m_pCurAsmRef->pHashBlob->length() : 0),            // [IN] Count of bytes in the Hash Blob.
+                    dwFlags,                         // [IN] Flags.
+                    (mdAssemblyRef*)&tk);         // [OUT] Returned AssemblyRef token.
+        if(m_pCurAsmRef->tkTok != tk)
+        {
+            report->error("AsmRef'%S' tok %8.8X -> %8.8X\n",wzUniBuf,m_pCurAsmRef->tkTok,tk);
+        }
+        if(FAILED(hr)) report->error("Failed to define assembly ref '%s': 0x%08X\n",m_pCurAsmRef->szName,hr);
+        else
+        {
+            ((Assembler*)m_pAssembler)->EmitCustomAttributes(m_pCurAsmRef->tkTok, &(m_pCurAsmRef->m_CustomDescrList));
+        }
+    } // end for(i=0; m_pCurAsmRef=m_AsmRefLst.PEEK(i); i++)
+}
+
+void    AsmMan::EmitAssembly()
+{
+    HRESULT                 hr = S_OK;
+    ASSEMBLYMETADATA md;
+            
+    wzUniBuf[0] = 0;
+    if(m_pAssembly == NULL) return;
+    if(!m_pAssembly->m_fNew) return;
+    m_pAssembly->m_fNew = FALSE;
+
+    FillAssemblyMetadata(m_pAssembly, &md);
+
+    // Convert name to Unicode
+    WszMultiByteToWideChar(g_uCodePage,0,m_pAssembly->szName,-1,wzUniBuf,dwUniBuf);
+
+    hr = m_pAsmEmitter->DefineAssembly(              // S_OK or error.
+        (const void*)(m_sStrongName.m_pbPublicKey), // [IN] Public key of the assembly.
+        m_sStrongName.m_cbPublicKey,                // [IN] Count of bytes in the public key.
+        m_pAssembly->ulHashAlgorithm,            // [IN] Hash algorithm used to hash the files.
+        (LPCWSTR)wzUniBuf,                 // [IN] Name of the assembly.
+        (const ASSEMBLYMETADATA*)&md,  // [IN] Assembly MetaData.
+        m_pAssembly->dwAttr,        // [IN] Flags.
+        (mdAssembly*)&(m_pAssembly->tkTok));             // [OUT] Returned Assembly token.
+
+    if(FAILED(hr)) report->error("Failed to define assembly '%s': 0x%08X\n",m_pAssembly->szName,hr);
+    else
+    {
+        Assembler* pAsm = ((Assembler*)m_pAssembler);
+        pAsm->EmitSecurityInfo(m_pAssembly->tkTok,
+                             m_pAssembly->m_pPermissions,
+                             m_pAssembly->m_pPermissionSets);
+        if(pAsm->m_dwIncludeDebugInfo)
+        {
+            EmitDebuggableAttribute(m_pAssembly->tkTok);
+        }
+        pAsm->EmitCustomAttributes(m_pAssembly->tkTok, &(m_pAssembly->m_CustomDescrList));
+    }
+}
+
+void    AsmMan::SetAssemblyPublicKey(BinStr* pPublicKey)
+{
+    if(m_pCurAsmRef)
+    {
+        m_pCurAsmRef->pPublicKey = pPublicKey;
+    }
+}
+
+void    AsmMan::SetAssemblyPublicKeyToken(BinStr* pPublicKeyToken)
+{
+    if(m_pCurAsmRef)
+    {
+        m_pCurAsmRef->pPublicKeyToken = pPublicKeyToken;
+    }
+}
+
+void    AsmMan::SetAssemblyHashAlg(ULONG ulAlgID)
+{
+    if(m_pCurAsmRef)
+    {
+        m_pCurAsmRef->ulHashAlgorithm = ulAlgID;
+    }
+}
+
+void    AsmMan::SetAssemblyVer(USHORT usMajor, USHORT usMinor, USHORT usBuild, USHORT usRevision)
+{
+    if(m_pCurAsmRef)
+    {
+        m_pCurAsmRef->usVerMajor = usMajor;
+        m_pCurAsmRef->usVerMinor = usMinor;
+        m_pCurAsmRef->usBuild = usBuild;
+        m_pCurAsmRef->usRevision = usRevision;
+    }
+}
+
+void    AsmMan::SetAssemblyLocale(BinStr* pLocale, BOOL bConvertToUnicode)
+{
+    if(m_pCurAsmRef)
+    {
+        m_pCurAsmRef->pLocale = bConvertToUnicode ? ::BinStrToUnicode(pLocale) : pLocale;
+    }
+}
+
+void    AsmMan::SetAssemblyHashBlob(BinStr* pHashBlob)
+{
+    if(m_pCurAsmRef)
+    {
+        m_pCurAsmRef->pHashBlob = pHashBlob;
+    }
+}
+
+void    AsmMan::SetAssemblyAutodetect()
+{
+    if(m_pCurAsmRef)
+    {
+        m_pCurAsmRef->isAutodetect = TRUE;
+    }
+}
+
+void    AsmMan::StartComType(__in __nullterminated char* szName, DWORD dwAttr)
+{
+    if((m_pCurComType = new AsmManComType))
+    {
+        memset(m_pCurComType,0,sizeof(AsmManComType));
+        m_pCurComType->szName = szName;
+        m_pCurComType->dwAttr = dwAttr;
+        m_pCurComType->m_fNew = TRUE;
+        ((Assembler*)m_pAssembler)->m_tkCurrentCVOwner = 0;
+        ((Assembler*)m_pAssembler)->m_CustomDescrListStack.PUSH(((Assembler*)m_pAssembler)->m_pCustomDescrList);
+        ((Assembler*)m_pAssembler)->m_pCustomDescrList = &(m_pCurComType->m_CustomDescrList);
+    }
+    else
+        report->error("Failed to allocate AsmManComType structure\n");
+}
+
+void    AsmMan::EndComType()
+{
+    if(m_pCurComType)
+    {
+        if(m_pAssembler)
+        { 
+            Class* pClass =((Assembler*)m_pAssembler)->m_pCurClass;
+            if(pClass)
+            {
+                m_pCurComType->tkClass = pClass->m_cl;
+                if(pClass->m_pEncloser)
+                {
+                    mdTypeDef tkEncloser = pClass->m_pEncloser->m_cl;
+                    AsmManComType* pCT;
+                    for(unsigned i=0; (pCT=m_ComTypeLst.PEEK(i)); i++)
+                    {
+                        if(pCT->tkClass == tkEncloser)
+                        {
+                            m_pCurComType->szComTypeName = pCT->szName;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (IsTdNested(m_pCurComType->dwAttr) && GetComTypeByName(m_pCurComType->szName, m_pCurComType->szComTypeName) != NULL)
+        {
+            report->error("Invalid TypeDefID of exported type\n");
+            delete m_pCurComType;
+        }
+        else
+        {
+            m_ComTypeLst.PUSH(m_pCurComType);
+        }
+
+        m_pCurComType = NULL;
+        ((Assembler*)m_pAssembler)->m_tkCurrentCVOwner = 0;
+        ((Assembler*)m_pAssembler)->m_pCustomDescrList = ((Assembler*)m_pAssembler)->m_CustomDescrListStack.POP();
+    }
+}
+
+void    AsmMan::SetComTypeFile(__in __nullterminated char* szFileName)
+{
+    if(m_pCurComType)
+    {
+        m_pCurComType->szFileName = szFileName;
+    }
+}
+
+void    AsmMan::SetComTypeAsmRef(__in __nullterminated char* szAsmRefName)
+{
+    if(m_pCurComType)
+    {
+        m_pCurComType->szAsmRefName = szAsmRefName;
+    }
+}
+
+void    AsmMan::SetComTypeComType(__in __nullterminated char* szComTypeName)
+{
+    if(m_pCurComType)
+    {
+        m_pCurComType->szComTypeName = szComTypeName;
+    }
+}
+BOOL    AsmMan::SetComTypeImplementationTok(mdToken tk)
+{
+    if(m_pCurComType)
+    {
+        switch(TypeFromToken(tk))
+        {
+        case mdtAssemblyRef:
+        case mdtExportedType:
+        case mdtFile:
+            m_pCurComType->tkImpl = tk;
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+BOOL    AsmMan::SetComTypeClassTok(mdToken tkClass)
+{
+    if((m_pCurComType)&&(TypeFromToken(tkClass)==mdtTypeDef))
+    {
+        m_pCurComType->tkClass = tkClass;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+void    AsmMan::StartManifestRes(__in __nullterminated char* szName, __in __nullterminated char* szAlias, DWORD dwAttr)
+{
+    if((m_pCurManRes = new AsmManRes))
+    {
+        m_pCurManRes->szName = szName;
+        m_pCurManRes->szAlias = szAlias;
+        m_pCurManRes->dwAttr = dwAttr;
+        m_pCurManRes->m_fNew = TRUE;
+        ((Assembler*)m_pAssembler)->m_tkCurrentCVOwner = 0;
+        ((Assembler*)m_pAssembler)->m_CustomDescrListStack.PUSH(((Assembler*)m_pAssembler)->m_pCustomDescrList);
+        ((Assembler*)m_pAssembler)->m_pCustomDescrList = &(m_pCurManRes->m_CustomDescrList);
+    }
+    else
+        report->error("Failed to allocate AsmManRes structure\n");
+}
+
+void    AsmMan::EndManifestRes()
+{
+    if(m_pCurManRes)
+    {
+        m_ManResLst.PUSH(m_pCurManRes);
+        m_pCurManRes = NULL;
+        ((Assembler*)m_pAssembler)->m_tkCurrentCVOwner = 0;
+        ((Assembler*)m_pAssembler)->m_pCustomDescrList = ((Assembler*)m_pAssembler)->m_CustomDescrListStack.POP();
+    }
+}
+
+
+void    AsmMan::SetManifestResFile(__in __nullterminated char* szFileName, ULONG ulOffset)
+{
+    if(m_pCurManRes)
+    {
+        m_pCurManRes->szFileName = szFileName;
+        m_pCurManRes->ulOffset = ulOffset;
+    }
+}
+
+void    AsmMan::SetManifestResAsmRef(__in __nullterminated char* szAsmRefName)
+{
+    if(m_pCurManRes)
+    {
+        m_pCurManRes->szAsmRefName = szAsmRefName;
+    }
+}
+
+HRESULT AsmMan::EmitManifest()
+{
+    //AsmManAssembly*           pAsmRef;
+    AsmManComType*          pComType;
+    AsmManRes*              pManRes;
+    HRESULT                 hr = S_OK;
+
+    wzUniBuf[0] = 0;
+
+    if(m_pAsmEmitter==NULL)
+        hr=m_pEmitter->QueryInterface(IID_IMetaDataAssemblyEmit, (void**) &m_pAsmEmitter);
+
+    if(SUCCEEDED(hr))
+    {
+        EmitFiles();
+        EmitAssembly();
+        
+        if((((Assembler*)m_pAssembler)->m_dwIncludeDebugInfo != 0) && (m_pAssembly == NULL) 
+           && !(((Assembler*)m_pAssembler)->m_fENCMode))
+        {
+            mdToken tkOwner, tkMscorlib;
+            tkMscorlib = ((Assembler*)m_pAssembler)->GetAsmRef("mscorlib");
+            tkOwner = ((Assembler*)m_pAssembler)->ResolveClassRef(tkMscorlib,
+                                                                  "System.Runtime.CompilerServices.AssemblyAttributesGoHere",
+                                                                  NULL);
+            EmitDebuggableAttribute(tkOwner);
+        }
+
+        // Emit all com types
+        unsigned i;
+        for(i = 0; (pComType = m_ComTypeLst.PEEK(i)); i++)
+        {
+            if(!pComType->m_fNew) continue;
+            pComType->m_fNew = FALSE;
+
+            WszMultiByteToWideChar(g_uCodePage,0,pComType->szName,-1,wzUniBuf,dwUniBuf);
+            mdToken     tkImplementation = mdTokenNil;
+            if(pComType->tkImpl) tkImplementation = pComType->tkImpl;
+            else if(pComType->szFileName)
+            {
+                tkImplementation = GetFileTokByName(pComType->szFileName);
+                if(tkImplementation==mdFileNil)
+                {
+                    report->error("Undefined File '%s' in ExportedType '%s'\n",pComType->szFileName,pComType->szName);
+                    if(!((Assembler*)m_pAssembler)->OnErrGo) continue;
+                }
+            }
+            else if(pComType->szAsmRefName)
+            {
+                tkImplementation = GetAsmRefTokByName(pComType->szAsmRefName);
+                if(RidFromToken(tkImplementation)==0)
+                {
+                    report->error("Undefined AssemblyRef '%s' in ExportedType '%s'\n",pComType->szAsmRefName,pComType->szName);
+                    if(!((Assembler*)m_pAssembler)->OnErrGo) continue;
+                }
+            }
+            else if(pComType->szComTypeName)
+            {
+                char* szLastName = strrchr(pComType->szComTypeName, NESTING_SEP);
+
+                if(szLastName)
+                {
+                    *szLastName = 0;
+                    szLastName ++;
+                    tkImplementation = GetComTypeTokByName(szLastName, pComType->szComTypeName);
+                    *(szLastName-1) = NESTING_SEP; // not really necessary
+                }
+
+                else
+                {
+                    tkImplementation = GetComTypeTokByName(pComType->szComTypeName);
+                }
+
+                if(tkImplementation==mdExportedTypeNil)
+                {
+                    report->error("Undefined ExportedType '%s' in ExportedType '%s'\n",pComType->szComTypeName,pComType->szName);
+                    if(!((Assembler*)m_pAssembler)->OnErrGo) continue;
+                }
+            }
+            else 
+            {
+                report->warn("Undefined implementation in ExportedType '%s' -- ExportType not emitted\n",pComType->szName);
+                if(!((Assembler*)m_pAssembler)->OnErrGo) continue;
+            }
+            hr = m_pAsmEmitter->DefineExportedType(         // S_OK or error.
+                    (LPCWSTR)wzUniBuf,                      // [IN] Name of the Com Type.
+                    tkImplementation,                       // [IN] mdFile or mdAssemblyRef that provides the ComType.
+                    (mdTypeDef)pComType->tkClass,           // [IN] TypeDef token within the file.
+                    pComType->dwAttr,                       // [IN] Flags.
+                    (mdExportedType*)&(pComType->tkTok));   // [OUT] Returned ComType token.
+            if(FAILED(hr)) report->error("Failed to define ExportedType '%s': 0x%08X\n",pComType->szName,hr);
+            else
+            {
+                ((Assembler*)m_pAssembler)->EmitCustomAttributes(pComType->tkTok, &(pComType->m_CustomDescrList));
+            }
+        }
+
+        // Emit all manifest resources
+        m_dwMResSizeTotal = 0;
+        m_dwMResNum = 0;
+        for(i = 0; (pManRes = m_ManResLst.PEEK(i)); i++)
+        {
+            BOOL fOK = TRUE;
+            mdToken     tkImplementation = mdFileNil;
+
+            if(!pManRes->m_fNew) continue;
+            pManRes->m_fNew = FALSE;
+
+            WszMultiByteToWideChar(g_uCodePage,0,pManRes->szAlias,-1,wzUniBuf,dwUniBuf);
+            if(pManRes->szAsmRefName)
+            {
+                tkImplementation = GetAsmRefTokByName(pManRes->szAsmRefName);
+                if(RidFromToken(tkImplementation)==0)
+                {
+                    report->error("Undefined AssemblyRef '%s' in MResource '%s'\n",pManRes->szAsmRefName,pManRes->szName);
+                    fOK = FALSE;
+                }
+            }
+            else if(pManRes->szFileName)
+            {
+                tkImplementation = GetFileTokByName(pManRes->szFileName);
+                if(RidFromToken(tkImplementation)==0)
+                {
+                    report->error("Undefined File '%s' in MResource '%s'\n",pManRes->szFileName,pManRes->szName);
+                    fOK = FALSE;
+                }
+            }
+            else // embedded mgd.resource, go after the file
+            {
+                HANDLE hFile = INVALID_HANDLE_VALUE;
+                int j;
+                WCHAR   wzFileName[2048];
+                WCHAR*  pwz;
+
+                pManRes->ulOffset = m_dwMResSizeTotal;
+                for(j=0; (hFile == INVALID_HANDLE_VALUE)&&(pwzInputFiles[j] != NULL); j++)
+                {
+                    wcscpy_s(wzFileName,2048,pwzInputFiles[j]);
+                    pwz = wcsrchr(wzFileName,'\\');
+                    if(pwz == NULL) pwz = wcsrchr(wzFileName,':');
+                    if(pwz == NULL) pwz = &wzFileName[0];
+                    else pwz++;
+                    wcscpy_s(pwz,2048-(pwz-wzFileName),wzUniBuf);
+                    hFile = WszCreateFile(wzFileName, GENERIC_READ, FILE_SHARE_READ,
+                             0, OPEN_EXISTING, 0, 0);
+                }
+                if (hFile == INVALID_HANDLE_VALUE)
+                {
+                    report->error("Failed to open managed resource file '%s'\n",pManRes->szAlias);
+                    fOK = FALSE;
+                }
+                else
+                {
+                    if (m_dwMResNum >= MAX_MANIFEST_RESOURCES)
+                    {
+                        report->error("Too many resources (implementation limit: %d); skipping file '%s'\n",MAX_MANIFEST_RESOURCES,pManRes->szAlias);
+                        fOK = FALSE;
+                    }
+                    else
+                    {
+                        m_dwMResSize[m_dwMResNum] = SafeGetFileSize(hFile,NULL);
+                        if(m_dwMResSize[m_dwMResNum] == 0xFFFFFFFF)
+                        {
+                            report->error("Failed to get size of managed resource file '%s'\n",pManRes->szAlias);
+                            fOK = FALSE;
+                        }
+                        else 
+                        {
+                            m_dwMResSizeTotal += m_dwMResSize[m_dwMResNum]+sizeof(DWORD);
+                            m_wzMResName[m_dwMResNum] = new WCHAR[wcslen(wzFileName)+1];
+                            wcscpy_s(m_wzMResName[m_dwMResNum],wcslen(wzFileName)+1,wzFileName);
+                            m_fMResNew[m_dwMResNum] = TRUE;
+                            m_dwMResNum++;
+                        }
+                        CloseHandle(hFile);
+                    }
+                }
+            }
+            if(fOK || ((Assembler*)m_pAssembler)->OnErrGo)
+            {
+                WszMultiByteToWideChar(g_uCodePage,0,pManRes->szName,-1,wzUniBuf,dwUniBuf);
+                hr = m_pAsmEmitter->DefineManifestResource(         // S_OK or error.
+                        (LPCWSTR)wzUniBuf,                          // [IN] Name of the resource.
+                        tkImplementation,                           // [IN] mdFile or mdAssemblyRef that provides the resource.
+                        pManRes->ulOffset,                          // [IN] Offset to the beginning of the resource within the file.
+                        pManRes->dwAttr,                            // [IN] Flags.
+                        (mdManifestResource*)&(pManRes->tkTok));    // [OUT] Returned ManifestResource token.
+                if(FAILED(hr))
+                    report->error("Failed to define manifest resource '%s': 0x%08X\n",pManRes->szName,hr);
+            }
+        }
+
+
+        m_pAsmEmitter->Release();
+        m_pAsmEmitter = NULL;
+    }
+    else 
+        report->error("Failed to obtain IMetaDataAssemblyEmit interface: 0x%08X\n",hr);
+    return hr;
+}
+
diff --git a/src/ilasm/asmman.hpp b/src/ilasm/asmman.hpp
new file mode 100644
index 0000000000..3db7ae2b2d
--- /dev/null
+++ b/src/ilasm/asmman.hpp
@@ -0,0 +1,301 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// asmman.hpp - header file for manifest-related ILASM functions
+//
+
+#ifndef ASMMAN_HPP
+#define ASMMAN_HPP
+
+#include "strongname.h"
+#include "LegacyActivationShim.h"
+#include "specstrings.h"
+
+struct AsmManFile
+{
+    char*   szName;
+    mdToken tkTok;
+    DWORD   dwAttr;
+    BinStr* pHash;
+    BOOL    m_fNew;
+    CustomDescrList m_CustomDescrList;
+    AsmManFile()
+    {
+        szName = NULL;
+        pHash = NULL;
+        m_fNew = TRUE;
+    }
+    ~AsmManFile()
+    {
+        if(szName)  delete szName;
+        if(pHash)   delete pHash;
+    }
+    int ComparedTo(AsmManFile* pX){ return strcmp(szName,pX->szName); }
+};
+//typedef SORTEDARRAY<AsmManFile> AsmManFileList;
+typedef FIFO<AsmManFile> AsmManFileList;
+
+struct AsmManAssembly
+{
+	BOOL	isRef;
+	BOOL	isAutodetect;
+	char*	szName;
+	char*	szAlias;
+    DWORD   dwAlias;
+	mdToken	tkTok;
+	DWORD	dwAttr;
+	BinStr* pPublicKey;
+	BinStr* pPublicKeyToken;
+	ULONG	ulHashAlgorithm;
+	BinStr*	pHashBlob;
+	BinStr*	pLocale;
+    BOOL    m_fNew;
+    // Security attributes
+    PermissionDecl* m_pPermissions;
+    PermissionSetDecl* m_pPermissionSets;
+	CustomDescrList m_CustomDescrList;
+	USHORT	usVerMajor;
+	USHORT	usVerMinor;
+	USHORT	usBuild;
+	USHORT	usRevision;
+    AsmManAssembly()
+    {
+    /*
+        usVerMajor = usVerMinor = usBuild = usRevision = 0xFFFF;
+        szName = szAlias = NULL;
+        dwAlias = dwAttr = 0;
+        tkTok = 0;
+        pPublicKey = pPublicKeyToken =pHashBlob = pLocale = NULL;
+        ulHashAlgorithm = 0;
+        m_fNew = TRUE;
+        isAutodetect = isRef = FALSE;
+    */
+    }
+	~AsmManAssembly() 
+	{
+		if(szAlias && (szAlias != szName)) delete [] szAlias;
+		if(szName) delete [] szName;
+		if(pPublicKey) delete pPublicKey;
+		if(pPublicKeyToken) delete pPublicKeyToken;
+		if(pHashBlob) delete pHashBlob;
+		if(pLocale) delete pLocale;
+	}
+    int ComparedTo(AsmManAssembly* pX){ return strcmp(szAlias,pX->szAlias); }
+};
+//typedef SORTEDARRAY<AsmManAssembly> AsmManAssemblyList;
+typedef FIFO<AsmManAssembly> AsmManAssemblyList;
+
+struct AsmManComType
+{
+    char*   szName;
+    mdToken tkTok;
+    mdToken tkImpl;
+    DWORD   dwAttr;
+    char*   szFileName;
+    char*   szAsmRefName;
+    char*   szComTypeName;
+    mdToken tkClass;
+    BOOL    m_fNew;
+    CustomDescrList m_CustomDescrList;
+    AsmManComType()
+    {
+        szName = szFileName = szAsmRefName = szComTypeName = NULL;
+        m_fNew = TRUE;
+        tkImpl = 0;
+    };
+    ~AsmManComType()
+    {
+        if(szName) delete szName;
+        if(szFileName) delete szFileName;
+    };
+    int ComparedTo(AsmManComType* pX){ return strcmp(szName,pX->szName); };
+};
+//typedef SORTEDARRAY<AsmManComType> AsmManComTypeList;
+typedef FIFO<AsmManComType> AsmManComTypeList;
+
+
+struct AsmManRes
+{
+	char*	szName;
+    char*   szAlias;
+	mdToken	tkTok;
+	DWORD	dwAttr;
+	char*	szFileName;
+	ULONG	ulOffset;
+    BOOL    m_fNew;
+	CustomDescrList m_CustomDescrList;
+	char*	szAsmRefName;
+	AsmManRes() { szName = szAlias = szAsmRefName = szFileName = NULL; ulOffset = 0; tkTok = 0; dwAttr = 0; m_fNew = TRUE; };
+	~AsmManRes()
+	{
+        if(szAlias && (szAlias != szName)) delete szAlias;
+		if(szName) delete szName;
+		if(szFileName) delete szFileName;
+		if(szAsmRefName) delete szAsmRefName;
+	}
+};
+typedef FIFO<AsmManRes> AsmManResList;
+
+struct AsmManModRef
+{
+    char*   szName;
+    mdToken tkTok;
+    BOOL    m_fNew;
+    AsmManModRef() {szName = NULL; tkTok = 0; m_fNew = TRUE; };
+    ~AsmManModRef() { if(szName) delete szName; };
+};
+typedef FIFO<AsmManModRef> AsmManModRefList;
+
+struct AsmManStrongName
+{
+    enum AllocationState
+    {
+        NotAllocated = 0,
+        AllocatedBySNApi,
+        AllocatedByNew
+    };
+
+    BYTE *m_pbSignatureKey;
+    DWORD m_cbSignatureKey;
+    BYTE   *m_pbPublicKey;
+    DWORD   m_cbPublicKey;
+    BYTE   *m_pbPrivateKey;
+    DWORD   m_cbPrivateKey;
+    WCHAR  *m_wzKeyContainer;
+    BOOL    m_fFullSign;
+
+    // Where has the memory pointed to by m_pbPublicKey been taken from:
+    AllocationState   m_dwPublicKeyAllocated;
+
+    AsmManStrongName() { ZeroMemory(this, sizeof(*this)); }
+    ~AsmManStrongName()
+    {
+        if (m_dwPublicKeyAllocated == AllocatedBySNApi)
+        {
+            LegacyActivationShim::StrongNameFreeBuffer(m_pbPublicKey);
+        }
+        else if (m_dwPublicKeyAllocated == AllocatedByNew)
+            delete [] m_pbPublicKey;
+    
+        if (m_pbPrivateKey)
+            delete [] m_pbPrivateKey;
+
+        if (m_pbSignatureKey)
+            delete [] m_pbSignatureKey;
+    }
+};
+
+class ErrorReporter;
+
+class AsmMan
+{
+    AsmManFileList      m_FileLst;
+    AsmManComTypeList   m_ComTypeLst;
+    AsmManResList       m_ManResLst;
+    AsmManModRefList    m_ModRefLst;
+
+    AsmManComType*      m_pCurComType;
+    AsmManRes*          m_pCurManRes;
+    ErrorReporter*      report;
+    void*               m_pAssembler;
+    
+    AsmManFile*         GetFileByName(__in __nullterminated char* szFileName);
+    AsmManAssembly*     GetAsmRefByName(__in __nullterminated char* szAsmRefName);
+    AsmManComType*      GetComTypeByName(__in_opt __nullterminated char* szComTypeName,
+                                         __in_opt __nullterminated char* szComEnclosingTypeName = NULL);
+    mdToken             GetComTypeTokByName(__in_opt __nullterminated char* szComTypeName,
+                                            __in_opt __nullterminated char* szComEnclosingTypeName = NULL);
+
+    IMetaDataEmit*          m_pEmitter;
+
+public:
+    IMetaDataAssemblyEmit*  m_pAsmEmitter;
+    AsmManAssemblyList  m_AsmRefLst;
+    AsmManAssembly*     m_pAssembly;
+    AsmManAssembly*     m_pCurAsmRef;
+    char*   m_szScopeName;
+    BinStr* m_pGUID;
+    AsmManStrongName    m_sStrongName;
+	// Embedded manifest resources paraphernalia:
+    WCHAR*  m_wzMResName[MAX_MANIFEST_RESOURCES];
+	DWORD	m_dwMResSize[MAX_MANIFEST_RESOURCES];
+    BOOL    m_fMResNew[MAX_MANIFEST_RESOURCES];
+	DWORD	m_dwMResNum;
+	DWORD	m_dwMResSizeTotal;
+	AsmMan() { m_pAssembly = NULL; m_szScopeName = NULL; m_pGUID = NULL; m_pAsmEmitter = NULL; 
+				memset(m_wzMResName,0,sizeof(m_wzMResName)); 
+				memset(m_dwMResSize,0,sizeof(m_dwMResSize)); 
+				m_dwMResNum = m_dwMResSizeTotal = 0; };
+	AsmMan(void* pAsm) { m_pAssembly = NULL; m_szScopeName = NULL; m_pGUID = NULL; m_pAssembler = pAsm;  m_pAsmEmitter = NULL;
+				memset(m_wzMResName,0,sizeof(m_wzMResName)); 
+				memset(m_dwMResSize,0,sizeof(m_dwMResSize)); 
+				m_dwMResNum = m_dwMResSizeTotal = 0; };
+	AsmMan(ErrorReporter* rpt) { m_pAssembly = NULL; m_szScopeName = NULL; m_pGUID = NULL; report = rpt;  m_pAsmEmitter = NULL;
+				memset(m_wzMResName,0,sizeof(m_wzMResName)); 
+				memset(m_dwMResSize,0,sizeof(m_dwMResSize)); 
+				m_dwMResNum = m_dwMResSizeTotal = 0; };
+	~AsmMan() 
+	{ 
+		if(m_pAssembly) delete m_pAssembly; 
+		if(m_szScopeName) delete m_szScopeName; 
+		if(m_pGUID) delete m_pGUID; 
+	};
+	void	SetErrorReporter(ErrorReporter* rpt) { report = rpt; };
+	HRESULT EmitManifest(void);
+
+    void    SetEmitter( IMetaDataEmit* pEmitter) { m_pEmitter = pEmitter; };
+
+    void    SetModuleName(__inout_opt __nullterminated char* szName);
+
+    void    AddFile(__in __nullterminated char* szName, DWORD dwAttr, BinStr* pHashBlob);
+    void    EmitFiles();
+	void	EmitDebuggableAttribute(mdToken tkOwner);
+
+	void	StartAssembly(__in __nullterminated char* szName, __in_opt __nullterminated char* szAlias, DWORD dwAttr, BOOL isRef);
+	void	EndAssembly();
+    void    EmitAssemblyRefs();
+    void    EmitAssembly();
+	void	SetAssemblyPublicKey(BinStr* pPublicKey);
+	void	SetAssemblyPublicKeyToken(BinStr* pPublicKeyToken);
+	void	SetAssemblyHashAlg(ULONG ulAlgID);
+	void	SetAssemblyVer(USHORT usMajor, USHORT usMinor, USHORT usBuild, USHORT usRevision);
+	void	SetAssemblyLocale(BinStr* pLocale, BOOL bConvertToUnicode);
+	void	SetAssemblyHashBlob(BinStr* pHashBlob);
+    void    SetAssemblyAutodetect();
+
+    void    StartComType(__in __nullterminated char* szName, DWORD dwAttr);
+    void    EndComType();
+    void    SetComTypeFile(__in __nullterminated char* szFileName);
+    void    SetComTypeAsmRef(__in __nullterminated char* szAsmRefName);
+    void    SetComTypeComType(__in __nullterminated char* szComTypeName);
+    BOOL    SetComTypeImplementationTok(mdToken tk);
+    BOOL    SetComTypeClassTok(mdToken tkClass);
+
+    void    StartManifestRes(__in __nullterminated char* szName, __in __nullterminated char* szAlias, DWORD dwAttr);
+    void    EndManifestRes();
+    void    SetManifestResFile(__in __nullterminated char* szFileName, ULONG ulOffset);
+    void    SetManifestResAsmRef(__in __nullterminated char* szAsmRefName);
+
+    mdToken             GetFileTokByName(__in __nullterminated char* szFileName);
+    mdToken             GetAsmRefTokByName(__in __nullterminated char* szAsmRefName);
+    mdToken             GetAsmTokByName(__in __nullterminated char* szAsmName) 
+        { return (m_pAssembly && (strcmp(m_pAssembly->szName,szAsmName)==0)) ? m_pAssembly->tkTok : 0; };
+
+    mdToken GetModuleRefTokByName(__in __nullterminated char* szName)
+    {
+        if(szName && *szName)
+        {
+            AsmManModRef* pMR;
+            for(unsigned i=0; (pMR=m_ModRefLst.PEEK(i)); i++)
+            {
+                if(!strcmp(szName, pMR->szName)) return pMR->tkTok;
+            }
+        }
+        return 0;
+    };
+
+};
+
+#endif
diff --git a/src/ilasm/asmparse.h b/src/ilasm/asmparse.h
new file mode 100644
index 0000000000..9c1ced273e
--- /dev/null
+++ b/src/ilasm/asmparse.h
@@ -0,0 +1,327 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+/**************************************************************************/
+/* asmParse is basically a wrapper around a YACC grammer COM+ assembly  */
+
+#ifndef asmparse_h
+#define asmparse_h
+
+#include <stdio.h>		// for FILE
+
+#include "assembler.h"	// for ErrorReporter Labels 
+//class Assembler;
+//class BinStr;
+
+
+/**************************************************************************/
+/* an abstraction of a stream of input characters */
+class ReadStream {
+public:
+
+    virtual unsigned getAll(__out char** ppch) = 0;
+
+    // read at most 'buffLen' bytes into 'buff', Return the
+        // number of characters read.  On EOF return 0
+    virtual unsigned read(__out_ecount(buffLen) char* buff, unsigned buffLen) = 0;
+        
+        // Return the name of the stream, (for error reporting).  
+    //virtual const char* name() = 0;
+        // Return the Unicode name of the stream  
+    virtual const WCHAR* namew() = 0;
+		//return ptr to buffer containing specified source line
+	virtual char* getLine(int lineNum) = 0;
+};
+
+/**************************************************************************/
+class BinStrStream : public ReadStream {
+public:
+    BinStrStream(BinStr* pbs)
+    {
+        m_pStart = (char*)(pbs->ptr());
+        m_pCurr = m_pStart;
+        m_pEnd = m_pStart + pbs->length();
+        m_pBS = pbs;
+    };
+    ~BinStrStream()
+    {
+        //if(m_pBS)
+        //    delete m_pBS;
+    };
+    unsigned getAll(__out char **ppbuff)
+    {
+        *ppbuff = m_pStart;
+        return m_pBS->length();
+    };
+    unsigned read(__out_ecount(buffLen) char* buff, unsigned buffLen) 
+    {
+        _ASSERTE(m_pStart != NULL);
+        unsigned Remainder = (unsigned)(m_pEnd - m_pCurr);
+        unsigned Len = buffLen;
+        if(Len > Remainder) Len = Remainder;
+        memcpy(buff,m_pCurr,Len);
+        m_pCurr += Len;
+        if(Len < buffLen)
+        {
+            memset(buff+Len,0,buffLen-Len);
+        }
+        return Len;
+    }
+
+    const WCHAR* namew()
+    {
+        return L"local_define";
+    }
+
+    BOOL IsValid()
+    {
+        return(m_pStart != NULL); 
+    }
+    
+	char* getLine(int lineNum)
+	{
+        return NULL; // this function is not used
+	}
+
+private:
+    char*   m_pStart;
+    char*   m_pEnd;
+    char*   m_pCurr;
+    BinStr* m_pBS;
+
+
+};
+/**************************************************************************/
+class MappedFileStream : public ReadStream {
+public:
+    MappedFileStream(__in __nullterminated WCHAR* wFileName) 
+    {
+        fileNameW = wFileName;
+        m_hFile = INVALID_HANDLE_VALUE;
+        m_hMapFile = NULL;
+        m_pStart = open(wFileName);
+        m_pCurr = m_pStart;
+        m_pEnd = m_pStart + m_FileSize;
+		//memset(fileNameANSI,0,MAX_FILENAME_LENGTH*4);
+		//WszWideCharToMultiByte(CP_ACP,0,wFileName,-1,fileNameANSI,MAX_FILENAME_LENGTH*4,NULL,NULL);
+    }
+    ~MappedFileStream()
+    {
+        if (m_hFile != INVALID_HANDLE_VALUE)
+        {
+            if (m_pStart)
+                UnmapViewOfFile((void*)m_pStart);
+            if (m_hMapFile)
+                CloseHandle(m_hMapFile);
+            CloseHandle(m_hFile);
+
+            m_pStart = NULL;
+            m_hMapFile = NULL;
+            m_hFile = INVALID_HANDLE_VALUE;
+            m_FileSize = 0;
+            delete [] fileNameW;
+            fileNameW = NULL;
+        }
+    }
+    unsigned getAll(__out char** pbuff)
+    {
+        *pbuff = m_pStart;
+        return m_FileSize;
+    }
+    unsigned read(__out_ecount(buffLen) char* buff, unsigned buffLen) 
+    {
+        _ASSERTE(m_pStart != NULL);
+        unsigned Remainder = (unsigned)(m_pEnd - m_pCurr);
+        unsigned Len = buffLen;
+        if(Len > Remainder) Len = Remainder;
+        memcpy(buff,m_pCurr,Len);
+        m_pCurr += Len;
+        if(Len < buffLen)
+        {
+            memset(buff+Len,0,buffLen-Len);
+        }
+        return Len;
+    }
+
+    //const char* name() 
+    //{ 
+    //    return(&fileNameANSI[0]); 
+    //}
+
+    const WCHAR* namew()
+    {
+        return fileNameW;
+    }
+
+    void set_namew(const WCHAR* namew)
+    {
+        fileNameW = namew;
+    }
+
+    BOOL IsValid()
+    {
+        return(m_pStart != NULL); 
+    }
+    
+	char* getLine(int lineNum)
+	{
+        return NULL; // this function is not used
+	}
+
+private:
+    char* map_file()
+    {
+        DWORD dwFileSizeLow;
+        
+        dwFileSizeLow = GetFileSize( m_hFile, NULL); 
+        if (dwFileSizeLow == INVALID_FILE_SIZE)
+            return NULL;
+        m_FileSize = dwFileSizeLow;
+    
+        // No difference between A and W in this case: last param (LPCTSTR) is NULL
+        m_hMapFile = WszCreateFileMapping(m_hFile, NULL, PAGE_READONLY, 0, 0, NULL);
+        if (m_hMapFile == NULL)
+            return NULL;
+    
+        return (char*)(HMODULE) MapViewOfFile(m_hMapFile, FILE_MAP_READ, 0, 0, 0);
+    }
+    char* open(const WCHAR* moduleName)
+    {
+        _ASSERTE(moduleName);
+        if (!moduleName)
+            return NULL;
+    
+        m_hFile = WszCreateFile(moduleName, GENERIC_READ, FILE_SHARE_READ,
+                             0, OPEN_EXISTING, 0, 0);
+        return (m_hFile == INVALID_HANDLE_VALUE) ? NULL : map_file();
+    }
+
+    const WCHAR* fileNameW;     // FileName (for error reporting)
+	//char	fileNameANSI[MAX_FILENAME_LENGTH*4];
+    HANDLE  m_hFile;                 // File we are reading from
+    DWORD   m_FileSize;
+    HANDLE  m_hMapFile;
+    char*   m_pStart;
+    char*   m_pEnd;
+    char*   m_pCurr;
+
+};
+
+typedef LIFO<ARG_NAME_LIST> ARG_NAME_LIST_STACK;
+
+// functional pointers used in parsing
+/*--------------------------------------------------------------------------*/
+typedef char*(*PFN_NEXTCHAR)(char*);
+
+char* nextcharA(__in __nullterminated char* pos);
+char* nextcharU(__in __nullterminated char* pos);
+char* nextcharW(__in __nullterminated char* pos);
+
+/*--------------------------------------------------------------------------*/
+typedef unsigned(*PFN_SYM)(char*);
+
+unsigned SymAU(__in __nullterminated char* curPos);
+unsigned SymW(__in __nullterminated char* curPos);
+/*--------------------------------------------------------------------------*/
+typedef char*(*PFN_NEWSTRFROMTOKEN)(char*,size_t);
+
+char* NewStrFromTokenAU(__in_ecount(tokLen) char* curTok, size_t tokLen);
+char* NewStrFromTokenW(__in_ecount(tokLen) char* curTok, size_t tokLen);
+/*--------------------------------------------------------------------------*/
+typedef char*(*PFN_NEWSTATICSTRFROMTOKEN)(char*,size_t,char*,size_t);
+
+char* NewStaticStrFromTokenAU(__in_ecount(tokLen) char* curTok, size_t tokLen, __out_ecount(bufSize) char* staticBuf, size_t bufSize);
+char* NewStaticStrFromTokenW(__in_ecount(tokLen) char* curTok, size_t tokLen, __out_ecount(bufSize) char* staticBuf, size_t bufSize);
+/*--------------------------------------------------------------------------*/
+typedef unsigned(*PFN_GETDOUBLE)(char*,unsigned,double**);
+
+unsigned GetDoubleAU(__in __nullterminated char* begNum, unsigned L, double** ppRes);
+unsigned GetDoubleW(__in __nullterminated char* begNum, unsigned L, double** ppRes);
+/*--------------------------------------------------------------------------*/
+struct PARSING_ENVIRONMENT
+{
+    char* curTok;         		// The token we are in the process of processing (for error reporting)
+    char* curPos;               // current place in input buffer
+    char* endPos;				// points just past the end of valid data in the buffer
+
+    ReadStream* in;             // how we fill up our buffer
+
+    PFN_NEXTCHAR    pfn_nextchar;
+    PFN_SYM         pfn_Sym;
+    PFN_NEWSTRFROMTOKEN pfn_NewStrFromToken;
+    PFN_NEWSTATICSTRFROMTOKEN pfn_NewStaticStrFromToken;
+    PFN_GETDOUBLE   pfn_GetDouble;
+
+    bool bExternSource;
+    bool bExternSourceAutoincrement;
+    unsigned  nExtLine;
+    unsigned  nExtCol;
+    unsigned  nExtLineEnd;
+    unsigned  nExtColEnd;
+    unsigned curLine;           // Line number (for error reporting)
+
+    unsigned  uCodePage;
+
+    char    szFileName[MAX_FILENAME_LENGTH*3+1];
+
+};
+typedef LIFO<PARSING_ENVIRONMENT> PARSING_ENVIRONMENT_STACK;
+
+/**************************************************************************/
+/* AsmParse does all the parsing.  It also builds up simple data structures,  
+   (like signatures), but does not do the any 'heavy lifting' like define
+   methods or classes.  Instead it calls to the Assembler object to do that */
+
+class AsmParse : public ErrorReporter 
+{
+public:
+    AsmParse(ReadStream* stream, Assembler *aAssem);
+    ~AsmParse();
+    void CreateEnvironment(ReadStream* stream);
+	void ParseFile(ReadStream* stream); 
+        // The parser knows how to put line numbers on things and report the error 
+    virtual void error(const char* fmt, ...);
+    virtual void warn(const char* fmt, ...);
+    virtual void msg(const char* fmt, ...);
+	char *getLine(int lineNum) { return penv->in->getLine(lineNum); };
+    unsigned getAll(__out char** pbuff) { return penv->in->getAll(pbuff); };
+	bool Success() {return success; };
+    void SetIncludePath(__in WCHAR* wz) { wzIncludePath = wz; };
+
+    ARG_NAME_LIST_STACK  m_ANSFirst;
+    ARG_NAME_LIST_STACK  m_ANSLast;
+    PARSING_ENVIRONMENT *penv;
+    PARSING_ENVIRONMENT_STACK   PEStack;
+
+private:
+    BinStr* MakeSig(unsigned callConv, BinStr* retType, BinStr* args, int ntyargs = 0);
+    BinStr* MakeTypeClass(CorElementType kind, mdToken tk);
+    BinStr* MakeTypeArray(CorElementType kind, BinStr* elemType, BinStr* bounds);
+
+    char* fillBuff(__in_opt __nullterminated char* curPos);   // refill the input buffer
+    DWORD IsItUnicode(CONST LPVOID pBuff, int cb, LPINT lpi);
+	HANDLE	hstdout;
+	HANDLE	hstderr;
+
+private:
+	friend void yyerror(__in __nullterminated char* str);
+    friend int parse_literal(unsigned curSym, __inout __nullterminated char* &curPos, BOOL translate_escapes);
+    friend int yyparse();
+    friend int yylex();
+    friend Instr* SetupInstr(unsigned short opcode);
+    friend int findKeyword(const char* name, size_t nameLen, unsigned short* opcode);
+    friend TypeDefDescr* findTypedef(__in_ecount(nameLen) char* name, size_t nameLen);
+    friend char* skipBlanks(__in __nullterminated char*,unsigned*);
+    friend char* nextBlank(__in __nullterminated char*);
+    friend int ProcessEOF();
+    friend unsigned __int8* skipType(unsigned __int8* ptr, BOOL fFixupType);
+    friend void FixupConstraints();
+
+	Assembler* assem;			// This does most of the semantic processing
+    bool success;               // overall success of the compilation
+    WCHAR* wzIncludePath;
+};
+
+#endif
+
diff --git a/src/ilasm/asmparse.y b/src/ilasm/asmparse.y
new file mode 100644
index 0000000000..6619cfba20
--- /dev/null
+++ b/src/ilasm/asmparse.y
@@ -0,0 +1,2053 @@
+%{
+
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// File asmparse.y
+//
+#include "ilasmpch.h"
+
+#include "grammar_before.cpp"
+
+%}
+
+%union {
+        CorRegTypeAttr classAttr;
+        CorMethodAttr methAttr;
+        CorFieldAttr fieldAttr;
+        CorMethodImpl implAttr;
+        CorEventAttr  eventAttr;
+        CorPropertyAttr propAttr;
+        CorPinvokeMap pinvAttr;
+        CorDeclSecurity secAct;
+        CorFileFlags fileAttr;
+        CorAssemblyFlags asmAttr;
+        CorAssemblyFlags asmRefAttr;
+        CorTypeAttr exptAttr;
+        CorManifestResourceFlags manresAttr;
+        double*  float64;
+        __int64* int64;
+        __int32  int32;
+        char*    string;
+        BinStr*  binstr;
+        Labels*  labels;
+        Instr*   instr;         // instruction opcode
+        NVPair*  pair;
+        pTyParList typarlist;
+        mdToken token;
+        TypeDefDescr* tdd;
+        CustomDescr*  cad;
+        unsigned short opcode;
+};
+
+        /* These are returned by the LEXER and have values */
+%token ERROR_ BAD_COMMENT_ BAD_LITERAL_                         /* bad strings,    */
+%token <string>  ID             /* testing343 */
+%token <string>  DOTTEDNAME     /* System.Object */
+%token <binstr>  QSTRING        /* "Hello World\n" */
+%token <string>  SQSTRING       /* 'Hello World\n' */
+%token <int32>   INT32          /* 3425 0x34FA  0352  */
+%token <int64>   INT64          /* 342534523534534      0x34FA434644554 */
+%token <float64> FLOAT64        /* -334234 24E-34 */
+%token <int32>   HEXBYTE        /* 05 1A FA */
+%token <tdd>     TYPEDEF_T
+%token <tdd>     TYPEDEF_M
+%token <tdd>     TYPEDEF_F
+%token <tdd>     TYPEDEF_TS
+%token <tdd>     TYPEDEF_MR
+%token <tdd>     TYPEDEF_CA
+
+
+        /* multi-character punctuation */
+%token DCOLON                   /* :: */
+%token ELIPSIS                  /* ... */
+
+        /* Keywords   Note the undersores are to avoid collisions as these are common names */
+%token VOID_ BOOL_ CHAR_ UNSIGNED_ INT_ INT8_ INT16_ INT32_ INT64_ FLOAT_ FLOAT32_ FLOAT64_ BYTEARRAY_
+%token UINT_ UINT8_ UINT16_ UINT32_ UINT64_  FLAGS_ CALLCONV_ MDTOKEN_
+%token OBJECT_ STRING_ NULLREF_
+        /* misc keywords */ 
+%token DEFAULT_ CDECL_ VARARG_ STDCALL_ THISCALL_ FASTCALL_ CLASS_ 
+%token TYPEDREF_ UNMANAGED_ FINALLY_ HANDLER_ CATCH_ FILTER_ FAULT_
+%token EXTENDS_ IMPLEMENTS_ TO_ AT_ TLS_ TRUE_ FALSE_ _INTERFACEIMPL
+
+        /* class, method, field attributes */
+
+%token VALUE_ VALUETYPE_ NATIVE_ INSTANCE_ SPECIALNAME_ FORWARDER_
+%token STATIC_ PUBLIC_ PRIVATE_ FAMILY_ FINAL_ SYNCHRONIZED_ INTERFACE_ SEALED_ NESTED_
+%token ABSTRACT_ AUTO_ SEQUENTIAL_ EXPLICIT_ ANSI_ UNICODE_ AUTOCHAR_ IMPORT_ ENUM_
+%token VIRTUAL_ NOINLINING_ AGGRESSIVEINLINING_ NOOPTIMIZATION_ UNMANAGEDEXP_ BEFOREFIELDINIT_
+%token STRICT_ RETARGETABLE_ WINDOWSRUNTIME_ NOPLATFORM_
+%token METHOD_ FIELD_ PINNED_ MODREQ_ MODOPT_ SERIALIZABLE_ PROPERTY_ TYPE_
+%token ASSEMBLY_ FAMANDASSEM_ FAMORASSEM_ PRIVATESCOPE_ HIDEBYSIG_ NEWSLOT_ RTSPECIALNAME_ PINVOKEIMPL_
+%token _CTOR _CCTOR LITERAL_ NOTSERIALIZED_ INITONLY_ REQSECOBJ_
+        /* method implementation attributes: NATIVE_ and UNMANAGED_ listed above */
+%token CIL_ OPTIL_ MANAGED_ FORWARDREF_ PRESERVESIG_ RUNTIME_ INTERNALCALL_
+        /* PInvoke-specific keywords */
+%token _IMPORT NOMANGLE_ LASTERR_ WINAPI_ AS_ BESTFIT_ ON_ OFF_ CHARMAPERROR_
+
+        /* intruction tokens (actually instruction groupings) */
+%token <opcode> INSTR_NONE INSTR_VAR INSTR_I INSTR_I8 INSTR_R INSTR_BRTARGET INSTR_METHOD INSTR_FIELD 
+%token <opcode> INSTR_TYPE INSTR_STRING INSTR_SIG INSTR_TOK 
+%token <opcode> INSTR_SWITCH
+
+        /* assember directives */
+%token _CLASS _NAMESPACE _METHOD _FIELD _DATA _THIS _BASE _NESTER
+%token _EMITBYTE _TRY _MAXSTACK _LOCALS _ENTRYPOINT _ZEROINIT  
+%token _EVENT _ADDON _REMOVEON _FIRE _OTHER 
+%token _PROPERTY _SET _GET DEFAULT_ 
+%token _PERMISSION _PERMISSIONSET
+
+                /* security actions */
+%token REQUEST_ DEMAND_ ASSERT_ DENY_ PERMITONLY_ LINKCHECK_ INHERITCHECK_ 
+%token REQMIN_ REQOPT_ REQREFUSE_ PREJITGRANT_ PREJITDENY_ NONCASDEMAND_
+%token NONCASLINKDEMAND_ NONCASINHERITANCE_ 
+
+        /* extern debug info specifier (to be used by precompilers only) */
+%token _LINE P_LINE _LANGUAGE
+        /* custom value specifier */
+%token _CUSTOM
+        /* local vars zeroinit specifier */
+%token INIT_
+        /* class layout */
+%token _SIZE _PACK
+%token _VTABLE _VTFIXUP FROMUNMANAGED_ CALLMOSTDERIVED_ _VTENTRY RETAINAPPDOMAIN_
+        /* manifest */
+%token _FILE NOMETADATA_ _HASH _ASSEMBLY _PUBLICKEY _PUBLICKEYTOKEN ALGORITHM_ _VER _LOCALE EXTERN_ 
+%token _MRESOURCE 
+%token _MODULE _EXPORT
+%token LEGACY_ LIBRARY_ X86_ IA64_ AMD64_ ARM_
+        /* field marshaling */
+%token MARSHAL_ CUSTOM_ SYSSTRING_ FIXED_ VARIANT_ CURRENCY_ SYSCHAR_ DECIMAL_ DATE_ BSTR_ TBSTR_ LPSTR_
+%token LPWSTR_ LPTSTR_ OBJECTREF_ IUNKNOWN_ IDISPATCH_ STRUCT_ SAFEARRAY_ BYVALSTR_ LPVOID_ ANY_ ARRAY_ LPSTRUCT_
+%token IIDPARAM_
+        /* parameter attributes */
+%token IN_ OUT_ OPT_ PARAM_
+                /* method implementations */
+%token _OVERRIDE WITH_
+                /* variant type specifics */
+%token NULL_ ERROR_ HRESULT_ CARRAY_ USERDEFINED_ RECORD_ FILETIME_ BLOB_ STREAM_ STORAGE_
+%token STREAMED_OBJECT_ STORED_OBJECT_ BLOB_OBJECT_ CF_ CLSID_ VECTOR_
+                /* header flags */
+%token _SUBSYSTEM _CORFLAGS ALIGNMENT_ _IMAGEBASE _STACKRESERVE
+
+        /* syntactic sugar */
+%token _TYPEDEF _TEMPLATE _TYPELIST _MSCORLIB      
+
+        /* compilation control directives */
+%token P_DEFINE P_UNDEF P_IFDEF P_IFNDEF P_ELSE P_ENDIF P_INCLUDE
+
+        /* nonTerminals */
+%type <string> dottedName id methodName atOpt slashedName
+%type <labels> labels
+%type <int32> callConv callKind int32 customHead customHeadWithOwner vtfixupAttr paramAttr ddItemCount variantType repeatOpt truefalse typarAttrib typarAttribs
+%type <int32> iidParamIndex genArity genArityNotEmpty
+%type <float64> float64
+%type <int64> int64
+%type <binstr> sigArgs0 sigArgs1 sigArg type bound bounds1 bytes hexbytes nativeType marshalBlob initOpt compQstring caValue
+%type <binstr> marshalClause
+%type <binstr> fieldInit serInit fieldSerInit
+%type <binstr> f32seq f64seq i8seq i16seq i32seq i64seq boolSeq sqstringSeq classSeq objSeq
+%type <binstr> simpleType
+%type <binstr> tyArgs0 tyArgs1 tyArgs2 typeList typeListNotEmpty tyBound
+%type <binstr> customBlobDescr serializType customBlobArgs customBlobNVPairs
+%type <binstr> secAttrBlob secAttrSetBlob
+%type <int32> fieldOrProp intOrWildcard
+%type <typarlist> typarsRest typars typarsClause
+%type <token> className typeSpec ownerType customType memberRef methodRef mdtoken
+%type <classAttr> classAttr
+%type <methAttr> methAttr
+%type <fieldAttr> fieldAttr
+%type <implAttr> implAttr
+%type <eventAttr> eventAttr
+%type <propAttr> propAttr
+%type <pinvAttr> pinvAttr
+%type <pair> nameValPairs nameValPair
+%type <secAct> secAction
+%type <secAct> psetHead
+%type <fileAttr> fileAttr
+%type <fileAttr> fileEntry
+%type <asmAttr> asmAttr
+%type <exptAttr> exptAttr
+%type <manresAttr> manresAttr
+%type <cad> customDescr customDescrWithOwner
+%type <instr> instr_none instr_var instr_i instr_i8 instr_r instr_brtarget instr_method instr_field
+%type <instr> instr_type instr_string instr_sig instr_tok instr_switch
+%type <instr> instr_r_head
+
+%start decls
+
+/**************************************************************************/
+%%      
+
+decls                   : /* EMPTY */
+                        | decls decl                                            
+                        ;
+/* Module-level declarations */
+decl                    : classHead '{' classDecls '}'                          { PASM->EndClass(); }
+                        | nameSpaceHead '{' decls '}'                           { PASM->EndNameSpace(); }
+                        | methodHead  methodDecls '}'                           { if(PASM->m_pCurMethod->m_ulLines[1] ==0)
+                                                                                  {  PASM->m_pCurMethod->m_ulLines[1] = PASM->m_ulCurLine;
+                                                                                     PASM->m_pCurMethod->m_ulColumns[1]=PASM->m_ulCurColumn;}
+                                                                                  PASM->EndMethod(); }
+                        | fieldDecl
+                        | dataDecl
+                        | vtableDecl
+                        | vtfixupDecl
+                        | extSourceSpec
+                        | fileDecl
+                        | assemblyHead '{' assemblyDecls '}'                    { PASMM->EndAssembly(); }
+                        | assemblyRefHead '{' assemblyRefDecls '}'              { PASMM->EndAssembly(); }
+                        | exptypeHead '{' exptypeDecls '}'                      { PASMM->EndComType(); }
+                        | manifestResHead '{' manifestResDecls '}'              { PASMM->EndManifestRes(); }
+                        | moduleHead
+                        | secDecl
+                        | customAttrDecl
+                        | _SUBSYSTEM int32                                      { 
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:22011) // Suppress PREFast warning about integer overflow/underflow
+#endif
+                                                                                  PASM->m_dwSubsystem = $2;
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif
+                                                                                }
+                        | _CORFLAGS int32                                       { PASM->m_dwComImageFlags = $2; }
+                        | _FILE ALIGNMENT_ int32                                { PASM->m_dwFileAlignment = $3; 
+                                                                                  if(($3 & ($3 - 1))||($3 < 0x200)||($3 > 0x10000))
+                                                                                    PASM->report->error("Invalid file alignment, must be power of 2 from 0x200 to 0x10000\n");}
+                        | _IMAGEBASE int64                                      { PASM->m_stBaseAddress = (ULONGLONG)(*($2)); delete $2; 
+                                                                                  if(PASM->m_stBaseAddress & 0xFFFF)
+                                                                                    PASM->report->error("Invalid image base, must be 0x10000-aligned\n");}
+                        | _STACKRESERVE int64                                   { PASM->m_stSizeOfStackReserve = (size_t)(*($2)); delete $2; }
+                        | languageDecl
+                        | typedefDecl
+                        | compControl
+                        | _TYPELIST '{' classNameSeq '}'
+                        | _MSCORLIB                                             { PASM->m_fIsMscorlib = TRUE; }
+                        ;
+                        
+classNameSeq            : /* EMPTY */
+                        | className classNameSeq
+                        ;                        
+
+compQstring             : QSTRING                                               { $$ = $1; }
+                        | compQstring '+' QSTRING                               { $$ = $1; $$->append($3); delete $3; }
+                        ;
+
+languageDecl            : _LANGUAGE SQSTRING                                    { LPCSTRToGuid($2,&(PASM->m_guidLang)); }
+                        | _LANGUAGE SQSTRING ',' SQSTRING                       { LPCSTRToGuid($2,&(PASM->m_guidLang)); 
+                                                                                  LPCSTRToGuid($4,&(PASM->m_guidLangVendor));}
+                        | _LANGUAGE SQSTRING ',' SQSTRING ',' SQSTRING          { LPCSTRToGuid($2,&(PASM->m_guidLang)); 
+                                                                                  LPCSTRToGuid($4,&(PASM->m_guidLangVendor));
+                                                                                  LPCSTRToGuid($4,&(PASM->m_guidDoc));}
+                        ;
+/*  Basic tokens  */                        
+id                      : ID                                  { $$ = $1; }
+                        | SQSTRING                            { $$ = $1; }
+                        ;
+
+dottedName              : id                                  { $$ = $1; }
+                        | DOTTEDNAME                          { $$ = $1; }
+                        | dottedName '.' dottedName           { $$ = newStringWDel($1, '.', $3); }
+                        ;
+
+int32                   : INT32                               { $$ = $1; }
+                        ;
+
+int64                   : INT64                               { $$ = $1; }
+                        | INT32                               { $$ = neg ? new __int64($1) : new __int64((unsigned)$1); }
+                        ;
+
+float64                 : FLOAT64                             { $$ = $1; }
+                        | FLOAT32_ '(' int32 ')'              { float f; *((__int32*) (&f)) = $3; $$ = new double(f); }
+                        | FLOAT64_ '(' int64 ')'              { $$ = (double*) $3; }
+                        ;
+
+/*  Aliasing of types, type specs, methods, fields and custom attributes */                        
+typedefDecl             : _TYPEDEF type AS_ dottedName                          { PASM->AddTypeDef($2,$4); }
+                        | _TYPEDEF className AS_ dottedName                     { PASM->AddTypeDef($2,$4); }
+                        | _TYPEDEF memberRef AS_ dottedName                     { PASM->AddTypeDef($2,$4); }
+                        | _TYPEDEF customDescr AS_ dottedName                   { $2->tkOwner = 0; PASM->AddTypeDef($2,$4); }
+                        | _TYPEDEF customDescrWithOwner AS_ dottedName          { PASM->AddTypeDef($2,$4); }
+                        ;
+                        
+/*  Compilation control directives are processed within yylex(), 
+    displayed here just for grammar completeness */
+compControl             : P_DEFINE dottedName                                   { DefineVar($2, NULL); }
+                        | P_DEFINE dottedName compQstring                       { DefineVar($2, $3); }
+                        | P_UNDEF dottedName                                    { UndefVar($2); }
+                        | P_IFDEF dottedName                                    { SkipToken = !IsVarDefined($2);
+                                                                                  IfEndif++;
+                                                                                }                        
+                        | P_IFNDEF dottedName                                   { SkipToken = IsVarDefined($2);
+                                                                                  IfEndif++;
+                                                                                } 
+                        | P_ELSE                                                { if(IfEndif == 1) SkipToken = !SkipToken;}
+                        | P_ENDIF                                               { if(IfEndif == 0)
+                                                                                    PASM->report->error("Unmatched #endif\n");
+                                                                                  else IfEndif--;
+                                                                                }
+                        | P_INCLUDE QSTRING                                     { _ASSERTE(!"yylex should have dealt with this"); }
+                        | ';'                                                   { }
+                        ; 
+                                              
+/* Custom attribute declarations  */
+customDescr             : _CUSTOM customType                                    { $$ = new CustomDescr(PASM->m_tkCurrentCVOwner, $2, NULL); }
+                        | _CUSTOM customType '=' compQstring                    { $$ = new CustomDescr(PASM->m_tkCurrentCVOwner, $2, $4); }
+                        | _CUSTOM customType '=' '{' customBlobDescr '}'        { $$ = new CustomDescr(PASM->m_tkCurrentCVOwner, $2, $5); }
+                        | customHead bytes ')'                                  { $$ = new CustomDescr(PASM->m_tkCurrentCVOwner, $1, $2); }
+                        ;
+
+customDescrWithOwner    : _CUSTOM '(' ownerType ')' customType                  { $$ = new CustomDescr($3, $5, NULL); }
+                        | _CUSTOM '(' ownerType ')' customType '=' compQstring  { $$ = new CustomDescr($3, $5, $7); }
+                        | _CUSTOM '(' ownerType ')' customType '=' '{' customBlobDescr '}'
+                                                                                { $$ = new CustomDescr($3, $5, $8); }
+                        | customHeadWithOwner bytes ')'                         { $$ = new CustomDescr(PASM->m_tkCurrentCVOwner, $1, $2); }
+                        ;
+                        
+customHead              : _CUSTOM customType '=' '('                            { $$ = $2; bParsingByteArray = TRUE; }
+                        ;
+
+customHeadWithOwner     : _CUSTOM '(' ownerType ')' customType '=' '('        
+                                                                                { PASM->m_pCustomDescrList = NULL;
+                                                                                  PASM->m_tkCurrentCVOwner = $3;
+                                                                                  $$ = $5; bParsingByteArray = TRUE; }
+                        ;
+
+customType              : methodRef                         { $$ = $1; }
+                        ;
+
+ownerType               : typeSpec                          { $$ = $1; }
+                        | memberRef                         { $$ = $1; }
+                        ;
+
+/*  Verbal description of custom attribute initialization blob  */                        
+customBlobDescr         : customBlobArgs customBlobNVPairs                      { $$ = $1; 
+                                                                                  $$->appendInt16(nCustomBlobNVPairs);
+                                                                                  $$->append($2);
+                                                                                  nCustomBlobNVPairs = 0; }
+                        ;
+                        
+customBlobArgs          : /* EMPTY */                                           { $$ = new BinStr(); $$->appendInt16(VAL16(0x0001)); }
+                        | customBlobArgs serInit                                { $$ = $1;
+                                                                                  $$->appendFrom($2, (*($2->ptr()) == ELEMENT_TYPE_SZARRAY) ? 2 : 1); }
+                        | customBlobArgs compControl                            { $$ = $1; }
+                        ;
+                        
+customBlobNVPairs       : /* EMPTY */                                           { $$ = new BinStr(); }
+                        | customBlobNVPairs fieldOrProp serializType dottedName '=' serInit
+                                                                                { $$ = $1; $$->appendInt8($2);
+                                                                                  $$->append($3); 
+                                                                                  AppendStringWithLength($$,$4);
+                                                                                  $$->appendFrom($6, (*($6->ptr()) == ELEMENT_TYPE_SZARRAY) ? 2 : 1);
+                                                                                  nCustomBlobNVPairs++; }
+                        | customBlobNVPairs compControl                         { $$ = $1; }
+                        ;
+
+fieldOrProp             : FIELD_                                                { $$ = SERIALIZATION_TYPE_FIELD; }
+                        | PROPERTY_                                             { $$ = SERIALIZATION_TYPE_PROPERTY; }
+                        ;
+
+customAttrDecl          : customDescr                                           { if($1->tkOwner && !$1->tkInterfacePair) 
+                                                                                    PASM->DefineCV($1);
+                                                                                  else if(PASM->m_pCustomDescrList)
+                                                                                    PASM->m_pCustomDescrList->PUSH($1); }
+                        | customDescrWithOwner                                  { PASM->DefineCV($1); }
+                        | TYPEDEF_CA                                            { CustomDescr* pNew = new CustomDescr($1->m_pCA);
+                                                                                  if(pNew->tkOwner == 0) pNew->tkOwner = PASM->m_tkCurrentCVOwner;
+                                                                                  if(pNew->tkOwner) 
+                                                                                    PASM->DefineCV(pNew);
+                                                                                  else if(PASM->m_pCustomDescrList)
+                                                                                    PASM->m_pCustomDescrList->PUSH(pNew); }
+                        ;
+                        
+serializType            : simpleType                          { $$ = $1; }
+                        | TYPE_                               { $$ = new BinStr(); $$->appendInt8(SERIALIZATION_TYPE_TYPE); }
+                        | OBJECT_                             { $$ = new BinStr(); $$->appendInt8(SERIALIZATION_TYPE_TAGGED_OBJECT); }
+                        | ENUM_ CLASS_ SQSTRING               { $$ = new BinStr(); $$->appendInt8(SERIALIZATION_TYPE_ENUM);
+                                                                AppendStringWithLength($$,$3); } 
+                        | ENUM_ className                     { $$ = new BinStr(); $$->appendInt8(SERIALIZATION_TYPE_ENUM);
+                                                                AppendStringWithLength($$,PASM->ReflectionNotation($2)); } 
+                        | serializType '[' ']'                { $$ = $1; $$->insertInt8(ELEMENT_TYPE_SZARRAY); } 
+                        ;
+
+                        
+/*  Module declaration */
+moduleHead              : _MODULE                                               { PASMM->SetModuleName(NULL); PASM->m_tkCurrentCVOwner=1; }
+                        | _MODULE dottedName                                    { PASMM->SetModuleName($2); PASM->m_tkCurrentCVOwner=1; }
+                        | _MODULE EXTERN_ dottedName                            { BinStr* pbs = new BinStr();
+                                                                                  unsigned L = (unsigned)strlen($3);
+                                                                                  memcpy((char*)(pbs->getBuff(L)),$3,L);
+                                                                                  PASM->EmitImport(pbs); delete pbs;}
+                        ;
+                        
+/*  VTable Fixup table declaration  */
+vtfixupDecl             : _VTFIXUP '[' int32 ']' vtfixupAttr AT_ id             { /*PASM->SetDataSection(); PASM->EmitDataLabel($7);*/
+                                                                                  PASM->m_VTFList.PUSH(new VTFEntry((USHORT)$3, (USHORT)$5, $7)); }
+                        ;
+
+vtfixupAttr             : /* EMPTY */                                           { $$ = 0; }
+                        | vtfixupAttr INT32_                                    { $$ = $1 | COR_VTABLE_32BIT; }
+                        | vtfixupAttr INT64_                                    { $$ = $1 | COR_VTABLE_64BIT; }
+                        | vtfixupAttr FROMUNMANAGED_                            { $$ = $1 | COR_VTABLE_FROM_UNMANAGED; }
+                        | vtfixupAttr CALLMOSTDERIVED_                          { $$ = $1 | COR_VTABLE_CALL_MOST_DERIVED; }
+                        | vtfixupAttr RETAINAPPDOMAIN_                          { $$ = $1 | COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN; }
+                        ;
+
+vtableDecl              : vtableHead bytes ')'   /* deprecated */               { PASM->m_pVTable = $2; }
+                        ;
+
+vtableHead              : _VTABLE '=' '('        /* deprecated */               { bParsingByteArray = TRUE; }
+                        ;
+
+/*  Namespace and class declaration  */                         
+nameSpaceHead           : _NAMESPACE dottedName                                 { PASM->StartNameSpace($2); }
+                        ;
+
+_class                  : _CLASS                                                { newclass = TRUE; }
+                        ;
+                        
+classHeadBegin          : _class classAttr dottedName typarsClause              { if($4) FixupConstraints();
+                                                                                  PASM->StartClass($3, $2, $4); 
+                                                                                  TyParFixupList.RESET(false);
+                                                                                  newclass = FALSE;
+                                                                                }
+                        ;
+classHead               : classHeadBegin extendsClause implClause               { PASM->AddClass(); }
+                        ;
+
+classAttr               : /* EMPTY */                       { $$ = (CorRegTypeAttr) 0; }
+                        | classAttr PUBLIC_                 { $$ = (CorRegTypeAttr) (($1 & ~tdVisibilityMask) | tdPublic); }
+                        | classAttr PRIVATE_                { $$ = (CorRegTypeAttr) (($1 & ~tdVisibilityMask) | tdNotPublic); }
+                        | classAttr VALUE_                  { $$ = (CorRegTypeAttr) ($1 | 0x80000000 | tdSealed); }
+                        | classAttr ENUM_                   { $$ = (CorRegTypeAttr) ($1 | 0x40000000); }
+                        | classAttr INTERFACE_              { $$ = (CorRegTypeAttr) ($1 | tdInterface | tdAbstract); }
+                        | classAttr SEALED_                 { $$ = (CorRegTypeAttr) ($1 | tdSealed); }
+                        | classAttr ABSTRACT_               { $$ = (CorRegTypeAttr) ($1 | tdAbstract); }
+                        | classAttr AUTO_                   { $$ = (CorRegTypeAttr) (($1 & ~tdLayoutMask) | tdAutoLayout); }
+                        | classAttr SEQUENTIAL_             { $$ = (CorRegTypeAttr) (($1 & ~tdLayoutMask) | tdSequentialLayout); }
+                        | classAttr EXPLICIT_               { $$ = (CorRegTypeAttr) (($1 & ~tdLayoutMask) | tdExplicitLayout); }
+                        | classAttr ANSI_                   { $$ = (CorRegTypeAttr) (($1 & ~tdStringFormatMask) | tdAnsiClass); }
+                        | classAttr UNICODE_                { $$ = (CorRegTypeAttr) (($1 & ~tdStringFormatMask) | tdUnicodeClass); }
+                        | classAttr AUTOCHAR_               { $$ = (CorRegTypeAttr) (($1 & ~tdStringFormatMask) | tdAutoClass); }
+                        | classAttr IMPORT_                 { $$ = (CorRegTypeAttr) ($1 | tdImport); }
+                        | classAttr SERIALIZABLE_           { $$ = (CorRegTypeAttr) ($1 | tdSerializable); }
+                        | classAttr WINDOWSRUNTIME_         { $$ = (CorRegTypeAttr) ($1 | tdWindowsRuntime); }
+                        | classAttr NESTED_ PUBLIC_         { $$ = (CorRegTypeAttr) (($1 & ~tdVisibilityMask) | tdNestedPublic); }
+                        | classAttr NESTED_ PRIVATE_        { $$ = (CorRegTypeAttr) (($1 & ~tdVisibilityMask) | tdNestedPrivate); }
+                        | classAttr NESTED_ FAMILY_         { $$ = (CorRegTypeAttr) (($1 & ~tdVisibilityMask) | tdNestedFamily); }
+                        | classAttr NESTED_ ASSEMBLY_       { $$ = (CorRegTypeAttr) (($1 & ~tdVisibilityMask) | tdNestedAssembly); }
+                        | classAttr NESTED_ FAMANDASSEM_    { $$ = (CorRegTypeAttr) (($1 & ~tdVisibilityMask) | tdNestedFamANDAssem); }
+                        | classAttr NESTED_ FAMORASSEM_     { $$ = (CorRegTypeAttr) (($1 & ~tdVisibilityMask) | tdNestedFamORAssem); }
+                        | classAttr BEFOREFIELDINIT_        { $$ = (CorRegTypeAttr) ($1 | tdBeforeFieldInit); }
+                        | classAttr SPECIALNAME_            { $$ = (CorRegTypeAttr) ($1 | tdSpecialName); }
+                        | classAttr RTSPECIALNAME_          { $$ = (CorRegTypeAttr) ($1); }
+                        | classAttr FLAGS_ '(' int32 ')'    { $$ = (CorRegTypeAttr) ($4); }
+                        ;
+
+extendsClause           : /* EMPTY */                                           
+                        | EXTENDS_ typeSpec                                 { PASM->m_crExtends = $2; }
+                        ;
+
+implClause              : /* EMPTY */
+                        | IMPLEMENTS_ implList
+                        ;
+
+classDecls              : /* EMPTY */
+                        | classDecls classDecl
+                        ;
+                        
+implList                : implList ',' typeSpec             { PASM->AddToImplList($3); }
+                        | typeSpec                          { PASM->AddToImplList($1); }
+                                        ;
+
+/* Generic type parameters declaration  */                         
+typeList                : /* EMPTY */                       { $$ = new BinStr(); }
+                        | typeListNotEmpty                  { $$ = $1; }
+                        ;
+                        
+typeListNotEmpty        : typeSpec                          { $$ = new BinStr(); $$->appendInt32($1); }
+                        | typeListNotEmpty ',' typeSpec     { $$ = $1; $$->appendInt32($3); }
+                        ;
+
+typarsClause            : /* EMPTY */                       { $$ = NULL; PASM->m_TyParList = NULL;}
+                        | '<' typars '>'                    { $$ = $2;   PASM->m_TyParList = $2;}
+                        ;
+
+typarAttrib             : '+'                               { $$ = gpCovariant; }
+                        | '-'                               { $$ = gpContravariant; }
+                        | CLASS_                            { $$ = gpReferenceTypeConstraint; }
+                        | VALUETYPE_                        { $$ = gpNotNullableValueTypeConstraint; }
+                        | _CTOR                             { $$ = gpDefaultConstructorConstraint; }
+                        ;
+                  
+typarAttribs            : /* EMPTY */                       { $$ = 0; }
+                        | typarAttrib typarAttribs          { $$ = $1 | $2; }                         
+                        ;
+
+typars                  : typarAttribs tyBound dottedName typarsRest {$$ = new TyParList($1, $2, $3, $4);}
+                        | typarAttribs dottedName typarsRest   {$$ = new TyParList($1, NULL, $2, $3);}
+                        ;
+
+typarsRest              : /* EMPTY */                       { $$ = NULL; }
+                        | ',' typars                        { $$ = $2; }
+                        ;
+
+tyBound                 : '(' typeList ')'                  { $$ = $2; }
+                        ;
+                        
+genArity                : /* EMPTY */                       { $$= 0; }
+                        | genArityNotEmpty                  { $$ = $1; }
+                        ;                        
+
+genArityNotEmpty        : '<' '[' int32 ']' '>'             { $$ = $3; }
+                        ;
+
+/*  Class body declarations  */                         
+classDecl               : methodHead  methodDecls '}'       { if(PASM->m_pCurMethod->m_ulLines[1] ==0)
+                                                              {  PASM->m_pCurMethod->m_ulLines[1] = PASM->m_ulCurLine;
+                                                                 PASM->m_pCurMethod->m_ulColumns[1]=PASM->m_ulCurColumn;}
+                                                              PASM->EndMethod(); }
+                        | classHead '{' classDecls '}'      { PASM->EndClass(); }
+                        | eventHead '{' eventDecls '}'      { PASM->EndEvent(); }
+                        | propHead '{' propDecls '}'        { PASM->EndProp(); }
+                        | fieldDecl
+                        | dataDecl
+                        | secDecl
+                        | extSourceSpec
+                        | customAttrDecl
+                        | _SIZE int32                           { PASM->m_pCurClass->m_ulSize = $2; }
+                        | _PACK int32                           { PASM->m_pCurClass->m_ulPack = $2; }
+                        | exportHead '{' exptypeDecls '}'       { PASMM->EndComType(); }
+                        | _OVERRIDE typeSpec DCOLON methodName WITH_ callConv type typeSpec DCOLON methodName '(' sigArgs0 ')'
+                                                                { BinStr *sig1 = parser->MakeSig($6, $7, $12); 
+                                                                  BinStr *sig2 = new BinStr(); sig2->append(sig1); 
+                                                                  PASM->AddMethodImpl($2,$4,sig1,$8,$10,sig2);
+                                                                  PASM->ResetArgNameList(); 
+                                                                } 
+                        | _OVERRIDE METHOD_ callConv type typeSpec DCOLON methodName genArity '(' sigArgs0 ')' WITH_ METHOD_ callConv type typeSpec DCOLON methodName genArity '(' sigArgs0 ')' 
+                                                                 { PASM->AddMethodImpl($5,$7,
+                                                                      ($8==0 ? parser->MakeSig($3,$4,$10) :
+                                                                      parser->MakeSig($3| IMAGE_CEE_CS_CALLCONV_GENERIC,$4,$10,$8)),
+                                                                      $16,$18,
+                                                                      ($19==0 ? parser->MakeSig($14,$15,$21) :
+                                                                      parser->MakeSig($14| IMAGE_CEE_CS_CALLCONV_GENERIC,$15,$21,$19))); 
+                                                                   PASM->ResetArgNameList();
+                                                                 }
+                        | languageDecl
+                        | compControl
+                        | PARAM_ TYPE_ '[' int32 ']'        { if(($4 > 0) && ($4 <= (int)PASM->m_pCurClass->m_NumTyPars))
+                                                                PASM->m_pCustomDescrList = PASM->m_pCurClass->m_TyPars[$4-1].CAList();
+                                                              else
+                                                                PASM->report->error("Type parameter index out of range\n");
+                                                            }
+                        | PARAM_ TYPE_ dottedName           { int n = PASM->m_pCurClass->FindTyPar($3);
+                                                              if(n >= 0)
+                                                                PASM->m_pCustomDescrList = PASM->m_pCurClass->m_TyPars[n].CAList();
+                                                              else
+                                                                PASM->report->error("Type parameter '%s' undefined\n",$3);
+                                                            }
+                        | _INTERFACEIMPL TYPE_ typeSpec customDescr   { $4->tkInterfacePair = $3;     
+                                                                        if(PASM->m_pCustomDescrList)
+                                                                            PASM->m_pCustomDescrList->PUSH($4);
+                                                                      }
+                        ;
+
+/*  Field declaration  */                        
+fieldDecl               : _FIELD repeatOpt fieldAttr type dottedName atOpt initOpt
+                                                            { $4->insertInt8(IMAGE_CEE_CS_CALLCONV_FIELD);
+                                                              PASM->AddField($5, $4, $3, $6, $7, $2); }
+                        ;
+
+fieldAttr               : /* EMPTY */                       { $$ = (CorFieldAttr) 0; }
+                        | fieldAttr STATIC_                 { $$ = (CorFieldAttr) ($1 | fdStatic); }
+                        | fieldAttr PUBLIC_                 { $$ = (CorFieldAttr) (($1 & ~mdMemberAccessMask) | fdPublic); }
+                        | fieldAttr PRIVATE_                { $$ = (CorFieldAttr) (($1 & ~mdMemberAccessMask) | fdPrivate); }
+                        | fieldAttr FAMILY_                 { $$ = (CorFieldAttr) (($1 & ~mdMemberAccessMask) | fdFamily); }
+                        | fieldAttr INITONLY_               { $$ = (CorFieldAttr) ($1 | fdInitOnly); }
+                        | fieldAttr RTSPECIALNAME_          { $$ = $1; } /*{ $$ = (CorFieldAttr) ($1 | fdRTSpecialName); }*/
+                        | fieldAttr SPECIALNAME_            { $$ = (CorFieldAttr) ($1 | fdSpecialName); }
+                                                /* <STRIP>commented out because PInvoke for fields is not supported by EE
+                        | fieldAttr PINVOKEIMPL_ '(' compQstring AS_ compQstring pinvAttr ')'                   
+                                                            { $$ = (CorFieldAttr) ($1 | fdPinvokeImpl); 
+                                                              PASM->SetPinvoke($4,0,$6,$7); }
+                        | fieldAttr PINVOKEIMPL_ '(' compQstring  pinvAttr ')'                      
+                                                            { $$ = (CorFieldAttr) ($1 | fdPinvokeImpl); 
+                                                              PASM->SetPinvoke($4,0,NULL,$5); }
+                        | fieldAttr PINVOKEIMPL_ '(' pinvAttr ')'                       
+                                                            { PASM->SetPinvoke(new BinStr(),0,NULL,$4); 
+                                                              $$ = (CorFieldAttr) ($1 | fdPinvokeImpl); }
+                                                </STRIP>*/
+                        | fieldAttr MARSHAL_ '(' marshalBlob ')'                 
+                                                            { PASM->m_pMarshal = $4; }
+                        | fieldAttr ASSEMBLY_               { $$ = (CorFieldAttr) (($1 & ~mdMemberAccessMask) | fdAssembly); }
+                        | fieldAttr FAMANDASSEM_            { $$ = (CorFieldAttr) (($1 & ~mdMemberAccessMask) | fdFamANDAssem); }
+                        | fieldAttr FAMORASSEM_             { $$ = (CorFieldAttr) (($1 & ~mdMemberAccessMask) | fdFamORAssem); }
+                        | fieldAttr PRIVATESCOPE_           { $$ = (CorFieldAttr) (($1 & ~mdMemberAccessMask) | fdPrivateScope); }
+                        | fieldAttr LITERAL_                { $$ = (CorFieldAttr) ($1 | fdLiteral); }
+                        | fieldAttr NOTSERIALIZED_          { $$ = (CorFieldAttr) ($1 | fdNotSerialized); }
+                        | fieldAttr FLAGS_ '(' int32 ')'    { $$ = (CorFieldAttr) ($4); }
+                        ;
+
+atOpt                   : /* EMPTY */                       { $$ = 0; } 
+                        | AT_ id                            { $$ = $2; }
+                        ;
+
+initOpt                 : /* EMPTY */                       { $$ = NULL; }
+                        | '=' fieldInit                     { $$ = $2; }
+                                                ;
+
+repeatOpt               : /* EMPTY */                       { $$ = 0xFFFFFFFF; }
+                        | '[' int32 ']'                     { $$ = $2; }
+                                                ;
+
+/*  Method referencing  */
+methodRef               : callConv type typeSpec DCOLON methodName tyArgs0 '(' sigArgs0 ')'
+                                                             { PASM->ResetArgNameList();
+                                                               if ($6 == NULL)
+                                                               {
+                                                                 if((iCallConv)&&(($1 & iCallConv) != iCallConv)) parser->warn("'instance' added to method's calling convention\n"); 
+                                                                 $$ = PASM->MakeMemberRef($3, $5, parser->MakeSig($1|iCallConv, $2, $8));
+                                                               }
+                                                               else
+                                                               {
+                                                                 mdToken mr;
+                                                                 if((iCallConv)&&(($1 & iCallConv) != iCallConv)) parser->warn("'instance' added to method's calling convention\n"); 
+                                                                 mr = PASM->MakeMemberRef($3, $5, 
+                                                                   parser->MakeSig($1 | IMAGE_CEE_CS_CALLCONV_GENERIC|iCallConv, $2, $8, corCountArgs($6)));
+                                                                 $$ = PASM->MakeMethodSpec(mr, 
+                                                                   parser->MakeSig(IMAGE_CEE_CS_CALLCONV_INSTANTIATION, 0, $6));
+                                                               }
+                                                             }
+                        | callConv type typeSpec DCOLON methodName genArityNotEmpty '(' sigArgs0 ')'
+                                                             { PASM->ResetArgNameList();
+                                                               if((iCallConv)&&(($1 & iCallConv) != iCallConv)) parser->warn("'instance' added to method's calling convention\n"); 
+                                                               $$ = PASM->MakeMemberRef($3, $5, 
+                                                                 parser->MakeSig($1 | IMAGE_CEE_CS_CALLCONV_GENERIC|iCallConv, $2, $8, $6));
+                                                             }
+                        | callConv type methodName tyArgs0 '(' sigArgs0 ')'
+                                                             { PASM->ResetArgNameList();
+                                                               if ($4 == NULL)
+                                                               {
+                                                                 if((iCallConv)&&(($1 & iCallConv) != iCallConv)) parser->warn("'instance' added to method's calling convention\n"); 
+                                                                 $$ = PASM->MakeMemberRef(mdTokenNil, $3, parser->MakeSig($1|iCallConv, $2, $6));
+                                                               }
+                                                               else
+                                                               {
+                                                                 mdToken mr;
+                                                                 if((iCallConv)&&(($1 & iCallConv) != iCallConv)) parser->warn("'instance' added to method's calling convention\n"); 
+                                                                 mr = PASM->MakeMemberRef(mdTokenNil, $3, parser->MakeSig($1 | IMAGE_CEE_CS_CALLCONV_GENERIC|iCallConv, $2, $6, corCountArgs($4)));
+                                                                 $$ = PASM->MakeMethodSpec(mr, 
+                                                                   parser->MakeSig(IMAGE_CEE_CS_CALLCONV_INSTANTIATION, 0, $4));
+                                                               }
+                                                             }
+                        | callConv type methodName genArityNotEmpty '(' sigArgs0 ')'
+                                                             { PASM->ResetArgNameList();
+                                                               if((iCallConv)&&(($1 & iCallConv) != iCallConv)) parser->warn("'instance' added to method's calling convention\n"); 
+                                                               $$ = PASM->MakeMemberRef(mdTokenNil, $3, parser->MakeSig($1 | IMAGE_CEE_CS_CALLCONV_GENERIC|iCallConv, $2, $6, $4));
+                                                             }
+                        | mdtoken                            { $$ = $1; }
+                        | TYPEDEF_M                          { $$ = $1->m_tkTypeSpec; }                                                             
+                        | TYPEDEF_MR                         { $$ = $1->m_tkTypeSpec; }                                                             
+                        ;
+                        
+callConv                : INSTANCE_ callConv                  { $$ = ($2 | IMAGE_CEE_CS_CALLCONV_HASTHIS); }
+                        | EXPLICIT_ callConv                  { $$ = ($2 | IMAGE_CEE_CS_CALLCONV_EXPLICITTHIS); }
+                        | callKind                            { $$ = $1; }
+                        | CALLCONV_ '(' int32 ')'             { $$ = $3; }
+                        ;
+
+callKind                : /* EMPTY */                         { $$ = IMAGE_CEE_CS_CALLCONV_DEFAULT; }
+                        | DEFAULT_                            { $$ = IMAGE_CEE_CS_CALLCONV_DEFAULT; }
+                        | VARARG_                             { $$ = IMAGE_CEE_CS_CALLCONV_VARARG; }
+                        | UNMANAGED_ CDECL_                   { $$ = IMAGE_CEE_CS_CALLCONV_C; }
+                        | UNMANAGED_ STDCALL_                 { $$ = IMAGE_CEE_CS_CALLCONV_STDCALL; }
+                        | UNMANAGED_ THISCALL_                { $$ = IMAGE_CEE_CS_CALLCONV_THISCALL; }
+                        | UNMANAGED_ FASTCALL_                { $$ = IMAGE_CEE_CS_CALLCONV_FASTCALL; }
+                        ;
+
+mdtoken                 : MDTOKEN_ '(' int32 ')'             { $$ = $3; }
+                        ;
+
+memberRef               : methodSpec methodRef               { $$ = $2; 
+                                                               PASM->delArgNameList(PASM->m_firstArgName);
+                                                               PASM->m_firstArgName = parser->m_ANSFirst.POP();
+                                                               PASM->m_lastArgName = parser->m_ANSLast.POP();
+                                                               PASM->SetMemberRefFixup($2,iOpcodeLen); }
+                        | FIELD_ type typeSpec DCOLON dottedName
+                                                             { $2->insertInt8(IMAGE_CEE_CS_CALLCONV_FIELD); 
+                                                               $$ = PASM->MakeMemberRef($3, $5, $2); 
+                                                               PASM->SetMemberRefFixup($$,iOpcodeLen); }
+                        | FIELD_ type dottedName
+                                                             { $2->insertInt8(IMAGE_CEE_CS_CALLCONV_FIELD); 
+                                                               $$ = PASM->MakeMemberRef(NULL, $3, $2); 
+                                                               PASM->SetMemberRefFixup($$,iOpcodeLen); }
+                        | FIELD_ TYPEDEF_F                   { $$ = $2->m_tkTypeSpec;
+                                                               PASM->SetMemberRefFixup($$,iOpcodeLen); }
+                        | FIELD_ TYPEDEF_MR                  { $$ = $2->m_tkTypeSpec;
+                                                               PASM->SetMemberRefFixup($$,iOpcodeLen); }
+                        | mdtoken                            { $$ = $1; 
+                                                               PASM->SetMemberRefFixup($$,iOpcodeLen); }
+                        ;
+
+/*  Event declaration  */                        
+eventHead               : _EVENT eventAttr typeSpec dottedName   { PASM->ResetEvent($4, $3, $2); }
+                        | _EVENT eventAttr dottedName            { PASM->ResetEvent($3, mdTypeRefNil, $2); }
+                        ;
+
+
+eventAttr               : /* EMPTY */                       { $$ = (CorEventAttr) 0; }
+                        | eventAttr RTSPECIALNAME_          { $$ = $1; }/*{ $$ = (CorEventAttr) ($1 | evRTSpecialName); }*/
+                        | eventAttr SPECIALNAME_            { $$ = (CorEventAttr) ($1 | evSpecialName); }
+                        ;
+
+eventDecls              : /* EMPTY */
+                        | eventDecls eventDecl
+                        ;
+
+eventDecl               : _ADDON methodRef                 { PASM->SetEventMethod(0, $2); }
+                        | _REMOVEON methodRef              { PASM->SetEventMethod(1, $2); }
+                        | _FIRE methodRef                  { PASM->SetEventMethod(2, $2); }
+                        | _OTHER methodRef                 { PASM->SetEventMethod(3, $2); }
+                        | extSourceSpec
+                        | customAttrDecl
+                        | languageDecl
+                        | compControl
+                        ;
+
+/*  Property declaration  */                         
+propHead                : _PROPERTY propAttr callConv type dottedName '(' sigArgs0 ')' initOpt     
+                                                            { PASM->ResetProp($5, 
+                                                              parser->MakeSig((IMAGE_CEE_CS_CALLCONV_PROPERTY |
+                                                              ($3 & IMAGE_CEE_CS_CALLCONV_HASTHIS)),$4,$7), $2, $9);}
+                        ;
+
+propAttr                : /* EMPTY */                       { $$ = (CorPropertyAttr) 0; }
+                        | propAttr RTSPECIALNAME_           { $$ = $1; }/*{ $$ = (CorPropertyAttr) ($1 | prRTSpecialName); }*/
+                        | propAttr SPECIALNAME_             { $$ = (CorPropertyAttr) ($1 | prSpecialName); }
+                        ;
+
+propDecls               : /* EMPTY */
+                        | propDecls propDecl
+                        ;
+
+
+propDecl                : _SET methodRef                    { PASM->SetPropMethod(0, $2); }
+                        | _GET methodRef                    { PASM->SetPropMethod(1, $2); }
+                        | _OTHER methodRef                  { PASM->SetPropMethod(2, $2); }
+                        | customAttrDecl
+                        | extSourceSpec
+                        | languageDecl
+                        | compControl
+                        ;
+
+/*  Method declaration  */
+methodHeadPart1         : _METHOD                           { PASM->ResetForNextMethod(); 
+                                                              uMethodBeginLine = PASM->m_ulCurLine;
+                                                              uMethodBeginColumn=PASM->m_ulCurColumn;
+                                                            }
+                        ;
+                        
+marshalClause           : /* EMPTY */                       { $$ = NULL; }
+                        | MARSHAL_ '(' marshalBlob ')'       { $$ = $3; }
+                        ;
+
+marshalBlob             : nativeType                        { $$ = $1; }
+                        | marshalBlobHead hexbytes '}'       { $$ = $2; }
+                        ;
+
+marshalBlobHead         : '{'                                { bParsingByteArray = TRUE; } 
+                        ;
+
+methodHead              : methodHeadPart1 methAttr callConv paramAttr type marshalClause methodName typarsClause'(' sigArgs0 ')' implAttr '{'
+                                                            { BinStr* sig;
+                                                              if ($8 == NULL) sig = parser->MakeSig($3, $5, $10);
+                                                              else {
+                                                               FixupTyPars($5);
+                                                               sig = parser->MakeSig($3 | IMAGE_CEE_CS_CALLCONV_GENERIC, $5, $10, $8->Count());
+                                                               FixupConstraints();
+                                                              }
+                                                              PASM->StartMethod($7, sig, $2, $6, $4, $8);
+                                                              TyParFixupList.RESET(false);
+                                                              PASM->SetImplAttr((USHORT)$12);  
+                                                              PASM->m_pCurMethod->m_ulLines[0] = uMethodBeginLine;
+                                                              PASM->m_pCurMethod->m_ulColumns[0]=uMethodBeginColumn; 
+                                                            }
+                        ;
+
+methAttr                : /* EMPTY */                       { $$ = (CorMethodAttr) 0; }
+                        | methAttr STATIC_                  { $$ = (CorMethodAttr) ($1 | mdStatic); }
+                        | methAttr PUBLIC_                  { $$ = (CorMethodAttr) (($1 & ~mdMemberAccessMask) | mdPublic); }
+                        | methAttr PRIVATE_                 { $$ = (CorMethodAttr) (($1 & ~mdMemberAccessMask) | mdPrivate); }
+                        | methAttr FAMILY_                  { $$ = (CorMethodAttr) (($1 & ~mdMemberAccessMask) | mdFamily); }
+                        | methAttr FINAL_                   { $$ = (CorMethodAttr) ($1 | mdFinal); }
+                        | methAttr SPECIALNAME_             { $$ = (CorMethodAttr) ($1 | mdSpecialName); }
+                        | methAttr VIRTUAL_                 { $$ = (CorMethodAttr) ($1 | mdVirtual); }
+                        | methAttr STRICT_                  { $$ = (CorMethodAttr) ($1 | mdCheckAccessOnOverride); }
+                        | methAttr ABSTRACT_                { $$ = (CorMethodAttr) ($1 | mdAbstract); }
+                        | methAttr ASSEMBLY_                { $$ = (CorMethodAttr) (($1 & ~mdMemberAccessMask) | mdAssem); }
+                        | methAttr FAMANDASSEM_             { $$ = (CorMethodAttr) (($1 & ~mdMemberAccessMask) | mdFamANDAssem); }
+                        | methAttr FAMORASSEM_              { $$ = (CorMethodAttr) (($1 & ~mdMemberAccessMask) | mdFamORAssem); }
+                        | methAttr PRIVATESCOPE_            { $$ = (CorMethodAttr) (($1 & ~mdMemberAccessMask) | mdPrivateScope); }
+                        | methAttr HIDEBYSIG_               { $$ = (CorMethodAttr) ($1 | mdHideBySig); }
+                        | methAttr NEWSLOT_                 { $$ = (CorMethodAttr) ($1 | mdNewSlot); }
+                        | methAttr RTSPECIALNAME_           { $$ = $1; }/*{ $$ = (CorMethodAttr) ($1 | mdRTSpecialName); }*/
+                        | methAttr UNMANAGEDEXP_            { $$ = (CorMethodAttr) ($1 | mdUnmanagedExport); }
+                        | methAttr REQSECOBJ_               { $$ = (CorMethodAttr) ($1 | mdRequireSecObject); }
+                        | methAttr FLAGS_ '(' int32 ')'     { $$ = (CorMethodAttr) ($4); }
+                        | methAttr PINVOKEIMPL_ '(' compQstring AS_ compQstring pinvAttr ')'                    
+                                                            { PASM->SetPinvoke($4,0,$6,$7); 
+                                                              $$ = (CorMethodAttr) ($1 | mdPinvokeImpl); }
+                        | methAttr PINVOKEIMPL_ '(' compQstring  pinvAttr ')'                       
+                                                            { PASM->SetPinvoke($4,0,NULL,$5); 
+                                                              $$ = (CorMethodAttr) ($1 | mdPinvokeImpl); }
+                        | methAttr PINVOKEIMPL_ '(' pinvAttr ')'                        
+                                                            { PASM->SetPinvoke(new BinStr(),0,NULL,$4); 
+                                                              $$ = (CorMethodAttr) ($1 | mdPinvokeImpl); }
+                        ;
+
+pinvAttr                : /* EMPTY */                       { $$ = (CorPinvokeMap) 0; }
+                        | pinvAttr NOMANGLE_                { $$ = (CorPinvokeMap) ($1 | pmNoMangle); }
+                        | pinvAttr ANSI_                    { $$ = (CorPinvokeMap) ($1 | pmCharSetAnsi); }
+                        | pinvAttr UNICODE_                 { $$ = (CorPinvokeMap) ($1 | pmCharSetUnicode); }
+                        | pinvAttr AUTOCHAR_                { $$ = (CorPinvokeMap) ($1 | pmCharSetAuto); }
+                        | pinvAttr LASTERR_                 { $$ = (CorPinvokeMap) ($1 | pmSupportsLastError); }
+                        | pinvAttr WINAPI_                  { $$ = (CorPinvokeMap) ($1 | pmCallConvWinapi); }
+                        | pinvAttr CDECL_                   { $$ = (CorPinvokeMap) ($1 | pmCallConvCdecl); }
+                        | pinvAttr STDCALL_                 { $$ = (CorPinvokeMap) ($1 | pmCallConvStdcall); }
+                        | pinvAttr THISCALL_                { $$ = (CorPinvokeMap) ($1 | pmCallConvThiscall); }
+                        | pinvAttr FASTCALL_                { $$ = (CorPinvokeMap) ($1 | pmCallConvFastcall); }
+                        | pinvAttr BESTFIT_ ':' ON_         { $$ = (CorPinvokeMap) ($1 | pmBestFitEnabled); }
+                        | pinvAttr BESTFIT_ ':' OFF_        { $$ = (CorPinvokeMap) ($1 | pmBestFitDisabled); }
+                        | pinvAttr CHARMAPERROR_ ':' ON_    { $$ = (CorPinvokeMap) ($1 | pmThrowOnUnmappableCharEnabled); }
+                        | pinvAttr CHARMAPERROR_ ':' OFF_   { $$ = (CorPinvokeMap) ($1 | pmThrowOnUnmappableCharDisabled); }
+                        | pinvAttr FLAGS_ '(' int32 ')'     { $$ = (CorPinvokeMap) ($4); }
+                        ;
+
+methodName              : _CTOR                             { $$ = newString(COR_CTOR_METHOD_NAME); }
+                        | _CCTOR                            { $$ = newString(COR_CCTOR_METHOD_NAME); }
+                        | dottedName                        { $$ = $1; }
+                        ;
+
+paramAttr               : /* EMPTY */                       { $$ = 0; }
+                        | paramAttr '[' IN_ ']'             { $$ = $1 | pdIn; }
+                        | paramAttr '[' OUT_ ']'            { $$ = $1 | pdOut; }
+                        | paramAttr '[' OPT_ ']'            { $$ = $1 | pdOptional; }
+                        | paramAttr '[' int32 ']'           { $$ = $3 + 1; } 
+                        ;
+        
+implAttr                : /* EMPTY */                       { $$ = (CorMethodImpl) (miIL | miManaged); }
+                        | implAttr NATIVE_                  { $$ = (CorMethodImpl) (($1 & 0xFFF4) | miNative); }
+                        | implAttr CIL_                     { $$ = (CorMethodImpl) (($1 & 0xFFF4) | miIL); }
+                        | implAttr OPTIL_                   { $$ = (CorMethodImpl) (($1 & 0xFFF4) | miOPTIL); }
+                        | implAttr MANAGED_                 { $$ = (CorMethodImpl) (($1 & 0xFFFB) | miManaged); }
+                        | implAttr UNMANAGED_               { $$ = (CorMethodImpl) (($1 & 0xFFFB) | miUnmanaged); }
+                        | implAttr FORWARDREF_              { $$ = (CorMethodImpl) ($1 | miForwardRef); }
+                        | implAttr PRESERVESIG_             { $$ = (CorMethodImpl) ($1 | miPreserveSig); }
+                        | implAttr RUNTIME_                 { $$ = (CorMethodImpl) ($1 | miRuntime); }
+                        | implAttr INTERNALCALL_            { $$ = (CorMethodImpl) ($1 | miInternalCall); }
+                        | implAttr SYNCHRONIZED_            { $$ = (CorMethodImpl) ($1 | miSynchronized); }
+                        | implAttr NOINLINING_              { $$ = (CorMethodImpl) ($1 | miNoInlining); }
+                        | implAttr AGGRESSIVEINLINING_      { $$ = (CorMethodImpl) ($1 | miAggressiveInlining); }
+                        | implAttr NOOPTIMIZATION_          { $$ = (CorMethodImpl) ($1 | miNoOptimization); }
+                        | implAttr FLAGS_ '(' int32 ')'     { $$ = (CorMethodImpl) ($4); }
+                        ;
+
+localsHead              : _LOCALS                           { PASM->delArgNameList(PASM->m_firstArgName); PASM->m_firstArgName = NULL;PASM->m_lastArgName = NULL; 
+                                                            }
+                        ;
+
+methodDecls             : /* EMPTY */
+                        | methodDecls methodDecl
+                        ;
+
+methodDecl              : _EMITBYTE int32                   { PASM->EmitByte($2); }
+                        | sehBlock                          { delete PASM->m_SEHD; PASM->m_SEHD = PASM->m_SEHDstack.POP(); }
+                        | _MAXSTACK int32                   { PASM->EmitMaxStack($2); }
+                        | localsHead '(' sigArgs0 ')'       { PASM->EmitLocals(parser->MakeSig(IMAGE_CEE_CS_CALLCONV_LOCAL_SIG, 0, $3)); 
+                                                            }
+                        | localsHead INIT_ '(' sigArgs0 ')' { PASM->EmitZeroInit(); 
+                                                              PASM->EmitLocals(parser->MakeSig(IMAGE_CEE_CS_CALLCONV_LOCAL_SIG, 0, $4)); 
+                                                            }
+                        | _ENTRYPOINT                       { PASM->EmitEntryPoint(); }
+                        | _ZEROINIT                         { PASM->EmitZeroInit(); }
+                        | dataDecl
+                        | instr
+                        | id ':'                            { PASM->AddLabel(PASM->m_CurPC,$1); /*PASM->EmitLabel($1);*/ }
+                        | secDecl
+                        | extSourceSpec
+                        | languageDecl
+                        | customAttrDecl
+                        | compControl
+                        | _EXPORT '[' int32 ']'             { if(PASM->m_pCurMethod->m_dwExportOrdinal == 0xFFFFFFFF)
+                                                              {
+                                                                PASM->m_pCurMethod->m_dwExportOrdinal = $3;
+                                                                PASM->m_pCurMethod->m_szExportAlias = NULL;
+                                                                if(PASM->m_pCurMethod->m_wVTEntry == 0) PASM->m_pCurMethod->m_wVTEntry = 1;
+                                                                if(PASM->m_pCurMethod->m_wVTSlot  == 0) PASM->m_pCurMethod->m_wVTSlot = $3 + 0x8000;
+                                                              }
+                                                              else
+                                                                PASM->report->warn("Duplicate .export directive, ignored\n");
+                                                            }
+                        | _EXPORT '[' int32 ']' AS_ id      { if(PASM->m_pCurMethod->m_dwExportOrdinal == 0xFFFFFFFF)
+                                                              {
+                                                                PASM->m_pCurMethod->m_dwExportOrdinal = $3;
+                                                                PASM->m_pCurMethod->m_szExportAlias = $6;
+                                                                if(PASM->m_pCurMethod->m_wVTEntry == 0) PASM->m_pCurMethod->m_wVTEntry = 1;
+                                                                if(PASM->m_pCurMethod->m_wVTSlot  == 0) PASM->m_pCurMethod->m_wVTSlot = $3 + 0x8000;
+                                                              }
+                                                              else
+                                                                PASM->report->warn("Duplicate .export directive, ignored\n");
+                                                            }
+                        | _VTENTRY int32 ':' int32          { PASM->m_pCurMethod->m_wVTEntry = (WORD)$2;
+                                                              PASM->m_pCurMethod->m_wVTSlot = (WORD)$4; }
+                        | _OVERRIDE typeSpec DCOLON methodName 
+                                                            { PASM->AddMethodImpl($2,$4,NULL,NULL,NULL,NULL); }
+
+                        | _OVERRIDE METHOD_ callConv type typeSpec DCOLON methodName genArity '(' sigArgs0 ')'
+                                                            { PASM->AddMethodImpl($5,$7,
+                                                              ($8==0 ? parser->MakeSig($3,$4,$10) :
+                                                              parser->MakeSig($3| IMAGE_CEE_CS_CALLCONV_GENERIC,$4,$10,$8))
+                                                              ,NULL,NULL,NULL); 
+                                                              PASM->ResetArgNameList();
+                                                            }
+                        | scopeBlock
+                        | PARAM_ TYPE_ '[' int32 ']'        { if(($4 > 0) && ($4 <= (int)PASM->m_pCurMethod->m_NumTyPars))
+                                                                PASM->m_pCustomDescrList = PASM->m_pCurMethod->m_TyPars[$4-1].CAList();
+                                                              else
+                                                                PASM->report->error("Type parameter index out of range\n");
+                                                            }
+                        | PARAM_ TYPE_ dottedName           { int n = PASM->m_pCurMethod->FindTyPar($3);
+                                                              if(n >= 0)
+                                                                PASM->m_pCustomDescrList = PASM->m_pCurMethod->m_TyPars[n].CAList();
+                                                              else
+                                                                PASM->report->error("Type parameter '%s' undefined\n",$3);
+                                                            }
+                        | PARAM_ '[' int32 ']' initOpt                            
+                                                            { if( $3 ) {
+                                                                ARG_NAME_LIST* pAN=PASM->findArg(PASM->m_pCurMethod->m_firstArgName, $3 - 1);
+                                                                if(pAN)
+                                                                {
+                                                                    PASM->m_pCustomDescrList = &(pAN->CustDList);
+                                                                    pAN->pValue = $5;
+                                                                }
+                                                                else
+                                                                {
+                                                                    PASM->m_pCustomDescrList = NULL;
+                                                                    if($5) delete $5;
+                                                                }
+                                                              } else {
+                                                                PASM->m_pCustomDescrList = &(PASM->m_pCurMethod->m_RetCustDList);
+                                                                PASM->m_pCurMethod->m_pRetValue = $5;
+                                                              }
+                                                              PASM->m_tkCurrentCVOwner = 0;
+                                                            }
+                        ;
+
+scopeBlock              : scopeOpen methodDecls '}'         { PASM->m_pCurMethod->CloseScope(); }
+                        ;
+
+scopeOpen               : '{'                               { PASM->m_pCurMethod->OpenScope(); }
+                        ;
+
+/* Structured exception handling directives  */                          
+sehBlock                : tryBlock sehClauses
+                        ;
+
+sehClauses              : sehClause sehClauses
+                        | sehClause
+                        ;
+
+tryBlock                : tryHead scopeBlock                { PASM->m_SEHD->tryTo = PASM->m_CurPC; }
+                        | tryHead id TO_ id                 { PASM->SetTryLabels($2, $4); }
+                        | tryHead int32 TO_ int32           { if(PASM->m_SEHD) {PASM->m_SEHD->tryFrom = $2;
+                                                              PASM->m_SEHD->tryTo = $4;} }
+                        ;
+
+tryHead                 : _TRY                              { PASM->NewSEHDescriptor();
+                                                              PASM->m_SEHD->tryFrom = PASM->m_CurPC; }
+                        ;
+
+
+sehClause               : catchClause handlerBlock           { PASM->EmitTry(); }
+                        | filterClause handlerBlock          { PASM->EmitTry(); }
+                        | finallyClause handlerBlock         { PASM->EmitTry(); }
+                        | faultClause handlerBlock           { PASM->EmitTry(); }
+                        ;
+
+                                                                                                                                
+filterClause            : filterHead scopeBlock              { PASM->m_SEHD->sehHandler = PASM->m_CurPC; }
+                        | filterHead id                      { PASM->SetFilterLabel($2); 
+                                                               PASM->m_SEHD->sehHandler = PASM->m_CurPC; }
+                        | filterHead int32                   { PASM->m_SEHD->sehFilter = $2; 
+                                                               PASM->m_SEHD->sehHandler = PASM->m_CurPC; }
+                        ;
+
+filterHead              : FILTER_                            { PASM->m_SEHD->sehClause = COR_ILEXCEPTION_CLAUSE_FILTER;
+                                                               PASM->m_SEHD->sehFilter = PASM->m_CurPC; } 
+                        ;
+
+catchClause             : CATCH_ typeSpec                   {  PASM->m_SEHD->sehClause = COR_ILEXCEPTION_CLAUSE_NONE;
+                                                               PASM->SetCatchClass($2); 
+                                                               PASM->m_SEHD->sehHandler = PASM->m_CurPC; }
+                        ;
+
+finallyClause           : FINALLY_                           { PASM->m_SEHD->sehClause = COR_ILEXCEPTION_CLAUSE_FINALLY;
+                                                               PASM->m_SEHD->sehHandler = PASM->m_CurPC; }
+                        ;
+
+faultClause             : FAULT_                             { PASM->m_SEHD->sehClause = COR_ILEXCEPTION_CLAUSE_FAULT;
+                                                               PASM->m_SEHD->sehHandler = PASM->m_CurPC; }
+                        ;
+
+handlerBlock            : scopeBlock                         { PASM->m_SEHD->sehHandlerTo = PASM->m_CurPC; }                 
+                        | HANDLER_ id TO_ id                 { PASM->SetHandlerLabels($2, $4); }
+                        | HANDLER_ int32 TO_ int32           { PASM->m_SEHD->sehHandler = $2;
+                                                               PASM->m_SEHD->sehHandlerTo = $4; }
+                        ;
+
+/*  Data declaration  */
+dataDecl                : ddHead ddBody
+                        ;
+
+ddHead                  : _DATA tls id '='                   { PASM->EmitDataLabel($3); }
+                        | _DATA tls  
+                        ;
+
+tls                     : /* EMPTY */                        { PASM->SetDataSection(); }
+                        | TLS_                               { PASM->SetTLSSection(); }
+                        | CIL_                               { PASM->SetILSection(); }
+                        ;
+
+ddBody                  : '{' ddItemList '}'
+                        | ddItem
+                        ;
+
+ddItemList              : ddItem ',' ddItemList
+                        | ddItem
+                        ;
+
+ddItemCount             : /* EMPTY */                        { $$ = 1; }
+                        | '[' int32 ']'                      { $$ = $2;
+                                                               if($2 <= 0) { PASM->report->error("Illegal item count: %d\n",$2);
+                                                                  if(!PASM->OnErrGo) $$ = 1; }}
+                        ;
+
+ddItem                  : CHAR_ '*' '(' compQstring ')'      { PASM->EmitDataString($4); }
+                        | '&' '(' id ')'                     { PASM->EmitDD($3); }
+                        | bytearrayhead bytes ')'            { PASM->EmitData($2->ptr(),$2->length()); }
+                        | FLOAT32_ '(' float64 ')' ddItemCount
+                                                             { float f = (float) (*$3); float* p = new (nothrow) float[$5];
+                                                               if(p != NULL) {
+                                                                 for(int i=0; i < $5; i++) p[i] = f;
+                                                                 PASM->EmitData(p, sizeof(float)*$5); delete $3; delete [] p; 
+                                                               } else PASM->report->error("Out of memory emitting data block %d bytes\n",
+                                                                     sizeof(float)*$5); }
+                        | FLOAT64_ '(' float64 ')' ddItemCount
+                                                             { double* p = new (nothrow) double[$5];
+                                                               if(p != NULL) {
+                                                                 for(int i=0; i<$5; i++) p[i] = *($3);
+                                                                 PASM->EmitData(p, sizeof(double)*$5); delete $3; delete [] p;
+                                                               } else PASM->report->error("Out of memory emitting data block %d bytes\n",
+                                                                     sizeof(double)*$5); }
+                        | INT64_ '(' int64 ')' ddItemCount
+                                                             { __int64* p = new (nothrow) __int64[$5];
+                                                               if(p != NULL) {
+                                                                 for(int i=0; i<$5; i++) p[i] = *($3);
+                                                                 PASM->EmitData(p, sizeof(__int64)*$5); delete $3; delete [] p;
+                                                               } else PASM->report->error("Out of memory emitting data block %d bytes\n",
+                                                                     sizeof(__int64)*$5); }
+                        | INT32_ '(' int32 ')' ddItemCount
+                                                             { __int32* p = new (nothrow) __int32[$5];
+                                                               if(p != NULL) {
+                                                                 for(int i=0; i<$5; i++) p[i] = $3;
+                                                                 PASM->EmitData(p, sizeof(__int32)*$5); delete [] p;
+                                                               } else PASM->report->error("Out of memory emitting data block %d bytes\n",
+                                                                     sizeof(__int32)*$5); }
+                        | INT16_ '(' int32 ')' ddItemCount
+                                                             { __int16 i = (__int16) $3; FAIL_UNLESS(i == $3, ("Value %d too big\n", $3));
+                                                               __int16* p = new (nothrow) __int16[$5];
+                                                               if(p != NULL) {
+                                                                 for(int j=0; j<$5; j++) p[j] = i;
+                                                                 PASM->EmitData(p, sizeof(__int16)*$5); delete [] p;
+                                                               } else PASM->report->error("Out of memory emitting data block %d bytes\n",
+                                                                     sizeof(__int16)*$5); }
+                        | INT8_ '(' int32 ')' ddItemCount
+                                                             { __int8 i = (__int8) $3; FAIL_UNLESS(i == $3, ("Value %d too big\n", $3));
+                                                               __int8* p = new (nothrow) __int8[$5];
+                                                               if(p != NULL) {
+                                                                 for(int j=0; j<$5; j++) p[j] = i;
+                                                                 PASM->EmitData(p, sizeof(__int8)*$5); delete [] p;
+                                                               } else PASM->report->error("Out of memory emitting data block %d bytes\n",
+                                                                     sizeof(__int8)*$5); }
+                        | FLOAT32_ ddItemCount               { PASM->EmitData(NULL, sizeof(float)*$2); }
+                        | FLOAT64_ ddItemCount               { PASM->EmitData(NULL, sizeof(double)*$2); }
+                        | INT64_ ddItemCount                 { PASM->EmitData(NULL, sizeof(__int64)*$2); }
+                        | INT32_ ddItemCount                 { PASM->EmitData(NULL, sizeof(__int32)*$2); }
+                        | INT16_ ddItemCount                 { PASM->EmitData(NULL, sizeof(__int16)*$2); }
+                        | INT8_ ddItemCount                  { PASM->EmitData(NULL, sizeof(__int8)*$2); }
+                        ;
+
+/*  Default values declaration for fields, parameters and verbal form of CA blob description  */
+fieldSerInit            : FLOAT32_ '(' float64 ')'           { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R4);
+                                                               float f = (float)(*$3);
+                                                               $$->appendInt32(*((__int32*)&f)); delete $3; }
+                        | FLOAT64_ '(' float64 ')'           { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R8); 
+                                                               $$->appendInt64((__int64 *)$3); delete $3; }
+                        | FLOAT32_ '(' int32 ')'             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R4); 
+                                                               $$->appendInt32($3); }
+                        | FLOAT64_ '(' int64 ')'             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R8); 
+                                                               $$->appendInt64((__int64 *)$3); delete $3; }
+                        | INT64_ '(' int64 ')'               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I8); 
+                                                               $$->appendInt64((__int64 *)$3); delete $3; } 
+                        | INT32_ '(' int32 ')'               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I4); 
+                                                               $$->appendInt32($3); }
+                        | INT16_ '(' int32 ')'               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I2); 
+                                                               $$->appendInt16($3); }
+                        | INT8_ '(' int32 ')'                { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I1); 
+                                                               $$->appendInt8($3); }
+                        | UNSIGNED_ INT64_ '(' int64 ')'     { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U8); 
+                                                               $$->appendInt64((__int64 *)$4); delete $4; } 
+                        | UNSIGNED_ INT32_ '(' int32 ')'     { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U4); 
+                                                               $$->appendInt32($4); }
+                        | UNSIGNED_ INT16_ '(' int32 ')'     { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U2); 
+                                                               $$->appendInt16($4); }
+                        | UNSIGNED_ INT8_ '(' int32 ')'      { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U1); 
+                                                               $$->appendInt8($4); }
+                        | UINT64_ '(' int64 ')'              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U8); 
+                                                               $$->appendInt64((__int64 *)$3); delete $3; } 
+                        | UINT32_ '(' int32 ')'              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U4); 
+                                                               $$->appendInt32($3); }
+                        | UINT16_ '(' int32 ')'              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U2); 
+                                                               $$->appendInt16($3); }
+                        | UINT8_ '(' int32 ')'               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U1); 
+                                                               $$->appendInt8($3); }
+                        | CHAR_ '(' int32 ')'                { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_CHAR); 
+                                                               $$->appendInt16($3); }
+                        | BOOL_ '(' truefalse ')'            { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_BOOLEAN); 
+                                                               $$->appendInt8($3);}
+                        | bytearrayhead bytes ')'            { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_STRING);
+                                                               $$->append($2); delete $2;}
+                        ;
+                        
+bytearrayhead           : BYTEARRAY_ '('                     { bParsingByteArray = TRUE; }
+                        ;
+
+bytes                   : /* EMPTY */                        { $$ = new BinStr(); }
+                        | hexbytes                           { $$ = $1; }
+                        ;
+
+hexbytes                : HEXBYTE                            { __int8 i = (__int8) $1; $$ = new BinStr(); $$->appendInt8(i); }
+                        | hexbytes HEXBYTE                   { __int8 i = (__int8) $2; $$ = $1; $$->appendInt8(i); }
+                        ;
+
+/*  Field/parameter initialization  */
+fieldInit               : fieldSerInit                       { $$ = $1; }
+                        | compQstring                        { $$ = BinStrToUnicode($1,true); $$->insertInt8(ELEMENT_TYPE_STRING);}
+                        | NULLREF_                           { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_CLASS); 
+                                                               $$->appendInt32(0); }
+                        ;                        
+
+/*  Values for verbal form of CA blob description  */
+serInit                 : fieldSerInit                       { $$ = $1; }
+                        | STRING_ '(' NULLREF_ ')'           { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_STRING); $$->appendInt8(0xFF); }
+                        | STRING_ '(' SQSTRING ')'           { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_STRING); 
+                                                               AppendStringWithLength($$,$3); delete [] $3;}
+                        | TYPE_ '(' CLASS_ SQSTRING ')'      { $$ = new BinStr(); $$->appendInt8(SERIALIZATION_TYPE_TYPE); 
+                                                               AppendStringWithLength($$,$4); delete [] $4;}
+                        | TYPE_ '(' className ')'            { $$ = new BinStr(); $$->appendInt8(SERIALIZATION_TYPE_TYPE); 
+                                                               AppendStringWithLength($$,PASM->ReflectionNotation($3));}
+                        | TYPE_ '(' NULLREF_ ')'             { $$ = new BinStr(); $$->appendInt8(SERIALIZATION_TYPE_TYPE); $$->appendInt8(0xFF); }
+                        | OBJECT_ '(' serInit ')'            { $$ = $3; $$->insertInt8(SERIALIZATION_TYPE_TAGGED_OBJECT);} 
+                        | FLOAT32_ '[' int32 ']' '(' f32seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_R4);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | FLOAT64_ '[' int32 ']' '(' f64seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_R8);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | INT64_ '[' int32 ']' '(' i64seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_I8);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | INT32_ '[' int32 ']' '(' i32seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_I4);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | INT16_ '[' int32 ']' '(' i16seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_I2);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | INT8_ '[' int32 ']' '(' i8seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_I1);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | UINT64_ '[' int32 ']' '(' i64seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_U8);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | UINT32_ '[' int32 ']' '(' i32seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_U4);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | UINT16_ '[' int32 ']' '(' i16seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_U2);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | UINT8_ '[' int32 ']' '(' i8seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_U1);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | UNSIGNED_ INT64_ '[' int32 ']' '(' i64seq ')'
+                                                             { $$ = $7; $$->insertInt32($4);
+                                                               $$->insertInt8(ELEMENT_TYPE_U8);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | UNSIGNED_ INT32_ '[' int32 ']' '(' i32seq ')'
+                                                             { $$ = $7; $$->insertInt32($4);
+                                                               $$->insertInt8(ELEMENT_TYPE_U4);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | UNSIGNED_ INT16_ '[' int32 ']' '(' i16seq ')'
+                                                             { $$ = $7; $$->insertInt32($4);
+                                                               $$->insertInt8(ELEMENT_TYPE_U2);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | UNSIGNED_ INT8_ '[' int32 ']' '(' i8seq ')'
+                                                             { $$ = $7; $$->insertInt32($4);
+                                                               $$->insertInt8(ELEMENT_TYPE_U1);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | CHAR_ '[' int32 ']' '(' i16seq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_CHAR);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | BOOL_ '[' int32 ']' '(' boolSeq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_BOOLEAN);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | STRING_ '[' int32 ']' '(' sqstringSeq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(ELEMENT_TYPE_STRING);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | TYPE_ '[' int32 ']' '(' classSeq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(SERIALIZATION_TYPE_TYPE);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        | OBJECT_ '[' int32 ']' '(' objSeq ')'
+                                                             { $$ = $6; $$->insertInt32($3);
+                                                               $$->insertInt8(SERIALIZATION_TYPE_TAGGED_OBJECT);
+                                                               $$->insertInt8(ELEMENT_TYPE_SZARRAY); }
+                        ;
+
+
+f32seq                  : /* EMPTY */                        { $$ = new BinStr(); }
+                        | f32seq float64                     { $$ = $1;
+                                                               float f = (float) (*$2); $$->appendInt32(*((__int32*)&f)); delete $2; }
+                        | f32seq int32                       { $$ = $1; 
+                                                               $$->appendInt32($2); }
+                        ;
+                                                               
+f64seq                  : /* EMPTY */                        { $$ = new BinStr(); }
+                        | f64seq float64                     { $$ = $1; 
+                                                               $$->appendInt64((__int64 *)$2); delete $2; }
+                        | f64seq int64                       { $$ = $1; 
+                                                               $$->appendInt64((__int64 *)$2); delete $2; }
+                        ;
+                        
+i64seq                  : /* EMPTY */                        { $$ = new BinStr(); }
+                        | i64seq int64                       { $$ = $1; 
+                                                               $$->appendInt64((__int64 *)$2); delete $2; }
+                        ;
+                        
+i32seq                  : /* EMPTY */                        { $$ = new BinStr(); }
+                        | i32seq int32                       { $$ = $1; $$->appendInt32($2);}
+                        ;
+                        
+i16seq                  : /* EMPTY */                        { $$ = new BinStr(); }
+                        | i16seq int32                       { $$ = $1; $$->appendInt16($2);}
+                        ;
+                        
+i8seq                   : /* EMPTY */                        { $$ = new BinStr(); }
+                        | i8seq int32                        { $$ = $1; $$->appendInt8($2); }
+                        ;
+                        
+boolSeq                 : /* EMPTY */                        { $$ = new BinStr(); }
+                        | boolSeq truefalse                  { $$ = $1; 
+                                                               $$->appendInt8($2);}
+                        ;
+                        
+sqstringSeq             : /* EMPTY */                        { $$ = new BinStr(); }
+                        | sqstringSeq NULLREF_               { $$ = $1; $$->appendInt8(0xFF); }
+                        | sqstringSeq SQSTRING               { $$ = $1; 
+                                                               AppendStringWithLength($$,$2); delete [] $2;}
+                        ;
+                        
+classSeq                : /* EMPTY */                        { $$ = new BinStr(); }
+                        | classSeq NULLREF_                  { $$ = $1; $$->appendInt8(0xFF); }
+                        | classSeq CLASS_ SQSTRING           { $$ = $1; 
+                                                               AppendStringWithLength($$,$3); delete [] $3;}
+                        | classSeq className                 { $$ = $1; 
+                                                               AppendStringWithLength($$,PASM->ReflectionNotation($2));}
+                        ;
+                        
+objSeq                  : /* EMPTY */                        { $$ = new BinStr(); }
+                        | objSeq serInit                     { $$ = $1; $$->append($2); delete $2; }
+                        ;
+
+/*  IL instructions and associated definitions  */
+methodSpec              : METHOD_                            { parser->m_ANSFirst.PUSH(PASM->m_firstArgName);
+                                                               parser->m_ANSLast.PUSH(PASM->m_lastArgName);   
+                                                               PASM->m_firstArgName = NULL;
+                                                               PASM->m_lastArgName = NULL; }
+                        ;
+                        
+instr_none              : INSTR_NONE                         { $$ = SetupInstr($1); }
+                        ;
+
+instr_var               : INSTR_VAR                          { $$ = SetupInstr($1); }
+                        ;
+
+instr_i                 : INSTR_I                            { $$ = SetupInstr($1); }
+                        ;
+
+instr_i8                : INSTR_I8                           { $$ = SetupInstr($1); }
+                        ;
+
+instr_r                 : INSTR_R                            { $$ = SetupInstr($1); }
+                        ;
+
+instr_brtarget          : INSTR_BRTARGET                     { $$ = SetupInstr($1); }
+                        ;
+
+instr_method            : INSTR_METHOD                       { $$ = SetupInstr($1); 
+                                                               if((!PASM->OnErrGo)&&
+                                                               (($1 == CEE_NEWOBJ)||
+                                                                ($1 == CEE_CALLVIRT))) 
+                                                                  iCallConv = IMAGE_CEE_CS_CALLCONV_HASTHIS;
+                                                             }
+                        ;
+
+instr_field             : INSTR_FIELD                        { $$ = SetupInstr($1); }
+                        ;
+
+instr_type              : INSTR_TYPE                         { $$ = SetupInstr($1); }
+                        ;
+
+instr_string            : INSTR_STRING                       { $$ = SetupInstr($1); }
+                        ;
+
+instr_sig               : INSTR_SIG                          { $$ = SetupInstr($1); }
+                        ;
+
+instr_tok               : INSTR_TOK                          { $$ = SetupInstr($1); iOpcodeLen = PASM->OpcodeLen($$); }
+                        ;
+
+instr_switch            : INSTR_SWITCH                       { $$ = SetupInstr($1); }
+                        ;
+
+instr_r_head            : instr_r '('                        { $$ = $1; bParsingByteArray = TRUE; }
+                        ;
+
+
+instr                   : instr_none                         { PASM->EmitOpcode($1); }
+                        | instr_var int32                    { PASM->EmitInstrVar($1, $2); }
+                        | instr_var id                       { PASM->EmitInstrVarByName($1, $2); }
+                        | instr_i int32                      { PASM->EmitInstrI($1, $2); }
+                        | instr_i8 int64                     { PASM->EmitInstrI8($1, $2); }
+                        | instr_r float64                    { PASM->EmitInstrR($1, $2); delete ($2);}
+                        | instr_r int64                      { double f = (double) (*$2); PASM->EmitInstrR($1, &f); }
+                        | instr_r_head bytes ')'             { unsigned L = $2->length();
+                                                               FAIL_UNLESS(L >= sizeof(float), ("%d hexbytes, must be at least %d\n",
+                                                                           L,sizeof(float))); 
+                                                               if(L < sizeof(float)) {YYERROR; } 
+                                                               else {
+                                                                   double f = (L >= sizeof(double)) ? *((double *)($2->ptr()))
+                                                                                    : (double)(*(float *)($2->ptr())); 
+                                                                   PASM->EmitInstrR($1,&f); }
+                                                               delete $2; }
+                        | instr_brtarget int32               { PASM->EmitInstrBrOffset($1, $2); }
+                        | instr_brtarget id                  { PASM->EmitInstrBrTarget($1, $2); }
+                        | instr_method methodRef
+                                                             { PASM->SetMemberRefFixup($2,PASM->OpcodeLen($1));
+                                                               PASM->EmitInstrI($1,$2);
+                                                               PASM->m_tkCurrentCVOwner = $2;
+                                                               PASM->m_pCustomDescrList = NULL;
+                                                               iCallConv = 0;
+                                                             }
+                        | instr_field type typeSpec DCOLON dottedName
+                                                             { $2->insertInt8(IMAGE_CEE_CS_CALLCONV_FIELD); 
+                                                               mdToken mr = PASM->MakeMemberRef($3, $5, $2);
+                                                               PASM->SetMemberRefFixup(mr, PASM->OpcodeLen($1));
+                                                               PASM->EmitInstrI($1,mr);
+                                                               PASM->m_tkCurrentCVOwner = mr;
+                                                               PASM->m_pCustomDescrList = NULL;
+                                                             }
+                        | instr_field type dottedName
+                                                             { $2->insertInt8(IMAGE_CEE_CS_CALLCONV_FIELD); 
+                                                               mdToken mr = PASM->MakeMemberRef(mdTokenNil, $3, $2);
+                                                               PASM->SetMemberRefFixup(mr, PASM->OpcodeLen($1));
+                                                               PASM->EmitInstrI($1,mr);
+                                                               PASM->m_tkCurrentCVOwner = mr;
+                                                               PASM->m_pCustomDescrList = NULL;
+                                                             }
+                        | instr_field mdtoken                { mdToken mr = $2;
+                                                               PASM->SetMemberRefFixup(mr, PASM->OpcodeLen($1));
+                                                               PASM->EmitInstrI($1,mr);
+                                                               PASM->m_tkCurrentCVOwner = mr;
+                                                               PASM->m_pCustomDescrList = NULL;
+                                                             }
+                        | instr_field TYPEDEF_F              { mdToken mr = $2->m_tkTypeSpec;
+                                                               PASM->SetMemberRefFixup(mr, PASM->OpcodeLen($1));
+                                                               PASM->EmitInstrI($1,mr);
+                                                               PASM->m_tkCurrentCVOwner = mr;
+                                                               PASM->m_pCustomDescrList = NULL;
+                                                             }
+                        | instr_field TYPEDEF_MR             { mdToken mr = $2->m_tkTypeSpec;
+                                                               PASM->SetMemberRefFixup(mr, PASM->OpcodeLen($1));
+                                                               PASM->EmitInstrI($1,mr);
+                                                               PASM->m_tkCurrentCVOwner = mr;
+                                                               PASM->m_pCustomDescrList = NULL;
+                                                             }
+                        | instr_type typeSpec                { PASM->EmitInstrI($1, $2); 
+                                                               PASM->m_tkCurrentCVOwner = $2;
+                                                               PASM->m_pCustomDescrList = NULL;
+                                                             }
+                        | instr_string compQstring           { PASM->EmitInstrStringLiteral($1, $2,TRUE); }
+                        | instr_string ANSI_ '(' compQstring ')'
+                                                             { PASM->EmitInstrStringLiteral($1, $4,FALSE); }
+                        | instr_string bytearrayhead bytes ')'
+                                                             { PASM->EmitInstrStringLiteral($1, $3,FALSE,TRUE); }
+                        | instr_sig callConv type '(' sigArgs0 ')'      
+                                                             { PASM->EmitInstrSig($1, parser->MakeSig($2, $3, $5)); 
+                                                               PASM->ResetArgNameList();
+                                                             }
+                        | instr_tok ownerType /* ownerType ::= memberRef | typeSpec */
+                                                             { PASM->EmitInstrI($1,$2);
+                                                               PASM->m_tkCurrentCVOwner = $2;
+                                                               PASM->m_pCustomDescrList = NULL;
+                                                               iOpcodeLen = 0;
+                                                             }
+                        | instr_switch '(' labels ')'        { PASM->EmitInstrSwitch($1, $3); }
+                        ;
+                        
+labels                  : /* empty */                         { $$ = 0; }
+                        | id ',' labels                       { $$ = new Labels($1, $3, TRUE); }
+                        | int32 ',' labels                    { $$ = new Labels((char *)(UINT_PTR)$1, $3, FALSE); }
+                        | id                                  { $$ = new Labels($1, NULL, TRUE); }
+                        | int32                               { $$ = new Labels((char *)(UINT_PTR)$1, NULL, FALSE); }
+                        ;
+
+/*  Signatures  */
+tyArgs0                 : /* EMPTY */                        { $$ = NULL; }
+                        | '<' tyArgs1 '>'                    { $$ = $2; }
+                        ;
+
+tyArgs1                 : /* EMPTY */                        { $$ = NULL; }
+                        | tyArgs2                            { $$ = $1; }
+                        ;
+
+tyArgs2                 : type                               { $$ = $1; }
+                        | tyArgs2 ',' type                   { $$ = $1; $$->append($3); delete $3; }
+                        ;
+
+
+sigArgs0                : /* EMPTY */                        { $$ = new BinStr(); }
+                        | sigArgs1                           { $$ = $1;}
+                        ;
+
+sigArgs1                : sigArg                             { $$ = $1; }
+                        | sigArgs1 ',' sigArg                { $$ = $1; $$->append($3); delete $3; }
+                        ;
+
+sigArg                  : ELIPSIS                             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_SENTINEL); }
+                        | paramAttr type marshalClause        { $$ = new BinStr(); $$->append($2); PASM->addArgName(NULL, $2, $3, $1); }
+                        | paramAttr type marshalClause id     { $$ = new BinStr(); $$->append($2); PASM->addArgName($4, $2, $3, $1);}
+                        ;
+
+/*  Class referencing  */
+className               : '[' dottedName ']' slashedName      { $$ = PASM->ResolveClassRef(PASM->GetAsmRef($2), $4, NULL); delete[] $2;}
+                        | '[' mdtoken ']' slashedName         { $$ = PASM->ResolveClassRef($2, $4, NULL); }
+                        | '[' '*' ']' slashedName             { $$ = PASM->ResolveClassRef(mdTokenNil, $4, NULL); }
+                        | '[' _MODULE dottedName ']' slashedName   { $$ = PASM->ResolveClassRef(PASM->GetModRef($3),$5, NULL); delete[] $3;}
+                        | slashedName                         { $$ = PASM->ResolveClassRef(1,$1,NULL); }
+                        | mdtoken                             { $$ = $1; }
+                        | TYPEDEF_T                           { $$ = $1->m_tkTypeSpec; }
+                        | _THIS                               { if(PASM->m_pCurClass != NULL) $$ = PASM->m_pCurClass->m_cl;
+                                                                else { $$ = 0; PASM->report->error(".this outside class scope\n"); } 
+                                                              }
+                        | _BASE                               { if(PASM->m_pCurClass != NULL) {
+                                                                  $$ = PASM->m_pCurClass->m_crExtends;
+                                                                  if(RidFromToken($$) == 0)
+                                                                    PASM->report->error(".base undefined\n");
+                                                                } else { $$ = 0; PASM->report->error(".base outside class scope\n"); } 
+                                                              }
+                        | _NESTER                             { if(PASM->m_pCurClass != NULL) {
+                                                                  if(PASM->m_pCurClass->m_pEncloser != NULL) $$ = PASM->m_pCurClass->m_pEncloser->m_cl;
+                                                                  else { $$ = 0; PASM->report->error(".nester undefined\n"); }
+                                                                } else { $$ = 0; PASM->report->error(".nester outside class scope\n"); } 
+                                                              }
+                        ;
+
+slashedName             : dottedName                          { $$ = $1; }
+                        | slashedName '/' dottedName          { $$ = newStringWDel($1, NESTING_SEP, $3); }
+                        ;
+
+typeSpec                : className                           { $$ = $1;}
+                        | '[' dottedName ']'                  { $$ = PASM->GetAsmRef($2); delete[] $2;}
+                        | '[' _MODULE dottedName ']'          { $$ = PASM->GetModRef($3); delete[] $3;}
+                        | type                                { $$ = PASM->ResolveTypeSpec($1); }
+                        ;
+
+/*  Native types for marshaling signatures  */                         
+nativeType              : /* EMPTY */                         { $$ = new BinStr(); } 
+                        | CUSTOM_ '(' compQstring ',' compQstring ',' compQstring ',' compQstring ')'
+                                                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_CUSTOMMARSHALER);
+                                                                corEmitInt($$,$3->length()); $$->append($3);
+                                                                corEmitInt($$,$5->length()); $$->append($5);
+                                                                corEmitInt($$,$7->length()); $$->append($7);
+                                                                corEmitInt($$,$9->length()); $$->append($9); 
+                                                                PASM->report->warn("Deprecated 4-string form of custom marshaler, first two strings ignored\n");}
+                        | CUSTOM_ '(' compQstring ',' compQstring ')'
+                                                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_CUSTOMMARSHALER);
+                                                                corEmitInt($$,0);
+                                                                corEmitInt($$,0);
+                                                                corEmitInt($$,$3->length()); $$->append($3);
+                                                                corEmitInt($$,$5->length()); $$->append($5); }
+                        | FIXED_ SYSSTRING_ '[' int32 ']'     { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_FIXEDSYSSTRING);
+                                                                corEmitInt($$,$4); }
+                        | FIXED_ ARRAY_ '[' int32 ']' nativeType
+                                                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_FIXEDARRAY);
+                                                                corEmitInt($$,$4); $$->append($6); }
+                        | VARIANT_                            { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_VARIANT); 
+                                                                PASM->report->warn("Deprecated native type 'variant'\n"); }
+                        | CURRENCY_                           { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_CURRENCY); }
+                        | SYSCHAR_                            { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_SYSCHAR); 
+                                                                PASM->report->warn("Deprecated native type 'syschar'\n"); }
+                        | VOID_                               { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_VOID); 
+                                                                PASM->report->warn("Deprecated native type 'void'\n"); }
+                        | BOOL_                               { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_BOOLEAN); }
+                        | INT8_                               { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_I1); }
+                        | INT16_                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_I2); }
+                        | INT32_                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_I4); }
+                        | INT64_                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_I8); }
+                        | FLOAT32_                            { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_R4); }
+                        | FLOAT64_                            { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_R8); }
+                        | ERROR_                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_ERROR); }
+                        | UNSIGNED_ INT8_                     { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_U1); }
+                        | UNSIGNED_ INT16_                    { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_U2); }
+                        | UNSIGNED_ INT32_                    { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_U4); }
+                        | UNSIGNED_ INT64_                    { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_U8); }
+                        | UINT8_                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_U1); }
+                        | UINT16_                             { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_U2); }
+                        | UINT32_                             { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_U4); }
+                        | UINT64_                             { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_U8); }
+                        | nativeType '*'                      { $$ = $1; $$->insertInt8(NATIVE_TYPE_PTR); 
+                                                                PASM->report->warn("Deprecated native type '*'\n"); }
+                        | nativeType '[' ']'                  { $$ = $1; if($$->length()==0) $$->appendInt8(NATIVE_TYPE_MAX);
+                                                                $$->insertInt8(NATIVE_TYPE_ARRAY); }
+                        | nativeType '[' int32 ']'            { $$ = $1; if($$->length()==0) $$->appendInt8(NATIVE_TYPE_MAX); 
+                                                                $$->insertInt8(NATIVE_TYPE_ARRAY);
+                                                                corEmitInt($$,0);
+                                                                corEmitInt($$,$3); 
+                                                                corEmitInt($$,0); }
+                        | nativeType '[' int32 '+' int32 ']'  { $$ = $1; if($$->length()==0) $$->appendInt8(NATIVE_TYPE_MAX); 
+                                                                $$->insertInt8(NATIVE_TYPE_ARRAY);
+                                                                corEmitInt($$,$5);
+                                                                corEmitInt($$,$3);
+                                                                corEmitInt($$,ntaSizeParamIndexSpecified); }
+                        | nativeType '[' '+' int32 ']'        { $$ = $1; if($$->length()==0) $$->appendInt8(NATIVE_TYPE_MAX); 
+                                                                $$->insertInt8(NATIVE_TYPE_ARRAY);
+                                                                corEmitInt($$,$4); }
+                        | DECIMAL_                            { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_DECIMAL); 
+                                                                PASM->report->warn("Deprecated native type 'decimal'\n"); }
+                        | DATE_                               { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_DATE); 
+                                                                PASM->report->warn("Deprecated native type 'date'\n"); }
+                        | BSTR_                               { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_BSTR); }
+                        | LPSTR_                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_LPSTR); }
+                        | LPWSTR_                             { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_LPWSTR); }
+                        | LPTSTR_                             { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_LPTSTR); }
+                        | OBJECTREF_                          { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_OBJECTREF); 
+                                                                PASM->report->warn("Deprecated native type 'objectref'\n"); }
+                        | IUNKNOWN_  iidParamIndex            { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_IUNKNOWN);
+                                                                if($2 != -1) corEmitInt($$,$2); }
+                        | IDISPATCH_ iidParamIndex            { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_IDISPATCH); 
+                                                                if($2 != -1) corEmitInt($$,$2); }
+                        | STRUCT_                             { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_STRUCT); }
+                        | INTERFACE_ iidParamIndex            { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_INTF);
+                                                                if($2 != -1) corEmitInt($$,$2); }
+                        | SAFEARRAY_ variantType              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_SAFEARRAY); 
+                                                                corEmitInt($$,$2); 
+                                                                corEmitInt($$,0);}
+                        | SAFEARRAY_ variantType ',' compQstring { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_SAFEARRAY); 
+                                                                corEmitInt($$,$2); 
+                                                                corEmitInt($$,$4->length()); $$->append($4); }
+                                                                
+                        | INT_                                { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_INT); }
+                        | UNSIGNED_ INT_                      { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_UINT); }
+                        | UINT_                               { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_UINT); }
+                        | NESTED_ STRUCT_                     { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_NESTEDSTRUCT); 
+                                                                PASM->report->warn("Deprecated native type 'nested struct'\n"); }
+                        | BYVALSTR_                           { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_BYVALSTR); }
+                        | ANSI_ BSTR_                         { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_ANSIBSTR); }
+                        | TBSTR_                              { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_TBSTR); }
+                        | VARIANT_ BOOL_                      { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_VARIANTBOOL); }
+                        | METHOD_                             { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_FUNC); }
+                        | AS_ ANY_                            { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_ASANY); }
+                        | LPSTRUCT_                           { $$ = new BinStr(); $$->appendInt8(NATIVE_TYPE_LPSTRUCT); }
+                        | TYPEDEF_TS                          { $$ = new BinStr(); $$->append($1->m_pbsTypeSpec); }
+                        ;
+                        
+iidParamIndex           : /* EMPTY */                         { $$ = -1; }
+                        | '(' IIDPARAM_ '=' int32 ')'         { $$ = $4; }
+                        ;                        
+
+variantType             : /* EMPTY */                         { $$ = VT_EMPTY; }
+                        | NULL_                               { $$ = VT_NULL; }
+                        | VARIANT_                            { $$ = VT_VARIANT; }
+                        | CURRENCY_                           { $$ = VT_CY; }
+                        | VOID_                               { $$ = VT_VOID; }
+                        | BOOL_                               { $$ = VT_BOOL; }
+                        | INT8_                               { $$ = VT_I1; }
+                        | INT16_                              { $$ = VT_I2; }
+                        | INT32_                              { $$ = VT_I4; }
+                        | INT64_                              { $$ = VT_I8; }
+                        | FLOAT32_                            { $$ = VT_R4; }
+                        | FLOAT64_                            { $$ = VT_R8; }
+                        | UNSIGNED_ INT8_                     { $$ = VT_UI1; }
+                        | UNSIGNED_ INT16_                    { $$ = VT_UI2; }
+                        | UNSIGNED_ INT32_                    { $$ = VT_UI4; }
+                        | UNSIGNED_ INT64_                    { $$ = VT_UI8; }
+                        | UINT8_                              { $$ = VT_UI1; }
+                        | UINT16_                             { $$ = VT_UI2; }
+                        | UINT32_                             { $$ = VT_UI4; }
+                        | UINT64_                             { $$ = VT_UI8; }
+                        | '*'                                 { $$ = VT_PTR; }
+                        | variantType '[' ']'                 { $$ = $1 | VT_ARRAY; }
+                        | variantType VECTOR_                 { $$ = $1 | VT_VECTOR; }
+                        | variantType '&'                     { $$ = $1 | VT_BYREF; }
+                        | DECIMAL_                            { $$ = VT_DECIMAL; }
+                        | DATE_                               { $$ = VT_DATE; }
+                        | BSTR_                               { $$ = VT_BSTR; }
+                        | LPSTR_                              { $$ = VT_LPSTR; }
+                        | LPWSTR_                             { $$ = VT_LPWSTR; }
+                        | IUNKNOWN_                           { $$ = VT_UNKNOWN; }
+                        | IDISPATCH_                          { $$ = VT_DISPATCH; }
+                        | SAFEARRAY_                          { $$ = VT_SAFEARRAY; }
+                        | INT_                                { $$ = VT_INT; }
+                        | UNSIGNED_ INT_                      { $$ = VT_UINT; }
+                        | UINT_                               { $$ = VT_UINT; }
+                        | ERROR_                              { $$ = VT_ERROR; }
+                        | HRESULT_                            { $$ = VT_HRESULT; }
+                        | CARRAY_                             { $$ = VT_CARRAY; }
+                        | USERDEFINED_                        { $$ = VT_USERDEFINED; }
+                        | RECORD_                             { $$ = VT_RECORD; }
+                        | FILETIME_                           { $$ = VT_FILETIME; }
+                        | BLOB_                               { $$ = VT_BLOB; }
+                        | STREAM_                             { $$ = VT_STREAM; }
+                        | STORAGE_                            { $$ = VT_STORAGE; }
+                        | STREAMED_OBJECT_                    { $$ = VT_STREAMED_OBJECT; }
+                        | STORED_OBJECT_                      { $$ = VT_STORED_OBJECT; }
+                        | BLOB_OBJECT_                        { $$ = VT_BLOB_OBJECT; }
+                        | CF_                                 { $$ = VT_CF; }
+                        | CLSID_                              { $$ = VT_CLSID; }
+                        ;
+
+/*  Managed types for signatures  */                        
+type                    : CLASS_ className                    { if($2 == PASM->m_tkSysString)
+                                                                {     $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_STRING); }
+                                                                else if($2 == PASM->m_tkSysObject)
+                                                                {     $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_OBJECT); }
+                                                                else  
+                                                                 $$ = parser->MakeTypeClass(ELEMENT_TYPE_CLASS, $2); } 
+                        | OBJECT_                             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_OBJECT); } 
+                        | VALUE_ CLASS_ className             { $$ = parser->MakeTypeClass(ELEMENT_TYPE_VALUETYPE, $3); } 
+                        | VALUETYPE_ className                { $$ = parser->MakeTypeClass(ELEMENT_TYPE_VALUETYPE, $2); } 
+                        | type '[' ']'                        { $$ = $1; $$->insertInt8(ELEMENT_TYPE_SZARRAY); } 
+                        | type '[' bounds1 ']'                { $$ = parser->MakeTypeArray(ELEMENT_TYPE_ARRAY, $1, $3); } 
+                        | type '&'                            { $$ = $1; $$->insertInt8(ELEMENT_TYPE_BYREF); }
+                        | type '*'                            { $$ = $1; $$->insertInt8(ELEMENT_TYPE_PTR); }
+                        | type PINNED_                        { $$ = $1; $$->insertInt8(ELEMENT_TYPE_PINNED); }
+                        | type MODREQ_ '(' typeSpec ')'       { $$ = parser->MakeTypeClass(ELEMENT_TYPE_CMOD_REQD, $4);
+                                                                $$->append($1); }
+                        | type MODOPT_ '(' typeSpec ')'       { $$ = parser->MakeTypeClass(ELEMENT_TYPE_CMOD_OPT, $4);
+                                                                $$->append($1); }
+                        | methodSpec callConv type '*' '(' sigArgs0 ')'  
+                                                              { $$ = parser->MakeSig($2, $3, $6);
+                                                                $$->insertInt8(ELEMENT_TYPE_FNPTR); 
+                                                                PASM->delArgNameList(PASM->m_firstArgName);
+                                                                PASM->m_firstArgName = parser->m_ANSFirst.POP();
+                                                                PASM->m_lastArgName = parser->m_ANSLast.POP();
+                                                              }
+                        | type '<' tyArgs1 '>'                { if($3 == NULL) $$ = $1;
+                                                                else {
+                                                                  $$ = new BinStr(); 
+                                                                  $$->appendInt8(ELEMENT_TYPE_GENERICINST); 
+                                                                  $$->append($1);
+                                                                  corEmitInt($$, corCountArgs($3));
+                                                                  $$->append($3); delete $1; delete $3; }}
+                        | '!' '!' int32                       { //if(PASM->m_pCurMethod)  {
+                                                                //  if(($3 < 0)||((DWORD)$3 >= PASM->m_pCurMethod->m_NumTyPars))
+                                                                //    PASM->report->error("Invalid method type parameter '%d'\n",$3);
+                                                                  $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_MVAR); corEmitInt($$, $3); 
+                                                                //} else PASM->report->error("Method type parameter '%d' outside method scope\n",$3);
+                                                              }
+                        | '!' int32                           { //if(PASM->m_pCurClass)  {
+                                                                //  if(($2 < 0)||((DWORD)$2 >= PASM->m_pCurClass->m_NumTyPars))
+                                                                //    PASM->report->error("Invalid type parameter '%d'\n",$2);
+                                                                  $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_VAR); corEmitInt($$, $2); 
+                                                                //} else PASM->report->error("Type parameter '%d' outside class scope\n",$2);
+                                                              }
+                        | '!' '!' dottedName                  { int eltype = ELEMENT_TYPE_MVAR;
+                                                                int n=-1;
+                                                                if(PASM->m_pCurMethod) n = PASM->m_pCurMethod->FindTyPar($3);
+                                                                else {
+                                                                  if(PASM->m_TyParList) n = PASM->m_TyParList->IndexOf($3);
+                                                                  if(n == -1)
+                                                                  { n = TyParFixupList.COUNT();
+                                                                    TyParFixupList.PUSH($3);
+                                                                    eltype = ELEMENT_TYPE_MVARFIXUP;
+                                                                  }
+                                                                }
+                                                                if(n == -1) { PASM->report->error("Invalid method type parameter '%s'\n",$3);
+                                                                n = 0x1FFFFFFF; }
+                                                                $$ = new BinStr(); $$->appendInt8(eltype); corEmitInt($$,n); 
+                                                              }
+                        | '!' dottedName                      { int eltype = ELEMENT_TYPE_VAR;
+                                                                int n=-1;
+                                                                if(PASM->m_pCurClass && !newclass) n = PASM->m_pCurClass->FindTyPar($2);
+                                                                else {
+                                                                  if(PASM->m_TyParList) n = PASM->m_TyParList->IndexOf($2);
+                                                                  if(n == -1)
+                                                                  { n = TyParFixupList.COUNT();
+                                                                    TyParFixupList.PUSH($2);
+                                                                    eltype = ELEMENT_TYPE_VARFIXUP;
+                                                                  }
+                                                                }
+                                                                if(n == -1) { PASM->report->error("Invalid type parameter '%s'\n",$2);
+                                                                n = 0x1FFFFFFF; }
+                                                                $$ = new BinStr(); $$->appendInt8(eltype); corEmitInt($$,n); 
+                                                              }
+                        | TYPEDREF_                           { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_TYPEDBYREF); }
+                        | VOID_                               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_VOID); }
+                        | NATIVE_ INT_                        { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I); }
+                        | NATIVE_ UNSIGNED_ INT_              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U); }
+                        | NATIVE_ UINT_                       { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U); }
+                        | simpleType                          { $$ = $1; }
+                        | ELIPSIS type                        { $$ = $2; $$->insertInt8(ELEMENT_TYPE_SENTINEL); }
+                        ;
+                        
+simpleType              : CHAR_                               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_CHAR); }
+                        | STRING_                             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_STRING); } 
+                        | BOOL_                               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_BOOLEAN); }
+                        | INT8_                               { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I1); }
+                        | INT16_                              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I2); }
+                        | INT32_                              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I4); }
+                        | INT64_                              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_I8); }
+                        | FLOAT32_                            { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R4); }
+                        | FLOAT64_                            { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_R8); }
+                        | UNSIGNED_ INT8_                     { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U1); }
+                        | UNSIGNED_ INT16_                    { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U2); }
+                        | UNSIGNED_ INT32_                    { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U4); }
+                        | UNSIGNED_ INT64_                    { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U8); }
+                        | UINT8_                              { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U1); }
+                        | UINT16_                             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U2); }
+                        | UINT32_                             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U4); }
+                        | UINT64_                             { $$ = new BinStr(); $$->appendInt8(ELEMENT_TYPE_U8); }
+                        | TYPEDEF_TS                          { $$ = new BinStr(); $$->append($1->m_pbsTypeSpec); }
+                        ;
+                        
+bounds1                 : bound                               { $$ = $1; }
+                        | bounds1 ',' bound                   { $$ = $1; $1->append($3); delete $3; }
+                        ;
+
+bound                   : /* EMPTY */                         { $$ = new BinStr(); $$->appendInt32(0x7FFFFFFF); $$->appendInt32(0x7FFFFFFF);  }
+                        | ELIPSIS                             { $$ = new BinStr(); $$->appendInt32(0x7FFFFFFF); $$->appendInt32(0x7FFFFFFF);  }
+                        | int32                               { $$ = new BinStr(); $$->appendInt32(0); $$->appendInt32($1); } 
+                        | int32 ELIPSIS int32                 { FAIL_UNLESS($1 <= $3, ("lower bound %d must be <= upper bound %d\n", $1, $3));
+                                                                if ($1 > $3) { YYERROR; };        
+                                                                $$ = new BinStr(); $$->appendInt32($1); $$->appendInt32($3-$1+1); }   
+                        | int32 ELIPSIS                       { $$ = new BinStr(); $$->appendInt32($1); $$->appendInt32(0x7FFFFFFF); } 
+                        ;
+
+/*  Security declarations  */                        
+secDecl                 : _PERMISSION secAction typeSpec '(' nameValPairs ')'
+                                                              { PASM->AddPermissionDecl($2, $3, $5); }
+                        | _PERMISSION secAction typeSpec '=' '{' customBlobDescr '}'
+                                                              { PASM->AddPermissionDecl($2, $3, $6); }
+                        | _PERMISSION secAction typeSpec      { PASM->AddPermissionDecl($2, $3, (NVPair *)NULL); }
+                        | psetHead bytes ')'                  { PASM->AddPermissionSetDecl($1, $2); }
+                        | _PERMISSIONSET secAction compQstring
+                                                              { PASM->AddPermissionSetDecl($2,BinStrToUnicode($3,true));}
+                        | _PERMISSIONSET secAction '=' '{' secAttrSetBlob '}'
+                                                              { BinStr* ret = new BinStr();
+                                                                ret->insertInt8('.');
+                                                                corEmitInt(ret, nSecAttrBlobs);
+                                                                ret->append($5);
+                                                                PASM->AddPermissionSetDecl($2,ret);
+                                                                nSecAttrBlobs = 0; }
+                        ;
+                        
+secAttrSetBlob          : /* EMPTY */                         { $$ = new BinStr(); nSecAttrBlobs = 0;}
+                        | secAttrBlob                         { $$ = $1; nSecAttrBlobs = 1; }
+                        | secAttrBlob ',' secAttrSetBlob      { $$ = $1; $$->append($3); nSecAttrBlobs++; }
+                        ;
+                        
+secAttrBlob             : typeSpec '=' '{' customBlobNVPairs '}'
+                                                              { $$ = PASM->EncodeSecAttr(PASM->ReflectionNotation($1),$4,nCustomBlobNVPairs); 
+                                                                nCustomBlobNVPairs = 0; }                                               
+                        | CLASS_ SQSTRING '=' '{' customBlobNVPairs '}'
+                                                              { $$ = PASM->EncodeSecAttr($2,$5,nCustomBlobNVPairs); 
+                                                                nCustomBlobNVPairs = 0; }
+                        ;                                               
+
+psetHead                : _PERMISSIONSET secAction '=' '('    { $$ = $2; bParsingByteArray = TRUE; }
+                        | _PERMISSIONSET secAction BYTEARRAY_ '(' 
+                                                              { $$ = $2; bParsingByteArray = TRUE; }
+                        ;
+
+nameValPairs            : nameValPair                         { $$ = $1; }
+                        | nameValPair ',' nameValPairs        { $$ = $1->Concat($3); }
+                        ;
+
+nameValPair             : compQstring '=' caValue             { $1->appendInt8(0); $$ = new NVPair($1, $3); }
+                        ;
+
+truefalse               : TRUE_                               { $$ = 1; }
+                        | FALSE_                              { $$ = 0; }
+                        ;
+
+caValue                 : truefalse                           { $$ = new BinStr();
+                                                                $$->appendInt8(SERIALIZATION_TYPE_BOOLEAN);
+                                                                $$->appendInt8($1); }
+                        | int32                               { $$ = new BinStr();
+                                                                $$->appendInt8(SERIALIZATION_TYPE_I4);
+                                                                $$->appendInt32($1); }
+                        | INT32_ '(' int32 ')'                { $$ = new BinStr();
+                                                                $$->appendInt8(SERIALIZATION_TYPE_I4);
+                                                                $$->appendInt32($3); }
+                        | compQstring                         { $$ = new BinStr();
+                                                                $$->appendInt8(SERIALIZATION_TYPE_STRING);
+                                                                $$->append($1); delete $1;
+                                                                $$->appendInt8(0); }
+                        | className '(' INT8_ ':' int32 ')'   { $$ = new BinStr();
+                                                                $$->appendInt8(SERIALIZATION_TYPE_ENUM);
+                                                                char* sz = PASM->ReflectionNotation($1);
+                                                                strcpy_s((char *)$$->getBuff((unsigned)strlen(sz) + 1), strlen(sz) + 1,sz);
+                                                                $$->appendInt8(1);
+                                                                $$->appendInt32($5); }
+                        | className '(' INT16_ ':' int32 ')'  { $$ = new BinStr();
+                                                                $$->appendInt8(SERIALIZATION_TYPE_ENUM);
+                                                                char* sz = PASM->ReflectionNotation($1);
+                                                                strcpy_s((char *)$$->getBuff((unsigned)strlen(sz) + 1), strlen(sz) + 1,sz);
+                                                                $$->appendInt8(2);
+                                                                $$->appendInt32($5); }
+                        | className '(' INT32_ ':' int32 ')'  { $$ = new BinStr();
+                                                                $$->appendInt8(SERIALIZATION_TYPE_ENUM);
+                                                                char* sz = PASM->ReflectionNotation($1);
+                                                                strcpy_s((char *)$$->getBuff((unsigned)strlen(sz) + 1), strlen(sz) + 1,sz);
+                                                                $$->appendInt8(4);
+                                                                $$->appendInt32($5); }
+                        | className '(' int32 ')'             { $$ = new BinStr();
+                                                                $$->appendInt8(SERIALIZATION_TYPE_ENUM);
+                                                                char* sz = PASM->ReflectionNotation($1);
+                                                                strcpy_s((char *)$$->getBuff((unsigned)strlen(sz) + 1), strlen(sz) + 1,sz);
+                                                                $$->appendInt8(4);
+                                                                $$->appendInt32($3); }
+                        ;
+
+secAction               : REQUEST_                            { $$ = dclRequest; }
+                        | DEMAND_                             { $$ = dclDemand; }
+                        | ASSERT_                             { $$ = dclAssert; }
+                        | DENY_                               { $$ = dclDeny; }
+                        | PERMITONLY_                         { $$ = dclPermitOnly; }
+                        | LINKCHECK_                          { $$ = dclLinktimeCheck; }
+                        | INHERITCHECK_                       { $$ = dclInheritanceCheck; }
+                        | REQMIN_                             { $$ = dclRequestMinimum; }
+                        | REQOPT_                             { $$ = dclRequestOptional; }
+                        | REQREFUSE_                          { $$ = dclRequestRefuse; }
+                        | PREJITGRANT_                        { $$ = dclPrejitGrant; }
+                        | PREJITDENY_                         { $$ = dclPrejitDenied; }
+                        | NONCASDEMAND_                       { $$ = dclNonCasDemand; }
+                        | NONCASLINKDEMAND_                   { $$ = dclNonCasLinkDemand; }
+                        | NONCASINHERITANCE_                  { $$ = dclNonCasInheritance; }
+                        ;
+
+/*  External source declarations  */                        
+esHead                  : _LINE                               { PASM->ResetLineNumbers(); nCurrPC = PASM->m_CurPC; PENV->bExternSource = TRUE; PENV->bExternSourceAutoincrement = FALSE; }
+                        | P_LINE                              { PASM->ResetLineNumbers(); nCurrPC = PASM->m_CurPC; PENV->bExternSource = TRUE; PENV->bExternSourceAutoincrement = TRUE; }
+                        ;
+                        
+extSourceSpec           : esHead int32 SQSTRING               { PENV->nExtLine = PENV->nExtLineEnd = $2;
+                                                                PENV->nExtCol = 0; PENV->nExtColEnd  = static_cast<unsigned>(-1);
+                                                                PASM->SetSourceFileName($3);}
+                        | esHead int32                        { PENV->nExtLine = PENV->nExtLineEnd = $2;
+                                                                PENV->nExtCol = 0; PENV->nExtColEnd  = static_cast<unsigned>(-1); }
+                        | esHead int32 ':' int32 SQSTRING     { PENV->nExtLine = PENV->nExtLineEnd = $2; 
+                                                                PENV->nExtCol=$4; PENV->nExtColEnd = static_cast<unsigned>(-1);
+                                                                PASM->SetSourceFileName($5);}
+                        | esHead int32 ':' int32              { PENV->nExtLine = PENV->nExtLineEnd = $2; 
+                                                                PENV->nExtCol=$4; PENV->nExtColEnd = static_cast<unsigned>(-1);}
+                        | esHead int32 ':' int32 ',' int32 SQSTRING     
+                                                              { PENV->nExtLine = PENV->nExtLineEnd = $2; 
+                                                                PENV->nExtCol=$4; PENV->nExtColEnd = $6;
+                                                                PASM->SetSourceFileName($7);}
+                        | esHead int32 ':' int32 ',' int32     
+                                                              { PENV->nExtLine = PENV->nExtLineEnd = $2; 
+                                                                PENV->nExtCol=$4; PENV->nExtColEnd = $6; }
+                        | esHead int32 ',' int32 ':' int32 SQSTRING     
+                                                              { PENV->nExtLine = $2; PENV->nExtLineEnd = $4; 
+                                                                PENV->nExtCol=$6; PENV->nExtColEnd = static_cast<unsigned>(-1);
+                                                                PASM->SetSourceFileName($7);}
+                        | esHead int32 ',' int32 ':' int32     
+                                                              { PENV->nExtLine = $2; PENV->nExtLineEnd = $4; 
+                                                                PENV->nExtCol=$6; PENV->nExtColEnd = static_cast<unsigned>(-1); }
+                        | esHead int32 ',' int32 ':' int32 ',' int32 SQSTRING     
+                                                              { PENV->nExtLine = $2; PENV->nExtLineEnd = $4; 
+                                                                PENV->nExtCol=$6; PENV->nExtColEnd = $8;
+                                                                PASM->SetSourceFileName($9);}
+                        | esHead int32 ',' int32 ':' int32 ',' int32     
+                                                              { PENV->nExtLine = $2; PENV->nExtLineEnd = $4; 
+                                                                PENV->nExtCol=$6; PENV->nExtColEnd = $8; }
+                        | esHead int32 QSTRING                { PENV->nExtLine = PENV->nExtLineEnd = $2 - 1;
+                                                                PENV->nExtCol = 0; PENV->nExtColEnd = static_cast<unsigned>(-1);
+                                                                PASM->SetSourceFileName($3);}
+                        ;
+
+/*  Manifest declarations  */                         
+fileDecl                : _FILE fileAttr dottedName fileEntry hashHead bytes ')' fileEntry      
+                                                              { PASMM->AddFile($3, $2|$4|$8, $6); }
+                        | _FILE fileAttr dottedName fileEntry { PASMM->AddFile($3, $2|$4, NULL); }
+                        ;
+
+fileAttr                : /* EMPTY */                         { $$ = (CorFileFlags) 0; }
+                        | fileAttr NOMETADATA_                { $$ = (CorFileFlags) ($1 | ffContainsNoMetaData); }
+                        ;
+
+fileEntry               : /* EMPTY */                         { $$ = (CorFileFlags) 0; }
+                        | _ENTRYPOINT                         { $$ = (CorFileFlags) 0x80000000; }
+                        ;
+
+hashHead                : _HASH '=' '('                       { bParsingByteArray = TRUE; }
+                        ;
+
+assemblyHead            : _ASSEMBLY asmAttr dottedName        { PASMM->StartAssembly($3, NULL, (DWORD)$2, FALSE); }
+                        ;
+
+asmAttr                 : /* EMPTY */                         { $$ = (CorAssemblyFlags) 0; }
+                        | asmAttr RETARGETABLE_               { $$ = (CorAssemblyFlags) ($1 | afRetargetable); }
+                        | asmAttr WINDOWSRUNTIME_             { $$ = (CorAssemblyFlags) ($1 | afContentType_WindowsRuntime); }
+                        | asmAttr NOPLATFORM_                 { $$ = (CorAssemblyFlags) ($1 | afPA_NoPlatform); }
+                        | asmAttr LEGACY_ LIBRARY_            { $$ = $1; }
+                        | asmAttr CIL_                        { SET_PA($$,$1,afPA_MSIL); }
+                        | asmAttr X86_                        { SET_PA($$,$1,afPA_x86); }
+                        | asmAttr IA64_                       { SET_PA($$,$1,afPA_IA64); }
+                        | asmAttr AMD64_                      { SET_PA($$,$1,afPA_AMD64); }
+                        | asmAttr ARM_                        { SET_PA($$,$1,afPA_ARM); }
+                        ;
+
+assemblyDecls           : /* EMPTY */
+                        | assemblyDecls assemblyDecl
+                        ;
+
+assemblyDecl            : _HASH ALGORITHM_ int32              { PASMM->SetAssemblyHashAlg($3); }
+                        | secDecl
+                        | asmOrRefDecl
+                        ;
+                        
+intOrWildcard           : int32                               { $$ = $1; }
+                        | '*'                                 { $$ = 0xFFFF; }
+                        ;                        
+
+asmOrRefDecl            : publicKeyHead bytes ')'             { PASMM->SetAssemblyPublicKey($2); }
+                        | _VER intOrWildcard ':' intOrWildcard ':' intOrWildcard ':' intOrWildcard      
+                                                              { PASMM->SetAssemblyVer((USHORT)$2, (USHORT)$4, (USHORT)$6, (USHORT)$8); }
+                        | _LOCALE compQstring                 { $2->appendInt8(0); PASMM->SetAssemblyLocale($2,TRUE); }
+                        | localeHead bytes ')'                { PASMM->SetAssemblyLocale($2,FALSE); }
+                        | customAttrDecl
+                        | compControl
+                        ;
+
+publicKeyHead           : _PUBLICKEY '=' '('                  { bParsingByteArray = TRUE; }
+                        ;
+
+publicKeyTokenHead      : _PUBLICKEYTOKEN '=' '('             { bParsingByteArray = TRUE; }
+                        ;
+
+localeHead              : _LOCALE '=' '('                     { bParsingByteArray = TRUE; }
+                        ;
+
+assemblyRefHead         : _ASSEMBLY EXTERN_ asmAttr dottedName     
+                                                              { PASMM->StartAssembly($4, NULL, $3, TRUE); }
+                        | _ASSEMBLY EXTERN_ asmAttr dottedName AS_ dottedName   
+                                                              { PASMM->StartAssembly($4, $6, $3, TRUE); }
+                        ;
+
+assemblyRefDecls        : /* EMPTY */
+                        | assemblyRefDecls assemblyRefDecl
+                        ;
+
+assemblyRefDecl         : hashHead bytes ')'                  { PASMM->SetAssemblyHashBlob($2); }
+                        | asmOrRefDecl
+                        | publicKeyTokenHead bytes ')'        { PASMM->SetAssemblyPublicKeyToken($2); }
+                        | AUTO_                               { PASMM->SetAssemblyAutodetect(); }
+                        ;
+
+exptypeHead             : _CLASS EXTERN_ exptAttr dottedName  { PASMM->StartComType($4, $3);} 
+                        ;
+
+exportHead              : _EXPORT exptAttr dottedName   /* deprecated */      { PASMM->StartComType($3, $2); }
+                        ;
+
+exptAttr                : /* EMPTY */                         { $$ = (CorTypeAttr) 0; }
+                        | exptAttr PRIVATE_                   { $$ = (CorTypeAttr) ($1 | tdNotPublic); }
+                        | exptAttr PUBLIC_                    { $$ = (CorTypeAttr) ($1 | tdPublic); }
+                        | exptAttr FORWARDER_                 { $$ = (CorTypeAttr) ($1 | tdForwarder); }
+                        | exptAttr NESTED_ PUBLIC_            { $$ = (CorTypeAttr) ($1 | tdNestedPublic); }
+                        | exptAttr NESTED_ PRIVATE_           { $$ = (CorTypeAttr) ($1 | tdNestedPrivate); }
+                        | exptAttr NESTED_ FAMILY_            { $$ = (CorTypeAttr) ($1 | tdNestedFamily); }
+                        | exptAttr NESTED_ ASSEMBLY_          { $$ = (CorTypeAttr) ($1 | tdNestedAssembly); }
+                        | exptAttr NESTED_ FAMANDASSEM_       { $$ = (CorTypeAttr) ($1 | tdNestedFamANDAssem); }
+                        | exptAttr NESTED_ FAMORASSEM_        { $$ = (CorTypeAttr) ($1 | tdNestedFamORAssem); }
+                        ;
+
+exptypeDecls            : /* EMPTY */
+                        | exptypeDecls exptypeDecl
+                        ;
+
+exptypeDecl             : _FILE dottedName                    { PASMM->SetComTypeFile($2); }
+                        | _CLASS EXTERN_ slashedName           { PASMM->SetComTypeComType($3); }
+                        | _ASSEMBLY EXTERN_ dottedName        { PASMM->SetComTypeAsmRef($3); }
+                        | MDTOKEN_ '(' int32 ')'              { if(!PASMM->SetComTypeImplementationTok($3))
+                                                                  PASM->report->error("Invalid implementation of exported type\n"); }
+                        | _CLASS  int32                       { if(!PASMM->SetComTypeClassTok($2))
+                                                                  PASM->report->error("Invalid TypeDefID of exported type\n"); }
+                        | customAttrDecl
+                        | compControl
+                        ;
+
+manifestResHead         : _MRESOURCE manresAttr dottedName    { PASMM->StartManifestRes($3, $3, $2); }
+                        | _MRESOURCE manresAttr dottedName AS_ dottedName
+                                                              { PASMM->StartManifestRes($3, $5, $2); }
+                        ;
+
+manresAttr              : /* EMPTY */                         { $$ = (CorManifestResourceFlags) 0; }
+                        | manresAttr PUBLIC_                  { $$ = (CorManifestResourceFlags) ($1 | mrPublic); }
+                        | manresAttr PRIVATE_                 { $$ = (CorManifestResourceFlags) ($1 | mrPrivate); }
+                        ;
+
+manifestResDecls        : /* EMPTY */
+                        | manifestResDecls manifestResDecl
+                        ;
+
+manifestResDecl         : _FILE dottedName AT_ int32          { PASMM->SetManifestResFile($2, (ULONG)$4); }
+                        | _ASSEMBLY EXTERN_ dottedName        { PASMM->SetManifestResAsmRef($3); }
+                        | customAttrDecl
+                        | compControl
+                        ;
+
+
+%%
+
+#include "grammar_after.cpp"
diff --git a/src/ilasm/asmtemplates.h b/src/ilasm/asmtemplates.h
new file mode 100644
index 0000000000..7ec206ec80
--- /dev/null
+++ b/src/ilasm/asmtemplates.h
@@ -0,0 +1,846 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+
+#ifndef ASMTEMPLATES_H
+#define ASMTEMPLATES_H
+
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:22008) // "Suppress PREfast warnings about integer overflow"
+#endif
+
+inline ULONG GrowBuffer(ULONG startingSize)
+{
+    int toAdd = startingSize >> 1;
+    if (toAdd < 8)
+        toAdd = 8;
+    if (toAdd > 2048)
+        toAdd = 2048;
+    return startingSize + toAdd;
+}
+
+/*****************************************************************************/
+/* LIFO (stack) and FIFO (queue) templates (must precede #include "method.h")*/
+template <class T>
+class LIST_EL
+{
+public:
+    T*  m_Ptr;
+    LIST_EL <T> *m_Next;
+    LIST_EL(T *item) {m_Next = NULL; m_Ptr = item; };
+};
+    
+template <class T>
+class LIFO
+{
+public:
+    inline LIFO() { m_pHead = NULL; };
+    inline ~LIFO() {T *val; while((val = POP()) != NULL) delete val; };
+    void PUSH(T *item) 
+    {
+        m_pTemp = new LIST_EL <T>(item); 
+        m_pTemp->m_Next = m_pHead; 
+        m_pHead = m_pTemp;
+    };
+    T* POP() 
+    {
+        T* ret = NULL;
+        if((m_pTemp = m_pHead) != NULL)
+        {
+            m_pHead = m_pHead->m_Next;
+            ret = m_pTemp->m_Ptr;
+            delete m_pTemp;
+        }
+        return ret;
+    };
+private:
+    LIST_EL <T> *m_pHead;
+    LIST_EL <T> *m_pTemp;
+};
+
+
+#if (0)
+template <class T>
+class FIFO
+{
+public:
+    inline FIFO() { m_pHead = m_pTail = NULL; m_ulCount = 0;};
+    inline ~FIFO() {T *val; while(val = POP()) delete val; };
+    void PUSH(T *item) 
+    {
+        m_pTemp = new LIST_EL <T>(item); 
+        if(m_pTail) m_pTail->m_Next = m_pTemp;
+        m_pTail = m_pTemp;
+        if(m_pHead == NULL) m_pHead = m_pTemp;
+        m_ulCount++;
+    };
+    T* POP() 
+    {
+        T* ret = NULL;
+        if(m_pTemp = m_pHead)
+        {
+            m_pHead = m_pHead->m_Next;
+            ret = m_pTemp->m_Ptr;
+            delete m_pTemp;
+            if(m_pHead == NULL) m_pTail = NULL;
+            m_ulCount--;
+        }
+        return ret;
+    };
+    ULONG COUNT() { return m_ulCount; };
+    T* PEEK(ULONG idx)
+    {
+        T* ret = NULL;
+        ULONG   i;
+        if(idx < m_ulCount)
+        {
+            if(idx == m_ulCount-1) m_pTemp = m_pTail;
+            else for(m_pTemp = m_pHead, i = 0; i < idx; m_pTemp = m_pTemp->m_Next, i++);
+            ret = m_pTemp->m_Ptr;
+        }
+        return ret;
+    };
+private:
+    LIST_EL <T> *m_pHead;
+    LIST_EL <T> *m_pTail;
+    LIST_EL <T> *m_pTemp;
+    ULONG       m_ulCount;
+};
+#else
+template <class T>
+class FIFO
+{
+public:
+    FIFO() { m_Arr = NULL; m_ulArrLen = 0; m_ulCount = 0; m_ulOffset = 0; };
+    ~FIFO() {
+        if(m_Arr) {
+            for(ULONG i=0; i < m_ulCount; i++) {
+                if(m_Arr[i+m_ulOffset]) delete m_Arr[i+m_ulOffset];
+            }
+            delete [] m_Arr;
+        }
+    };
+    void RESET(bool DeleteElements = true) {
+        if(m_Arr) {
+            for(ULONG i=0; i < m_ulCount; i++) {
+                if(DeleteElements) delete m_Arr[i+m_ulOffset];
+                m_Arr[i+m_ulOffset] = NULL;
+            }
+            m_ulCount = 0;
+            m_ulOffset= 0;
+        }
+    };
+    void PUSH(T *item) 
+    {
+		if(item)
+		{
+			if(m_ulCount+m_ulOffset >= m_ulArrLen)
+			{
+				if(m_ulOffset)
+				{
+					memcpy(m_Arr,&m_Arr[m_ulOffset],m_ulCount*sizeof(T*));
+					m_ulOffset = 0;
+				}
+				else
+				{
+                    m_ulArrLen = GrowBuffer(m_ulArrLen);
+					T** tmp = new T*[m_ulArrLen];
+					if(tmp)
+					{
+						if(m_Arr)
+						{
+							memcpy(tmp,m_Arr,m_ulCount*sizeof(T*));
+							delete [] m_Arr;
+						}
+						m_Arr = tmp;
+					}
+					else fprintf(stderr,"\nOut of memory!\n");
+				}
+			}
+			m_Arr[m_ulOffset+m_ulCount] = item;
+			m_ulCount++;
+		}
+    };
+    ULONG COUNT() { return m_ulCount; };
+    T* POP() 
+    {
+        T* ret = NULL;
+        if(m_ulCount)
+        {
+            ret = m_Arr[m_ulOffset++];
+            m_ulCount--;
+        }
+        return ret;
+    };
+    T* PEEK(ULONG idx) { return (idx < m_ulCount) ? m_Arr[m_ulOffset+idx] : NULL; };
+private:
+    T** m_Arr;
+    ULONG       m_ulCount;
+    ULONG       m_ulOffset;
+    ULONG       m_ulArrLen;
+};
+#endif
+
+
+template <class T> struct Indx256
+{
+    void* table[256];
+    Indx256() { memset(table,0,sizeof(table)); };
+    ~Indx256()
+    {
+        ClearAll(true);
+        for(int i = 1; i < 256; i++) delete ((Indx256*)(table[i]));
+    };
+    T** IndexString(BYTE* psz, T* pObj)
+    {
+        if(*psz == 0)
+        {
+            table[0] = (void*)pObj;
+            return (T**)table;
+        }
+        else
+        {
+            Indx256* pInd = (Indx256*)(table[*psz]);
+            if(pInd == NULL)
+            {
+                pInd = new Indx256;
+                if(pInd)
+                    table[*psz] = pInd;
+                else
+                {
+                    _ASSERTE(!"Out of memory in Indx256::IndexString!");
+                    fprintf(stderr,"\nOut of memory in Indx256::IndexString!\n");
+                    return NULL;
+                }
+            }
+            return pInd->IndexString(psz+1,pObj);
+        }
+    };
+    T*  FindString(BYTE* psz)
+    {
+        if(*psz > 0)
+        {
+            Indx256* pInd = (Indx256*)(table[*psz]);
+            return (pInd == NULL) ? NULL : pInd->FindString(psz+1);
+        }
+        return (T*)(table[0]); // if i==0
+    };
+    
+    void ClearAll(bool DeleteObj)
+    {
+        if(DeleteObj) delete (T*)(table[0]);
+        table[0] = NULL;
+        for(unsigned i = 1; i < 256; i++)
+        {
+            if(table[i])
+            {
+                Indx256* pInd = (Indx256*)(table[i]);
+                pInd->ClearAll(DeleteObj);
+                //delete pInd;
+                //table[i] = NULL;
+            }
+        }
+    };
+};
+
+//
+// Template intended for named objects, that expose function char* NameOf()
+//
+template <class T>
+class FIFO_INDEXED
+{
+public:
+    FIFO_INDEXED() { m_Arr = NULL; m_ulArrLen = 0; m_ulCount = 0; m_ulOffset = 0; };
+    ~FIFO_INDEXED() {
+        if(m_Arr)
+        {
+            RESET(true);
+            delete [] m_Arr;
+        }
+    };
+    void RESET(bool DeleteElements = true) {
+        if(m_Arr) {
+            unsigned i;
+            if(DeleteElements)
+            {
+                for(i=m_ulOffset; i < m_ulOffset+m_ulCount; i++)
+                {
+                    T** ppT = m_Arr[i];
+                    delete *ppT;
+                }
+            }
+            for(i=m_ulOffset; i < m_ulOffset+m_ulCount; i++)
+            {
+                *m_Arr[i] = NULL;
+            }
+            memset(&m_Arr[m_ulOffset],0,m_ulCount*sizeof(void*));
+            m_ulCount = 0;
+            m_ulOffset= 0;
+        }
+    };
+    void PUSH(T *item) 
+    {
+		if(item)
+		{
+            T** itemaddr = m_Index.IndexString((BYTE*)(item->NameOf()),item);
+            if(m_ulCount+m_ulOffset >= m_ulArrLen)
+			{
+				if(m_ulOffset)
+				{
+					memcpy(m_Arr,&m_Arr[m_ulOffset],m_ulCount*sizeof(T*));
+					m_ulOffset = 0;
+				}
+				else
+				{
+					m_ulArrLen = GrowBuffer(m_ulArrLen);
+					T*** tmp = new T**[m_ulArrLen];
+					if(tmp)
+					{
+						if(m_Arr)
+						{
+							memcpy(tmp,m_Arr,m_ulCount*sizeof(T**));
+							delete [] m_Arr;
+						}
+						m_Arr = tmp;
+					}
+					else fprintf(stderr,"\nOut of memory!\n");
+				}
+			}
+			m_Arr[m_ulOffset+m_ulCount] = itemaddr;
+			m_ulCount++;
+		}
+    };
+    ULONG COUNT() { return m_ulCount; };
+    T* POP() 
+    {
+        T* ret = NULL;
+        if(m_ulCount)
+        {
+            ret = *(m_Arr[m_ulOffset]);
+            *m_Arr[m_ulOffset] = NULL;
+            m_ulOffset++;
+            m_ulCount--;
+        }
+        return ret;
+    };
+    T* PEEK(ULONG idx) { return (idx < m_ulCount) ? *(m_Arr[m_ulOffset+idx]) : NULL; };
+    T* FIND(T* item) { return m_Index.FindString((BYTE*)(item->NameOf())); };
+private:
+    T*** m_Arr;
+    ULONG       m_ulCount;
+    ULONG       m_ulOffset;
+    ULONG       m_ulArrLen;
+    Indx256<T>  m_Index;
+};
+
+template <class T>
+class SORTEDARRAY
+{
+public:
+    SORTEDARRAY() { m_Arr = NULL; m_ulArrLen = 0; m_ulCount = 0; m_ulOffset = 0; };
+    ~SORTEDARRAY() {
+        if(m_Arr) {
+            for(ULONG i=0; i < m_ulCount; i++) {
+                if(m_Arr[i+m_ulOffset]) delete m_Arr[i+m_ulOffset];
+            }
+            delete [] m_Arr;
+        }
+    };
+    void RESET(bool DeleteElements = true) {
+        if(m_Arr) {
+            if(DeleteElements)
+            {
+                for(ULONG i=0; i < m_ulCount; i++) {
+                    delete m_Arr[i+m_ulOffset];
+                }
+            }
+            memset(m_Arr,0,m_ulArrLen*sizeof(T*));
+            m_ulCount = 0;
+            m_ulOffset= 0;
+        }
+    };
+    void PUSH(T *item) 
+    {
+		if(item)
+		{
+			if(m_ulCount+m_ulOffset >= m_ulArrLen)
+			{
+				if(m_ulOffset)
+				{
+					memcpy(m_Arr,&m_Arr[m_ulOffset],m_ulCount*sizeof(T*));
+					m_ulOffset = 0;
+				}
+				else
+				{
+					m_ulArrLen = GrowBuffer(m_ulArrLen);
+					T** tmp = new T*[m_ulArrLen];
+					if(tmp)
+					{
+						if(m_Arr)
+						{
+							memcpy(tmp,m_Arr,m_ulCount*sizeof(T*));
+							delete [] m_Arr;
+						}
+						m_Arr = tmp;
+					}
+					else fprintf(stderr,"\nOut of memory!\n");
+				}
+			}
+            if(m_ulCount)
+            {
+                // find  1st arr.element > item
+                T** low = &m_Arr[m_ulOffset];
+                T** high = &m_Arr[m_ulOffset+m_ulCount-1];
+                T** mid;
+            
+                if(item->ComparedTo(*high) > 0) mid = high+1;
+                else if(item->ComparedTo(*low) < 0) mid = low;
+                else for(;;) 
+                {
+                    mid = &low[(high - low) >> 1];
+            
+                    int cmp = item->ComparedTo(*mid);
+            
+                    if (mid == low)
+                    {
+                        if(cmp > 0) mid++;
+                        break;
+                    }
+            
+                    if (cmp > 0) low = mid;
+                    else        high = mid;
+                }
+
+                /////////////////////////////////////////////
+                 memmove(mid+1,mid,(BYTE*)&m_Arr[m_ulOffset+m_ulCount]-(BYTE*)mid);
+                *mid = item;
+            }
+			else m_Arr[m_ulOffset+m_ulCount] = item;
+			m_ulCount++;
+		}
+    };
+    ULONG COUNT() { return m_ulCount; };
+    T* POP() 
+    {
+        T* ret = NULL;
+        if(m_ulCount)
+        {
+            ret = m_Arr[m_ulOffset++];
+            m_ulCount--;
+        }
+        return ret;
+    };
+    T* PEEK(ULONG idx) { return (idx < m_ulCount) ? m_Arr[m_ulOffset+idx] : NULL; };
+    T* FIND(T* item)
+    {
+        if(m_ulCount)
+        {
+            T** low = &m_Arr[m_ulOffset];
+            T** high = &m_Arr[m_ulOffset+m_ulCount-1];
+            T** mid;
+            if(item->ComparedTo(*high) == 0) return(*high);
+            for(;;) 
+            {
+                mid = &low[(high - low) >> 1];
+                int cmp = item->ComparedTo(*mid);
+                if (cmp == 0) return(*mid);
+                if (mid == low)  break;
+                if (cmp > 0) low = mid;
+                else        high = mid;
+            }
+        }
+        return NULL;
+    };
+    /*
+    T* FIND(U item)
+    {
+        if(m_ulCount)
+        {
+            T** low = &m_Arr[m_ulOffset];
+            T** high = &m_Arr[m_ulOffset+m_ulCount-1];
+            T** mid;
+            if((*high)->Compare(item) == 0) return(*high);
+            for(;;) 
+            {
+                mid = &low[(high - low) >> 1];
+                int cmp = (*mid)->Compare(item);
+                if (cmp == 0) return(*mid);
+                if (mid == low)  break;
+                if (cmp > 0) low = mid;
+                else        high = mid;
+            }
+        }
+        return NULL;
+    };
+    */
+    BOOL DEL(T* item)
+    {
+        if(m_ulCount)
+        {
+            T** low = &m_Arr[m_ulOffset];
+            T** high = &m_Arr[m_ulOffset+m_ulCount-1];
+            T** mid;
+            if(item->ComparedTo(*high) == 0)
+            {
+                delete (*high);
+                m_ulCount--;
+                return TRUE;
+            }
+            for(;;) 
+            {
+                mid = &low[(high - low) >> 1];
+                int cmp = item->ComparedTo(*mid);
+                if (cmp == 0)
+                { 
+                    delete (*mid);
+                    memcpy(mid,mid+1,(BYTE*)&m_Arr[m_ulOffset+m_ulCount]-(BYTE*)mid-1);
+                    m_ulCount--;
+                    return TRUE;
+                }
+                if (mid == low)  break;
+                if (cmp > 0) low = mid;
+                else        high = mid;
+            }
+        }
+        return FALSE;
+    };
+private:
+    T** m_Arr;
+    ULONG       m_ulCount;
+    ULONG       m_ulOffset;
+    ULONG       m_ulArrLen;
+};
+
+template <class T> struct RBNODE
+{
+private:
+    DWORD       dwRed;
+public:
+    DWORD       dwInUse;
+    T*          tVal;
+    RBNODE<T>*  pLeft;
+    RBNODE<T>*  pRight;
+    RBNODE<T>*  pParent;
+    RBNODE()
+    {
+        pLeft = pRight = pParent = NULL;
+        tVal = NULL;
+        dwRed = dwInUse = 0;
+    };
+    RBNODE(T* pVal, DWORD dwColor)
+    {
+        pLeft = pRight = pParent = NULL;
+        tVal = pVal;
+        dwRed = dwColor;
+        dwInUse = 0;
+    };
+    bool IsRed() { return (dwRed != 0); };
+    void SetRed() { dwRed = 1; };
+    void SetBlack() { dwRed = 0; };
+};
+
+#define BUCKETCOUNT 512
+
+template <class T> class RBNODEBUCKET
+{
+private:
+    RBNODEBUCKET<T>* pNext;
+    RBNODE<T> bucket[BUCKETCOUNT];
+    unsigned  alloc_count;
+
+public:
+    RBNODEBUCKET()
+    {
+        alloc_count = 0;
+        pNext = NULL;
+    };
+
+    ~RBNODEBUCKET() { if(pNext) delete pNext; };
+    
+    bool CanAlloc() { return (alloc_count < BUCKETCOUNT); };
+    
+    RBNODE<T>* AllocNode()
+    {
+        RBNODE<T>* pRet;
+        for(unsigned i = 0; i < BUCKETCOUNT; i++)
+        {
+            if(bucket[i].dwInUse == 0)
+            {
+                alloc_count++;
+                pRet = &bucket[i];
+                memset(pRet, 0, sizeof(RBNODE<T>));
+                pRet->dwInUse = 1;
+                return pRet;
+            }
+        }
+        _ASSERTE(!"AllocNode returns NULL");
+        return NULL;
+    };
+    
+    bool FreeNode(RBNODE<T>* ptr)
+    {
+        size_t idx = ((size_t)ptr - (size_t)bucket)/sizeof(RBNODE<T>);
+        if(idx < BUCKETCOUNT)
+        {
+            bucket[idx].dwInUse = 0;
+            alloc_count--;
+            return true;
+        }
+        return false;
+    };
+    
+    RBNODEBUCKET<T>* Next() { return pNext; };
+    
+    void Append(RBNODEBUCKET<T>* ptr) { pNext = ptr; };
+};
+
+template <class T> class RBNODEPOOL
+{
+private:
+    RBNODEBUCKET<T> base;
+
+public:
+    RBNODEPOOL()
+    {
+        memset(&base,0,sizeof(RBNODEBUCKET<T>));
+    };
+
+    RBNODE<T>* AllocNode()
+    {
+        RBNODEBUCKET<T>* pBucket = &base;
+        RBNODEBUCKET<T>* pLastBucket = &base;
+        do 
+        {
+            if(pBucket->CanAlloc())
+            {
+                return pBucket->AllocNode();
+            }
+            pLastBucket = pBucket;
+            pBucket = pBucket->Next();
+        } 
+        while (pBucket != NULL);
+        pLastBucket->Append(new RBNODEBUCKET<T>);
+        return pLastBucket->Next()->AllocNode();
+    };
+
+    void FreeNode(RBNODE<T>* ptr)
+    {
+        RBNODEBUCKET<T>* pBucket = &base;
+        do
+        {
+            if(pBucket->FreeNode(ptr))
+                break;
+            pBucket = pBucket->Next();
+        }
+        while (pBucket != NULL);
+    };
+};
+
+template <class T> class RBTREE
+{
+private:
+    RBNODE<T>* pRoot;
+    RBNODE<T>* pNil;
+    RBNODEPOOL<T> NodePool;
+    void RotateLeft(RBNODE<T>* pX)
+    {
+        RBNODE<T>* pY;
+
+        pY = pX->pRight;
+        pX->pRight = pY->pLeft;
+
+        if(pY->pLeft != pNil)
+            pY->pLeft->pParent = pX;
+
+        pY->pParent = pX->pParent;
+
+        if(pX == pX->pParent->pLeft)
+            pX->pParent->pLeft = pY;
+        else
+            pX->pParent->pRight = pY;
+
+        pY->pLeft = pX;
+        pX->pParent = pY;
+    };
+
+    void RotateRight(RBNODE<T>* pX)
+    {
+        RBNODE<T>* pY;
+
+        pY = pX->pLeft;
+        pX->pLeft = pY->pRight;
+
+        if(pY->pRight != pNil)
+            pY->pRight->pParent = pX;
+
+        pY->pParent = pX->pParent;
+
+        if(pX == pX->pParent->pLeft)
+            pX->pParent->pLeft = pY;
+        else
+            pX->pParent->pRight = pY;
+
+        pY->pRight = pX;
+        pX->pParent = pY;
+
+    };
+
+    void InsertNode(RBNODE<T>* pZ)
+    {
+        RBNODE<T>* pX;
+        RBNODE<T>* pY;
+
+        pZ->pLeft = pZ->pRight = pNil;
+        pY = pRoot;
+        pX = pRoot->pLeft;
+
+        if(pX != pY)
+        {
+            while(pX != pNil)
+            {
+                pY = pX;
+                if(pX->tVal->ComparedTo(pZ->tVal) > 0)
+                    pX = pX->pLeft;
+                else
+                    pX = pX->pRight;
+            }
+        }
+        pZ->pParent = pY;
+        if((pY == pRoot) || (pY->tVal->ComparedTo(pZ->tVal) > 0))
+            pY->pLeft = pZ;
+        else
+            pY->pRight = pZ;
+    };
+
+    void InitSpecNode(RBNODE<T>* pNode)
+    {
+        pNode->pLeft = pNode->pRight = pNode->pParent = pNode;
+    };
+
+    void DeleteNode(RBNODE<T>* pNode, bool DeletePayload = true)
+    {
+        if((pNode != pNil)&&(pNode != pRoot))
+        {
+            DeleteNode(pNode->pLeft, DeletePayload);
+            DeleteNode(pNode->pRight, DeletePayload);
+            if(DeletePayload)
+                delete pNode->tVal;
+            NodePool.FreeNode(pNode);
+        }
+    };
+
+public:
+    RBTREE()
+    {
+        pRoot = NodePool.AllocNode();
+        InitSpecNode(pRoot);
+
+        pNil = NodePool.AllocNode();
+        InitSpecNode(pNil);
+    };
+
+    ~RBTREE()
+    {
+        //RESET(false);
+        //NodePool.FreeNode(pRoot);
+        //NodePool.FreeNode(pNil);
+    };
+
+    void RESET(bool DeletePayload = true)
+    {
+        DeleteNode(pRoot->pLeft, DeletePayload);
+        InitSpecNode(pRoot);
+        InitSpecNode(pNil);
+    };
+
+    void PUSH(T* pT)
+    {
+        RBNODE<T>* pX;
+        RBNODE<T>* pY;
+        RBNODE<T>* pNewNode = NodePool.AllocNode();
+        
+        pNewNode->tVal = pT;
+        pNewNode->SetRed();
+
+        InsertNode(pNewNode);
+
+        for(pX = pNewNode; pX->pParent->IsRed();)
+        {
+            if(pX->pParent == pX->pParent->pLeft)
+            {
+                pY = pX->pParent->pRight;
+                if(pY->IsRed())
+                {
+                    pX->pParent->SetBlack();
+                    pY->SetBlack();
+                    pX->pParent->pParent->SetRed();
+                    pX = pX->pParent->pParent;
+                }
+                else
+                {
+                    if(pX == pX->pParent->pRight)
+                    {
+                        pX = pX->pParent;
+                        RotateLeft(pX);
+                    }
+                    pX->pParent->SetBlack();
+                    pX->pParent->pParent->SetRed();
+                    RotateRight(pX->pParent->pParent);
+                }
+            }
+            else // if(pX->pParent == pX->pParent->pRight)
+            {
+                pY = pX->pParent->pParent->pLeft;
+                if(pY->IsRed())
+                {
+                    pX->pParent->SetBlack();
+                    pY->SetBlack();
+                    pX->pParent->pParent->SetRed();
+                    pX = pX->pParent->pParent;
+                }
+                else
+                {
+                    if(pX == pX->pParent->pLeft)
+                    {
+                        pX = pX->pParent;
+                        RotateRight(pX);
+                    }
+                    pX->pParent->SetBlack();
+                    pX->pParent->pParent->SetRed();
+                    RotateLeft(pX->pParent->pParent);
+                }
+            }// end if(pX->pParent == pX->pParent->pLeft) -- else
+        } // end for(pX = pNewNode; pX->pParent->IsRed();)
+        pRoot->pLeft->SetBlack();
+    };
+
+    T* FIND(T* pT)
+    {
+        RBNODE<T>* pX = pRoot->pLeft;
+        if((pX != pNil) && (pX != pRoot))
+        {
+            int cmp = pX->tVal->ComparedTo(pT);
+            while(cmp != 0)
+            {
+                if(cmp > 0)
+                    pX = pX->pLeft;
+                else
+                    pX = pX->pRight;
+                if(pX == pNil)
+                    return NULL;
+                cmp = pX->tVal->ComparedTo(pT);
+            }
+            return pX->tVal;
+        }
+        return NULL;
+    };
+};
+
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif
+
+#endif //ASMTEMPLATES_H
+
diff --git a/src/ilasm/assem.cpp b/src/ilasm/assem.cpp
new file mode 100644
index 0000000000..8f30613430
--- /dev/null
+++ b/src/ilasm/assem.cpp
@@ -0,0 +1,1613 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// File: assem.cpp
+//
+
+//
+// COM+ IL assembler
+//
+#include "ilasmpch.h"
+
+#define INITGUID
+
+#define DECLARE_DATA
+
+#include "assembler.h"
+#include "MscorpeSxS.h"
+
+void indexKeywords(Indx* indx); // defined in asmparse.y
+
+unsigned int g_uCodePage = CP_ACP;
+unsigned int g_uConsoleCP = CP_ACP;
+
+char g_szSourceFileName[MAX_FILENAME_LENGTH*3];
+
+WCHAR wzUniBuf[dwUniBuf];      // Unicode conversion global buffer
+
+Assembler::Assembler()
+{
+    m_pDisp = NULL;
+    m_pEmitter = NULL;
+    m_pImporter = NULL;
+
+    m_fCPlusPlus = FALSE;
+    m_fWindowsCE = FALSE;
+    char* pszFQN = new char[16];
+    strcpy_s(pszFQN,16,"<Module>");
+    m_pModuleClass = new Class(pszFQN);
+    m_lstClass.PUSH(m_pModuleClass);
+    m_hshClass.PUSH(m_pModuleClass);
+    m_pModuleClass->m_cl = mdTokenNil;
+    m_pModuleClass->m_bIsMaster = FALSE;
+
+    m_fStdMapping   = FALSE;
+    m_fDisplayTraceOutput= FALSE;
+    m_fENCMode = FALSE;
+    m_fTolerateDupMethods = FALSE;
+
+    m_pCurOutputPos = NULL;
+
+    m_CurPC             = 0;    // PC offset in method
+    m_pCurMethod        = NULL;
+    m_pCurClass         = NULL;
+    m_pCurEvent         = NULL;
+    m_pCurProp          = NULL;
+
+    m_wzMetadataVersion = NULL;
+    m_wMSVmajor = 0xFFFF;
+    m_wMSVminor = 0xFFFF;
+
+    m_wSSVersionMajor = 4;
+    m_wSSVersionMinor = 0;
+    m_fAppContainer = FALSE;
+    m_fHighEntropyVA = FALSE;
+
+    m_pCeeFileGen            = NULL;
+    m_pCeeFile               = 0;
+
+    m_pManifest         = NULL;
+
+    m_pCustomDescrList  = NULL;
+
+    m_pGlobalDataSection = NULL;
+    m_pILSection = NULL;
+    m_pTLSSection = NULL;
+
+    m_fDidCoInitialise = FALSE;
+
+    m_fDLL = FALSE;
+    m_fEntryPointPresent = FALSE;
+    m_fHaveFieldsWithRvas = FALSE;
+    m_fFoldCode = FALSE;
+    m_dwMethodsFolded = 0;
+
+    m_szScopeName[0] = 0;
+    m_crExtends = mdTypeDefNil;
+
+    m_nImplList = 0;
+    m_TyParList = NULL;
+
+    m_SEHD = NULL;
+    m_firstArgName = NULL;
+    m_lastArgName = NULL;
+    m_szNamespace = new char[2];
+    m_szNamespace[0] = 0;
+    m_NSstack.PUSH(m_szNamespace);
+
+    m_szFullNS = new char[MAX_NAMESPACE_LENGTH];
+    memset(m_szFullNS,0,MAX_NAMESPACE_LENGTH);
+    m_ulFullNSLen = MAX_NAMESPACE_LENGTH;
+
+    m_State             = STATE_OK;
+    m_fInitialisedMetaData = FALSE;
+    m_fAutoInheritFromObject = TRUE;
+
+    m_ulLastDebugLine = 0xFFFFFFFF;
+    m_ulLastDebugColumn = 0xFFFFFFFF;
+    m_ulLastDebugLineEnd = 0xFFFFFFFF;
+    m_ulLastDebugColumnEnd = 0xFFFFFFFF;
+    m_pSymWriter = NULL;
+    m_pSymDocument = NULL;
+    m_dwIncludeDebugInfo = 0;
+    m_fGeneratePDB = FALSE;
+    m_fIsMscorlib = FALSE;
+    m_fOptimize = FALSE;
+    m_tkSysObject = 0;
+    m_tkSysString = 0;
+    m_tkSysValue = 0;
+    m_tkSysEnum = 0;
+
+    m_pVTable = NULL;
+    m_pMarshal = NULL;
+    m_pPInvoke = NULL;
+
+    m_fReportProgress = TRUE;
+    m_tkCurrentCVOwner = 1; // module
+    m_pOutputBuffer = NULL;
+
+    m_dwSubsystem = (DWORD)-1;
+    m_dwComImageFlags = COMIMAGE_FLAGS_ILONLY;
+    m_dwFileAlignment = 0;
+    m_stBaseAddress = 0;
+    m_stSizeOfStackReserve = 0;
+    m_dwCeeFileFlags = ICEE_CREATE_FILE_PURE_IL;
+
+    g_szSourceFileName[0] = 0;
+
+    m_guidLang = CorSym_LanguageType_ILAssembly;
+    m_guidLangVendor = CorSym_LanguageVendor_Microsoft;
+    m_guidDoc = CorSym_DocumentType_Text;
+    for(int i=0; i<INSTR_POOL_SIZE; i++) m_Instr[i].opcode = -1;
+    m_wzResourceFile = NULL;
+    m_wzKeySourceName = NULL;
+    OnErrGo = false;
+    bClock = NULL;
+
+    m_pbsMD = NULL;
+
+    m_pOutputBuffer = new BYTE[OUTPUT_BUFFER_SIZE];
+
+    m_pCurOutputPos = m_pOutputBuffer;
+    m_pEndOutputPos = m_pOutputBuffer + OUTPUT_BUFFER_SIZE;
+
+    m_crImplList = new mdTypeRef[MAX_INTERFACES_IMPLEMENTED];
+    m_nImplListSize = MAX_INTERFACES_IMPLEMENTED;
+
+    m_pManifest = new AsmMan((void*)this);
+
+    dummyClass = new Class(NULL);
+    indexKeywords(&indxKeywords);
+}
+
+
+Assembler::~Assembler()
+{
+    if(m_pbsMD) delete m_pbsMD;
+
+    if(m_pMarshal) delete m_pMarshal;
+    if(m_pManifest) delete m_pManifest;
+    if(m_pPInvoke) delete m_pPInvoke;
+
+    if(m_pVTable) delete m_pVTable;
+
+    m_lstGlobalLabel.RESET(true);
+    m_lstGlobalFixup.RESET(true);
+    m_hshClass.RESET(false);
+    m_lstClass.RESET(true);
+    while((m_ClassStack.POP()));
+    while(m_CustomDescrListStack.POP());
+    m_pCurClass = NULL;
+    dummyClass->m_szFQN = NULL;
+    delete dummyClass;
+
+    if (m_pOutputBuffer)    delete [] m_pOutputBuffer;
+    if (m_crImplList)       delete [] m_crImplList;
+    if (m_TyParList)        delete m_TyParList;
+
+    if (m_pCeeFileGen != NULL) {
+        if (m_pCeeFile)
+            m_pCeeFileGen->DestroyCeeFile(&m_pCeeFile);
+        MscorpeSxS::DestroyICeeFileGen(&m_pCeeFileGen);
+        m_pCeeFileGen = NULL;
+    }
+
+    while((m_szNamespace = m_NSstack.POP())) ;
+    delete [] m_szFullNS;
+
+    m_DocWriterList.RESET(true);
+
+    m_MethodBodyList.RESET(true);
+    
+    m_TypeDefDList.RESET(true);
+
+    if (m_pSymWriter != NULL)
+    {
+        m_pSymWriter->Close();
+        m_pSymWriter->Release();
+        m_pSymWriter = NULL;
+    }
+    if (m_pImporter != NULL)
+    {
+        m_pImporter->Release();
+        m_pImporter = NULL;
+    }
+    if (m_pEmitter != NULL)
+    {
+        m_pEmitter->Release();
+        m_pEmitter = NULL;
+    }
+
+    if (m_pDisp != NULL)
+    {
+        m_pDisp->Release();
+        m_pDisp = NULL;
+    }
+
+    if (m_fDidCoInitialise)
+        CoUninitialize();
+
+}
+
+
+BOOL Assembler::Init()
+{
+    if(!m_fDidCoInitialise)
+    {
+        if (FAILED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
+            return FALSE;
+        m_fDidCoInitialise = TRUE;
+    }
+    if (m_pCeeFileGen != NULL) {
+        if (m_pCeeFile)
+            m_pCeeFileGen->DestroyCeeFile(&m_pCeeFile);
+        MscorpeSxS::DestroyICeeFileGen(&m_pCeeFileGen);
+        m_pCeeFileGen = NULL;
+    }
+    if (FAILED(MscorpeSxS::CreateICeeFileGen(&m_pCeeFileGen))) return FALSE;
+    if (FAILED(m_pCeeFileGen->CreateCeeFileEx(&m_pCeeFile,(ULONG)m_dwCeeFileFlags))) return FALSE;
+
+    if (FAILED(m_pCeeFileGen->GetSectionCreate(m_pCeeFile, ".il", sdReadOnly, &m_pILSection))) return FALSE;
+    if (FAILED(m_pCeeFileGen->GetSectionCreate (m_pCeeFile, ".sdata", sdReadWrite, &m_pGlobalDataSection))) return FALSE;
+    if (FAILED(m_pCeeFileGen->GetSectionCreate (m_pCeeFile, ".tls", sdReadWrite, &m_pTLSSection))) return FALSE;
+
+    return TRUE;
+}
+
+void Assembler::SetDLL(BOOL IsDll)
+{
+    HRESULT OK;
+    OK = m_pCeeFileGen->SetDllSwitch(m_pCeeFile, IsDll);
+    _ASSERTE(SUCCEEDED(OK));
+
+    m_fDLL = IsDll;
+}
+
+void Assembler::SetOBJ(BOOL IsObj)
+{
+    HRESULT OK;
+    OK = m_pCeeFileGen->SetObjSwitch(m_pCeeFile, IsObj);
+    _ASSERTE(SUCCEEDED(OK));
+
+    m_fOBJ = IsObj;
+}
+
+
+void Assembler::ResetArgNameList()
+{
+    if(m_firstArgName) delArgNameList(m_firstArgName);
+    m_firstArgName = NULL;
+    m_lastArgName = NULL;
+}
+
+void Assembler::ResetForNextMethod()
+{
+
+    ResetArgNameList();
+
+    m_CurPC         = 0;
+    m_pCurOutputPos = m_pOutputBuffer;
+    m_State         = STATE_OK;
+    m_pCurMethod = NULL;
+}
+
+void Assembler::ResetLineNumbers()
+{
+    // reset line number information
+    m_ulLastDebugLine = 0xFFFFFFFF;
+    m_ulLastDebugColumn = 0xFFFFFFFF;
+    m_ulLastDebugLineEnd = 0xFFFFFFFF;
+    m_ulLastDebugColumnEnd = 0xFFFFFFFF;
+}
+
+BOOL Assembler::AddMethod(Method *pMethod)
+{
+    BOOL                     fIsInterface=FALSE, fIsImport=FALSE;
+    ULONG                    PEFileOffset=0;
+
+    _ASSERTE(m_pCeeFileGen != NULL);
+    if (pMethod == NULL)
+    {
+        report->error("pMethod == NULL");
+        return FALSE;
+    }
+    if(pMethod->m_pClass != NULL)
+    {
+        fIsInterface = IsTdInterface(pMethod->m_pClass->m_Attr);
+        fIsImport = IsTdImport(pMethod->m_pClass->m_Attr);
+    }
+    if(m_CurPC)
+    {
+        char sz[1024];
+        sz[0] = 0;
+        if(fIsInterface  && (!IsMdStatic(pMethod->m_Attr))) strcat_s(sz,1024," non-static declared in interface");
+        if(fIsImport) strcat_s(sz,1024," imported");
+        if(IsMdAbstract(pMethod->m_Attr)) strcat_s(sz,1024," abstract");
+        if(IsMdPinvokeImpl(pMethod->m_Attr)) strcat_s(sz,1024," pinvoke");
+        if(!IsMiIL(pMethod->m_wImplAttr)) strcat_s(sz,1024," non-IL");
+        if(IsMiRuntime(pMethod->m_wImplAttr)) strcat_s(sz,1024," runtime-supplied");
+        if(IsMiInternalCall(pMethod->m_wImplAttr)) strcat_s(sz,1024," an internal call");
+        if(strlen(sz))
+        {
+            report->error("Method cannot have body if it is%s\n",sz);
+        }
+    }
+    else // method has no body
+    {
+        if(fIsImport || IsMdAbstract(pMethod->m_Attr) || IsMdPinvokeImpl(pMethod->m_Attr)
+           || IsMiRuntime(pMethod->m_wImplAttr) || IsMiInternalCall(pMethod->m_wImplAttr)) return TRUE;
+        if(OnErrGo)
+        {
+            report->error("Method has no body\n");
+            return TRUE;
+        }
+        else
+        {
+            report->warn("Method has no body, 'ret' emitted\n");
+            Instr* pIns = GetInstr();
+            if(pIns)
+            {
+                memset(pIns,0,sizeof(Instr));
+                pIns->opcode = CEE_RET;
+                EmitOpcode(pIns);
+            }
+        }
+    }
+
+    if(pMethod->m_Locals.COUNT()) pMethod->m_LocalsSig=0x11000001; // placeholder, the real token 2b defined in EmitMethod
+
+    COR_ILMETHOD_FAT fatHeader;
+    fatHeader.SetFlags(pMethod->m_Flags);
+    fatHeader.SetMaxStack(pMethod->m_MaxStack);
+    fatHeader.SetLocalVarSigTok(pMethod->m_LocalsSig);
+    fatHeader.SetCodeSize(m_CurPC);
+    bool moreSections = (pMethod->m_dwNumExceptions != 0);
+
+    // if max stack is specified <8, force fat header, otherwise (with tiny header) it will default to 8
+    if((fatHeader.GetMaxStack() < 8)&&(fatHeader.GetLocalVarSigTok()==0)&&(fatHeader.GetCodeSize()<64)&&(!moreSections))
+        fatHeader.SetFlags(fatHeader.GetFlags() | CorILMethod_InitLocals); //forces fat header but does nothing else, since LocalVarSigTok==0
+
+    unsigned codeSize = m_CurPC;
+    unsigned codeSizeAligned = codeSize;
+    if (moreSections)
+        codeSizeAligned = (codeSizeAligned + 3) & ~3;    // to insure EH section aligned
+
+    unsigned headerSize = COR_ILMETHOD::Size(&fatHeader, moreSections);
+    unsigned ehSize     = COR_ILMETHOD_SECT_EH::Size(pMethod->m_dwNumExceptions, pMethod->m_ExceptionList);
+    unsigned totalSize  = headerSize + codeSizeAligned + ehSize;
+
+    BYTE* outBuff;
+    BYTE* endbuf;
+    BinStr* pbsBody;
+    if((pbsBody = new BinStr())==NULL) return FALSE;
+    if((outBuff = pbsBody->getBuff(totalSize))==NULL) return FALSE;
+    endbuf = &outBuff[totalSize];
+
+    // Emit the header
+    outBuff += COR_ILMETHOD::Emit(headerSize, &fatHeader, moreSections, outBuff);
+
+    pMethod->m_pCode = outBuff;
+    pMethod->m_headerOffset= PEFileOffset;
+    pMethod->m_methodOffset= PEFileOffset + headerSize;
+    pMethod->m_CodeSize = codeSize;
+
+    // Emit the code
+    if (codeSizeAligned)
+    {
+        memset(outBuff,0,codeSizeAligned);
+        memcpy(outBuff, m_pOutputBuffer, codeSize);
+        outBuff += codeSizeAligned;
+    }
+
+    if(pMethod->m_dwNumExceptions)
+    {
+        // Validate the eh
+        COR_ILMETHOD_SECT_EH_CLAUSE_FAT* pEx;
+        DWORD   TryEnd,HandlerEnd, dwEx, dwEf;
+        for(dwEx = 0, pEx = pMethod->m_ExceptionList; dwEx < pMethod->m_dwNumExceptions; dwEx++, pEx++)
+        {
+            if(pEx->GetTryOffset() > m_CurPC) // i.e., pMethod->m_CodeSize
+            {
+                report->error("Invalid SEH clause #%d: Try block starts beyond code size\n",dwEx+1);
+            }
+            TryEnd = pEx->GetTryOffset()+pEx->GetTryLength();
+            if(TryEnd > m_CurPC)
+            {
+                report->error("Invalid SEH clause #%d: Try block ends beyond code size\n",dwEx+1);
+            }
+            if(pEx->GetHandlerOffset() > m_CurPC)
+            {
+                report->error("Invalid SEH clause #%d: Handler block starts beyond code size\n",dwEx+1);
+            }
+            HandlerEnd = pEx->GetHandlerOffset()+pEx->GetHandlerLength();
+            if(HandlerEnd > m_CurPC)
+            {
+                report->error("Invalid SEH clause #%d: Handler block ends beyond code size\n",dwEx+1);
+            }
+            if(pEx->Flags & COR_ILEXCEPTION_CLAUSE_FILTER)
+            {
+                if(!((pEx->GetFilterOffset() >= TryEnd)||(pEx->GetTryOffset() >= HandlerEnd)))
+                {
+                    report->error("Invalid SEH clause #%d: Try and Filter/Handler blocks overlap\n",dwEx+1);
+                }
+                for(dwEf = 0; dwEf < pMethod->m_dwNumEndfilters; dwEf++)
+                {
+                    if(pMethod->m_EndfilterOffsetList[dwEf] == pEx->GetHandlerOffset()) break;
+                }
+                if(dwEf >= pMethod->m_dwNumEndfilters)
+                {
+                    report->error("Invalid SEH clause #%d: Filter block separated from Handler, or not ending with endfilter\n",dwEx+1);
+                }
+            }
+            else
+            if(!((pEx->GetHandlerOffset() >= TryEnd)||(pEx->GetTryOffset() >= HandlerEnd)))
+            {
+                report->error("Invalid SEH clause #%d: Try and Handler blocks overlap\n",dwEx+1);
+            }
+
+        }
+        // Emit the eh
+        outBuff += COR_ILMETHOD_SECT_EH::Emit(ehSize, pMethod->m_dwNumExceptions,
+                                    pMethod->m_ExceptionList, false, outBuff);
+    }
+    _ASSERTE(outBuff == endbuf);
+
+    pMethod->m_pbsBody = pbsBody;
+
+    LocalMemberRefFixup*             pMRF;
+    while((pMRF = pMethod->m_LocalMemberRefFixupList.POP()))
+    {
+        pMRF->offset += (size_t)(pMethod->m_pCode);
+        m_LocalMemberRefFixupList.PUSH(pMRF); // transfer MRF to assembler's list
+    }
+
+    if(m_fReportProgress)
+    {
+        if (pMethod->IsGlobalMethod())
+            report->msg("Assembled global method %s\n", pMethod->m_szName);
+        else report->msg("Assembled method %s::%s\n", pMethod->m_pClass->m_szFQN,
+                  pMethod->m_szName);
+    }
+    return TRUE;
+}
+
+
+BOOL Assembler::EmitMethodBody(Method* pMethod, BinStr* pbsOut)
+{
+    if(pMethod)
+    {
+        BinStr* pbsBody = pMethod->m_pbsBody;
+        unsigned totalSize;
+        if(pbsBody && (totalSize = pbsBody->length()))
+        {
+            unsigned headerSize = pMethod->m_methodOffset-pMethod->m_headerOffset;
+            MethodBody* pMB = NULL;
+            // ----------emit locals signature-------------------
+            unsigned uLocals;
+            if((uLocals = pMethod->m_Locals.COUNT()))
+            {
+                VarDescr* pVD;
+                BinStr*   pbsSig = new BinStr();
+                unsigned cnt;
+                HRESULT hr;
+                DWORD   cSig;
+                const COR_SIGNATURE* mySig;
+
+                pbsSig->appendInt8(IMAGE_CEE_CS_CALLCONV_LOCAL_SIG);
+                cnt = CorSigCompressData(uLocals,pbsSig->getBuff(5));
+                pbsSig->remove(5-cnt);
+                for(cnt = 0; (pVD = pMethod->m_Locals.PEEK(cnt)); cnt++)
+                {
+                    if(pVD->pbsSig) pbsSig->append(pVD->pbsSig);
+                    else
+                    {
+                        report->error("Undefined type of local var slot %d in method %s\n",cnt,pMethod->m_szName);
+                        pbsSig->appendInt8(ELEMENT_TYPE_I4);
+                    }
+                }
+
+                cSig = pbsSig->length();
+                mySig = (const COR_SIGNATURE *)(pbsSig->ptr());
+
+                if (cSig > 1)    // non-empty signature
+                {
+                    hr = m_pEmitter->GetTokenFromSig(mySig, cSig, &pMethod->m_LocalsSig);
+                    _ASSERTE(SUCCEEDED(hr));
+                }
+                delete pbsSig;
+                COR_ILMETHOD_FAT* pFH; // Fat header guaranteed, because there are local vars
+                pFH = (COR_ILMETHOD_FAT*)(pMethod->m_pbsBody->ptr());
+                pFH->SetLocalVarSigTok(pMethod->m_LocalsSig);
+            }
+            //--------------------------------------------------------------------------------
+            if(m_fGeneratePDB && (m_pSymWriter != NULL))
+            {
+                m_pSymWriter->OpenMethod(pMethod->m_Tok);
+                ULONG N = pMethod->m_LinePCList.COUNT();
+                if(pMethod->m_fEntryPoint) m_pSymWriter->SetUserEntryPoint(pMethod->m_Tok);
+                if(N)
+                {
+                    LinePC  *pLPC;
+                    ULONG32  *offsets=new ULONG32[N], *lines = new ULONG32[N], *columns = new ULONG32[N];
+                    ULONG32  *endlines=new ULONG32[N], *endcolumns=new ULONG32[N];
+                    if(offsets && lines && columns && endlines && endcolumns)
+                    {
+                        DocWriter* pDW;
+                        unsigned j=0;
+                        while((pDW = m_DocWriterList.PEEK(j++)))
+                        {
+                            if((m_pSymDocument = pDW->pWriter))
+                            {
+                                int i, n;
+                                for(i=0, n=0; (pLPC = pMethod->m_LinePCList.PEEK(i)); i++)
+                                {
+                                    if(pLPC->pWriter == m_pSymDocument)
+                                    {
+                                        offsets[n] = pLPC->PC;
+                                        lines[n] = pLPC->Line;
+                                        columns[n] = pLPC->Column;
+                                        endlines[n] = pLPC->LineEnd;
+                                        endcolumns[n] = pLPC->ColumnEnd;
+                                        n++;
+                                    }
+                                }
+                                if(n) m_pSymWriter->DefineSequencePoints(m_pSymDocument,n,
+                                                                   offsets,lines,columns,endlines,endcolumns);
+                            } // end if(pSymDocument)
+                        } // end while(pDW = next doc.writer)
+                        pMethod->m_LinePCList.RESET(true);
+                    }
+                    else report->error("\nOutOfMemory!\n");
+                    delete [] offsets;
+                    delete [] lines;
+                    delete [] columns;
+                    delete [] endlines;
+                    delete [] endcolumns;
+                }//enf if(N)
+                HRESULT hrr;
+                if(pMethod->m_ulLines[1])
+                    hrr = m_pSymWriter->SetMethodSourceRange(m_pSymDocument,pMethod->m_ulLines[0], pMethod->m_ulColumns[0],
+                                                       m_pSymDocument,pMethod->m_ulLines[1], pMethod->m_ulColumns[1]);
+                EmitScope(&(pMethod->m_MainScope)); // recursively emits all nested scopes
+
+                m_pSymWriter->CloseMethod();
+            } // end if(fIncludeDebugInfo)
+            //-----------------------------------------------------
+
+            if(m_fFoldCode)
+            {
+                for(int k=0; (pMB = m_MethodBodyList.PEEK(k)) != NULL; k++)
+                {
+                    if((pMB->pbsBody->length() == totalSize)
+                      && (memcmp(pMB->pbsBody->ptr(), pbsBody->ptr(),totalSize)==0))
+                    break;
+                }
+                if(pMB)
+                {
+                    pMethod->m_headerOffset= pMB->RVA;
+                    pMethod->m_methodOffset= pMB->RVA + headerSize;
+                    pMethod->m_pCode = pMB->pCode;
+                    delete pbsBody;
+                    pMethod->m_pbsBody = NULL;
+                    m_dwMethodsFolded++;
+                }
+            }
+            if(pMB == NULL)
+            {
+                BYTE* outBuff;
+                unsigned align = (headerSize == 1)? 1 : 4;
+                ULONG    PEFileOffset, methodRVA;
+                if(m_fENCMode)
+                {
+                    if(pbsOut)
+                    {
+                        PEFileOffset = pbsOut->length();
+                        align--;
+                        while(PEFileOffset & align)
+                        {
+                            pbsOut->appendInt8(0);
+                            PEFileOffset++;
+                        }
+                        pbsOut->append(pbsBody);
+                        outBuff = (BYTE*)(pbsOut->ptr()) + (pbsOut->length() - pbsBody->length());
+                    }
+                    else return FALSE;
+
+                }
+                else
+                {
+                    if (FAILED(m_pCeeFileGen->GetSectionBlock (m_pILSection, totalSize,
+                            align, (void **) &outBuff)))    return FALSE;
+                    memcpy(outBuff,pbsBody->ptr(),totalSize);
+                    // The offset where we start, (not where the alignment bytes start!
+                    if (FAILED(m_pCeeFileGen->GetSectionDataLen (m_pILSection, &PEFileOffset)))
+                        return FALSE;
+                    PEFileOffset -= totalSize;
+                }
+
+                pMethod->m_pCode = outBuff + headerSize;
+                pMethod->m_headerOffset= PEFileOffset;
+                pMethod->m_methodOffset= PEFileOffset + headerSize;
+                DoDeferredILFixups(pMethod);
+
+                if(m_fENCMode) methodRVA = PEFileOffset;
+                else m_pCeeFileGen->GetMethodRVA(m_pCeeFile, PEFileOffset,&methodRVA);
+
+                pMethod->m_headerOffset= methodRVA;
+                pMethod->m_methodOffset= methodRVA + headerSize;
+                if(m_fFoldCode)
+                {
+                    if((pMB = new MethodBody)==NULL) return FALSE;
+                    pMB->pbsBody = pbsBody;
+                    pMB->RVA = methodRVA;
+                    pMB->pCode = pMethod->m_pCode;
+                    m_MethodBodyList.PUSH(pMB);
+                }
+                //else
+                //    delete pbsBody;
+                //pMethod->m_pbsBody = NULL;
+            }
+            m_pEmitter->SetRVA(pMethod->m_Tok,pMethod->m_headerOffset);
+        }
+        return TRUE;
+    }
+    else return FALSE;
+}
+
+ImportDescriptor* Assembler::EmitImport(BinStr* DllName)
+{
+    int i = 0, l = 0;
+    ImportDescriptor*   pID;
+    char* sz=NULL;
+
+    if(DllName) l = DllName->length();  // No zero terminator here!
+    if(l)
+    {
+        sz = (char*)DllName->ptr();
+        while((pID=m_ImportList.PEEK(i++)))
+        {
+            if((pID->dwDllName== (DWORD) l)&& !memcmp(pID->szDllName,sz,l)) return pID;
+        }
+    }
+    else
+    {
+        while((pID=m_ImportList.PEEK(i++)))
+        {
+            if(pID->dwDllName==0) return pID;
+        }
+    }
+    if((pID = new ImportDescriptor(sz,l)))
+    {
+        m_ImportList.PUSH(pID);
+        pID->mrDll = TokenFromRid(m_ImportList.COUNT(),mdtModuleRef);
+        return pID;
+    }
+    else report->error("Failed to allocate import descriptor\n");
+    return NULL;
+}
+
+void Assembler::EmitImports()
+{
+    WCHAR*               wzDllName=&wzUniBuf[0];
+    ImportDescriptor*   pID;
+    int i;
+    mdToken tk;
+    for(i=0; (pID = m_ImportList.PEEK(i)); i++)
+    {
+        WszMultiByteToWideChar(g_uCodePage,0,pID->szDllName,-1,wzDllName,dwUniBuf-1);
+        if(FAILED(m_pEmitter->DefineModuleRef(             // S_OK or error.
+                            wzDllName,            // [IN] DLL name
+                            &tk)))      // [OUT] returned
+            report->error("Failed to define module ref '%s'\n",pID->szDllName);
+        else
+            _ASSERTE(tk == pID->mrDll);
+    }
+}
+
+HRESULT Assembler::EmitPinvokeMap(mdToken tk, PInvokeDescriptor* pDescr)
+{
+    WCHAR*               wzAlias=&wzUniBuf[0];
+
+    if(pDescr->szAlias) WszMultiByteToWideChar(g_uCodePage,0,pDescr->szAlias,-1,wzAlias,dwUniBuf-1);
+
+    return m_pEmitter->DefinePinvokeMap(        // Return code.
+                        tk,                     // [IN] FieldDef, MethodDef or MethodImpl.
+                        pDescr->dwAttrs,        // [IN] Flags used for mapping.
+                        (LPCWSTR)wzAlias,       // [IN] Import name.
+                        pDescr->mrDll);         // [IN] ModuleRef token for the target DLL.
+}
+
+void Assembler::EmitScope(Scope* pSCroot)
+{
+    static ULONG32          scopeID;
+    static ARG_NAME_LIST    *pVarList;
+    int                     i;
+    WCHAR*                  wzVarName=&wzUniBuf[0];
+    char*                   szPhonyName=(char*)&wzUniBuf[dwUniBuf >> 1];
+    Scope*                  pSC = pSCroot;
+    if(pSC && m_pSymWriter)
+    {
+        if(SUCCEEDED(m_pSymWriter->OpenScope(pSC->dwStart,&scopeID)))
+        {
+            if(pSC->pLocals)
+            {
+                for(pVarList = pSC->pLocals; pVarList; pVarList = pVarList->pNext)
+                {
+                    if(pVarList->pSig)
+                    {
+                        if((pVarList->szName)&&(*(pVarList->szName))) strcpy_s(szPhonyName,dwUniBuf >> 1,pVarList->szName);
+                        else sprintf_s(szPhonyName,(dwUniBuf >> 1),"V_%d",pVarList->dwAttr);
+
+                        WszMultiByteToWideChar(g_uCodePage,0,szPhonyName,-1,wzVarName,dwUniBuf >> 1);
+
+                        m_pSymWriter->DefineLocalVariable(wzVarName,0,pVarList->pSig->length(),
+                            (BYTE*)pVarList->pSig->ptr(),ADDR_IL_OFFSET,pVarList->dwAttr,0,0,0,0);
+                    }
+                    else
+                    {
+                        report->error("Local Var '%s' has no signature\n",pVarList->szName);
+                    }
+                }
+            }
+            for(i = 0; (pSC = pSCroot->SubScope.PEEK(i)); i++) EmitScope(pSC);
+            m_pSymWriter->CloseScope(pSCroot->dwEnd);
+        }
+    }
+}
+
+BOOL Assembler::EmitMethod(Method *pMethod)
+{
+// Emit the metadata for a method definition
+    BOOL                fSuccess = FALSE;
+    WCHAR*              wzMemberName=&wzUniBuf[0];
+    BOOL                fIsInterface;
+    DWORD               cSig;
+    ULONG               methodRVA = 0;
+    mdMethodDef         MethodToken;
+    mdTypeDef           ClassToken = mdTypeDefNil;
+    char                *pszMethodName;
+    COR_SIGNATURE       *mySig;
+
+    _ASSERTE((m_pCeeFileGen != NULL) && (pMethod != NULL));
+    fIsInterface = ((pMethod->m_pClass != NULL) && IsTdInterface(pMethod->m_pClass->m_Attr));
+
+
+    pszMethodName = pMethod->m_szName;
+    mySig = pMethod->m_pMethodSig;
+    cSig = pMethod->m_dwMethodCSig;
+
+    // If  this is an instance method, make certain the signature says so
+
+    if (!(pMethod->m_Attr & mdStatic))
+        *mySig |= IMAGE_CEE_CS_CALLCONV_HASTHIS;
+
+    ClassToken = (pMethod->IsGlobalMethod())? mdTokenNil
+                                    : pMethod->m_pClass->m_cl;
+    // Convert name to UNICODE
+    WszMultiByteToWideChar(g_uCodePage,0,pszMethodName,-1,wzMemberName,dwUniBuf-1);
+
+    if(IsMdPrivateScope(pMethod->m_Attr))
+    {
+        WCHAR* p = wcsstr(wzMemberName,L"$PST06");
+        if(p) *p = 0;
+    }
+
+    if (FAILED(m_pEmitter->DefineMethod(ClassToken,       // parent class
+                                      wzMemberName,     // member name
+                                      pMethod->m_Attr & ~mdReservedMask,  // member attributes
+                                      mySig, // member signature
+                                      cSig,
+                                      methodRVA,                // RVA
+                                      pMethod->m_wImplAttr,                // implflags
+                                      &MethodToken)))
+    {
+        report->error("Failed to define method '%s'\n",pszMethodName);
+        goto exit;
+    }
+    pMethod->m_Tok = MethodToken;
+    //--------------------------------------------------------------------------------
+    // the only way to set mdRequireSecObject:
+    if(pMethod->m_Attr & mdRequireSecObject)
+    {
+        mdToken tkPseudoClass;
+        if(FAILED(m_pEmitter->DefineTypeRefByName(1, COR_REQUIRES_SECOBJ_ATTRIBUTE, &tkPseudoClass)))
+            report->error("Unable to define type reference '%s'\n", COR_REQUIRES_SECOBJ_ATTRIBUTE_ANSI);
+        else
+        {
+            mdToken tkPseudoCtor;
+            BYTE bSig[3] = {IMAGE_CEE_CS_CALLCONV_HASTHIS,0,ELEMENT_TYPE_VOID};
+            if(FAILED(m_pEmitter->DefineMemberRef(tkPseudoClass, L".ctor", (PCCOR_SIGNATURE)bSig, 3, &tkPseudoCtor)))
+                report->error("Unable to define member reference '%s::.ctor'\n", COR_REQUIRES_SECOBJ_ATTRIBUTE_ANSI);
+            else DefineCV(new CustomDescr(MethodToken,tkPseudoCtor,NULL));
+        }
+    }
+
+    if (pMethod->m_NumTyPars)
+    {
+        ULONG i;
+        mdToken* ptk;
+        mdToken tk;
+        for(i = 0; i < pMethod->m_NumTyPars; i++)
+        {
+            //ptk = (pMethod->m_TyParBounds[i] == NULL)? NULL :  (mdToken*)(pMethod->m_TyParBounds[i]->ptr());
+            //if(FAILED(m_pEmitter->DefineGenericParam(MethodToken,i,0,pMethod->m_TyParNames[i],0,ptk,&tk)))
+            ptk = (pMethod->m_TyPars[i].Bounds() == NULL)? NULL :  (mdToken*)(pMethod->m_TyPars[i].Bounds()->ptr());
+            if(FAILED(m_pEmitter->DefineGenericParam(MethodToken,i,pMethod->m_TyPars[i].Attrs(),pMethod->m_TyPars[i].Name(),0,ptk,&tk)))
+                report->error("Unable to define generic param'\n");
+            else
+                EmitCustomAttributes(tk, pMethod->m_TyPars[i].CAList());
+        }
+    }
+    //--------------------------------------------------------------------------------
+    EmitSecurityInfo(MethodToken,
+                     pMethod->m_pPermissions,
+                     pMethod->m_pPermissionSets);
+    //--------------------------------------------------------------------------------
+    if (pMethod->m_fEntryPoint)
+    {
+        if(fIsInterface) report->error("Entrypoint in Interface: Method '%s'\n",pszMethodName);
+
+        if (FAILED(m_pCeeFileGen->SetEntryPoint(m_pCeeFile, MethodToken)))
+        {
+            report->error("Failed to set entry point for method '%s'\n",pszMethodName);
+            goto exit;
+        }
+
+    }
+    //--------------------------------------------------------------------------------
+    if(IsMdPinvokeImpl(pMethod->m_Attr))
+    {
+        if(pMethod->m_pPInvoke)
+        {
+            HRESULT hr;
+            if(pMethod->m_pPInvoke->szAlias == NULL) pMethod->m_pPInvoke->szAlias = pszMethodName;
+            hr = EmitPinvokeMap(MethodToken,pMethod->m_pPInvoke);
+            if(pMethod->m_pPInvoke->szAlias == pszMethodName) pMethod->m_pPInvoke->szAlias = NULL;
+
+            if(FAILED(hr))
+            {
+                report->error("Failed to set PInvoke map for method '%s'\n",pszMethodName);
+                goto exit;
+            }
+        }
+    }
+
+    { // add parameters to metadata
+        void const *pValue=NULL;
+        ULONG       cbValue;
+        DWORD dwCPlusTypeFlag=0;
+        mdParamDef pdef;
+        WCHAR* wzParName=&wzUniBuf[0];
+        char*  szPhonyName=(char*)&wzUniBuf[dwUniBuf >> 1];
+        if(pMethod->m_dwRetAttr || pMethod->m_pRetMarshal || pMethod->m_RetCustDList.COUNT())
+        {
+            if(pMethod->m_pRetValue)
+            {
+                dwCPlusTypeFlag= (DWORD)*(pMethod->m_pRetValue->ptr());
+                pValue = (void const *)(pMethod->m_pRetValue->ptr()+1);
+                cbValue = pMethod->m_pRetValue->length()-1;
+                if(dwCPlusTypeFlag == ELEMENT_TYPE_STRING) cbValue /= sizeof(WCHAR);
+            }
+            else
+            {
+                pValue = NULL;
+                cbValue = (ULONG)-1;
+                dwCPlusTypeFlag=0;
+            }
+            m_pEmitter->DefineParam(MethodToken,0,NULL,pMethod->m_dwRetAttr,dwCPlusTypeFlag,pValue,cbValue,&pdef);
+
+            if(pMethod->m_pRetMarshal)
+            {
+                if(FAILED(m_pEmitter->SetFieldMarshal (
+                                            pdef,                       // [IN] given a fieldDef or paramDef token
+                            (PCCOR_SIGNATURE)(pMethod->m_pRetMarshal->ptr()),   // [IN] native type specification
+                                            pMethod->m_pRetMarshal->length())))  // [IN] count of bytes of pvNativeType
+                    report->error("Failed to set param marshaling for return\n");
+
+            }
+            EmitCustomAttributes(pdef, &(pMethod->m_RetCustDList));
+        }
+        for(ARG_NAME_LIST *pAN=pMethod->m_firstArgName; pAN; pAN = pAN->pNext)
+        {
+            if(pAN->nNum >= 65535)
+            {
+                report->error("Method '%s': Param.sequence number (%d) exceeds 65535, unable to define parameter\n",pszMethodName,pAN->nNum+1);
+                continue;
+            }
+            if(pAN->dwName) strcpy_s(szPhonyName,dwUniBuf >> 1,pAN->szName);
+            else sprintf_s(szPhonyName,(dwUniBuf >> 1),"A_%d",pAN->nNum);
+
+            WszMultiByteToWideChar(g_uCodePage,0,szPhonyName,-1,wzParName,dwUniBuf >> 1);
+
+            if(pAN->pValue)
+            {
+                dwCPlusTypeFlag= (DWORD)*(pAN->pValue->ptr());
+                pValue = (void const *)(pAN->pValue->ptr()+1);
+                cbValue = pAN->pValue->length()-1;
+                if(dwCPlusTypeFlag == ELEMENT_TYPE_STRING) cbValue /= sizeof(WCHAR);
+            }
+            else
+            {
+                pValue = NULL;
+                cbValue = (ULONG)-1;
+                dwCPlusTypeFlag=0;
+            }
+            m_pEmitter->DefineParam(MethodToken,pAN->nNum+1,wzParName,pAN->dwAttr,dwCPlusTypeFlag,pValue,cbValue,&pdef);
+            if(pAN->pMarshal)
+            {
+                if(FAILED(m_pEmitter->SetFieldMarshal (
+                                            pdef,                       // [IN] given a fieldDef or paramDef token
+                            (PCCOR_SIGNATURE)(pAN->pMarshal->ptr()),   // [IN] native type specification
+                                            pAN->pMarshal->length())))  // [IN] count of bytes of pvNativeType
+                    report->error("Failed to set param marshaling for '%s'\n",pAN->szName);
+            }
+            EmitCustomAttributes(pdef, &(pAN->CustDList));
+        }
+    }
+    fSuccess = TRUE;
+    //--------------------------------------------------------------------------------
+    // Update method implementations for this method
+    {
+        MethodImplDescriptor*   pMID;
+        int i;
+        for(i=0;(pMID = pMethod->m_MethodImplDList.PEEK(i));i++)
+        {
+            pMID->m_tkImplementingMethod = MethodToken;
+            // don't delete it here, it's still in the general list
+        }
+    }
+    //--------------------------------------------------------------------------------
+    EmitCustomAttributes(MethodToken, &(pMethod->m_CustomDescrList));
+exit:
+    if (fSuccess == FALSE) m_State = STATE_FAIL;
+    return fSuccess;
+}
+
+BOOL Assembler::EmitMethodImpls()
+{
+    MethodImplDescriptor*   pMID;
+    BOOL ret = TRUE;
+    int i;
+    for(i=0; (pMID = m_MethodImplDList.PEEK(i)); i++)
+    {
+        if(m_fENCMode && (!pMID->m_fNew)) continue;
+        pMID->m_tkImplementingMethod = ResolveLocalMemberRef(pMID->m_tkImplementingMethod);
+        pMID->m_tkImplementedMethod = ResolveLocalMemberRef(pMID->m_tkImplementedMethod);
+        if(FAILED(m_pEmitter->DefineMethodImpl( pMID->m_tkDefiningClass,
+                                                pMID->m_tkImplementingMethod,
+                                                pMID->m_tkImplementedMethod)))
+        {
+            report->error("Failed to define Method Implementation");
+            ret = FALSE;
+        }
+        pMID->m_fNew = FALSE;
+    }// end while
+    return ret;
+}
+
+mdToken Assembler::ResolveLocalMemberRef(mdToken tok)
+{
+    if(TypeFromToken(tok) == 0x99000000)
+    {
+        tok = RidFromToken(tok);
+        if(tok) tok = m_LocalMethodRefDList.PEEK(tok-1)->m_tkResolved;
+    }
+    else if(TypeFromToken(tok) == 0x98000000)
+    {
+        tok = RidFromToken(tok);
+        if(tok) tok = m_LocalFieldRefDList.PEEK(tok-1)->m_tkResolved;
+    }
+    return tok;
+}
+
+BOOL Assembler::EmitEvent(EventDescriptor* pED)
+{
+    mdMethodDef mdAddOn=mdMethodDefNil,
+                mdRemoveOn=mdMethodDefNil,
+                mdFire=mdMethodDefNil,
+                *mdOthers;
+    int                 nOthers;
+    WCHAR*              wzMemberName=&wzUniBuf[0];
+
+    if(!pED) return FALSE;
+
+    WszMultiByteToWideChar(g_uCodePage,0,pED->m_szName,-1,wzMemberName,dwUniBuf-1);
+
+    mdAddOn = ResolveLocalMemberRef(pED->m_tkAddOn);
+    if(TypeFromToken(mdAddOn) != mdtMethodDef)
+    {
+        report->error("Invalid Add method of event '%s'\n",pED->m_szName);
+        return FALSE;
+    }
+    mdRemoveOn = ResolveLocalMemberRef(pED->m_tkRemoveOn);
+    if(TypeFromToken(mdRemoveOn) != mdtMethodDef)
+    {
+        report->error("Invalid Remove method of event '%s'\n",pED->m_szName);
+        return FALSE;
+    }
+    mdFire = ResolveLocalMemberRef(pED->m_tkFire);
+    if((RidFromToken(mdFire)!=0)&&(TypeFromToken(mdFire) != mdtMethodDef))
+    {
+        report->error("Invalid Fire method of event '%s'\n",pED->m_szName);
+        return FALSE;
+    }
+
+    nOthers = pED->m_tklOthers.COUNT();
+    mdOthers = new mdMethodDef[nOthers+1];
+    if(mdOthers == NULL)
+    {
+        report->error("Failed to allocate Others array for event descriptor\n");
+        nOthers = 0;
+    }
+    for(int j=0; j < nOthers; j++)
+    {
+        mdOthers[j] = ResolveLocalMemberRef((mdToken)(UINT_PTR)(pED->m_tklOthers.PEEK(j)));     // @WARNING: casting down from 'mdToken*' to 'mdToken'
+    }
+    mdOthers[nOthers] = mdMethodDefNil; // like null-terminator
+
+    if(FAILED(m_pEmitter->DefineEvent(  pED->m_tdClass,
+                                        wzMemberName,
+                                        pED->m_dwAttr,
+                                        pED->m_tkEventType,
+                                        mdAddOn,
+                                        mdRemoveOn,
+                                        mdFire,
+                                        mdOthers,
+                                        &(pED->m_edEventTok))))
+    {
+        report->error("Failed to define event '%s'.\n",pED->m_szName);
+        delete [] mdOthers;
+        return FALSE;
+    }
+    EmitCustomAttributes(pED->m_edEventTok, &(pED->m_CustomDescrList));
+    return TRUE;
+}
+
+BOOL Assembler::EmitProp(PropDescriptor* pPD)
+{
+    mdMethodDef mdSet, mdGet, *mdOthers;
+    int nOthers;
+    WCHAR*              wzMemberName=&wzUniBuf[0];
+
+    if(!pPD) return FALSE;
+
+    WszMultiByteToWideChar(g_uCodePage,0,pPD->m_szName,-1,wzMemberName,dwUniBuf-1);
+
+    mdSet = ResolveLocalMemberRef(pPD->m_tkSet);
+    if((RidFromToken(mdSet)!=0)&&(TypeFromToken(mdSet) != mdtMethodDef))
+    {
+        report->error("Invalid Set method of property '%s'\n",pPD->m_szName);
+        return FALSE;
+    }
+    mdGet = ResolveLocalMemberRef(pPD->m_tkGet);
+    if((RidFromToken(mdGet)!=0)&&(TypeFromToken(mdGet) != mdtMethodDef))
+    {
+        report->error("Invalid Get method of property '%s'\n",pPD->m_szName);
+        return FALSE;
+    }
+
+    nOthers = pPD->m_tklOthers.COUNT();
+    mdOthers = new mdMethodDef[nOthers+1];
+    if(mdOthers == NULL)
+    {
+        report->error("Failed to allocate Others array for prop descriptor\n");
+        nOthers = 0;
+    }
+    for(int j=0; j < nOthers; j++)
+    {
+        mdOthers[j] = ResolveLocalMemberRef((mdToken)(UINT_PTR)(pPD->m_tklOthers.PEEK(j)));     // @WARNING: casting down from 'mdToken*' to 'mdToken'
+        
+        if((RidFromToken(mdOthers[j])!=0)&&(TypeFromToken(mdOthers[j]) != mdtMethodDef))
+        {
+            report->error("Invalid Other method of property '%s'\n",pPD->m_szName);
+            delete [] mdOthers;
+            return FALSE;
+        }
+        
+    }
+    mdOthers[nOthers] = mdMethodDefNil; // like null-terminator
+
+    if(FAILED(m_pEmitter->DefineProperty(   pPD->m_tdClass,
+                                            wzMemberName,
+                                            pPD->m_dwAttr,
+                                            pPD->m_pSig,
+                                            pPD->m_dwCSig,
+                                            pPD->m_dwCPlusTypeFlag,
+                                            pPD->m_pValue,
+                                            pPD->m_cbValue,
+                                            mdSet,
+                                            mdGet,
+                                            mdOthers,
+                                            &(pPD->m_pdPropTok))))
+    {
+        report->error("Failed to define property '%s'.\n",pPD->m_szName);
+        delete [] mdOthers;
+        return FALSE;
+    }
+    EmitCustomAttributes(pPD->m_pdPropTok, &(pPD->m_CustomDescrList));
+    return TRUE;
+}
+
+Class *Assembler::FindCreateClass(__in __nullterminated char *pszFQN)
+{
+    Class *pSearch = NULL;
+
+    if(pszFQN)
+    {
+        dummyClass->m_szFQN = pszFQN;
+        dummyClass->m_Hash = hash((BYTE*)pszFQN, (unsigned)strlen(pszFQN), 10);
+        pSearch = m_hshClass.FIND(dummyClass);
+        dummyClass->m_szFQN = NULL;
+        dummyClass->m_Hash = 0;
+
+        if(!pSearch)
+        {
+            char* pch;
+            DWORD dwFQN = (DWORD)strlen(pszFQN);
+
+            Class *pEncloser = NULL;
+            char* pszNewFQN = new char[dwFQN+1];
+            strcpy_s(pszNewFQN,dwFQN+1,pszFQN);
+            if((pch = strrchr(pszNewFQN, NESTING_SEP)) != NULL)
+            {
+                *pch = 0;
+                pEncloser = FindCreateClass(pszNewFQN);
+                *pch = NESTING_SEP;
+            }
+            pSearch = new Class(pszNewFQN);
+            if (pSearch == NULL)
+                report->error("Failed to create class '%s'\n",pszNewFQN);
+            else
+            {
+                pSearch->m_pEncloser = pEncloser;
+                m_lstClass.PUSH(pSearch);
+                pSearch->m_cl = mdtTypeDef | m_lstClass.COUNT();
+                m_hshClass.PUSH(pSearch);
+            }
+        }
+    }
+
+    return pSearch;
+}
+
+
+BOOL Assembler::EmitClass(Class *pClass)
+{
+    LPCUTF8              szFullName;
+    WCHAR*              wzFullName=&wzUniBuf[0];
+    HRESULT             hr = E_FAIL;
+    GUID                guid;
+    size_t              L;
+    mdToken             tok;
+
+    if(pClass == NULL) return FALSE;
+
+    hr = CoCreateGuid(&guid);
+    if (FAILED(hr))
+    {
+        printf("Unable to create GUID\n");
+        m_State = STATE_FAIL;
+        return FALSE;
+    }
+
+    if(pClass->m_pEncloser)
+        szFullName = strrchr(pClass->m_szFQN,NESTING_SEP) + 1;
+    else
+        szFullName = pClass->m_szFQN;
+
+    WszMultiByteToWideChar(g_uCodePage,0,szFullName,-1,wzFullName,dwUniBuf);
+
+    L = wcslen(wzFullName);
+    if((L==0)||(wzFullName[L-1]==L'.')) // Missing class name!
+    {
+        wcscat_s(wzFullName,dwUniBuf,L"$UNNAMED_TYPE$");
+    }
+
+    pClass->m_Attr = CheckClassFlagsIfNested(pClass->m_pEncloser, pClass->m_Attr);
+
+    if (pClass->m_pEncloser)
+    {
+        hr = m_pEmitter->DefineNestedType( wzFullName,
+                                        pClass->m_Attr,      // attributes
+                                        pClass->m_crExtends,  // CR extends class
+                                        pClass->m_crImplements,// implements
+                                        pClass->m_pEncloser->m_cl,  // Enclosing class.
+                                        &tok);
+    }
+    else
+    {
+        hr = m_pEmitter->DefineTypeDef( wzFullName,
+                                        pClass->m_Attr,      // attributes
+                                        pClass->m_crExtends,  // CR extends class
+                                        pClass->m_crImplements,// implements
+                                        &tok);
+    }
+    _ASSERTE(tok == pClass->m_cl);
+    if (FAILED(hr)) goto exit;
+    if (pClass->m_NumTyPars)
+    {
+        ULONG i;
+        mdToken* ptk;
+        mdToken tk;
+        for(i = 0; i < pClass->m_NumTyPars; i++)
+        {
+            //ptk = (pClass->m_TyParBounds[i] == NULL)? NULL :  (mdToken*)(pClass->m_TyParBounds[i]->ptr());
+            //if(FAILED(m_pEmitter->DefineGenericParam(pClass->m_cl,i,pClass->m_TyParAttrs[i],pClass->m_TyParNames[i],0,ptk,&tk)))
+            ptk = (pClass->m_TyPars[i].Bounds() == NULL)? NULL :  (mdToken*)(pClass->m_TyPars[i].Bounds()->ptr());
+            if(FAILED(m_pEmitter->DefineGenericParam(pClass->m_cl,i,pClass->m_TyPars[i].Attrs(),pClass->m_TyPars[i].Name(),0,ptk,&tk)))
+                report->error("Unable to define generic param'\n");
+            else
+                EmitCustomAttributes(tk, pClass->m_TyPars[i].CAList());
+        }
+    }
+    
+    
+    EmitCustomAttributes(pClass->m_cl, &(pClass->m_CustDList));
+    hr = S_OK;
+
+exit:
+    return SUCCEEDED(hr);
+}
+
+BOOL Assembler::DoGlobalFixups()
+{
+    GlobalFixup *pSearch;
+
+    for (int i=0; (pSearch = m_lstGlobalFixup.PEEK(i)); i++)
+    {
+        GlobalLabel *   pLabel = FindGlobalLabel(pSearch->m_szLabel);
+        if (pLabel == NULL)
+        {
+            report->error("Unable to find forward reference global label '%s'\n",
+                pSearch->m_szLabel);
+
+            m_State = STATE_FAIL;
+            return FALSE;
+        }
+        //BYTE * pReference = pSearch->m_pReference;
+        //DWORD  GlobalOffset = pLabel->m_GlobalOffset;
+        //memcpy(pReference,&GlobalOffset,4);
+        SET_UNALIGNED_VAL32(pSearch->m_pReference,pLabel->m_GlobalOffset);
+    }
+
+    return TRUE;
+}
+
+state_t Assembler::AddGlobalLabel(__in __nullterminated char *pszName, HCEESECTION section)
+{
+    if (FindGlobalLabel(pszName) != NULL)
+    {
+        report->error("Duplicate global label '%s'\n", pszName);
+        m_State = STATE_FAIL;
+        return m_State;
+    }
+
+    ULONG GlobalOffset;
+
+    HRESULT hr;
+    hr = m_pCeeFileGen->GetSectionDataLen(section, &GlobalOffset);
+    _ASSERTE(SUCCEEDED(hr));
+
+    GlobalLabel *pNew = new GlobalLabel(pszName, GlobalOffset, section);
+    if (pNew == 0)
+    {
+        report->error("Failed to allocate global label '%s'\n",pszName);
+        m_State = STATE_FAIL;
+        return m_State;
+    }
+
+    m_lstGlobalLabel.PUSH(pNew);
+    return m_State;
+}
+
+void Assembler::AddLabel(DWORD CurPC, __in __nullterminated char *pszName)
+{
+    if (m_pCurMethod->FindLabel(pszName) != NULL)
+    {
+        report->error("Duplicate label: '%s'\n", pszName);
+
+        m_State = STATE_FAIL;
+    }
+    else
+    {
+        Label *pNew = new Label(pszName, CurPC);
+
+        if (pNew != NULL)
+            //m_pCurMethod->m_lstLabel.PUSH(pNew);
+            m_lstLabel.PUSH(pNew);
+        else
+        {
+            report->error("Failed to allocate label '%s'\n",pszName);
+            m_State = STATE_FAIL;
+        }
+    }
+}
+
+void Assembler::DoDeferredILFixups(Method* pMethod)
+{ // Now that we know where in the file the code bytes will wind up,
+  // we can update the RVAs and offsets.
+    ILFixup *pSearch;
+    HRESULT hr;
+    GlobalFixup *Fix = NULL;
+    int i;
+    for (i=0;(pSearch = pMethod->m_lstILFixup.PEEK(i));i++)
+    {
+        switch(pSearch->m_Kind)
+        {
+            case ilGlobal:
+                Fix = pSearch->m_Fixup;
+                _ASSERTE(Fix != NULL);
+                Fix->m_pReference = pMethod->m_pCode+pSearch->m_OffsetInMethod;
+                break;
+
+            case ilToken:
+                hr = m_pCeeFileGen->AddSectionReloc(m_pILSection,
+                                    pSearch->m_OffsetInMethod+pMethod->m_methodOffset,
+                                    m_pILSection,
+                                    srRelocMapToken);
+                _ASSERTE(SUCCEEDED(hr));
+                break;
+
+            case ilRVA:
+                hr = m_pCeeFileGen->AddSectionReloc(m_pILSection,
+                                    pSearch->m_OffsetInMethod+pMethod->m_methodOffset,
+                                    m_pGlobalDataSection,
+                                    srRelocAbsolute);
+                _ASSERTE(SUCCEEDED(hr));
+                break;
+
+            default:
+                ;
+        }
+    }
+}
+/**************************************************************************/
+BOOL Assembler::DoFixups(Method* pMethod)
+{
+    Fixup *pSearch;
+
+    for (int i=0; (pSearch = pMethod->m_lstFixup.PEEK(i)); i++)
+    {
+        Label * pLabel = pMethod->FindLabel(pSearch->m_szLabel);
+        long    offset;
+
+        if (pLabel == NULL)
+        {
+            report->error("Unable to find forward reference label '%s' called from PC=%d\n",
+                pSearch->m_szLabel, pSearch->m_RelativeToPC);
+
+            //m_State = STATE_FAIL;
+            return FALSE;
+        }
+
+        offset = pLabel->m_PC - pSearch->m_RelativeToPC;
+
+        if (pSearch->m_FixupSize == 1)
+        {
+            if (offset > 127 || offset < -128)
+            {
+                report->error("Offset of forward reference label '%s' called from PC=%d is too large for 1 byte pcrel\n",
+                    pLabel->m_szName, pSearch->m_RelativeToPC);
+
+                //m_State = STATE_FAIL;
+                return FALSE;
+            }
+
+            *pSearch->m_pBytes = (BYTE) offset;
+        }
+        else if (pSearch->m_FixupSize == 4)
+        {
+            SET_UNALIGNED_VAL32(pSearch->m_pBytes,offset);
+        }
+    }
+
+    return TRUE;
+}
+
+
+OPCODE Assembler::DecodeOpcode(const BYTE *pCode, DWORD *pdwLen)
+{
+    OPCODE opcode;
+
+    *pdwLen = 1;
+    opcode = OPCODE(pCode[0]);
+    switch(opcode) {
+        case CEE_PREFIX1:
+            opcode = OPCODE(pCode[1] + 256);
+            if (opcode < 0 || opcode >= CEE_COUNT)
+                return CEE_COUNT;
+            *pdwLen = 2;
+            break;
+
+        case CEE_PREFIXREF:
+        case CEE_PREFIX2:
+        case CEE_PREFIX3:
+        case CEE_PREFIX4:
+        case CEE_PREFIX5:
+        case CEE_PREFIX6:
+        case CEE_PREFIX7:
+            return CEE_COUNT;
+        default:
+            break;
+    }
+    return opcode;
+}
+
+char* Assembler::ReflectionNotation(mdToken tk)
+{
+    char *sz = (char*)&wzUniBuf[dwUniBuf>>1], *pc;
+    *sz=0;
+    switch(TypeFromToken(tk))
+    {
+        case mdtTypeDef:
+            {
+                Class *pClass = m_lstClass.PEEK(RidFromToken(tk)-1);
+                if(pClass)
+                {
+                    strcpy_s(sz,dwUniBuf>>1,pClass->m_szFQN);
+                    pc = sz;
+                    while((pc = strchr(pc,NESTING_SEP)) != NULL)
+                    {
+                        *pc = '+';
+                        pc++;
+                    }
+                }
+            }
+            break;
+
+        case mdtTypeRef:
+            {
+                ULONG   N;
+                mdToken tkResScope;
+                if(SUCCEEDED(m_pImporter->GetTypeRefProps(tk,&tkResScope,wzUniBuf,dwUniBuf>>1,&N)))
+                {
+                    WszWideCharToMultiByte(CP_UTF8,0,wzUniBuf,-1,sz,dwUniBuf>>1,NULL,NULL);
+                    if(TypeFromToken(tkResScope)==mdtAssemblyRef)
+                    {
+                        AsmManAssembly *pAsmRef = m_pManifest->m_AsmRefLst.PEEK(RidFromToken(tkResScope)-1);
+                        if(pAsmRef)
+                        {
+                            pc = &sz[strlen(sz)];
+                            pc+=sprintf_s(pc,(dwUniBuf >> 1),", %s, Version=%d.%d.%d.%d, Culture=",pAsmRef->szName,
+                                    pAsmRef->usVerMajor,pAsmRef->usVerMinor,pAsmRef->usBuild,pAsmRef->usRevision);
+                            ULONG L=0;
+                            if(pAsmRef->pLocale && (L=pAsmRef->pLocale->length()))
+                            {
+                                memcpy(wzUniBuf,pAsmRef->pLocale->ptr(),L);
+                                wzUniBuf[L>>1] = 0;
+                                WszWideCharToMultiByte(CP_UTF8,0,wzUniBuf,-1,pc,dwUniBuf>>1,NULL,NULL);
+                            }
+                            else pc+=sprintf_s(pc,(dwUniBuf >> 1),"neutral");
+                            pc = &sz[strlen(sz)];
+                            if(pAsmRef->pPublicKeyToken && (L=pAsmRef->pPublicKeyToken->length()))
+                            {
+                                pc+=sprintf_s(pc,(dwUniBuf >> 1),", Publickeytoken=");
+                                BYTE* pb = (BYTE*)(pAsmRef->pPublicKeyToken->ptr());
+                                for(N=0; N<L; N++,pb++) pc+=sprintf_s(pc,(dwUniBuf >> 1),"%2.2x",*pb);
+                            }
+                        }
+                    }
+                }
+            }
+            break;
+
+        default:
+            break;
+    }
+    return sz;
+}
+
+/*
+--------------------------------------------------------------------
+mix -- mix 3 32-bit values reversibly.
+For every delta with one or two bits set, and the deltas of all three
+  high bits or all three low bits, whether the original value of a,b,c
+  is almost all zero or is uniformly distributed,
+* If mix() is run forward or backward, at least 32 bits in a,b,c
+  have at least 1/4 probability of changing.
+* If mix() is run forward, every bit of c will change between 1/3 and
+  2/3 of the time.  (Well, 22/100 and 78/100 for some 2-bit deltas.)
+mix() was built out of 36 single-cycle latency instructions in a 
+  structure that could supported 2x parallelism, like so:
+      a -= b; 
+      a -= c; x = (c>>13);
+      b -= c; a ^= x;
+      b -= a; x = (a<<8);
+      c -= a; b ^= x;
+      c -= b; x = (b>>13);
+      ...
+  Unfortunately, superscalar Pentiums and Sparcs can't take advantage 
+  of that parallelism.  They've also turned some of those single-cycle
+  latency instructions into multi-cycle latency instructions.  Still,
+  this is the fastest good hash I could find.  There were about 2^^68
+  to choose from.  I only looked at a billion or so.
+--------------------------------------------------------------------
+*/
+#define mix(a,b,c) \
+{ \
+  a -= b; a -= c; a ^= (c >> 13); \
+  b -= c; b -= a; b ^= (a << 8);  \
+  c -= a; c -= b; c ^= (b >> 13); \
+  a -= b; a -= c; a ^= (c >> 12); \
+  b -= c; b -= a; b ^= (a << 16); \
+  c -= a; c -= b; c ^= (b >> 5);  \
+  a -= b; a -= c; a ^= (c >> 3);  \
+  b -= c; b -= a; b ^= (a << 10); \
+  c -= a; c -= b; c ^= (b >> 15); \
+}
+
+/*
+--------------------------------------------------------------------
+hash() -- hash a variable-length key into a 32-bit value
+  k       : the key (the unaligned variable-length array of bytes)
+  len     : the length of the key, counting by bytes
+  initval : can be any 4-byte value
+Returns a 32-bit value.  Every bit of the key affects every bit of
+the return value.  Every 1-bit and 2-bit delta achieves avalanche.
+About 6*len+35 instructions.
+
+The best hash table sizes are powers of 2.  There is no need to do
+mod a prime (mod is sooo slow!).  If you need less than 32 bits,
+use a bitmask.  For example, if you need only 10 bits, do
+  h = (h & hashmask(10));
+In which case, the hash table should have hashsize(10) elements.
+
+If you are hashing n strings (ub1 **)k, do it like this:
+  for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h);
+
+By Bob Jenkins, 1996.  bob_jenkins@burtleburtle.net.  You may use this
+code any way you wish, private, educational, or commercial.  It's free.
+
+See http://burtleburtle.net/bob/hash/evahash.html
+Use for hash table lookup, or anything where one collision in 2^^32 is
+acceptable.  Do NOT use for cryptographic purposes.
+--------------------------------------------------------------------
+*/
+
+unsigned hash( 
+     __in_ecount(length) const BYTE *k,        /* the key */
+     unsigned  length,   /* the length of the key */
+     unsigned  initval)  /* the previous hash, or an arbitrary value */
+{
+   register unsigned a,b,c,len;
+
+   /* Set up the internal state */
+   len = length;
+   a = b = 0x9e3779b9;  /* the golden ratio; an arbitrary value */
+   c = initval;         /* the previous hash value */
+
+   /*---------------------------------------- handle most of the key */
+   while (len >= 12)
+   {
+      a += (k[0] + ((unsigned)k[1] << 8) + ((unsigned)k[2]  << 16) + ((unsigned)k[3]  << 24));
+      b += (k[4] + ((unsigned)k[5] << 8) + ((unsigned)k[6]  << 16) + ((unsigned)k[7]  << 24));
+      c += (k[8] + ((unsigned)k[9] << 8) + ((unsigned)k[10] << 16) + ((unsigned)k[11] << 24));
+      mix(a,b,c);
+      k += 12; len -= 12;
+   }
+
+   /*------------------------------------- handle the last 11 bytes */
+   c += length;
+   switch(len)              /* all the case statements fall through */
+   {
+       case 11: c+=((unsigned)k[10] << 24);
+       case 10: c+=((unsigned)k[9] << 16);
+       case 9 : c+=((unsigned)k[8] << 8);
+          /* the first byte of c is reserved for the length */
+       case 8 : b+=((unsigned)k[7] << 24);
+       case 7 : b+=((unsigned)k[6] << 16);
+       case 6 : b+=((unsigned)k[5] << 8);
+       case 5 : b+=k[4];
+       case 4 : a+=((unsigned)k[3] << 24);
+       case 3 : a+=((unsigned)k[2] << 16);
+       case 2 : a+=((unsigned)k[1] << 8);
+       case 1 : a+=k[0];
+     /* case 0: nothing left to add */
+   }
+   mix(a,b,c);
+   /*-------------------------------------------- report the result */
+   return c;
+}
+
diff --git a/src/ilasm/assembler.cpp b/src/ilasm/assembler.cpp
new file mode 100644
index 0000000000..d83bf7ce2b
--- /dev/null
+++ b/src/ilasm/assembler.cpp
@@ -0,0 +1,2466 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// File: assembler.cpp
+//
+
+//
+
+#include "ilasmpch.h"
+
+#include "assembler.h"
+#include "binstr.h"
+#include "nvpair.h"
+
+#define FAIL_UNLESS(x, y) if (!(x)) { report->error y; return; }
+
+/**************************************************************************/
+void Assembler::StartNameSpace(__in __nullterminated char* name)
+{
+    m_NSstack.PUSH(m_szNamespace);
+    m_szNamespace = name;
+    unsigned L = (unsigned)strlen(m_szFullNS);
+    unsigned l = (unsigned)strlen(name);
+    if(L+l+1 >= m_ulFullNSLen)
+    {
+        char* pch = new char[((L+l)/MAX_NAMESPACE_LENGTH + 1)*MAX_NAMESPACE_LENGTH];
+        if(pch)
+        {
+            memcpy(pch,m_szFullNS,L+1);
+            delete [] m_szFullNS;
+            m_szFullNS = pch;
+            m_ulFullNSLen = ((L+l)/MAX_NAMESPACE_LENGTH + 1)*MAX_NAMESPACE_LENGTH;
+        }
+        else report->error("Failed to reallocate the NameSpace buffer\n");
+    }
+    if(L) m_szFullNS[L] = NAMESPACE_SEPARATOR_CHAR;
+    else L = 0xFFFFFFFF;
+    memcpy(&m_szFullNS[L+1],m_szNamespace, l+1);
+}
+
+/**************************************************************************/
+void Assembler::EndNameSpace()
+{
+    char *p = &m_szFullNS[strlen(m_szFullNS)-strlen(m_szNamespace)];
+    if(p > m_szFullNS) p--;
+    *p = 0;
+    delete [] m_szNamespace;
+    if((m_szNamespace = m_NSstack.POP())==NULL)
+    {
+        m_szNamespace = new char[2];
+        m_szNamespace[0] = 0;
+    }
+}
+
+/**************************************************************************/
+void    Assembler::ClearImplList(void)
+{
+    while(m_nImplList) m_crImplList[--m_nImplList] = mdTypeRefNil;
+}
+/**************************************************************************/
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:22008) // "Suppress PREfast warnings about integer overflow"
+#endif
+void    Assembler::AddToImplList(mdToken tk)
+{
+    if(m_nImplList+1 >= m_nImplListSize)
+    {
+        mdToken *ptr = new mdToken[m_nImplListSize + MAX_INTERFACES_IMPLEMENTED];
+        if(ptr == NULL)
+        {
+            report->error("Failed to reallocate Impl List from %d to %d bytes\n",
+                m_nImplListSize*sizeof(mdToken),
+                (m_nImplListSize+MAX_INTERFACES_IMPLEMENTED)*sizeof(mdToken));
+            return;
+        }
+        memcpy(ptr,m_crImplList,m_nImplList*sizeof(mdToken));
+        delete m_crImplList;
+        m_crImplList = ptr;
+        m_nImplListSize += MAX_INTERFACES_IMPLEMENTED;
+    }
+    m_crImplList[m_nImplList++] = tk;
+    m_crImplList[m_nImplList] = mdTypeRefNil;
+}
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif
+
+void    Assembler::ClearBoundList(void)
+{
+    m_TyParList = NULL;
+}
+/**************************************************************************/
+mdToken Assembler::ResolveClassRef(mdToken tkResScope, __in __nullterminated char *pszFullClassName, Class** ppClass)
+{
+    Class *pClass = NULL;
+    mdToken tkRet = mdTokenNil;
+    mdToken *ptkSpecial = NULL;
+
+    if(pszFullClassName == NULL) return mdTokenNil;
+#if (0)
+    if (m_fInitialisedMetaData == FALSE)
+    {
+        if (FAILED(InitMetaData())) // impl. see WRITER.CPP
+        {
+            _ASSERTE(0);
+            if(ppClass) *ppClass = NULL;
+            return mdTokenNil;
+        }
+    }
+#endif
+
+    switch(strlen(pszFullClassName))
+    {
+        case 11:
+            if(strcmp(pszFullClassName,"System.Enum")==0) ptkSpecial = &m_tkSysEnum;
+            break;
+        case 13:
+            if(strcmp(pszFullClassName,"System.Object")==0) ptkSpecial = &m_tkSysObject;
+            else if(strcmp(pszFullClassName,"System.String")==0) ptkSpecial = &m_tkSysString;
+            break;
+        case 16:
+            if(strcmp(pszFullClassName,"System.ValueType")==0) ptkSpecial = &m_tkSysValue;
+            break;
+    }
+    if(ptkSpecial) // special token
+    {
+        if(*ptkSpecial) // already resolved
+        {
+            tkRet = *ptkSpecial;
+            if(ppClass)
+            {
+                if(TypeFromToken(tkRet)==mdtTypeDef)
+                    *ppClass = m_lstClass.PEEK(RidFromToken(tkRet)-1);
+                else *ppClass = NULL;
+            }
+            return tkRet;
+        }
+        else  // needs to be resolved
+            if(!m_fIsMscorlib) tkResScope = GetBaseAsmRef();
+    }
+    if(tkResScope == 1)
+    {
+        if((pClass = FindCreateClass(pszFullClassName)) != NULL) tkRet = pClass->m_cl;
+    }
+    else
+    {
+        tkRet = MakeTypeRef(tkResScope, pszFullClassName);
+        pClass = NULL;
+    }
+    if(ppClass) *ppClass = pClass;
+    if(ptkSpecial) *ptkSpecial = tkRet;
+    return tkRet;
+}
+
+class TypeSpecContainer
+{
+private:
+    // Contain a BinStr
+    unsigned __int8 *ptr_;
+    unsigned len_;
+    // Hash the BinStr, just for speed of lookup
+    unsigned hash_;
+    // The value we're looking for
+    mdToken token_;
+public:
+    // Constructor for a 'lookup' object
+    TypeSpecContainer(BinStr *typeSpec) : 
+        len_(typeSpec->length()), 
+        hash_(typeSpec->length()), 
+        token_(mdTokenNil), 
+        ptr_(typeSpec->ptr())
+    {        
+        for (unsigned i = 0; i < len_; i++)
+            hash_ = (hash_ * 257) ^ ((i + 1) * (ptr_[i] ^ 0xA5));
+    }
+    // Constructor for a 'permanent' object
+    // Don't bother re-hashing, since we will always have already constructed the lookup object
+    TypeSpecContainer(const TypeSpecContainer &t, mdToken tk) : 
+        len_(t.len_), 
+        hash_(t.hash_),
+        token_(tk), 
+        ptr_(new unsigned __int8[t.len_])
+    {
+        _ASSERT(tk != mdTokenNil);
+        _ASSERT(t.token_ == mdTokenNil);
+        memcpy(ptr_, t.ptr_, len_);
+    }
+    ~TypeSpecContainer()
+    {
+        if (token_ != mdTokenNil)
+            // delete any memory for a 'permanent' object
+            delete[] ptr_;
+    }
+    // this is the operator for a RBTREE
+    int ComparedTo(TypeSpecContainer *t) const
+    {
+        // If they don't hash the same, just diff the hashes
+        if (hash_ != t->hash_)
+            return hash_ - t->hash_;
+        if (len_ != t->len_)
+            return len_ - t->len_;
+        return memcmp(ptr_, t->ptr_, len_);
+    }
+    // The only public data we need
+    const mdToken Token() const { return token_; }
+};
+
+static RBTREE<TypeSpecContainer> typeSpecCache;
+
+extern FIFO<char> TyParFixupList;
+
+/**************************************************************************/
+mdToken Assembler::ResolveTypeSpec(BinStr* typeSpec)
+{
+    mdToken tk;
+
+    // It is safe to use the cache only if there are no pending fixups
+    if (TyParFixupList.COUNT() != 0)
+    {
+        if (FAILED(m_pEmitter->GetTokenFromTypeSpec(typeSpec->ptr(), typeSpec->length(), &tk)))
+            return mdTokenNil;
+        return tk;
+    }
+
+    TypeSpecContainer tsc(typeSpec);
+
+    // GetTokenFromTypeSpec is a linear search through an unsorted list
+    // Instead of doing that all the time, look this thing up in a cache
+    TypeSpecContainer *res = typeSpecCache.FIND(&tsc);
+    if (res != NULL)
+    {
+#ifdef _DEBUG
+        // Verify that the cache is in sync with the master copy in metadata
+        PCOR_SIGNATURE pSig;
+        ULONG cSig;
+        m_pImporter->GetTypeSpecFromToken(res->Token(),(PCCOR_SIGNATURE*)&pSig,&cSig);
+        _ASSERTE(typeSpec->length() == cSig);
+        _ASSERTE(memcmp(typeSpec->ptr(), pSig, cSig) == 0);
+#endif
+
+        return res->Token();
+    }
+
+    if (FAILED(m_pEmitter->GetTokenFromTypeSpec(typeSpec->ptr(), typeSpec->length(), &tk)))
+        return mdTokenNil;
+
+    typeSpecCache.PUSH(new TypeSpecContainer(tsc, tk));
+    return tk;
+}
+
+/**************************************************************************/
+mdToken Assembler::GetAsmRef(__in __nullterminated char* szName)
+{
+    mdToken tkResScope = 0;
+    if(strcmp(szName,"*")==0) tkResScope = mdTokenNil;
+    else
+    {
+        tkResScope = m_pManifest->GetAsmRefTokByName(szName);
+        if(RidFromToken(tkResScope)==0)
+        {
+            // emit the AssemblyRef
+            // if it's not self, try to get attributes with Autodetect
+            unsigned L = (unsigned)strlen(szName)+1;
+            char *sz = new char[L];
+            if(sz)
+            {
+                memcpy(sz,szName,L);
+                AsmManAssembly *pAsmRef = m_pManifest->m_pCurAsmRef;
+                m_pManifest->StartAssembly(sz,NULL,0,TRUE);
+                if(RidFromToken(m_pManifest->GetAsmTokByName(szName))==0)
+                {
+                    report->warn("Reference to undeclared extern assembly '%s'. Attempting autodetect\n",szName);
+                    m_pManifest->SetAssemblyAutodetect();
+                }
+                m_pManifest->EndAssembly();
+                tkResScope = m_pManifest->GetAsmRefTokByName(szName);
+                m_pManifest->m_pCurAsmRef = pAsmRef;
+            }
+            else
+                report->error("\nOut of memory!\n");
+        }
+    }
+    return tkResScope;
+}
+
+mdToken Assembler::GetBaseAsmRef()
+{
+    if(RidFromToken(m_pManifest->GetAsmRefTokByName("System.Runtime")) != 0)
+    {
+        return GetAsmRef("System.Runtime");
+    }
+
+    return GetAsmRef("mscorlib");
+}
+
+mdToken Assembler::GetInterfaceImpl(mdToken tsClass, mdToken tsInterface) 
+{
+    mdToken result = mdTokenNil;
+    HCORENUM iiEnum = 0;
+    ULONG actualInterfaces;
+    mdInterfaceImpl impls;
+    
+    while (SUCCEEDED(m_pImporter->EnumInterfaceImpls(&iiEnum, tsClass, &impls, 1, &actualInterfaces)))
+    {
+        if (actualInterfaces == 1)
+        {
+            mdToken classToken, interfaceToken;
+            if (FAILED(m_pImporter->GetInterfaceImplProps(impls, &classToken, &interfaceToken)))
+                break;
+            if (classToken == tsClass && interfaceToken == tsInterface)
+            {
+                result = impls;
+                break;
+            }
+        }
+    }
+    m_pImporter->CloseEnum(iiEnum);
+    return result;
+}
+
+/**************************************************************************/
+mdToken Assembler::GetModRef(__in __nullterminated char* szName)
+{
+    mdToken tkResScope = 0;
+    if(!strcmp(szName,m_szScopeName))
+            tkResScope = 1; // scope is "this module"
+    else
+    {
+        ImportDescriptor*   pID;
+        int i = 0;
+        tkResScope = mdModuleRefNil;
+        DWORD L = (DWORD)strlen(szName);
+        while((pID=m_ImportList.PEEK(i++)))
+        {
+            if(pID->dwDllName != L) continue;
+            if((L > 0) && (strcmp(pID->szDllName,szName)!=0)) continue;
+            tkResScope = pID->mrDll;
+            break;
+        }
+        if(RidFromToken(tkResScope)==0)
+            report->error("Undefined module ref '%s'\n",szName);
+    }
+    return tkResScope;
+}
+/**************************************************************************/
+mdToken Assembler::MakeTypeRef(mdToken tkResScope, LPCUTF8 pszFullClassName)
+{
+    mdToken tkRet = mdTokenNil;
+    if(pszFullClassName && *pszFullClassName)
+    {
+        LPCUTF8 pc;
+        if((pc = strrchr(pszFullClassName,NESTING_SEP))) // scope: enclosing class
+        {
+            LPUTF8 szScopeName;
+            DWORD L = (DWORD)(pc-pszFullClassName);
+            if((szScopeName = new char[L+1]) != NULL)
+            {
+                memcpy(szScopeName,pszFullClassName,L);
+                szScopeName[L] = 0;
+                tkResScope = MakeTypeRef(tkResScope,szScopeName);
+                delete [] szScopeName;
+            }
+            else
+                report->error("\nOut of memory!\n");
+            pc++;
+        }
+        else pc = pszFullClassName;
+        if(*pc)
+        {
+            // convert name to widechar
+            WszMultiByteToWideChar(g_uCodePage,0,pc,-1,wzUniBuf,dwUniBuf);
+            if(FAILED(m_pEmitter->DefineTypeRefByName(tkResScope, wzUniBuf, &tkRet))) tkRet = mdTokenNil;
+        }
+    }
+    return tkRet;
+}
+/**************************************************************************/
+
+DWORD Assembler::CheckClassFlagsIfNested(Class* pEncloser, DWORD attr)
+{
+    DWORD wasAttr = attr;
+    if(pEncloser && (!IsTdNested(attr)))
+    {
+        if(OnErrGo)
+            report->error("Nested class has non-nested visibility (0x%08X)\n",attr);
+        else
+        {
+            attr &= ~tdVisibilityMask;
+            attr |= (IsTdPublic(wasAttr) ? tdNestedPublic : tdNestedPrivate);
+            report->warn("Nested class has non-nested visibility (0x%08X), changed to nested (0x%08X)\n",wasAttr,attr);
+        }
+    }
+    else if((pEncloser==NULL) && IsTdNested(attr))
+    {
+        if(OnErrGo)
+            report->error("Non-nested class has nested visibility (0x%08X)\n",attr);
+        else
+        {
+            attr &= ~tdVisibilityMask;
+            attr |= (IsTdNestedPublic(wasAttr) ? tdPublic : tdNotPublic);
+            report->warn("Non-nested class has nested visibility (0x%08X), changed to non-nested (0x%08X)\n",wasAttr,attr);
+        }
+    }
+    return attr;
+}
+
+/**************************************************************************/
+
+void Assembler::StartClass(__in __nullterminated char* name, DWORD attr, TyParList *typars)
+{
+    Class *pEnclosingClass = m_pCurClass;
+    char *szFQN;
+    ULONG LL;
+
+    m_TyParList = typars;
+
+    if (m_pCurMethod != NULL)
+    {
+        report->error("Class cannot be declared within a method scope\n");
+    }
+    if(pEnclosingClass)
+    {
+        LL = pEnclosingClass->m_dwFQN+(ULONG)strlen(name)+2;
+        if((szFQN = new char[LL]))
+            sprintf_s(szFQN,LL,"%s%c%s",pEnclosingClass->m_szFQN,NESTING_SEP,name);
+        else
+            report->error("\nOut of memory!\n");
+    }
+    else
+    {
+        unsigned L = (unsigned)strlen(m_szFullNS);
+        unsigned LLL = (unsigned)strlen(name);
+        LL = L + LLL + (L ? 2 : 1);
+        if((szFQN = new char[LL]))
+        {
+            if(L) sprintf_s(szFQN,LL,"%s.%s",m_szFullNS,name);
+            else memcpy(szFQN,name,LL);
+            if(LL > MAX_CLASSNAME_LENGTH)
+            {
+                report->error("Full class name too long (%d characters, %d allowed).\n",LL-1,MAX_CLASSNAME_LENGTH-1);
+            }
+        }
+        else
+            report->error("\nOut of memory!\n");
+    }
+    if(szFQN == NULL) return;
+
+    mdToken tkThis;
+    if(m_fIsMscorlib)
+        tkThis = ResolveClassRef(1,szFQN,&m_pCurClass); // boils down to FindCreateClass(szFQN)
+    else
+    {
+        m_pCurClass = FindCreateClass(szFQN);
+        tkThis = m_pCurClass->m_cl;
+    }
+    if(m_pCurClass->m_bIsMaster)
+    {
+        m_pCurClass->m_Attr = CheckClassFlagsIfNested(pEnclosingClass, attr);
+
+        if (m_TyParList)
+        {
+            //m_pCurClass->m_NumTyPars = m_TyParList->ToArray(&m_pCurClass->m_TyParBounds, &m_pCurClass->m_TyParNames, &m_pCurClass->m_TyParAttrs);
+            m_pCurClass->m_NumTyPars = m_TyParList->ToArray(&(m_pCurClass->m_TyPars));
+            delete m_TyParList;
+            m_TyParList = NULL;
+        }
+        else m_pCurClass->m_NumTyPars = 0;
+        m_pCurClass->m_pEncloser = pEnclosingClass;
+    } // end if(old class) else
+    m_tkCurrentCVOwner = 0;
+    m_CustomDescrListStack.PUSH(m_pCustomDescrList);
+    m_pCustomDescrList = &(m_pCurClass->m_CustDList);
+
+    m_ClassStack.PUSH(pEnclosingClass);
+    ClearBoundList();
+}
+
+/**************************************************************************/
+
+void Assembler::AddClass()
+{
+    mdTypeRef   crExtends = mdTypeRefNil;
+    BOOL bIsEnum = FALSE;
+    BOOL bIsValueType = FALSE;
+
+    if(m_pCurClass->m_bIsMaster)
+    {
+        DWORD attr = m_pCurClass->m_Attr;
+        if(!IsNilToken(m_crExtends))
+        {
+            // has a superclass
+            if(IsTdInterface(attr)) report->error("Base class in interface\n");
+            bIsValueType = (m_crExtends == m_tkSysValue)&&(m_pCurClass->m_cl != m_tkSysEnum);
+            bIsEnum = (m_crExtends == m_tkSysEnum);
+            crExtends = m_crExtends;
+        }
+        else
+        {
+            bIsEnum = ((attr & 0x40000000) != 0);
+            bIsValueType = ((attr & 0x80000000) != 0);
+        }
+        attr &= 0x3FFFFFFF;
+        if (m_fAutoInheritFromObject && (crExtends == mdTypeRefNil) && (!IsTdInterface(attr)))
+        {
+            mdToken tkMscorlib = m_fIsMscorlib ? 1 : GetBaseAsmRef();
+            crExtends = bIsEnum ?
+                ResolveClassRef(tkMscorlib,"System.Enum",NULL)
+                :( bIsValueType ?
+                    ResolveClassRef(tkMscorlib,"System.ValueType",NULL)
+                    : ResolveClassRef(tkMscorlib, "System.Object",NULL));
+        }
+        m_pCurClass->m_Attr = attr;
+        m_pCurClass->m_crExtends = (m_pCurClass->m_cl == m_tkSysObject)? mdTypeRefNil : crExtends;
+
+        if ((m_pCurClass->m_dwNumInterfaces = m_nImplList) != NULL)
+        {
+            if(bIsEnum) report->error("Enum implementing interface(s)\n");
+            if((m_pCurClass->m_crImplements = new mdTypeRef[m_nImplList+1]) != NULL)
+                memcpy(m_pCurClass->m_crImplements, m_crImplList, (m_nImplList+1)*sizeof(mdTypeRef));
+            else
+            {
+                report->error("Failed to allocate Impl List for class '%s'\n", m_pCurClass->m_szFQN);
+                m_pCurClass->m_dwNumInterfaces = 0;
+            }
+        }
+        else m_pCurClass->m_crImplements = NULL;
+        if(bIsValueType)
+        {
+            if(!IsTdSealed(attr))
+            {
+                if(OnErrGo) report->error("Non-sealed value class\n");
+                else
+                {
+                    report->warn("Non-sealed value class, made sealed\n");
+                    m_pCurClass->m_Attr |= tdSealed;
+                }
+            }
+        }
+        m_pCurClass->m_bIsMaster = FALSE;
+    } // end if(old class) else
+    ClearImplList();
+    m_crExtends = mdTypeRefNil;
+}
+
+/**************************************************************************/
+void Assembler::EndClass()
+{
+    m_pCurClass = m_ClassStack.POP();
+    m_tkCurrentCVOwner = 0;
+    m_pCustomDescrList = m_CustomDescrListStack.POP();
+}
+
+/**************************************************************************/
+void Assembler::SetPinvoke(BinStr* DllName, int Ordinal, BinStr* Alias, int Attrs)
+{
+    if(m_pPInvoke) delete m_pPInvoke;
+    if(DllName->length())
+    {
+        if((m_pPInvoke = new PInvokeDescriptor))
+        {
+            unsigned l;
+            ImportDescriptor* pID;
+            if((pID = EmitImport(DllName)))
+            {
+                m_pPInvoke->mrDll = pID->mrDll;
+                m_pPInvoke->szAlias = NULL;
+                if(Alias)
+                {
+                    l = Alias->length();
+                    if((m_pPInvoke->szAlias = new char[l+1]))
+                    {
+                        memcpy(m_pPInvoke->szAlias,Alias->ptr(),l);
+                        m_pPInvoke->szAlias[l] = 0;
+                    }
+                    else report->error("\nOut of memory!\n");
+                }
+                m_pPInvoke->dwAttrs = (DWORD)Attrs;
+            }
+            else
+            {
+                delete m_pPInvoke;
+                m_pPInvoke = NULL;
+                report->error("PInvoke refers to undefined imported DLL\n");
+            }
+        }
+        else
+            report->error("Failed to allocate PInvokeDescriptor\n");
+    }
+    else
+    {
+        m_pPInvoke = NULL; // No DLL name, it's "local" (IJW) PInvoke
+        report->error("Local (embedded native) PInvoke method, the resulting PE file is unusable\n");
+    }
+    if(DllName) delete DllName;
+    if(Alias) delete Alias;
+}
+
+/**************************************************************************/
+void Assembler::StartMethod(__in __nullterminated char* name, BinStr* sig, CorMethodAttr flags, BinStr* retMarshal, DWORD retAttr, TyParList *typars)
+{
+    if (m_pCurMethod != NULL)
+    {
+        report->error("Cannot declare a method '%s' within another method\n",name);
+    }
+    if (!m_fInitialisedMetaData)
+    {
+        if (FAILED(InitMetaData())) // impl. see WRITER.CPP
+        {
+            _ASSERTE(0);
+        }
+    }
+    size_t namelen = strlen(name);
+    if(namelen >= MAX_CLASSNAME_LENGTH)
+    {
+        char c = name[MAX_CLASSNAME_LENGTH-1];
+        name[MAX_CLASSNAME_LENGTH-1] = 0;
+        report->error("Method '%s...' -- name too long (%d characters).\n",name,namelen);
+        name[MAX_CLASSNAME_LENGTH-1] = c;
+    }
+    if (!(flags & mdStatic))
+        *(sig->ptr()) |= IMAGE_CEE_CS_CALLCONV_HASTHIS;
+    else if(*(sig->ptr()) & (IMAGE_CEE_CS_CALLCONV_HASTHIS | IMAGE_CEE_CS_CALLCONV_EXPLICITTHIS))
+    {
+        if(OnErrGo) report->error("Method '%s' -- both static and instance\n", name);
+        else
+        {
+            report->warn("Method '%s' -- both static and instance, set to static\n", name);
+            *(sig->ptr()) &= ~(IMAGE_CEE_CS_CALLCONV_HASTHIS | IMAGE_CEE_CS_CALLCONV_EXPLICITTHIS);
+        }
+    }
+
+    if(!IsMdPrivateScope(flags))
+    {
+        Method* pMethod;
+        Class* pClass = (m_pCurClass ? m_pCurClass : m_pModuleClass);
+        DWORD L = (DWORD)strlen(name);
+        for(int j=0; (pMethod = pClass->m_MethodList.PEEK(j)); j++)
+        {
+            if( (pMethod->m_dwName == L) &&
+                (!strcmp(pMethod->m_szName,name)) &&
+                (pMethod->m_dwMethodCSig == sig->length())  &&
+                (!memcmp(pMethod->m_pMethodSig,sig->ptr(),sig->length()))
+                &&(!IsMdPrivateScope(pMethod->m_Attr)))
+            {
+                if(m_fTolerateDupMethods)
+                {
+                    // reset for new body
+                    pMethod->m_lstFixup.RESET(true);
+                    //pMethod->m_lstLabel.RESET(true);
+                    m_lstLabel.RESET(true);
+                    pMethod->m_Locals.RESET(true);
+                    delArgNameList(pMethod->m_firstArgName);
+                    delArgNameList(pMethod->m_firstVarName);
+                    pMethod->m_pCurrScope = &(pMethod->m_MainScope);
+                    pMethod->m_pCurrScope->Reset();
+                    pMethod->m_firstArgName = getArgNameList();
+                    pMethod->m_dwNumExceptions = 0;
+                    pMethod->m_dwNumEndfilters = 0;
+                    if(pMethod->m_pRetMarshal) delete pMethod->m_pRetMarshal;
+                    if(pMethod->m_pRetValue) delete pMethod->m_pRetValue;
+                    
+                    pMethod->m_MethodImplDList.RESET(false); // ptrs in m_MethodImplDList are dups of those in Assembler
+
+                    pMethod->m_CustomDescrList.RESET(true);
+
+                    if(pMethod->m_fEntryPoint)
+                    {
+                        pMethod->m_fEntryPoint = FALSE;
+                        m_fEntryPointPresent = FALSE;
+                    }
+
+                    if(pMethod->m_pbsBody)
+                    {
+                        // no need to remove relevant MemberRef Fixups from the Assembler list:
+                        // their m_fNew flag is set to FALSE anyway.
+                        // Just get rid of old method body
+                        delete pMethod->m_pbsBody;
+                        pMethod->m_pbsBody = NULL;
+                    }
+
+                    pMethod->m_fNewBody = TRUE;
+                    m_pCurMethod = pMethod;
+                }
+                else
+                    report->error("Duplicate method declaration\n");
+                break;
+            }
+        }
+    }
+    if(m_pCurMethod == NULL)
+    {
+        if(m_pCurClass)
+        { // instance method
+            if(IsMdAbstract(flags) && !IsTdAbstract(m_pCurClass->m_Attr))
+            {
+                report->error("Abstract method '%s' in non-abstract class '%s'\n",name,m_pCurClass->m_szFQN);
+            }
+            if(m_pCurClass->m_crExtends == m_tkSysEnum) report->error("Method in enum\n");
+
+            if(!strcmp(name,COR_CTOR_METHOD_NAME))
+            {
+                flags = (CorMethodAttr)(flags | mdSpecialName);
+                if(IsTdInterface(m_pCurClass->m_Attr)) report->error("Instance constructor in interface\n");
+
+            }
+            if(!IsMdStatic(flags))
+            {
+                if(IsTdInterface(m_pCurClass->m_Attr))
+                {
+                    if(!IsMdPublic(flags)) report->error("Non-public instance method in interface\n");
+                    if((!(IsMdVirtual(flags) && IsMdAbstract(flags))))
+                    {
+                        if(OnErrGo) report->error("Non-virtual, non-abstract instance method in interface\n");
+                        else
+                        {
+                            report->warn("Non-virtual, non-abstract instance method in interface, set to such\n");
+                            flags = (CorMethodAttr)(flags |mdVirtual | mdAbstract);
+                        }
+                    }
+    
+                }
+            }
+            m_pCurMethod = new Method(this, m_pCurClass, name, sig, flags);
+        }
+        else
+        {
+            if(IsMdAbstract(flags))
+            {
+                if(OnErrGo) report->error("Global method '%s' can't be abstract\n",name);
+                else
+                {
+                    report->warn("Global method '%s' can't be abstract, flag removed\n",name);
+                    flags = (CorMethodAttr)(((int) flags) &~mdAbstract);
+                }
+            }
+            if(!IsMdStatic(flags))
+            {
+                if(OnErrGo) report->error("Non-static global method '%s'\n",name);
+                else
+                {
+                    report->warn("Non-static global method '%s', made static\n",name);
+                    flags = (CorMethodAttr)(flags | mdStatic);
+                    *((BYTE*)(sig->ptr())) &= ~(IMAGE_CEE_CS_CALLCONV_HASTHIS | IMAGE_CEE_CS_CALLCONV_EXPLICITTHIS);
+                }
+            }
+            m_pCurMethod = new Method(this, m_pCurClass, name, sig, flags);
+            if (m_pCurMethod)
+            {
+                m_pCurMethod->SetIsGlobalMethod();
+                if (m_fInitialisedMetaData == FALSE) InitMetaData();
+            }
+        }
+        if(m_pCurMethod)
+        {
+            if(!OnErrGo)
+            {
+                if(m_pCurMethod->m_firstArgName)
+                {
+                    for(ARG_NAME_LIST *pAN=m_pCurMethod->m_firstArgName; pAN; pAN = pAN->pNext)
+                    {
+                        if(pAN->dwName)
+                        {
+                            int k = m_pCurMethod->findArgNum(pAN->pNext,pAN->szName,pAN->dwName);
+                            if(k >= 0)
+                                report->warn("Duplicate param name '%s' in method '%s'\n",pAN->szName,name);
+                        }
+                    }
+                }
+            }
+            m_pCurMethod->m_pRetMarshal = retMarshal;
+            m_pCurMethod->m_dwRetAttr = retAttr;
+            m_tkCurrentCVOwner = 0;
+            m_CustomDescrListStack.PUSH(m_pCustomDescrList);
+            m_pCustomDescrList = &(m_pCurMethod->m_CustomDescrList);
+            m_pCurMethod->m_MainScope.dwStart = m_CurPC;
+            if (typars)
+            {
+                //m_pCurMethod->m_NumTyPars = typars->ToArray(&m_pCurMethod->m_TyParBounds,
+                //&m_pCurMethod->m_TyParNames, NULL);
+                m_pCurMethod->m_NumTyPars = typars->ToArray(&(m_pCurMethod->m_TyPars));
+                delete typars;
+                m_TyParList = NULL;
+            }
+            else m_pCurMethod->m_NumTyPars = 0;
+        }
+        else report->error("Failed to allocate Method class\n");
+    } // end if new method
+}
+
+/**************************************************************************/
+void Assembler::EndMethod()
+{
+
+    if(m_pCurMethod->m_pCurrScope != &(m_pCurMethod->m_MainScope))
+    {
+        report->error("Invalid lexical scope structure in method %s\n",m_pCurMethod->m_szName);
+    }
+    m_pCurMethod->m_pCurrScope->dwEnd = m_CurPC;
+    if (DoFixups(m_pCurMethod)) AddMethod(m_pCurMethod); //AddMethod - see ASSEM.CPP
+    else
+    {
+        report->error("Method '%s' compilation failed.\n",m_pCurMethod->m_szName);
+    }
+    //m_pCurMethod->m_lstLabel.RESET(true);
+    m_lstLabel.RESET(true);
+    m_tkCurrentCVOwner = 0;
+    m_pCustomDescrList = m_CustomDescrListStack.POP();
+    ResetForNextMethod(); // see ASSEM.CPP
+}
+/**************************************************************************/
+/* rvaLabel is the optional label that indicates this field points at a particular RVA */
+void Assembler::AddField(__inout_z __inout char* name, BinStr* sig, CorFieldAttr flags, __in __nullterminated char* rvaLabel, BinStr* pVal, ULONG ulOffset)
+{
+    FieldDescriptor*    pFD;
+    ULONG   i,n;
+    mdToken tkParent = mdTokenNil;
+    Class* pClass;
+
+    if (m_pCurMethod)
+        report->error("Field cannot be declared within a method\n");
+
+    if(strlen(name) >= MAX_CLASSNAME_LENGTH)
+    {
+        char c = name[MAX_CLASSNAME_LENGTH-1];
+        name[MAX_CLASSNAME_LENGTH-1] = 0;
+        report->error("Field '%s...' -- name too long (%d characters).\n",name,strlen(name));
+        name[MAX_CLASSNAME_LENGTH-1] = c;
+    }
+
+    if(sig && (sig->length() >= 2))
+    {
+        if(sig->ptr()[1] == ELEMENT_TYPE_VOID)
+            report->error("Illegal use of type 'void'\n");
+    }
+
+    if (m_pCurClass)
+    {
+        tkParent = m_pCurClass->m_cl;
+
+        if(IsTdInterface(m_pCurClass->m_Attr))
+        {
+            if(!IsFdStatic(flags))
+            { 
+                report->warn("Instance field in interface (CLS violation)\n");
+                if(!IsFdPublic(flags)) report->error("Non-public instance field in interface\n");
+            }
+        }
+    }
+    else
+    {
+        if(ulOffset != 0xFFFFFFFF)
+        {
+            report->warn("Offset in global field '%s' is ignored\n",name);
+            ulOffset = 0xFFFFFFFF;
+        }
+        if(!IsFdStatic(flags))
+        {
+            if(OnErrGo) report->error("Non-static global field\n");
+            else
+            {
+                report->warn("Non-static global field, made static\n");
+                flags = (CorFieldAttr)(flags | fdStatic);
+            }
+        }
+    }
+    pClass = (m_pCurClass ? m_pCurClass : m_pModuleClass);
+    n = pClass->m_FieldDList.COUNT();
+    DWORD L = (DWORD)strlen(name);
+    for(i = 0; i < n; i++)
+    {
+        pFD = pClass->m_FieldDList.PEEK(i);
+        if((pFD->m_tdClass == tkParent)&&(L==pFD->m_dwName)&&(!strcmp(pFD->m_szName,name))
+            &&(pFD->m_pbsSig->length() == sig->length())
+            &&(memcmp(pFD->m_pbsSig->ptr(),sig->ptr(),sig->length())==0))
+        {
+            report->error("Duplicate field declaration: '%s'\n",name);
+            break;
+        }
+    }
+    if (rvaLabel && !IsFdStatic(flags))
+        report->error("Only static fields can have 'at' clauses\n");
+
+    if(i >= n)
+    {
+        if((pFD = new FieldDescriptor))
+        {
+            pFD->m_tdClass = tkParent;
+            pFD->m_szName = name;
+            pFD->m_dwName = L;
+            pFD->m_fdFieldTok = mdTokenNil;
+            if((pFD->m_ulOffset = ulOffset) != 0xFFFFFFFF) pClass->m_dwNumFieldsWithOffset++;
+            pFD->m_rvaLabel = rvaLabel;
+            pFD->m_pbsSig = sig;
+            pFD->m_pClass = pClass;
+            pFD->m_pbsValue = pVal;
+            pFD->m_pbsMarshal = m_pMarshal;
+            pFD->m_pPInvoke = m_pPInvoke;
+            pFD->m_dwAttr = flags;
+
+            m_tkCurrentCVOwner = 0;
+            m_pCustomDescrList = &(pFD->m_CustomDescrList);
+
+            pClass->m_FieldDList.PUSH(pFD);
+            pClass->m_fNewMembers = TRUE;
+        }
+        else
+            report->error("Failed to allocate Field Descriptor\n");
+    }
+    else
+    {
+        if(pVal) delete pVal;
+        if(m_pPInvoke) delete m_pPInvoke;
+        if(m_pMarshal) delete m_pMarshal;
+        delete name;
+    }
+    m_pPInvoke = NULL;
+    m_pMarshal = NULL;
+}
+
+BOOL Assembler::EmitField(FieldDescriptor* pFD)
+{
+    WCHAR*   wzFieldName=&wzUniBuf[0];
+    HRESULT hr;
+    DWORD   cSig;
+    COR_SIGNATURE* mySig;
+    mdFieldDef mb;
+    BYTE    ValType = ELEMENT_TYPE_VOID;
+    void * pValue = NULL;
+    unsigned lVal = 0;
+    BOOL ret = TRUE;
+
+    cSig = pFD->m_pbsSig->length();
+    mySig = (COR_SIGNATURE*)(pFD->m_pbsSig->ptr());
+
+    WszMultiByteToWideChar(g_uCodePage,0,pFD->m_szName,-1,wzFieldName,dwUniBuf); //int)cFieldNameLength);
+    if(IsFdPrivateScope(pFD->m_dwAttr))
+    {
+        WCHAR* p = wcsstr(wzFieldName,L"$PST04");
+        if(p) *p = 0;
+    }
+
+    if(pFD->m_pbsValue && pFD->m_pbsValue->length())
+    {
+        ValType = *(pFD->m_pbsValue->ptr());
+        lVal = pFD->m_pbsValue->length() - 1; // 1 is type byte
+        pValue = (void*)(pFD->m_pbsValue->ptr() + 1);
+        if(ValType == ELEMENT_TYPE_STRING)
+        {
+            //while(lVal % sizeof(WCHAR)) { pFD->m_pbsValue->appendInt8(0); lVal++; }
+            lVal /= sizeof(WCHAR);
+
+#if defined(ALIGN_ACCESS) || BIGENDIAN
+            void* pValueTemp = _alloca(lVal * sizeof(WCHAR));
+            memcpy(pValueTemp, pValue, lVal * sizeof(WCHAR));
+            pValue = pValueTemp;
+
+            SwapStringLength((WCHAR*)pValue, lVal);
+#endif
+        }
+    }
+
+    hr = m_pEmitter->DefineField(
+        pFD->m_tdClass,
+        wzFieldName,
+        pFD->m_dwAttr,
+        mySig,
+        cSig,
+        ValType,
+        pValue,
+        lVal,
+        &mb
+    );
+    if (FAILED(hr))
+    {
+        report->error("Failed to define field '%s' (HRESULT=0x%08X)\n",pFD->m_szName,hr);
+        ret = FALSE;
+    }
+    else
+    {
+        //--------------------------------------------------------------------------------
+        if(IsFdPinvokeImpl(pFD->m_dwAttr)&&(pFD->m_pPInvoke))
+        {
+            if(pFD->m_pPInvoke->szAlias == NULL) pFD->m_pPInvoke->szAlias = pFD->m_szName;
+            if(FAILED(EmitPinvokeMap(mb,pFD->m_pPInvoke)))
+            {
+                report->error("Failed to define PInvoke map of .field '%s'\n",pFD->m_szName);
+                ret = FALSE;
+            }
+        }
+        //--------------------------------------------------------------------------
+        if(pFD->m_pbsMarshal)
+        {
+            if(FAILED(hr = m_pEmitter->SetFieldMarshal (
+                                        mb,                     // [IN] given a fieldDef or paramDef token
+                        (PCCOR_SIGNATURE)(pFD->m_pbsMarshal->ptr()),   // [IN] native type specification
+                                        pFD->m_pbsMarshal->length())))  // [IN] count of bytes of pvNativeType
+            {
+                report->error("Failed to set field marshaling for '%s' (HRESULT=0x%08X)\n",pFD->m_szName,hr);
+                ret = FALSE;
+            }
+        }
+        //--------------------------------------------------------------------------------
+        // Set the the RVA to a dummy value.  later it will be fixed
+        // up to be something correct, but if we don't emit something
+        // the size of the meta-data will not be correct
+        if (pFD->m_rvaLabel)
+        {
+            m_fHaveFieldsWithRvas = TRUE;
+            hr = m_pEmitter->SetFieldRVA(mb, 0xCCCCCCCC);
+            if (FAILED(hr))
+            {
+                report->error("Failed to set RVA for field '%s' (HRESULT=0x%08X)\n",pFD->m_szName,hr);
+                ret = FALSE;
+            }
+        }
+        //--------------------------------------------------------------------------------
+        EmitCustomAttributes(mb, &(pFD->m_CustomDescrList));
+
+    }
+    pFD->m_fdFieldTok = mb;
+    return ret;
+}
+
+/**************************************************************************/
+void Assembler::EmitByte(int val)
+{
+    char ch = (char)val;
+    //if((val < -128)||(val > 127))
+   //       report->warn("Emitting 0x%X as a byte: data truncated to 0x%X\n",(unsigned)val,(BYTE)ch);
+    EmitBytes((BYTE *)&ch,1);
+}
+
+/**************************************************************************/
+void Assembler::NewSEHDescriptor(void) //sets m_SEHD
+{
+    m_SEHDstack.PUSH(m_SEHD);
+    m_SEHD = new SEH_Descriptor;
+    if(m_SEHD == NULL) report->error("Failed to allocate SEH descriptor\n");
+}
+/**************************************************************************/
+void Assembler::SetTryLabels(__in __nullterminated char * szFrom, __in __nullterminated char *szTo)
+{
+    if(!m_SEHD) return;
+    Label *pLbl = m_pCurMethod->FindLabel(szFrom);
+    if(pLbl)
+    {
+        m_SEHD->tryFrom = pLbl->m_PC;
+        if((pLbl = m_pCurMethod->FindLabel(szTo)))  m_SEHD->tryTo = pLbl->m_PC; //FindLabel: Method.CPP
+        else report->error("Undefined 2nd label in 'try <label> to <label>'\n");
+    }
+    else report->error("Undefined 1st label in 'try <label> to <label>'\n");
+}
+/**************************************************************************/
+void Assembler::SetFilterLabel(__in __nullterminated char *szFilter)
+{
+    if(!m_SEHD) return;
+    Label *pLbl = m_pCurMethod->FindLabel(szFilter);
+    if(pLbl)    m_SEHD->sehFilter = pLbl->m_PC;
+    else report->error("Undefined label in 'filter <label>'\n");
+}
+/**************************************************************************/
+void Assembler::SetCatchClass(mdToken catchClass)
+{
+    if(!m_SEHD) return;
+    m_SEHD->cException = catchClass;
+
+}
+/**************************************************************************/
+void Assembler::SetHandlerLabels(__in __nullterminated char *szHandlerFrom, __in __nullterminated char *szHandlerTo)
+{
+    if(!m_SEHD) return;
+    Label *pLbl = m_pCurMethod->FindLabel(szHandlerFrom);
+    if(pLbl)
+    {
+        m_SEHD->sehHandler = pLbl->m_PC;
+        if(szHandlerTo)
+        {
+            pLbl = m_pCurMethod->FindLabel(szHandlerTo);
+            if(pLbl)
+            {
+                m_SEHD->sehHandlerTo = pLbl->m_PC;
+                return;
+            }
+        }
+        else
+        {
+            m_SEHD->sehHandlerTo = m_SEHD->sehHandler - 1;
+            return;
+        }
+    }
+    report->error("Undefined label in 'handler <label> to <label>'\n");
+}
+/**************************************************************************/
+void Assembler::EmitTry(void) //enum CorExceptionFlag kind, char* beginLabel, char* endLabel, char* handleLabel, char* filterOrClass)
+{
+    if(m_SEHD)
+    {
+        bool isFilter=(m_SEHD->sehClause == COR_ILEXCEPTION_CLAUSE_FILTER),
+             isFault=(m_SEHD->sehClause == COR_ILEXCEPTION_CLAUSE_FAULT),
+             isFinally=(m_SEHD->sehClause == COR_ILEXCEPTION_CLAUSE_FINALLY);
+
+        AddException(m_SEHD->tryFrom, m_SEHD->tryTo, m_SEHD->sehHandler, m_SEHD->sehHandlerTo,
+            m_SEHD->cException, isFilter, isFault, isFinally);
+    }
+    else report->error("Attempt to EmitTry with NULL SEH descriptor\n");
+}
+/**************************************************************************/
+
+void Assembler::AddException(DWORD pcStart, DWORD pcEnd, DWORD pcHandler, DWORD pcHandlerTo, mdTypeRef crException, BOOL isFilter, BOOL isFault, BOOL isFinally)
+{
+    if (m_pCurMethod == NULL)
+    {
+        report->error("Exceptions can be declared only when in a method scope\n");
+        return;
+    }
+
+    if (m_pCurMethod->m_dwNumExceptions >= m_pCurMethod->m_dwMaxNumExceptions)
+    {
+        COR_ILMETHOD_SECT_EH_CLAUSE_FAT *ptr =
+            new COR_ILMETHOD_SECT_EH_CLAUSE_FAT[m_pCurMethod->m_dwMaxNumExceptions+MAX_EXCEPTIONS];
+        if(ptr == NULL)
+        {
+            report->error("Failed to reallocate SEH buffer\n");
+            return;
+        }
+        memcpy(ptr,m_pCurMethod->m_ExceptionList,m_pCurMethod->m_dwNumExceptions*sizeof(COR_ILMETHOD_SECT_EH_CLAUSE_FAT));
+        delete [] m_pCurMethod->m_ExceptionList;
+        m_pCurMethod->m_ExceptionList = ptr;
+        m_pCurMethod->m_dwMaxNumExceptions += MAX_EXCEPTIONS;
+    }
+
+    COR_ILMETHOD_SECT_EH_CLAUSE_FAT *clause = &m_pCurMethod->m_ExceptionList[m_pCurMethod->m_dwNumExceptions];
+    clause->SetTryOffset(pcStart);
+    clause->SetTryLength(pcEnd - pcStart);
+    clause->SetHandlerOffset(pcHandler);
+    clause->SetHandlerLength(pcHandlerTo - pcHandler);
+    clause->SetClassToken(crException);
+
+    int flags = COR_ILEXCEPTION_CLAUSE_OFFSETLEN;
+    if (isFilter) {
+        flags |= COR_ILEXCEPTION_CLAUSE_FILTER;
+    }
+    if (isFault) {
+        flags |= COR_ILEXCEPTION_CLAUSE_FAULT;
+    }
+    if (isFinally) {
+        flags |= COR_ILEXCEPTION_CLAUSE_FINALLY;
+    }
+    clause->SetFlags((CorExceptionFlag)flags);
+
+    m_pCurMethod->m_dwNumExceptions++;
+}
+
+/**************************************************************************/
+void Assembler::EmitMaxStack(unsigned val)
+{
+    if(val > 0xFFFF) report->warn(".maxstack parameter exceeds 65535, truncated to %d\n",val&0xFFFF);
+    if (m_pCurMethod) m_pCurMethod->m_MaxStack = val&0xFFFF;
+    else  report->error(".maxstack can be used only within a method scope\n");
+}
+
+/**************************************************************************/
+void Assembler::EmitLocals(BinStr* sig)
+{
+    if(sig)
+    {
+        if (m_pCurMethod)
+        {
+            ARG_NAME_LIST   *pAN, *pList= getArgNameList();
+            if(pList)
+            {
+                VarDescr*       pVD;
+                for(pAN=pList; pAN; pAN = pAN->pNext)
+                {
+                    if(pAN->dwAttr == 0) pAN->dwAttr = m_pCurMethod->m_Locals.COUNT() +1;
+                    (pAN->dwAttr)--;
+                    if((pVD = m_pCurMethod->m_Locals.PEEK(pAN->dwAttr)))
+                    {
+                        if(pVD->bInScope)
+                        {
+                            report->warn("Local var slot %d is in use\n",pAN->dwAttr);
+                        }
+                        if(pVD->pbsSig && ((pVD->pbsSig->length() != pAN->pSig->length()) ||
+                            (memcmp(pVD->pbsSig->ptr(),pAN->pSig->ptr(),pVD->pbsSig->length()))))
+                        {
+                            report->error("Local var slot %d: type conflict\n",pAN->dwAttr);
+                        }
+                    }
+                    else
+                    { // create new entry:
+                        for(unsigned n = m_pCurMethod->m_Locals.COUNT(); n <= pAN->dwAttr; n++)
+                        {
+                            pVD = new VarDescr;
+                            if(pVD != NULL) m_pCurMethod->m_Locals.PUSH(pVD);
+                            else
+                            {
+                                report->error("Out of memory allocating local var descriptor\n");
+                                delete sig;
+                                return;
+                            }
+                        }
+                    }
+                    pVD->dwSlot = pAN->dwAttr;
+                    pVD->pbsSig = pAN->pSig;
+                    pVD->bInScope = TRUE;
+                }
+                if(pVD->pbsSig && (pVD->pbsSig->length() == 1))
+                {
+                    if(pVD->pbsSig->ptr()[0] == ELEMENT_TYPE_VOID)
+                        report->error("Illegal local var type: 'void'\n");
+                }
+                m_pCurMethod->m_pCurrScope->pLocals =
+                    m_pCurMethod->catArgNameList(m_pCurMethod->m_pCurrScope->pLocals, pList);
+            }
+        }
+        else    report->error(".locals can be used only within a method scope\n");
+        delete sig;
+    }
+    else report->error("Attempt to EmitLocals with NULL argument\n");
+}
+
+/**************************************************************************/
+void Assembler::EmitEntryPoint()
+{
+    if (m_pCurMethod)
+    {
+        if(!m_fEntryPointPresent)
+        {
+            if(IsMdStatic(m_pCurMethod->m_Attr))
+            {
+                m_pCurMethod->m_fEntryPoint = TRUE;
+                m_fEntryPointPresent = TRUE;
+            }
+            else report->error("Non-static method as entry point\n");
+        }
+        else report->error("Multiple .entrypoint declarations\n");
+    }
+    else report->error(".entrypoint can be used only within a method scope\n");
+}
+
+/**************************************************************************/
+void Assembler::EmitZeroInit()
+{
+    if (m_pCurMethod) m_pCurMethod->m_Flags |= CorILMethod_InitLocals;
+    else report->error(".zeroinit can be used only within a method scope\n");
+}
+
+/**************************************************************************/
+void Assembler::SetImplAttr(unsigned short attrval)
+{
+    if (m_pCurMethod)
+    {
+        if(IsMiNative(attrval)||IsMiOPTIL(attrval)||IsMiUnmanaged(attrval))
+            report->error("Cannot compile native/unmanaged method\n");
+        m_pCurMethod->m_wImplAttr = attrval;
+    }
+}
+
+/**************************************************************************/
+void Assembler::EmitData(__in_opt void *buffer, unsigned len)
+{
+    if (len != 0)
+    {
+        void* ptr;
+        HRESULT hr = m_pCeeFileGen->GetSectionBlock(m_pCurSection, len, 1, &ptr);
+        if (FAILED(hr))
+        {
+            report->error("Could not extend data section (out of memory?)");
+            exit(1);
+        }
+        
+        if (buffer != NULL)
+        {
+            memcpy(ptr, buffer, len);
+        }
+        else
+        {
+            memset(ptr, 0, len);
+        }
+    }
+}
+
+/**************************************************************************/
+void Assembler::EmitDD(__in __nullterminated char *str)
+{
+    DWORD       dwAddr = 0;
+    GlobalLabel *pLabel = FindGlobalLabel(str);
+
+    ULONG loc;
+    HRESULT hr = m_pCeeFileGen->GetSectionDataLen(m_pCurSection, &loc);
+    _ASSERTE(SUCCEEDED(hr));
+
+    DWORD* ptr;
+    DWORD sizeofptr = (DWORD)((m_dwCeeFileFlags & ICEE_CREATE_FILE_PE32) ? sizeof(DWORD) : sizeof(__int64));
+    hr = m_pCeeFileGen->GetSectionBlock(m_pCurSection, sizeofptr, 1, (void**) &ptr);
+    if (FAILED(hr))
+    {
+        report->error("Could not extend data section (out of memory?)");
+        exit(1);
+    }
+
+    if (pLabel != 0) {
+        dwAddr = pLabel->m_GlobalOffset;
+        if (pLabel->m_Section != m_pGlobalDataSection) {
+            report->error("For '&label', label must be in data section");
+            m_State = STATE_FAIL;
+            }
+        }
+    else
+        AddDeferredGlobalFixup(str, (BYTE*) ptr);
+
+    hr = m_pCeeFileGen->AddSectionReloc(m_pCurSection, loc, m_pGlobalDataSection, srRelocHighLow);
+    _ASSERTE(SUCCEEDED(hr));
+    if(m_dwCeeFileFlags & ICEE_CREATE_FILE_STRIP_RELOCS)
+    {
+        report->error("Base relocations are emitted, while /STRIPRELOC option has been specified");
+    }
+    if(m_dwCeeFileFlags & ICEE_CREATE_FILE_PE32)
+    {
+        m_dwComImageFlags &= ~COMIMAGE_FLAGS_ILONLY;
+        if (m_dwCeeFileFlags & ICEE_CREATE_MACHINE_I386)
+            COR_SET_32BIT_REQUIRED(m_dwComImageFlags);
+        *ptr = dwAddr;
+    }
+    else
+    {
+        m_dwComImageFlags &= ~COMIMAGE_FLAGS_ILONLY;
+        *((__int64*)ptr) = (__int64)dwAddr;
+    }
+}
+
+/**************************************************************************/
+GlobalLabel *Assembler::FindGlobalLabel(LPCUTF8 pszName)
+{
+    GlobalLabel lSearch(pszName,0,NULL), *pL;
+    pL =  m_lstGlobalLabel.FIND(&lSearch);
+    lSearch.m_szName = NULL;
+    return pL;
+    //return  m_lstGlobalLabel.FIND(pszName);
+}
+
+/**************************************************************************/
+
+GlobalFixup *Assembler::AddDeferredGlobalFixup(__in __nullterminated char *pszLabel, BYTE* pReference)
+{
+    GlobalFixup *pNew = new GlobalFixup(pszLabel, (BYTE*) pReference);
+    if (pNew == NULL)
+    {
+        report->error("Failed to allocate global fixup\n");
+        m_State = STATE_FAIL;
+    }
+    else
+        m_lstGlobalFixup.PUSH(pNew);
+
+    return pNew;
+}
+
+/**************************************************************************/
+void Assembler::AddDeferredILFixup(ILFixupType Kind)
+{
+    _ASSERTE(Kind != ilGlobal);
+  AddDeferredILFixup(Kind, NULL);
+}
+/**************************************************************************/
+
+void Assembler::AddDeferredILFixup(ILFixupType Kind,
+                                   GlobalFixup *GFixup)
+{
+    ILFixup *pNew = new ILFixup(m_CurPC, Kind, GFixup);
+
+    _ASSERTE(m_pCurMethod != NULL);
+    if (pNew == NULL)
+    {
+        report->error("Failed to allocate IL fixup\n");
+        m_State = STATE_FAIL;
+    }
+    else
+        m_pCurMethod->m_lstILFixup.PUSH(pNew);
+}
+
+/**************************************************************************/
+void Assembler::EmitDataString(BinStr* str)
+{
+    if(str)
+    {
+        str->appendInt8(0);
+        DWORD   DataLen = str->length();
+        char    *pb = (char*)(str->ptr());
+        WCHAR   *UnicodeString = (DataLen >= dwUniBuf) ? new WCHAR[DataLen] : &wzUniBuf[0];
+
+        if(UnicodeString)
+        {
+            WszMultiByteToWideChar(g_uCodePage,0,pb,-1,UnicodeString,DataLen);
+            EmitData(UnicodeString,DataLen*sizeof(WCHAR));
+            if(DataLen >= dwUniBuf) delete [] UnicodeString;
+        }
+        else report->error("\nOut of memory!\n");
+        delete str;
+    }
+}
+
+
+
+/**************************************************************************/
+unsigned Assembler::OpcodeLen(Instr* instr)
+{
+    return (m_fStdMapping ? OpcodeInfo[instr->opcode].Len : 3);
+}
+/**************************************************************************/
+void Assembler::EmitOpcode(Instr* instr)
+{
+    if(m_fGeneratePDB &&
+       ((instr->linenum != m_ulLastDebugLine)
+        ||(instr->column != m_ulLastDebugColumn)
+        ||(instr->linenum_end != m_ulLastDebugLineEnd)
+        ||(instr->column_end != m_ulLastDebugColumnEnd)))
+    {
+        if(m_pCurMethod)
+        {
+            LinePC *pLPC = new LinePC;
+            if(pLPC)
+            {
+                pLPC->Line = instr->linenum;
+                pLPC->Column = instr->column;
+                pLPC->LineEnd = instr->linenum_end;
+                pLPC->ColumnEnd = instr->column_end;
+                pLPC->PC = m_CurPC;
+                pLPC->pWriter = instr->pWriter;
+                m_pCurMethod->m_LinePCList.PUSH(pLPC);
+            }
+            else report->error("\nOut of memory!\n");
+        }
+        m_ulLastDebugLine = instr->linenum;
+        m_ulLastDebugColumn = instr->column;
+        m_ulLastDebugLineEnd = instr->linenum_end;
+        m_ulLastDebugColumnEnd = instr->column_end;
+    }
+    if(instr->opcode == CEE_ENDFILTER)
+    {
+        if(m_pCurMethod)
+        {
+            if(m_pCurMethod->m_dwNumEndfilters >= m_pCurMethod->m_dwMaxNumEndfilters)
+            {
+                DWORD *pdw = new DWORD[m_pCurMethod->m_dwMaxNumEndfilters+MAX_EXCEPTIONS];
+                if(pdw == NULL)
+                {
+                    report->error("Failed to reallocate auxiliary SEH buffer\n");
+                    instr->opcode = -1;
+                    return;
+                }
+                memcpy(pdw,m_pCurMethod->m_EndfilterOffsetList,m_pCurMethod->m_dwNumEndfilters*sizeof(DWORD));
+                delete m_pCurMethod->m_EndfilterOffsetList;
+                m_pCurMethod->m_EndfilterOffsetList = pdw;
+                m_pCurMethod->m_dwMaxNumEndfilters += MAX_EXCEPTIONS;
+            }
+            m_pCurMethod->m_EndfilterOffsetList[m_pCurMethod->m_dwNumEndfilters++] = m_CurPC+2;
+        }
+    }
+    if (m_fStdMapping)
+    {
+        if (OpcodeInfo[instr->opcode].Len == 2)
+            EmitByte(OpcodeInfo[instr->opcode].Std1);
+        EmitByte(OpcodeInfo[instr->opcode].Std2);
+    }
+    else
+    {
+        unsigned short us = (unsigned short)instr->opcode;
+        EmitByte(REFPRE);
+        EmitBytes((BYTE *)&us,2);
+    }
+    instr->opcode = -1;
+}
+
+/**************************************************************************/
+//void Assembler::OptimizeInstr(Instr* instr, int var)
+//{
+
+//}
+/**************************************************************************/
+unsigned Assembler::ShortOf(unsigned opcode)
+{
+    unsigned retcode;
+    switch(opcode)
+    {
+        case CEE_LDARG:     retcode=CEE_LDARG_S;    break;
+        case CEE_LDARGA:    retcode=CEE_LDARGA_S;   break;
+        case CEE_STARG:     retcode=CEE_STARG_S;    break;
+
+        case CEE_LDLOC:     retcode=CEE_LDLOC_S;    break;
+        case CEE_LDLOCA:    retcode=CEE_LDLOCA_S;   break;
+        case CEE_STLOC:     retcode=CEE_STLOC_S;    break;
+
+        case CEE_BR:        retcode=CEE_BR_S;       break;
+        case CEE_BRFALSE:   retcode=CEE_BRFALSE_S;  break;
+        case CEE_BRTRUE:    retcode=CEE_BRTRUE_S;   break;
+        case CEE_BEQ:       retcode=CEE_BEQ_S;      break;
+        case CEE_BGE:       retcode=CEE_BGE_S;      break;
+        case CEE_BGT:       retcode=CEE_BGT_S;      break;
+        case CEE_BLE:       retcode=CEE_BLE_S;      break;
+        case CEE_BLT:       retcode=CEE_BLT_S;      break;
+        case CEE_BNE_UN:    retcode=CEE_BNE_UN_S;   break;
+        case CEE_BGE_UN:    retcode=CEE_BGE_UN_S;   break;
+        case CEE_BGT_UN:    retcode=CEE_BGT_UN_S;   break;
+        case CEE_BLE_UN:    retcode=CEE_BLE_UN_S;   break;
+        case CEE_BLT_UN:    retcode=CEE_BLT_UN_S;   break;
+        case CEE_LEAVE:     retcode=CEE_LEAVE_S;    break;
+
+        case CEE_LDC_I4:    retcode=CEE_LDC_I4_S;   break;
+        case CEE_LDC_R8:    retcode=CEE_LDC_R4;     break;
+
+
+        default: retcode = opcode;  break;
+    }
+    return retcode;
+}
+
+/**************************************************************************/
+void Assembler::EmitInstrVar(Instr* instr, int var)
+{
+    unsigned opc = instr->opcode;
+    if(m_fOptimize)
+    {
+        if(var < 4)
+        {
+            switch(opc)
+            {
+                case CEE_LDARG:
+                case CEE_LDARG_S: opc = CEE_LDARG_0 + var; break;
+
+                case CEE_LDLOC:
+                case CEE_LDLOC_S: opc = CEE_LDLOC_0 + var; break;
+
+                case CEE_STLOC:
+                case CEE_STLOC_S: opc = CEE_STLOC_0 + var; break;
+
+                default: break;
+            }
+            if(opc != (unsigned) instr->opcode)
+            {
+                instr->opcode = opc;
+                EmitOpcode(instr);
+                return;
+            }
+        }
+        if(var <= 0xFF)
+        {
+            opc = instr->opcode = ShortOf(opc);
+        }
+    }
+    EmitOpcode(instr);
+    if (isShort(opc))
+    {
+        EmitByte(var);
+    }
+    else
+    {
+        short sh = (short)var;
+        EmitBytes((BYTE *)&sh,2);
+    }
+}
+
+/**************************************************************************/
+void Assembler::EmitInstrVarByName(Instr* instr, __in __nullterminated char* label)
+{
+    int idx = -1, nArgVarFlag=0;
+    switch(instr->opcode)
+    {
+        case CEE_LDARGA:
+        case CEE_LDARGA_S:
+        case CEE_LDARG:
+        case CEE_LDARG_S:
+        case CEE_STARG:
+        case CEE_STARG_S:
+            nArgVarFlag++;
+        case CEE_LDLOCA:
+        case CEE_LDLOCA_S:
+        case CEE_LDLOC:
+        case CEE_LDLOC_S:
+        case CEE_STLOC:
+        case CEE_STLOC_S:
+
+            if(m_pCurMethod)
+            {
+                DWORD L = (DWORD)strlen(label);
+                if(nArgVarFlag == 1)
+                {
+                    idx = m_pCurMethod->findArgNum(m_pCurMethod->m_firstArgName,label,L);
+                }
+                else
+                {
+                    for(Scope* pSC = m_pCurMethod->m_pCurrScope; pSC; pSC=pSC->pSuperScope)
+                    {
+                        idx = m_pCurMethod->findLocSlot(pSC->pLocals,label,L);
+                        if(idx >= 0) break;
+                    }
+                }
+                if(idx >= 0) EmitInstrVar(instr,
+                    ((nArgVarFlag==0)||(m_pCurMethod->m_Attr & mdStatic))? idx : idx+1);
+                else    report->error("Undeclared identifier %s\n",label);
+            }
+            else
+                report->error("Instructions can be used only when in a method scope\n");
+            break;
+        default:
+            report->error("Named argument illegal for this instruction\n");
+    }
+    instr->opcode = -1; // in case we got here with error
+}
+
+/**************************************************************************/
+void Assembler::EmitInstrI(Instr* instr, int val)
+{
+    int opc = instr->opcode;
+    if(m_fOptimize)
+    {
+        if((val >= -1)&&(val <= 8))
+        {
+            switch(opc)
+            {
+                case CEE_LDC_I4:
+                case CEE_LDC_I4_S: opc = CEE_LDC_I4_M1 + (val+1); break;
+
+                default: break;
+            }
+            if(opc != instr->opcode)
+            {
+                instr->opcode = opc;
+                EmitOpcode(instr);
+                return;
+            }
+        }
+        if((-128 <= val)&&(val <= 127))
+        {
+            opc = instr->opcode = ShortOf(opc);
+        }
+    }
+    EmitOpcode(instr);
+    if (isShort(opc))
+    {
+        EmitByte(val);
+    }
+    else
+    {
+        int i = val;
+        EmitBytes((BYTE *)&i,sizeof(int));
+    }
+}
+
+/**************************************************************************/
+void Assembler::EmitInstrI8(Instr* instr, __int64* val)
+{
+    EmitOpcode(instr);
+    EmitBytes((BYTE *)val, sizeof(__int64));
+    delete val;
+}
+
+/**************************************************************************/
+void Assembler::EmitInstrR(Instr* instr, double* pval)
+{
+    unsigned opc = instr->opcode;
+    EmitOpcode(instr);
+    if (isShort(opc))
+    {
+        float val = (float)*pval;
+        EmitBytes((BYTE *)&val, sizeof(float));
+    }
+    else
+        EmitBytes((BYTE *)pval, sizeof(double));
+}
+
+/**************************************************************************/
+void Assembler::EmitInstrBrTarget(Instr* instr, __in __nullterminated char* label)
+{
+    Label * pLabel = m_pCurMethod->FindLabel(label);
+    int offset=0;
+    if (pLabel == NULL) // branching forward -- no optimization
+    {
+        int pcrelsize = 1+(isShort(instr->opcode) ? 1 : 4); //size of the instruction plus argument
+        AddDeferredFixup(label, m_pCurOutputPos+1,
+                                       (m_CurPC + pcrelsize), pcrelsize-1);
+    }
+    else
+    {
+        offset = pLabel->m_PC - m_CurPC;
+        if(m_fOptimize)
+        {
+            if((-128 <= offset-5)&&(offset-2 <= 127)) //need to take into account the argument size (worst cases)
+            {
+                instr->opcode = ShortOf(instr->opcode);
+            }
+        }
+        if(isShort(instr->opcode))
+        {
+            offset -= 2;
+            if((-128 > offset)||(offset > 127))
+                report->error("Offset too large for short branching instruction, truncated\n");
+        }
+        else
+            offset -= 5;
+        delete [] label;
+    }
+    int opc = instr->opcode;
+    EmitOpcode(instr);
+    if(isShort(opc))  EmitByte(offset);
+    else              EmitBytes((BYTE *)&offset,4);
+}
+/**************************************************************************/
+void Assembler::AddDeferredFixup(__in __nullterminated char *pszLabel, BYTE *pBytes, DWORD RelativeToPC, BYTE FixupSize)
+{
+    Fixup *pNew = new Fixup(pszLabel, pBytes, RelativeToPC, FixupSize);
+
+    if (pNew == NULL)
+    {
+        report->error("Failed to allocate deferred fixup\n");
+        m_State = STATE_FAIL;
+    }
+    else
+        m_pCurMethod->m_lstFixup.PUSH(pNew);
+}
+/**************************************************************************/
+void Assembler::EmitInstrBrOffset(Instr* instr, int offset)
+{
+    unsigned opc=instr->opcode;
+    if(m_fOptimize)
+    {
+        if((-128 >= offset)&&(offset <= 127))
+        {
+            opc = instr->opcode = ShortOf(opc);
+        }
+    }
+    EmitOpcode(instr);
+    if(isShort(opc))    EmitByte(offset);
+    else
+    {
+        int i = offset;
+        EmitBytes((BYTE *)&i,4);
+    }
+}
+
+/**************************************************************************/
+mdToken Assembler::MakeMemberRef(mdToken cr, __in __nullterminated char* pszMemberName, BinStr* sig)
+{
+    DWORD           cSig = sig->length();
+    COR_SIGNATURE*  mySig = (COR_SIGNATURE *)(sig->ptr());
+    mdToken         mr = mdMemberRefNil;
+    Class*          pClass = NULL;
+    if(cr == 0x00000001) cr = mdTokenNil; // Module -> nil for globals
+    if(TypeFromToken(cr) == mdtTypeDef) pClass = m_lstClass.PEEK(RidFromToken(cr)-1);
+    if((TypeFromToken(cr) == mdtTypeDef)||(cr == mdTokenNil))
+    {
+        MemberRefDescriptor* pMRD = new MemberRefDescriptor;
+        if(pMRD)
+        {
+            pMRD->m_tdClass = cr;
+            pMRD->m_pClass = pClass;
+            pMRD->m_szName = pszMemberName;
+            pMRD->m_dwName = (DWORD)strlen(pszMemberName);
+            pMRD->m_pSigBinStr = sig;
+            pMRD->m_tkResolved = 0;
+            if(*(sig->ptr())== IMAGE_CEE_CS_CALLCONV_FIELD)
+            {
+                m_LocalFieldRefDList.PUSH(pMRD);
+                mr = 0x98000000 | m_LocalFieldRefDList.COUNT();
+            }
+            else
+            {
+                m_LocalMethodRefDList.PUSH(pMRD);
+                mr = 0x99000000 | m_LocalMethodRefDList.COUNT();
+            }
+        }
+        else
+        {
+            report->error("Failed to allocate MemberRef Descriptor\n");
+            return 0;
+        }
+    }
+    else
+    {
+        WszMultiByteToWideChar(g_uCodePage,0,pszMemberName,-1,wzUniBuf,dwUniBuf);
+
+        if(cr == mdTokenNil) cr = mdTypeRefNil;
+        if(TypeFromToken(cr) == mdtAssemblyRef)
+        {
+            report->error("Cross-assembly global references are not supported ('%s')\n", pszMemberName);
+            mr = 0;
+        }
+        else
+        {
+            HRESULT hr = m_pEmitter->DefineMemberRef(cr, wzUniBuf, mySig, cSig, &mr);
+            if(FAILED(hr))
+            {
+                report->error("Unable to define member reference '%s'\n", pszMemberName);
+                mr = 0;
+            }
+        }
+        //if(m_fOBJ)    m_pCurMethod->m_TRDList.PUSH(new TokenRelocDescr(m_CurPC,mr));
+        delete pszMemberName;
+        delete sig;
+    }
+    return mr;
+}
+/**************************************************************************/
+void Assembler::SetMemberRefFixup(mdToken tk, unsigned opcode_len)
+{
+    if(opcode_len)
+    {
+        switch(TypeFromToken(tk))
+        {
+            case 0x98000000:
+            case 0x99000000:
+            case 0x9A000000:
+                if(m_pCurMethod != NULL)
+                    m_pCurMethod->m_LocalMemberRefFixupList.PUSH(
+                            new LocalMemberRefFixup(tk,(size_t)(m_CurPC + opcode_len)));
+                break;
+        }
+    }
+}
+
+/**************************************************************************/
+mdToken Assembler::MakeMethodSpec(mdToken tkParent, BinStr* sig)
+{
+    DWORD           cSig = sig->length();
+    COR_SIGNATURE*  mySig = (COR_SIGNATURE *)(sig->ptr());
+    mdMethodSpec mi = mdMethodSpecNil;
+    if(TypeFromToken(tkParent) == 0x99000000) // Local MemberRef: postpone until resolved
+    {
+        MemberRefDescriptor* pMRD = new MemberRefDescriptor;
+        if(pMRD)
+        {
+            memset(pMRD,0,sizeof(MemberRefDescriptor));
+            pMRD->m_tdClass = tkParent;
+            pMRD->m_pSigBinStr = sig;
+            m_MethodSpecList.PUSH(pMRD);
+            mi = 0x9A000000 | m_MethodSpecList.COUNT();
+        }
+        else
+        {
+            report->error("Failed to allocate MemberRef Descriptor\n");
+            return 0;
+        }
+    }
+    else
+    {
+        HRESULT hr = m_pEmitter->DefineMethodSpec(tkParent, mySig, cSig, &mi);
+        if(FAILED(hr))
+        {
+            report->error("Unable to define method instantiation");
+            return 0;
+        }
+    }
+    return mi;
+}
+
+/**************************************************************************/
+void Assembler::EndEvent(void)
+{
+    Class* pClass = (m_pCurClass ? m_pCurClass : m_pModuleClass);
+    if(m_pCurEvent->m_tkAddOn == 0)
+        report->error("Event %s of class %s has no Add method. Event not emitted.",
+                      m_pCurEvent->m_szName,pClass->m_szFQN);
+    else if(m_pCurEvent->m_tkRemoveOn == 0)
+        report->error("Event %s of class %s has no Remove method. Event not emitted.",
+                      m_pCurEvent->m_szName,pClass->m_szFQN);
+    else
+    {
+        pClass->m_EventDList.PUSH(m_pCurEvent);
+        pClass->m_fNewMembers = TRUE;
+    }
+    m_pCurEvent = NULL;
+    m_tkCurrentCVOwner = 0;
+    m_pCustomDescrList = m_CustomDescrListStack.POP();
+}
+
+void Assembler::ResetEvent(__inout_z __inout char* szName, mdToken typeSpec, DWORD dwAttr)
+{
+    if(strlen(szName) >= MAX_CLASSNAME_LENGTH)
+    {
+        char c = szName[MAX_CLASSNAME_LENGTH-1];
+        szName[MAX_CLASSNAME_LENGTH-1] = 0;
+        report->error("Event '%s...' -- name too long (%d characters).\n",szName,strlen(szName));
+        szName[MAX_CLASSNAME_LENGTH-1] = c;
+    }
+    if((m_pCurEvent = new EventDescriptor))
+    {
+        memset(m_pCurEvent,0,sizeof(EventDescriptor));
+        m_pCurEvent->m_tdClass = m_pCurClass->m_cl;
+        m_pCurEvent->m_szName = szName;
+        m_pCurEvent->m_dwAttr = dwAttr;
+        m_pCurEvent->m_tkEventType = typeSpec;
+        m_pCurEvent->m_fNew = TRUE;
+        m_tkCurrentCVOwner = 0;
+        m_CustomDescrListStack.PUSH(m_pCustomDescrList);
+        m_pCustomDescrList = &(m_pCurEvent->m_CustomDescrList);
+    }
+    else report->error("Failed to allocate Event Descriptor\n");
+}
+
+void Assembler::SetEventMethod(int MethodCode, mdToken tk)
+{
+    switch(MethodCode)
+    {
+        case 0:
+            m_pCurEvent->m_tkAddOn = tk;
+            break;
+        case 1:
+            m_pCurEvent->m_tkRemoveOn = tk;
+            break;
+        case 2:
+            m_pCurEvent->m_tkFire = tk;
+            break;
+        case 3:
+            m_pCurEvent->m_tklOthers.PUSH((mdToken*)(UINT_PTR)tk);
+            break;
+    }
+}
+/**************************************************************************/
+
+void Assembler::EndProp(void)
+{
+    Class* pClass = (m_pCurClass ? m_pCurClass : m_pModuleClass);
+    pClass->m_PropDList.PUSH(m_pCurProp);
+    pClass->m_fNewMembers = TRUE;
+    m_pCurProp = NULL;
+    m_tkCurrentCVOwner = 0;
+    m_pCustomDescrList = m_CustomDescrListStack.POP();
+}
+
+void Assembler::ResetProp(__inout_z __inout char * szName, BinStr* bsType, DWORD dwAttr, BinStr* pValue)
+{
+    DWORD           cSig = bsType->length();
+    COR_SIGNATURE*  mySig = (COR_SIGNATURE *)(bsType->ptr());
+
+    if(strlen(szName) >= MAX_CLASSNAME_LENGTH)
+    {
+        char c = szName[MAX_CLASSNAME_LENGTH-1];
+        szName[MAX_CLASSNAME_LENGTH-1] = 0;
+        report->error("Property '%s...' -- name too long (%d characters).\n",szName,strlen(szName));
+        szName[MAX_CLASSNAME_LENGTH-1] = c;
+    }
+    m_pCurProp = new PropDescriptor;
+    if(m_pCurProp == NULL)
+    {
+        report->error("Failed to allocate Property Descriptor\n");
+        return;
+    }
+    memset(m_pCurProp,0,sizeof(PropDescriptor));
+    m_pCurProp->m_tdClass = m_pCurClass->m_cl;
+    m_pCurProp->m_szName = szName;
+    m_pCurProp->m_dwAttr = dwAttr;
+    m_pCurProp->m_fNew = TRUE;
+
+    m_pCurProp->m_pSig = new COR_SIGNATURE[cSig];
+    if(m_pCurProp->m_pSig == NULL)
+    {
+        report->error("\nOut of memory!\n");
+        return;
+    }
+    memcpy(m_pCurProp->m_pSig,mySig,cSig);
+    m_pCurProp->m_dwCSig = cSig;
+
+    if(pValue && pValue->length())
+    {
+        BYTE* pch = pValue->ptr();
+        m_pCurProp->m_dwCPlusTypeFlag = (DWORD)(*pch);
+        m_pCurProp->m_cbValue = pValue->length() - 1;
+        m_pCurProp->m_pValue = (PVOID)(pch+1);
+        if(m_pCurProp->m_dwCPlusTypeFlag == ELEMENT_TYPE_STRING) m_pCurProp->m_cbValue /= sizeof(WCHAR);
+        m_pCurProp->m_dwAttr |= prHasDefault;
+    }
+    else
+    {
+        m_pCurProp->m_dwCPlusTypeFlag = ELEMENT_TYPE_VOID;
+        m_pCurProp->m_pValue = NULL;
+        m_pCurProp->m_cbValue = 0;
+    }
+    m_tkCurrentCVOwner = 0;
+    m_CustomDescrListStack.PUSH(m_pCustomDescrList);
+    m_pCustomDescrList = &(m_pCurProp->m_CustomDescrList);
+}
+
+void Assembler::SetPropMethod(int MethodCode, mdToken tk)
+{
+    switch(MethodCode)
+    {
+        case 0:
+            m_pCurProp->m_tkSet = tk;
+            break;
+        case 1:
+            m_pCurProp->m_tkGet = tk;
+            break;
+        case 2:
+            m_pCurProp->m_tklOthers.PUSH((mdToken*)(UINT_PTR)tk);
+            break;
+    }
+}
+
+/**************************************************************************/
+void Assembler::EmitInstrStringLiteral(Instr* instr, BinStr* literal, BOOL ConvertToUnicode, BOOL Swap /*=FALSE*/)
+{
+    DWORD   DataLen = literal->length(),L;
+    unsigned __int8 *pb = literal->ptr();
+    HRESULT hr = S_OK;
+    mdToken tk;
+    WCHAR   *UnicodeString;
+    if(DataLen == 0)
+    {
+        //report->warn("Zero length string emitted\n");
+        ConvertToUnicode = FALSE;
+    }
+    if(ConvertToUnicode)
+    {
+        UnicodeString = (DataLen >= dwUniBuf) ? new WCHAR[DataLen+1] : &wzUniBuf[0];
+        literal->appendInt8(0);
+        pb = literal->ptr();
+        // convert string to Unicode
+        L = UnicodeString ? WszMultiByteToWideChar(g_uCodePage,0,(char*)pb,-1,UnicodeString,DataLen+1) : 0;
+        if(L == 0)
+        {
+            char* sz=NULL;
+            DWORD dw;
+            switch(dw=GetLastError())
+            {
+                case ERROR_INSUFFICIENT_BUFFER: sz = "ERROR_INSUFFICIENT_BUFFER"; break;
+                case ERROR_INVALID_FLAGS:       sz = "ERROR_INVALID_FLAGS"; break;
+                case ERROR_INVALID_PARAMETER:   sz = "ERROR_INVALID_PARAMETER"; break;
+                case ERROR_NO_UNICODE_TRANSLATION: sz = "ERROR_NO_UNICODE_TRANSLATION"; break;
+            }
+            if(sz)  report->error("Failed to convert string '%s' to Unicode: %s\n",(char*)pb,sz);
+            else    report->error("Failed to convert string '%s' to Unicode: error 0x%08X\n",(char*)pb,dw);
+            delete instr;
+            goto OuttaHere;
+        }
+        L--;
+    }
+    else
+    {
+        if(DataLen & 1)
+        {
+            literal->appendInt8(0);
+            pb = literal->ptr();
+            DataLen++;
+        }
+        UnicodeString = (WCHAR*)pb;
+        L = DataLen/sizeof(WCHAR);
+
+#if BIGENDIAN
+        if (Swap)
+            SwapStringLength(UnicodeString, L);
+#endif
+    }
+    // Add the string data to the metadata, which will fold dupes.
+    hr = m_pEmitter->DefineUserString(
+        UnicodeString,
+        L,
+        &tk
+    );
+    if (FAILED(hr))
+    {
+        report->error("Failed to add user string using DefineUserString, hr=0x%08x, data: '%S'\n",
+               hr, UnicodeString);
+        delete instr;
+    }
+    else
+    {
+        EmitOpcode(instr);
+        if(m_fOBJ)  m_pCurMethod->m_TRDList.PUSH(new TokenRelocDescr(m_CurPC,tk));
+
+        EmitBytes((BYTE *)&tk,sizeof(mdToken));
+    }
+OuttaHere:
+    delete literal;
+    if(((void*)UnicodeString != (void*)pb)&&(DataLen >= dwUniBuf)) delete [] UnicodeString;
+    instr->opcode = -1; // in case we got here with error
+}
+
+/**************************************************************************/
+void Assembler::EmitInstrSig(Instr* instr, BinStr* sig)
+{
+    mdSignature MetadataToken;
+    DWORD       cSig = sig->length();
+    COR_SIGNATURE* mySig = (COR_SIGNATURE *)(sig->ptr());
+
+    if (FAILED(m_pEmitter->GetTokenFromSig(mySig, cSig, &MetadataToken)))
+    {
+        report->error("Unable to convert signature to metadata token.\n");
+        delete instr;
+    }
+    else
+    {
+        EmitOpcode(instr);
+        if(m_fOBJ)  m_pCurMethod->m_TRDList.PUSH(new TokenRelocDescr(m_CurPC,MetadataToken));
+        EmitBytes((BYTE *)&MetadataToken, sizeof(mdSignature));
+    }
+    delete sig;
+    instr->opcode = -1; // in case we got here with error
+}
+
+/**************************************************************************/
+void Assembler::EmitInstrSwitch(Instr* instr, Labels* targets)
+{
+    Labels  *pLbls;
+    int     NumLabels;
+    Label   *pLabel;
+    long    offset;
+
+    EmitOpcode(instr);
+
+    // count # labels
+    for(pLbls = targets, NumLabels = 0; pLbls; pLbls = pLbls->Next, NumLabels++);
+
+    EmitBytes((BYTE *)&NumLabels,sizeof(int));
+    DWORD PC_nextInstr = m_CurPC + 4*NumLabels;
+    for(pLbls = targets; pLbls; pLbls = pLbls->Next)
+    {
+        if(pLbls->isLabel)
+        {
+            if((pLabel = m_pCurMethod->FindLabel(pLbls->Label)))
+            {
+                offset = pLabel->m_PC - PC_nextInstr;
+                if (m_fDisplayTraceOutput) report->msg("%d\n", offset);
+            }
+            else
+            {
+                // defer until we find the label
+                AddDeferredFixup(pLbls->Label, m_pCurOutputPos, PC_nextInstr, 4 /* pcrelsize */ );
+                offset = 0;
+                pLbls->Label = NULL;
+                if (m_fDisplayTraceOutput) report->msg("forward label %s\n", pLbls->Label);
+            }
+        }
+        else
+        {
+            offset = (long)(UINT_PTR)pLbls->Label;
+            if (m_fDisplayTraceOutput) report->msg("%d\n", offset);
+        }
+        EmitBytes((BYTE *)&offset, sizeof(long));
+    }
+    delete targets;
+}
+
+/**************************************************************************/
+void Assembler::EmitLabel(__in __nullterminated char* label)
+{
+    _ASSERTE(m_pCurMethod);
+    AddLabel(m_CurPC, label);
+}
+/**************************************************************************/
+void Assembler::EmitDataLabel(__in __nullterminated char* label)
+{
+    AddGlobalLabel(label, m_pCurSection);
+}
+
+/**************************************************************************/
+void Assembler::EmitBytes(BYTE *p, unsigned len)
+{
+    if(m_pCurOutputPos + len >= m_pEndOutputPos)
+    {
+        size_t buflen = m_pEndOutputPos - m_pOutputBuffer;
+        size_t newlen = buflen+(len/OUTPUT_BUFFER_INCREMENT + 1)*OUTPUT_BUFFER_INCREMENT;
+        BYTE *pb = new BYTE[newlen];
+        if(pb == NULL)
+        {
+            report->error("Failed to extend output buffer from %d to %d bytes. Aborting\n",
+                buflen, newlen);
+            exit(1);
+        }
+        size_t delta = pb - m_pOutputBuffer;
+        int i;
+        Fixup* pSearch;
+        GlobalFixup *pGSearch;
+        for (i=0; (pSearch = m_pCurMethod->m_lstFixup.PEEK(i)); i++) pSearch->m_pBytes += delta;
+        for (i=0; (pGSearch = m_lstGlobalFixup.PEEK(i)); i++) //need to move only those pointing to output buffer
+        {
+            if((pGSearch->m_pReference >= m_pOutputBuffer)&&(pGSearch->m_pReference <= m_pEndOutputPos))
+                pGSearch->m_pReference += delta;
+        }
+
+
+        memcpy(pb,m_pOutputBuffer,m_CurPC);
+        delete m_pOutputBuffer;
+        m_pOutputBuffer = pb;
+        m_pCurOutputPos = &m_pOutputBuffer[m_CurPC];
+        m_pEndOutputPos = &m_pOutputBuffer[newlen];
+
+    }
+
+    switch (len)
+    {
+    case 1:
+        *m_pCurOutputPos = *p;
+        break;
+    case 2:
+        SET_UNALIGNED_VAL16(m_pCurOutputPos, GET_UNALIGNED_16(p));
+        break;
+    case 4:
+        SET_UNALIGNED_VAL32(m_pCurOutputPos, GET_UNALIGNED_32(p));
+        break;
+    case 8:
+        SET_UNALIGNED_VAL64(m_pCurOutputPos, GET_UNALIGNED_64(p));
+        break;
+    default:
+        _ASSERTE(!"NYI");
+        break;
+    }
+
+    m_pCurOutputPos += len;
+    m_CurPC += len;
+}
+/**************************************************************************/
+BinStr* Assembler::EncodeSecAttr(__in __nullterminated char* szReflName, BinStr* pbsSecAttrBlob, unsigned nProps)
+{
+    unsigned cnt;
+#if (0)
+    // Emit MemberRef for .ctor
+    mdToken tkMscorlib = m_fIsMscorlib ? 1 : GetAsmRef("mscorlib");
+    char buffer[64];
+    BinStr  *pbsSig = new BinStr();
+
+    strcpy(buffer,"System.Security.Permissions.SecurityAction");
+    mdToken tkSecAction = ResolveClassRef(tkMscorlib,buffer, NULL);
+
+    pbsSig->appendInt8(IMAGE_CEE_CS_CALLCONV_HASTHIS);
+    pbsSig->appendInt8(1); //corEmitInt(pbsSig,1);
+    pbsSig->appendInt8(ELEMENT_TYPE_VOID);
+    pbsSig->appendInt8(ELEMENT_TYPE_VALUETYPE);
+    cnt = CorSigCompressToken(tkSecAction, pbsSig->getBuff(5));
+    pbsSig->remove(5 - cnt);
+    
+    char* szName = new char[16];
+    strcpy(szName,".ctor");
+    MakeMemberRef(tkSecAttr,szName,pbsSig);
+#endif
+
+    // build the blob As BinStr
+    unsigned L = (unsigned) strlen(szReflName);
+    BYTE* pb = NULL;
+    BinStr* pbsRet = new BinStr();
+    // encode the Reflection name length
+    cnt = CorSigCompressData(L, pbsRet->getBuff(5));
+    pbsRet->remove(5 - cnt);
+    //put the name in
+    if((pb = pbsRet->getBuff(L)) != NULL)
+        memcpy(pb,szReflName,L);
+    // find out the size of compressed nProps
+    cnt = CorSigCompressData(nProps, pbsRet->getBuff(5)); 
+    pbsRet->remove(5);
+    // encode blob size
+    unsigned nSize = cnt + pbsSecAttrBlob->length();
+    cnt = CorSigCompressData(nSize, pbsRet->getBuff(5));  
+    pbsRet->remove(5 - cnt);
+    // actually encode nProps
+    cnt = CorSigCompressData(nProps, pbsRet->getBuff(5));  
+    pbsRet->remove(5 - cnt);
+    // append the props/values blob
+    pbsRet->append(pbsSecAttrBlob);
+    delete pbsSecAttrBlob;
+    return pbsRet;
+}
+/**************************************************************************/
+void Assembler::EmitSecurityInfo(mdToken            token,
+                                 PermissionDecl*    pPermissions,
+                                 PermissionSetDecl* pPermissionSets)
+{
+    PermissionDecl     *pPerm, *pPermNext;
+    PermissionSetDecl  *pPset, *pPsetNext;
+    unsigned            uCount = 0;
+    COR_SECATTR        *pAttrs;
+    unsigned            i;
+    unsigned            uLength;
+    mdTypeRef           tkTypeRef;
+    BinStr             *pSig;
+    char               *szMemberName;
+    DWORD               dwErrorIndex;
+
+    if (pPermissions) {
+
+        for (pPerm = pPermissions; pPerm; pPerm = pPerm->m_Next)
+            uCount++;
+
+        _ASSERTE(uCount > 0);
+        // uCount is expected to be positive all the time. The if statement is here to please prefast.
+        if (uCount > 0)
+        {
+            if((pAttrs = new COR_SECATTR[uCount])==NULL)
+            {
+                report->error("\nOut of memory!\n");
+                return;
+            }
+
+            mdToken tkMscorlib = m_fIsMscorlib ? 1 : GetAsmRef("mscorlib");
+            tkTypeRef = ResolveClassRef(tkMscorlib,"System.Security.Permissions.SecurityAction", NULL);
+            for (pPerm = pPermissions, i = 0; pPerm; pPerm = pPermNext, i++) {
+                pPermNext = pPerm->m_Next;
+
+                pSig = new BinStr();
+                pSig->appendInt8(IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS);
+                pSig->appendInt8(1);
+                pSig->appendInt8(ELEMENT_TYPE_VOID);
+                pSig->appendInt8(ELEMENT_TYPE_VALUETYPE);
+                uLength = CorSigCompressToken(tkTypeRef, pSig->getBuff(5));
+                pSig->remove(5 - uLength);
+
+                uLength = (unsigned)strlen(COR_CTOR_METHOD_NAME) + 1;
+                if((szMemberName = new char[uLength]))
+                {
+                    memcpy(szMemberName, COR_CTOR_METHOD_NAME, uLength);
+                    pAttrs[i].tkCtor = MakeMemberRef(pPerm->m_TypeSpec, szMemberName, pSig);
+                    pAttrs[i].pCustomAttribute = (const void *)pPerm->m_Blob;
+                    pAttrs[i].cbCustomAttribute = pPerm->m_BlobLength;
+                }
+                else report->error("\nOut of memory!\n");
+            }
+
+            if (FAILED(m_pEmitter->DefineSecurityAttributeSet(token,
+                                                       pAttrs,
+                                                       uCount,
+                                                       &dwErrorIndex)))
+            {
+                if (dwErrorIndex == uCount)
+                {
+                    report->error("Failed to define security attribute set for 0x%08X\n", token);
+                }
+                else
+                {
+                    _ASSERT(uCount > dwErrorIndex);
+                    if (uCount > dwErrorIndex)
+                    {
+                        report->error("Failed to define security attribute set for 0x%08X\n  (error in permission %u)\n",
+                                      token, uCount - dwErrorIndex);
+                    }
+                }
+            }
+            delete [] pAttrs;
+            for (pPerm = pPermissions, i = 0; pPerm; pPerm = pPermNext, i++) {
+                pPermNext = pPerm->m_Next;
+                delete pPerm;
+            }
+        }
+    }
+
+    for (pPset = pPermissionSets; pPset; pPset = pPsetNext) {
+        pPsetNext = pPset->m_Next;
+        if(FAILED(m_pEmitter->DefinePermissionSet(token,
+                                           pPset->m_Action,
+                                           pPset->m_Value->ptr(),
+                                           pPset->m_Value->length(),
+                                           NULL)))
+            report->error("Failed to define security permission set for 0x%08X\n", token);
+        delete pPset;
+    }
+}
+
+void Assembler::AddMethodImpl(mdToken tkImplementedTypeSpec, __in __nullterminated char* szImplementedName, BinStr* pImplementedSig,
+                  mdToken tkImplementingTypeSpec, __in_opt __nullterminated char* szImplementingName, BinStr* pImplementingSig)
+{
+    if(m_pCurClass)
+    {
+        MethodImplDescriptor*   pMID = new MethodImplDescriptor;
+        pMID->m_fNew = TRUE;
+        if(pMID == NULL)
+        {
+            report->error("Failed to allocate MethodImpl Descriptor\n");
+            return;
+        }
+        pMID->m_tkDefiningClass = m_pCurClass->m_cl;
+        if(szImplementingName) //called from class scope, overriding method specified
+        {
+            pMID->m_tkImplementedMethod = MakeMemberRef(tkImplementedTypeSpec,szImplementedName,pImplementedSig);
+            pMID->m_tkImplementingMethod = MakeMemberRef(tkImplementingTypeSpec,szImplementingName,pImplementingSig);
+        }
+        else    //called from method scope, use current method as overriding
+        {
+            if(m_pCurMethod)
+            {
+                if (pImplementedSig == NULL)
+                {
+                    pImplementedSig = new BinStr();
+                    memcpy(pImplementedSig->getBuff(m_pCurMethod->m_dwMethodCSig), m_pCurMethod->m_pMethodSig,m_pCurMethod->m_dwMethodCSig);
+                }
+                pMID->m_tkImplementedMethod = MakeMemberRef(tkImplementedTypeSpec,szImplementedName,pImplementedSig);
+                pMID->m_tkImplementingMethod = 0;
+
+                m_pCurMethod->m_MethodImplDList.PUSH(pMID); // copy goes to method's own list (ptr only)
+            }
+            else
+            {
+                report->error("No overriding method specified");
+                delete pMID;
+                return;
+            }
+        }
+        m_MethodImplDList.PUSH(pMID);
+    }
+    else
+        report->error(".override directive outside class scope");
+}
+// source file name paraphernalia
+void Assembler::SetSourceFileName(__in __nullterminated char* szName)
+{
+    if(szName)
+    {
+        if(*szName)
+        {
+            if(strcmp(m_szSourceFileName,szName))
+            {
+                strcpy_s(m_szSourceFileName,MAX_FILENAME_LENGTH*3+1,szName);
+                WszMultiByteToWideChar(g_uCodePage,0,szName,-1,m_wzSourceFileName,MAX_FILENAME_LENGTH);
+            }
+            if(m_fGeneratePDB)
+            {
+                DocWriter* pDW;
+                unsigned i=0;
+                while((pDW = m_DocWriterList.PEEK(i++)) != NULL)
+                {
+                    if(!strcmp(szName,pDW->Name)) break;
+                }
+                if(pDW)
+                {
+                     m_pSymDocument = pDW->pWriter;
+                     delete [] szName;
+                }
+                else if(m_pSymWriter)
+                {
+                    HRESULT hr;
+                    WszMultiByteToWideChar(g_uCodePage,0,szName,-1,wzUniBuf,dwUniBuf);
+                    if(FAILED(hr=m_pSymWriter->DefineDocument(wzUniBuf,&m_guidLang,
+                        &m_guidLangVendor,&m_guidDoc,&m_pSymDocument)))
+                    {
+                        m_pSymDocument = NULL;
+                        report->error("Failed to define a document writer");
+                    }
+                    if((pDW = new DocWriter()) != NULL)
+                    {
+                        pDW->Name = szName;
+                        pDW->pWriter = m_pSymDocument;
+                        m_DocWriterList.PUSH(pDW);
+                    }
+                    else
+                    {
+                        report->error("Out of memory");
+                        delete [] szName;
+                    }
+                }
+                else delete [] szName;
+            }
+            else delete [] szName;
+        }
+        else delete [] szName;
+    }
+}
+void Assembler::SetSourceFileName(BinStr* pbsName)
+{
+    ULONG L;
+    if(pbsName && (L = (ULONG)(pbsName->length())))
+    {
+        pbsName->appendInt8(0);
+        char* sz = new char[L+1];
+        memcpy(sz,pbsName->ptr(),L+1);
+        SetSourceFileName(sz);
+        delete pbsName;
+    }
+}
diff --git a/src/ilasm/binstr.h b/src/ilasm/binstr.h
new file mode 100644
index 0000000000..0b8ee1794f
--- /dev/null
+++ b/src/ilasm/binstr.h
@@ -0,0 +1,78 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+/**************************************************************************/
+/* a binary string (blob) class */
+
+#ifndef BINSTR_H
+#define BINSTR_H
+
+#include <string.h>         // for memmove, memcpy ...
+
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:22008) // "Suppress PREfast warnings about integer overflow"
+#endif
+
+class BinStr {
+public:
+    BinStr()  { len = 0L; max = 8L; ptr_ = buff; }
+    BinStr(BYTE* pb, DWORD cb) { len = cb; max = cb+8; ptr_ = pb; }
+    ~BinStr() { if (ptr_ != buff) delete [] ptr_;   }
+
+    void insertInt8(int val) { if (len >= max) Realloc(); memmove(ptr_+1, ptr_, len); *ptr_ = val; len++; }
+    void insertInt32(int val) { if (len + 4 > max) Realloc(); memmove(ptr_+4, ptr_, len); SET_UNALIGNED_32(&ptr_[0], val); len+=4; }
+    void appendInt8(int val) { if (len >= max) Realloc(); ptr_[len++] = val; }
+    void appendInt16(int val) { if (len + 2 > max) Realloc(); SET_UNALIGNED_16(&ptr_[len], val); len += 2; }
+    void appendInt32(int val) { if (len + 4 > max) Realloc(); SET_UNALIGNED_32(&ptr_[len], val); len += 4; }
+    void appendInt64(__int64 *pval) { if (len + 8 > max) Realloc(8); SET_UNALIGNED_64(&ptr_[len],(*pval)); len += 8; }
+    unsigned __int8* getBuff(unsigned size) {
+        if (len + size > max) Realloc(size);
+        _ASSERTE(len + size <= max);
+        unsigned __int8* ret = &ptr_[len];
+        len += size;
+        return(ret);
+        }
+    void append(BinStr* str) {
+       memcpy(getBuff(str->length()), str->ptr(), str->length());
+       }
+
+    void appendFrom(BinStr* str, unsigned ix) {
+        _ASSERTE(str->length() >= ix);
+        if (str->length() >= ix)
+        {
+            memcpy(getBuff(str->length()-ix), str->ptr()+ix, str->length()-ix);
+        }
+       }
+
+    void remove(unsigned size) { _ASSERTE(len >= size); len -= size; }
+
+    unsigned __int8* ptr()      { return(ptr_); }
+    unsigned length()   { return(len); }
+
+private:
+    void Realloc(unsigned atLeast = 4) {
+        max = max * 2;
+        if (max < atLeast + len)
+            max = atLeast + len;
+        _ASSERTE(max >= len + atLeast);
+        unsigned __int8* newPtr = new unsigned __int8[max];
+        memcpy(newPtr, ptr_, len);
+        if (ptr_ != buff) delete [] ptr_;
+        ptr_ = newPtr;
+        }
+
+private:
+    unsigned  len;
+    unsigned  max;
+    unsigned __int8 *ptr_;
+    unsigned __int8 buff[8];
+};
+BinStr* BinStrToUnicode(BinStr* pSource, bool Swap = false);
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif
+
+#endif
+
diff --git a/src/ilasm/class.hpp b/src/ilasm/class.hpp
new file mode 100644
index 0000000000..027021de37
--- /dev/null
+++ b/src/ilasm/class.hpp
@@ -0,0 +1,119 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// class.hpp
+//
+
+#ifndef _CLASS_HPP
+#define _CLASS_HPP
+
+class PermissionDecl;
+class PermissionSetDecl;
+
+extern unsigned int g_uCodePage;
+extern WCHAR    wzUniBuf[];
+
+class Class
+{
+public:
+    Class * m_pEncloser;
+    LPCUTF8 m_szFQN;
+    DWORD   m_dwFQN;
+    unsigned m_Hash;
+    mdTypeDef m_cl;
+    mdTypeRef m_crExtends;
+    mdTypeRef *m_crImplements;
+    TyParDescr* m_TyPars;
+    DWORD   m_NumTyPars;
+    DWORD   m_Attr;
+    DWORD   m_dwNumInterfaces;
+    DWORD	m_dwNumFieldsWithOffset;
+    PermissionDecl* m_pPermissions;
+    PermissionSetDecl* m_pPermissionSets;
+    ULONG	m_ulSize;
+    ULONG	m_ulPack;
+    BOOL	m_bIsMaster;
+    BOOL    m_fNew;
+    BOOL    m_fNewMembers;
+
+    MethodList			m_MethodList;
+    //MethodSortedList    m_MethodSList;
+    FieldDList          m_FieldDList;	
+    EventDList          m_EventDList;
+    PropDList           m_PropDList;
+    CustomDescrList     m_CustDList;
+
+    Class(LPCUTF8 pszFQN)
+    {
+        m_pEncloser = NULL;
+        m_cl = mdTypeDefNil;
+        m_crExtends = mdTypeRefNil;
+        m_NumTyPars = 0;
+        m_TyPars = NULL;
+        m_dwNumInterfaces = 0;
+        m_dwNumFieldsWithOffset = 0;
+        m_crImplements = NULL;
+        m_szFQN = pszFQN;
+        m_dwFQN = pszFQN ? (DWORD)strlen(pszFQN) : 0;
+        m_Hash = pszFQN ? hash((const BYTE*)pszFQN, m_dwFQN, 10) : 0;
+
+        m_Attr = tdPublic;
+
+        m_bIsMaster  = TRUE;
+        m_fNew = TRUE;
+
+        m_pPermissions = NULL;
+        m_pPermissionSets = NULL;
+
+        m_ulPack = 0;
+        m_ulSize = 0xFFFFFFFF;
+    }
+    
+    ~Class()
+    {
+        delete [] m_szFQN;
+        delete [] m_crImplements;
+        delete [] m_TyPars;
+    }
+
+    int FindTyPar(LPCWSTR wz)
+    {
+        int i,retval=-1;
+        for(i=0; i < (int)m_NumTyPars; i++)
+        {
+            if(!wcscmp(wz,m_TyPars[i].Name()))
+            {
+                retval = i;
+                break;
+            }
+        }
+        return retval;
+    };
+    int FindTyPar(LPCUTF8 sz)
+    {
+        if(sz)
+        {
+            wzUniBuf[0] = 0;
+            WszMultiByteToWideChar(g_uCodePage,0,sz,-1,wzUniBuf,dwUniBuf);
+            return FindTyPar(wzUniBuf);
+        }
+        else return -1;
+    };
+    int ComparedTo(Class* T) 
+    { 
+        if (m_Hash == T->m_Hash) 
+        {
+            // Properly handle hash conflict
+            return (m_szFQN == T->m_szFQN) ? 0 : strcmp(m_szFQN, T->m_szFQN);
+        } else
+        {
+            return (m_Hash > T->m_Hash) ? 1 : -1;
+        }
+    }
+};
+
+
+#endif /* _CLASS_HPP */
+
diff --git a/src/ilasm/extractGrammar.pl b/src/ilasm/extractGrammar.pl
new file mode 100644
index 0000000000..b5a99b1fea
--- /dev/null
+++ b/src/ilasm/extractGrammar.pl
@@ -0,0 +1,60 @@
+#
+# Copyright (c) Microsoft. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+#
+# a simple script that extracts the grammar from a yacc file
+
+undef $/;			# read in the whole file
+my $file = <>;
+$file =~ /^(.*)%%(.*)%%/s || die "Could not find %% markers";
+my $prefix = $1;
+my $grammar = $2;
+
+#my $line;
+#foreach $line (split /\n/s, $prefix) {
+#	if ($line =~ /^\s*%token/) { 
+#		$line =~ s/\s*<.*>//g;
+#		print "$line\n" 
+#	}
+#}
+
+	# remove any text in {}
+while ($grammar =~ s/\s*([^']){[^{}]*}/$1/sg) {}
+
+	# change keyword identifiers into the string they represent
+$grammar =~ s/\b([A-Z0-9_]+)_\b/'\L$1\E'/sg;
+
+	# change assembler directives into their string
+$grammar =~ s/\b_([A-Z0-9]+)\b/'\L.$1\E'/sg;
+
+	# do the special punctuation by hand
+$grammar =~ s/\bELIPSIS\b/'...'/sg;
+$grammar =~ s/\bDCOLON\b/'::'/sg;
+
+#<STRIP>
+	# remove TODO comments
+$grammar =~ s/\n\s*\/\*[^\n]*TODO[^\n]*\*\/\s*\n/\n/sg;
+#</STRIP>
+
+print "Lexical tokens\n";
+print "    ID - C style alphaNumeric identifier (e.g. Hello_There2)\n";
+print "    DOTTEDNAME - Sequence of dot-separated IDs (e.g. System.Object)\n";
+print "    QSTRING  - C style quoted string (e.g.  \"hi\\n\")\n";
+print "    SQSTRING - C style singlely quoted string(e.g.  'hi')\n";
+print "    INT32    - C style 32 bit integer (e.g.  235,  03423, 0x34FFF)\n";
+print "    INT64    - C style 64 bit integer (e.g.  -2353453636235234,  0x34FFFFFFFFFF)\n";
+print "    FLOAT64  - C style floating point number (e.g.  -0.2323, 354.3423, 3435.34E-5)\n";
+print "    INSTR_*  - IL instructions of a particular class (see opcode.def).\n";
+print "    HEXBYTE  - 1- or 2-digit hexadecimal number (e.g., A2, F0).\n";
+print "Auxiliary lexical tokens\n";
+print "    TYPEDEF_T - Aliased class (TypeDef or TypeRef).\n";
+print "    TYPEDEF_M - Aliased method.\n";
+print "    TYPEDEF_F - Aliased field.\n";
+print "    TYPEDEF_TS - Aliased type specification (TypeSpec).\n";
+print "    TYPEDEF_MR - Aliased field/method reference (MemberRef).\n";
+print "    TYPEDEF_CA - Aliased Custom Attribute.\n";
+print "----------------------------------------------------------------------------------\n";
+print "START           : decls\n";
+print "                ;";
+
+print $grammar;
diff --git a/src/ilasm/grammar_after.cpp b/src/ilasm/grammar_after.cpp
new file mode 100644
index 0000000000..8fe93dab4b
--- /dev/null
+++ b/src/ilasm/grammar_after.cpp
@@ -0,0 +1,1726 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+/********************************************************************************/
+/* Code goes here */
+
+/********************************************************************************/
+
+struct Keywords {
+    const char* name;
+    unsigned short token;
+    unsigned short tokenVal;// this holds the instruction enumeration for those keywords that are instrs
+    size_t   stname;
+};
+
+#define NO_VALUE        ((unsigned short)-1)              // The token has no value
+
+static Keywords keywords[] = {
+// Attention! Because of aliases, the instructions MUST go first!
+// Redefine all the instructions (defined in assembler.h <- asmenum.h <- opcode.def)
+#undef InlineNone
+#undef InlineVar        
+#undef ShortInlineVar
+#undef InlineI          
+#undef ShortInlineI     
+#undef InlineI8         
+#undef InlineR          
+#undef ShortInlineR     
+#undef InlineBrTarget
+#undef ShortInlineBrTarget
+#undef InlineMethod
+#undef InlineField 
+#undef InlineType 
+#undef InlineString
+#undef InlineSig        
+#undef InlineTok        
+#undef InlineSwitch
+#undef InlineVarTok     
+
+
+#define InlineNone              INSTR_NONE
+#define InlineVar               INSTR_VAR
+#define ShortInlineVar          INSTR_VAR
+#define InlineI                 INSTR_I
+#define ShortInlineI            INSTR_I
+#define InlineI8                INSTR_I8
+#define InlineR                 INSTR_R
+#define ShortInlineR            INSTR_R
+#define InlineBrTarget          INSTR_BRTARGET
+#define ShortInlineBrTarget             INSTR_BRTARGET
+#define InlineMethod            INSTR_METHOD
+#define InlineField             INSTR_FIELD
+#define InlineType              INSTR_TYPE
+#define InlineString            INSTR_STRING
+#define InlineSig               INSTR_SIG
+#define InlineTok               INSTR_TOK
+#define InlineSwitch            INSTR_SWITCH
+
+#define InlineVarTok            0
+#define NEW_INLINE_NAMES
+                // The volatile instruction collides with the volatile keyword, so 
+                // we treat it as a keyword everywhere and modify the grammar accordingly (Yuck!) 
+#define OPDEF(c,s,pop,push,args,type,l,s1,s2,ctrl) { s, args, c, lengthof(s)-1 },
+#define OPALIAS(alias_c, s, c) { s, NO_VALUE, c, lengthof(s)-1 },
+#include "opcode.def"
+#undef OPALIAS
+#undef OPDEF
+
+                /* keywords */
+#define KYWD(name, sym, val)    { name, sym, val, lengthof(name)-1 },
+#include "il_kywd.h"
+#undef KYWD
+
+};
+
+/********************************************************************************/
+/* File encoding-dependent functions */
+/*--------------------------------------------------------------------------*/
+char* nextcharA(__in __nullterminated char* pos)
+{
+    return (*pos > 0) ? ++pos : (char *)_mbsinc((const unsigned char *)pos);
+}
+
+char* nextcharU(__in __nullterminated char* pos)
+{
+    return ++pos;
+}
+
+char* nextcharW(__in __nullterminated char* pos)
+{
+    return (pos+2);
+}
+/*--------------------------------------------------------------------------*/
+unsigned SymAU(__in __nullterminated char* curPos)
+{
+    return (unsigned)*curPos;
+}
+
+unsigned SymW(__in __nullterminated char* curPos)
+{
+    return (unsigned)*((WCHAR*)curPos);
+}
+/*--------------------------------------------------------------------------*/
+char* NewStrFromTokenAU(__in_ecount(tokLen) char* curTok, size_t tokLen)
+{
+    char *nb = new char[tokLen+1];
+    if(nb != NULL)
+    {
+        memcpy(nb, curTok, tokLen);
+        nb[tokLen] = 0;
+    }
+    return nb;
+}
+char* NewStrFromTokenW(__in_ecount(tokLen) char* curTok, size_t tokLen)
+{
+    WCHAR* wcurTok = (WCHAR*)curTok;
+    char *nb = new char[(tokLen<<1) + 2];
+    if(nb != NULL)
+    {
+        tokLen = WszWideCharToMultiByte(CP_UTF8,0,(LPCWSTR)wcurTok,(int)(tokLen >> 1),nb,(int)(tokLen<<1) + 2,NULL,NULL);
+        nb[tokLen] = 0;
+    }
+    return nb;
+}
+/*--------------------------------------------------------------------------*/
+char* NewStaticStrFromTokenAU(__in_ecount(tokLen) char* curTok, size_t tokLen, __out_ecount(bufSize) char* staticBuf, size_t bufSize)
+{
+    if(tokLen >= bufSize) return NULL;
+    memcpy(staticBuf, curTok, tokLen);
+    staticBuf[tokLen] = 0;
+    return staticBuf;
+}
+char* NewStaticStrFromTokenW(__in_ecount(tokLen) char* curTok, size_t tokLen, __out_ecount(bufSize) char* staticBuf, size_t bufSize)
+{
+    WCHAR* wcurTok = (WCHAR*)curTok;
+    if(tokLen >= bufSize/2) return NULL;
+    tokLen = WszWideCharToMultiByte(CP_UTF8,0,(LPCWSTR)wcurTok,(int)(tokLen >> 1),staticBuf,(int)bufSize,NULL,NULL);
+    staticBuf[tokLen] = 0;
+    return staticBuf;
+}
+/*--------------------------------------------------------------------------*/
+unsigned GetDoubleAU(__in __nullterminated char* begNum, unsigned L, double** ppRes)
+{
+    static char dbuff[128];
+    char* pdummy;
+    if(L > 127) L = 127;
+    memcpy(dbuff,begNum,L);
+    dbuff[L] = 0;
+    *ppRes = new double(strtod(dbuff, &pdummy));
+    return ((unsigned)(pdummy - dbuff));
+}
+
+unsigned GetDoubleW(__in __nullterminated char* begNum, unsigned L, double** ppRes)
+{
+    static char dbuff[256];
+    char* pdummy;
+    if(L > 254) L = 254;
+    memcpy(dbuff,begNum,L);
+    dbuff[L] = 0;
+    dbuff[L+1] = 0;
+    *ppRes = new double(wcstod((const wchar_t*)dbuff, (wchar_t**)&pdummy));
+    return ((unsigned)(pdummy - dbuff));
+}
+/*--------------------------------------------------------------------------*/
+char* yygetline(int Line)
+{
+    static char buff[0x4000];
+    char *pLine=NULL, *pNextLine=NULL;
+    char *pBegin=NULL, *pEnd = NULL;
+    unsigned uCount = parser->getAll(&pBegin);
+    pEnd = pBegin + uCount;
+    buff[0] = 0;
+    for(uCount=0, pLine=pBegin; pLine < pEnd; pLine = nextchar(pLine))
+    {
+        if(Sym(pLine) == '\n') uCount++;
+        if(uCount == (unsigned int)(Line-1)) break;
+    }
+    pLine = nextchar(pLine);
+    if(pLine < pEnd)
+    {
+        for(pNextLine = pLine; pNextLine < pEnd; pNextLine = nextchar(pNextLine))
+        {
+            if(Sym(pNextLine) == '\n') break;
+        }
+        if(Sym == SymW) // Unicode file
+        {
+            if(*((WCHAR*)pNextLine - 1) == '\r') pNextLine -= 2;
+            uCount = (unsigned)(pNextLine - pLine);
+            uCount &= 0x1FFF; // limit: 8K wchars
+            WCHAR* wzBuff = (WCHAR*)buff;
+            memcpy(buff,pLine,uCount);
+            wzBuff[uCount >> 1] = 0;
+        }
+        else
+        {
+            if(*(pNextLine-1)=='\r') pNextLine--;
+            uCount = (unsigned)(pNextLine - pLine);
+            uCount &= 0x3FFF; // limit: 16K chars
+            memcpy(buff,pLine,uCount);
+            buff[uCount]=0;
+        }
+    }    
+    return buff;
+}
+
+void yyerror(__in __nullterminated char* str) {
+    char tokBuff[64];
+    WCHAR *wzfile = (WCHAR*)(PENV->in->namew());
+    int iline = PENV->curLine;
+    
+    size_t len = PENV->curPos - PENV->curTok;
+    if (len > 62) len = 62;
+    memcpy(tokBuff, PENV->curTok, len);
+    tokBuff[len] = 0;
+    tokBuff[len+1] = 0;
+    if(PENV->bExternSource)
+    {
+        wzfile = PASM->m_wzSourceFileName;
+        iline = PENV->nExtLine;
+    }
+    if(Sym == SymW) // Unicode file
+        fprintf(stderr, "%S(%d) : error : %s at token '%S' in: %S\n", 
+                wzfile, iline, str, (WCHAR*)tokBuff, (WCHAR*)yygetline(PENV->curLine));
+    else
+        fprintf(stderr, "%S(%d) : error : %s at token '%s' in: %s\n", 
+                wzfile, iline, str, tokBuff, yygetline(PENV->curLine));
+    parser->success = false;
+}
+
+/********************************************************************************/
+/* looks up the typedef 'name' of length 'nameLen' (name does not need to be 
+   null terminated)   Returns 0 on failure */
+TypeDefDescr* findTypedef(__in_ecount(NameLen) char* name, size_t NameLen)
+{
+    TypeDefDescr* pRet = NULL;
+    static char Name[4096];
+    if(PASM->NumTypeDefs())
+    {
+        if(NewStaticStrFromToken(name,NameLen,Name,4096))
+            pRet = PASM->FindTypeDef(Name);
+    }
+    return pRet;
+}
+
+int TYPEDEF(TypeDefDescr* pTDD)
+{
+    switch(TypeFromToken(pTDD->m_tkTypeSpec))
+    {
+        case mdtTypeDef:
+        case mdtTypeRef:
+            return TYPEDEF_T;
+        case mdtMethodDef:
+        case 0x99000000:
+            return TYPEDEF_M;
+        case mdtFieldDef:
+        case 0x98000000:
+            return TYPEDEF_F;
+        case mdtMemberRef:
+            return TYPEDEF_MR;
+        case mdtTypeSpec:
+            return TYPEDEF_TS;
+        case mdtCustomAttribute:
+            return TYPEDEF_CA;
+    }
+    return ERROR_;
+            
+}
+
+/********************************************************************************/
+void indexKeywords(Indx* indx)  // called in Assembler constructor (assem.cpp)
+{
+    Keywords* low = keywords;
+    Keywords* high = keywords + (sizeof(keywords) / sizeof(Keywords));
+    Keywords* mid;
+    for(mid = low; mid < high; mid++)
+    {
+        indx->IndexString((char*)(mid->name),mid);
+    }
+}
+
+Instr* SetupInstr(unsigned short opcode)
+{
+    Instr* pVal = NULL;
+    if((pVal = PASM->GetInstr()))
+    {
+        pVal->opcode = opcode;
+        if((pVal->pWriter = PASM->m_pSymDocument)!=NULL)
+        {
+            if(PENV->bExternSource)
+            {
+                pVal->linenum = PENV->nExtLine;
+                pVal->column = PENV->nExtCol;
+                pVal->linenum_end = PENV->nExtLineEnd;
+                pVal->column_end = PENV->nExtColEnd;
+                pVal->pc = nCurrPC;
+            }
+            else
+            {
+                pVal->linenum = PENV->curLine;
+                pVal->column = 1;
+                pVal->linenum_end = PENV->curLine;
+                pVal->column_end = 0;
+                pVal->pc = PASM->m_CurPC;
+            }
+        }
+    }
+    return pVal;
+}
+/* looks up the keyword 'name' of length 'nameLen' (name does not need to be 
+   null terminated)   Returns 0 on failure */
+int findKeyword(const char* name, size_t nameLen, unsigned short* pOpcode) 
+{
+    static char Name[128];
+    Keywords* mid;
+
+    if(NULL == NewStaticStrFromToken((char*)name,nameLen,Name,128)) return 0; // can't be a keyword
+    mid = (Keywords*)(PASM->indxKeywords.FindString(Name));
+    if(mid == NULL) return 0;
+    *pOpcode = mid->tokenVal;
+
+    return(mid->token);
+}
+
+/********************************************************************************/
+/* convert str to a uint64 */
+unsigned digits[128];
+void Init_str2uint64()
+{
+    int i;
+    memset(digits,255,sizeof(digits));
+    for(i='0'; i <= '9'; i++) digits[i] = i - '0';
+    for(i='A'; i <= 'Z'; i++) digits[i] = i + 10 - 'A';
+    for(i='a'; i <= 'z'; i++) digits[i] = i + 10 - 'a';
+}
+static unsigned __int64 str2uint64(const char* str, const char** endStr, unsigned radix) 
+{
+    unsigned __int64 ret = 0;
+    unsigned digit,ix;
+    _ASSERTE(radix <= 36);
+    for(;;str = nextchar((char*)str)) 
+    {
+        ix = Sym((char*)str);
+        if(ix <= 0x7F)
+        {
+            digit = digits[ix];
+            if(digit < radix)
+            {
+                ret = ret * radix + digit;
+                continue;
+            }
+        }
+        *endStr = str;
+        return(ret);
+    }
+}
+/********************************************************************************/
+/* Append an UTF-8 string preceded by compressed length, no zero terminator, to a BinStr */
+static void AppendStringWithLength(BinStr* pbs, __in __nullterminated char* sz)
+{
+    if((pbs != NULL) && (sz != NULL))
+    {
+        unsigned L = (unsigned) strlen(sz);
+        BYTE* pb = NULL;
+        corEmitInt(pbs,L);
+        if((pb = pbs->getBuff(L)) != NULL)
+            memcpy(pb,sz,L);
+    }
+}
+
+/********************************************************************************/
+/* fetch the next token, and return it   Also set the yylval.union if the
+   lexical token also has a value */
+   
+#if (0)   
+
+#define IsAlpha(x) ((('A' <= (x))&&((x) <= 'Z'))||(('a' <= (x))&&((x) <= 'z')))
+#define IsDigit(x) (('0' <= (x))&&((x) <= '9'))
+#define IsAlNum(x) (IsAlpha(x) || IsDigit(x))
+#define IsValidStartingSymbol(x) (IsAlpha(x)||((x)=='#')||((x)=='_')||((x)=='@')||((x)=='$'))
+#define IsValidContinuingSymbol(x) (IsAlNum(x)||((x)=='_')||((x)=='@')||((x)=='$')||((x)=='?'))
+void SetSymbolTables() { ; }
+
+#else
+
+BOOL _Alpha[128];
+BOOL _Digit[128];
+BOOL _AlNum[128];
+BOOL _ValidSS[128];
+BOOL _ValidCS[128];
+void SetSymbolTables()
+{
+    unsigned i;
+    memset(_Alpha,0,sizeof(_Alpha)); 
+    memset(_Digit,0,sizeof(_Digit)); 
+    memset(_AlNum,0,sizeof(_AlNum)); 
+    memset(_ValidSS,0,sizeof(_ValidSS)); 
+    memset(_ValidCS,0,sizeof(_ValidCS));
+    for(i = 'A'; i <= 'Z'; i++)
+    {
+        _Alpha[i] = TRUE;
+        _AlNum[i] = TRUE;
+        _ValidSS[i] = TRUE;
+        _ValidCS[i] = TRUE;
+    } 
+    for(i = 'a'; i <= 'z'; i++)
+    {
+        _Alpha[i] = TRUE;
+        _AlNum[i] = TRUE;
+        _ValidSS[i] = TRUE;
+        _ValidCS[i] = TRUE;
+    }
+    for(i = '0'; i <= '9'; i++)
+    {
+        _Digit[i] = TRUE;
+        _AlNum[i] = TRUE;
+        _ValidCS[i] = TRUE;
+    }
+    _ValidSS[(unsigned char)'_'] = TRUE;
+    _ValidSS[(unsigned char)'#'] = TRUE;
+    _ValidSS[(unsigned char)'$'] = TRUE;
+    _ValidSS[(unsigned char)'@'] = TRUE;
+     
+    _ValidCS[(unsigned char)'_'] = TRUE;
+    _ValidCS[(unsigned char)'?'] = TRUE;
+    _ValidCS[(unsigned char)'$'] = TRUE;
+    _ValidCS[(unsigned char)'@'] = TRUE;
+    _ValidCS[(unsigned char)'`'] = TRUE;
+}
+BOOL IsAlpha(unsigned x) { return (x < 128)&&_Alpha[x]; }
+BOOL IsDigit(unsigned x) { return (x < 128)&&_Digit[x]; }     
+BOOL IsAlNum(unsigned x) { return (x < 128)&&_AlNum[x]; }     
+BOOL IsValidStartingSymbol(unsigned x) { return (x < 128)&&_ValidSS[x]; }     
+BOOL IsValidContinuingSymbol(unsigned x) { return (x < 128)&&_ValidCS[x]; } 
+
+#endif
+
+char* nextBlank(__in __nullterminated char* curPos)
+{
+    for(;;) 
+    {   
+        switch(Sym(curPos)) 
+        {
+            case '/' :
+                if ((Sym(nextchar(curPos)) == '/')|| (Sym(nextchar(curPos)) == '*'))
+                    return curPos;
+                else
+                {
+                    curPos = nextchar(curPos);
+                    break;
+                }
+            case 0: 
+            case '\n':
+            case '\r':
+            case ' ' :
+            case '\t':
+            case '\f':
+                return curPos;
+
+            default:
+                curPos = nextchar(curPos);
+        }
+    }
+}
+
+char* skipBlanks(__in __nullterminated char* curPos, unsigned* pstate)
+{
+    const unsigned eolComment = 1;
+    const unsigned multiComment = 2;
+    unsigned nextSym, state = *pstate;
+    char* nextPos;
+    for(;;) 
+    {   // skip whitespace and comments
+        if (curPos >= PENV->endPos) 
+        {
+            *pstate = state;    
+            return NULL;
+        }
+        switch(Sym(curPos)) 
+        {
+            case 0: 
+                return NULL;       // EOF
+            case '\n':
+                state &= ~eolComment;
+                PENV->curLine++;
+                if(PENV->bExternSource)
+                {
+                    if(PENV->bExternSourceAutoincrement) PENV->nExtLine++;
+                    PASM->m_ulCurLine = PENV->nExtLine;
+                    PASM->m_ulCurColumn = PENV->nExtCol;
+                }
+                else
+                {
+                    PASM->m_ulCurLine = PENV->curLine;
+                    PASM->m_ulCurColumn = 1;
+                }
+                break;
+            case '\r':
+            case ' ' :
+            case '\t':
+            case '\f':
+                break;
+
+            case '*' :
+                if(state == 0) goto PAST_WHITESPACE;
+                if(state & multiComment)
+                {
+                    nextPos = nextchar(curPos);
+                    if (Sym(nextPos) == '/') 
+                    {
+                        curPos = nextPos;
+                        state &= ~multiComment;
+                    }
+                }
+                break;
+
+            case '/' :
+                if(state == 0)
+                {
+                    nextPos = nextchar(curPos);
+                    nextSym = Sym(nextPos);
+                    if (nextSym == '/')
+                    {
+                        curPos = nextPos;
+                        state |= eolComment;
+                    }
+                    else if (nextSym == '*') 
+                    {
+                        curPos = nextPos;
+                        state |= multiComment;
+                    }
+                    else goto PAST_WHITESPACE;
+                }
+                break;
+
+            default:
+                if (state == 0)  goto PAST_WHITESPACE;
+        }
+        curPos = nextchar(curPos);
+    }
+PAST_WHITESPACE:
+    *pstate = state;
+    return curPos;
+}
+
+char* FullFileName(__in __nullterminated WCHAR* wzFileName, unsigned uCodePage);
+
+int ProcessEOF()
+{
+    PARSING_ENVIRONMENT* prev_penv = parser->PEStack.POP();
+    if(prev_penv != NULL)
+    {
+        //delete [] (WCHAR*)(PENV->in->namew());
+        delete PENV->in;
+        delete PENV;
+        parser->penv = prev_penv;
+        SetFunctionPtrs();
+        char* szFileName = new char[strlen(PENV->szFileName)+1];
+        strcpy_s(szFileName,strlen(PENV->szFileName)+1,PENV->szFileName);
+        PASM->SetSourceFileName(szFileName); // deletes the argument!
+        return ';';
+    }
+    //PENV->in = NULL;
+    return 0;
+}
+
+#define NEXT_TOKEN  {state=0; curPos=PENV->curPos; goto NextToken;}
+
+int parse_literal(unsigned curSym, __inout __nullterminated char* &curPos, BOOL translate_escapes)
+{
+    unsigned quote = curSym;
+    curPos = nextchar(curPos);
+    char* fromPtr = curPos;
+    bool escape = false;
+
+    for(;;) 
+    {     // Find matching quote
+        curSym = (curPos >= PENV->endPos) ? 0 : Sym(curPos);
+        if(curSym == 0)
+        {
+            PENV->curPos = curPos; 
+            return(BAD_LITERAL_);
+        }
+        else if(curSym == '\\')
+            escape = !escape;
+        else
+        {
+            if(curSym == '\n')
+            {
+                PENV->curLine++;
+                if(PENV->bExternSource)
+                {
+                    if(PENV->bExternSourceAutoincrement) PENV->nExtLine++;
+                    PASM->m_ulCurLine = PENV->nExtLine;
+                    PASM->m_ulCurColumn = PENV->nExtCol;
+                }
+                else
+                {
+                    PASM->m_ulCurLine = PENV->curLine;
+                    PASM->m_ulCurColumn = 1;
+                }
+                if (!escape) { PENV->curPos = curPos; return(BAD_LITERAL_); }
+            }
+            else if ((curSym == quote) && (!escape)) break;
+            escape = false;
+        }        
+        curPos = nextchar(curPos);
+    }
+    // translate escaped characters
+    unsigned tokLen = (unsigned)(curPos - fromPtr);
+    char* newstr = NewStrFromToken(fromPtr, tokLen);
+    char* toPtr;
+    curPos = nextchar(curPos);  // skip closing quote
+    if(translate_escapes)
+    {
+        fromPtr = newstr;
+        //_ASSERTE(0);
+        tokLen = (unsigned)strlen(newstr);
+        toPtr = new char[tokLen+1];
+        if(toPtr==NULL) return BAD_LITERAL_;
+        yylval.string = toPtr;
+        char* endPtr = fromPtr+tokLen;
+        while(fromPtr < endPtr) 
+        {
+            if (*fromPtr == '\\') 
+            {
+                fromPtr++;
+                switch(*fromPtr) 
+                {
+                    case 't':
+                            *toPtr++ = '\t';
+                            break;
+                    case 'n':
+                            *toPtr++ = '\n';
+                            break;
+                    case 'b':
+                            *toPtr++ = '\b';
+                            break;
+                    case 'f':
+                            *toPtr++ = '\f';
+                            break;
+                    case 'v':
+                            *toPtr++ = '\v';
+                            break;
+                    case '?':
+                            *toPtr++ = '\?';
+                            break;
+                    case 'r':
+                            *toPtr++ = '\r';
+                            break;
+                    case 'a':
+                            *toPtr++ = '\a';
+                            break;
+                    case '\n':
+                            do      fromPtr++;
+                            while(isspace(*fromPtr));
+                            --fromPtr;              // undo the increment below   
+                            break;
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                            if (IsDigit(fromPtr[1]) && IsDigit(fromPtr[2])) 
+                            {
+                                *toPtr++ = ((fromPtr[0] - '0') * 8 + (fromPtr[1] - '0')) * 8 + (fromPtr[2] - '0');
+                                fromPtr+= 2;                                                            
+                            }
+                            else if(*fromPtr == '0') *toPtr++ = 0;
+                            else *toPtr++ = *fromPtr;
+                            break;
+                    default:
+                            *toPtr++ = *fromPtr;
+                }
+                fromPtr++;
+            }
+            else
+            //  *toPtr++ = *fromPtr++;
+            {
+                char* tmpPtr = fromPtr;
+                fromPtr = (nextchar == nextcharW) ? nextcharU(fromPtr) : nextchar(fromPtr);
+                while(tmpPtr < fromPtr) *toPtr++ = *tmpPtr++;
+            }
+    
+        } //end while(fromPtr < endPtr)
+        *toPtr = 0;                     // terminate string
+        delete [] newstr;
+    }
+    else
+    {
+        yylval.string = newstr;
+        toPtr = newstr + strlen(newstr);
+    }
+            
+    PENV->curPos = curPos;
+    if(quote == '"')
+    {
+        BinStr* pBS = new BinStr();
+        unsigned size = (unsigned)(toPtr - yylval.string);
+        memcpy(pBS->getBuff(size),yylval.string,size);
+        delete [] yylval.string;
+        yylval.binstr = pBS;
+        return QSTRING;
+    }
+    else
+    {
+        if(PASM->NumTypeDefs())
+        {
+            TypeDefDescr* pTDD = PASM->FindTypeDef(yylval.string);
+            if(pTDD != NULL)
+            {
+                delete [] yylval.string;
+                yylval.tdd = pTDD;
+                return(TYPEDEF(pTDD));
+            }
+        }
+        return SQSTRING;
+    }
+}
+
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
+#endif
+int yylex() 
+{
+    char* curPos = PENV->curPos;
+    unsigned state = 0;
+    const unsigned multiComment = 2;
+    unsigned curSym;
+    
+    char* newstr;
+    
+NextToken:    
+    // Skip any leading whitespace and comments
+    curPos = skipBlanks(curPos, &state);
+    if(curPos == NULL)
+    {
+        if (state & multiComment) return (BAD_COMMENT_);
+        if(ProcessEOF() == 0) return 0;       // EOF
+        NEXT_TOKEN;
+    }
+    char* curTok = curPos;
+    PENV->curTok = curPos;
+    PENV->curPos = curPos;
+    int tok = ERROR_;
+    yylval.string = 0;
+
+    curSym = Sym(curPos);
+    if(bParsingByteArray) // only hexadecimals w/o 0x, ')' and white space allowed!
+    {
+        int i,s=0;
+        for(i=0; i<2; i++, curPos = nextchar(curPos), curSym = Sym(curPos))
+        {
+            if(('0' <= curSym)&&(curSym <= '9')) s = s*16+(curSym - '0');
+            else if(('A' <= curSym)&&(curSym <= 'F')) s = s*16+(curSym - 'A' + 10);
+            else if(('a' <= curSym)&&(curSym <= 'f')) s = s*16+(curSym - 'a' + 10);
+            else break; // don't increase curPos!
+        }
+        if(i)
+        {
+            tok = HEXBYTE;
+            yylval.int32 = s;
+        }
+        else
+        {
+            if(curSym == ')' || curSym == '}') 
+            {
+                bParsingByteArray = FALSE;
+                goto Just_A_Character;
+            }
+        }
+        PENV->curPos = curPos;
+        return(tok);
+    }
+    if(curSym == '?') // '?' may be part of an identifier, if it's not followed by punctuation
+    {
+        if(IsValidContinuingSymbol(Sym(nextchar(curPos)))) goto Its_An_Id;
+        goto Just_A_Character;
+    }
+
+    if (IsValidStartingSymbol(curSym)) 
+    { // is it an ID
+Its_An_Id:
+        size_t offsetDot = (size_t)-1; // first appearance of '.'
+                size_t offsetDotDigit = (size_t)-1; // first appearance of '.<digit>' (not DOTTEDNAME!)
+        do 
+        {
+            curPos = nextchar(curPos);
+            if (Sym(curPos) == '.') 
+            {
+                if (offsetDot == (size_t)-1) offsetDot = curPos - curTok;
+                curPos = nextchar(curPos);
+                if((offsetDotDigit==(size_t)-1)&&(Sym(curPos) >= '0')&&(Sym(curPos) <= '9')) 
+                        offsetDotDigit = curPos - curTok - 1;
+            }
+        } while(IsValidContinuingSymbol(Sym(curPos)));
+        
+        size_t tokLen = curPos - curTok;
+        // check to see if it is a keyword
+        int token = findKeyword(curTok, tokLen, &yylval.opcode);
+        if (token != 0) 
+        {
+            //printf("yylex: TOK = %d, curPos=0x%8.8X\n",token,curPos);
+            PENV->curPos = curPos;
+            PENV->curTok = curTok;
+            if(!SkipToken)
+            {
+                switch(token)
+                {
+                    case P_INCLUDE:
+                        //if(include_first_pass)
+                        //{
+                        //    PENV->curPos = curTok;
+                        //    include_first_pass = FALSE;
+                        //    return ';';
+                        //}
+                        //include_first_pass = TRUE;
+                        curPos = skipBlanks(curPos,&state);
+                        if(curPos == NULL)
+                        {
+                            if (state & multiComment) return (BAD_COMMENT_);
+                            if(ProcessEOF() == 0) return 0;       // EOF
+                            NEXT_TOKEN;
+                        }
+                        if(Sym(curPos) != '"') return ERROR_;
+                        curPos = nextchar(curPos);
+                        curTok = curPos;
+                        PENV->curTok = curPos;
+                        while(Sym(curPos) != '"')
+                        {
+                            curPos = nextchar(curPos);
+                            if(curPos >= PENV->endPos) return ERROR_;
+                            PENV->curPos = curPos;
+                        }
+                        tokLen = PENV->curPos - curTok;
+                        curPos = nextchar(curPos);
+                        PENV->curPos = curPos;
+                        {
+                            WCHAR* wzFile=NULL;
+                            if(Sym == SymW)
+                            {
+                                if((wzFile = new WCHAR[tokLen/2 + 1]) != NULL)
+                                {
+                                    memcpy(wzFile,curTok,tokLen);
+                                    wzFile[tokLen/2] = 0;
+                                }
+                            }
+                            else
+                            {
+                                if((wzFile = new WCHAR[tokLen+1]) != NULL)
+                                {
+                                    tokLen = WszMultiByteToWideChar(g_uCodePage,0,curTok,(int)tokLen,wzFile,(int)tokLen+1);
+                                    wzFile[tokLen] = 0;
+                                }
+                            }
+                            if(wzFile != NULL)
+                            {
+                                if((parser->wzIncludePath != NULL)
+                                 &&(wcschr(wzFile,'\\')==NULL)&&(wcschr(wzFile,':')==NULL))
+                                {
+                                    WCHAR* wzFullName =  new WCHAR[MAX_FILENAME_LENGTH+1];
+                                    if(wzFullName != NULL)
+                                    {
+                                        WCHAR* pwz;
+                                        DWORD dw = WszSearchPath(parser->wzIncludePath,wzFile,NULL,
+                                                   MAX_FILENAME_LENGTH+1,wzFullName,&pwz);
+                                        if(dw != 0)
+                                        {
+                                            wzFullName[dw] = 0;
+                                            delete [] wzFile;
+                                            wzFile = wzFullName;
+                                        }
+                                        else
+                                        {
+                                            delete [] wzFullName;
+                                        }
+                                    }
+                                }
+                                if(PASM->m_fReportProgress)
+                                    parser->msg("\nIncluding '%S'\n",wzFile);
+                                MappedFileStream *pIn = new MappedFileStream(wzFile);
+                                if((pIn != NULL)&&pIn->IsValid())
+                                {
+                                    parser->PEStack.PUSH(PENV);
+                                    PASM->SetSourceFileName(FullFileName(wzFile,CP_UTF8)); // deletes the argument!
+                                    parser->CreateEnvironment(pIn);
+                                    NEXT_TOKEN;
+                                }
+                                else
+                                {
+                                    delete [] wzFile;
+                                    PASM->report->error("#include failed\n");
+                                    return ERROR_;
+                                }
+                            }
+                            else
+                            {
+                                PASM->report->error("Out of memory\n");
+                                return ERROR_;
+                            }
+                        }
+                        curPos = PENV->curPos;
+                        curTok = PENV->curTok;
+                        break;
+                    case P_IFDEF:
+                    case P_IFNDEF:
+                    case P_DEFINE:
+                    case P_UNDEF:
+                        curPos = skipBlanks(curPos,&state);
+                        if(curPos == NULL)
+                        {
+                            if (state & multiComment) return (BAD_COMMENT_);
+                            if(ProcessEOF() == 0) return 0;       // EOF
+                            NEXT_TOKEN;
+                        }
+                        curTok = curPos;
+                        PENV->curTok = curPos;
+                        PENV->curPos = curPos;
+                        if (!IsValidStartingSymbol(Sym(curPos))) return ERROR_;
+                        do 
+                        {
+                            curPos = nextchar(curPos);
+                        } while(IsValidContinuingSymbol(Sym(curPos)));
+                        tokLen = curPos - curTok;
+                            
+                        newstr = NewStrFromToken(curTok, tokLen);
+                        if((token==P_DEFINE)||(token==P_UNDEF))
+                        {
+                            if(token == P_DEFINE)
+                            {
+                                curPos = skipBlanks(curPos,&state);
+                                if ((curPos == NULL) && (ProcessEOF() == 0))
+                                {
+                                    DefineVar(newstr, NULL);
+                                    return 0;
+                                }
+                                curSym = Sym(curPos);
+                                if(curSym != '"')
+                                    DefineVar(newstr, NULL);
+                                else
+                                {
+                                    tok = parse_literal(curSym, curPos, FALSE);
+                                    if(tok == QSTRING)
+                                    {
+                                        // if not ANSI, then string is in UTF-8,
+                                        // insert prefix
+                                        if(nextchar != nextcharA)
+                                        {
+                                            yylval.binstr->insertInt8(0xEF);
+                                            yylval.binstr->insertInt8(0xBB);
+                                            yylval.binstr->insertInt8(0xBF);
+                                        }
+                                        yylval.binstr->appendInt8(' ');
+                                        DefineVar(newstr, yylval.binstr);
+                                    }
+                                    else
+                                        return tok;
+                                }
+                            }
+                            else UndefVar(newstr);
+                        }
+                        else
+                        {
+                            SkipToken = IsVarDefined(newstr);
+                            if(token == P_IFDEF) SkipToken = !SkipToken;
+                            IfEndif++;
+                            if(SkipToken) IfEndifSkip=IfEndif;
+                        }
+                        break;
+                    case P_ELSE:
+                        SkipToken = TRUE;
+                        IfEndifSkip=IfEndif;
+                        break;
+                    case P_ENDIF:
+                        if(IfEndif == 0)
+                        {
+                            PASM->report->error("Unmatched #endif\n");
+                            return ERROR_;
+                        }
+                        IfEndif--;
+                        break;
+                    default:
+                        return(token);
+                }
+                goto NextToken;
+            }
+            if(SkipToken)
+            {
+                switch(token)
+                {
+                    case P_IFDEF:
+                    case P_IFNDEF:
+                        IfEndif++;
+                        break;
+                    case P_ELSE:
+                        if(IfEndif == IfEndifSkip) SkipToken = FALSE;
+                        break;
+                    case P_ENDIF:
+                        if(IfEndif == IfEndifSkip) SkipToken = FALSE;
+                        IfEndif--;
+                        break;
+                    default:
+                        break;
+                }
+                //if(yylval.instr) yylval.instr->opcode = -1;
+                goto NextToken;
+            }
+            return(token);
+        } // end if token != 0
+        if(SkipToken) { curPos = nextBlank(curPos); goto NextToken; }
+        
+        VarName* pVarName = FindVarDef(NewStrFromToken(curTok, tokLen));
+        if(pVarName != NULL)
+        {
+            if(pVarName->pbody != NULL)
+            {
+                BinStrStream *pIn = new BinStrStream(pVarName->pbody);
+                if((pIn != NULL)&&pIn->IsValid())
+                {
+                    PENV->curPos = curPos;
+                    parser->PEStack.PUSH(PENV);
+                    parser->CreateEnvironment(pIn);
+                    NEXT_TOKEN;
+                }
+            }
+        }
+        
+        TypeDefDescr* pTDD = findTypedef(curTok,tokLen);
+        
+        if(pTDD != NULL)
+        {
+            yylval.tdd = pTDD;
+            PENV->curPos = curPos;
+            PENV->curTok = curTok;
+            return(TYPEDEF(pTDD));
+        }
+        if(Sym(curTok) == '#') 
+        {
+            PENV->curPos = curPos;
+            PENV->curTok = curTok;
+            return(ERROR_);
+        }
+        // Not a keyword, normal identifiers don't have '.' in them
+        if (offsetDot < (size_t)-1) 
+        {
+            if(offsetDotDigit < (size_t)-1)
+            {
+                curPos = curTok+offsetDotDigit;
+                tokLen = offsetDotDigit;
+            }
+            // protection against something like Foo.Bar..123 or Foo.Bar.
+            unsigned D = (Sym == SymW) ? 2 : 1; // Unicode or ANSI/UTF8!
+            while((Sym(curPos-D)=='.')&&(tokLen))
+            {
+                curPos -= D;
+                tokLen -= D;
+            }
+        }
+        if((yylval.string = NewStrFromToken(curTok,tokLen)))
+        {
+            tok = (offsetDot == (size_t)(-1))? ID : DOTTEDNAME;
+            //printf("yylex: ID = '%s', curPos=0x%8.8X\n",yylval.string,curPos);
+        }
+        else return BAD_LITERAL_;
+    }
+    else if(SkipToken) { curPos = nextBlank(curPos); goto NextToken; }
+    else if (IsDigit(curSym) 
+        || (curSym == '.' && IsDigit(Sym(nextchar(curPos))))
+        || (curSym == '-' && IsDigit(Sym(nextchar(curPos))))) 
+    {
+        const char* begNum = curPos;
+        unsigned radix = 10;
+
+        neg = (curSym == '-');    // always make it unsigned 
+        if (neg) curPos = nextchar(curPos);
+
+        if (Sym(curPos) == '0' && Sym(nextchar(curPos)) != '.') 
+        {
+            curPos = nextchar(curPos);
+            radix = 8;
+            if (Sym(curPos) == 'x' || Sym(curPos) == 'X') 
+            {
+                curPos = nextchar(curPos);
+                radix = 16;
+            }
+        }
+        begNum = curPos;
+        {
+            unsigned __int64 i64 = str2uint64(begNum, const_cast<const char**>(&curPos), radix);
+            unsigned __int64 mask64 = neg ? UI64(0xFFFFFFFF80000000) : UI64(0xFFFFFFFF00000000);
+            unsigned __int64 largestNegVal32 = UI64(0x0000000080000000);
+            if ((i64 & mask64) && (i64 != largestNegVal32))
+            {
+                yylval.int64 = new __int64(i64);
+                tok = INT64;                    
+                if (neg) *yylval.int64 = -*yylval.int64;
+            }
+            else
+            {
+                yylval.int32 = (__int32)i64;
+                tok = INT32;
+                if(neg) yylval.int32 = -yylval.int32;
+            }
+        }
+        if (radix == 10 && ((Sym(curPos) == '.' && Sym(nextchar(curPos)) != '.') || Sym(curPos) == 'E' || Sym(curPos) == 'e')) 
+        {
+            unsigned L = (unsigned)(PENV->endPos - begNum);
+            curPos = (char*)begNum + GetDouble((char*)begNum,L,&yylval.float64);
+            if (neg) *yylval.float64 = -*yylval.float64;
+            tok = FLOAT64;
+        }
+    }
+    else 
+    {   //      punctuation
+        if (curSym == '"' || curSym == '\'') 
+        {
+            return parse_literal(curSym, curPos, TRUE);
+        } // end if (*curPos == '"' || *curPos == '\'')
+        else if (curSym==':' && Sym(nextchar(curPos))==':') 
+        {
+            curPos = nextchar(nextchar(curPos));
+            tok = DCOLON;
+        }       
+        else if(curSym == '.') 
+        {
+            if (Sym(nextchar(curPos))=='.' && Sym(nextchar(nextchar(curPos)))=='.') 
+            {
+                curPos = nextchar(nextchar(nextchar(curPos)));
+                tok = ELIPSIS;
+            }
+            else
+            {
+                do
+                {
+                    curPos = nextchar(curPos);
+                    if (curPos >= PENV->endPos) 
+                    return ERROR_;
+                    curSym = Sym(curPos);
+                }
+                while(IsAlNum(curSym) || curSym == '_' || curSym == '$'|| curSym == '@'|| curSym == '?');
+                size_t tokLen = curPos - curTok;
+    
+                // check to see if it is a keyword
+                int token = findKeyword(curTok, tokLen, &yylval.opcode);
+                if(token)
+                        {
+                    //printf("yylex: TOK = %d, curPos=0x%8.8X\n",token,curPos);
+                    PENV->curPos = curPos;
+                    PENV->curTok = curTok; 
+                    return(token);
+                }
+                tok = '.';
+                curPos = nextchar(curTok);
+            }
+        }
+        else 
+        {
+Just_A_Character:
+            tok = curSym;
+            curPos = nextchar(curPos);
+        }
+        //printf("yylex: PUNCT curPos=0x%8.8X\n",curPos);
+    }
+    dbprintf(("    Line %d token %d (%c) val = %s\n", PENV->curLine, tok, 
+            (tok < 128 && isprint(tok)) ? tok : ' ', 
+            (tok > 255 && tok != INT32 && tok != INT64 && tok!= FLOAT64) ? yylval.string : ""));
+
+    PENV->curPos = curPos;
+    PENV->curTok = curTok; 
+    return(tok);
+}
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif
+
+/**************************************************************************/
+static char* newString(__in __nullterminated char* str1) 
+{
+    char* ret = new char[strlen(str1)+1];
+    if(ret) strcpy_s(ret, strlen(str1)+1, str1);
+    return(ret);
+}
+
+/**************************************************************************/
+/* concatenate strings and release them */
+
+static char* newStringWDel(__in __nullterminated char* str1, char delimiter, __in __nullterminated char* str3) 
+{
+    size_t len1 = strlen(str1);
+    size_t len = len1+2;
+    if (str3) len += strlen(str3);
+    char* ret = new char[len];
+    if(ret)
+    {
+        strcpy_s(ret, len, str1);
+        delete [] str1;
+        ret[len1] = delimiter;
+        ret[len1+1] = 0;
+        if (str3)
+        {
+            strcat_s(ret, len, str3);
+            delete [] str3;
+        }
+    }
+    return(ret);
+}
+
+/**************************************************************************/
+static void corEmitInt(BinStr* buff, unsigned data) 
+{
+    unsigned cnt = CorSigCompressData(data, buff->getBuff(5));
+    buff->remove(5 - cnt);
+}
+
+
+/**************************************************************************/
+/* move 'ptr past the exactly one type description */
+
+unsigned __int8* skipType(unsigned __int8* ptr, BOOL fFixupType) 
+{
+    mdToken  tk;
+AGAIN:
+    switch(*ptr++) {
+        case ELEMENT_TYPE_VOID         :
+        case ELEMENT_TYPE_BOOLEAN      :
+        case ELEMENT_TYPE_CHAR         :
+        case ELEMENT_TYPE_I1           :
+        case ELEMENT_TYPE_U1           :
+        case ELEMENT_TYPE_I2           :
+        case ELEMENT_TYPE_U2           :
+        case ELEMENT_TYPE_I4           :
+        case ELEMENT_TYPE_U4           :
+        case ELEMENT_TYPE_I8           :
+        case ELEMENT_TYPE_U8           :
+        case ELEMENT_TYPE_R4           :
+        case ELEMENT_TYPE_R8           :
+        case ELEMENT_TYPE_U            :
+        case ELEMENT_TYPE_I            :
+        case ELEMENT_TYPE_STRING       :
+        case ELEMENT_TYPE_OBJECT       :
+        case ELEMENT_TYPE_TYPEDBYREF   :
+        case ELEMENT_TYPE_SENTINEL     :
+                /* do nothing */
+                break;
+
+        case ELEMENT_TYPE_VALUETYPE   :
+        case ELEMENT_TYPE_CLASS        :
+                ptr += CorSigUncompressToken(ptr, &tk);
+                break;
+
+        case ELEMENT_TYPE_CMOD_REQD    :
+        case ELEMENT_TYPE_CMOD_OPT     :
+                ptr += CorSigUncompressToken(ptr, &tk);
+                goto AGAIN;
+        
+        case ELEMENT_TYPE_ARRAY         :
+                {
+                    ptr = skipType(ptr, fFixupType);                    // element Type
+                    unsigned rank = CorSigUncompressData((PCCOR_SIGNATURE&) ptr);
+                    if (rank != 0)
+                    {
+                        unsigned numSizes = CorSigUncompressData((PCCOR_SIGNATURE&) ptr);
+                        while(numSizes > 0)
+                                                {
+                            CorSigUncompressData((PCCOR_SIGNATURE&) ptr);
+                                                        --numSizes;
+                                                }
+                        unsigned numLowBounds = CorSigUncompressData((PCCOR_SIGNATURE&) ptr);
+                        while(numLowBounds > 0)
+                                                {
+                            CorSigUncompressData((PCCOR_SIGNATURE&) ptr);
+                                                        --numLowBounds;
+                                                }
+                    }
+                }
+                break;
+
+                // Modifiers or depedant types
+        case ELEMENT_TYPE_PINNED                :
+        case ELEMENT_TYPE_PTR                   :
+        case ELEMENT_TYPE_BYREF                 :
+        case ELEMENT_TYPE_SZARRAY               :
+                // tail recursion optimization
+                // ptr = skipType(ptr, fFixupType);
+                // break
+                goto AGAIN;
+
+        case ELEMENT_TYPE_VAR:
+        case ELEMENT_TYPE_MVAR:
+                CorSigUncompressData((PCCOR_SIGNATURE&) ptr);  // bound
+                break;
+        
+        case ELEMENT_TYPE_VARFIXUP:
+        case ELEMENT_TYPE_MVARFIXUP:
+                if(fFixupType)
+                {
+                    BYTE* pb = ptr-1; // ptr incremented in switch
+                    unsigned __int8* ptr_save = ptr;
+                    int n = CorSigUncompressData((PCCOR_SIGNATURE&) ptr);  // fixup #
+                    int compressed_size_n = (int)(ptr - ptr_save);  // ptr was updated by CorSigUncompressData()
+                    int m = -1;
+                    if(PASM->m_TyParList)
+                        m = PASM->m_TyParList->IndexOf(TyParFixupList.PEEK(n));
+                    if(m == -1)
+                    {
+                        PASM->report->error("(fixupType) Invalid %stype parameter '%s'\n",
+                            (*pb == ELEMENT_TYPE_MVARFIXUP)? "method ": "",
+                            TyParFixupList.PEEK(n));
+                        m = 0;
+                    }
+                    *pb = (*pb == ELEMENT_TYPE_MVARFIXUP)? ELEMENT_TYPE_MVAR : ELEMENT_TYPE_VAR;
+                    int compressed_size_m = (int)CorSigCompressData(m,pb+1);
+
+                    // Note that CorSigCompressData() (and hence, CorSigUncompressData()) store a number
+                    // 0 <= x <= 0x1FFFFFFF in 1, 2, or 4 bytes. Above, 'n' is the fixup number being read,
+                    // and 'm' is the generic parameter number being written out (in the same place where 'n'
+                    // came from). If 'n' takes more space to compress than 'm' (e.g., 0x80 <= n <= 0x3fff so
+                    // it takes 2 bytes, and m < 0x80 so it takes one byte), then when we overwrite the fixup
+                    // number with the generic parameter number, we'll leave extra bytes in the signature following
+                    // the written generic parameter number. Thus, we do something of a hack to ensure that the
+                    // compressed number is correctly readable even if 'm' compresses smaller than 'n' did: we
+                    // recompress 'm' to use the same amount of space as 'n' used. This is possible because smaller
+                    // numbers can still be compressed in a larger amount of space, even though it's not optimal (and
+                    // CorSigCompressData() would never do it). If, however, the compressed sizes are the other
+                    // way around (m takes more space to compress than n), then we've already corrupted the
+                    // signature that we're reading by writing beyond what we should (is there some reason why
+                    // this is not possible?).
+                    // Note that 'ptr' has already been adjusted, above, to point to the next type after this one.
+                    // There is no need to update it when recompressing the data.
+
+                    if (compressed_size_m > compressed_size_n)
+                    {
+                        // We've got a problem: we just corrupted the rest of the signature!
+                        // (Can this ever happen in practice?)
+                        PASM->report->error("(fixupType) Too many %stype parameters\n",
+                            (*pb == ELEMENT_TYPE_MVARFIXUP)? "method ": "");
+                    }
+                    else if (compressed_size_m < compressed_size_n)
+                    {
+                        // We didn't write out as much data as we read. This will leave extra bytes in the
+                        // signature that will be incorrectly recognized. Ideally, we would just shrink the
+                        // signature. That's not easy to do here. Instead, pad the bytes to force it to use
+                        // a larger encoding than needed. This assumes knowledge of the CorSigCompressData()
+                        // encoding.
+                        //
+                        // The cases:
+                        //      compressed_size_m   m bytes     compressed_size_n   result bytes
+                        //      1                   m1          2                   0x80 m1
+                        //      1                   m1          4                   0xC0 0x00 0x00 m1
+                        //      2                   m1 m2       4                   0xC0 0x00 (m1 & 0x7f) m2
+
+                        _ASSERTE((compressed_size_m == 1) || (compressed_size_m == 2) || (compressed_size_m == 4));
+                        _ASSERTE((compressed_size_n == 1) || (compressed_size_n == 2) || (compressed_size_n == 4));
+
+                        if ((compressed_size_m == 1) &&
+                            (compressed_size_n == 2))
+                        {
+                            unsigned __int8 m1 = *(pb + 1);
+                            _ASSERTE(m1 < 0x80);
+                            *(pb + 1) = 0x80;
+                            *(pb + 2) = m1;
+                        }
+                        else
+                        if ((compressed_size_m == 1) &&
+                            (compressed_size_n == 4))
+                        {
+                            unsigned __int8 m1 = *(pb + 1);
+                            _ASSERTE(m1 < 0x80);
+                            *(pb + 1) = 0xC0;
+                            *(pb + 2) = 0x00;
+                            *(pb + 3) = 0x00;
+                            *(pb + 4) = m1;
+                        }
+                        else
+                        if ((compressed_size_m == 2) &&
+                            (compressed_size_n == 4))
+                        {
+                            unsigned __int8 m1 = *(pb + 1);
+                            unsigned __int8 m2 = *(pb + 2);
+                            _ASSERTE(m1 >= 0x80);
+                            m1 &= 0x7f; // strip the bit indicating it's a 2-byte thing
+                            *(pb + 1) = 0xC0;
+                            *(pb + 2) = 0x00;
+                            *(pb + 3) = m1;
+                            *(pb + 4) = m2;
+                        }
+                    }
+                }
+                else
+                    CorSigUncompressData((PCCOR_SIGNATURE&) ptr);  // bound
+                break;
+
+        case ELEMENT_TYPE_FNPTR: 
+                {
+                    CorSigUncompressData((PCCOR_SIGNATURE&) ptr);    // calling convention
+                    unsigned argCnt = CorSigUncompressData((PCCOR_SIGNATURE&) ptr);    // arg count
+                    ptr = skipType(ptr, fFixupType);                             // return type
+                    while(argCnt > 0)
+                    {
+                        ptr = skipType(ptr, fFixupType);
+                        --argCnt;
+                    }
+                }
+                break;
+
+        case ELEMENT_TYPE_GENERICINST: 
+               {
+                   ptr = skipType(ptr, fFixupType);                 // type constructor
+                   unsigned argCnt = CorSigUncompressData((PCCOR_SIGNATURE&)ptr);               // arg count
+                   while(argCnt > 0) {
+                       ptr = skipType(ptr, fFixupType);
+                       --argCnt;
+                   }
+               }
+               break;                        
+
+        default:
+        case ELEMENT_TYPE_END                   :
+                _ASSERTE(!"Unknown Type");
+                break;
+    }
+    return(ptr);
+}
+
+/**************************************************************************/
+void FixupTyPars(PCOR_SIGNATURE pSig, ULONG cSig)
+{
+    if(TyParFixupList.COUNT() > 0)
+    {
+        BYTE* ptr = (BYTE*)pSig;
+        BYTE* ptrEnd = ptr + cSig;
+        while(ptr < ptrEnd)
+        {
+            ptr = skipType(ptr, TRUE);
+        } // end while
+    } // end if(COUNT>0)
+}
+void FixupTyPars(BinStr* pbstype) 
+{
+    FixupTyPars((PCOR_SIGNATURE)(pbstype->ptr()),(ULONG)(pbstype->length()));
+}
+/**************************************************************************/
+static unsigned corCountArgs(BinStr* args) 
+{
+    unsigned __int8* ptr = args->ptr();
+    unsigned __int8* end = &args->ptr()[args->length()];
+    unsigned ret = 0;
+    while(ptr < end) 
+    {
+        if (*ptr != ELEMENT_TYPE_SENTINEL) 
+        {
+            ptr = skipType(ptr, FALSE);
+            ret++;
+        }
+        else ptr++;
+    }
+    return(ret);
+}
+
+/********************************************************************************/
+AsmParse::AsmParse(ReadStream* aIn, Assembler *aAssem) 
+{
+#ifdef DEBUG_PARSING
+    extern int yydebug;
+    yydebug = 1;
+#endif
+
+    assem = aAssem;
+    assem->SetErrorReporter((ErrorReporter *)this);
+
+    assem->m_ulCurLine = 1;
+    assem->m_ulCurColumn = 1;
+    
+    wzIncludePath = NULL;
+    penv = NULL;
+
+    hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
+    hstderr = GetStdHandle(STD_ERROR_HANDLE);
+
+    success = true; 
+    _ASSERTE(parser == 0);          // Should only be one parser instance at a time
+
+   // Resolve aliases
+   for (unsigned int i = 0; i < sizeof(keywords) / sizeof(Keywords); i++)
+   {
+       if (keywords[i].token == NO_VALUE)
+           keywords[i].token = keywords[keywords[i].tokenVal].token;
+   }
+    SetSymbolTables();
+    Init_str2uint64();
+    parser = this;
+    //yyparse();
+}
+
+/********************************************************************************/
+AsmParse::~AsmParse() 
+{
+    parser = 0;
+    delete penv;
+    while(m_ANSLast.POP());
+}
+
+/**************************************************************************/
+DWORD AsmParse::IsItUnicode(CONST LPVOID pBuff, int cb, LPINT lpi)
+{
+    return IsTextUnicode(pBuff,cb,lpi);
+}
+
+/**************************************************************************/
+void AsmParse::CreateEnvironment(ReadStream* stream) 
+{ 
+    penv = new PARSING_ENVIRONMENT;
+    memset(penv,0,sizeof(PARSING_ENVIRONMENT));
+    penv->in = stream; 
+    penv->curLine = 1;
+    strcpy_s(penv->szFileName, MAX_FILENAME_LENGTH*3+1,assem->m_szSourceFileName); 
+    
+    penv->curPos = fillBuff(NULL);
+    penv->uCodePage = g_uCodePage;
+    
+    SetFunctionPtrs();
+};
+
+/**************************************************************************/
+void AsmParse::ParseFile(ReadStream* stream) 
+{ 
+    CreateEnvironment(stream);
+    yyparse(); 
+    penv->in = NULL; 
+};
+
+/**************************************************************************/
+char* AsmParse::fillBuff(__in_opt __nullterminated char* pos) 
+{
+    int iPutToBuffer;
+    int iOptions = IS_TEXT_UNICODE_UNICODE_MASK;
+    g_uCodePage = CP_ACP;
+    iPutToBuffer = (int)penv->in->getAll(&(penv->curPos));
+    
+    penv->endPos = penv->curPos + iPutToBuffer;
+    if(iPutToBuffer > 128) iPutToBuffer = 128;
+    if(IsItUnicode(penv->curPos,iPutToBuffer,&iOptions))
+    {
+        g_uCodePage = CP_UTF8;
+        if(iOptions & IS_TEXT_UNICODE_SIGNATURE)
+        {
+            penv->curPos += 2;
+        }
+        if(assem->m_fReportProgress) printf("Source file is UNICODE\n\n");
+        penv->pfn_Sym = SymW;
+        penv->pfn_nextchar = nextcharW;
+        penv->pfn_NewStrFromToken = NewStrFromTokenW;
+        penv->pfn_NewStaticStrFromToken = NewStaticStrFromTokenW;
+        penv->pfn_GetDouble = GetDoubleW;
+    }
+    else
+    {
+        if(((penv->curPos[0]&0xFF)==0xEF)&&((penv->curPos[1]&0xFF)==0xBB)&&((penv->curPos[2]&0xFF)==0xBF))
+        {
+            g_uCodePage = CP_UTF8;
+            penv->curPos += 3;
+            if(assem->m_fReportProgress) printf("Source file is UTF-8\n\n");
+            penv->pfn_nextchar = nextcharU;
+        }
+        else
+        {
+            if(assem->m_fReportProgress) printf("Source file is ANSI\n\n");
+            penv->pfn_nextchar = nextcharA;
+        }    
+        penv->pfn_Sym = SymAU;
+        penv->pfn_NewStrFromToken = NewStrFromTokenAU;
+        penv->pfn_NewStaticStrFromToken = NewStaticStrFromTokenAU;
+        penv->pfn_GetDouble = GetDoubleAU;
+    }
+    return(penv->curPos);
+}
+
+/********************************************************************************/
+BinStr* AsmParse::MakeSig(unsigned callConv, BinStr* retType, BinStr* args, int ntyargs) 
+{
+    _ASSERTE((ntyargs != 0) == ((callConv & IMAGE_CEE_CS_CALLCONV_GENERIC) != 0));
+    BinStr* ret = new BinStr();
+    if(ret)
+    {
+        //if (retType != 0) 
+        ret->insertInt8(callConv);
+        if (ntyargs != 0)
+            corEmitInt(ret, ntyargs);
+        corEmitInt(ret, corCountArgs(args));
+
+        if (retType != 0) 
+        {
+            ret->append(retType); 
+            delete retType;
+        }
+        ret->append(args); 
+    }
+    else
+        error("\nOut of memory!\n");
+
+    delete args;
+    return(ret);
+}
+
+/********************************************************************************/
+BinStr* AsmParse::MakeTypeArray(CorElementType kind, BinStr* elemType, BinStr* bounds) 
+{
+    // 'bounds' is a binary buffer, that contains an array of 'struct Bounds' 
+    struct Bounds {
+        int lowerBound;
+        unsigned numElements;
+    };
+
+    _ASSERTE(bounds->length() % sizeof(Bounds) == 0);
+    unsigned boundsLen = bounds->length() / sizeof(Bounds);
+    _ASSERTE(boundsLen > 0);
+    Bounds* boundsArr = (Bounds*) bounds->ptr();
+
+    BinStr* ret = new BinStr();
+
+    ret->appendInt8(kind);
+    ret->append(elemType);
+    corEmitInt(ret, boundsLen);                     // emit the rank
+
+    unsigned lowerBoundsDefined = 0;
+    unsigned numElementsDefined = 0;
+    unsigned i;
+    for(i=0; i < boundsLen; i++) 
+    {
+        if(boundsArr[i].lowerBound < 0x7FFFFFFF) lowerBoundsDefined = i+1;
+        else boundsArr[i].lowerBound = 0;
+
+        if(boundsArr[i].numElements < 0x7FFFFFFF) numElementsDefined = i+1;
+        else boundsArr[i].numElements = 0;
+    }
+
+    corEmitInt(ret, numElementsDefined);                    // emit number of bounds
+
+    for(i=0; i < numElementsDefined; i++) 
+    {
+        _ASSERTE (boundsArr[i].numElements >= 0);               // enforced at rule time
+        corEmitInt(ret, boundsArr[i].numElements);
+
+    }
+
+    corEmitInt(ret, lowerBoundsDefined);    // emit number of lower bounds
+    for(i=0; i < lowerBoundsDefined; i++)
+        {
+                unsigned cnt = CorSigCompressSignedInt(boundsArr[i].lowerBound, ret->getBuff(5));
+                ret->remove(5 - cnt);
+        }
+    delete elemType;
+    delete bounds;
+    return(ret);
+}
+
+/********************************************************************************/
+BinStr* AsmParse::MakeTypeClass(CorElementType kind, mdToken tk) 
+{
+
+    BinStr* ret = new BinStr();
+    _ASSERTE(kind == ELEMENT_TYPE_CLASS || kind == ELEMENT_TYPE_VALUETYPE ||
+                     kind == ELEMENT_TYPE_CMOD_REQD || kind == ELEMENT_TYPE_CMOD_OPT);
+    ret->appendInt8(kind);
+    unsigned cnt = CorSigCompressToken(tk, ret->getBuff(5));
+    ret->remove(5 - cnt);
+    return(ret);
+}
+/**************************************************************************/
+void PrintANSILine(FILE* pF, __in __nullterminated char* sz)
+{
+        WCHAR *wz = &wzUniBuf[0];
+        if(g_uCodePage != CP_ACP)
+        {
+                memset(wz,0,dwUniBuf); // dwUniBuf/2 WCHARs = dwUniBuf bytes
+                WszMultiByteToWideChar(g_uCodePage,0,sz,-1,wz,(dwUniBuf >> 1)-1);
+
+                memset(sz,0,dwUniBuf);
+                WszWideCharToMultiByte(g_uConsoleCP,0,wz,-1,sz,dwUniBuf-1,NULL,NULL);
+        }
+        fprintf(pF,"%s",sz);
+}
+/**************************************************************************/
+void AsmParse::error(const char* fmt, ...)
+{
+    char *sz = (char*)(&wzUniBuf[(dwUniBuf >> 1)]);
+    char *psz=&sz[0];
+    FILE* pF = ((!assem->m_fReportProgress)&&(assem->OnErrGo)) ? stdout : stderr;
+    success = false;
+    va_list args;
+    va_start(args, fmt);
+
+    if((penv) && (penv->in)) psz+=sprintf_s(psz, (dwUniBuf >> 1), "%S(%d) : ", penv->in->namew(), penv->curLine);
+    psz+=sprintf_s(psz, (dwUniBuf >> 1), "error : ");
+    _vsnprintf_s(psz, (dwUniBuf >> 1),(dwUniBuf >> 1)-strlen(sz)-1, fmt, args);
+    PrintANSILine(pF,sz);
+}
+
+/**************************************************************************/
+void AsmParse::warn(const char* fmt, ...)
+{
+    char *sz = (char*)(&wzUniBuf[(dwUniBuf >> 1)]);
+    char *psz=&sz[0];
+    FILE* pF = ((!assem->m_fReportProgress)&&(assem->OnErrGo)) ? stdout : stderr;
+    va_list args;
+    va_start(args, fmt);
+
+    if((penv) && (penv->in)) psz+=sprintf_s(psz, (dwUniBuf >> 1), "%S(%d) : ", penv->in->namew(), penv->curLine);
+    psz+=sprintf_s(psz, (dwUniBuf >> 1), "warning : ");
+    _vsnprintf_s(psz, (dwUniBuf >> 1),(dwUniBuf >> 1)-strlen(sz)-1, fmt, args);
+    PrintANSILine(pF,sz);
+}
+/**************************************************************************/
+void AsmParse::msg(const char* fmt, ...)
+{
+    char *sz = (char*)(&wzUniBuf[(dwUniBuf >> 1)]);
+    va_list args;
+    va_start(args, fmt);
+
+    _vsnprintf_s(sz, (dwUniBuf >> 1),(dwUniBuf >> 1)-1, fmt, args);
+    PrintANSILine(stdout,sz);
+}
+
+#ifdef _MSC_VER
+#pragma warning(default : 4640)
+#endif
diff --git a/src/ilasm/grammar_before.cpp b/src/ilasm/grammar_before.cpp
new file mode 100644
index 0000000000..60d6b57b3b
--- /dev/null
+++ b/src/ilasm/grammar_before.cpp
@@ -0,0 +1,150 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+#include <asmparse.h>
+#include <assembler.h>
+
+// Disable the "initialization of static local vars is no thread safe" error
+#ifdef _MSC_VER
+#pragma warning(disable : 4640)
+#endif
+
+#define YYMAXDEPTH 0x80000
+//#define YYRECURSIVE
+
+//#define DEBUG_PARSING
+#ifdef DEBUG_PARSING
+bool parseDBFlag = true;
+#define dbprintf(x)     if (parseDBFlag) printf x
+#define YYDEBUG 1
+#else
+#define dbprintf(x)     
+#endif
+
+#define FAIL_UNLESS(cond, msg) if (!(cond)) { parser->success = false; parser->error msg; }
+
+static AsmParse* parser = 0;
+#define PASM    (parser->assem)
+#define PASMM   (parser->assem->m_pManifest)
+#define PENV    (parser->penv)
+
+#if (0)
+
+#define nextchar                parser->penv->pfn_nextchar
+#define Sym                     parser->penv->pfn_Sym
+#define NewStrFromToken         parser->penv->pfn_NewStrFromToken
+#define NewStaticStrFromToken   parser->penv->pfn_NewStaticStrFromToken
+#define GetDouble               parser->penv->pfn_GetDouble
+
+void SetFunctionPtrs() {;}
+
+#else
+
+
+PFN_NEXTCHAR    nextchar;
+PFN_SYM         Sym;
+PFN_NEWSTRFROMTOKEN NewStrFromToken;
+PFN_NEWSTATICSTRFROMTOKEN NewStaticStrFromToken;
+PFN_GETDOUBLE   GetDouble;
+
+void SetFunctionPtrs()
+{
+    nextchar = PENV->pfn_nextchar;
+    Sym = PENV->pfn_Sym;
+    NewStrFromToken = PENV->pfn_NewStrFromToken;
+    NewStaticStrFromToken = PENV->pfn_NewStaticStrFromToken;
+    GetDouble = PENV->pfn_GetDouble;
+}    
+    
+#endif    
+
+static char* newStringWDel(__in __nullterminated char* str1, char delimiter, __in __nullterminated char* str3 = 0);
+static char* newString(__in __nullterminated char* str1);
+static void corEmitInt(BinStr* buff, unsigned data);
+static void AppendStringWithLength(BinStr* pbs, __in __nullterminated char* sz);
+bool bParsingByteArray = FALSE;
+int iOpcodeLen = 0;
+int iCallConv = 0;
+unsigned IfEndif = 0;
+unsigned IfEndifSkip = 0;
+unsigned nCustomBlobNVPairs = 0;
+unsigned nSecAttrBlobs = 0;
+unsigned  nCurrPC = 0;
+BOOL SkipToken = FALSE;
+BOOL neg = FALSE;
+BOOL newclass = FALSE;
+
+extern unsigned int g_uConsoleCP;
+
+struct VarName
+{
+    char* name;
+    BinStr* pbody;
+    VarName(__in_opt __nullterminated char* sz, BinStr* pbs) { name = sz; pbody = pbs; };
+    ~VarName() { delete [] name; delete pbody; };
+    int ComparedTo(VarName* pN) { return strcmp(name,pN->name); };
+};
+SORTEDARRAY<VarName> VarNameList;
+void DefineVar(__in __nullterminated char* sz, BinStr* pbs) { VarNameList.PUSH(new VarName(sz,pbs)); };
+void UndefVar(__in __nullterminated char* sz) 
+{ 
+    CHECK_LOCAL_STATIC_VAR(static VarName VN(NULL,NULL)); 
+
+    VN.name = sz; 
+    VarNameList.DEL(&VN); 
+    VN.name = NULL; 
+    delete [] sz;
+}
+VarName* FindVarDef(__in __nullterminated char* sz)
+{
+    CHECK_LOCAL_STATIC_VAR(static VarName VN(NULL,NULL));
+
+    VarName* Ret = NULL;
+    VN.name = sz;
+    Ret = VarNameList.FIND(&VN);
+    VN.name = NULL; 
+    delete [] sz;
+    return Ret;
+}
+BOOL IsVarDefined(__in __nullterminated char* sz)
+{
+    return (FindVarDef(sz) != NULL);
+}
+
+int  nTemp=0;
+
+unsigned int uMethodBeginLine,uMethodBeginColumn;
+
+#define ELEMENT_TYPE_VARFIXUP ELEMENT_TYPE_MAX+2
+#define ELEMENT_TYPE_MVARFIXUP ELEMENT_TYPE_MAX+3
+
+FIFO<char> TyParFixupList;
+void FixupTyPars(PCOR_SIGNATURE pSig, ULONG cSig);
+void FixupTyPars(BinStr* pbstype);
+void FixupConstraints()
+{
+    if((TyParFixupList.COUNT()) && (PASM->m_TyParList))
+    {
+        TyParList* pTPL;
+        for(pTPL = PASM->m_TyParList; pTPL; pTPL=pTPL->Next())
+        {
+            mdToken* ptk;
+            for(ptk = (mdToken*)(pTPL->Bound()->ptr()); *ptk; ptk++)
+            {
+                if(TypeFromToken(*ptk)==mdtTypeSpec)
+                {
+                    PCOR_SIGNATURE pSig;
+                    ULONG cSig;
+                    PASM->m_pImporter->GetTypeSpecFromToken(*ptk,(PCCOR_SIGNATURE*)&pSig,&cSig);
+                    if((pSig)&&(cSig))
+                    {
+                        FixupTyPars(pSig,cSig);    
+                    } // end if((pSig)&&(cSig))
+                } // end if(TypeFromToken(*ptk)==mdtTypeSpec)
+            } //end for(ptk    
+        } // end for(pTPL
+    } //end if((TyParFixupList.COUNT()) 
+}
+
+#define SET_PA(x,y,z) {x = (CorAssemblyFlags)(((y) & ~afPA_FullMask)|(z)|afPA_Specified);}
diff --git a/src/ilasm/ilasm.nativeproj b/src/ilasm/ilasm.nativeproj
new file mode 100644
index 0000000000..318f3e9645
--- /dev/null
+++ b/src/ilasm/ilasm.nativeproj
@@ -0,0 +1,87 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="dogfood">
+  <!--*****************************************************-->
+  <!--This MSBuild project file was automatically generated-->
+  <!--from the original SOURCES/DIRS file by the KBC tool.-->
+  <!--*****************************************************-->
+  <!--Import the settings-->
+  <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.props" />
+  <!--Leaf project Properties-->
+  <PropertyGroup>
+    <LibCLib>$(ClrCrtLib)</LibCLib>
+    <CDefines>$(CDefines);UNICODE;_UNICODE;FEATURE_NO_HOST;SELF_NO_HOST;NO_HOST_CPP_EH_ONLY</CDefines>
+    <CDefines>$(CDefines);__TODO_PORT_TO_WRAPPERS__</CDefines>
+    <OutputName>ilasm</OutputName>
+    <FileToMarkForSigning>$(BinariesDirectory)\$(OutputName).exe</FileToMarkForSigning>
+    <TargetType>PROGRAM</TargetType>
+    <LinkSubsystem>console</LinkSubsystem>
+    <EntryPoint>wmain</EntryPoint>
+    <LinkLibIgnore>$(LinkLibIgnore),4078</LinkLibIgnore>
+    <LinkGenerateManifest>true</LinkGenerateManifest>
+    <LinkAdditionalOptions>$(LinkAdditionalOptions) /MANIFEST -HEAP:4194304 </LinkAdditionalOptions>
+    <LinkStackReserve>4194304</LinkStackReserve>
+    
+    <!-- PCH baloney -->
+    <EnableCxxPCHHeaders>true</EnableCxxPCHHeaders>
+    <PCHCompile>ilasmpch.cpp</PCHCompile>
+    <PCHHeader>ilasmpch.h</PCHHeader>
+
+  </PropertyGroup>
+  <!--Leaf Project Items-->
+  <ItemGroup>
+    <ProjectReference Include="$(ClrSrcDirectory)utilcode\dyncrtnohost\dyncrtnohost.nativeproj" />
+    <LinkPreCrtLibs Include="$(ClrLibPath)\utilcodenohost.lib" />
+    <ProjectReference Include="$(ClrSrcDirectory)md\hotdata\full\mdhotdata.nativeproj" />
+    <LinkPreCrtLibs Include="$(ClrLibPath)\MDHotData.lib" />
+  </ItemGroup>
+  <ItemGroup>
+    <TargetLib Include="$(ClrLibPath)\corguids.lib">
+      <ProjectReference>$(ClrSrcDirectory)inc\corguids.nativeproj</ProjectReference>
+    </TargetLib>
+    <TargetLib Include="$(ClrLibPath)\fusion.lib">
+      <ProjectReference>$(ClrSrcDirectory)dlls\fusion\fusion.nativeproj</ProjectReference>
+    </TargetLib>
+    <TargetLib Include="$(SdkLibPath)\mscoree.lib" />
+    <TargetLib Include="$(SdkLibPath)\ole32.lib" />
+    <TargetLib Include="$(SdkLibPath)\oleaut32.lib" />
+    <TargetLib Include="$(SdkLibPath)\user32.lib" />
+    <TargetLib Include="$(SdkLibPath)\uuid.lib" />
+  </ItemGroup>
+  <ItemGroup>
+    <RCResourceFile Include="native.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <CppCompile Include="assem.cpp" />
+    <CppCompile Include="writer.cpp" />
+    <CppCompile Include="writer_enc.cpp" />
+    <CppCompile Include="method.cpp" />
+    <CppCompile Include="asmman.cpp" />
+    <CppCompile Include="main.cpp" />
+    <CppCompile Include="assembler.cpp" />
+    <CppCompile Include="MscorpeSxS.cpp" />
+    <CppCompile Include="$(IntermediateOutputDirectory)\asmparse.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <DataFile Include="$(IntermediateOutputDirectory)\asmparse.grammar" />
+  </ItemGroup>
+  <!--Import the targets-->
+  <Import Project="$(_NTDRIVE)$(_NTROOT)\ndp\clr\clr.targets" />
+  
+  <PropertyGroup>
+    <BuildGeneratedDependsOn>
+      $(BuildGeneratedDependsOn);
+      GenerateAsmParseC
+    </BuildGeneratedDependsOn>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <Clean Include="$O\asmparse.c" />
+    <Clean Include="$O\asmparse.grammar" />
+  </ItemGroup>
+  <Target Name="GenerateAsmParseC"
+          Inputs="asmparse.y;asmparse.h;$(ClrSrcDirectory)inc\openum.h"
+          Outputs="$(IntermediateOutputDirectory)\asmparse.c;$(IntermediateOutputDirectory)\asmparse.grammar">
+    <Delete Files="$(IntermediateOutputDirectory)\asmparse.c;$(IntermediateOutputDirectory)\asmparse.grammar" />
+    <Exec Command="$(DevDivToolsBinPath)\yacc_ms.exe -o $(IntermediateOutputDirectory)\asmparse -i asmparse.y" StandardOutputImportance="Normal" />
+    <Exec Command="$(PerlCommand) extractGrammar.pl asmparse.y &gt; $(IntermediateOutputDirectory)\asmparse.grammar" StandardOutputImportance="Normal" />
+  </Target>
+</Project>
diff --git a/src/ilasm/ilasmpch.cpp b/src/ilasm/ilasmpch.cpp
new file mode 100644
index 0000000000..c4e6eb73de
--- /dev/null
+++ b/src/ilasm/ilasmpch.cpp
@@ -0,0 +1,6 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+
+#include "ilasmpch.h"
diff --git a/src/ilasm/ilasmpch.h b/src/ilasm/ilasmpch.h
new file mode 100644
index 0000000000..16d1cad64b
--- /dev/null
+++ b/src/ilasm/ilasmpch.h
@@ -0,0 +1,28 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+
+#if !defined(_ILASMPCH_H)
+#define _ILASMPCH_H
+#define NEW_INLINE_NAMES
+
+#include "cor.h"        // for CorMethodAttr ...
+#include <crtdbg.h>     // For _ASSERTE
+#include <corsym.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "utilcode.h"
+#include "debugmacros.h"
+#include "corpriv.h"
+
+#include "specstrings.h"
+#include <string.h>             // for strcmp    
+#include <mbstring.h>           // for _mbsinc    
+#include <ctype.h>                      // for isspace    
+#include "openum.h"             // for CEE_*
+#include <stdarg.h>         // for vararg macros 
+
+#endif
diff --git a/src/ilasm/main.cpp b/src/ilasm/main.cpp
new file mode 100644
index 0000000000..2bb06612a6
--- /dev/null
+++ b/src/ilasm/main.cpp
@@ -0,0 +1,904 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+// File:  main.cpp
+//
+
+//
+
+#include "ilasmpch.h"
+
+#include "asmparse.h"
+#include "ndpversion.h"
+#include "shimload.h"
+
+#include "strsafe.h"
+
+WCHAR* EqualOrColon(__in __nullterminated WCHAR* szArg)
+{
+    WCHAR* pchE = wcschr(szArg,L'=');
+    WCHAR* pchC = wcschr(szArg,L':');
+    WCHAR* ret;
+    if(pchE == NULL) ret = pchC;
+    else if(pchC == NULL) ret = pchE;
+    else ret = (pchE < pchC)? pchE : pchC;
+    return ret;
+}
+
+static DWORD    g_dwSubsystem=(DWORD)-1,g_dwComImageFlags=(DWORD)-1,g_dwFileAlignment=0,g_dwTestRepeat=0;
+static ULONGLONG   g_stBaseAddress=0;
+static size_t   g_stSizeOfStackReserve=0;
+extern unsigned int g_uConsoleCP;
+
+void MakeTestFile(__in __nullterminated char* szFileName)
+{
+    if(g_dwTestRepeat)
+    {
+        FILE* pF = NULL;
+        if(fopen_s(&pF,szFileName,"wt")==0 && pF != NULL)
+        {
+            printf("Making test file\n");
+            fprintf(pF,".assembly extern mscorlib {}\n");
+            fprintf(pF,".assembly test%d {}\n",g_dwTestRepeat);
+            fprintf(pF,".module test%d.exe\n",g_dwTestRepeat);
+            fprintf(pF,".method public static void Exec() { .entrypoint\n");
+            for(unsigned i=0; i<g_dwTestRepeat*1000; i++)
+            {
+                fprintf(pF,"ldc.i4.1\ncall void [mscorlib]System.Console::WriteLine(int32)\n");
+            }
+            fprintf(pF,"ret }\n");
+            fclose(pF);
+        }
+    }
+}
+
+void MakeProperSourceFileName(__in __nullterminated WCHAR* wzOrigName, 
+                              unsigned uCodePage, 
+                              __out_ecount(MAX_FILENAME_LENGTH) WCHAR* wzProperName, 
+                              __out_ecount(MAX_FILENAME_LENGTH*3) char* szProperName)
+{
+    wcscpy_s(wzProperName,MAX_FILENAME_LENGTH, wzOrigName);
+    size_t j = wcslen(wzProperName);
+    do
+    {
+        j--;
+        if(wzProperName[j] == '.') break;
+        if((wzProperName[j] == '\\')||(j == 0))
+        {
+            wcscat_s(wzProperName,MAX_FILENAME_LENGTH,L".il");
+            break;
+        }
+    }
+    while(j);
+    WszWideCharToMultiByte(uCodePage,0,wzProperName,-1,szProperName,MAX_FILENAME_LENGTH*3-1,NULL,NULL);
+}
+
+char* FullFileName(__in __nullterminated WCHAR* wzFileName, unsigned uCodePage)
+{
+    static WCHAR wzFullPath[MAX_FILENAME_LENGTH];
+    WCHAR* pwz;
+    WszGetFullPathName(wzFileName,MAX_FILENAME_LENGTH,wzFullPath,&pwz);
+    char szFullPath[MAX_FILENAME_LENGTH*3];
+    WszWideCharToMultiByte(uCodePage,0,wzFullPath,-1,szFullPath,MAX_FILENAME_LENGTH*3-1,NULL,NULL);
+    char* sz = new char[strlen(szFullPath)+1];
+    if(sz) strcpy_s(sz,strlen(szFullPath)+1,szFullPath);
+    return sz;
+}
+
+WCHAR       *pwzInputFiles[1024];
+WCHAR       *pwzDeltaFiles[1024];
+
+char        szInputFilename[MAX_FILENAME_LENGTH*3];
+WCHAR       wzInputFilename[MAX_FILENAME_LENGTH];
+WCHAR       wzOutputFilename[MAX_FILENAME_LENGTH];
+WCHAR       wzIncludePathBuffer[MAX_FILENAME_LENGTH];
+
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
+#endif
+extern "C" int _cdecl wmain(int argc, __in WCHAR **argv)
+{
+    int         i, NumFiles = 0, NumDeltaFiles = 0;
+    bool        IsDLL = false, IsOBJ = false;
+    char        szOpt[128];
+    Assembler   *pAsm;
+    MappedFileStream *pIn;
+    AsmParse    *pParser;
+    int         exitval=1;
+    bool        bLogo = TRUE;
+    bool        bReportProgress = TRUE;
+    BOOL        bNoDebug = TRUE;
+    WCHAR*      wzIncludePath = NULL;
+    int exitcode = 0;
+    unsigned    uCodePage;
+
+    bool bClock = false;
+    Clockwork   cw;
+
+    // SWI has requested that the exact form of the function call below be used. For details
+    // see http://swi/SWI%20Docs/Detecting%20Heap%20Corruption.doc
+    (void)HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
+
+    memset(pwzInputFiles,0,1024*sizeof(WCHAR*));
+    memset(pwzDeltaFiles,0,1024*sizeof(WCHAR*));
+    memset(&cw,0,sizeof(Clockwork));
+    cw.cBegin = GetTickCount();
+
+    g_uConsoleCP = GetConsoleOutputCP();
+    memset(wzOutputFilename,0,sizeof(wzOutputFilename));
+
+#ifdef _DEBUG
+    DisableThrowCheck();
+    //CONTRACT_VIOLATION(ThrowsViolation);
+#endif
+
+    if(argc < 2) goto ErrorExit;
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:26000) // "Suppress prefast warning about index overflow"
+#endif
+    if (! wcscmp(argv[1], L"/?") || ! wcscmp(argv[1],L"-?"))
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif    
+    {
+        printf("\nMicrosoft (R) .NET Framework IL Assembler version " VER_FILEVERSION_STR);
+        printf("\n%S\n\n", VER_LEGALCOPYRIGHT_LOGO_STR_L);
+        goto PrintUsageAndExit;
+
+    ErrorExit:
+      exitcode = 1;
+    PrintUsageAndExit:
+      printf("\n\nUsage: ilasm [Options] <sourcefile> [Options]");
+      printf("\n\nOptions:");
+      printf("\n/NOLOGO         Don't type the logo");
+      printf("\n/QUIET          Don't report assembly progress");
+      printf("\n/NOAUTOINHERIT  Disable inheriting from System.Object by default");
+      printf("\n/DLL            Compile to .dll");
+      printf("\n/EXE            Compile to .exe (default)");
+      printf("\n/PDB            Create the PDB file without enabling debug info tracking");
+      printf("\n/APPCONTAINER   Create an AppContainer exe or dll");
+      printf("\n/DEBUG          Disable JIT optimization, create PDB file, use sequence points from PDB");
+      printf("\n/DEBUG=IMPL     Disable JIT optimization, create PDB file, use implicit sequence points");
+      printf("\n/DEBUG=OPT      Enable JIT optimization, create PDB file, use implicit sequence points");
+      printf("\n/OPTIMIZE       Optimize long instructions to short");
+      printf("\n/FOLD           Fold the identical method bodies into one");
+      printf("\n/CLOCK          Measure and report compilation times");
+//      printf("\n/ERROR          Try to create .exe or .dll file despite errors reported");
+//      printf("\n       Warning! Results are unpredictable, use this option at your own risk!");
+      printf("\n/RESOURCE=<res_file>    Link the specified resource file (*.res) \n\t\t\tinto resulting .exe or .dll");
+      printf("\n/OUTPUT=<targetfile>    Compile to file with specified name \n\t\t\t(user must provide extension, if any)");
+      printf("\n/KEY=<keyfile>      Compile with strong signature \n\t\t\t(<keyfile> contains private key)");
+      printf("\n/KEY=@<keysource>   Compile with strong signature \n\t\t\t(<keysource> is the private key source name)");
+      printf("\n/INCLUDE=<path>     Set path to search for #include'd files");
+      printf("\n/SUBSYSTEM=<int>    Set Subsystem value in the NT Optional header");
+      printf("\n/SSVER=<int>.<int>  Set Subsystem version number in the NT Optional header");
+      printf("\n/FLAGS=<int>        Set CLR ImageFlags value in the CLR header");
+      printf("\n/ALIGNMENT=<int>    Set FileAlignment value in the NT Optional header");
+      printf("\n/BASE=<int>     Set ImageBase value in the NT Optional header (max 2GB for 32-bit images)");
+      printf("\n/STACK=<int>    Set SizeOfStackReserve value in the NT Optional header");
+      printf("\n/MDV=<version_string>   Set Metadata version string");
+      printf("\n/MSV=<int>.<int>   Set Metadata stream version (<major>.<minor>)");
+      printf("\n/PE64           Create a 64bit image (PE32+)");
+      printf("\n/HIGHENTROPYVA  Set High Entropy Virtual Address capable PE32+ images (default for /APPCONTAINER)");
+      printf("\n/NOCORSTUB      Suppress generation of CORExeMain stub");
+      printf("\n/STRIPRELOC     Indicate that no base relocations are needed");
+      printf("\n/ITANIUM        Target processor: Intel Itanium");
+      printf("\n/X64            Target processor: 64bit AMD processor");
+      printf("\n/ARM            Target processor: ARM processor");
+      printf("\n/32BITPREFERRED Create a 32BitPreferred image (PE32)");
+      printf("\n/ENC=<file>     Create Edit-and-Continue deltas from specified source file");
+      
+      printf("\n\nKey may be '-' or '/'\nOptions are recognized by first 3 characters\nDefault source file extension is .il\n");
+
+      printf("\nTarget defaults:");
+      printf("\n/PE64      => /PE64 /ITANIUM");
+      printf("\n/ITANIUM   => /PE64 /ITANIUM");
+      printf("\n/X64       => /PE64 /X64");
+
+      printf("\n\n");
+      exit(exitcode);
+    }
+
+    uCodePage = CP_UTF8;
+    WszSetEnvironmentVariable(L"COMP_ENC_OPENSCOPE", L"");
+    WszSetEnvironmentVariable(L"COMP_ENC_EMIT", L"");
+    if((pAsm = new Assembler()))
+    {
+        pAsm->SetCodePage(uCodePage);
+        //if(pAsm->Init())
+        {
+            pAsm->SetStdMapping(1);
+            //-------------------------------------------------
+            for (i = 1; i < argc; i++)
+            {
+                if((argv[i][0] == L'/') || (argv[i][0] == L'-'))
+                {
+                    memset(szOpt,0,sizeof(szOpt));
+                    WszWideCharToMultiByte(uCodePage,0,&argv[i][1],-1,szOpt,sizeof(szOpt),NULL,NULL);
+                    szOpt[3] = 0;
+                    if (!_stricmp(szOpt,"NOA"))
+                    {
+                        pAsm->m_fAutoInheritFromObject = FALSE;
+                    }
+                    else if (!_stricmp(szOpt,"QUI"))
+                    {
+                        pAsm->m_fReportProgress = FALSE;
+                        bReportProgress = FALSE;
+                        bLogo = FALSE;
+                    }
+                    else if (!_stricmp(szOpt, "NOL"))
+                    {
+                        bLogo = FALSE;
+                    }
+                    else if (!_stricmp(szOpt, "FOL"))
+                    {
+                      pAsm->m_fFoldCode = TRUE;
+                    }
+                    else if (!_stricmp(szOpt, "DEB"))
+                    {
+                      pAsm->m_dwIncludeDebugInfo = 0x101;
+                      pAsm->m_fGeneratePDB = TRUE;
+                      bNoDebug = FALSE;
+
+                      WCHAR *pStr = EqualOrColon(argv[i]);
+                      if(pStr != NULL)
+                      {
+                          for(pStr++; *pStr == L' '; pStr++); //skip the blanks
+                          if(wcslen(pStr)==0) goto InvalidOption; //if no suboption
+                          else
+                          {
+                              WCHAR wzSubOpt[8];
+                              wcsncpy_s(wzSubOpt,8,pStr,3);
+                              wzSubOpt[3] = 0;
+                              if(0 == _wcsicmp(wzSubOpt,L"OPT"))
+                                pAsm->m_dwIncludeDebugInfo = 0x3;
+                              else if(0 == _wcsicmp(wzSubOpt,L"IMP"))
+                                pAsm->m_dwIncludeDebugInfo = 0x103;
+                              else 
+                              {
+                                WCHAR *pFmt =((*pStr == '0')&&(*(pStr+1) == 'x'))? L"%lx" : L"%ld";
+                                if(swscanf_s(pStr,pFmt,&(pAsm->m_dwIncludeDebugInfo))!=1)
+                                goto InvalidOption; // bad subooption
+                              }
+                          }
+                      }
+                    }
+                    else if (!_stricmp(szOpt, "PDB"))
+                    {
+                      pAsm->m_fGeneratePDB = TRUE;
+                      bNoDebug = FALSE;
+                    }
+                    else if (!_stricmp(szOpt, "CLO"))
+                    {
+                      bClock = true;
+                      pAsm->SetClock(&cw);
+                    }
+                    else if (!_stricmp(szOpt, "DLL"))
+                    {
+                      IsDLL = true; IsOBJ = false;
+                    }
+                    else if (!_stricmp(szOpt, "OBJ"))
+                    {
+                      //IsOBJ = true; IsDLL = false;
+                      printf("Option /OBJECT is not supported.\n");
+                      goto ErrorExit;
+                    }
+                    else if (!_stricmp(szOpt, "ERR"))
+                    {
+                      pAsm->OnErrGo = true;
+                    }
+                    else if (!_stricmp(szOpt, "EXE"))
+                    {
+                      IsDLL = false;
+                    }
+                    else if (!_stricmp(szOpt, "APP"))
+                    {
+                        pAsm->m_fAppContainer = TRUE;
+                    }
+                    else if (!_stricmp(szOpt, "HIG"))
+                    {
+                        pAsm->m_fHighEntropyVA = TRUE;
+                    }
+                    else if (!_stricmp(szOpt, "OPT"))
+                    {
+                      pAsm->m_fOptimize = TRUE;
+                    }
+                    else if (!_stricmp(szOpt, "ITA"))
+                    {
+                      pAsm->m_dwCeeFileFlags &= ~ICEE_CREATE_MACHINE_MASK;
+                      pAsm->m_dwCeeFileFlags |= ICEE_CREATE_MACHINE_IA64;
+                    }
+                    else if (!_stricmp(szOpt, "X64"))
+                    {
+                      pAsm->m_dwCeeFileFlags &= ~ICEE_CREATE_MACHINE_MASK;        
+                      pAsm->m_dwCeeFileFlags |= ICEE_CREATE_MACHINE_AMD64;
+                    }
+                    else if (!_stricmp(szOpt, "ARM"))
+                    {
+                      pAsm->m_dwCeeFileFlags &= ~ICEE_CREATE_MACHINE_MASK;        
+                      pAsm->m_dwCeeFileFlags |= ICEE_CREATE_MACHINE_ARM;
+                    }
+                    else if (!_stricmp(szOpt, "32B"))
+                    {
+                        if (g_dwComImageFlags == (DWORD)-1)
+                            g_dwComImageFlags = pAsm->m_dwComImageFlags;
+                        COR_SET_32BIT_PREFERRED(g_dwComImageFlags);
+                    }
+                    else if (!_stricmp(szOpt, "PE6"))
+                    {
+                      pAsm->m_dwCeeFileFlags &= ~ICEE_CREATE_FILE_PE32;
+                      pAsm->m_dwCeeFileFlags |= ICEE_CREATE_FILE_PE64;
+                    }
+                    else if (!_stricmp(szOpt, "NOC"))
+                    {
+                      pAsm->m_dwCeeFileFlags &= ~ICEE_CREATE_FILE_CORMAIN_STUB;
+                    }
+                    else if (!_stricmp(szOpt, "STR"))
+                    {
+                      pAsm->m_dwCeeFileFlags |= ICEE_CREATE_FILE_STRIP_RELOCS;
+                    }
+                    else if (!_stricmp(szOpt, "OPT"))
+                    {
+                      pAsm->m_fOptimize = TRUE;
+                    }
+                    else if (!_stricmp(szOpt, "LIS"))
+                    {
+                        printf("Option /LISTING is not supported, use ILDASM.EXE\n");
+                    }
+                    else if (!_stricmp(szOpt, "RES"))
+                    {
+                        if(pAsm->m_wzResourceFile==NULL)
+                        {
+                            WCHAR *pStr = EqualOrColon(argv[i]);
+                            if(pStr == NULL) goto ErrorExit;
+                            for(pStr++; *pStr == L' '; pStr++); //skip the blanks
+                            if(wcslen(pStr)==0) goto InvalidOption; //if no file name
+                            pAsm->m_wzResourceFile = pStr;
+                        }
+                        else
+                            printf("Multiple resource files not allowed. Option %ls skipped\n",argv[i]);
+                    }
+                    else if (!_stricmp(szOpt, "KEY"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        for(pStr++; *pStr == L' '; pStr++); //skip the blanks
+                        if(wcslen(pStr)==0) goto InvalidOption; //if no file name
+                        pAsm->m_wzKeySourceName = pStr;
+                    }
+                    else if (!_stricmp(szOpt, "INC"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        for(pStr++; *pStr == L' '; pStr++); //skip the blanks
+                        if(wcslen(pStr)==0) goto InvalidOption; //if no file name
+                        wzIncludePath = pStr;
+                    }
+                    else if (!_stricmp(szOpt, "OUT"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        for(pStr++; *pStr == L' '; pStr++); //skip the blanks
+                        if(wcslen(pStr)==0) goto InvalidOption; //if no file name
+                        if(wcslen(pStr) >= MAX_FILENAME_LENGTH)
+                        {
+                            fprintf(stderr,"\nError: Output file name exceeds %d characters\n",MAX_FILENAME_LENGTH-1);
+                            goto ErrorExit;
+                        }
+                        wcscpy_s(wzOutputFilename,MAX_FILENAME_LENGTH,pStr);
+                    }
+                    else if (!_stricmp(szOpt, "MDV"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        for(pStr++; *pStr == L' '; pStr++); //skip the blanks
+                        if(wcslen(pStr)==0) goto InvalidOption; //if no version string
+                        pAsm->m_wzMetadataVersion = pStr;
+                    }
+                    else if (!_stricmp(szOpt, "MSV"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        for(pStr++; *pStr == L' '; pStr++); //skip the blanks
+                        if(wcslen(pStr)==0) goto InvalidOption; //if no version
+                        {
+                            int major=-1,minor=-1;
+                            if(swscanf_s(pStr,L"%d.%d",&major, &minor)==2)
+                            {
+                                if((major >= 0)&&(major < 0xFF))
+                                    pAsm->m_wMSVmajor = (WORD)major;
+                                if((minor >= 0)&&(minor < 0xFF))
+                                    pAsm->m_wMSVminor = (WORD)minor;
+                            }
+                        }
+                    }
+                    else if (!_stricmp(szOpt, "ENC"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        for(pStr++; *pStr == L' '; pStr++); //skip the blanks
+                        if(wcslen(pStr)==0) goto InvalidOption; //if no file name
+                        pwzDeltaFiles[NumDeltaFiles++] = pStr;
+                        pAsm->m_fTolerateDupMethods = TRUE;
+                    }
+                    else if (!_stricmp(szOpt, "SUB"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        pStr++;
+                        WCHAR *pFmt = ((*pStr=='0')&&(*(pStr+1) == 'x'))? L"%lx" : L"%ld";
+                        if(swscanf_s(pStr,pFmt,&g_dwSubsystem)!=1) goto InvalidOption;
+                    }
+                    else if (!_stricmp(szOpt, "SSV"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        for(pStr++; *pStr == L' '; pStr++); //skip the blanks
+                        if(wcslen(pStr)==0) goto InvalidOption; //if no version
+                        {
+                            int major=-1,minor=-1;
+                            if(swscanf_s(pStr,L"%d.%d",&major, &minor)==2)
+                            {
+                                if((major >= 0)&&(major < 0xFFFF))
+                                    pAsm->m_wSSVersionMajor = (WORD)major;
+                                if((minor >= 0)&&(minor < 0xFFFF))
+                                    pAsm->m_wSSVersionMinor = (WORD)minor;
+                            } else 
+                                goto InvalidOption;
+                        }
+                    }
+                    else if (!_stricmp(szOpt, "ALI"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        pStr++;
+                        WCHAR *pFmt = ((*pStr=='0')&&(*(pStr+1) == 'x'))? L"%lx" : L"%ld";
+                        if(swscanf_s(pStr,pFmt,&g_dwFileAlignment)!=1) goto InvalidOption;
+                        if((g_dwFileAlignment & (g_dwFileAlignment-1))
+                           || (g_dwFileAlignment < 0x200) || (g_dwFileAlignment > 0x10000))
+                        {
+                            fprintf(stderr,"\nFile Alignment must be power of 2 from 0x200 to 0x10000\n");
+                            if(!pAsm->OnErrGo) goto InvalidOption;
+                        }
+                    }
+                    else if (!_stricmp(szOpt, "FLA"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        pStr++;
+                        WCHAR *pFmt = ((*pStr=='0')&&(*(pStr+1) == 'x'))? L"%lx" : L"%ld";
+                        if(swscanf_s(pStr,pFmt,&g_dwComImageFlags)!=1) goto InvalidOption;
+                    }
+                    else if (!_stricmp(szOpt, "BAS"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        pStr++;
+                        WCHAR *pFmt = ((*pStr=='0')&&(*(pStr+1) == 'x'))? L"%I64x" : L"%I64d";
+                        if(swscanf_s(pStr,pFmt,&g_stBaseAddress)!=1) goto InvalidOption;
+                        if(g_stBaseAddress & 0xFFFF)
+                        {
+                            fprintf(stderr,"\nBase address must be 0x10000-aligned\n");
+                            if(!pAsm->OnErrGo) goto InvalidOption;
+                        }
+                    }
+                    else if (!_stricmp(szOpt, "STA"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        pStr++;
+                        WCHAR *pFmt = ((*pStr=='0')&&(*(pStr+1) == 'x'))? L"%lx" : L"%ld";
+                        if(swscanf_s(pStr,pFmt,&g_stSizeOfStackReserve)!=1) goto InvalidOption;
+                    }
+#ifdef _SPECIAL_INTERNAL_USE_ONLY
+                    else if (!_stricmp(szOpt, "TES"))
+                    {
+                        WCHAR *pStr = EqualOrColon(argv[i]);
+                        if(pStr == NULL) goto InvalidOption;
+                        pStr++;
+                        WCHAR *pFmt = ((*pStr=='0')&&(*(pStr+1) == 'x'))? L"%lx" : L"%ld";
+                        if(swscanf_s(pStr,pFmt,&g_dwTestRepeat)!=1) goto InvalidOption;
+                    }
+#endif
+                    else
+                    {
+                    InvalidOption:
+                        fprintf(stderr, "Error : Invalid Option: %LS\n", argv[i]);
+                        goto ErrorExit;
+                    }
+                }
+                else
+                {
+                    if(wcslen(argv[i]) >= MAX_FILENAME_LENGTH)
+                    {
+                        printf("\nError: Input file name exceeds %d characters\n",MAX_FILENAME_LENGTH-1);
+                        goto ErrorExit;
+                    }
+                    pwzInputFiles[NumFiles++] = argv[i];
+                    if(NumFiles == 1)
+                    {
+                        MakeProperSourceFileName(argv[i], uCodePage, wzInputFilename, szInputFilename);
+                    }
+                }
+
+            }
+            if(NumFiles == 0)
+            {
+                delete pAsm;
+                goto ErrorExit;
+            }
+            if(pAsm->m_dwCeeFileFlags & ICEE_CREATE_FILE_PE64)
+            {
+                if((pAsm->m_dwCeeFileFlags & ICEE_CREATE_MACHINE_I386)
+                   ||(pAsm->m_dwCeeFileFlags & ICEE_CREATE_MACHINE_ARM))
+                {
+                    printf("\nMachine type /ITANIUM or /X64 must be specified for 64 bit targets.");
+                    if(!pAsm->OnErrGo)
+                    {
+                        pAsm->m_dwCeeFileFlags &= ~ICEE_CREATE_MACHINE_MASK;
+                        pAsm->m_dwCeeFileFlags |= ICEE_CREATE_MACHINE_IA64;
+                        printf(" Type set to ITANIUM.");
+                    }
+                    printf("\n");
+                }
+            }
+            else
+            {
+                if((pAsm->m_dwCeeFileFlags & ICEE_CREATE_MACHINE_IA64)
+                  ||(pAsm->m_dwCeeFileFlags & ICEE_CREATE_MACHINE_AMD64))
+                {
+                    printf("\n64 bit target must be specified for machine type /ITANIUM or /X64.");
+                    if(!pAsm->OnErrGo)
+                    {
+                        pAsm->m_dwCeeFileFlags &= ~ICEE_CREATE_FILE_PE32;
+                        pAsm->m_dwCeeFileFlags |= ICEE_CREATE_FILE_PE64;
+                        printf(" Target set to 64 bit.");
+                    }
+                    printf("\n");
+                }
+            }
+            if((pAsm->m_dwCeeFileFlags & ICEE_CREATE_MACHINE_IA64))
+            {
+                pAsm->m_dwComImageFlags &= ~COMIMAGE_FLAGS_ILONLY;
+            }
+            if(pAsm->m_dwCeeFileFlags & ICEE_CREATE_FILE_PE32)
+            {
+                if(g_stBaseAddress > 0x80000000)
+                {
+                    fprintf(stderr,"Invalid Image Base specified for 32-bit target\n");
+                    delete pAsm;
+                    goto ErrorExit;
+                }
+            }
+            if (COR_IS_32BIT_PREFERRED(pAsm->m_dwComImageFlags) &&
+                ((pAsm->m_dwCeeFileFlags & ICEE_CREATE_FILE_PE64) ||
+                 ((pAsm->m_dwCeeFileFlags & ICEE_CREATE_FILE_PE32) == 0) ||
+                 ((pAsm->m_dwCeeFileFlags & ICEE_CREATE_MACHINE_I386) == 0) ||
+                 ((pAsm->m_dwComImageFlags & COMIMAGE_FLAGS_ILONLY) == 0)))
+            {
+                fprintf(stderr,"/32BITPREFERRED valid only with PE32/X86/ILONLY images\n");
+                delete pAsm;
+                goto ErrorExit;
+            }
+            if(!pAsm->Init())
+            {
+                fprintf(stderr,"Failed to initialize Assembler\n");
+                delete pAsm;
+                goto ErrorExit;
+            }
+            if(g_dwTestRepeat)
+                MakeTestFile(szInputFilename);
+
+            if(wzOutputFilename[0] == 0)
+            {
+                wcscpy_s(wzOutputFilename,MAX_FILENAME_LENGTH,pwzInputFiles[0]);
+                size_t j = wcslen(wzOutputFilename);
+                do
+                {
+                    j--;
+                    if(wzOutputFilename[j] == L'.')
+                    {
+                        wzOutputFilename[j] = 0;
+                        break;
+                    }
+                }
+                while(j);
+                wcscat_s(wzOutputFilename, MAX_FILENAME_LENGTH,(IsDLL ? L".dll" : (IsOBJ ? L".obj" : L".exe")));
+            }
+            if(wzIncludePath == NULL)
+            {
+                if(0!=WszGetEnvironmentVariable(L"ILASM_INCLUDE",wzIncludePathBuffer,MAX_FILENAME_LENGTH))
+                    wzIncludePath = wzIncludePathBuffer;
+            }
+            //------------ Assembler initialization done. Now, to business -----------------------
+            if((pParser = new AsmParse(NULL, pAsm)))
+            {
+                uCodePage = CP_UTF8;
+                pAsm->SetCodePage(uCodePage);
+                pParser->SetIncludePath(wzIncludePath);
+                //======================================================================
+                if(bLogo)
+                {
+                    printf("\nMicrosoft (R) .NET Framework IL Assembler.  Version " VER_FILEVERSION_STR);
+                    printf("\n%S", VER_LEGALCOPYRIGHT_LOGO_STR_L);
+                }
+
+                pAsm->SetDLL(IsDLL);
+                pAsm->SetOBJ(IsOBJ);
+                wcscpy_s(pAsm->m_wzOutputFileName,MAX_FILENAME_LENGTH,wzOutputFilename);
+                strcpy_s(pAsm->m_szSourceFileName,MAX_FILENAME_LENGTH*3+1,szInputFilename);
+
+                if (SUCCEEDED(pAsm->InitMetaData()))
+                {
+                    int iFile;
+                    BOOL fAllFilesPresent = TRUE;
+                    if(bClock) cw.cParsBegin = GetTickCount();
+                    for(iFile = 0; iFile < NumFiles; iFile++)
+                    {
+                        uCodePage = CP_UTF8;
+                        pAsm->SetCodePage(uCodePage);
+                        if(iFile) // for the first file, it's already done
+                        {
+                            MakeProperSourceFileName(pwzInputFiles[iFile], uCodePage, wzInputFilename, szInputFilename);
+                        }
+                        if(pAsm->m_fReportProgress)
+                        {
+                            pParser->msg("\nAssembling '%s' ", szInputFilename);
+                            if(pAsm->m_fCPlusPlus)  pParser->msg(" C++");
+                            if(pAsm->m_fWindowsCE)  pParser->msg(" WINCE");
+                            if(!pAsm->m_fAutoInheritFromObject) pParser->msg(" NOAUTOINHERIT");
+                            pParser->msg(IsDLL ? " to DLL" : (IsOBJ? " to OBJ" : " to EXE"));
+                            //======================================================================
+                            if (pAsm->m_fStdMapping == FALSE)
+                                pParser->msg(", with REFERENCE mapping");
+
+                            {
+                                char szOutputFilename[MAX_FILENAME_LENGTH*3];
+                                memset(szOutputFilename,0,sizeof(szOutputFilename));
+                                WszWideCharToMultiByte(uCodePage,0,wzOutputFilename,-1,szOutputFilename,MAX_FILENAME_LENGTH*3-1,NULL,NULL);
+                                pParser->msg(" --> '%s'\n", szOutputFilename);
+                            }
+                        }
+                            
+                        pIn = new MappedFileStream(wzInputFilename);
+
+                        if ((!pIn) || !(pIn->IsValid()))
+                        {
+                            pParser->msg("Could not open %s\n", szInputFilename);
+                            fAllFilesPresent = FALSE;
+                        }
+                        else
+                        {
+                            DWORD dwBinType;
+                            if(GetBinaryTypeA(szInputFilename,&dwBinType))
+                            {
+                                pParser->msg("%s is not a text file\n",szInputFilename);
+                                fAllFilesPresent = FALSE;
+                            }
+                            else
+                            {
+                                pAsm->SetSourceFileName(FullFileName(wzInputFilename,uCodePage)); // deletes the argument!
+
+                                pParser->ParseFile(pIn);
+                            }
+                        }
+                        if(pIn)
+                        {
+                            pIn->set_namew(NULL);
+                            delete pIn;
+                        }
+                    } // end for(iFile)
+                    if(bClock) cw.cParsEnd = GetTickCount();
+                    if ((pParser->Success() && fAllFilesPresent) || pAsm->OnErrGo)
+                    {
+                        HRESULT hr;
+                        if(g_dwSubsystem  != (DWORD)-1)      pAsm->m_dwSubsystem = g_dwSubsystem;
+                        if(g_dwComImageFlags != (DWORD)-1)   pAsm->m_dwComImageFlags = g_dwComImageFlags;
+                        if(g_dwFileAlignment)   pAsm->m_dwFileAlignment = g_dwFileAlignment;
+                        if(g_stBaseAddress)     pAsm->m_stBaseAddress = g_stBaseAddress;
+                        if(g_stSizeOfStackReserve)     pAsm->m_stSizeOfStackReserve = g_stSizeOfStackReserve;
+                        if(FAILED(hr=pAsm->CreatePEFile(wzOutputFilename)))
+                            pParser->msg("Could not create output file, error code=0x%08X\n",hr);
+                        else
+                        {
+                            if(pAsm->m_fFoldCode && pAsm->m_fReportProgress)
+                                pParser->msg("%d methods folded\n",pAsm->m_dwMethodsFolded);
+                            if(pParser->Success() && fAllFilesPresent) exitval = 0;
+                            else
+                            {
+                                pParser->msg("Output file contains errors\n");
+                                if(pAsm->OnErrGo) exitval = 0;
+                            }
+                            if(exitval == 0) // Write the output file
+                            {
+                                if(bClock) cw.cFilegenEnd = GetTickCount();
+                                if(pAsm->m_fReportProgress) pParser->msg("Writing %s file\n", pAsm->m_fOBJ ? "COFF" : "PE");
+                                // Generate the file
+                                if (FAILED(hr = pAsm->m_pCeeFileGen->GenerateCeeFile(pAsm->m_pCeeFile)))
+                                {
+                                    exitval = 1;
+                                    pParser->msg("Failed to write output file, error code=0x%08X\n",hr);
+                                }
+                                else if (pAsm->m_pManifest->m_sStrongName.m_fFullSign)
+                                {
+                                    // Strong name sign the resultant assembly.
+                                    if(pAsm->m_fReportProgress) pParser->msg("Signing file with strong name\n");
+                                    if (FAILED(hr=pAsm->StrongNameSign()))
+                                    {
+                                        exitval = 1;
+                                        pParser->msg("Failed to strong name sign output file, error code=0x%08X\n",hr);
+                                    }
+                                }
+                                if(bClock) cw.cEnd = GetTickCount();
+#define ENC_ENABLED
+#ifdef ENC_ENABLED
+                                if(exitval==0)
+                                {
+                                    pAsm->m_fENCMode = TRUE;
+                                    WCHAR wzNewOutputFilename[MAX_FILENAME_LENGTH+16];
+                                    for(iFile = 0; iFile < NumDeltaFiles; iFile++)
+                                    {
+                                        wcscpy_s(wzNewOutputFilename,MAX_FILENAME_LENGTH+16,wzOutputFilename);
+                                        exitval = (int)StringCchPrintfW(&wzNewOutputFilename[wcslen(wzNewOutputFilename)], 32,
+                                                 L".%d",iFile+1);
+                                        MakeProperSourceFileName(pwzDeltaFiles[iFile], uCodePage, wzInputFilename, szInputFilename);
+                                        if(pAsm->m_fReportProgress)
+                                        {
+                                            pParser->msg("\nAssembling delta '%s' ", szInputFilename);
+                                            if(pAsm->m_fCPlusPlus)  pParser->msg(" C++");
+                                            if(pAsm->m_fWindowsCE)  pParser->msg(" WINCE");
+                                            if(!pAsm->m_fAutoInheritFromObject) pParser->msg(" NOAUTOINHERIT");
+                                            pParser->msg(" to DMETA,DIL");
+                                            //======================================================================
+                                            if (pAsm->m_fStdMapping == FALSE)
+                                                pParser->msg(", with REFERENCE mapping");
+
+                                            pParser->msg(" --> '%S.*'\n", wzNewOutputFilename);
+                                        }
+                                        exitval = 0;
+                                        pIn = new MappedFileStream(wzInputFilename);
+
+                                        if ((!pIn) || !(pIn->IsValid()))
+                                        {
+                                            pParser->msg("Could not open %s\n", szInputFilename);
+                                            fAllFilesPresent = FALSE;
+                                        }
+                                        else
+                                        {
+                                            DWORD dwBinType;
+                                            if(GetBinaryTypeA(szInputFilename,&dwBinType))
+                                            {
+                                                pParser->msg("%s is not a text file\n",szInputFilename);
+                                                fAllFilesPresent = FALSE;
+                                            }
+                                            else
+                                            if (SUCCEEDED(pAsm->InitMetaDataForENC(wzNewOutputFilename)))
+                                            {
+                                                pAsm->SetSourceFileName(FullFileName(wzInputFilename,uCodePage)); // deletes the argument!
+
+                                                pParser->ParseFile(pIn);
+                                                if (pParser->Success() || pAsm->OnErrGo)
+                                                {
+                                                    exitval = 1;
+                                                    if(FAILED(hr=pAsm->CreateDeltaFiles(wzNewOutputFilename)))
+                                                        pParser->msg("Could not create output delta files, error code=0x%08X\n",hr);
+                                                    else
+                                                    {
+                                                        if(pAsm->m_fFoldCode && pAsm->m_fReportProgress)
+                                                            pParser->msg("%d methods folded\n",pAsm->m_dwMethodsFolded);
+                                                        if(pParser->Success()) exitval = 0;
+                                                        else    pParser->msg("Output delta files contain errors\n");
+
+#ifdef GENERATE_SUMMARY_PE_FILE
+                                                        if(pAsm->OnErrGo) exitval = 0;
+
+                                                        //if(FAILED(hr=pAsm->CreatePEFile(wzOutputFilename)))
+                                                        //    pParser->msg("Could not create output file, error code=0x%08X\n",hr);
+                                                        //else
+                                                        {
+                                                            if(pAsm->m_fReportProgress) pParser->msg("Writing %s file\n", pAsm->m_fOBJ ? "COFF" : "PE");
+                                                            // Generate the file
+                                                            if (FAILED(hr = pAsm->m_pCeeFileGen->GenerateCeeFile(pAsm->m_pCeeFile)))
+                                                            {
+                                                                exitval = 1;
+                                                                pParser->msg("Failed to write output file, error code=0x%08X\n",hr);
+                                                            }
+                                                            else if (pAsm->m_pManifest->m_sStrongName.m_fFullSign)
+                                                            {
+                                                                // Strong name sign the resultant assembly.
+                                                                if(pAsm->m_fReportProgress) pParser->msg("Signing file with strong name\n");
+                                                                if (FAILED(hr=pAsm->StrongNameSign()))
+                                                                {
+                                                                    exitval = 1;
+                                                                    pParser->msg("Failed to strong name sign output file, error code=0x%08X\n",hr);
+                                                                }
+                                                            }
+                                                        }
+#endif
+                                                    }
+                                                } // end if (pParser->Success() || pAsm->OnErrGo)
+                                            } //end if (SUCCEEDED(pAsm->InitMetaDataForENC()))
+                                        } // end if ((!pIn) || !(pIn->IsValid())) -- else
+                                        if(pIn)
+                                        {
+                                            pIn->set_namew(NULL);
+                                            delete pIn;
+                                        }
+                                    } // end for(iFile)
+                                } // end if(exitval==0)
+#endif
+                            }
+
+                        }
+                    }
+                }
+                else pParser->msg("Failed to initialize Meta Data\n");
+                delete pParser;
+            }
+            else printf("Could not create parser\n");
+        }
+        //else printf("Failed to initialize Assembler\n");
+        delete pAsm;
+    }
+    else printf("Insufficient memory\n");
+
+    WszSetEnvironmentVariable(L"COMP_ENC_OPENSCOPE", L"");
+    WszSetEnvironmentVariable(L"COMP_ENC_EMIT", L"");
+
+    if(exitval || bNoDebug)
+    {
+        // PE file was not created, or no debug info required. Kill PDB if any
+        WCHAR* pc = wcsrchr(wzOutputFilename,L'.');
+        if(pc==NULL)
+        {
+            pc = &wzOutputFilename[wcslen(wzOutputFilename)];
+            *pc = L'.';
+        }
+        wcscpy_s(pc+1,4,L"PDB");
+#undef DeleteFileW
+        DeleteFileW(wzOutputFilename);
+    }
+    if (exitval == 0)
+    {
+        if(bReportProgress) printf("Operation completed successfully\n");
+        if(bClock)
+        {
+            printf("Timing (msec): Total run                 %d\n",(cw.cEnd-cw.cBegin));
+            printf("               Startup                   %d\n",(cw.cParsBegin-cw.cBegin));
+            printf("               - MD initialization       %d\n",(cw.cMDInitEnd - cw.cMDInitBegin));
+            printf("               Parsing                   %d\n",(cw.cParsEnd - cw.cParsBegin));
+            printf("               Emitting MD               %d\n",(cw.cMDEmitEnd - cw.cRef2DefEnd)+(cw.cRef2DefBegin - cw.cMDEmitBegin));
+            //printf("                - global fixups         %d\n",(cw.cMDEmit1 - cw.cMDEmitBegin));
+            printf("                - SN sig alloc           %d\n",(cw.cMDEmit2 - cw.cMDEmitBegin));
+            printf("                - Classes,Methods,Fields %d\n",(cw.cRef2DefBegin - cw.cMDEmit2));
+            printf("                - Events,Properties      %d\n",(cw.cMDEmit3 - cw.cRef2DefEnd));
+            printf("                - MethodImpls            %d\n",(cw.cMDEmit4 - cw.cMDEmit3));
+            printf("                - Manifest,CAs           %d\n",(cw.cMDEmitEnd - cw.cMDEmit4));
+            printf("               Ref to Def resolution     %d\n",(cw.cRef2DefEnd - cw.cRef2DefBegin));
+            printf("               Fixup and linking         %d\n",(cw.cFilegenBegin - cw.cMDEmitEnd));
+            printf("               CEE file generation       %d\n",(cw.cFilegenEnd - cw.cFilegenBegin));
+            printf("               PE file writing           %d\n",(cw.cEnd - cw.cFilegenEnd));
+        }
+    }
+    else
+    {
+        printf("\n***** FAILURE ***** \n");
+    }
+    exit(exitval);
+    return exitval;
+}
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif
+
+
+HINSTANCE GetModuleInst()
+{
+    return (NULL);
+}
+
+
+
diff --git a/src/ilasm/method.cpp b/src/ilasm/method.cpp
new file mode 100644
index 0000000000..1e3eec5e65
--- /dev/null
+++ b/src/ilasm/method.cpp
@@ -0,0 +1,158 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// file: method.cpp
+//
+
+//
+#include "ilasmpch.h"
+#include "assembler.h"
+
+Method::Method(Assembler *pAssembler, Class *pClass, __in __nullterminated char *pszName, BinStr* pbsSig, DWORD Attr)
+{
+
+    // default values
+    m_pClass        = pClass;
+    m_MaxStack      = 8;
+    m_Flags         = 0;
+    m_LocalsSig     = 0;
+    m_dwNumExceptions = 0;
+    m_dwNumEndfilters = 0;
+    m_firstArgName = NULL;
+    m_firstVarName = NULL;
+    m_pMethodSig = NULL;
+    m_wImplAttr = miIL; //default, if native or optil are not specified
+    m_wVTEntry = 0;
+    m_wVTSlot = 0;
+    m_pAssembler = pAssembler;
+    m_pCurrScope = &m_MainScope;
+    m_pRetMarshal = NULL;
+    m_pRetValue = NULL;
+    m_szExportAlias = NULL;
+    m_dwExportOrdinal = 0xFFFFFFFF;
+    m_ulLines[0]=m_ulLines[1]=0;
+    m_ulColumns[0]=m_ulColumns[0]=0;
+    m_pbsBody = NULL;
+    m_fNewBody = TRUE;
+    m_fNew = TRUE;
+
+    // move the PInvoke descriptor (if any) from Assembler
+    // (Assembler gets the descriptor BEFORE it calls new Method)
+    m_pPInvoke = pAssembler->m_pPInvoke;
+    pAssembler->m_pPInvoke = NULL;
+
+    _ASSERTE(pszName);
+    if (!pszName) return;
+
+    m_szName = pszName;
+    m_dwName = (DWORD)strlen(pszName);
+
+    m_ExceptionList = new COR_ILMETHOD_SECT_EH_CLAUSE_FAT[MAX_EXCEPTIONS];
+    m_EndfilterOffsetList = new DWORD[MAX_EXCEPTIONS];
+    if((m_ExceptionList==NULL)||(m_EndfilterOffsetList==NULL))
+    {
+        fprintf(stderr,"\nOutOfMemory!\n");
+        return;
+    }
+    m_dwMaxNumExceptions = MAX_EXCEPTIONS;
+    m_dwMaxNumEndfilters = MAX_EXCEPTIONS;
+
+    m_Attr          = Attr;
+    if((!strcmp(pszName,COR_CCTOR_METHOD_NAME))||(!strcmp(pszName,COR_CTOR_METHOD_NAME)))
+        m_Attr |= mdSpecialName;
+    m_fEntryPoint   = FALSE;
+    m_fGlobalMethod = FALSE;
+
+    if(pbsSig)
+    {
+        m_dwMethodCSig = pbsSig->length();
+        m_pMethodSig = (COR_SIGNATURE*)(pbsSig->ptr());
+        m_pbsMethodSig = pbsSig;
+    }
+
+    m_firstArgName = pAssembler->getArgNameList();
+    if(pClass == NULL) pClass = pAssembler->m_pModuleClass; // fake "class" <Module>
+    pClass->m_MethodList.PUSH(this);
+    pClass->m_fNewMembers = TRUE;
+
+
+    m_pPermissions = NULL;
+    m_pPermissionSets = NULL;
+
+    m_TyPars = NULL;
+    m_NumTyPars = 0;
+}
+
+
+// lexical scope handling
+void Method::OpenScope()
+{
+    Scope*  psc = new Scope;
+    if(psc)
+    {
+        psc->dwStart = m_pAssembler->m_CurPC;
+        psc->pSuperScope = m_pCurrScope;
+#if(0)
+        LinePC *pLPC = new LinePC;
+        if(pLPC)
+        {
+            pLPC->Line = m_pAssembler->m_ulCurLine;
+            pLPC->Column = m_pAssembler->m_ulCurColumn;
+            pLPC->PC = m_pAssembler->m_CurPC;
+            m_LinePCList.PUSH(pLPC);
+        }
+#endif
+        m_pCurrScope->SubScope.PUSH(psc);
+        m_pCurrScope = psc;
+    }
+}
+void Method::CloseScope()
+{
+    VarDescr*       pVD;
+    ARG_NAME_LIST*  pAN;
+    for(pAN=m_pCurrScope->pLocals; pAN; pAN = pAN->pNext)
+    {
+        if((pVD = m_Locals.PEEK(pAN->dwAttr))) pVD->bInScope = FALSE;
+    }
+    m_pCurrScope->dwEnd = m_pAssembler->m_CurPC;
+#if(0)
+    LinePC *pLPC = new LinePC;
+    if(pLPC)
+    {
+        pLPC->Line = m_pAssembler->m_ulCurLine;
+        pLPC->Column = m_pAssembler->m_ulCurColumn;
+        pLPC->PC = m_pAssembler->m_CurPC;
+        m_LinePCList.PUSH(pLPC);
+    }
+#endif
+    m_pCurrScope = m_pCurrScope->pSuperScope;
+}
+
+Label *Method::FindLabel(LPCUTF8 pszName)
+{
+    Label lSearch(pszName,0), *pL;
+    lSearch.m_szName = pszName;
+    //pL =  m_lstLabel.FIND(&lSearch);
+    pL =  m_pAssembler->m_lstLabel.FIND(&lSearch);
+    lSearch.m_szName = NULL;
+    return pL;
+    //return  m_lstLabel.FIND(pszName);
+}
+
+
+Label *Method::FindLabel(DWORD PC)
+{
+    Label *pSearch;
+
+    //for (int i = 0; (pSearch = m_lstLabel.PEEK(i)); i++)
+    for (int i = 0; (pSearch = m_pAssembler->m_lstLabel.PEEK(i)); i++)
+    {
+        if (pSearch->m_PC == PC)
+            return pSearch;
+    }
+
+    return NULL;
+}
+
diff --git a/src/ilasm/method.hpp b/src/ilasm/method.hpp
new file mode 100644
index 0000000000..86019201e6
--- /dev/null
+++ b/src/ilasm/method.hpp
@@ -0,0 +1,381 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// method.hpp
+//
+#ifndef _METHOD_HPP
+#define _METHOD_HPP
+
+class Assembler;
+class PermissionDecl;
+class PermissionSetDecl;
+
+#define MAX_EXCEPTIONS 16   // init.number; increased by 16 when needed
+
+extern unsigned int g_uCodePage;
+extern WCHAR    wzUniBuf[];
+
+/**************************************************************************/
+struct LinePC
+{
+    ULONG   Line;
+    ULONG   Column;
+    ULONG   LineEnd;
+    ULONG   ColumnEnd;
+    ULONG   PC;
+    ISymUnmanagedDocumentWriter* pWriter;
+};
+typedef FIFO<LinePC> LinePCList;
+
+
+struct PInvokeDescriptor
+{
+    mdModuleRef mrDll;
+    char*   szAlias;
+    DWORD   dwAttrs;
+};
+
+struct TokenRelocDescr // for OBJ generation only!
+{
+    DWORD   offset;
+    mdToken token;
+    TokenRelocDescr(DWORD off, mdToken tk) { offset = off; token = tk; };
+};
+typedef FIFO<TokenRelocDescr> TRDList;
+/* structure - element of [local] signature name list */
+
+struct  ARG_NAME_LIST
+{
+    LPCUTF8 szName; //szName[1024];
+    DWORD dwName;
+    BinStr*   pSig; // argument's signature  ptr
+    BinStr*   pMarshal;
+    BinStr*   pValue;
+    int  nNum;
+    DWORD     dwAttr;
+    CustomDescrList CustDList;
+    ARG_NAME_LIST *pNext;
+    __forceinline ARG_NAME_LIST(int i, LPCUTF8 sz, BinStr *pbSig, BinStr *pbMarsh, DWORD attr)
+    {
+        nNum = i;
+        //dwName = (DWORD)strlen(sz);
+        //strcpy(szName,sz);
+        szName = sz;
+        dwName = (sz == NULL) ? 0 : (DWORD)strlen(sz);
+        pNext = NULL;
+        pSig=pbSig;
+        pMarshal = pbMarsh;
+        dwAttr = attr;
+        pValue=NULL;
+    };
+    inline ~ARG_NAME_LIST()
+    {
+        if(pSig) delete pSig;
+        if(pMarshal) delete pMarshal;
+        if(pValue) delete pValue;
+        if(szName) delete [] szName;
+    }
+};
+
+class Scope;
+typedef FIFO<Scope> ScopeList;
+class Scope
+{
+public:
+    DWORD   dwStart;
+    DWORD   dwEnd;
+    ARG_NAME_LIST*  pLocals;
+    ScopeList       SubScope;
+    Scope*          pSuperScope;
+    Scope() { dwStart = dwEnd = 0; pLocals = NULL; pSuperScope = NULL; };
+    ~Scope() { Reset(); };
+    void Reset()
+    {
+        ARG_NAME_LIST* pNext;
+        while(pLocals) { pNext = pLocals->pNext; delete pLocals; pLocals = pNext; }
+        Scope* pS;
+        while((pS = SubScope.POP()) != NULL) delete pS;
+        pSuperScope = NULL;
+        dwStart = dwEnd = 0;
+    };
+};
+struct VarDescr
+{
+    DWORD   dwSlot;
+    BinStr* pbsSig;
+    BOOL    bInScope;
+    VarDescr() { dwSlot = (DWORD) -1; pbsSig = NULL; bInScope = FALSE; };
+};
+typedef FIFO<VarDescr> VarDescrList;
+
+
+struct Label
+{
+//public:
+    LPCUTF8  m_szName;
+    DWORD   m_PC;
+
+    Label() :m_szName(NULL),m_PC(0){};
+    Label(LPCUTF8 pszName, DWORD PC):m_szName(pszName),m_PC(PC){};
+    ~Label(){ delete [] m_szName; };
+    int ComparedTo(Label* L) { return strcmp(m_szName,L->m_szName); };
+    //int Compare(char* L) { return strcmp(L,m_szName); };
+    LPCUTF8 NameOf() { return m_szName; };
+};
+//typedef SORTEDARRAY<Label> LabelList;
+typedef FIFO_INDEXED<Label> LabelList;
+
+class GlobalFixup
+{
+public:
+    LPCUTF8  m_szLabel;
+    BYTE *  m_pReference;               // The place to fix up
+
+    GlobalFixup(LPCUTF8 pszName, BYTE* pReference)
+    {
+        m_pReference   = pReference;
+        m_szLabel = pszName;
+    }
+    ~GlobalFixup(){ delete [] m_szLabel; }
+};
+typedef FIFO<GlobalFixup> GlobalFixupList;
+
+
+class Fixup
+{
+public:
+    LPCUTF8  m_szLabel;
+    BYTE *  m_pBytes; // where to make the fixup
+    DWORD   m_RelativeToPC;
+    BYTE    m_FixupSize;
+
+    Fixup(LPCUTF8 pszName, BYTE *pBytes, DWORD RelativeToPC, BYTE FixupSize)
+    {
+        m_pBytes        = pBytes;
+        m_RelativeToPC  = RelativeToPC;
+        m_FixupSize     = FixupSize;
+        m_szLabel = pszName;
+    }
+    ~Fixup(){ delete [] m_szLabel; }
+};
+typedef FIFO<Fixup> FixupList;
+
+typedef enum { ilRVA, ilToken, ilGlobal} ILFixupType;
+
+class ILFixup
+{
+public:
+    ILFixupType   m_Kind;
+    DWORD         m_OffsetInMethod;
+    GlobalFixup * m_Fixup;
+
+    ILFixup(DWORD Offset, ILFixupType Kind, GlobalFixup *Fix)
+    {
+      m_Kind           = Kind;
+      m_OffsetInMethod = Offset;
+      m_Fixup          = Fix;
+    }
+};
+typedef FIFO<ILFixup> ILFixupList;
+
+class Method
+{
+public:
+    Class  *m_pClass;
+    //BinStr **m_TyParBounds;
+    //LPCWSTR *m_TyParNames;
+    TyParDescr* m_TyPars;
+    DWORD   m_NumTyPars;
+    DWORD   m_SigInfoCount;
+    USHORT  m_MaxStack;
+    mdSignature  m_LocalsSig;
+    DWORD   m_Flags;
+    char*   m_szName;
+    DWORD   m_dwName;
+    char*   m_szExportAlias;
+    DWORD   m_dwExportOrdinal;
+    COR_ILMETHOD_SECT_EH_CLAUSE_FAT *m_ExceptionList;
+    DWORD   m_dwNumExceptions;
+    DWORD   m_dwMaxNumExceptions;
+    DWORD*  m_EndfilterOffsetList;
+    DWORD   m_dwNumEndfilters;
+    DWORD   m_dwMaxNumEndfilters;
+    DWORD   m_Attr;
+    BOOL    m_fEntryPoint;
+    BOOL    m_fGlobalMethod;
+    BOOL    m_fNewBody;
+    BOOL    m_fNew;
+    DWORD   m_methodOffset;
+    DWORD   m_headerOffset;
+    BYTE *  m_pCode;
+    DWORD   m_CodeSize;
+    WORD    m_wImplAttr;
+    ULONG   m_ulLines[2];
+    ULONG   m_ulColumns[2];
+    // PInvoke attributes
+    PInvokeDescriptor* m_pPInvoke;
+    // Security attributes
+    PermissionDecl* m_pPermissions;
+    PermissionSetDecl* m_pPermissionSets;
+    // VTable attributes
+    WORD            m_wVTEntry;
+    WORD            m_wVTSlot;
+    // Return marshaling
+    BinStr* m_pRetMarshal;
+    BinStr* m_pRetValue;
+    DWORD   m_dwRetAttr;
+    CustomDescrList m_RetCustDList;
+    ILFixupList     m_lstILFixup;
+    FixupList       m_lstFixup;
+//    LabelList       m_lstLabel;
+    // Member ref fixups
+    LocalMemberRefFixupList  m_LocalMemberRefFixupList;
+    // Method body (header+code+EH)
+    BinStr* m_pbsBody;
+    mdToken m_Tok;
+    Method(Assembler *pAssembler, Class *pClass, __in __nullterminated char *pszName, BinStr* pbsSig, DWORD Attr);
+    ~Method()
+    {
+        m_lstFixup.RESET(true);
+        //m_lstLabel.RESET(true);
+        delete [] m_szName;
+        if(m_szExportAlias) delete [] m_szExportAlias;
+        delArgNameList(m_firstArgName);
+        delArgNameList(m_firstVarName);
+        delete m_pbsMethodSig;
+        delete [] m_ExceptionList;
+        delete [] m_EndfilterOffsetList;
+        if(m_pRetMarshal) delete m_pRetMarshal;
+        if(m_pRetValue) delete m_pRetValue;
+        while(m_MethodImplDList.POP()); // ptrs in m_MethodImplDList are dups of those in Assembler
+        if(m_pbsBody) delete m_pbsBody;
+        if(m_TyPars) delete [] m_TyPars;
+    };
+
+    BOOL IsGlobalMethod()
+    {
+        return m_fGlobalMethod;
+    };
+
+    void SetIsGlobalMethod()
+    {
+        m_fGlobalMethod = TRUE;
+    };
+
+    void delArgNameList(ARG_NAME_LIST *pFirst)
+    {
+        ARG_NAME_LIST *pArgList=pFirst, *pArgListNext;
+        for(; pArgList; pArgListNext=pArgList->pNext,
+                        delete pArgList,
+                        pArgList=pArgListNext);
+    };
+
+    ARG_NAME_LIST *catArgNameList(ARG_NAME_LIST *pBase, ARG_NAME_LIST *pAdd)
+    {
+        if(pAdd) //even if nothing to concatenate, result == head
+        {
+            ARG_NAME_LIST *pAN = pBase;
+            if(pBase)
+            {
+                int i;
+                for(; pAN->pNext; pAN = pAN->pNext) ;
+                pAN->pNext = pAdd;
+                i = pAN->nNum;
+                for(pAN = pAdd; pAN; pAN->nNum = ++i, pAN = pAN->pNext);
+            }
+            else pBase = pAdd; //nothing to concatenate to, result == tail
+        }
+        return pBase;
+    };
+
+    int findArgNum(ARG_NAME_LIST *pFirst, LPCUTF8 szArgName, DWORD dwArgName)
+    {
+        int ret=-1;
+        if(dwArgName)
+        {
+            ARG_NAME_LIST *pAN;
+            for(pAN=pFirst; pAN; pAN = pAN->pNext)
+            {
+                if((pAN->dwName == dwArgName)&& ((dwArgName==0)||(!strcmp(pAN->szName,szArgName))))
+                {
+                    ret = pAN->nNum;
+                    break;
+                }
+            }
+        }
+        return ret;
+    };
+
+    int findLocSlot(ARG_NAME_LIST *pFirst, LPCUTF8 szArgName, DWORD dwArgName)
+    {
+        int ret=-1;
+        if(dwArgName)
+        {
+            ARG_NAME_LIST *pAN;
+            for(pAN=pFirst; pAN; pAN = pAN->pNext)
+            {
+                if((pAN->dwName == dwArgName)&& ((dwArgName==0)||(!strcmp(pAN->szName,szArgName))))
+                {
+                    ret = (int)(pAN->dwAttr);
+                    break;
+                }
+            }
+        }
+        return ret;
+    };
+
+    BinStr  *m_pbsMethodSig;
+    COR_SIGNATURE*  m_pMethodSig;
+    DWORD   m_dwMethodCSig;
+    ARG_NAME_LIST *m_firstArgName;
+    ARG_NAME_LIST *m_firstVarName;
+    // to call error() from Method:
+    const char* m_FileName;
+    unsigned m_LineNum;
+    // debug info
+    LinePCList m_LinePCList;
+    // custom values
+    CustomDescrList m_CustomDescrList;
+    // token relocs (used for OBJ generation only)
+    TRDList m_TRDList;
+    // method's own list of method impls
+    MethodImplDList m_MethodImplDList;
+    // lexical scope handling
+    Assembler*      m_pAssembler;
+    Scope           m_MainScope;
+    Scope*          m_pCurrScope;
+    VarDescrList    m_Locals;
+    void OpenScope();
+    void CloseScope();
+
+    Label *FindLabel(LPCUTF8 pszName);
+    Label *FindLabel(DWORD PC);
+
+    int FindTyPar(__in __nullterminated WCHAR* wz)
+    {
+        int i,retval=-1;
+        for(i=0; i < (int)m_NumTyPars; i++)
+        {
+            if(!wcscmp(wz,m_TyPars[i].Name()))
+            {
+                retval = i;
+            }
+        }
+        return retval;
+    };
+    int FindTyPar(__in __nullterminated char* sz)
+    {
+        if(sz)
+        {
+            wzUniBuf[0] = 0;
+            WszMultiByteToWideChar(g_uCodePage,0,sz,-1,wzUniBuf,dwUniBuf);
+            return FindTyPar(wzUniBuf);
+        }
+        else return -1;
+    };
+};
+
+#endif /* _METHOD_HPP */
+
diff --git a/src/ilasm/nvpair.h b/src/ilasm/nvpair.h
new file mode 100644
index 0000000000..9f67b98b42
--- /dev/null
+++ b/src/ilasm/nvpair.h
@@ -0,0 +1,47 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+/***************************************************************************/
+/* Name value pair (both strings) which can be linked into a list of pairs */
+
+#ifndef NVPAIR_H
+#define NVPAIR_H
+
+#include "binstr.h"
+
+class NVPair
+{
+public:
+
+    NVPair(BinStr *name, BinStr *value)
+    {
+        m_Name = name;
+        m_Value = value;
+        m_Tail = NULL;
+    }
+
+    ~NVPair()
+    {
+        delete m_Name;
+        delete m_Value;
+        delete m_Tail;
+    }
+
+    NVPair *Concat(NVPair *list)
+    {
+        m_Tail = list;
+        return this;
+    }
+
+    BinStr *Name() { return m_Name; }
+    BinStr *Value() { return m_Value; }
+    NVPair *Next() { return m_Tail; }
+
+private:
+    BinStr *m_Name;
+    BinStr *m_Value;
+    NVPair *m_Tail;
+};
+
+#endif
diff --git a/src/ilasm/typar.hpp b/src/ilasm/typar.hpp
new file mode 100644
index 0000000000..ad5cb0e997
--- /dev/null
+++ b/src/ilasm/typar.hpp
@@ -0,0 +1,167 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+/**************************************************************************/
+/* a type parameter list */
+
+#ifndef TYPAR_H
+#define TYPAR_H
+#include "binstr.h"
+
+extern unsigned int g_uCodePage;
+
+class TyParDescr
+{
+public:
+    TyParDescr()
+    {
+        m_pbsBounds = NULL;
+        m_wzName = NULL;
+        m_dwAttrs = 0;
+    };
+    ~TyParDescr()
+    {
+        delete m_pbsBounds;
+        delete [] m_wzName;
+        m_lstCA.RESET(true);
+    };
+    void Init(BinStr* bounds, LPCUTF8 name, DWORD attrs)
+    {
+        m_pbsBounds = bounds;
+        ULONG               cTemp = (ULONG)strlen(name)+1;
+        WCHAR *pwzName;
+        m_wzName = pwzName = new WCHAR[cTemp];
+        if(pwzName)
+        {
+            memset(pwzName,0,sizeof(WCHAR)*cTemp);
+            WszMultiByteToWideChar(g_uCodePage,0,name,-1,pwzName,cTemp);
+        }
+        m_dwAttrs = attrs;
+    };
+    BinStr* Bounds() { return m_pbsBounds; };
+    LPCWSTR Name() { return m_wzName; };
+    DWORD   Attrs() { return m_dwAttrs; };
+    CustomDescrList* CAList() { return &m_lstCA; };
+private:
+    BinStr* m_pbsBounds;
+    LPCWSTR m_wzName;
+    DWORD   m_dwAttrs;
+    CustomDescrList m_lstCA;
+};
+
+class TyParList {
+public:
+	TyParList(DWORD a, BinStr* b, LPCUTF8 n, TyParList* nx = NULL) 
+    { 
+        bound  = (b == NULL) ? new BinStr() : b;
+        bound->appendInt32(0); // zero terminator
+		attrs = a; name = n; next = nx;
+	};
+	~TyParList() 
+    { 
+        if(bound) delete bound;
+		if (next) delete next; 
+	};
+    int Count()
+    {
+        TyParList* tp = this;
+        int n;
+        for(n = 1; (tp = tp->next) != NULL; n++);
+        return n;
+    };
+    int IndexOf(LPCUTF8 name)
+    {
+        TyParList* tp = this;
+        int n;
+        int ret = -1;
+        for(n=0; tp != NULL; n++, tp = tp->next)
+        {
+            if(tp->name == NULL)
+            {
+                if(name == NULL) ret = n;
+            }
+            else
+            {
+                if(name == NULL) continue;
+                if(0 == strcmp(name,tp->name)) ret = n;
+            }
+        }
+        return ret;
+    };
+
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:6211) // "Leaking memory 'b' due to an exception. Consider using a local catch block to clean up memory"
+#endif /*_PREFAST_ */
+
+    int ToArray(BinStr ***bounds, LPCWSTR** names, DWORD **attrs)
+    {   
+        int n = Count();
+        BinStr **b = new BinStr* [n];
+        LPCWSTR *nam = new LPCWSTR [n];
+        DWORD *attr = attrs ? new DWORD [n] : NULL;
+        TyParList *tp = this;
+        int i = 0;
+        while (tp)
+        {
+            ULONG               cTemp = (ULONG)strlen(tp->name)+1;
+            WCHAR*              wzDllName = new WCHAR [cTemp];
+            // Convert name to UNICODE
+            memset(wzDllName,0,sizeof(WCHAR)*cTemp);
+            WszMultiByteToWideChar(g_uCodePage,0,tp->name,-1,wzDllName,cTemp);
+            nam[i] = (LPCWSTR)wzDllName;
+            b[i] = tp->bound;
+            if (attr) 
+                attr[i] = tp->attrs;
+            tp->bound = 0; // to avoid deletion by destructor
+            i++;
+            tp = tp->next;
+        }
+        *bounds = b;
+        *names = nam;          
+        if (attrs)
+            *attrs = attr;
+        return n;
+    };
+
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif /*_PREFAST_*/
+
+    int ToArray(TyParDescr **ppTPD)
+    {
+        int n = Count();
+        TyParDescr *pTPD = NULL;
+        if(n)
+        {
+            pTPD = new TyParDescr[n];
+            if(pTPD)
+            {
+                int i = 0;
+                TyParList *tp = this;
+                while (tp)
+                {
+                    pTPD[i].Init(tp->bound,tp->name,tp->attrs);
+                    tp->bound = 0; // to avoid deletion by destructor
+                    i++;
+                    tp = tp->next;
+                }
+            }
+        }
+        *ppTPD = pTPD;
+        return n;
+    };
+    TyParList* Next() { return next; };
+    BinStr* Bound() { return bound; };
+private:
+	BinStr* bound;
+    LPCUTF8 name;
+    TyParList* next;
+    DWORD   attrs;
+};
+
+typedef TyParList* pTyParList;
+
+#endif
+
diff --git a/src/ilasm/writer.cpp b/src/ilasm/writer.cpp
new file mode 100644
index 0000000000..c2b81ffa72
--- /dev/null
+++ b/src/ilasm/writer.cpp
@@ -0,0 +1,1798 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// writer.cpp
+//
+
+#include "ilasmpch.h"
+
+#include "assembler.h"
+
+#include "ceefilegenwriter.h"
+#include "strongname.h"
+#include "LegacyActivationShim.h"
+
+#ifndef _MSC_VER
+//cloned definition from ntimage.h that is removed for non MSVC builds
+typedef VOID
+(NTAPI *PIMAGE_TLS_CALLBACK) (
+    PVOID DllHandle,
+    ULONG Reason,
+    PVOID Reserved
+    );
+#endif //_MSC_VER
+
+
+HRESULT Assembler::InitMetaData()
+{
+    HRESULT             hr = E_FAIL;
+
+    if(m_fInitialisedMetaData) return S_OK;
+
+    if(bClock) bClock->cMDInitBegin = GetTickCount();
+
+    hr = LegacyActivationShim::ClrCoCreateInstance(
+        CLSID_CorMetaDataDispenser, 
+        NULL, 
+        CLSCTX_INPROC_SERVER, 
+        IID_IMetaDataDispenserEx, 
+        (void **)&m_pDisp);
+    if (FAILED(hr))
+        goto exit;
+
+    if(m_wzMetadataVersion)
+    {
+        VARIANT encOption;
+        BSTR    bstr;
+        V_VT(&encOption) = VT_BSTR;
+        V_BSTR(&encOption) = bstr = ::SysAllocString(m_wzMetadataVersion);
+        hr = m_pDisp->SetOption(MetaDataRuntimeVersion, &encOption);
+        ::SysFreeString(bstr);
+    }
+    hr = m_pDisp->DefineScope(CLSID_CorMetaDataRuntime, 0, IID_IMetaDataEmit2,
+                        (IUnknown **)&m_pEmitter);
+    if (FAILED(hr))
+        goto exit;
+
+    m_pManifest->SetEmitter(m_pEmitter);
+    if(FAILED(hr = m_pEmitter->QueryInterface(IID_IMetaDataImport2, (void**)&m_pImporter)))
+        goto exit;
+
+    hr = CoCreateInstance(CLSID_CorSymWriter_SxS,
+                           NULL,
+                           CLSCTX_INPROC_SERVER,
+                           IID_ISymUnmanagedWriter,
+                           (void **)&m_pSymWriter);
+    if(SUCCEEDED(hr))
+    {
+        if(m_pSymWriter) m_pSymWriter->Initialize((IUnknown*)m_pEmitter,
+                                                  m_wzOutputFileName,
+                                                  NULL,
+                                                  TRUE);
+    }
+    else
+    {
+        fprintf(stderr, "Error: QueryInterface(IID_ISymUnmanagedWriter) returns %X\n",hr);
+        m_pSymWriter = NULL;
+    }
+
+    //m_Parser = new AsmParse(m_pEmitter);
+    m_fInitialisedMetaData = TRUE;
+
+    hr = S_OK;
+
+exit:
+    if(bClock) bClock->cMDInitEnd = GetTickCount();
+    return hr;
+}
+/*********************************************************************************/
+/* if we have any Thread local store data, make the TLS directory record for it */
+
+HRESULT Assembler::CreateTLSDirectory() {
+
+    ULONG tlsEnd;
+    HRESULT hr;
+    if (FAILED(hr=m_pCeeFileGen->GetSectionDataLen(m_pTLSSection, &tlsEnd))) return(hr);
+
+    if (tlsEnd == 0)        // No TLS data, we are done
+        return(S_OK);
+
+        // place to put the TLS directory
+    HCEESECTION tlsDirSec = m_pGlobalDataSection;
+
+    if(m_dwCeeFileFlags & ICEE_CREATE_FILE_PE32)
+    {
+        DWORD sizeofptr = (DWORD)sizeof(DWORD);
+        DWORD sizeofdir = (DWORD)sizeof(IMAGE_TLS_DIRECTORY32);
+        DWORD offsetofStartAddressOfRawData  = (DWORD)offsetof(IMAGE_TLS_DIRECTORY32, StartAddressOfRawData);
+        DWORD offsetofEndAddressOfRawData    = (DWORD)offsetof(IMAGE_TLS_DIRECTORY32, EndAddressOfRawData);
+        DWORD offsetofAddressOfIndex         = (DWORD)offsetof(IMAGE_TLS_DIRECTORY32, AddressOfIndex);
+        DWORD offsetofAddressOfCallBacks     = (DWORD)offsetof(IMAGE_TLS_DIRECTORY32, AddressOfCallBacks);
+
+            // Get memory for for the TLS directory block,as well as a spot for callback chain
+        IMAGE_TLS_DIRECTORY32* tlsDir;
+        if(FAILED(hr=m_pCeeFileGen->GetSectionBlock(tlsDirSec, sizeofdir + sizeofptr, sizeofptr, (void**) &tlsDir))) return(hr);
+        DWORD* callBackChain = (DWORD*) &tlsDir[1];
+        *callBackChain = 0;
+    
+            // Find out where the tls directory will end up
+        ULONG tlsDirOffset;
+        if(FAILED(hr=m_pCeeFileGen->GetSectionDataLen(tlsDirSec, &tlsDirOffset))) return(hr);
+        tlsDirOffset -= (sizeofdir + sizeofptr);
+    
+            // Set the start of the TLS data (offset 0 of hte TLS section)
+        tlsDir->StartAddressOfRawData = 0;
+        if(FAILED(hr=m_pCeeFileGen->AddSectionReloc(tlsDirSec, tlsDirOffset + offsetofStartAddressOfRawData, m_pTLSSection, srRelocHighLow))) return(hr);
+    
+            // Set the end of the TLS data
+        tlsDir->EndAddressOfRawData = VALPTR(tlsEnd);
+        if(FAILED(hr=m_pCeeFileGen->AddSectionReloc(tlsDirSec, tlsDirOffset + offsetofEndAddressOfRawData, m_pTLSSection, srRelocHighLow))) return(hr);
+    
+            // Allocate space for the OS to put the TLS index for this PE file (needs to be Read/Write?)
+        DWORD* tlsIndex;
+        if(FAILED(hr=m_pCeeFileGen->GetSectionBlock(m_pGlobalDataSection, sizeof(DWORD), sizeof(DWORD), (void**) &tlsIndex))) return(hr);
+        *tlsIndex = 0xCCCCCCCC;     // Does't really matter, the OS will fill it in
+    
+            // Find out where tlsIndex index is
+        ULONG tlsIndexOffset;
+        if(FAILED(hr=m_pCeeFileGen->GetSectionDataLen(tlsDirSec, &tlsIndexOffset))) return(hr);
+        tlsIndexOffset -= sizeof(DWORD);
+    
+            // Set the address of the TLS index
+        tlsDir->AddressOfIndex = VALPTR(tlsIndexOffset);
+        if(FAILED(hr=m_pCeeFileGen->AddSectionReloc(tlsDirSec, tlsDirOffset + offsetofAddressOfIndex, m_pGlobalDataSection, srRelocHighLow))) return(hr);
+    
+            // Set addres of callbacks chain
+        tlsDir->AddressOfCallBacks = VALPTR((DWORD)(DWORD_PTR)(PIMAGE_TLS_CALLBACK*)(size_t)(tlsDirOffset + sizeofdir));
+        if(FAILED(hr=m_pCeeFileGen->AddSectionReloc(tlsDirSec, tlsDirOffset + offsetofAddressOfCallBacks, tlsDirSec, srRelocHighLow))) return(hr);
+        
+            // Set the other fields.
+        tlsDir->SizeOfZeroFill = 0;
+        tlsDir->Characteristics = 0;
+    
+        hr=m_pCeeFileGen->SetDirectoryEntry (m_pCeeFile, tlsDirSec, IMAGE_DIRECTORY_ENTRY_TLS,
+            sizeofdir, tlsDirOffset);
+
+        if (m_dwCeeFileFlags & ICEE_CREATE_MACHINE_I386)
+            COR_SET_32BIT_REQUIRED(m_dwComImageFlags);
+    }
+    else
+    {
+        DWORD sizeofptr = (DWORD)sizeof(__int64);
+        DWORD sizeofdir = (DWORD)sizeof(IMAGE_TLS_DIRECTORY64);
+        DWORD offsetofStartAddressOfRawData  = (DWORD)offsetof(IMAGE_TLS_DIRECTORY64, StartAddressOfRawData);
+        DWORD offsetofEndAddressOfRawData    = (DWORD)offsetof(IMAGE_TLS_DIRECTORY64, EndAddressOfRawData);
+        DWORD offsetofAddressOfIndex         = (DWORD)offsetof(IMAGE_TLS_DIRECTORY64, AddressOfIndex);
+        DWORD offsetofAddressOfCallBacks     = (DWORD)offsetof(IMAGE_TLS_DIRECTORY64, AddressOfCallBacks);
+
+            // Get memory for for the TLS directory block,as well as a spot for callback chain
+        IMAGE_TLS_DIRECTORY64* tlsDir;
+        if(FAILED(hr=m_pCeeFileGen->GetSectionBlock(tlsDirSec, sizeofdir + sizeofptr, sizeofptr, (void**) &tlsDir))) return(hr);
+        __int64* callBackChain = (__int64*) &tlsDir[1];
+        *callBackChain = 0;
+    
+            // Find out where the tls directory will end up
+        ULONG tlsDirOffset;
+        if(FAILED(hr=m_pCeeFileGen->GetSectionDataLen(tlsDirSec, &tlsDirOffset))) return(hr);
+        tlsDirOffset -= (sizeofdir + sizeofptr);
+    
+            // Set the start of the TLS data (offset 0 of hte TLS section)
+        tlsDir->StartAddressOfRawData = 0;
+        if(FAILED(hr=m_pCeeFileGen->AddSectionReloc(tlsDirSec, tlsDirOffset + offsetofStartAddressOfRawData, m_pTLSSection, srRelocHighLow))) return(hr);
+    
+            // Set the end of the TLS data
+        tlsDir->EndAddressOfRawData = VALPTR(tlsEnd);
+        if(FAILED(hr=m_pCeeFileGen->AddSectionReloc(tlsDirSec, tlsDirOffset + offsetofEndAddressOfRawData, m_pTLSSection, srRelocHighLow))) return(hr);
+    
+            // Allocate space for the OS to put the TLS index for this PE file (needs to be Read/Write?)
+        DWORD* tlsIndex;
+        if(FAILED(hr=m_pCeeFileGen->GetSectionBlock(m_pGlobalDataSection, sizeof(DWORD), sizeof(DWORD), (void**) &tlsIndex))) return(hr);
+        *tlsIndex = 0xCCCCCCCC;     // Does't really matter, the OS will fill it in
+    
+            // Find out where tlsIndex index is
+        ULONG tlsIndexOffset;
+        if(FAILED(hr=m_pCeeFileGen->GetSectionDataLen(tlsDirSec, &tlsIndexOffset))) return(hr);
+        tlsIndexOffset -= sizeof(DWORD);
+    
+            // Set the address of the TLS index
+        tlsDir->AddressOfIndex = VALPTR(tlsIndexOffset);
+        if(FAILED(hr=m_pCeeFileGen->AddSectionReloc(tlsDirSec, tlsDirOffset + offsetofAddressOfIndex, m_pGlobalDataSection, srRelocHighLow))) return(hr);
+    
+            // Set addres of callbacks chain
+        tlsDir->AddressOfCallBacks = VALPTR((DWORD)(DWORD_PTR)(PIMAGE_TLS_CALLBACK*)(size_t)(tlsDirOffset + sizeofdir));
+        if(FAILED(hr=m_pCeeFileGen->AddSectionReloc(tlsDirSec, tlsDirOffset + offsetofAddressOfCallBacks, tlsDirSec, srRelocHighLow))) return(hr);
+        
+            // Set the other fields.
+        tlsDir->SizeOfZeroFill = 0;
+        tlsDir->Characteristics = 0;
+    
+        hr=m_pCeeFileGen->SetDirectoryEntry (m_pCeeFile, tlsDirSec, IMAGE_DIRECTORY_ENTRY_TLS,
+            sizeofdir, tlsDirOffset);
+    }
+
+    if(m_dwCeeFileFlags & ICEE_CREATE_FILE_STRIP_RELOCS)
+    {
+        report->error("Base relocations are emitted, while /STRIPRELOC option has been specified");
+    }
+    m_dwComImageFlags &= ~COMIMAGE_FLAGS_ILONLY;
+
+    return(hr);
+}
+
+HRESULT Assembler::CreateDebugDirectory()
+{
+    HRESULT hr = S_OK;
+
+    // Only emit this if we're also emitting debug info.
+    if (!(m_fGeneratePDB && m_pSymWriter))
+        return S_OK;
+
+    IMAGE_DEBUG_DIRECTORY  debugDirIDD;
+    struct Param
+    {
+    DWORD                  debugDirDataSize;
+        BYTE              *debugDirData;
+    } param;
+    param.debugDirData = NULL;
+
+    // Get the debug info from the symbol writer.
+    if (FAILED(hr=m_pSymWriter->GetDebugInfo(NULL, 0, &param.debugDirDataSize, NULL)))
+        return hr;
+
+    // Will there even be any?
+    if (param.debugDirDataSize == 0)
+        return S_OK;
+
+    // Make some room for the data.
+    PAL_TRY(Param *, pParam, &param) {
+        pParam->debugDirData = new BYTE[pParam->debugDirDataSize];
+    } PAL_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
+        hr = E_FAIL;
+    } WIN_PAL_ENDTRY
+
+    if(FAILED(hr)) return hr;
+    // Actually get the data now.
+    if (FAILED(hr = m_pSymWriter->GetDebugInfo(&debugDirIDD,
+                                               param.debugDirDataSize,
+                                               NULL,
+                                               param.debugDirData)))
+        goto ErrExit;
+
+    // Grab the timestamp of the PE file.
+    DWORD fileTimeStamp;
+
+    if (FAILED(hr = m_pCeeFileGen->GetFileTimeStamp(m_pCeeFile,
+                                                    &fileTimeStamp)))
+        goto ErrExit;
+
+    // Fill in the directory entry.
+    debugDirIDD.TimeDateStamp = VAL32(fileTimeStamp);
+
+    // Grab memory in the section for our stuff.
+    // Note that UpdateResource doesn't work correctly if the debug directory is
+    // in the data section.  So instead we put it in the text section (same as
+    // cs compiler).
+    HCEESECTION sec = m_pILSection;//m_pGlobalDataSection;
+    BYTE *de;
+
+    if (FAILED(hr = m_pCeeFileGen->GetSectionBlock(sec,
+                                                   sizeof(debugDirIDD) +
+                                                   param.debugDirDataSize,
+                                                   4,
+                                                   (void**) &de)))
+        goto ErrExit;
+
+    // Where did we get that memory?
+    ULONG deOffset;
+    if (FAILED(hr = m_pCeeFileGen->GetSectionDataLen(sec,
+                                                     &deOffset)))
+        goto ErrExit;
+
+    deOffset -= (sizeof(debugDirIDD) + param.debugDirDataSize);
+
+    // Setup a reloc so that the address of the raw
+    // data is setup correctly.
+    debugDirIDD.PointerToRawData = VAL32(deOffset + sizeof(debugDirIDD));
+
+    if (FAILED(hr = m_pCeeFileGen->AddSectionReloc(
+                                          sec,
+                                          deOffset +
+                                          offsetof(IMAGE_DEBUG_DIRECTORY,
+                                                   PointerToRawData),
+                                          sec, srRelocFilePos)))
+        goto ErrExit;
+
+    debugDirIDD.AddressOfRawData = VAL32(deOffset + sizeof(debugDirIDD));
+
+    if (FAILED(hr = m_pCeeFileGen->AddSectionReloc(
+                                          sec,
+                                          deOffset +
+                                          offsetof(IMAGE_DEBUG_DIRECTORY,
+                                                   AddressOfRawData),
+                                          sec, srRelocAbsolute)))
+        goto ErrExit;
+    // Emit the directory entry.
+    if (FAILED(hr = m_pCeeFileGen->SetDirectoryEntry(m_pCeeFile,
+                                                     sec,
+                                                     IMAGE_DIRECTORY_ENTRY_DEBUG,
+                                                     sizeof(debugDirIDD),
+                                                     deOffset)))
+        goto ErrExit;
+
+    // Copy the debug directory into the section.
+    memcpy(de, &debugDirIDD, sizeof(debugDirIDD));
+    memcpy(de + sizeof(debugDirIDD), param.debugDirData,
+           param.debugDirDataSize);
+
+    if (param.debugDirData)
+    {
+        delete [] param.debugDirData;
+    }
+    return S_OK;
+
+ErrExit:
+    if (param.debugDirData)
+    {
+        delete [] param.debugDirData;
+    }
+    return hr;
+}
+//#ifdef EXPORT_DIR_ENABLED
+HRESULT Assembler::CreateExportDirectory()
+{
+    HRESULT hr = S_OK;
+    DWORD   Nentries = m_EATList.COUNT();
+    if(Nentries == 0) return S_OK;
+
+    IMAGE_EXPORT_DIRECTORY  exportDirIDD;
+    DWORD                   exportDirDataSize;
+    BYTE                   *exportDirData;
+    EATEntry               *pEATE;
+    unsigned                i, L, ordBase = 0xFFFFFFFF, Ldllname;
+    // get the DLL name from output file name
+    char*                   pszDllName;
+    Ldllname = (unsigned)wcslen(m_wzOutputFileName)*3+3;
+    char*                   szOutputFileName = new char[Ldllname];
+    memset(szOutputFileName,0,wcslen(m_wzOutputFileName)*3+3);
+    WszWideCharToMultiByte(CP_ACP,0,m_wzOutputFileName,-1,szOutputFileName,Ldllname,NULL,NULL);
+    pszDllName = strrchr(szOutputFileName,'\\');
+    if(pszDllName == NULL) pszDllName = strrchr(szOutputFileName,':');
+    if(pszDllName == NULL) pszDllName = szOutputFileName;
+    Ldllname = (unsigned)strlen(pszDllName)+1;
+
+    // Allocate buffer for tables
+    for(i = 0, L=0; i < Nentries; i++) L += 1+(unsigned)strlen(m_EATList.PEEK(i)->szAlias);
+    exportDirDataSize = Nentries*5*sizeof(WORD) + L + Ldllname;
+    exportDirData = new BYTE[exportDirDataSize];
+    memset(exportDirData,0,exportDirDataSize);
+
+    // Export address table
+    DWORD*  pEAT = (DWORD*)exportDirData;
+    // Name pointer table
+    DWORD*  pNPT = pEAT + Nentries;
+    // Ordinal table
+    WORD*   pOT = (WORD*)(pNPT + Nentries);
+    // Export name table
+    char*   pENT = (char*)(pOT + Nentries);
+    // DLL name
+    char*   pDLLName = pENT + L;
+
+    // sort the names/ordinals
+    char**  pAlias = new char*[Nentries];
+    for(i = 0; i < Nentries; i++)
+    {
+        pEATE = m_EATList.PEEK(i);
+        pOT[i] = (WORD)pEATE->dwOrdinal;
+        if(pOT[i] < ordBase) ordBase = pOT[i];
+        pAlias[i] = pEATE->szAlias;
+    }
+    bool swapped = true;
+    unsigned j;
+    char*    pch;
+    while(swapped)
+    {
+        swapped = false;
+        for(i=1; i < Nentries; i++)
+        {
+            if(strcmp(pAlias[i-1],pAlias[i]) > 0)
+            {
+                swapped = true;
+                pch = pAlias[i-1];
+                pAlias[i-1] = pAlias[i];
+                pAlias[i] = pch;
+                j = pOT[i-1];
+                pOT[i-1] = pOT[i];
+                pOT[i] = j;
+            }
+        }
+    }
+    // normalize ordinals
+    for(i = 0; i < Nentries; i++) pOT[i] -= ordBase;
+    // fill the export address table
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:22008) // "Suppress PREfast warnings about integer overflow"
+#endif
+    for(i = 0; i < Nentries; i++)
+    {
+        pEATE = m_EATList.PEEK(i);
+        pEAT[pEATE->dwOrdinal - ordBase] = pEATE->dwStubRVA;
+    }
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif
+    // fill the export names table
+    unsigned l;
+    for(i = 0, j = 0; i < Nentries; i++)
+    {
+        pNPT[i] = j; // relative offset in the table
+        l = (unsigned)strlen(pAlias[i])+1;
+        memcpy(&pENT[j],pAlias[i],l);
+        j+=l;
+    }
+    _ASSERTE(j==L);
+    // fill the DLL name
+    memcpy(pDLLName,pszDllName,Ldllname);
+
+    // Data blob is ready pending Name Pointer Table values offsetting
+
+    memset(&exportDirIDD,0,sizeof(IMAGE_EXPORT_DIRECTORY));
+    // Grab the timestamp of the PE file.
+    DWORD fileTimeStamp;
+    if (FAILED(hr = m_pCeeFileGen->GetFileTimeStamp(m_pCeeFile,&fileTimeStamp))) return hr;
+    // Fill in the directory entry.
+    // Characteristics, MajorVersion and MinorVersion play no role and stay 0
+    exportDirIDD.TimeDateStamp = VAL32(fileTimeStamp);
+    exportDirIDD.Name = VAL32(exportDirDataSize - Ldllname); // to be offset later
+    exportDirIDD.Base = VAL32(ordBase);
+    exportDirIDD.NumberOfFunctions = VAL32(Nentries);
+    exportDirIDD.NumberOfNames = VAL32(Nentries);
+    exportDirIDD.AddressOfFunctions = 0;    // to be offset later
+    exportDirIDD.AddressOfNames = VAL32(Nentries*sizeof(DWORD));   // to be offset later
+    exportDirIDD.AddressOfNameOrdinals = VAL32(Nentries*sizeof(DWORD)*2);  // to be offset later
+
+    // Grab memory in the section for our stuff.
+    HCEESECTION sec = m_pGlobalDataSection;
+    BYTE *de;
+    if (FAILED(hr = m_pCeeFileGen->GetSectionBlock(sec,
+                                                   sizeof(IMAGE_EXPORT_DIRECTORY) + exportDirDataSize,
+                                                   4,
+                                                   (void**) &de))) return hr;
+    // Where did we get that memory?
+    ULONG deOffset, deDataOffset;
+    if (FAILED(hr = m_pCeeFileGen->GetSectionDataLen(sec, &deDataOffset))) return hr;
+
+    deDataOffset -= exportDirDataSize;
+    deOffset = deDataOffset - sizeof(IMAGE_EXPORT_DIRECTORY);
+
+    // Add offsets and set up relocs for header entries
+    exportDirIDD.Name = VAL32(VAL32(exportDirIDD.Name) + deDataOffset);
+    if (FAILED(hr = m_pCeeFileGen->AddSectionReloc(sec,deOffset + offsetof(IMAGE_EXPORT_DIRECTORY,Name),
+                                          sec, srRelocAbsolute))) return hr;
+    exportDirIDD.AddressOfFunctions = VAL32(VAL32(exportDirIDD.AddressOfFunctions) + deDataOffset);
+    if (FAILED(hr = m_pCeeFileGen->AddSectionReloc(sec,deOffset + offsetof(IMAGE_EXPORT_DIRECTORY,AddressOfFunctions),
+                                          sec, srRelocAbsolute))) return hr;
+    exportDirIDD.AddressOfNames = VAL32(VAL32(exportDirIDD.AddressOfNames) + deDataOffset);
+    if (FAILED(hr = m_pCeeFileGen->AddSectionReloc(sec,deOffset + offsetof(IMAGE_EXPORT_DIRECTORY,AddressOfNames),
+                                          sec, srRelocAbsolute))) return hr;
+    exportDirIDD.AddressOfNameOrdinals = VAL32(VAL32(exportDirIDD.AddressOfNameOrdinals) + deDataOffset);
+    if (FAILED(hr = m_pCeeFileGen->AddSectionReloc(sec,deOffset + offsetof(IMAGE_EXPORT_DIRECTORY,AddressOfNameOrdinals),
+                                          sec, srRelocAbsolute))) return hr;
+
+    // Add offsets and set up relocs for Name Pointer Table
+    j = deDataOffset + Nentries*5*sizeof(WORD); // EA, NP and O Tables come first
+    for(i = 0; i < Nentries; i++)
+    {
+        pNPT[i] += j;
+        if (FAILED(hr = m_pCeeFileGen->AddSectionReloc(sec,exportDirIDD.AddressOfNames+i*sizeof(DWORD),
+            sec, srRelocAbsolute))) return hr;
+    }
+
+
+    // Emit the directory entry.
+    if (FAILED(hr = m_pCeeFileGen->SetDirectoryEntry(m_pCeeFile, sec, IMAGE_DIRECTORY_ENTRY_EXPORT,
+                                                     sizeof(IMAGE_EXPORT_DIRECTORY), deOffset)))  return hr;
+
+    // Copy the debug directory into the section.
+    memcpy(de, &exportDirIDD, sizeof(IMAGE_EXPORT_DIRECTORY));
+    memcpy(de + sizeof(IMAGE_EXPORT_DIRECTORY), exportDirData, exportDirDataSize);
+    delete [] pAlias;
+    delete [] exportDirData;
+    return S_OK;
+}
+
+static const BYTE ExportStubAMD64Template[] = 
+{
+	// Jump through VTFixup table 
+	0x48, 0xA1,				// rex.w rex.b mov rax,[following address]
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,//address of VTFixup slot
+    0xFF, 0xE0              // jmp [rax]
+};
+static const BYTE ExportStubX86Template[] = 
+{
+	// Jump through VTFixup table 
+	0xFF, 0x25,				// jmp [following address]
+    0x00, 0x00, 0x00, 0x00  //address of VTFixup slot
+};
+static const WORD ExportStubARMTemplate[] = 
+{
+	// Jump through VTFixup table
+    0xf8df, 0xf000,         // ldr pc, [pc, #0]
+    0x0000, 0x0000          //address of VTFixup slot
+};
+
+static const BYTE ExportStubIA64Template[] =
+{
+    // ld8    r9  = [gp]    ;;
+    // ld8    r10 = [r9],8
+    // nop.i                ;;
+    // ld8    gp  = [r9]
+    // mov    b6  = r10
+    // br.cond.sptk.few  b6
+    //
+    0x0B, 0x48, 0x00, 0x02, 0x18, 0x10, 0xA0, 0x40, 
+    0x24, 0x30, 0x28, 0x00, 0x00, 0x00, 0x04, 0x00, 
+    0x10, 0x08, 0x00, 0x12, 0x18, 0x10, 0x60, 0x50, 
+    0x04, 0x80, 0x03, 0x00, 0x60, 0x00, 0x80, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,//address of the template
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 //address of VTFixup slot
+};
+DWORD   Assembler::EmitExportStub(DWORD dwVTFSlotRVA)
+{
+    DWORD EXPORT_STUB_SIZE = (DWORD)(sizeof(WORD)+sizeof(DWORD));
+    DWORD OFFSET_OF_ADDR = (DWORD)sizeof(WORD);
+    DWORD STUB_ALIGNMENT = 16;
+    BYTE* STUB_TEMPLATE = NULL;
+    DWORD PEFileOffset;
+    BYTE* outBuff;
+    DWORD*  pdwVTFSlotRVA;
+    if(m_dwCeeFileFlags & ICEE_CREATE_MACHINE_IA64)
+    {
+        STUB_TEMPLATE = (BYTE*)&ExportStubIA64Template[0];
+        EXPORT_STUB_SIZE = sizeof(ExportStubIA64Template);
+        OFFSET_OF_ADDR = 40;
+        if (FAILED(m_pCeeFileGen->GetSectionBlock (m_pILSection, EXPORT_STUB_SIZE, STUB_ALIGNMENT, (void **) &outBuff))) return 0;
+        memcpy(outBuff,STUB_TEMPLATE,EXPORT_STUB_SIZE);
+        pdwVTFSlotRVA = (DWORD*)(&outBuff[OFFSET_OF_ADDR]);
+        *pdwVTFSlotRVA = VAL32(dwVTFSlotRVA);
+    
+        // The offset where we start, (not where the alignment bytes start!)
+        if (FAILED(m_pCeeFileGen->GetSectionDataLen (m_pILSection, &PEFileOffset))) return 0;
+    
+        PEFileOffset -= EXPORT_STUB_SIZE;
+        *((DWORD*)(&outBuff[OFFSET_OF_ADDR - 8])) = PEFileOffset; // set PLabel
+        m_pCeeFileGen->AddSectionReloc(m_pILSection, PEFileOffset+OFFSET_OF_ADDR-8,m_pILSection, srRelocHighLow);
+        m_pCeeFileGen->AddSectionReloc(m_pILSection, PEFileOffset+OFFSET_OF_ADDR,m_pGlobalDataSection, srRelocHighLow);
+        PEFileOffset += OFFSET_OF_ADDR - 8; // entry point is PLabel, which points at the template
+    }
+    else
+    {
+        if(m_dwCeeFileFlags & ICEE_CREATE_MACHINE_AMD64)
+        {
+            STUB_TEMPLATE = (BYTE*)&ExportStubAMD64Template[0];
+            EXPORT_STUB_SIZE = sizeof(ExportStubAMD64Template);
+            OFFSET_OF_ADDR = 2;
+            STUB_ALIGNMENT = 4;
+        }
+        else if(m_dwCeeFileFlags & ICEE_CREATE_MACHINE_I386)
+        {
+            STUB_TEMPLATE = (BYTE*)&ExportStubX86Template[0];
+            EXPORT_STUB_SIZE = sizeof(ExportStubX86Template);
+            OFFSET_OF_ADDR = 2;
+        }
+        else if(m_dwCeeFileFlags & ICEE_CREATE_MACHINE_ARM)
+        {
+            STUB_TEMPLATE = (BYTE*)&ExportStubARMTemplate[0];
+            EXPORT_STUB_SIZE = sizeof(ExportStubARMTemplate);
+            OFFSET_OF_ADDR = 4;
+            STUB_ALIGNMENT = 4;
+        }
+        else
+        {
+            report->error("Unmanaged exports are not implemented for unknown platform");
+            return NULL;
+        }
+        // Addr must be aligned, not the stub!
+        if (FAILED(m_pCeeFileGen->GetSectionDataLen (m_pILSection, &PEFileOffset))) return 0;
+        if((PEFileOffset + OFFSET_OF_ADDR)&(STUB_ALIGNMENT-1))
+        {
+            ULONG L = STUB_ALIGNMENT - ((PEFileOffset + OFFSET_OF_ADDR)&(STUB_ALIGNMENT-1));
+            if (FAILED(m_pCeeFileGen->GetSectionBlock (m_pILSection, L, 1, (void **) &outBuff))) return 0;
+            memset(outBuff,0,L);
+        }
+        
+        if (FAILED(m_pCeeFileGen->GetSectionBlock (m_pILSection, EXPORT_STUB_SIZE, 1, (void **) &outBuff))) return 0;
+        memcpy(outBuff,STUB_TEMPLATE,EXPORT_STUB_SIZE);
+        pdwVTFSlotRVA = (DWORD*)(&outBuff[OFFSET_OF_ADDR]);
+        *pdwVTFSlotRVA = VAL32(dwVTFSlotRVA);
+    
+        // The offset where we start, (not where the alignment bytes start!)
+        if (FAILED(m_pCeeFileGen->GetSectionDataLen (m_pILSection, &PEFileOffset))) return 0;
+    
+        PEFileOffset -= EXPORT_STUB_SIZE;
+        _ASSERTE(((PEFileOffset + OFFSET_OF_ADDR)&(STUB_ALIGNMENT-1))==0);
+        m_pCeeFileGen->AddSectionReloc(m_pILSection, PEFileOffset+OFFSET_OF_ADDR,m_pGlobalDataSection, srRelocHighLow);
+    }
+    if(m_dwCeeFileFlags & ICEE_CREATE_FILE_STRIP_RELOCS)
+    {
+        report->error("Base relocations are emitted, while /STRIPRELOC option has been specified");
+    }
+    m_pCeeFileGen->GetMethodRVA(m_pCeeFile, PEFileOffset,&PEFileOffset);
+    return PEFileOffset;
+}
+//#endif
+
+HRESULT Assembler::GetCAName(mdToken tkCA, __out LPWSTR *ppszName)
+{
+    HRESULT hr = S_OK;
+    DWORD cchName;
+    LPWSTR name;
+
+    *ppszName = NULL;
+
+    if (TypeFromToken(tkCA) == mdtMemberRef)
+    {
+        mdToken parent;
+        if (FAILED(hr = m_pImporter->GetMemberRefProps( tkCA, &parent, NULL, 0, NULL, NULL, NULL)))
+            return hr;
+        tkCA = parent;
+    }
+    else if (TypeFromToken(tkCA) == mdtMethodDef)
+    {
+        mdToken parent;
+        if (FAILED(hr = m_pImporter->GetMemberProps( tkCA, &parent, NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)))
+            return hr;
+        tkCA = parent;
+    }
+
+    if (TypeFromToken(tkCA) == mdtTypeRef)
+    {
+        // A TypeRef
+        if (FAILED(hr = m_pImporter->GetTypeRefProps(tkCA, NULL, NULL, 0, &cchName)))
+            return hr;
+        if ((name = new WCHAR[cchName + 1]) == NULL)
+            return E_OUTOFMEMORY;
+        hr = m_pImporter->GetTypeRefProps(tkCA, NULL, name, cchName, &cchName);
+    }
+    else
+    {
+        hr = m_pImporter->GetTypeDefProps(tkCA, NULL, 0, &cchName, NULL, NULL);
+        if (hr != S_OK)
+            return hr;
+        if ((name = new WCHAR[cchName + 1]) == NULL)
+            return E_OUTOFMEMORY;
+        hr = m_pImporter->GetTypeDefProps(tkCA, name, cchName, &cchName, NULL, NULL);
+    }
+    if (SUCCEEDED(hr))
+        *ppszName = name;
+    else
+        delete [] name;
+    return hr;
+}
+
+BYTE HexToByte (CHAR wc)
+{
+    if (!iswxdigit(wc)) return (BYTE) 0xff;
+    if (iswdigit(wc)) return (BYTE) (wc - L'0');
+    if (iswupper(wc)) return (BYTE) (wc - L'A' + 10);
+    return (BYTE) (wc - L'a' + 10);
+}
+
+bool GetBytesFromHex (LPCSTR szPublicKeyHexString, ULONG cchPublicKeyHexString, BYTE** buffer, ULONG *cbBufferSize)
+{
+    ULONG cchHex = cchPublicKeyHexString;
+    if (cchHex % 2 != 0)
+        return false;
+    *cbBufferSize = cchHex / 2;
+
+    *buffer = new BYTE[*cbBufferSize];
+    if (!*buffer)
+        return false;
+
+    for (ULONG i = 0; i < *cbBufferSize; i++)
+    {
+        BYTE msn = HexToByte(*szPublicKeyHexString);
+        BYTE lsn = HexToByte(*(szPublicKeyHexString + 1));
+        if (msn == 0xFF || lsn == 0xFF)
+        {
+            delete[] *buffer;
+            return false;
+        }
+
+        (*buffer)[i] = (BYTE) ( (msn << 4) | lsn );
+        szPublicKeyHexString += 2;
+    }
+
+    return true;
+}
+
+HRESULT Assembler::GetSignatureKey()
+{
+    HRESULT     hr = S_OK;
+    ULONG        cbSize = 0;
+    void *            pvData = NULL;
+    LPWSTR      pName = NULL;
+    
+    CustomDescrList* pCDList = &m_pManifest->m_pAssembly->m_CustomDescrList;
+    
+    for (ULONG i = 0;i < pCDList->COUNT(); i++)
+    {
+        CustomDescr* pCD = pCDList->PEEK(i);
+
+        if(pCD->pBlob)
+        {
+            pvData = (void *)(pCD->pBlob->ptr());
+            cbSize = pCD->pBlob->length();
+            pCD->tkOwner = m_pManifest->m_pAssembly->tkTok;
+            mdToken tkOwnerType, tkTypeType = TypeFromToken(pCD->tkType);
+            
+            if (GetCAName(pCD->tkType, &pName) != S_OK)
+                continue;
+
+            if (wcscmp(pName, L"System.Reflection.AssemblySignatureKeyAttribute") == 0)
+            {
+                    if (cbSize < sizeof(WORD) || GET_UNALIGNED_VAL16(pvData) != 1)
+                    {
+                        hr = E_FAIL;
+                        break;;
+                    }
+                    pvData = (unsigned char *)pvData  + sizeof(WORD);
+                    cbSize -= sizeof(WORD);
+                    
+                    // String is stored as compressed length, UTF8.
+                    if (*(const BYTE*)pvData != 0xFF)
+                    {
+                        PCCOR_SIGNATURE sig = (PCCOR_SIGNATURE)pvData;
+                        cbSize -= CorSigUncompressedDataSize(sig);
+                        DWORD len = CorSigUncompressData(sig);
+                        pvData = (void *)sig;
+                        if (cbSize < len)
+                        {
+                            hr = E_FAIL;
+                            break;
+                        }
+
+                        AsmManStrongName   *pSN = &m_pManifest->m_sStrongName;
+                        GetBytesFromHex((LPCSTR)pvData, len, &pSN->m_pbSignatureKey, &pSN->m_cbSignatureKey);
+                    }
+                    
+                    break;
+            }
+            
+            if (pName)
+            {
+                delete pName;
+                pName = NULL;
+            }
+        }
+    }
+
+    if (pName)
+        delete pName;
+    return hr;
+}
+
+HRESULT Assembler::AllocateStrongNameSignature()
+{
+    HRESULT             hr = S_OK;
+    HCEESECTION         hSection;
+    DWORD               dwDataLength;
+    DWORD               dwDataOffset;
+    DWORD               dwDataRVA;
+    VOID               *pvBuffer;
+    AsmManStrongName   *pSN = &m_pManifest->m_sStrongName;
+
+    // Pulls  the AssemblySignatureKey attribute from m_CustomDescrList
+    // If present, populate the pSN->m_pbSignatureKey from the AssemblySignatureKeyAttribute blob
+    if (FAILED(hr = GetSignatureKey()))
+    {
+        return hr;
+    }
+
+   // Determine size of signature blob.
+    if (pSN->m_pbSignatureKey != NULL)
+    {
+        // If m_pbSignatureKey present use it, else fall back to using identity key.
+        if (FAILED(hr = LegacyActivationShim::StrongNameSignatureSize_HRESULT(
+            pSN->m_pbSignatureKey, 
+            pSN->m_cbSignatureKey, 
+            &dwDataLength)))
+         {
+            return hr;
+        }
+    }
+    else if (FAILED(hr = LegacyActivationShim::StrongNameSignatureSize_HRESULT(
+            pSN->m_pbPublicKey, 
+            pSN->m_cbPublicKey, 
+            &dwDataLength)))
+    {
+        return hr;
+    }
+
+    // Grab memory in the section for our stuff.
+    if (FAILED(hr = m_pCeeFileGen->GetIlSection(m_pCeeFile,
+                                                &hSection)))
+        return hr;
+
+    if (FAILED(hr = m_pCeeFileGen->GetSectionBlock(hSection,
+                                                   dwDataLength,
+                                                   4,
+                                                   &pvBuffer)))
+        return hr;
+
+    // Where did we get that memory?
+    if (FAILED(hr = m_pCeeFileGen->GetSectionDataLen(hSection,
+                                                     &dwDataOffset)))
+        return hr;
+
+    dwDataOffset -= dwDataLength;
+
+    // Convert to an RVA.
+    if (FAILED(hr = m_pCeeFileGen->GetMethodRVA(m_pCeeFile,
+                                                dwDataOffset,
+                                                &dwDataRVA)))
+        return hr;
+
+    // Emit the directory entry.
+    if (FAILED(hr = m_pCeeFileGen->SetStrongNameEntry(m_pCeeFile,
+                                                      dwDataLength,
+                                                      dwDataRVA)))
+        return hr;
+
+    return S_OK;
+}
+
+HRESULT Assembler::StrongNameSign()
+{
+    LPWSTR              wszOutputFile;
+    HRESULT             hr = S_OK;
+    AsmManStrongName   *pSN = &m_pManifest->m_sStrongName;
+
+    // Determine what the ouput PE was called.
+    if (FAILED(hr = m_pCeeFileGen->GetOutputFileName(m_pCeeFile,
+                                                     &wszOutputFile)))
+        return hr;
+
+    // Update the output PE image with a strong name signature.
+    if (FAILED(hr = LegacyActivationShim::StrongNameSignatureGeneration_HRESULT(
+        wszOutputFile, 
+        pSN->m_wzKeyContainer, 
+        pSN->m_pbPrivateKey, 
+        pSN->m_cbPrivateKey, 
+        NULL, 
+        NULL)))
+    {
+        return hr;
+    }
+
+    return S_OK;
+}
+
+BOOL Assembler::EmitFieldsMethods(Class* pClass)
+{
+    unsigned n;
+    BOOL ret = TRUE;
+    // emit all field definition metadata tokens
+    if((n = pClass->m_FieldDList.COUNT()))
+    {
+        FieldDescriptor*    pFD;
+        if(m_fReportProgress) printf("Fields: %d;\t",n);
+        for(int j=0; (pFD = pClass->m_FieldDList.PEEK(j)); j++) // can't use POP here: we'll need field list for props
+        {
+            if(!EmitField(pFD))
+            {
+                if(!OnErrGo) return FALSE;
+                ret = FALSE;
+            }
+            pFD->m_fNew = FALSE;
+        }
+    }
+    // Fields are emitted; emit the class layout
+    {
+        COR_FIELD_OFFSET *pOffsets = NULL;
+        ULONG ul = pClass->m_ulPack;
+        ULONG N = pClass->m_dwNumFieldsWithOffset;
+
+        EmitSecurityInfo(pClass->m_cl,
+                         pClass->m_pPermissions,
+                         pClass->m_pPermissionSets);
+        pClass->m_pPermissions = NULL;
+        pClass->m_pPermissionSets = NULL;
+        if((pClass->m_ulSize != 0xFFFFFFFF)||(ul != 0)||(N != 0))
+        {
+            if(IsTdAutoLayout(pClass->m_Attr)) report->warn("Layout specified for auto-layout class\n");
+            if((ul > 128)||((ul & (ul-1)) !=0 ))
+                report->error("Invalid packing parameter (%d), must be 1,2,4,8...128\n",pClass->m_ulPack);
+            if(N)
+            {
+                pOffsets = new COR_FIELD_OFFSET[N+1];
+                ULONG i,j=0;
+                FieldDescriptor *pFD;
+                for(i=0; (pFD = pClass->m_FieldDList.PEEK(i)); i++)
+                {
+                    if(pFD->m_ulOffset != 0xFFFFFFFF)
+                    {
+                        pOffsets[j].ridOfField = RidFromToken(pFD->m_fdFieldTok);
+                        pOffsets[j].ulOffset = pFD->m_ulOffset;
+                        j++;
+                    }
+                }
+                _ASSERTE(j == N);
+                pOffsets[j].ridOfField = mdFieldDefNil;
+            }
+            m_pEmitter->SetClassLayout   (
+                        pClass->m_cl,       // [IN] typedef
+                        ul,                     // [IN] packing size specified as 1, 2, 4, 8, or 16
+                        pOffsets,               // [IN] array of layout specification
+                        pClass->m_ulSize); // [IN] size of the class
+            if(pOffsets) delete [] pOffsets;
+        }
+    }
+    // emit all method definition metadata tokens
+    if((n = pClass->m_MethodList.COUNT()))
+    {
+        Method* pMethod;
+
+        if(m_fReportProgress) printf("Methods: %d;\t",n);
+        for(int i=0; (pMethod = pClass->m_MethodList.PEEK(i));i++)
+        {
+            if(!EmitMethod(pMethod))
+            {
+                if(!OnErrGo) return FALSE;
+                ret = FALSE;
+            }
+            pMethod->m_fNew = FALSE;
+        }
+    }
+    if(m_fReportProgress) printf("\n");
+    return ret;
+}
+
+HRESULT Assembler::ResolveLocalMemberRefs()
+{
+    unsigned ulTotal=0, ulDefs=0, ulRefs=0, ulUnres=0;
+    MemberRefDList* pList[2] = {&m_LocalMethodRefDList,&m_LocalFieldRefDList};
+
+    if(pList[0]->COUNT() + pList[1]->COUNT())
+    {
+        MemberRefDescriptor*    pMRD;
+        mdToken         tkMemberDef = 0;
+        int i,j,k;
+        Class   *pSearch;
+
+        if(m_fReportProgress) printf("Resolving local member refs: ");
+        for(k=0; k<2; k++)
+        {
+            for(i=0; (pMRD = pList[k]->PEEK(i)) != NULL; i++)
+            {
+                if(pMRD->m_tkResolved) continue;
+
+                tkMemberDef = 0;
+                Method* pListMD;
+                char*           pMRD_szName = pMRD->m_szName;
+                DWORD           pMRD_dwName = pMRD->m_dwName;
+                ULONG           pMRD_dwCSig = (pMRD->m_pSigBinStr ? pMRD->m_pSigBinStr->length() : 0);
+                PCOR_SIGNATURE  pMRD_pSig = (PCOR_SIGNATURE)(pMRD->m_pSigBinStr ? pMRD->m_pSigBinStr->ptr() : NULL);
+                CQuickBytes     qbSig;
+
+                ulTotal++;
+
+                pSearch = NULL;
+                if(pMRD->m_tdClass == mdTokenNil)
+                    pSearch = m_lstClass.PEEK(0);
+                else if((TypeFromToken(pMRD->m_tdClass) != mdtTypeDef)
+                    ||((pSearch = m_lstClass.PEEK(RidFromToken(pMRD->m_tdClass)-1)) == NULL))
+                {
+                    report->msg("Error: bad parent 0x%08X of local member ref '%s'\n",
+                        pMRD->m_tdClass,pMRD->m_szName);
+                }
+                if(pSearch)
+                {
+                    // MemberRef may reference a method or a field
+                    if(k==0) //methods
+                    {
+                        if((*pMRD_pSig & IMAGE_CEE_CS_CALLCONV_MASK)==IMAGE_CEE_CS_CALLCONV_VARARG)
+                        {
+                            ULONG L;
+                            qbSig.Shrink(0);
+                            _GetFixedSigOfVarArg(pMRD_pSig,pMRD_dwCSig,&qbSig,&L);
+                            pMRD_pSig = (PCOR_SIGNATURE)(qbSig.Ptr());
+                            pMRD_dwCSig = L;
+                        }
+                        for(j=0; (pListMD = pSearch->m_MethodList.PEEK(j)) != NULL; j++)
+                        {
+                            if(pListMD->m_dwName != pMRD_dwName) continue;
+                            if(strcmp(pListMD->m_szName,pMRD_szName)) continue;
+                            if(pListMD->m_dwMethodCSig  != pMRD_dwCSig)  continue;
+                            if(memcmp(pListMD->m_pMethodSig,pMRD_pSig,pMRD_dwCSig)) continue;
+                            tkMemberDef = pListMD->m_Tok;
+                            ulDefs++;
+                            break;
+                        }
+                        if(tkMemberDef && ((*pMRD_pSig & IMAGE_CEE_CS_CALLCONV_MASK)==IMAGE_CEE_CS_CALLCONV_VARARG))
+                        {
+                            WszMultiByteToWideChar(g_uCodePage,0,pMRD_szName,-1,wzUniBuf,dwUniBuf);
+
+                            if(IsMdPrivateScope(pListMD->m_Attr))
+                            {
+                                WCHAR* p = wcsstr(wzUniBuf,L"$PST06");
+                                if(p) *p = 0;
+                            }
+
+                            m_pEmitter->DefineMemberRef(tkMemberDef, wzUniBuf,
+                                                             pMRD->m_pSigBinStr->ptr(),
+                                                             pMRD->m_pSigBinStr->length(),
+                                                             &tkMemberDef);
+                            ulDefs--;
+                            ulRefs++;
+                        }
+                    }
+                    else   // fields
+                    {
+                        FieldDescriptor* pListFD;
+                        for(j=0; (pListFD = pSearch->m_FieldDList.PEEK(j)) != NULL; j++)
+                        {
+                            if(pListFD->m_dwName != pMRD_dwName) continue;
+                            if(strcmp(pListFD->m_szName,pMRD_szName)) continue;
+                            if(pListFD->m_pbsSig)
+                            {
+                                if(pListFD->m_pbsSig->length()  != pMRD_dwCSig)  continue;
+                                if(memcmp(pListFD->m_pbsSig->ptr(),pMRD_pSig,pMRD_dwCSig)) continue;
+                            }
+                            else if(pMRD_dwCSig) continue;
+                            tkMemberDef = pListFD->m_fdFieldTok;
+                            ulDefs++;
+                            break;
+                        }
+                    }
+                }
+                if(tkMemberDef==0)
+                { // could not resolve ref to def, make new ref and leave it this way
+                    if((pSearch = pMRD->m_pClass) != NULL)
+                    {
+                        mdToken tkRef = MakeTypeRef(1,pSearch->m_szFQN);
+
+                        if(RidFromToken(tkRef))
+                        {
+                            WszMultiByteToWideChar(g_uCodePage,0,pMRD_szName,-1,wzUniBuf,dwUniBuf);
+
+                            m_pEmitter->DefineMemberRef(tkRef, wzUniBuf, pMRD_pSig,
+                                pMRD_dwCSig, &tkMemberDef);
+                            ulRefs++;
+                        }
+                        else
+                        {
+                            report->msg("Error: unresolved member ref '%s' of class 0x%08X\n",pMRD->m_szName,pMRD->m_tdClass);
+                            ulUnres++;
+                        }
+                    }
+                    else
+                    {
+                        report->msg("Error: unresolved global member ref '%s'\n",pMRD->m_szName);
+                        ulUnres++;
+                    }
+                }
+                pMRD->m_tkResolved = tkMemberDef;
+            }
+        }
+        for(i=0; (pMRD = m_MethodSpecList.PEEK(i)) != NULL; i++)
+        {
+            if(pMRD->m_tkResolved) continue;
+            tkMemberDef = pMRD->m_tdClass;
+            if(TypeFromToken(tkMemberDef)==0x99000000)
+            {
+                tkMemberDef = m_LocalMethodRefDList.PEEK(RidFromToken(tkMemberDef)-1)->m_tkResolved;
+                if((TypeFromToken(tkMemberDef)==mdtMethodDef)||(TypeFromToken(tkMemberDef)==mdtMemberRef))
+                {
+                    ULONG           pMRD_dwCSig = (pMRD->m_pSigBinStr ? pMRD->m_pSigBinStr->length() : 0);
+                    PCOR_SIGNATURE  pMRD_pSig = (PCOR_SIGNATURE)(pMRD->m_pSigBinStr ? pMRD->m_pSigBinStr->ptr() : NULL);
+                    HRESULT hr = m_pEmitter->DefineMethodSpec(tkMemberDef, pMRD_pSig, pMRD_dwCSig, &(pMRD->m_tkResolved));
+                    if(FAILED(hr))
+                        report->error("Unable to define method instantiation");
+                }
+            }
+            if(RidFromToken(pMRD->m_tkResolved)) ulDefs++;
+            else ulUnres++;
+        }
+        if(m_fReportProgress) printf("%d -> %d defs, %d refs, %d unresolved\n",ulTotal,ulDefs,ulRefs,ulUnres);
+    }
+    return (ulUnres ? E_FAIL : S_OK);
+}
+
+HRESULT Assembler::DoLocalMemberRefFixups()
+{
+    MemberRefDList* pList;
+    unsigned    Nlmr = m_LocalMethodRefDList.COUNT() + m_LocalFieldRefDList.COUNT(),
+                Nlmrf = m_LocalMemberRefFixupList.COUNT();
+    HRESULT     hr = S_OK;
+    if(Nlmr)
+    {
+        MemberRefDescriptor* pMRD;
+        LocalMemberRefFixup* pMRF;
+        int i;
+        for(i = 0; (pMRF = m_LocalMemberRefFixupList.PEEK(i)) != NULL; i++)
+        {
+            if(m_fENCMode && (!pMRF->m_fNew)) continue;
+
+            switch(TypeFromToken(pMRF->tk))
+            {
+                case 0x99000000: pList = &m_LocalMethodRefDList; break;
+                case 0x98000000: pList = &m_LocalFieldRefDList; break;
+                case 0x9A000000: pList = &m_MethodSpecList; break;
+                default: pList = NULL; break;
+            }
+            if(pList)
+            {
+                if((pMRD = pList->PEEK(RidFromToken(pMRF->tk)-1)) != NULL)
+                    SET_UNALIGNED_VAL32((void *)(pMRF->offset), pMRD->m_tkResolved);
+                else
+                {
+                    report->msg("Error: bad local member ref token 0x%08X in LMR fixup\n",pMRF->tk);
+                    hr = E_FAIL;
+                }
+            }
+            pMRF->m_fNew = FALSE;
+        }
+    }
+    else if(Nlmrf)
+    {
+        report->msg("Error: %d local member ref fixups, no local member refs\n",Nlmrf);
+        hr = E_FAIL;
+    }
+    return hr;
+}
+void Assembler::EmitUnresolvedCustomAttributes()
+{
+    CustomDescr *pCD;
+    while((pCD = m_CustomDescrList.POP()) != NULL)
+    {
+        pCD->tkType = ResolveLocalMemberRef(pCD->tkType);
+        pCD->tkOwner = ResolveLocalMemberRef(pCD->tkOwner);
+        // Look for the class'es interfaceimpl if this CA is one of those
+        if (pCD->tkInterfacePair)
+            pCD->tkOwner = GetInterfaceImpl(pCD->tkOwner, pCD->tkInterfacePair);
+        DefineCV(new CustomDescr(pCD->tkOwner,pCD->tkType,pCD->pBlob));
+    }
+}
+
+BOOL Assembler::EmitEventsProps(Class* pClass)
+{
+    unsigned n;
+    BOOL ret = TRUE;
+    // emit all event definition metadata tokens
+    if((n = pClass->m_EventDList.COUNT()))
+    {
+        if(m_fReportProgress) printf("Events: %d;\t",n);
+        EventDescriptor* pED;
+        for(int j=0; (pED = pClass->m_EventDList.PEEK(j)); j++) // can't use POP here: we'll need event list for props
+        {
+            if(!EmitEvent(pED))
+            {
+                if(!OnErrGo) return FALSE;
+                ret = FALSE;
+            }
+            pED->m_fNew = FALSE;
+        }
+    }
+    // emit all property definition metadata tokens
+    if((n = pClass->m_PropDList.COUNT()))
+    {
+        if(m_fReportProgress) printf("Props: %d;\t",n);
+        PropDescriptor* pPD;
+
+        for(int j=0; (pPD = pClass->m_PropDList.PEEK(j)); j++)
+        {
+            if(!EmitProp(pPD))
+            {
+                if(!OnErrGo) return FALSE;
+                ret = FALSE;
+            }
+            pPD->m_fNew = FALSE;
+        }
+    }
+    if(m_fReportProgress) printf("\n");
+    return ret;
+}
+
+#ifdef _PREFAST_
+#pragma warning(push)
+#pragma warning(disable:21000) // Suppress PREFast warning about overly large function
+#endif
+HRESULT Assembler::CreatePEFile(__in __nullterminated WCHAR *pwzOutputFilename)
+{
+    HRESULT             hr;
+    DWORD               mresourceSize = 0;
+    BYTE*               mresourceData = NULL;
+    WCHAR*              wzScopeName = NULL;
+
+    if(bClock) bClock->cMDEmitBegin = GetTickCount();
+    if(m_fReportProgress) printf("Creating PE file\n");
+    if (!m_pEmitter)
+    {
+        printf("Error: Cannot create a PE file with no metadata\n");
+        return E_FAIL;
+    }
+    if(!(m_fDLL || m_fEntryPointPresent))
+    {
+        printf("Error: No entry point declared for executable\n");
+        if(!OnErrGo) return E_FAIL;
+    }
+
+    if(bClock) bClock->cMDEmit1 = GetTickCount();
+
+    // Allocate space for a strong name signature if we're delay or full
+    // signing the assembly.
+    if (m_pManifest->m_sStrongName.m_pbPublicKey)
+        if (FAILED(hr = AllocateStrongNameSignature()))
+            goto exit;
+    if(bClock) bClock->cMDEmit2 = GetTickCount();
+
+    if(m_VTFList.COUNT()==0)
+    {
+        Method* pMD;
+        Class* pClass;
+        unsigned N=0, OrdBase=0xFFFFFFFF, i, j;
+        for(i=0; (pClass = m_lstClass.PEEK(i)) != NULL; i++)
+        {
+            for(j = 0; (pMD = pClass->m_MethodList.PEEK(j)) != NULL; j++)
+            {
+                if(pMD->m_dwExportOrdinal != 0xFFFFFFFF)
+                {
+                    N++;
+                    if(pMD->m_dwExportOrdinal < OrdBase) OrdBase = pMD->m_dwExportOrdinal;
+                }
+            }
+        }
+        if(N)
+        {
+            for(i=0; (pClass = m_lstClass.PEEK(i)) != NULL; i++)
+            {
+                for(j = 0; (pMD = pClass->m_MethodList.PEEK(j)) != NULL; j++)
+                {
+                    if(pMD->m_wVTSlot >= 0x8000)
+                    {
+                        pMD->m_wVTSlot -= 0x8000 + OrdBase - 1;
+                    }
+                }
+            }
+            SetDataSection();
+            char* sz = new char[20];
+            strcpy_s(sz,20,"VTF_EAT_internal");
+            EmitDataLabel(sz);
+            sz = new char[20];
+            strcpy_s(sz,20,"VTF_EAT_internal");
+            if(m_dwCeeFileFlags & ICEE_CREATE_FILE_PE64)
+            {
+                ULONGLONG *pdw = new ULONGLONG[N];
+                for(i=0; i<N; i++) pdw[i] = UI64(0xdeadbeefdeadbeef);
+                EmitData(pdw,sizeof(ULONGLONG)*N);
+                m_VTFList.PUSH(new VTFEntry((USHORT)N,COR_VTABLE_64BIT|COR_VTABLE_FROM_UNMANAGED,sz));
+                delete [] pdw;
+            }
+            else
+            {
+                unsigned *pdw = new unsigned[N];
+                for(i=0; i<N; i++) pdw[i] = 0xdeadbeef;
+                EmitData(pdw,sizeof(unsigned)*N);
+                m_VTFList.PUSH(new VTFEntry((USHORT)N,COR_VTABLE_32BIT|COR_VTABLE_FROM_UNMANAGED,sz));
+                delete [] pdw;
+            }
+        }
+    }
+    wzScopeName=&wzUniBuf[0];
+    if(m_szScopeName[0]) // default: scope name = output file name
+    {
+        WszMultiByteToWideChar(g_uCodePage,0,m_szScopeName,-1,wzScopeName,MAX_SCOPE_LENGTH);
+    }
+    else
+    {
+        WCHAR* pwc;
+        if ((pwc = wcsrchr(m_wzOutputFileName, '\\')) != NULL) pwc++;
+        else if ((pwc = wcsrchr(m_wzOutputFileName, ':')) != NULL) pwc++;
+        else pwc = m_wzOutputFileName;
+
+        wcsncpy_s(wzScopeName, MAX_SCOPE_LENGTH, pwc, _TRUNCATE);
+    }
+    hr = m_pEmitter->SetModuleProps(wzScopeName);
+
+    if (FAILED(hr))
+        goto exit;
+
+    EmitImports();
+    if(m_pManifest)
+    {
+        hr = S_OK;
+        if(m_pManifest->m_pAsmEmitter==NULL)
+            hr=m_pEmitter->QueryInterface(IID_IMetaDataAssemblyEmit, (void**) &(m_pManifest->m_pAsmEmitter));
+
+        if(SUCCEEDED(hr))
+        {
+            m_pManifest->EmitAssemblyRefs();
+        }
+    }
+    // Emit classes, class members and globals:
+    {
+        Class *pSearch;
+        int i;
+        BOOL    bIsUndefClass = FALSE;
+        if(m_fReportProgress)   printf("\nEmitting classes:\n");
+        for (i=1; (pSearch = m_lstClass.PEEK(i)); i++)   // 0 is <Module>
+        {
+            if(m_fReportProgress)
+                printf("Class %d:\t%s\n",i,pSearch->m_szFQN);
+
+            if(pSearch->m_bIsMaster)
+            {
+                report->msg("Error: Reference to undefined class '%s'\n",pSearch->m_szFQN);
+                bIsUndefClass = TRUE;
+            }
+            if(!EmitClass(pSearch))
+            {
+                if(!OnErrGo) return E_FAIL;
+            }
+            pSearch->m_fNew = FALSE;
+        }
+        if(bIsUndefClass && !OnErrGo) return E_FAIL;
+
+        if(m_fReportProgress)   printf("\nEmitting fields and methods:\n");
+        for (i=0; (pSearch = m_lstClass.PEEK(i)) != NULL; i++)
+        {
+            if(m_fReportProgress)
+            {
+                if(i == 0)  printf("Global \t");
+                else        printf("Class %d\t",i);
+            }
+            if(!EmitFieldsMethods(pSearch))
+            {
+                if(!OnErrGo) return E_FAIL;
+            }
+        }
+    }
+
+    // All ref'ed items def'ed in this file are emitted, resolve member refs to member defs:
+    if(bClock) bClock->cRef2DefBegin = GetTickCount();
+    hr = ResolveLocalMemberRefs();
+    if(bClock) bClock->cRef2DefEnd = GetTickCount();
+    if(FAILED(hr) &&(!OnErrGo)) goto exit;
+
+    // Local member refs resolved, emit events, props and method impls
+    {
+        Class *pSearch;
+        int i;
+
+        if(m_fReportProgress)   printf("\nEmitting events and properties:\n");
+        for (i=0; (pSearch = m_lstClass.PEEK(i)); i++)
+        {
+            if(m_fReportProgress)
+            {
+                if(i == 0)  printf("Global \t");
+                else        printf("Class %d\t",i);
+            }
+            if(!EmitEventsProps(pSearch))
+            {
+                if(!OnErrGo) return E_FAIL;
+            }
+            pSearch->m_fNewMembers = FALSE;
+        }
+    }
+    if(bClock) bClock->cMDEmit3 = GetTickCount();
+    if(m_MethodImplDList.COUNT())
+    {
+        if(m_fReportProgress) report->msg("Method Implementations (total): %d\n",m_MethodImplDList.COUNT());
+        if(!EmitMethodImpls())
+        {
+            if(!OnErrGo) return E_FAIL;
+        }
+    }
+    // Emit the rest of the metadata
+    if(bClock) bClock->cMDEmit4 = GetTickCount();
+    hr = S_OK;
+    if(m_pManifest)
+    {
+        if (FAILED(hr = m_pManifest->EmitManifest())) goto exit;
+    }
+    ResolveLocalMemberRefs(); // in case CAs added some
+    EmitUnresolvedCustomAttributes();
+    // Emit typedefs as special TypeSpecs
+    {
+#define ELEMENT_TYPE_TYPEDEF ELEMENT_TYPE_MAX+1
+        TypeDefDescr* pTDD;
+        unsigned __int8* pb;
+        unsigned namesize;
+        while((pTDD = m_TypeDefDList.POP()))
+        {
+            BinStr* pbs = new BinStr();
+            if(pbs)
+            {
+                namesize = 1 + (unsigned)strlen(pTDD->m_szName);
+                pb = pbs->getBuff(namesize + 1 + sizeof(mdToken));
+                *pb = ELEMENT_TYPE_TYPEDEF;
+                memcpy(++pb,pTDD->m_szName,namesize);
+                pTDD->m_tkTypeSpec = ResolveLocalMemberRef(pTDD->m_tkTypeSpec);
+                memcpy(pb+namesize,&(pTDD->m_tkTypeSpec),sizeof(mdToken));
+                if(TypeFromToken(pTDD->m_tkTypeSpec)==mdtCustomAttribute)
+                {
+                    CustomDescr* pCA = pTDD->m_pCA;
+                    pbs->appendInt32(pCA->tkType);
+                    pbs->appendInt32(pCA->tkOwner);
+                    if(pCA->pBlob) pbs->append(pCA->pBlob);
+                }
+                ResolveTypeSpec(pbs);
+                delete pbs;
+            }
+            delete pTDD;
+        }
+    }
+    if(bClock) bClock->cMDEmitEnd = GetTickCount();
+
+    hr = DoLocalMemberRefFixups();
+    if(FAILED(hr) &&(!OnErrGo)) goto exit;
+    // Local member refs resolved and fixed up in BinStr method bodies. Emit the bodies.
+    {
+        Class* pClass;
+        Method* pMethod;
+        for (int i=0; (pClass = m_lstClass.PEEK(i)); i++)
+        {
+            for(int j=0; (pMethod = pClass->m_MethodList.PEEK(j)); j++)
+            {
+                if(!EmitMethodBody(pMethod,NULL))
+                {
+                    report->msg("Error: failed to emit body of '%s'\n",pMethod->m_szName);
+                    hr = E_FAIL;
+                    if(!OnErrGo) goto exit;
+                }
+                pMethod->m_fNewBody = FALSE;
+            }
+        }
+        //while(MethodBody* pMB = m_MethodBodyList.POP()) delete pMB;
+    }
+
+    if (DoGlobalFixups() == FALSE)
+        return E_FAIL;
+
+    if(m_wzResourceFile)
+    {
+        if (FAILED(hr=m_pCeeFileGen->SetResourceFileName(m_pCeeFile, m_wzResourceFile)))
+        {
+            report->msg("Warning: failed to set Win32 resource file name '%S', hr=0x%8.8X\n         The Win32 resource is not emitted.\n",
+                        m_wzResourceFile, hr);
+        }
+    }
+
+    if (FAILED(hr=CreateTLSDirectory())) goto exit;
+
+    if (FAILED(hr=CreateDebugDirectory())) goto exit;
+
+    if (FAILED(hr=m_pCeeFileGen->SetOutputFileName(m_pCeeFile, pwzOutputFilename))) goto exit;
+
+        // Reserve a buffer for the meta-data
+    DWORD metaDataSize;
+    if (FAILED(hr=m_pEmitter->GetSaveSize(cssAccurate, &metaDataSize))) goto exit;
+    BYTE* metaData;
+    if (FAILED(hr=m_pCeeFileGen->GetSectionBlock(m_pILSection, metaDataSize, sizeof(DWORD), (void**) &metaData))) goto exit;
+    ULONG metaDataOffset;
+    if (FAILED(hr=m_pCeeFileGen->GetSectionDataLen(m_pILSection, &metaDataOffset))) goto exit;
+    metaDataOffset -= metaDataSize;
+    // set managed resource entry, if any
+    if(m_pManifest && m_pManifest->m_dwMResSizeTotal)
+    {
+        mresourceSize = m_pManifest->m_dwMResSizeTotal;
+
+        if (FAILED(hr=m_pCeeFileGen->GetSectionBlock(m_pILSection, mresourceSize,
+                                            sizeof(DWORD), (void**) &mresourceData))) goto exit;
+        if (FAILED(hr=m_pCeeFileGen->SetManifestEntry(m_pCeeFile, mresourceSize, 0))) goto exit;
+    }
+    if(m_VTFList.COUNT())
+    {
+        GlobalLabel *pGlobalLabel;
+        VTFEntry*   pVTFEntry;
+
+        if(m_pVTable) delete m_pVTable; // can't have both; list takes precedence
+        m_pVTable = new BinStr();
+        hr = S_OK;
+        for(WORD k=0; (pVTFEntry = m_VTFList.POP()); k++)
+        {
+            if((pGlobalLabel = FindGlobalLabel(pVTFEntry->m_szLabel)))
+            {
+                Method* pMD;
+                Class* pClass;
+                m_pVTable->appendInt32(pGlobalLabel->m_GlobalOffset);
+                m_pVTable->appendInt16(pVTFEntry->m_wCount);
+                m_pVTable->appendInt16(pVTFEntry->m_wType);
+                for(int i=0; (pClass = m_lstClass.PEEK(i)); i++)
+                {
+                    for(WORD j = 0; (pMD = pClass->m_MethodList.PEEK(j)); j++)
+                    {
+                        if(pMD->m_wVTEntry == k+1)
+                        {
+                            char*   ptr;
+                            if(SUCCEEDED(hr = m_pCeeFileGen->ComputeSectionPointer(m_pGlobalDataSection,pGlobalLabel->m_GlobalOffset,&ptr)))
+                            {
+                                DWORD dwDelta;
+                                if((pVTFEntry->m_wType & COR_VTABLE_32BIT))
+                                {
+                                    dwDelta = (pMD->m_wVTSlot-1)*(DWORD)sizeof(DWORD);
+                                    ptr += dwDelta;
+                                    DWORD* mptr = (DWORD*)ptr;
+                                    *mptr = (DWORD)(pMD->m_Tok);
+                                }
+                                else
+                                {
+                                    dwDelta = (pMD->m_wVTSlot-1)*(DWORD)sizeof(ULONGLONG);
+                                    ptr += dwDelta;
+                                    ULONGLONG* mptr = (ULONGLONG*)ptr;
+                                    *mptr = (ULONGLONG)(pMD->m_Tok);
+                                }
+                                if(pMD->m_dwExportOrdinal != 0xFFFFFFFF)
+                                {
+                                    EATEntry*   pEATE = new EATEntry;
+                                    pEATE->dwOrdinal = pMD->m_dwExportOrdinal;
+                                    pEATE->szAlias = pMD->m_szExportAlias ? pMD->m_szExportAlias : pMD->m_szName;
+                                    pEATE->dwStubRVA = EmitExportStub(pGlobalLabel->m_GlobalOffset+dwDelta);
+                                    m_EATList.PUSH(pEATE);
+                                }
+                            }
+                            else
+                                report->msg("Error: Failed to get pointer to label '%s' inVTable fixup\n",pVTFEntry->m_szLabel);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                report->msg("Error: Unresolved label '%s' in VTable fixup\n",pVTFEntry->m_szLabel);
+                hr = E_FAIL;
+            }
+            delete pVTFEntry;
+        }
+        if(FAILED(hr)) goto exit;
+    }
+    if(m_pVTable)
+    {
+        ULONG i, N = m_pVTable->length()/sizeof(DWORD);
+        ULONG ulVTableOffset;
+        m_pCeeFileGen->GetSectionDataLen (m_pILSection, &ulVTableOffset);
+        // SetVTableEntry will align VTable on DWORD
+        ulVTableOffset = (ulVTableOffset + (ULONG)sizeof(DWORD) - 1) & ~((ULONG)sizeof(DWORD) - 1);
+        if (FAILED(hr=m_pCeeFileGen->SetVTableEntry64(m_pCeeFile, m_pVTable->length(),(void*)(m_pVTable->ptr())))) goto exit; // @WARNING: casting down from pointer-size to DWORD
+        for(i = 0; i < N; i+=2)
+        {
+            m_pCeeFileGen->AddSectionReloc(m_pILSection,
+                                            ulVTableOffset+(i*sizeof(DWORD)),
+                                            m_pGlobalDataSection,
+                                            srRelocAbsolute);
+        }
+    }
+    if(m_EATList.COUNT())
+    {
+        if(FAILED(CreateExportDirectory())) goto exit;
+        m_dwComImageFlags &= ~COMIMAGE_FLAGS_ILONLY;
+        if (m_dwCeeFileFlags & ICEE_CREATE_MACHINE_I386)
+            COR_SET_32BIT_REQUIRED(m_dwComImageFlags);
+    }
+    if (m_fWindowsCE)
+    {
+        if (FAILED(hr=m_pCeeFileGen->SetSubsystem(m_pCeeFile, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI, 2, 10))) goto exit;
+
+        if (FAILED(hr=m_pCeeFileGen->SetImageBase(m_pCeeFile, 0x10000))) goto exit;
+    }
+    else
+    {
+        if (m_dwCeeFileFlags & ICEE_CREATE_MACHINE_ARM || m_fAppContainer)
+        {
+            // For AppContainer and ARM, you must have a minimum subsystem version of 6.02
+            m_wSSVersionMajor = (m_wSSVersionMajor < 6) ? 6 : m_wSSVersionMajor;
+            m_wSSVersionMinor = (m_wSSVersionMinor < 2 && m_wSSVersionMajor <= 6) ? 2 : m_wSSVersionMinor;
+
+        }
+
+        // Default the subsystem, instead the user doesn't set it to GUI or CUI
+        if (m_dwSubsystem == (DWORD)-1)
+            // The default for ILAsm previously was CUI, so that should be the default behavior...
+            m_dwSubsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI;
+
+        if (FAILED(hr=m_pCeeFileGen->SetSubsystem(m_pCeeFile, m_dwSubsystem, m_wSSVersionMajor, m_wSSVersionMinor))) goto exit;
+    }
+
+    if (FAILED(hr=m_pCeeFileGen->ClearComImageFlags(m_pCeeFile, COMIMAGE_FLAGS_ILONLY))) goto exit;
+    if (FAILED(hr=m_pCeeFileGen->SetComImageFlags(m_pCeeFile, m_dwComImageFlags & ~COMIMAGE_FLAGS_STRONGNAMESIGNED))) goto exit;
+
+    if(m_dwFileAlignment)
+    {
+        if(FAILED(hr=m_pCeeFileGen->SetFileAlignment(m_pCeeFile, m_dwFileAlignment))) goto exit;
+    }
+    if(m_stBaseAddress)
+    {
+
+        if(m_dwCeeFileFlags & ICEE_CREATE_FILE_PE64)
+        {
+            if(FAILED(hr=m_pCeeFileGen->SetImageBase64(m_pCeeFile, m_stBaseAddress))) goto exit;
+        }
+        else
+        {
+            if(FAILED(hr=m_pCeeFileGen->SetImageBase(m_pCeeFile, (size_t)m_stBaseAddress))) goto exit;
+        }
+    }
+    if(m_stSizeOfStackReserve || m_fAppContainer || m_fHighEntropyVA)
+    {
+        PIMAGE_NT_HEADERS   pNT;
+        PIMAGE_SECTION_HEADER   pSect;
+        ULONG   ulNumSect;
+        if(FAILED(hr=m_pCeeFileGen->GetHeaderInfo(m_pCeeFile,&pNT,&pSect,&ulNumSect))) goto exit;
+        if(m_dwCeeFileFlags & ICEE_CREATE_FILE_PE64)
+        {
+            PIMAGE_OPTIONAL_HEADER64 pOpt = (PIMAGE_OPTIONAL_HEADER64)(&pNT->OptionalHeader);
+            if (m_stSizeOfStackReserve)
+                pOpt->SizeOfStackReserve = VAL64(m_stSizeOfStackReserve); 
+            if (m_fAppContainer)
+                pOpt->DllCharacteristics |= IMAGE_DLLCHARACTERISTICS_APPCONTAINER;
+            if (m_fHighEntropyVA)
+                pOpt->DllCharacteristics |= IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA;
+        }
+        else
+        {
+            PIMAGE_OPTIONAL_HEADER32 pOpt = (PIMAGE_OPTIONAL_HEADER32)(&pNT->OptionalHeader);
+            if (m_stSizeOfStackReserve)
+                pOpt->SizeOfStackReserve = (DWORD)VAL32(m_stSizeOfStackReserve);
+            if (m_fAppContainer)
+                pOpt->DllCharacteristics |= IMAGE_DLLCHARACTERISTICS_APPCONTAINER;
+            if (m_fHighEntropyVA)
+                pOpt->DllCharacteristics |= IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA;
+        }
+    }
+        //Compute all the RVAs
+    if (FAILED(hr=m_pCeeFileGen->LinkCeeFile(m_pCeeFile))) goto exit;
+
+        // Fix up any fields that have RVA associated with them
+    if (m_fHaveFieldsWithRvas) {
+        hr = S_OK;
+        ULONG dataSectionRVA;
+        if (FAILED(hr=m_pCeeFileGen->GetSectionRVA(m_pGlobalDataSection, &dataSectionRVA))) goto exit;
+
+        ULONG tlsSectionRVA;
+        if (FAILED(hr=m_pCeeFileGen->GetSectionRVA(m_pTLSSection, &tlsSectionRVA))) goto exit;
+
+        ULONG ilSectionRVA;
+        if (FAILED(hr=m_pCeeFileGen->GetSectionRVA(m_pILSection, &ilSectionRVA))) goto exit;
+
+        FieldDescriptor* pListFD;
+        Class* pClass;
+        for(int i=0; (pClass = m_lstClass.PEEK(i)); i++)
+        {
+            for(int j=0; (pListFD = pClass->m_FieldDList.PEEK(j)); j++)
+            {
+                if (pListFD->m_rvaLabel != 0)
+                {
+                    DWORD rva;
+                    if(*(pListFD->m_rvaLabel)=='@')
+                    {
+                        rva = (DWORD)atoi(pListFD->m_rvaLabel + 1);
+                    }
+                    else
+                    {
+                        GlobalLabel *pLabel = FindGlobalLabel(pListFD->m_rvaLabel);
+                        if (pLabel == 0)
+                        {
+                            report->msg("Error:Could not find label '%s' for the field '%s'\n", pListFD->m_rvaLabel, pListFD->m_szName);
+                            hr = E_FAIL;
+                            continue;
+                        }
+
+                        rva = pLabel->m_GlobalOffset;
+                        if (pLabel->m_Section == m_pTLSSection)
+                            rva += tlsSectionRVA;
+                        else if (pLabel->m_Section == m_pILSection)
+                            rva += ilSectionRVA;
+                        else {
+                            _ASSERTE(pLabel->m_Section == m_pGlobalDataSection);
+                            rva += dataSectionRVA;
+                        }
+                    }
+                    if (FAILED(m_pEmitter->SetFieldRVA(pListFD->m_fdFieldTok, rva))) goto exit;
+                }
+            }
+        }
+        if (FAILED(hr)) goto exit;
+    }
+
+    if(bClock) bClock->cFilegenBegin = GetTickCount();
+    // actually output the meta-data
+    if (FAILED(hr=m_pCeeFileGen->EmitMetaDataAt(m_pCeeFile, m_pEmitter, m_pILSection, metaDataOffset, metaData, metaDataSize))) goto exit;
+    
+    if((m_wMSVmajor < 0xFF)&&(m_wMSVminor < 0xFF))
+    {
+        STORAGESIGNATURE *pSSig = (STORAGESIGNATURE *)metaData;
+        BYTE* pb = metaData;
+        pb += 3*sizeof(DWORD)+2*sizeof(WORD)+VAL32(pSSig->iVersionString);
+        pb = (BYTE*)(((size_t)pb + 3) & ~3);
+        PSTORAGEHEADER pSHdr = (PSTORAGEHEADER)pb;
+        PSTORAGESTREAM pStr = (PSTORAGESTREAM)(pSHdr+1);
+        for(short iStr = 1; iStr <= VAL16(pSHdr->iStreams); iStr++)
+        {
+            if((strcmp(pStr->rcName,"#-")==0)||(strcmp(pStr->rcName,"#~")==0))
+            {
+                pb = metaData + VAL32(pStr->iOffset); // start of the stream header
+                pb += sizeof(DWORD); // skip Reserved
+                *pb = VAL16(m_wMSVmajor)&0xFF;
+                *(pb+1) = VAL16(m_wMSVminor)&0xFF;
+                break;
+            }
+            pb = (BYTE*)pStr;
+            pb += 2*sizeof(DWORD)+strlen(pStr->rcName)+1;
+            pb = (BYTE*)(((size_t)pb + 3) & ~3);
+            pStr = (PSTORAGESTREAM)pb;
+        }
+    }
+
+    if(m_fTolerateDupMethods) // means that there are /ENC files
+    {
+        if(m_pbsMD) delete m_pbsMD;
+        m_pbsMD = new BinStr();
+        memcpy(m_pbsMD->getBuff(metaDataSize),metaData,metaDataSize);
+    }
+    // actually output the resources
+    if(mresourceSize && mresourceData)
+    {
+        size_t i, N = m_pManifest->m_dwMResNum, sizeread, L;
+        BYTE    *ptr = (BYTE*)mresourceData;
+        BOOL    mrfail = FALSE;
+        FILE*   pFile = NULL;
+        char sz[2048];
+        for(i=0; i < N; i++)
+        {
+            m_pManifest->m_fMResNew[i] = FALSE;
+            memset(sz,0,2048);
+            WszWideCharToMultiByte(CP_ACP,0,m_pManifest->m_wzMResName[i],-1,sz,2047,NULL,NULL);
+            L = m_pManifest->m_dwMResSize[i];
+            sizeread = 0;
+            memcpy(ptr,&L,sizeof(DWORD));
+            ptr += sizeof(DWORD);
+            if(fopen_s(&pFile,sz,"rb") == 0)
+            {
+                sizeread = fread((void *)ptr,1,L,pFile);
+                fclose(pFile);
+                ptr += sizeread;
+            }
+            else
+            {
+                report->msg("Error: failed to open mgd resource file '%ls'\n",m_pManifest->m_wzMResName[i]);
+                mrfail = TRUE;
+            }
+            if(sizeread < L)
+            {
+                report->msg("Error: failed to read expected %d bytes from mgd resource file '%ls'\n",L,m_pManifest->m_wzMResName[i]);
+                mrfail = TRUE;
+                L -= sizeread;
+                memset(ptr,0,L);
+                ptr += L;
+            }
+        }
+        if(mrfail)
+        {
+            hr = E_FAIL;
+            goto exit;
+        }
+    }
+    /*
+    if((m_wRTVmajor < 0xFFFF)&&(m_wRTVminor < 0xFFFF))
+    {
+        IMAGE_COR20_HEADER* pCorH;
+        if(FAILED(hr=m_pCeeFileGen->GetCorHeader(m_pCeeFile,&pCorH))) goto exit;
+        pCorH->MajorRuntimeVersion = VAL16(m_wRTVmajor);
+        pCorH->MinorRuntimeVersion = VAL16(m_wRTVminor);
+    }
+    */
+    // Generate the file -- moved to main
+    //if (FAILED(hr=m_pCeeFileGen->GenerateCeeFile(m_pCeeFile))) goto exit;
+
+
+    hr = S_OK;
+
+exit:
+    return hr;
+}
+#ifdef _PREFAST_
+#pragma warning(pop)
+#endif
diff --git a/src/ilasm/writer_enc.cpp b/src/ilasm/writer_enc.cpp
new file mode 100644
index 0000000000..79f5245448
--- /dev/null
+++ b/src/ilasm/writer_enc.cpp
@@ -0,0 +1,661 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+//
+// writer_ENC.cpp
+//
+
+//
+#include "ilasmpch.h"
+
+#include "assembler.h"
+
+//#include "ceefilegenwriter.h"
+#include "strongname.h"
+
+int ist=0;
+#define REPT_STEP   //printf("Step %d\n",++ist);
+
+HRESULT Assembler::InitMetaDataForENC(__in __nullterminated WCHAR* wzOrigFileName)
+{
+    HRESULT             hr = E_FAIL;
+
+    if((wzOrigFileName==NULL)||(*wzOrigFileName == 0)||(m_pDisp==NULL)) return hr;
+    if (m_pSymWriter != NULL)
+    {
+        m_pSymWriter->Close();
+        m_pSymWriter->Release();
+        m_pSymWriter = NULL;
+    }
+    if (m_pImporter != NULL)
+    {
+        m_pImporter->Release();
+        m_pImporter = NULL;
+    }
+    if (m_pEmitter != NULL)
+    {
+        m_pEmitter->Release();
+        m_pEmitter = NULL;
+    }
+    //WszSetEnvironmentVariable(L"COMP_ENC_OPENSCOPE", wzOrigFileName);
+    //hr = m_pDisp->DefineScope(CLSID_CorMetaDataRuntime, 0, IID_IMetaDataEmit2,
+    //                    (IUnknown **)&m_pEmitter);
+
+    if((m_pbsMD==NULL)||(m_pbsMD->length()==0))
+    {
+        _ASSERTE(!"NO BASE METADATA!");
+        return E_FAIL;
+    }
+   
+    VARIANT encOption;
+    V_VT(&encOption) = VT_UI4;
+    V_UI4(&encOption) = MDUpdateENC;
+    m_pDisp->SetOption(MetaDataSetENC, &encOption);
+    V_UI4(&encOption) = MDErrorOutOfOrderDefault;
+    m_pDisp->SetOption(MetaDataErrorIfEmitOutOfOrder, &encOption);
+    hr = m_pDisp->OpenScopeOnMemory( m_pbsMD->ptr(), 
+                                     m_pbsMD->length(), 
+                                     ofWrite, 
+                                     IID_IMetaDataEmit2, 
+                                     (IUnknown **)&m_pEmitter);
+    _ASSERTE(SUCCEEDED(hr));
+    if (FAILED(hr))
+        goto exit;
+
+    m_pManifest->SetEmitter(m_pEmitter);
+    if(FAILED(hr = m_pEmitter->QueryInterface(IID_IMetaDataImport2, (void**)&m_pImporter)))
+        goto exit;
+
+    //WszSetEnvironmentVariable(L"COMP_ENC_EMIT", wzOrigFileName);
+    if(!Init()) goto exit; // close and re-open CeeFileGen and CeeFile
+    hr = S_OK;
+
+    hr = CoCreateInstance(CLSID_CorSymWriter_SxS,
+                           NULL,
+                           CLSCTX_INPROC_SERVER,
+                           IID_ISymUnmanagedWriter,
+                           (void **)&m_pSymWriter);
+    if(SUCCEEDED(hr))
+    {
+        WCHAR* pwc = &wzOrigFileName[wcslen(wzOrigFileName)];
+        wcscat_s(wzOrigFileName,MAX_SCOPE_LENGTH,L".pdb");
+        if(m_pSymWriter) m_pSymWriter->Initialize((IUnknown*)m_pEmitter,
+                                                  wzOrigFileName,
+                                                  NULL,
+                                                  TRUE);
+        *pwc = 0;
+    }
+    else 
+    {
+        fprintf(stderr, "Error: CoCreateInstance(IID_ISymUnmanagedWriter) returns %X\n",hr);
+        m_pSymWriter = NULL;
+    }
+
+
+exit:
+    return hr;
+}
+/*********************************************************************************/
+
+BOOL Assembler::EmitFieldsMethodsENC(Class* pClass)
+{
+    unsigned n;
+    BOOL ret = TRUE;
+    // emit all field definition metadata tokens
+    if((pClass->m_FieldDList.COUNT()))
+    {
+        FieldDescriptor*    pFD;
+        int j;
+        for(j=0, n=0; (pFD = pClass->m_FieldDList.PEEK(j)); j++) // can't use POP here: we'll need field list for props
+        {
+            if(pFD->m_fNew)
+            {
+                if(!EmitField(pFD))
+                {
+                    if(!OnErrGo) return FALSE;
+                    ret = FALSE;
+                }
+                pFD->m_fNew = FALSE;
+                n++;
+            }
+        }
+        if(m_fReportProgress) printf("Fields: %d;\t",n);
+    }
+    // Fields are emitted; emit the class layout
+    {
+        COR_FIELD_OFFSET *pOffsets = NULL;
+        ULONG ul = pClass->m_ulPack;
+        ULONG N = pClass->m_dwNumFieldsWithOffset;
+
+        EmitSecurityInfo(pClass->m_cl,
+                         pClass->m_pPermissions,
+                         pClass->m_pPermissionSets);
+        pClass->m_pPermissions = NULL;
+        pClass->m_pPermissionSets = NULL;
+        if((pClass->m_ulSize != 0xFFFFFFFF)||(ul != 0)||(N != 0))
+        {
+            if(IsTdAutoLayout(pClass->m_Attr)) report->warn("Layout specified for auto-layout class\n");
+            if((ul > 128)||((ul & (ul-1)) !=0 ))
+                report->error("Invalid packing parameter (%d), must be 1,2,4,8...128\n",pClass->m_ulPack);
+            if(N)
+            {
+                pOffsets = new COR_FIELD_OFFSET[N+1];
+                ULONG i,j=0;
+                FieldDescriptor *pFD;
+                for(i=0; (pFD = pClass->m_FieldDList.PEEK(i)); i++)
+                {
+                    if(pFD->m_ulOffset != 0xFFFFFFFF)
+                    {
+                        pOffsets[j].ridOfField = RidFromToken(pFD->m_fdFieldTok);
+                        pOffsets[j].ulOffset = pFD->m_ulOffset;
+                        j++;
+                    }
+                }
+                _ASSERTE(j == N);
+                pOffsets[j].ridOfField = mdFieldDefNil;
+            }
+            m_pEmitter->SetClassLayout   (   
+                        pClass->m_cl,       // [IN] typedef 
+                        ul,                     // [IN] packing size specified as 1, 2, 4, 8, or 16 
+                        pOffsets,               // [IN] array of layout specification   
+                        pClass->m_ulSize); // [IN] size of the class   
+            if(pOffsets) delete [] pOffsets;
+        }
+    }
+    // emit all method definition metadata tokens
+    if((pClass->m_MethodList.COUNT()))
+    {
+        Method* pMethod;
+        int i;
+
+        for(i=0, n=0; (pMethod = pClass->m_MethodList.PEEK(i));i++)
+        {
+            if(pMethod->m_fNew)
+            {
+                if(!EmitMethod(pMethod))
+                {
+                    if(!OnErrGo) return FALSE;
+                    ret = FALSE;
+                }
+                pMethod->m_fNew = FALSE;
+                n++;
+            }
+        }
+        if(m_fReportProgress) printf("Methods: %d;\t",n);
+    }
+    if(m_fReportProgress) printf("\n");
+    return ret;
+}
+
+BOOL Assembler::EmitEventsPropsENC(Class* pClass)
+{
+    unsigned n;
+    BOOL ret = TRUE;
+    // emit all event definition metadata tokens
+    if((pClass->m_EventDList.COUNT()))
+    {
+        EventDescriptor* pED;
+        int j;
+        for(j=0,n=0; (pED = pClass->m_EventDList.PEEK(j)); j++) // can't use POP here: we'll need event list for props
+        {
+            if(pED->m_fNew)
+            {
+                if(!EmitEvent(pED))
+                {
+                    if(!OnErrGo) return FALSE;
+                    ret = FALSE;
+                }
+                pED->m_fNew = FALSE;
+                n++;
+            }
+        }
+        if(m_fReportProgress) printf("Events: %d;\t",n);
+    }
+    // emit all property definition metadata tokens
+    if((pClass->m_PropDList.COUNT()))
+    {
+        PropDescriptor* pPD;
+        int j;
+
+        for(j=0,n=0; (pPD = pClass->m_PropDList.PEEK(j)); j++)
+        {
+            if(pPD->m_fNew)
+            {
+                if(!EmitProp(pPD))
+                {
+                    if(!OnErrGo) return FALSE;
+                    ret = FALSE;
+                }
+                pPD->m_fNew = FALSE;
+                n++;
+            }
+        }
+        if(m_fReportProgress) printf("Props: %d;\t",n);
+    }
+    if(m_fReportProgress) printf("\n");
+    return ret;
+}
+
+HRESULT Assembler::CreateDeltaFiles(__in __nullterminated WCHAR *pwzOutputFilename)
+{
+    HRESULT             hr;
+    DWORD               mresourceSize = 0;
+    BYTE*               mresourceData = NULL;
+    WCHAR*              pEnd = NULL;
+
+    if(m_fReportProgress) printf("Creating DMETA,DIL files\n");
+    if (!m_pEmitter)
+    {
+        printf("Error: Cannot create a PE file with no metadata\n");
+        return E_FAIL;
+    }
+REPT_STEP
+    if(m_pManifest)
+    {
+        hr = S_OK;
+        if(m_pManifest->m_pAsmEmitter==NULL)
+            hr=m_pEmitter->QueryInterface(IID_IMetaDataAssemblyEmit, (void**) &(m_pManifest->m_pAsmEmitter));
+
+        if(SUCCEEDED(hr))
+        {
+            m_pManifest->EmitAssemblyRefs();
+        }
+    }
+    // Emit classes, class members and globals:
+    {
+        Class *pSearch;
+        int i;
+        BOOL    bIsUndefClass = FALSE;
+        if(m_fReportProgress)   printf("\nEmitting classes:\n");
+        for (i=1; (pSearch = m_lstClass.PEEK(i)); i++)   // 0 is <Module>
+        {
+            if(pSearch->m_fNew)
+            {
+                if(m_fReportProgress)
+                    printf("Class %d:\t%s\n",i,pSearch->m_szFQN);
+                
+                if(pSearch->m_bIsMaster)
+                {
+                    report->msg("Error: Reference to undefined class '%s'\n",pSearch->m_szFQN);
+                    bIsUndefClass = TRUE;
+                }
+                if(!EmitClass(pSearch))
+                {
+                    if(!OnErrGo) return E_FAIL;
+                }
+                pSearch->m_fNew = FALSE;
+            }
+        }
+        if(bIsUndefClass && !OnErrGo) return E_FAIL;
+        
+        if(m_fReportProgress)   printf("\nEmitting fields and methods:\n");
+        for (i=0; (pSearch = m_lstClass.PEEK(i)) != NULL; i++)
+        {
+            if(pSearch->m_fNewMembers)
+            {
+                if(m_fReportProgress)
+                {
+                    if(i == 0)  printf("Global \t");
+                    else        printf("Class %d\t",i);
+                }
+                if(!EmitFieldsMethodsENC(pSearch))
+                {
+                    if(!OnErrGo) return E_FAIL;
+                }
+            }
+        }
+    }
+REPT_STEP
+
+    // All ref'ed items def'ed in this file are emitted, resolve member refs to member defs:
+    hr = ResolveLocalMemberRefs();
+    if(FAILED(hr) &&(!OnErrGo)) goto exit;
+
+    // Local member refs resolved, emit events, props and method impls
+    {
+        Class *pSearch;
+        int i;
+    
+        if(m_fReportProgress)   printf("\nEmitting events and properties:\n");
+        for (i=0; (pSearch = m_lstClass.PEEK(i)); i++)
+        {
+            if(pSearch->m_fNewMembers)
+            {
+                if(m_fReportProgress)
+                {
+                    if(i == 0)  printf("Global \t");
+                    else        printf("Class %d\t",i);
+                }
+                if(!EmitEventsPropsENC(pSearch))
+                {
+                    if(!OnErrGo) return E_FAIL;
+                }
+                pSearch->m_fNewMembers = FALSE;
+            }
+        }
+    }
+    if(m_MethodImplDList.COUNT())
+    {
+        if(m_fReportProgress) report->msg("Method Implementations (total): %d\n",m_MethodImplDList.COUNT());
+        if(!EmitMethodImpls())
+        {
+            if(!OnErrGo) return E_FAIL;
+        }
+    }
+REPT_STEP
+    // Emit the rest of the metadata
+    hr = S_OK;
+    if(m_pManifest) 
+    {
+        if (FAILED(hr = m_pManifest->EmitManifest())) goto exit;
+    }
+    ResolveLocalMemberRefs(); // in case CAs added some
+    EmitUnresolvedCustomAttributes();
+REPT_STEP
+
+    hr = DoLocalMemberRefFixups();
+    if(FAILED(hr) &&(!OnErrGo)) goto exit;
+
+    // Local member refs resolved and fixed up in BinStr method bodies. Emit the bodies to a separate file.
+    pEnd = &pwzOutputFilename[wcslen(pwzOutputFilename)];
+    {
+        Class* pClass;
+        Method* pMethod;
+        FILE* pF = NULL;
+        wcscat_s(pwzOutputFilename,MAX_SCOPE_LENGTH,L".dil");
+        if(_wfopen_s(&pF,pwzOutputFilename,L"wb")==0)
+        {
+            int i,j,L=0,M=0;
+            BinStr bsOut;
+            for (i=0; (pClass = m_lstClass.PEEK(i)); i++)
+            {
+                for(j=0; (pMethod = pClass->m_MethodList.PEEK(j)); j++)
+                {
+                    if(pMethod->m_fNewBody)
+                    {
+                        L+= pMethod->m_pbsBody->length()+3;
+                        M++;
+                    }
+                }
+            }
+            bsOut.getBuff(L+sizeof(DWORD)); // to avoid reallocs
+            bsOut.remove(L);
+            for (i=0; (pClass = m_lstClass.PEEK(i)); i++)
+            {
+                for(j=0; (pMethod = pClass->m_MethodList.PEEK(j)); j++)
+                {
+                    if(pMethod->m_fNewBody)
+                    {
+                        if(!EmitMethodBody(pMethod,&bsOut))
+                        {
+                            report->msg("Error: failed to emit body of '%s'\n",pMethod->m_szName);
+                            hr = E_FAIL;
+                            if(!OnErrGo)
+                            { 
+                                fclose(pF);
+                                *pEnd = 0;
+                                goto exit;
+                            }
+                        }
+                        pMethod->m_fNewBody = FALSE;
+                    }
+                }
+            }
+            *((DWORD*)(bsOut.ptr())) = bsOut.length() - sizeof(DWORD);
+            fwrite(bsOut.ptr(),bsOut.length(),1,pF);
+            fclose(pF);
+        }
+        else
+            report->msg("Error: failed to open file '%S'\n",pwzOutputFilename);
+
+        *pEnd = 0;
+    }
+REPT_STEP
+    
+    //if (DoGlobalFixups() == FALSE)
+    //    return E_FAIL;
+    
+    //if (FAILED(hr=m_pCeeFileGen->SetOutputFileName(m_pCeeFile, pwzOutputFilename))) goto exit;
+
+    // Emit the meta-data to a separate file
+    IMetaDataEmit2* pENCEmitter;
+    if(FAILED(hr = m_pEmitter->QueryInterface(IID_IMetaDataEmit2, (void**)&pENCEmitter)))
+        goto exit;
+
+    DWORD metaDataSize; 
+    if (FAILED(hr=pENCEmitter->GetDeltaSaveSize(cssAccurate, &metaDataSize))) goto exit;
+
+    wcscat_s(pwzOutputFilename,MAX_SCOPE_LENGTH,L".dmeta");
+    pENCEmitter->SaveDelta(pwzOutputFilename,0); // second arg (dwFlags) is not used
+    *pEnd = 0;
+    pENCEmitter->Release();
+
+    // apply delta to create basis for the next ENC iteration
+    if(m_pbsMD)
+    {
+        IMetaDataEmit2* pBaseMDEmit = NULL;
+        if(FAILED(hr = m_pDisp->OpenScopeOnMemory(m_pbsMD->ptr(),
+                                                  m_pbsMD->length(),
+                                                  ofWrite,
+                                                  IID_IMetaDataEmit2,
+                                    (IUnknown **)&pBaseMDEmit))) goto exit;
+    
+        if(FAILED(hr = pBaseMDEmit->ApplyEditAndContinue((IUnknown*)m_pImporter))) goto exit;
+        delete m_pbsMD;
+        if((m_pbsMD = new BinStr()) != NULL)
+        {
+            DWORD cb;
+            hr = pBaseMDEmit->GetSaveSize(cssAccurate,&cb);
+            BYTE* pb = m_pbsMD->getBuff(cb);
+            hr = pBaseMDEmit->SaveToMemory(pb,cb);
+        }
+        pBaseMDEmit->Release();
+    }
+
+#if(0)
+//===================================================================================
+    // release SymWriter interfaces
+    if (m_pSymWriter != NULL)
+    {
+        m_pSymWriter->Close();
+        m_pSymWriter->Release();
+        m_pSymWriter = NULL;
+    }
+
+    hr = CoCreateInstance(CLSID_CorSymWriter_SxS,
+                           NULL,
+                           CLSCTX_INPROC_SERVER,
+                           IID_ISymUnmanagedWriter,
+                           (void **)&m_pSymWriter);
+    if(SUCCEEDED(hr))
+    {
+        WCHAR* pwc = &pwzOutputFilename[wcslen(pwzOutputFilename)];
+        wcscat(pwzOutputFilename,L".pdb");
+        if(m_pSymWriter) m_pSymWriter->Initialize((IUnknown*)m_pEmitter,
+                                                  pwzOutputFilename,
+                                                  NULL,
+                                                  TRUE);
+        *pwc = 0;
+    }
+    else 
+    {
+        fprintf(stderr, "Error: CoCreateInstance(IID_ISymUnmanagedWriter) returns %X\n",hr);
+        m_pSymWriter = NULL;
+    }
+    
+    m_fENCMode = FALSE;
+    if(FAILED(hr=CreatePEFile(pwzOutputFilename))) 
+        report->msg("Could not create output file, error code=0x%08X\n",hr);
+    m_fENCMode = TRUE;
+//=====================================================================================    
+#endif
+
+    // release all interfaces
+    if (m_pSymWriter != NULL)
+    {
+        m_pSymWriter->Close();
+        m_pSymWriter->Release();
+        m_pSymWriter = NULL;
+    }
+    if (m_pImporter != NULL)
+    {
+        m_pImporter->Release();
+        m_pImporter = NULL;
+    }
+    if (m_pEmitter != NULL)
+    {
+        m_pEmitter->Release();
+        m_pEmitter = NULL;
+    }
+
+    return S_OK;
+
+REPT_STEP
+    
+    // set managed resource entry, if any
+    if(m_pManifest && m_pManifest->m_dwMResSizeTotal)
+    {
+        mresourceSize = m_pManifest->m_dwMResSizeTotal;
+
+        if (FAILED(hr=m_pCeeFileGen->GetSectionBlock(m_pILSection, mresourceSize, 
+                                            sizeof(DWORD), (void**) &mresourceData))) goto exit; 
+        if (FAILED(hr=m_pCeeFileGen->SetManifestEntry(m_pCeeFile, mresourceSize, 0))) goto exit;
+    }
+REPT_STEP
+    /*
+    if (m_fWindowsCE)
+    {
+        if (FAILED(hr=m_pCeeFileGen->SetSubsystem(m_pCeeFile, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI, 2, 10))) goto exit;
+
+        if (FAILED(hr=m_pCeeFileGen->SetImageBase(m_pCeeFile, 0x10000))) goto exit;
+    }
+    else if(m_dwSubsystem != (DWORD)-1)
+    {
+        if (FAILED(hr=m_pCeeFileGen->SetSubsystem(m_pCeeFile, m_dwSubsystem, 4, 0))) goto exit;
+    }
+    
+    if (FAILED(hr=m_pCeeFileGen->ClearComImageFlags(m_pCeeFile, COMIMAGE_FLAGS_ILONLY))) goto exit;
+    if (FAILED(hr=m_pCeeFileGen->SetComImageFlags(m_pCeeFile, m_dwComImageFlags & ~COMIMAGE_FLAGS_STRONGNAMESIGNED))) goto exit;
+
+    if(m_dwFileAlignment)
+    {
+        if(FAILED(hr=m_pCeeFileGen->SetFileAlignment(m_pCeeFile, m_dwFileAlignment))) goto exit;
+    }
+    if(m_stBaseAddress)
+    {
+        if(FAILED(hr=m_pCeeFileGen->SetImageBase(m_pCeeFile, m_stBaseAddress))) goto exit;
+    }
+    */
+REPT_STEP
+        //Compute all the RVAs
+    if (FAILED(hr=m_pCeeFileGen->LinkCeeFile(m_pCeeFile))) goto exit;
+
+REPT_STEP
+        // Fix up any fields that have RVA associated with them
+/*
+    if (m_fHaveFieldsWithRvas) {
+        hr = S_OK;
+        ULONG dataSectionRVA;
+        if (FAILED(hr=m_pCeeFileGen->GetSectionRVA(m_pGlobalDataSection, &dataSectionRVA))) goto exit;
+        
+        ULONG tlsSectionRVA;
+        if (FAILED(hr=m_pCeeFileGen->GetSectionRVA(m_pTLSSection, &tlsSectionRVA))) goto exit;
+
+        FieldDescriptor* pListFD;
+        Class* pClass;
+        for(int i=0; (pClass = m_lstClass.PEEK(i)); i++)
+        {
+            for(int j=0; (pListFD = pClass->m_FieldDList.PEEK(j)); j++)
+            {
+                if (pListFD->m_rvaLabel != 0) 
+                {
+                    DWORD rva;
+                    if(*(pListFD->m_rvaLabel)=='@')
+                    {
+                        rva = (DWORD)atoi(pListFD->m_rvaLabel + 1);
+                    }
+                    else
+                    {
+                        GlobalLabel *pLabel = FindGlobalLabel(pListFD->m_rvaLabel);
+                        if (pLabel == 0)
+                        {
+                            report->msg("Error:Could not find label '%s' for the field '%s'\n", pListFD->m_rvaLabel, pListFD->m_szName);
+                            hr = E_FAIL;
+                            continue;
+                        }
+                    
+                        rva = pLabel->m_GlobalOffset;
+                        if (pLabel->m_Section == m_pTLSSection)
+                            rva += tlsSectionRVA;
+                        else {
+                            _ASSERTE(pLabel->m_Section == m_pGlobalDataSection);
+                            rva += dataSectionRVA;
+                        }
+                    }
+                    if (FAILED(m_pEmitter->SetFieldRVA(pListFD->m_fdFieldTok, rva))) goto exit;
+                }
+            }
+        }
+        if (FAILED(hr)) goto exit;
+    }
+REPT_STEP
+*/
+
+REPT_STEP
+    // actually output the resources
+    if(mresourceSize && mresourceData)
+    {
+        size_t i, N = m_pManifest->m_dwMResNum, sizeread, L;
+        BYTE    *ptr = (BYTE*)mresourceData;
+        BOOL    mrfail = FALSE;
+        FILE*   pFile = NULL;
+        char sz[2048];
+        for(i=0; i < N; i++)
+        {
+            if(!m_pManifest->m_fMResNew[i]) continue;
+            m_pManifest->m_fMResNew[i] = FALSE;
+            memset(sz,0,2048);
+            WszWideCharToMultiByte(CP_ACP,0,m_pManifest->m_wzMResName[i],-1,sz,2047,NULL,NULL);
+            L = m_pManifest->m_dwMResSize[i];
+            sizeread = 0;
+            memcpy(ptr,&L,sizeof(DWORD));
+            ptr += sizeof(DWORD);
+            pFile = NULL;
+            if(fopen_s(&pFile,sz,"rb")==0)
+            {
+                sizeread = fread((void *)ptr,1,L,pFile);
+                fclose(pFile);
+                ptr += sizeread;
+            }
+            else
+            {
+                report->msg("Error: failed to open mgd resource file '%ls'\n",m_pManifest->m_wzMResName[i]);
+                mrfail = TRUE;
+            }
+            if(sizeread < L)
+            {
+                report->msg("Error: failed to read expected %d bytes from mgd resource file '%ls'\n",L,m_pManifest->m_wzMResName[i]);
+                mrfail = TRUE;
+                L -= sizeread;
+                memset(ptr,0,L);
+                ptr += L;
+            }
+        }
+        if(mrfail) 
+        { 
+            hr = E_FAIL;
+            goto exit;
+        }
+    }
+REPT_STEP
+
+    // Generate the file -- moved to main
+    //if (FAILED(hr=m_pCeeFileGen->GenerateCeeFile(m_pCeeFile))) goto exit;
+
+
+    hr = S_OK;
+
+exit:
+    return hr;
+}