[Planeshift-cvs] CVS: planeshift/src/common/util fpconfig.h,NONE,1.1 fpoptimizer.cpp,NONE,1.1 fptype

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/planeshift/planeshift/src/common/util
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv31358/src/common/util

Modified Files:
	fparser.cpp fparser.h fparser.txt 
Added Files:
	fpconfig.h fpoptimizer.cpp fptypes.h 
Log Message:
Updated fparser to latest version.

--- NEW FILE: fpconfig.h ---
//==============================
// Function parser v2.8 by Warp
//==============================

// Configuration file
// ------------------

// NOTE:
// This file is for the internal use of the function parser only.
// You don't need to include this file in your source files, just
// include "fparser.hh".

/*
 Comment out the following line if your compiler supports the (non-standard)
 asinh, acosh and atanh functions and you want them to be supported. If
 you are not sure, just leave it (those function will then not be supported).
*/
#define NO_ASINH

/*
 Uncomment the following line to disable the eval() function if it could
 be too dangerous in the target application.
 Note that even though the maximum recursion level of eval() is limited,
 it is still possible to write functions using it which take enormous
 amounts of time to evaluate even though the maximum recursion is never
 reached. This may be undesirable in some applications.
*/
//#define DISABLE_EVAL

/*
 Maximum recursion level for eval() calls:
*/
#define EVAL_MAX_REC_LEVEL 1000

/*
 Comment out the following lines out if you are not going to use the
 optimizer and want a slightly smaller library. The Optimize() method
 can still be called, but it will not do anything.
 If you are unsure, just leave it. It won't slow down the other parts of
 the library.
*/
#ifndef NO_SUPPORT_OPTIMIZER
#define SUPPORT_OPTIMIZER
#endif

/*
 Epsilon value used with the comparison operators (must be non-negative):
 (Comment it out if you don't want to use epsilon in comparisons. Might
 lead to marginally faster evaluation of the comparison operators, but
 can introduce inaccuracies in comparisons.)
*/
#define FP_EPSILON 1e-14

--- NEW FILE: fpoptimizer.cpp ---
//===========================================
// Function parser v2.8 optimizer by Bisqwit
//===========================================

/*
 NOTE!
 ----
 Everything that goes into the #ifndef SUPPORT_OPTIMIZER part
 (ie. when SUPPORT_OPTIMIZER is not defined) should be put in
 the end of fparser.cc file, not in this file.

 Everything in this file should be inside the #ifdef SUPPORT_OPTIMIZER
 block (except the #include "fpconfig.hh" line).
*/

#include "fpconfig.h"

#ifdef SUPPORT_OPTIMIZER
[...1806 lines suppressed...]

    delete[] data->ByteCode; data->ByteCode = 0;
    if((data->ByteCodeSize = byteCode.size()) > 0)
    {
        data->ByteCode = new unsigned[data->ByteCodeSize];
        for(unsigned a=0; a<byteCode.size(); ++a)
            data->ByteCode[a] = byteCode[a];
    }

    delete[] data->Immed; data->Immed = 0;
    if((data->ImmedSize = immed.size()) > 0)
    {
        data->Immed = new double[data->ImmedSize];
        for(unsigned a=0; a<immed.size(); ++a)
            data->Immed[a] = immed[a];
    }
}

#endif // #ifdef SUPPORT_OPTIMIZER

--- NEW FILE: fptypes.h ---
//==============================
// Function parser v2.8 by Warp
//==============================

// NOTE:
// This file contains only internal types for the function parser library.
// You don't need to include this file in your code. Include "fparser.hh"
// only.

namespace FUNCTIONPARSERTYPES
{
// The functions must be in alphabetical order:
    enum OPCODE
    {
        cAbs, cAcos,
#ifndef NO_ASINH
        cAcosh,
#endif
        cAsin,
#ifndef NO_ASINH
        cAsinh,
#endif
        cAtan,
        cAtan2,
#ifndef NO_ASINH
        cAtanh,
#endif
        cCeil, cCos, cCosh, cCot, cCsc,
#ifndef DISABLE_EVAL
        cEval,
#endif
        cExp, cFloor, cIf, cInt, cLog, cLog10, cMax, cMin,
        cSec, cSin, cSinh, cSqrt, cTan, cTanh,

// These do not need any ordering:
        cImmed, cJump,
        cNeg, cAdd, cSub, cMul, cDiv, cMod, cPow,
        cEqual, cNEqual, cLess, cLessOrEq, cGreater, cGreaterOrEq,
        cNot, cAnd, cOr,

        cDeg, cRad,

        cFCall, cPCall,

#ifdef SUPPORT_OPTIMIZER
        cVar, cDup, cInv,
#endif

        VarBegin
    };

    struct FuncDefinition
    {
        const char* name;
        unsigned nameLength;
        unsigned opcode;
        unsigned params;

