bool 
Reader::decodeUnicodeEscapeSequence( Token &token, 
                                     Location &current, 
                                     Location end, 
                                     unsigned int &unicode )
{
   if ( end - current < 4 )
      return addError( "Bad unicode escape sequence in string: four digits expected.", token, current );
   unicode = 0;
   for ( int index =0; index < 4; ++index )
   {
      Char c = *current++;
      unicode *= 16;
      if ( c >= '0'  &&  c <= '9' )
         unicode += c - '0';
      else if ( c >= 'a'  &&  c <= 'f' )
         unicode += c - 'a' + 10;
      else if ( c >= 'A'  &&  c <= 'F' )
         unicode += c - 'A' + 10;
      else
         return addError( "Bad unicode escape sequence in string: hexadecimal digit expected.", token, current );
   }
   return true;
}
Example #2
0
/**
 * \brief
 * judge expr is divided by zero or add error
 *
 * @param expr
 *      target node
 * @param nk
 *      number value kind
 * @param nv
 *      number value
 * @return
 *      0:no error, 1:error
 */
PRIVATE_STATIC int
checkDivisionByZero(CExpr *expr, CNumValueKind nk, CNumValue *nv)
{
    int err = 0;
    switch(nk) {
    case NK_LL:  err = (nv->ll == 0); break;
    case NK_ULL: err = (nv->ull == 0); break;
    case NK_LD:  err = (nv->ld == 0.0); break;
    }

    if(err)
        addError(expr, CERR_015);

    return err;
}
Example #3
0
bool WheelBaseData::hasDuplicateChars(QString alphabet)
{
    bool result = false;
    QString msg;

    // the same character may not appear more than once in the alphabet
    if (GenLib::hasDuplicateChars(alphabet))
    {
        msg = QString("[%1] has duplicate characters").arg(alphabet);
        addError(msg);
        result = true;
    }

    return result;
}
Example #4
0
bool WheelBaseData::isUniqueName(QSqlQuery qry, QString errMsg)
{
    bool result = true;

    if (GenLib::execQry(qry, true))
    {
        if (qry.record().value("recCount").toInt() == 0)
        {
            result = true;
        }
        else
        {
            result = false;
            addError(errMsg);
        }
    }
    else
    {
        result = false;
        addError(qry.lastError().text());
    }

    return result;
}
	bool
		Reader::readValue()
	{
		Token token;
		skipCommentTokens( token );
		bool successful = true;

		if ( collectComments_  &&  !commentsBefore_.empty() )
		{
			currentValue().setComment( commentsBefore_, commentBefore );
			commentsBefore_ = "";
		}

		switch ( token.type_ )
		{
		case tokenObjectBegin:
			successful = readObject( token );
			break;
		case tokenArrayBegin:
			successful = readArray( token );
			break;
		case tokenNumber:
			successful = decodeNumber( token );
			break;
		case tokenString:
			successful = decodeString( token );
			break;
		case tokenTrue:
			currentValue() = true;
			break;
		case tokenFalse:
			currentValue() = false;
			break;
		case tokenNull:
			currentValue() = Value();
			break;
		default:
			return addError( "Syntax error: value, object or array expected.", token );
		}

		if ( collectComments_ )
		{
			lastValueEnd_ = current_;
			lastValue_ = &currentValue();
		}

		return successful;
	}
