QCss::Parser Class Reference

#include <qcssparser_p.h>

Public Functions
Symbol	errorSymbol ()
bool	hasNext () const
void	init (const QString &css, bool file=false)
QString	lexem () const
QString	lexemUntil (TokenType t)
TokenType	lookup () const
bool	lookupElementName () const
TokenType	next ()
bool	next (TokenType t)
bool	parse (StyleSheet *styleSheet, Qt::CaseSensitivity nameCaseSensitivity=Qt::CaseSensitive)
bool	parseAttrib (AttributeSelector *attr)
bool	parseClass (QString *name)
bool	parseCombinator (BasicSelector::Relation *relation)
bool	parseElementName (QString *name)
bool	parseExpr (QVector< Value > *values)
bool	parseFunction (QString *name, QString *args)
bool	parseHexColor (QColor *col)
bool	parseImport (ImportRule *importRule)
bool	parseMedia (MediaRule *mediaRule)
bool	parseMedium (QStringList *media)
bool	parseNextDeclaration (Declaration *declaration)
bool	parseNextExpr (QVector< Value > *values)
bool	parseNextFunction (QString *name, QString *args)
bool	parseNextMedium (QStringList *media)
bool	parseNextOperator (Value *value)
bool	parseNextSelector (Selector *sel)
bool	parseNextSimpleSelector (BasicSelector *basicSel)
bool	parsePage (PageRule *pageRule)
bool	parsePrio (Declaration *declaration)
bool	parseProperty (Declaration *decl)
bool	parsePseudo (Pseudo *pseudo)
bool	parsePseudoPage (QString *selector)
	Parser ()
	Parser (const QString &css, bool file=false)
bool	parseRuleset (StyleRule *styleRule)
bool	parseSelector (Selector *sel)
bool	parseSimpleSelector (BasicSelector *basicSel)
bool	parseTerm (Value *value)
void	prev ()
bool	recordError ()
void	skipSpace ()
const Symbol &	symbol () const
bool	test (TokenType t)
bool	testAndParseUri (QString *uri)
bool	testAttrib ()
bool	testClass ()
bool	testCombinator ()
bool	testElementName ()
bool	testExpr ()
bool	testFunction ()
bool	testHexColor ()
bool	testImport ()
bool	testMedia ()
bool	testMedium ()
bool	testPage ()
bool	testPrio ()
bool	testProperty ()
bool	testPseudo ()
bool	testPseudoPage ()
bool	testRuleset ()
bool	testSelector ()
bool	testSimpleSelector ()
bool	testTerm ()
bool	testTokenAndEndsWith (TokenType t, const QLatin1String &str)
QString	unquotedLexem () const
bool	until (TokenType target, TokenType target2=NONE)

Public Variables
int	errorIndex
bool	hasEscapeSequences
int	index
QString	sourcePath
QVector< Symbol >	symbols

Detailed Description

Definition at line 749 of file qcssparser_p.h.

Constructors and Destructors

Parser() [1/2]

Parser::Parser

(

)

Definition at line 2101 of file qcssparser.cpp.

{
    index = 0;
    errorIndex = -1;
    hasEscapeSequences = false;
}

Parser() [2/2]

Parser::Parser	(	const QString &	css,
		bool	file = false
	)

Definition at line 2096 of file qcssparser.cpp.

{
    init(css, isFile);
}

Functions

errorSymbol()

Symbol Parser::errorSymbol

(

)

Definition at line 2173 of file qcssparser.cpp.

{
    if (errorIndex == -1) return Symbol();
    return symbols.at(errorIndex);
}

hasNext()

bool QCss::Parser::hasNext ( ) const

inline

Definition at line 811 of file qcssparser_p.h.

{ return index < symbols.count(); }

init()

void Parser::init	(	const QString &	css,
		bool	file = false
	)

Definition at line 2108 of file qcssparser.cpp.

{
    QString styleSheet = css;
    if (isFile) {
        QFile file(css);
        if (file.open(QFile::ReadOnly)) {
            sourcePath = QFileInfo(styleSheet).absolutePath() + QLatin1Char('/');
            QTextStream stream(&file);
            styleSheet = stream.readAll();
        } else {
            qWarning() << "QCss::Parser - Failed to load file " << css;
            styleSheet.clear();
        }
    } else {
        sourcePath.clear();
    }

    hasEscapeSequences = false;
    symbols.resize(0);
    symbols.reserve(8);
    Scanner::scan(Scanner::preprocess(styleSheet, &hasEscapeSequences), &symbols);
    index = 0;
    errorIndex = -1;
}

