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;
}
}
bool Clipboard::setData(const String& type, const String& data)
{
if (!canWriteData())
return false;
return m_dataObject->setData(normalizeType(type), data);
}
void DataTransfer::setData(const String& type, const String& data)
{
if (!canWriteData())
return;
m_dataObject->setData(normalizeType(type), data);
}
void ResourceManager::addResource(Resource &resource, uint64 hash, ChangeID &change) {
normalizeType(resource);
ResourceMap::iterator resList = _resources.find(hash);
if (resList == _resources.end()) {
// We don't have a resource with this name yet, create a new resource list for it
std::pair<ResourceMap::iterator, bool> result;
result = _resources.insert(std::make_pair(hash, ResourceList()));
resList = result.first;
}
#ifdef CHECK_HASH_COLLISION
checkHashCollision(resource, resList);
#endif
// Add the resource to the list and sort by priority
resList->second.push_back(resource);
resList->second.sort();
// Remember the resource in the change set
change._change->resources.push_back(ResourceChange());
change._change->resources.back().hashIt = resList;
change._change->resources.back().resIt = --resList->second.end();
}
// like parseFunction, but never aborts with an error
bool Moc::parseMaybeFunction(FunctionDef *def)
{
def->type = parseType();
if (def->type.name.isEmpty())
return false;
bool scopedFunctionName = false;
if (test(LPAREN)) {
def->name = def->type.name;
scopedFunctionName = def->type.isScoped;
def->type = Type("int");
} else {
Type tempType = parseType();;
while (!tempType.name.isEmpty() && lookup() != LPAREN) {
if (def->type.name == "QT_MOC_COMPAT" || def->type.name == "QT3_SUPPORT")
def->isCompat = true;
else if (def->type.name == "Q_INVOKABLE")
def->isInvokable = true;
else if (def->type.name == "Q_SCRIPTABLE")
def->isInvokable = def->isScriptable = true;
else if (def->type.name == "Q_SIGNAL")
def->isSignal = true;
else if (def->type.name == "Q_SLOT")
def->isSlot = true;
else {
if (!def->tag.isEmpty())
def->tag += ' ';
def->tag += def->type.name;
}
def->type = tempType;
tempType = parseType();
}
if (!test(LPAREN))
return false;
def->name = tempType.name;
scopedFunctionName = tempType.isScoped;
}
// we don't support references as return types, it's too dangerous
if (def->type.referenceType == Type::Reference)
def->type = Type("void");
def->normalizedType = normalizeType(def->type.name);
if (!test(RPAREN)) {
parseFunctionArguments(def);
if (!test(RPAREN))
return false;
}
def->isConst = test(CONST);
if (scopedFunctionName
&& (def->isSignal || def->isSlot || def->isInvokable)) {
QByteArray msg("parsemaybe: Function declaration ");
msg += def->name;
msg += " contains extra qualification. Ignoring as signal or slot.";
warning(msg.constData());
return false;
}
return true;
}
static char *findType(struct hash *cvHash,char **requested,int requestCount,
char **queryBy, char **org,boolean silent)
/* returns the type that was requested or else the type associated with the term requested */
{
struct hashCookie hc = hashFirst(cvHash);
struct hashEl *hEl;
struct hash *ra;
char *type = typeOpt;
if (requested != NULL) // if no type, find it from requested terms. Will validate terms match type
{ // NOTE: Enter here even if there is a type, to confirm the type
while ((hEl = hashNext(&hc)) != NULL) // FIXME: This should be using mdbCv APIs to get hashes.
{ // One per "request[]"
ra = (struct hash *)hEl->val;
if (sameWord(hashMustFindVal(ra, CV_TYPE),CV_TOT)) // TOT = typeOfTerm
continue;
char *val = hashFindVal(ra, *queryBy);
if (val != NULL)
{
int ix = stringArrayIx(val,requested,requestCount);
if (ix != -1) // found
{
char *thisType = hashMustFindVal(ra, CV_TYPE);
char *thisOrg = hashFindVal(ra, ORGANISM);
if (type == NULL)
{
if (thisOrg != NULL)
{
*org = strLower(cloneString(thisOrg));
}
type = thisType;
}
else if (differentWord(type,thisType))
{
if (sameWord(CV_TERM_CONTROL,type))
type = thisType;
else if (differentWord(CV_TERM_CONTROL,thisType))
errAbort("Error: Requested %s of type '%s'. But '%s' has type '%s'\n",
*queryBy,type,requested[ix],thisType);
}
}
}
}
}
if (type == NULL && sameWord(*queryBy,CV_TERM)) // Special case of term becoming target
{
char *queryByTarget = CV_TARGET;
type = findType(cvHash,requested,requestCount,&queryByTarget,org,TRUE); // silent here
if (type != NULL)
*queryBy = queryByTarget;
}
if (type == NULL && !silent) // Still not type? abort
errAbort("Error: Required %s=%s ['%s', '%s', '%s', '%s' or '%s'] argument not found\n",
*queryBy,(requested != NULL) ? *requested : "?",
CV_TYPE, CV_TERM, CV_TAG, CV_TARGET, CV_LABEL);
return normalizeType(type);
}
void DataTransfer::clearData(const String& type) {
if (!canWriteData())
return;
if (type.isNull())
m_dataObject->clearAll();
else
m_dataObject->clearData(normalizeType(type));
}
String DataTransfer::getData(const String& type) const {
if (!canReadData())
return String();
bool convertToURL = false;
String data = m_dataObject->getData(normalizeType(type, &convertToURL));
if (!convertToURL)
return data;
return convertURIListToURL(data);
}
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);
}
}
// like parseFunction, but never aborts with an error
bool Moc::parseMaybeFunction(const ClassDef *cdef, FunctionDef *def)
{
def->isVirtual = false;
//skip modifiers and attributes
while (test(EXPLICIT) || test(INLINE) || test(STATIC) ||
(test(VIRTUAL) && (def->isVirtual = true)) //mark as virtual
|| testFunctionAttribute(def)) {}
bool tilde = test(TILDE);
def->type = parseType();
if (def->type.name.isEmpty())
return false;
bool scopedFunctionName = false;
if (test(LPAREN)) {
def->name = def->type.name;
scopedFunctionName = def->type.isScoped;
if (def->name == cdef->classname) {
def->isDestructor = tilde;
def->isConstructor = !tilde;
def->type = Type();
} else {
def->type = Type("int");
}
} else {
Type tempType = parseType();;
while (!tempType.name.isEmpty() && lookup() != LPAREN) {
if (testFunctionAttribute(def->type.firstToken, def))
; // fine
else if (def->type.name == "Q_SIGNAL")
def->isSignal = true;
else if (def->type.name == "Q_SLOT")
def->isSlot = true;
else {
if (!def->tag.isEmpty())
def->tag += ' ';
def->tag += def->type.name;
}
def->type = tempType;
tempType = parseType();
}
if (!test(LPAREN))
return false;
def->name = tempType.name;
scopedFunctionName = tempType.isScoped;
}
// we don't support references as return types, it's too dangerous
if (def->type.referenceType == Type::Reference)
def->type = Type("void");
def->normalizedType = normalizeType(def->type.name);
if (!test(RPAREN)) {
parseFunctionArguments(def);
if (!test(RPAREN))
return false;
}
def->isConst = test(CONST);
if (scopedFunctionName
&& (def->isSignal || def->isSlot || def->isInvokable)) {
QByteArray msg("parsemaybe: Function declaration ");
msg += def->name;
msg += " contains extra qualification. Ignoring as signal or slot.";
warning(msg.constData());
return false;
}
return true;
}
// returns false if the function should be ignored
bool Moc::parseFunction(FunctionDef *def, bool inMacro)
{
def->isVirtual = false;
//skip modifiers and attributes
while (test(INLINE) || test(STATIC) ||
(test(VIRTUAL) && (def->isVirtual = true)) //mark as virtual
|| testFunctionAttribute(def)) {}
bool templateFunction = (lookup() == TEMPLATE);
def->type = parseType();
if (def->type.name.isEmpty()) {
if (templateFunction)
error("Template function as signal or slot");
else
error();
}
bool scopedFunctionName = false;
if (test(LPAREN)) {
def->name = def->type.name;
scopedFunctionName = def->type.isScoped;
def->type = Type("int");
} else {
Type tempType = parseType();;
while (!tempType.name.isEmpty() && lookup() != LPAREN) {
if (testFunctionAttribute(def->type.firstToken, def))
; // fine
else if (def->type.firstToken == Q_SIGNALS_TOKEN)
error();
else if (def->type.firstToken == Q_SLOTS_TOKEN)
error();
else {
if (!def->tag.isEmpty())
def->tag += ' ';
def->tag += def->type.name;
}
def->type = tempType;
tempType = parseType();
}
next(LPAREN, "Not a signal or slot declaration");
def->name = tempType.name;
scopedFunctionName = tempType.isScoped;
}
// we don't support references as return types, it's too dangerous
if (def->type.referenceType == Type::Reference)
def->type = Type("void");
def->normalizedType = normalizeType(def->type.name);
if (!test(RPAREN)) {
parseFunctionArguments(def);
next(RPAREN);
}
// support optional macros with compiler specific options
while (test(IDENTIFIER))
;
def->isConst = test(CONST);
while (test(IDENTIFIER))
;
if (inMacro) {
next(RPAREN);
prev();
} else {
if (test(THROW)) {
next(LPAREN);
until(RPAREN);
}
if (test(SEMIC))
;
else if ((def->inlineCode = test(LBRACE)))
until(RBRACE);
else if ((def->isAbstract = test(EQ)))
until(SEMIC);
else
error();
}
if (scopedFunctionName) {
QByteArray msg("Function declaration ");
msg += def->name;
msg += " contains extra qualification. Ignoring as signal or slot.";
warning(msg.constData());
return false;
}
return true;
}
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;
}
