// Parse one simple selector, e.g.: `type#id.class1.class2.class3`
SimpleSelector CSSParser::parseSimpleSelector(){
    QString tagName;
    QString id;
    QVector<QString> classes;
    if(!eof()){
        QChar c = peekChar();
        if(c == '#'){
            consumeChar('#');
            id = parseIdentifier();
            qDebug() << "#";
        } else if(c == '.') {
            consumeChar('.');
            classes.append(parseIdentifier());
            qDebug() << ".";
        } else if(c == '*'){
            consumeChar('*');//TODO
            qDebug() << "*";
        } else if(isVaidIdentifier(c)){
            //h1 div.note
            tagName = parseIdentifier();
        }
    }
    SimpleSelector ret{tagName, id, classes};
#ifdef CSS_DEBUG
    qDebug() << Q_FUNC_INFO;
#endif /* CSS_DEBUG */
    return ret;

}

static std::vector<AlterMetaDataCommand> parseCommands( const std::string& source)
{
	std::vector<AlterMetaDataCommand> rt;
	std::string::const_iterator si = source.begin(), se = source.end();

	for (si = skipSpaces( si, se); si != se; si = skipSpaces( si, se))
	{
		std::string cmd( parseIdentifier( si, se, _TXT("command name")));
		if (strus::utils::caseInsensitiveEquals( cmd, "Alter"))
		{
			std::string name( parseIdentifier( si, se, _TXT("old element name")));
			std::string newname( parseIdentifier( si, se, _TXT("new element name")));
			std::string type( parseIdentifier( si, se, _TXT("new element type")));

			rt.push_back( AlterMetaDataCommand::AlterElement( name, newname, type));
		}
		else if (strus::utils::caseInsensitiveEquals( cmd, "Add"))
		{
			std::string name( parseIdentifier( si, se, _TXT("element name")));
			std::string type( parseIdentifier( si, se, _TXT("element type name")));

			rt.push_back( AlterMetaDataCommand::AddElement( name, type));
		}
		else if (strus::utils::caseInsensitiveEquals( cmd, "Rename"))
		{
			std::string name( parseIdentifier( si, se, _TXT("old element name")));
			std::string newname( parseIdentifier( si, se, _TXT("new element name")));

			rt.push_back( AlterMetaDataCommand::RenameElement( name, newname));
		}
		else if (strus::utils::caseInsensitiveEquals( cmd, "Delete"))
		{
			std::string name( parseIdentifier( si, se, _TXT("element name")));

			rt.push_back( AlterMetaDataCommand::DeleteElement( name));
		}
		else if (strus::utils::caseInsensitiveEquals( cmd, "Clear"))
		{
			std::string name( parseIdentifier( si, se, _TXT("element name")));
			
			rt.push_back( AlterMetaDataCommand::ClearValue( name));
		}
		si = skipSpaces( si, se);
		if (si == se)
		{
			break;
		}
		else if (*si == ';')
		{
			++si;
		}
		else
		{
			std::string str( si, si+30);
			throw strus::runtime_error( _TXT( "semicolon expected as separator of commands at '..."), str.c_str());
		}
	}
	return rt;
}

bool
PluginIdentifier::areIdentifiersSimilar(QString id1, QString id2)
{
    QString type1, type2, soName1, soName2, label1, label2;

    parseIdentifier(id1, type1, soName1, label1);
    parseIdentifier(id2, type2, soName2, label2);

    if (type1 != type2 || label1 != label2)
        return false;

    bool similar = (soName1.section('/', -1).section('.', 0, 0) ==
                    soName2.section('/', -1).section('.', 0, 0));

    return similar;
}

  //----------------------------------------------------------------------------
  bool XmlConfig::setParameter( const std::string& key,
                                const std::string& val,
                                const std::string& type )
  {
    if( !_config )
      return false;

    std::cout << "setParameter(key = " << key
                         << ", val = " << val
                         << ", type = " << type
                         << ")"
                         << std::endl;

    //resolve parts of identifier (Renderer:FeatureX) and find in config
    std::string valname;
    TiXmlNode* container = parseIdentifier(key, valname, true);

    if( key.length() > valname.length() + 1 )
    {
      std::string component_name =
        key.substr(0, key.length() - valname.length() - 1);
      Configurable* comp = findComponent(component_name);
      if( !comp )
        LOG_ERROR("No such component: " << component_name);
      else
        comp->setParameter(valname, val, type);
    }

    //check if exists
    TiXmlNode* node = container->FirstChild(valname);
    TiXmlElement* arg = 0;
    if( node )
    {
      arg = node->ToElement();

      //check if it matches
      int res = checkTypeMatch(key, arg, type);
      if(res == 1)
        arg->SetAttribute("type", type);
      else if(res == 0)
        return false;

    }
    else
    {
      //create new one
      arg = new TiXmlElement( valname );
      container->LinkEndChild(arg);
      arg->SetAttribute("type", type);
    }

    arg->SetAttribute("val", val);

    _dirty_write = true;

    saveFile(); // TODO check if multiple variables changed within small
                //      time window

    return true;
  }

  //----------------------------------------------------------------------------
  XmlConfig::NodePtr XmlConfig::parseIdentifier( const std::string& identifier,
                                                 size_t pos,
                                                 NodePtr container,
                                                 std::string& valname,
                                                 bool create )
  {
    size_t p = identifier.find_first_of(':', pos);
    if(p == std::string::npos)
    {
      valname = identifier.substr(pos);
      return container;
    }

    assert(container);

    std::string containername = identifier.substr(pos, p-pos);
    TiXmlElement* child = 0;
    TiXmlNode* node = container->FirstChild(containername);
    if( !node )
    {
      if( !create )
        return 0;

      child = new TiXmlElement( containername );
      container->LinkEndChild(child);
    }
    else
      child = node->ToElement();

    return parseIdentifier(identifier, p+1, child, valname, create);
  }

