docs/html/_local_2src_2_pika_script_8h_source.html

 #ifndef PikaScript_h

 #define PikaScript_h


 #include "assert.h" // Note: I always include assert.h like this so that you can override it with a "local" file.

 #include <vector>

 #include <map>

 #include <string>

 #include <functional>


 // These are defined as macros in the Windows headers and collide with some of our "proper" C++ definitions. Sorry, it

 // just ain't right to use global macros in C++. I #undef them. Include PikaScript.h before the Windows headers if you

 // need these macros (or push and pop their definitions before and after including this header with #pragma push_macro

 // and pop_macro).


 #undef VOID

 #undef ERROR


 namespace Pika {


 #if (PIKA_UNICODE)

         #define STR(s) L##s

         #define PIKA_SCRIPT_VERSION L"0.942"

 #else

         #define STR(x) x

         #define PIKA_SCRIPT_VERSION "0.942"

 #endif


 typedef unsigned char uchar;

 typedef unsigned int uint;

 typedef unsigned long ulong;


 template<class S> std::string toStdString(const S& s);

 template<class S> ulong hexToLong(typename S::const_iterator& p, const typename S::const_iterator& e);

 template<class S> long stringToLong(typename S::const_iterator& p, const typename S::const_iterator& e);

 template<class S, typename T> S intToString(T i, int radix = 10, int minLength = 1);

 template<class S> double stringToDouble(typename S::const_iterator& p, const typename S::const_iterator& e);

 template<class S> bool stringToDouble(const S& s, double& d);

 template<class S> S doubleToString(double d, int precision = 14);

 template<class S> S unescape(typename S::const_iterator& p, const typename S::const_iterator& e);

 template<class S> S escape(const S& s);


 template<class C, class A0, class R> class bound_mem_fun_t : public std::unary_function<A0, R> {

         public:         bound_mem_fun_t(R (C::*m)(A0), C* o) : m(m), o(o) { }

         public:         R operator()(A0 a) const { return (o->*m)(a); }

         protected:      R (C::*m)(A0);

         protected:      C* o;

 };


 template<class C, class A0, class R> inline bound_mem_fun_t<C, A0, R> bound_mem_fun(R (C::*m)(A0), C* o) {

         return bound_mem_fun_t<C, A0, R>(m, o);

 }


 template<class T> class Dumb { };


 template<class S> class Exception : public std::exception {

         public:         Exception(const S& error) : error(error) { }

         public:         virtual S getError() const throw() { return error; }

         public:         virtual const char *what() const throw() { return (converted = toStdString(error)).c_str(); }

         public:         virtual ~Exception() throw() { }                                                                                                                                                // (GCC requires explicit destructor with one that has throw().)

         protected:      S error;

         protected:      mutable std::string converted;

 };


 template<class S> class STLValue : public S {


         public:         typedef S String;

         public:         typedef typename S::value_type Char;


         public:         STLValue() { }

         public:         STLValue(double d) : S(doubleToString<S>(d)) { }

         public:         STLValue(float f) : S(doubleToString<S>(f)) { }

         public:         STLValue(long i) : S(intToString<S, long>(i)) { }

         public:         STLValue(ulong i) : S(intToString<S, ulong>(i)) { }

         public:         STLValue(int i) : S(intToString<S, long>(i)) { }

         public:         STLValue(uint i) : S(intToString<S, ulong>(i)) { }

         public:         STLValue(bool b) : S(b ? S(STR("true")) : S(STR("false"))) { }

         public:         template<class T> STLValue(const T& s) : S(s) { }


         public:         operator bool() const;

         public:         operator long() const;

         public:         operator double() const;

         public:         operator float() const { return float(double(*this)); }

         public:         operator ulong() const { return ulong(long(*this)); }

         public:         operator int() const { return int(long(*this)); }

         public:         operator uint() const { return uint(int(*this)); }


         public:         bool operator<(const STLValue& r) const;

         public:         bool operator==(const STLValue& r) const;

         public:         bool operator!=(const STLValue& r) const { return !(*this == r); }

         public:         bool operator>(const STLValue& r) const { return r < (*this); }

         public:         bool operator<=(const STLValue& r) const { return !(r < (*this)); }

         public:         bool operator>=(const STLValue& r) const { return !((*this) < r); }

         public:         const STLValue operator[](const STLValue& i) const;


         public:         bool isVoid() const { return S::empty(); }


         public:         template<class T> bool operator<(const T& r) const { return operator<(STLValue(r)); }

         public:         template<class T> bool operator==(const T& r) const { return operator==(STLValue(r)); }

         public:         template<class T> bool operator!=(const T& r) const { return operator!=(STLValue(r)); }

         public:         template<class T> bool operator>(const T& r) const { return operator>(STLValue(r)); }

         public:         template<class T> bool operator<=(const T& r) const { return operator<=(STLValue(r)); }

         public:         template<class T> bool operator>=(const T& r) const { return operator>=(STLValue(r)); }

         public:         template<class T> const STLValue operator[](const T& i) const { return operator[](STLValue(i)); }

 };


 enum Precedence {

         NO_TRACE = 0

         , TRACE_ERROR = 1

         , TRACE_CALL = 2

         , TRACE_LOOP = 3

         , STATEMENT = 4

         , BODY = 5

         , ARGUMENT = 6

         , BRACKETS = 7

         , ASSIGN = 8

         , LOGICAL_OR = 9

         , LOGICAL_AND = 10

         , BIT_OR = 11

         , BIT_XOR = 12

         , BIT_AND = 13

         , EQUALITY = 14

         , COMPARE = 15

         , CONCAT = 16

         , SHIFT = 17

         , ADD_SUB = 18

         , MUL_DIV = 19

         , PREFIX = 20

         , POSTFIX = 21

         , DEFINITION = 22

 };


 template<class Config> struct Script {


         typedef typename Config::Value Value;

         typedef typename Value::String String;

         typedef typename String::value_type Char;

         typedef typename String::size_type SizeType;

         typedef typename String::const_iterator StringIt;

         typedef Exception<String> Xception;


         class Native;

         class Root;


         class Variables {

                 public:         typedef Script ForScript;

                 public:         typedef std::vector< std::pair<String, Value> > VarList;

                 public:         virtual bool lookup(const String& symbol, Value& result) = 0;

                 public:         virtual bool assign(const String& symbol, const Value& value) = 0;

                 public:         virtual bool erase(const String& symbol) = 0;

                 public:         virtual void list(const String& key, VarList& list) = 0;

                 public:         virtual Native* lookupNative(const String& identifier) = 0;

                 public:         virtual bool assignNative(const String& identifier, Native* native) = 0;

                 public:         virtual ~Variables();

         };


         class Frame {


                 public:         Frame(Variables& vars, Root& root, Frame* previous);


                 public:         Variables& getVariables() const throw() { return vars; }

                 public:         Root& getRoot() const throw() { return root; }

                 public:         Frame& getPrevious() const throw() { assert(previous != 0); return *previous; }


                 public:         Value get(const String& identifier, bool fallback = false) const;

                 public:         Value getOptional(const String& identifier, const Value& defaultValue = Value()) const;

                 public:         const Value& set(const String& identifier, const Value& v);

                 public:         Value reference(const String& identifier) const;

                 public:         std::pair< Frame*, String > resolveFrame(const String& identifier) const;


                 public:         Value call(const String& callee, const Value& body, long argc, const Value* argv = 0);

                 public:         Value execute(const String& body);

                 public:         Value evaluate(const String source);

                 public:         StringIt parse(const StringIt& begin, const StringIt& end, bool literal);


                 public:         void registerNative(const String& identifier, Native* native);

                 public:         template<class A0, class R> void registerNative(const String& i, R (*f)(A0)) {

                                                 registerNative(i, newUnaryFunctor(std::ptr_fun(f)));

                                         }

                 public:         template<class A0, class A1, class R> void registerNative(const String& i, R (*f)(A0, A1)) {

                                                 registerNative(i, newBinaryFunctor(std::ptr_fun(f)));

                                         }

                 public:         template<class C, class A0, class R> void registerNative(const String& i, C* o, R (C::*m)(A0)) {

                                                 registerNative(i, newUnaryFunctor(bound_mem_fun(m, o)));

                                         }

                 public:         void unregisterNative(const String& identifier) { registerNative(identifier, (Native*)(0)); }


                 public:         virtual ~Frame() { }


                 protected:      typedef std::pair<bool, Value> XValue;

                 protected:      void tick(const StringIt& p, const XValue& v, Precedence thres, bool exit);

                 protected:      Value rvalue(const XValue& v, bool fallback = true);

                 protected:      const Value& lvalue(const XValue& v);

                 protected:      void white(StringIt& p, const StringIt& e);

                 protected:      bool token(StringIt& p, const StringIt& e, const Char* token);

                 protected:      Frame* resolveFrame(StringIt& p, const StringIt& e) const;

                 protected:      template<class F> bool binaryOp(StringIt& p, const StringIt& e, XValue& v, bool dry

                                                         , Precedence thres, int hop, Precedence prec, F op);

                 protected:      template<class F> bool assignableOp(StringIt& p, const StringIt& e, XValue& v, bool dry

                                                         , Precedence thres, int hop, Precedence prec, F op);

                 protected:      template<class F> bool addSubOp(StringIt& p, const StringIt& e, XValue& v, bool dry

                                                         , Precedence thres, const F& f);

                 protected:      template<class E, class I, class S> bool lgtOp(StringIt& p, const StringIt& e, XValue& v, bool dry

                                                         , Precedence thres, const E& excl, const I& incl, S shift);

                 protected:      bool pre(StringIt& p, const StringIt& e, XValue& v, bool dry);

                 protected:      bool post(StringIt& p, const StringIt& e, XValue& v, bool dry, Precedence thres);

                 protected:      bool expr(StringIt& p, const StringIt& e, XValue& v, bool emptyOk, bool dry, Precedence thres);

                 protected:      bool termExpr(StringIt& p, const StringIt& e, XValue& v, bool emptyOk, bool dry, Precedence thres

                                                         , Char term);


                 protected:      Variables& vars;

                 protected:      Root& root;

                 protected:      Frame* const previous;

                 protected:      Frame* closure;

                 protected:      const String* source;

                 protected:      const String label;


                 private:        Frame(const Frame& copy); // N/A

                 private:        Frame& operator=(const Frame& copy); // N/A

         };


         class Root : public Frame {

                 public:         Root(Variables& vars);

                 public:         virtual void trace(Frame& frame, const String& source, SizeType offset, bool lvalue

                                                         , const Value& value, Precedence level, bool exit);

                 public:         virtual void setTracer(Precedence traceLevel, const Value& tracerFunction) throw();

                 public:         bool doTrace(Precedence level) const throw() { return level <= traceLevel; }

                 public:         String generateLabel();

                 protected:      Precedence traceLevel;

                 protected:      Value tracerFunction;

                 protected:      bool isInsideTracer;

                 protected:      Char autoLabel[32];

                 protected:      Char* autoLabelStart;

         };


         class FullRoot : public Root, public Config::Globals {

                 public:         FullRoot(bool includeIONatives = true) : Root(*(typename Config::Globals*)(this)) {

                                                 addLibraryNatives(*this, includeIONatives);

                                         }

         };


         class STLVariables : public Variables {

                 public:         typedef std::map<const String, Value> VariableMap;

                 public:         typedef std::map<const String, Native* > NativeMap;

                 public:         virtual bool lookup(const String& symbol, Value& result);

                 public:         virtual bool assign(const String& symbol, const Value& value) { vars[symbol] = value; return true; }

                 public:         virtual bool erase(const String& symbol) { return (vars.erase(symbol) > 0); }

                 public:         virtual void list(const String& key, typename Variables::VarList& list);

                 public:         virtual Native* lookupNative(const String& name);

                 public:         virtual bool assignNative(const String& name, Native* native);

                 public:         virtual ~STLVariables();

                 public:         VariableMap vars;

                 public:         NativeMap natives;

         };


         class Native {

                 public:         virtual Value pikaCall(Frame& /*frame*/) { throw Xception(STR("Not callable")); }

                 public:         virtual ~Native();

         };


         template<class F, class A0 = typename F::argument_type, class R = typename F::result_type> class UnaryFunctor

                         : public Native {

                 public:         UnaryFunctor(const F& functor) : func(functor) { }

                 protected:      template<class T> const Value arg(Frame& f, const T&) { return f.get(STR("$0")); }

                 protected:      Frame& arg(Frame& f, const Dumb<Frame&>&) { return f; }

                 protected:      const Frame& arg(Frame& f, const Dumb<const Frame&>&) { return f; }

                 protected:      template<class A, class T> Value call(A& a, const Dumb<T>&) { return func(a); }

                 protected:      template<class A> Value call(A& a, const Dumb<void>&) { func(a); return Value(); }

                 public:         virtual Value pikaCall(Frame& f) { return call(arg(f, Dumb<A0>()), Dumb<R>()); }

                 protected:      F func;

         };


         template<class F, class A0 = typename F::first_argument_type, class A1 = typename F::second_argument_type

                         , class R = typename F::result_type> class BinaryFunctor : public Native {

                 public:         BinaryFunctor(const F& functor) : func(functor) { }

                 protected:      template<class T> Value call(const Value& a0, const Value& a1, const T&) { return func(a0, a1); }

                 protected:      Value call(const Value& a0, const Value& a1, const Dumb<void>&) { func(a0, a1); return Value(); }

                 public:         virtual Value pikaCall(Frame& f) { return call(f.get(STR("$0")), f.get(STR("$1")), Dumb<R>()); }

                 protected:      F func;

         };


         template<class F> static UnaryFunctor<F>* newUnaryFunctor(const F& f) { return new UnaryFunctor<F>(f); }

         template<class F> static BinaryFunctor<F>* newBinaryFunctor(const F& f) { return new BinaryFunctor<F>(f); }


         static std::pair<Value, String> getThisAndMethod(Frame& frame);

         static Value getThis(Frame& frame) { return getThisAndMethod(frame).first; }

         static Value getMethod(Frame& frame) { return getThisAndMethod(frame).second; }


         struct lib {

                 static Value elevate(Frame& frame);

                 static String character(double d);

                 static bool deleter(const Frame& frame);

                 static Value evaluate(const Frame& frame);

                 static bool exists(const Frame& frame);

                 static ulong find(const String& a, const String& b);

                 static void foreach(Frame& frame);

                 static String input(const String& prompt);

                 static Value invoke(Frame& frame);

                 static ulong length(const String& s);

                 static String load(const String& file);

                 static String lower(String s);

                 static ulong mismatch(const String& a, const String& b);

                 static uint ordinal(const String& s);

                 static ulong parse(Frame& frame);

                 static String precision(const Frame& frame);

                 static void print(const String& s);

                 static String radix(const Frame& frame);

                 static double random(double m);

                 static String reverse(String s);

                 static void save(const String& file, const String& chars);

                 static int system(const String& command);

                 static ulong search(const String& a, const String& b);

                 static ulong span(const String& a, const String& b);

                 static void thrower(const String& s);

                 static Value time(const Frame&);

                 static void trace(const Frame& frame);

                 static Value tryer(Frame& frame);

                 static String upper(String s);

         };


         static void addLibraryNatives(Frame& frame, bool includeIO = true);


 }; // struct Script


 struct StdConfig {

         typedef STLValue<std::string> Value;

         typedef Script<StdConfig>::STLVariables Locals;

         typedef Locals Globals;

 };


 typedef Script<StdConfig> StdScript;


 #undef STR


 } // namespace Pika


 #endif

