static void parseFeatureClauses (tokenInfo *const token)
{
Assert (isKeyword (token, KEYWORD_feature));
do
{
if (isKeyword (token, KEYWORD_feature))
parseExport (token);
if (! isKeyword (token, KEYWORD_feature) &&
! isKeyword (token, KEYWORD_invariant) &&
! isKeyword (token, KEYWORD_indexing))
{
if (! parseFeature (token))
readToken (token);
}
} while (! isKeyword (token, KEYWORD_end) &&
! isKeyword (token, KEYWORD_invariant) &&
! isKeyword (token, KEYWORD_indexing));
}
Error parseOne() {
read();
switch (Tok.K) {
case Eof:
return Error::success();
case KwExports:
for (;;) {
read();
if (Tok.K != Identifier) {
unget();
return Error::success();
}
if (Error Err = parseExport())
return Err;
}
case KwHeapsize:
return parseNumbers(&Info.HeapReserve, &Info.HeapCommit);
case KwStacksize:
return parseNumbers(&Info.StackReserve, &Info.StackCommit);
case KwLibrary:
case KwName: {
bool IsDll = Tok.K == KwLibrary; // Check before parseName.
std::string Name;
if (Error Err = parseName(&Name, &Info.ImageBase))
return Err;
Info.ImportName = Name;
// Set the output file, but don't override /out if it was already passed.
if (Info.OutputFile.empty()) {
Info.OutputFile = Name;
// Append the appropriate file extension if not already present.
if (!sys::path::has_extension(Name))
Info.OutputFile += IsDll ? ".dll" : ".exe";
}
return Error::success();
}
case KwVersion:
return parseVersion(&Info.MajorImageVersion, &Info.MinorImageVersion);
default:
return createError("unknown directive: " + Tok.Value);
}
}
//static
Command* Command::parseTokens( Tokens& tokens, bool helpMode )
{
if (tokens.empty()) THROW( CWDB_ERR_PARSER, "Bad syntax: no tokens to parse");
Command* result = 0;
try {
switch(tokens.front().m_angen) {
case ANGEN_CREATE: parseCreate( tokens, helpMode, result ); break;
case ANGEN_DESCR: parseDescr( tokens, helpMode, result ); break;
case ANGEN_DROP: parseDrop( tokens, helpMode, result ); break;
case ANGEN_DUMP: parseDump( tokens, helpMode, result ); break;
case ANGEN_GET:
case ANGEN_SET:
case ANGEN_PUT: parseInput( tokens, helpMode, result ); break;
case ANGEN_QUERY: parseQuery( tokens, helpMode, result ); break;
case ANGEN_USE: parseUse( tokens, helpMode, result ); break;
case ANGEN_GENERATE: parseGenerate( tokens, helpMode, result ); break;
case ANGEN_VERSION: parseVersion( tokens, helpMode, result ); break;
case ANGEN_FORMAT: parseFormat( tokens, helpMode, result ); break;
case ANGEN_COMPACT: parseCompact( tokens, helpMode, result ); break;
case ANGEN_UPDATE: parseUpdate( tokens, helpMode, result ); break;
case ANGEN_START:
case ANGEN_STOP: parseStart( tokens, helpMode, result ); break;
case ANGEN_EXPORT: parseExport( tokens, helpMode, result ); break;
case ANGEN_IMPORT: parseImport( tokens, helpMode, result ); break;
default: THROW( CWDB_ERR_PARSER, "Bad syntax: unknown command" );
}
}
catch (CWDBException& e) {
if (result != 0) {
delete result;
result = 0;
}
throw e;
}
return result;
}
bool Parser::parseOne(Directive *&ret) {
consumeToken();
switch (_tok._kind) {
case Kind::eof:
return true;
case Kind::kw_exports: {
// EXPORTS
std::vector<PECOFFLinkingContext::ExportDesc> exports;
for (;;) {
PECOFFLinkingContext::ExportDesc desc;
if (!parseExport(desc))
break;
exports.push_back(desc);
}
ret = new (_alloc) Exports(exports);
return true;
}
case Kind::kw_heapsize: {
// HEAPSIZE
uint64_t reserve, commit;
if (!parseMemorySize(reserve, commit))
return false;
ret = new (_alloc) Heapsize(reserve, commit);
return true;
}
case Kind::kw_library: {
// LIBRARY
std::string name;
uint64_t baseaddr;
if (!parseName(name, baseaddr))
return false;
if (!StringRef(name).endswith_lower(".dll"))
name.append(".dll");
ret = new (_alloc) Library(name, baseaddr);
return true;
}
case Kind::kw_stacksize: {
// STACKSIZE
uint64_t reserve, commit;
if (!parseMemorySize(reserve, commit))
return false;
ret = new (_alloc) Stacksize(reserve, commit);
return true;
}
case Kind::kw_name: {
// NAME
std::string outputPath;
uint64_t baseaddr;
if (!parseName(outputPath, baseaddr))
return false;
ret = new (_alloc) Name(outputPath, baseaddr);
return true;
}
case Kind::kw_version: {
// VERSION
int major, minor;
if (!parseVersion(major, minor))
return false;
ret = new (_alloc) Version(major, minor);
return true;
}
default:
error(_tok, Twine("Unknown directive: ") + _tok._range);
return false;
}
}
int updateScriptImport(int ovlIdx) {
char buffer[256];
ovlDataStruct *ovlData;
int numData3;
int size5;
int numRelocGlob;
int param;
int var_32;
ovlData3Struct *pScript;
// char* arrayRelocGlob;
// char* namePtr;
// char* arrayMsgRelHeader;
if (!overlayTable[ovlIdx].ovlData)
return (-4);
ovlData = overlayTable[ovlIdx].ovlData;
numData3 = ovlData->numProc;
size5 = ovlData->numRel;
numRelocGlob = ovlData->numRelocGlob;
param = 0;
// do it for the 2 first string types
do {
int i = 0;
if (param == 0) {
var_32 = numData3;
} else {
var_32 = size5;
}
if (var_32) {
do {
importScriptStruct *ptrImportData;
const char *ptrImportName;
uint8 *ptrData;
int var_22 = 0;
if (param == 0) {
pScript = getOvlData3Entry(ovlIdx, i);
} else {
pScript = scriptFunc1Sub2(ovlIdx, i);
}
ptrImportData = (importScriptStruct *)(pScript->dataPtr + pScript->offsetToImportData); // import data
ptrImportName = (const char*)(pScript->dataPtr + pScript->offsetToImportName); // import name
ptrData = pScript->dataPtr;
var_22 = 0;
if (pScript->numRelocGlob > 0) {
int counter = pScript->numRelocGlob;
do {
int param2 = ptrImportData->type;
if (param2 != 70) {
exportEntryStruct * ptrDest2;
int out1;
int out2;
strcpy(buffer, ptrImportName + ptrImportData->offsetToName);
ptrDest2 = parseExport(&out1, &out2, buffer);
if (ptrDest2 && out2) {
int temp =
ptrImportData->
offset;
if (out1) { //is sub function... (ie 'invent.livre:s')
uint8 *ptr = ptrData + temp;
*(ptr + 1) = out2;
WRITE_BE_UINT16(ptr + 2, ptrDest2->idx);
} else {
if (param2 == 20 || param2 == 30 || param2 == 40 || param2 == 50) { // this patch a double push
uint8 *ptr = ptrData + temp;
*(ptr + 1) = 0;
*(ptr + 2) = out2; // update the overlay number
WRITE_BE_UINT16(ptr + 4, ptrDest2->idx);
} else {
int var_4 = ptrDest2->var4;
if (var_4 & 1) {
param2 = 8;
} else {
param2 = 16;
}
if (var_4 >= 0 && var_4 <= 3) {
param2 |= 5;
} else {
param2 |= 6;
}
*(ptrData + temp) = param2;
*(ptrData + temp + 1) = out2;
WRITE_BE_UINT16(ptrData + temp + 2, ptrDest2->idx);
}
}
}
}
ptrImportData++;
} while (--counter);
}
} while (++i < var_32);
}
} while (++param < 2);
if (ovlData->arrayRelocGlob && ovlData->arrayNameRelocGlob && numRelocGlob) {
int numImport2 = numRelocGlob;
int i;
for (i = 0; i < numImport2; i++) {
int out1;
int foundExportIdx;
exportEntryStruct *pFoundExport;
int linkType;
int linkEntryIdx;
strcpy(buffer, ovlData->arrayNameRelocGlob + ovlData->arrayRelocGlob[i].nameOffset);
pFoundExport = parseExport(&out1, &foundExportIdx, buffer);
linkType = ovlData->arrayRelocGlob[i].linkType;
linkEntryIdx = ovlData->arrayRelocGlob[i].linkIdx;
if (pFoundExport && foundExportIdx) {
switch (linkType) {
case 0: { // verb
ovlData->arrayMsgRelHeader[linkEntryIdx].verbOverlay = foundExportIdx;
ovlData->arrayMsgRelHeader[linkEntryIdx].verbNumber = pFoundExport->idx;
break;
}
case 1: { // obj1
ovlData->arrayMsgRelHeader[linkEntryIdx].obj1Overlay = foundExportIdx;
ovlData->arrayMsgRelHeader[linkEntryIdx].obj1Number = pFoundExport->idx;
break;
}
case 2: { // obj2
ovlData->arrayMsgRelHeader[linkEntryIdx].obj2Overlay = foundExportIdx;
ovlData->arrayMsgRelHeader[linkEntryIdx].obj2Number = pFoundExport->idx;
break;
}
}
}
}
}
return (0);
}
