Evaluator Class Reference

This class has got everything you need to evaluate stuff. More...

#include <Evaluator-es.h>

Public Member Functions
	Evaluator ()
	Evaluator (Variant &stacktop, string scope)
	~Evaluator ()
void	CallFunction (const OpNode *node)
bool	Evaluate1 ()
bool	Evaluate1 (const PNode *node)
bool	Evaluate1 (const OpNode *node)
	This method evaluates OpNodes.
bool	Evaluate1 (const DataNode *node)
	This method evaluates DataNodes.
void	Push (Variant v)
Variant	Pop ()
Variant	Peek ()
void	NodeStackPush (const PNode *node)
int	GetNodeStackDepth ()
int	GetStackDepth ()
PEventLoop *	GetEventLoop ()
bool	IsVariableName (Variant v)
	Evaluator ()
	Evaluator (Variant &stacktop, string scope)
	~Evaluator ()
void	CallFunction (const OpNode *node)
bool	Evaluate (const PNode *node)
bool	Evaluate (const OpNode *node)
	This method evaluates OpNodes.
bool	Evaluate (const DataNode *node)
	This method evaluates DataNodes.
void	Push (const Variant &v)
Variant	Pop ()
const Variant &	Peek () const
unsigned long int	GetStackDepth ()
PEventLoop *	GetEventLoop ()
bool	IsVariableName (Variant v)

Static Public Attributes
static FunctionMap	mFunctionMap
	Initiate some static member data.
static VariableMap	gGlobalVariableMap
static PEventLoop *	mEventLoop =NULL
static PEBLPath	gPath
static const PNode *	gEvalNode = NULL
static PCallStack	gCallStack

Friends
class	PEventLoop

Detailed Description

This class has got everything you need to evaluate stuff.

Definition at line 58 of file Evaluator-es.h.

Constructor & Destructor Documentation

Evaluator() [1/4]

Evaluator::Evaluator

(

)

Definition at line 92 of file Evaluator-es.cpp.

                    :
    mStackMax(10000),
    mScope("Base Scope")
{
#ifdef PEBL_DEBUG_PRINT 
    cout << "Creating Evaluator: " << mScope << endl;
#endif
 
 
    mEventLoop = new PEventLoop();
 
    gCallStack.Push(gEvalNode);
}

References gCallStack, gEvalNode, mEventLoop, PEventLoop, and PCallStack::Push().

Evaluator() [2/4]

Evaluator::Evaluator	(	Variant &	stacktop,
		string	scope
	)

Definition at line 107 of file Evaluator-es.cpp.

                                                    :
    //    mCallStack(callstack),
    mStackMax(10000),
    mScope(scope)
{
#ifdef PEBL_DEBUG_PRINT 
    cout << "Creating Evaluator: " << mScope << endl;
#endif
 
    //add everything in callstack onto mCallStack
    //mCallStack = callstack;
 
    mEventLoop = new PEventLoop();
 
    //Push the current evalnode onto the stack, if
    //it exists.
    if(gEvalNode)
        {
            gCallStack.Push(gEvalNode);
 
        }
    //Initialize the evaluator scope with a variant which is a list of variables
    Push(stacktop);
}

References gCallStack, gEvalNode, mEventLoop, PEventLoop, PCallStack::Push(), and Push().

~Evaluator() [1/2]

Evaluator::~Evaluator

(

)

Definition at line 133 of file Evaluator-es.cpp.

{
#ifdef PEBL_DEBUG_PRINT
    cout << "Deleting Evaluator: " << mScope << endl;
#endif
 
    //NOTE: gCallStack is a GLOBAL variable shared across all evaluator instances.
    //We should NOT clear it in the destructor, as it may contain entries from other
    //evaluators that are still running. Each function call properly pushes/pops
    //its own entry via PEBL_LAMBDAFUNCTION/PEBL_FUNCTION_TAIL_LIBFUNCTION.
    //
    //while( gCallStack.Size())
    //    gCallStack.Pop();
 
 
}

Evaluator() [3/4]

Evaluator::Evaluator

(

)

Evaluator() [4/4]

Evaluator::Evaluator	(	Variant &	stacktop,
		string	scope
	)

~Evaluator() [2/2]

Evaluator::~Evaluator

(

)

Member Function Documentation

CallFunction() [1/2]

void Evaluator::CallFunction

(

const OpNode *

node

)

This method takes a PEBL_FUNCTION OpNode, which is comprised of a P_DATA_FUNCTION DataNode on the left and a parameter list on the right, Finds the function code in the FunctionMap, and Evaluates that code.

Definition at line 1982 of file Evaluator-es.cpp.

{
 
 
    // First get the right node (the argument list) and evaluate it.
    // This will end up with a list Variant on top of the stack. 
    const PNode *node1 = node->GetRight();
    
    Evaluate1(node1);
 
 
    // The parameters for a function are in a list on the top of the stack.
    // A function should pull the list off the stack and push it onto
    // the stack of the new evaluator scope.
 
 
    //Get the name of the function.  
 
    Variant funcname =dynamic_cast<DataNode*>(node->GetLeft())->GetValue();
 
    //If the argument is a custom object, the custom object
    //might contain a class-specific method to use instead of the generic function
    //The argument is at the top of the stack right now.
 
    Variant v = Peek();
    if(v.IsComplexData())
        {
            //if v is a comlpex data, it should be a parameter list.
 
 
            PList *plist = dynamic_cast<PList*>(v.GetComplexData()->GetObject().get());
            Variant first = plist->First();
            
            if(first.IsComplexData())
                {
 
                    if( first.GetComplexData()->IsCustomObject())
                        {
 
                            PCustomObject * pco = dynamic_cast<PCustomObject*>(first.GetComplexData()->GetObject().get());
                            
 
                            if(OVE_SUCCESS== pco->ValidateProperty(funcname))
                                {
 
                                    funcname = Variant(pco->GetProperty(funcname).GetString().c_str(), P_DATA_FUNCTION);
 
                                }
 
                        }
                }
        }
 
 
    
    const PNode * node2 = mFunctionMap.GetFunction(funcname);
 
 
#ifdef PEBL_DEBUG_PRINT
    cout << "Calling a function with argument list: " <<  endl;
#endif 
    
 
    //Now, node2 will either be a PEBL_LAMBDAFUNCTION or a PEBL_BUILTINFUNCTION
    //Lambda functions are just code blocks, but need to be executed in 
    //a new scope, so need their own evaluator.  A built-in function is precompiled
    //and doesn't need its own new scope, so don't create one in that case.
    
 
 
 
    switch(((OpNode*)node2)->GetOp())
        {
        case PEBL_LAMBDAFUNCTION:
            {   //Need to create a new scope to allow for variable declaration
                //within case statement
 
                //get the top item of the stack.
                Variant v = Pop();
                
                
                //Make a new evaluator for the function scope and v at the top of the stack.
                Evaluator  myEval(v,funcname.GetFunctionName());
                
                //The callstack just keeps track of the series of
                //evaluators for debugging purposes.
                
                //Evaluate the lambda function in new scope.
 
                
                myEval.Evaluate1(node2);
 
                //Now that myEval is finished, take the
                //node off the callstack.
                //gCallStack.Pop();
                
                //If myEval has a stack depth of 1, it does not return anything.
                //If myEval has a stack depth of 2, it wants to return the top value.
                if(myEval.GetStackDepth() == 1)
                    {
                        //Add '1' to the stack as the default return value for a function (i.e., one without
                        //an explicit return value.)
                        cout << "Adding dummy value to end of null function\n";
                        Push(1);
                    }
                else if (myEval.GetStackDepth() == 2)
                    {
                        //Get the top of the function evaluator and push it onto the current evaluator.
                        //cout << "Adding real value of subfunction to end of null function\n";
                        Variant v1 = myEval.Pop();
                        Push(v1);
                    }
            }
            break;
            
        case PEBL_LIBRARYFUNCTION:
            Evaluate1(node2);
 
            break;
 
 
        default:
            PError::SignalFatalError("Unknown Function Type in Evaluator::CallFunction");
            break;
                }
 
}

References Evaluate1(), PList::First(), counted_ptr< X >::get(), Variant::GetComplexData(), FunctionMap::GetFunction(), Variant::GetFunctionName(), OpNode::GetLeft(), PComplexData::GetObject(), PCustomObject::GetProperty(), OpNode::GetRight(), GetStackDepth(), Variant::GetString(), Variant::IsComplexData(), PComplexData::IsCustomObject(), mFunctionMap, myEval, OVE_SUCCESS, P_DATA_FUNCTION, Peek(), Pop(), Push(), PError::SignalFatalError(), and PCustomObject::ValidateProperty().

Referenced by PEBLEnvironment::CallFunction(), and Evaluate().

CallFunction() [2/2]

void Evaluator::CallFunction

(

const OpNode *

node

)

Evaluate() [1/3]

bool Evaluator::Evaluate

(

const DataNode *

node

)

This method evaluates DataNodes.

Definition at line 1271 of file Evaluator.cpp.

{
 
    //Set up the globally-accessible structure to allow
    //better error reporting.
    if(node->GetLineNumber() > -1)
        gEvalNode = node;
 
#ifdef PEBL_DEBUG_PRINT
    cout << "-------------------------";
    cout << "Evaluating DataNode of Value: " << node->GetValue() << endl;;
    cout << "Line: " << node->GetLineNumber() << endl;
#endif
 
    Variant v1, v2;
 
    //A node of type P_DATA_NODE could be an integer, a float, a variable, a string, etc.
    //Grab the variant out of the node.  If it is a Variable, extract the value.
    //Push the initial value or the variable onto the stack.
 
    v1 = node->GetValue();
 
    switch(v1.GetDataType())
        {
        case P_DATA_LOCALVARIABLE:
            {
 
                v2  = mLocalVariableMap.RetrieveValue(v1.GetVariableBaseName());
                //Get the name of property being
                string property =v1.GetVariablePropertyName();
 
                if(property!="")
                    {
                        v2 = PEBLUtility::ResolvePropertyChain(v2, property);
                    }
 
                Push(v2);
            }
            break;
 
 
 
 
        case P_DATA_GLOBALVARIABLE:
            {
                v2  = gGlobalVariableMap.RetrieveValue(v1.GetVariableBaseName());
 
                //Get the name of property being
                string property =v1.GetVariablePropertyName();
                if(property!="")
                    {
                        v2 = PEBLUtility::ResolvePropertyChain(v2, property);
                    }
 
                Push(v2);
            }
            break;
 
        case P_DATA_NUMBER_INTEGER:
        case P_DATA_NUMBER_FLOAT:
        case P_DATA_STRING:
        case P_DATA_COMPLEXDATA:
 
#ifdef PEBL_DEBUG_PRINT
            cout << "Evaluating a normal Variant: ";
            cout <<  v1 << endl;
#endif
            Push(v1);
            break;
 
        case P_DATA_UNDEFINED:
        default:
            //This should signal an error.
            PError::SignalFatalError("In Function [" + mScope + "Undefined Data Type in Evaluate::Evaluate(DataNode)");
            return false;
            break;
        }
 
    return true;
}

References Variant::GetDataType(), PNode::GetLineNumber(), DataNode::GetValue(), Variant::GetVariableBaseName(), Variant::GetVariablePropertyName(), gEvalNode, gGlobalVariableMap, P_DATA_COMPLEXDATA, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, P_DATA_NUMBER_FLOAT, P_DATA_NUMBER_INTEGER, P_DATA_STRING, P_DATA_UNDEFINED, Push(), PEBLUtility::ResolvePropertyChain(), VariableMap::RetrieveValue(), and PError::SignalFatalError().

Evaluate() [2/3]

bool Evaluator::Evaluate

(

const OpNode *

node

)

This method evaluates OpNodes.

This switch could probably be improved with an STL Map

Definition at line 186 of file Evaluator.cpp.