static void parseSimpleTag (const unsigned char *cp, erlangKind kind)
{
	vString *const identifier = vStringNew ();
	parseIdentifier (cp, identifier);
	makeSimpleTag (identifier, ErlangKinds, kind);
	vStringDelete (identifier);
}

char *OpenDDLParser::parseName( char *in, char *end, Name **name ) {
    *name = ddl_nullptr;
    if( ddl_nullptr == in || in == end ) {
        return in;
    }

    // ignore blanks
    in = lookForNextToken( in, end );
    if( *in != '$' && *in != '%' ) {
        return in;
    }

    NameType ntype( GlobalName );
    if( *in == '%' ) {
        ntype = LocalName;
    }
    in++;
    Name *currentName( ddl_nullptr );
    Text *id( ddl_nullptr );
    in = parseIdentifier( in, end, &id );
    if( id ) {
        currentName = new Name( ntype, id );
        if( currentName ) {
            *name = currentName;
        }
    }

    return in;
}

static void parseFunctionTag (const unsigned char *cp, vString *const module)
{
	vString *const identifier = vStringNew ();
	parseIdentifier (cp, identifier);
	makeMemberTag (identifier, K_FUNCTION, module);
	vStringDelete (identifier);
}

    boost::any visit( FunctionDeclaration functionDeclaration ) {

        extractToken( TokenType::KeywordFunction );

        functionDeclaration->identifier = parseIdentifier();

        extractToken( TokenType::PunctuatorOpeningParenthesis );

        while( !currentTokenIs(TokenType::PunctuatorClosingParenthesis) ) {

            if( !functionDeclaration->arguments.empty() )
                extractToken( TokenType::PunctuatorComma );

            functionDeclaration->arguments.emplace_back(
                parse<_FunctionArgument>() );
        }

        extractToken( TokenType::PunctuatorClosingParenthesis );

        if( !currentTokenIs(TokenType::PunctuatorOpeningBrace) )
            functionDeclaration->returnType = parse<_Type>();

        functionDeclaration->block = parse<_Block>();

        return boost::any();
    }

    Token Lexer::parseNext() {
        //skip whitespace of the current character
        skipWhitespace();

        //return eof if we are at the end
        if (curChar() == '\0') {
            return Token::Eof;
        }

        Token ret;

        //first check if it is a keyword and return it
        ret = parseKeyword();
        if (ret != Token::None)
            return ret;
        ret = parseSymbol();
        if (ret != Token::None)
            return ret;
        ret = parseIdentifier();
        if (ret != Token::None)
            return ret;
        ret = parseNumeric();
        if (ret != Token::None)
            return ret;

        //if nothing was able to parse it, it must be a character and we return it
        value.character = eatChar();
        return Token::Character;
    }

/*
 * Directives are of the form:
 * def defp
 * defmacro defmacrop
 * defrecord
 * defmodule
 * defprotocol
 * defimpl
 */
