bool Reader::decodeUnicodeEscapeSequence( Token &token, Location ¤t, 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; }
/** * \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; }
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; }
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_ = ¤tValue(); } return successful; }
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++; } }
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; } }
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; }
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; }
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; } }
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; }
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); } }
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()); }
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(); }
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; }
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); } }
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); } }
//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); }
// 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; }
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; }
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; }
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()); }
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." ) ); }