コード例 #1
0
ファイル: uciengine.cpp プロジェクト: ajithcj/cutechess
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;
	}
}
コード例 #2
0
ファイル: xltmetinf.c プロジェクト: 01org/libdmclient
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;
}
コード例 #3
0
ファイル: module.cpp プロジェクト: piotrbetlej/hexplorer
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;
    }
}
コード例 #4
0
ファイル: dummy-xml-ll.cpp プロジェクト: wpbest/copperspice
bool parse()
{
    nextToken();
    return parseXmlStream();
}
コード例 #5
0
// 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;
  	
}
コード例 #6
0
ファイル: Parser.cpp プロジェクト: flame1/armips
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(&macroTokenizer,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(&macroTokenizer,true);
}
コード例 #7
0
ファイル: unit.cpp プロジェクト: piotrbetlej/hexplorer
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;
    }
}
コード例 #8
0
ファイル: xltdmtnd.c プロジェクト: happerchen/packages
/* 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;
}
コード例 #9
0
ファイル: xltdmtnd.c プロジェクト: happerchen/packages
/* 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;
}
コード例 #10
0
	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;
				}
			}
		}
	}
コード例 #11
0
	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;
			}
		}
	}
コード例 #12
0
ファイル: chessengine.cpp プロジェクト: eliaskousk/cutechess
QStringRef ChessEngine::firstToken(const QString& str, bool untilEnd)
{
	return nextToken(QStringRef(&str, 0, 0), untilEnd);
}
コード例 #13
0
ファイル: tokenizer.cpp プロジェクト: jspenguin/glbumper
void TokenStream::expectToken(Token& t, TokenType type) {
    nextToken(t);
    if (t.type != type) {
	throw TokenExpectError(type,t);
    }
}
コード例 #14
0
ファイル: myintl.cpp プロジェクト: bingmann/cryptote
MyPluralFormsScanner::MyPluralFormsScanner(const char* s) : m_s(s)
{
    nextToken();
}
コード例 #15
0
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;
}
コード例 #16
0
ファイル: xltdmtnd.c プロジェクト: happerchen/packages
/* 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;
}
コード例 #17
0
ファイル: Parser.cpp プロジェクト: flame1/armips
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 &macro = 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;
}
コード例 #18
0
ファイル: xltdmtnd.c プロジェクト: happerchen/packages
/* 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;
}
コード例 #19
0
ファイル: main.c プロジェクト: yangpeiyong/compilers
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;
	}
}
コード例 #20
0
ファイル: xltdmtnd.c プロジェクト: happerchen/packages
/* 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;
}
コード例 #21
0
/*******************************************************************************
 * 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;
}
コード例 #22
0
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 ---------------------------------------------*/
コード例 #23
0
ファイル: SqlTokenizer.cpp プロジェクト: joonhwan/Waffle
//-----------------------------------------------------------------------------
void SqlTokenizer::init()
{
    sqlTokenEndM = sqlTokenStartM = sqlM.constData();
    nextToken();
}
コード例 #24
0
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();
  }
}
コード例 #25
0
ファイル: tokenizer.cpp プロジェクト: harkal/sylphis3d
void CTokenizerBase::skipToToken(const string &token){
	while ( nextToken() ){
		if(getToken() == token)return;
	}
}
コード例 #26
0
void UnwrappedLineParser::parsePPUnknown() {
  do {
    nextToken();
  } while (!eof());
  addUnwrappedLine();
}
コード例 #27
0
ファイル: xltmetinf.c プロジェクト: 01org/libdmclient
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;
}
コード例 #28
0
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());
}
コード例 #29
0
ファイル: module.cpp プロジェクト: piotrbetlej/hexplorer
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();
}
コード例 #30
0
ファイル: uciengine.cpp プロジェクト: ajithcj/cutechess
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;
}