castemplates.h

Go to the documentation of this file.

// -*- C++ -*-
//
//  Copyright (c) 2006 by Rafael Ostertag
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
//
// $Id: castemplates.h,v 1.14 2006/12/28 19:01:24 rafi Exp $
//

#ifndef _CASTEMPLATES_H
#define _CASTEMPLATES_H

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#if defined(DEBUG) || defined(DEBUG2)
#include <iostream>
#include <typeinfo>
#include <cassert>
#endif

#include <algorithm>
#include <iterator>
#include <functional>



#include "casobject.h"
#include "casexception.h"
#include "casfuncobj.h"

template<class T> void resolve_parentheses ( CASObject *o ) {
    checkptr ( o );

    T *object = dynamic_cast<T*> ( o );
    checkptr ( object );
#ifdef DEBUG2
    std::cerr << "Resolving parentheses of type: " << typeid ( *object ).name() << std::endl;
    o->Print();
    std::cout << std::endl;
#endif

    bool has_found;
    do {
        has_found = false;

        // Holds all fetched objects
        std::vector<CASObject*> fetched_objects;

        // Removal list holds all objects, from where we fetch
        // the operands.
        std::vector<CASObject*> removal_list;

        // This loop searches for nested objects
        std::vector<CASObject*>::iterator op_it = object->operands.begin();

        // Loop thru all operands
        while ( op_it != object->operands.end() ) {
            CASObject *casobj = ( *op_it );
            if ( object->GetType() == casobj->GetType() ) {
                // Fetch all operands from the nested object into the operands
                // vector of this object
                T *tp = dynamic_cast<T*> ( casobj );
#ifdef DEBUG
                assert ( casobj != 0 );
#endif
                removal_list.push_back ( tp );

                // Set the fetched operand to zero, so we can identify
                // it later in order to remove it.
                *op_it = 0;

                std::transform ( tp->operands.begin(),
                                 tp->operands.end(),
                                 std::back_inserter ( fetched_objects ),
                                 CASCloneObject() );

                has_found = true;
            }
            op_it++;
        }


        // Destroy the fetched objects
        CASObject::Garbage->Put ( removal_list );

        // Remove the 0's from this operand list
        std::vector<CASObject*>::iterator re_it =
            std::remove (
                    object->operands.begin(),
                    object->operands.end(),
                    ( CASObject* ) 0 );

        // shrink the vector
        object->operands.erase ( re_it, object->operands.end() );

        // copy the fetched objects to the operands vector
        std::copy ( fetched_objects.begin(),
                    fetched_objects.end(),
                    std::back_inserter ( object->operands ) );

    } while ( has_found );
    o->meta.UnsetSorted();
    o->meta.UnsetEvaluated();
    o->Sort();
}

template<class T> void evaluate_operands ( T *o ) {
    // Holds the addresses to the evaluated objects
    std::vector<CASObject*> eval;

    // Evaluate the operands
    std::transform ( o->operands.begin(),
                     o->operands.end(),
                     std::back_inserter ( eval ),
                     CASEvaluateObject() );

    // Put the previous operands to the garbage
    CASObject::Garbage->Put ( o->operands );

    // Now, clear the existing list
    o->operands.clear();

    // and replace it with the evaluated ones
    std::copy ( eval.begin(),
                eval.end(),
                std::back_inserter ( o->operands )
              );
}

template<class T> void expand_operands ( T *o ) {
#ifdef DEBUG2
    std::cerr << "Evaluate operands of: " << typeid ( *o ).name() << std::endl;
#endif

    // Holds the addresses to the evaluated objects
    std::vector<CASObject*> eval;

    // Evaluate the operands
    std::transform ( o->operands.begin(),
                     o->operands.end(),
                     std::back_inserter ( eval ),
                     CASExpandObject() );

    // Put the previous operands to the garbage
    CASObject::Garbage->Put ( o->operands );

    // Now, clear the existing list
    o->operands.clear();

    // and replace it with the evaluated ones
    o->operands = eval;
}

#endif /* _CASTEMPLATES_H */

---