        // This is basically strcmp(), but taking 'nameLength' as string
        // length (not ending '\0'):
        bool operator<(const FuncDefinition& rhs) const
        {
            for(unsigned i = 0; i < nameLength; ++i)
            {
                if(i == rhs.nameLength) return false;
                const char c1 = name[i], c2 = rhs.name[i];
                if(c1 < c2) return true;
                if(c2 < c1) return false;
            }
            return nameLength < rhs.nameLength;
        }
    };

// This list must be in alphabetical order:
    const FuncDefinition Functions[]=
    {
        { "abs", 3, cAbs, 1 },
        { "acos", 4, cAcos, 1 },
#ifndef NO_ASINH
        { "acosh", 5, cAcosh, 1 },
#endif
        { "asin", 4, cAsin, 1 },
#ifndef NO_ASINH
        { "asinh", 5, cAsinh, 1 },
#endif
        { "atan", 4, cAtan, 1 },
        { "atan2", 5, cAtan2, 2 },
#ifndef NO_ASINH
        { "atanh", 5, cAtanh, 1 },
#endif
        { "ceil", 4, cCeil, 1 },
        { "cos", 3, cCos, 1 },
        { "cosh", 4, cCosh, 1 },
        { "cot", 3, cCot, 1 },
        { "csc", 3, cCsc, 1 },
#ifndef DISABLE_EVAL
        { "eval", 4, cEval, 0 },
#endif
        { "exp", 3, cExp, 1 },
        { "floor", 5, cFloor, 1 },
        { "if", 2, cIf, 0 },
        { "int", 3, cInt, 1 },
        { "log", 3, cLog, 1 },
        { "log10", 5, cLog10, 1 },
        { "max", 3, cMax, 2 },
        { "min", 3, cMin, 2 },
        { "sec", 3, cSec, 1 },
        { "sin", 3, cSin, 1 },
        { "sinh", 4, cSinh, 1 },
        { "sqrt", 4, cSqrt, 1 },
        { "tan", 3, cTan, 1 },
        { "tanh", 4, cTanh, 1 }
    };
}

Index: fparser.cpp
===================================================================
RCS file: /cvsroot/planeshift/planeshift/src/common/util/fparser.cpp,v
retrieving revision 1.9
retrieving revision 1.10
diff -C2 -d -r1.9 -r1.10
*** fparser.cpp	2 Sep 2005 01:35:50 -0000	1.9
--- fparser.cpp	20 Nov 2005 22:39:48 -0000	1.10
***************
*** 1,144 ****
- /**************************************************************************
- *
- Copyright © 2003 Juha Nieminen, Joel Yliluoma
- 
-   This library is distributed under two distinct usage licenses depending
- on the software ("Software" below) which uses the Function Parser library
- ("Library" below).
-   The reason for having two distinct usage licenses is to make the library
- compatible with the GPL license while still being usable in other non-GPL
- (even commercial) software.
[...3768 lines suppressed...]
!             data->Immed[a] = immed[a];
!     }
! }
! 
! 
! #else /* !SUPPORT_OPTIMIZER */
! 
! /* keep the linker happy */
! void FunctionParser::MakeTree(CodeTree *) const {}
  void FunctionParser::Optimize()
  {
--- 1347,1354 ----

! #ifndef SUPPORT_OPTIMIZER
! void FunctionParser::MakeTree(void *) const {}
  void FunctionParser::Optimize()
  {

Index: fparser.h
===================================================================
RCS file: /cvsroot/planeshift/planeshift/src/common/util/fparser.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** fparser.h	31 Aug 2005 19:08:07 -0000	1.3
--- fparser.h	20 Nov 2005 22:39:48 -0000	1.4
***************
*** 1,6 ****
  /***************************************************************************\
! |* Function parser v2.7 by Warp                                            *|
  |* ----------------------------                                            *|
  |* Parses and evaluates the given function with the given variable values. *|
  |*                                                                         *|
  \***************************************************************************/
--- 1,7 ----
  /***************************************************************************\
! |* Function parser v2.8 by Warp                                            *|
  |* ----------------------------                                            *|
  |* Parses and evaluates the given function with the given variable values. *|
+ |* See fparser.txt for details.                                            *|
  |*                                                                         *|
  \***************************************************************************/
***************
*** 29,33 ****

!     size_t Parse(const std::string& Function, const std::string& Vars,
                bool useDegrees = false);
      const char* ErrorMsg() const;
--- 30,34 ----

!     int Parse(const std::string& Function, const std::string& Vars,
                bool useDegrees = false);
      const char* ErrorMsg() const;
***************
*** 77,84 ****
          unsigned referenceCounter;

!         size_t varAmount;
          bool useDegreeConversion;

!         typedef std::map<std::string, size_t> VarMap_t;
          VarMap_t Variables;

--- 78,85 ----
          unsigned referenceCounter;

!         int varAmount;
          bool useDegreeConversion;

!         typedef std::map<std::string, unsigned> VarMap_t;
          VarMap_t Variables;

***************
*** 89,93 ****
          struct FuncPtrData
          {
!             FunctionPtr ptr; size_t params;
              FuncPtrData(FunctionPtr p, unsigned par): ptr(p), params(par) {}
          };
--- 90,94 ----
          struct FuncPtrData
          {
!             FunctionPtr ptr; unsigned params;
              FuncPtrData(FunctionPtr p, unsigned par): ptr(p), params(par) {}
          };
***************
*** 97,106 ****
          std::vector<FunctionParser*> FuncParsers;

!         size_t* ByteCode;
!         size_t ByteCodeSize;
          double* Immed;
!         size_t ImmedSize;
          double* Stack;
!         size_t StackSize;

          Data();
--- 98,107 ----
          std::vector<FunctionParser*> FuncParsers;

!         unsigned* ByteCode;
!         unsigned ByteCodeSize;
          double* Immed;
!         unsigned ImmedSize;
          double* Stack;
!         unsigned StackSize;

          Data();
***************
*** 112,119 ****

      Data* data;

      // Temp data needed in Compile():
!     size_t StackPtr;
!     std::vector<size_t>* tempByteCode;
      std::vector<double>* tempImmed;

--- 113,121 ----

      Data* data;
+     unsigned evalRecursionLevel;

      // Temp data needed in Compile():
!     unsigned StackPtr;
!     std::vector<unsigned>* tempByteCode;
      std::vector<double>* tempImmed;

***************
*** 121,125 ****
  // Private methods:
  // ---------------
!     inline void copyOnWrite();

--- 123,127 ----
  // Private methods:
  // ---------------
!     void copyOnWrite();

***************
*** 130,151 ****
                                                  const Data::VarMap_t&) const;
      Data::ConstMap_t::const_iterator FindConstant(const char*) const;
!     size_t CheckSyntax(const char*);
      bool Compile(const char*);
      bool IsVariable(int);
!     void AddCompiledByte(size_t);
      void AddImmediate(double);
      void AddFunctionOpcode(unsigned);
      inline void incStackPtr();
!     size_t Compileif (const char*, size_t);
!     size_t CompileFunctionParams(const char*, size_t, size_t);
!     size_t CompileElement(const char*, size_t);
!     size_t CompilePow(const char*, size_t);
!     size_t CompileUnaryMinus(const char*, size_t);
!     size_t CompileMult(const char*, size_t);
!     size_t CompileAddition(const char*, size_t);
!     size_t CompileComparison(const char*, size_t);
!     size_t CompileAnd(const char*, size_t);
!     size_t CompileOr(const char*, size_t);
!     size_t CompileExpression(const char*, size_t, bool=false);

--- 132,153 ----
                                                  const Data::VarMap_t&) const;
      Data::ConstMap_t::const_iterator FindConstant(const char*) const;
