/var/www/hormigaproject.com.ar/files/src/oper/operand.cpp

Go to the documentation of this file.

/*
# Hormiga - Software de cálculo programable.
#
# Copyright (C) 2008, 2009 Leonardo Román, Hugo J. Curti, Norma  Ercoli,
# Universidad Nacional del Centro de la Provincia de Buenos Aires
# (UNCPBA)
#
# Este programa es parte de Hormiga.
#
# Hormiga es software libre. Puede redistribuirlo y/o modificarlo
# bajo los términos de la Licencia Pública General de GNU según es
# publicada por la Free Software Foundation, versión 2. Vea el archivo
# COPIA (español, no oficial) o COPYING (inglés, oficial) en directorio
# raíz.
#
# Hormiga se distribuye con la esperanza de que sea útil, pero SIN
# NINGUNA GARANTÍA, incluso sin la garantía MERCANTIL implícita o sin
# garantizar la CONVENIENCIA PARA UN PROPÓSITO PARTICULAR. Véase la
# Licencia Pública General de GNU para más detalles.
#
# Debería haber recibido una copia de la Licencia Pública General junto
# con Hormiga. Si no ha sido así, escriba a la Free Software
# Foundation, Inc., en 675 Mass Ave, Cambridge, MA 02139, EEUU.
# Añada también información sobre cómo contactar con usted mediante
# correo electrónico y postal.
#
# This file is part of Hormiga.
#
# Hormiga is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2
# as published by the Free Software Foundation; see the file COPYING
# in the top directory for details.
#
# Hormiga is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Hormiga; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
# USA
*/


#include "operand.h"

#include <math.h>

Typeable::Typeable( Type* t )
{
    this->type = t ;
}

Type* Typeable::getType() const
{
    return this->type ;
}

T_MAGNITUDE Boolean::getValue() const
{
    return ( ( this->value == FALSE )? FALSE : TRUE ) ;
}

T_STRING Boolean::toString() const
{
    //return ( ( this->value == FALSE )? QString("FALSE") : QString("TRUE") ) ;
    return ( this->getSymbol() ) ;
}

bool Boolean::isConstantExpresion () const
{
    return ( true ) ;
}

Boolean::Boolean()
{
    this->value = FALSE ;
}

Boolean::Boolean( Boolean &v )
{
    this->value = v.getValue() ;
    this->symbol = v.getSymbol() ;
}

Boolean::Boolean( T_MAGNITUDE v , T_STRING &symbol )
{
    this->value = ( v == FALSE )? FALSE : TRUE ;
    this->symbol = symbol ;
}


T_MAGNITUDE VarBoolean::setValue( T_MAGNITUDE v )
{
    return ( this->value = v != FALSE ) ;
}

bool VarBoolean::isConstantExpresion () const
{
    return ( false ) ;
}

VarBoolean::VarBoolean()
{}

VarBoolean::VarBoolean( T_MAGNITUDE &v , T_STRING &symbol )
{
    this->setValue( v ) ;
    this->symbol = symbol ;
}

VarBoolean::VarBoolean( VarBoolean &v ) : Boolean::Boolean( (Boolean&) v )
{}

VarBoolean::VarBoolean( Boolean &v ) : Boolean::Boolean( v )
{}


T_MAGNITUDE Value::getValue() const
{
    return ( this->value ) ;
}

T_STRING Value::toString() const
{
    //return ( QString("%1").arg( this->getValue() ) ) ;
    return ( this->getSymbol() ) ;
}

bool Value::isConstantExpresion () const
{
    return ( true ) ;
}

Value::Value()
{
    this->value = 0 ;
}

Value::Value( T_MAGNITUDE v , T_STRING &symbol , Type *t ) : Typeable( t )
{
    this->value = v ;
    this->symbol = symbol ;
}

Value::Value( Value &v ) : Typeable( v.type )
{
    this->value = v.getValue() ;
    this->symbol = v.getSymbol() ;
}