lexem()

QString QCss::Parser::lexem ( ) const

inline

Definition at line 817 of file qcssparser_p.h.

{ return symbol().lexem(); }

lexemUntil()

QString Parser::lexemUntil

(

QCss::TokenType

t

)

Definition at line 2709 of file qcssparser.cpp.

{
    QString lexem;
    while (hasNext() && next() != t)
        lexem += symbol().lexem();
    return lexem;
}

lookup()

TokenType QCss::Parser::lookup ( ) const

inline

Definition at line 821 of file qcssparser_p.h.

                                    {
        return (index - 1) < symbols.count() ? symbols.at(index - 1).token : NONE;
    }

lookupElementName()

bool QCss::Parser::lookupElementName ( ) const

inline

Definition at line 807 of file qcssparser_p.h.

{ return lookup() == IDENT || lookup() == STAR; }

next() [1/2]

TokenType QCss::Parser::next ( )

inline

Definition at line 812 of file qcssparser_p.h.

{ return symbols.at(index++).token; }

next() [2/2]

bool Parser::next

(

QCss::TokenType

t

)

Definition at line 2681 of file qcssparser.cpp.

{
    if (hasNext() && next() == t)
        return true;
    return recordError();
}

parse()

bool Parser::parse	(	StyleSheet *	styleSheet,
		Qt::CaseSensitivity	nameCaseSensitivity = Qt::CaseSensitive
	)

Definition at line 2133 of file qcssparser.cpp.

Referenced by QSvgHandler::characters(), QTextHtmlParser::importStyleSheet(), QTextHtmlParserNode::parseStyleAttribute(), QSvgHandler::processingInstruction(), and QTextDocument::setDefaultStyleSheet().

{
    if (testTokenAndEndsWith(ATKEYWORD_SYM, QLatin1String("charset"))) {
        if (!next(STRING)) return false;
        if (!next(SEMICOLON)) return false;
    }

    while (test(S) || test(CDO) || test(CDC)) {}

    while (testImport()) {
        ImportRule rule;
        if (!parseImport(&rule)) return false;
        styleSheet->importRules.append(rule);
        while (test(S) || test(CDO) || test(CDC)) {}
    }

    do {
        if (testMedia()) {
            MediaRule rule;
            if (!parseMedia(&rule)) return false;
            styleSheet->mediaRules.append(rule);
        } else if (testPage()) {
            PageRule rule;
            if (!parsePage(&rule)) return false;
            styleSheet->pageRules.append(rule);
        } else if (testRuleset()) {
            StyleRule rule;
            if (!parseRuleset(&rule)) return false;
            styleSheet->styleRules.append(rule);
        } else if (test(ATKEYWORD_SYM)) {
            if (!until(RBRACE)) return false;
        } else if (hasNext()) {
            return false;
        }
        while (test(S) || test(CDO) || test(CDC)) {}
    } while (hasNext());
    styleSheet->buildIndexes(nameCaseSensitivity);
    return true;
}

parseAttrib()

bool Parser::parseAttrib

(

AttributeSelector *

attr

)

Definition at line 2433 of file qcssparser.cpp.

{
    skipSpace();
    if (!next(IDENT)) return false;
    attr->name = lexem();
    skipSpace();

    if (test(EQUAL)) {
        attr->valueMatchCriterium = AttributeSelector::MatchEqual;
    } else if (test(INCLUDES)) {
        attr->valueMatchCriterium = AttributeSelector::MatchContains;
    } else if (test(DASHMATCH)) {
        attr->valueMatchCriterium = AttributeSelector::MatchBeginsWith;
    } else {
        return next(RBRACKET);
    }

    skipSpace();

    if (!test(IDENT) && !test(STRING)) return false;
    attr->value = unquotedLexem();

    skipSpace();
    return next(RBRACKET);
}

parseClass()

bool Parser::parseClass

(

QString *

name

)

