/**
* @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));
}
