---

nci/suif/suif2b/tools/smgn/macroBase.h

Go to the documentation of this file.

#ifndef __MACROBASE__
#define __MACROBASE__

#include <stddef.h>
#include <stdio.h>
#include "common/simple_stack.h"
#include "common/MString.h"
#include "common/ref_counter.h"

#ifndef NULL
#define NULL 0
#endif

//      A macro exapnder
//
//

class MacroIter;

class MacroObject;

typedef RCPointer<MacroObject> MacroObjectPtr;
typedef DerivedRCPointer<MacroIter,MacroObjectPtr> MacroIterPtr;

class MacroObject : public RefCountedClass
    {
    public:

        static const LString ClassName;

        MacroObject() {}

        virtual ~MacroObject() {}
 
        // get the text associated with the object
        virtual const String get_text() const = 0;
 
        // return an iterator associated with this object
        // If this object is not iterated, just return the object using
        // SingleMacroIter. You can also return NULL if there are no objects
        // to iterate over (or you can return an iterator with isDone true)
 
        virtual MacroIterPtr get_iter() = 0;
 
        // get a child object. Return NULL if does not exist.
 
        virtual MacroObjectPtr  get_child(const LString &name) const {return NULL;}
 
        virtual String child_name_list() const {return String("<none>");}
 
        virtual void Print(int indent = 0) const
                { fprintf(stdout,"%s",(const char *)get_text()); }
 
        virtual bool IS_SIMPLE_list() {return false;}
        virtual void set_type_name(const LString &)  {}
        virtual LString get_instance_class_name() const = 0;
        virtual LString object_type_name() const {
            return get_instance_class_name();
        }

        // is_instance_of checks for a kind in the application domain/ This
        // is in contradistinction to isKindOf which checks the type
        // of the representation (ie, the latter is what kind of macro object)
        //
        virtual bool is_instance_of(const LString &kind ) const
            { return kind == object_type_name();}
        static const LString & get_ClassName() {return ClassName;}
        virtual bool isKindOf( const LString &kind ) const
            { return (kind == ClassName);
            }
        virtual void perform_final_cleanup() {}
    };


//      All classes which are passed to the macro processor must be MacroObjects

//      For forall, a MacroIter is required. 

class MacroIter : public MacroObject
    {
        static const LString ClassName;
    public:

        // get the current object
        virtual MacroObjectPtr Item() const = 0;

        // move to next, return true if successful
        virtual bool Next() = 0;

        // are we at end

        virtual bool isDone() = 0;
        virtual bool isLast() = 0;
        virtual int pos() = 0;

        virtual const String get_text() const;

        // return an iterator associated with this object
        // If this object is not iterated, just return the object using
        // SingleMacroIter. You can also return NULL if there are no objects
        // to iterate over (or you can return an iterator with isDone true)

        virtual MacroIterPtr get_iter();

        // get a child object. Return NULL if does not exist.

        virtual MacroObjectPtr  get_child(const LString &name) const;

        virtual String child_name_list() const;

        virtual void Print(int indent = 0) const;

        virtual LString get_instance_class_name() const {
        return ClassName;
    }
        static const LString & get_ClassName() {return ClassName;}
        virtual bool isKindOf( const LString &kind ) const
            { return ((kind == ClassName) || MacroObject::isKindOf(kind));
            }
    };

MacroIter * to_MacroIter(MacroObject * );

//      Often, simple_stack objects are iterated over. 
//      Here is a template of simple_stack base macro iterator

template <class x> class simple_stack_MacroIter : public MacroIter
    {
        int iter_pos;
        const ref_stack<x> list;
    public:
        simple_stack_MacroIter(const ref_stack<x> &the_list) : iter_pos(0), list(the_list) {}
        
        // note that this is an x not an x *. which means this template can only
        // be instantiated with pointer types!!!!!
        MacroObjectPtr  Item() const
            {
            if (iter_pos >= list.len()) 
                return NULL;
            return list[iter_pos];
            }

        bool Next() 
            {
            iter_pos ++; 
            if (iter_pos >= list.len()) 
                {
                iter_pos = list.len();
                return false;
                }
            else 
                return true;
            }

        bool isDone() 
            {
            return (iter_pos >= list.len());
            }

        bool isLast()
            {
            return (iter_pos == (list.len() - 1));
            }

        int pos() {return iter_pos;}
    };