Definition at line 2416 of file qcssparser.cpp.

{
    if (!next(IDENT)) return false;
    *name = lexem();
    return true;
}

parseCombinator()

bool Parser::parseCombinator

(

BasicSelector::Relation *

relation

)

Definition at line 2285 of file qcssparser.cpp.

{
    *relation = BasicSelector::NoRelation;
    if (lookup() == S) {
        *relation = BasicSelector::MatchNextSelectorIfAncestor;
        skipSpace();
    } else {
        prev();
    }
    if (test(PLUS)) {
        *relation = BasicSelector::MatchNextSelectorIfPreceeds;
    } else if (test(GREATER)) {
        *relation = BasicSelector::MatchNextSelectorIfParent;
    }
    skipSpace();
    return true;
}

parseElementName()

bool Parser::parseElementName

(

QString *

name

)

Definition at line 2423 of file qcssparser.cpp.

{
    switch (lookup()) {
        case STAR: name->clear(); break;
        case IDENT: *name = lexem(); break;
        default: return false;
    }
    return true;
}

parseExpr()

bool Parser::parseExpr

(

QVector< Value > *

values

)

Definition at line 2515 of file qcssparser.cpp.

{
    Value val;
    if (!parseTerm(&val)) return false;
    values->append(val);
    bool onceMore;
    do {
        onceMore = false;
        val = Value();
        if (!parseNextOperator(&val)) return false;
        if (val.type != QCss::Value::Unknown)
            values->append(val);
        if (testTerm()) {
            onceMore = true;
            val = Value();
            if (!parseTerm(&val)) return false;
            values->append(val);
        }
    } while (onceMore);
    return true;
}

parseFunction()

bool Parser::parseFunction	(	QString *	name,
		QString *	args
	)

Definition at line 2625 of file qcssparser.cpp.

{
    *name = lexem();
    name->chop(1);
    skipSpace();
    const int start = index;
    if (!until(RPAREN)) return false;
    for (int i = start; i < index - 1; ++i)
        args->append(symbols.at(i).lexem());
    /*
    if (!nextExpr(&arguments)) return false;
    if (!next(RPAREN)) return false;
    */
    skipSpace();
    return true;
}

parseHexColor()

bool Parser::parseHexColor

(

QColor *

col

)

Definition at line 2642 of file qcssparser.cpp.

{
    col->setNamedColor(lexem());
    if (!col->isValid()) {
        qWarning("QCssParser::parseHexColor: Unknown color name '%s'",lexem().toLatin1().constData());
        return false;
    }
    skipSpace();
    return true;
}

parseImport()

bool Parser::parseImport

(

ImportRule *

importRule

)

Definition at line 2188 of file qcssparser.cpp.

{
    skipSpace();

    if (test(STRING)) {
        importRule->href = lexem();
    } else {
        if (!testAndParseUri(&importRule->href)) return false;
    }
    removeOptionalQuotes(&importRule->href);

    skipSpace();

    if (testMedium()) {
        if (!parseMedium(&importRule->media)) return false;

        while (test(COMMA)) {
            skipSpace();
            if (!parseNextMedium(&importRule->media)) return false;
        }
    }

    if (!next(SEMICOLON)) return false;

    skipSpace();
    return true;
}

parseMedia()

bool Parser::parseMedia

(

MediaRule *

mediaRule

)

Definition at line 2216 of file qcssparser.cpp.

{
    do {
        skipSpace();
        if (!parseNextMedium(&mediaRule->media)) return false;
    } while (test(COMMA));

    if (!next(LBRACE)) return false;
    skipSpace();

    while (testRuleset()) {
        StyleRule rule;
        if (!parseRuleset(&rule)) return false;
        mediaRule->styleRules.append(rule);
    }

    if (!next(RBRACE)) return false;
    skipSpace();
    return true;
}

parseMedium()

bool Parser::parseMedium

(

QStringList *

media

)

Definition at line 2237 of file qcssparser.cpp.

{
    media->append(lexem());
    skipSpace();
    return true;
}

parseNextDeclaration()

bool Parser::parseNextDeclaration

(

Declaration *

declaration

)

Definition at line 2479 of file qcssparser.cpp.

