modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/Windows/mkasm/mkasm.cpp

1265 lines
38 KiB
C++
Raw Normal View History

RDK 1.1
2008-03-05 09:52:00 -05:00
//////////////////////////////////////////////////////////////////////////////
//
// Microsoft Research
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// File: mkasm.cpp
//
// Contents: Converts binary files into .asm or .cs files.
//
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <winlean.h>
#include <assert.h>
//////////////////////////////////////////////////////////////////////////////
//
enum {
TARGET_BASE = 0x60000,
TARGET_RANGE = 0x10000,
};
BOOL fAsm = TRUE;
BOOL fCpp = FALSE;
BOOL fManaged = FALSE;
BOOL fCompress = FALSE;
BOOL fList = FALSE;
BOOL fAllow64 = FALSE;
CHAR szByteByteVTable[] = "?_vtable@ClassVector_ClassVector_uint8@@2UClass_System_VTable@@A";
// struct Class_System_VTable ClassVector_ClassVector_uint8::_vtable
CHAR szByteByteSuffix[] = "@@2PAUClassVector_ClassVector_uint8@@A";
// ?c_Content@Class_Microsoft_Singularity_Shell_Slides@@2PAUClassVector_ClassVector_uint8@@A
// struct ClassVector_ClassVector_uint8 * Class_Microsoft_Singularity_Shell_Slides::c_Content
CHAR szByteVTable[] = "?_vtable@ClassVector_uint8@@2UClass_System_VTable@@A";
// struct Class_System_VTable ClassVector_uint8::_vtable
CHAR szByteSuffix[] = "@@2PAUClassVector_uint8@@A";
// ?c_Content@Class_Microsoft_Singularity_Shell_Slides@@2PAUClassVector_ClassVector_uint8@@A
// struct ClassVector_ClassVector_uint8 * Class_Microsoft_Singularity_Shell_Slides::c_Content
//////////////////////////////////////////////////////////////////////////////
class CFileInfo
{
public:
CFileInfo()
{
m_pszFile = NULL;
m_pNext = NULL;
m_cbInput = 0;
m_cbOutput = 0;
}
BOOL SetFileName(PCSTR pszFile)
{
m_pszFile = pszFile;
return TRUE;
}
BOOL SetFileAndSize()
{
HANDLE hFile = CreateFile(m_pszFile,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
0,
NULL);
if (hFile == INVALID_HANDLE_VALUE) {
return FALSE;
}
m_cbInput = GetFileSize(hFile, NULL);
CloseHandle(hFile);
if (m_cbInput == 0xffffffff) {
m_cbInput = 0;
return FALSE;
}
m_cbOutput = m_cbInput;
return TRUE;
}
BOOL SetOutputSize(UINT32 cbOutput)
{
m_cbOutput = cbOutput;
return TRUE;
}
CFileInfo * m_pNext;
PCSTR m_pszFile;
UINT32 m_cbInput;
UINT32 m_cbOutput;
};
//////////////////////////////////////////////////////////////////// CFileMap.
//
class CFileMap
{
public:
CFileMap();
~CFileMap();
public:
BOOL Load(PCSTR pszFile);
PBYTE Seek(UINT32 cbPos);
UINT32 Size();
VOID Close();
protected:
PBYTE m_pbData;
UINT32 m_cbData;
};
CFileMap::CFileMap()
{
m_pbData = NULL;
m_cbData = 0;
}
CFileMap::~CFileMap()
{
Close();
}
VOID CFileMap::Close()
{
if (m_pbData) {
UnmapViewOfFile(m_pbData);
m_pbData = NULL;
}
m_cbData = 0;
}
UINT32 CFileMap::Size()
{
return m_cbData;
}
PBYTE CFileMap::Seek(UINT32 cbPos)
{
if (m_pbData && cbPos <= m_cbData) {
return m_pbData + cbPos;
}
return NULL;
}
BOOL CFileMap::Load(PCSTR pszFile)
{
Close();
HANDLE hFile = CreateFile(pszFile,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
0,
NULL);
if (hFile == INVALID_HANDLE_VALUE) {
return FALSE;
}
ULONG cbInFileData = GetFileSize(hFile, NULL);
if (cbInFileData == 0xffffffff) {
CloseHandle(hFile);
return FALSE;
}
HANDLE hInFileMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
CloseHandle(hFile);
if (hInFileMap == NULL) {
return FALSE;
}
m_pbData = (PBYTE)MapViewOfFile(hInFileMap, FILE_MAP_COPY, 0, 0, 0);
CloseHandle(hInFileMap);
if (m_pbData == NULL) {
return FALSE;
}
m_cbData = cbInFileData;
return TRUE;
}
//////////////////////////////////////////////////////////////////// CFileOut.
//
class CFileOut
{
public:
CFileOut();
~CFileOut();
public:
BOOL Create(PCSTR pszFile);
BOOL IsOpen();
BOOL Write(PBYTE pbData, UINT32 cbData);
BOOL Print(PCSTR pszMsg, ...);
BOOL VPrint(PCSTR pszMsg, va_list args);
BOOL Delete();
VOID Close();
protected:
HANDLE m_hFile;
CHAR m_szFile[MAX_PATH];
CHAR m_szBuffer[4096];
INT m_cbBuffer;
};
CFileOut::CFileOut()
{
m_hFile = INVALID_HANDLE_VALUE;
m_szFile[0] = '\0';
m_cbBuffer = 0;
}
CFileOut::~CFileOut()
{
Close();
}
VOID CFileOut::Close()
{
if (m_hFile != INVALID_HANDLE_VALUE) {
if (m_cbBuffer) {
Write((PBYTE)m_szBuffer, m_cbBuffer);
m_cbBuffer = 0;
}
CloseHandle(m_hFile);
m_hFile = INVALID_HANDLE_VALUE;
}
}
BOOL CFileOut::IsOpen()
{
return (m_hFile != INVALID_HANDLE_VALUE);
}
BOOL CFileOut::Write(PBYTE pbData, UINT32 cbData)
{
if (m_hFile == INVALID_HANDLE_VALUE) {
return FALSE;
}
DWORD dwWrote = 0;
if (!WriteFile(m_hFile, pbData, cbData, &dwWrote, NULL) || dwWrote != cbData) {
return FALSE;
}
return TRUE;
}
BOOL CFileOut::VPrint(PCSTR pszMsg, va_list args)
{
if (m_hFile == INVALID_HANDLE_VALUE) {
return FALSE;
}
INT cbUsed = m_cbBuffer;
INT cbData;
cbData = _vsnprintf(m_szBuffer + cbUsed, sizeof(m_szBuffer)-cbUsed-1, pszMsg, args);
m_cbBuffer += cbData;
if (m_szBuffer[m_cbBuffer - 1] == '\n' ||
m_szBuffer[m_cbBuffer - 1] == '\r') {
cbData = m_cbBuffer;
m_cbBuffer = 0;
return Write((PBYTE)m_szBuffer, cbData);
}
return TRUE;
}
BOOL CFileOut::Print(PCSTR pszMsg, ...)
{
BOOL f;
va_list args;
va_start(args, pszMsg);
f = VPrint(pszMsg, args);
va_end(args);
return f;
}
BOOL CFileOut::Delete()
{
if (m_hFile != INVALID_HANDLE_VALUE) {
Close();
return DeleteFile(m_szFile);
}
return FALSE;
}
BOOL CFileOut::Create(PCSTR pszFile)
{
Close();
m_szFile[0] = '\0';
m_hFile = CreateFile(pszFile,
GENERIC_WRITE,
0, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (m_hFile == INVALID_HANDLE_VALUE) {
return FALSE;
}
strcpy(m_szFile, pszFile);
m_cbBuffer = 0;
return TRUE;
}
//
//////////////////////////////////////////////////////////////////////////////
class COutput
{
protected:
UINT m_nOffset;
CFileOut *m_pfOutput;
public:
COutput(CFileOut *pfOutput)
{
m_pfOutput = pfOutput;
m_nOffset = 0;
}
BOOL VPrint(PCSTR pszMsg, va_list args)
{
return m_pfOutput->VPrint(pszMsg, args);
}
BOOL Print(PCSTR pszMsg, ...)
{
BOOL f;
va_list args;
va_start(args, pszMsg);
f = m_pfOutput->VPrint(pszMsg, args);
va_end(args);
return f;
}
virtual void Dump(PBYTE pbData, UINT cbData) = 0;
virtual void Finish()
{
if ((m_nOffset % 16) != 0) {
m_pfOutput->Print("\n");
}
m_nOffset = 0;
}
UINT Size()
{
return m_nOffset;
}
};
class CAsmOutput : public COutput
{
public:
CAsmOutput(CFileOut *pfOutput)
: COutput(pfOutput)
{
}
void Dump(PBYTE pbData, UINT cbData)
{
PBYTE pbEnd = pbData + cbData;
for (; pbData < pbEnd; pbData++, m_nOffset++) {
switch (m_nOffset % 16) {
case 0:
Print(" uint8 %03xh", *pbData);
break;
default:
Print(",%03xh", *pbData);
break;
case 15:
Print(",%03xh\n", *pbData);
break;
}
}
}
};
class CSharpOutput : public COutput
{
public:
CSharpOutput(CFileOut *pfOutput)
: COutput(pfOutput)
{
}
void Dump(PBYTE pbData, UINT cbData)
{
PBYTE pbEnd = pbData + cbData;
for (; pbData < pbEnd; pbData++, m_nOffset++) {
switch (m_nOffset % 16) {
case 0:
Print(" 0x%02x,", *pbData);
break;
default:
Print("0x%02x,", *pbData);
break;
case 15:
Print("0x%02x,\n", *pbData);
break;
}
}
}
};
//////////////////////////////////////////////////////////////////////////////
//
UINT DumpBmp(COutput *output, PBYTE pbData, UINT cbData)
{
#pragma pack(2)
struct BITMAPFILEHEADER {
UINT16 bfType;
UINT32 bfSize;
UINT16 bfReserved1;
UINT16 bfReserved2;
UINT32 bfOffBits;
};
struct BITMAPINFOHEADER {
UINT32 biSize;
UINT32 biWidth;
UINT32 biHeight;
UINT16 biPlanes;
UINT16 biBitCount;
UINT32 biCompression;
UINT32 biSizeImage;
UINT32 biXPelsPerMeter;
UINT32 biYPelsPerMeter;
UINT32 biClrUsed;
UINT32 biClrImportant;
};
#pragma pack()
BITMAPFILEHEADER *pbmf = (BITMAPFILEHEADER *)pbData;
BITMAPINFOHEADER *pbmi = (BITMAPINFOHEADER *)(pbmf + 1);
if (pbmf->bfType != 'MB') {
fprintf(stderr, "Can't convert non-BMP files to BMP compression.\n");
return 0;
}
UINT cbDumped = 0;
INT16 nValue;
UINT cbScanLine = (((pbmi->biWidth * pbmi->biBitCount) + 31) & ~31) / 8;
PBYTE pbLine = pbData + pbmf->bfOffBits;
//PBYTE pbOut = pbData + pbmf->bfOffBits;
pbmi->biCompression |= 0xff000000;
if (output != NULL) {
output->Dump(pbData, pbmf->bfOffBits);
}
cbDumped += pbmf->bfOffBits;
for (UINT i = 0; i < pbmi->biHeight; i++) {
PBYTE pbIn = pbLine;
PBYTE pbRaw = pbIn;
PBYTE pbEnd = pbLine + cbScanLine;
while (pbIn < pbEnd) {
if (pbIn + 6 < pbEnd &&
pbIn[3] == pbIn[0] &&
pbIn[4] == pbIn[1] &&
pbIn[5] == pbIn[2]) {
PBYTE pbBase = pbIn;
pbIn += 3;
while (pbIn + 3 <= pbEnd &&
pbIn[0] == pbBase[0] &&
pbIn[1] == pbBase[1] &&
pbIn[2] == pbBase[2]) {
pbIn += 3;
}
if (pbBase > pbRaw) {
nValue = (INT16)(pbBase - pbRaw);
if (output != NULL) {
output->Dump((PBYTE)&nValue, sizeof(nValue));
output->Dump(pbRaw, pbBase - pbRaw);
}
cbDumped += sizeof(nValue);
cbDumped += pbBase - pbRaw;
}
nValue = (INT16)(-((pbIn - pbBase) / 3));
if (output != NULL) {
output->Dump((PBYTE)&nValue, sizeof(nValue));
output->Dump(pbBase, 3);
}
cbDumped += sizeof(nValue);
cbDumped += 3;
pbRaw = pbIn;
}
else {
pbIn++;
}
}
if (pbEnd > pbRaw) {
nValue = (INT16)(pbEnd - pbRaw);
if (output != NULL) {
output->Dump((PBYTE)&nValue, sizeof(nValue));
output->Dump(pbRaw, pbEnd - pbRaw);
}
cbDumped += sizeof(nValue);
cbDumped += pbEnd - pbRaw;
}
pbLine += cbScanLine;
}
if (output != NULL) {
printf(" From %8d to %8d bytes\n", cbData, cbDumped);
if (output->Size() != cbDumped) {
fprintf(stderr, "Failure in compression: %d reported, %d written\n",
cbDumped, output->Size());
}
output->Finish();
}
return cbDumped;
}
char *find_contents64(CFileMap *pfFile,
PIMAGE_NT_HEADERS64 ppe,
UINT32 *pcbEntry,
UINT32 *pcbBase,
UINT32 *pcbSize,
PBYTE *ppbData)
{
PIMAGE_SECTION_HEADER psec;
fprintf(stderr,"Processing a 64-bit image.\n");
psec = IMAGE_FIRST_SECTION(ppe);
if (ppe->FileHeader.NumberOfSections != 1) {
fprintf(stderr, "Warning: More than one section (.pdata)\n");
}
if (ppe->OptionalHeader.SizeOfInitializedData != 0) {
fprintf(stderr, "Image has initialized data outside of text section.\n");
}
if (ppe->OptionalHeader.SizeOfUninitializedData != 0) {
return "Image has uninitialized data outside of text section.";
}
if (psec->PointerToRawData == 0) {
return "Image has no text content.";
}
if (pfFile->Seek(psec->PointerToRawData) == NULL) {
return "Image text section is invalid.";
}
*pcbEntry =(UINT32) ppe->OptionalHeader.ImageBase + ppe->OptionalHeader.AddressOfEntryPoint;
*pcbBase = (UINT32) ppe->OptionalHeader.ImageBase;
*pcbSize = ppe->OptionalHeader.SizeOfImage;
*ppbData = pfFile->Seek(0);
return NULL;
}
char *find_contents32(CFileMap *pfFile,
PIMAGE_NT_HEADERS ppe,
UINT32 *pcbEntry,
UINT32 *pcbBase,
UINT32 *pcbSize,
PBYTE *ppbData)
{
PIMAGE_SECTION_HEADER psec;
psec = IMAGE_FIRST_SECTION(ppe);
if (ppe->FileHeader.NumberOfSections != 1) {
return "Image has more than one sections.";
}
if (ppe->OptionalHeader.SizeOfInitializedData != 0) {
return "Image has initialized data outside of text section.";
}
if (ppe->OptionalHeader.SizeOfUninitializedData != 0) {
return "Image has uninitialized data outside of text section.";
}
if (psec->PointerToRawData == 0) {
return "Image has no text content.";
}
if (pfFile->Seek(psec->PointerToRawData) == NULL) {
return "Image text section is invalid.";
}
*pcbEntry = ppe->OptionalHeader.ImageBase + ppe->OptionalHeader.AddressOfEntryPoint;
*pcbBase = ppe->OptionalHeader.ImageBase;
*pcbSize = ppe->OptionalHeader.SizeOfImage;
*ppbData = pfFile->Seek(0);
return NULL;
}
char *find_contents(CFileMap *pfFile,
UINT32 *pcbEntry,
UINT32 *pcbBase,
UINT32 *pcbSize,
PBYTE *ppbData)
{
PIMAGE_DOS_HEADER pdos;
PIMAGE_NT_HEADERS ppe;
//PIMAGE_NT_HEADERS64 ppe64;
*pcbEntry = 0;
*pcbBase = 0;
*pcbSize = 0;
*ppbData = NULL;
// Read in the PE image header
//
pdos = (PIMAGE_DOS_HEADER)pfFile->Seek(0);
if (pdos == NULL || pdos->e_magic != IMAGE_DOS_SIGNATURE) {
return "Image doesn't have MZ signature.";
}
ppe = (PIMAGE_NT_HEADERS)pfFile->Seek(pdos->e_lfanew);
if (ppe == NULL || ppe->Signature != IMAGE_NT_SIGNATURE) {
return "Image doesn't have PE signature.";
}
if (ppe->FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64) {
if (fAllow64) {
return find_contents64(pfFile, (PIMAGE_NT_HEADERS64) ppe, pcbEntry, pcbBase, pcbSize, ppbData);
}
else {
return "Image is 64-bit. Use /64 option";
}
}
else return find_contents32(pfFile, ppe, pcbEntry, pcbBase, pcbSize, ppbData);
}
BOOL dump_pe(COutput *pOutput, CFileMap *pInput, PCSTR pszRoot)
{
UINT32 cbEntry = 0;
UINT32 cbBase = 0;
UINT32 cbSize = 0;
PBYTE pbData = NULL;
char *error = find_contents(pInput, &cbEntry, &cbBase, &cbSize, &pbData);
if (error != NULL) {
fprintf(stderr, "Failed: %s\n", error);
return FALSE;
}
if (cbEntry < cbBase || cbEntry >= cbBase + cbSize) {
fprintf(stderr, "Failed: Image entry point is not in text section.");
return FALSE;
}
if (cbBase < TARGET_BASE || cbBase > TARGET_BASE + TARGET_RANGE) {
fprintf(stderr, "Failed: Image is not based at 0x%x.\n", TARGET_BASE);
return FALSE;
}
printf("Total text section: %d bytes\n", cbSize);
// Write .asm data.
//
pOutput->Print("%s_ent EQU 0%08xh\n", pszRoot, cbEntry);
pOutput->Print("%s_dst EQU 0%08xh\n", pszRoot, cbBase);
pOutput->Print("%s_siz EQU 0%08xh\n", pszRoot, cbSize);
pOutput->Print("%s_dat ", pszRoot);
pOutput->Dump(pbData, cbSize);
pOutput->Finish();
pOutput->Print("\n");
return TRUE;
}
BOOL blob_to_asm(COutput *pOutput, CFileMap *pInput)
{
// Copy the rest of the image.
//
pOutput->Dump(pInput->Seek(0), pInput->Size());
pOutput->Finish();
return TRUE;
}
int CompareName(PCSTR psz1, PCSTR psz2)
{
for (;;) {
CHAR c1 = *psz1;
CHAR c2 = *psz2;
if (c1 >= 'A' && c1 <= 'Z') {
c1 = c1 - 'A' + 'a';
}
if (c2 >= 'A' && c2 <= 'Z') {
c2 = c2 - 'A' + 'a';
}
if ((c1 >= '0' && c1 <= '9') && (c2 >= '0' && c2 <= '9')) {
for (c1 = 0; *psz1 >= '0' && *psz1 <= '9'; psz1++) {
c1 = c1 * 10 + (*psz1 - '0');
}
psz1--;
for (c2 = 0; *psz2 >= '0' && *psz2 <= '9'; psz2++) {
c2 = c2 * 10 + (*psz2 - '0');
}
psz2--;
}
if (c1 != c2) {
return c1 - c2;
}
if (c1 == 0 && c2 == 0) {
return 0;
}
psz1++;
psz2++;
}
}
PCHAR AppendToName(PCHAR pszDst, PCSTR pszSrc)
{
while (*pszSrc) {
if (*pszSrc == '.') {
*pszDst++ = '_';
pszSrc++;
}
else {
*pszDst++ = *pszSrc++;
}
}
return pszDst;
}
void AsmName(PCHAR pszAsmName, PCSTR pszNamespace, PCSTR pszClass, PCSTR pszField)
{
pszAsmName = AppendToName(pszAsmName, "?c_");
pszAsmName = AppendToName(pszAsmName, pszField);
pszAsmName = AppendToName(pszAsmName, "@Class_");
pszAsmName = AppendToName(pszAsmName, pszNamespace);
pszAsmName = AppendToName(pszAsmName, "_");
pszAsmName = AppendToName(pszAsmName, pszClass);
*pszAsmName = '\0';
}
void CppClassName(PCHAR pszCppClassName, PCSTR pszNamespace, PCSTR pszClass)
{
pszCppClassName = AppendToName(pszCppClassName, "Class_");
pszCppClassName = AppendToName(pszCppClassName, pszNamespace);
pszCppClassName = AppendToName(pszCppClassName, "_");
pszCppClassName = AppendToName(pszCppClassName, pszClass);
*pszCppClassName = '\0';
}
int __cdecl main(int argc, char **argv)
{
BOOL fNeedHelp = FALSE;
BOOL fFlattenPE = TRUE;
PCSTR pszRoot = "asm";
CFileOut cfOutput;
CFileInfo rFiles[512];
CFileInfo *pFiles = NULL;
UINT cFiles = 0;
CHAR szField[256] = "";
CHAR szClass[512] = "";
CHAR szNamespace[512] = "";
CHAR szAsmName[1024];
CHAR szCppClassName[1024];
for (int arg = 1; arg < argc; arg++) {
if (argv[arg][0] == '-' || argv[arg][0] == '/') {
char *argn = argv[arg]+1; // Argument name
char *argp = argn; // Argument parameter
while (*argp && *argp != ':')
argp++;
if (*argp == ':')
*argp++ = '\0';
switch (argn[0]) {
case 'a': // ASM Format
case 'A':
fAsm = TRUE;
break;
case 'b': // Binary Blob
case 'B':
fFlattenPE = FALSE;
fManaged = TRUE;
break;
case 'c': // C# Class
case 'C':
strcpy(szClass, argp);
fManaged = TRUE;
break;
case 'f': // C# Field
case 'F':
strcpy(szField, argp);
fManaged = TRUE;
break;
case 'l': // List of files
case 'L':
fManaged = TRUE;
fList = TRUE;
break;
case 'm': // C# Format
case 'M':
fAsm = FALSE;
break;
case 'n': // C# Namespace
case 'N':
strcpy(szNamespace, argp);
fManaged = TRUE;
break;
case 'o': // Output file.
case 'O':
if (!cfOutput.Create(argp)) {
fprintf(stderr, "Could not open output file: %s\n", argp);
}
break;
case 'p': // Cpp Format
case 'P':
fCpp = TRUE;
fAsm = FALSE;
break;
case 'r': // Set Label Root
case 'R':
pszRoot = argp;
break;
case 'x': // Compress BMP
case 'X': //
fCompress = TRUE;
fManaged = TRUE;
break;
case '6': // 64-bit PE
fAllow64 = TRUE;
break;
case 'h': // Help
case 'H':
case '?':
fNeedHelp = TRUE;
break;
default:
printf("Unknown argument: %s\n", argv[arg]);
fNeedHelp = TRUE;
break;
}
}
else {
// Save the input files away in sorted linked list.
CFileInfo *pNew = &rFiles[cFiles++];
CFileInfo **ppHead = &pFiles;
pNew->SetFileName(argv[arg]);
while (*ppHead != NULL && CompareName(pNew->m_pszFile, (*ppHead)->m_pszFile) > 0) {
ppHead = &(*ppHead)->m_pNext;
}
pNew->m_pNext = *ppHead;
*ppHead = pNew;
}
}
if (argc == 1) {
fNeedHelp = TRUE;
}
if (!fNeedHelp && !cfOutput.IsOpen()) {
fprintf(stderr, "No output file specified.\n");
fNeedHelp = TRUE;
}
if (!fNeedHelp && pFiles == NULL) {
fprintf(stderr, "No output file specified.\n");
fNeedHelp = TRUE;
}
if (!fNeedHelp && fManaged &&
(szField[0] == '\0' || szClass[0] == '\0')) {
fprintf(stderr, "No field or class name specified for target.\n");
fNeedHelp = TRUE;
}
if (fNeedHelp) {
printf(
"Usage:\n"
" mkasm /o:output [options] inputs\n"
"Options:\n"
" /o:output -- Specify output file.\n"
" /r:root -- Set root label [defaults to `asm'].\n"
" /b -- Treat file as binary blob (not PE file).\n"
" /a -- Output ASM format (default for PE).\n"
" /m -- Output C# format (default for blob).\n"
" /c:class -- Set C# class.\n"
" /n:namespace -- Set C# namespace.\n"
" /f:field -- Set C# field.\n"
" /x -- Use bizarre compression for BMP files.\n"
" /l -- Output contents in an array (list).\n"
" /64 -- manipulate 64-bit PE files."
" /h or /? -- Display this help screen.\n"
"Summary:\n"
" Copies the contents of the input files into the output file\n"
" in .asm format. Specific conversions exists for PE and BMP files.\n"
);
return 2;
}
//////////////////////////////////////////////////////////////////////////
//
// At this point, we have input file(s), output file, and set of desired
// conversions. Time to process the output.
//
BOOL fAbort = false;
COutput *pOutput = NULL;
CAsmOutput asmOutput(&cfOutput);
CSharpOutput sharpOutput(&cfOutput);
AsmName(szAsmName, szNamespace, szClass, szField);
CppClassName(szCppClassName, szNamespace, szClass);
if (fAsm) {
pOutput = &asmOutput;
}
else {
pOutput = &sharpOutput;
}
ULONG cbFiles = 0;
UINT cFile = 0;
for (CFileInfo *pFile = pFiles; pFile != NULL; pFile = pFile->m_pNext) {
if (!pFile->SetFileAndSize()) {
fprintf(stderr, "Unable to open %s, error = %d\n",
pFile->m_pszFile,
GetLastError());
goto abort;
}
if (fCompress) {
CFileMap cfInput;
printf(".");
if (!cfInput.Load(pFile->m_pszFile)) {
fprintf(stderr, "Could not open input file: %s\n", pFile->m_pszFile);
goto abort;
}
pFile->SetOutputSize(DumpBmp(NULL, cfInput.Seek(0), cfInput.Size()));
cfInput.Close();
}
cFile++;
cbFiles += pFile->m_cbOutput;
}
//public: static struct ClassVector_ClassVector_uint8 *
// Class_Microsoft_Singularity_Shell_Slides::c_Content;
//" (?c_Content@Class_Microsoft_Singularity_Shell_Slides@@2PAUClassVector_ClassVector_uint8@@A
if (!fFlattenPE) {
if (fAsm) {
cfOutput.Print("externdef %s:NEAR\n", szByteVTable);
if (fList) {
cfOutput.Print("externdef %s:NEAR\n", szByteByteVTable);
}
else {
cfOutput.Print("align 4\n");
cfOutput.Print(" BARTOK_OBJECT_HEADER {} \n");
cfOutput.Print("%s%s_0 UINT32 %s\n",
szAsmName, szByteSuffix, szByteVTable);
cfOutput.Print(" UINT32 %d\n", cbFiles);
}
}
else if (fCpp) {
if (fList) {
cFile = 0;
for (CFileInfo *pFile = pFiles; pFile != NULL; pFile = pFile->m_pNext) {
cfOutput.Print("struct Vector_%s_%s_0_%d {\n",
szCppClassName, szField, cFile);
cfOutput.Print(" uintptr headerwords[HDRWORDCOUNT];\n");
cfOutput.Print(" union {\n");
cfOutput.Print(" struct {\n");
cfOutput.Print(" Class_System_VTable * vtable;\n");
cfOutput.Print(" uint32 length;\n");
cfOutput.Print(" uint8 data[%d];\n",
pFile->m_cbOutput);
cfOutput.Print(" };\n");
cfOutput.Print(" ClassVector_uint8 object;\n");
cfOutput.Print(" };\n");
cfOutput.Print("};\n");
cFile++;
}
cfOutput.Print("struct Vector_%s_%s_0 {\n",
szCppClassName, szField);
cfOutput.Print(" uintptr headerwords[HDRWORDCOUNT];\n");
cfOutput.Print(" union {\n");
cfOutput.Print(" struct {\n");
cfOutput.Print(" Class_System_VTable * vtable;\n");
cfOutput.Print(" uint32 length;\n");
cfOutput.Print(" ClassVector_uint8 * data[%d];\n", cFiles);
cfOutput.Print(" };\n");
cfOutput.Print(" ClassVector_ClassVector_uint8 object;\n");
cfOutput.Print(" };\n");
cfOutput.Print("};\n");
cfOutput.Print("struct %s {\n", szCppClassName);
cfOutput.Print(" private:\n");
for (UINT i = 0; i < cFiles; i++) {
cfOutput.Print(" static Vector_%s_%s_0_%d c_%s_0_%d;\n",
szCppClassName, szField, i,
szField, i);
}
cfOutput.Print(" static Vector_%s_%s_0 c_%s_0;\n",
szCppClassName, szField, szField);
cfOutput.Print(" public:\n");
cfOutput.Print(" static ClassVector_ClassVector_uint8 * c_%s;\n", szField);
cfOutput.Print("};\n");
cfOutput.Print("\n");
cfOutput.Print("ClassVector_ClassVector_uint8 * %s::c_%s = &%s::c_%s_0.object;\n",
szCppClassName, szField,
szCppClassName, szField);
cfOutput.Print("\n");
cfOutput.Print("Vector_%s_%s_0 %s::c_%s_0 = {\n",
szCppClassName, szField,
szCppClassName, szField);
cfOutput.Print(" {},\n");
cfOutput.Print(" (Class_System_VTable *)&ClassVector_ClassVector_uint8::_vtable,\n");
cfOutput.Print(" %d,\n", cFiles);
cfOutput.Print(" {\n");
for (UINT i = 0; i < cFiles; i++) {
cfOutput.Print(" &%s::c_%s_0_%d.object,\n",
szCppClassName, szField, i);
}
cfOutput.Print(" },\n");
cfOutput.Print("};\n");
cfOutput.Print("\n");
}
else {
cfOutput.Print("struct Vector_%s_%s_0 {\n",
szCppClassName, szField);
cfOutput.Print(" uintptr headerwords[HDRWORDCOUNT];\n");
cfOutput.Print(" union { \n");
cfOutput.Print(" struct {\n");
cfOutput.Print(" Class_System_VTable * vtable;\n");
cfOutput.Print(" uint32 length;\n");
cfOutput.Print(" uint8 data[%d];\n",
cbFiles);
cfOutput.Print(" };\n");
cfOutput.Print(" ClassVector_uint8 object;\n");
cfOutput.Print(" };\n");
cfOutput.Print("};\n");
cfOutput.Print("struct %s {\n", szCppClassName);
cfOutput.Print(" private:\n");
cfOutput.Print(" static Vector_%s_%s_0 c_%s_0;\n",
szCppClassName, szField, szField);
cfOutput.Print(" public:\n");
cfOutput.Print(" static ClassVector_uint8 * c_%s;\n", szField);
cfOutput.Print("};\n");
cfOutput.Print("\n");
cfOutput.Print("ClassVector_uint8 * %s::c_%s = &%s::c_%s_0.object;\n",
szCppClassName, szField,
szCppClassName, szField);
cfOutput.Print("\n");
cfOutput.Print("Vector_%s_%s_0 %s::c_%s_0 = {\n",
szCppClassName, szField,
szCppClassName, szField);
cfOutput.Print(" {},\n");
cfOutput.Print(" (Class_System_VTable *)&ClassVector_uint8::_vtable,\n");
cfOutput.Print(" %d,\n", cbFiles);
cfOutput.Print(" {\n");
}
}
else {
if (szNamespace) {
cfOutput.Print("namespace %s {\n", szNamespace);
}
cfOutput.Print(" public class %s {\n", szClass);
if (fList) {
cfOutput.Print(" public static readonly byte[][] %s = {\n", szField);
}
else {
cfOutput.Print(" public static readonly byte[] %s = {\n", szField);
}
}
}
cFile = 0;
for (CFileInfo *pFile = pFiles; pFile != NULL; pFile = pFile->m_pNext) {
CFileMap cfInput;
printf(".");
if (!cfInput.Load(pFile->m_pszFile)) {
fprintf(stderr, "Could not open input file: %s\n", pFile->m_pszFile);
goto abort;
}
if (fFlattenPE) {
// Flatten PE file
if (!dump_pe(pOutput, &cfInput, pszRoot)) {
goto abort;
}
}
else {
if (fAsm) {
if (fList) {
cfOutput.Print("\n");
cfOutput.Print("align 4\n");
cfOutput.Print(" BARTOK_OBJECT_HEADER {} \n");
cfOutput.Print("%s%s_0_%d UINT32 %s\n",
szAsmName,
szByteSuffix,
cFile,
szByteVTable);
cfOutput.Print(" UINT32 %d\n", cfInput.Size());
}
}
else if (fCpp) {
if (fList) {
cfOutput.Print("Vector_%s_%s_0_%d %s::c_%s_0_%d = {\n",
szCppClassName, szField, cFile,
szCppClassName, szField, cFile);
cfOutput.Print(" {},\n");
cfOutput.Print(" (Class_System_VTable *)&ClassVector_uint8::_vtable,\n");
cfOutput.Print(" %d,\n", cfInput.Size());
cfOutput.Print(" {\n");
}
}
else {
if (fList) {
cfOutput.Print(" new byte[] {\n");
}
}
if (fCompress) {
if (!DumpBmp(pOutput, cfInput.Seek(0), cfInput.Size())) {
goto abort;
}
}
else {
pOutput->Dump(cfInput.Seek(0), cfInput.Size());
pOutput->Finish();
}
if (fAsm) {
}
else if (fCpp) {
if (fList) {
cfOutput.Print(" },\n");
cfOutput.Print("};\n");
cfOutput.Print("\n");
}
}
else {
if (fList) {
cfOutput.Print(" },\n");
}
}
}
cfInput.Close();
cFile++;
}
if (!fFlattenPE) {
if (fAsm) {
if (fList) {
// create list array at end.
cfOutput.Print("\n");
cfOutput.Print("align 4\n");
cfOutput.Print(" BARTOK_OBJECT_HEADER {} \n");
cfOutput.Print("public %s%s\n",
szAsmName,
szByteByteSuffix);
cfOutput.Print("%s%s_0 UINT32 %s\n",
szAsmName,
szByteByteSuffix,
szByteByteVTable);
cfOutput.Print(" UINT32 %d\n", cFiles);
for (UINT i = 0; i < cFiles; i++) {
cfOutput.Print(" UINT32 %s%s_0_%d\n",
szAsmName,
szByteSuffix,
i);
}
cfOutput.Print("\n");
cfOutput.Print("align 4\n");
cfOutput.Print("public %s%s\n",
szAsmName,
szByteByteSuffix);
cfOutput.Print("%s%s UINT32 %s%s_0\n",
szAsmName,
szByteByteSuffix,
szAsmName,
szByteByteSuffix);
}
else {
cfOutput.Print("\n");
cfOutput.Print("align 4\n");
cfOutput.Print("public %s%s\n",
szAsmName,
szByteSuffix);
cfOutput.Print("%s%s UINT32 %s%s_0\n",
szAsmName,
szByteSuffix,
szAsmName,
szByteSuffix);
}
}
else if (fCpp) {
if (!fList) {
cfOutput.Print(" },\n");
cfOutput.Print("};\n");
cfOutput.Print("\n");
}
}
else
{
cfOutput.Print(" };\n");
cfOutput.Print(" }\n");
cfOutput.Print("}\n");
}
}
if (fAbort) {
abort:
cfOutput.Delete();
return 1;
}
cfOutput.Close();
return 0;
}
//
///////////////////////////////////////////////////////////////// End of File.