void ModItemsTree::findCompOfInheritingClassesInDescendants2(const QStringList & classNames,QString parentName,QString parentClass,QMultiMap<QString,QString> &result,QRegExp classFilter)
{
if(classFilter.isValid() && !parentClass.contains(classFilter))
return ;// no need to carry on
QStringList compShortNames,compClasses;
QString childLongName;
// quick version but does not catch everything
_moomc->getContainedComponents(parentClass,compShortNames,compClasses,true);
foreach(QString className, classNames)
{
for(int i=0;i<compClasses.size();i++)
{
if(!classFilter.isValid() || parentClass.contains(classFilter))
{
if((compClasses.at(i)==className)||_moomc->inherits(compClasses.at(i),className))
{
childLongName = parentClass.isEmpty() ? compShortNames.at(i) : parentName+"."+compShortNames.at(i);
result.insert(className,childLongName);
}
}
}
}
ModItem* compItem;
for(int i=0;i<compClasses.size();i++)
{
childLongName = parentClass.isEmpty() ? compShortNames.at(i) : parentName+"."+compShortNames.at(i);
findCompOfInheritingClassesInDescendants2(classNames,childLongName,compClasses.at(i),result,classFilter);
}
}
void CustomParserConfigDialog::changed()
{
QRegExp rx;
rx.setPattern(ui->errorPattern->text());
rx.setMinimal(true);
QPalette palette;
palette.setColor(QPalette::Text, rx.isValid() ? Qt::black : Qt::red);
ui->errorPattern->setPalette(palette);
ui->errorPattern->setToolTip(rx.isValid() ? QString() : rx.errorString());
int pos = rx.indexIn(ui->errorMessage->text());
if (rx.isEmpty() || !rx.isValid() || pos < 0) {
QString error = QLatin1String("<font color=\"red\">") + tr("Not applicable: ");
if (rx.isEmpty())
error += tr("Pattern is empty.");
else if (!rx.isValid())
error += rx.errorString();
else
error += tr("Pattern does not match the error message.");
ui->fileNameTest->setText(error);
ui->lineNumberTest->setText(error);
ui->messageTest->setText(error);
ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
return;
}
ui->fileNameTest->setText(rx.cap(ui->fileNameCap->value()));
ui->lineNumberTest->setText(rx.cap(ui->lineNumberCap->value()));
ui->messageTest->setText(rx.cap(ui->messageCap->value()));
ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
m_dirty = true;
}
static bool isIntegerList(const QString &s)
{
// Check for empty string or comma-separated list of integers
static const QRegExp re(QLatin1String("[0-9]+(,[0-9]+)+"));
Q_ASSERT(re.isValid());
return s.isEmpty() || re.exactMatch(s);
}
void PerforceSubmitEditor::updateFields()
{
PerforceSubmitEditorWidget *widget = submitEditorWidget();
widget->setData(m_entries.value(QLatin1String("Change")).trimmed(),
m_entries.value(QLatin1String("Client")).trimmed(),
m_entries.value(QLatin1String("User")).trimmed());
const QString newLine = QString(QLatin1Char('\n'));
QStringList lines = m_entries.value(QLatin1String("Description")).split(newLine);
lines.removeFirst(); // that is the line break after 'Description:'
lines.removeLast(); // that is the empty line at the end
const QRegExp leadingTabPattern = QRegExp(QLatin1String("^\\t"));
QTC_ASSERT(leadingTabPattern.isValid(), /**/);
lines.replaceInStrings(leadingTabPattern, QString());
widget->setDescriptionText(lines.join(newLine));
lines = m_entries.value(QLatin1String("Files")).split(newLine);
// split up "file#add" and store complete spec line as user data
foreach (const QString &specLine, lines) {
const QStringList list = specLine.split(QLatin1Char('#'));
if (list.size() == 2) {
const QString file = list.at(0).trimmed();
const QString state = list.at(1).trimmed();
m_fileModel->addFile(file, state).at(0)->setData(specLine, FileSpecRole);
}
}
}
RvctToolChain::RvctVersion RvctToolChain::version(const QString &rvctPath)
{
RvctToolChain::RvctVersion v;
QProcess armcc;
const QString binary = rvctPath;
armcc.start(binary, QStringList());
if (!armcc.waitForStarted()) {
qWarning("Unable to run rvct binary '%s' when trying to determine version.", qPrintable(binary));
return v;
}
armcc.closeWriteChannel();
if (!armcc.waitForFinished()) {
Utils::SynchronousProcess::stopProcess(armcc);
qWarning("Timeout running rvct binary '%s' trying to determine version.", qPrintable(binary));
return v;
}
if (armcc.exitStatus() != QProcess::NormalExit) {
qWarning("A crash occurred when running rvct binary '%s' trying to determine version.", qPrintable(binary));
return v;
}
QString versionLine = QString::fromLocal8Bit(armcc.readAllStandardOutput());
versionLine += QString::fromLocal8Bit(armcc.readAllStandardError());
const QRegExp versionRegExp(QLatin1String("RVCT(\\d*)\\.(\\d*).*\\[Build.(\\d*)\\]"),
Qt::CaseInsensitive);
Q_ASSERT(versionRegExp.isValid());
if (versionRegExp.indexIn(versionLine) != -1) {
v.majorVersion = versionRegExp.cap(1).toInt();
v.minorVersion = versionRegExp.cap(2).toInt();
v.build = versionRegExp.cap(3).toInt();
}
return v;
}
void ItemEditorWidget::search(const QRegExp &re, bool backwards)
{
if ( !re.isValid() )
return;
auto tc = textCursor();
if ( tc.isNull() )
return;
QTextDocument::FindFlags flags;
if (backwards)
flags = QTextDocument::FindBackward;
auto tc2 = tc.document()->find(re, tc, flags);
if (tc2.isNull()) {
tc2 = tc;
if (backwards)
tc2.movePosition(QTextCursor::End);
else
tc2.movePosition(QTextCursor::Start);
tc2 = tc.document()->find(re, tc2, flags);
}
if (!tc2.isNull())
setTextCursor(tc2);
}
void SearchDialog::doSearch()
{
QRegExp re;
re.setWildcard(true); // most people understand these better.
re.setCaseSensitive(false);
re.setPattern(searchEdit->text());
if(!re.isValid())
{
KMessageBox::sorry(this,
i18n("Invalid search expression, cannot perform "
"the search. Please enter a search expression "
"using the wildcard characters '*' and '?' "
"where needed."));
return;
}
search(re);
listView->showIncidences(mMatchedEvents);
if(mMatchedEvents.count() == 0)
{
KMessageBox::information(this,
i18n("No events were found matching your search expression."),
"NoSearchResults");
}
}
MessageHandler::Result ScriptMessageHandler::doHandle(Message &message, QString *reason)
{
Q_UNUSED(reason);
if (message.isIncoming())
return MessageHandler::Accept;
QLatin1Literal command("/script");
QString text = message.text();
if (text.size() < command.size() + 2
|| !text.startsWith(QLatin1String(command.data()))
|| !text.at(command.size()).isSpace()) {
static QRegExp regexp("\\[\\[(.*)\\]\\]", Qt::CaseInsensitive);
Q_ASSERT(regexp.isValid());
int pos = 0;
bool first = true;
while ((pos = regexp.indexIn(text, pos)) != -1) {
if (first) {
first = false;
openContext(message.chatUnit());
}
QString result = m_engine->evaluate(regexp.cap(1)).toString();
debug() << regexp.cap(1) << result;
text.replace(pos, regexp.matchedLength(), result);
pos += result.length();
}
if (!first) {
closeContext();
message.setText(text);
}
return MessageHandler::Accept;
}
openContext(message.chatUnit());
m_engine->evaluate(message.text().mid(command.size() + 1));
closeContext();
return MessageHandler::Reject;
}
QSObject QSRegExpClass::fetchValue( const QSObject *objPtr,
const QSMember &mem ) const
{
if ( mem.type() != QSMember::Custom )
return QSWritableClass::fetchValue( objPtr, mem );
QRegExp *re = regExp( objPtr );
switch ( mem.index() ) {
case Valid:
return createBoolean( re->isValid() );
case Empty:
return createBoolean( re->isEmpty() );
case MLength:
return createNumber( re->matchedLength() );
case Source:
return createString( source(objPtr) );
case Global:
return createBoolean( isGlobal(objPtr) );
case IgnoreCase:
return createBoolean( isIgnoreCase(objPtr) );
case CTexts: {
QSArray array( env() );
QStringList ct = re->capturedTexts();
QStringList::ConstIterator it = ct.begin();
int i = 0;
for ( ; it != ct.end(); ++it, ++i )
array.put( QString::number( i ), createString( *it ) );
array.put( QString::fromLatin1("length"), createNumber( i ) );
return array;
}
default:
return createUndefined();
}
}
QRegExp* XMLUtility::readRegExp(QXmlStreamReader& reader)
{
QRegExp* regExp = new QRegExp();
if (reader.attributes().hasAttribute("IsMinimal"))
{
regExp->setMinimal(stringToBoolean(reader.attributes().value("IsMinimal").toString()));
}
if (reader.attributes().hasAttribute("CaseSensitive"))
{
regExp->setCaseSensitivity(stringToCase(reader.attributes().value("CaseSensitive").toString()));
}
if (reader.attributes().hasAttribute("PatternSyntax"))
{
regExp->setPatternSyntax(getEnumMapper().stringToPatternSyntax(reader.attributes().value("PatternSyntax").toString()));
}
while (!reader.isEndElement())
{
if (reader.isCharacters())
{
regExp->setPattern(reader.text().toString());
}
reader.readNext();
}
if (!regExp->isValid())
{
delete regExp;
regExp = nullptr;
}
return regExp;
}
void ModelGrouper::setColumnGroupRegex( int column, const QRegExp & regEx )
{
if( regEx.isValid() )
mColumnRegexMap[column] = regEx;
else
mColumnRegexMap.remove(column);
}
// parseInt()
static QSObject qsParseInt( QSEnv *env )
{
if( env->numArgs() < 1 )
return QSObject();
QString str = env->arg( 0 ).toString();
int radix;
if (env->numArgs()==1) {
if (str.startsWith(QString::fromLatin1("0x")))
radix = 16;
else if (str.startsWith(QString::fromLatin1("0")))
radix = 8;
else
radix = 10;
} else {
radix = env->arg( 1 ).toInt32();
if (radix < 2 || radix > 36 )
return env->createNumber(NaN);
}
QRegExp re = qs_regexp_for_radix(radix);
Q_ASSERT(re.isValid());
int pos = str.indexOf(re);
if (pos >= 0) {
str = re.cap(1);
bool ok = false;
int val = str.toInt(&ok, radix);
if (ok)
return env->createNumber(val);
}
return env->createNumber(NaN);
}
void QtLineEditFactory::slotRegExpChanged(QtProperty *property,
const QRegExp ®Exp)
{
if (!m_createdEditors.contains(property))
return;
QtStringPropertyManager *manager = this->propertyManager(property);
if (!manager)
return;
QListIterator<QLineEdit *> itEditor(m_createdEditors[property]);
while (itEditor.hasNext()) {
QLineEdit *editor = itEditor.next();
editor->blockSignals(true);
const QValidator *oldValidator = editor->validator();
QValidator *newValidator = 0;
if (regExp.isValid()) {
newValidator = new QRegExpValidator(regExp, editor);
}
editor->setValidator(newValidator);
if (oldValidator)
delete oldValidator;
editor->blockSignals(false);
}
}
void JSoftwareDetection::handlePresence(const Jreen::Presence &presence)
{
QString jid = presence.from().full();
ChatUnit *unit = m_account->getUnit(jid, false);
if (JContactResource *resource = qobject_cast<JContactResource *>(unit)) {
if (!resource->features().isEmpty())
return;
setClientInfo(resource, "", "unknown-client");
QString node;
if (Jreen::Capabilities::Ptr caps = presence.payload<Jreen::Capabilities>()) {
// qDebug() << "handle caps" << caps->node();
QString capsNode = caps->node();
if(capsNode == QLatin1String("http://www.android.com/gtalk/client/caps")) {
QString software = "GTalk (Android)";
QString softwareVersion = caps->ver();
QString client = getClientDescription(software, softwareVersion, QString());
updateClientData(resource, client, software, softwareVersion, QString(), "gtalk-android");
return;
}
static const QRegExp regExp("^http://.*google.com/.*client/caps$");
Q_ASSERT(regExp.isValid());
if(regExp.exactMatch(capsNode)) {
QString software = "GTalk";
if(capsNode.startsWith("http://mail."))
software += " (GMail)";
else if(capsNode.startsWith("http://talkgadget."))
software += " (Gadget)";
QString softwareVersion = caps->ver();
QString client = getClientDescription(software, softwareVersion, QString());
updateClientData(resource, client, software, softwareVersion, QString(), "gtalk");
return;
} else {
node = caps->node() + '#' + caps->ver();
unit->setProperty("node", node);
SoftwareInfoHash::iterator it = m_hash.find(node);
// qDebug() << "find from hash" << m_hash.count();
if (it != m_hash.end()) {
SoftwareInfo &info = *it;
resource->setFeatures(info.features);
// qDebug() << info.name;
if (!info.finished) {
// qDebug() << "Send software version request";
requestSoftware(presence.from());
} else {
updateClientData(resource, info.description, info.name, info.version, info.os, info.icon);
}
return;
}
}
}
setClientInfo(resource, "", "unknown-client");
Jreen::Disco::Item discoItem(presence.from(), node, QString());
Jreen::DiscoReply *reply = m_account->client()->disco()->requestInfo(discoItem);
connect(reply, SIGNAL(finished()), SLOT(onInfoRequestFinished()));
}
}
bool MainWindow::checkRegx(QRegExp rx)
{
if (!rx.isValid() && rx.isEmpty() && rx.exactMatch("")){
QMessageBox::information(this, "", "Not valid regx");
return false;
}
else
return true;
}
static QRect stringToRectangle(const QString &v)
{
static QRegExp pattern(QLatin1String("(\\d+)x(\\d+)([-+]\\d+)([-+]\\d+)"));
Q_ASSERT(pattern.isValid());
return pattern.exactMatch(v) ?
QRect(QPoint(pattern.cap(3).toInt(), pattern.cap(4).toInt()),
QSize(pattern.cap(1).toInt(), pattern.cap(2).toInt())) :
QRect();
}
QString ModelGrouper::groupValue( const QModelIndex & idx )
{
QRegExp regEx = columnGroupRegex(mGroupColumn);
QString strValue = model()->data( idx.column() == mGroupColumn ? idx : idx.sibling(idx.row(),mGroupColumn), Qt::DisplayRole ).toString();
if( !regEx.isEmpty() && regEx.isValid() && strValue.contains(regEx) )
strValue = regEx.cap(regEx.captureCount() > 1 ? 1 : 0);
//LOG_5( QString("Index %1 grouped with value %2").arg(indexToStr(idx)).arg(strValue) );
return strValue;
}
void SpecialOrderEditor::applyFilter(const QString &text)
{
QRegExp regexp = QRegExp(text);
if (!regexp.isValid()) ui->editFilter->setText("");
if (text == "*" || text == "") m_model->setFilter("products.isARawProduct=true and products.isAGroup=false ");
else m_model->setFilter(QString("products.isARawProduct=true and products.isAGroup=false and products.name REGEXP '%1'").arg(text));
m_model->select();
}
void ItemEditorWidget::search(const QRegExp &re)
{
if ( !re.isValid() || re.isEmpty() )
return;
auto tc = textCursor();
tc.setPosition(tc.selectionStart());
setTextCursor(tc);
findNext(re);
}
DiffHighlighterPrivate::DiffHighlighterPrivate(const QRegExp &filePattern) :
q_ptr(0),
m_filePattern(filePattern),
m_locationIndicator(QLatin1String("@@")),
m_diffInIndicator(QLatin1Char('+')),
m_diffOutIndicator(QLatin1Char('-')),
m_foldingState(Internal::StartOfFile)
{
QTC_CHECK(filePattern.isValid());
}
int PopupProxy::buildParent( int index, const QRegExp& filter ) {
deleteMoreMenus();
// Start from top of history (again)
m_spill_uuid = parent()->history()->empty() ? QByteArray() : parent()->history()->first()->uuid();
if ( filter.isValid() ) {
m_filter = filter;
}
return insertFromSpill( index );
}
/*!
\internal
Determines whether \a encName is a valid instance of production [81]EncName in the XML 1.0
specification. If it is, true is returned, otherwise false.
\sa \l {http://www.w3.org/TR/REC-xml/#NT-EncName}
{Extensible Markup Language (XML) 1.0 (Fourth Edition), [81] EncName}
*/
bool QXmlUtils::isEncName(const QString &encName)
{
/* Right, we here have a dependency on QRegExp. Writing a manual parser to
* replace that regexp is probably a 70 lines so I prioritize this to when
* the dependency is considered alarming, or when the rest of the bugs
* are fixed. */
const QRegExp encNameRegExp(QLatin1String("[A-Za-z][A-Za-z0-9._\\-]*"));
Q_ASSERT(encNameRegExp.isValid());
return encNameRegExp.exactMatch(encName);
}
void GenericProperty::setStringRegExp(const QRegExp &new_value) {
if (!new_value.isValid() || new_value.isEmpty())
return;
if (d->string_reg_exp != new_value) {
if (d->type == TypeString && !new_value.exactMatch(d->value))
setValueString(d->default_value);
d->string_reg_exp = new_value;
emit possibleValuesDisplayedChanged(this);
}
}
QWidget *WidgetBoxCategoryEntryDelegate::createEditor(QWidget *parent,
const QStyleOptionViewItem &option,
const QModelIndex &index) const
{
QWidget *result = QItemDelegate::createEditor(parent, option, index);
if (QLineEdit *line_edit = qobject_cast<QLineEdit*>(result)) {
QRegExp re = QRegExp(QStringLiteral("[_a-zA-Z][_a-zA-Z0-9]*"));
Q_ASSERT(re.isValid());
line_edit->setValidator(new QRegExpValidator(re, line_edit));
}
return result;
}
DiffAndLogHighlighterPrivate(DiffAndLogHighlighter *q_, const QRegExp &filePattern,
const QRegExp &changePattern) :
q(q_),
m_filePattern(filePattern),
m_changePattern(changePattern),
m_locationIndicator(QLatin1String("@@")),
m_diffInIndicator(QLatin1Char('+')),
m_diffOutIndicator(QLatin1Char('-')),
m_foldingState(Internal::StartOfFile)
{
QTC_CHECK(filePattern.isValid());
}
void PatternPlatform::applyFlags(const Flags flags, QRegExp &patternP)
{
Q_ASSERT(patternP.isValid());
if(flags == NoFlags)
return;
if(flags & CaseInsensitive)
{
patternP.setCaseSensitivity(Qt::CaseInsensitive);
}
// TODO Apply the other flags, like 'x'.
}
QList<FilterEntry> BaseFileFilter::matchesFor(QFutureInterface<Locator::FilterEntry> &future, const QString &origEntry)
{
updateFiles();
QList<FilterEntry> matches;
QList<FilterEntry> badMatches;
QString needle = trimWildcards(origEntry);
QStringMatcher matcher(needle, Qt::CaseInsensitive);
const QChar asterisk = QLatin1Char('*');
const QRegExp regexp(asterisk + needle+ asterisk, Qt::CaseInsensitive, QRegExp::Wildcard);
if (!regexp.isValid())
return matches;
bool hasWildcard = (needle.contains(asterisk) || needle.contains('?'));
QStringList searchListPaths;
QStringList searchListNames;
if (!m_previousEntry.isEmpty() && !m_forceNewSearchList && needle.contains(m_previousEntry)) {
searchListPaths = m_previousResultPaths;
searchListNames = m_previousResultNames;
} else {
searchListPaths = m_files;
searchListNames = m_fileNames;
}
m_previousResultPaths.clear();
m_previousResultNames.clear();
m_forceNewSearchList = false;
m_previousEntry = needle;
QStringListIterator paths(searchListPaths);
QStringListIterator names(searchListNames);
while (paths.hasNext() && names.hasNext()) {
if (future.isCanceled())
break;
QString path = paths.next();
QString name = names.next();
if ((hasWildcard && regexp.exactMatch(name))
|| (!hasWildcard && matcher.indexIn(name) != -1)) {
QFileInfo fi(path);
FilterEntry entry(this, fi.fileName(), path);
entry.extraInfo = QDir::toNativeSeparators(fi.path());
entry.resolveFileIcon = true;
if (name.startsWith(needle))
matches.append(entry);
else
badMatches.append(entry);
m_previousResultPaths.append(path);
m_previousResultNames.append(name);
}
}
matches.append(badMatches);
return matches;
}
/*!
Gets several parameters from the \a config, including
tab size, program name, and a regular expression that
appears to be used for matching certain error messages
so that emitMessage() can avoid printing them.
*/
void Location::initialize(const Config& config)
{
tabSize = config.getInt(CONFIG_TABSIZE);
programName = config.programName();
QRegExp regExp = config.getRegExp(CONFIG_SPURIOUS);
if (regExp.isValid()) {
spuriousRegExp = new QRegExp(regExp);
}
else {
config.lastLocation().warning(tr("Invalid regular expression '%1'")
.arg(regExp.pattern()));
}
}
void XMLUtility::write(QXmlStreamWriter& writer, const QRegExp& regExp, const QString& name)
{
if (regExp.isEmpty() || !regExp.isValid() || name.length() == 0)
{
return;
}
writer.writeStartElement(name);
writer.writeAttribute("IsMinimal", booleanToString(regExp.isMinimal()));
writer.writeAttribute("CaseSensitive", caseToString(regExp.caseSensitivity()));
writer.writeAttribute("PatternSyntax", getEnumMapper().PatternSyntaxToString(regExp.patternSyntax()));
writer.writeCharacters(regExp.pattern());
writer.writeEndElement();
}
void FilterDialog::validate()
{
QString
error = "Could not parse %1 regular expression. \n";
error += "Please correct the error or remove the regular expression.\n";
error += "Expression: '%2' \n";
error += "Error: %3 ";
if(!(getEnableRegexp_Context()||getEnableRegexp_Header()||getEnableRegexp_Payload()))
{
emit accept();
return;
}
QRegExp rx;
rx.setPattern(getPayloadText());
if(!rx.isValid()) {
QMessageBox::warning(this, "Warning", error.arg("PAYLOAD").arg(rx.pattern()).arg(rx.errorString()));
return;
}
rx.setPattern(getHeaderText());
if(!rx.isValid()) {
QMessageBox::warning(this, "Warning", error.arg("HEADER").arg(rx.pattern()).arg(rx.errorString()));
return;
}
rx.setPattern(getContextId());
if(!rx.isValid()) {
QMessageBox::warning(this, "Warning", error.arg("CONTEXTID").arg(rx.pattern()).arg(rx.errorString()));
return;
}
emit accept();
}