{
    if (!testProperty())
        return true; // not an error!
    if (!parseProperty(decl)) return false;
    if (!next(COLON)) return false;
    skipSpace();
    if (!parseNextExpr(&decl->d->values)) return false;
    if (testPrio())
        if (!parsePrio(decl)) return false;
    return true;
}

parseNextExpr()

bool QCss::Parser::parseNextExpr ( QVector< Value > *  values )

inline

Definition at line 801 of file qcssparser_p.h.

{ if (!testExpr()) return recordError(); return parseExpr(values); }

parseNextFunction()

bool QCss::Parser::parseNextFunction ( QString *  name, QString *  args  )

inline

Definition at line 805 of file qcssparser_p.h.

{ if (!testFunction()) return recordError(); return parseFunction(name, args); }

parseNextMedium()

bool QCss::Parser::parseNextMedium ( QStringList *  media )

inline

Definition at line 792 of file qcssparser_p.h.

{ if (!testMedium()) return recordError(); return parseMedium(media); }

parseNextOperator()

bool Parser::parseNextOperator

(

Value *

value

)

Definition at line 2274 of file qcssparser.cpp.

{
    if (!hasNext()) return true;
    switch (next()) {
        case SLASH: value->type = Value::TermOperatorSlash; skipSpace(); break;
        case COMMA: value->type = Value::TermOperatorComma; skipSpace(); break;
        default: prev(); break;
    }
    return true;
}

parseNextSelector()

bool QCss::Parser::parseNextSelector ( Selector *  sel )

inline

Definition at line 784 of file qcssparser_p.h.

{ if (!testSelector()) return recordError(); return parseSelector(sel); }

parseNextSimpleSelector()

bool QCss::Parser::parseNextSimpleSelector ( BasicSelector *  basicSel )

inline

Definition at line 786 of file qcssparser_p.h.

{ if (!testSimpleSelector()) return recordError(); return parseSimpleSelector(basicSel); }

parsePage()

bool Parser::parsePage

(

PageRule *

pageRule

)

Definition at line 2244 of file qcssparser.cpp.

{
    skipSpace();

    if (testPseudoPage())
        if (!parsePseudoPage(&pageRule->selector)) return false;

    skipSpace();
    if (!next(LBRACE)) return false;

    do {
        skipSpace();
        Declaration decl;
        if (!parseNextDeclaration(&decl)) return false;
        if (!decl.isEmpty())
            pageRule->declarations.append(decl);
    } while (test(SEMICOLON));

    if (!next(RBRACE)) return false;
    skipSpace();
    return true;
}

parsePrio()

bool Parser::parsePrio

(

Declaration *

declaration

)

Definition at line 2508 of file qcssparser.cpp.

{
    declaration->d->important = true;
    skipSpace();
    return true;
}

parseProperty()

bool Parser::parseProperty

(

Declaration *

decl

)

Definition at line 2303 of file qcssparser.cpp.

{
    decl->d->property = lexem();
    decl->d->propertyId = static_cast<Property>(findKnownValue(decl->d->property, properties, NumProperties));
    skipSpace();
    return true;
}

parsePseudo()

bool Parser::parsePseudo

(

Pseudo *

pseudo

)

Definition at line 2459 of file qcssparser.cpp.

{
    (void)test(COLON);
    pseudo->negated = test(EXCLAMATION_SYM);
    if (test(IDENT)) {
        pseudo->name = lexem();
        pseudo->type = static_cast<quint64>(findKnownValue(pseudo->name, pseudos, NumPseudos));
        return true;
    }
    if (!next(FUNCTION)) return false;
    pseudo->function = lexem();
    // chop off trailing parenthesis
    pseudo->function.chop(1);
    skipSpace();
    if (!test(IDENT)) return false;
    pseudo->name = lexem();
    skipSpace();
    return next(RPAREN);
}

parsePseudoPage()

bool Parser::parsePseudoPage

(

QString *

selector

)

Definition at line 2267 of file qcssparser.cpp.

{
    if (!next(IDENT)) return false;
    *selector = lexem();
    return true;
}

parseRuleset()

bool Parser::parseRuleset

(

StyleRule *

styleRule

)

Definition at line 2311 of file qcssparser.cpp.