T_MAGNITUDE VarValue::setValue( T_MAGNITUDE v )
{
    this->value = v ;
    return ( v ) ;
}

bool VarValue::isConstantExpresion () const
{
    return ( false ) ;
}

VarValue::VarValue()
{
    owner = NULL ;
}

VarValue::VarValue( T_MAGNITUDE v , T_STRING &s , Type *t ) : Value ( v , s , t )
{
    owner = NULL ;
}

VarValue::VarValue( Value &v ) : Value ( v )
{
    owner = NULL ;
}

VarValue::VarValue( VarValue &v ) : Value::Value( v )
{
    owner = v.getOwnerStep() ;
}


void VarValueProxy::setProxiedOperand ( Operand* pv )
{
    this->realParam = pv ;
    /* As we only accept 'COPY passed params', here can't be a SymbolTable
     * object ('REFERENCE passed' param), then we need to delete it
     */
    if ( this->formalParam != NULL )
        delete this->formalParam ;
    this->formalParam = NULL ;
}

void VarValueProxy::resetInternalValue ()
{
    /* First condition is needed when it's used for internals params values on
       'integration' */
    if ( ( this->realParam != NULL )
         && (this->formalParam != NULL )
         && ( ! this->isReference ) )
    {
        delete this->formalParam ;
        this->formalParam = NULL ;
    }
}

T_MAGNITUDE VarValueProxy::setValue ( T_MAGNITUDE v )
{
    /* For memory management efficience, we only create an internal storage
     * if it's realy needed.
     */
    if ( this->formalParam == NULL )
    {
        if ( this->isReference )
        {
            this->formalParam = (VarValue*) this->realParam ;
            this->formalParam->setValue( v ) ;
        }
        else
        {
            T_STRING symbol = "internal" ;
            this->formalParam = new VarValue ( v , symbol , this->getType() ) ;
        }
    }
    else
        this->formalParam->setValue( v ) ;
    return v ;
}

T_MAGNITUDE VarValueProxy::getValue () const
{
    if ( this->formalParam == NULL )
        return this->realParam->getValue() ;
    else
        return this->formalParam->getValue() ;
}

T_STRING VarValueProxy::toString () const
{
    if ( this->realParam != NULL )
        return this->realParam->toString() ;
    else if ( this->formalParam != NULL )
        return this->formalParam->toString() ;
    return ( "VarValueProxy without instance" ) ;
}

VarValueProxy::VarValueProxy ()
{
    this->formalParam = NULL ;
    this->realParam = NULL ;
    this->isReference = false ;
}

VarValueProxy::VarValueProxy ( T_STRING symbol , Type* type , bool isReference )
        : VarValue( 0.0 , symbol , type )
{
    this->formalParam = NULL ;
    this->realParam = NULL ;
    this->isReference = isReference ;
}

VarValueProxy::~VarValueProxy ()
{
    if ( (this->formalParam != NULL ) && ( ! this->isReference ) )
        delete this->formalParam ;
}


T_MAGNITUDE Sequence::getFirst() const
{
    return ( this->first->getValue() ) ;
}

T_MAGNITUDE Sequence::getLast() const
{
    return ( this->last->getValue() ) ;
}

T_MAGNITUDE Sequence::getStep() const
{
    return ( this->step->getValue() ) ;
}

T_MAGNITUDE Sequence::getValue () const
{
    T_MAGNITUDE total = 0 ;
    for ( T_MAGNITUDE i = first->getValue() ;
          i <= last->getValue() ;
          i += step->getValue() )
        total += i ;
    return ( total ) ;
}

T_STRING Sequence::toString () const
{
    return ( QString ("[%1 .. %2 step %3]")
            .arg( first->toString() )
            .arg( last->toString() )
            .arg( step->toString() ) ) ;
}