{
 
    unsigned long int numargs = 0;
    if(node == NULL) PError::SignalFatalError("Trying to evaluate null node\n");
    //Set up the globally-accessible structure to allow
    //better error reporting.
    if(node->GetLineNumber() > -1)
        gEvalNode = node;
 
#ifdef PEBL_DEBUG_PRINT
    cout << "-------------------------Evaluating OpNode ["<< node->GetOp() << "] of Type: " << node->GetOpName() << "------------\n";
#endif
 
 
    switch(node->GetOp())
        {
 
        case NULL:
            break;
 
 
        case PEBL_ASSIGN:
            {
                //The left node should contain a DataNode of Variant type Variable.
                //The right node should contain an expression that evaluates to a number
                //that should be assigned to the datanode.
 
 
                const PNode * node2 = node->GetRight();
                Evaluate(node2);
 
                //The evaluated expression is now at the top of the stack.
                //Leave it there, because this statement should return that value; but assign
                //it to v2.
                Variant v2 = mStack.top();
 
                const PNode * node1 =node->GetLeft();
 
                //Extract the variable name from the node.
 
                Variant v1=((DataNode*)node1)->GetValue();
 
 
#ifdef PEBL_DEBUG_PRINT
                cout << "Initial Variable Name: [" << v1.GetVariableName() << "]" << endl;
#endif
 
                //Get the name of property being set
                string property =v1.GetVariablePropertyName();
 
                //Add the variable name/value pair to the appropriate map structure
                if(v1.IsLocalVariable())
                    {
 
                        if(property == "")
                            {
                                //Variable is added here.  What
                                //happens if it overwrites something?
 
                                mLocalVariableMap.AddVariable(v1.GetVariableName(), v2);
                            }
                        else
                            {
                                //otherwise get the object from the variable store
                                //and set its property.
 
                                Variant v3 = mLocalVariableMap.RetrieveValue(v1.GetVariableBaseName());
                                PEBLUtility::SetPropertyChain(v3, property, v2);
                            }
 
 
                    }
                else
                    {
 
                        if(property == "")
                            {
                                gGlobalVariableMap.AddVariable(v1.GetVariableName(),v2);
                            }
                        else
                            {
                                //otherwise get the object from the variable store
                                //and set its property.
                                Variant v3 = gGlobalVariableMap.RetrieveValue(v1.GetVariableBaseName());
                                PEBLUtility::SetPropertyChain(v3, property, v2);
                            }
 
                    }
 
 
            }
            break;
 
        case PEBL_ADD:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate(node2);
 
                //Get the top two items from the stack.  The rightmost will
                //be on top.
                Variant v2 = Pop();
                Variant v1 = Pop();
 
                //There maybe should be more error checking to ensure
                //that the atoms are numbers.
 
                Push(v1+v2);
            }
            break;
 
 
        case PEBL_DIVIDE:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2);
 
 
 
                //Get the top two items from the stack
                Variant v2 = Pop();
                Variant v1 = Pop();
 
                Push(v1/v2);
            }
            break;
 
 
        case PEBL_MULTIPLY:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2 );
 
 
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
 
                Push(v1*v2);
            }
            break;
 
 
        case PEBL_POWER:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2);
 
 
 
                //Get the top two items from the stack
                Variant v2 = Pop();
                Variant v1 = Pop();
 
                Push(Variant(pow((pDouble)v1,(pDouble)v2)));
            }
            break;
 
 
        case PEBL_SUBTRACT:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2 );
 
 
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
 
                Push(v1 - v2);
            }
            break;
 
 
        case PEBL_AND:
            {
                // Short-circuit AND: evaluate left first; if false, skip right.
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                Variant v1 = Peek();
                if(!(bool)v1)
                {
                    // Left is false; result is false without evaluating right.
                    // (v1 already on stack from Evaluate; replace it)
                    Pop();
                    Push(Variant(0));
                }
                else
                {
                    Pop();
                    const PNode * node2 = node->GetRight();
                    Evaluate( node2 );
                    Variant v2 = Pop();
                    Push(v1 && v2);
                }
 
            }
            break;
 
        case PEBL_OR:
            {
                // Short-circuit OR: evaluate left first; if true, skip right.
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                Variant v1 = Peek();
                if((bool)v1)
                {
                    // Left is true; result is true without evaluating right.
                    Pop();
                    Push(Variant(1));
                }
                else
                {
                    Pop();
                    const PNode * node2 = node->GetRight();
                    Evaluate( node2 );
                    Variant v2 = Pop();
                    Push(v1 || v2);
                }
 
            }
            break;
 
        case PEBL_NOT:
            {
                //Evaluate left nodes, and negate it.
 
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
 
                //Get the top two items from the stack.  The right will be on top
                Variant v1 = Pop();
 
                Push(!v1);
            }
            break;
 
 
        case PEBL_IF:
            {
 
                //Left node is the expression test;
                //Right node is the code block to execute if true.
 
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                Variant v1 = Pop();
                if(v1)
                    {
                        PNode * node2 = node->GetRight();
                        Evaluate( node2 );
                    }
                else
                    {
                        //If the IF is not true, we still need to leave something on the
                        // stack; leave a 0.
                        Push(0);
 
                    }
            }
            break;
 
        case PEBL_IFELSE:
            {
                //Left node is the expression test;
                //Right node is the THEN code block to execute.
 
                //Execute left node, which puts results on stack
                const PNode * node1=node->GetLeft();
                Evaluate( node1 );
 
                const PNode * node2 = node->GetRight();
                Evaluate(node2);
            }
            break;
 
        case PEBL_ELSE:
            {
                //This looks on the top of the stack and
                //executes the left node if true; right node if false.
 
                Variant v1 = Pop();
 
                const PNode * node1;
                if(v1)
                    {
                        node1 = node->GetLeft();
                    }
                else
                    {
                        node1 = node->GetRight();
                    }
                Evaluate(node1);
            }
            break;
 
        case PEBL_LAMBDAFUNCTION:
            {
                // This is the top node of an anonymous function.  It is a
                // node with two children: on the left is a variable list, and
                // on the right is a code block.  To make it a named function, just
                // the parent node will be a PEBL_FUNCTION OpNode with a left child
                // which is a function datanode.
 
                // When this function is called, the top of the stack is a list that contains
                // the bindings for the variables. Get the list and assign the values to the
                // variables one-by-one, then execute the code block.
 
                //Get the variable list.  This may have either empty or variable-pair default values.
 
                const PNode * node1 = node->GetLeft();
 
                //Get the argument list is at the top of the stack right now.
 
                Variant v1 = Pop();
 
                //Create a list to use.
                //If v1 is a stacksignal list_head, there are no arguments
                //provided.
 
 
 
                counted_ptr<PEBLObjectBase> tmpList;
 
                if( v1.IsStackSignal() && v1.GetSignal() == STACK_LIST_HEAD)
                    {
                        //v1 is empty, so make a dummy parameter list to send.
 
                        tmpList = counted_ptr<PEBLObjectBase>(new PList());
                    }
 
 
                if( v1.IsComplexData())
                    {
 
                        //extract the object out of v1 to send.
                        tmpList = v1.GetComplexData()->GetObject();
                    }
 
 
                //now, tmpList is a list containing the sequence of arguments fed into the function call.
                //They should map onto the first N arguments in the template.
 
                Variant v2 = 0;
 
                //iterate through the lists and assign values to variables.
                PList * arglist = (PList*)(tmpList.get());
 
                vector <Variant>::iterator p = arglist->Begin();
                Variant vdef = 0;  // Initialize to prevent uninitialized reads
 
                while(node1)
                    {
                        //Each variable could be either a variable name (global or local)
                        //or a varpair--a node pairing a global/local with a value.
                        vdef = 0;  // Reset to 0 each iteration (don't re-declare, would shadow outer vdef)
 
                        //This loads the default values initially when they appear,
                        //and then overwrites them if actual values exist.  This means
                        //the default value(if global) needs to exist--it probably shoudn't have to
                        bool hasdefault = false;
                        if(((OpNode*)(((OpNode*)node1)->GetLeft()))->GetOp()==PEBL_VARPAIR)
                            {
                           //this variable has a default value....
                                hasdefault = true;
                                //v2 is the variable name.
                                DataNode* varNameNode = ((DataNode*)(((OpNode*)(((OpNode*)node1)->GetLeft()))->GetLeft()));
                                v2 = varNameNode->GetValue();
 
                                // Get the default value node - could be DataNode or OpNode
                                PNode* defaultNode = ((OpNode*)(((OpNode*)node1)->GetLeft()))->GetRight();
 
                                if(defaultNode->GetType() == PEBL_OP_NODE)
                                    {
                                        // The default value is an expression (e.g., -1, Min(data)).
                                        // Evaluate it in the current function scope to get its value.
                                        // This allows referencing previously-bound parameters.
                                        Evaluate(defaultNode);
                                        vdef = Pop();
                                    }
                                else
                                    {
                                        //It is a data node--default value.
                                        DataNode* defValueNode = (DataNode*)defaultNode;
                                        vdef = defValueNode->GetValue();
                                    }
                            }
                        else
 
                            {
                                //it is a pure value here
                                v2 = ((DataNode*)(((OpNode*)node1)->GetLeft()))->GetValue();
 
                            }
 
 
 
                        // Now bind the parameter immediately (either from argument or default)
                        // This allows later parameters' defaults to reference earlier parameters.
                        if(p != arglist->End())
                            {
                                // We have an argument value - use it
                                mLocalVariableMap.AddVariable(v2, *p);
                                p++;
                                node1 = ((OpNode*)node1)->GetRight();
                            }
                        else if(hasdefault)
                            {
                                // No argument provided, but we have a default value
                                // Resolve variable references in the default value
                                if(vdef.IsGlobalVariable())
                                    {
                                        vdef = gGlobalVariableMap.RetrieveValue(vdef);
                                    }
                                else if (vdef.IsLocalVariable())
                                    {
                                        // A local variable may be bound to a previously-specified parameter
                                        vdef = mLocalVariableMap.RetrieveValue(vdef);
                                    }
                                mLocalVariableMap.AddVariable(v2, vdef);
                                node1 = ((OpNode*)node1)->GetRight();
                            }
                        else
                            {
                                // No argument and no default - too few parameters
                                string message = "Too few arguments passed to function [" + mScope + "].";
 
                                if(mScope == "Start")
                                    message += " (Make sure Start function has only one variable).";
 
                                PError::SignalFatalError(message);
                            }
                    }
 
 
 
                //if(arglist && arglist->Length() > 0)
                if(p != arglist->End())
                    {
                        //Too many arguments.
                        string message = string("");
 
                        if(mScope == "Start")
                            message += "Start() function must be Start(p)).";
                        else
                            message += "Too many arguments passed to function [" + mScope + "].";
 
                        
                        PError::SignalFatalError(message);
                    }
 
 
                //Now, get the code block and execute it.
                const PNode * node2 = node->GetRight();
                Evaluate(node2);
            }
            break;
 
 
        case PEBL_LIBRARYFUNCTION:
            {
 
                // This type of function is built in and precompiled.  The loader examines
                // the parse tree and
                // identifies each function that is used.
 
                //The left child of a PEBL_LIBRARYFUNCTION contains an PEBL_AND node containing two datanodes
                //each containing integers describing the min and max  number of arguments, respectively.
 
 
                //We should be able to tell the name of the function
                std::string name = node->GetFunctionName();
 
                const OpNode * node0 =(OpNode*)(node->GetLeft());
                const unsigned int min = ((DataNode*)(node0->GetLeft()))->GetValue().GetInteger();
                const unsigned int max = ((DataNode*)(node0->GetRight()))->GetValue().GetInteger();
                
                //The right child of a PEBL_LIBRARYFUNCTION contains a datanode which
                //has a function pointer in it.
 
 
                const PNode * node1 = node->GetRight();
                Variant v1 = ((DataNode*)node1)->GetValue();
 
 
                //All built-in functions take a single parameter: a Variant list.
                //This variant should be on the top of the stack right now. So get it.
 
                Variant v2 = Pop();
 
 
                //Before we execute, check to see if v2 has a length  between min and max.
 
 
                PList * tmp = NULL;
                if (v2.IsStackSignal())
                    numargs = 0;
                else
                    {
 
                        //      cout << "((("<<name<<"|"<<v2<<")))\n";
 
                        if(v2.IsComplexData())
                            {
                                if((v2.GetComplexData())->IsList())
                                    {
                                        //#if !defined(PEBL_EMSCRIPTEN)
 
 
                                        //Dont check parameter numbers in EMSCRIPTEN
                                        //cout << "[[[<"<<v2<<">]]]\n";
                                        tmp = (PList*)(v2.GetComplexData()->GetObject().get());
                                        numargs = tmp->Length();
 
                                        //#endif
                                    }
                                else
                                    {
                                        cout << "UNHANDLED ELSE CASE. NOT A LIST\n" ;
                                    }
                            }
                        //cout << "numargs now: " << numargs << endl;
                    }
 
 
                //#if !defined(PEBL_EMSCRIPTEN)
                if(numargs < min || numargs > max)
                    {
 
                        Variant message = Variant("In scope [") + mScope + Variant("]:") +
                            Variant("function [") +name+Variant("]:")+
                            Variant("Incorrect number of arguments..  Wanted between ")+
                            Variant((int)min) + Variant(" and ") +Variant((int)max) + Variant(" but got ") + Variant((int)numargs);
 
 
                        cout << message << endl;
                        PError::SignalFatalError(message);
                    }
                //#endif
 
                //Execute the functionpointer and push the results onto the stack.
                Push((v1.GetFunctionPointer())(v2));
            }
 
            break;
 
 
        case PEBL_FUNCTION:
            // This controls the execution of a function. (not the
            // loading of a defined function).  A function node
            // has a function datanode on its left child and an arglist (the head of a list of
            // arguments) on its right child.  Just pass these  along to the CallFunction Method.
 
            CallFunction(node);
 
 
            break;
 
        case PEBL_WHILE:
            {
                // The left child node is an expression to test
                // The right node is a code block.
                // Test the left node, then evaluate the right node if true.
                // Repeat until left node is false.
 
                Variant results=0;
                while(1)
                    {
                        //Execute left node, which puts results on stack
                        const PNode * node1=node->GetLeft();
                        Evaluate( node1 );
 
                        //Get the result of the evaluation
                        Variant v1 = Pop();
 
                        //If the evaluation is false, break out of loop/switch
                        if(!v1)
                            {
                                results = Variant(0);
                                break;
                            }
 
 
                        //Evaluate the right node.
                        const PNode * node2 = node->GetRight();
                        Evaluate(node2);
 
                        //Now, the results of the while block are on top of the stack.
                        //Pop them off so the stack doesn't grow; add them back at the end.
                        results = Pop();
 
                        if(results.GetDataType() == P_DATA_STACK_SIGNAL &&
                           results == Variant(STACK_BREAK))
                            {
                                results = Pop();
                                break;
                            }
 
                    }
                //Push the last results back onto the stack.
                Push(results);
            }
            break;
 
 
        case PEBL_LOOP:
            {
                // The PEBL_LOOP node has two children: the left child is a variable/datum pair,
                // and the right child is a code block that should be evaluated once for each
                // element of the datum, with the variable being set to that element for
                // each iteration.
 
                //Get the variabledatum pair:
                const PNode * node1 = node->GetLeft();
 
                Evaluate(node1);
 
                //Now, the top two items on the stack should be the datum and the variable.
 
                Variant v1 = Pop();
                Variant v2 = Pop();
 
                PError::AssertType(v2, PEAT_VARIABLE,"Error: iterator of loop not a variable");
 
                const PNode * node2 = node->GetRight();
 
                //Now, iterate through the elements of v1.  If v1 is not a list,
                //just set the variable equal to v1 and execute once.
 
 
                PList * tmp;
                if(v1.IsInteger())
                    {
                        tmp = new PList();
                        for(int count=1; count <= v1.GetInteger(); count++)
                            {
                                tmp->PushBack(count);
                            }
 
                        //make a list here containing numbers 1...v1
                    }else{
 
                        PError::AssertType(v1, PEAT_LIST,"Second argument of loop(<iterator>, <list>) must be a list.");
                        tmp = (PList*)(v1.GetComplexData()->GetObject().get());
                    }
 
                //Retrieve an iterator to the items in the list.
                //PComplexData * tmpPCD = v1.GetComplexData();
 
                vector<Variant>::const_iterator p = tmp->Begin();
                vector<Variant>::const_iterator end = tmp->End();
                Variant results=0;
 
                while(p != end)
                    {
 
                        //Set the variable to the current list element, and increment p
                        if(v2.IsLocalVariable())
                            {
                                mLocalVariableMap.AddVariable(v2, *p);
                            }
                        else if (v2.IsGlobalVariable())
                            {
                                gGlobalVariableMap.AddVariable(v2,*p);
                            }
 
                        p++;
 
                        //Execute the code block.
                        Evaluate(node2);
 
                        //Now, the results of the while block are on top of the stack.
                        //Pop them off so the stack doesn't grow; add them back at the end.
                        results = Pop();
 
                        if(results.GetDataType() == P_DATA_STACK_SIGNAL &&
                           results == Variant(STACK_BREAK))
                            {
                                p = end;
                                Pop();
                                results = Variant(0);
 
                            }
                    }
                //Push the last results back onto the stack.
                        Push(results);
 
            }
            break;
 
        case PEBL_VARIABLEDATUM:
            {
                //The VARIABLDATUM node is used in the loop function. The variable is the
                //left child, a list of data is the right. This node is executed once at the beginning
                //of the loop; it pushes the variable name and the evaluated list onto the stack.
                //PEBL_LOOP evaluation then gets them from the stack and iterates through the list,
                //setting the variable to each element of the data.
 
                //Get the variable:
                const PNode * node1 = node->GetLeft();
 
                //Push the variable name directly on the stack (without evaluating it.)
                Push(((DataNode*)node1)->GetValue());
 
                //Get the datum:
                const PNode * node2 = node->GetRight();
 
                //Evaluate the datum--it gets put on the stack.
                Evaluate(node2);
            }
            break;
 
 
        case PEBL_ARGLIST:
            {
                // This behaves almost exactly like a listhead. It will end up with a variant
                // on the top of the stack that is a list containing all of the arguments
                // for a function.
 
 
                //Create the stack signal variant and push it onto the stack.
                Variant v1 = Variant(STACK_LIST_HEAD);
                Push(v1);
 
                //Get the top node of the list
                const PNode * node1 = node->GetLeft();
 
                if(node1)
                    {
                        //If it exists, evaluate it.
                        Evaluate(node1);
                    }
 
                //if node1 doesn't exist, it is a null argument list--do nothing more.
 
 
            }
            break;
 
        case PEBL_LISTHEAD:
            {
                //When we get a list head, we need to evaluate each expression in the list,
                //pushing them onto the stack. When we get to the end of the list, we just need
                //to pop items, adding them to the list,  until we get back up to the top.
                //To do this efficiently and avoid recreating lists iteratively, the bottom
                //item does this in a while loop.  to signal the end of the while loop, the
                //PEBL_LISTHEAD must put a dummy item on the stack so the bottom item
                //knows when the front of the list has been reached.
                //This is a variant of type STACK_LIST_HEAD
 
                //Create the stack signal variant and push it onto the stack.
                Variant v1 = Variant(STACK_LIST_HEAD);
                Push(v1);
 
                //Get the top node of the list and Evaluate it.
                const PNode * node1 = node->GetLeft();
                if(node1)
                    {
                        Evaluate(node1);
                    }
                else
                    {
                        //If node1 is NULL, we have an empty list.
                        //Get rid of the STACK_LIST_HEAD on the top of the stack
                        Pop();
 
                        //Make an empty list and push it onto the stack.
                        counted_ptr<PEBLObjectBase> tmpList = counted_ptr<PEBLObjectBase>(new PList());
 
                        PComplexData  pcd = PComplexData(tmpList);
                        Variant v2 = Variant(&pcd);
                        Push(v2);
                    }
            }
            break;
 
 
        case PEBL_LISTITEM:
            {
                // for a list item, the list is represented as a parsed tree with the
                // left node being the data and the right node being another listitem node.
                // This should create the list piece by piece recursively.
 
                // To do this, Evaluate() each item so it gets executed and the value
                // gets pushed onto the stack.  When you come to the end of the list,
                // pop the items off the list iteratively until you get back where you came from.
 
                //The data: Get it out of the tree and evaluate it, so it gets
                //push onto the stack.
 
 
                const PNode * node1 = node->GetLeft();
                Evaluate(node1);
 
                //The rest of the list;
                const PNode * node2 = node->GetRight();
 
                // If the right node not null, then we need to evaluate it until we get to the end
                // of the list. If it is null, we are at the end of the list; create
                // the beginning of a list and push it onto the stack.
                if(node2)
                    {
                        //Evaluate the tail of the list
                        Evaluate(node2);
 
                        //When above is done, a list object will be at the top
                        //of the stack.  don't touch it
                    }
                else
                    {
 
 
                        //If node2 is NULL, then we are at the end of the list.
                        //everything has been pushed to the stack.  Just get everything
                        //off the stack, make a list out of it,  and put it back on the stack.
 
 
                        //Must make a new list, and create a variant out of it.
                        PList * tmpList = new PList();
                        PList order;
                        int ord = 0;
                        //Now, pop off items from the list until you get to a
                        //P_DATA_STACK_SIGNAL, then if it i
                        Variant v1 = Pop();
 
                        //we need to create the list from the items on the stack.
                        //But the top of the stack is the end of the list.
                        while(v1.GetDataType() != P_DATA_STACK_SIGNAL)
                            {
 
                                //cout << "::::" << v1 << endl;
                                //Add the item to the list.
                                tmpList->PushBack(v1);//This used to be PushFront
                                order.PushBack(ord--);
                                //Pop and repeat.
                                v1 = Pop();
                            }
 
                        //When tmpList had a list inside it, we could use PushFront to
                        //automatically reverse the list, which is now on the stack with
                        //the last element first.
                        //But now that it is a vector, it is inefficient to push onto the front
                        //And involves recopying every element), so we will just reverse it now
                        //that it is in a handy list format.
 
                        std::reverse(tmpList->Begin(),tmpList->End());
 
                        counted_ptr<PEBLObjectBase> pl = counted_ptr<PEBLObjectBase>(tmpList);
                        PComplexData  pcd =  PComplexData(pl);
                        Variant v2 = Variant(&pcd);
                        Push(v2);
                    }
            }
            break;
 
        case PEBL_LT:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2);
 
 
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
 
 
 
                Push(v1 < v2);
            }
            break;
 
        case PEBL_GT:
            {
 
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2);
 
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
                Push(v1 > v2);
            }
            break;
 
        case PEBL_GE:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2);
 
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
 
                Push(v1 >= v2);
            }
            break;
 
        case PEBL_LE:
            {
 
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2);
 
 
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
 
                Push(v1 <= v2);
            }
            break;
 
        case PEBL_EQ:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2);
 
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
                Push(v1 == v2);
            }
            break;
 
        case PEBL_NE:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                Evaluate( node1 );
                const PNode * node2 = node->GetRight();
                Evaluate( node2);
 
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
 
                Push(v1 != v2);
            }
            break;
 
        case PEBL_STATEMENTS:
            {
                //This is a node that connects two statements. Since a statement leaves its
                //evaluation on the stack, this should pop the stack after evaluating the LEFT
                //statement. This means that the last statement in a series remains on the stack.
 
#ifdef PEBL_DEBUG_PRINT
                cout << "Checking a PEBL_STATEMENTS: " << GetStackDepth() << endl;
#endif
 
                //If the top of the stack is a STACK_BREAK, we should do nothing.
                if(GetStackDepth())
                    {
 
                        Variant v1 = Peek();
 
 
                        if(v1.GetDataType() == P_DATA_STACK_SIGNAL &&
                           v1 == Variant(STACK_BREAK))
                            {
                                //cout << "STACKBREAKING ON RIGHT\n";
 
                                //If this is a stack signal, and if
                                //it is a break, we should just back out
                                Push(Variant(0));  //why isn't this stack_break?
                                break;
                            }
                    }
 
                if(node->GetLeft())
                    {
                        Evaluate(node->GetLeft());
                        Variant v1 = Pop();
 
 
                        if(v1.GetDataType() == P_DATA_STACK_SIGNAL &&
                           v1 == Variant(STACK_BREAK))
                            {
                                //cout << "STACKBREAKING ON LEFT\n";
                                //If this is a stack signal, and if
                                //it is a break, we should just back out
                                Push(Variant(STACK_BREAK));
                                break;
                            }
                    }
 
                if(node->GetRight())
                    Evaluate(node->GetRight());
            }
 
            break;
 
 
        case PEBL_BREAK:
            {
                //This exits out of the current loop, while, or function context.
                //it works by adding a STACK_BREAK stacksignalevent onto the top of the stack.
                //all relevant loops look for this type of event and
                //cleanly abort when that times comes.
 
                //                cout << "PEBL_BREAK HANDLER\n";
 
                Variant v1 = Variant(STACK_BREAK);
                Push(v1);
                Push(v1);
#ifdef PEBL_DEBUG_PRINT
                cout << "PEBL_BREAK: pushing break onto stack.\n";
#endif
 
            }
            break;
 
        case PEBL_RETURN:
            {
                //The return keyword is used ONLY at the very end of a
                //function.  Here, we pushes a dummy variant
                //STACK_RETURN_DUMMY onto the stack and then evaluates
                //the left node.  Consequently, after the return
                //expression is evaluated, the stack depth will be two
                //instead of one. The CallFunction() method then
                //extracts the top of the stack from the function
                //scope and puts it on the caller's stack, otherwise
                //it puts a '1' to indicate that the function has
                //returned successfully.
 
                //This is done to avoid the potentially confusing
                //construct in LISP and others that the final
                //expression in a function is the return value.
 
                //This is a brittle way to signal a return value.
 
                //
                Push(Variant(STACK_RETURN_DUMMY));
 
                const PNode * node1 = node->GetLeft();
                Evaluate(node1);
            }
            break;
 
        default:
            //Signal an error here.
            return false;
            break;
 
        }
    return true;
}