{
    Selector sel;
    if (!parseSelector(&sel)) return false;
    styleRule->selectors.append(sel);

    while (test(COMMA)) {
        skipSpace();
        Selector sel;
        if (!parseNextSelector(&sel)) return false;
        styleRule->selectors.append(sel);
    }

    skipSpace();
    if (!next(LBRACE)) return false;
    const int declarationStart = index;

    do {
        skipSpace();
        Declaration decl;
        const int rewind = index;
        if (!parseNextDeclaration(&decl)) {
            index = rewind;
            const bool foundSemicolon = until(SEMICOLON);
            const int semicolonIndex = index;

            index = declarationStart;
            const bool foundRBrace = until(RBRACE);

            if (foundSemicolon && semicolonIndex < index) {
                decl = Declaration();
                index = semicolonIndex - 1;
            } else {
                skipSpace();
                return foundRBrace;
            }
        }
        if (!decl.isEmpty())
            styleRule->declarations.append(decl);
    } while (test(SEMICOLON));

    if (!next(RBRACE)) return false;
    skipSpace();
    return true;
}

parseSelector()

bool Parser::parseSelector

(

Selector *

sel

)

Definition at line 2357 of file qcssparser.cpp.

{
    BasicSelector basicSel;
    if (!parseSimpleSelector(&basicSel)) return false;
    while (testCombinator()) {
        if (!parseCombinator(&basicSel.relationToNext)) return false;

        if (!testSimpleSelector()) break;
        sel->basicSelectors.append(basicSel);

        basicSel = BasicSelector();
        if (!parseSimpleSelector(&basicSel)) return false;
    }
    sel->basicSelectors.append(basicSel);
    return true;
}

parseSimpleSelector()

bool Parser::parseSimpleSelector

(

BasicSelector *

basicSel

)

Definition at line 2374 of file qcssparser.cpp.

{
    int minCount = 0;
    if (lookupElementName()) {
        if (!parseElementName(&basicSel->elementName)) return false;
    } else {
        prev();
        minCount = 1;
    }
    bool onceMore;
    int count = 0;
    do {
        onceMore = false;
        if (test(HASH)) {
            QString theid = lexem();
            // chop off leading #
            theid.remove(0, 1);
            basicSel->ids.append(theid);
            onceMore = true;
        } else if (testClass()) {
            onceMore = true;
            AttributeSelector a;
            a.name = QLatin1String("class");
            a.valueMatchCriterium = AttributeSelector::MatchContains;
            if (!parseClass(&a.value)) return false;
            basicSel->attributeSelectors.append(a);
        } else if (testAttrib()) {
            onceMore = true;
            AttributeSelector a;
            if (!parseAttrib(&a)) return false;
            basicSel->attributeSelectors.append(a);
        } else if (testPseudo()) {
            onceMore = true;
            Pseudo ps;
            if (!parsePseudo(&ps)) return false;
            basicSel->pseudos.append(ps);
        }
        if (onceMore) ++count;
    } while (onceMore);
    return count >= minCount;
}

parseTerm()

bool Parser::parseTerm

(

Value *

value

)

Definition at line 2549 of file qcssparser.cpp.

{
    QString str = lexem();
    bool haveUnary = false;
    if (lookup() == PLUS || lookup() == MINUS) {
        haveUnary = true;
        if (!hasNext()) return false;
        next();
        str += lexem();
    }

    value->variant = str;
    value->type = QCss::Value::String;
    switch (lookup()) {
        case NUMBER:
            value->type = Value::Number;
            value->variant.convert(QVariant::Double);
            break;
        case PERCENTAGE:
            value->type = Value::Percentage;
            str.chop(1); // strip off %
            value->variant = str;
            break;
        case LENGTH:
            value->type = Value::Length;
            break;

        case STRING:
            if (haveUnary) return false;
            value->type = Value::String;
            str.chop(1);
            str.remove(0, 1);
            value->variant = str;
            break;
        case IDENT: {
            if (haveUnary) return false;
            value->type = Value::Identifier;
            const int theid = findKnownValue(str, values, NumKnownValues);
            if (theid != 0) {
                value->type = Value::KnownIdentifier;
                value->variant = theid;
            }
            break;
        }
        default: {
            if (haveUnary) return false;
            prev();
            if (testHexColor()) {
                QColor col;
                if (!parseHexColor(&col)) return false;
                value->type = Value::Color;
                value->variant = col;
            } else if (testFunction()) {
                QString name, args;
                if (!parseFunction(&name, &args)) return false;
                if (name == QLatin1String("url")) {
                    value->type = Value::Uri;
                    removeOptionalQuotes(&args);
                    if (QFileInfo(args).isRelative() && !sourcePath.isEmpty()) {
                        args.prepend(sourcePath);
                    }
                    value->variant = args;
                } else {
                    value->type = Value::Function;
                    value->variant = QStringList() << name << args;
                }
            } else {
                return recordError();
            }
            return true;
        }
    }
    skipSpace();
    return true;
}