!     int CheckSyntax(const char*);
      bool Compile(const char*);
      bool IsVariable(int);
!     void AddCompiledByte(unsigned);
      void AddImmediate(double);
      void AddFunctionOpcode(unsigned);
      inline void incStackPtr();
!     int CompileIf(const char*, int);
!     int CompileFunctionParams(const char*, int, unsigned);
!     int CompileElement(const char*, int);
!     int CompilePow(const char*, int);
!     int CompileUnaryMinus(const char*, int);
!     int CompileMult(const char*, int);
!     int CompileAddition(const char*, int);
!     int CompileComparison(const char*, int);
!     int CompileAnd(const char*, int);
!     int CompileOr(const char*, int);
!     int CompileExpression(const char*, int, bool=false);

Index: fparser.txt
===================================================================
RCS file: /cvsroot/planeshift/planeshift/src/common/util/fparser.txt,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** fparser.txt	29 Dec 2004 08:21:31 -0000	1.1
--- fparser.txt	20 Nov 2005 22:39:48 -0000	1.2
***************
*** 1,777 ****
!   Function parser for C++  v2.7 by Warp.
!   =====================================
! 
!   Optimization code contributed by Bisqwit (http://iki.fi/bisqwit/)
! 
! 
!   The usage license of this library is located at the end of this text file.
! 
! 
! 
[...1542 lines suppressed...]
! to the program.
!   "Heavily dependent" means that the program depends so much on the library
! that without it the functionality of the program would be seriously
! degraded or the program would even become completely non-functional.
! 
!   In other words: If the program does not depend heavily on the library,
! that is, the library only provides a minor secondary feature which could
! be removed without the program being degraded in any considerable way,
! then it's OK to use the library in the commercial program.
!   If, however, the program depends so heavily on the library that
! removing it would make the program non-functional or degrade its
! functionality considerably, then it's NOT OK to use the library.
! 
!   The ideology behind this is that it's not fair to use a free library
! as a base for a commercial program, but it's fair if the library is
! just a minor, unimportant extra.
! 
!   If you are going to ask me for permission to use the library in a
! commercial program, please describe the feature which the library will
! be providing and how important it is to the program.

[Planeshift-cvs] CVS: planeshift/src/common/util fpconfig.h,NONE,1.1 fpoptimizer.cpp,NONE,1.1 fptype

[Planeshift-cvs] CVS: planeshift/src/common/util fpconfig.h,NONE,1.1 fpoptimizer.cpp,NONE,1.1 fptypes.h,NONE,1.1 fparser.cpp,1.9,1.10 fparser.h,1.3,1.4 fparser.txt,1.1,1.2