FunctionMap Class Reference

#include <FunctionMap.h>

Public Member Functions
	FunctionMap ()
	The Standard constructor.
	~FunctionMap ()
	The Standard destructor.
void	AddFunction (std::string funcname, OpNode *node)
PNode *	GetFunction (const std::string &funcname)
bool	IsFunction (const std::string &funcname)
void	Erase (const std::string &funcname)
void	DumpValues ()
void	Destroy ()

Detailed Description

This is the primary structure for holding user-defined functions. It is an STL map that takes a string-based function name and stores a PNode. FunctionMap uses an STL multimap, which allows us to have many functions with the same name. The most recently loaded function blocks earlier ones, but earlier ones can be access if the later ones are deleted.

Definition at line 45 of file FunctionMap.h.

Constructor & Destructor Documentation

FunctionMap()

FunctionMap::FunctionMap

(

)

The Standard constructor.

This class stores pointers to user-defined pnode-parsed functions, which can be accessed by name. This includes the main function of the PEBL program.

Definition at line 53 of file FunctionMap.cpp.

{
    //Initiate anything necessary here.
}

~FunctionMap()

FunctionMap::~FunctionMap

(

)

The Standard destructor.

Definition at line 59 of file FunctionMap.cpp.

{
 
    //cout << "Detelitng functionmap\n";
    //Delete mFunctionMap if necessary.
    //go through each function and delete the opnode,  because
    //it is a pointer that is held nowhere else.
    Destroy();
}

References Destroy().

Member Function Documentation

AddFunction()

void FunctionMap::AddFunction	(	std::string	funcname,
		OpNode *	node
	)

This method will add a new variable with name varname and value val to the variable map, or (if it already exists) change its value to val.

Definition at line 94 of file FunctionMap.cpp.

{
 
    //Get the uppercase version of the funcname.
 
    std::string upperfuncname = PEBLUtility::ToUpper(funcname);
    //std::cout << "Adding " <<  upperfuncname << endl;
    map<string, PNode*>::iterator p;
    p = mFunctionMap.find(upperfuncname);
 
    //If a function is in there already, just signal an error.
    // Maybe we should clean up the PNode tree that
    //is there and add the new one in its place.
    if(p!=mFunctionMap.end())
        {
            cerr << "Error in function '" << upperfuncname << "'.  Function already exists.\n";
        }
    else
        {
            //variable isn't there yet, so add the new value into map
            mFunctionMap.insert(pair<string, PNode* >(upperfuncname, node));
        }
}

References PEBLUtility::ToUpper().

Referenced by Loader::LoadLibraryFunctions(), Loader::LoadUserFunctions(), and main().

Destroy()

void FunctionMap::Destroy

(

)

Definition at line 69 of file FunctionMap.cpp.

{
 
    //Delete mFunctionMap if necessary.
    //go through each function and delete the opnode,  because
    //it is a pointer that is held nowhere else.
    std::map<std::string, PNode*>::iterator i = mFunctionMap.begin();
 
    while(i != mFunctionMap.end())
        {
            if(i->second)
                {
                    i->second->DestroyChildren();
                    delete i->second;
                    i->second = NULL;
                }
            i++;
        }
    mFunctionMap.clear();
}

References NULL.

Referenced by CaptureSignal(), PEBLInterpret(), and ~FunctionMap().

DumpValues()

void FunctionMap::DumpValues

(

)

This method is primarily for debugging purposes. It will iterate through the entire variable map, and Display each of the values held in the map.

Definition at line 212 of file FunctionMap.cpp.

{
    map<string,PNode *>::iterator p;
    cerr << "---------------------------\n    Function Map:\n";
    for(p= mFunctionMap.begin(); p!=mFunctionMap.end(); p++)
        {
            cerr << "Function Name:  [" << std::flush;
            cerr << p->first << ":";
            cerr << ":" << *(p->second) << "]\n" ;
 
        }
 
}

Referenced by GetFunction(), Loader::LoadLibraryFunctions(), main(), and PEBLInterpret().

Erase()

void FunctionMap::Erase

(

const std::string &

funcname

)

This will erase the topmost value stored in varname

Definition at line 200 of file FunctionMap.cpp.

{
    std::string upperfuncname = PEBLUtility::ToUpper(funcname);
    mFunctionMap.erase(upperfuncname);
}

References PEBLUtility::ToUpper().

Referenced by main().

GetFunction()

PNode * FunctionMap::GetFunction

(

const std::string &

funcname

)

This method will add a new function with name and code associated with the OpNode node, which is of type PEBL_FUNCTION. This method will retrieve the value designated by funcname. If funcname doesn't exist, it will return a null pointer.

Definition at line 140 of file FunctionMap.cpp.

{
    // Convert the function name to uppercase, so that it will find
    // a match when searching through the upper-case functionmap.
 
    std::string  funcname = PEBLUtility::ToUpper(lcasefuncname);
    map<string,PNode*>::iterator p;
 
    //Get a the function
 
    p = mFunctionMap.find(funcname);
 
    if(p == mFunctionMap.end())
        {
            //This should probably signal an error.
            PError::SignalFatalError(string("Function Name [")+ funcname+string("] not found.\n"));
            DumpValues();
            return NULL;//new DataNode(Variant(PEBL_DATA_NODE),"PEBL SELF-GENERATED OBJECT",-1);
        }
    else
        {
 
            //Otherwise, just return a pointer to the node.
            //cast it to the appropriate type.
            if((p->second)->GetType() == PEBL_OP_NODE)
                return (OpNode*)(p->second);
 
            else if((p->second)->GetType() == PEBL_DATA_NODE)
                return (DataNode*)(p->second);
 
            else
                return p->second;
        }
 
}

References DumpValues(), NULL, PEBL_DATA_NODE, PEBL_OP_NODE, PError::SignalFatalError(), and PEBLUtility::ToUpper().

Referenced by Evaluator::CallFunction(), Evaluator::Evaluate1(), Loader::GetMainPEBLFunction(), and main().

IsFunction()

bool FunctionMap::IsFunction

(

const std::string &

funcname

)

This function just determines whether there is a function of the given name. It is useful because GetFunction() may behave badly when the function doesn't exist. It converts the query to uppercase, because everything in the functionmap should be uppercase.

Definition at line 182 of file FunctionMap.cpp.

{
 
    std::string  upperfuncname = PEBLUtility::ToUpper(funcname);
    //Get a the function from the map
    map<string,PNode*>::iterator p;
    p = mFunctionMap.find(upperfuncname);
 
    //If it isn't in there, return false, otherwise true.
    if(p == mFunctionMap.end())
        return false;
    else
        return true;
}

References PEBLUtility::ToUpper().

---

The documentation for this class was generated from the following files:

• FunctionMap.h
• FunctionMap.cpp