Example #6
0
static void					checkLine(char *s, int line, t_asm *asM)
{
	int					i;
	char				*tmp;

	i = 0;
	while (s[i])
	{
		if (ft_strchr(AUTH_CHAR, s[i]) == NULL)
		{
			tmp = ft_strjoinwsep("Unauthorized char : ", "", s[i]);
			addError(tmp, line, asM);
		}
		i++;
	}
}
Example #7
0
void MetaInfoReader::elementStart(const QString &name)
{
    switch (parserState()) {
    case ParsingDocument: setParserState(readDocument(name)); break;
    case ParsingMetaInfo: setParserState(readMetaInfoRootElement(name)); break;
    case ParsingType: setParserState(readTypeElement(name)); break;
    case ParsingItemLibrary: setParserState(readItemLibraryEntryElement(name)); break;
    case ParsingProperty: setParserState(readPropertyElement(name)); break;
    case ParsingQmlSource: setParserState(readQmlSourceElement(name)); break;
    case Finished:
    case Undefined: setParserState(Error);
        addError(tr("Illegal state while parsing"), currentSourceLocation());
    case Error:
    default: return;
    }
}
Example #8
0
bool WheelBaseData::isNameMinLengthOk(QString name)
{
    bool result = true;


    if (name.length() < AlphabetData::MIN_ALPHABET_NAME_LENGTH)
    {
        QString msg = QString("Name must contain at least %1 characters").
                        arg(AlphabetData::MIN_ALPHABET_NAME_LENGTH);
        qDebug("%s", msg.toStdString().data());
        addError(msg);
        result = false;
    }

    return result;
}
Example #9
0
bool WheelBaseData::isMinLengthOk(QString alphabet, QString name)
{
    bool result = true;

    // alphabet must contain at least three characters
    if (alphabet.length() < AlphabetData::MIN_ALPHABET_LENGTH)
    {
        QString msg = QString("%1 must contain at least %2 characters").
                        arg(name).
                        arg(AlphabetData::MIN_ALPHABET_LENGTH);
        addError(msg);
        result = false;
    }

    return result;
}
Example #10
0
void MetaInfoReader::elementEnd()
{
    switch (parserState()) {
    case ParsingMetaInfo: setParserState(Finished); break;
    case ParsingType: setParserState(ParsingMetaInfo); break;
    case ParsingItemLibrary: insertItemLibraryEntry(); setParserState((ParsingType)); break;
    case ParsingProperty: insertProperty(); setParserState(ParsingItemLibrary);  break;
    case ParsingQmlSource: setParserState(ParsingItemLibrary); break;
    case ParsingDocument:
    case Finished:
    case Undefined: setParserState(Error);
        addError(tr("Illegal state while parsing"), currentSourceLocation());
    case Error:
    default: return;
    }
}
Example #11
0
bool Reader::decodeNumber(Token &token, Value &decoded) {
  bool isDouble = false;
  for (Location inspect = token.start_; inspect != token.end_; ++inspect) {
    isDouble = isDouble || in(*inspect, '.', 'e', 'E', '+') ||
               (*inspect == '-' && inspect != token.start_);
  }
  if (isDouble)
    return decodeDouble(token, decoded);
  // Attempts to parse the number as an integer. If the number is
  // larger than the maximum supported value of an integer then
  // we decode the number as a double.
  Location current = token.start_;
  bool isNegative = *current == '-';
  if (isNegative)
    ++current;
  Value::LargestUInt maxIntegerValue =
      isNegative ? Value::LargestUInt(-Value::minLargestInt)
                 : Value::maxLargestUInt;
  Value::LargestUInt threshold = maxIntegerValue / 10;
  Value::LargestUInt value = 0;
  while (current < token.end_) {
    Char c = *current++;
    if (c < '0' || c > '9')
      return addError("'" + std::string(token.start_, token.end_) +
                          "' is not a number.",
                      token);
    Value::UInt digit(c - '0');
    if (value >= threshold) {
      // We've hit or exceeded the max value divided by 10 (rounded down). If
      // a) we've only just touched the limit, b) this is the last digit, and
      // c) it's small enough to fit in that rounding delta, we're okay.
      // Otherwise treat this number as a double to avoid overflow.
      if (value > threshold || current != token.end_ ||
          digit > maxIntegerValue % 10) {
        return decodeDouble(token, decoded);
      }
    }
    value = value * 10 + digit;
  }
  if (isNegative)
    decoded = -Value::LargestInt(value);
  else if (value <= Value::LargestUInt(Value::maxInt))
    decoded = Value::LargestInt(value);
  else
    decoded = value;
  return true;
}
static bool doOneDir(TestState* state, bool threaded) {
    int dirNo = state->fResult.fDirNo;
    SkString dirName = get_in_path(dirNo, nullptr);
    if (!dirName.size()) {
        return false;
    }
    SkTDArray<TestResult> tests[1];
    SkTDArray<SortByName*> sorted[1];
    if (!buildTestDir(dirNo, dirNo, tests, sorted)) {
        return false;
    }
    SkOSFile::Iter iter(dirName.c_str(), "skp");
    SkString filename;
    while (iter.next(&filename)) {
        for (size_t index = 0; index < skipOverCount; ++index) {
            if (skipOver[index].directory == dirNo
                    && strcmp(filename.c_str(), skipOver[index].filename) == 0) {
                goto checkEarlyExit;
            }
        }
        {
            SortByName name;
            name.init(dirNo);
            strncpy(name.fFilename, filename.c_str(), filename.size() - 4);  // drop .skp
            int count = sorted[0].count();
            int idx = SkTSearch<SortByName, Less>(sorted[0].begin(), count, &name, sizeof(&name));
            if (idx >= 0) {
                SortByName* found = sorted[0][idx];
                (void) addError(state, *found);
                continue;
            }
            TestResult test;
            test.init(dirNo, filename);
            state->fResult = test;
            testSkpClip(state);
#if 0 // artificially limit to a few while debugging code
            static int debugLimit = 0;
            if (++debugLimit == 5) {
                return true;
            }
#endif
        }
checkEarlyExit:
        ;
    }
    return true;
}
Example #13
0
void MetaInfoReader::readItemLibraryEntryProperty(const QString &name, const QVariant &value)
{
    if (name == QStringLiteral("name")) {
        m_currentEntry.setName(value.toString());
    } else if (name == QStringLiteral("category")) {
        m_currentEntry.setCategory(value.toString());
    } else if (name == QStringLiteral("libraryIcon")) {
        m_currentEntry.setLibraryEntryIconPath(absoluteFilePathForDocument(value.toString()));
    } else if (name == QStringLiteral("version")) {
        setVersion(value.toString());
    } else if (name == QStringLiteral("requiredImport")) {
        m_currentEntry.setRequiredImport(value.toString());
    } else {
        addError(tr("Unknown property for ItemLibraryEntry %1").arg(name), currentSourceLocation());
        setParserState(Error);
    }
}
Example #14
0
void Executer::executeAssign(TreeNode* node) {
//	//qDebug() << "called";
	if(node->childCount()!=2) {
	addError(i18n("You need one variable and a value or variable to do a '='"), *node->token(), 0);
		return;
	}
	if (!functionStack.isEmpty() && !globalVariableTable.contains(node->child(0)->token()->look())) // &&functionStack.top().variableTable->contains(node->token()->look())) 
	{
		// //qDebug() << "function scope";
		functionStack.top().variableTable->insert(node->child(0)->token()->look(), node->child(1)->value());
	} else {
		// inserts unless already exists then replaces
		globalVariableTable.insert(node->child(0)->token()->look(), node->child(1)->value());
	}
	// //qDebug() << "variableTable updated!";
	emit variableTableUpdated(node->child(0)->token()->look(), node->child(1)->value());
}
Example #15
0
bool IdacDriverES::boot()
{
    //QString			strMsg;
    //int				Key;
    //int				Present;
    //LONG			Adr;

    int n = IdacType();
    switch (n)
    {
    case IDAC_TYPE_2_USB:
        return boot_2_USB();

    case IDAC_TYPE_4:
        return boot_2000_4("4");

    /*case IDAC_TYPE_2000:
    	return boot_2000_4("2000");

    case IDAC_TYPE_SERIAL:
    	/ * FIXME:
    	m_Address = RegInfo . m_IdacAddress;
    	Present = IdacPresent(RegInfo . m_IdacAddress);

    	if (Present == 0)
    		return false;
    	break;
    	* /
    	addError(tr("Your IDAC type is not supported"));
    	return false;

    case IDAC_TYPE_ISA_V2:
    case IDAC_TYPE_USB_V3:
    	return boot_ISA_USB();
    */

    default:
        addError(tr("Your IDAC device is not supported"));
        return false;
    }

    // FIXME: RegInfo.m_IdacAddress = Address();
}
Example #16
0
bool WheelBaseData::checkIsInUse(QString machineName, QStringList lst, QString colName, QString strId)
{
    bool result = false;
    QString msg;

    for (int i = 0; i < lst.count(); i++)
    {
        if (lst.at(i).compare(strId) == 0)
        {
            msg = QString("id [%1] is in use in %2 of machine [%3]").
                    arg(strId).
                    arg(colName).
                    arg(machineName);
            addError(msg);
            result = true;
        }
    }
    return result;
}
Example #17
0
bool WheelBaseData::alphabetDuplicateCheck(QString alphabetName, QString alphabet)
{
    bool result = true;

    for (int i = 0; i < alphabet.count(); i++)
    {
        if (alphabet.count(alphabet.at(i), Qt::CaseSensitive ) != 1)
        {
            QString tmp = QString("character [%1] found [%2] time(s) in definition [%3] - should only be one").
                            arg(alphabet.at(i)).
                            arg(alphabet.count(alphabet.at(i), Qt::CaseSensitive )).
                            arg(alphabetName);
            addError(tmp);
            result = false;
        }
    }

    return result;
}
CMakeBuildDirCreator::CMakeBuildDirCreator(const KUrl& srcDir, QWidget* parent, Qt::WindowFlags f)
	: QDialog(parent, f), m_srcFolder(srcDir)
{
	m_creatorUi = new Ui::CMakeBuildDirCreator;
	m_creatorUi->setupUi( this );
	m_creatorUi->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
	
	QString cmakeBin=executeProcess("which", QStringList("cmake"));
	setCMakeBinary(KUrl(cmakeBin));
	
	connect(m_creatorUi->run, SIGNAL(clicked()), this, SLOT(runBegin()));
	connect(m_creatorUi->cmakeBin, SIGNAL(textChanged(const QString &)), this, SLOT(updated()));
	connect(m_creatorUi->buildFolder, SIGNAL(textChanged(const QString &)), this, SLOT(updated()));
	connect(m_creatorUi->buildType, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(updated()));
	connect(&m_proc, SIGNAL(readyReadStandardError()), this, SLOT(addError()));
	connect(&m_proc, SIGNAL(readyReadStandardOutput()), this, SLOT(addOutput()));
	connect(&m_proc, SIGNAL(finished ( int , QProcess::ExitStatus )), this, SLOT(cmakeCommandDone ( int , QProcess::ExitStatus )));
	updated();
}
bool 
Reader::parse( const char *beginDoc, const char *endDoc, 
               Value &root,
               bool collectComments )
{
   if ( !features_.allowComments_ )
   {
      collectComments = false;
   }

   begin_ = beginDoc;
   end_ = endDoc;
   collectComments_ = collectComments;
   current_ = begin_;
   lastValueEnd_ = 0;
   lastValue_ = 0;
   commentsBefore_ = "";
   errors_.clear();
   while ( !nodes_.empty() )
      nodes_.pop();
   nodes_.push( &root );
   
   bool successful = readValue();
   Token token;
   skipCommentTokens( token );
   if ( collectComments_  &&  !commentsBefore_.empty() )
      root.setComment( commentsBefore_, commentAfter );
   if ( features_.strictRoot_ )
   {
      if ( !root.isArray()  &&  !root.isObject() )
      {
         // Set error location to start of doc, ideally should be first token found in doc
         token.type_ = tokenError;
         token.start_ = beginDoc;
         token.end_ = endDoc;
         addError( "A valid JSON document must be either an array or an object value.",
                   token );
         return false;
      }
   }
   return successful;
}
void ProjectExporter::writeZip(QString path, QString base)
{
    if(base == "")
        base = path;
    if(path == "")
    {
        addError(tr("Couldn't locate project directory"));
        return;
    }

    QDir dir(path);

    /* First adding any files in the directory */
    QFileInfoList files = dir.entryInfoList(QDir::Files);
    for(int i = 0; i < files.count(); i++)
    {
        QFileInfo current = files[i];

        QString newPath = current.absoluteFilePath().replace(base, "/.rockbox");

        QuaZipFile fout(&zipFile);
        QFile fin(current.absoluteFilePath());

        fin.open(QFile::ReadOnly | QFile::Text);
        fout.open(QIODevice::WriteOnly,
                  QuaZipNewInfo(newPath, current.absoluteFilePath()));

        fout.write(fin.readAll());

        fin.close();
        fout.close();
    }

    /* Then recursively adding any directories */
    QFileInfoList dirs = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
    for(int i = 0; i < dirs.count(); i++)
    {
        QFileInfo current = dirs[i];
        writeZip(current.absoluteFilePath(), base);
    }
}
Example #21
0
void extractDataParams(GuidelineHolder* holder, AssemblyLine* assemblyLine)
{
	const char* delimiters = DELIMATER_PARAMS;
	
	char* convertionEnd;
	int num;
	char* token = strtok(assemblyLine->line, delimiters);
	
	/* walk through the tokens */
	while (token != NULL)
	{
		num = strtol(trim(token), &convertionEnd, 10);
		if ((*convertionEnd)) {
			addError(holder->errorHolder, "Data must contain numbers only", assemblyLine->lineNumber);
			return;
		}
		addData(holder, num, assemblyLine);

		token = strtok(NULL, delimiters);
	}
}
Example #22
0
//virtual
bool JsonGenerator::processBeanSpecification(BeanClazzSpecification & bcs) {
    std::string content = getTemplateContent("json_bean_template.t");
    if(bcs.getFields().size() == 0) {
        std::ostringstream msg;
        msg << "Bean " << bcs.getName() << " has no fields ?!?";
        addError(msg.str());
        return false;
    }
    if(!registerOutputTemplate(bcs.getName(), content)) {
        return false;
    }
    std::cout << "Generating bean file : " << bcs.getName() << std::endl;

    //1: replace the names
    std::string beanName = bcs.getName();
    FTemplate & t = getTemplate(beanName);

    std::string lowercaseName = boost::to_lower_copy(beanName);
    std::string uppercaseName = boost::to_upper_copy(beanName);
    t.replaceToken("BEANNAME", uppercaseName);
    t.replaceToken("beanname", lowercaseName);
    t.replaceToken("BeanName", beanName);

    //2: fix the namespaces
    std::string namespaceBegin;
    std::string namespaceEnd;
    for(auto & s : spec.getNamespaces()) {
        namespaceBegin.append("namespace ").append(s).append(" { ");
        namespaceEnd.append("} ");
    }
    t.replaceToken("namespace_def_begin", namespaceBegin);
    t.replaceToken("namespace_def_end", namespaceEnd);

    std::ostringstream n;
    n << bcs.getFields().size();
    t.replaceToken("bean_number_of_fields", n.str());

    //3: process the fields
    return processBeanFieldsSpecification(t, bcs);
}
Example #23
0
//  Create a filespec from a single short flag and push it onto the array
Boolean getoopt::addFlagspec(char flag, Boolean hasarg)
{
    if (flag == '*')
    {
        MessageLoaderParms parms(
            "getoopt.getoopt.CANT_NAME_FLAG",
            "You can't have a flag named '$0'",
            flag);
        addError(MessageLoader::getMessage(parms));
        return false;
    }
    flagspec fs;
    char c[2];
    c[0] = flag;
    c[1] = 0;
    fs.name = c;
    fs.argtype = hasarg ? 1 : 0;
    fs.islong = false;
    fs.active = true;
    _flagspecs.append(fs);
    return true;
}
Example #24
0
bool SpecificationParser::processLine(int line, const std::string & s) {
    //this line is trimmed, so we need to see how we're called
    if(s.size() == 0) {
        return true;
    }
    if(boost::starts_with(s, "//") || boost::starts_with(s, "#")) {
        return true;
    }

    bool err;
    if(boost::starts_with(s, "namespace ") || boost::starts_with(s, "namespace\t")) {
        err = processNamespace(s);
    } else if(boost::starts_with(s, "class ") || boost::starts_with(s, "class\t")) {
        err = processClassDefinition(s);
    } else {
        err = processFieldDefinition(s);
    }
    if(!err) {
        addError(line);
    }
    return err;
}
Example #25
0
  bool
  Reader::readValue ()
  {
    Token token;
    do
      readToken (token);
    while (token.type_ == tokenComment);
    bool successful = true;

    switch (token.type_)
      {
      case tokenObjectBegin:
	successful = readObject ();
	break;
      case tokenArrayBegin:
	successful = readArray ();
	break;
      case tokenNumber:
	successful = decodeNumber (token);
	break;
      case tokenString:
	successful = decodeString (token);
	break;
      case tokenTrue:
	currentValue () = true;
	break;
      case tokenFalse:
	currentValue () = false;
	break;
      case tokenNull:
	currentValue () = Value ();
	break;
      default:
	return addError ("Syntax error: value, object or array expected.", token);
      }

    return successful;
  }
