/*****************************************************************************
*   "Irit" - the 3d polygonal solid modeller.				     *
*									     *
* Written by:  Gershon Elber				Ver 0.2, Mar. 1990   *
******************************************************************************
*   Module to evaluate the binary tree generated by the InptPrsr module.     *
*   All the objects are handled the same but the numerical one, which is     *
* moved as a RealType and not as an object (only internally within this	     *
* module) as it is frequently used and consumes much less memory this way.   *
*   Note this module is par of InptPrsr module and was splited only because  *
* of text file sizes problems...					     *
*****************************************************************************/

#ifdef __MSDOS__
#include <alloc.h>
#include <dir.h>
#endif /* __MSDOS__ */

#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <string.h>
#include "program.h"
#include "allocate.h"
#include "attribut.h"
#include "convex.h"
#include "ctrl-brk.h"
#include "dataprsr.h"
#include "dosintr.h"
#include "freeform.h"
#include "geomat3d.h"
#include "geomvals.h"
#include "graphgen.h"
#include "inptprsg.h"
#include "inptprsl.h"
#include "matherr.h"
#include "objects.h"
#include "overload.h"
#include "primitiv.h"
#include "viewobj.h"
#include "windows.h"

InptPrsrEvalErrType IPGlblEvalError = IPE_NO_ERR;/* Global used by EvalTree. */
extern char IPGlblCharData[LINE_LEN_LONG];    /* Used for both parse & eval. */

/*   I prefer to put the declarations of static functions just before the    */
/* function themselves, but the tables below needs them so...		     */
static int FetchParameters(ParseTree *Root, int NumParams, int Level,
							 ParseTree *Params[]);
static void PrintHelp(char *HelpHeader);
static void IfCondition(ParseTree *Left, ParseTree *Cond, ParseTree *Right,
							  ParseTree *PBody);
static void ForLoop(ParseTree *PStart, ParseTree *PInc, ParseTree *PEnd,
							ParseTree *PBody);
static ObjectStruct *GenObjectList(ParseTree *PObjParams);
static ObjectStruct *CtlPtFromParams(ParseTree *PObjParams);
static int CountNumExpressions(ParseTree *Root);
static ParseTree *FetchExpression(ParseTree *Root, int i, int n);
static int RetrieveMathError(void);
static int CountNumParameters(ParseTree *Root);
static ParseTree *FetchParameter(ParseTree *Root, int i, int n);
static int FuncParamMismatch(ParseTree *Root);
static void LocalPrintTree(ParseTree *Root, int Level, char *Str);
static void RebindVariable(ParseTree *Root, ObjectStruct *PObj);
static int RetrieveMathError(void);

/* Although the type of parameters is specified (for InptPrsrTypeCheck rtn)  */
/* All the parameters to the following dispatched functions are passed by    */
/* address. There is a problem in TurboC (ANSI C?) that all the real types   */
/* are passed as double, even if the are float. As RealType may be float,    */
/* the problems is hidden by passing parameters by address...		     */

NumFuncTableType NumFuncTable[] = {
    { "ACOS",	ARCCOS,	acos,		1,	{ NUMERIC_EXPR } },
    { "ASIN",	ARCSIN,	asin,		1,	{ NUMERIC_EXPR } },
    { "ATAN2",	ARCTAN2, atan2,		2,	{ NUMERIC_EXPR, NUMERIC_EXPR } },
    { "ATAN",	ARCTAN,	atan,		1,	{ NUMERIC_EXPR } },
    { "COS",	COS,	cos,		1,	{ NUMERIC_EXPR } },
    { "EXP",	EXP,	exp,		1,	{ NUMERIC_EXPR } },
    { "ABS",	FABS,	fabs,		1,	{ NUMERIC_EXPR } },
    { "LN",	LN,	log,		1,	{ NUMERIC_EXPR } },
    { "LOG",	LOG,	log10,		1,	{ NUMERIC_EXPR } },
    { "SIN",	SIN,	sin,		1,	{ NUMERIC_EXPR } },
    { "SQRT",	SQRT,	sqrt,		1,	{ NUMERIC_EXPR } },
    { "TAN",	TAN,	tan,		1,	{ NUMERIC_EXPR } },
    { "CPOLY",	CPOLY,	PolyCountPolys,	1,	{ POLY_EXPR } },
    { "AREA",	AREA,	PolyObjectArea,	1,	{ POLY_EXPR } },
    { "VOLUME",	VOLUME,	PolyObjectVolume, 1,	{ POLY_EXPR } },
    { "TIME",	TIME,	DosGetTime,	1,	{ NUMERIC_EXPR } },
};
int NumFuncTableSize = sizeof(NumFuncTable) / sizeof(NumFuncTableType);

