00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #ifndef ONCE_FPARSER_TYPES_H_
00013 #define ONCE_FPARSER_TYPES_H_
00014
00015 #include "fpconfig.h"
00016 #include <cstring>
00017
00018 #ifdef ONCE_FPARSER_H_
00019 # include <map>
00020 #endif
00021
00022 namespace FUNCTIONPARSERTYPES
00023 {
00024 enum OPCODE
00025 {
00026
00027
00028 cAbs,
00029 cAcos, cAcosh,
00030 cAsin, cAsinh,
00031 cAtan, cAtan2, cAtanh,
00032 cCbrt, cCeil,
00033 cCos, cCosh, cCot, cCsc,
00034 cEval,
00035 cExp, cExp2, cFloor, cIf, cInt, cLog, cLog10, cLog2, cMax, cMin,
00036 cPow, cSec, cSin, cSinh, cSqrt, cTan, cTanh,
00037 cTrunc,
00038
00039
00040
00041
00042 cImmed, cJump,
00043 cNeg, cAdd, cSub, cMul, cDiv, cMod,
00044 cEqual, cNEqual, cLess, cLessOrEq, cGreater, cGreaterOrEq,
00045 cNot, cAnd, cOr,
00046 cNotNot,
00047
00048 cDeg, cRad,
00049
00050 cFCall, cPCall,
00051
00052 #ifdef FP_SUPPORT_OPTIMIZER
00053 cFetch,
00054
00055 cPopNMov,
00056
00057
00058 cLog2by,
00059 #endif
00060 cAbsAnd,
00061 cAbsOr,
00062 cAbsNot,
00063 cAbsNotNot,
00064 cAbsIf,
00065
00066 cDup,
00067 cInv,
00068 cSqr,
00069 cRDiv,
00070 cRSub,
00071 cRSqrt,
00072
00073 cNop,
00074 VarBegin
00075 };
00076
00077 #ifdef ONCE_FPARSER_H_
00078 struct FuncDefinition
00079 {
00080 enum FunctionFlags
00081 {
00082 Enabled = 0x01,
00083 AngleIn = 0x02,
00084 AngleOut = 0x04,
00085 OkForInt = 0x08
00086 };
00087
00088 #ifdef FUNCTIONPARSER_SUPPORT_DEBUG_OUTPUT
00089 const char name[8];
00090 #else
00091 struct name { } name;
00092 #endif
00093 unsigned params : 8;
00094 unsigned flags : 8;
00095
00096 inline bool enabled() const { return flags != 0; }
00097 inline bool okForInt() const { return (flags & OkForInt) != 0; }
00098 };
00099
00100 #ifndef FP_DISABLE_EVAL
00101 # define FP_EVAL_FUNCTION_ENABLED \
00102 FuncDefinition::Enabled | FuncDefinition::OkForInt
00103 #else
00104 # define FP_EVAL_FUNCTION_ENABLED 0
00105 #endif
00106 #ifdef FUNCTIONPARSER_SUPPORT_DEBUG_OUTPUT
00107 # define FP_FNAME(n) n
00108 #else
00109 # define FP_FNAME(n) {}
00110 #endif
00111
00112
00113
00114 const FuncDefinition Functions[]=
00115 {
00116 { FP_FNAME("abs"), 1,
00117 FuncDefinition::Enabled | FuncDefinition::OkForInt },
00118 { FP_FNAME("acos"), 1,
00119 FuncDefinition::Enabled | FuncDefinition::AngleOut },
00120 { FP_FNAME("acosh"), 1,
00121 FuncDefinition::Enabled | FuncDefinition::AngleOut },
00122 { FP_FNAME("asin"), 1,
00123 FuncDefinition::Enabled | FuncDefinition::AngleOut },
00124 { FP_FNAME("asinh"), 1,
00125 FuncDefinition::Enabled | FuncDefinition::AngleOut },
00126 { FP_FNAME("atan"), 1,
00127 FuncDefinition::Enabled | FuncDefinition::AngleOut },
00128 { FP_FNAME("atan2"), 2,
00129 FuncDefinition::Enabled | FuncDefinition::AngleOut },
00130 { FP_FNAME("atanh"), 1, FuncDefinition::Enabled },
00131 { FP_FNAME("cbrt"), 1, FuncDefinition::Enabled },
00132 { FP_FNAME("ceil"), 1, FuncDefinition::Enabled },
00133 { FP_FNAME("cos"), 1,
00134 FuncDefinition::Enabled | FuncDefinition::AngleIn },
00135 { FP_FNAME("cosh"), 1,
00136 FuncDefinition::Enabled | FuncDefinition::AngleIn },
00137 { FP_FNAME("cot"), 1,
00138 FuncDefinition::Enabled | FuncDefinition::AngleIn },
00139 { FP_FNAME("csc"), 1,
00140 FuncDefinition::Enabled | FuncDefinition::AngleIn },
00141 { FP_FNAME("eval"), 0, FP_EVAL_FUNCTION_ENABLED },
00142 { FP_FNAME("exp"), 1, FuncDefinition::Enabled },
00143 { FP_FNAME("exp2"), 1, FuncDefinition::Enabled },
00144 { FP_FNAME("floor"), 1, FuncDefinition::Enabled },
00145 { FP_FNAME("if"), 0,
00146 FuncDefinition::Enabled | FuncDefinition::OkForInt },
00147 { FP_FNAME("int"), 1, FuncDefinition::Enabled },
00148 { FP_FNAME("log"), 1, FuncDefinition::Enabled },
00149 { FP_FNAME("log10"), 1, FuncDefinition::Enabled },
00150 { FP_FNAME("log2"), 1, FuncDefinition::Enabled },
00151 { FP_FNAME("max"), 2,
00152 FuncDefinition::Enabled | FuncDefinition::OkForInt },
00153 { FP_FNAME("min"), 2,
00154 FuncDefinition::Enabled | FuncDefinition::OkForInt },
00155 { FP_FNAME("pow"), 2, FuncDefinition::Enabled },
00156 { FP_FNAME("sec"), 1,
00157 FuncDefinition::Enabled | FuncDefinition::AngleIn },
00158 { FP_FNAME("sin"), 1,
00159 FuncDefinition::Enabled | FuncDefinition::AngleIn },
00160 { FP_FNAME("sinh"), 1,
00161 FuncDefinition::Enabled | FuncDefinition::AngleIn },
00162 { FP_FNAME("sqrt"), 1,
00163 FuncDefinition::Enabled },
00164 { FP_FNAME("tan"), 1,
00165 FuncDefinition::Enabled | FuncDefinition::AngleIn },
00166 { FP_FNAME("tanh"), 1,
00167 FuncDefinition::Enabled | FuncDefinition::AngleIn },
00168 { FP_FNAME("trunc"), 1,
00169 FuncDefinition::Enabled }
00170 };
00171 #undef FP_FNAME
00172
00173 struct NamePtr
00174 {
00175 const char* name;
00176 unsigned nameLength;
00177
00178 NamePtr(const char* n, unsigned l): name(n), nameLength(l) {}
00179
00180 inline bool operator==(const NamePtr& rhs) const
00181 {
00182 return nameLength == rhs.nameLength
00183 && std::memcmp(name, rhs.name, nameLength) == 0;
00184 }
00185 inline bool operator<(const NamePtr& rhs) const
00186 {
00187 for(unsigned i = 0; i < nameLength; ++i)
00188 {
00189 if(i == rhs.nameLength) return false;
00190 const char c1 = name[i], c2 = rhs.name[i];
00191 if(c1 < c2) return true;
00192 if(c2 < c1) return false;
00193 }
00194 return nameLength < rhs.nameLength;
00195 }
00196 };
00197
00198 template<typename Value_t>
00199 struct NameData
00200 {
00201 enum DataType { CONSTANT, UNIT, FUNC_PTR, PARSER_PTR, VARIABLE };
00202 DataType type;
00203 unsigned index;
00204 Value_t value;
00205
00206 NameData(DataType t, unsigned v) : type(t), index(v), value() { }
00207 NameData(DataType t, Value_t v) : type(t), index(), value(v) { }
00208 NameData() { }
00209 };
00210
00211 template<typename Value_t>
00212 class namePtrsType: public
00213 std::map<
00214 FUNCTIONPARSERTYPES::NamePtr,
00215 FUNCTIONPARSERTYPES::NameData<Value_t>
00216 >
00217 {
00218 };
00219
00220 const unsigned FUNC_AMOUNT = sizeof(Functions)/sizeof(Functions[0]);
00221 #endif // ONCE_FPARSER_H_
00222 }
00223
00224 #ifdef ONCE_FPARSER_H_
00225 #include <vector>
00226
00227 template<typename Value_t>
00228 struct FunctionParserBase<Value_t>::Data
00229 {
00230 unsigned referenceCounter;
00231
00232 unsigned numVariables;
00233 std::string variablesString;
00234 FUNCTIONPARSERTYPES::namePtrsType<Value_t> namePtrs;
00235
00236 struct FuncPtrData
00237 {
00238 union
00239 {
00240 FunctionPtr funcPtr;
00241 FunctionParserBase<Value_t>* parserPtr;
00242 };
00243 unsigned params;
00244 };
00245
00246 std::vector<FuncPtrData> FuncPtrs;
00247 std::vector<FuncPtrData> FuncParsers;
00248
00249 std::vector<unsigned> ByteCode;
00250 std::vector<Value_t> Immed;
00251 #ifndef FP_USE_THREAD_SAFE_EVAL
00252 std::vector<Value_t> Stack;
00253
00254
00255 #endif
00256 unsigned StackSize;
00257
00258 Data();
00259 Data(const Data&);
00260 Data& operator=(const Data&);
00261 ~Data();
00262 };
00263 #endif
00264
00265 #include "fpaux.h"
00266
00267 #endif