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

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
*/


#ifndef OPERAND_H
#define OPERAND_H

#include "oper/operand_interface.h"


/* Mmmm... necesito un puntero a Step, pero si hago el include se arma la del
 * huevo y la gallina ... Parece que una declaracion implicita de la clase
 * soluciona el problema.
 */
//#include "step/step.h"
class Step ;



class Boolean : public Operand
{
public:
    virtual T_MAGNITUDE getValue () const ;
    virtual T_STRING toString () const ;
    virtual bool isShareable () { return ( true ) ; }
    virtual T_STRING getSymbol() const { return ( symbol ) ; }
    virtual bool isConstantExpresion () const ;
    Boolean () ;
    Boolean ( T_MAGNITUDE v , T_STRING &symbol ) ;
    Boolean ( Boolean &v ) ;
    virtual ~Boolean () {}

protected:
    bool value ;
    T_STRING symbol ;
};


class VarBoolean : public Boolean , Seteable
{
public:
    virtual T_MAGNITUDE setValue ( T_MAGNITUDE v ) ;
    virtual bool isConstantExpresion () const ;
    VarBoolean () ;
    VarBoolean ( T_MAGNITUDE &v , T_STRING &symbol ) ;
    VarBoolean ( Boolean &v ) ;
    VarBoolean ( VarBoolean &v ) ;
    virtual ~VarBoolean () {} ;
};

class Value : public Operand , public Typeable
{
public:
    virtual T_MAGNITUDE getValue () const ;
    virtual T_STRING toString () const ;
    virtual bool isShareable () { return ( true ) ; }
    virtual T_STRING getSymbol() const { return ( symbol ) ; }
    // This method should be abstracted into a super-class over 'Variable'
    virtual bool isSeteable () { return ( false ) ; }
    virtual bool isConstantExpresion () const ;
    Value () ;
    Value ( T_MAGNITUDE v , T_STRING &symbol , Type* type = NULL ) ;
    Value ( Value &v ) ;
    virtual ~Value () {}
protected:
    T_MAGNITUDE value ;
    T_STRING symbol ;
};

class VarValue : public Value , Seteable
{
public:
    virtual T_MAGNITUDE setValue ( T_MAGNITUDE v ) ;
    virtual void setOwnerStep ( Step *step ) { this->owner = step ; }
    virtual Step* getOwnerStep () { return ( owner ) ; }
    // Overloaded from 'Value'
    virtual bool isSeteable () { return ( true ) ; }
    virtual bool isConstantExpresion () const ;
    VarValue () ;
    VarValue ( T_MAGNITUDE v , T_STRING &symbol  , Type* type ) ;
    VarValue ( Value &v ) ;
    VarValue ( VarValue &v ) ;
    virtual ~VarValue () {}
protected:
    Step* owner ;
};

class VarValueProxy : public VarValue
{
public:
    virtual void setProxiedOperand ( Operand* proxyedVar ) ;
    virtual Operand* getProxiedOperand () { return ( realParam ) ; }
    virtual void resetInternalValue () ;
    virtual T_MAGNITUDE setValue ( T_MAGNITUDE v ) ;
    virtual T_MAGNITUDE getValue () const ;
    virtual T_STRING toString () const ;
    //virtual bool isShareable () { return ( false ) ; } ???
    VarValueProxy () ;
    VarValueProxy ( T_STRING symbol  , Type* type , bool isReference ) ;
    virtual ~VarValueProxy () ;
protected:
    Operand *realParam ;
    VarValue *formalParam ; // Not alwais used.
    bool isReference ;
};


class Sequence : public Operand
{
public:
    T_MAGNITUDE getFirst () const ;
    T_MAGNITUDE getLast () const ;
    T_MAGNITUDE getStep () const ;

    /* This method is needed by FunctionInstance in order to known that the
     * Function should be 'Integrated' (not only evaluated)
     */
    virtual bool isSequence () { return ( true ) ; }

    virtual bool isConstantExpresion () const ;

    virtual T_MAGNITUDE getValue () const ;
    virtual T_STRING toString () const ;
    virtual T_STRING getSymbol () const { return ("SEQUENCE") ; }

    Sequence ( Operand* first , Operand* last , Operand* step ) ;
    virtual ~Sequence () ;
protected:
    Operand* first ;
    Operand* last ;
    Operand* step ;
};


class OperatorNot : public UnaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorNot ( Operand *op ) ;
protected:
    static T_STRING symbol ;
};

class OperatorNeg : public UnaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorNeg ( Operand *op ) ;
protected:
    static T_STRING symbol ;
};

class OperatorFactorial : public UnaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorFactorial ( Operand *op ) ;
protected:
    static T_STRING symbol ;
};


// ------ ARITMETICS
class OperatorAdd : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorAdd ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};


class OperatorSub : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorSub ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorMul : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorMul ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorDiv : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorDiv ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorMod : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorMod ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

// ----- BOLEANS
class OperatorAnd : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorAnd ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorOr : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorOr ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorEqual : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorEqual ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorDistinct : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorDistinct ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorGT : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorGT ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorLT : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorLT ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorGE : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorGE ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

class OperatorLE : public BinaryOperator
{
public:
    virtual T_STRING getSymbol () const ;
    virtual T_MAGNITUDE getValue() const ;
    OperatorLE ( Operand *op1 , Operand *op2 ) ;
protected:
    static T_STRING symbol ;
};

#endif // OPERAND_H