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); }