// You also often want to pass in a null iterator or an iterator with
// exactly one object in it. When a forall is done on an object which is
// not a list, just the object itself should be returned. 

class SingleMacroIter : public MacroIter
    {
        MacroObjectPtr object;
    public:
        SingleMacroIter(MacroObjectPtr the_object = NULL) 
                : object(the_object) {}

        // note that this is an x not an x *. which means this template can only
        // be instantiated with pointer types!!!!!
        MacroObjectPtr  Item() const {return object;}

        bool Next() {object.make_null();return false;}
        bool isDone() {return object.is_null();}
        bool isLast() {return true;}

        int pos() {return 0;}

    };


class AbstractMacroListObject : public MacroObject
    {
        static const LString ClassName;

    protected:
        bool is_temp;

    public:

        AbstractMacroListObject() : is_temp(false) {}

        virtual ~AbstractMacroListObject() {}

        const String get_text() const    {return "";}

        virtual void AddObject(MacroObjectPtr object) = 0;

        virtual void CutBack(int new_len)=0;

        virtual MacroIterPtr get_iter()= 0;

        virtual int length() const = 0;

        virtual MacroObjectPtr  get_item(int i) const = 0;

        virtual void Print(int indent = 0) const = 0;

        bool get_is_temp()    {return is_temp;}

        void set_is_temp()    {is_temp = true;}

        void set_is_not_temp() {is_temp = false;}

        virtual void AddObjectList(const AbstractMacroListObject &x) = 0;

        virtual void reset()=0;

        virtual bool is_simple_list()      {return true;}

        virtual LString get_instance_class_name() const {
        return ClassName;
    }

        static const LString & get_ClassName() {return ClassName;}
        virtual bool isKindOf( const LString &kind ) const
            { return ((kind == ClassName) || MacroObject::isKindOf(kind));
            }


        MacroObjectPtr  get_child(const LString &name) const;

    };

AbstractMacroListObject * to_AbstractMacroListObject(MacroObject* p);

//      Only one parameter gets passed in. This has no name. To pass in real parameters,
//      you generally want to pass an instance of the following class. The top level name resolution
//      will then be done in the class object


class AbstractNamedList : public MacroObject
    {
        static const LString ClassName;

    public:
        virtual ~AbstractNamedList();

        virtual String child_name_list() const = 0;

        virtual void AddObject(const LString &name, MacroObjectPtr object)= 0;

        virtual void CutBack(int new_len)=0;

        virtual MacroIterPtr get_iter() = 0;

        virtual MacroObjectPtr  get_item(int i) const = 0;

        virtual void Print(int indent = 0) const = 0;

        virtual bool is_simple_list()             {return false;}

        virtual  MacroObjectPtr  get_child(const LString &name) const = 0;

        virtual int length()const  = 0;

        virtual LString get_instance_class_name() const {
        return ClassName;
    }
        static const LString & get_ClassName() {return ClassName;}
        virtual bool isKindOf( const LString &kind ) const
            { return ((kind == ClassName) || MacroObject::isKindOf(kind));
            }


        const String get_text() const    {return "";}

        virtual MacroObjectPtr get_as_list();


    };

AbstractNamedList * to_AbstractNamedList(MacroObject * );


//      Implementation of the simple string valued macro object


class AbstractStringMacroObject : public MacroObject
    {
        static const LString ClassName;

    public:

        virtual MacroIterPtr get_iter() = 0;

        // get a child object. Return NULL if does not exist.

        virtual void set_text(const String &the_text) = 0;

        virtual const String get_text() const = 0;

        virtual LString get_instance_class_name() const {
        return ClassName;
    }
        static const LString & get_ClassName() {return ClassName;}
        virtual bool isKindOf( const LString &kind ) const
            { return ((kind == ClassName) || MacroObject::isKindOf(kind));
            }

    };

AbstractStringMacroObject*  to_AbstractStringMacroObject(MacroObject * p);

#endif

---