/** * @brief readColumn return all the values on a named column * @param pFile is the database to be readed from. * @param pColumnName parameter for returning a value. * @return */ array<char*> readfile::readColumn(string pFile , string pColumnName){ string standardDir; array <char*> errorArray (ONE_BYTE); //if !database, return null array if ( !(file.is_open()) ){ standardDir = createNewFile(&pFile); file.open(standardDir.c_str()); } if ( !(file.is_open()) ){ cout << "NED " + pFile << endl; return errorArray; } int Column = getColumnNumber(&standardDir , &pColumnName ); int regQty = getRegisterQuantity(); string strToConvert = EMPTY_STRING; char * toAdd; array <char*> arrayToReturn (regQty); for (int rowCounter = ONE_BYTE ; rowCounter <= regQty ; rowCounter++){ strToConvert = readField(pFile , rowCounter , pColumnName); toAdd = new char[strToConvert.size()+1]; strcpy(toAdd, strToConvert.c_str()); arrayToReturn[rowCounter - ONE_BYTE] = toAdd; } return arrayToReturn; }
/*! @decl int getColumnNumber() */ static void f_getColumnNumber(INT32 args) { pop_n_elems(args); if (!THIS->ctxt) push_int(-1); else push_int(getColumnNumber(THIS->ctxt)); }
/** * @brief writeRegister Method to append a whole registry. Add new element to database. * @param pFileName is the name of database file to add to. * @param pColumnData it's what to append. * @param columnPos is where to append it. */ bool writefile::writeRegister(string pFileName, array<char*>* pColumnData , array<char*>* pColumnNam){ int currSeek = file.tellg(); string standardDir = createNewFile(pFileName); file.open(standardDir.c_str()); bool isOpen = true; if(!file.is_open()){ cout << "NED " + pFileName << endl; return false; } file.seekg(K->ZE_ROW); int spacesToMove; int Csize; int lon = pColumnNam->getLenght(); array<char*> tempCDataArr = *pColumnData; array<char*> tempNames = *pColumnNam; array<int> ColumnPos (lon); string registerToWrite = K->EMPTY_STRING; string Cdata; const char* charT ; for (int i = K->ZE_ROW ; i < lon ; i++){ charT = tempNames[i]; string strToAdd(charT); ColumnPos[i] = getColumnNumber(&pFileName, &strToAdd); } //Get the register and fill the blanks. fillString (®isterToWrite , getRegisterSize()); for (int i = 0 ; i < ColumnPos.getLenght() ; i++){ Cdata = tempCDataArr[i]; checkString(&Cdata); Csize = columnSize(ColumnPos[i]); //Not sure spacesToMove = sizeUntilColumn(ColumnPos[i]); fillString(&Cdata ,Csize); registerToWrite.replace(spacesToMove , Csize , Cdata.c_str()); } if (file.is_open()){ file.seekg(K->ZE_ROW , ios::end); file << registerToWrite; } file.seekg(currSeek); file.close(); return isOpen; }
/** * @brief updateColumn From pCname of pFile, replace pToCompare with newData * @param newData * @param pToCompare * @param pFile * @param pCName */ bool writefile::updateColumn(string newData,string pToCompare, string pFile, string pCName){ int currSeek = file.tellg(); int sizeToColumn; int cSize; string standardDir; bool bowl = true; //Relative route + the name of the file if ( !(file.is_open()) ){ string fileH = pFile; standardDir = createNewFile(fileH.c_str()); file.open(standardDir.c_str()); } if ( !(file.is_open()) ){ cout << "NED " + pFile << endl; bowl = false; } int Column = getColumnNumber(&standardDir , &pCName ); int regQty = getRegisterQuantity(); string currentData = K->EMPTY_STRING; for (int rowCounter = K->ONE_BYTE ; rowCounter <= regQty ; rowCounter++){ //Move the seek to the column and register. placeSeekOn( &rowCounter , &Column, &sizeToColumn, &cSize); //Build the string of the old data for (int i = 0 ; i < cSize ; i++){ char temp = file.get(); if (temp == '*'){ break; }else{ currentData.push_back(temp); } } //Compare data. if (currentData == pToCompare){ updateField(newData, pFile , rowCounter , Column); }else{ currentData = K->EMPTY_STRING; } } file.seekg(currSeek); if (file.is_open()){ file.close(); } return bowl; }
void QFCompleterTextEditWidget::cursorChanged() { emit cursorMoved(getLineNumber(), getColumnNumber()); QString s=validTextUnderCursor().trimmed(); //std::cout<<s.toLatin1().data()<<std::endl; if (currentTextUnderCursor!=s) { currentTextUnderCursor=s; emit wordUnderCursorChanged(s); } /*std::cout<<"document()->documentLayout()->documentSize() = "<<document()->documentLayout()->documentSize().width()<<" "<<document()->documentLayout()->documentSize().height()<<std::endl; std::cout<<"verticalScrollBar()->value() = "<<verticalScrollBar()->value()<<std::endl; std::cout<<"verticalScrollBar()->min max = "<<verticalScrollBar()->minimum()<<" "<<verticalScrollBar()->maximum()<<std::endl; std::cout<<"viewport()->height() = "<<viewport()->height()<<std::endl; std::cout<<"viewport()->width() = "<<viewport()->width()<<std::endl;*/ }
bool writefile::deleteRegister(string pFile, string pCName, string newData){ int currSeek = file.tellg(); int Column; int cSize; string standardDir; bool bowl = true; //Relative route + the name of the file if ( !(file.is_open()) ){ standardDir = createNewFile(pFile.c_str()); file.open(standardDir.c_str()); } if ( !(file.is_open()) ){ cout << "NED " + pFile << endl; return false; } Column = getColumnNumber(&standardDir , &pCName ); cSize = getRegisterSize(); int regQty = getRegisterQuantity(); string voidField = K->EMPTY_STRING; int sizeToColumn = sizeUntilColumn(Column); fillString(&voidField,cSize); cout << voidField.length() <<endl; for (int rowCounter = K->ONE_BYTE ; rowCounter <= regQty ; rowCounter++){ //Compare data. if (readField(pFile , rowCounter , Column) == newData){ placeSeekOn(&rowCounter , &Column, &sizeToColumn, &cSize); if (file.is_open()){ file << voidField; } else { bowl = false; } } } file.seekg(currSeek); if (file.is_open()){ file.close(); } return bowl; }
int MaIterator::getStep(qint64 position) const { CHECK(!coreRegionsOnly, 1); SAFE_POINT(isInRange(position), "Out of boundaries", 1); const int rowNumber = getRowNumber(position); const int columnNumber = getColumnNumber(position); const MultipleAlignmentRow row = ma->getRow(rowsIndexes[rowNumber]); CHECK(!row->isTrailingOrLeadingGap(columnNumber), 1); switch (direction) { case Forward: return row->getCoreEnd() <= columnNumber ? ma->getLength() - columnNumber : 1; break; case Backward: return row->getCoreStart() >= columnNumber ? ma->getLength() - columnNumber : 1; break; default: FAIL("An unknown direction", 1); } }
void Reader::dumpNode(bsl::ostream & os) const { const char *name = nodeName(); const char *value = nodeValue(); const char *nsUri = nodeNamespaceUri(); int line = getLineNumber(); int column = getColumnNumber(); int depth = nodeDepth(); NodeType type = nodeType(); bsl::string strPad((bsl::string::size_type)depth*2, ' '); os << strPad << "Node pos=" << line << ":" << column << " type=" << type << "(" << nodeTypeAsString(type) << ") empty=" << isEmptyElement() << " hasValue=" << nodeHasValue() << " name=" << CHK(name) << " value=" << CHK(value) << " uri=" << CHK(nsUri) << bsl::endl; int numAttr = numAttributes(); for (int i = 0; i < numAttr; ++i) { ElementAttribute attr; lookupAttribute(&attr, i); os << strPad << " ATTRIBUTE " << CHK(attr.qualifiedName()) << "=" << CHK(attr.value()) << " uri=" << CHK(attr.namespaceUri()) << bsl::endl; } }
//-------------------------------------------------------------------- bool ParserTemplateBase::handleError( ParserError::Severity severity, ParserError::ErrorType errorType, StringHash elementHash, StringHash attributeHash, const ParserChar* additionalText /*= ""*/ ) { IErrorHandler* errorHandler = getErrorHandler(); if ( !errorHandler ) return (severity == ParserError::SEVERITY_CRITICAL) ? true : false; ParserError error(severity, errorType, getNameByStringHash(elementHash), getNameByStringHash(attributeHash), getLineNumber(), getColumnNumber(), additionalText ? (const char*)additionalText : ""); bool handlerWantsToAbort = errorHandler->handleError(error); return (severity == ParserError::SEVERITY_CRITICAL) ? true : handlerWantsToAbort; }
array< array<char*> > readfile::getRegisters(string pFile, string pColumnName, string valueToConsult){ string standardDir; int regs = getRegisterQuantity(); int colNum; if ( !(file.is_open()) ){ standardDir = createNewFile(&pFile); file.open(standardDir.c_str()); } colNum = getColumnNumber(&standardDir, &pColumnName); array< array<char*> > select (getRegisterQuantity()); for ( int i = ZE_ROW ; i < regs ; i ++){ if(valueToConsult == readField(pFile,i+1,colNum)){ select [i] = readRegistry( pFile , colNum); } } return select; }
/*** Execute this node ***/ Outcome Input::execute() { for(int i = 0; i < (int) exprs.size(); i++) { if(exprs.at(i)->getType() != OP_VARIABLE) throw Excep(getLineNumber(), getColumnNumber(), "Expected variable name to input statement!"); // Input text if(getText) { char str[256]; std::cin.getline(str, 256); Assign(static_cast<Variable*>(exprs.at(i))->clone(), new Text(std::string(str))).execute(); continue; } // Input a number or logical std::string text; do { char str[256]; std::cin.getline(str, 256); text = std::string(str); } while(text == "" || (!isInteger(text) && !isReal(text) && text != "yes" && text != "no")); if(isInteger(text)) Assign(static_cast<Variable*>(exprs.at(i))->clone(), new Integer(text)).execute(); else if(isReal(text)) Assign(static_cast<Variable*>(exprs.at(i))->clone(), new Real(text)).execute(); else if(text == "yes") Assign(static_cast<Variable*>(exprs.at(i))->clone(), new Logical(true)).execute(); else Assign(static_cast<Variable*>(exprs.at(i))->clone(), new Logical(false)).execute(); } return Outcome(S_SUCCESS); }
/*** Evaluate this object ***/ Object* SpecialFunction::evaluate() { if(args.size() == 0) throw Excep(getLineNumber(), getColumnNumber(), "Expected argument to special function!"); std::auto_ptr<Object> arg1(args.at(0)->evaluate()); if(id == SPF_INDEX) { if(args.size() != 2) throw Excep(getLineNumber(), getColumnNumber(), "Invalid number of arguments passed to special function!"); std::auto_ptr<Object> arg2(args.at(1)->evaluate()); if(arg2->getType() == OBJ_TEXT) { if(arg1->getType() != OBJ_TEXT) throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_TEXT, arg1->getType(), 1); Text* cast1 = static_cast<Text*>(arg1.get()); Text* cast2 = static_cast<Text*>(arg2.get()); size_t index = cast2->getValue().find(cast1->getValue()); if(index != std::string::npos) return new Integer(index + 1); return new Integer(0); } if(arg2->getType() == OBJ_SEQUENCE) { Sequence* cast = dynamic_cast<Sequence*>(arg2.get()); for(unsigned int i = 0; i < cast->getLength(); i++) { std::auto_ptr<Logical> eqOp(static_cast<Logical*>(Equal(arg1->clone(), cast->getObject(i)->clone()).evaluate())); if(eqOp->getValue() == true) return new Integer(i + 1); } return new Integer(0); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_TEXT | OBJ_SEQUENCE, arg2->getType(), 2); } if(args.size() > 1) throw Excep(getLineNumber(), getColumnNumber(), "Invalid number of arguments passed to special function!"); if(id == SPF_ABS) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); if(cast->getValue() < 0) return new Integer(-cast->getValue()); return new Integer(cast->getValue()); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); if(cast->getValue() < 0) return new Real(-cast->getValue()); return new Real(cast->getValue()); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_SIGN) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); if(cast->getValue() < 0) return new Integer(-1); if(cast->getValue() > 0) return new Integer(1); return new Integer(0); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); if(cast->getValue() < 0) return new Integer(-1); if(cast->getValue() > 0) return new Integer(1); return new Integer(0); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_SQRT) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); if(cast->getValue() < 0) throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1); double res = sqrt((double) cast->getValue()); if((long) res == res) return new Integer((long) res); return new Real(res); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); if(cast->getValue() < 0) throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1); double res = sqrt((double) cast->getValue()); return new Real(res); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_ENTIER) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); return new Integer(cast->getValue()); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); return new Integer(floor(cast->getValue())); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_ROUND) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); return new Integer(cast->getValue()); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); long rounded = cast->getValue() < 0.0 ? ceil(cast->getValue() - 0.5) : floor(cast->getValue() + 0.5); return new Integer(rounded); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_RAND) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); if(cast->getValue() < 0) throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1); double f = (double) rand() / RAND_MAX; return new Real( f * cast->getValue() ); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); if(cast->getValue() < 0) throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1); double f = (double) rand() / RAND_MAX; return new Real( f * cast->getValue() ); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_INTRAND) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); if(cast->getValue() < 0) throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1); return new Integer( rand() % cast->getValue() + 1 ); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); if(cast->getValue() < 0) throw NegativeValueException(getLineNumber(), getColumnNumber(), cast->getValue(), 1); return new Integer( rand() % (long) cast->getValue() + 1 ); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_ISEMPTY) { return new Logical(arg1->getType() == OBJ_EMPTY); } if(id == SPF_ISLOG) { return new Logical(arg1->getType() == OBJ_LOGICAL); } if(id == SPF_ISINT) { return new Logical(arg1->getType() == OBJ_INTEGER); } if(id == SPF_ISREAL) { return new Logical(arg1->getType() == OBJ_REAL); } if(id == SPF_ISTEXT) { return new Logical(arg1->getType() == OBJ_TEXT); } if(id == SPF_ISSEQ) { return new Logical(arg1->getType() == OBJ_SEQUENCE); } if(id == SPF_ISPROC) { return new Logical(arg1->getType() == OBJ_PROCEDURE); } if(id == SPF_ISFUN) { return new Logical(arg1->getType() == OBJ_FUNCTION || arg1->getType() == OBJ_SPFUNCTION); } if(id == SPF_SIN) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); return new Real(sin((double) cast->getValue())); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); return new Real(sin(cast->getValue())); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_COS) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); return new Real(cos((double) cast->getValue())); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); return new Real(cos(cast->getValue())); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_TG) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); return new Real(tan((double) cast->getValue())); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); return new Real(tan(cast->getValue())); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_ARCSIN) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); if(errno == EDOM) throw new Excep(getLineNumber(), getColumnNumber(), "Invalid value passed to special function!"); return new Real(exp((double) cast->getValue())); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); if(errno == EDOM) throw new Excep(getLineNumber(), getColumnNumber(), "Invalid value passed to special function!"); return new Real(exp(cast->getValue())); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_ARCTG) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); if(errno == EDOM) throw new Excep(getLineNumber(), getColumnNumber(), "Invalid value passed to special function!"); return new Real(exp((double) cast->getValue())); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); if(errno == EDOM) throw new Excep(getLineNumber(), getColumnNumber(), "Invalid value passed to special function!"); return new Real(exp(cast->getValue())); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_EXP) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); return new Real(exp((double) cast->getValue())); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); return new Real(exp(cast->getValue())); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_LN) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); return new Real(log((double) cast->getValue())); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); return new Real(log(cast->getValue())); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } if(id == SPF_LG) { if(arg1->getType() == OBJ_INTEGER) { Integer* cast = static_cast<Integer*>(arg1.get()); return new Real(log10((double) cast->getValue())); } if(arg1->getType() == OBJ_REAL) { Real* cast = static_cast<Real*>(arg1.get()); return new Real(log10(cast->getValue())); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, arg1->getType(), 1); } throw Excep(getLineNumber(), getColumnNumber(), "Invalid special function!"); }
/*** Execute this node ***/ Outcome For::execute() { // Check for the for value if(forValue == 0) throw Excep(getLineNumber(), getColumnNumber(), "No variable specified in for loop."); if(forValue->getType() != OP_VARIABLE) throw Excep(getLineNumber(), getColumnNumber(), "For loop must be given a valid variable."); // Store the for value variable Variable* forVar = static_cast<Variable*>(forValue); // If a from value was given, set the counter to this initial value if(from != 0) { // Evaluate the std::auto_ptr<Object> fromEval(from->evaluate()); if(fromEval->getType() != OBJ_INTEGER && fromEval->getType() != OBJ_REAL) throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, fromEval->getType()); Assign(forVar->clone(), fromEval.release()).execute(); } else Assign(forVar->clone(), new Integer(1)).execute(); // Create an Outcome object to store the result Outcome result(S_SUCCESS); do { // Check the while condition, if present if(whileCond != 0) { std::auto_ptr<Object> whileCondEval(whileCond->evaluate()); if(whileCondEval->getType() != OBJ_LOGICAL) throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_LOGICAL, whileCondEval->getType()); bool whileCondResult = static_cast<Logical*>(whileCondEval.get())->getValue(); if(!whileCondResult) break; } // Check the to value if(to != 0) { std::auto_ptr<Object> toEval(to->evaluate()); // Store the step value evaluated std::auto_ptr<Object> stepEval; if(step == 0) stepEval.reset(new Integer(1)); else stepEval.reset(step->evaluate()); // Confirm that the step is an integer if(stepEval->getType() != OBJ_INTEGER && stepEval->getType() != OBJ_REAL) throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, stepEval->getType()); std::auto_ptr<Real> castStep; // Cast the step value to a real if(stepEval->getType() == OBJ_INTEGER) castStep.reset(new Real(static_cast<Integer*>(stepEval.get())->getValue())); else castStep.reset(static_cast<Real*>(stepEval.release())); bool toCondition = false; if(castStep->getValue() > 0) { std::auto_ptr<Object> operation(Greater(forVar->clone(), toEval.release()).evaluate()); toCondition = static_cast<Logical*>(operation.get())->getValue(); } if(castStep->getValue() < 0) { std::auto_ptr<Object> operation(Less(forVar->clone(), toEval.release()).evaluate()); toCondition = static_cast<Logical*>(operation.get())->getValue(); } if(toCondition) break; } // Execute the NodeList of statements result = list->execute(); // Modify forVar based on step if(step == 0) { std::auto_ptr<Object> addOperation(Add(forVar->clone(), new Integer(1)).evaluate()); Assign(forVar->clone(), addOperation.release()).execute(); } else { std::auto_ptr<Object> stepEval(step->evaluate()); if(stepEval->getType() != OBJ_INTEGER && stepEval->getType() != OBJ_REAL) throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, stepEval->getType()); std::auto_ptr<Object> addOperation(Add(forVar->clone(), stepEval.release()).evaluate()); Assign(forVar->clone(), addOperation.release()).execute(); } // Check the until condition, if present if(untilCond != 0) { std::auto_ptr<Object> untilEval(untilCond->evaluate()); if(untilEval->getType() != OBJ_LOGICAL) throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_LOGICAL, untilEval->getType()); bool untilResult = static_cast<Logical*>(untilEval.get())->getValue(); if(untilResult) break; } } while(result.getStatus() == S_SUCCESS); return result; }
void Scanner::startCountingMovements() { movementCounter = 0; movementStartedColumnNumber = getColumnNumber(); movementStartedLineNumber = getLineNumber(); }
/*** Evaluate this object ***/ Object* Equal::evaluate() { if(arg1 == 0) throw MissingArgumentException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL | OBJ_SEQUENCE | OBJ_TEXT | OBJ_LOGICAL, 1); if(arg2 == 0) throw MissingArgumentException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL | OBJ_SEQUENCE | OBJ_TEXT | OBJ_LOGICAL, 2); std::auto_ptr<Object> obj1(arg1->evaluate()); std::auto_ptr<Object> obj2(arg2->evaluate()); if(obj1->getType() == OBJ_EMPTY && obj2->getType() == OBJ_EMPTY) return new Logical(true); if(obj1->getType() == OBJ_EMPTY || obj2->getType() == OBJ_EMPTY) return new Logical(false); if(obj1->getType() == OBJ_LOGICAL) { if(obj2->getType() != OBJ_LOGICAL) throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_LOGICAL, obj2->getType(), 2); Logical* cast1 = static_cast<Logical*>(obj1.get()); Logical* cast2 = static_cast<Logical*>(obj2.get()); return new Logical(cast1->getValue() == cast2->getValue()); } if(obj1->getType() == OBJ_INTEGER) { Integer* cast1 = static_cast<Integer*>(obj1.get()); if(obj2->getType() == OBJ_INTEGER) { Integer* cast2 = static_cast<Integer*>(obj2.get()); return new Logical(cast1->getValue() == cast2->getValue()); } if(obj2->getType() == OBJ_REAL) { Real* cast2 = static_cast<Real*>(obj2.get()); return new Logical(cast1->getValue() == cast2->getValue()); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, obj2->getType(), 2); } if(obj1->getType() == OBJ_REAL) { Real* cast1 = static_cast<Real*>(obj1.get()); if(obj2->getType() == OBJ_INTEGER) { Integer* cast2 = static_cast<Integer*>(obj2.get()); return new Logical(cast1->getValue() == cast2->getValue()); } if(obj2->getType() == OBJ_REAL) { Real* cast2 = static_cast<Real*>(obj2.get()); return new Logical(cast1->getValue() == cast2->getValue()); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_INTEGER | OBJ_REAL, obj2->getType(), 2); } if(obj1->getType() == OBJ_TEXT) { if(obj2->getType() != OBJ_TEXT) throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_TEXT, obj2->getType(), 2); Text* cast1 = static_cast<Text*>(obj1.get()); Text* cast2 = static_cast<Text*>(obj2.get()); return new Logical(cast1->getValue().compare(cast2->getValue()) == 0); } if(obj1->getType() == OBJ_SEQUENCE) { if(obj2->getType() != OBJ_SEQUENCE) throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_SEQUENCE, obj2->getType(), 2); Sequence* cast1 = static_cast<Sequence*>(obj1.get()); Sequence* cast2 = static_cast<Sequence*>(obj2.get()); if(cast1->getLength() != cast2->getLength()) return new Logical(false); for(unsigned int i = 0; i < cast1->getLength(); i++) { std::auto_ptr<Object> eqResult(Equal(cast1->getObject(i)->clone(), cast2->getObject(i)->clone()).evaluate()); Logical* logResult = static_cast<Logical*>(eqResult.get()); if(logResult->getValue() == false) return new Logical(false); } return new Logical(true); } throw InvalidTypeException(getLineNumber(), getColumnNumber(), OBJ_LOGICAL | OBJ_REAL | OBJ_TEXT | OBJ_SEQUENCE | OBJ_INTEGER, obj1->getType(), 1); return 0; }
QPoint MaIterator::getMaPoint() const { SAFE_POINT(isInRange(position), "Out of boundaries", QPoint(-1, -1)); return QPoint(getColumnNumber(position), getRowNumber(position)); }