prev()

void QCss::Parser::prev ( )

inline

Definition at line 815 of file qcssparser_p.h.

{ index--; }

recordError()

bool QCss::Parser::recordError ( )

inline

Definition at line 827 of file qcssparser_p.h.

{ errorIndex = index; return false; }

skipSpace()

void QCss::Parser::skipSpace ( )

inline

Definition at line 809 of file qcssparser_p.h.

Referenced by parseBrushValue().

{ while (test(S)) {}; }

symbol()

const Symbol& QCss::Parser::symbol ( ) const

inline

Definition at line 816 of file qcssparser_p.h.

{ return symbols.at(index - 1); }

test()

bool Parser::test

(

QCss::TokenType

t

)

Definition at line 2688 of file qcssparser.cpp.

{
    if (index >= symbols.count())
        return false;
    if (symbols.at(index).token == t) {
        ++index;
        return true;
    }
    return false;
}

testAndParseUri()

bool Parser::testAndParseUri

(

QString *

uri

)

Definition at line 2653 of file qcssparser.cpp.

{
    const int rewind = index;
    if (!testFunction()) return false;

    QString name, args;
    if (!parseFunction(&name, &args)) {
        index = rewind;
        return false;
    }
    if (name.toLower() != QLatin1String("url")) {
        index = rewind;
        return false;
    }
    *uri = args;
    removeOptionalQuotes(uri);
    return true;
}

testAttrib()

bool QCss::Parser::testAttrib ( )

inline

Definition at line 789 of file qcssparser_p.h.

{ return test(LBRACKET); }

testClass()

bool QCss::Parser::testClass ( )

inline

Definition at line 788 of file qcssparser_p.h.

{ return test(DOT); }

testCombinator()

bool QCss::Parser::testCombinator ( )

inline

Definition at line 797 of file qcssparser_p.h.

{ return test(PLUS) || test(GREATER) || test(S); }

testElementName()

bool QCss::Parser::testElementName ( )

inline

Definition at line 787 of file qcssparser_p.h.

{ return test(IDENT) || test(STAR); }

testExpr()

bool QCss::Parser::testExpr ( )

inline

Definition at line 800 of file qcssparser_p.h.

{ return testTerm(); }

testFunction()

bool QCss::Parser::testFunction ( )

inline

Definition at line 804 of file qcssparser_p.h.

{ return test(FUNCTION); }

testHexColor()

bool QCss::Parser::testHexColor ( )

inline

Definition at line 803 of file qcssparser_p.h.

{ return test(HASH); }

testImport()

bool QCss::Parser::testImport ( )

inline

Definition at line 794 of file qcssparser_p.h.

{ return testTokenAndEndsWith(ATKEYWORD_SYM, QLatin1String("import")); }

testMedia()

bool QCss::Parser::testMedia ( )

inline

Definition at line 795 of file qcssparser_p.h.

{ return testTokenAndEndsWith(ATKEYWORD_SYM, QLatin1String("media")); }

testMedium()

bool QCss::Parser::testMedium ( )

inline

Definition at line 791 of file qcssparser_p.h.

{ return test(IDENT); }

testPage()

bool QCss::Parser::testPage ( )

inline

Definition at line 796 of file qcssparser_p.h.

{ return testTokenAndEndsWith(ATKEYWORD_SYM, QLatin1String("page")); }

testPrio()

bool Parser::testPrio

(

)

Definition at line 2492 of file qcssparser.cpp.