Pika::ASSIGN
x=y x*=y x/=y x\=y x%=y x+=y x-=y x<<=y x>>=y x#=y x&=y x^=y x|=y
Definition: PikaScript.h:238

Pika::EQUALITY
x===y x==y x!==y x!=y
Definition: PikaScript.h:244

Pika::Script::addLibraryNatives
static void addLibraryNatives(Frame &frame, bool includeIO=true)
Registers the standard library native functions to frame. If includeIO is false, 'load', 'save', 'input', 'print' and 'system' will not be registered. Please, refer to the PikaScript standard library reference guide for more info on individual native functions.
Definition: PikaScriptImpl.h:1003

Pika::Script::getMethod
static Value getMethod(Frame &frame)
Returns only the "method" value as descripted in getThisAndMethod().
Definition: PikaScript.h:531

Pika::Script::BinaryFunctor::call
Value call(const Value &a0, const Value &a1, const T &)
Call the functor with the arguments a0 and a1.
Definition: PikaScript.h:502

Pika::Script::UnaryFunctor::call
Value call(A &a, const Dumb< void > &)
Overloaded to return the void value for functors that returns the void type.
Definition: PikaScript.h:491

Pika::STATEMENT
x; y;
Definition: PikaScript.h:234

Pika::Script::Root::autoLabelStart
Char * autoLabelStart
The first character of the last generated frame label (begins at autoLabel + 30 and slowly moves back...
Definition: PikaScript.h:414

Pika::Script::UnaryFunctor::call
Value call(A &a, const Dumb< T > &)
Call the functor with the argument a.
Definition: PikaScript.h:490

Pika::Script::UnaryFunctor::arg
Frame & arg(Frame &f, const Dumb< Frame & > &)
Overloaded arg() that returns the actual frame instead of getting the argument value if the functor a...
Definition: PikaScript.h:488

Pika::Script::Char
String::value_type Char
The character type for all strings (defined by the string class). E.g. char.
Definition: PikaScript.h:270

Pika::Script::Variables::lookup
virtual bool lookup(const String &symbol, Value &result)=0
Lookup symbol.

Pika::Exception
The PikaScript exception class.
Definition: PikaScript.h:135

Pika::Script::Frame::getOptional
Value getOptional(const String &identifier, const Value &defaultValue=Value()) const
Tries to get the variable value as with get() (but never "falls back").

Pika::Script::Variables::~Variables
virtual ~Variables()
Destructor.
Definition: PikaScriptImpl.h:1058

Pika::Exception::Exception
Exception(const S &error)
Simply constructs the exception with error string error.
Definition: PikaScript.h:136

Pika::STLValue::operator>=
bool operator>=(const STLValue &r) const
Greater than or equal to comparison operator.
Definition: PikaScript.h:209

Pika::Script::Frame::XValue
std::pair< bool, Value > XValue
The XValue differentiates lvalues and rvalues and is used internally in the interpreter.
Definition: PikaScript.h:356

Pika::unescape
S unescape(typename S::const_iterator &p, const typename S::const_iterator &e)
Converts a string that is either enclosed in single (' ') or double (" ") quotes. ...
Definition: PikaScriptImpl.h:198

Pika::Script::StringIt
String::const_iterator StringIt
The const_iterator of the string is used so frequently it deserves its own typedef.
Definition: PikaScript.h:272

Pika::Script::FullRoot::FullRoot
FullRoot(bool includeIONatives=true)
Definition: PikaScript.h:423

Pika::CONCAT
x::y
Definition: PikaScript.h:246

Pika::Dumb
We use this dummy class to specialize member functions for arbitrary types (including void...
Definition: PikaScript.h:127

Pika::STLValue::STLValue
STLValue(const T &s)
Pass other types of construction onwards to the super-class S.
Definition: PikaScript.h:190

Pika::STLValue::operator<
bool operator<(const STLValue &r) const
Less than comparison operator.
Definition: PikaScriptImpl.h:270

Pika::LOGICAL_AND
x&&y
Definition: PikaScript.h:240

Pika::Script::Frame::getVariables
Variables & getVariables() const
Returns a reference to the Variable instance associated with this Frame. Simple as that...
Definition: PikaScript.h:319

Pika::Script::Root::generateLabel
String generateLabel()
Each "sub-frame" requires a unique "frame label".

Pika::Script::UnaryFunctor
We provide two Native template classes for bridging PikaScript calls to C++ "functors".
Definition: PikaScript.h:484

Pika::STLValue::String
S String
The class to use for all strings (i.e. the super-class).
Definition: PikaScript.h:177

Pika::STLValue::operator>
bool operator>(const STLValue &r) const
Greater than comparison operator.
Definition: PikaScript.h:207

Pika::Exception::error
S error
The error string.
Definition: PikaScript.h:140

Pika::Script::Frame::execute
Value execute(const String &body)
A low-level function that executes body directly on the Frame instance.

Pika::LOGICAL_OR
x||y
Definition: PikaScript.h:239

Pika::Script::Value
Config::Value Value
The class used for all values and variables (defined by the configuration meta-class). E.g. STLValue.
Definition: PikaScript.h:268

Pika::Script::Frame::resolveFrame
std::pair< Frame *, String > resolveFrame(const String &identifier) const
Resolves the frame for identifier and returns it together with identifier stripped of any prefixed "f...
Definition: PikaScriptImpl.h:325

Pika::Exception::what
virtual const char * what() const
Returns the error as a null-terminated char string.
Definition: PikaScript.h:138

Pika::STLValue::isVoid
bool isVoid() const
Returns true if the value represents the empty string.
Definition: PikaScript.h:214

Pika::Script::UnaryFunctor::arg
const Frame & arg(Frame &f, const Dumb< const Frame & > &)
Overloaded arg() that returns the actual frame instead of getting the argument value if the functor a...
Definition: PikaScript.h:489

Pika::STLValue::STLValue
STLValue(ulong i)
Constructs a value representing the ulong integer l.
Definition: PikaScript.h:186

Pika::COMPARE
xy x>=y
Definition: PikaScript.h:245

Pika::BODY
if () x, for () x
Definition: PikaScript.h:235

Pika::SHIFT
x<>y
Definition: PikaScript.h:247

Pika::Script::Variables::assignNative
virtual bool assignNative(const String &identifier, Native *native)=0
Assign the native function (or object) native to identifier, replacing any already existing definitio...

Pika::Script::Root
The Root is the first Frame you instantiate.
Definition: PikaScript.h:403

Pika::Script::BinaryFunctor::call
Value call(const Value &a0, const Value &a1, const Dumb< void > &)
Overloaded to return the void value for functors that returns the void type.
Definition: PikaScript.h:503

Pika::escape
S escape(const S &s)
Depending on the contents of the source string s it is encoded either in single (' ') or double (" ")...
Definition: PikaScriptImpl.h:225

Pika::Script::Frame::unregisterNative
void unregisterNative(const String &identifier)
Helper function for unregistering a native function / object.
Definition: PikaScript.h:350

Pika::Script::Frame::registerNative
void registerNative(const String &i, R(*f)(A0))
Helper template for easily registering a unary C++ function.
Definition: PikaScript.h:341

Pika::MUL_DIV
x*y x/y x xy
Definition: PikaScript.h:249

Pika::STLValue::operator<=
bool operator<=(const STLValue &r) const
Less than or equal to comparison operator.
Definition: PikaScript.h:208

Pika::ARGUMENT
(x, y)
Definition: PikaScript.h:236

Pika::StdScript
Script< StdConfig > StdScript
This typedef exist for your convenience.
Definition: PikaScript.h:583

Pika::Precedence
Precedence
Precedence levels are used both internally for the parser and externally for the tracing mechanism...
Definition: PikaScript.h:229

Pika::Script::Frame::registerNative
void registerNative(const String &i, C *o, R(C::*m)(A0))
Helper template for easily registering a unary C++ member function in the C++ object pointed to by o...
Definition: PikaScript.h:347

Pika::Exception::getError
virtual S getError() const
Return the error string for this exception.
Definition: PikaScript.h:137

Pika::BRACKETS
(x) [x]
Definition: PikaScript.h:237

Pika::Script::Frame::parse
StringIt parse(const StringIt &begin, const StringIt &end, bool literal)
Parses a PikaScript expression or literal (without evaluating it) and returns an iterator pointing at...

Pika::Script::Native::pikaCall
virtual Value pikaCall(Frame &)
Process the PikaScript call.
Definition: PikaScript.h:460

Pika::Script::Frame::getRoot
Root & getRoot() const
Returns a reference to the "root frame" for this Frame. (No brainer.)
Definition: PikaScript.h:320

Pika::STLValue::STLValue
STLValue(uint i)
Constructs a value representing the unsigned integer i.
Definition: PikaScript.h:188

Pika::Script::Frame::reference
Value reference(const String &identifier) const
Creates a reference to the variable identified by identifier by prefixing it with a "frame label"...

Pika::ADD_SUB
x+y x-y
Definition: PikaScript.h:248

Pika::NO_TRACE
used only for tracing with tick()
Definition: PikaScript.h:230

Pika::intToString
S intToString(T i, int radix=10, int minLength=1)
Converts the integer i to a string with a radix and minimum length of your choice.
Definition: PikaScriptImpl.h:117

Pika::Script::Frame::registerNative
void registerNative(const String &identifier, Native *native)
Registers the native function (or object) native with identifier in the appropriate variable space (d...
Definition: PikaScriptImpl.h:775

Pika::Script::BinaryFunctor
See UnaryFunctor for documentation.
Definition: PikaScript.h:500

Pika::STLValue::STLValue
STLValue(float f)
Constructs a value representing the single precision floating point f.
Definition: PikaScript.h:184

Pika::stringToDouble
double stringToDouble(typename S::const_iterator &p, const typename S::const_iterator &e)
Converts a string in scientific e notation (e.g. -12.34e-3) to a double floating point value...
Definition: PikaScriptImpl.h:129

Pika::STLValue::STLValue
STLValue()
The default constructor initializes the value to the empty string (or "void").
Definition: PikaScript.h:182

Pika::Script::Frame
The execution context and interpreter for PikaScript.
Definition: PikaScript.h:311

Pika::hexToLong
ulong hexToLong(typename S::const_iterator &p, const typename S::const_iterator &e)
Converts a string in hexadecimal form to an ulong integer.
Definition: PikaScriptImpl.h:101

Pika::POSTFIX
x() x.y x[y] x{y} x++ x–
Definition: PikaScript.h:251

Pika::Script::newBinaryFunctor
static BinaryFunctor< F > * newBinaryFunctor(const F &f)
Helper function to create a BinaryFunctor class with correct template parameters. ...
Definition: PikaScript.h:509

Pika::Script::String
Value::String String
The class used for strings (defined by the string class). E.g. std::string.
Definition: PikaScript.h:269

Pika::STLValue::STLValue
STLValue(long i)
Constructs a value representing the signed long integer l.
Definition: PikaScript.h:185

Pika::Script::Root::tracerFunction
Value tracerFunction
Pika-script tracer function (used by the default trace() implementation).
Definition: PikaScript.h:411

Pika::STLValue::operator[]
const STLValue operator[](const STLValue &i) const
The subscript operator returns the concatenation of the value with the dot (.) separator (if necessar...
Definition: PikaScriptImpl.h:282

Pika::Script::Variables::assign
virtual bool assign(const String &symbol, const Value &value)=0
Assign value to symbol and return true if the assignment succeeded.

Pika::Script::getThis
static Value getThis(Frame &frame)
Returns only the "this" value as descripted in getThisAndMethod().
Definition: PikaScript.h:530

Pika::DEFINITION
function { }
Definition: PikaScript.h:252

Pika::Script::SizeType
String::size_type SizeType
The length type for all strings (defined by the string class). E.g. size_t.
Definition: PikaScript.h:271

Pika::BIT_AND
x&y
Definition: PikaScript.h:243

Pika::Script::Frame::registerNative
void registerNative(const String &i, R(*f)(A0, A1))
Helper template for easily registering a binary C++ function.
Definition: PikaScript.h:344

Pika::Script
Script is a meta-class that groups all the core classes of the PikaScript interpreter together (excep...
Definition: PikaScript.h:266

Pika::STLValue
STLValue is the reference implementation of a PikaScript variable.
Definition: PikaScript.h:173

Pika::Script::getThisAndMethod
static std::pair< Value, String > getThisAndMethod(Frame &frame)
getThisAndMethod splits the $callee variable of frame into object ("this") and method.
Definition: PikaScriptImpl.h:854

Pika::Script::Frame::call
Value call(const String &callee, const Value &body, long argc, const Value *argv=0)
Calls a Pika function (by setting up a new "sub-frame" and executing the function body)...

Pika::Script::Frame::evaluate
Value evaluate(const String source)
Evaluates the PikaScript expression in source directly on this Frame.

Pika::Script::Root::autoLabel
Char autoLabel[32]
The last generated frame label (padded with leading ':').
Definition: PikaScript.h:413

Pika::STLValue::operator==
bool operator==(const STLValue &r) const
Equality operator.
Definition: PikaScriptImpl.h:276

Pika::bound_mem_fun
bound_mem_fun_t< C, A0, R > bound_mem_fun(R(C::*m)(A0), C *o)
bound_mem_fun creates a member functor bound to a specific C++ object through a pointer.
Definition: PikaScript.h:120

Pika::Script::Variables::lookupNative
virtual Native * lookupNative(const String &identifier)=0
Lookup the native function (or object) with identifier.

Pika::STLValue::Char
S::value_type Char
The character type for all strings (e.g. char or wchar_t).
Definition: PikaScript.h:178

Pika::TRACE_LOOP
used only for tracing with tick()
Definition: PikaScript.h:233

Pika::Script::Xception
Exception< String > Xception
The exception type.
Definition: PikaScript.h:273

Pika::STLValue::STLValue
STLValue(bool b)
Constructs a value representing the boolean b.
Definition: PikaScript.h:189

Pika::Script::Frame::set
const Value & set(const String &identifier, const Value &v)
Sets a variable value.

Pika::Script::newUnaryFunctor
static UnaryFunctor< F > * newUnaryFunctor(const F &f)
Helper function to create a UnaryFunctor class with correct template parameters.
Definition: PikaScript.h:508

Pika::Script::Root::isInsideTracer
bool isInsideTracer
Set to prevent recursive calling of tracer (used by the default trace() implementation).
Definition: PikaScript.h:412

Pika::Exception::converted
std::string converted
Since what() is defined to return a pointer only, we need storage for the converted string within thi...
Definition: PikaScript.h:141

Pika::TRACE_CALL
used only for tracing with tick()
Definition: PikaScript.h:232

Pika::Script::Variables::list
virtual void list(const String &key, VarList &list)=0
Iterate all symbols that begins with key and push back names and values to list.

Pika::Script::Frame::~Frame
virtual ~Frame()
The default destructor does nothing, but it is always good practice to have a virtual destructor...
Definition: PikaScript.h:354

Pika::Script::Native
Native is the base class for the native functions and objects that can be accessed from PikaScript...
Definition: PikaScript.h:459

Pika::BIT_OR
x|y
Definition: PikaScript.h:241

Pika::stringToLong
long stringToLong(typename S::const_iterator &p, const typename S::const_iterator &e)
Converts a string in decimal form to a signed long integer.
Definition: PikaScriptImpl.h:109

Pika::Script::Root::trace
virtual void trace(Frame &frame, const String &source, SizeType offset, bool lvalue, const Value &value, Precedence level, bool exit)
Overload this member function if you want to customize the tracing mechanism in PikaScript.
Definition: PikaScriptImpl.h:808

Pika::Script::Root::doTrace
bool doTrace(Precedence level) const
Definition: PikaScript.h:408

Pika::Script::Root::setTracer
virtual void setTracer(Precedence traceLevel, const Value &tracerFunction)
Called by the standard library function "trace" to assign a PikaScript tracer function and a trace le...
Definition: PikaScriptImpl.h:803

Pika::Script::Frame::getPrevious
Frame & getPrevious() const
Returns a reference to the previous frame (i.e. the frame of the caller of this frame). Must not be called on the root frame (will assert).
Definition: PikaScript.h:321

Pika::doubleToString
S doubleToString(double d, int precision=14)
Converts the double d to a string (in scientific e notation, e.g. -12.34e-3).
Definition: PikaScriptImpl.h:157

Pika::Script::lib::elevate
static Value elevate(Frame &frame)
Used to "aggregate" different method calls into a single function call.

Pika::Script::Frame::Frame
Frame(Variables &vars, Root &root, Frame *previous)
Constructs the Frame and associates it with the variable space vars.
Definition: PikaScriptImpl.h:294

Pika::TRACE_ERROR
used only for tracing with tick()
Definition: PikaScript.h:231

Pika::Script::Root::traceLevel
Precedence traceLevel
Calls to trace() will only happen when the "precedence level" is less or equal to this...
Definition: PikaScript.h:410

Pika::Script::Variables::erase
virtual bool erase(const String &symbol)=0
Erase symbol. Return true if the symbol existed and was successfully erased.

Pika::STLValue::operator!=
bool operator!=(const STLValue &r) const
Non-equality operator.
Definition: PikaScript.h:206

Pika::Script::Variables
Variables is an abstract base class which implements the interface to the variable space that a Frame...
Definition: PikaScript.h:291

Pika::BIT_XOR
x^y
Definition: PikaScript.h:242

Pika::Script::UnaryFunctor::arg
const Value arg(Frame &f, const T &)
Get the first argument from the frame f.
Definition: PikaScript.h:487

Pika::STLValue::STLValue
STLValue(int i)
Constructs a value representing the signed integer i.
Definition: PikaScript.h:187

Pika::toStdString
std::string toStdString(const S &s)
Converts the string s to a standard C++ string.
Definition: PikaScriptImpl.h:97

Pika::STLValue::STLValue
STLValue(double d)
Constructs a value representing the double precision floating point d.
Definition: PikaScript.h:183

Pika::PREFIX
@x !x ~x +x -x ++x –x
Definition: PikaScript.h:250