References VariableMap::AddVariable(), PError::AssertType(), PList::Begin(), CallFunction(), count, PList::End(), Evaluate(), counted_ptr< X >::get(), Variant::GetComplexData(), Variant::GetDataType(), PNode::GetFunctionName(), Variant::GetFunctionPointer(), Variant::GetInteger(), OpNode::GetLeft(), PNode::GetLineNumber(), PComplexData::GetObject(), OpNode::GetOp(), OpNode::GetOpName(), OpNode::GetRight(), Variant::GetSignal(), GetStackDepth(), PNode::GetType(), DataNode::GetValue(), Variant::GetVariableBaseName(), Variant::GetVariableName(), Variant::GetVariablePropertyName(), gEvalNode, gGlobalVariableMap, Variant::IsComplexData(), Variant::IsGlobalVariable(), Variant::IsInteger(), Variant::IsLocalVariable(), Variant::IsStackSignal(), PList::Length(), NULL, P_DATA_STACK_SIGNAL, pDouble, PEAT_LIST, PEAT_VARIABLE, PEBL_OP_NODE, Peek(), Pop(), Push(), PList::PushBack(), VariableMap::RetrieveValue(), PEBLUtility::SetPropertyChain(), PError::SignalFatalError(), STACK_BREAK, STACK_LIST_HEAD, and STACK_RETURN_DUMMY.

