source: golgotha/src/max_plugin/sdk_inc/expr.h @ 80

Last change on this file since 80 was 80, checked in by Sam Hocevar, 11 years ago
  • Adding the Golgotha source code. Not sure what's going to be interesting in there, but since it's all public domain, there's certainly stuff to pick up.
  • Property svn:keywords set to Id
File size: 3.7 KB
Line 
1/**********************************************************************
2 *<
3        FILE: expr.h
4
5        DESCRIPTION: expression object include file.
6
7        CREATED BY: Don Brittain
8
9        HISTORY:
10
11 *>     Copyright (c) 1994, All Rights Reserved.
12 **********************************************************************/
13
14#ifndef _EXPR_H_
15
16#define _EXPR_H_
17
18#include "export.h"
19
20#define SCALAR_EXPR             1
21#define VECTOR_EXPR             3
22
23#define SCALAR_VAR              SCALAR_EXPR
24#define VECTOR_VAR              VECTOR_EXPR
25
26class Expr;
27
28typedef int (*ExprFunc)(Expr *e, float f);
29
30class DllExport Inst {
31public:
32    ExprFunc    func;
33    float               sVal;
34};
35
36class ExprVar {
37public:
38        TSTR            name;
39        int                     type;
40        int                     regNum;
41};
42
43MakeTab(float);
44MakeTab(Point3);
45MakeTab(Inst);
46MakeTab(ExprVar);
47
48class Expr {
49public:
50        Expr()  { sValStk = vValStk = instStk = nextScalar = nextVector = 0; }
51        ~Expr() { deleteAllVars(); }
52
53        DllExport int           load(char *s);
54        DllExport int           eval(float *ans, int sRegCt, float *sRegs, int vRegCt=0, Point3 *vRegs=NULL);
55        int                                     getExprType(void)       { return exprType; }
56        TCHAR *                         getExprStr(void)        { return origStr; }
57        TCHAR *                         getProgressStr(void){ return progressStr; }
58        DllExport int           defVar(int type, TCHAR *name);
59        DllExport int           getVarCount(int type);
60        DllExport TCHAR *       getVarName(int type, int i);
61        DllExport int           getVarRegNum(int type, int i);
62        DllExport BOOL          deleteAllVars();
63        DllExport BOOL          deleteVar(TCHAR *name);
64
65// pseudo-private: (only to be used by the "instruction" functions
66        void            setExprType(int type)   { exprType = type; }
67        void            pushInst(ExprFunc fn, float f)
68                                        { if(instStk >= inst.Count()) inst.SetCount(instStk+30);
69                                        inst[instStk].func = fn; inst[instStk++].sVal = f; }
70        void            pushSVal(float f)       { if(sValStk>=sVal.Count())sVal.SetCount(sValStk+10);sVal[sValStk++]=f; }
71        float           popSVal()                       { return sVal[--sValStk]; }
72        void            pushVVal(Point3 &v)     { if(vValStk>=vVal.Count())vVal.SetCount(vValStk+10);vVal[vValStk++]=v; }
73        Point3 &        popVVal()                       { return vVal[--vValStk]; }
74        int                     getSRegCt(void)         { return sRegCt; }
75        float           getSReg(int index)      { return sRegPtr[index]; }
76        int                     getVRegCt(void)         { return vRegCt; }
77        Point3 &        getVReg(int index)      { return vRegPtr[index]; }
78
79        ExprVarTab      vars;                   // named variables
80private:
81        TCHAR *         exprPtr;                // pointer to current str pos during parsing
82        TCHAR *         exprStr;                // ptr to original expression string to parse
83        TSTR            origStr;                // original expression string that was loaded
84        TSTR            progressStr;    // string to hold part of expr successfully parsed
85        int                     sRegCt;                 // actual number of scalar registers passed to "eval"
86        float           *sRegPtr;               // pointer to the scalar register array
87        int                     vRegCt;                 // actual number of vector registers passed to "eval"
88        Point3          *vRegPtr;               // pointer to the vector register array
89        int                     exprType;               // expression type: SCALAR_EXPR or VECTOR_EXPR (set by load)
90
91        int                     sValStk;                // scalar value stack
92        floatTab        sVal;
93        int                     vValStk;                // vector value stack
94        Point3Tab       vVal;
95        int                     instStk;                // instruction stack
96        InstTab         inst;
97
98        int                     nextScalar;             // next scalar slot
99        int                     nextVector;             // next vector slot
100
101        friend          yylex();
102        friend          yyerror(char *);
103};
104
105#define EXPR_NORMAL                      0
106#define EXPR_INST_OVERFLOW      -1      // instruction stack overflow during parsing
107#define EXPR_UNKNOWN_TOKEN      -2  // unknown function, const, or reg during parsing
108#define EXPR_TOO_MANY_VARS      -3      // value stack overflow
109#define EXPR_TOO_MANY_REGS      -4      // register array overflow, or reg number too big
110#define EXPR_CANT_EVAL          -5      // function can't be evaluated with given arg
111#define EXPR_CANT_PARSE         -6      // expression can't be parsed (syntactically)
112
113#endif // _EXPR_H_
Note: See TracBrowser for help on using the repository browser.