Applied Aimee's patch for doing simple math in the build editor

5 files changed, 444 insertions, 0 deletions

diff --git a/linden/indra/llmath/CMakeLists.txt b/linden/indra/llmath/CMakeLists.txt
index 6a329fa..e5ec3e1 100644
--- a/linden/indra/llmath/CMakeLists.txt
+++ b/linden/indra/llmath/CMakeLists.txt
@@ -11,6 +11,8 @@ include_directories(
 
 set(llmath_SOURCE_FILES
     llbboxlocal.cpp
+    llcalc.cpp
+    llcalcparser.cpp
     llcamera.cpp
     llcoordframe.cpp
     llline.cpp
@@ -40,6 +42,8 @@ set(llmath_HEADER_FILES
     camera.h
     coordframe.h
     llbboxlocal.h
+    llcalc.h
+    llcalcparser.h
     llcamera.h
     llcoord.h
     llcoordframe.h
diff --git a/linden/indra/llmath/llcalc.cpp b/linden/indra/llmath/llcalc.cpp
new file mode 100644
index 0000000..feb072a
--- /dev/null
+++ b/linden/indra/llmath/llcalc.cpp
@@ -0,0 +1,155 @@
+/*
+ *  LLCalc.cpp
+ *  SecondLife
+ *
+ *  Created by Aimee Walton on 28/09/2008.
+ *  Copyright 2008 Aimee Walton.
+ *
+ */
+
+#include "linden_common.h"
+
+#include "llcalc.h"
+
+#include <boost/spirit/core.hpp>
+#include <boost/spirit/error_handling.hpp>
+
+#include "llcalcparser.h"
+#include "llmath.h"
+
+
+// Variable names for use in the build floater
+const char* LLCalc::X_POS = "X";
+const char* LLCalc::Y_POS = "Y";
+const char* LLCalc::Z_POS = "Z";
+const char* LLCalc::X_SCALE = "XS";
+const char* LLCalc::Y_SCALE = "YS";
+const char* LLCalc::Z_SCALE = "ZS";
+const char* LLCalc::X_ROT = "XR";
+const char* LLCalc::Y_ROT = "YR";
+const char* LLCalc::Z_ROT = "ZR";
+const char* LLCalc::HOLLOW = "HLW";
+const char* LLCalc::CUT_BEGIN = "CB";
+const char* LLCalc::CUT_END = "CE";
+const char* LLCalc::PATH_BEGIN = "PB";
+const char* LLCalc::PATH_END = "PE";
+const char* LLCalc::TWIST_BEGIN = "TB";
+const char* LLCalc::TWIST_END = "TE";
+const char* LLCalc::X_SHEAR = "XSH";
+const char* LLCalc::Y_SHEAR = "YSH";
+const char* LLCalc::X_TAPER = "XTP";
+const char* LLCalc::Y_TAPER = "YTP";
+const char* LLCalc::RADIUS_OFFSET = "ROF";
+const char* LLCalc::REVOLUTIONS = "REV";
+const char* LLCalc::SKEW = "SKW";
+const char* LLCalc::X_HOLE = "XHL";
+const char* LLCalc::Y_HOLE = "YHL";
+const char* LLCalc::TEX_U_SCALE = "TSU";
+const char* LLCalc::TEX_V_SCALE = "TSV";
+const char* LLCalc::TEX_U_OFFSET = "TOU";
+const char* LLCalc::TEX_V_OFFSET = "TOV";
+const char* LLCalc::TEX_ROTATION = "TROT";
+const char* LLCalc::TEX_TRANSPARENCY = "TRNS";
+const char* LLCalc::TEX_GLOW = "GLOW";
+
+
+LLCalc* LLCalc::sInstance = NULL;
+
+LLCalc::LLCalc() : mLastErrorPos(0)
+{
+//      mUserVariables = new calc_map_t;
+        mVariables = new calc_map_t;
+        mConstants = new calc_map_t;
+                
+        // Init table of constants
+        (*mConstants)["PI"] = F_PI;
+        (*mConstants)["TWO_PI"] = F_TWO_PI;
+        (*mConstants)["PI_BY_TWO"] = F_PI_BY_TWO;
+        (*mConstants)["SQRT2"] = F_SQRT2;
+        (*mConstants)["DEG_TO_RAD"] = DEG_TO_RAD;
+        (*mConstants)["RAD_TO_DEG"] = RAD_TO_DEG;
+        (*mConstants)["GRAVITY"] = GRAVITY;
+}
+
+LLCalc::~LLCalc()
+{
+        delete mConstants;
+        delete mVariables;
+//      delete mUserVariables;  
+}
+
+//static
+void LLCalc::cleanUp()
+{
+        delete sInstance;
+        sInstance = NULL;
+}
+
+//static
+LLCalc* LLCalc::getInstance()
+{
+    if (!sInstance)     sInstance = new LLCalc();
+        return sInstance;
+}
+
+void LLCalc::setVar(const std::string& name, const F32& value)
+{
+        (*mVariables)[name] = value;
+}
+
+void LLCalc::clearVar(const std::string& name)
+{
+        mVariables->erase(name);
+}
+
+void LLCalc::clearAllVariables()
+{
+        mVariables->clear();
+}
+
+/*
+void LLCalc::updateVariables(LLSD& vars)
+{
+        LLSD::map_iterator cIt = vars.beginMap();
+        for(; cIt != vars.endMap(); cIt++)
+        {
+                setVar(cIt->first, (F32)(LLSD::Real)cIt->second);
+        }
+}
+*/
+
+bool LLCalc::evalString(const std::string& expression, F32& result)
+{
+        using namespace boost::spirit;
+        
+        std::string expr_upper = expression;
+        LLStringUtil::toUpper(expr_upper);
+        
+        LLCalcParser calc(result, mConstants, mVariables);
+
+        mLastErrorPos = 0;
+        std::string::iterator start = expr_upper.begin();
+        parse_info<std::string::iterator> info;
+        
+        try
+        {
+                info = parse(start, expr_upper.end(), calc, space_p);
+                lldebugs << "Math expression: " << expression << " = " << result << llendl;
+        }
+        catch(parser_error<std::string, std::string::iterator> &e)
+        {
+                mLastErrorPos = e.where - expr_upper.begin();
+                
+                llinfos << "Calc parser exception: " << e.descriptor << " at " << mLastErrorPos << " in expression: " << expression << llendl;
+                return false;
+        }
+        
+        if (!info.full)
+        {
+                mLastErrorPos = info.stop - expr_upper.begin();
+                llinfos << "Unhandled syntax error at " << mLastErrorPos << " in expression: " << expression << llendl;
+                return false;
+        }
+        
+        return true;
+}
diff --git a/linden/indra/llmath/llcalc.h b/linden/indra/llmath/llcalc.h
new file mode 100644
index 0000000..a376895
--- /dev/null
+++ b/linden/indra/llmath/llcalc.h
@@ -0,0 +1,85 @@
+/*
+ *  LLCalc.h
+ *  SecondLife
+ *
+ *  Created by Aimee Walton on 28/09/2008.
+ *  Copyright 2008 Aimee Walton.
+ *
+ */
+
+#ifndef LL_CALC_H
+#define LL_CALC_H
+
+#include <map>
+#include <string>
+
+//#include "llsd.h"
+
+class LLCalc
+{
+public:
+        LLCalc();
+        ~LLCalc();
+
+        // Variable name constants
+        static const char* X_POS;
+        static const char* Y_POS;
+        static const char* Z_POS;
+        static const char* X_SCALE;
+        static const char* Y_SCALE;
+        static const char* Z_SCALE;
+        static const char* X_ROT;
+        static const char* Y_ROT;
+        static const char* Z_ROT;
+        static const char* HOLLOW;
+        static const char* CUT_BEGIN;
+        static const char* CUT_END;
+        static const char* PATH_BEGIN;
+        static const char* PATH_END;
+        static const char* TWIST_BEGIN;
+        static const char* TWIST_END;
+        static const char* X_SHEAR;
+        static const char* Y_SHEAR;
+        static const char* X_TAPER;
+        static const char* Y_TAPER;
+        static const char* RADIUS_OFFSET;
+        static const char* REVOLUTIONS;
+        static const char* SKEW;
+        static const char* X_HOLE;
+        static const char* Y_HOLE;
+        static const char* TEX_U_SCALE;
+        static const char* TEX_V_SCALE;
+        static const char* TEX_U_OFFSET;
+        static const char* TEX_V_OFFSET;
+        static const char* TEX_ROTATION;
+        static const char* TEX_TRANSPARENCY;
+        static const char* TEX_GLOW;
+
+        void    setVar(const std::string& name, const F32& value);
+        void    clearVar(const std::string& name);
+        void    clearAllVariables();
+//      void    updateVariables(LLSD& vars);
+
+        bool    evalString(const std::string& expression, F32& result);
+        std::string::size_type  getLastErrorPos()       { return mLastErrorPos; }
+        
+        static LLCalc* getInstance();
+        static void cleanUp();
+
+        typedef std::map<std::string, F32> calc_map_t;
+        
+private:
+        std::string::size_type  mLastErrorPos;
+        
+        calc_map_t*     mConstants;
+        calc_map_t*     mVariables;
+        
+        // *TODO: Add support for storing user defined variables, and stored functions.
+        //      Will need UI work, and a means to save them between sessions.
+//      calc_map_t* mUserVariables;
+        
+        // "There shall be only one"
+        static LLCalc*  sInstance;
+};
+
+#endif // LL_CALC_H
diff --git a/linden/indra/llmath/llcalcparser.cpp b/linden/indra/llmath/llcalcparser.cpp
new file mode 100644
index 0000000..1546c09
--- /dev/null
+++ b/linden/indra/llmath/llcalcparser.cpp
@@ -0,0 +1,45 @@
+/*
+ *  LLCalcParser.cpp
+ *  SecondLife
+ *
+ *  Created by Aimee Walton on 28/09/2008.
+ *  Copyright 2008 Aimee Walton.
+ *
+ */
+
+#include "linden_common.h"
+
+#include "llcalcparser.h"
+
+F32 LLCalcParser::lookup(const std::string::iterator& start, const std::string::iterator& end) const
+{
+        LLCalc::calc_map_t::iterator iter;
+
+        std::string name(start, end);
+        
+        if (mConstants)
+        {
+                iter = mConstants->find(name);
+                if (iter != mConstants->end())
+                {
+                        return (*iter).second;
+                }
+        }
+        else
+        {
+                // This should never happen!
+                boost::spirit::throw_(end, std::string("Missing constants table"));
+        }
+        
+        if (mVariables)
+        {
+                iter = mVariables->find(name);
+                if (iter != mVariables->end())
+                {
+                        return (*iter).second;
+                }
+        }
+        
+        boost::spirit::throw_(end, std::string("Unknown symbol " + name));
+        return 0.f;
+}
diff --git a/linden/indra/llmath/llcalcparser.h b/linden/indra/llmath/llcalcparser.h
new file mode 100644
index 0000000..c405b62
--- /dev/null
+++ b/linden/indra/llmath/llcalcparser.h
@@ -0,0 +1,155 @@
+/*
+ *  LLCalcParser.h
+ *  SecondLife
+ *
+ *  Created by Aimee Walton on 28/09/2008.
+ *  Copyright 2008 Aimee Walton.
+ *
+ */
+
+#ifndef LL_CALCPARSER_H
+#define LL_CALCPARSER_H
+
+#include <boost/spirit/attribute.hpp>
+#include <boost/spirit/core.hpp>
+#include <boost/spirit/error_handling.hpp>
+#include <boost/spirit/iterator/position_iterator.hpp>
+#include <boost/spirit/phoenix/binders.hpp>
+//#include <boost/spirit/symbols/symbols.hpp>
+#include <map>
+#include <string>
+
+#include "llcalc.h"
+#include "llmath.h"
+
+struct LLCalcParser : boost::spirit::grammar<LLCalcParser>
+{
+        LLCalcParser(F32& result, LLCalc::calc_map_t* constants, LLCalc::calc_map_t* vars) :
+                mResult(result), mConstants(constants), mVariables(vars) {};
+        
+        struct value_closure : boost::spirit::closure<value_closure, F32>
+        {
+                member1 value;
+        };
+        
+        template <typename ScannerT>
+        struct definition
+        {
+                // Rule declarations
+                boost::spirit::rule<ScannerT> statement, identifier;
+                boost::spirit::rule<ScannerT, value_closure::context_t> expression, term,
+                        power, 
+                        unary_expr, 
+                        factor, 
+                        /*unary_func, 
+                        /binary_func,*/ 
+                        group;
+
+                // start() should return the starting symbol
+                boost::spirit::rule<ScannerT> const& start() const { return statement; }
+                
+                definition(LLCalcParser const& self)
+                {
+                        using namespace boost::spirit;
+                        using namespace phoenix;
+                        
+                        assertion<std::string> assert_domain("Domain error");
+//                      assertion<std::string> assert_symbol("Unknown symbol");
+                        assertion<std::string> assert_syntax("Syntax error");
+                        
+                        identifier =
+                                lexeme_d[(alpha_p | '_') >> *(alnum_p | '_')]
+                        ;
+                        
+                        group =
+                                '(' >> expression[group.value = arg1] >> assert_syntax(ch_p(')'))
+                        ;
+                        
+                        /*unary_func =
+                                ((str_p("SIN") >> '(' >> expression[unary_func.value = bind(&sin)(DEG_TO_RAD * arg1)]) |
+                                 (str_p("COS") >> '(' >> expression[unary_func.value = bind(&cos)(DEG_TO_RAD * arg1)]) |
+                                 (str_p("TAN") >> '(' >> expression[unary_func.value = bind(&tan)(DEG_TO_RAD * arg1)]) |
+                                 (str_p("ASIN") >> '(' >> expression[unary_func.value = (bind(&asin)(arg1)) * RAD_TO_DEG]) |
+                                 (str_p("ACOS") >> '(' >> expression[unary_func.value = bind(&acos)(arg1) * RAD_TO_DEG]) |
+                                 (str_p("ATAN") >> '(' >> expression[unary_func.value = bind(&atan)(arg1) * RAD_TO_DEG]) |
+                                 (str_p("SQRT") >> '(' >> expression[unary_func.value = bind(&sqrt)(arg1)]) |
+                                 (str_p("LOG") >> '(' >> expression[unary_func.value = bind(&log)(arg1)]) |
+                                 (str_p("EXP") >> '(' >> expression[unary_func.value = bind(&exp)(arg1)]) |
+                                 (str_p("ABS") >> '(' >> expression[unary_func.value = bind(&fabs)(arg1)])
+                                ) >> assert_syntax(ch_p(')'))
+                        ;
+                        
+                        binary_func =
+                                ((str_p("ATAN2") >> '(' >> expression[binary_func.value = arg1] >> ',' >>
+                                  expression[binary_func.value = bind(&atan2)(binary_func.value, arg1) * RAD_TO_DEG]) |
+                                 (str_p("MIN") >> '(' >> expression[binary_func.value = arg1] >> ',' >> 
+                                  expression[binary_func.value = bind(&LLCalcParser::min)(self, binary_func.value, arg1)]) |
+                                 (str_p("MAX") >> '(' >> expression[binary_func.value = arg1] >> ',' >> 
+                                  expression[binary_func.value = bind(&LLCalcParser::max)(self, binary_func.value, arg1)])
+                                ) >> assert_syntax(ch_p(')'))
+                        ;*/
+                        
+                        // *TODO: Localisation of the decimal point?
+                        // Problem, LLLineEditor::postvalidateFloat accepts a comma when appropriate
+                        // for the current locale. However to do that here could clash with using
+                        // the comma as a separator when passing arguments to functions.
+                        factor =
+                                (ureal_p[factor.value = arg1] |
+                                 group[factor.value = arg1] |
+                                 /*unary_func[factor.value = arg1] |
+                                 binary_func[factor.value = arg1] |*/
+                                 // Lookup throws an Unknown Symbol error if it is unknown, while this works fine,
+                                 // would be "neater" to handle symbol lookup from here with an assertive parser.
+//                               constants_p[factor.value = arg1]|
+                                 identifier[factor.value = bind(&LLCalcParser::lookup)(self, arg1, arg2)]
+                                ) >>
+                                // Detect and throw math errors.
+                                assert_domain(eps_p(bind(&LLCalcParser::checkNaN)(self, factor.value)))
+                        ;
+
+                        unary_expr =
+                                !ch_p('+') >> factor[unary_expr.value = arg1] |
+                                '-' >> factor[unary_expr.value = -arg1]
+                        ;
+                        
+                        power =
+                                unary_expr[power.value = arg1] >>
+                                *('^' >> assert_syntax(unary_expr[power.value = bind(&powf)(power.value, arg1)]))
+                        ;
+                        
+                        term =
+                                power[term.value = arg1] >>
+                                *(('*' >> assert_syntax(power[term.value *= arg1])) |
+                                  ('/' >> assert_syntax(power[term.value /= arg1]))
+                                )
+                        ;
+                        
+                        expression =
+                                assert_syntax(term[expression.value = arg1]) >>
+                                *(('+' >> assert_syntax(term[expression.value += arg1])) |
+                                  ('-' >> assert_syntax(term[expression.value -= arg1]))
+                                )
+                        ;
+
+                        statement =
+                                !ch_p('=') >> ( expression )[var(self.mResult) = arg1] >> (end_p)
+                        ;
+                }
+        };
+        
+private:
+        // Member functions for semantic actions
+        F32     lookup(const std::string::iterator&, const std::string::iterator&) const;
+        F32 min(const F32& a, const F32& b) const { return llmin(a, b); }
+        F32 max(const F32& a, const F32& b) const { return llmax(a, b); }
+        
+        bool checkNaN(const F32& a) const { return !llisnan(a); }
+
+        LLCalc::calc_map_t* mConstants;
+        LLCalc::calc_map_t* mVariables;
+//      LLCalc::calc_map_t* mUserVariables;
+        
+        F32&            mResult;
+};
+
+#endif // LL_CALCPARSER_H