void UciEngine::parseLine(const QString& line) { const QStringRef command(firstToken(line)); if (command == "info") { parseInfo(command); } else if (command == "bestmove") { if (state() != Thinking) { if (state() == FinishingGame) pong(); else qDebug() << "Unexpected move from" << name(); return; } QString moveString(nextToken(command).toString()); m_moveStrings += " " + moveString; Chess::Move move = board()->moveFromString(moveString); if (!move.isNull()) emitMove(move); else forfeit(Chess::Result::IllegalMove, moveString); } else if (command == "readyok") { pong(); } else if (command == "uciok") { if (state() == Starting) { onProtocolStart(); ping(); } } else if (command == "id") { QStringRef tag(nextToken(command)); if (tag == "name" && name() == "UciEngine") setName(nextToken(tag, true).toString()); } else if (command == "registration") { if (nextToken(command) == "error") { qDebug("Failed to register UCI engine %s", qPrintable(name())); write("register later"); } } else if (command == "option") { EngineOption* option = parseOption(command); QString variant; if (option == 0 || !option->isValid()) qDebug("Invalid UCI option from %s: %s", qPrintable(name()), qPrintable(line)); else if (!(variant = variantFromUci(option->name())).isEmpty()) addVariant(variant); else if (option->name() == "UCI_Opponent") m_sendOpponentsName = true; else if (option->name() == "Ponder" || (option->name().startsWith("UCI_") && option->name() != "UCI_LimitStrength" && option->name() != "UCI_Elo")) { // TODO: Deal with UCI features } else { addOption(option); return; } delete option; } }
Ret_t buildMetInfMemCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { XltDecScannerPtr_t pScanner; SmlMetInfMemPtr_t pMem; Ret_t rc; pScanner = pDecoder->scanner; if (*ppElem != NULL) return SML_ERR_XLT_INVAL_SYNCML_DOC; if ((pMem = (SmlMetInfMemPtr_t)smlLibMalloc(sizeof(SmlMetInfMem_t))) == NULL) return SML_ERR_NOT_ENOUGH_SPACE; smlLibMemset(pMem, 0, sizeof(SmlMetInfMem_t)); if (IS_EMPTY(pScanner->curtok)) { *ppElem = pMem; return SML_ERR_OK; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeMetinfMem(pMem); //smlLibFree(pMem); return rc; } while (pScanner->curtok->type != TOK_TAG_END) { switch (pScanner->curtok->tagid) { /* %%% luz 2005-08-24 :this definition was plain wrong - shared is a flag, not Pcdata! case TN_METINF_SHAREDMEM: rc = buildPCData(pDecoder, (VoidPtr_t)&pMem->shared); break; */ /* PCDATA elements */ case TN_METINF_FREEMEM: rc = buildPCData(pDecoder, (VoidPtr_t)&pMem->free); break; case TN_METINF_FREEID: rc = buildPCData(pDecoder, (VoidPtr_t)&pMem->freeid); break; /* flags */ case TN_METINF_SHAREDMEM: pMem->flags |= SmlMetInfSharedMem_f; rc = buildEmptyTag(pDecoder); // allow for <tag></tag> instead of <tag/> break; default: rc = SML_ERR_XLT_INVAL_SYNCML_DOC; } if (rc != SML_ERR_OK) { smlFreeMetinfMem(pMem); //smlLibFree(pMem); return rc; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeMetinfMem(pMem); //smlLibFree(pMem); return rc; } } *ppElem = pMem; return SML_ERR_OK; }
TokenTyp MODULE::parseOptPar(QMap<std::string, Occurence> *nameOptPar) { if (nameOptPar->isEmpty()) return nextToken(); else { TokenTyp token = nextToken(); while (token == BlockBegin || token == Keyword) { //Nodes if (token == BlockBegin) { token = this->nextToken(); if (token == Keyword) { std::string lexem = lex->getLexem(); if (factoryOptNode->contains(lexem)) { if (this->occOptPar->value(lexem) == ZeroOrOne) { this->occOptPar->insert(lexem, Zero); Node *instance = factoryOptNode->value(lexem)->createInstance(this); this->addChildNode(instance); token = nextToken(); } else if (this->occOptPar->value(lexem) == ZeroOrMore) { Node *instance; if (lexem == "CHARACTERISTIC") { if (!this->isChild("CHARACTERISTIC")) { Node *Char = new Node(this, this->lex, this->errorList); Char->name = (char*)"CHARACTERISTIC"; this->addChildNode(Char); //Char->_pixmap = ":/icones/CHAR.bmp"; Char->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("CHARACTERISTIC", false)); child("CHARACTERISTIC", false)->addChildNode(instance); listChar.append(instance->name); } else if (lexem == "AXIS_PTS") { if (!this->isChild("AXIS_PTS")) { Node *Axis = new Node(this, this->lex, this->errorList); Axis->name = (char*)"AXIS_PTS"; this->addChildNode(Axis); //Axis->_pixmap = ":/icones/AXIS.bmp"; Axis->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("AXIS_PTS", false)); child("AXIS_PTS", false)->addChildNode(instance); listChar.append(instance->name); } else if (lexem == "MEASUREMENT") { if (!this->isChild("MEASUREMENT")) { Node *Meas = new Node(this, this->lex, this->errorList); Meas->name = (char*)"MEASUREMENT"; this->addChildNode(Meas); //Meas->_pixmap = ":/icones/MEAS.bmp"; Meas->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("MEASUREMENT", false)); child("MEASUREMENT", false)->addChildNode(instance); } else if (lexem == "FUNCTION") { if (!this->isChild("FUNCTION")) { Node *Func = new Node(this, this->lex, this->errorList); Func->name = (char*)"FUNCTION"; this->addChildNode(Func); //Func->_pixmap = ":/icones/FUNCTION.bmp"; Func->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("FUNCTION", false)); child("FUNCTION", false)->addChildNode(instance); } else if (lexem == "GROUP") { if (!this->isChild("GROUP")) { Node *Grp = new Node(this, this->lex, this->errorList); Grp->name = (char*)"GROUP"; this->addChildNode(Grp); //Func->_pixmap = ":/icones/FUNCTION.bmp"; Grp->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("GROUP", false)); child("GROUP", false)->addChildNode(instance); } else if (lexem == "UNIT") { if (!this->isChild("UNIT")) { Node *Grp = new Node(this, this->lex, this->errorList); Grp->name = (char*)"UNIT"; this->addChildNode(Grp); //Func->_pixmap = ":/icones/FUNCTION.bmp"; Grp->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("UNIT", false)); child("UNIT", false)->addChildNode(instance); } else if (lexem == "COMPU_METHOD") { if (!this->isChild("COMPU_METHOD")) { Node *Comp_m = new Node(this, this->lex, this->errorList); Comp_m->name = (char*)"COMPU_METHOD"; this->addChildNode(Comp_m); //Comp_m->_pixmap = ":/icones/COMPU_METHOD.bmp"; Comp_m->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("COMPU_METHOD", false)); child("COMPU_METHOD", false)->addChildNode(instance); } else if (lexem == "COMPU_VTAB") { if (!this->isChild("COMPU_VTAB")) { Node *Comp_v = new Node(this, this->lex, this->errorList); Comp_v->name = (char*)"COMPU_VTAB"; this->addChildNode(Comp_v); //Comp_v->_pixmap = ":/icones/COMPU_VTAB.bmp"; Comp_v->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("COMPU_VTAB", false)); child("COMPU_VTAB", false)->addChildNode(instance); } else if (lexem == "RECORD_LAYOUT") { if (!this->isChild("RECORD_LAYOUT")) { Node *Rec = new Node(this, this->lex, this->errorList); Rec->name = (char*)"RECORD_LAYOUT"; this->addChildNode(Rec); //Rec->_pixmap = ":/icones/CONV.bmp"; Rec->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("RECORD_LAYOUT", false)); child("RECORD_LAYOUT", false)->addChildNode(instance); } else if (lexem == "IF_DATA") { if (!isChild("IF_DATA")) { Node *If_data = new Node(this, this->lex, this->errorList); If_data->name = (char*)"IF_DATA"; this->addChildNode(If_data); //If_data->_pixmap = ":/icones/MOD_PAR.bmp"; If_data->_pixmap = ""; } instance = factoryOptNode->value(lexem)->createInstance(child("IF_DATA", false)); child("IF_DATA", false)->addChildNode(instance); } else { instance = factoryOptNode->value(lexem)->createInstance(this); this->addChildNode(instance); } token = nextToken(); } else { QString s(lexem.c_str()); this->showError(" Keyword : " + s + " can only be once declared"); return token; } } else { QString s(lexem.c_str()); this->showError("unknown Keyword : " + s); return token; } } else { QString s(lex->toString(token).c_str()); this->showError("expected token : BlockBegin or Keyword\nfind token : " + s); return token; } } //Items else if (token == Keyword) { std::string lexem = lex->getLexem(); if (factoryOptItem->contains(lexem)) { if (this->occOptPar->value(lexem) == ZeroOrOne) { this->occOptPar->insert(lexem, Zero); Item *instance = factoryOptItem->value(lexem)->createInstance(this); this->addOptItem(instance); token = nextToken(); } else if (this->occOptPar->value(lexem) == ZeroOrMore) { Item *instance = factoryOptItem->value(lexem)->createInstance(this); this->addOptItem(instance); token = nextToken(); } else { QString s(lexem.c_str()); this->showError(" Keyword : " + s + " can only be once declared"); return token; } } else { QString s(lexem.c_str()); this->showError("unknown Keyword : " + s); return token; } } } return token; } }
bool parse() { nextToken(); return parseXmlStream(); }
// printStartQuery - prints the hit void SpectraSTTxtSearchOutput::printHit(string query, unsigned int hitRank, SpectraSTLibEntry* entry, SpectraSTSimScores& simScores) { if (!entry) { (*m_fout).width(4); (*m_fout) << "0"; (*m_fout).width(MAX_NAME_LEN); (*m_fout) << left << "NO_MATCH"; (*m_fout) << endl; return; } if (hitRank > 1) { (*m_fout).width(MAX_NAME_LEN); (*m_fout) << left << "--"; } (*m_fout).width(4); (*m_fout) << left << hitRank; stringstream peptidess; peptidess << entry->getName(); (*m_fout).width(MAX_NAME_LEN); (*m_fout) << left << peptidess.str(); simScores.printFixedWidth((*m_fout)); (*m_fout).width(10); (*m_fout) << left << entry->getStatus(); (*m_fout).width(10); string inst(""); if (entry->getOneComment("Inst", inst)) { (*m_fout) << left << inst; } else { (*m_fout) << left << "Unk"; } (*m_fout).width(6); string spectrumType(""); if (entry->getOneComment("Spec", spectrumType)) { (*m_fout) << left << spectrumType.substr(0, spectrumType.length() < 3 ? spectrumType.length() : 3); } else { (*m_fout) << left << "Unk"; } (*m_fout).width(20); (*m_fout) << left << entry->getLibFileOffset(); string protein(""); stringstream proteinss; string sample(""); string::size_type pos = 0; if (entry->getOneComment("Protein", protein)) { if (protein.find('/') != string::npos) { int proteinCount = atoi(nextToken(protein, 0, pos, "/\t\r\n").c_str()); proteinss << proteinCount << ':'; bool isFirstProtein = true; while (pos < protein.length()) { if (!isFirstProtein) proteinss << ';'; proteinss << nextToken(protein, pos, pos, "/\t\r\n", "/"); isFirstProtein = false; } } else { proteinss << '1' << ':' << protein; } } else if (entry->getOneComment("Sample", sample)) { // if no protein field is given, use the sample field. (this is useful for unidentified spectra) if (sample.find('/') != string::npos) { int sampleCount = atoi(nextToken(sample, 0, pos, "/\t\r\n").c_str()); proteinss << sampleCount << ':'; bool isFirstSample = true; while (pos < sample.length()) { if (!isFirstSample) proteinss << ';'; proteinss << nextToken(sample, pos, pos, "/\t\r\n", "/"); isFirstSample = false; } } } else { proteinss << '0'; } (*m_fout) << proteinss.str(); (*m_fout) << endl; }
CAssemblerCommand* Parser::parseMacroCall() { const Token& start = peekToken(); if (start.type != TokenType::Identifier) return nullptr; auto it = macros.find(start.getStringValue()); if (it == macros.end()) return nullptr; ParserMacro& macro = it->second; eatToken(); // create a token stream for the macro content, // registering replacements for parameter values TokenStreamTokenizer macroTokenizer; std::set<std::wstring> identifierParameters; for (size_t i = 0; i < macro.parameters.size(); i++) { if (i != 0) { if (nextToken().type != TokenType::Comma) return nullptr; } if (i == macro.parameters.size()) { size_t count = macro.parameters.size(); while (peekToken().type == TokenType::Comma) { eatToken(); parseExpression(); } printError(start,L"Not enough macro arguments (%d vs %d)",count,macro.parameters.size()); return nullptr; } TokenizerPosition startPos = getTokenizer()->getPosition(); Expression exp = parseExpression(); if (exp.isLoaded() == false) return nullptr; TokenizerPosition endPos = getTokenizer()->getPosition(); std::vector<Token> tokens = getTokenizer()->getTokens(startPos,endPos); // remember any single identifier parameters for the label replacement if (tokens.size() == 1 && tokens[0].type == TokenType::Identifier) identifierParameters.insert(tokens[0].getStringValue()); // give them as a replacement to new tokenizer macroTokenizer.registerReplacement(macro.parameters[i],tokens); } if (peekToken().type == TokenType::Comma) { size_t count = macro.parameters.size(); while (peekToken().type == TokenType::Comma) { eatToken(); parseExpression(); count++; } printError(start,L"Too many macro arguments (%d vs %d)",count,macro.parameters.size()); return nullptr; } // a macro is fully parsed once when it's loaded // to gather all labels. it's not necessary to // instantiate other macros at that time if (initializingMacro) return new DummyCommand(); // the first time a macro is instantiated, it needs to be analyzed // for labels if (macro.counter == 0) { initializingMacro = true; // parse the short lived next command macroTokenizer.init(macro.content); CAssemblerCommand* command = parse(¯oTokenizer,true); delete command; macro.labels = macroLabels; macroLabels.clear(); initializingMacro = false; } // register labels and replacements for (const std::wstring& label: macro.labels) { // check if the label is using the name of a parameter // in that case, don't register a unique replacement if (identifierParameters.find(label) != identifierParameters.end()) continue; // otherwise make sure the name is unique std::wstring fullName; if (Global.symbolTable.isLocalSymbol(label)) fullName = formatString(L"@@%s_%s_%08X",macro.name,label.substr(2),macro.counter); else if (Global.symbolTable.isStaticSymbol(label)) fullName = formatString(L"@%s_%s_%08X",macro.name,label.substr(1),macro.counter); else fullName = formatString(L"%s_%s_%08X",macro.name,label,macro.counter); macroTokenizer.registerReplacement(label,fullName); } macroTokenizer.init(macro.content); macro.counter++; return parse(¯oTokenizer,true); }
TokenTyp UNIT::parseOptPar(QMap<std::string, Occurence> *nameOptPar) { if (nameOptPar->isEmpty()) return nextToken(); else { TokenTyp token = nextToken(); while (token == BlockBegin || token == Keyword) { //Nodes if (token == BlockBegin) { token = this->nextToken(); if (token == Keyword) { std::string lexem = lex->getLexem(); if (factoryOptNode->contains(lexem)) { if (this->occOptPar->value(lexem) == ZeroOrOne) { this->occOptPar->insert(lexem, Zero); Node *instance = factoryOptNode->value(lexem)->createInstance( this); this->addChildNode(instance); token = nextToken(); } else if (this->occOptPar->value(lexem) == ZeroOrMore) { Node *instance = factoryOptNode->value(lexem)->createInstance( this); this->addChildNode(instance); token = nextToken(); } else { QString s(lexem.c_str()); this->showError(" Keyword : " + s + " can only be once declared"); return token; } } else { QString s(lexem.c_str()); this->showError("unknown Keyword : " + s ); return token; } } else { QString s(lex->toString(token).c_str()); this->showError("expected token : BlockBegin or Keyword\nfind token : " + s ); return token; } } //Items else if (token == Keyword) { std::string lexem = lex->getLexem(); if (factoryOptItem->contains(lexem)) { if (this->occOptPar->value(lexem) == ZeroOrOne) { this->occOptPar->insert(lexem, Zero); Item *instance = factoryOptItem->value(lexem)->createInstance( this); this->addOptItem(instance); token = nextToken(); } else if (this->occOptPar->value(lexem) == ZeroOrMore) { Item *instance = factoryOptItem->value(lexem)->createInstance( this); this->addOptItem(instance); token = nextToken(); } else { QString s(lexem.c_str()); this->showError(" Keyword : " + s + " can only be once declared"); return token; } } else { QString s(lexem.c_str()); this->showError("unknown Keyword : " + s ); return token; } } } return token; } }
/* decoder callbacks */ Ret_t buildDmTndDFElementCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { XltDecScannerPtr_t pScanner; SmlDmTndDFElementPtr_t pDmTndDFElement; Ret_t rc; pScanner = pDecoder->scanner; if (*ppElem != NULL) return SML_ERR_XLT_INVAL_SYNCML_DOC; if ((pDmTndDFElement = (SmlDmTndDFElementPtr_t)smlLibMalloc(sizeof(SmlDmTndDFElement_t))) == NULL) return SML_ERR_NOT_ENOUGH_SPACE; smlLibMemset(pDmTndDFElement, 0, sizeof(SmlDmTndDFElement_t)); if (IS_EMPTY(pScanner->curtok)) { *ppElem = pDmTndDFElement; return SML_ERR_OK; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeDmTndDFElement(pDmTndDFElement); return rc; } while (pScanner->curtok->type != TOK_TAG_END) { VoidPtr_t pContent = smlLibMalloc(10); if ( pContent == NULL ) { smlFreeDmTndDFElement(pDmTndDFElement); return SML_ERR_NOT_ENOUGH_SPACE; } smlLibMemset(pContent, 0, 10); switch (pScanner->curtok->tagid) { /* AccessType Elements */ case TN_DMTND_Add: smlLibStrcpy(pContent, "Add"); break; case TN_DMTND_Copy: smlLibStrcpy(pContent, "Copy"); break; case TN_DMTND_Delete: smlLibStrcpy(pContent, "Delete"); break; case TN_DMTND_Exec: smlLibStrcpy(pContent, "Exec"); break; case TN_DMTND_Get: smlLibStrcpy(pContent, "Get"); break; case TN_DMTND_Replace: smlLibStrcpy(pContent, "Replace"); break; /* Occurrence Elements */ case TN_DMTND_One: smlLibStrcpy(pContent, "One"); break; case TN_DMTND_ZeroOrOne: smlLibStrcpy(pContent, "ZeroOrOne"); break; case TN_DMTND_ZeroOrMore: smlLibStrcpy(pContent, "ZeroOrMore"); break; case TN_DMTND_OneOrMore: smlLibStrcpy(pContent, "OneOrMore"); break; case TN_DMTND_ZeroOrN: smlLibStrcpy(pContent, "ZeroOrN"); break; case TN_DMTND_OneOrN: smlLibStrcpy(pContent, "OneOrN"); break; /* Scope Elements */ case TN_DMTND_Permanent: smlLibStrcpy(pContent, "Permanent"); break; case TN_DMTND_Dynamic: smlLibStrcpy(pContent, "Dynamic"); break; /* CaseSense Elements */ case TN_DMTND_CS: smlLibStrcpy(pContent, "CS"); break; case TN_DMTND_CIS: smlLibStrcpy(pContent, "CIS"); break; default: KCDBG(">>>>> buildDmTndDFElementCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid); rc = SML_ERR_XLT_INVAL_SYNCML_DOC; } if (rc != SML_ERR_OK) { smlFreeDmTndDFElement(pDmTndDFElement); return rc; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeDmTndDFElement(pDmTndDFElement); return rc; } if (pScanner->curtok->type != TOK_TAG_END) { smlFreeDmTndDFElement(pDmTndDFElement); return SML_ERR_XLT_INVAL_SYNCML_DOC; } } *ppElem = pDmTndDFElement; return SML_ERR_OK; }
/* decoder callbacks */ Ret_t buildDmTndRTPropsCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { XltDecScannerPtr_t pScanner; SmlDmTndRTPropsPtr_t pDmTndRTProps; Ret_t rc; pScanner = pDecoder->scanner; if (*ppElem != NULL) return SML_ERR_XLT_INVAL_SYNCML_DOC; if ((pDmTndRTProps = (SmlDmTndRTPropsPtr_t)smlLibMalloc(sizeof(SmlDmTndRTProps_t))) == NULL) return SML_ERR_NOT_ENOUGH_SPACE; smlLibMemset(pDmTndRTProps, 0, sizeof(SmlDmTndRTProps_t)); if (IS_EMPTY(pScanner->curtok)) { *ppElem = pDmTndRTProps; return SML_ERR_OK; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeDmTndRTProps(pDmTndRTProps); return rc; } while (pScanner->curtok->type != TOK_TAG_END) { switch (pScanner->curtok->tagid) { case TN_DMTND_ACL: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->acl); break; case TN_DMTND_Format: rc = buildDmTndFormatCmd(pDecoder, (VoidPtr_t)&pDmTndRTProps->format); break; case TN_DMTND_Name: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->name); break; case TN_DMTND_Size: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->size); break; case TN_DMTND_Title: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->title); break; case TN_DMTND_TStamp: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->tstamp); break; case TN_DMTND_Type: rc = buildDmTndTypeCmd(pDecoder, (VoidPtr_t)&pDmTndRTProps->type); break; case TN_DMTND_VerNo: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndRTProps->verno); break; default: KCDBG(">>>>> buildDmTndRTPropsCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid); rc = SML_ERR_XLT_INVAL_SYNCML_DOC; } if (rc != SML_ERR_OK) { smlFreeDmTndRTProps(pDmTndRTProps); return rc; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeDmTndRTProps(pDmTndRTProps); return rc; } } *ppElem = pDmTndRTProps; return SML_ERR_OK; }
void DebugCLI::set() { const char* what = nextToken(); const char* equ = nextToken(); const char* to = nextToken(); if (!to || !equ || !what || *equ != '=') { core->console << " Bad format, should be: 'set {variable} = {value}' "; } else { // look for the varable in our locals or args. Atom* ptr; int count, line; SourceInfo* src; DebugFrame* frame = core->debugger->frameAt(0); // source information frame->sourceLocation(src, line); if (!src) { core->console << "Unable to locate debug information for current source file, so no local or argument names known"; return; } // method MethodInfo* info = functionFor(src, line); if (!info) { core->console << "Unable to find method debug information, so no local or argument names known"; return; } frame->arguments(ptr, count); for(int i=0; i<count; i++) { Stringp arg = info->getArgName(i); if (arg->Equals(what)) { // match! Atom a = ease2Atom(to, ptr[i]); if (a == undefinedAtom) core->console << " Type mismatch : current value is " << core->format(ptr[i]); else frame->setArgument(i, a); return; } } frame->locals(ptr, count); for(int i=0; i<count; i++) { Stringp local = info->getLocalName(i); if ( local->Equals(what)) { // match! Atom a = ease2Atom(to, ptr[i]); if (a == undefinedAtom) core->console << " Type mismatch : current value is " << core->format(ptr[i]); else frame->setLocal(i, a); return; } } } }
void DebugCLI::enterDebugger() { setCurrentSource( (core->callStack) ? (core->callStack->filename()) : 0 ); if (currentSource == NULL) { stepInto(); return; } for (;;) { printIP(); core->console << "(asdb) "; fflush(stdout); fgets(commandLine, kMaxCommandLine, stdin); commandLine[strlen(commandLine)-1] = 0; if (!commandLine[0]) { strcpy(commandLine, lastCommand); } else { strcpy(lastCommand, commandLine); } currentToken = commandLine; char *command = nextToken(); int cmd = commandFor(command); switch (cmd) { case -1: // ambiguous, we already printed error message break; case CMD_INFO: info(); break; case CMD_BREAK: breakpoint(nextToken()); break; case CMD_DELETE: deleteBreakpoint(nextToken()); break; case CMD_LIST: list(nextToken()); break; case CMD_UNKNOWN: core->console << "Unknown command.\n"; break; case CMD_QUIT: exit(0); break; case CMD_CONTINUE: return; case CMD_PRINT: print(nextToken()); break; case CMD_NEXT: stepOver(); return; case INFO_STACK_CMD: bt(); break; case CMD_FINISH: stepOut(); return; case CMD_STEP: stepInto(); return; case CMD_SET: set(); break; default: core->console << "Command not implemented.\n"; break; } } }
QStringRef ChessEngine::firstToken(const QString& str, bool untilEnd) { return nextToken(QStringRef(&str, 0, 0), untilEnd); }
void TokenStream::expectToken(Token& t, TokenType type) { nextToken(t); if (t.type != type) { throw TokenExpectError(type,t); } }
MyPluralFormsScanner::MyPluralFormsScanner(const char* s) : m_s(s) { nextToken(); }
bool UnwrappedLineParser::tryToParseLambdaIntroducer() { nextToken(); if (FormatTok->is(tok::equal)) { nextToken(); if (FormatTok->is(tok::r_square)) { nextToken(); return true; } if (FormatTok->isNot(tok::comma)) return false; nextToken(); } else if (FormatTok->is(tok::amp)) { nextToken(); if (FormatTok->is(tok::r_square)) { nextToken(); return true; } if (!FormatTok->isOneOf(tok::comma, tok::identifier)) { return false; } if (FormatTok->is(tok::comma)) nextToken(); } else if (FormatTok->is(tok::r_square)) { nextToken(); return true; } do { if (FormatTok->is(tok::amp)) nextToken(); if (!FormatTok->isOneOf(tok::identifier, tok::kw_this)) return false; nextToken(); if (FormatTok->is(tok::comma)) { nextToken(); } else if (FormatTok->is(tok::r_square)) { nextToken(); return true; } else { return false; } } while (!eof()); return false; }
/* decoder callbacks */ Ret_t buildDmTndDFPropsCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { XltDecScannerPtr_t pScanner; SmlDmTndDFPropsPtr_t pDmTndDFProps; Ret_t rc = SML_ERR_OK; pScanner = pDecoder->scanner; if (*ppElem != NULL) return SML_ERR_XLT_INVAL_SYNCML_DOC; if ((pDmTndDFProps = (SmlDmTndDFPropsPtr_t)smlLibMalloc(sizeof(SmlDmTndDFProps_t))) == NULL) return SML_ERR_NOT_ENOUGH_SPACE; smlLibMemset(pDmTndDFProps, 0, sizeof(SmlDmTndDFProps_t)); if (IS_EMPTY(pScanner->curtok)) { *ppElem = pDmTndDFProps; return SML_ERR_OK; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeDmTndDFProps(pDmTndDFProps); return rc; } while (pScanner->curtok->type != TOK_TAG_END) { switch (pScanner->curtok->tagid) { case TN_DMTND_AccessType: rc = buildDmTndDFElementCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->accesstype); break; case TN_DMTND_DefaultValue: rc = buildDmTndFormatCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->defaultvalue); break; case TN_DMTND_Description: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndDFProps->description); break; case TN_DMTND_DFFormat: rc = buildDmTndFormatCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->dfformat); break; case TN_DMTND_Occurrence: rc = buildDmTndDFElementCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->occurrence); break; case TN_DMTND_Scope: rc = buildDmTndDFElementCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->scope); break; case TN_DMTND_DFTitle: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndDFProps->dftitle); break; case TN_DMTND_DFType: rc = buildDmTndTypeCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->dftype); break; case TN_DMTND_CaseSense: rc = buildDmTndDFElementCmd(pDecoder, (VoidPtr_t)&pDmTndDFProps->casesense); break; default: KCDBG(">>>>> buildDmTndDFPropsCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid); rc = SML_ERR_XLT_INVAL_SYNCML_DOC; } if (rc != SML_ERR_OK) { smlFreeDmTndDFProps(pDmTndDFProps); return rc; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeDmTndDFProps(pDmTndDFProps); return rc; } } *ppElem = pDmTndDFProps; return SML_ERR_OK; }
bool Parser::checkMacroDefinition() { const Token& first = peekToken(); if (first.type != TokenType::Identifier) return false; if (!first.stringValueStartsWith(L'.') || first.getStringValue() != L".macro") return false; eatToken(); // nested macro definitions are not allowed if (initializingMacro) { printError(first,L"Nested macro definitions not allowed"); while (!atEnd()) { const Token& token = nextToken(); if (token.type == TokenType::Identifier && token.getStringValue() == L".endmacro") break; } return true; } std::vector<Expression> parameters; if (parseExpressionList(parameters,1,-1) == false) return false; // load name std::wstring macroName; if (parameters[0].evaluateIdentifier(macroName) == false) return false; // duplicate check the macro ParserMacro ¯o = macros[macroName]; if (macro.name.length() != 0) { printError(first,L"Macro \"%s\" already defined",macro.name); return false; } // and register it macro.name = macroName; macro.counter = 0; // load parameters for (size_t i = 1; i < parameters.size(); i++) { std::wstring name; if (parameters[i].evaluateIdentifier(name) == false) return false; macro.parameters.push_back(name); } // load macro content TokenizerPosition start = getTokenizer()->getPosition(); bool valid = false; while (atEnd() == false) { const Token& tok = nextToken(); if (tok.type == TokenType::Identifier && tok.getStringValue() == L".endmacro") { valid = true; break; } } // no .endmacro, not valid if (valid == false) return true; // get content TokenizerPosition end = getTokenizer()->getPosition().previous(); macro.content = getTokenizer()->getTokens(start,end); return true; }
/* decoder callbacks */ Ret_t buildDmTndNodeCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { XltDecScannerPtr_t pScanner; SmlDmTndNodePtr_t pDmTndNode; Ret_t rc; pScanner = pDecoder->scanner; if (*ppElem != NULL) return SML_ERR_XLT_INVAL_SYNCML_DOC; if ((pDmTndNode = (SmlDmTndNodePtr_t)smlLibMalloc(sizeof(SmlDmTndNode_t))) == NULL) return SML_ERR_NOT_ENOUGH_SPACE; smlLibMemset(pDmTndNode, 0, sizeof(SmlDmTndNode_t)); if (IS_EMPTY(pScanner->curtok)) { *ppElem = pDmTndNode; return SML_ERR_OK; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeDmTndNode(pDmTndNode); return rc; } while (pScanner->curtok->type != TOK_TAG_END) { switch (pScanner->curtok->tagid) { case TN_DMTND_NodeName: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndNode->nodename); break; case TN_DMTND_Path: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndNode->path); break; case TN_DMTND_RTProperties: rc = buildDmTndRTPropsCmd(pDecoder, (VoidPtr_t)&pDmTndNode->rtprops); break; case TN_DMTND_DFProperties: rc = buildDmTndDFPropsCmd(pDecoder, (VoidPtr_t)&pDmTndNode->dfprops); break; case TN_DMTND_Value: rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndNode->value); break; case TN_DMTND_Node: rc = buildDmTndNodeList(pDecoder, (VoidPtr_t)&pDmTndNode->nodelist); break; default: KCDBG(">>>>> buildDmTndDFPropsCmd: Unkown token: %d <<<<<\n", pScanner->curtok->tagid); rc = SML_ERR_XLT_INVAL_SYNCML_DOC; } if (rc != SML_ERR_OK) { if ( NULL != pDmTndNode->nodename && NULL != pDmTndNode->nodename->content ) { KCDBG(">>>>> buildDmTndDFPropsCmd: Node %s corrupted <<<<<\n", (char *)pDmTndNode->nodename->content); } smlFreeDmTndNode(pDmTndNode); return rc; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeDmTndNode(pDmTndNode); return rc; } } *ppElem = pDmTndNode; return SML_ERR_OK; }
struct token nextToken(){ short gotword = 0; short fileEnd = 0; char c; if(feof(fp)){ fileEnd = 1; gotword=1; } else { c = fgetc(fp); switch(c){ case ' ': case '\r': case '\n': gotword = 1; break; default : name[name_length]=c; current_column++; name_length++; } } struct token t; if(gotword==1){ if(name_length>0){ if(name_length==2&&name[0]=='i'&&name[1]=='f'){ t.k = IF; char lexeme[256]; lexeme[0]='i'; lexeme[1]='f'; lexeme[2]=0; t.lexeme = lexeme; t.line = current_line; t.column = current_column-name_length; name_length=0; } else { t.k = ID; char lexeme[256]; short isNumber = 1; for(int i=0;i<name_length;i++){ lexeme[i] = name[i]; if (name[i]<'0'||name[i]>'9') { isNumber=0; } } if(isNumber==1){ t.k=NUMBER; } lexeme[name_length]=0; t.lexeme = lexeme; t.line = current_line; t.column = current_column-name_length; name_length = 0; } } else { t = nextToken(); } switch(c){ case ' ': current_column++; break; case '\r': case '\n': if(lastChar!='\r'&&lastChar!='\n'){ current_line++; current_column=0; } break; } lastChar = c; return t; } else { t = nextToken(); return t; } }
/* decoder callbacks */ Ret_t buildDmTndFormatCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { XltDecScannerPtr_t pScanner; SmlDmTndFormatPtr_t pDmTndFormat; Ret_t rc; pScanner = pDecoder->scanner; if (*ppElem != NULL) return SML_ERR_XLT_INVAL_SYNCML_DOC; if ((pDmTndFormat = (SmlDmTndFormatPtr_t)smlLibMalloc(sizeof(SmlDmTndFormat_t))) == NULL) return SML_ERR_NOT_ENOUGH_SPACE; smlLibMemset(pDmTndFormat, 0, sizeof(SmlDmTndFormat_t)); if (IS_EMPTY(pScanner->curtok)) { *ppElem = pDmTndFormat; return SML_ERR_OK; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeDmTndFormat(pDmTndFormat); return rc; } while (pScanner->curtok->type != TOK_TAG_END) { VoidPtr_t pContent = smlLibMalloc(6); if ( pContent == NULL ) { smlFreeDmTndFormat(pDmTndFormat); return SML_ERR_NOT_ENOUGH_SPACE; } smlLibMemset(pContent, 0, 6); switch (pScanner->curtok->tagid) { case TN_DMTND_b64: smlLibStrcpy(pContent, "b64"); break; case TN_DMTND_bin: smlLibStrcpy(pContent, "bin"); break; case TN_DMTND_bool: smlLibStrcpy(pContent, "bool"); break; case TN_DMTND_chr: smlLibStrcpy(pContent, "chr"); break; case TN_DMTND_int: smlLibStrcpy(pContent, "int"); break; case TN_DMTND_node: smlLibStrcpy(pContent, "node"); break; case TN_DMTND_null: smlLibStrcpy(pContent, "null"); break; case TN_DMTND_xml: smlLibStrcpy(pContent, "xml"); break; case TN_DMTND_date: smlLibStrcpy(pContent, "date"); break; case TN_DMTND_time: smlLibStrcpy(pContent, "time"); break; case TN_DMTND_float: smlLibStrcpy(pContent, "float"); break; default: KCDBG(">>>>> Unkown token: %d <<<<<\n", pScanner->curtok->tagid); rc = SML_ERR_XLT_INVAL_SYNCML_DOC; } if (rc != SML_ERR_OK) { smlLibFree(pContent); smlFreeDmTndFormat(pDmTndFormat); return rc; } rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndFormat->value); if (rc != SML_ERR_OK) { smlLibFree(pContent); smlFreeDmTndFormat(pDmTndFormat); return rc; } pDmTndFormat->value->content = pContent; pDmTndFormat->value->length = smlLibStrlen(pContent); if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlLibFree(pContent); smlFreeDmTndFormat(pDmTndFormat); return rc; } if (pScanner->curtok->type != TOK_TAG_END) { smlLibFree(pContent); smlFreeDmTndFormat(pDmTndFormat); return SML_ERR_XLT_INVAL_SYNCML_DOC; } } *ppElem = pDmTndFormat; return SML_ERR_OK; }
/******************************************************************************* * Parser Definitions ******************************************************************************/ bool KAbstractHdrParserPrivate::parse() { // Initialize lexer nextChar(); if(!readExpect("#?RADIANCE\n")) { qFatal("No #?RADIANCE header, the file may be corrupt or invalid."); return false; } forceValidate(); nextToken(); // Read the Key/Value pairs for (;;) { if (peekToken() == PT_ENDOFHEADER) break; switch (nextToken()) { case PT_ERROR: qFatal("Encountered an error! Aborting"); return false; case PT_EOF: return true; case PT_KEYVALUE: m_parser->onKeyValue(m_key.c_str(), m_value.c_str()); case PT_ENDOFHEADER: break; } } // Read the data parseDimension(); parseDimension(); m_parser->onResolution(m_xOrder, m_yOrder, m_xSize, m_ySize); // Start parsing the data Rgbe color; RleCode rle; float *dest = m_parser->beginData(); int count; size_t repeat = 0; unsigned invalidCount = 0; unsigned char *scanline = new unsigned char[4 * m_xSize]; unsigned char *ptr, *end; int scanlines = 0; color = nextColor(); while (scanlines != m_ySize) { // Check for invalid color which marks RLE pixel repeat // Consecutive repeat invalid pixels increments repeat count. if (color.r == 1 && color.g == 1 && color.b == 1) { qFatal("Untested! Possibly incorrect!"); while (color.r == 1 && color.g == 1 && color.b == 1) { repeat += (color.e << (invalidCount * 8)); color = nextColor(); ++invalidCount; } while (repeat) { writeColor(dest, color); --repeat; } } // Check for invalid color which marks per-element RLE if (color.r == 2 && color.g == 2) { // Check scanline width if (((color.b << 8) | color.e) != m_xSize) { qFatal("Incorrect encoded scanline width! Expected `%d`, got `%d`", m_xSize, int((color.r << 8) | color.e)); } // Read all channels ptr = &scanline[0]; int written = 0; for (int channel = 0; channel < 4; ++channel) { end = &scanline[(channel+1)*m_xSize]; while (ptr < end) { rle = nextRle(); if (rle.run > 128) { count = int(rle.run) - 128; Q_ASSERT(count != 0); Q_ASSERT(count <= end - ptr); while (count > 0) { ++written; *ptr++ = rle.color; --count; } } else { count = int(rle.run) - 1; Q_ASSERT(count != -1); Q_ASSERT(count <= end - ptr); *ptr++ = rle.color; ++written; while (count > 0) { ++written; *ptr++ = nextChar(); --count; } } } } // Output the scanline data writeScanline(dest, scanline, scanlines); ++scanlines; } color = nextColor(); } m_parser->endData(); delete [] scanline; return false; }
static Token nextToken() { char* p; char c, q; Word[0] = EOS; p = Word; c = getchar(); if ( c < 0 ){ return Tend; } switch ( c ) { case ' ': case '\t': return nextToken(); case '\n': return Tnl; case '&': return Tamp; case ';': return Tsemi; case '<': return Tin; case '|': // could be a | or a |& ReadChar(c); if ( c == '&' ) return TpipeErr; ungetc(c, stdin); // it's a |, put back the last char return Tpipe; case '>': ReadChar(c); // could be a >, >>, or >>& if ( c == '>' ) { ReadChar(c); if ( c == '&' ) return TappErr; else { ungetc(c, stdin); // it's a >>, put back last char return Tapp; } } else if ( c == '&' ) { return ToutErr; } else { ungetc(c, stdin); // it's a >, put back last char return Tout; } break; case '\'': case '"': string: // process strings q = c; // p = Word; c = getchar(); // get chars until the matching quote character while ( c != q ) { if ( c < 0 || c == '\n' ) { // end of input before matching quote printf("Unmatched %c\n", q); return Terror; } *p++ = c; // copy char to buffer at p if ( p > Word + BUF_SIZE ) { printf("String too long (> %d bytes)\n", BUF_SIZE); while ( (c = getchar()) > 0 && c != '\n' ) ; return Terror; } c = getchar(); } *p++ = EOS; p = Word; return Tword; default: // everything else is a word // p = Word; while (1) { if ( c == '\\' ) { // strip \ from stream ReadChar(c); } *p++ = c; if ( p > Word + BUF_SIZE ) { printf("Word too long (> %d bytes)\n", BUF_SIZE); while ( (c = getchar()) > 0 && c != '\n' ) ; return Terror; } ReadChar(c); switch ( c ) { case ' ': case '\t': *p++ = EOS; return Tword; case '\n': case '&': case ';': case '<': case '|': case '>': *p++ = EOS; ungetc(c, stdin); // put back these chars for next time p = Word; // reset p return Tword; case '\'': case '\"': goto string; default: break; } } } } /*---------- End of nextToken ---------------------------------------------*/
//----------------------------------------------------------------------------- void SqlTokenizer::init() { sqlTokenEndM = sqlTokenStartM = sqlM.constData(); nextToken(); }
void UnwrappedLineParser::parseTryCatch() { assert(FormatTok->is(tok::kw_try) && "'try' expected"); nextToken(); bool NeedsUnwrappedLine = false; if (FormatTok->is(tok::colon)) { // We are in a function try block, what comes is an initializer list. nextToken(); while (FormatTok->is(tok::identifier)) { nextToken(); if (FormatTok->is(tok::l_paren)) parseParens(); else StructuralError = true; if (FormatTok->is(tok::comma)) nextToken(); } } if (FormatTok->is(tok::l_brace)) { CompoundStatementIndenter Indenter(this, Style, Line->Level); parseBlock(/*MustBeDeclaration=*/false); if (Style.BreakBeforeBraces == FormatStyle::BS_Allman || Style.BreakBeforeBraces == FormatStyle::BS_GNU || Style.BreakBeforeBraces == FormatStyle::BS_Stroustrup) { addUnwrappedLine(); } else { NeedsUnwrappedLine = true; } } else if (!FormatTok->is(tok::kw_catch)) { // The C++ standard requires a compound-statement after a try. // If there's none, we try to assume there's a structuralElement // and try to continue. StructuralError = true; addUnwrappedLine(); ++Line->Level; parseStructuralElement(); --Line->Level; } while (FormatTok->is(tok::kw_catch) || (Style.Language == FormatStyle::LK_JavaScript && FormatTok->TokenText == "finally")) { nextToken(); while (FormatTok->isNot(tok::l_brace)) { if (FormatTok->is(tok::l_paren)) { parseParens(); continue; } if (FormatTok->isOneOf(tok::semi, tok::r_brace)) return; nextToken(); } NeedsUnwrappedLine = false; CompoundStatementIndenter Indenter(this, Style, Line->Level); parseBlock(/*MustBeDeclaration=*/false); if (Style.BreakBeforeBraces == FormatStyle::BS_Allman || Style.BreakBeforeBraces == FormatStyle::BS_GNU || Style.BreakBeforeBraces == FormatStyle::BS_Stroustrup) { addUnwrappedLine(); } else { NeedsUnwrappedLine = true; } } if (NeedsUnwrappedLine) { addUnwrappedLine(); } }
void CTokenizerBase::skipToToken(const string &token){ while ( nextToken() ){ if(getToken() == token)return; } }
void UnwrappedLineParser::parsePPUnknown() { do { nextToken(); } while (!eof()); addUnwrappedLine(); }
Ret_t buildMetInfMetInfCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem) { XltDecScannerPtr_t pScanner; SmlMetInfMetInfPtr_t pMeta; Ret_t rc; int foundWrapper = 0; pScanner = pDecoder->scanner; if (*ppElem != NULL) return SML_ERR_XLT_INVAL_SYNCML_DOC; if ((pMeta = (SmlMetInfMetInfPtr_t)smlLibMalloc(sizeof(SmlMetInfMetInf_t))) == NULL) return SML_ERR_NOT_ENOUGH_SPACE; smlLibMemset(pMeta, 0, sizeof(SmlMetInfMetInf_t)); if (IS_EMPTY(pScanner->curtok)) { *ppElem = pMeta; return SML_ERR_OK; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeMetinfMetinf(pMeta); //smlLibFree(pMeta); return rc; } while (pScanner->curtok->type != TOK_TAG_END) { switch (pScanner->curtok->tagid) { case TN_METINF_METINF: /* ignore - it's just the wrapper tag */ foundWrapper = 1; break; case TN_METINF_FORMAT: rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->format); break; case TN_METINF_TYPE: rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->type); break; case TN_METINF_MARK: rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->mark); break; case TN_METINF_SIZE: rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->size); break; case TN_METINF_VERSION: rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->version); break; case TN_METINF_NEXTNONCE: rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->nextnonce); break; case TN_METINF_ANCHOR: rc = buildMetInfAnchorCmd(pDecoder, (VoidPtr_t)&pMeta->anchor); break; case TN_METINF_MAXMSGSIZE: rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->maxmsgsize); break; /* SCTSTK - 18/03/2002 S.H. 2002-04-05: SyncML 1.1 */ case TN_METINF_MAXOBJSIZE: rc = buildPCData(pDecoder, (VoidPtr_t)&pMeta->maxobjsize); break; case TN_METINF_MEM: rc = buildMetInfMemCmd(pDecoder, (VoidPtr_t)&pMeta->mem); break; case TN_METINF_EMI: rc = buildPCDataList(pDecoder, (VoidPtr_t)&pMeta->emi); break; /* SyncML DS 1.2, Synthesis/luz 2005-08-24 */ case TN_METINF_FIELDLEVEL: pMeta->flags |= SmlMetInfFieldLevel_f; rc = buildEmptyTag(pDecoder); // allow for <tag></tag> instead of <tag/> break; default: rc = SML_ERR_XLT_INVAL_SYNCML_DOC; } if (rc != SML_ERR_OK) { smlFreeMetinfMetinf(pMeta); //smlLibFree(pMeta); return rc; } if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeMetinfMetinf(pMeta); //smlLibFree(pMeta); return rc; } } if (foundWrapper) { /* Optional Metinf root tag was used in this message. * The actual token is the closing root tag. * It is required that the scanner points to the first tag _after_ * <MetInf>...</MetInf>, so we just skip to the next token and continue. */ if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) { smlFreeMetinfMetinf(pMeta); //smlLibFree(pMeta); return rc; } } *ppElem = pMeta; return SML_ERR_OK; }
void UnwrappedLineParser::parseStructuralElement() { assert(!FormatTok->Tok.is(tok::l_brace)); switch (FormatTok->Tok.getKind()) { case tok::at: nextToken(); if (FormatTok->Tok.is(tok::l_brace)) { parseBracedList(); break; } switch (FormatTok->Tok.getObjCKeywordID()) { case tok::objc_public: case tok::objc_protected: case tok::objc_package: case tok::objc_private: return parseAccessSpecifier(); case tok::objc_interface: case tok::objc_implementation: return parseObjCInterfaceOrImplementation(); case tok::objc_protocol: return parseObjCProtocol(); case tok::objc_end: return; // Handled by the caller. case tok::objc_optional: case tok::objc_required: nextToken(); addUnwrappedLine(); return; default: break; } break; case tok::kw_namespace: parseNamespace(); return; case tok::kw_inline: nextToken(); if (FormatTok->Tok.is(tok::kw_namespace)) { parseNamespace(); return; } break; case tok::kw_public: case tok::kw_protected: case tok::kw_private: parseAccessSpecifier(); return; case tok::kw_if: parseIfThenElse(); return; case tok::kw_for: case tok::kw_while: parseForOrWhileLoop(); return; case tok::kw_do: parseDoWhile(); return; case tok::kw_switch: parseSwitch(); return; case tok::kw_default: nextToken(); parseLabel(); return; case tok::kw_case: parseCaseLabel(); return; case tok::kw_try: parseTryCatch(); return; case tok::kw_extern: nextToken(); if (FormatTok->Tok.is(tok::string_literal)) { nextToken(); if (FormatTok->Tok.is(tok::l_brace)) { parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/false); addUnwrappedLine(); return; } } break; case tok::identifier: if (FormatTok->IsForEachMacro) { parseForOrWhileLoop(); return; } // In all other cases, parse the declaration. break; default: break; } do { switch (FormatTok->Tok.getKind()) { case tok::at: nextToken(); if (FormatTok->Tok.is(tok::l_brace)) parseBracedList(); break; case tok::kw_enum: parseEnum(); break; case tok::kw_typedef: nextToken(); // FIXME: Use the IdentifierTable instead. if (FormatTok->TokenText == "NS_ENUM") parseEnum(); break; case tok::kw_struct: case tok::kw_union: case tok::kw_class: parseRecord(); // A record declaration or definition is always the start of a structural // element. break; case tok::semi: nextToken(); addUnwrappedLine(); return; case tok::r_brace: addUnwrappedLine(); return; case tok::l_paren: parseParens(); break; case tok::caret: nextToken(); if (FormatTok->Tok.isAnyIdentifier() || FormatTok->isSimpleTypeSpecifier()) nextToken(); if (FormatTok->is(tok::l_paren)) parseParens(); if (FormatTok->is(tok::l_brace)) parseChildBlock(); break; case tok::l_brace: if (!tryToParseBracedList()) { // A block outside of parentheses must be the last part of a // structural element. // FIXME: Figure out cases where this is not true, and add projections // for them (the one we know is missing are lambdas). if (Style.BreakBeforeBraces != FormatStyle::BS_Attach) addUnwrappedLine(); FormatTok->Type = TT_FunctionLBrace; parseBlock(/*MustBeDeclaration=*/false); addUnwrappedLine(); return; } // Otherwise this was a braced init list, and the structural // element continues. break; case tok::kw_try: // We arrive here when parsing function-try blocks. parseTryCatch(); return; case tok::identifier: { StringRef Text = FormatTok->TokenText; if (Style.Language == FormatStyle::LK_JavaScript && Text == "function") { tryToParseJSFunction(); break; } nextToken(); if (Line->Tokens.size() == 1) { if (FormatTok->Tok.is(tok::colon)) { parseLabel(); return; } // Recognize function-like macro usages without trailing semicolon. if (FormatTok->Tok.is(tok::l_paren)) { parseParens(); if (FormatTok->NewlinesBefore > 0 && tokenCanStartNewLine(FormatTok->Tok) && Text == Text.upper()) { addUnwrappedLine(); return; } } else if (FormatTok->HasUnescapedNewline && Text.size() >= 5 && Text == Text.upper()) { // Recognize free-standing macros like Q_OBJECT. addUnwrappedLine(); return; } } break; } case tok::equal: nextToken(); if (FormatTok->Tok.is(tok::l_brace)) { parseBracedList(); } break; case tok::l_square: parseSquare(); break; default: nextToken(); break; } } while (!eof()); }
MODULE::MODULE(Node *parentNode) : Node(parentNode, parentNode->lex, parentNode->errorList) { //get grammar A2lGrammar* gram = parentNode->lex->grammar; namePar = &gram->module.namePar; typePar = &gram->module.typePar; factoryOptNode = &gram->module.factoryOptNode; factoryOptItem = &gram->module.factoryOptItem; //opt Parameters occOptPar = new QMap<std::string, Occurence>; occOptPar->insert("CHARACTERISTIC", ZeroOrMore); occOptPar->insert("MEASUREMENT", ZeroOrMore); occOptPar->insert("IF_DATA", ZeroOrMore); occOptPar->insert("FUNCTION", ZeroOrMore); occOptPar->insert("AXIS_PTS", ZeroOrMore); occOptPar->insert("COMPU_METHOD", ZeroOrMore); occOptPar->insert("COMPU_VTAB", ZeroOrMore); occOptPar->insert("RECORD_LAYOUT", ZeroOrMore); occOptPar->insert("A2ML", ZeroOrOne); occOptPar->insert("MOD_PAR", ZeroOrOne); occOptPar->insert("MOD_COMMON", ZeroOrOne); occOptPar->insert("GROUP", ZeroOrMore); occOptPar->insert("UNIT", ZeroOrMore); //Set the line where the Node starts in ASAP file a2lLine = lex->getLine(); //check if it is a chunk for multi_threading TokenTyp token = lex->getNextToken(); if (token == Identifier && lex->getLexem() == "CHUNKstart") { stopped = true; } else { QString str = lex->getLexem().c_str(); lex->backward(str.length()); } //TokenTyp token; //Parse Mandatory PARAMETERS parseFixPar(typePar); name = parameters.at(0); //Parse optional PARAMETERS token = parseOptPar(occOptPar); //End parsing if (token == BlockEnd) { token = nextToken(); if (token == Keyword && lex->getLexem() == "MODULE") { //Sort the childNodes foreach (Node *node, childNodes) node->sortChildrensName(); } else { QString s(lex->toString(token).c_str()); this->showError("expected token : BlockEnd MODULE\nfind token : " + s); } } else if (token == Identifier && lex->getLexem() == "CHUNKend") { //Sort the childNodes foreach (Node *node, childNodes) node->sortChildrensName(); stopped = true; lex->backward(); } else { QString s1(lex->toString(token).c_str()); QString s2(lex->getLexem().c_str()); this->showError("expected end MODULE\nfind : " + s1 + " " + s2); } //Sort The childItems and childNodes qSort(optItems.begin(), optItems.end(), itemLessThan); qSort(childNodes.begin(), childNodes.end(), nodeLessThan); listChar.sort(); }
EngineOption* UciEngine::parseOption(const QStringRef& line) { enum Keyword { OptionName, OptionType, OptionDefault, OptionMin, OptionMax, OptionVar }; static const QString types[] = { "name", "type", "default", "min", "max", "var" }; QString name; QString type; QString value; QStringList choices; int min = 0; int max = 0; int keyword = -1; QStringRef token(nextToken(line)); QVarLengthArray<QStringRef> tokens; while (!token.isNull()) { token = parseUciTokens(token, types, 6, tokens, keyword); if (tokens.isEmpty() || keyword == -1) continue; QString str(joinTokens(tokens).toString()); switch (keyword) { case OptionName: name = str; break; case OptionType: type = str; break; case OptionDefault: value = str; break; case OptionMin: min = str.toInt(); break; case OptionMax: max = str.toInt(); break; case OptionVar: choices << str; break; } } if (name.isEmpty()) return 0; if (type == "button") return new EngineButtonOption(name); else if (type == "check") { if (value == "true") return new EngineCheckOption(name, true, true); else return new EngineCheckOption(name, false, false); } else if (type == "combo") return new EngineComboOption(name, value, value, choices); else if (type == "spin") return new EngineSpinOption(name, value.toInt(), value.toInt(), min, max); else if (type == "string") return new EngineTextOption(name, value, value); else if (type == "filename") return new EngineTextOption(name, value, value, QString(), EngineTextOption::FileDialog); return 0; }