ObjFuncTableType ObjFuncTable[] = {
    { "VECTOR",	  VECTOR,	GenVecObject,		3,	{ NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "CTLPT",	  CTLPT,	CtlPtFromParams,	ANY_PARAM_NUM, { 0 } },
    { "ROTX",	  ROTX,		GenMatObjectRotX,	1,	{ NUMERIC_EXPR } },
    { "ROTY",	  ROTY,		GenMatObjectRotY,	1,	{ NUMERIC_EXPR } },
    { "ROTZ",	  ROTZ,		GenMatObjectRotZ,	1,	{ NUMERIC_EXPR } },
    { "TRANS",	  TRANS,	GenMatObjectTrans,	1,	{ VECTOR_EXPR } },
    { "SCALE",	  SCALE,	GenMatObjectScale,	1,	{ VECTOR_EXPR } },
    { "BOX",	  BOX,		GenBOXObject,		4,	{ VECTOR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "GBOX",	  GBOX,		GenGBOXObject,		4,	{ VECTOR_EXPR, VECTOR_EXPR, VECTOR_EXPR, VECTOR_EXPR } },
    { "CONE",	  CONE,		GenCONEObject,		3,	{ VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR } },
    { "CON2",	  CONE2,	GenCONE2Object,		4,	{ VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "CYLIN",	  CYLIN,	GenCYLINObject,		3,	{ VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR } },
    { "SPHERE",	  SPHERE,	GenSPHEREObject,	2,	{ VECTOR_EXPR, NUMERIC_EXPR } },
    { "TORUS",	  TORUS,	GenTORUSObject,		4,	{ VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "CIRCPOLY", CIRCPOLY,	GenPLANEObject,		3,	{ VECTOR_EXPR, VECTOR_EXPR, NUMERIC_EXPR } },
    { "POLY",	  POLY,		GenPOLYGONObject,	1,	{ OLST_EXPR } },
    { "CROSSEC",  CROSSEC,	GenCROSSECObject,	1,	{ POLY_CURVE_EXPR } },
    { "SURFREV",  SURFREV,	GenSURFREVObject,	1,	{ POLY_CURVE_EXPR } },
    { "EXTRUDE",  EXTRUDE,	GenEXTRUDEObject,	2,	{ POLY_CURVE_EXPR, VECTOR_EXPR } },
    { "LIST",	  LIST,		GenObjectList,		ANY_PARAM_NUM, { 0 } },
    { "LOAD",     LOAD,		DataPrsrGetObjects,	1,	{ STRING_EXPR } },
    { "CONVEX",	  CONVEX,	ConvexPolyObjectN,	1,	{ POLY_EXPR } },
    { "SBEZIER",  SBEZIER,	GenBezierSurfaceObject, 1,	{ OLST_EXPR } },
    { "CBEZIER",  CBEZIER,	GenBezierCurveObject,	1,	{ OLST_EXPR } },
    { "SBSPLINE", SBSPLINE,	GenBsplineSurfaceObject, 4,	{ NUMERIC_EXPR, NUMERIC_EXPR, OLST_EXPR, OLST_EXPR } },
    { "CBSPLINE", CBSPLINE,	GenBsplineCurveObject,	3,	{ NUMERIC_EXPR, OLST_EXPR, OLST_EXPR } },
    { "SEVAL",    SEVAL,	EvalSurfaceObject,	3,	{ SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "CEVAL",    CEVAL,	EvalCurveObject,	2,	{ CURVE_EXPR, NUMERIC_EXPR } },
    { "STANGENT", STANGENT,	TangentSurfaceObject,	4,	{ SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "CTANGENT", CTANGENT,	TangentCurveObject,	2,	{ CURVE_EXPR, NUMERIC_EXPR } },
    { "SNORMAL",  SNORMAL,	NormalSurfaceObject,	3,	{ SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "SDIVIDE",  SDIVIDE,	DivideSurfaceObject,	3,	{ SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "CDIVIDE",  CDIVIDE,	DivideCurveObject,	2,	{ CURVE_EXPR, NUMERIC_EXPR } },
    { "SREGION",  SREGION,	RegionFromSurfaceObject, 4,	{ SURFACE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "CREGION",  CREGION,	RegionFromCurveObject,	3,	{ CURVE_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "SREFINE",  SREFINE,	RefineSurfaceObject,	4,	{ SURFACE_EXPR, NUMERIC_OBJ, NUMERIC_OBJ, OLST_EXPR } },
    { "CREFINE",  CREFINE,	RefineCurveObject,	3,	{ CURVE_EXPR, NUMERIC_OBJ, OLST_EXPR } },
    { "SRAISE",   SRAISE,	RaiseSurfaceObject,	3,	{ SURFACE_EXPR, NUMERIC_OBJ, NUMERIC_OBJ } },
    { "CRAISE",   CRAISE,	RaiseCurveObject,	2,	{ CURVE_EXPR, NUMERIC_OBJ } },
    { "CSURFACE", CSURFACE,	CurveFromSurface,	3,	{ SURFACE_EXPR, NUMERIC_OBJ, NUMERIC_OBJ } },
    { "CMESH",    CMESH,	CurveFromSrfMesh,	3,	{ SURFACE_EXPR, NUMERIC_OBJ, NUMERIC_OBJ } },
    { "NTH",	  NTH,		GetNthList,		2,	{ OLST_EXPR, NUMERIC_EXPR } },
    { "GPOLYGON", GPOLYGON,	Geometry2Polygons,	1,	{ OLST_GEOM_EXPR } },
    { "GPOLYLINE", GPOLYLINE,	Geometry2Polylines,	1,	{ OLST_GEOM_EXPR } },
    { "CIRCLE",   CIRCLE,	GenCircleCurveObject,	2,	{ VECTOR_EXPR, NUMERIC_EXPR } },
    { "ARC",	  ARC,		GenArcCurveObject,	3,	{ VECTOR_EXPR, VECTOR_EXPR, VECTOR_EXPR } },
    { "RULEDSRF", RULEDSRF,	GenRuledSrfObject,	2,	{ CURVE_EXPR, CURVE_EXPR } },
    { "BOOLSUM",  BOOLSUM,	GenBoolSumSrfObject,	4,	{ CURVE_EXPR, CURVE_EXPR, CURVE_EXPR, CURVE_EXPR } },
    { "SFROMCRVS", SFROMCRVS,	GenSrfFromCrvsObject,	1,	{ OLST_EXPR } },
    { "SWEEPSRF", SWEEPSRF,	GenSweepSrfObject,	3,	{ CURVE_EXPR, CURVE_EXPR, CURVE_EXPR | NUMERIC_EXPR } },
    { "OFFSET",	  OFFSET,	GenOffsetObject,	2,	{ CURVE_EXPR | SURFACE_EXPR, NUMERIC_EXPR } },
    { "CEDITPT",  CEDITPT,	EditCrvControlPoint,	3,	{ CURVE_EXPR, CTLPT_EXPR, NUMERIC_EXPR } },
    { "SEDITPT",  SEDITPT,	EditSrfControlPoint,	4,	{ SURFACE_EXPR, CTLPT_EXPR, NUMERIC_EXPR, NUMERIC_EXPR } },
    { "MERGEPOLY",MERGEPOLY,	GenObjectFromPolyList,	1,	{ OLST_EXPR } },
};
int ObjFuncTableSize = sizeof(ObjFuncTable) / sizeof(ObjFuncTableType);

/* The cast for DosSystem below is because of the xlc compiler for the R6000 */
/* aix system complains on DosSystem as function with no arguments, so we    */
/* make it think it has one integer argument...				     */
typedef void (*VoidFuncIntPtr)(int);
GenFuncTableType GenFuncTable[] = {
    { "EXIT",	EXIT,		MyExit,			0,	{ 0 } },
    { "VIEW",	VIEW,		WndwViewGeomObject,	2,	{ OLST_GEOM_EXPR, NUMERIC_EXPR } },
    { "DIR",	DIR,		DosPrintDir,		1,	{ STRING_EXPR } },
    { "CHDIR",	CHDIR,		DosChangeDir,		1,	{ STRING_EXPR } },
    { "NORMAL",	NORMAL,		ViewSetNormals,		3,	{ NUMERIC_EXPR,	NUMERIC_EXPR, NUMERIC_EXPR } },
    { "INCLUDE", INCLUDE,	FileInclude,		1,	{ STRING_EXPR } },
    { "SAVE",	SAVE,		DataPrsrPutObject,	2,	{ STRING_EXPR, ANY_EXPR } },
    { "FREE",	FREEOBJ,	FreeObject,		1,	{ ANY_EXPR } },
    { "INTERACT", INTERACT, 	InteractPolyObject,	2,	{ OLST_GEOM_EXPR, NUMERIC_EXPR } },
    { "PAUSE",	PAUSE,		WndwPause,		1,	{ NUMERIC_EXPR } },
    { "IF",	IFCOND, 	IfCondition,		4,	{ NUMERIC_EXPR,	STRING_EXPR, NUMERIC_EXPR, ANY_EXPR } },
    { "FOR",	FORLOOP, 	ForLoop,		4,	{ NUMERIC_EXPR,	NUMERIC_EXPR, NUMERIC_EXPR, ANY_EXPR } },
    { "HELP",	PRHELP,		PrintHelp,		1,	{ STRING_EXPR } },
    { "VARLIST", VARLIST, 	PrintObjectList,	0,	{ 0 } },
    { "ALIAS",	ALIAS,		AliasEdit,		2,	{ STRING_EXPR, STRING_EXPR } },
    { "BEEP",	BEEP,   	GGTone,			2,	{ NUMERIC_EXPR, NUMERIC_EXPR } },
    { "EDIT",	EDIT,		DosEditFile,		1,	{ STRING_EXPR } },
    { "SYSTEM",	SYSTEM,		(VoidFuncIntPtr) DosSystem, 0,   { 0 } },
    { "LOGFILE", LOGFILE, 	WndwLogPrint,		1,	{ NUMERIC_EXPR } },
    { "COLOR",	COLOR,		SetObjectColor, 	2,	{ GEOM_EXPR, NUMERIC_EXPR } },
    { "SNOC",	SNOC,		SnocList,		2,	{ ANY_EXPR, OLST_EXPR } },
    { "ATTRIB",	ATTRIB,		SetObjectStrAttrib,	3,	{ GEOM_EXPR, STRING_EXPR, STRING_EXPR } },
    { "CLOSED", CLOSED,		ViewSetClosed,		1,	{ NUMERIC_EXPR } }
};
int GenFuncTableSize = sizeof(GenFuncTable) / sizeof(GenFuncTableType);

ConstantTableType ConstantTable[] = {
    { "PI",	M_PI },

    { "ON",	1.0 },
    { "TRUE",	1.0 },
    { "OFF",	0.0 },
    { "FALSE",	0.0 },

    { "COL",    (double) CAGD_CONST_U_DIR },
    { "ROW",    (double) CAGD_CONST_V_DIR },

    { "KV_OPEN", (double) KV_UNIFORM_OPEN },
    { "KV_FLOAT", (double) KV_UNIFORM_FLOAT },

    { "E2",     (double) CAGD_PT_E2_TYPE },
    { "E3",     (double) CAGD_PT_E3_TYPE },
    { "P2",     (double) CAGD_PT_P2_TYPE },
    { "P3",     (double) CAGD_PT_P3_TYPE },

    { "BLACK",  (double) BLACK },
    { "BLUE",	(double) BLUE },
    { "GREEN",	(double) GREEN },
    { "CYAN",	(double) CYAN },
    { "RED",	(double) RED },
    { "MAGENTA", (double) MAGENTA },
    { "YELLOW", (double) YELLOW },
    { "WHITE",  (double) WHITE },

    { "MSDOS",  (double) MACHINE_MSDOS },
    { "SGI",    (double) MACHINE_SGI },
    { "HP",     (double) MACHINE_HP },
    { "SUN",    (double) MACHINE_SUN },
    { "APOLLO", (double) MACHINE_APOLLO },
    { "UNIX",   (double) MACHINE_UNIX },
};
int ConstantTableSize = sizeof(ConstantTable) / sizeof(ConstantTableType);

/*****************************************************************************
*   Routine to do type checking to the given tree - return type if found one *
* or returns ERROR_EXPR if error in types was detected.			     *
*****************************************************************************/
IritExprType InptPrsrTypeCheck(ParseTree *Root, int Level)
{
    IritExprType Right, Left, Result;

    if (Level == 0 &&
	Root->NodeKind != PARAMETER &&	    /* What is allowed on top level. */
	Root->NodeKind != EQUAL &&
	!IS_GEN_FUNCTION(Root->NodeKind)) {
	IPGlblEvalError = IE_ERR_NO_ASSIGNMENT;
	strcpy(IPGlblCharData, "");
	return ERROR_EXPR;
    }

    if (IS_NUM_FUNCTION(Root->NodeKind)) { /* Funcs which returns Real Type: */
	if (FuncParamMismatch(Root)) return ERROR_EXPR;
	return NUMERIC_EXPR;
    }

    if (IS_GEN_FUNCTION(Root->NodeKind)) {   /* Funcs which returns nothing: */
	if (Level == 0) {
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return NO_EXPR;
	}
	else {
	    IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
	    UpdateCharError("Procedure ", Root->NodeKind);
	    return ERROR_EXPR;
	}
    }

    switch (Root->NodeKind) {
	case VECTOR:	      /* Object functions which returns Vector Type: */
	case STANGENT:
	case CTANGENT:
	case SNORMAL:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return VECTOR_EXPR;
	case CTLPT:	      /* Object functions which returns Ctl Pt Type: */
	case CEVAL:
	case SEVAL:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return CTLPT_EXPR;
	case ROTX:
	case ROTY:
	case ROTZ:
	case TRANS:
	case SCALE:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return MATRIX_EXPR;
	case BOX:
	case GBOX:
	case CONE:
	case CONE2:
	case CYLIN:
	case SPHERE:
	case TORUS:
	case CIRCPOLY:
	case POLY:
	case CROSSEC:
	case CONVEX:
	case GPOLYGON:
	case GPOLYLINE:
	case MERGEPOLY:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return POLY_EXPR;
	case CBEZIER:
	case CBSPLINE:
	case CREFINE:
	case CRAISE:
	case CSURFACE:
	case CMESH:
	case CIRCLE:
	case ARC:
	case CREGION:
	case CEDITPT:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return CURVE_EXPR;
	case SBEZIER:
	case SBSPLINE:
	case SREFINE:
	case SRAISE:
	case RULEDSRF:
	case BOOLSUM:
	case SWEEPSRF:
	case SREGION:
	case SFROMCRVS:
	case SEDITPT:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return SURFACE_EXPR;
	case LOAD:
	case NTH:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return ANY_EXPR;
	case OFFSET:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return SURFACE_EXPR | CURVE_EXPR;
	case SURFREV:
	case EXTRUDE:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return SURFACE_EXPR | POLY_EXPR;
	case LIST:
	case SDIVIDE:
	case CDIVIDE:
	    if (FuncParamMismatch(Root)) return ERROR_EXPR;
	    return OLST_EXPR;
	case PLUS:
	case MINUS:
	case MULT:
	case DIV:
	case POWER:
	    Right = InptPrsrTypeCheck(Root->Right, Level+1);
	    Left  = InptPrsrTypeCheck(Root->Left,  Level+1);
	    if (Right == ERROR_EXPR || Left == ERROR_EXPR) return ERROR_EXPR;
	    if (!OverLoadTypeCheck(Root->NodeKind, Right, Left, &Result)) {
		IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
                UpdateCharError("Operator ", Root->NodeKind);
		return ERROR_EXPR;
	    }
	    else
		return Result;
	case UNARMINUS:
	    if ((Right = InptPrsrTypeCheck(Root->Right, Level+1)) == ERROR_EXPR)
		return ERROR_EXPR;
	    else if (!OverLoadTypeCheck(Root->NodeKind, Right, NO_EXPR,
								&Result)) {
		IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
                UpdateCharError("Operator ", Root->NodeKind);
		return ERROR_EXPR;
	    }
	    else
		return Result;
	case EQUAL:
	    if ((Right = InptPrsrTypeCheck(Root->Right, Level+1)) == ERROR_EXPR)
		return ERROR_EXPR;
	    if (Root->Left->NodeKind != PARAMETER) {
		IPGlblEvalError = IE_ERR_ASSIGN_LEFT_OP;
		InptPrsrPrintTree(Root->Left, IPGlblCharData);
		return ERROR_EXPR;
	    }
	    return Right;
	case NUMBER:
	    return NUMERIC_EXPR;
	case PARAMETER:
	    switch (Root->U.PObj->ObjType) {
                case POLY_OBJ:
                    return POLY_EXPR;
		case NUMERIC_OBJ:
		    return NUMERIC_EXPR;
		case VECTOR_OBJ:
		    return VECTOR_EXPR;
		case CTLPT_OBJ:
		    return CTLPT_EXPR;
		case MATRIX_OBJ:
		    return MATRIX_EXPR;
		case STRING_OBJ:
		    return STRING_EXPR;
		case OBJ_LIST_OBJ:
		    return OLST_EXPR;
		case CURVE_OBJ:
		    return CURVE_EXPR;
		case SURFACE_OBJ:
		    return SURFACE_EXPR;
		case UNDEF_OBJ:
		    IPGlblEvalError = IE_ERR_UNDEF_OBJECT;
		    strcpy(IPGlblCharData, Root->U.PObj->Name);
		    return ERROR_EXPR;
	    }
	    IPGlblEvalError = IE_ERR_FATAL_ERROR;
	    sprintf(IPGlblCharData, "Object = %s, Type %d",
				Root->U.PObj->Name, Root->U.PObj->ObjType);
	    return ERROR_EXPR;
	case STRING:
	    return STRING_EXPR;
	default:				     /* Should never happen. */
	    IPGlblEvalError = IE_ERR_FATAL_ERROR;
            UpdateCharError("Token ", Root->NodeKind);
	    return ERROR_EXPR;
    }
}

/* Disable the function with no prototype warning on Borland's compilers. */
#ifdef __BORLANDC__
#pragma warn -pro
#endif /* __BORLANDC__ */

/*****************************************************************************
*   Routine to evaluate	a value	of a given tree	root and parameter.	     *
* Note we change the tree itself during the evaluation process.		     *
* Also note we assume the tree is type checked (via InptPrsrTypeCheck rtn).  *
*****************************************************************************/
ParseTree *InptPrsrEvalTree(ParseTree *Root, int Level)
{
    char *ErrorMsg;
    RealType R;
    ParseTree *TempL, *TempR, *Params[5];
    PolygonStruct *PPoly;
    ObjectStruct *PObj;

    switch (Root->NodeKind) {
	case ARCSIN:	   /* Real return functions with one real parameter. */
	case ARCCOS:
	case ARCTAN:
	case COS:
	case EXP:
	case FABS:
	case LN:
	case LOG:
	case SIN:
	case SQRT:
	case TAN:
	case TIME:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.R = (NumFuncTable[Root->NodeKind-NUM_FUNC_OFFSET].Func)
							     (Params[0]->U.R);
	    Root->ObjType = NUMERIC_OBJ;
	    if (RetrieveMathError()) return NULL;
	    return Root;

	case CPOLY:
	case AREA:
	case VOLUME:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.R = (NumFuncTable[Root->NodeKind-NUM_FUNC_OFFSET].Func)
					       		  (Params[0]->U.PObj);
	    Root->ObjType = NUMERIC_OBJ;
	    if (RetrieveMathError()) return NULL;
	    return Root;

	case ARCTAN2:	  /* Real return functions with two real parameters. */
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.R = (NumFuncTable[Root->NodeKind-NUM_FUNC_OFFSET].Func)
					     (Params[0]->U.R, Params[1]->U.R);
	    Root->ObjType = NUMERIC_OBJ;
	    if (RetrieveMathError()) return NULL;
	    return Root;

	case VECTOR:  /* Object return functions with three real parameters. */
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		("", &Params[0]->U.R, &Params[1]->U.R, &Params[2]->U.R, NULL);
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case CTLPT:
	case LIST:
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
							       (Root -> Right);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case ROTX:
	case ROTY:
	case ROTZ:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
							     (&Params[0]->U.R);
	    if (RetrieveMathError()) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case TRANS:
	case SCALE:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
						    (Params[0]->U.PObj->U.Vec);
	    if (RetrieveMathError()) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case BOX:
	    if (!FetchParameters(Root, 4, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		(Params[0]->U.PObj->U.Vec, &Params[1]->U.R, &Params[2]->U.R,
                					    &Params[3]->U.R);
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case GBOX:
	    if (!FetchParameters(Root, 4, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		(Params[0]->U.PObj->U.Vec, Params[1]->U.PObj ->U.Vec,
		 Params[2]->U.PObj->U.Vec, Params[3]->U.PObj ->U.Vec);
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case CONE:
	case CYLIN:
	case CIRCPOLY:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		(Params[0]->U.PObj->U.Vec, Params[1]->U.PObj->U.Vec,
                					&Params[2]->U.R);
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case SPHERE:
	case CIRCLE:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
			           (Params[0]->U.PObj->U.Vec, &Params[1]->U.R);
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case TORUS:
	case CONE2:
	    if (!FetchParameters(Root, 4, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		(Params[0]->U.PObj->U.Vec, Params[1]->U.PObj->U.Vec,
		 &Params[2]->U.R, &Params[3]->U.R);
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case SEVAL:
	case SNORMAL:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
			  (Params[0]->U.PObj, &Params[1]->U.R, &Params[2]->U.R);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case STANGENT:
	case SREGION:
	    if (!FetchParameters(Root, 4, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
			  (Params[0]->U.PObj, &Params[1]->U.R,
			   &Params[2]->U.R, &Params[3]->U.R);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case CDIVIDE:
	case CEVAL:
	case CTANGENT:
	case CRAISE:
	case OFFSET:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
			  (Params[0]->U.PObj, &Params[1]->U.R);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case SREFINE:
	    if (!FetchParameters(Root, 4, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		       (Params[0]->U.PObj, &Params[1]->U.R,
                       		     &Params[2]->U.R, Params[3]->U.PObj);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case CREFINE:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
	         (Params[0]->U.PObj, &Params[1]->U.R, Params[2]->U.PObj);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case SDIVIDE:
	case SRAISE:
	case CSURFACE:
	case CREGION:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		   (Params[0]->U.PObj, &Params[1]->U.R, &Params[2]->U.R);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case CMESH:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		   (Params[0]->U.PObj,
		    &Params[1]->U.R, &Params[2]->U.R);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case NTH:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
			            (Params[0]->U.PObj, &Params[1]->U.R);
	    if (Root->U.PObj == NULL) return NULL;

	    if (IS_NUM_OBJ(Root->U.PObj)) {
		Root->ObjType = NUMERIC_OBJ;
		MyFree((char *) Root->U.PObj, ALLOC_OBJECT);
		Root->U.R = Root->U.PObj->U.R;
		Root->NodeKind = NUMBER;     /* Disconnect the var. binding. */
		return Root;
            }
            else {
		Root->ObjType = Root->U.PObj->ObjType;
		/* Since at this point, no one is pointing on it: */
		Root->U.PObj->Count = 0;
		return Root;
	    }

	case POLY:
	case SBEZIER:
	case CBEZIER:
	case SURFREV:
	case CONVEX:
	case GPOLYGON:
	case GPOLYLINE:
	case SFROMCRVS:
	case MERGEPOLY:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
							   (Params[0]->U.PObj);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case CBSPLINE:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
			(&Params[0]->U.R, Params[1]->U.PObj, Params[2]->U.PObj);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case SBSPLINE:
	    if (!FetchParameters(Root, 4, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
			(&Params[0]->U.R, &Params[1]->U.R,
			 Params[2]->U.PObj, Params[3]->U.PObj);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case CROSSEC:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    Root->ObjType = POLY_OBJ;
	    /* Use table entries to call the function directly. */
	    if (IS_POLY_OBJ(Params[0] -> U.PObj))
		Root->U.PObj =
		    (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
			(Params[0]->U.PObj);
	    else
		Root->U.PObj =
		    (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)(NULL);
	    if (Root->U.PObj == NULL) return NULL;
	    return Root;

	case EXTRUDE:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
				 (Params[0]->U.PObj, Params[1]->U.PObj->U.Vec);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case RULEDSRF:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
				 (Params[0]->U.PObj, Params[1]->U.PObj);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case BOOLSUM:
	    if (!FetchParameters(Root, 4, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
				 (Params[0]->U.PObj, Params[1]->U.PObj,
				  Params[2]->U.PObj, Params[3]->U.PObj);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case CEDITPT:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
				 (Params[0]->U.PObj, Params[1]->U.PObj,
				  &Params[2]->U.R);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case SEDITPT:
	    if (!FetchParameters(Root, 4, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
				 (Params[0]->U.PObj, Params[1]->U.PObj,
				  &Params[2]->U.R, &Params[3]->U.R);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case ARC:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		          (Params[0]->U.PObj->U.Vec, Params[1]->U.PObj->U.Vec,
						     Params[2]->U.PObj->U.Vec);
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case SWEEPSRF:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    if (IS_NUM_NODE(Params[2])) {
	    	Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		     (Params[0]->U.PObj, Params[1]->U.PObj, NULL,
							       &Params[2]->U.R);
	    }
	    else {
		R = 1.0;
	    	Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
		     (Params[0]->U.PObj, Params[1]->U.PObj, Params[2]->U.PObj,
									    &R);
	    }
	    if (Root->U.PObj == NULL) return NULL;
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case LOAD:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    Root->U.PObj = (ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].Func)
						(Params[0]->U.PObj->U.Str, "");
	    if (Root->U.PObj == NULL) {
	        DataPrsrParseError(&ErrorMsg);
		IPGlblEvalError = IE_ERR_DATA_PRSR_ERROR;
		strcpy(IPGlblCharData, ErrorMsg);
		return NULL;
	    }
	    Root->ObjType = Root -> U.PObj -> ObjType;
	    return Root;

	case SNOC:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;

	    if (Params[0]->ObjType == NUMERIC_OBJ) {
		PObj = GenNumObject("", &Params[0]->U.R, NULL);
		/* Use table entries to call the function directly. */
		(GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
						    (PObj, Params[1]->U.PObj);
		MyFree((char *) PObj, ALLOC_OBJECT);
	    }
	    else {
		/* Use table entries to call the function directly. */
		(GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
					(Params[0]->U.PObj, Params[1]->U.PObj);
	    }
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case VIEW:
	case INTERACT:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    Root->ObjType = UNDEF_OBJ;
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
					  (Params[0]->U.PObj, &Params[1]->U.R);
	    return Root;

	case COLOR:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    Root->ObjType = UNDEF_OBJ;
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
			    (Params[0]->U.PObj, REAL_TO_INT(Params[1]->U.R));
	    return Root;

	case EXIT:
	    /* Yes - we finished for today... */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)(0);

	case PAUSE:
	case LOGFILE:
	case CLOSED:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
	            					  (&Params[0] -> U.R);
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case VARLIST:
	case SYSTEM:
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)(GlblObjList);
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case DIR:
	case CHDIR:
	case INCLUDE:
	case PRHELP:
	case EDIT:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
			 (Params[0]->U.PObj->U.Str);
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case SAVE:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    if (Params[1]->ObjType == NUMERIC_OBJ) {
		PObj = GenNumObject("", &Params[1]->U.R, NULL);
	    	/* Use table entries to call the function directly. */
	        (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
					(Params[0]->U.PObj->U.Str, PObj);
		MyFree((char *) PObj, ALLOC_OBJECT);
	    }
	    else {
		/* Use table entries to call the function directly. */
		(GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
				(Params[0]->U.PObj->U.Str, Params[1]->U.PObj);
	    }

	    if (DataPrsrParseError(&ErrorMsg) != 0) {
		IPGlblEvalError = IE_ERR_DATA_PRSR_ERROR;
		strcpy(IPGlblCharData, ErrorMsg);
		return NULL;
	    }
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case BEEP:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
		 (REAL_TO_INT(Params[0]->U.R), REAL_TO_INT(Params[1]->U.R));
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case ALIAS:
	    if (!FetchParameters(Root, 2, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
			 (Params[0]->U.PObj->U.Str, Params[1]->U.PObj->U.Str);
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case ATTRIB:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
			(Params[0]->U.PObj,
			 Params[1]->U.PObj->U.Str, Params[2]->U.PObj->U.Str);
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case FREEOBJ:
	    if (!FetchParameters(Root, 1, Level, Params)) return NULL;
	    if ((TempR = InptPrsrEvalTree(Root->Right, Level+1)) == NULL)
		return NULL;
	    if (TempR->ObjType == NUMERIC_OBJ) {
		IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
		strcpy(IPGlblCharData, "Func FREE, parameter 1");
		return Root;
	    }
	    if (strlen(TempR->U.PObj->Name) == 0) {
		IPGlblEvalError = IE_ERR_FREE_SIMPLE;
                UpdateCharError("Procedure ", FREEOBJ);
		return Root;
	    }
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
							      (TempR->U.PObj);
	    Root->ObjType = UNDEF_OBJ;
	    TempR->U.PObj = NULL;	    /* Make sure its disconnected... */
	    return Root;

	case NORMAL:
	    if (!FetchParameters(Root, 3, Level, Params)) return NULL;
	    /* Use table entries to call the function directly. */
	    (GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].Func)
		          (&Params[0]->U.R, &Params[1]->U.R, &Params[2]->U.R);
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case IFCOND:
	    IfCondition(FetchParameter(Root->Right, 0, 4),
			FetchParameter(Root->Right, 1, 4),
			FetchParameter(Root->Right, 2, 4),
			FetchParameter(Root->Right, 3, 4));
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case FORLOOP:
	    ForLoop(FetchParameter(Root->Right, 0, 4),
		    FetchParameter(Root->Right, 1, 4),
		    FetchParameter(Root->Right, 2, 4),
		    FetchParameter(Root->Right, 3, 4));
	    Root->ObjType = UNDEF_OBJ;
	    return Root;

	case PLUS:
	case MINUS:
	case MULT:
	case DIV:
	case POWER:
	    if (((TempR = InptPrsrEvalTree(Root->Right, Level+1)) == NULL)
	     || ((TempL = InptPrsrEvalTree(Root->Left,  Level+1)) == NULL))
		return NULL;
	    TempR = OverLoadEvalOper(Root, TempR, TempL,
					&IPGlblEvalError, IPGlblCharData);
	    if (RetrieveMathError())
		return NULL;
	    else
		return TempR;

	case UNARMINUS:
	    if ((TempR = InptPrsrEvalTree(Root->Right, Level+1)) == NULL)
		return NULL;
	    TempR = OverLoadEvalOper(Root, TempR, NULL,
					&IPGlblEvalError, IPGlblCharData);
	    if (RetrieveMathError())
	        return NULL;
	    else
		return TempR;

	case NUMBER:
	    Root->ObjType = NUMERIC_OBJ;
            return Root;

	case PARAMETER:
	    if (Level == 0) {	      /* If only object - print its content. */
		Root->U.PObj->Count--;   /* Remove reference from this tree. */
		PrintObject(Root->U.PObj);
		Root->U.PObj->Count++;		      /* Add reference back. */
		Root->ObjType = Root->U.PObj->ObjType;
		return Root;
	    }
	    if (IS_NUM_OBJ(Root->U.PObj)) {
		Root->ObjType = NUMERIC_OBJ;
		Root->U.PObj->Count--;
		Root->U.R = Root->U.PObj->U.R;
		Root->NodeKind = NUMBER;     /* Disconnect the var. binding. */
		return Root;
            }
	    else {
		Root->ObjType = Root->U.PObj->ObjType;
		return Root;
	    }

	case STRING:
	    Root->ObjType = STRING_OBJ;
            return Root;

	case EQUAL:
	    if ((TempR = InptPrsrEvalTree(Root->Right, Level+1)) == NULL)
		return NULL;
	    TempL = Root->Left;
	    PPoly = NULL;
	    if (IS_UNDEF_OBJ(TempL->U.PObj))		  /* Its new object. */
		InsertObject(TempL->U.PObj);	   /* Insert to global vars. */
	    else if (IS_POLY_OBJ(TempL->U.PObj))    /* If old var. was poly. */
		PPoly = TempL->U.PObj->U.Pl.P;

            if (IS_NUM_NODE(TempR)) {
		TempL->ObjType = TempL->U.PObj->ObjType = NUMERIC_OBJ;
		TempL->U.PObj->U.R = TempR->U.R;
	    }
            else {
		if (TempL -> U.PObj == TempR -> U.PObj) return TempR;/* A=A. */
		TempL->ObjType = TempR->ObjType;
		CopyObject(TempL->U.PObj, TempR->U.PObj, FALSE);
	    }
	    if (PPoly != NULL) MyFree((char *) (PPoly), ALLOC_POLYGON);

	    Root->ObjType = UNDEF_OBJ;
	    return TempR;
    }
    return NULL;				    /* Makes warning silent. */
}

/* Restore the function with no prototype warning on Borland's compilers. */
#ifdef __BORLANDC__
#pragma warn .pro
#endif /* __BORLANDC__ */

/*****************************************************************************
*   Routine to print help on the given subject HelpHeader.		     *
* Note a match is if the HelpHeader in prefix of help file line.	     *
*****************************************************************************/
static void PrintHelp(char *HelpHeader)
{
    int	i;
    char *Path, s[LINE_LEN];
    FILE *f;

    Path = searchpath(GlblHelpFileName);

    if (strlen(HelpHeader) == 0)
	HelpHeader = "Commands";	    /* Print a list of all commands. */

    if ((f = fopen(Path, "r")) == NULL) {
	sprintf(s, "Cannot open help file \"%s\".\n", GlblHelpFileName);
	WndwInputWindowPutStr(s);
	return;
    }

    for (i = 0; i < (int) strlen(HelpHeader); i++)
	if (islower(HelpHeader[i])) HelpHeader[i] = toupper(HelpHeader[i]);

    while (fgets(s, LINE_LEN-1, f) != NULL) {
	if (strncmp(HelpHeader, s, strlen(HelpHeader)) == 0) {
	    /* Found match - print it. */
	    while (fgets(s, LINE_LEN-1, f) != NULL && s[0] != '$') {
		WndwInputWindowPutStr(&s[1]);		     /* Skip char 1. */
	    }
	    fclose(f);
	    return;
	}
    }

    fclose(f);

    sprintf(s, "No help on %s\n", HelpHeader);
    WndwInputWindowPutStr(s);
}

/*****************************************************************************
*   Routine to execute the IF structure.				     *
*****************************************************************************/
static void IfCondition(ParseTree *Left, ParseTree *Cond, ParseTree *Right,
							  ParseTree *PBody)
{
    int i, NumOfExpr;
    RealType L, R;
    char *Str;

    Left = InptPrsrEvalTree(Left, 1);
    Cond = InptPrsrEvalTree(Cond, 1);
    Right = InptPrsrEvalTree(Right, 1);

    L = Left->U.R;
    Str = Cond->U.PObj->U.Str;
    R = Right->U.R;

    if ((strcmp(Str, "=")  == 0 && L == R) ||
	(strcmp(Str, "<>") == 0 && L != R) ||
	(strcmp(Str, "<=") == 0 && L <= R) ||
	(strcmp(Str, ">=") == 0 && L >= R) ||
	(strcmp(Str, ">")  == 0 && L > R) ||
	(strcmp(Str, "<")  == 0 && L < R)) {
	/* If we are here, then the condition holds: */
	for (i = 0; i < (NumOfExpr = CountNumExpressions(PBody)); i++) {
	    InptPrsrEvalTree(FetchExpression(PBody, i, NumOfExpr), 0);
	    if (GlblWasCtrlBrk ||	 /* async. break send from the user. */
		IPGlblEvalError) break;
	}
    }
}

/*****************************************************************************
*   Routine to execute the FOR structure loop.				     *
*   Note that as InptPrsrEvalTree routine is destructive on its input tree,  *
* we must make a copy of the body before executing it!			     *
*   We wish we could access the loop variable directly, but the user might   *
* be stupid and free it in the loop - so me must access it by name.	     *
*****************************************************************************/
static void ForLoop(ParseTree *PStart, ParseTree *PInc, ParseTree *PEnd,
							ParseTree *PBody)
{
    int i, NumOfExpr, LoopCount;
    char *LoopVarName = NULL;
    RealType LoopVar, StartVal, Increment, EndVal;
    ParseTree *PTemp;
    ObjectStruct *PLoopVar;

    /* Find the only two cases where loop variable is allowed - when then */
    /* given starting value is a parameter, or assignment to parameter... */
    if (PStart -> NodeKind == PARAMETER)
	LoopVarName = PStart -> U.PObj -> Name;
    else if (PStart -> NodeKind == EQUAL &&
	     PStart -> Left -> NodeKind == PARAMETER) {
	LoopVarName = PStart -> Left -> U.PObj -> Name;
	/* Rebind the iteration variable to body - it might be new: */
	RebindVariable(PBody, PStart -> Left -> U.PObj);
	if (GetObject(LoopVarName) == NULL)		/* It is really new. */
	    PStart -> Left -> U.PObj -> Count++;
    }

    PStart = InptPrsrEvalTree(PStart, 1);	 /* Evaluate starting value. */
    PInc   = InptPrsrEvalTree(PInc, 1);		/* Evaluate increment value. */
    PEnd   = InptPrsrEvalTree(PEnd, 1);		      /* Evaluate end value. */
    if (IPGlblEvalError ||
	PStart == NULL || PInc == NULL || PEnd == NULL) return;
    StartVal = PStart -> U.R;
    Increment = PInc -> U.R;
    EndVal = PEnd -> U.R;

    NumOfExpr = CountNumExpressions(PBody);    /* Num. of expr. in the body. */
    for (LoopVar = StartVal, LoopCount = 0;
	APX_EQ(LoopVar, EndVal) ||
	(Increment > 0 ? LoopVar <= EndVal : LoopVar >= EndVal);
	LoopVar += Increment, LoopCount++) {
	if (GlblWasCtrlBrk ||		 /* Async. break send from the user. */
	    IPGlblEvalError || GlblFatalError) return;
	if (LoopVarName != NULL) {
	    if ((PLoopVar = GetObject(LoopVarName)) != NULL &&
		 IS_NUM_OBJ(PLoopVar))
		PLoopVar -> U.R = LoopVar; /* Update loop var. */
	    else {
		IPGlblEvalError = IE_ERR_MODIF_ITER_VAR;
		strcpy(IPGlblCharData, LoopVarName);
	    }
	}

	for (i = 0; i < NumOfExpr; i++) {
	    PTemp = FetchExpression(PBody, i, NumOfExpr);
	    if (LoopCount == 0 && InptPrsrTypeCheck(PTemp, 0) == ERROR_EXPR)
		return;
	    else {
		if (LoopVar == EndVal) {
		    /* Use the original tree. Note we must evaluate the      */
		    /* original tree at least once as ObjType's are updated. */
		    InptPrsrEvalTree(PTemp, 0);	 /* Eval as its top level... */
		}
		else {
		    PTemp = InptPrsrCopyTree(PTemp);
		    InptPrsrEvalTree(PTemp, 0);	 /* Eval as its top level... */
		    InptPrsrFreeTree(PTemp);	     /* Not needed any more. */
		}
	    }
	}
    }
}

/*****************************************************************************
*   Routine to create an OBJECT LIST object out of all parameters.	     *
*****************************************************************************/
static ObjectStruct *GenObjectList(ParseTree *PObjParams)
{
    int i, NumOfParams;
    ParseTree *Param;
    ObjectStruct *PObj;

    NumOfParams = CountNumParameters(PObjParams);
    if (NumOfParams > MAX_OBJ_LIST) {
	IPGlblEvalError = IE_ERR_LIST_TOO_LONG;
	return NULL;
    }

    PObj = AllocObject("", OBJ_LIST_OBJ, NULL);

    for (i = 0; i < NumOfParams; i++) {
	if ((Param = InptPrsrEvalTree(FetchParameter(PObjParams, i,
						     NumOfParams),
				      1)) == NULL) {
	    MyFree((char *) PObj, ALLOC_OBJECT);
	    return NULL;
        }
	if (Param -> NodeKind == NUMBER ||
	    (Param -> NodeKind == UNARMINUS &&
	     Param -> ObjType == NUMERIC_OBJ)) {
	    /* This is a special case in which the data is saved in parse    */
            /* tree instead of as an underneath object - make an object!     */
	    PObj -> U.PObjList[i] = AllocObject("", NUMERIC_OBJ, NULL);
	    PObj -> U.PObjList[i] -> U.R = Param -> U.R;
	}
        else {
	    if (Param -> U.PObj -> ObjType == UNDEF_OBJ) {
		IPGlblEvalError = IE_ERR_UNDEF_OBJECT;
		strcpy(IPGlblCharData, Param -> U.PObj -> Name);
		PObj -> U.PObjList[i] = NULL;
		MyFree((char *) PObj, ALLOC_OBJECT);
		return NULL;
	    }

	    PObj -> U.PObjList[i] = Param -> U.PObj;
	    Param -> U.PObj -> Count++;    /* Increase number of references. */
        }
    }

    if (NumOfParams < MAX_OBJ_LIST) PObj -> U.PObjList[NumOfParams] = NULL;
    return PObj;
}

/*****************************************************************************
*   Routine to create an Control Point Object out of all parameters.	     *
*****************************************************************************/
static ObjectStruct *CtlPtFromParams(ParseTree *PObjParams)
{
    int i, NumPts, NumOfParams, PtType,
	CoordCount = 0;
    ParseTree *Param;
    ObjectStruct *PObj;

    NumOfParams = CountNumParameters(PObjParams);

    PObj = AllocObject("", CTLPT_OBJ, NULL);

    for (i = 0; i < NumOfParams; i++) {
	if ((Param = InptPrsrEvalTree(FetchParameter(PObjParams, i,
						     NumOfParams),
				      1)) == NULL) {
	    MyFree((char *) PObj, ALLOC_OBJECT);
	    return NULL;
        }
        if (Param -> ObjType != NUMERIC_OBJ) {
	    IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
	    strcpy(IPGlblCharData, "Numeric data expected");
	    MyFree((char *) PObj, ALLOC_OBJECT);
	    return NULL;
        }

	if (i == 0) {
	    PtType = PObj -> U.CtlPt.PtType = (CagdPointType) Param -> U.R;
	    switch (PtType) {
		case CAGD_PT_E2_TYPE:
		    NumPts = 2;
		    CoordCount = 1;
		    break;
		case CAGD_PT_E3_TYPE:
		    NumPts = 3;
		    CoordCount = 1;
		    break;
		case CAGD_PT_P2_TYPE:
		    NumPts = 3;
		    break;
		case CAGD_PT_P3_TYPE:
		    NumPts = 4;
		    break;
		default:
		    IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
		    strcpy(IPGlblCharData, "E2, E3, P2, P3 expected");
		    MyFree((char *) PObj, ALLOC_OBJECT);
		    return NULL;
	    }
	    if (NumOfParams - 1 != NumPts) {
		IPGlblEvalError = IE_ERR_NUM_PRM_MISMATCH;
		sprintf(IPGlblCharData, "%d expected", NumPts);
		MyFree((char *) PObj, ALLOC_OBJECT);
		return NULL;
	    }
	}
        else
	    PObj -> U.CtlPt.Coords[CoordCount++] = Param -> U.R;
    }

    return PObj;
}

/*****************************************************************************
*   Routine to count number of expressions seperated by a COLON are given    *
* in the tree ROOT. This routine is similar to CountNumParameters below.     *
*****************************************************************************/
static int CountNumExpressions(ParseTree *Root)
{
    int i=1;

    while (Root->NodeKind == COLON) {
	i++;
	Root = Root->Right;
    }
    return i;
}

/*****************************************************************************
*   Routine to fetch the i expression out of a tree represent n expressions  *
* (0 <= i < n) seperated by colonc. Similar to FetchParameter routine below. *
*****************************************************************************/
static ParseTree *FetchExpression(ParseTree *Root, int i, int n)
{
    int j;

    for (j = 0; j < i; j++) Root = Root->Right;

    if (i == n - 1)
        return Root;
    else
	return Root->Left;
}

/*****************************************************************************
*   Routine to retrieve math error if was one. return TRUE if was error.     *
*****************************************************************************/
static int RetrieveMathError(void)
{
    int Error;
    char *FuncName, *p;

#ifdef __MSDOS__
    if ((Error = MathError(&FuncName)) != 0) {
	switch (Error) {
	    case DOMAIN:
		p = "DOMAIN";
		break;
	    case SING:
		p = "SING";
		break;
	    case OVERFLOW:
		p = "O.F.";
		break;
	    case UNDERFLOW:
		p = "U.F.";
		break;
	    case TLOSS:
		p = "TLOSS";
		break;
	    default:
		p = "Undef.";
		break;
	}
        strcpy(IPGlblCharData, p);
	strcat(IPGlblCharData, " error - func. ");
	strcat(IPGlblCharData, FuncName);
	IPGlblEvalError = IE_ERR_FP_ERROR;
	return TRUE;
    }
#endif /* __MSDOS__ */

    return FALSE;
}

/*****************************************************************************
*  Routine to count number of parameters where given: parameters are defined *
* as subtrees seperated by commas, i.e.: the infix form 1, 2, 3, 4 is 	     *
* represented as [1, [2, [3, 4]]] in the tree supplied to this function and  *
* 4 (number of parameters) is returned.					     *
*****************************************************************************/
static int CountNumParameters(ParseTree *Root)
{
    int i = 1;

    if (Root == NULL) return 0;

    while (Root->NodeKind == COMMA) {
	i++;
	Root = Root->Right;
    }
    return i;
}

/*****************************************************************************
*   Routine to fetch the i paramter out of a tree represent n parameters     *
* (0 <= i < n). See CountNumParameters for more description of structure.    *
* Note it is assumed the tree HAS n parameters and 0<=i<n (No input error).  *
*****************************************************************************/
static ParseTree *FetchParameter(ParseTree *Root, int i, int n)
{
    int j;

    for (j = 0; j < i; j++) Root = Root->Right;

    if (i == n - 1)
	return Root;
    else
	return Root->Left;
}

/*****************************************************************************
*   Routine to fetch the parameters from the parsed tree.		     *
* Returns TRUE iff fetching was succesfull.				     *
*****************************************************************************/
static int FetchParameters(ParseTree *Root, int NumParams, int Level,
							 ParseTree *Params[])
{
    int i;

    Level++;
    for (i = 0; i < NumParams; i++)
	if ((Params[i] =  InptPrsrEvalTree(FetchParameter(Root->Right, i,
        						 NumParams),
					  Level)) == NULL)
	    return FALSE;

    return TRUE;
}

/*****************************************************************************
*   Routine to test number of parameters and type of them against what is    *
* defined in its global tables Num/Obj/GenFuncTable. return TRUE if mismatch *
* was detected:								     *
*****************************************************************************/
static int FuncParamMismatch(ParseTree *Root)
{
    int FuncOffset, Count, i = Root->NodeKind / 100;
    FuncTableType *FuncTable;

    switch (i * 100) {
	case NUM_FUNC:		       /* Numeric (real returned) functions. */
	    FuncOffset = Root->NodeKind-NUM_FUNC_OFFSET;
	    FuncTable = (FuncTableType *) NumFuncTable;
	    break;
	case OBJ_FUNC:			     /* Object (returned) functions. */
	    FuncOffset = Root->NodeKind-OBJ_FUNC_OFFSET;
	    FuncTable = (FuncTableType *) ObjFuncTable;
	    break;
	case GEN_FUNC:
	    FuncOffset = Root->NodeKind-GEN_FUNC_OFFSET;
	    FuncTable = (FuncTableType *) GenFuncTable;
	    break;
	default:
	    IPGlblEvalError = IE_ERR_FATAL_ERROR;
	    UpdateCharError("Undefined function - ", Root->NodeKind);
	    return TRUE;
    }

    if (FuncTable[FuncOffset].NumOfParam == ANY_PARAM_NUM)
	return FALSE;

    /* See if number of parameters is ok: */
    if ((Count = CountNumParameters(Root->Right)) !=
	FuncTable[FuncOffset].NumOfParam) {
	IPGlblEvalError = IE_ERR_NUM_PRM_MISMATCH;
	sprintf(IPGlblCharData, "Func %s - %d expected, %d found",
		FuncTable[FuncOffset].FuncName,
		FuncTable[FuncOffset].NumOfParam,
		Count);
	return TRUE;
    }

    /* See if type of parameters is consistent: */
    for (i = 0; i < Count; i++) {
	if (FuncTable[FuncOffset].ParamObjType[i] != ANY_EXPR &&
	    !(FuncTable[FuncOffset].ParamObjType[i] &
	      InptPrsrTypeCheck(FetchParameter(Root->Right, i, Count), 1))) {
	    sprintf(IPGlblCharData, "Func %s,%sparameter %d",
		    FuncTable[FuncOffset].FuncName,
		    IPGlblEvalError == IE_ERR_UNDEF_OBJECT ? " undefined " : " ",
		    i+1);
	    IPGlblEvalError = IE_ERR_TYPE_MISMATCH;
	    return TRUE;
	}
    }
    return FALSE;
}

/*****************************************************************************
*   Routine to free a tree - release all memory	allocated by it.	     *
*****************************************************************************/
void InptPrsrFreeTree(ParseTree *Root)
{
    char s[LINE_LEN];
    int ValidObject;

    if (!Root) return;

    ValidObject = Root->ObjType != NUMERIC_OBJ && Root->ObjType != UNDEF_OBJ;

    if (IS_FUNCTION(Root -> NodeKind)) {
	if (IS_NO_PARAM_FUNC(Root -> NodeKind))
	    MyExprFree(Root);
	else {
	    InptPrsrFreeTree(Root->Right);
	    if (ValidObject && strlen(Root->U.PObj->Name) == 0)
		MyFree((char *) Root->U.PObj, ALLOC_OBJECT);     /* Its temp.*/
	    MyExprFree(Root);
        }
	return;
    }

    switch (Root -> NodeKind) {
	case DIV:
	case MINUS:
	case MULT:
	case PLUS:
	case POWER:
	    InptPrsrFreeTree(Root->Right);
	    InptPrsrFreeTree(Root->Left);
	    if (ValidObject && strlen(Root->U.PObj->Name) == 0)
		MyFree((char *) Root->U.PObj, ALLOC_OBJECT);/* Its temporary.*/
	    MyExprFree(Root);
	    break;

	case UNARMINUS:
	    InptPrsrFreeTree(Root->Right);
	    if (ValidObject && strlen(Root->U.PObj->Name) == 0)
		MyFree((char *) Root->U.PObj, ALLOC_OBJECT);/* Its temporary.*/
	    MyExprFree(Root);
	    break;

	case COMMA:
	case COLON:
	case EQUAL:
  	    InptPrsrFreeTree(Root->Right);
	    InptPrsrFreeTree(Root->Left);
	    MyExprFree(Root);
	    break;

	case NUMBER:
	    MyExprFree(Root);
	    break;

	case PARAMETER:
	    if (Root->U.PObj) {
		/* No assign took place -  Its temporary. */
		if ((Root->U.PObj->ObjType == UNDEF_OBJ ||
		     strlen(Root->U.PObj->Name) == 0))
		    MyFree((char *) Root->U.PObj, ALLOC_OBJECT);
		else
		    Root->U.PObj->Count--;
	    }
	    MyExprFree(Root);
	    break;

	case STRING:
	    MyFree((char *) Root->U.PObj, ALLOC_OBJECT);/* The string object.*/
	    MyExprFree(Root);
	    break;

	case TOKENSTART:
	    MyExprFree(Root);
	    break;

	case OPENPARA:
	case CLOSPARA:
	    MyExprFree(Root);
	    break;

	default:
	    /*   We might free partially build (by InptPrsr) tree when error */
	    /* is detected, and such tree may have nodes with NodeKind>=1000.*/
	    if (Root->NodeKind >= 1000) {
		MyExprFree(Root);
	    }
	    else {
		sprintf(s, "%s (%d).\n",
		    "InptPrsrFreeTree: Undefined ParseTree type to free",
		    Root -> NodeKind);
		FatalError(s);
	    }
	    break;
    }
}

/*****************************************************************************
*   Routine to print a content of ROOT (using inorder traversal):	     *
* level	holds: 0 for lowest level +/-, 1 for *, /, 2 for ^ operations.	     *
* If *str = NULL print on stderr, else on given	string Str.		     *
*****************************************************************************/
void InptPrsrPrintTree(ParseTree *Root, char *Str)
{
    strcpy(IPGlblCharData, "");			   /* Make the string empty. */

    if (Str == NULL) {
	strcpy(IPGlblCharData, "");		   /* Make the string empty. */
	LocalPrintTree(Root, 0, IPGlblCharData);       /* Copy to local str. */
	fprintf(stderr, IPGlblCharData);		     /* and print... */
    }
    else {
	strcpy(Str, "");			   /* Make the string empty. */
	LocalPrintTree(Root, 0, Str); /* Dont print to stderr - copy to str. */
    }
}

/*****************************************************************************
*   Routine to print a content of ROOT (using inorder traversal):	     *
* level	holds: 0 for lowest level +/-, 1 for *, /, 2 for ^ operations.	     *
* It is assumed Str has at list LINE_LEN_LONG places to write the expression.*
*****************************************************************************/
static void LocalPrintTree(ParseTree *Root, int Level, char *Str)
{
    int	CloseFlag = FALSE, Len, i;

    if (!Root) return;
    i = Root->NodeKind / 100;

    if ((Len = strlen(Str)) > LINE_LEN_LONG * 2 / 3)/* Prevent from overflow.*/
	if (Str[Len-1] == '.')
	    return;			 /* "..." was allready concatenated. */
	else {
	    strcat(Str, "...");
	    return;
	}

#   ifdef DEBUG
	strcat(Str, "[");   /* Usefull to see ALL nestings - no preceedings. */
#   endif /* DEBUG */

    switch (i * 100) {
	case NUM_FUNC:
	    Level = 0;
	    CloseFlag = TRUE;
            strcat(Str, NumFuncTable[Root->NodeKind-NUM_FUNC_OFFSET].FuncName);
	    strcat(Str, "(");
	    break;

	case OBJ_FUNC:
	    Level = 0;
	    CloseFlag = TRUE;
            strcat(Str, ObjFuncTable[Root->NodeKind-OBJ_FUNC_OFFSET].FuncName);
	    strcat(Str, "(");
	    break;

	case GEN_FUNC:
	    Level = 0;
	    CloseFlag = TRUE;
            strcat(Str, GenFuncTable[Root->NodeKind-GEN_FUNC_OFFSET].FuncName);
	    strcat(Str, "(");
	    break;

	case OPERATORS:
	    switch (Root->NodeKind) {
		case DIV:
		    if (Level > 1) {
			strcat(Str, "(");
		        CloseFlag = TRUE;
		    }
		    Level = 1;					       /* Div Level. */
		    LocalPrintTree(Root->Left, Level, Str);
		    strcat(Str, "/");
		    break;

		case MINUS:
		    if (Level > 0) {
			strcat(Str, "(");
	        	CloseFlag = TRUE;
		    }
		    Level = 0;					     /* Minus Level. */
		    LocalPrintTree(Root->Left, Level, Str);
		    strcat(Str, "-");
		    break;

		case MULT:
		    if (Level > 1) {
			strcat(Str, "(");
		        CloseFlag = TRUE;
		    }
		    Level = 1;					       /* Mul Level. */
		    LocalPrintTree(Root->Left, Level, Str);
		    strcat(Str, "*");
		    break;

		case PLUS:
		    if (Level > 0) {
			strcat(Str, "(");
	        	CloseFlag = TRUE;
		    }
		    Level = 0;					      /* Plus Level. */
		    LocalPrintTree(Root->Left, Level, Str);
		    strcat(Str, "+");
		    break;

		case POWER:
		    Level = 2;					     /* Power Level. */
		    LocalPrintTree(Root->Left, Level, Str);
		    strcat(Str, "^");
		    break;

		case UNARMINUS:
		    strcat(Str, "(-");
		    Level = 0;
		    CloseFlag = TRUE;
		    break;

		case COMMA:
		    LocalPrintTree(Root->Left, Level, Str);
		    strcat(Str, ",");
		    break;

		case COLON:
		    LocalPrintTree(Root->Left, Level, Str);
		    strcat(Str, ":");
		    break;

		case EQUAL:
		    LocalPrintTree(Root->Left, Level, Str);
		    strcat(Str, "=");
		    break;

		case NUMBER:
		    sprintf(&Str[strlen(Str)], "%lg", Root->U.R);
		    break;

		case PARAMETER:
		    sprintf(&Str[strlen(Str)], "%s", Root->U.PObj->Name);
		    break;

		case STRING:
		    sprintf(&Str[strlen(Str)], "\"%s\"", Root->U.PObj->U.Str);
		    break;

		case OPENPARA:
		    strcat(Str, "(");
		    break;

		case CLOSPARA:
		    strcat(Str, ")");
		    break;

		case TOKENSTART:
		    break;

		default:
		    FatalError("LocalPrintTree: Undefined ParseTree type to print, exit");
            }
            break;

	default:
	    FatalError("LocalPrintTree: Undefined ParseTree type to print, exit");
    }
    LocalPrintTree(Root->Right, Level, Str);
    if (CloseFlag) strcat(Str, ")");

#   ifdef DEBUG
	strcat(Str, "]");   /* Usefull to see ALL nestings - no preceedings. */
#   endif /* DEBUG */
}

/*****************************************************************************
*   Routine to copy a parse tree - Generate brand new ParseTree structure    *
* but bind to non-temp variables if they are exists - their Name is not NULL *
*   This means that updating these objects in the copied tree, will affect   *
* these objects in the original tree.					     *
*****************************************************************************/
ParseTree *InptPrsrCopyTree(ParseTree *Root)
{
    ParseTree *NewRoot;

    if (Root == NULL) return NULL;

    NewRoot = MyExprMalloc();

    if (IS_FUNCTION(Root->NodeKind)) {		       /* All the functions. */
	NewRoot -> NodeKind = Root -> NodeKind;
	NewRoot -> ObjType = Root -> ObjType;
	NewRoot -> Right = InptPrsrCopyTree(Root -> Right);
	return NewRoot;
    }

    switch (Root->NodeKind) {
	case DIV:
	case MINUS:
	case MULT:
	case PLUS:
	case POWER:

	case COMMA:
	case COLON:
	case EQUAL:
	    NewRoot -> NodeKind = Root -> NodeKind;
	    NewRoot -> ObjType = Root -> ObjType;
	    NewRoot -> Right = InptPrsrCopyTree(Root -> Right);
	    NewRoot -> Left  = InptPrsrCopyTree(Root -> Left);
	    return NewRoot;

	case NUMBER:
	    NewRoot -> NodeKind = Root -> NodeKind;
	    NewRoot -> ObjType = Root -> ObjType;
	    NewRoot -> U.R = Root -> U.R;
	    return NewRoot;

	case PARAMETER:
	case STRING:
	    NewRoot -> NodeKind = Root -> NodeKind;
	    NewRoot -> ObjType = Root -> ObjType;
	    NewRoot -> U.PObj = Root -> U.PObj;	    /* Point on SAME object. */
	    NewRoot -> U.PObj -> Count++;    /* But increase its ref. count. */
	    return NewRoot;

	case TOKENSTART:
	    NewRoot -> NodeKind = Root -> NodeKind;
	    NewRoot -> ObjType = Root -> ObjType;
	    return NewRoot;

	default:
	    FatalError("InptPrsrCopyTree: Undefined ParseTree type to copy, exit\n");
    }
    return NULL;				    /* Makes warning silent. */
}

/*****************************************************************************
*  Routine to rebind a variable - given a tree, scan it and update each      *
* occurance of that variable to point to PObj.				     *
*****************************************************************************/
static void RebindVariable(ParseTree *Root, ObjectStruct *PObj)
{
    if (Root == NULL) return;

    if (IS_FUNCTION(Root->NodeKind)) {		       /* All the functions. */
	RebindVariable(Root -> Right, PObj);
	return;
    }

    switch (Root->NodeKind) {
	case UNARMINUS:
	    RebindVariable(Root -> Right, PObj);
	    return;

	case DIV:
	case MINUS:
	case MULT:
	case PLUS:
	case POWER:

	case COMMA:
	case COLON:
	case EQUAL:
	    RebindVariable(Root -> Right, PObj);
	    RebindVariable(Root -> Left, PObj);
	    return;

	case NUMBER:
	    return;

	case PARAMETER:
	case STRING:
	    if (strcmp(Root -> U.PObj -> Name, PObj -> Name) == 0) {
		/* I wish I could free that, but nesting loops might try */
		/* to free the same place n times... We will loose this  */
		/* variable place if it defined for the first time. Fix  */
		/* it if you really care...				 */
		/*
		if (IS_UNDEF_OBJ(Root -> U.PObj))
		    MyFree((char *) Root->U.PObj, ALLOC_OBJECT);
		*/
		Root -> U.PObj = PObj;
	    }
            return;

	case TOKENSTART:
	    return;

	default:
	    FatalError("RebindVariable: Undefined ParseTree type, exit\n");
    }
}

/*****************************************************************************
*   Routine to return evaluation error if happen one, zero elsewhere	     *
*****************************************************************************/
InptPrsrEvalErrType InptPrsrEvalError(char **Message)
{
    InptPrsrEvalErrType Temp;

    *Message = IPGlblCharData;
    Temp = IPGlblEvalError;
    IPGlblEvalError = IPE_NO_ERR;

    return Temp;
}