expr.h

Go to the documentation of this file.

/**********************************************************************
 *<
    FILE: expr.h

    DESCRIPTION: expression object include file.

    CREATED BY: Don Brittain

    HISTORY:

 *> Copyright (c) 1994, All Rights Reserved.
 **********************************************************************/

#pragma once

#include "maxheap.h"
#include "export.h"
#include "strclass.h"
#include "Point3.h"
#include "TabTypes.h"

#define SCALAR_EXPR     1   //!< A single floating point value.

#define VECTOR_EXPR     3   //!< An array of floating point values.


#define SCALAR_VAR      SCALAR_EXPR //!< A single floating point value.

#define VECTOR_VAR      VECTOR_EXPR //!< A Point3 value when passed to the eval() method.


class Expr;

typedef int (*ExprFunc)(Expr *e, float f);

class DllExport Inst: public MaxHeapOperators {
public:
    ExprFunc    func;
    float       sVal;
};

class ExprVar : public MaxHeapOperators {
public:
    MSTR        name;
    int     type;
    int     regNum;
};


typedef Tab<Inst>    InstTab;
typedef Tab<ExprVar> ExprVarTab;

class Expr: public MaxHeapOperators {
public:
    Expr()  { sValStk = vValStk = instStk = nextScalar = nextVector = 0; }
    ~Expr() { deleteAllVars(); }

    DllExport int       load(MCHAR *s);
    DllExport int       eval(float *ans, int sRegCt, float *sRegs, int vRegCt=0, Point3 *vRegs=NULL);
    int                 getExprType(void)   { return exprType; }
    MCHAR *             getExprStr(void)    { return origStr; }
    MCHAR *             getProgressStr(void){ return progressStr; }
    DllExport int       defVar(int type, MCHAR *name);
    DllExport int       getVarCount(int type);
    DllExport MCHAR *   getVarName(int type, int i);
    DllExport int       getVarRegNum(int type, int i);
    DllExport BOOL      deleteAllVars();
    DllExport BOOL      deleteVar(MCHAR *name);

// pseudo-private: (only to be used by the "instruction" functions
    void        setExprType(int type)   { exprType = type; }
    void        pushInst(ExprFunc fn, float f) 
                    { if(instStk >= inst.Count()) inst.SetCount(instStk+30); 
                    inst[instStk].func = fn; inst[instStk++].sVal = f; }
    void        pushSVal(float f)   { if(sValStk>=sVal.Count())sVal.SetCount(sValStk+10);sVal[sValStk++]=f; }
    float       popSVal()           { return sVal[--sValStk]; }
    void        pushVVal(Point3 &v) { if(vValStk>=vVal.Count())vVal.SetCount(vValStk+10);vVal[vValStk++]=v; }
    Point3 &    popVVal()           { return vVal[--vValStk]; }
    int         getSRegCt(void)     { return sRegCt; }
    float       getSReg(int index)  { return sRegPtr[index]; }
    int         getVRegCt(void)     { return vRegCt; }
    Point3 &    getVReg(int index)  { return vRegPtr[index]; }

    ExprVarTab  vars;           // named variables
private:
    MCHAR *     exprPtr;        // pointer to current str pos during parsing
    MCHAR *     exprStr;        // ptr to original expression string to parse
    MSTR        origStr;        // original expression string that was loaded
    MSTR        progressStr;    // string to hold part of expr successfully parsed
    int         sRegCt;         // actual number of scalar registers passed to "eval"
    float       *sRegPtr;       // pointer to the scalar register array
    int         vRegCt;         // actual number of vector registers passed to "eval"
    Point3      *vRegPtr;       // pointer to the vector register array
    int         exprType;       // expression type: SCALAR_EXPR or VECTOR_EXPR (set by load)

    int         sValStk;        // scalar value stack
    floatTab    sVal;
    int         vValStk;        // vector value stack
    Point3Tab   vVal;
    int         instStk;        // instruction stack
    InstTab     inst;

    int         nextScalar;     // next scalar slot
    int         nextVector;     // next vector slot

    friend      int yylex();
    friend      int yyerror(char *);
};

#define EXPR_NORMAL          0  //!< No problems, expression evaluated successfully.
#define EXPR_INST_OVERFLOW  -1  //!< Instruction stack overflow during parsing.
#define EXPR_UNKNOWN_TOKEN  -2  //!< Unknown function, const, or reg during parsing.
#define EXPR_TOO_MANY_VARS  -3  //!< Value stack overflow.
#define EXPR_TOO_MANY_REGS  -4  //!< Register array overflow, or reg number too big.
#define EXPR_CANT_EVAL      -5  //!< Function can't be evaluated with given arguments.
#define EXPR_CANT_PARSE     -6  //!< Expression can't be parsed syntactically.