static void parseDirective (const unsigned char *cp, vString *const module)
{
    vString *const directive = vStringNew ();
    const char *const drtv = vStringValue (directive);
    cp = parseIdentifier (cp, directive);
    skipWhitespace (&cp);
    /* if (*cp == '(') */
    /*     ++cp; */

    if (strcmp (drtv, "def") == 0 || strcmp (drtv, "defp") == 0)
        parseSimpleTag (cp, K_FUNCTION);
    else if (strcmp (drtv, "defmacro") == 0 || strcmp (drtv, "defmacrop") == 0)
        parseSimpleTag (cp, K_MACRO);
    else if (strcmp (drtv, "defrecord") == 0)
        parseSimpleTag (cp, K_RECORD);
    else if (strcmp (drtv, "defmodule") == 0)
        parseSimpleTag (cp, K_MODULE);
    else if (strcmp (drtv, "defprotocol") == 0)
        parseSimpleTag(cp, K_PROTOCOL);
    else if (strcmp (drtv, "defimpl") == 0)
        parseSimpleTag(cp, K_IMPL);
    /* Otherwise, it was an import, require, etc. */

    vStringDelete (directive);
}

/*
 * Directives are of the form:
 * -module(foo)
 * -define(foo, bar)
 * -record(graph, {vtab = notable, cyclic = true}).
 * -type some_type() :: any().
 * -opaque some_opaque_type() :: any().
 */
static void parseDirective (const unsigned char *cp, vString *const module)
{
	/*
	 * A directive will be either a record definition or a directive.
	 * Record definitions are handled separately
	 */
	vString *const directive = vStringNew ();
	const char *const drtv = vStringValue (directive);
	cp = parseIdentifier (cp, directive);
	cp = skipSpace (cp);
	if (*cp == '(')
		++cp;

	if (strcmp (drtv, "record") == 0)
		parseSimpleTag (cp, K_RECORD);
	else if (strcmp (drtv, "define") == 0)
		parseSimpleTag (cp, K_MACRO);
	else if (strcmp (drtv, "type") == 0)
		parseSimpleTag (cp, K_TYPE);
	else if (strcmp (drtv, "opaque") == 0)
		parseSimpleTag (cp, K_TYPE);
	else if (strcmp (drtv, "module") == 0)
		parseModuleTag (cp, module);
	/* Otherwise, it was an import, export, etc. */
	
	vStringDelete (directive);
}

std::vector<MarkupDescription> parseMarkupDescriptions( const std::string& src)
{
	char const* si = src.c_str();
	try
	{
		std::vector<MarkupDescription> rt;
		while (*si)
		{
			si = skipNextNonSpace( si);
			if (!isDigit(*si)) throw std::runtime_error("position number expected as 1st argument of markup description)");
			unsigned int position = parseUintValue( si);
			si = skipNextNonSpace( si);
			unsigned int offset = parseUintValue( si);
			si = skipNextNonSpace( si);
			char type = *si++;
			if (type != '>' && type != '<' && type != '@') throw std::runtime_error("expected '<' or '>' or '@' as type (2nd argument of markup description)");
			si = skipNextNonSpace( si);
			if (!isAlpha(*si)) throw std::runtime_error("identifier expected as 3rd argument of markup description");
			std::string name = parseIdentifier( si);
			si = skipNextNonSpace( si);
			char const* expr = si;
			si = skipEoln( si);
			std::string value( expr, si - expr);
			rt.push_back( MarkupDescription( position, offset, type, name, value));
			++si;
		}
		return rt;
	}
	catch (const std::runtime_error& err)
	{
		std::ostringstream msg;
		msg << "error on line " << getLine( src.c_str(), si) << " of markup description file: " << err.what();
		throw std::runtime_error( msg.str());
	}
}

QVariant
parseAtom(ParserState &st)
{
    checkEndOfFile(st);

    if (isalpha(*st.ptr))
    {
        return parseIdentifier(st);
    }
    else if (isdigit(*st.ptr))
    {
        return parseNumber(st);
    }
    else if (*st.ptr == '-')
    {
        st.ptr++;
        return -parseNumber(st);
    }
    else if (*st.ptr == '"')
    {
        return parseString(st);
    }
    else
    {
        throw ParserError(QString("unexpected character '%1'").arg(*st.ptr));
    }
}