bool Sequence::isConstantExpresion () const
{
    return ( this->first->isConstantExpresion()
             && this->last->isConstantExpresion()
             && this->step->isConstantExpresion() ) ;
}

Sequence::Sequence( Operand *f , Operand *l , Operand *s )
{
    this->first = f ;
    this->last = l ;
    this->step = s ;
}

Sequence::~Sequence ()
{
    if ( (first != NULL) && !first->isShareable() ) delete first ;
    if ( (last != NULL) && !last->isShareable() ) delete last ;
    if ( (step != NULL) && !step->isShareable() ) delete step ;
}


T_STRING UnaryOperator::toString() const
{
    return ( QString ("(%1 %2)")
            .arg( this->getSymbol() )
            .arg( op1->toString() ) ) ;
}

bool UnaryOperator::isConstantExpresion () const
{
    return ( this->op1->isConstantExpresion () ) ;
}

UnaryOperator::UnaryOperator ( Operand *op )
{
    this->op1 = op ;
}

UnaryOperator::~UnaryOperator ()
{
    if ( op1 != NULL && ! op1->isShareable() ) delete op1 ;
}


T_STRING OperatorNot::symbol = "NOT" ;

T_STRING OperatorNot::getSymbol() const
{
    return ( OperatorNot::symbol ) ;
}

T_MAGNITUDE OperatorNot::getValue() const
{
    return ( ( this->op1->getValue() == FALSE )? TRUE : FALSE ) ;
}

OperatorNot::OperatorNot( Operand *op ) : UnaryOperator::UnaryOperator ( op )
{}


T_STRING OperatorNeg::symbol = "-" ;

T_STRING OperatorNeg::getSymbol() const
{
    return ( OperatorNeg::symbol );
}

T_MAGNITUDE OperatorNeg::getValue() const
{
    return ( - this->op1->getValue() ) ;
}

OperatorNeg::OperatorNeg( Operand *op ) : UnaryOperator::UnaryOperator ( op )
{}


T_STRING OperatorFactorial::symbol = "!" ;

T_STRING OperatorFactorial::getSymbol() const
{
    return ( OperatorFactorial::symbol );
}

T_MAGNITUDE OperatorFactorial::getValue() const
{
    long long i = nearbyintl ( this->op1->getValue() ) ;
    long long t = 1 ;
    while ( i > 1 ) {
        t *= i-- ;
    }
    return ( t ) ;
}

OperatorFactorial::OperatorFactorial( Operand *op )
    : UnaryOperator::UnaryOperator ( op )
{}


T_STRING BinaryOperator::toString() const
{
    return ( QString ("( %1 %2 %3 )")
            .arg( op1->toString() )
            .arg( this->getSymbol() )
            .arg( op2->toString() ) ) ;
}

bool BinaryOperator::isConstantExpresion () const
{
    return ( this->op1->isConstantExpresion ()
             && this->op2->isConstantExpresion () ) ;
}

BinaryOperator::BinaryOperator ( Operand *op1 , Operand *op2 )
{
    this->op1 = op1 ;
    this->op2 = op2 ;
}

BinaryOperator::~BinaryOperator ()
{
    if ( op1 != NULL && ! op1->isShareable() ) delete op1 ;
    if ( op2 != NULL && ! op2->isShareable() ) delete op2 ;
}


T_STRING OperatorAdd::symbol = "+" ;

T_STRING OperatorAdd::getSymbol() const
{
    return ( OperatorAdd::symbol );
}

T_MAGNITUDE OperatorAdd::getValue() const
{
    return ( this->op1->getValue() + this->op2->getValue() ) ;
}

OperatorAdd::OperatorAdd( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}

T_STRING OperatorSub::symbol = "-" ;

T_STRING OperatorSub::getSymbol() const
{
    return ( OperatorSub::symbol );
}

T_MAGNITUDE OperatorSub::getValue() const
{
    return ( this->op1->getValue() - this->op2->getValue() ) ;
}

