/var/www/hormigaproject.com.ar/files/src/symboltable.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 "symboltable.h"

SymbolTable::SymbolTable( SymbolTable *parentContext )
{
    this->parent = parentContext ;
}

SymbolTable::~SymbolTable()
{
    T_ST_HASH_IT is ( this->symbols ) ;
    while ( is.hasNext () )
    {
        is.next() ;
        Operand *o = this->symbols.take( is.key() ) ;
        delete ( o ) ;
    }

    T_TYPE_HASH_IT it ( this->types ) ;
    while ( it.hasNext () )
    {
        it.next() ;
        Type *o = this->types.take( it.key() ) ;
        delete ( o ) ;
    }

    T_UNIT_HASH_IT iu ( this->units ) ;
    while ( iu.hasNext () )
    {
        iu.next() ;
        Unit *o = this->units.take( iu.key() ) ;
        delete ( o ) ;
    }

    T_FUNC_HASH_IT iF ( this->funcs ) ;
    while ( iF.hasNext () )
    {
        iF.next() ;
        Function *o = this->funcs.take( iF.key() ) ;
        delete ( o ) ;
    }

    T_STEPS_HASH_IT ip ( this->steps ) ;
    while ( ip.hasNext () )
    {
        ip.next() ;
        Step *o = this->steps.take( ip.key() ) ;
        delete ( o ) ;
    }
}

SymbolTable* SymbolTable::getParentSymbolTable ()
{
    return this->parent ;
}

T_STRING SymbolTable::toString()
{
    T_ST_HASH_IT it ( this->symbols ) ;
    it.toFront() ;
    T_STRING toRet = "**Symbols:\n" ;
    while ( it.hasNext () )
    {
        it.next() ;
        Operand *o = this->symbols.value( it.key() , NULL ) ;
        toRet += QString( "%1 = %2\n" )
                 .arg( o->getSymbol() )
                 .arg( o->getValue() ) ;
    }
    return ( toRet ) ;
}

bool SymbolTable::populateSymbol ( Operand *o )
{
    /* First, some security checks...
     * if a symbol with the same name is already at global scope, do nothing.
     */
    T_STRING name = o->getSymbol() ;
    if ( (parent != NULL) && (parent->getLocalSymbol( name ) == NULL)
        && ( this->symbols.remove( name ) > 0 ) )
    {
        parent->setLocalSymbol( name , o ) ;
        return ( true ) ;
    }
    return ( false ) ;
}

Operand* SymbolTable::getSymbol ( T_STRING &key ) const
{
    Operand *o = this->getLocalSymbol( key ) ;
    if ( ( o == NULL ) && ( this->parent != NULL ) )
        o = this->parent->getSymbol( key ) ;
    return ( o ) ;
}

Operand* SymbolTable::getLocalSymbol ( T_STRING &key ) const
{
    return ( this->symbols.value( key , NULL ) ) ;
}

Operand* SymbolTable::setLocalSymbol( T_STRING &key, Operand *o )
{
    Operand *tmp = this->getLocalSymbol( key ) ;
    if ( tmp == NULL )
    {
        this->symbols.insert( key , o ) ;
        return ( o ) ;
    }
    delete ( o ) ;
    return ( tmp ) ;
}

Type* SymbolTable::getType ( T_STRING &key )  const
{
    Type *t = this->getLocalType( key ) ;
    if ( ( t == NULL ) && ( this->parent != NULL ) )
        t = this->parent->getType( key ) ;
    return ( t ) ;
}

Type* SymbolTable::getLocalType ( T_STRING &key ) const
{
    return ( this->types.value( key , NULL ) ) ;
}

Type* SymbolTable::setLocalType ( T_STRING &key , Type *t )
{
    Type *tmp = this->getLocalType( key ) ;
    if ( tmp == NULL )
    {
        this->types.insert( key , t ) ;
        return ( t ) ;
    }
    delete ( t ) ;
    return ( tmp ) ;
}

Unit* SymbolTable::getUnit ( T_STRING &key )  const
{
    Unit *t = this->getLocalUnit( key ) ;
    if ( ( t == NULL ) && ( this->parent != NULL ) )
        t = this->parent->getUnit( key ) ;
    return ( t ) ;
}

Unit* SymbolTable::getLocalUnit ( T_STRING &key ) const
{
    return ( this->units.value( key , NULL ) ) ;
}

Unit* SymbolTable::setLocalUnit ( T_STRING &key , Unit *t )
{
    Unit *tmp = this->getLocalUnit( key ) ;
    if ( tmp == NULL )
    {
        this->units.insert( key , t ) ;
        return ( t ) ;
    }
    delete ( t ) ;
    return ( tmp ) ;
}

Function* SymbolTable::getFunction ( T_STRING &key ) const
{
    Function *t = this->getLocalFunction( key ) ;
    if ( ( t == NULL ) && ( this->parent != NULL ) )
        t = this->parent->getFunction( key ) ;
    return ( t ) ;
}

Function* SymbolTable::getLocalFunction ( T_STRING &key ) const
{
    return ( this->funcs.value( key , NULL ) ) ;
}


Function* SymbolTable::setLocalFunction ( T_STRING &key , Function *f )
{
    Function *tmp = this->getLocalFunction( key ) ;
    if ( tmp == NULL )
    {
        this->funcs.insert( key , f ) ;
        return ( f ) ;
    }
    delete ( f ) ;
    return ( tmp ) ;
}

Step* SymbolTable::getStep ( T_STRING &key ) const
{
    Step *t = this->getLocalStep( key ) ;
    if ( ( t == NULL ) && ( this->parent != NULL ) )
        t = this->parent->getStep( key ) ;
    return ( t ) ;
}

Step* SymbolTable::getLocalStep ( T_STRING &key ) const
{
    return ( this->steps.value( key , NULL ) ) ;
}

Step* SymbolTable::setLocalStep ( T_STRING &key , Step *f )
{
    Step *tmp = this->getLocalStep( key ) ;
    if ( tmp == NULL )
    {
        this->steps.insert( key , f ) ;
        return ( f ) ;
    }
    delete ( f ) ;
    return ( tmp ) ;
}



#include "function/corefunctions.h"
Function* CoreFunctionsBuilder::getFunction ( T_STRING &key )
{
    /* Aca habria que implementar un buen builder capaz de soportar dinamicamente
     * las funciones cargadas por biblioteca de carga dinamica
     */
    Function* f = this->funcs.value( key , NULL ) ;
    if ( f == NULL )
    {
        if ( key == "pow" )
            f = this->setFunction( key, new FunctionPow ) ;
        else if ( key == "sqrt" )
            f = this->setFunction( key, new FunctionSqrt ) ;
        else if ( key == "abs" )
            f = this->setFunction( key, new FunctionAbs ) ;
        else if ( key == "ln" )
            f = this->setFunction( key, new FunctionLn ) ;
        else if ( key == "log" )
            f = this->setFunction( key, new FunctionLog ) ;
        else if ( key == "sin" )
            f = this->setFunction( key, new FunctionSin ) ;
        else if ( key == "cos" )
            f = this->setFunction( key, new FunctionCos ) ;
        else if ( key == "tan" )
            f = this->setFunction( key, new FunctionTan ) ;
        else if ( key == "floor" )
            f = this->setFunction( key, new FunctionFloor ) ;
        else if ( key == "ceil" )
            f = this->setFunction( key, new FunctionCeil ) ;
    }
    return ( f ) ;
}

Function* CoreFunctionsBuilder::setFunction ( T_STRING &key , Function *f )
{
    this->funcs.insert( key , f ) ;
    return f ;
}