PARSENODE_PTR SQLParser::parseExpression() {
    PARSENODE_PTR columnNode = parseIdentifier();
    PARSENODE_PTR opNode = parseOperator();
    PARSENODE_PTR valueNode = parseLiteral();
    opNode->children.push_back(columnNode);
    opNode->children.push_back(valueNode);
    return opNode;
}

  bool parse(const char *subEngineString) {
    // Ignore whitespaces
    subEngineString = parseWhitespaces(subEngineString);

    // Extract engine identifier. It can be empty at this point
    const char *beginOfIdentifier = subEngineString;
    subEngineString = parseIdentifier(subEngineString);
    engineName.assign(beginOfIdentifier, subEngineString - beginOfIdentifier);

    // Ignore whitespaces
    subEngineString = parseWhitespaces(subEngineString);

    // String termination is allowed at this place
    if (!*subEngineString)
        return true;

    // Otherwise colon must be specified and engine identifier cannot be empty
    if (!engineName.length() ||  (*subEngineString != ':')
            ||  (*(subEngineString+1) == '\0'))
        LOG(FATAL) << "Wrong engine specification";

    // Process sub engines
    subEngineString++;
    while (true) {
      // Ignore separators
      subEngineString = parseSeparators(subEngineString);

      // String termination is allowed at this place
      if (!*subEngineString)
          return true;

      // Extract sub engine identifier
      const char *beginOfIdentifier = subEngineString;
      subEngineString = parseIdentifier(subEngineString);

      // Identifier can not be empty nor contain invalid characters
      if (beginOfIdentifier == subEngineString)
          return false;

      // Collect all valid sub engine names
      std::string subEngineName;
      subEngineName.assign(beginOfIdentifier,
              subEngineString - beginOfIdentifier);
      subEngines.push_back(subEngineName);
    }
  }

Unit CSSParser::parseUnit(){
    QString u = parseIdentifier().toLower();
    if (u == "px") {
        return Unit::Px;
    } else {
        qDebug() << "Unrecognized unit";
        return Unit::Undefined;
    }
}

FactorPtr Parser::parseFactor()
{
    FactorPtr factor(new Factor);

    if (m_curToken.tokenType() == TokenType::Number) {
        factor->number = parseNumber();
        if (m_errorCode > ErrorCodes::NoError) {
            panic(factorFollow, factorFollowSize);
            return FactorPtr();
        }

        return factor;
    } else if (m_curToken.tokenType() == TokenType::LParen) {
        match(TokenType::LParen);

        ExpressionPtr expr = parseExpression();
        if (m_errorCode > ErrorCodes::NoError) {
            panic(factorFollow, factorFollowSize);
            return FactorPtr();
        }

        if (!match(TokenType::RParen)) {
            reportError(ErrorCodes::ExpectedRParen);

            panic(factorFollow, factorFollowSize);
            return FactorPtr();
        }

        factor->expression = expr;
        return factor;
    } else if (m_curToken.tokenType() == TokenType::Not) {
        match(TokenType::Not);

        factor->negatedFactor = parseFactor();
        if (m_errorCode > ErrorCodes::NoError) {
            panic(factorFollow, factorFollowSize);
            return FactorPtr();
        }

        return factor;
    }

    IdentifierPtr identifier = parseIdentifier();
    if (m_errorCode > ErrorCodes::NoError) {
        panic(factorFollow, factorFollowSize);
        return FactorPtr();
    }

    parseFactor_p(identifier);
    if (m_errorCode > ErrorCodes::NoError) {
        panic(factorFollow, factorFollowSize);
        return FactorPtr();
    }

    factor->id = identifier;
    return factor;
}

bool CVarConsole::parseInput(char* input) {
	if(strlen(input) == 0) return true;

	if(parseAssignment(input)) return true;
	if(parseCommand(input)) return true;
	if(parseIdentifier(input)) return true;

	return false;
}

bool parseObject(File& file, Object& out_obj)
{
	file.str++; // consume '{'

	skipWhitespaces(file);

	while(*file.str != '}')
	{
		std::string key;

		uint32_t key_line_num = file.current_line_num;

		if(!parseIdentifier(file, key))
		{
			std::cout << "Line " << key_line_num << ": Error parsing identifier!\n";
			return false;
		}
		else if(key.empty())
		{
			std::cout << "Line " << key_line_num << ": Identifier can't be an empty string!\n";
			return false;
		}

		if(out_obj[key] != nullptr)
		{
			std::cout << "Line " << key_line_num << ": Key '" << key << "' already exists!\n";
			return false;
		}

		skipWhitespaces(file);

		if(*file.str != '=')
		{
			std::cout << "Line " << file.current_line_num << ": Expected '=' not found!\n";
			return false;
		}

		file.str++; //consume '='

		skipWhitespaces(file);

		Value value;

		if(!parseValue(file, value))
			return false;

		out_obj.insert(std::move(key), std::move(value), key_line_num);

		skipWhitespaces(file);
	}

	//consume '}'
	file.str++;

	return true;
}