OperatorSub::OperatorSub( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorMul::symbol = "*" ;

T_STRING OperatorMul::getSymbol() const
{
    return ( OperatorMul::symbol );
}

T_MAGNITUDE OperatorMul::getValue() const
{
    return ( this->op1->getValue() * this->op2->getValue() ) ;
}

OperatorMul::OperatorMul( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorDiv::symbol = "/" ;

T_STRING OperatorDiv::getSymbol() const
{
    return ( OperatorDiv::symbol );
}

T_MAGNITUDE OperatorDiv::getValue() const
{
    return ( this->op1->getValue() / this->op2->getValue() ) ;
}

OperatorDiv::OperatorDiv( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorMod::symbol = "MOD" ;

T_STRING OperatorMod::getSymbol() const
{
    return ( OperatorMod::symbol );
}

T_MAGNITUDE OperatorMod::getValue() const
{
    /* Here we sould use modf() ?? */
    long long x = nearbyintl ( this->op1->getValue() ) ;
    long long y = nearbyintl ( this->op1->getValue() ) ;
    return ( x % y ) ;
}

OperatorMod::OperatorMod( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorAnd::symbol = "AND" ;

T_STRING OperatorAnd::getSymbol() const
{
    return ( OperatorAnd::symbol );
}

T_MAGNITUDE OperatorAnd::getValue() const
{
    return ( this->op1->getValue() && this->op2->getValue() ) ;
}

OperatorAnd::OperatorAnd( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorOr::symbol = "OR" ;

T_STRING OperatorOr::getSymbol() const
{
    return ( OperatorOr::symbol );
}

T_MAGNITUDE OperatorOr::getValue() const
{
    return ( this->op1->getValue() || this->op2->getValue() ) ;
}

OperatorOr::OperatorOr( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorEqual::symbol = "=" ;

T_STRING OperatorEqual::getSymbol() const
{
    return ( OperatorEqual::symbol );
}

T_MAGNITUDE OperatorEqual::getValue() const
{
    return ( this->op1->getValue() == this->op2->getValue() ) ;
}

OperatorEqual::OperatorEqual( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorDistinct::symbol = "!=" ;

T_STRING OperatorDistinct::getSymbol() const
{
    return ( OperatorDistinct::symbol );
}

T_MAGNITUDE OperatorDistinct::getValue() const
{
    return ( this->op1->getValue() != this->op2->getValue() ) ;
}

OperatorDistinct::OperatorDistinct( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorGT::symbol = ">" ;

T_STRING OperatorGT::getSymbol() const
{
    return ( OperatorGT::symbol );
}

T_MAGNITUDE OperatorGT::getValue() const
{
    return ( this->op1->getValue() > this->op2->getValue() ) ;
}

OperatorGT::OperatorGT( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorLT::symbol = "<" ;

T_STRING OperatorLT::getSymbol() const
{
    return ( OperatorLT::symbol );
}

T_MAGNITUDE OperatorLT::getValue() const
{
    return ( this->op1->getValue() < this->op2->getValue() ) ;
}

OperatorLT::OperatorLT( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorGE::symbol = ">=" ;

T_STRING OperatorGE::getSymbol() const
{
    return ( OperatorGE::symbol );
}

T_MAGNITUDE OperatorGE::getValue() const
{
    return ( this->op1->getValue() >= this->op2->getValue() ) ;
}

OperatorGE::OperatorGE( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}


T_STRING OperatorLE::symbol = "<=" ;

T_STRING OperatorLE::getSymbol() const
{
    return ( OperatorLE::symbol );
}

T_MAGNITUDE OperatorLE::getValue() const
{
    return ( this->op1->getValue() <= this->op2->getValue() ) ;
}

OperatorLE::OperatorLE( Operand *op1 , Operand *op2 )
    : BinaryOperator::BinaryOperator ( op1 , op2 )
{}