1402 lines
38 KiB
C++
1402 lines
38 KiB
C++
//depot/private/Lab06_DEV/Windows/AppCompat/ShimDBC/mig.cpp#1 - branch change 8778 (text)
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// File: mig.cpp
|
|
//
|
|
// History: ??-Jul-00 vadimb Added Migdb logic
|
|
//
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "StdAfx.h"
|
|
#include "xml.h"
|
|
#include "mig.h"
|
|
#include "make.h"
|
|
#include "typeinfo.h"
|
|
#include "fileio.h"
|
|
|
|
//
|
|
// Max length of a migdb.inf string entry
|
|
//
|
|
#define MAX_INF_STRING_LENGTH 255
|
|
|
|
//
|
|
// from read.cpp - converts module type to a string (which is static)
|
|
//
|
|
LPCTSTR ModuleTypeIndicatorToStr(DWORD ModuleType);
|
|
|
|
|
|
//
|
|
// Mig tags support -- translation table
|
|
//
|
|
ATTRLISTENTRY g_rgMigDBAttributes[] = {
|
|
MIGDB_ENTRY2(COMPANYNAME, COMPANY_NAME, COMPANYNAME ),
|
|
MIGDB_ENTRY2(FILEDESCRIPTION, FILE_DESCRIPTION, FILEDESCRIPTION),
|
|
MIGDB_ENTRY2(FILEVERSION, FILE_VERSION, FILEVERSION ),
|
|
MIGDB_ENTRY2(INTERNALNAME, INTERNAL_NAME, INTERNALNAME ),
|
|
MIGDB_ENTRY2(LEGALCOPYRIGHT, LEGAL_COPYRIGHT, LEGALCOPYRIGHT ),
|
|
MIGDB_ENTRY2(ORIGINALFILENAME, ORIGINAL_FILENAME, ORIGINALFILENAME),
|
|
MIGDB_ENTRY2(PRODUCTNAME, PRODUCT_NAME, PRODUCTNAME ),
|
|
MIGDB_ENTRY2(PRODUCTVERSION, PRODUCT_VERSION, PRODUCTVERSION ),
|
|
MIGDB_ENTRY2(FILESIZE, SIZE, FILESIZE ),
|
|
MIGDB_ENTRY4(ISMSBINARY),
|
|
MIGDB_ENTRY4(ISWIN9XBINARY),
|
|
MIGDB_ENTRY4(INWINDIR),
|
|
MIGDB_ENTRY4(INCATDIR),
|
|
MIGDB_ENTRY4(INHLPDIR),
|
|
MIGDB_ENTRY4(INSYSDIR),
|
|
MIGDB_ENTRY4(INPROGRAMFILES),
|
|
MIGDB_ENTRY4(ISNOTSYSROOT),
|
|
MIGDB_ENTRY (CHECKSUM),
|
|
MIGDB_ENTRY2(EXETYPE, MODULE_TYPE, EXETYPE ),
|
|
MIGDB_ENTRY5(DESCRIPTION, 16BIT_DESCRIPTION, S16BITDESCRIPTION ),
|
|
MIGDB_ENTRY4(INPARENTDIR),
|
|
MIGDB_ENTRY4(INROOTDIR),
|
|
MIGDB_ENTRY4(PNPID),
|
|
MIGDB_ENTRY4(HLPTITLE),
|
|
MIGDB_ENTRY4(ISWIN98),
|
|
MIGDB_ENTRY4(HASVERSION),
|
|
// MIGDB_ENTRY (REQFILE),
|
|
MIGDB_ENTRY2(BINFILEVER, BIN_FILE_VERSION, BINFILEVER ),
|
|
MIGDB_ENTRY2(BINPRODUCTVER, BIN_PRODUCT_VERSION, BINPRODUCTVER ),
|
|
MIGDB_ENTRY5(FILEDATEHI, VERFILEDATEHI, FILEDATEHI),
|
|
MIGDB_ENTRY5(FILEDATELO, VERFILEDATELO, FILEDATELO),
|
|
MIGDB_ENTRY2(FILEVEROS, VERFILEOS, FILEVEROS ),
|
|
MIGDB_ENTRY2(FILEVERTYPE, VERFILETYPE, FILEVERTYPE ),
|
|
MIGDB_ENTRY4(FC),
|
|
MIGDB_ENTRY2(UPTOBINPRODUCTVER,UPTO_BIN_PRODUCT_VERSION,UPTOBINPRODUCTVER),
|
|
MIGDB_ENTRY2(UPTOBINFILEVER,UPTO_BIN_FILE_VERSION,UPTOBINFILEVER),
|
|
MIGDB_ENTRY4(SECTIONKEY),
|
|
MIGDB_ENTRY2(REGKEYPRESENT, REGISTRY_ENTRY, REGKEYPRESENT),
|
|
MIGDB_ENTRY4(ATLEASTWIN98),
|
|
// MIGDB_ENTRY (ARG)
|
|
};
|
|
|
|
TCHAR g_szArg[] = _T("ARG");
|
|
TCHAR g_szReqFile[] = _T("REQFILE");
|
|
|
|
|
|
//
|
|
// report MigDB exception
|
|
// this is our mechanism for passing errors around
|
|
//
|
|
|
|
void __cdecl MigThrowException(
|
|
LPCTSTR lpszFormat, ...
|
|
)
|
|
{
|
|
va_list arglist;
|
|
CString csError;
|
|
int nSize = 1024;
|
|
LPTSTR lpszBuffer;
|
|
|
|
va_start(arglist, lpszFormat);
|
|
|
|
try {
|
|
lpszBuffer = csError.GetBuffer(nSize);
|
|
StringCchVPrintf(lpszBuffer, nSize, lpszFormat, arglist);
|
|
csError.ReleaseBuffer();
|
|
} catch(CMemoryException* pMemoryException) {
|
|
SDBERROR(_T("Memory allocation error while trying to report an error\n"));
|
|
pMemoryException->Delete();
|
|
}
|
|
|
|
// now we throw
|
|
throw new CMigDBException(csError);
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Given an XML attribute mask, produce equivalent Migdb attribute type
|
|
//
|
|
|
|
MIGATTRTYPE GetInfTagByXMLAttrType(
|
|
IN DWORD dwXMLAttrType
|
|
)
|
|
{
|
|
MIGATTRTYPE MigAttrType = NONE;
|
|
int i;
|
|
|
|
for (i = 0; i < sizeof(g_rgMigDBAttributes)/sizeof(g_rgMigDBAttributes[0]); ++i) {
|
|
if (g_rgMigDBAttributes[i].XMLAttrType == dwXMLAttrType) {
|
|
MigAttrType = g_rgMigDBAttributes[i].MigAttrType;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return MigAttrType;
|
|
}
|
|
|
|
//
|
|
// make string nice and flat, with no extra spaces in-between
|
|
//
|
|
//
|
|
|
|
LPCTSTR g_pszDelim = _T(" \t\n\r");
|
|
|
|
CString FlattenString(LPCTSTR lpszStr)
|
|
{
|
|
TCHAR* pchStart = (TCHAR*)lpszStr;
|
|
TCHAR* pch;
|
|
CString csResult;
|
|
BOOL bSpace = FALSE;
|
|
|
|
while (*pchStart) {
|
|
//
|
|
// skip leading spaces or other trash
|
|
//
|
|
pchStart += _tcsspn(pchStart, g_pszDelim);
|
|
if (*pchStart == _T('\0')) {
|
|
// tough bananas - we got what we've got, exit now
|
|
break;
|
|
}
|
|
|
|
// search for the end-of-line
|
|
pch = _tcspbrk(pchStart, g_pszDelim);
|
|
if (pch == NULL) {
|
|
// we are done, no more nasty characters
|
|
// append and exit
|
|
//
|
|
if (bSpace) {
|
|
csResult += _T(' ');
|
|
}
|
|
csResult += pchStart;
|
|
break;
|
|
}
|
|
|
|
|
|
// add everything -- up until this \n
|
|
if (bSpace) {
|
|
csResult += _T(' ');
|
|
}
|
|
csResult += CString(pchStart, (int)(pch - pchStart));
|
|
bSpace = TRUE; // we have just removed a portion of the string containing \n
|
|
|
|
pchStart = pch; // point to the \n
|
|
}
|
|
|
|
//
|
|
// Make quotes (") into double quotes ("") so that
|
|
// it is legal INF
|
|
//
|
|
ReplaceStringNoCase(csResult, _T("\""), _T("\"\""));
|
|
|
|
return csResult;
|
|
}
|
|
|
|
VOID FilterStringNonAlnum(
|
|
CString& csTarget
|
|
)
|
|
{
|
|
TCHAR ch;
|
|
INT i;
|
|
|
|
for (i = 0; i < csTarget.GetLength(); i++) {
|
|
ch = csTarget.GetAt(i);
|
|
if (!((ch >= 'a' && ch <= 'z') ||
|
|
(ch >= 'A' && ch <= 'Z') ||
|
|
(ch >= '0' && ch <= '9'))) {
|
|
csTarget.SetAt(i, _T('_'));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Dumping .inf data support
|
|
//
|
|
|
|
CString MigApp::dump(void)
|
|
{
|
|
CString cs;
|
|
BOOL bInline;
|
|
INT i;
|
|
MigAttribute* pAttr;
|
|
|
|
// we can't do "inline" sections if we also have "ARGS"
|
|
bInline = (0 == m_rgArgs.GetSize());
|
|
|
|
cs = m_pSection->dump(m_csDescription.IsEmpty() ? NULL : (LPCTSTR)m_csDescription, NULL, FALSE, bInline);
|
|
if (m_csDescription.IsEmpty() && !bInline) {
|
|
cs += _T(",");
|
|
}
|
|
|
|
if (!bInline) {
|
|
for (i = 0; i < m_rgArgs.GetSize(); ++i) {
|
|
pAttr = (MigAttribute*)m_rgArgs.GetAt(i);
|
|
cs += (cs.IsEmpty()? _T(""): _T(", ")) + pAttr->dump();
|
|
}
|
|
}
|
|
return cs;
|
|
}
|
|
|
|
|
|
// we dump info into an array of strings, single-line entries are returned
|
|
|
|
// The first kind of return is "inline" --
|
|
// all the supplemental info is shoved into the rgOut
|
|
// for example, the return might be a reference to the section
|
|
// section's header and body are placed into rgOut
|
|
|
|
// ELIMINATE duplicate section names (reqfile!)
|
|
// optimize output - single "and" replaced with straight
|
|
// if a section is generated and placed as a single-line entry, promote the contents
|
|
// to upper level
|
|
|
|
|
|
CString MigSection::dump(LPCTSTR lpszDescription, int* pIndexContents, BOOL bNoHeader, BOOL bInline)
|
|
{
|
|
SdbArrayElement* p;
|
|
MigEntry* pEntry;
|
|
MigSection* pSection;
|
|
int indexContents = -1;
|
|
int nEntries;
|
|
|
|
const type_info& tiEntry = typeid(MigEntry); // cache type id info
|
|
const type_info& tiSection = typeid(MigSection);
|
|
int i;
|
|
|
|
CString cs; // inline return
|
|
CString csContents; // contents of supplemental section information
|
|
CString csSect;
|
|
CString csHeader;
|
|
CString csDescription(lpszDescription);
|
|
|
|
// place inline name and description
|
|
// we may need to enclose this into quotes
|
|
|
|
cs = m_csName;
|
|
if (!csDescription.IsEmpty()) {
|
|
if (csDescription.Left(1) == _T("%") &&
|
|
csDescription.Right(1) == _T("%")) {
|
|
cs += _T(", ") + csDescription;
|
|
} else {
|
|
cs += _T(", \"") + csDescription + _T("\"");
|
|
}
|
|
}
|
|
|
|
// if our section is a single-entry
|
|
// we dump this depending on the calling
|
|
|
|
// special case -- single file (and/or, matters not)
|
|
if (1 == m_rgEntries.GetSize() && m_bTopLevel && bInline) {
|
|
|
|
// this single line goes "inline" only if we are called from within
|
|
// other section
|
|
|
|
// dump the entry if it's an entry
|
|
p = (SdbArrayElement*)m_rgEntries.GetAt(0);
|
|
if (typeid(*p) == tiEntry) {
|
|
pEntry = (MigEntry*)p;
|
|
|
|
if (m_bTopLevel && csDescription.IsEmpty()) { // if the description was not added earlier and top-level...
|
|
cs += _T(",");
|
|
}
|
|
cs += _T(", ") + pEntry->dump();
|
|
return cs;
|
|
}
|
|
}
|
|
|
|
|
|
// first deal with sections...
|
|
switch(m_Operation) {
|
|
case MIGOP_OR:
|
|
// grab just one section in all if more than one entry
|
|
// IF we're the only entry -- but we need to have the right entry
|
|
//
|
|
if (!bNoHeader) { // ONLY valid for OR sections
|
|
csContents.Format(_T("[%s]\n"), (LPCTSTR)m_csName);
|
|
}
|
|
|
|
for (i = 0; i < m_rgEntries.GetSize(); ++i) {
|
|
p = (SdbArrayElement*)m_rgEntries.GetAt(i);
|
|
const type_info& tiPtr = typeid(*p);
|
|
if (tiPtr == tiEntry) {
|
|
pEntry = (MigEntry*)p;
|
|
csContents += pEntry->dump() + _T("\n");
|
|
}
|
|
else if (tiPtr == tiSection) {
|
|
pSection = (MigSection*)p;
|
|
csContents += pSection->dump() + _T("\n");
|
|
}
|
|
else {
|
|
// if we are here -- something is seriously wrong
|
|
// _tprintf(_T("Error - bad class information\n"));
|
|
MigThrowException(_T("Bad Entry detected in section \"%s\"\n"), (LPCTSTR)m_csName);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case MIGOP_AND:
|
|
// and for this entry ...
|
|
|
|
// optimization:
|
|
// if we're single-entry, retrieve the contents of the child section
|
|
// and put it right in
|
|
nEntries = m_rgEntries.GetSize();
|
|
for (i = 0; i < nEntries; ++i) {
|
|
p = (SdbArrayElement*)m_rgEntries.GetAt(i);
|
|
|
|
if (nEntries > 1) {
|
|
++m_nEntry;
|
|
csSect.Format(_T("[%s.%d]\n"), (LPCTSTR)m_csName, m_nEntry);
|
|
}
|
|
else {
|
|
csSect.Format(_T("[%s]\n"), (LPCTSTR)m_csName);
|
|
}
|
|
csContents += csSect;
|
|
|
|
const type_info& tiPtr = typeid(*p);
|
|
if (tiPtr == tiEntry) { // this is an entry, dump it into the section body
|
|
pEntry = (MigEntry*)p;
|
|
|
|
// numbered entry please...
|
|
csContents += pEntry->dump() + _T("\n");
|
|
|
|
}
|
|
else if (tiPtr == tiSection) { // this is a section, dump it, get the ref into the section body
|
|
pSection = (MigSection*)p;
|
|
|
|
// optimization:
|
|
if (pSection->m_Operation == MIGOP_OR) { // sub is an "OR" -- we need not have a ref
|
|
int index;
|
|
CString csSingle;
|
|
|
|
// dump all the entries right here
|
|
csSingle = pSection->dump(NULL, &index, TRUE);
|
|
if (index >= 0) {
|
|
csContents += m_pMigDB->m_rgOut.GetAt(index) + _T("\n");
|
|
m_pMigDB->m_rgOut.RemoveAt(index);
|
|
}
|
|
else {
|
|
csContents += csSingle;
|
|
}
|
|
|
|
}
|
|
else {
|
|
csContents += pSection->dump(NULL) + _T("\n");
|
|
}
|
|
}
|
|
else {
|
|
MigThrowException(_T("Internal Error: bad migration object\n"));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if (!csContents.IsEmpty()) {
|
|
indexContents = m_pMigDB->m_rgOut.Add(csContents);
|
|
}
|
|
if (NULL != pIndexContents) {
|
|
*pIndexContents = indexContents;
|
|
}
|
|
|
|
return cs;
|
|
}
|
|
|
|
CString MigEntry::FormatName(
|
|
VOID
|
|
)
|
|
{
|
|
INT i;
|
|
TCHAR ch;
|
|
BOOL bQuoteStr = FALSE;
|
|
CString csName;
|
|
|
|
bQuoteStr = (m_csName.GetLength() > 12); // 8.3 outright
|
|
|
|
for (i = 0; i < m_csName.GetLength() && !bQuoteStr; ++i) {
|
|
ch = m_csName.GetAt(i);
|
|
bQuoteStr = _istspace(ch) || (!_istalnum(ch) && _T('.') != ch);
|
|
}
|
|
|
|
if (!bQuoteStr) { // hmmm check filename and ext part
|
|
i = m_csName.Find(_T('.'));
|
|
if (i < 0) {
|
|
bQuoteStr = (m_csName.GetLength() > 8);
|
|
}
|
|
else {
|
|
// check for the second dot
|
|
bQuoteStr = (m_csName.Find(_T('.'), i+1) >= 0);
|
|
if (!bQuoteStr) {
|
|
// check for the ext length
|
|
bQuoteStr = (m_csName.Mid(i).GetLength() > 4); // with .abc
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bQuoteStr) {
|
|
return m_csName;
|
|
}
|
|
|
|
// else
|
|
|
|
csName.Format(_T("\"%s\""), m_csName);
|
|
return csName;
|
|
}
|
|
|
|
|
|
CString MigEntry::dump(void)
|
|
{
|
|
INT i;
|
|
MigAttribute* pAttr;
|
|
CString cs;
|
|
CString csName;
|
|
ULONG ulResult;
|
|
|
|
// _tprintf(_T("Entry: name=\"%s\"\n"), (LPCTSTR)m_csName);
|
|
// check whether we need to enclose this into quotes
|
|
// to do such a check we need to:
|
|
// check for non-ascii stuff...
|
|
|
|
// parser has put all the ARG attributes in the beginning of the array
|
|
|
|
// put any "arg" attributes before the exe name
|
|
for (i = 0; i < m_rgAttrs.GetSize(); ++i) {
|
|
pAttr = (MigAttribute*)m_rgAttrs.GetAt(i);
|
|
if (ARG != pAttr->m_type) {
|
|
break;
|
|
}
|
|
|
|
cs += (cs.IsEmpty()? _T(""): _T(", ")) + pAttr->dump();
|
|
}
|
|
|
|
|
|
cs += (cs.IsEmpty()? _T(""): _T(", ")) + FormatName();
|
|
|
|
for (;i < m_rgAttrs.GetSize(); ++i) {
|
|
pAttr = (MigAttribute*)m_rgAttrs.GetAt(i);
|
|
cs += (cs.IsEmpty()? _T(""): _T(", ")) + pAttr->dump();
|
|
}
|
|
|
|
return cs;
|
|
}
|
|
|
|
|
|
CString MigAttribute::dump(void)
|
|
{
|
|
|
|
CString cs;
|
|
CString csTemp;
|
|
|
|
switch(m_type) {
|
|
// note -- none of the attributes below are supported
|
|
case ISMSBINARY:
|
|
case ISWIN9XBINARY:
|
|
case INWINDIR:
|
|
case INCATDIR:
|
|
case INHLPDIR:
|
|
case INSYSDIR:
|
|
case INPROGRAMFILES:
|
|
case ISNOTSYSROOT:
|
|
case INROOTDIR:
|
|
case ISWIN98:
|
|
case HASVERSION:
|
|
case ATLEASTWIN98:
|
|
cs.Format(_T("%s%s"), m_bNot ? _T("!") : _T(""), (LPCTSTR)m_csName);
|
|
break;
|
|
|
|
case CHECKSUM:
|
|
case FILESIZE:
|
|
// under old code the following two values had been strings
|
|
case FILEDATEHI:
|
|
case FILEDATELO:
|
|
cs.Format(_T("%s%s(0x%.8lX)"), m_bNot?_T("!"):_T(""), (LPCTSTR)m_csName, m_dwValue);
|
|
break;
|
|
|
|
case BINFILEVER:
|
|
case BINPRODUCTVER:
|
|
case UPTOBINFILEVER:
|
|
case UPTOBINPRODUCTVER:
|
|
// version, ull
|
|
VersionQwordToString(csTemp, m_ullValue);
|
|
cs.Format(_T("%s%s(%s)"), m_bNot? _T("!"):_T(""), (LPCTSTR)m_csName, (LPCTSTR)csTemp);
|
|
break;
|
|
|
|
case EXETYPE:
|
|
// this is dword-encoded format that really is a string, convert
|
|
//
|
|
cs.Format(_T("%s%s(\"%s\")"), m_bNot ? _T("!") : _T(""), (LPCTSTR)m_csName, ModuleTypeIndicatorToStr(m_dwValue));
|
|
break;
|
|
|
|
// these two attributes are not supported either
|
|
case ARG:
|
|
case REQFILE:
|
|
|
|
if (m_pSection) {
|
|
m_pSection->dump();
|
|
}
|
|
// fall through
|
|
|
|
default:
|
|
cs.Format(_T("%s%s(\"%s\")"), m_bNot ? _T("!") : _T(""), (LPCTSTR)m_csName, (LPCTSTR)m_csValue);
|
|
break;
|
|
}
|
|
|
|
return cs;
|
|
}
|
|
|
|
|
|
/*++
|
|
Used to be a nice statistics-spewing function
|
|
|
|
|
|
VOID DumpMigDBStats(ShimDatabase* pDatabase)
|
|
{
|
|
POSITION pos = pDatabase->m_mapMigApp.GetStartPosition();
|
|
ShimArray* prgApp;
|
|
CString csSection;
|
|
DWORD dwApps = 0;
|
|
INT i;
|
|
|
|
Print( _T("Sections compiled: %d\n\n"), pDatabase->m_mapMigApp.GetCount());
|
|
while (pos) {
|
|
pDatabase->m_mapMigApp.GetNextAssoc(pos, csSection, (LPVOID&)prgApp);
|
|
|
|
Print(_T("Section [%36s]: %8ld apps\n"), (LPCTSTR)csSection, prgApp->GetSize());
|
|
dwApps += prgApp->GetSize();
|
|
}
|
|
Print( _T("--------\n"));
|
|
Print( _T("Total %38s: %8ld entries\n"), "", dwApps);
|
|
Print( _T("\n"));
|
|
if (gfVerbose) {
|
|
Print(_T("APPS\n"));
|
|
|
|
pos = pDatabase->m_mapMigApp.GetStartPosition();
|
|
while (pos) {
|
|
pDatabase->m_mapMigApp.GetNextAssoc(pos, csSection, (LPVOID&)prgApp);
|
|
|
|
Print(_T("Section [%36s]: %8ld apps\n"), (LPCTSTR)csSection, prgApp->GetSize());
|
|
Print(_T("-------------------------------------------------------------\n"));
|
|
for (i = 0; i < prgApp->GetSize(); ++i) {
|
|
MigApp* pApp = (MigApp*)prgApp->GetAt(i);
|
|
Print(_T("%s\n"), (LPCTSTR)pApp->m_csName);
|
|
}
|
|
Print(_T("\n"));
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
--*/
|
|
|
|
BOOL MigDatabase::DumpMigDBStrings(
|
|
LPCTSTR lpszFilename
|
|
)
|
|
{
|
|
CString csOut;
|
|
POSITION pos;
|
|
CANSITextFile OutFile(
|
|
lpszFilename,
|
|
m_pAppHelpDatabase->m_pCurrentMakefile->GetLangMap(m_pAppHelpDatabase->m_pCurrentOutputFile->m_csLangID)->m_dwCodePage,
|
|
CFile::modeCreate|CFile::modeReadWrite|CFile::shareDenyWrite);
|
|
CString csStringID;
|
|
CString csStringContent;
|
|
CString csCompoundString, csCompoundStringPart;
|
|
long nCursor = 0;
|
|
|
|
//
|
|
// write header (needed for postbuild!)
|
|
//
|
|
OutFile.WriteString(_T(";\n; AppCompat additions start here\n;\n; ___APPCOMPAT_MIG_ENTRIES___\n;\n"));
|
|
|
|
//
|
|
// write out the strings section
|
|
//
|
|
pos = m_mapStringsOut.GetStartPosition();
|
|
while (pos) {
|
|
m_mapStringsOut.GetNextAssoc(pos, csStringID, csStringContent);
|
|
|
|
if (csStringContent.GetLength() > MAX_INF_STRING_LENGTH) {
|
|
nCursor = 0;
|
|
csCompoundString.Empty();
|
|
while (nCursor * MAX_INF_STRING_LENGTH < csStringContent.GetLength()) {
|
|
csOut.Format(_T("%s.%d = \"%s\"\n"),
|
|
(LPCTSTR)csStringID,
|
|
nCursor + 1,
|
|
(LPCTSTR)csStringContent.Mid(nCursor * MAX_INF_STRING_LENGTH, MAX_INF_STRING_LENGTH));
|
|
|
|
OutFile.WriteString(csOut);
|
|
|
|
csCompoundStringPart.Format(_T(" %%%s.%d%%"), csStringID, nCursor + 1);
|
|
csCompoundString += csCompoundStringPart;
|
|
nCursor++;
|
|
}
|
|
} else {
|
|
csOut.Format(_T("%s = \"%s\"\n"), (LPCTSTR)csStringID, (LPCTSTR)csStringContent);
|
|
OutFile.WriteString(csOut);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL MigDatabase::DumpMigDBInf(
|
|
LPCTSTR lpszFilename
|
|
)
|
|
{
|
|
CString csSection;
|
|
CString csOut;
|
|
SdbArray<SdbArrayElement>* prgApp;
|
|
INT i;
|
|
MigApp* pApp;
|
|
BOOL bSuccess = FALSE;
|
|
POSITION pos;
|
|
|
|
CStringArray rgShowInSimplifiedView;
|
|
|
|
// clear out help array
|
|
m_rgOut.RemoveAll();
|
|
|
|
CANSITextFile OutFile(
|
|
lpszFilename,
|
|
m_pAppHelpDatabase->m_pCurrentMakefile->GetLangMap(m_pAppHelpDatabase->m_pCurrentOutputFile->m_csLangID)->m_dwCodePage,
|
|
CFile::modeCreate|CFile::modeReadWrite|CFile::shareDenyWrite);
|
|
|
|
//
|
|
// traverse sections...
|
|
//
|
|
pos = m_mapSections.GetStartPosition();
|
|
while (pos) {
|
|
m_mapSections.GetNextAssoc(pos, csSection, (LPVOID&)prgApp);
|
|
csOut.Format(_T("[%s]\n"), (LPCTSTR)csSection);
|
|
OutFile.WriteString(csOut);
|
|
|
|
for (i = 0; i < prgApp->GetSize(); ++i) {
|
|
pApp = (MigApp*)prgApp->GetAt(i);
|
|
csOut.Format(_T("%s\n"), pApp->dump());
|
|
|
|
if (pApp->m_bShowInSimplifiedView) {
|
|
rgShowInSimplifiedView.Add(csOut);
|
|
}
|
|
|
|
OutFile.WriteString(csOut);
|
|
}
|
|
|
|
csOut.Format(_T("\n"));
|
|
OutFile.WriteString(csOut);
|
|
}
|
|
|
|
//
|
|
// Dump ShowInSimplifiedView section
|
|
//
|
|
OutFile.WriteString(_T("[ShowInSimplifiedView]\n"));
|
|
for (i = 0; i < rgShowInSimplifiedView.GetSize(); i++) {
|
|
OutFile.WriteString(rgShowInSimplifiedView[i]);
|
|
}
|
|
|
|
OutFile.WriteString(_T("\n"));
|
|
|
|
for (i = 0; i < m_rgOut.GetSize(); ++i) {
|
|
OutFile.WriteString(m_rgOut.GetAt(i));
|
|
}
|
|
|
|
bSuccess = TRUE;
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
MigSection& MigSection::operator=(SdbMatchOperation& rMatchOp)
|
|
{
|
|
MigEntry* pEntry;
|
|
MigSection* pSection;
|
|
int i;
|
|
|
|
if (rMatchOp.m_Type == SDB_MATCH_ALL) {
|
|
m_Operation = MIGOP_AND;
|
|
} else if (rMatchOp.m_Type == SDB_MATCH_ANY) {
|
|
m_Operation = MIGOP_OR;
|
|
} else {
|
|
MigThrowException(_T("Bad matching operation\n"));
|
|
}
|
|
|
|
// now translate the content
|
|
for (i = 0; i < rMatchOp.m_rgMatchingFiles.GetSize(); ++i) {
|
|
SdbMatchingFile* pMatchingFile = (SdbMatchingFile*)rMatchOp.m_rgMatchingFiles.GetAt(i);
|
|
|
|
pEntry = new MigEntry(m_pMigDB);
|
|
if (pEntry == NULL) {
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
*pEntry = *pMatchingFile;
|
|
|
|
// add the entry in
|
|
m_rgEntries.Add(pEntry, m_pDB);
|
|
}
|
|
|
|
for (i = 0; i < rMatchOp.m_rgSubMatchOps.GetSize(); ++i) {
|
|
SdbMatchOperation* pMatchOp = (SdbMatchOperation*)rMatchOp.m_rgSubMatchOps.GetAt(i);
|
|
|
|
pSection = new MigSection(m_pMigDB);
|
|
|
|
if (pSection == NULL) {
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
//
|
|
// format section's name
|
|
//
|
|
pSection->m_csName.Format(_T("%s_%lx"), (LPCTSTR)m_csName, i);
|
|
|
|
*pSection = *pMatchOp;
|
|
|
|
//
|
|
// patch the name of the section
|
|
//
|
|
|
|
m_rgEntries.Add(pSection, m_pDB);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Conversion code
|
|
//
|
|
|
|
MigApp& MigApp::operator=(
|
|
SdbWin9xMigration& rMig
|
|
)
|
|
{
|
|
INT i;
|
|
SdbMatchingFile* pMatchingFile;
|
|
MigEntry* pMigEntry;
|
|
CString csSectionName;
|
|
CString csID;
|
|
BOOL bSuccess;
|
|
CString csName;
|
|
|
|
if (rMig.m_pApp == NULL) {
|
|
MigThrowException(_T("Internal Compiler Error: Migration object should contain reference to the application"));
|
|
}
|
|
|
|
// name please
|
|
|
|
csName = m_pMigDB->GetAppTitle(&rMig);
|
|
|
|
m_csName = csName;
|
|
|
|
++m_pMigDB->m_dwExeCount;
|
|
|
|
//
|
|
// step one -- translate the general stuff
|
|
// we will probably need
|
|
|
|
m_pSection = new MigSection(m_pMigDB); //
|
|
if (m_pSection == NULL) {
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
|
|
// our matching method is always AND (meaning all the files have to be present to produce a match
|
|
// it is set when constructing the section object
|
|
|
|
//
|
|
// m_csSection -- set here the section where this exe will go
|
|
// should the function below fail -- it will throw an exception
|
|
//
|
|
m_csSection = rMig.m_csSection; // copy the section over
|
|
|
|
//
|
|
// check whether we will have description
|
|
m_csDescription = m_pMigDB->FormatDescriptionStringID(&rMig);
|
|
|
|
//
|
|
// Set the section's level
|
|
//
|
|
m_pSection->m_bTopLevel = TRUE;
|
|
|
|
// the name of the section is the name of the app
|
|
m_pSection->m_csName = csName;
|
|
|
|
m_bShowInSimplifiedView = rMig.m_bShowInSimplifiedView;
|
|
|
|
//
|
|
// on to the assignment operation
|
|
//
|
|
*m_pSection = rMig.m_MatchOp; // simple assignment
|
|
|
|
return *this;
|
|
}
|
|
|
|
MigEntry& MigEntry::operator=(
|
|
SdbMatchingFile& rMatchingFile
|
|
)
|
|
{
|
|
INT i;
|
|
MigAttribute* pAttr;
|
|
|
|
//
|
|
// this name may be '*' denoting the main exe -- in this case the name will be corrected
|
|
// on the upper level, after this assignment operation completes
|
|
//
|
|
m_csName = rMatchingFile.m_csName;
|
|
|
|
// inherit the database ptr
|
|
m_pDB = rMatchingFile.m_pDB;
|
|
|
|
// roll through the attributes now
|
|
for (i = 0; i < sizeof(g_rgMigDBAttributes)/sizeof(g_rgMigDBAttributes[0]); ++i) {
|
|
if (!g_rgMigDBAttributes[i].XMLAttrType) {
|
|
continue;
|
|
}
|
|
|
|
// now check whether this attribute is present in matching file
|
|
if (!(rMatchingFile.m_dwMask & g_rgMigDBAttributes[i].XMLAttrType)) {
|
|
// attribute not present, keep on
|
|
continue;
|
|
}
|
|
|
|
// this attribute is present, encode it
|
|
pAttr = new MigAttribute(m_pMigDB);
|
|
if (pAttr == NULL) {
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
pAttr->m_type = g_rgMigDBAttributes[i].MigAttrType;
|
|
pAttr->m_csName = g_rgMigDBAttributes[i].szOutputName ?
|
|
g_rgMigDBAttributes[i].szOutputName :
|
|
g_rgMigDBAttributes[i].szAttributeName;
|
|
|
|
switch(g_rgMigDBAttributes[i].XMLAttrType) {
|
|
case SDB_MATCHINGINFO_SIZE:
|
|
pAttr->m_dwValue = rMatchingFile.m_dwSize;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_CHECKSUM:
|
|
pAttr->m_dwValue = rMatchingFile.m_dwChecksum;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_COMPANY_NAME:
|
|
pAttr->m_csValue = rMatchingFile.m_csCompanyName;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_PRODUCT_NAME:
|
|
pAttr->m_csValue = rMatchingFile.m_csProductName;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_PRODUCT_VERSION:
|
|
pAttr->m_csValue = rMatchingFile.m_csProductVersion;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_FILE_DESCRIPTION:
|
|
pAttr->m_csValue = rMatchingFile.m_csFileDescription;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_BIN_FILE_VERSION:
|
|
pAttr->m_ullValue = rMatchingFile.m_ullBinFileVersion;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_BIN_PRODUCT_VERSION:
|
|
pAttr->m_ullValue = rMatchingFile.m_ullBinProductVersion;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_MODULE_TYPE:
|
|
pAttr->m_dwValue = rMatchingFile.m_dwModuleType;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_VERFILEDATEHI:
|
|
pAttr->m_dwValue = rMatchingFile.m_dwFileDateMS;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_VERFILEDATELO:
|
|
pAttr->m_dwValue = rMatchingFile.m_dwFileDateLS;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_VERFILEOS:
|
|
pAttr->m_dwValue = rMatchingFile.m_dwFileOS;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_VERFILETYPE:
|
|
pAttr->m_dwValue = rMatchingFile.m_dwFileType;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_PE_CHECKSUM:
|
|
pAttr->m_ulValue = rMatchingFile.m_ulPECheckSum;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_FILE_VERSION:
|
|
pAttr->m_csValue = rMatchingFile.m_csFileVersion;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_ORIGINAL_FILENAME:
|
|
pAttr->m_csValue = rMatchingFile.m_csOriginalFileName;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_INTERNAL_NAME:
|
|
pAttr->m_csValue = rMatchingFile.m_csInternalName;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_LEGAL_COPYRIGHT:
|
|
pAttr->m_csValue = rMatchingFile.m_csLegalCopyright;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_UPTO_BIN_PRODUCT_VERSION:
|
|
pAttr->m_ullValue = rMatchingFile.m_ullUpToBinProductVersion;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_UPTO_BIN_FILE_VERSION:
|
|
pAttr->m_ullValue = rMatchingFile.m_ullUpToBinFileVersion;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_16BIT_DESCRIPTION:
|
|
pAttr->m_csValue = rMatchingFile.m_cs16BitDescription;
|
|
break;
|
|
|
|
case SDB_MATCHINGINFO_REGISTRY_ENTRY:
|
|
pAttr->m_csValue = rMatchingFile.m_csRegistryEntry;
|
|
break;
|
|
|
|
|
|
//
|
|
// case SDB_MATCHINGINFO_PREVOSMAJORVERSION
|
|
// case SDB_MATCHINGINFO_PREVOSMINORVERSION
|
|
// case SDB_MATCHINGINFO_PREVOSPLATFORMID
|
|
// case SDB_MATCHINGINFO_PREVOSBUILDNO
|
|
// there is no such attribute. it will simply be ignored
|
|
//
|
|
|
|
}
|
|
|
|
m_rgAttrs.Add(pAttr, NULL);
|
|
|
|
}
|
|
|
|
|
|
return *this;
|
|
}
|
|
|
|
TCHAR g_szIncompatible[] = _T("Incompatible");
|
|
TCHAR g_szReinstall[] = _T("Reinstall");
|
|
|
|
CString MigDatabase::GetAppTitle(
|
|
SdbWin9xMigration* pAppMig
|
|
)
|
|
{
|
|
// part one -- get the application's title
|
|
BOOL bSuccess;
|
|
CString csID;
|
|
CString csAppTitle;
|
|
LPTSTR pBuffer = csID.GetBuffer(64); // a little more than you need for guid
|
|
if (pBuffer == NULL) {
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
bSuccess = StringFromGUID(pBuffer, &pAppMig->m_ID);
|
|
csID.ReleaseBuffer();
|
|
if (!bSuccess) {
|
|
MigThrowException(_T("Failed trying to convert GUID to string for entry \"%s\"\n"),
|
|
(LPCTSTR)pAppMig->m_pApp->m_csName);
|
|
}
|
|
|
|
//
|
|
// name of this particular exe (we don't care for it -- it won't be reflected anywhere)
|
|
//
|
|
csAppTitle.Format(_T("%s_%s"), (LPCTSTR)pAppMig->m_pApp->m_csName, (LPCTSTR)csID);
|
|
csAppTitle.Remove(_T('{'));
|
|
csAppTitle.Remove(_T('}'));
|
|
|
|
// weed out the rest of non-alnum characters
|
|
|
|
FilterStringNonAlnum(csAppTitle);
|
|
|
|
return csAppTitle;
|
|
|
|
|
|
}
|
|
|
|
|
|
CString MigDatabase::GetDescriptionStringID(
|
|
SdbWin9xMigration* pAppMig
|
|
)
|
|
{
|
|
CString csDescriptionID;
|
|
|
|
// part one -- get the application's title
|
|
BOOL bSuccess;
|
|
CString csID;
|
|
CString csAppTitle;
|
|
|
|
if (pAppMig->m_csMessage.IsEmpty()) {
|
|
return csID; // empty string
|
|
}
|
|
|
|
LPTSTR pBuffer = csID.GetBuffer(64); // a little more than you need for guid
|
|
if (pBuffer == NULL) {
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
bSuccess = StringFromGUID(pBuffer, &pAppMig->m_ID);
|
|
csID.ReleaseBuffer();
|
|
if (!bSuccess) {
|
|
MigThrowException(_T("Failed trying to convert GUID to string for entry \"%s\"\n"),
|
|
(LPCTSTR)pAppMig->m_pApp->m_csName);
|
|
}
|
|
|
|
//
|
|
// name of this particular exe (we don't care for it -- it won't be reflected anywhere)
|
|
//
|
|
|
|
csDescriptionID.Format(_T("__Message_%s_%s"), (LPCTSTR)pAppMig->m_csMessage, (LPCTSTR)csID);
|
|
csDescriptionID.Remove(_T('{'));
|
|
csDescriptionID.Remove(_T('}'));
|
|
|
|
// weed out the rest of non-alnum characters
|
|
|
|
FilterStringNonAlnum(csDescriptionID);
|
|
|
|
return csDescriptionID;
|
|
|
|
|
|
}
|
|
|
|
CString MigDatabase::FormatDescriptionStringID(
|
|
SdbWin9xMigration* pMigApp
|
|
)
|
|
{
|
|
CString csDescriptionID;
|
|
CString csRet;
|
|
CString csCompoundStringPart;
|
|
CString csStringContent;
|
|
long nCursor;
|
|
|
|
//
|
|
// get the string
|
|
// basis is the application's name
|
|
|
|
csDescriptionID = GetDescriptionStringID(pMigApp);
|
|
if (csDescriptionID.IsEmpty()) {
|
|
return csDescriptionID;
|
|
}
|
|
|
|
csStringContent = GetDescriptionString(pMigApp);
|
|
|
|
if (csStringContent.GetLength() > MAX_INF_STRING_LENGTH) {
|
|
nCursor = 0;
|
|
while (nCursor * MAX_INF_STRING_LENGTH < csStringContent.GetLength()) {
|
|
csCompoundStringPart.Format(_T("%%%s.%d%%"), csDescriptionID, nCursor + 1);
|
|
csRet += csCompoundStringPart;
|
|
nCursor++;
|
|
}
|
|
} else {
|
|
csRet.Format(_T("%%%s%%"), csDescriptionID);
|
|
}
|
|
|
|
//
|
|
// return id
|
|
//
|
|
return csRet;
|
|
|
|
}
|
|
|
|
CString MigDatabase::GetDescriptionString(
|
|
SdbWin9xMigration* pMigApp
|
|
)
|
|
{
|
|
CString csDescription;
|
|
|
|
SdbMessage* pMessage;
|
|
SdbDatabase* pMessageDB;
|
|
|
|
CString csDetails;
|
|
|
|
BOOL bSuccess;
|
|
|
|
//
|
|
// get apphelp database
|
|
//
|
|
pMessageDB = m_pMessageDatabase;
|
|
if (pMessageDB == NULL) {
|
|
MigThrowException(_T("Internal error: cannot produce description without apphelp database\n"));
|
|
}
|
|
|
|
if (pMigApp->m_csMessage.IsEmpty()) {
|
|
return csDescription;
|
|
}
|
|
|
|
//
|
|
// lookup this app in the apphelp db
|
|
//
|
|
pMessage = (SdbMessage *)pMessageDB->m_rgMessages.LookupName(pMigApp->m_csMessage, pMessageDB->m_pCurrentMakefile->m_csLangID);
|
|
if (pMessage == NULL) {
|
|
MigThrowException(_T("Exe \"%s\" has bad apphelp reference object\n"), (LPCTSTR)pMigApp->m_csMessage);
|
|
}
|
|
|
|
bSuccess = pMessageDB->ConstructMigrationMessage(pMigApp,
|
|
pMessage,
|
|
&csDetails);
|
|
if (!bSuccess) {
|
|
MigThrowException(_T("Failed to construct Migration message %s for \"%s\"\n"),
|
|
(LPCTSTR)pMigApp->m_pApp->m_csName, pMigApp->m_csMessage);
|
|
}
|
|
|
|
//
|
|
// 2. now that we have csDetails, flatten it
|
|
//
|
|
|
|
csDescription = FlattenString(csDetails);
|
|
|
|
return csDescription;
|
|
}
|
|
|
|
BOOL MigDatabase::AddApp(
|
|
MigApp* pApp
|
|
)
|
|
{
|
|
SdbArray<MigApp>* prgApp;
|
|
CString csSection;
|
|
|
|
csSection = pApp->m_csSection;
|
|
|
|
csSection.MakeUpper();
|
|
|
|
if (m_mapSections.Lookup(csSection, (LPVOID&)prgApp)) {
|
|
if (g_bStrict && NULL != prgApp->LookupName(pApp->m_csName)) {
|
|
|
|
//
|
|
// can't do that -- duplicate name
|
|
//
|
|
|
|
MigThrowException(_T("Duplicate application name found for app \"%s\"\n"), (LPCTSTR)pApp->m_csName);
|
|
}
|
|
|
|
prgApp->Add(pApp, m_pFixDatabase, FALSE);
|
|
} else {
|
|
prgApp = new SdbArray<MigApp>;
|
|
if (prgApp == NULL) {
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
prgApp->Add(pApp, m_pFixDatabase, FALSE);
|
|
m_mapSections.SetAt(csSection, (LPVOID&)prgApp);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL MigDatabase::Populate(
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// roll through all the outer objects (exes and generate migdb objects)
|
|
//
|
|
|
|
int i, iMig;
|
|
SdbExe* pExe;
|
|
MigApp* pMigApp;
|
|
SdbDatabase* pFixDatabase = m_pFixDatabase;
|
|
SdbApp* pApp;
|
|
SdbWin9xMigration* pMigration;
|
|
|
|
if (pFixDatabase == NULL) {
|
|
MigThrowException(_T("Cannot produce migdb entries without fix db\n"));
|
|
}
|
|
|
|
for (i = 0; i < pFixDatabase->m_rgApps.GetSize(); i++) {
|
|
//
|
|
// for each app check whether it has migration info
|
|
//
|
|
pApp = (SdbApp*)pFixDatabase->m_rgApps.GetAt(i);
|
|
|
|
for (iMig = 0; iMig < pApp->m_rgWin9xMigEntries.GetSize(); ++iMig) {
|
|
pMigration = (SdbWin9xMigration*)pApp->m_rgWin9xMigEntries.GetAt(iMig);
|
|
|
|
pMigApp = new MigApp(this);
|
|
if (pMigApp == NULL) {
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
// we have a brand new migration object, assign it
|
|
*pMigApp = *pMigration;
|
|
|
|
// once that is done, pMigApp->m_csSection has the destination of it
|
|
// this function will throw an exception if an error occurs
|
|
AddApp(pMigApp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
BOOL MigDatabase::PopulateStrings(
|
|
VOID
|
|
)
|
|
{
|
|
SdbWin9xMigration* pMigration;
|
|
SdbApp* pApp;
|
|
CString csDescriptionID;
|
|
CString csDescription;
|
|
CString csAppTitleID;
|
|
CString csAppTitle;
|
|
CString csTemp;
|
|
int i, iMig;
|
|
|
|
//
|
|
// get all the strings
|
|
//
|
|
for (i = 0; i < m_pAppHelpDatabase->m_rgApps.GetSize(); i++) {
|
|
//
|
|
// for each app check whether it has migration info
|
|
//
|
|
pApp = (SdbApp*)m_pAppHelpDatabase->m_rgApps.GetAt(i);
|
|
|
|
for (iMig = 0; iMig < pApp->m_rgWin9xMigEntries.GetSize(); ++iMig) {
|
|
pMigration = (SdbWin9xMigration*)pApp->m_rgWin9xMigEntries.GetAt(iMig);
|
|
|
|
|
|
//
|
|
// Set up title strings
|
|
//
|
|
csAppTitleID = GetAppTitle(pMigration);
|
|
csAppTitle = pMigration->m_pApp->GetLocalizedAppName();
|
|
|
|
if (m_mapStringsOut.Lookup(csAppTitleID, csTemp)) {
|
|
MigThrowException(_T("Duplicate String ID \"%s\" found for entry \"%s\"\n"),
|
|
csAppTitleID,
|
|
pMigration->m_pApp->m_csName);
|
|
}
|
|
|
|
m_mapStringsOut.SetAt(csAppTitleID, csAppTitle);
|
|
|
|
csDescription = GetDescriptionString(pMigration);
|
|
csDescriptionID = GetDescriptionStringID(pMigration);
|
|
|
|
if (csDescriptionID.IsEmpty()) { // we allow description to be empty
|
|
continue;
|
|
}
|
|
|
|
if (m_mapStringsOut.Lookup(csDescriptionID, csTemp)) {
|
|
MigThrowException(_T("Duplicate String ID \"%s\" found for entry \"%s\"\n"),
|
|
csDescriptionID,
|
|
pMigration->m_pApp->m_csName);
|
|
}
|
|
|
|
m_mapStringsOut.SetAt(csDescriptionID, csDescription);
|
|
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Top-level function
|
|
//
|
|
// if supplied: pAppHelpDatabase and pFixDatabase ->> migapp.inx is produced
|
|
// pAppHelpDatabase and pMessageDatabas ->> migapp.txt is produced
|
|
//
|
|
BOOL WriteMigDBFile(
|
|
SdbDatabase* pFixDatabase, // may be NULL
|
|
SdbDatabase* pAppHelpDatabase, // always supplied
|
|
SdbDatabase* pMessageDatabase, // may be NULL
|
|
LPCTSTR lpszFileName // always supplied
|
|
)
|
|
{
|
|
MigDatabase* pMigDatabase = NULL;
|
|
BOOL bSuccess = FALSE;
|
|
|
|
// construct migdatabase object and populate it
|
|
|
|
try {
|
|
|
|
// construct
|
|
|
|
pMigDatabase = new MigDatabase;
|
|
if (pMigDatabase == NULL) {
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
// init MigDatabase object
|
|
//
|
|
// [markder] Make them all the same so that
|
|
// we can process messages/fixes at the same
|
|
// time.
|
|
//
|
|
pMigDatabase->m_pFixDatabase = pAppHelpDatabase;
|
|
pMigDatabase->m_pAppHelpDatabase = pAppHelpDatabase;
|
|
pMigDatabase->m_pMessageDatabase = pAppHelpDatabase;
|
|
|
|
bSuccess = pMigDatabase->Populate();
|
|
if (!bSuccess) {
|
|
throw new CMigDBException(_T("Unknown error populating MIGDB additions."));
|
|
}
|
|
|
|
bSuccess = pMigDatabase->PopulateStrings();
|
|
if (!bSuccess) {
|
|
throw new CMigDBException(_T("Unknown error populating MIGDB additions."));
|
|
}
|
|
|
|
if (pFixDatabase != NULL) {
|
|
|
|
//
|
|
// produce migdb.inf
|
|
//
|
|
bSuccess = pMigDatabase->DumpMigDBInf(lpszFileName);
|
|
|
|
} else { // dumping the strings
|
|
|
|
bSuccess = pMigDatabase->DumpMigDBStrings(lpszFileName);
|
|
|
|
}
|
|
|
|
delete pMigDatabase;
|
|
|
|
//
|
|
// can only get here if we don't catch any exceptions
|
|
//
|
|
return bSuccess;
|
|
|
|
} catch(CMigDBException* pMigdbException) {
|
|
|
|
SDBERROR((LPCTSTR)pMigdbException->m_csError);
|
|
pMigdbException->Delete();
|
|
|
|
} catch(CFileException* pFileException) {
|
|
//
|
|
// a little more tricky
|
|
//
|
|
CString csError;
|
|
int nSize = 1024;
|
|
BOOL bError;
|
|
bError = pFileException->GetErrorMessage(csError.GetBuffer(nSize), nSize);
|
|
csError.ReleaseBuffer();
|
|
if (bError) {
|
|
SDBERROR((LPCTSTR)csError);
|
|
}
|
|
|
|
pFileException->Delete();
|
|
|
|
} catch(CMemoryException* pMemoryException) {
|
|
|
|
SDBERROR(_T("Memory Allocation Failure\n"));
|
|
pMemoryException->Delete();
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|