{
    const int rewind = index;
    if (!test(EXCLAMATION_SYM)) return false;
    skipSpace();
    if (!test(IDENT)) {
        index = rewind;
        return false;
    }
    if (lexem().compare(QLatin1String("important"), Qt::CaseInsensitive) != 0) {
        index = rewind;
        return false;
    }
    return true;
}

testProperty()

bool QCss::Parser::testProperty ( )

inline

Definition at line 798 of file qcssparser_p.h.

{ return test(IDENT); }

testPseudo()

bool QCss::Parser::testPseudo ( )

inline

Definition at line 790 of file qcssparser_p.h.

{ return test(COLON); }

testPseudoPage()

bool QCss::Parser::testPseudoPage ( )

inline

Definition at line 793 of file qcssparser_p.h.

{ return test(COLON); }

testRuleset()

bool QCss::Parser::testRuleset ( )

inline

Definition at line 782 of file qcssparser_p.h.

{ return testSelector(); }

testSelector()

bool QCss::Parser::testSelector ( )

inline

Definition at line 783 of file qcssparser_p.h.

{ return testSimpleSelector(); }

testSimpleSelector()

bool Parser::testSimpleSelector

(

)

Definition at line 2672 of file qcssparser.cpp.

{
    return testElementName()
           || (test(HASH))
           || testClass()
           || testAttrib()
           || testPseudo();
}

testTerm()

bool Parser::testTerm

(

)

Definition at line 2537 of file qcssparser.cpp.

{
    return test(PLUS) || test(MINUS)
           || test(NUMBER)
           || test(PERCENTAGE)
           || test(LENGTH)
           || test(STRING)
           || test(IDENT)
           || testHexColor()
           || testFunction();
}

testTokenAndEndsWith()

bool Parser::testTokenAndEndsWith	(	QCss::TokenType	t,
		const QLatin1String &	str
	)

Definition at line 2757 of file qcssparser.cpp.

{
    if (!test(t)) return false;
    if (!lexem().endsWith(str, Qt::CaseInsensitive)) {
        prev();
        return false;
    }
    return true;
}

unquotedLexem()

QString Parser::unquotedLexem

(

)

const

Definition at line 2699 of file qcssparser.cpp.

{
    QString s = lexem();
    if (lookup() == STRING) {
        s.chop(1);
        s.remove(0, 1);
    }
    return s;
}

until()

bool Parser::until	(	QCss::TokenType	target,
		QCss::TokenType	target2 = NONE
	)

Definition at line 2717 of file qcssparser.cpp.

{
    int braceCount = 0;
    int brackCount = 0;
    int parenCount = 0;
    if (index) {
        switch(symbols.at(index-1).token) {
        case LBRACE: ++braceCount; break;
        case LBRACKET: ++brackCount; break;
        case FUNCTION:
        case LPAREN: ++parenCount; break;
        default: ;
        }
    }
    while (index < symbols.size()) {
        QCss::TokenType t = symbols.at(index++).token;
        switch (t) {
        case LBRACE: ++braceCount; break;
        case RBRACE: --braceCount; break;
        case LBRACKET: ++brackCount; break;
        case RBRACKET: --brackCount; break;
        case FUNCTION:
        case LPAREN: ++parenCount; break;
        case RPAREN: --parenCount; break;
        default: break;
        }
        if ((t == target || (target2 != NONE && t == target2))
            && braceCount <= 0
            && brackCount <= 0
            && parenCount <= 0)
            return true;

        if (braceCount < 0 || brackCount < 0 || parenCount < 0) {
            --index;
            break;
        }
    }
    return false;
}

Properties

errorIndex

int QCss::Parser::errorIndex

Definition at line 831 of file qcssparser_p.h.

hasEscapeSequences

bool QCss::Parser::hasEscapeSequences

Definition at line 832 of file qcssparser_p.h.

index

int QCss::Parser::index

Definition at line 830 of file qcssparser_p.h.

sourcePath

QString QCss::Parser::sourcePath

Definition at line 833 of file qcssparser_p.h.

symbols

QVector<Symbol> QCss::Parser::symbols

Definition at line 829 of file qcssparser_p.h.

---

The documentation for this class was generated from the following files:

• /src/gui/text/qcssparser_p.h
• /src/gui/text/qcssparser.cpp