Evaluate() [3/3]

bool Evaluator::Evaluate

(

const PNode *

node

)

This is the generic PNode evaluator

Definition at line 148 of file Evaluator.cpp.

{
 
    if(node == NULL) PError::SignalFatalError("Trying to evaluate null node\n");
    //Set up the globally-accessible structure to allow
    //better error reporting.  Only change it if the new node's
    //line number is greater than -1; if not, it is a PEBL-generated
    //node that won't give very good information.
    if(node->GetLineNumber() > -1)
        gEvalNode = node;
 
#ifdef PEBL_DEBUG_PRINT
    cout << "Line: " << node->GetLineNumber() << endl;
    cout << "PDP::Type: " << node->GetType() << endl;
    cout << "PDP::Type: " << node->GetType() << endl;
#endif
 
    if(node->GetType() ==  PEBL_OP_NODE)
        {
            return Evaluate((OpNode*)node);
        }
    else if (node->GetType() ==  PEBL_DATA_NODE)
        {
            return Evaluate((DataNode*)node);
        }
    else
        {
#ifdef PEBL_DEBUG_PRINT
            cout << "ERROR IN GENERIC EVALUATOR::EVALUATE" << endl;
#endif
            return false;
        }
 
    return true;
}

References Evaluate(), PNode::GetLineNumber(), PNode::GetType(), gEvalNode, NULL, PEBL_DATA_NODE, PEBL_OP_NODE, and PError::SignalFatalError().

Referenced by PEBLEnvironment::CallFunction(), Evaluate(), Evaluate(), PEBLInterpret(), and PEBLInterpret().

Evaluate1() [1/4]

bool Evaluator::Evaluate1

(

)

Definition at line 199 of file Evaluator-es.cpp.

{
    const PNode * node =  mNodeStack.top();
 
#ifdef PEBL_DEBUG_PRINT 
    cout << "---------------async--a--------\n";
#endif
 
 
    mNodeStack.pop();
 
    return Evaluate1(node);
}

References Evaluate1().

Referenced by CallFunction(), PEBLEnvironment::CallFunction(), Eval1(), Evaluate1(), Evaluate1(), Evaluate1(), PEventLoop::Loop(), and PEBLInterpret().

Evaluate1() [2/4]

bool Evaluator::Evaluate1

(

const DataNode *

node

)

This method evaluates DataNodes.

Definition at line 1891 of file Evaluator-es.cpp.

{
 
    //Set up the globally-accessible structure to allow
    //better error reporting.
    if(node->GetLineNumber() > -1)
        gEvalNode = node;
 
#ifdef PEBL_DEBUG_PRINT 
    cout << "-------------------------";
    cout << "Evaluating DataNode of Value: " << node->GetValue() << endl;;
    cout << "Line: " << node->GetLineNumber() << endl;
#endif
 
    Variant v1, v2;
 
    //A node of type P_DATA_NODE could be an integer, a float, a variable, a string, etc.
    //Grab the variant out of the node.  If it is a Variable, extract the value.
    //Push the initial value or the variable onto the stack.
  
    v1 = node->GetValue();
 
    switch(v1.GetDataType())
        {
 
        case P_DATA_LOCALVARIABLE:
            {
 
                v2  = mLocalVariableMap.RetrieveValue(v1.GetVariableBaseName());
                //Get the name of property being
                string property =v1.GetVariablePropertyName();
 
                if(property!="")
                    {
                        v2 = PEBLUtility::ResolvePropertyChain(v2, property);
                    }
 
                Push(v2);
            }
            break;
 
 
 
 
        case P_DATA_GLOBALVARIABLE:
            {
                v2  = gGlobalVariableMap.RetrieveValue(v1.GetVariableBaseName());
 
                //Get the name of property being
                string property =v1.GetVariablePropertyName();
                if(property!="")
                    {
                        v2 = PEBLUtility::ResolvePropertyChain(v2, property);
                    }
 
                Push(v2);
            }
            break;
 
        case P_DATA_NUMBER_INTEGER:
        case P_DATA_NUMBER_FLOAT:
        case P_DATA_STRING:
        case P_DATA_COMPLEXDATA:
      
#ifdef PEBL_DEBUG_PRINT 
            cout << "Evaluating a normal Variant: ";
            cout <<  v1 << endl;
#endif
            Push(v1);
            break;
 
        case P_DATA_UNDEFINED:
        default:
            //This should signal an error.
            PError::SignalFatalError("In Function [" + mScope + "Undefined Data Type in Evaluate::Evaluate(DataNode)");
            return false;
            break;
        }
 
    return true;
}

References Variant::GetDataType(), PNode::GetLineNumber(), DataNode::GetValue(), Variant::GetVariableBaseName(), Variant::GetVariablePropertyName(), gEvalNode, gGlobalVariableMap, P_DATA_COMPLEXDATA, P_DATA_GLOBALVARIABLE, P_DATA_LOCALVARIABLE, P_DATA_NUMBER_FLOAT, P_DATA_NUMBER_INTEGER, P_DATA_STRING, P_DATA_UNDEFINED, Push(), PEBLUtility::ResolvePropertyChain(), VariableMap::RetrieveValue(), and PError::SignalFatalError().

Evaluate1() [3/4]

bool Evaluator::Evaluate1

(

const OpNode *

node

)

This method evaluates OpNodes.

Definition at line 216 of file Evaluator-es.cpp.

