NFA RE2NFA::parseAtom()
{
// ####
switch (next()) {
case TOK_STRING:
return createCharNFA();
case TOK_LPAREN: {
NFA subExpr = parseExpr();
next(TOK_RPAREN);
return subExpr;
}
case TOK_LBRACE: {
QString macroName = lexemUntil(TOK_RBRACE);
QMap<QString, NFA>::ConstIterator macro = macros.find(macroName);
if (macro == macros.end()) {
qWarning("Unknown macro '%s' - probably used before defined", qPrintable(macroName));
return NFA();
}
return *macro;
}
case TOK_LBRACKET: {
NFA set = parseSet();
next(TOK_RBRACKET);
return set;
}
case TOK_SEQUENCE:
return parseSet2();
case TOK_DOT:
return NFA::createSetNFA(maxInputSet);
default:
prev();
return NFA();
}
}
void Moc::parseFunctionArguments(FunctionDef *def)
{
Q_UNUSED(def);
while (hasNext()) {
ArgumentDef arg;
arg.type = parseType();
if (arg.type.name == "void")
break;
if (test(IDENTIFIER))
arg.name = lexem();
while (test(LBRACK)) {
arg.rightType += lexemUntil(RBRACK);
}
if (test(CONST) || test(VOLATILE)) {
arg.rightType += ' ';
arg.rightType += lexem();
}
arg.normalizedType = normalizeType(arg.type.name + ' ' + arg.rightType);
arg.typeNameForCast = normalizeType(noRef(arg.type.name) + "(*)" + arg.rightType);
if (test(EQ))
arg.isDefault = true;
def->arguments += arg;
if (!until(COMMA))
break;
}
}
void Moc::parseDeclareMetatype()
{
next(LPAREN);
QByteArray typeName = lexemUntil(RPAREN);
typeName.remove(0, 1);
typeName.chop(1);
metaTypes.append(typeName);
}
void Moc::parseSignals(ClassDef *def)
{
int defaultRevision = -1;
if (test(Q_REVISION_TOKEN)) {
next(LPAREN);
QByteArray revision = lexemUntil(RPAREN);
revision.remove(0, 1);
revision.chop(1);
bool ok = false;
defaultRevision = revision.toInt(&ok);
if (!ok || defaultRevision < 0)
error("Invalid revision");
}
next(COLON);
while (inClass(def) && hasNext()) {
switch (next()) {
case PUBLIC:
case PROTECTED:
case PRIVATE:
case Q_SIGNALS_TOKEN:
case Q_SLOTS_TOKEN:
prev();
return;
case SEMIC:
continue;
case FRIEND:
until(SEMIC);
continue;
case USING:
error("'using' directive not supported in 'signals' section");
default:
prev();
}
FunctionDef funcDef;
funcDef.access = FunctionDef::Protected;
parseFunction(&funcDef);
if (funcDef.isVirtual)
warning("Signals cannot be declared virtual");
if (funcDef.inlineCode)
error("Not a signal declaration");
if (funcDef.revision > 0) {
++def->revisionedMethods;
} else if (defaultRevision != -1) {
funcDef.revision = defaultRevision;
++def->revisionedMethods;
}
def->signalList += funcDef;
while (funcDef.arguments.size() > 0 && funcDef.arguments.last().isDefault) {
funcDef.wasCloned = true;
funcDef.arguments.removeLast();
def->signalList += funcDef;
}
}
}
bool Moc::testFunctionRevision(FunctionDef *def)
{
if (test(Q_REVISION_TOKEN)) {
next(LPAREN);
QByteArray revision = lexemUntil(RPAREN);
revision.remove(0, 1);
revision.chop(1);
bool ok = false;
def->revision = revision.toInt(&ok);
if (!ok || def->revision < 0)
error("Invalid revision");
return true;
}
return false;
}
void Moc::createPropertyDef(PropertyDef &propDef)
{
QByteArray type = parseType().name;
if (type.isEmpty())
error();
propDef.designable = propDef.scriptable = propDef.stored = "true";
propDef.user = "******";
/*
The Q_PROPERTY construct cannot contain any commas, since
commas separate macro arguments. We therefore expect users
to type "QMap" instead of "QMap<QString, QVariant>". For
coherence, we also expect the same for
QValueList<QVariant>, the other template class supported by
QVariant.
*/
type = normalizeType(type);
if (type == "QMap")
type = "QMap<QString,QVariant>";
else if (type == "QValueList")
type = "QValueList<QVariant>";
else if (type == "LongLong")
type = "qlonglong";
else if (type == "ULongLong")
type = "qulonglong";
else if (type == "qreal")
mustIncludeQMetaTypeH = true;
propDef.type = type;
next();
propDef.name = lexem();
while (test(IDENTIFIER)) {
QByteArray l = lexem();
if (l[0] == 'C' && l == "CONSTANT") {
propDef.constant = true;
continue;
} else if(l[0] == 'F' && l == "FINAL") {
propDef.final = true;
continue;
}
QByteArray v, v2;
if (test(LPAREN)) {
v = lexemUntil(RPAREN);
} else {
next(IDENTIFIER);
v = lexem();
if (test(LPAREN))
v2 = lexemUntil(RPAREN);
else if (v != "true" && v != "false")
v2 = "()";
}
switch (l[0]) {
case 'R':
if (l == "READ")
propDef.read = v;
else if (l == "RESET")
propDef.reset = v + v2;
else
error(2);
break;
case 'S':
if (l == "SCRIPTABLE")
propDef.scriptable = v + v2;
else if (l == "STORED")
propDef.stored = v + v2;
else
error(2);
break;
case 'W': if (l != "WRITE") error(2);
propDef.write = v;
break;
case 'D': if (l != "DESIGNABLE") error(2);
propDef.designable = v + v2;
break;
case 'E': if (l != "EDITABLE") error(2);
propDef.editable = v + v2;
break;
case 'N': if (l != "NOTIFY") error(2);
propDef.notify = v;
break;
case 'U': if (l != "USER") error(2);
propDef.user = v + v2;
break;
default:
error(2);
}
}
Type Moc::parseType()
{
Type type;
bool hasSignedOrUnsigned = false;
bool isVoid = false;
type.firstToken = lookup();
for (;;) {
switch (next()) {
case SIGNED:
case UNSIGNED:
hasSignedOrUnsigned = true;
// fall through
case CONST:
case VOLATILE:
type.name += lexem();
type.name += ' ';
if (lookup(0) == VOLATILE)
type.isVolatile = true;
continue;
case Q_MOC_COMPAT_TOKEN:
case Q_QT3_SUPPORT_TOKEN:
case Q_INVOKABLE_TOKEN:
case Q_SCRIPTABLE_TOKEN:
case Q_SIGNALS_TOKEN:
case Q_SLOTS_TOKEN:
case Q_SIGNAL_TOKEN:
case Q_SLOT_TOKEN:
type.name += lexem();
return type;
default:
prev();
break;
}
break;
}
test(ENUM) || test(CLASS) || test(STRUCT);
for(;;) {
switch (next()) {
case IDENTIFIER:
// void mySlot(unsigned myArg)
if (hasSignedOrUnsigned) {
prev();
break;
}
case CHAR:
case SHORT:
case INT:
case LONG:
type.name += lexem();
// preserve '[unsigned] long long', 'short int', 'long int', 'long double'
if (test(LONG) || test(INT) || test(DOUBLE)) {
type.name += ' ';
prev();
continue;
}
break;
case FLOAT:
case DOUBLE:
case VOID:
case BOOL:
type.name += lexem();
isVoid |= (lookup(0) == VOID);
break;
default:
prev();
;
}
if (test(LANGLE)) {
QByteArray templ = lexemUntil(RANGLE);
for (int i = 0; i < templ.size(); ++i) {
type.name += templ.at(i);
if ((templ.at(i) == '<' && i < templ.size()-1 && templ.at(i+1) == ':')
|| (templ.at(i) == '>' && i < templ.size()-1 && templ.at(i+1) == '>')) {
type.name += ' ';
}
}
}
if (test(SCOPE)) {
type.name += lexem();
type.isScoped = true;
} else {
break;
}
}
while (test(CONST) || test(VOLATILE) || test(SIGNED) || test(UNSIGNED)
|| test(STAR) || test(AND) || test(ANDAND)) {
type.name += ' ';
type.name += lexem();
if (lookup(0) == AND)
type.referenceType = Type::Reference;
else if (lookup(0) == ANDAND)
type.referenceType = Type::RValueReference;
else if (lookup(0) == STAR)
type.referenceType = Type::Pointer;
}
// transform stupid things like 'const void' or 'void const' into 'void'
if (isVoid && type.referenceType == Type::NoReference) {
type.name = "void";
}
return type;
}
void Moc::parseProperty(ClassDef *def)
{
next(LPAREN);
PropertyDef propDef;
QByteArray type = parseType().name;
if (type.isEmpty())
error();
propDef.designable = propDef.scriptable = propDef.stored = "true";
propDef.user = "******";
/*
The Q_PROPERTY construct cannot contain any commas, since
commas separate macro arguments. We therefore expect users
to type "QMap" instead of "QMap<QString, QVariant>". For
coherence, we also expect the same for
QValueList<QVariant>, the other template class supported by
QVariant.
*/
type = normalizeType(type);
if (type == "QMap")
type = "QMap<QString,QVariant>";
else if (type == "QValueList")
type = "QValueList<QVariant>";
else if (type == "LongLong")
type = "qlonglong";
else if (type == "ULongLong")
type = "qulonglong";
propDef.type = type;
next();
propDef.name = lexem();
while (test(IDENTIFIER)) {
QByteArray l = lexem();
QByteArray v, v2;
if (test(LPAREN)) {
v = lexemUntil(RPAREN);
} else {
next(IDENTIFIER);
v = lexem();
if (test(LPAREN))
v2 = lexemUntil(RPAREN);
else if (v != "true" && v != "false")
v2 = "()";
}
switch (l[0]) {
case 'R':
if (l == "READ")
propDef.read = v;
else if (l == "RESET")
propDef.reset = v + v2;
else
error(2);
break;
case 'S':
if (l == "SCRIPTABLE")
propDef.scriptable = v + v2;
else if (l == "STORED")
propDef.stored = v + v2;
else
error(2);
break;
case 'W': if (l != "WRITE") error(2);
propDef.write = v;
break;
case 'D': if (l != "DESIGNABLE") error(2);
propDef.designable = v + v2;
break;
case 'E': if (l != "EDITABLE") error(2);
propDef.editable = v + v2;
break;
case 'N': if (l != "NOTIFY") error(2);
propDef.notify = v;
break;
case 'U': if (l != "USER") error(2);
propDef.user = v + v2;
break;
default:
error(2);
}
}
next(RPAREN);
if (propDef.read.isNull()) {
QByteArray msg;
msg += "Property declaration ";
msg += propDef.name;
msg += " has no READ accessor function. The property will be invalid.";
warning(msg.constData());
}
if(!propDef.notify.isEmpty())
def->notifyableProperties++;
def->propertyList += propDef;
}