Example #26
0
bool SimpleAbstractStreamReader::readFromSource(const QString &source)
{
    m_errors.clear();
    m_currentSourceLocation = AST::SourceLocation();

    m_source = source;

    Engine engine;
    Lexer lexer(&engine);
    Parser parser(&engine);

    lexer.setCode(source, /*line = */ 1, /*qmlMode = */true);

    if (!parser.parse()) {
        QString errorMessage = QString::fromLatin1("%1:%2: %3").arg(
                    QString::number(parser.errorLineNumber()),
                    QString::number(parser.errorColumnNumber()),
                    parser.errorMessage());
        addError(errorMessage);
        return false;
    }
    return readDocument(parser.ast());
}
Example #27
0
void SFZSound::loadSamples(
	AudioFormatManager* formatManager,
	double* progressVar, Thread* thread)
{
	if (progressVar)
		*progressVar = 0.0;

	double numSamplesLoaded = 1.0, numSamples = samples.size();
	for (HashMap<String,SFZSample*>::Iterator i(samples); i.next();) {
		SFZSample* sample = i.getValue();
		bool ok = sample->load(formatManager);
		if (!ok)
			addError("Couldn't load sample \"" + sample->getShortName() + "\"");

		numSamplesLoaded += 1.0;
		if (progressVar)
			*progressVar = numSamplesLoaded / numSamples;
		if (thread && thread->threadShouldExit())
			return;
		}

	if (progressVar)
		*progressVar = 1.0;
}
ProjectExporter::ProjectExporter(QString path, ProjectModel* project,
                                 QWidget *parent)
    :QDialog(parent),
     ui(new Ui::ProjectExporter), zipFile(path)
{
    ui->setupUi(this);

    QObject::connect(ui->closeButton, SIGNAL(clicked()),
                     this, SLOT(close()));

    if(zipFile.open(QuaZip::mdCreate))
    {

        checkRes(project);
        writeZip(project->getSetting("themebase", ""));
        zipFile.close();

        addSuccess(tr("Project exported successfully"));
    }
    else
    {
        addError(tr("Couldn't open zip file"));
    }
}
bool 
Reader::decodeNumber( Token &token )
{
   bool isDouble = false;
   for ( Location inspect = token.start_; inspect != token.end_; ++inspect )
   {
      isDouble = isDouble  
                 ||  in( *inspect, '.', 'e', 'E', '+' )  
                 ||  ( *inspect == '-'  &&  inspect != token.start_ );
   }
   if ( isDouble )
      return decodeDouble( token );
   Location current = token.start_;
   bool isNegative = *current == '-';
   if ( isNegative )
      ++current;
   Value::UInt threshold = (isNegative ? Value::UInt(-Value::minInt) 
                                       : Value::maxUInt) / 10;
   Value::UInt value = 0;
   while ( current < token.end_ )
   {
      Char c = *current++;
      if ( c < '0'  ||  c > '9' )
         return addError( "'" + std::string( token.start_, token.end_ ) + "' is not a number.", token );
      if ( value >= threshold )
         return decodeDouble( token );
      value = value * 10 + Value::UInt(c - '0');
   }
   if ( isNegative )
      currentValue() = -Value::Int( value );
   else if ( value <= Value::UInt(Value::maxInt) )
      currentValue() = Value::Int( value );
   else
      currentValue() = value;
   return true;
}
void QgsSelectedFeature::validateGeometry( QgsGeometry *g )
{
  QgsDebugCall;
  QSettings settings;
  if ( settings.value( "/qgis/digitizing/validate_geometries", 1 ).toInt() == 0 )
    return;

  if ( !g )
    g = mGeometry;

  mTip.clear();

  if ( mValidator )
  {
    mValidator->stop();
    mValidator->wait();
    mValidator->deleteLater();
    mValidator = nullptr;
  }

  mGeomErrors.clear();
  while ( !mGeomErrorMarkers.isEmpty() )
  {
    QgsVertexMarker *vm = mGeomErrorMarkers.takeFirst();
    QgsDebugMsg( "deleting " + vm->toolTip() );
    delete vm;
  }

  mValidator = new QgsGeometryValidator( g );
  connect( mValidator, SIGNAL( errorFound( QgsGeometry::Error ) ), this, SLOT( addError( QgsGeometry::Error ) ) );
  connect( mValidator, SIGNAL( finished() ), this, SLOT( validationFinished() ) );
  mValidator->start();

  QStatusBar *sb = QgisApp::instance()->statusBar();
  sb->showMessage( tr( "Validation started." ) );
}