{
 
    int numargs = -1;
    if(node == NULL) PError::SignalFatalError("Trying to evaluate null node\n");
    //Set up the globally-accessible structure to allow
    //better error reporting.
    if(node->GetLineNumber() > -1)
        gEvalNode = node;
 
#ifdef PEBL_DEBUG_PRINT
    cout << "---------------async--b--------Evaluating OpNode ["<< node->GetOp() << "] of Type: " << node->GetOpName() << "------------\n";
 
#endif
 
 
 
    switch(node->GetOp()) 
        {
            
        case NULL:
            break;
 
            /******************************
              Handled
            ***********************************/
            
        case PEBL_ASSIGN:
            {
                //The left node should contain a DataNode of Variant type Variable.
                //The right node should contain an expression that evaluates to a number
                //that should be assigned to the datanode.
                
                
                const PNode * node2 = node->GetRight();
                //Evaluate(node2);
                const OpNode * tail = new OpNode(PEBL_ASSIGN_TAIL,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
 
 
                const PNode * variablenode = node->GetLeft();
 
                mNodeStack.push(variablenode);
                mNodeStack.push(tail);
                mNodeStack.push(node2);
 
            }
 
            break;
 
            case PEBL_ASSIGN_TAIL:
                {
                    //The evaluated expression is now at the top of the stack.
                    //Leave it there, because this statement should return that value; but assign
                    //it to v2.
                    Variant v2 = mStack.top();
 
                    const PNode * node1 = mNodeStack.top();
                    mNodeStack.pop();
                
                    //Extract the variable name from the node.
                    Variant v1=((DataNode*)node1)->GetValue();
 
 
#ifdef PEBL_DEBUG_PRINT
                    cout << "Initial Variable Name: [" << v1.GetVariableName() << "]" << endl;
#endif
 
                    //Get the name of property being 
                    string property =v1.GetVariablePropertyName();
 
                    //Add the variable name/value pair to the appropriate map structure
                    if(v1.IsLocalVariable())
                        {
 
                            if(property == "")
                                {
                                    mLocalVariableMap.AddVariable(v1.GetVariableName(), v2);
                                }
                            else
                                {
                                    //otherwise get the object from the variable store
                                    //and set its property.
 
                                    Variant v3 = mLocalVariableMap.RetrieveValue(v1.GetVariableBaseName());
                                    PEBLUtility::SetPropertyChain(v3, property, v2);
                                }
 
 
                        }
                    else
                        {
 
                            if(property == "")
                                {
                                    gGlobalVariableMap.AddVariable(v1.GetVariableName(),v2);
                                }
                            else
                                {
                                    //otherwise get the object from the variable store
                                    //and set its property.
                                    Variant v3 = gGlobalVariableMap.RetrieveValue(v1.GetVariableBaseName());
                                    PEBLUtility::SetPropertyChain(v3, property, v2);
                                }
 
                        }
 
 
                }
                break;
          
                /*****************************
             HANDLED ITERATIVE
                ************************************/
            case PEBL_ADD:
                {
                    //Execute left and right nodes, which puts results on stack
                    const PNode * node1 = node->GetLeft();
                    const PNode * node2 = node->GetRight();
                    //Create new opnode to handle tail...
                    const OpNode * tail = new OpNode(PEBL_ADD_TAIL,NULL,NULL,node->GetFilename(), node->GetLineNumber());
 
                    mNodeStack.push(tail);
                    mNodeStack.push(node2);
                    mNodeStack.push(node1);
        
                }
                break;
 
 
            case PEBL_ADD_TAIL:
                {
                    //Get the top two items from the stack.  The rightmost will
                    //be on top.
                    Variant v2 = Pop();
                    Variant v1 = Pop();
 
                    //There maybe should be more error checking to ensure
                    //that the atoms are numbers.
                
                    Push(v1+v2);
 
                }
                break;
 
                /*******************************
               ITERATED COMPLETE:
                *******************************/
            case PEBL_DIVIDE:
                {
                    //Execute left and right nodes, which puts results on stack
                    const PNode * node1 = node->GetLeft();
                    const PNode * node2 = node->GetRight();
                    const OpNode * tail = new OpNode(PEBL_DIVIDE_TAIL,NULL,NULL,
                                                     node->GetFilename(), node->GetLineNumber());
                
                    mNodeStack.push(tail);
                    mNodeStack.push(node2);
                    mNodeStack.push(node1);
                
                }
                break;
            
            case PEBL_DIVIDE_TAIL:
                {
                    //Get the top two items from the stack
                    Variant v2 = Pop(); 
                    Variant v1 = Pop();
                
                    Push(v1/v2);
                }
                break;
 
 
                /***************************
              ITERATED!!!
                **************************/
            case PEBL_MULTIPLY:
                {
                    //Execute left and right nodes, which puts results on stack
                    const PNode * node1 = node->GetLeft();
                    const PNode * node2 = node->GetRight();
                    const OpNode * tail = new OpNode(PEBL_MULTIPLY_TAIL,NULL,NULL,
                                                     node->GetFilename(), node->GetLineNumber());
                
                    mNodeStack.push(tail);
                    mNodeStack.push(node2);
                    mNodeStack.push(node1);
                }
                break;
            case PEBL_MULTIPLY_TAIL:
                {
                    //Get the top two items from the stack.  The right will be on top
                    Variant v2 = Pop(); 
                    Variant v1 = Pop();
                
                    Push(v1*v2);
                }
                break;
            
 
                /******************************
              ITERATED!!!
                ***********************************/
            case PEBL_POWER:
                {
                    //Execute left and right nodes, which puts results on stack
                    const PNode * node1 = node->GetLeft();
                    const PNode * node2 = node->GetRight();
                    const OpNode * tail = new OpNode(PEBL_POWER_TAIL,NULL,NULL,
                                                     node->GetFilename(), node->GetLineNumber());
                    mNodeStack.push(tail);
                    mNodeStack.push(node2);
                    mNodeStack.push(node1);
 
                }
                break;
            case PEBL_POWER_TAIL:
                {
                
                    //Get the top two items from the stack
                    Variant v2 = Pop(); 
                    Variant v1 = Pop();
 
                    Push(Variant(pow((pDouble)v1,(pDouble)v2)));
                }
                break;
 
 
                /******************************
              ITERATED!!!
                ***********************************/
            case PEBL_SUBTRACT:
                {
                    //Execute left and right nodes, which puts results on stack
                    const PNode * node1 = node->GetLeft();
                    const PNode * node2 = node->GetRight();
        
                    const OpNode * tail = new OpNode(PEBL_SUBTRACT_TAIL,NULL,NULL,
                                                     node->GetFilename(), node->GetLineNumber());
                    mNodeStack.push(tail);
                    mNodeStack.push(node2);
                    mNodeStack.push(node1);
                
                }
                break;
            case PEBL_SUBTRACT_TAIL:
                {
                    //Get the top two items from the stack.  The right will be on top
                    Variant v2 = Pop(); 
                    Variant v1 = Pop();
                
                    Push(v1 - v2);
                }
                break;
        
 
                /**************************
                   HANDLED
                **************************/
            case PEBL_AND:
                {
                    // Short-circuit AND: store node2 in the tail so PEBL_AND_TAIL
                    // can conditionally schedule it after seeing v1.
                    PNode * node1 = node->GetLeft();
                    PNode * node2 = node->GetRight();
                    const OpNode * tail = new OpNode(PEBL_AND_TAIL, node2, NULL,
                                                     node->GetFilename(), node->GetLineNumber());
                    mNodeStack.push(tail);
                    mNodeStack.push(node1);
                }
                break;
            case PEBL_AND_TAIL:
                {
                    if(node->GetLeft() != NULL)
                    {
                        // Phase 1: v1 is on the data stack; decide whether to evaluate v2.
                        Variant v1 = Pop();
                        if(!(bool)v1)
                        {
                            // Short-circuit: left is false, result is false.
                            Push(Variant((pInt)0));
                        }
                        else
                        {
                            // Left is true: push v1 back, schedule node2, then a finish TAIL.
                            Push(v1);
                            const OpNode * finish = new OpNode(PEBL_AND_TAIL, NULL, NULL,
                                                               node->GetFilename(), node->GetLineNumber());
                            mNodeStack.push(finish);
                            mNodeStack.push(node->GetLeft());  // node2
                        }
                    }
                    else
                    {
                        // Phase 2 (finish): both v1 and v2 are on the data stack.
                        Variant v2 = Pop();
                        Variant v1 = Pop();
                        Push(v1 && v2);
                    }
                }
                break;
 
                /*****************************
                   HANDLED
                ************************************/
            case PEBL_OR:
                {
                    // Short-circuit OR: store node2 in the tail so PEBL_OR_TAIL
                    // can conditionally schedule it after seeing v1.
                    PNode * node1 = node->GetLeft();
                    PNode * node2 = node->GetRight();
                    const OpNode * tail = new OpNode(PEBL_OR_TAIL, node2, NULL,
                                                     node->GetFilename(), node->GetLineNumber());
                    mNodeStack.push(tail);
                    mNodeStack.push(node1);
                }
                break;
            case PEBL_OR_TAIL:
                {
                    if(node->GetLeft() != NULL)
                    {
                        // Phase 1: v1 is on the data stack; decide whether to evaluate v2.
                        Variant v1 = Pop();
                        if((bool)v1)
                        {
                            // Short-circuit: left is true, result is true.
                            Push(Variant((pInt)1));
                        }
                        else
                        {
                            // Left is false: push v1 back, schedule node2, then a finish TAIL.
                            Push(v1);
                            const OpNode * finish = new OpNode(PEBL_OR_TAIL, NULL, NULL,
                                                               node->GetFilename(), node->GetLineNumber());
                            mNodeStack.push(finish);
                            mNodeStack.push(node->GetLeft());  // node2
                        }
                    }
                    else
                    {
                        // Phase 2 (finish): both v1 and v2 are on the data stack.
                        Variant v2 = Pop();
                        Variant v1 = Pop();
                        Push(v1 || v2);
                    }
                }
                break;
            
            /*******************************
             HANDLED:
            **********************************/
            case PEBL_NOT:
                {
                    //Evaluate left nodes, and negate it.
                    
                    //Execute left and right nodes, which puts results on stack
                    const PNode * node1 = node->GetLeft();
                    const OpNode * tail = new OpNode(PEBL_NOT_TAIL,NULL,NULL,
                                                     node->GetFilename(), node->GetLineNumber());
                    
                    mNodeStack.push(tail);
                    mNodeStack.push(node1);
                    
                    
                }
                break;
                
            case PEBL_NOT_TAIL:
                {
                    //Get the top two items from the stack.  The right will be on top
                    Variant v1 = Pop();
                    Push(!v1);
                }
                break;
                
                
                /**************************
                    HANDLED
          *********************************/
            case PEBL_IF:
                {
 
                    //Left node is the expression test;
                    //Right node is the code block to execute if true.
 
                    const PNode * node1 = node->GetLeft();
                    const OpNode * tail = new OpNode(PEBL_IF_TAIL,NULL,NULL,
                                                     node->GetFilename(), node->GetLineNumber());
 
                    const PNode * codeblock = node->GetRight();
 
                    //Put the codeblock on the stack; we will remove it
                    //later if need be.
 
                    mNodeStack.push(codeblock);
                    mNodeStack.push(tail);
                    mNodeStack.push(node1);
 
                }
                break;
 
            case PEBL_IF_TAIL:
                {
                    Variant v1 = Pop();
                    if(v1)
                        {
                            //The test was true, so execute the codeblock.
                            //We need a tail to check if the codeblock returned a STACK_BREAK
                            const OpNode * tail2 = new OpNode(PEBL_IF_TAIL2,NULL,NULL,
                                                              node->GetFilename(), node->GetLineNumber());
                            mNodeStack.push(tail2);
                            //The codeblock is already on the node stack and will execute next
 
                        }
                    else
                        {
                            //The code block we want to execute is on top...
                            //remove it because the test failed.
 
                            mNodeStack.pop();
 
                            //Put a dummy value on the stack as the return value.
                            Push(0);
                        }
                }
                break;
 
            case PEBL_IF_TAIL2:
                {
                    //The codeblock has executed. Check if it returned a STACK_BREAK
                    //If so, propagate it; otherwise leave the result as-is
                    //Actually, we don't need to do anything here - the result is already
                    //on the stack and will be checked by the enclosing STATEMENTS node
                }
                break;
                
            /*****************************************************************/
            case PEBL_IFELSE:
                {
                    //Left node is the expression test;
                    //Right node is a PEBL_ELSE node, which 
                    //has both code blocks on it, and 
                    //decides what to do based on what is
                    //on the top o' the stack.
 
                
                //Execute left node, which puts results on stack
                const PNode * node1 = node->GetLeft();
                const PNode * node2 = node->GetRight();
 
                mNodeStack.push(node2);
                mNodeStack.push(node1);
                    
            }
            break;
 
            /****************************
 
                 HANDLED
    *************************************/
        case PEBL_ELSE:
            {
                //This looks on the top of the stack and
                //executes the left node if true; right node if false.
 
                Variant v1 = Pop();
 
                const PNode * node1;
                if(v1)
                    {
                        node1 = node->GetLeft();
                    }
                else
                    {
                        node1 = node->GetRight();
                    }
 
                //Add a tail to check if the codeblock returns a STACK_BREAK
                const OpNode * tail = new OpNode(PEBL_ELSE_TAIL,NULL,NULL,
                                                  node->GetFilename(), node->GetLineNumber());
                mNodeStack.push(tail);
                mNodeStack.push(node1);
            }
            break;
 
        case PEBL_ELSE_TAIL:
            {
                //The codeblock has executed. Check if it returned a STACK_BREAK
                //If so, propagate it; otherwise leave the result as-is
                //The result is already on the stack and will be checked by the enclosing STATEMENTS node
            }
            break;
 
            /*****************************************************************/
        case PEBL_LAMBDAFUNCTION:
            {
                // This is the top node of an anonymous function.  It is a 
                // node with two children: on the left is a variable list, and
                // on the right is a code block.  To make it a named function, just
                // the parent node will be a PEBL_FUNCTION OpNode with a left child
                // which is a function datanode.
                
                // When this function is called, the top of the stack is a list that contains
                // the bindings for the variables. Get the list and assign the values to the 
                // variables one-by-one, then execute the code block.
                
                //Get the variable list.
                const PNode * node1 = node->GetLeft();
 
                //Get the argument list.
                Variant v1 = Pop();
 
                //Create a list to use.
                //If v1 is a stacksignal list_head, there are no arguments
                //provided.
 
 
                counted_ptr<PEBLObjectBase> tmpList;
 
                if( v1.IsStackSignal() && v1.GetSignal() == STACK_LIST_HEAD)
                    {
                        //v1 is empty, so make a dummy parameter list to send.
 
                        tmpList = counted_ptr<PEBLObjectBase>(new PList());
                    }
 
 
                if( v1.IsComplexData())
                    {
 
                        //extract the object out of v1 to send.
                        tmpList = v1.GetComplexData()->GetObject(); 
                    }
 
 
 
 
                Variant v2 = 0;
 
 
                //iterate through the lists and assign values to variables.
                PList * tmp = (PList*)(tmpList.get());
 
                vector <Variant>::iterator p = tmp->Begin();
                Variant vdef = 0;  // Initialize to prevent uninitialized reads
 
                while(node1)
                    {
                        //Each variable could be either a variable name (global or local)
                        //or a varpair--a node pairing a global/local with a value.
                        vdef = 0;  // Reset to 0 each iteration
 
                        //This loads the default values initially when they appear,
                        //and then overwrites them if actual values exist.  This means
                        //the default value(if global) needs to exist--it probably shoudn't have to
                        bool hasdefault = false;
                        if(((OpNode*)(((OpNode*)node1)->GetLeft()))->GetOp()==PEBL_VARPAIR)
                            {
                           //this variable has a default value....
                                hasdefault = true;
                                //v2 is the variable name.
                                v2 =   ((DataNode*) (  ((OpNode*)(((OpNode*)node1)->GetLeft()))->GetLeft()))->GetValue();
 
                                // Get the default value node - could be DataNode or OpNode
                                PNode* defaultNode = ((OpNode*)(((OpNode*)node1)->GetLeft()))->GetRight();
 
                                if(defaultNode->GetType() == PEBL_OP_NODE)
                                    {
                                        // The default value is an expression (e.g., -1, Min(data)).
                                        // Evaluate it in the current function scope to get its value.
                                        // This allows referencing previously-bound parameters.
                                        mNodeStack.push(defaultNode);
                                        while(mNodeStack.size() > 0)
                                            {
                                                Evaluate1();
                                            }
                                        vdef = Pop();
                                    }
                                else
                                    {
                                        //It is a data node--default value.
                                        vdef = ((DataNode*)defaultNode)->GetValue();
                                    }
                            }
                        else
                            {
                                //it is a pure value here
                                v2 = ((DataNode*)(((OpNode*)node1)->GetLeft()))->GetValue();
                            }
 
                        // Now bind the parameter immediately (either from argument or default)
                        // This allows later parameters' defaults to reference earlier parameters.
                        if(p != tmp->End())
                            {
                                // We have an argument value - use it
                                mLocalVariableMap.AddVariable(v2, *p);
                                p++;
                                node1 = ((OpNode*)node1)->GetRight();
                            }
                        else if(hasdefault)
                            {
                                // No argument provided, but we have a default value
                                // Resolve variable references in the default value
                                if(vdef.IsGlobalVariable())
                                    {
                                        vdef = gGlobalVariableMap.RetrieveValue(vdef);
                                    }
                                else if (vdef.IsLocalVariable())
                                    {
                                        // A local variable may be bound to a previously-specified parameter
                                        vdef = mLocalVariableMap.RetrieveValue(vdef);
                                    }
                                mLocalVariableMap.AddVariable(v2, vdef);
                                node1 = ((OpNode*)node1)->GetRight();
                            }
                        else
                            {
                                // No argument and no default - too few parameters
                                string message = "Too few arguments passed to function [" + mScope + "].";
 
                                if(mScope == "Start")
                                    message += " (Make sure Start function has only one variable).";
 
                                PError::SignalFatalError(message);
                            }
                    }
 
 
 
                //if(tmp && tmp->Length() > 0)
                if(p != tmp->End())
                    {
                        //Too many arguments.
                        string message = string("Too many arguments passed to function [" + mScope + "].");
 
                        if(mScope == "Start") message += " (Make sure Start function has a variable).";
                        PError::SignalFatalError(message);
                    }
                    
 
                //Now, get the code block and execute it.
                const PNode * node2 = node->GetRight();
 
                //No tail function needed?
                mNodeStack.push(node2);
            }
            break;
            
            /*******************************
              HANDLED (Nothing needed)
          **********************************/
        case PEBL_LIBRARYFUNCTION:
            {
 
 
                // This type of function is built in and precompiled.  The loader examines
                // the parse tree and
                // identifies each function that is used.
                
                //The left child of a PEBL_LIBRARYFUNCTION contains an PEBL_AND node containing two datanodes 
                //each containing integers describing the min and max  number of arguments, respectively.
 
 
                const OpNode * node0 =(OpNode*)(node->GetLeft());
                //We should be able to tell the name of the function
 
                std::string name = node->GetFunctionName();
 
 
 
 
                const unsigned int min = ((DataNode*)(node0->GetLeft()))->GetValue().GetInteger();
                const unsigned int max = ((DataNode*)(node0->GetRight()))->GetValue().GetInteger();
 
                
 
                //The right child of a PEBL_LIBRARYFUNCTION contains a datanode which
                //has a function pointer in it.
 
                const PNode * node1 = node->GetRight();
                Variant v1 = ((DataNode*)node1)->GetValue();
 
                //All built-in functions take a single parameter: a Variant list.  
                //This variant should be on the top of the stack right now. So get it.
                Variant v2 = Pop();
 
                //Before we execute, check to see if v2 has a length  between min and max.
 
 
                PList * tmp = NULL;
                if (v2.IsStackSignal())
                    numargs = 0;
                else
                    {
                        if(v2.IsComplexData())
                            {
                                if((v2.GetComplexData())->IsList())
                                    {
                                        //#if !defined(PEBL_EMSCRIPTEN)
                                        
                                        //Dont check parameter numbers in EMSCRIPTEN
 
                                        tmp = (PList*)(v2.GetComplexData()->GetObject().get());
                                        numargs = tmp->Length();
                                        //#endif
                                    }
                                else
                                    {
                                        cerr << "UNHANDLED ELSE CASE. NOT A LIST\n" ;
                                    }
                            }
                    }
 
                //#if !defined(PEBL_EMSCRIPTEN)
                if(numargs < min || numargs > max)
                    {
 
                        Variant message = Variant("In scope [") + mScope + Variant("]:") +
                            Variant("function [") +name+Variant("]:")+
                            Variant("Incorrect number of arguments..  Wanted between ")+
                            Variant((int)min) + Variant(" and ") +Variant((int) max) + Variant(" but got ") + Variant( (int)numargs);
 
                        PError::SignalFatalError(message);
                    }
                //#endif
                
 
 
                //Execute the functionpointer and push the results onto the stack.
                //Note that this will happen 'synchronously'; not through the eval loop.
                Push((v1.GetFunctionPointer())(v2));
            }
 
            break;
 
 
            /*********************************
                   HANDLED (Nothing needed directly)
             ********************************/
        case PEBL_FUNCTION:
            {
                // This controls the execution of a function. (not the
                // loading of a defined function).  A function node
                // has a function datanode on its left child (specifies the function name)
                // and an arglist (the head of a list of arguments) on its right child.  
                
                //Note that there is no direct link to the actual function code--it needs
                //to be accessed via a lookup map. Once that code is identified and the paramaters are handled 
                //here, the rest is managed via a PEBL_LAMBDAFUNCTION node above. 
 
 
                //We need to evaluate the arguments on the right, then pick up later.
 
                const PNode *node1 = node->GetRight();
                
                const OpNode * tail = new OpNode(PEBL_FUNCTION_TAIL1,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
 
 
                //get the function name now, and put it on the stack, to get back later.
                Variant funcname = dynamic_cast<DataNode*>(node->GetLeft())->GetValue();
            
               Push(funcname); //Put the function name on the stack.
            
            
                mNodeStack.push(tail);
                mNodeStack.push(node1);
            }
            break;
 
        case PEBL_FUNCTION_TAIL1:
            {
 
                //The arguments should have been evaluated, and are at the top of the stack.
                //Right below them is the function name.
 
                // The parameters for a function are in a list on the top of the stack.
                // A function should pull the list off the stack and push it onto
                // the stack of the new evaluator scope.
 
                //    cout << dynamic_cast<DataNode*>(node->GetLeft())->GetValue() << endl;
                //Get the name of the function.
 
                Variant args = Pop();
 
                Variant funcname = Pop(); //We would just put this back later, so only take a look.
 
 
                //Check for custom object method dispatch before looking up the function
                //If the first argument is a custom object with a property matching the function name,
                //redirect to that function name instead
                if(args.IsComplexData())
                {
                    PList *plist = dynamic_cast<PList*>(args.GetComplexData()->GetObject().get());
                    if(plist && plist->Length() > 0)
                    {
                        Variant first = plist->First();
 
                        if(first.IsComplexData())
                        {
                            if(first.GetComplexData()->IsCustomObject())
                            {
                                PCustomObject * pco = dynamic_cast<PCustomObject*>(first.GetComplexData()->GetObject().get());
 
                                if(OVE_SUCCESS == pco->ValidateProperty(funcname))
                                {
                                    funcname = Variant(pco->GetProperty(funcname).GetString().c_str(), P_DATA_FUNCTION);
                                }
                            }
                        }
                    }
                }
 
                //put the arguments back on top of the stack for the second tail, in
                //reverse order.
                Push(args);
 
 
                //The funcname is just used to update the scope variable.  Maybe we could do that now instead
                //of putting it on the stack?
                Push(funcname);
 
 
                //now, get the actual function code from the function map:
                const PNode * node2 = mFunctionMap.GetFunction(funcname);
 
            
#ifdef PEBL_DEBUG_PRINT
                cout << "Calling a function with argument list. " <<  endl;
#endif 
                
         
                //Now, node2 will either be a PEBL_LAMBDAFUNCTION or a PEBL_BUILTINFUNCTION
                //Lambda functions are just code blocks, but need to be executed in 
                //a new scope.  A built-in function is precompiled
                //and doesn't need its own new scope, so don't create one in that case.
                
 
                mNodeStack.push(node2);
               
 
 
                const OpNode * tail2 = new OpNode(PEBL_FUNCTION_TAIL2,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
                
                //schedule handling by the base function code. It will either 
                //handle the lamdafunction path or the builtinfunction path.
                mNodeStack.push(tail2);
 
            }
            break;
 
        case PEBL_FUNCTION_TAIL2:
            {
                //function name is on top; next are the arguments.
                Variant funcname = Pop();
                
                //right now, the top node should be the result of node->GetOp()...
                
                const OpNode * node2 = (OpNode*)(mNodeStack.top());
                mNodeStack.pop();
                
#ifdef PEBL_DEBUG_PRINT 
                cout << "In function_tail2  OpNode ["<< node2->GetOp() << "] of Type: " << node2->GetOpName() << "------------\n";
#endif
                
                
                switch(((OpNode*)node2)->GetOp())
                    {
 
 
 
                    case PEBL_LIBRARYFUNCTION:
                        {
 
                            mNodeStack.push(node2);
 
                        }
                        break;
 
 
                    case PEBL_LAMBDAFUNCTION:
                        {   //Need to create a new scope to allow for variable declaration
                            //within case statement
 
                            //We want to avoid creating multiple evaluators so that we can
                            //more easily async the evaluator loop.  So, create a stack
                            //to hold them.
 
                            mVariableMapStack.push(mLocalVariableMap);
                            //VariableMap & tmpmap = mLocalVariableMap;
 
 
                            mScopeStack.push(mScope);
 
 
                            mScope = funcname.GetFunctionName();
 
                            //Push the call site onto the call stack for error reporting
                            gCallStack.Push(node);
 
                            //This cleans up the return arguments of the lambda function.
                            const OpNode * tail = new OpNode( PEBL_FUNCTION_TAIL_LIBFUNCTION,NULL,NULL,
                                                              node->GetFilename(), node->GetLineNumber());
 
                            mNodeStack.push(tail);
 
                            //Add this last so it gets executed first
                            mNodeStack.push(node2);
 
                        }
                        break;
 
                  
 
                    default:
                        PError::SignalFatalError("Unknown Function Type in PEBL_FUNCTION_TAIL2");
                        break;
                    }
                
            }
 
            break;
 
        case PEBL_FUNCTION_TAIL_LIBFUNCTION:
            {
                //Pop the call site from the call stack for error reporting
                if(gCallStack.Size() == 0) {
                    PError::SignalFatalError("gCallStack is empty in PEBL_FUNCTION_TAIL_LIBFUNCTION");
                }
                gCallStack.Pop();
 
                //Go to the previous context/scope label and variables.
                if(mScopeStack.size() == 0) {
                    PError::SignalFatalError("mScopeStack is empty in PEBL_FUNCTION_TAIL_LIBFUNCTION");
                }
 
                mScope = mScopeStack.top();
                mScopeStack.pop();
 
                if(mVariableMapStack.size() == 0) {
                    PError::SignalFatalError("mVariableMapStack is empty in PEBL_FUNCTION_TAIL_LIBFUNCTION");
                }
 
                mLocalVariableMap = mVariableMapStack.top();
                mVariableMapStack.pop();
 
            }
            break;
            
 
            /*****************************************************************/
        case PEBL_WHILE:
            {
 
 
                //we might have gotten here from an iteration of while
                //that contained a break command. Check this
                if(GetStackDepth()>0)
                    {
                        Variant results = Peek();
                        if(results.GetDataType() == P_DATA_STACK_SIGNAL &&
                           results == Variant(STACK_BREAK))
                            {
                                Pop();
                                Push(Variant(1)); //Put a dummy variant on the stack so the 
                                //stop signal does not get propogated.
                                break;
                            }
                    }
 
 
                // The left child node is an expression to test
                // The right node is a code block.
                // Test the left node, then evaluate the right node if true, 
                //then re-program a while node to repeat until not successful.
 
 
 
 
                const PNode * node1 = node->GetLeft();
 
                const OpNode * tail = new OpNode( PEBL_WHILE_TAIL,NULL,NULL,
                                                  node->GetFilename(), node->GetLineNumber());
                
 
                mNodeStack.push(node);  //Push the while node back on the stack...we need this later.
                mNodeStack.push(tail);  //the while_tail which checks the value...
                mNodeStack.push(node1); //first evaluate the left node value.
                    
            }
            break;
            
            case PEBL_WHILE_TAIL:
                {
                    
                    //Get the result of the evaluation
                    Variant v1 = Pop();
            
                    //If the evaluation is false, break out of loop/switch
                    if(v1) 
                        {
 
                            //This should handle a 'break'
                            if(v1.GetDataType() == P_DATA_STACK_SIGNAL &&
                               v1 == Variant(STACK_BREAK))
                                {
                                    Variant results = Pop();
                                    Push(results);
                                    break;
                                }
 
                            //Ok, the test was true, so Evaluate the right node
                            //of the while(), which is on the top of the stack right now.
 
                            OpNode * whilenode = (OpNode*)(mNodeStack.top());
                            OpNode * node2 = (OpNode*)(whilenode->GetRight());
                            
                            const OpNode * whiletail2 = new OpNode( PEBL_WHILE_TAIL2,NULL,NULL,
                                                                    node->GetFilename(), node->GetLineNumber());
 
                            //Execute the code, then it will re-execute the while node
                            //which is still on top of the stack.
                            mNodeStack.push(whiletail2);
                            mNodeStack.push(node2);
                            
                            break;
                    
                            
                        }
                    else                    
                        {       
                            //Remove the pending while node from the stack.
                            mNodeStack.pop();
                            Push(Variant(1));  //Add a value to the stack that will get popped at the next statement.
                            break;
                        }
 
                }
                break;
            
 
        case PEBL_WHILE_TAIL2:
            {
                //At the end of executing the code block for a while loop, the result
                //is on top of the stack.  Remove it now.
 
                Variant value = Pop();
 
                if(value.IsStackSignal() && value.GetSignal() == STACK_BREAK)
                    {
                        //put the stack break value back on the stack to 
                        //signal the while head.
                        Push(value); 
 
                    }
            }
            break;
 
            /*****************************************************************/
        case PEBL_LOOP:
            {
                // The PEBL_LOOP node has two children: the left child is a variable/datum pair,
                // and the right child is a code block that should be evaluated once for each
                // element of the datum, with the variable being set to that element for
                // each iteration.
                
                //Get the variabledatum pair.  Evaluating this will create a list and 
                //put it on top of the stack.
                const PNode * node1 = node->GetLeft();  //A variable-datum node.
                const PNode * codeblock = node->GetRight();
                const OpNode * tail = new OpNode(PEBL_LOOP_TAIL1,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
             
 
                const OpNode * tail2 = new OpNode(PEBL_LOOP_TAIL2,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
 
                
                mNodeStack.push(codeblock);  //Put the codeblock on the stack for access later.
                mNodeStack.push(tail2);      //This will re-program the loop when the codeblock is done.
                mNodeStack.push(codeblock);  //put this on the stack for execution after variables are bound
                mNodeStack.push(tail);       //execute the tail after the node1 is executed.
                mNodeStack.push(node1);      //first, execute the variable-datum node to put the list 
                //                             and the variable on the stack.
 
                Push(Variant(1)); //now, add index 0  to the top of the stack.
            }
            break;
 
 
        case PEBL_LOOP_TAIL1:
            {
                //Now, the next two items on the stack should be the datum and the variable.
 
                Variant list = Pop();
                Variant varname = Pop();
                const long unsigned int index = (const long unsigned int)Pop();
 
 
                PError::AssertType(varname, PEAT_VARIABLE,"Error: iterator of loop not a variable");
 
                // Handle integer to list conversion (like Evaluator.cpp does)
                PList * tmp;
                if(list.IsInteger())
                {
                    // Convert integer to list [1, 2, 3, ..., n]
                    tmp = new PList();
                    for(int count=1; count <= list.GetInteger(); count++)
                    {
                        tmp->PushBack(count);
                    }
                    // Update the list on the stack to be this new list
                    counted_ptr<PEBLObjectBase> tmpptr = counted_ptr<PEBLObjectBase>(tmp);
                    PComplexData * pcd = new PComplexData(tmpptr);
                    list = Variant(pcd);
                }
                else
                {
                    PError::AssertType(list, PEAT_LIST,"Second argument of loop(<iterator>, <list>) must be a list.");
                    tmp = (PList*)(list.GetComplexData()->GetObject().get());
                }
                
                if(tmp->Length()<index)
                    {
                        //Looping is over!
                        mNodeStack.pop(); //Get rid of the codeblock node, which should come next
                        mNodeStack.pop();  //Get rid of the pre-programmed tail2 node
                        mNodeStack.pop();  //Get rid of copy 2 of the codeblock.
                        Push(1);         //Handle the stack.  We may need to adjust this for break.
                    } else {
 
 
 
                    const Variant p = tmp->Nth(index); 
                    //Set the variable to the current list element, and increment p
 
                    if(varname.IsLocalVariable())
                        {
                            mLocalVariableMap.AddVariable(varname, p);
                        }
                    else if (varname.IsGlobalVariable())
                        {
                            gGlobalVariableMap.AddVariable(varname,p);
                        }
                    
                    
                    //Now, the codeblock will execute automatically.  But need to reprogram the loop1
                    //to occur after that.
 
                    
                    //Add the new index.
 
                    Push(index+1);
 
                    //Put the varname back on the stack, for the next time through
                    Push(varname);
                    
                    //Put the list back on the stack
                    Push(list);
                }
            }
            break;
 
 
        case PEBL_LOOP_TAIL2:
            {
                //the code block has just been executed. We need to look at the results to
                //handle any breaks.
                //Normally, the top of the stack will be the next index to handle
 
                Variant results = Pop();
 
                if(results.GetDataType() == P_DATA_STACK_SIGNAL &&
                   results == Variant(STACK_BREAK))
                    {
                        Pop();  //pop the list
                        Pop();  //pop the variable name
                        Pop();  //pop the next index
                        Push(Variant(0));  //Push on a dummy return value
 
                        mNodeStack.pop(); //pop the codeblock (the original copy from PEBL_LOOP setup)
                    } else {
                
 
                    //reprogram another loop.
                    //once again, the variable and the list need to be on top of the stack.
 
                    //The codeblock is currently at the top of the stack.
                    const PNode * codeblock = mNodeStack.top();
 
                    //Program the next tail1/tail2 combo, with the codeblock sandwiched between:
                    const OpNode * tail1 = new OpNode(PEBL_LOOP_TAIL1,NULL,NULL,
                                                     node->GetFilename(), node->GetLineNumber());
                    
                    
                    const OpNode * tail2 = new OpNode(PEBL_LOOP_TAIL2,NULL,NULL,
                                                      node->GetFilename(), node->GetLineNumber());
 
 
                    mNodeStack.push(tail2);      //This will re-execute the loop when the codeblock is done.
                    mNodeStack.push(codeblock);  //(put this on the stack for later)
                    mNodeStack.push(tail1);       
 
                    
                    //Right now, the index is on the top of the data stack, so we don't need to push it
                    //back on.
                }                        
 
            }
            break;
 
 
        case PEBL_VARIABLEDATUM:
            {
                //The VARIABLDATUM node is used in the loop function. The variable is the 
                //left child, a list of data in the form of an expression is the right. 
 
                //This node is executed once at the beginning
                //of the loop; it pushes the variable name and the evaluated list onto the stack.
                //PEBL_LOOP evaluation then gets them from the stack and iterates through the list,
                //setting the variable to each element of the data.
                
                //Get the variable:
                const PNode * node1 = node->GetLeft();
 
                //Push the variable name directly on the stack (without evaluating it.)
                Push(((DataNode*)node1)->GetValue());
                
                //Get the datum:
                const PNode * node2 = node->GetRight();
                
                //Evaluate the datum--it gets put on the stack.
                mNodeStack.push(node2);
            }
            break;
 
 
            /**********************************
                   HANDLED: (no tail needed)
             *******************************/
        case PEBL_ARGLIST:
            {
                // This behaves almost exactly like a listhead. It will end up with a variant
                // on the top of the stack that is a list containing all of the arguments
                // for a function.
 
 
                //Create the stack signal variant and push it onto the stack.
                Variant v1 = Variant(STACK_LIST_HEAD);
                Push(v1);
                
                //Get the top node of the list 
                const PNode * node1 = node->GetLeft();
 
                if(node1)
                    { 
                        //If it exists, evaluate it.
                        mNodeStack.push(node1);
                    }
 
                //if node1 doesn't exist, it is a null argument list--do nothing more.
                        
 
            }
            break;
 
            /***************************
             //Handled, no tail needed
             ***************************/
        case PEBL_LISTHEAD:
            {
                //When we get a list head, we need to evaluate each expression in the list,
                //pushing them onto the stack. When we get to the end of the list, we just need
                //to pop items, adding them to the list,  until we get back up to the top.
                //To do this efficiently and avoid recreating lists iteratively, the bottom
                //item does this in a while loop.  to signal the end of the while loop, the
                //PEBL_LISTHEAD must put a dummy item on the stack so the bottom item
                //knows when the front of the list has been reached.  This is a variant of type STACK_LIST_HEAD
                
                //Create the stack signal variant and push it onto the stack.
                Variant v1 = Variant(STACK_LIST_HEAD);
                Push(v1);
            
                //Get the top node of the list and Evaluate it.
                const PNode * node1 = node->GetLeft();
                if(node1)
                    {
 
                        mNodeStack.push(node1);
 
                    }
                else
                    {
                        //If node1 is NULL, we have an empty list.
                        //Get rid of the STACK_LIST_HEAD on the top of the stack
                        Pop();
 
                        //Make an empty list and push it onto the stack.
                        counted_ptr<PEBLObjectBase> tmpList = counted_ptr<PEBLObjectBase>(new PList());
 
                        PComplexData  pcd = PComplexData(tmpList);
                        Variant v2 = Variant(&pcd);
                        Push(v2);
                    }
            }
            break;
 
 
            /*****************************************************************/
        case PEBL_LISTITEM:
            {
                // for a list item, the list is represented as a parsed tree with the 
                // left node being the data and the right node being another listitem node.
                // This should create the list piece by piece recursively.
                
                // To do this, Evaluate() each item so it gets executed and the value
                // gets pushed onto the stack.  When you come to the end of the list, 
                // pop the items off the list iteratively until you get back where you came from.
                
                //The data: Get it out of the tree and evaluate it, so it gets
                //push onto the stack.
 
 
                const PNode * node1 = node->GetLeft();
                const PNode * node2 = node->GetRight();
                
                if(node2)
                    {
                        mNodeStack.push(node2);  //do the right node after the left node.
                    }
                else
                    {//we are at the end of the list, so do the cleanup stuff.
                        const OpNode * tail = new OpNode(PEBL_LISTITEM_TAIL,NULL,NULL,
                                                         node->GetFilename(), node->GetLineNumber());
                        mNodeStack.push(tail);   
                    }
 
                
                mNodeStack.push(node1);  //do the left node first.
 
            }
            break;
 
            case PEBL_LISTITEM_TAIL:
                {
  
                    //We are at the end of the list.  
                    //If node2 is NULL, then we are at the end of the list.
                    //everything has been pushed to the stack.  Just get everything
                    //off the stack, make a list out of it,  and put it back on the stack.
 
 
                    //Must make a new list, and create a variant out of it.
                    PList * tmpList = new PList();
                    PList order;
                    int ord = 0;
                    //Now, pop off items from the list until you get to a
                    //P_DATA_STACK_SIGNAL, then if it i
                    Variant v1 = Pop();
                    
                    //we need to create the list from the items on the stack. 
                    //But the top of the stack is the end of the list.
 
                    while(v1.GetDataType() != P_DATA_STACK_SIGNAL)
                        {
                            
                            //Add the item to the list.
                            tmpList->PushBack(v1);
                            order.PushBack(ord--);
                            //Pop and repeat.
                            v1 = Pop();
                        }
 
                    
                        //add tmplist (in reverse order) to the stack as the argument list.
                        std::reverse(tmpList->Begin(),tmpList->End());
                        counted_ptr<PEBLObjectBase> pl = counted_ptr<PEBLObjectBase>(tmpList);
                        PComplexData  pcd =  PComplexData(pl);
                        Variant v2 = Variant(&pcd);
                        Push(v2);
                }
        
                break;
 
            /************************ HANDLED *****************************************/
 case PEBL_LT:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                const PNode * node2 = node->GetRight();
                const OpNode * tail = new OpNode(PEBL_LT_TAIL,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
 
                mNodeStack.push(tail);
                mNodeStack.push(node2);
                mNodeStack.push(node1);
                
            }
            break;
 
        case PEBL_LT_TAIL:
            {
                
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
                
                Push(v1 < v2);
            }
            break;
                        
            /*********************************HANDLED   ********************************/
        case PEBL_GT:
            {
 
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                const PNode * node2 = node->GetRight();
                const OpNode * tail = new OpNode(PEBL_GT_TAIL,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
                
                mNodeStack.push(tail);
                mNodeStack.push(node2);
                mNodeStack.push(node1);
            }
            break;
 
        case PEBL_GT_TAIL:
            {
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
                Push(v1 > v2);
            }
            break;
            
            /**********************************HANDLED*******************************/
        case PEBL_GE:
            {
                //Execute left and right nodes, which puts results on stack
 
                const PNode * node1 = node->GetLeft();
                const PNode * node2 = node->GetRight();
                const OpNode * tail = new OpNode(PEBL_GE_TAIL,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
                
 
                mNodeStack.push(tail);
                mNodeStack.push(node2);
                mNodeStack.push(node1);
 
            }
            break;
 
       case PEBL_GE_TAIL:
           {
               
 
               //Get the top two items from the stack.  The right will be on top
               Variant v2 = Pop();
               Variant v1 = Pop();
               Push(v1 >= v2);
           }
           break;
 
            /*******************************HANDLED**********************************/
        case PEBL_LE:
            {
                
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                const PNode * node2 = node->GetRight();
                
                const OpNode * tail = new OpNode(PEBL_LE_TAIL,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
                
                mNodeStack.push(tail);
                mNodeStack.push(node2);
                mNodeStack.push(node1);
            }
            break;
        case PEBL_LE_TAIL:
            {
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
                
                Push(v1 <= v2);
            }
            break;
 
 
            /********************************HANDLED*********************************/
        case PEBL_EQ:
            {
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                const PNode * node2 = node->GetRight();
 
                
                const OpNode * tail = new OpNode(PEBL_EQ_TAIL,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
                
                mNodeStack.push(tail);
                mNodeStack.push(node2);
                mNodeStack.push(node1);
            }
            break;
 
        case PEBL_EQ_TAIL:
            {
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
                Push(v1 == v2);
            }
            break;
 
            /*******************************  HANDLED  **********************************/
        case PEBL_NE:
            {           
                //Execute left and right nodes, which puts results on stack
                const PNode * node1 = node->GetLeft();
                const PNode * node2 = node->GetRight();
       
                const OpNode * tail = new OpNode(PEBL_NE_TAIL,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
                
                mNodeStack.push(tail);
                mNodeStack.push(node2);
                mNodeStack.push(node1);
            }
            break;
 
        case PEBL_NE_TAIL:
            {
                //Get the top two items from the stack.  The right will be on top
                Variant v2 = Pop();
                Variant v1 = Pop();
                
                Push(v1 != v2);
            }
            break;
          
 
            /*****************************************************************/
        case PEBL_STATEMENTS:
            {
                //This is a node that connects two statements. 
 
                // a STATEMENTS node connects a PEBL_STATEMENTS node on the left 
                //with an arbitrary OpNode on the right.
                //Note that if you have a chain of PEBL_STATEMENTS nodes,
                //it works from the bottom up: the right node at the top
                //of the chain is really the last node that will be executed.
 
 
 
#ifdef PEBL_DEBUG_PRINT
                cout << "Checking a PEBL_STATEMENTS: " << GetStackDepth() << endl;
#endif
                
                //If the top of the stack is a STACK_BREAK, we should do nothing.
                if(GetStackDepth()>0)
                    {
             
                        Variant v1 = Peek();
 
 
                        if(v1.GetDataType() == P_DATA_STACK_SIGNAL &&
                           v1 == Variant(STACK_BREAK))
                            {
                                //If this is a stack signal, and if 
                                //it is a break, we should just back out
                                //stackbreak is already on top of the stack.  Add a dummy to be taken off.
                                Push(Variant(0));
                                break;
                            }
                    }
 
 
 
                const OpNode * tail = new OpNode(PEBL_STATEMENTS_TAIL1,NULL,NULL,
                                                 node->GetFilename(), node->GetLineNumber());
 
                //We need to execute the left node, and then process the right node, so 
                //add them to the stack in inverse order.
 
                mNodeStack.push(node->GetRight());
                mNodeStack.push(tail);
                mNodeStack.push(node->GetLeft());
 
 
 
            }
            break;
 
            case PEBL_STATEMENTS_TAIL1:
                {
 
                    //The results of the first statement are on top of the stack.  Get them off:
                    Variant v1 = Pop();
 
 
                    if(v1.GetDataType() == P_DATA_STACK_SIGNAL &&
                       v1 == Variant(STACK_BREAK))
                        {
                                //If this is a stack signal, and if
                                //it is a break, we should just back out
                                //But first, we need to pop the Right node from the node stack
                                //to prevent it from executing
                            mNodeStack.pop();  //Remove the right statement from the node stack
                            Push(Variant(STACK_BREAK));
                            break;
                        }
 
                }
                break;
 
 
 
 
            /***************************ITERATIVE--NOTHING IS NEEDED HERE
             **************************************/
        case PEBL_BREAK:
            {
 
                //This exits out of the current loop, while, or function context.
                //it works by adding a STACK_BREAK stacksignalevent onto the top of the stack.
                //all relevant loops look for this type of event and 
                //cleanly abort when that times comes.
                Variant v1 = Variant(STACK_BREAK);
                Push(v1);
 
#ifdef PEBL_DEBUG_PRINT
                cout << "PEBL_BREAK: pushing break onto stack.\n";
#endif
 
            }
            break;
 
            /******************************
               Hnadled, no tail needed?
        ***********************************/
        case PEBL_RETURN:
            {
                //The return keyword is used ONLY at the very end of a
                //function. Its left node is the value to return; its right
                //node should be NULL.  So evaluate the left node; then what's on
                //the stack will be the return value.
 
                //Push(Variant(STACK_RETURN_DUMMY));
 
                const PNode * node1 = node->GetLeft();
                mNodeStack.push(node1);
 
            }
            break;
 
        default:
            //Signal an error here.
            return false;
            break;
 
        }
    return true;
}      

References VariableMap::AddVariable(), PError::AssertType(), PList::Begin(), count, PList::End(), Evaluate1(), PList::First(), gCallStack, counted_ptr< X >::get(), Variant::GetComplexData(), Variant::GetDataType(), PNode::GetFilename(), FunctionMap::GetFunction(), PNode::GetFunctionName(), Variant::GetFunctionName(), Variant::GetFunctionPointer(), Variant::GetInteger(), OpNode::GetLeft(), PNode::GetLineNumber(), PComplexData::GetObject(), OpNode::GetOp(), OpNode::GetOpName(), PCustomObject::GetProperty(), OpNode::GetRight(), Variant::GetSignal(), GetStackDepth(), Variant::GetString(), PNode::GetType(), Variant::GetVariableBaseName(), Variant::GetVariableName(), Variant::GetVariablePropertyName(), gEvalNode, gGlobalVariableMap, Variant::IsComplexData(), PComplexData::IsCustomObject(), Variant::IsGlobalVariable(), Variant::IsInteger(), Variant::IsLocalVariable(), Variant::IsStackSignal(), PList::Length(), mFunctionMap, PList::Nth(), NULL, OVE_SUCCESS, P_DATA_FUNCTION, P_DATA_STACK_SIGNAL, pDouble, PEAT_LIST, PEAT_VARIABLE, PEBL_OP_NODE, Peek(), pInt, Pop(), PCallStack::Pop(), PCallStack::Push(), Push(), PList::PushBack(), VariableMap::RetrieveValue(), PEBLUtility::SetPropertyChain(), PError::SignalFatalError(), PCallStack::Size(), STACK_BREAK, STACK_LIST_HEAD, and PCustomObject::ValidateProperty().

Evaluate1() [4/4]

bool Evaluator::Evaluate1

(

const PNode *

node

)

Definition at line 150 of file Evaluator-es.cpp.

{
 
#ifdef PEBL_EMSCRIPTEN
    
    if(node == NULL) PError::ExitQuietly("Trying to evaluate null node\n");
#else
    
    if(node == NULL) PError::SignalFatalError("Trying to evaluate null node\n");
#endif
    //Set up the globally-accessible structure to allow
    //better error reporting.  Only change it if the new node's
    //line number is greater than -1; if not, it is a PEBL-generated
    //node that won't give very good information.
    if(node->GetLineNumber() > -1)
        gEvalNode = node;
 
 
 
#ifdef PEBL_DEBUG_PRINT 
    cout << "Line: " << node->GetLineNumber() << endl;
    cout << "PDP::Type: " << node->GetType() << endl;
#endif
 
    if(node->GetType() ==  PEBL_OP_NODE)
        {
            return Evaluate1((OpNode*)node);
        }
    else if (node->GetType() ==  PEBL_DATA_NODE)
        {
            return Evaluate1((DataNode*)node);
        }
    else
        {
#ifdef PEBL_DEBUG_PRINT 
            cout << "ERROR IN GENERIC EVALUATOR::EVALUATE" << endl;
#endif
            return false;
        }
 
    return true;
}

References Evaluate1(), PError::ExitQuietly(), PNode::GetLineNumber(), PNode::GetType(), gEvalNode, NULL, PEBL_DATA_NODE, PEBL_OP_NODE, and PError::SignalFatalError().

GetEventLoop() [1/2]

PEventLoop * Evaluator::GetEventLoop ( )

inline

Definition at line 90 of file Evaluator-es.h.

{return mEventLoop;};

References mEventLoop.

GetEventLoop() [2/2]

PEventLoop * Evaluator::GetEventLoop ( )

inline

Definition at line 80 of file Evaluator.h.

{return mEventLoop;};

References mEventLoop.

GetNodeStackDepth()

int Evaluator::GetNodeStackDepth ( )

inline

Definition at line 86 of file Evaluator-es.h.

{return mNodeStack.size();};

Referenced by PEBLEnvironment::CallFunction(), and PEBLInterpret().

GetStackDepth() [1/2]

int Evaluator::GetStackDepth ( )

inline

Definition at line 87 of file Evaluator-es.h.

{return mStack.size();};

Referenced by CallFunction(), PEBLEnvironment::CallFunction(), Evaluate(), Evaluate1(), PEBLInterpret(), Pop(), Push(), and Push().

GetStackDepth() [2/2]

unsigned long int Evaluator::GetStackDepth ( )

inline

Definition at line 78 of file Evaluator.h.

{return mStack.size();};

IsVariableName() [1/2]

bool Evaluator::IsVariableName

(

Variant

v

)

Definition at line 2169 of file Evaluator-es.cpp.

{
    return gGlobalVariableMap.Exists(v) || mLocalVariableMap.Exists(v);
}

References VariableMap::Exists(), and gGlobalVariableMap.

Referenced by PEBLEnvironment::VariableExists().

IsVariableName() [2/2]

bool Evaluator::IsVariableName

(

Variant

v

)

NodeStackPush()

void Evaluator::NodeStackPush

(

const PNode *

node

)

Definition at line 2176 of file Evaluator-es.cpp.

{
    mNodeStack.push(node);
}

Referenced by PEBLEnvironment::CallFunction(), and PEventLoop::Loop1().

Peek() [1/2]

Variant Evaluator::Peek

(

)

Definition at line 2154 of file Evaluator-es.cpp.

{
#ifdef PEBL_DEBUG_PRINT
    cout << "Peeking at top of stack: "<< mStack.size() << endl;
#endif 
    if(mStack.size() <=0 )
        {
            PError::SignalFatalError("Error: Tried to Peek at an empty stack.");
        }
   
    Variant v = mStack.top();
    return v;
}

References PError::SignalFatalError().

Referenced by CallFunction(), Evaluate(), and Evaluate1().

Peek() [2/2]

const Variant & Evaluator::Peek

(

)

const

Definition at line 1525 of file Evaluator.cpp.

{
#ifdef PEBL_DEBUG_PRINT
    cout << "Peeking at top of stack: "<< mStack.size() << endl;
#endif
    if(mStack.size() <=0 )
        {
            PError::SignalFatalError("Error: Tried to Peek at an empty stack.");
        }
 
    return mStack.top();
}

References PError::SignalFatalError().

Pop() [1/2]

Variant Evaluator::Pop

(

)

Definition at line 2134 of file Evaluator-es.cpp.

{
#ifdef PEBL_DEBUG_PRINT
    cout << "Popping Stack: depth: "<< mStack.size() << "-->" << GetStackDepth() - 1;
#endif 
    if(mStack.size() <=0 )
        {
            PError::SignalFatalError("Error: Tried to Pop an empty stack.");
        }
   
    Variant v = mStack.top();
    mStack.pop();
#ifdef PEBL_DEBUG_PRINT
    if(mStack.size())cout << "  [" << mStack.top() << "] is on top.\n";
    else cout << endl;
#endif 
    return v;
}

References GetStackDepth(), and PError::SignalFatalError().

Referenced by CallFunction(), PEBLEnvironment::CallFunction(), Evaluate(), Evaluate1(), and PEBLInterpret().

Pop() [2/2]

Variant Evaluator::Pop

(

)

Push() [1/2]

void Evaluator::Push

(

const Variant &

v

)

Definition at line 1485 of file Evaluator.cpp.

{
 
#ifdef PEBL_DEBUG_PRINT
    cout << "Pushing Stack: depth: "<< mStack.size() << "-->" << GetStackDepth() + 1;
#endif
 
    if (mStack.size() > mStackMax)
        {
            PError::SignalFatalError("Maximum Stack Depth Exceeded.  Runaway Function?");
        }
    mStack.push(v);
#ifdef PEBL_DEBUG_PRINT
    if(mStack.size())cout << "  [" << mStack.top() << "] is on top.\n";
    else cout << endl;
#endif
 
}

References GetStackDepth(), and PError::SignalFatalError().

Push() [2/2]

void Evaluator::Push

(

Variant

v

)

Definition at line 2114 of file Evaluator-es.cpp.

{
 
#ifdef PEBL_DEBUG_PRINT
    cout << "Pushing Stack: depth: "<< mStack.size() << "-->" << GetStackDepth() + 1;
#endif 
 
    if (mStack.size() > mStackMax)
        {
            PError::SignalFatalError("Maximum Stack Depth Exceeded.  Runaway Function?");
        }
    mStack.push(v);
#ifdef PEBL_DEBUG_PRINT
    if(mStack.size())cout << "  [" << mStack.top() << "] is on top.\n";
    else cout << endl;
#endif 
 
}

References GetStackDepth(), and PError::SignalFatalError().

Referenced by CallFunction(), PEBLEnvironment::CallFunction(), Evaluate(), Evaluate(), Evaluate1(), Evaluate1(), and Evaluator().

Friends And Related Symbol Documentation

PEventLoop

friend class PEventLoop

friend

Definition at line 61 of file Evaluator-es.h.

Referenced by Evaluator(), and Evaluator().

Member Data Documentation

gCallStack

static PCallStack Evaluator::gCallStack

static

Definition at line 120 of file Evaluator-es.h.

Referenced by Evaluate1(), Evaluator(), and Evaluator().

gEvalNode

const PNode * Evaluator::gEvalNode = NULL

static

This is used for error detection. Every time gEvalNode is updated, this is set to gEvalNode. But, it is done for all evaluators. Thus, it always points to the last node processed, and error reporting routines can look for it and find out where it came from.

Definition at line 117 of file Evaluator-es.h.

Referenced by Evaluate(), Evaluate(), Evaluate(), Evaluate1(), Evaluate1(), Evaluate1(), Evaluator(), Evaluator(), and PError::SignalWarning().

gGlobalVariableMap

VariableMap Evaluator::gGlobalVariableMap

static

The static keyword defines a 'Global' variable map that can be accessed\all Evaluators. It needs to be initialized somewhere outside the class, however. This is done in the main program file.

Definition at line 104 of file Evaluator-es.h.

Referenced by CaptureSignal(), Evaluate(), Evaluate(), Evaluate1(), Evaluate1(), PlatformWindow::Initialize(), IsVariableName(), PEventLoop::Loop(), PEventLoop::Loop1(), main(), PEBLObjects::MakeTextBox(), PEBLObjects::MakeWindow(), PEBLInterpret(), PlatformEventQueue::Prime(), and PlatformWindow::Resize().

gPath

PEBLPath Evaluator::gPath

static

Definition at line 108 of file Evaluator-es.h.

Referenced by PEBLStream::AppendFile(), PEBLStream::CopyFile(), PEBLStream::FileReadList(), PEBLStream::FileReadTable(), PEBLStream::FileReadText(), PlatformImageBox::LoadImage(), PlatformAudioOut::LoadSoundFile(), main(), PEBLInterpret(), PlatformAudioOut::PlatformAudioOut(), PlatformFont::PlatformFont(), PlatformFont::PlatformFont(), PlatformFont::SetFontSize(), and PlatformFont::SetFontStyle().

mEventLoop

PEventLoop Evaluator::mEventLoop =NULL

static

Definition at line 106 of file Evaluator-es.h.

Referenced by PEBLEnvironment::ClearEventLoop(), Evaluator(), Evaluator(), GetEventLoop(), PEBLEnvironment::GetInput0(), PEBLEnvironment::PlayMovie(), PEBLEnvironment::RegisterEvent(), PEBLEnvironment::StartEventLoop(), PEBLEnvironment::Wait(), PEBLEnvironment::WaitForAllKeysUp(), PEBLEnvironment::WaitForAnyKeyDown(), PEBLEnvironment::WaitForAnyKeyDownWithTimeout(), PEBLEnvironment::WaitForAnyKeyPress(), PEBLEnvironment::WaitForAnyKeyPressWithTimeout(), PEBLEnvironment::WaitForKeyDown(), PEBLEnvironment::WaitForKeyListDown(), PEBLEnvironment::WaitForKeyPress(), PEBLEnvironment::WaitForKeyRelease(), PEBLEnvironment::WaitForKeyUp(), PEBLEnvironment::WaitForListKeyPress(), PEBLEnvironment::WaitForListKeyPressWithTimeout(), PEBLEnvironment::WaitForMouseButton(), and PEBLEnvironment::WaitForMouseButtonWithTimeout().

mFunctionMap

FunctionMap Evaluator::mFunctionMap

static

Initiate some static member data.

This holds a pointer to a FunctionMap, which is loaded from the initial PNode tree by the loader. It is static and public, which means that all Evaluators have access to the same one, and anything else can access it with Evaluator::mFunctionMap

Definition at line 99 of file Evaluator-es.h.

Referenced by CallFunction(), PEBLEnvironment::CallFunction(), CaptureSignal(), Evaluate1(), Loader::GetMainPEBLFunction(), Loader::LoadLibraryFunctions(), Loader::LoadUserFunctions(), and PEBLInterpret().

---

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

• Evaluator-es.h
• Evaluator.h
• PEBL.cpp
• PEBLValidator.cpp
• VCGMaker.cpp
• Evaluator-es.cpp
• Evaluator.cpp
• AudioOutTest.cpp
• VariableMapTest.cpp
• VariantTest.cpp