into anything yet, but it builds OK inside SimGear.
simgear/bucket/Makefile \
simgear/debug/Makefile \
simgear/ephemeris/Makefile \
+ simgear/interpreter/Makefile \
simgear/io/Makefile \
simgear/magvar/Makefile \
simgear/math/Makefile \
SUBDIRS = \
xml \
+ interpreter \
debug \
misc \
bucket \
--- /dev/null
+.deps
+Makefile
+Makefile.in
--- /dev/null
+includedir = @includedir@/js
+
+lib_LIBRARIES = libsginterp.a
+
+include_HEADERS = \
+ interpreter.hxx
+
+libsginterp_a_SOURCES = \
+ interpreter.cxx interpreter.hxx \
+ ixlib_javascript.hh \
+ js_array.cc \
+ js_expression.cc \
+ js_interpreter.cc \
+ js_value.cc \
+ js_declaration.cc \
+ js_instruction.cc \
+ js_library.cc \
+ lex.javascript.cc ixlib_token_lex.hh ixlib_token_javascript.hh \
+ scanner.cc ixlib_scanner.hh ixlib_scanjs.hh \
+ exbase.cc \
+ numeric.cc ixlib_numeric.hh \
+ numconv.cc ixlib_numconv.hh \
+ re.cc ixlib_re.hh ixlib_re_impl.hh \
+ exgen.cc ixlib_exgen.hh \
+ string.cc ixlib_string.hh \
+ ixlib_base.hh \
+ ixlib_exbase.hh \
+ ixlib_garbage.hh \
+ ixlib_i18n.hh \
+ ixlib_js_internals.hh \
+ ixlib_random.hh
+
+if OLD_AUTOMAKE
+INCLUDES += -I$(top_srcdir)
+else
+INCLUDES = -I$(top_srcdir)
+endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Exception handling
+// ----------------------------------------------------------------------------
+// (c) Copyright 1996 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <cstdio>
+#include <cstring>
+#include <ixlib_exbase.hh>
+
+
+
+
+using namespace ixion;
+
+
+
+
+// Description forms ----------------------------------------------------------
+#define T_DESCRIPTION1 "[%s%04X] %s"
+#define T_DESCRIPTION2 "[%s%04X] %s <%s>"
+#define T_DESCRIPTION3 "[%s%04X] %s <%s,%d>"
+#define T_DESCRIPTION1I "[%s%04X] %s (%s)"
+#define T_DESCRIPTION2I "[%s%04X] %s (%s) <%s>"
+#define T_DESCRIPTION3I "[%s%04X] %s (%s) <%s,%d>"
+
+
+
+
+// base_exception -------------------------------------------------------------
+char base_exception::RenderBuffer[EX_INFOMAX+1+100];
+
+
+
+
+base_exception::base_exception(TErrorCode error,char const *info,char *module,
+ TIndex line,char *category)
+: Error(error),Module(module),Line(line),Category(category) {
+ HasInfo = (info!=NULL);
+ if (info) {
+ if (strlen(info)>EX_INFOMAX) {
+ strncpy(Info,info,EX_INFOMAX);
+ Info[EX_INFOMAX] = '\0';
+ }
+ else strcpy(Info,info);
+ }
+ }
+
+
+
+
+char const *base_exception::what() const throw () {
+ if (HasInfo) {
+ if (Module) {
+ if (Line)
+ sprintf(RenderBuffer,T_DESCRIPTION3I,Category,Error,getText(),Info,Module,Line);
+ else
+ sprintf(RenderBuffer,T_DESCRIPTION2I,Category,Error,getText(),Info,Module);
+ }
+ else
+ sprintf(RenderBuffer,T_DESCRIPTION1I,Category,Error,getText(),Info);
+ }
+ else {
+ if (Module) {
+ if (Line)
+ sprintf(RenderBuffer,T_DESCRIPTION3,Category,Error,getText(),Module,Line);
+ else
+ sprintf(RenderBuffer,T_DESCRIPTION2,Category,Error,getText(),Module);
+ }
+ else
+ sprintf(RenderBuffer,T_DESCRIPTION1,Category,Error,getText());
+ }
+ return RenderBuffer;
+ }
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Generic exceptions
+// ----------------------------------------------------------------------------
+// (c) Copyright 1996 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include "ixlib_i18n.hh"
+#include <ixlib_exgen.hh>
+#include <ixlib_numconv.hh>
+
+
+
+
+using namespace ixion;
+
+
+
+
+static char *(PlainText[]) = {
+ N_("Unable to evaluate expression"),
+ N_("Function not yet implemented"),
+ N_("General error"),
+ N_("NULL pointer encountered"),
+ N_("Invalid parameter"),
+ N_("Index out of range"),
+ N_("Buffer overrun"),
+ N_("Buffer underrun"),
+ N_("Item not found"),
+ N_("Invalid operation"),
+ N_("Dimension mismatch"),
+ N_("Operation cancelled"),
+ N_("Unable to operate on empty set"),
+ N_("Unable to remove GC entry"),
+ N_("Unable to protect non-freeable entry")
+ };
+
+
+
+
+// generic_exception ----------------------------------------------------------
+char const *generic_exception::getText() const {
+ return _(PlainText[Error]);
+ }
--- /dev/null
+#include "interpreter.hxx"
+
+SGInterpreter::SGInterpreter ()
+{
+}
+
+SGInterpreter::~SGInterpreter ()
+{
+}
--- /dev/null
+#ifndef __INTERPRETER_HXX
+#define __INTERPRETER_HXX 1
+
+class SGInterpreter
+{
+public:
+
+ SGInterpreter ();
+ virtual ~SGInterpreter ();
+
+};
+
+#endif
--- /dev/null
+/* ----------------------------------------------------------------------------
+ Description : iXiONmedia library base declarations
+ ----------------------------------------------------------------------------
+ (c) Copyright 1996 by iXiONmedia, all rights reserved.
+ ----------------------------------------------------------------------------
+ This header must be C-safe for autoconf purposes.
+ */
+
+
+
+
+#ifndef IXLIB_BASE
+#define IXLIB_BASE
+
+
+#undef HAVE_CONFIG_H
+
+#ifdef HAVE_CONFIG_H
+#include <ixlib_config.hh>
+#undef PACKAGE
+#undef VERSION
+#endif
+
+
+
+
+#ifdef __cplusplus
+namespace ixion {
+ extern "C" {
+#endif
+/* Aliases --------------------------------------------------------------------
+*/
+ const double Pi = 3.141592653589793285;
+ const double Euler = 2.718281828;
+ const double Gravity = 9.8065; // m/s^2
+ const double UniGravity = 6.673e-11; // m^3/kg s^2
+ const double Epsilon0 = 8.8542e-12; // F/m
+ const double Mu0 = 1.2566e-6; // H/m
+ const double LightSpeed = 2.9972e8; // m/s
+ const double Planck = 6.6261e-34; // Js
+
+
+
+
+/* STL Helper macro -----------------------------------------------------------
+*/
+#define FOREACH(VAR,LIST,LISTTYPE) \
+ for (LISTTYPE::iterator VAR = (LIST).begin(),last = (LIST).end();VAR != last;VAR++)
+#define FOREACH_CONST(VAR,LIST,LISTTYPE) \
+ for (LISTTYPE::const_iterator VAR = (LIST).begin(),last = (LIST).end();VAR != last;VAR++)
+
+
+
+
+/* Nomenclature typedefs ------------------------------------------------------
+*/
+ typedef unsigned char TUnsigned8;
+ typedef unsigned short TUnsigned16;
+ typedef unsigned long TUnsigned32;
+ typedef unsigned long long TUnsigned64;
+
+ typedef signed char TSigned8;
+ typedef signed short TSigned16;
+ typedef signed long TSigned32;
+ typedef signed long long TSigned64;
+
+ typedef TSigned8 TDelta8;
+ typedef TSigned16 TDelta16;
+ typedef TSigned32 TDelta32;
+ typedef TSigned64 TDelta64;
+ typedef signed TDelta;
+
+ typedef TUnsigned8 TSize8;
+ typedef TUnsigned16 TSize16;
+ typedef TUnsigned32 TSize32;
+ typedef TUnsigned64 TSize64;
+ typedef unsigned TSize;
+
+ typedef TUnsigned8 TIndex8;
+ typedef TUnsigned16 TIndex16;
+ typedef TUnsigned32 TIndex32;
+ typedef TUnsigned64 TIndex64;
+ typedef unsigned TIndex;
+
+ typedef TUnsigned8 TByte;
+
+
+
+
+ int ixlibGetMajorVersion();
+ int ixlibGetMinorVersion();
+ int ixlibGetMicroVersion();
+
+ void ixlibInitI18n();
+
+
+
+
+ #ifdef __cplusplus
+ }
+ }
+ #endif
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Exception handling
+// ----------------------------------------------------------------------------
+// (c) Copyright 1996 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_EXBASE
+#define IXLIB_EXBASE
+
+
+
+
+#include <stdexcept>
+#include <ixlib_base.hh>
+
+
+
+
+// constants ------------------------------------------------------------------
+#define EX_INFOMAX 255
+
+
+
+
+// throw macro ----------------------------------------------------------------
+#define EX_THROW(TYPE,CODE)\
+ throw ::ixion::TYPE##_exception(CODE,NULL,__FILE__,__LINE__);
+#define EX_THROWINFO(TYPE,CODE,INFO)\
+ throw ::ixion::TYPE##_exception(CODE,(char const *) INFO,__FILE__,__LINE__);
+#define EX_CATCHCODE(TYPE,CODE,HANDLER)\
+ catch (TYPE##_exception &ex) { \
+ if (ex.Error != CODE) throw; \
+ HANDLER \
+ }
+#define EX_CONVERT(TYPE,CODE,DESTTYPE,DESTCODE)\
+ catch (TYPE##_exception &ex) { \
+ if (ex.Error != CODE) throw; \
+ throw DESTTYPE##_exception(DESTCODE,ex.Info,__FILE__,__LINE__); \
+ }
+
+
+
+
+// xBaseException -------------------------------------------------------------
+namespace ixion {
+ typedef unsigned int TErrorCode;
+
+
+
+
+ struct base_exception : public std::exception {
+ TErrorCode Error;
+ char *Module;
+ TIndex Line;
+ char *Category;
+ bool HasInfo;
+ char Info[EX_INFOMAX+1];
+ static char RenderBuffer[EX_INFOMAX+1+100];
+
+ base_exception(TErrorCode error,char const *info = NULL,char *module = NULL,
+ TIndex line = 0,char *category = NULL);
+ char const *what() const throw ();
+ virtual const char *getText() const = 0;
+ };
+ }
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Generic exceptions
+// ----------------------------------------------------------------------------
+// (c) Copyright 1996 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_EXGEN
+#define IXLIB_EXGEN
+
+
+
+
+#include <ixlib_exbase.hh>
+
+
+
+
+// Error codes ----------------------------------------------------------------
+#define EC_CANNOTEVALUATE 0
+#define EC_NOTYETIMPLEMENTED 1
+#define EC_ERROR 2
+#define EC_NULLPOINTER 3
+#define EC_INVALIDPAR 4
+#define EC_INDEX 5
+#define EC_BUFFEROVERFLOW 6
+#define EC_BUFFERUNDERFLOW 7
+#define EC_ITEMNOTFOUND 8
+#define EC_INVALIDOP 9
+#define EC_DIMENSIONMISMATCH 10
+#define EC_CANCELLED 11
+#define EC_EMPTYSET 12
+#define EC_CANNOTREMOVEFROMGC 13
+#define EC_REMAININGREF 14
+
+#define ECMEM_GENERAL 0
+
+
+
+// Throw macro ----------------------------------------------------------------
+#define EXGEN_THROW(CODE)\
+ EX_THROW(generic,CODE)
+#define EXGEN_THROWINFO(CODE,INFO)\
+ EX_THROWINFO(generic,CODE,INFO)
+#define EXGEN_NYI\
+ EXGEN_THROW(EC_NOTYETIMPLEMENTED)
+
+
+
+
+namespace ixion {
+// generic_exception ----------------------------------------------------------
+ struct generic_exception : public base_exception {
+ generic_exception(TErrorCode error,char const *info = NULL,char *module = NULL,
+ TIndex line = 0)
+ : base_exception(error,info,module,line,"GEN") {
+ }
+ virtual char const *getText() const;
+ };
+ }
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Garbage collection
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_GARBAGE
+#define IXLIB_GARBAGE
+
+
+
+
+#include <memory>
+#include <ixlib_exgen.hh>
+#include <ixlib_base.hh>
+
+
+
+
+namespace ixion {
+ template<class T>
+ class delete_deallocator {
+ public:
+ void operator()(T const *instance) {
+ delete instance;
+ }
+ };
+ template<class T>
+ class delete_array_deallocator {
+ public:
+ void operator()(T const *instance) {
+ delete[] instance;
+ }
+ };
+
+ template<class T,class Deallocator = delete_deallocator<T> >
+ class reference_manager;
+
+ template<class T>
+ class ref_base {
+ protected:
+ T *Instance;
+
+ public:
+ ref_base(T *instance = NULL)
+ : Instance(instance) {
+ }
+ ref_base(ref_base const &src)
+ : Instance(src.Instance) {
+ }
+
+ // comparison
+ bool operator==(ref_base const &op2) const {
+ return Instance == op2.Instance;
+ }
+
+ // smart pointer nitty-gritty
+ T &operator*() const {
+ return *Instance;
+ }
+ T *operator->() const {
+ return Instance;
+ }
+ T *operator+(TIndex index) const {
+ return Instance + index;
+ }
+ T &operator[](TIndex index) const {
+ return Instance[index];
+ }
+
+ // methods
+ T *get() const {
+ return Instance;
+ }
+ };
+
+
+
+
+ template<class T,class T_Managed = T>
+ class ref;
+ template<class T,class T_Managed = T>
+ class no_free_ref;
+
+
+
+
+ template<class T_Managed>
+ class reference_manager_keeper {
+ public:
+ // *** FIXME should be private, but cannot be
+ // (partial specializations cannot be declared friends)
+ static reference_manager<T_Managed> Manager;
+ };
+
+
+
+
+
+ /**
+ An object that acts like a reference-counted pointer to an object.
+ The corresponding reference_manager is identified implicitly through
+ static references.
+
+ Example:
+ <code>
+ IXLIB_GARBAGE_DECLARE_MANAGER(int)
+
+ int main() {
+ ref<int> my_int = new int(5);
+ *my_int = 17;
+ ref<int> another_int = my_int;
+ *another_int = 12;
+
+ *my_int == 12; // true
+ }
+ </code>
+ */
+ template<class T,class T_Managed>
+ class ref : public ref_base<T> {
+ public:
+ // we have to have an explicit copy constructor, otherwise the
+ // compiler generates one, which is *ahem* - fatal
+ ref(ref const &src)
+ : ref_base<T>(src) {
+ reference_manager_keeper<T_Managed>::Manager.addReference(Instance);
+ }
+ template<class T2>
+ ref(ref<T2,T_Managed> const &src)
+ : ref_base<T>(src.get()) {
+ reference_manager_keeper<T_Managed>::Manager.addReference(Instance);
+ }
+ template<class T2>
+ ref(no_free_ref<T2,T_Managed> const &src)
+ : ref_base<T>(src.get()) {
+ reference_manager_keeper<T_Managed>::Manager.addReference(Instance);
+ }
+ ref(T *instance = NULL)
+ : ref_base<T>(instance) {
+ reference_manager_keeper<T_Managed>::Manager.addReference(Instance);
+ }
+ ~ref() {
+ reference_manager_keeper<T_Managed>::Manager.freeReference(Instance);
+ }
+
+ ref &operator=(ref const &src) {
+ set(src.get());
+ return *this;
+ }
+ ref &operator=(T *ptr) {
+ set(ptr);
+ return *this;
+ }
+
+ // methods
+ void release() {
+ reference_manager_keeper<T_Managed>::Manager.freeReference(Instance);
+ Instance = NULL;
+ }
+ void set(T *instance) {
+ if (instance == Instance) return;
+
+ reference_manager_keeper<T_Managed>::Manager.freeReference(Instance);
+ Instance = instance;
+ reference_manager_keeper<T_Managed>::Manager.addReference(Instance);
+ }
+ T *releaseFromGCArena() {
+ T *oldinst = Instance;
+ reference_manager_keeper<T_Managed>::Manager.forgetReference(Instance);
+ Instance = NULL;
+ return oldinst;
+ }
+ };
+
+
+
+
+ /**
+ An object that acts like a reference-counted pointer to an object.
+ However, the referenced object is not freed if the no_free_ref
+ is the last reference to the object to go out of scope.
+
+ This is useful to pass objects allocated e.g. on the stack along
+ inside ref's, while making sure they aren't freed.
+ (which would most probably lead to disaster)
+
+ no_free_ref's are mostly a hack, but there are situations where you cannot
+ avoid them. But even so, you should try not to use them where possible.
+
+ The corresponding reference_manager is identified implicitly through
+ static references.
+ */
+ template<class T,class T_Managed>
+ class no_free_ref : public ref_base<T>{
+ public:
+ // we have to have an explicit copy constructor, otherwise the
+ // compiler generates one, which is *ahem* - fatal
+ no_free_ref(no_free_ref const &src)
+ : ref_base<T>(src) {
+ reference_manager_keeper<T_Managed>::Manager.addNoFreeReference(Instance);
+ }
+ template<class T2>
+ no_free_ref(ref<T2,T_Managed> const &src)
+ : ref_base<T>(src.get()) {
+ reference_manager_keeper<T_Managed>::Manager.addNoFreeReference(Instance);
+ }
+ template<class T2>
+ no_free_ref(no_free_ref<T2,T_Managed> const &src)
+ : ref_base<T>(src.get()) {
+ reference_manager_keeper<T_Managed>::Manager.addNoFreeReference(Instance);
+ }
+ no_free_ref(T *instance = NULL)
+ : ref_base<T>(instance) {
+ reference_manager_keeper<T_Managed>::Manager.addNoFreeReference(Instance);
+ }
+ ~no_free_ref() {
+ reference_manager_keeper<T_Managed>::Manager.removeNoFreeReference(Instance);
+ }
+
+ // assignment
+ no_free_ref &operator=(no_free_ref const &src) {
+ set(src.get());
+ return *this;
+ }
+ no_free_ref &operator=(T *ptr) {
+ set(ptr);
+ return *this;
+ }
+
+ // methods
+ void release() {
+ reference_manager_keeper<T_Managed>::Manager.removeNoFreeReference(Instance);
+ Instance = NULL;
+ }
+ void set(T *instance) {
+ if (instance == Instance) return;
+
+ reference_manager_keeper<T_Managed>::Manager.removeNoFreeReference(Instance);
+ Instance = instance;
+ reference_manager_keeper<T_Managed>::Manager.addNoFreeReference(Instance);
+ }
+ T *releaseFromGCArena() {
+ T *oldinst = Instance;
+ reference_manager_keeper<T_Managed>::Manager.forgetReference(Instance);
+ Instance = NULL;
+ return oldinst;
+ }
+ };
+
+
+
+
+ /**
+ An object that acts like a reference-counted pointer to an object.
+ The corresponding reference_manager is identified explicitly.
+ */
+ template<class T>
+ class dynamic_ref : public ref_base<T> {
+ protected:
+ reference_manager<T> &Manager;
+
+ public:
+ dynamic_ref(dynamic_ref const &src)
+ : ref_base<T>(src),Manager(src.Manager) {
+ Manager.addReference(Instance);
+ }
+ dynamic_ref(reference_manager<T> &mgr,T *instance = NULL)
+ : ref_base<T>(instance),Manager(mgr) {
+ Manager.addReference(Instance);
+ }
+ ~dynamic_ref() {
+ Manager.freeReference(Instance);
+ }
+
+ // assignment
+ dynamic_ref &operator=(dynamic_ref const &src) {
+ set(src.get());
+ return *this;
+ }
+ dynamic_ref &operator=(T *ptr) {
+ set(ptr);
+ return *this;
+ }
+
+ // methods
+ void release() {
+ Manager.freeReference(Instance);
+ Instance = NULL;
+ }
+ void set(T *instance) {
+ if (instance == Instance) return;
+
+ Manager.freeReference(Instance);
+ Instance = instance;
+ Manager.addReference(Instance);
+ }
+ T *releaseFromGCArena() {
+ T *oldinst = Instance;
+ Manager.forgetReference(Instance);
+ Instance = NULL;
+ return oldinst;
+ }
+ };
+
+
+
+
+ /**
+ An object that acts like a reference-counted pointer to an object.
+ However, the referenced object is not freed if the no_free_ref
+ is the last reference to the object to go out of scope.
+
+ This is useful to pass objects allocated e.g. on the stack along
+ inside ref's, while making sure they aren't freed.
+ (which would most probably lead to disaster)
+
+ no_free_ref's are mostly a hack, but there are situations where you cannot
+ avoid them. But even so, you should try not to use them where possible.
+
+ The corresponding reference_manager is identified explicitly.
+ */
+ template<class T>
+ class no_free_dynamic_ref : public ref_base<T> {
+ protected:
+ reference_manager<T> &Manager;
+
+ public:
+ no_free_dynamic_ref(no_free_dynamic_ref const &src)
+ : ref_base<T>(src),Manager(src.Manager) {
+ Manager.addNoFreeReference(Instance);
+ }
+ no_free_dynamic_ref(reference_manager<T> &mgr,T *instance = NULL)
+ : ref_base<T>(instance),Manager(mgr) {
+ Manager.addNoFreeReference(Instance);
+ }
+ ~no_free_dynamic_ref() {
+ Manager.removeNoFreeReference(Instance);
+ }
+
+ // assignment
+ no_free_dynamic_ref &operator=(no_free_dynamic_ref const &src) {
+ set(src.get());
+ return *this;
+ }
+ no_free_dynamic_ref &operator=(T *ptr) {
+ set(ptr);
+ return *this;
+ }
+
+ // methods
+ void release() {
+ Manager.removeNoFreeReference(Instance);
+ Instance = NULL;
+ }
+ void set(T *instance) {
+ if (instance == Instance) return;
+
+ Manager.removeNoFreeReference(Instance);
+ Instance = instance;
+ Manager.addNoFreeReference(Instance);
+ }
+ T *releaseFromGCArena() {
+ T *oldinst = Instance;
+ Manager.forgetReference(Instance);
+ Instance = NULL;
+ return oldinst;
+ }
+ };
+
+
+
+
+ template<class T,class Deallocator>
+ class reference_manager {
+ protected:
+
+ struct instance_data {
+ T const *Instance;
+ TSize ReferenceCount,NoFreeReferenceCount;
+ instance_data *Next,*Previous;
+ };
+
+ class pointer_hash {
+ public:
+ };
+
+ typedef unsigned hash_value;
+ static hash_value const HASH_MAX = 0x3ff;
+
+ instance_data *Instances[HASH_MAX+1];
+ Deallocator Dealloc;
+
+ public:
+ reference_manager(Deallocator const &dealloc = Deallocator())
+ : Dealloc(dealloc) {
+ for (hash_value hv = 0;hv <= HASH_MAX;hv++)
+ Instances[hv] = NULL;
+ }
+
+ // *** FIXME should be
+ // protected:
+ // but cannot because partial specializations cannot be declared friends
+ void addReference(T const *instance) {
+ if (!instance) return;
+ instance_data *data = getHashEntry(instance);
+ data->ReferenceCount++;
+ }
+ void freeReference(T const *instance) {
+ if (!instance) return;
+ instance_data *data = getHashEntry(instance);
+ if (--data->ReferenceCount == 0 && data->NoFreeReferenceCount == 0) {
+ removeHashEntry(data);
+ Dealloc(instance);
+ }
+ }
+ void addNoFreeReference(T const *instance) {
+ if (!instance) return;
+ instance_data *data = getHashEntry(instance);
+ data->NoFreeReferenceCount++;
+ }
+ void removeNoFreeReference(T const *instance) {
+ if (!instance) return;
+ instance_data *data = getHashEntry(instance);
+ if (--data->NoFreeReferenceCount == 0) {
+ if (data->ReferenceCount != 0)
+ EXGEN_THROW(EC_REMAININGREF)
+ removeHashEntry(data);
+ }
+ }
+ void forgetReference(T const *instance) {
+ if (!instance) return;
+ instance_data *data = getHashEntry(instance);
+ if (data->ReferenceCount != 1)
+ EXGEN_THROW(EC_CANNOTREMOVEFROMGC)
+ removeHashEntry(data);
+ }
+
+ private:
+ hash_value hash(T const *ptr) const {
+ unsigned u = reinterpret_cast<unsigned>(ptr);
+ return (u ^ (u >> 8) ^ (u >> 16) ^ (u >> 24)) & HASH_MAX;
+ }
+ instance_data *getHashEntry(T const *instance) {
+ instance_data *data = Instances[hash(instance)];
+ while (data) {
+ if (data->Instance == instance) return data;
+ data = data->Next;
+ }
+
+ // not found, add new at front
+ instance_data *link = Instances[hash(instance)];
+ data = new instance_data;
+
+ data->Instance = instance;
+ data->ReferenceCount = 0;
+ data->NoFreeReferenceCount = 0;
+ data->Previous = NULL;
+ data->Next = link;
+ if (link) link->Previous = data;
+ Instances[hash(instance)] = data;
+ return data;
+ }
+ void removeHashEntry(instance_data *data) {
+ instance_data *prev = data->Previous;
+ if (prev) {
+ prev->Next = data->Next;
+ if (data->Next) data->Next->Previous = prev;
+ delete data;
+ }
+ else {
+ Instances[hash(data->Instance)] = data->Next;
+ if (data->Next) data->Next->Previous = NULL;
+ delete data;
+ }
+ }
+ };
+
+
+
+
+ #define IXLIB_GARBAGE_DECLARE_MANAGER(TYPE) \
+ ixion::reference_manager<TYPE> ixion::reference_manager_keeper<TYPE>::Manager;
+ }
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : ixlib internationalization wrapper
+// ----------------------------------------------------------------------------
+// (c) Copyright 2001 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_I18N
+
+
+
+
+#include <string>
+#include <libintl.h>
+#define _(String) gettext(String)
+#define N_(String) (String)
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript interpreter
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_JAVASCRIPT
+#define IXLIB_JAVASCRIPT
+
+
+
+
+#include <vector>
+#if __GNUC__ < 3
+ #include <hash_map>
+#else
+ #include <ext/hash_map>
+#endif
+#include <ixlib_string.hh>
+#include <ixlib_exbase.hh>
+#include <ixlib_garbage.hh>
+#include <ixlib_scanner.hh>
+
+
+
+
+// Error codes ----------------------------------------------------------------
+#define ECJS_UNTERMINATED_COMMENT 0
+#define ECJS_CANNOT_CONVERT 1
+#define ECJS_INVALID_OPERATION 2
+#define ECJS_UNEXPECTED 3
+#define ECJS_UNEXPECTED_EOF 4
+#define ECJS_CANNOT_MODIFY_RVALUE 5
+#define ECJS_UNKNOWN_IDENTIFIER 6
+#define ECJS_UNKNOWN_OPERATOR 7
+#define ECJS_INVALID_NON_LOCAL_EXIT 8
+#define ECJS_INVALID_NUMBER_OF_ARGUMENTS 9
+#define ECJS_INVALID_TOKEN 10
+#define ECJS_CANNOT_REDECLARE 11
+#define ECJS_DOUBLE_CONSTRUCTION 12
+#define ECJS_NO_SUPERCLASS 13
+#define ECJS_DIVISION_BY_ZERO 14
+
+
+
+
+// helpful macros -------------------------------------------------------------
+#define IXLIB_JS_ASSERT_PARAMETERS(NAME,ARGMIN,ARGMAX) \
+ if (parameters.size() < ARGMIN || parameters.size() > ARGMAX) \
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,NAME)
+
+#define IXLIB_JS_IF_METHOD(NAME,ARGMIN,ARGMAX) \
+ if (identifier == NAME) \
+ if (parameters.size() < ARGMIN || parameters.size() > ARGMAX) \
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,NAME) \
+ else
+
+#define IXLIB_JS_DECLARE_FUNCTION(NAME) \
+ namespace { \
+ class NAME : public value { \
+ public: \
+ value_type getType() const { \
+ return VT_FUNCTION; \
+ } \
+ ixion::ref<ixion::javascript::value> call(parameter_list const ¶meters); \
+ }; \
+ } \
+ ixion::ref<ixion::javascript::value> NAME::call(parameter_list const ¶meters)
+
+#define IXLIB_JS_CONVERT_PARAMETERS_0 \
+
+
+
+
+// Exception throw macros -----------------------------------------------------
+#define EXJS_THROW(CODE)\
+ EX_THROW(javascript,CODE)
+#define EXJS_THROWINFO(CODE,INFO)\
+ EX_THROWINFO(javascript,CODE,INFO)
+#define EXJS_THROW_NO_LOCATION(CODE)\
+ EX_THROW(no_location_javascript,CODE)
+#define EXJS_THROWINFO_NO_LOCATION(CODE,INFO)\
+ EX_THROWINFO(no_location_javascript,CODE,INFO)
+#define EXJS_THROWINFOLOCATION(CODE,INFO,LOCATION)\
+ throw ixion::javascript_exception(CODE,LOCATION,INFO,__FILE__,__LINE__);
+#define EXJS_THROWINFOTOKEN(CODE,INFO,TOKEN)\
+ EXJS_THROWINFOLOCATION(CODE,INFO,code_location(TOKEN))
+#define EXJS_THROWINFOEXPRESSION(CODE,INFO,EXPR)\
+ EXJS_THROWINFOLOCATION(CODE,INFO,(EXPR).getCodeLocation())
+
+
+
+
+
+namespace ixion {
+ namespace javascript {
+ struct code_location;
+ }
+
+ // exceptions ---------------------------------------------------------------
+ struct no_location_javascript_exception : public base_exception {
+ no_location_javascript_exception(TErrorCode error,char const *info = NULL,char *module = NULL,
+ TIndex line = 0)
+ : base_exception(error,info,module,line,"JS") {
+ }
+ virtual char *getText() const;
+ };
+
+
+
+
+ struct javascript_exception : public base_exception {
+ javascript_exception(TErrorCode error,char const *info = NULL,char *module = NULL,
+ TIndex line = 0)
+ : base_exception(error,info,module,line,"JS") {
+ }
+ javascript_exception(TErrorCode error,javascript::code_location const &loc,char const *info = 0,char *module = NULL,
+ TIndex line = 0);
+ javascript_exception(no_location_javascript_exception const &half_ex,javascript::code_location const &loc);
+ virtual char *getText() const;
+ };
+
+
+
+
+ // javascript ---------------------------------------------------------------
+ /**
+ This code tries to be an implementation of ECMAScript 4, as available at
+ http://www.mozilla.org/js/language/
+ Note that ES4 is still in the process of standardization.
+
+ It is meant to behave like an ES4 interpreter in strict mode, none
+ of the backward-compatible braindead-isms like newline semicolon
+ insertion and other stuff will ever be implemented.
+
+ This is the list of its shortcomings:
+ <ul>
+ <li> exceptions
+ <li> namespaces,packages
+ <li> constness
+ <li> Number/String constructor and class methods
+ <li> real regexp's
+ <li> the methods listed in FIXME's (js_library.cc js_value.cc)
+ <li> cannot cross-assign predefined methods [won't be]
+ <li> Grammatical semicolon insertion [won't be]
+ <li> type declaration [won't be]
+ </ul>
+
+ Be advised that a javascript value that is passed to you through the
+ interpreter, e.g. as a call parameter, may not be of the type that
+ you expect. For example, in "var x = 4; f(x);", what comes in as
+ the parameter x into f is a wrapper value that adds assign()ability
+ to a value that is wrapped inside. The advised solution to get the
+ object that you expect is to call eliminateWrappers() on the potentially
+ wrapped value.
+ */
+ namespace javascript {
+ class value;
+ class list_scope;
+ struct context {
+ ref<list_scope,value> DeclarationScope;
+ ref<value> LookupScope;
+
+ context(ref<list_scope,value> scope);
+ context(ref<value> scope);
+ context(ref<list_scope,value> decl_scope,ref<value> lookup_scope);
+ };
+
+ class expression;
+
+ class value {
+ public:
+ enum operator_id {
+ // unary, modifying
+ OP_PRE_INCREMENT,OP_POST_INCREMENT,
+ OP_PRE_DECREMENT,OP_POST_DECREMENT,
+ // unary, non-modifying
+ OP_UNARY_PLUS,OP_UNARY_MINUS,
+ OP_LOG_NOT,OP_BIN_NOT,
+ // binary, modifying
+ OP_PLUS_ASSIGN,OP_MINUS_ASSIGN,
+ OP_MUTLIPLY_ASSIGN,OP_DIVIDE_ASSIGN,OP_MODULO_ASSIGN,
+ OP_BIT_AND_ASSIGN,OP_BIT_OR_ASSIGN,OP_BIT_XOR_ASSIGN,
+ OP_LEFT_SHIFT_ASSIGN,OP_RIGHT_SHIFT_ASSIGN,
+ // binary, non-modifying
+ OP_PLUS,OP_MINUS,
+ OP_MULTIPLY,OP_DIVIDE,OP_MODULO,
+ OP_BIT_AND,OP_BIT_OR,OP_BIT_XOR,
+ OP_LEFT_SHIFT,OP_RIGHT_SHIFT,
+ OP_LOGICAL_OR,OP_LOGICAL_AND,
+ OP_EQUAL,OP_NOT_EQUAL,OP_IDENTICAL,OP_NOT_IDENTICAL,
+ OP_LESS_EQUAL,OP_GREATER_EQUAL,OP_LESS,OP_GREATER,
+ // special
+ OP_ASSIGN,
+ };
+
+ enum value_type {
+ VT_UNDEFINED,VT_NULL,
+ VT_INTEGER,VT_FLOATING_POINT,VT_STRING,
+ VT_FUNCTION,VT_OBJECT,VT_BUILTIN,VT_HOST,
+ VT_SCOPE,VT_BOUND_METHOD,VT_TYPE
+ };
+ typedef std::vector<ref<value> > parameter_list;
+
+ virtual ~value() {
+ }
+
+ virtual value_type getType() const = 0;
+ virtual std::string toString() const;
+ virtual int toInt() const;
+ virtual double toFloat() const;
+ virtual bool toBoolean() const;
+ // toString is meant as a type conversion, whereas stringify
+ // is for debuggers and the like
+ virtual std::string stringify() const;
+
+ virtual ref<value> eliminateWrappers();
+ virtual ref<value> duplicate();
+
+ virtual ref<value> lookup(std::string const &identifier);
+ virtual ref<value> subscript(value const &index);
+ virtual ref<value> call(parameter_list const ¶meters);
+ virtual ref<value> callAsMethod(ref<value> instance,parameter_list const ¶meters);
+ virtual ref<value> construct(parameter_list const ¶meters);
+ virtual ref<value> assign(ref<value> op2);
+
+ virtual ref<value> operatorUnary(operator_id op) const;
+ virtual ref<value> operatorBinary(operator_id op,ref<value> op2) const;
+ virtual ref<value> operatorBinaryShortcut(operator_id op,expression const &op2,context const &ctx) const;
+ virtual ref<value> operatorUnaryModifying(operator_id op);
+ virtual ref<value> operatorBinaryModifying(operator_id op,ref<value> op2);
+
+ static operator_id token2operator(scanner::token const &token,bool unary = false,bool prefix = false);
+ static std::string operator2string(operator_id op);
+ static std::string valueType2string(value_type vt);
+ };
+
+ // obviously, any value can have methods, but with this neat little
+ // interface implementing methods has just become easier.
+ class value_with_methods : public value {
+ class bound_method : public value {
+ std::string Identifier;
+ ref<value_with_methods,value> Parent;
+
+ public:
+ bound_method(std::string const &identifier,ref<value_with_methods,value> parent);
+
+ value_type getType() const {
+ return VT_BOUND_METHOD;
+ }
+
+ ref<value> duplicate();
+ ref<value> call(parameter_list const ¶meters);
+ };
+
+ public:
+ ref<value> lookup(std::string const &identifier);
+ virtual ref<value> callMethod(std::string const &identifier,parameter_list const ¶meters) = 0;
+ };
+
+ // obviously, any value can already represent a scope ("lookup" member!).
+ // the list_scope class is an explicit scope that can "swallow"
+ // (=unite with) other scopes and keeps a list of registered members
+ class list_scope : public value {
+ protected:
+ typedef std::hash_map<std::string,ref<value>,string_hash> member_map;
+ typedef std::vector<ref<value> > swallowed_list;
+
+ member_map MemberMap;
+ swallowed_list SwallowedList;
+
+ public:
+ value_type getType() const {
+ return VT_SCOPE;
+ }
+
+ ref<value> lookup(std::string const &identifier);
+
+ void unite(ref<value> scope);
+ void separate(ref<value> scope);
+ void clearScopes();
+
+ bool hasMember(std::string const &name) const;
+ void addMember(std::string const &name,ref<value> member);
+ void removeMember(std::string const &name);
+ void clearMembers();
+
+ void clear();
+ };
+
+ class js_array : public value_with_methods {
+ private:
+ typedef value_with_methods super;
+
+ protected:
+ typedef std::vector<ref<value> > value_array;
+ value_array Array;
+
+ public:
+ js_array() {
+ }
+ js_array(TSize size);
+ js_array(value_array::const_iterator first,value_array::const_iterator last)
+ : Array(first,last) {
+ }
+ js_array(js_array const &src)
+ : Array(src.Array) {
+ }
+
+ value_type getType() const {
+ return VT_BUILTIN;
+ }
+
+ std::string stringify() const;
+
+ ref<value> duplicate();
+
+ ref<value> lookup(std::string const &identifier);
+ ref<value> subscript(value const &index);
+ ref<value> callMethod(std::string const &identifier,parameter_list const ¶meters);
+
+ TSize size() const {
+ return Array.size();
+ }
+ void resize(TSize size);
+ ref<value> &operator[](TIndex idx);
+ void push_back(ref<value> val);
+ };
+
+ class expression;
+
+ ref<value> makeUndefined();
+ ref<value> makeNull();
+ ref<value> makeValue(signed long val);
+ ref<value> makeConstant(signed long val);
+ ref<value> makeValue(signed int val);
+ ref<value> makeConstant(signed int val);
+ ref<value> makeValue(unsigned long val);
+ ref<value> makeConstant(unsigned long val);
+ ref<value> makeValue(unsigned int val);
+ ref<value> makeConstant(unsigned int val);
+ ref<value> makeValue(double val);
+ ref<value> makeConstant(double val);
+ ref<value> makeValue(std::string const &val);
+ ref<value> makeConstant(std::string const &val);
+ ref<value> makeArray(TSize size = 0);
+ ref<value> makeLValue(ref<value> target);
+ ref<value> wrapConstant(ref<value> val);
+
+ class interpreter {
+ public:
+ ref<list_scope,value> RootScope;
+
+ public:
+ interpreter();
+ ~interpreter();
+
+ ref<expression> parse(std::string const &str);
+ ref<expression> parse(std::istream &istr);
+ ref<value> execute(std::string const &str);
+ ref<value> execute(std::istream &istr);
+ ref<value> execute(ref<expression> expr);
+
+ private:
+ ref<value> evaluateCatchExits(ref<expression> expr);
+ };
+
+ void addGlobal(interpreter &ip);
+ void addMath(interpreter &ip);
+ void addStandardLibrary(interpreter &ip);
+ }
+ }
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript interpreter
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_JS_INTERNALS
+#define IXLIB_JS_INTERNALS
+
+
+
+
+#include <ixlib_javascript.hh>
+
+
+
+
+using namespace std;
+
+
+
+
+namespace ixion {
+ namespace javascript {
+ struct code_location {
+ TIndex Line;
+
+ code_location(scanner::token &tok);
+ explicit code_location(TIndex line);
+ string stringify() const;
+ };
+
+ struct return_exception {
+ ref<value> ReturnValue;
+ code_location Location;
+
+ return_exception(ref<value> retval,code_location const &loc)
+ : ReturnValue(retval),Location(loc) {
+ }
+ };
+
+ struct break_exception {
+ bool HasLabel;
+ string Label;
+ code_location Location;
+
+ break_exception(bool has_label,string const &label,code_location const &loc)
+ : HasLabel(has_label),Label(label),Location(loc) {
+ }
+ };
+
+ struct continue_exception {
+ bool HasLabel;
+ string Label;
+ code_location Location;
+
+ continue_exception(bool has_label,string const &label,code_location const &loc)
+ : HasLabel(has_label),Label(label),Location(loc) {
+ }
+ };
+
+ // values -----------------------------------------------------------------
+ class null : public value {
+ private:
+ typedef value super;
+
+ public:
+ value_type getType() const;
+ bool toBoolean() const;
+
+ ref<value> duplicate();
+ };
+
+ class const_floating_point : public value_with_methods {
+ private:
+ typedef value_with_methods super;
+
+ protected:
+ double Value;
+
+ public:
+ const_floating_point(double value);
+
+ value_type getType() const;
+ int toInt() const;
+ double toFloat() const;
+ bool toBoolean() const;
+ string toString() const;
+
+ ref<value> duplicate();
+
+ ref<value> callMethod(string const &identifier,parameter_list const ¶meters);
+
+ ref<value> operatorUnary(operator_id op) const;
+ ref<value> operatorBinary(operator_id op,ref<value> op2) const;
+ };
+
+ class floating_point : public const_floating_point {
+ private:
+ typedef const_floating_point super;
+
+ public:
+ floating_point(double value);
+
+ ref<value> operatorUnaryModifying(operator_id op);
+ ref<value> operatorBinaryModifying(operator_id op,ref<value> op2);
+ };
+
+ class const_integer : public value_with_methods {
+ private:
+ typedef value_with_methods super;
+
+ protected:
+ long Value;
+
+ public:
+ const_integer(long value);
+
+ value_type getType() const;
+ int toInt() const;
+ double toFloat() const;
+ bool toBoolean() const;
+ string toString() const;
+
+ ref<value> duplicate();
+
+ ref<value> callMethod(string const &identifier,parameter_list const ¶meters);
+
+ ref<value> operatorUnary(operator_id op) const;
+ ref<value> operatorBinary(operator_id op,ref<value> op2) const;
+ };
+
+ class integer : public const_integer {
+ private:
+ typedef const_integer super;
+
+ public:
+ integer(long value);
+
+ ref<value> operatorUnaryModifying(operator_id op);
+ ref<value> operatorBinaryModifying(operator_id op,ref<value> op2);
+ };
+
+ class js_string : public value_with_methods {
+ private:
+ typedef value_with_methods super;
+
+ protected:
+ string Value;
+
+ public:
+ js_string(string const &value);
+
+ value_type getType() const;
+ string toString() const;
+ bool toBoolean() const;
+ string stringify() const;
+
+ ref<value> duplicate();
+
+ ref<value> lookup(string const &identifier);
+ ref<value> callMethod(string const &identifier,parameter_list const ¶meters);
+
+ ref<value> operatorBinary(operator_id op,ref<value> op2) const;
+ ref<value> operatorBinaryModifying(operator_id op,ref<value> op2);
+ };
+
+ class lvalue : public value {
+ protected:
+ ref<value> Reference;
+
+ public:
+ lvalue(ref<value> ref);
+
+ value_type getType() const;
+ string toString() const;
+ int toInt() const;
+ double toFloat() const;
+ bool toBoolean() const;
+ string stringify() const;
+
+ ref<value> eliminateWrappers();
+ ref<value> duplicate();
+
+ ref<value> lookup(string const &identifier);
+ ref<value> subscript(value const &index);
+ ref<value> call(parameter_list const ¶meters);
+ ref<value> callAsMethod(ref<value> instance,parameter_list const ¶meters);
+ ref<value> construct(parameter_list const ¶meters);
+ ref<value> assign(ref<value> op2);
+
+ ref<value> operatorUnary(operator_id op) const;
+ ref<value> operatorBinary(operator_id op,ref<value> op2) const;
+ ref<value> operatorBinaryShortcut(operator_id op,expression const &op2,context const &ctx) const;
+ ref<value> operatorUnaryModifying(operator_id op);
+ ref<value> operatorBinaryModifying(operator_id op,ref<value> op2);
+ };
+
+ class constant_wrapper : public value {
+ protected:
+ ref<value> Constant;
+
+ public:
+ constant_wrapper(ref<value> val);
+
+ value_type getType() const;
+ string toString() const;
+ int toInt() const;
+ double toFloat() const;
+ bool toBoolean() const;
+ string stringify() const;
+
+ ref<value> eliminateWrappers();
+ ref<value> duplicate();
+
+ ref<value> lookup(string const &identifier);
+ ref<value> subscript(value const &index);
+ ref<value> call(parameter_list const ¶meters) const;
+ ref<value> callAsMethod(ref<value> instance,parameter_list const ¶meters);
+ ref<value> construct(parameter_list const ¶meters);
+ ref<value> assign(ref<value> value);
+
+ ref<value> operatorUnary(operator_id op) const;
+ ref<value> operatorBinary(operator_id op,ref<value> op2) const;
+ ref<value> operatorBinaryShortcut(operator_id op,expression const &op2,context const &ctx) const;
+ ref<value> operatorUnaryModifying(operator_id op);
+ ref<value> operatorBinaryModifying(operator_id op,ref<value> op2);
+ };
+
+ class callable_with_parameters : public value {
+ public:
+ typedef vector<string> parameter_name_list;
+
+ protected:
+ parameter_name_list ParameterNameList;
+
+ public:
+ callable_with_parameters(parameter_name_list const &pnames);
+
+ void addParametersTo(list_scope &scope,parameter_list const ¶meters) const;
+ static ref<value> evaluateBody(expression &body,context const &ctx);
+ };
+
+ class function : public callable_with_parameters {
+ typedef callable_with_parameters super;
+ ref<expression> Body;
+ ref<value> LexicalScope;
+
+ public:
+ function(parameter_name_list const &pnames,ref<expression> body,ref<value> lex_scope);
+
+ value_type getType() const{
+ return VT_FUNCTION;
+ }
+
+ ref<value> duplicate();
+
+ ref<value> call(parameter_list const ¶meters);
+ };
+
+ class method : public callable_with_parameters {
+ typedef callable_with_parameters super;
+ ref<expression> Body;
+ ref<value> LexicalScope;
+
+ public:
+ method(parameter_name_list const &pnames,ref<expression> body,ref<value> lex_scope);
+
+ value_type getType() const{
+ return VT_FUNCTION;
+ }
+
+ ref<value> duplicate();
+
+ ref<value> callAsMethod(ref<value> instance,parameter_list const ¶meters);
+ };
+
+ class constructor : public callable_with_parameters {
+ typedef callable_with_parameters super;
+ ref<expression> Body;
+ ref<value> LexicalScope;
+
+ public:
+ constructor(parameter_name_list const &pnames,ref<expression> body,ref<value> lex_scope);
+
+ value_type getType() const{
+ return VT_FUNCTION;
+ }
+
+ ref<value> duplicate();
+ ref<value> callAsMethod(ref<value> instance,parameter_list const ¶meters);
+ };
+
+ class js_class : public value {
+ class super_instance_during_construction : public value {
+ // this object constructs the superclass
+ // a) if it is called, by calling the super constructor
+ // with the aprropriate parameters
+ // b) implicitly with no super constructor arguments,
+ // if the super object is referenced explicitly
+
+ ref<value> SuperClass;
+ ref<value> SuperClassInstance;
+
+ public:
+ super_instance_during_construction(ref<value> super_class);
+
+ value_type getType() const {
+ return VT_OBJECT;
+ }
+
+ ref<value> call(parameter_list const ¶meters);
+ ref<value> lookup(string const &identifier);
+
+ ref<value> getSuperClassInstance();
+ };
+
+ typedef vector<ref<expression> > declaration_list;
+
+ ref<value> LexicalScope;
+ ref<value> SuperClass;
+ ref<value> Constructor;
+ ref<value> StaticMethodScope;
+ ref<value> MethodScope;
+ ref<value> StaticVariableScope;
+ declaration_list VariableList;
+
+ public:
+ js_class(ref<value> lex_scope,ref<value> super_class,ref<value> constructor,
+ ref<value> static_method_scope,ref<value> method_scope,
+ ref<value> static_variable_scope,declaration_list const &variable_list);
+
+ value_type getType() const {
+ return VT_TYPE;
+ }
+
+ ref<value> duplicate();
+ ref<value> lookup(string const &identifier);
+ ref<value> lookupLocal(string const &identifier);
+ ref<value> construct(parameter_list const ¶meters);
+ };
+
+ class js_class_instance : public value {
+ class bound_method : public value {
+ ref<value> Instance;
+ ref<value> Method;
+
+ public:
+ bound_method(ref<value> instance,ref<value> method);
+
+ value_type getType() const {
+ return VT_BOUND_METHOD;
+ }
+
+ ref<value> call(parameter_list const ¶meters);
+ };
+
+ ref<value> SuperClassInstance;
+ ref<js_class,value> Class;
+ ref<value> MethodScope;
+ ref<value> VariableScope;
+
+ public:
+ js_class_instance(ref<js_class,value> cls,ref<value> method_scope,
+ ref<value> variable_scope);
+
+ void setSuperClassInstance(ref<value> super_class_instance);
+
+ value_type getType() const {
+ return VT_OBJECT;
+ }
+
+ ref<value> duplicate();
+ ref<value> lookup(string const &identifier);
+ };
+
+ class js_array_constructor : public value {
+ public:
+ value_type getType() const {
+ return VT_TYPE;
+ }
+
+ ref<value> duplicate();
+ ref<value> construct(parameter_list const ¶meters);
+ };
+
+ // expressions ----------------------------------------------------------
+ class expression {
+ code_location Location;
+
+ public:
+ expression(code_location const &loc);
+ virtual ~expression();
+ virtual ref<value> evaluate(context const &ctx) const = 0;
+
+ code_location const &getCodeLocation() const {
+ return Location;
+ }
+ };
+
+ class constant : public expression {
+ ref<value> Value;
+ public:
+ constant(ref<value> val,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class unary_operator : public expression {
+ value::operator_id Operator;
+ ref<expression> Operand;
+
+ public:
+ unary_operator(value::operator_id opt,ref<expression> opn,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class modifying_unary_operator : public expression {
+ value::operator_id Operator;
+ ref<expression> Operand;
+
+ public:
+ modifying_unary_operator(value::operator_id opt,ref<expression> opn,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class binary_operator : public expression {
+ value::operator_id Operator;
+ ref<expression> Operand1;
+ ref<expression> Operand2;
+
+ public:
+ binary_operator(value::operator_id opt,ref<expression> opn1,ref<expression> opn2,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class binary_shortcut_operator : public expression {
+ value::operator_id Operator;
+ ref<expression> Operand1;
+ ref<expression> Operand2;
+
+ public:
+ binary_shortcut_operator(value::operator_id opt,ref<expression> opn1,ref<expression> opn2,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class modifying_binary_operator : public expression {
+ value::operator_id Operator;
+ ref<expression> Operand1;
+ ref<expression> Operand2;
+
+ public:
+ modifying_binary_operator(value::operator_id opt,ref<expression> opn1,ref<expression> opn2,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class ternary_operator : public expression {
+ ref<expression> Operand1;
+ ref<expression> Operand2;
+ ref<expression> Operand3;
+
+ public:
+ ternary_operator(ref<expression> opn1,ref<expression> opn2,ref<expression> opn3,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class subscript_operation : public expression {
+ ref<expression> Operand1;
+ ref<expression> Operand2;
+
+ public:
+ subscript_operation(ref<expression> opn1,ref<expression> opn2,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class lookup_operation : public expression {
+ ref<expression> Operand;
+ string Identifier;
+
+ public:
+ lookup_operation(string const &id,code_location const &loc);
+ lookup_operation(ref<expression> opn,string const &id,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class assignment : public expression {
+ ref<expression> Operand1;
+ ref<expression> Operand2;
+
+ public:
+ assignment(ref<expression> opn1,ref<expression> opn2,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class basic_call : public expression {
+ public:
+ typedef vector<ref<expression> > parameter_expression_list;
+ typedef vector<ref<value> > parameter_value_list;
+
+ private:
+ parameter_expression_list ParameterExpressionList;
+
+ public:
+ basic_call(parameter_expression_list const &pexps,code_location const &loc);
+ void makeParameterValueList(context const &ctx,parameter_value_list &pvalues) const;
+ };
+
+ class function_call : public basic_call {
+ typedef basic_call super;
+ ref<expression> Function;
+
+ public:
+ function_call(ref<expression> fun,parameter_expression_list const &pexps,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class construction : public basic_call {
+ typedef basic_call super;
+ ref<expression> Class;
+
+ public:
+ construction(ref<expression> cls,parameter_expression_list const &pexps,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ // declarations -----------------------------------------------------------
+ class variable_declaration : public expression {
+ protected:
+ string Identifier;
+ ref<expression> DefaultValue;
+
+ public:
+ variable_declaration(string const &id,ref<expression> def_value,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class constant_declaration : public expression {
+ protected:
+ string Identifier;
+ ref<expression> DefaultValue;
+
+ public:
+ constant_declaration(string const &id,ref<expression> def_value,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class function_declaration : public expression {
+ public:
+ typedef function::parameter_name_list parameter_name_list;
+
+ private:
+ string Identifier;
+ parameter_name_list ParameterNameList;
+ ref<expression> Body;
+
+ public:
+ function_declaration(string const &id,parameter_name_list const &pnames,
+ ref<expression> body,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class method_declaration : public expression {
+ public:
+ typedef method::parameter_name_list parameter_name_list;
+
+ private:
+ string Identifier;
+ parameter_name_list ParameterNameList;
+ ref<expression> Body;
+
+ public:
+ method_declaration(string const &id,parameter_name_list const &pnames,
+ ref<expression> body,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class constructor_declaration : public expression {
+ public:
+ typedef method::parameter_name_list parameter_name_list;
+
+ private:
+ parameter_name_list ParameterNameList;
+ ref<expression> Body;
+
+ public:
+ constructor_declaration(parameter_name_list const &pnames,
+ ref<expression> body,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_class_declaration : public expression {
+ typedef vector<ref<expression> > declaration_list;
+
+ string Identifier;
+ ref<expression> SuperClass;
+ ref<expression> ConstructorDeclaration;
+ declaration_list StaticMethodList;
+ declaration_list MethodList;
+ declaration_list StaticVariableList;
+ declaration_list VariableList;
+
+ public:
+ js_class_declaration(string const &id,ref<expression> superclass,
+ code_location const &loc);
+
+ ref<value> evaluate(context const &ctx) const;
+
+ void setConstructor(ref<expression> decl);
+ void addStaticMethod(ref<expression> decl);
+ void addMethod(ref<expression> decl);
+ void addStaticVariable(ref<expression> decl);
+ void addVariable(ref<expression> decl);
+ };
+
+ // instructions ---------------------------------------------------------
+ class instruction_list : public expression {
+ typedef vector<ref<expression> > expression_list;
+ expression_list ExpressionList;
+
+ public:
+ instruction_list(code_location const &loc)
+ : expression(loc) {
+ }
+ ref<value> evaluate(context const &ctx) const;
+ void add(ref<expression> expr);
+ };
+
+ class scoped_instruction_list : public instruction_list {
+ public:
+ scoped_instruction_list(code_location const &loc)
+ : instruction_list(loc) {
+ }
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_if : public expression {
+ ref<expression> Conditional;
+ ref<expression> IfExpression;
+ ref<expression> IfNotExpression;
+
+ public:
+ js_if(ref<expression> cond,ref<expression> ifex,ref<expression> ifnotex,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_while : public expression {
+ ref<expression> Conditional;
+ ref<expression> LoopExpression;
+ bool HasLabel;
+ string Label;
+
+ public:
+ js_while(ref<expression> cond,ref<expression> loopex,code_location const &loc);
+ js_while(ref<expression> cond,ref<expression> loopex,string const &Label,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_do_while : public expression {
+ ref<expression> Conditional;
+ ref<expression> LoopExpression;
+ bool HasLabel;
+ string Label;
+
+ public:
+ js_do_while(ref<expression> cond,ref<expression> loopex,code_location const &loc);
+ js_do_while(ref<expression> cond,ref<expression> loopex,string const &Label,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_for : public expression {
+ ref<expression> Initialization;
+ ref<expression> Conditional;
+ ref<expression> Update;
+ ref<expression> LoopExpression;
+ bool HasLabel;
+ string Label;
+
+ public:
+ js_for(ref<expression> init,ref<expression> cond,ref<expression> update,ref<expression> loop,code_location const &loc);
+ js_for(ref<expression> init,ref<expression> cond,ref<expression> update,ref<expression> loop,string const &label,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_for_in : public expression {
+ ref<expression> Iterator;
+ ref<expression> Array;
+ ref<expression> LoopExpression;
+ bool HasLabel;
+ string Label;
+
+ public:
+ js_for_in(ref<expression> iter,ref<expression> array,ref<expression> loop,code_location const &loc);
+ js_for_in(ref<expression> iter,ref<expression> array,ref<expression> loop,string const &label,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_return : public expression {
+ ref<expression> ReturnValue;
+
+ public:
+ js_return(ref<expression> retval,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_break : public expression {
+ bool HasLabel;
+ string Label;
+
+ public:
+ js_break(code_location const &loc);
+ js_break(string const &label,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_continue : public expression {
+ bool HasLabel;
+ string Label;
+
+ public:
+ js_continue(code_location const &loc);
+ js_continue(string const &label,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class break_label : public expression {
+ string Label;
+ ref<expression> Expression;
+
+ public:
+ break_label(string const &label,ref<expression> expr,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ };
+
+ class js_switch : public expression {
+ bool HasLabel;
+ string Label;
+ ref<expression> Discriminant;
+
+ struct case_label {
+ ref<expression> DiscriminantValue;
+ ref<expression> Expression;
+ };
+ typedef vector<case_label> case_list;
+ case_list CaseList;
+
+ public:
+ js_switch(ref<expression> discriminant,code_location const &loc);
+ js_switch(ref<expression> discriminant,string const &label,code_location const &loc);
+ ref<value> evaluate(context const &ctx) const;
+ void addCase(ref<expression> dvalue,ref<expression> expr);
+ };
+ }
+ }
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Numeric conversions
+// ----------------------------------------------------------------------------
+// (c) Copyright 1999 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_NUMCONV
+#define IXLIB_NUMCONV
+
+
+
+
+#include <ixlib_base.hh>
+#include <ixlib_string.hh>
+
+
+
+
+// Macros ---------------------------------------------------------------------
+#define IXLIB_NUMCHARS "0123456789ABCDEF"
+
+
+
+
+// Functions ------------------------------------------------------------------
+namespace ixion {
+ std::string float2dec(double value);
+ std::string float2dec(double value,unsigned int precision);
+ std::string unsigned2base(unsigned long value,char digits = 0,char radix = 10);
+ inline std::string unsigned2dec(unsigned long value,char digits = 0)
+ { return unsigned2base(value,digits,10); }
+ inline std::string unsigned2hex(unsigned long value,char digits = 0)
+ { return unsigned2base(value,digits,16); }
+ inline std::string unsigned2bin(unsigned long value,char digits = 0)
+ { return unsigned2base(value,digits,2); }
+ inline std::string unsigned2oct(unsigned long value,char digits = 0)
+ { return unsigned2base(value,digits,8); }
+ std::string signed2base(signed long value,char digits = 0,char radix = 10);
+ inline std::string signed2dec(signed long value,char digits = 0)
+ { return signed2base(value,digits,10); }
+ inline std::string signed2hex(signed long value,char digits = 0)
+ { return signed2base(value,digits,16); }
+ inline std::string signed2bin(signed long value,char digits = 0)
+ { return signed2base(value,digits,2); }
+ inline std::string signed2oct(signed long value,char digits = 0)
+ { return signed2base(value,digits,8); }
+
+ std::string bytes2dec(TSize bytes);
+
+ unsigned long evalNumeral(std::string const &numeral,unsigned radix = 10);
+ double evalFloat(std::string const &numeral);
+ unsigned long evalUnsigned(std::string const &numeral,unsigned default_base = 10);
+ signed long evalSigned(std::string const &numeral,unsigned default_base = 10);
+ }
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : numeric / order processing
+// ----------------------------------------------------------------------------
+// (c) Copyright 1996 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_NUMERIC
+#define IXLIB_NUMERIC
+
+
+
+
+#include <cstring>
+#include <ixlib_base.hh>
+#include <ixlib_exgen.hh>
+
+
+
+
+// Macros ---------------------------------------------------------------------
+#ifdef _GNUC_
+ #define NUM_MIN(a,b) ( (a)<?(b) )
+ #define NUM_MAX(a,b) ( (a)>?(b) )
+ #define NUM_ABS(a) ( (a)<0 ? (-(a)) : (a) )
+#else
+ #define NUM_MIN(a,b) ( (a)<(b) ? (a) : (b) )
+ #define NUM_MAX(a,b) ( (a)>(b) ? (a) : (b) )
+ #define NUM_ABS(a) ( (a)<0 ? (-(a)) : (a) )
+#endif
+
+#define NUM_LIMIT(lower,value,upper) \
+ ( NUM_MAX(lower,NUM_MIN(upper,vallue)) )
+#define NUM_INBOUND(lower,value,upper) \
+ (((lower) <= (value)) && ((value) <= (upper)))
+#define NUM_OVERLAP(a1,a2,b1,b2) \
+ ((((a1)<=(b1))&&((a2)>(b1)))||(((a1)<(b2))&&((a2)>(b2)))||(((a1)>=(b1))&&((a2)<=(b2))))
+#define NUM_CIRCLEINC(index,size) \
+ ( ((index)+1) >= (size) ? 0 : ((index)+1) )
+#define NUM_CIRCLEDIST(head,tail,size) \
+ ( (head)<(tail) ? ((head)+(size)-(tail)) : ((head)-(tail)) )
+
+
+
+
+// Primitive inlines ---------------------------------------------------------
+namespace ixion {
+ inline signed short sgn(signed long value);
+ inline bool getBit(unsigned long value,char bit);
+ inline TUnsigned8 hiByte(TUnsigned16 value);
+ inline TUnsigned16 hiWord(TUnsigned32 value);
+ inline TUnsigned8 loByte(TUnsigned16 value);
+ inline TUnsigned16 loWord(TUnsigned32 value);
+ inline TUnsigned16 makeWord(TUnsigned8 hi,TUnsigned8 lo);
+ inline TUnsigned32 makeDWord(TUnsigned16 hi,TUnsigned16 lo);
+
+
+
+
+// BCD encoding ---------------------------------------------------------------
+ unsigned long unsigned2BCD(unsigned long value);
+ unsigned long BCD2unsigned(unsigned long value);
+
+
+
+
+// Primitive inlines ---------------------------------------------------------
+ inline signed short ixion::sgn(signed long value) {
+ return (value<0) ? -1 : ( (value>0) ? 1 : 0);
+ }
+
+
+
+
+ inline bool ixion::getBit(unsigned long value,char bit) {
+ return (value >> bit) & 1;
+ }
+
+
+
+
+ inline TUnsigned8 ixion::hiByte(TUnsigned16 value) {
+ return value >> 8;
+ }
+
+
+
+
+ inline TUnsigned16 ixion::hiWord(TUnsigned32 value) {
+ return value >> 16;
+ }
+
+
+
+
+ inline TUnsigned8 ixion::loByte(TUnsigned16 value) {
+ return value & 0xff;
+ }
+
+
+
+
+ inline TUnsigned16 ixion::loWord(TUnsigned32 value) {
+ return value & 0xffff;
+ }
+
+
+
+
+ inline TUnsigned16 ixion::makeWord(TUnsigned8 hi,TUnsigned8 lo) {
+ return (TUnsigned16) hi << 8 | lo;
+ }
+
+
+
+
+ inline TUnsigned32 ixion::makeDWord(TUnsigned16 hi,TUnsigned16 lo) {
+ return (TUnsigned32) hi << 16 | lo;
+ }
+ }
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Random numbers
+// ----------------------------------------------------------------------------
+// (c) Copyright 1996 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_RANDOM
+#define IXLIB_RANDOM
+
+
+
+
+#include <cstdlib>
+#include <cmath>
+#include <ctime>
+#include <ixlib_base.hh>
+#include <ixlib_numeric.hh>
+
+
+
+
+namespace ixion {
+ class float_random {
+ double Seed;
+
+ public:
+ float_random()
+ : Seed(1)
+ { }
+
+ void init() {
+ double current_time = time(NULL);
+ Seed = current_time*sin(current_time);
+ }
+ void init(double seed)
+ { Seed = NUM_ABS(seed); }
+
+ /// Generate one random number in the interval [0,max).
+ double operator()(double max = 1) {
+ // normalize
+ while (Seed > 3) Seed = log(Seed);
+ Seed -= floor(Seed);
+ Seed = pow(Seed+Pi,8);
+ Seed -= floor(Seed);
+ return Seed*max;
+ }
+ };
+
+
+
+
+ class int_random {
+ float_random Generator;
+
+ public:
+ int_random()
+ { }
+
+ void init()
+ { Generator.init(); }
+ void init(unsigned seed)
+ { Generator.init(seed); }
+
+ /// Generate one random number in the interval [0,max).
+ unsigned operator()(unsigned max = 32768) {
+ unsigned num = rng8() + (rng8() << 7) + (rng8() << 14) + (rng8() << 21) + (rng8() << 28);
+ return num % max;
+ }
+ private:
+ TUnsigned8 rng8() {
+ return (TUnsigned8) (Generator()*256);
+ }
+ };
+ }
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Regular expressions string object
+// ----------------------------------------------------------------------------
+// (c) Copyright 1998 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_RE
+#define IXLIB_RE
+
+
+
+
+#include <vector>
+#include <memory>
+#include <ixlib_exgen.hh>
+#include <ixlib_string.hh>
+
+
+
+
+// Regex exceptions -----------------------------------------------------------
+#define ECRE_INVQUANTIFIER 0
+#define ECRE_UNBALBACKREF 1
+#define ECRE_INVESCAPE 2
+#define ECRE_INVBACKREF 3
+#define ECRE_UNTERMCLASS 4
+#define ECRE_NOPATTERN 5
+
+
+
+
+namespace ixion {
+ class regex_exception : public base_exception {
+ public:
+ regex_exception(TErrorCode error,char const *info = NULL,char *module = NULL,TIndex line = 0);
+ virtual char *getText() const;
+ };
+ }
+
+
+
+
+// Regex token macros ---------------------------------------------------------
+#define XSTRRE_LITERAL '\\'
+#define XSTRRE_BACKREF '\\'
+#define XSTRRE_ESCAPESEQ '\\'
+#define XSTRRE_ANYCHAR '.'
+#define XSTRRE_START '^'
+#define XSTRRE_END '$'
+#define XSTRRE_ALTERNATIVE '|'
+#define XSTRRE_CLASSSTART '['
+#define XSTRRE_CLASSNEG '^'
+#define XSTRRE_CLASSRANGE '-'
+#define XSTRRE_CLASSSTOP ']'
+
+#define XSTRRE_BACKREFSTART '('
+#define XSTRRE_BACKREFSTOP ')'
+
+#define XSTRREQ_0PLUS '*'
+#define XSTRREQ_1PLUS '+'
+#define XSTRREQ_01 '?'
+#define XSTRREQ_START '{'
+#define XSTRREQ_RANGE ','
+#define XSTRREQ_STOP '}'
+#define XSTRREQ_NONGREEDY '?'
+
+
+
+
+namespace ixion {
+ /**
+ A class implementing a generic regular expression matcher not only for strings.
+ If you are looking for a usual regular expresion parser, look at
+ ixion::regex_string.
+
+ If you query anything about the last match, and that last match did
+ never happen, behavior is undefined.
+ */
+
+ template<class T>
+ class regex {
+ protected:
+ // various helper classes -----------------------------------------------
+ class backref_stack {
+ private:
+ struct backref_entry {
+ enum { OPEN,CLOSE } Type;
+ TIndex Index;
+ };
+
+ typedef std::vector<backref_entry> internal_stack;
+
+ internal_stack Stack;
+
+ public:
+ typedef TSize rewind_info;
+
+ void open(TIndex index);
+ void close(TIndex index);
+
+ rewind_info getRewindInfo() const;
+ void rewind(rewind_info ri);
+ void clear();
+
+ TSize size();
+ T get(TIndex number,T const &candidate) const;
+ };
+
+
+
+
+ // matchers -------------------------------------------------------------
+ class matcher {
+ protected:
+ matcher *Next;
+ bool OwnNext;
+ TSize MatchLength;
+
+ public:
+ matcher();
+ virtual ~matcher();
+
+ virtual matcher *duplicate() const = 0;
+
+ TSize getMatchLength() const {
+ return MatchLength;
+ }
+ TSize subsequentMatchLength() const;
+ virtual TSize minimumMatchLength() const = 0;
+ TSize minimumSubsequentMatchLength() const;
+
+ matcher *getNext() const {
+ return Next;
+ }
+ virtual void setNext(matcher *next,bool ownnext = true) {
+ Next = next;
+ OwnNext = ownnext;
+ }
+
+ // this routine must set the MatchLength member correctly.
+ virtual bool match(backref_stack &brstack,T const &candidate,TIndex at)
+ = 0;
+
+ protected:
+ bool matchNext(backref_stack &brstack,T const &candidate,TIndex at) const {
+ return Next ? Next->match(brstack,candidate,at) : true;
+ }
+ void copy(matcher const *src);
+ };
+
+
+
+
+ class quantifier : public matcher {
+ private:
+ typedef matcher super;
+ bool Greedy,MaxValid;
+ TSize MinCount,MaxCount;
+ matcher *Quantified;
+
+ struct backtrack_stack_entry {
+ TIndex Index;
+ backref_stack::rewind_info RewindInfo;
+ };
+
+ public:
+ quantifier()
+ : Quantified(NULL) {
+ }
+ quantifier(bool greedy,TSize mincount);
+ quantifier(bool greedy,TSize mincount,TSize maxcount);
+ ~quantifier();
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const;
+
+ void setQuantified(matcher *quantified) {
+ Quantified = quantified;
+ }
+ bool match(backref_stack &brstack,T const &candidate,TIndex at);
+
+ protected:
+ void copy(quantifier const *src);
+ };
+
+
+
+
+ class sequence_matcher : public matcher {
+ T MatchStr;
+
+ public:
+ sequence_matcher(T const &matchstr);
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const {
+ return MatchStr.size();
+ }
+ bool match(backref_stack &brstack,T const &candidate,TIndex at);
+ };
+
+
+
+
+ class any_matcher : public matcher {
+ public:
+ any_matcher() {
+ MatchLength = 1;
+ }
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const {
+ return 1;
+ }
+ bool match(backref_stack &brstack,T const &candidate,TIndex at) {
+ return at < candidate.size() && matchNext(brstack,candidate,at+1);
+ }
+ };
+
+
+
+
+ class start_matcher : public matcher {
+ public:
+ start_matcher() {
+ MatchLength = 0;
+ }
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const {
+ return 0;
+ }
+ bool match(backref_stack &brstack,T const &candidate,TIndex at);
+ };
+
+
+
+
+ class end_matcher : public matcher {
+ public:
+ end_matcher() {
+ MatchLength = 0;
+ }
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const {
+ return 0;
+ }
+ bool match(backref_stack &brstack,T const &candidate,TIndex at);
+ };
+
+
+
+
+ class backref_open_matcher : public matcher {
+ public:
+ backref_open_matcher() {
+ MatchLength = 0;
+ }
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const {
+ return 0;
+ }
+ bool match(backref_stack &brstack,T const &candidate,TIndex at);
+ };
+
+
+
+
+ class backref_close_matcher : public matcher {
+ public:
+ backref_close_matcher() {
+ MatchLength = 0;
+ }
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const {
+ return 0;
+ }
+ bool match(backref_stack &brstack,T const &candidate,TIndex at);
+ };
+
+
+
+
+ class alternative_matcher : public matcher {
+ // The connector serves two purposes:
+ // a) be a null-matcher that re-unites the different alternate token
+ // sequences
+ // b) make the end of each sequence identifiable to be able to compute
+ // the match length
+
+ class connector : public matcher {
+ public:
+ matcher *duplicate() const {
+ return NULL;
+ }
+
+ TSize minimumMatchLength() const {
+ return 0;
+ }
+ bool match(backref_stack &brstack,T const &candidate,TIndex at);
+ };
+
+ typedef matcher super;
+ typedef std::vector<matcher *> alt_list;
+ alt_list AltList;
+ connector Connector;
+
+ public:
+ ~alternative_matcher();
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const;
+ void setNext(matcher *next,bool ownnext = true);
+ void addAlternative(matcher *alternative);
+ bool match(backref_stack &brstack,T const &candidate,TIndex at);
+
+ protected:
+ void copy(alternative_matcher const *src);
+ };
+
+
+
+
+ class backref_matcher : public matcher {
+ TIndex Backref;
+
+ public:
+ backref_matcher(TIndex backref);
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const {
+ return 0;
+ }
+ bool match(backref_stack &brstack,T const &candidate,TIndex at);
+ };
+
+ // instance data --------------------------------------------------------
+ std::auto_ptr<matcher> ParsedRegex;
+ backref_stack BackrefStack;
+ T LastCandidate;
+ TIndex MatchIndex;
+ TSize MatchLength;
+
+ public:
+ // interface ------------------------------------------------------------
+ regex();
+ regex(regex const &src);
+
+ regex &operator=(regex const &src);
+
+ bool match(T const &candidate,TIndex from = 0);
+ bool matchAt(T const &candidate,TIndex at = 0);
+
+ // Queries pertaining to the last match
+ TIndex getMatchIndex() {
+ return MatchIndex;
+ }
+ TSize getMatchLength() {
+ return MatchLength;
+ }
+ std::string getMatch() {
+ return T(LastCandidate.begin()+MatchIndex,
+ LastCandidate.begin()+MatchIndex+MatchLength);
+ }
+ TSize countBackrefs() {
+ return BackrefStack.size();
+ }
+ T getBackref(TIndex index) {
+ return BackrefStack.get(index,LastCandidate);
+ }
+ };
+
+
+
+ /**
+ A regular expression parser and matcher.
+
+ Backref numbering starts at \0.
+
+ ReplaceAll does not set the MatchIndex/MatchGlobal members.
+
+ What is there is compatible with perl5. (See man perlre or
+ http://www.cpan.org/doc/manual/html/pod/perlre.html)
+ However, not everything is there. Here's what's missing:
+
+ <ul>
+ <li> \Q-\E,\b,\B,\A,\Z,\z
+ <li> discerning between line and string
+ <li> (?#comments)
+ <li> (?:clustering)
+ <li> (?=positive lookahead assumptions)
+ <li> (?!negative lookahead assumptions
+ <li> (?<=positive lookbehind assumptions)
+ <li> (?<!negative lookbehind assumptions
+ <li> (?>independent substrings)
+ <li> modifiers such as "case independent"
+ </ul>
+
+ as well as all the stuff involving perl code, naturally.
+ None of these is actually hard to hack in. If you want them,
+ pester me or try for yourself (and submit patches!)
+ */
+ class regex_string : public regex<std::string> {
+ private:
+ class class_matcher : public regex<std::string>::matcher {
+ private:
+ typedef regex<std::string>::matcher super;
+ static TSize const CharValues = 256;
+ bool Set[CharValues];
+ bool Negated;
+
+ public:
+ class_matcher();
+ class_matcher(std::string const &cls);
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const {
+ return 1;
+ }
+ bool match(backref_stack &brstack,std::string const &candidate,TIndex at);
+
+ private:
+ void expandClass(std::string const &cls);
+
+ protected:
+ void copy(class_matcher const *src);
+ };
+
+
+
+
+ class special_class_matcher : public regex<std::string>::matcher {
+ public:
+ enum type { DIGIT,NONDIGIT,ALNUM,NONALNUM,SPACE,NONSPACE };
+
+ private:
+ type Type;
+
+ public:
+ special_class_matcher(type tp);
+
+ matcher *duplicate() const;
+
+ TSize minimumMatchLength() const {
+ return 1;
+ }
+ bool match(backref_stack &brstack,std::string const &candidate,TIndex at);
+ };
+
+
+
+
+ public:
+ regex_string() {
+ }
+ regex_string(std::string const &str) {
+ parse(str);
+ }
+ regex_string(char const *s) {
+ parse(s);
+ }
+
+ void parse(std::string const &expr);
+
+ std::string replaceAll(std::string const &candidate,std::string const &replacement,
+ TIndex from = 0);
+
+ private:
+ regex<std::string>::matcher *parseRegex(std::string const &expr);
+ quantifier *parseQuantifier(std::string const &expr,TIndex &at);
+ bool isGreedy(std::string const &expr,TIndex &at);
+ };
+ }
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Regular expressions string object.
+// ----------------------------------------------------------------------------
+// (c) Copyright 1998 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <stack>
+#include <cctype>
+#include "ixlib_i18n.hh"
+#include <ixlib_exgen.hh>
+#include <ixlib_numeric.hh>
+#include <ixlib_numconv.hh>
+#include <ixlib_re.hh>
+
+
+
+
+// regex::backref_stack -------------------------------------------------------
+template<class T>
+void ixion::regex<T>::backref_stack::open(TIndex index) {
+ backref_entry entry = { backref_entry::OPEN,index };
+ Stack.push_back(entry);
+ }
+
+
+
+
+template<class T>
+void ixion::regex<T>::backref_stack::close(TIndex index) {
+ backref_entry entry = { backref_entry::CLOSE,index };
+ Stack.push_back(entry);
+ }
+
+
+
+
+template<class T>
+ixion::regex<T>::backref_stack::rewind_info
+ixion::regex<T>::backref_stack::getRewindInfo() const {
+ return Stack.size();
+ }
+
+
+
+
+template<class T>
+void ixion::regex<T>::backref_stack::rewind(rewind_info ri) {
+ Stack.erase(Stack.begin()+ri,Stack.end());
+ }
+
+
+
+
+template<class T>
+void ixion::regex<T>::backref_stack::clear() {
+ Stack.clear();
+ }
+
+
+
+
+template<class T>
+ixion::TSize ixion::regex<T>::backref_stack::size() {
+ TSize result = 0;
+ FOREACH_CONST(first,Stack,internal_stack)
+ if (first->Type == backref_entry::OPEN) result++;
+ return result;
+ }
+
+
+
+
+template<class T>
+T ixion::regex<T>::backref_stack::get(TIndex number,T const &candidate) const {
+ TIndex level = 0,next_index = 0;
+ TIndex start;
+ TIndex startlevel;
+
+ internal_stack::const_iterator first = Stack.begin(),last = Stack.end();
+ while (first != last) {
+ if (first->Type == backref_entry::OPEN) {
+ if (number == next_index) {
+ start = first->Index;
+ startlevel = level;
+ level++;
+ break;
+ }
+ next_index++;
+ level++;
+ }
+ if (first->Type == backref_entry::CLOSE)
+ level--;
+ first++;
+ }
+
+ if (first == last)
+ EX_THROW(regex,ECRE_INVBACKREF)
+
+ first++;
+
+ while (first != last) {
+ if (first->Type == backref_entry::OPEN)
+ level++;
+ if (first->Type == backref_entry::CLOSE) {
+ level--;
+ if (startlevel == level)
+ return candidate.substr(start,first->Index - start);
+ }
+ first++;
+ }
+ EX_THROW(regex,ECRE_UNBALBACKREF)
+ }
+
+
+
+
+// regex::matcher -------------------------------------------------------------
+template<class T>
+ixion::regex<T>::matcher::matcher()
+ : Next(NULL) {
+ }
+
+
+
+
+template<class T>
+ixion::regex<T>::matcher::~matcher() {
+ if (Next && OwnNext)
+ delete Next;
+ }
+
+
+
+
+template<class T>
+ixion::TSize ixion::regex<T>::matcher::subsequentMatchLength() const {
+ TSize totalml = 0;
+ matcher const *object = this;
+ while (object) {
+ totalml += object->MatchLength;
+ object = object->Next;
+ }
+ return totalml;
+ }
+
+
+
+
+template<class T>
+ixion::TSize ixion::regex<T>::matcher::minimumSubsequentMatchLength() const {
+ TSize totalml = 0;
+ matcher const *object = this;
+ while (object) {
+ totalml += object->minimumMatchLength();
+ object = object->Next;
+ }
+ return totalml;
+ }
+
+
+
+
+template<class T>
+void ixion::regex<T>::matcher::copy(matcher const *src) {
+ if (src->Next && src->OwnNext)
+ setNext(src->Next->duplicate(),src->OwnNext);
+ else
+ setNext(NULL);
+ }
+
+
+
+
+// regex::quantifier ----------------------------------------------------------
+template<class T>
+ixion::regex<T>::quantifier::quantifier(bool greedy,TSize mincount)
+ : Greedy(greedy),MaxValid(false),MinCount(mincount) {
+ }
+
+
+
+
+template<class T>
+ixion::regex<T>::quantifier::quantifier(bool greedy,TSize mincount,TSize maxcount)
+ : Greedy(greedy),MaxValid(true),MinCount(mincount),MaxCount(maxcount) {
+ }
+
+
+
+
+template<class T>
+ixion::regex<T>::quantifier::~quantifier() {
+ if (Quantified)
+ delete Quantified;
+ }
+
+
+
+
+template<class T>
+ixion::regex<T>::matcher *ixion::regex<T>::quantifier::duplicate() const {
+ quantifier *dupe = new quantifier();
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+template<class T>
+ixion::TSize ixion::regex<T>::quantifier::minimumMatchLength() const {
+ if (Quantified)
+ return MinCount * Quantified->minimumMatchLength();
+ else
+ return 0;
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::quantifier::match(backref_stack &brstack,T const &candidate,TIndex at) {
+ // this routine does speculative matching, so it must pay close attention
+ // to rewind the backref stack appropriately.
+ // NB: matchNext does the rewinding automatically, whereas speculative
+ // matches of the quantified portion must be rewound.
+
+ // There should be at least one character in each match, we'd
+ // run to Baghdad otherwise.
+
+ if (!Quantified)
+ return matchNext(brstack,candidate,at);
+
+ // calculate accurate maximum match count
+ TSize quant_min = Quantified->minimumSubsequentMatchLength();
+ if (quant_min == 0) quant_min = 1;
+
+ TSize max_count = candidate.size() - at;
+ if (Next) max_count -= Next->minimumSubsequentMatchLength();
+ max_count = max_count/quant_min + 1;
+
+ if (MaxValid) max_count = NUM_MIN(max_count,MaxCount);
+
+ // check that at least MinCount matches take place (non-speculative)
+ TIndex idx = at;
+ for (TSize c = 1;c <= MinCount;c++)
+ if (Quantified->match(brstack,candidate,idx))
+ idx += Quantified->subsequentMatchLength();
+ else
+ return false;
+
+ // determine number of remaining matches
+ TSize remcount = max_count-MinCount;
+
+ // test for the remaining matches in a way that depends on Greedy flag
+ if (Greedy) {
+ // try to gobble up as many matches of quantified part as possible
+ // (speculative)
+
+ std::stack<backtrack_stack_entry> successful_indices;
+ { backtrack_stack_entry entry = { idx,brstack.getRewindInfo() };
+ successful_indices.push(entry);
+ }
+
+ while (Quantified->match(brstack,candidate,idx) && successful_indices.size()-1 < remcount) {
+ idx += Quantified->subsequentMatchLength();
+ backtrack_stack_entry entry = { idx,brstack.getRewindInfo() };
+ successful_indices.push(entry);
+ }
+
+ // backtrack until rest of sequence also matches
+ while (successful_indices.size() && !matchNext(brstack,candidate,successful_indices.top().Index)) {
+ brstack.rewind(successful_indices.top().RewindInfo);
+ successful_indices.pop();
+ }
+
+ if (successful_indices.size()) {
+ MatchLength = successful_indices.top().Index - at;
+ return true;
+ }
+ else return false;
+ }
+ else {
+ for (TSize c = 0;c <= remcount;c++) {
+ if (matchNext(brstack,candidate,idx)) {
+ MatchLength = idx-at;
+ return true;
+ }
+ // following part runs once too much, effectively:
+ // if c == remcount, idx may be increased, but the search fails anyway
+ // => no problem
+ if (Quantified->match(brstack,candidate,idx))
+ idx += Quantified->subsequentMatchLength();
+ else
+ return false;
+ }
+ return false;
+ }
+ }
+
+
+
+
+template<class T>
+void ixion::regex<T>::quantifier::copy(quantifier const *src) {
+ super::copy(src);
+ Greedy = src->Greedy;
+ MaxValid = src->MaxValid;
+ MinCount = src->MinCount;
+ MaxCount = src->MaxCount;
+ Quantified = src->Quantified->duplicate();
+ }
+
+
+
+
+// regex::sequence_matcher ------------------------------------------------------
+template<class T>
+ixion::regex<T>::sequence_matcher::sequence_matcher(T const &matchstr)
+ : MatchStr(matchstr) {
+ MatchLength = MatchStr.size();
+ }
+
+
+
+
+template<class T>
+ixion::regex<T>::matcher *ixion::regex<T>::sequence_matcher::duplicate() const {
+ sequence_matcher *dupe = new sequence_matcher(MatchStr);
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::sequence_matcher::match(backref_stack &brstack,T const &candidate,TIndex at) {
+ if (at+MatchStr.size() > candidate.size()) return false;
+ return (T(candidate.begin()+at,candidate.begin()+at+MatchStr.size()) == MatchStr) &&
+ matchNext(brstack,candidate,at+MatchStr.size());
+ }
+
+
+
+
+// regex::any_matcher ---------------------------------------------------------
+template<class T>
+ixion::regex<T>::matcher *ixion::regex<T>::any_matcher::duplicate() const {
+ any_matcher *dupe = new any_matcher();
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+// regex::start_matcher ---------------------------------------------------------
+template<class T>
+ixion::regex<T>::matcher *ixion::regex<T>::start_matcher::duplicate() const {
+ start_matcher *dupe = new start_matcher();
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::start_matcher::match(backref_stack &brstack,T const &candidate,TIndex at) {
+ return (at == 0) && matchNext(brstack,candidate,at);
+ }
+
+
+
+
+// regex::end_matcher ---------------------------------------------------------
+template<class T>
+ixion::regex<T>::matcher *ixion::regex<T>::end_matcher::duplicate() const {
+ end_matcher *dupe = new end_matcher();
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::end_matcher::match(backref_stack &brstack,T const &candidate,TIndex at) {
+ return (at == candidate.size()) && matchNext(brstack,candidate,at);
+ }
+
+
+
+
+// regex::backref_open_matcher ------------------------------------------------
+template<class T>
+ixion::regex<T>::matcher *ixion::regex<T>::backref_open_matcher::duplicate() const {
+ backref_open_matcher *dupe = new backref_open_matcher();
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::backref_open_matcher::match(backref_stack &brstack,T const &candidate,TIndex at) {
+ backref_stack::rewind_info ri = brstack.getRewindInfo();
+ brstack.open(at);
+
+ bool result = matchNext(brstack,candidate,at);
+
+ if (!result)
+ brstack.rewind(ri);
+ return result;
+ }
+
+
+
+
+// regex::backref_close_matcher -----------------------------------------------
+template<class T>
+ixion::regex<T>::matcher *ixion::regex<T>::backref_close_matcher::duplicate() const {
+ backref_close_matcher *dupe = new backref_close_matcher();
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::backref_close_matcher::match(backref_stack &brstack,T const &candidate,TIndex at) {
+ backref_stack::rewind_info ri = brstack.getRewindInfo();
+ brstack.close(at);
+
+ bool result = matchNext(brstack,candidate,at);
+
+ if (!result)
+ brstack.rewind(ri);
+ return result;
+ }
+
+
+
+
+// regex::alternative_matcher::connector --------------------------------------
+template<class T>
+bool ixion::regex<T>::alternative_matcher::connector::match(backref_stack &brstack,T const &candidate,TIndex at) {
+ return matchNext(brstack,candidate,at);
+ }
+
+
+
+
+// regex::alternative_matcher -------------------------------------------------
+template<class T>
+ixion::regex<T>::alternative_matcher::~alternative_matcher() {
+ while (AltList.size()) {
+ delete AltList.back();
+ AltList.pop_back();
+ }
+ }
+
+
+
+
+template<class T>
+ixion::regex<T>::matcher *ixion::regex<T>::alternative_matcher::duplicate() const {
+ alternative_matcher *dupe = new alternative_matcher();
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+template<class T>
+ixion::TSize ixion::regex<T>::alternative_matcher::minimumMatchLength() const {
+ TSize result = 0;
+ bool is_first = true;
+
+ FOREACH_CONST(first,AltList,alt_list)
+ if (is_first) {
+ result = (*first)->minimumMatchLength();
+ is_first = true;
+ }
+ else {
+ TSize current = (*first)->minimumMatchLength();
+ if (current < result) result = current;
+ }
+ return result;
+ }
+
+
+
+
+template<class T>
+void ixion::regex<T>::alternative_matcher::setNext(matcher *next,bool ownnext = true) {
+ matcher::setNext(next);
+ Connector.setNext(next,false);
+ }
+
+
+
+
+template<class T>
+void ixion::regex<T>::alternative_matcher::addAlternative(matcher *alternative) {
+ AltList.push_back(alternative);
+ matcher *searchlast = alternative,*last = NULL;
+ while (searchlast) {
+ last = searchlast;
+ searchlast = searchlast->getNext();
+ }
+ last->setNext(&Connector,false);
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::alternative_matcher::match(backref_stack &brstack,T const &candidate,TIndex at) {
+ std::vector<matcher *>::iterator first = AltList.begin(),last = AltList.end();
+ while (first != last) {
+ if ((*first)->match(brstack,candidate,at)) {
+ MatchLength = 0;
+ matcher const *object = *first;
+ while (object != &Connector) {
+ MatchLength += object->getMatchLength();
+ object = object->getNext();
+ }
+ return true;
+ }
+ first++;
+ }
+ return false;
+ }
+
+
+
+
+template<class T>
+void ixion::regex<T>::alternative_matcher::copy(alternative_matcher const *src) {
+ super::copy(src);
+ Connector.setNext(Next,false);
+
+ FOREACH_CONST(first,src->AltList,alt_list)
+ addAlternative((*first)->duplicate());
+ }
+
+
+
+
+// regex::backref_matcher -----------------------------------------------------
+template<class T>
+ixion::regex<T>::backref_matcher::backref_matcher(TIndex backref)
+ : Backref(backref) {
+ }
+
+
+
+
+template<class T>
+ixion::regex<T>::matcher *ixion::regex<T>::backref_matcher::duplicate() const {
+ backref_matcher *dupe = new backref_matcher(Backref);
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::backref_matcher::match(backref_stack &brstack,T const &candidate,TIndex at) {
+ T matchstr = brstack.get(Backref,candidate);
+ MatchLength = matchstr.size();
+
+ if (at+matchstr.size() > candidate.size()) return false;
+ return (T(candidate.begin()+at,candidate.begin()+at+matchstr.size()) == matchstr) &&
+ matchNext(brstack,candidate,at+matchstr.size());
+ }
+
+
+
+
+// regex ----------------------------------------------------------------------
+template<class T>
+ixion::regex<T>::regex()
+ : MatchIndex(0),MatchLength(0) {
+ }
+
+
+
+
+template<class T>
+ixion::regex<T>::regex(regex const &src)
+ : ParsedRegex(src.ParsedRegex->duplicate()),
+ MatchIndex(0),MatchLength(0) {
+ }
+
+
+
+
+template<class T>
+ixion::regex<T> &ixion::regex<T>::operator=(regex const &src) {
+ std::auto_ptr<matcher> regex_copy(src.ParsedRegex->duplicate());
+ ParsedRegex = regex_copy;
+ return *this;
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::match(T const &candidate,TIndex from) {
+ LastCandidate = candidate;
+ BackrefStack.clear();
+
+ if (ParsedRegex.get() == NULL)
+ EX_THROW(regex,ECRE_NOPATTERN)
+
+ for (TIndex index = from;index < candidate.size();index++)
+ if (ParsedRegex->match(BackrefStack,candidate,index)) {
+ MatchIndex = index;
+ MatchLength = ParsedRegex->subsequentMatchLength();
+ return true;
+ }
+ return false;
+ }
+
+
+
+
+template<class T>
+bool ixion::regex<T>::matchAt(T const &candidate,TIndex at) {
+ LastCandidate = candidate;
+ BackrefStack.clear();
+
+ if (ParsedRegex.get() == NULL)
+ EX_THROW(regex,ECRE_NOPATTERN)
+
+ if (ParsedRegex->match(BackrefStack,candidate,at)) {
+ MatchIndex = at;
+ MatchLength = ParsedRegex->subsequentMatchLength();
+ return true;
+ }
+ return false;
+ }
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript scanner
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_SCANJS
+#define IXLIB_SCANJS
+
+
+
+
+#undef yyFlexLexer
+#define yyFlexLexer jsFlexLexer
+#include <FlexLexer.h>
+#undef yyFlexLexer
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : scanner wrapper for FlexLexer
+// ----------------------------------------------------------------------------
+// (c) Copyright 1999 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_SCANNER
+#define IXLIB_SCANNER
+
+
+
+
+#include <ixlib_base.hh>
+#include <ixlib_exbase.hh>
+#include <vector>
+#include <ixlib_string.hh>
+
+
+
+
+class FlexLexer;
+
+
+
+
+// possible errors during execution -------------------------------------------
+#define ECSCAN_UNKNOWN_TOKEN 0
+#define ECSCAN_EOF 1
+
+
+
+
+// scanner_exception ----------------------------------------------------------
+namespace ixion {
+ struct scanner_exception : public base_exception {
+ scanner_exception(TErrorCode const error,TIndex const line,std::string const &info);
+ virtual char *getText() const;
+ };
+
+
+
+
+// scanner --------------------------------------------------------------------
+ class scanner {
+ public:
+ typedef unsigned token_type;
+
+ struct token {
+ token_type Type;
+ TIndex Line;
+ std::string Text;
+ };
+
+ typedef std::vector<token> token_list;
+ typedef std::vector<token>::iterator token_iterator;
+
+ scanner(FlexLexer &lexer);
+ token_list scan();
+
+ protected:
+ FlexLexer &Lexer;
+ token CurrentToken;
+
+ token getNextToken();
+ bool reachedEOF() const;
+ };
+ }
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : String crunching tools
+// ----------------------------------------------------------------------------
+// (c) Copyright 1999 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_STRING
+#define IXLIB_STRING
+
+
+
+
+#include <string>
+#include <ixlib_base.hh>
+#include <ixlib_exgen.hh>
+
+
+
+
+namespace ixion {
+ template<class InputIterator>
+ inline std::string concat(InputIterator first,InputIterator last,std::string const &sep = " ") {
+ std::string str;
+ while (first != last) {
+ if (str.size()) str += sep;
+ str += *first++;
+ }
+ return str;
+ }
+
+
+
+
+ std::string findReplace(std::string const &target,std::string const &src,std::string const &dest);
+ std::string findReplace(std::string const &target,char* src,char *dest);
+ std::string findReplace(std::string const &target,char src,char dest);
+ std::string upper(std::string const &original);
+ std::string lower(std::string const &original);
+ std::string removeLeading(std::string const &original,char ch = ' ');
+ std::string removeTrailing(std::string const &original,char ch = ' ');
+ std::string removeLeadingTrailing(std::string const &original,char ch = ' ');
+ std::string parseCEscapes(std::string const &original);
+
+ TSize getMaxBase64DecodedSize(TSize encoded);
+ // data must provide enough space for the maximal size determined by the
+ // above function
+ TSize base64decode(TByte *data,std::string const &base64);
+ void base64encode(std::string &base64,TByte const *data,TSize size);
+
+
+
+
+ class string_hash {
+ public:
+ unsigned long operator()(std::string const &str) const;
+ };
+ }
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Token definitions for Javascript scanner
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_TOKEN_JAVASCRIPT
+#define IXLIB_TOKEN_JAVASCRIPT
+
+
+
+
+#include <ixlib_token_lex.hh>
+
+
+
+
+// keywords
+#define TT_JS_THIS (TT_USER + 0)
+#define TT_JS_FUNCTION (TT_USER + 1)
+#define TT_JS_VAR (TT_USER + 2)
+#define TT_JS_NULL (TT_USER + 3)
+#define TT_JS_IF (TT_USER + 4)
+#define TT_JS_WHILE (TT_USER + 5)
+#define TT_JS_DO (TT_USER + 6)
+#define TT_JS_ELSE (TT_USER + 7)
+#define TT_JS_FOR (TT_USER + 8)
+#define TT_JS_RETURN (TT_USER + 9)
+#define TT_JS_SWITCH (TT_USER + 10)
+#define TT_JS_CASE (TT_USER + 11)
+#define TT_JS_CONTINUE (TT_USER + 12)
+#define TT_JS_BREAK (TT_USER + 13)
+#define TT_JS_DEFAULT (TT_USER + 14)
+#define TT_JS_IN (TT_USER + 15)
+#define TT_JS_CONST (TT_USER + 16)
+#define TT_JS_CLASS (TT_USER + 17)
+#define TT_JS_EXTENDS (TT_USER + 18)
+#define TT_JS_NAMESPACE (TT_USER + 19)
+#define TT_JS_STATIC (TT_USER + 20)
+#define TT_JS_CONSTRUCTOR (TT_USER + 21)
+
+// operators
+#define TT_JS_NEW (TT_USER + 1024)
+
+#define TT_JS_PLUS_ASSIGN (TT_USER + 1025)
+#define TT_JS_MINUS_ASSIGN (TT_USER + 1026)
+#define TT_JS_MULTIPLY_ASSIGN (TT_USER + 1027)
+#define TT_JS_DIVIDE_ASSIGN (TT_USER + 1028)
+#define TT_JS_MODULO_ASSIGN (TT_USER + 1029)
+#define TT_JS_BIT_XOR_ASSIGN (TT_USER + 1030)
+#define TT_JS_BIT_AND_ASSIGN (TT_USER + 1031)
+#define TT_JS_BIT_OR_ASSIGN (TT_USER + 1032)
+#define TT_JS_LEFT_SHIFT (TT_USER + 1033)
+#define TT_JS_RIGHT_SHIFT (TT_USER + 1034)
+#define TT_JS_LEFT_SHIFT_ASSIGN (TT_USER + 1035)
+#define TT_JS_RIGHT_SHIFT_ASSIGN (TT_USER + 1036)
+#define TT_JS_EQUAL (TT_USER + 1037)
+#define TT_JS_NOT_EQUAL (TT_USER + 1038)
+#define TT_JS_LESS_EQUAL (TT_USER + 1039)
+#define TT_JS_GREATER_EQUAL (TT_USER + 1040)
+#define TT_JS_LOGICAL_AND (TT_USER + 1041)
+#define TT_JS_LOGICAL_OR (TT_USER + 1042)
+#define TT_JS_INCREMENT (TT_USER + 1043)
+#define TT_JS_DECREMENT (TT_USER + 1044)
+#define TT_JS_IDENTICAL (TT_USER + 1045)
+#define TT_JS_NOT_IDENTICAL (TT_USER + 1046)
+
+// literals
+#define TT_JS_LIT_INT (TT_USER + 2048)
+#define TT_JS_LIT_FLOAT (TT_USER + 2049)
+#define TT_JS_LIT_STRING (TT_USER + 2050)
+#define TT_JS_LIT_TRUE (TT_USER + 2051)
+#define TT_JS_LIT_FALSE (TT_USER + 2052)
+#define TT_JS_LIT_UNDEFINED (TT_USER + 2053)
+
+// identifier
+#define TT_JS_IDENTIFIER (TT_USER + 3072)
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Basic definitions
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#ifndef IXLIB_TOKENLEX
+#define IXLIB_TOKENLEX
+
+
+
+
+// Basic token types
+#define TT_EOF 1024
+#define TT_UNKNOWN 1025
+#define TT_WHITESPACE 1026
+#define TT_USER 2048
+
+
+
+
+#endif
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript interpreter
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <ixlib_js_internals.hh>
+
+
+
+
+using namespace ixion;
+using namespace javascript;
+
+
+
+
+// js_array -------------------------------------------------------------------
+js_array::
+js_array(TSize size) {
+ Array.resize(size);
+
+ ref<value> null = javascript::makeNull();
+ for (TIndex i = 0;i < size;i++)
+ Array[i] = makeLValue(null);
+ }
+
+
+
+
+string js_array::stringify() const {
+ value_array::const_iterator first = Array.begin(),last = Array.end();
+
+ string result = "{ ";
+ bool at_first = true;
+ while (first != last) {
+ if (!at_first) result += ',';
+ else at_first = false;
+ result += (*first)->stringify();
+ first++;
+ }
+ return result + " }";
+ }
+
+
+
+
+ref<javascript::value>
+js_array::
+duplicate() {
+ ref<value> result = new js_array(*this);
+ return result;
+ }
+
+
+
+
+ref<javascript::value>
+js_array::
+lookup(string const &identifier) {
+ if (identifier == "length") return javascript::makeConstant(Array.size());
+ return super::lookup(identifier);
+ }
+
+
+
+
+ref<javascript::value>
+js_array::
+subscript(value const &index) {
+ TIndex idx = index.toInt();
+ return operator[](idx);
+ }
+
+
+
+
+ref<javascript::value>
+js_array::
+callMethod(string const &id,parameter_list const ¶meters) {
+ if (id == "pop" && parameters.size() == 0) {
+ if (Array.size() == 0) return javascript::makeNull();
+ else {
+ ref<value> back = Array.back();
+ Array.pop_back();
+ return back;
+ }
+ }
+ else if (id == "push") {
+ FOREACH_CONST(first,parameters,parameter_list) {
+ Array.push_back((*first)->duplicate());
+ }
+ return javascript::makeConstant(Array.size());
+ }
+ else if (id == "reverse" && parameters.size() == 0) {
+ reverse(Array.begin(),Array.end());
+ return this;
+ }
+ else if (id == "shift" && parameters.size() == 0) {
+ if (Array.size() == 0) return javascript::makeNull();
+ else {
+ ref<value> front = Array.front();
+ Array.erase(Array.begin());
+ return front;
+ }
+ }
+ else if (id == "slice" && parameters.size() == 2) {
+ value_array::const_iterator first = Array.begin() + parameters[0]->toInt();
+ value_array::const_iterator last = Array.begin() + parameters[1]->toInt();
+
+ auto_ptr<js_array> array(new js_array(first,last));
+ return array.release();
+ }
+ else if (id == "unshift") {
+ TIndex i = 0;
+ FOREACH_CONST(first,parameters,parameter_list) {
+ Array.insert(Array.begin() + i++,(*first)->duplicate());
+ }
+ return javascript::makeConstant(Array.size());
+ }
+ else if (id == "join" && parameters.size() == 1) {
+ string sep = parameters[0]->toString();
+ string result;
+
+ for( TIndex i = 0; i < Array.size(); ++i ) {
+ if (i != 0)
+ result += sep;
+
+ result += Array[i]->toString();
+ }
+
+ return javascript::makeValue(result);
+ }
+ // *** FIXME: implement splice and sort
+
+ EXJS_THROWINFO(ECJS_UNKNOWN_IDENTIFIER,("Array."+id).c_str())
+ }
+
+
+
+
+void js_array::resize(TSize size) {
+ if (size >= Array.size()) {
+ TSize prevsize = Array.size();
+
+ Array.resize(size);
+
+ ref<value> null = javascript::makeNull();
+ for (TIndex i = prevsize;i < size;i++)
+ Array[i] = makeLValue(null);
+ }
+ }
+
+
+
+
+ref<value> &js_array::operator[](TIndex idx) {
+ if (idx >= Array.size())
+ resize((Array.size()+1)*2);
+
+ return Array[idx];
+ }
+
+
+
+
+
+void js_array::push_back(ref<value> val) {
+ Array.push_back(val);
+ }
+
+
+
+
+// js_array_constructor -------------------------------------------------------
+ref<javascript::value> js_array_constructor::duplicate() {
+ // array_constructor is not mutable
+ return this;
+ }
+
+
+
+
+ref<javascript::value>
+js_array_constructor::
+construct(parameter_list const ¶meters) {
+ if (parameters.size() == 0) return makeArray();
+ else if (parameters.size() == 1) return makeArray(parameters[0]->toInt());
+ else /* parameters.size() >= 2 */ {
+ auto_ptr<js_array> result(new js_array(parameters.size()));
+
+ TIndex i = 0;
+ FOREACH_CONST(first,parameters,parameter_list) {
+ (*result)[i++] = (*first)->duplicate();
+ }
+ return result.release();
+ }
+ }
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript interpreter
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <ixlib_js_internals.hh>
+#include <ixlib_token_javascript.hh>
+
+
+
+
+#define EXJS_ADD_CODE_LOCATION \
+ catch (no_location_javascript_exception &half) { \
+ throw javascript_exception(half,getCodeLocation()); \
+ }
+
+
+
+
+using namespace ixion;
+using namespace javascript;
+
+
+
+
+// variable_declaration -------------------------------------------------------
+variable_declaration::variable_declaration(string const &id,ref<expression> def_value,code_location const &loc)
+ : expression(loc),Identifier(id),DefaultValue(def_value) {
+ }
+
+
+
+
+ref<value> variable_declaration::evaluate(context const &ctx) const {
+ try {
+ ref<value> def;
+ if (DefaultValue.get() != NULL) def = DefaultValue->evaluate(ctx)->eliminateWrappers()->duplicate();
+ else def = makeNull();
+
+ ref<value> lv = makeLValue(def);
+ ctx.DeclarationScope->addMember(Identifier,lv);
+ return lv;
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// constant_declaration -------------------------------------------------------
+constant_declaration::constant_declaration(string const &id,ref<expression> def_value,code_location const &loc)
+ : expression(loc),Identifier(id),DefaultValue(def_value) {
+ }
+
+
+
+
+ref<value> constant_declaration::evaluate(context const &ctx) const {
+ try {
+ ref<value> def;
+ if (DefaultValue.get() != NULL) def = DefaultValue->evaluate(ctx)->eliminateWrappers()->duplicate();
+ else def = makeNull();
+
+ ref<value> cns = wrapConstant(def);
+ ctx.DeclarationScope->addMember(Identifier,cns);
+ return cns;
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// function_declaration -------------------------------------------------------
+function_declaration::
+function_declaration(string const &id,parameter_name_list const &pnames,
+ref<expression> body,code_location const &loc)
+ : expression(loc),Identifier(id),ParameterNameList(pnames),Body(body) {
+ }
+
+
+
+
+ref<value> function_declaration::evaluate(context const &ctx) const {
+ try {
+ ref<value> fun = new function(ParameterNameList,Body,ctx.LookupScope);
+ ctx.DeclarationScope->addMember(Identifier,fun);
+ return ref<value>(NULL);
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// method_declaration ---------------------------------------------------------
+method_declaration::
+method_declaration(string const &id,parameter_name_list const &pnames,
+ref<expression> body,code_location const &loc)
+ : expression(loc),Identifier(id),ParameterNameList(pnames),Body(body) {
+ }
+
+
+
+
+ref<value> method_declaration::evaluate(context const &ctx) const {
+ try {
+ ref<value> fun = new method(ParameterNameList,Body,ctx.LookupScope);
+ ctx.DeclarationScope->addMember(Identifier,fun);
+ return ref<value>(NULL);
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// constructor_declaration ---------------------------------------------------------
+constructor_declaration::
+constructor_declaration(parameter_name_list const &pnames,
+ref<expression> body,code_location const &loc)
+ : expression(loc),ParameterNameList(pnames),Body(body) {
+ }
+
+
+
+
+ref<value> constructor_declaration::evaluate(context const &ctx) const {
+ try {
+ ref<value> fun = new constructor(ParameterNameList,Body,ctx.LookupScope);
+ return fun;
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// js_class_declaration -------------------------------------------------------
+js_class_declaration::js_class_declaration(string const &id,ref<expression> superclass,code_location const &loc)
+ : expression(loc),Identifier(id),SuperClass(superclass) {
+ }
+
+
+
+
+ref<value> js_class_declaration::evaluate(context const &ctx) const {
+ try {
+ ref<list_scope,value> sml(new list_scope);
+ ref<list_scope,value> ml(new list_scope);
+ ref<list_scope,value> svl(new list_scope);
+
+ ref<value> sc;
+ if (SuperClass.get())
+ sc = SuperClass->evaluate(ctx);
+
+ ref<value> constructor;
+ if (ConstructorDeclaration.get())
+ constructor = ConstructorDeclaration->evaluate(ctx);
+ ref<value> cls(new js_class(ctx.LookupScope,sc,constructor,sml,ml,svl,VariableList));
+
+ ref<list_scope,value> static_scope(new list_scope);
+ static_scope->unite(ctx.LookupScope);
+ static_scope->unite(cls);
+
+ FOREACH_CONST(first,StaticMethodList,declaration_list)
+ (*first)->evaluate(context(sml,static_scope));
+ FOREACH_CONST(first,MethodList,declaration_list)
+ (*first)->evaluate(context(ml,ctx.LookupScope));
+ FOREACH_CONST(first,StaticVariableList,declaration_list)
+ (*first)->evaluate(context(svl,static_scope));
+
+ ctx.DeclarationScope->addMember(Identifier,cls);
+ return cls;
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+void js_class_declaration::setConstructor(ref<expression> decl) {
+ ConstructorDeclaration = decl;
+ }
+
+
+
+
+void js_class_declaration::addStaticMethod(ref<expression> decl) {
+ StaticMethodList.push_back(decl);
+ }
+
+
+
+
+void js_class_declaration::addMethod(ref<expression> decl) {
+ MethodList.push_back(decl);
+ }
+
+
+
+
+void js_class_declaration::addStaticVariable(ref<expression> decl) {
+ StaticVariableList.push_back(decl);
+ }
+
+
+
+
+void js_class_declaration::addVariable(ref<expression> decl) {
+ VariableList.push_back(decl);
+ }
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript interpreter
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <ixlib_js_internals.hh>
+#include <ixlib_token_javascript.hh>
+
+
+
+
+#define EXJS_ADD_CODE_LOCATION \
+ catch (no_location_javascript_exception &half) { \
+ throw javascript_exception(half,getCodeLocation()); \
+ }
+
+
+
+
+using namespace ixion;
+using namespace javascript;
+
+
+
+
+// expression -----------------------------------------------------------------
+expression::expression(code_location const &loc)
+ : Location(loc) {
+ }
+
+
+
+
+expression::~expression() {
+ }
+
+
+
+
+// constant -------------------------------------------------------------------
+constant::constant(ref<value> val,code_location const &loc)
+ : expression(loc),Value(val) {
+ }
+
+
+
+
+ref<value>
+constant::
+evaluate(context const &ctx) const {
+ return Value;
+ }
+
+
+
+
+// unary_operator -------------------------------------------------
+unary_operator::unary_operator(value::operator_id opt,ref<expression> opn,code_location const &loc)
+ : expression(loc),Operator(opt),Operand(opn) {
+ }
+
+
+
+
+ref<value>
+unary_operator::
+evaluate(context const &ctx) const {
+ try {
+ return Operand->evaluate(ctx)->operatorUnary(Operator);
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// modifying_unary_operator ---------------------------------------------------
+modifying_unary_operator::
+modifying_unary_operator(value::operator_id opt,ref<expression> opn,code_location const &loc)
+ : expression(loc),Operator(opt),Operand(opn) {
+ }
+
+
+
+
+ref<value>
+modifying_unary_operator::
+evaluate(context const &ctx) const {
+ try {
+ return Operand->evaluate(ctx)->operatorUnaryModifying(Operator);
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// binary_operator ------------------------------------------------------------
+binary_operator::binary_operator(value::operator_id opt,ref<expression> opn1,ref<expression> opn2,code_location const &loc)
+ : expression(loc),Operator(opt),Operand1(opn1),Operand2(opn2) {
+ }
+
+
+
+
+ref<value> binary_operator::evaluate(context const &ctx) const {
+ try {
+ return Operand1->evaluate(ctx)->operatorBinary(Operator,Operand2->evaluate(ctx));
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// binary_shortcut_operator ---------------------------------------------------
+binary_shortcut_operator::binary_shortcut_operator(value::operator_id opt,ref<expression> opn1,ref<expression> opn2,code_location const &loc)
+ : expression(loc),Operator(opt),Operand1(opn1),Operand2(opn2) {
+ }
+
+
+
+
+ref<value> binary_shortcut_operator::evaluate(context const &ctx) const {
+ try {
+ return Operand1->evaluate(ctx)->operatorBinaryShortcut(Operator,*Operand2,ctx);
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// modifying_binary_operator --------------------------------------
+modifying_binary_operator::
+modifying_binary_operator(value::operator_id opt,ref<expression> opn1,ref<expression> opn2,code_location const &loc)
+ : expression(loc),Operator(opt),Operand1(opn1),Operand2(opn2) {
+ }
+
+
+
+
+ref<value>
+modifying_binary_operator::
+evaluate(context const &ctx) const {
+ try {
+ return Operand1->evaluate(ctx)->operatorBinaryModifying(Operator,Operand2->evaluate(ctx));
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// ternary_operator -----------------------------------------------------------
+ternary_operator::
+ternary_operator(ref<expression> opn1,ref<expression> opn2,ref<expression> opn3,code_location const &loc)
+ : expression(loc),Operand1(opn1),Operand2(opn2),Operand3(opn3) {
+ }
+
+
+
+
+ref<value>
+ternary_operator::
+evaluate(context const &ctx) const {
+ try {
+ if (Operand1->evaluate(ctx)->toBoolean())
+ return Operand2->evaluate(ctx);
+ else
+ return Operand3->evaluate(ctx);
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// subscript_operation --------------------------------------------------------
+subscript_operation::subscript_operation(ref<expression> opn1,ref<expression> opn2,code_location const &loc)
+ : expression(loc),Operand1(opn1),Operand2(opn2) {
+ }
+
+
+
+
+ref<value> subscript_operation::evaluate(context const &ctx) const {
+ try {
+ ref<value> op2 = Operand2->evaluate(ctx);
+ return Operand1->evaluate(ctx)->subscript(*op2);
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// lookup_operation -----------------------------------------------------------
+lookup_operation::lookup_operation(string const &id,code_location const &loc)
+ : expression(loc),Identifier(id) {
+ }
+
+
+
+
+lookup_operation::lookup_operation(ref<expression> opn,string const &id,code_location const &loc)
+ : expression(loc),Operand(opn),Identifier(id) {
+ }
+
+
+
+
+ref<value> lookup_operation::evaluate(context const &ctx) const {
+ try {
+ ref<value> scope(ctx.LookupScope);
+ if (Operand.get() != NULL)
+ scope = Operand->evaluate(ctx);
+ return scope->lookup(Identifier);
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// assignment -----------------------------------------------------------------
+assignment::
+assignment(ref<expression> opn1,ref<expression> opn2,code_location const &loc)
+ : expression(loc),Operand1(opn1),Operand2(opn2) {
+ }
+
+
+
+
+ref<value>
+assignment::evaluate(context const &ctx) const {
+ try {
+ return Operand1->evaluate(ctx)->assign(Operand2->evaluate(ctx)->eliminateWrappers()->duplicate());
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// basic_call -----------------------------------------------------------------
+basic_call::basic_call(parameter_expression_list const &pexps,code_location const &loc)
+ : expression(loc),ParameterExpressionList(pexps) {
+ }
+
+
+
+
+void basic_call::makeParameterValueList(context const &ctx,parameter_value_list &pvalues) const {
+ FOREACH_CONST(first,ParameterExpressionList,parameter_expression_list) {
+ pvalues.push_back((*first)->evaluate(ctx));
+ }
+ }
+
+
+
+
+// function_call --------------------------------------------------------------
+function_call::function_call(ref<expression> fun,parameter_expression_list const &pexps,code_location const &loc)
+ : super(pexps,loc),Function(fun) {
+ }
+
+
+
+
+ref<value> function_call::evaluate(context const &ctx) const {
+ try {
+ ref<value> func_value = Function->evaluate(ctx);
+
+ value::parameter_list pvalues;
+ makeParameterValueList(ctx,pvalues);
+ ref<value> result = func_value->call(pvalues);
+
+ if (result.get() == NULL) return makeNull();
+ else return result;
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
+
+
+
+
+// construction ---------------------------------------------------------------
+construction::construction(ref<expression> cls,parameter_expression_list const &pexps,code_location const &loc)
+ : super(pexps,loc),Class(cls) {
+ }
+
+
+
+
+ref<value> construction::evaluate(context const &ctx) const {
+ try {
+ ref<value> class_value = Class->evaluate(ctx);
+
+ value::parameter_list pvalues;
+ makeParameterValueList(ctx,pvalues);
+
+ return class_value->construct(pvalues);
+ }
+ EXJS_ADD_CODE_LOCATION
+ }
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript interpreter
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <ixlib_js_internals.hh>
+#include <ixlib_token_javascript.hh>
+
+
+
+
+using namespace ixion;
+using namespace javascript;
+
+
+
+
+// instruction_list -----------------------------------------------------------
+ref<value>
+instruction_list::evaluate(context const &ctx) const {
+ ref<value> result;
+ FOREACH_CONST(first,ExpressionList,expression_list)
+ result = (*first)->evaluate(ctx);
+ return result;
+ }
+
+
+
+
+void instruction_list::add(ref<expression> expr) {
+ ExpressionList.push_back(expr);
+ }
+
+
+
+
+// scoped_instruction_list ----------------------------------------
+ref<value> scoped_instruction_list::evaluate(context const &ctx) const {
+ ref<list_scope,value> scope = new list_scope;
+ scope->unite(ctx.LookupScope);
+
+ ref<value> result = instruction_list::evaluate(context(scope));
+ if (result.get()) return result->duplicate();
+ return ref<value>(NULL);
+
+ // ATTENTION: this is a scope cancellation point.
+ }
+
+
+
+
+// js_if ----------------------------------------------------------------------
+js_if::js_if(ref<expression> cond,ref<expression> ifex,ref<expression> ifnotex,code_location const &loc)
+ : expression(loc),Conditional(cond),IfExpression(ifex),IfNotExpression(ifnotex) {
+ }
+
+
+
+
+ref<value> js_if::evaluate(context const &ctx) const {
+ if (Conditional->evaluate(ctx)->toBoolean())
+ return IfExpression->evaluate(ctx);
+ else
+ if (IfNotExpression.get())
+ return IfNotExpression->evaluate(ctx);
+ else
+ return ref<value>(NULL);
+ }
+
+
+
+
+// js_while -------------------------------------------------------------------
+js_while::js_while(ref<expression> cond,ref<expression> loopex,code_location const &loc)
+ : expression(loc),Conditional(cond),LoopExpression(loopex),HasLabel(false) {
+ }
+
+
+
+
+js_while::js_while(ref<expression> cond,ref<expression> loopex,string const &label,code_location const &loc)
+ : expression(loc),Conditional(cond),LoopExpression(loopex),HasLabel(true),Label(label) {
+ }
+
+
+
+
+ref<value> js_while::evaluate(context const &ctx) const {
+ ref<value> result;
+ while (Conditional->evaluate(ctx)->toBoolean()) {
+ try {
+ result = LoopExpression->evaluate(ctx);
+ }
+ catch (break_exception &be) {
+ if (!be.HasLabel || (HasLabel && be.HasLabel && be.Label == Label))
+ break;
+ else throw;
+ }
+ catch (continue_exception &ce) {
+ if (!ce.HasLabel || (HasLabel && ce.HasLabel && ce.Label == Label))
+ continue;
+ else throw;
+ }
+ }
+ return result;
+ }
+
+
+
+
+// js_do_while ----------------------------------------------------------------
+js_do_while::js_do_while(ref<expression> cond,ref<expression> loopex,code_location const &loc)
+ : expression(loc),Conditional(cond),LoopExpression(loopex),HasLabel(false) {
+ }
+
+
+
+
+js_do_while::js_do_while(ref<expression> cond,ref<expression> loopex,string const &label,code_location const &loc)
+ : expression(loc),Conditional(cond),LoopExpression(loopex),HasLabel(true),Label(label) {
+ }
+
+
+
+
+ref<value> js_do_while::evaluate(context const &ctx) const {
+ ref<value> result;
+ do {
+ try {
+ result = LoopExpression->evaluate(ctx);
+ }
+ catch (break_exception &be) {
+ if (!be.HasLabel || (HasLabel && be.HasLabel && be.Label == Label))
+ break;
+ else throw;
+ }
+ catch (continue_exception &ce) {
+ if (!ce.HasLabel || (HasLabel && ce.HasLabel && ce.Label == Label))
+ continue;
+ else throw;
+ }
+ } while (Conditional->evaluate(ctx)->toBoolean());
+ return result;
+ }
+
+
+
+
+// js_for ---------------------------------------------------------------------
+js_for::js_for(ref<expression> init,ref<expression> cond,ref<expression> update,ref<expression> loop,code_location const &loc)
+ : expression(loc),Initialization(init),Conditional(cond),Update(update),
+ LoopExpression(loop),HasLabel(false) {
+ }
+
+
+
+
+js_for::js_for(ref<expression> init,ref<expression> cond,ref<expression> update,ref<expression> loop,string const &label,code_location const &loc)
+ : expression(loc),Initialization(init),Conditional(cond),Update(update),LoopExpression(loop),
+ HasLabel(true),Label(label) {
+ }
+
+
+
+
+ref<value> js_for::evaluate(context const &ctx) const {
+ ref<list_scope,value> scope = new list_scope;
+ scope->unite(ctx.LookupScope);
+ context inner_context(scope);
+
+ ref<value> result;
+ for (Initialization->evaluate(inner_context);Conditional->evaluate(inner_context)->toBoolean();
+ Update->evaluate(inner_context)) {
+ try {
+ result = LoopExpression->evaluate(inner_context);
+ }
+ catch (break_exception &be) {
+ if (!be.HasLabel || (HasLabel && be.HasLabel && be.Label == Label))
+ break;
+ else throw;
+ }
+ catch (continue_exception &ce) {
+ if (!ce.HasLabel || (HasLabel && ce.HasLabel && ce.Label == Label))
+ continue;
+ else throw;
+ }
+ }
+ return result;
+ }
+
+
+
+
+// js_for_in ------------------------------------------------------------------
+js_for_in::js_for_in(ref<expression> iter,ref<expression> array,ref<expression> loop,code_location const &loc)
+ : expression(loc),Iterator(iter),Array(array),LoopExpression(loop),HasLabel(false) {
+ }
+
+
+
+
+js_for_in::js_for_in(ref<expression> iter,ref<expression> array,ref<expression> loop,string const &label,code_location const &loc)
+ : expression(loc),Iterator(iter),Array(array),LoopExpression(loop),
+ HasLabel(true),Label(label) {
+ }
+
+
+
+
+ref<value> js_for_in::evaluate(context const &ctx) const {
+ ref<list_scope,value> scope = new list_scope;
+ scope->unite(ctx.LookupScope);
+ context inner_context(scope);
+
+ ref<value> result;
+ ref<value> iterator = Iterator->evaluate(inner_context);
+ ref<value> array = Array->evaluate(inner_context);
+
+ TSize size = array->lookup("length")->toInt();
+
+ for (TIndex i = 0;i < size;i++) {
+ try {
+ iterator->assign(array->subscript(*makeConstant(i)));
+ result = LoopExpression->evaluate(inner_context);
+ }
+ catch (break_exception &be) {
+ if (!be.HasLabel || (HasLabel && be.HasLabel && be.Label == Label))
+ break;
+ else throw;
+ }
+ catch (continue_exception &ce) {
+ if (!ce.HasLabel || (HasLabel && ce.HasLabel && ce.Label == Label))
+ continue;
+ else throw;
+ }
+ }
+ if (result.get()) return result->duplicate();
+ return ref<value>(NULL);
+
+ // ATTENTION: this is a scope cancellation point.
+ }
+
+
+
+
+// js_return ------------------------------------------------------------------
+js_return::js_return(ref<expression> retval,code_location const &loc)
+ : expression(loc),ReturnValue(retval) {
+ }
+
+
+
+
+ref<value> js_return::evaluate(context const &ctx) const {
+ ref<value> retval;
+ if (ReturnValue.get())
+ retval = ReturnValue->evaluate(ctx);
+
+ throw return_exception(retval,getCodeLocation());
+ }
+
+
+
+
+// js_break -------------------------------------------------------------------
+js_break::js_break(code_location const &loc)
+ : expression(loc),HasLabel(false) {
+ }
+
+
+
+
+js_break::js_break(string const &label,code_location const &loc)
+ : expression(loc),HasLabel(true),Label(label) {
+ }
+
+
+
+
+ref<value> js_break::evaluate(context const &ctx) const {
+ throw break_exception(HasLabel,Label,getCodeLocation());
+ }
+
+
+
+
+// js_continue ----------------------------------------------------------------
+js_continue::js_continue(code_location const &loc)
+ : expression(loc),HasLabel(false) {
+ }
+
+
+
+
+js_continue::js_continue(string const &label,code_location const &loc)
+ : expression(loc),HasLabel(true),Label(label) {
+ }
+
+
+
+
+ref<value> js_continue::evaluate(context const &ctx) const {
+ throw continue_exception(HasLabel,Label,getCodeLocation());
+ }
+
+
+
+
+// break_label ----------------------------------------------------------------
+break_label::break_label(string const &label,ref<expression> expr,code_location const &loc)
+ : expression(loc),Label(label),Expression(expr) {
+ }
+
+
+
+
+ref<value>
+break_label::evaluate(context const &ctx) const {
+ try {
+ return Expression->evaluate(ctx);
+ }
+ catch (break_exception &be) {
+ if (be.HasLabel && be.Label == Label) return ref<value>(NULL);
+ else throw;
+ }
+ }
+
+
+
+
+// js_switch -----------------------------------------------------------------
+js_switch::js_switch(ref<expression> discriminant,code_location const &loc)
+ : expression(loc),HasLabel(false),Discriminant(discriminant) {
+ }
+
+
+
+
+js_switch::js_switch(ref<expression> discriminant,string const &label,code_location const &loc)
+ : expression(loc),HasLabel(true),Label(label),Discriminant(discriminant) {
+ }
+
+
+
+
+ref<value>
+js_switch::
+evaluate(context const &ctx) const {
+ ref<list_scope,value> scope = new list_scope;
+ scope->unite(ctx.LookupScope);
+ context inner_context(scope);
+
+ ref<value> discr = Discriminant->evaluate(inner_context);
+
+ case_list::const_iterator expr,def;
+ bool expr_found = false,def_found = false;
+ FOREACH_CONST(first,CaseList,case_list) {
+ if (first->DiscriminantValue.get()) {
+ if (first->DiscriminantValue->evaluate(inner_context)->
+ operatorBinary(value::OP_EQUAL,Discriminant->evaluate(inner_context))->toBoolean()) {
+ expr = first;
+ expr_found = true;
+ break;
+ }
+ }
+ else {
+ if (!def_found) {
+ def = first;
+ def_found = true;
+ }
+ }
+ }
+
+ try {
+ case_list::const_iterator exec,last = CaseList.end();
+ if (expr_found)
+ exec = expr;
+ else if (def_found)
+ exec = def;
+ else
+ return ref<value>(NULL);
+
+ ref<value> result;
+ while (exec != last) {
+ result = exec->Expression->evaluate(inner_context);
+ exec++;
+ }
+ if (result.get()) return result->duplicate();
+ return ref<value>(NULL);
+ }
+ catch (break_exception &be) {
+ if (!be.HasLabel || (HasLabel && be.HasLabel && be.Label == Label))
+ return ref<value>(NULL);
+ else
+ throw;
+ }
+
+ // ATTENTION: this is a scope cancellation point.
+ }
+
+
+
+
+void js_switch::addCase(ref<expression> dvalue,ref<expression> expr) {
+ case_label cl;
+ cl.DiscriminantValue = dvalue;
+ cl.Expression = expr;
+ CaseList.push_back(cl);
+ }
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript interpreter
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <strstream>
+#include "ixlib_i18n.hh"
+#include <ixlib_base.hh>
+#include <ixlib_scanjs.hh>
+#include <ixlib_numconv.hh>
+#include <ixlib_js_internals.hh>
+#include <ixlib_token_javascript.hh>
+
+
+
+
+// tools ----------------------------------------------------------------------
+#define ADVANCE \
+ first++; \
+ if (first == last) EXJS_THROW(ECJS_UNEXPECTED_EOF)
+#define EXPECT(WHAT,STRINGIFIED) \
+ if (first == last) EXJS_THROW(ECJS_UNEXPECTED_EOF) \
+ if (first->Type != WHAT) \
+ EXJS_THROWINFOTOKEN(ECJS_UNEXPECTED,("'"+first->Text+"' "+_("instead of ")+STRINGIFIED).c_str(),*first)
+
+
+
+
+static char *dummy_i18n_referencer = N_("instead of ");
+
+
+
+using namespace ixion;
+using namespace javascript;
+
+
+
+
+namespace {
+ ref<expression>
+ makeConstantExpression(ref<value> val,code_location const &loc) {
+ ref<expression> result(new constant(val,loc));
+ return result;
+ }
+ }
+
+
+
+
+// garbage collectors ---------------------------------------------------------
+IXLIB_GARBAGE_DECLARE_MANAGER(value)
+IXLIB_GARBAGE_DECLARE_MANAGER(expression)
+
+
+
+
+// exception texts ------------------------------------------------------------
+static char *(PlainText[]) ={
+ N_("Unterminated comment"),
+ N_("Cannot convert"),
+ N_("Invalid operation"),
+ N_("Unexpected token encountered"),
+ N_("Unexpected end of file"),
+ N_("Cannot modify rvalue"),
+ N_("Unknown identifier"),
+ N_("Unknown operator"),
+ N_("Invalid non-local exit"),
+ N_("Invalid number of arguments"),
+ N_("Invalid token encountered"),
+ N_("Cannot redeclare identifier"),
+ N_("Constructor called on constructed object"),
+ N_("No superclass available"),
+ N_("Division by zero"),
+ };
+
+
+
+
+// no_location_javascript_exception -------------------------------------------
+char *no_location_javascript_exception::getText() const {
+ return _(PlainText[Error]);
+ }
+
+
+
+
+// javascript_exception -------------------------------------------------------
+javascript_exception::javascript_exception(TErrorCode error,code_location const &loc,char const *info,char *module = NULL,
+ TIndex line = 0)
+: base_exception(error, NULL, module, line, "JS") {
+ HasInfo = true;
+ try {
+ string temp = loc.stringify();
+ if (info) {
+ temp += ": ";
+ temp += info;
+ }
+ strcpy(Info,temp.c_str());
+ }
+ catch (...) { }
+ }
+
+
+
+javascript_exception::javascript_exception(no_location_javascript_exception const &half_ex,javascript::code_location const &loc)
+: base_exception(half_ex.Error,NULL,half_ex.Module,half_ex.Line,half_ex.Category) {
+ HasInfo = true;
+ try {
+ string temp = loc.stringify() + ": " + half_ex.Info;
+ strcpy(Info,temp.c_str());
+ }
+ catch (...) { }
+ }
+
+
+
+
+char *javascript_exception::getText() const {
+ return _(PlainText[Error]);
+ }
+
+
+
+
+// code_location --------------------------------------------------------------
+code_location::code_location(scanner::token &tok)
+ : Line(tok.Line) {
+ }
+
+
+
+
+code_location::code_location(TIndex line)
+ : Line(line) {
+ }
+
+
+
+
+string code_location::stringify() const {
+ return "l"+unsigned2dec(Line);
+ }
+
+
+
+
+// context --------------------------------------------------------------------
+context::context(ref<list_scope,value> scope)
+ : DeclarationScope(scope),LookupScope(scope) {
+ }
+
+
+
+
+context::context(ref<value> scope)
+ : LookupScope(scope) {
+ }
+
+
+
+
+context::context(ref<list_scope,value> decl_scope,ref<value> lookup_scope)
+ : DeclarationScope(decl_scope),LookupScope(lookup_scope) {
+ }
+
+
+
+
+// parser ---------------------------------------------------------------------
+namespace {
+ ref<expression>
+ parseInstructionList(scanner::token_iterator &first,scanner::token_iterator const &last,bool scoped);
+ ref<expression>
+ parseSwitch(scanner::token_iterator &first,scanner::token_iterator const &last,string const &label);
+ ref<expression>
+ parseVariableDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last);
+ ref<expression>
+ parseConstantDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last);
+ ref<expression>
+ parseFunctionDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last);
+ ref<expression>
+ parseMethodDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last);
+ ref<expression>
+ parseConstructorDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last,string const &class_id);
+ ref<expression>
+ parseClassDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last);
+ ref<expression>
+ parseInstruction(scanner::token_iterator &first,scanner::token_iterator const &last);
+ ref<expression>
+ parseExpression(scanner::token_iterator &first,scanner::token_iterator const &last,int precedence = 0);
+
+
+
+
+ ref<expression>
+ parseInstructionList(scanner::token_iterator &first,scanner::token_iterator const &last,bool scoped) {
+ auto_ptr<instruction_list> ilist(
+ scoped
+ ? new scoped_instruction_list(*first)
+ : new instruction_list(*first));
+
+ while (first != last && first->Type != '}') {
+ ref<expression> expr = parseInstruction(first,last);
+ if (expr.get() != NULL)
+ ilist->add(expr);
+ }
+ return ilist.release();
+ }
+
+
+
+
+ ref<expression>
+ parseSwitch(scanner::token_iterator &first,scanner::token_iterator const &last,string const &label) {
+ code_location loc(*first);
+
+ ADVANCE
+ EXPECT('(',_("'(' in switch statement"))
+ ADVANCE
+
+ ref<expression> discr = parseExpression(first,last);
+ EXPECT(')',_("')' in switch statement"))
+ ADVANCE
+
+ EXPECT('{',_("'{' in switch statement"))
+ ADVANCE
+
+ auto_ptr<js_switch> sw;
+ if (label.size()) {
+ auto_ptr<js_switch> tsw(new js_switch(discr,label,loc));
+ sw = tsw;
+ }
+ else {
+ auto_ptr<js_switch> tsw(new js_switch(discr,loc));
+ sw = tsw;
+ }
+
+ ref<expression> dvalue;
+ auto_ptr<instruction_list> ilist;
+
+ while (first != last && first->Type != '}') {
+ if (first->Type == TT_JS_CASE) {
+ if (ilist.get())
+ sw->addCase(dvalue,ilist.release());
+
+ auto_ptr<instruction_list> tilist(new instruction_list(*first));
+ ilist = tilist;
+
+ ADVANCE
+
+ dvalue = parseExpression(first,last);
+ EXPECT(':',_("':' in case label"))
+ ADVANCE
+ }
+ else if (first->Type == TT_JS_DEFAULT) {
+ if (ilist.get())
+ sw->addCase(dvalue,ilist.release());
+
+ auto_ptr<instruction_list> tilist(new instruction_list(*first));
+ ilist = tilist;
+
+ ADVANCE
+ dvalue = NULL;
+ EXPECT(':',_("':' in default label"))
+ ADVANCE
+ }
+ else {
+ ref<expression> expr = parseInstruction(first,last);
+ if (ilist.get() && expr.get() != NULL)
+ ilist->add(expr);
+ }
+ }
+
+ if (ilist.get())
+ sw->addCase(dvalue,ilist.release());
+
+ EXPECT('}',_("'}' in switch statement"))
+ ADVANCE
+
+ return sw.release();
+ }
+
+
+
+
+ ref<expression>
+ parseVariableDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last) {
+ code_location loc(*first);
+
+ EXPECT(TT_JS_IDENTIFIER,_("variable identifier"))
+ string id = first->Text;
+ ADVANCE
+
+ ref<expression> def;
+ if (first->Type == '=') {
+ ADVANCE
+ def = parseExpression(first,last);
+ }
+ ref<expression> result = new variable_declaration(id,def,loc);
+
+ if (first->Type == ',') {
+ auto_ptr<instruction_list> ilist(new instruction_list(*first));
+ ilist->add(result);
+
+ while (first->Type == ',') {
+ ADVANCE
+
+ code_location loc(*first);
+
+ EXPECT(TT_JS_IDENTIFIER,_("variable identifier"))
+ id = first->Text;
+ ADVANCE
+
+ if (first->Type == '=') {
+ ADVANCE
+ def = parseExpression(first,last);
+ }
+ ref<expression> decl = new variable_declaration(id,def,loc);
+ ilist->add(decl);
+ }
+ result = ilist.release();
+ }
+
+ return result;
+ }
+
+
+
+
+ ref<expression>
+ parseConstantDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last) {
+ code_location loc(*first);
+
+ EXPECT(TT_JS_IDENTIFIER,_("constant identifier"))
+ string id = first->Text;
+ ADVANCE
+
+ ref<expression> def;
+ EXPECT('=',_("initializer for constant"))
+ ADVANCE
+ def = parseExpression(first,last);
+
+ ref<expression> result = new constant_declaration(id,def,loc);
+
+ if (first->Type == ',') {
+ auto_ptr<instruction_list> ilist(new instruction_list(*first));
+ ilist->add(result);
+
+ while (first->Type == ',') {
+ ADVANCE
+
+ code_location loc(*first);
+
+ EXPECT(TT_JS_IDENTIFIER,_("constant identifier"))
+ id = first->Text;
+ ADVANCE
+
+ EXPECT('=',_("initializer for constant"))
+ ADVANCE
+ def = parseExpression(first,last);
+
+ ref<expression> decl = new constant_declaration(id,def,loc);
+ ilist->add(decl);
+ }
+ result = ilist.release();
+ }
+
+ return result;
+ }
+
+
+
+
+ ref<expression>
+ parseFunctionDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last) {
+ code_location loc(*first);
+
+ EXPECT(TT_JS_IDENTIFIER,_("function identifier"))
+ string id = first->Text;
+ ADVANCE
+
+ EXPECT('(',_("'(' in function declaration"))
+ ADVANCE
+
+ function::parameter_name_list pnames;
+
+ while (first->Type != ')') {
+ EXPECT(TT_JS_IDENTIFIER,_("parameter identifier"))
+ pnames.push_back(first->Text);
+ ADVANCE
+
+ if (first->Type == ',') {
+ ADVANCE
+ }
+ }
+ EXPECT(')',_("')' in function declaration"))
+ ADVANCE
+
+ EXPECT('{',_("'{' in function definition"))
+ ADVANCE
+
+ ref<expression> body = parseInstructionList(first,last,false);
+
+ EXPECT('}',"'}' in method definition")
+ first++;
+
+ ref<expression> result = new function_declaration(id,pnames,body,loc);
+ return result;
+ }
+
+
+
+
+ ref<expression>
+ parseMethodDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last) {
+ code_location loc(*first);
+
+ EXPECT(TT_JS_IDENTIFIER,_("method identifier"))
+ string id = first->Text;
+ ADVANCE
+
+ EXPECT('(',_("'(' in method declaration"))
+ ADVANCE
+
+ method::parameter_name_list pnames;
+
+ while (first->Type != ')') {
+ EXPECT(TT_JS_IDENTIFIER,_("parameter identifier"))
+ pnames.push_back(first->Text);
+ ADVANCE
+
+ if (first->Type == ',') {
+ ADVANCE
+ }
+ }
+ EXPECT(')',_("')' in method declaration"))
+ ADVANCE
+
+ EXPECT('{',_("'{' in method definition"))
+ ADVANCE
+
+ ref<expression> body = parseInstructionList(first,last,false);
+
+ EXPECT('}',"'}' in method definition")
+ first++;
+
+ ref<expression> result = new method_declaration(id,pnames,body,loc);
+ return result;
+ }
+
+
+
+
+ ref<expression>
+ parseConstructorDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last,string const &class_id) {
+ code_location loc(*first);
+
+ EXPECT(TT_JS_IDENTIFIER,_("constructor identifier"))
+ if (first->Text != class_id) {
+ EXJS_THROWINFOTOKEN(ECJS_UNEXPECTED,("'"+first->Text+"' "+_("instead of ")+_("class identifier")).c_str(),*first)
+ }
+ ADVANCE
+
+ EXPECT('(',_("'(' in constructor declaration"))
+ ADVANCE
+
+ method::parameter_name_list pnames;
+
+ while (first->Type != ')') {
+ EXPECT(TT_JS_IDENTIFIER,_("parameter identifier"))
+ pnames.push_back(first->Text);
+ ADVANCE
+
+ if (first->Type == ',') {
+ ADVANCE
+ }
+ }
+ EXPECT(')',_("')' in constructor declaration"))
+ ADVANCE
+
+ EXPECT('{',_("'{' in constructor definition"))
+ ADVANCE
+
+ ref<expression> body = parseInstructionList(first,last,false);
+
+ EXPECT('}',"'}' in constructor definition")
+ first++;
+
+ ref<expression> result = new constructor_declaration(pnames,body,loc);
+ return result;
+ }
+
+
+
+
+ ref<expression>
+ parseClassDeclaration(scanner::token_iterator &first,scanner::token_iterator const &last) {
+ code_location loc(*first);
+
+ EXPECT(TT_JS_IDENTIFIER,_("class identifier"))
+ string id = first->Text;
+ ADVANCE
+
+ ref<expression> superclass;
+ if (first->Type == TT_JS_EXTENDS) {
+ ADVANCE
+ superclass = parseExpression(first,last);
+ }
+
+ EXPECT('{',_("'{' in class declaration"))
+ ADVANCE
+
+ auto_ptr<js_class_declaration> decl(new js_class_declaration(id,superclass,loc));
+
+ while (first != last && first->Type != '}') {
+ if (first->Type == TT_JS_STATIC) {
+ ADVANCE
+
+ if (first->Type == TT_JS_FUNCTION) {
+ ADVANCE
+ decl->addStaticMethod(parseFunctionDeclaration(first,last));
+ }
+ else {
+ if (first->Type == TT_JS_CONST) {
+ ADVANCE
+ decl->addStaticVariable(parseConstantDeclaration(first,last));
+ }
+ else {
+ ADVANCE
+ decl->addStaticVariable(parseVariableDeclaration(first,last));
+ }
+ EXPECT(';',"';'")
+ first++;
+ }
+ }
+ else {
+ if (first->Type == TT_JS_FUNCTION) {
+ ADVANCE
+ decl->addMethod(parseMethodDeclaration(first,last));
+ }
+ else if (first->Type == TT_JS_CONSTRUCTOR) {
+ ADVANCE
+
+ EXPECT(TT_JS_FUNCTION,_("'function' keyword"))
+ ADVANCE
+
+ decl->setConstructor(parseConstructorDeclaration(first,last,id));
+ }
+ else {
+ if (first->Type == TT_JS_CONST) {
+ ADVANCE
+ decl->addVariable(parseConstantDeclaration(first,last));
+ }
+ else {
+ ADVANCE
+ decl->addVariable(parseVariableDeclaration(first,last));
+ }
+ EXPECT(';',"';'")
+ first++;
+ }
+ }
+ }
+
+ EXPECT('}',"'}' in class declaration")
+ first++;
+
+ return decl.release();
+ }
+
+
+
+
+ ref<expression>
+ parseInstruction(scanner::token_iterator &first,scanner::token_iterator const &last) {
+ if (first == last) EXJS_THROW(ECJS_UNEXPECTED_EOF)
+
+ string label;
+ if (first+1 != last && first[1].Type == ':') {
+ label = first->Text;
+ ADVANCE
+ ADVANCE
+ }
+
+ ref<expression> result;
+
+ if (first->Type == '{') {
+ ADVANCE
+ result = parseInstructionList(first,last,true);
+ EXPECT('}',"'}'")
+ first++;
+ }
+ else if (first->Type == TT_JS_VAR) {
+ ADVANCE
+
+ result = parseVariableDeclaration(first,last);
+
+ EXPECT(';',"';'")
+ first++;
+ }
+ else if (first->Type == TT_JS_CONST) {
+ ADVANCE
+
+ result = parseConstantDeclaration(first,last);
+
+ EXPECT(';',"';'")
+ first++;
+ }
+ else if (first->Type == TT_JS_FUNCTION) {
+ ADVANCE
+ result = parseFunctionDeclaration(first,last);
+ }
+ else if (first->Type == TT_JS_CLASS) {
+ ADVANCE
+ result = parseClassDeclaration(first,last);
+ }
+ else if (first->Type == TT_JS_IF) {
+ code_location loc(*first);
+ ADVANCE
+
+ EXPECT('(',_("'(' in if statement"))
+ ADVANCE
+
+ ref<expression> cond = parseExpression(first,last);
+ EXPECT(')',_("')' in if statement"))
+ first++;
+ ref<expression> if_expr = parseInstruction(first,last);
+ ref<expression> else_expr;
+
+ if (first != last && first->Type == TT_JS_ELSE) {
+ ADVANCE
+ else_expr = parseInstruction(first,last);
+ }
+ result = new js_if(cond,if_expr,else_expr,loc);
+ }
+ else if (first->Type == TT_JS_SWITCH) {
+ result = parseSwitch(first,last,label);
+ }
+ else if (first->Type == TT_JS_WHILE) {
+ code_location loc(*first);
+
+ ADVANCE
+ EXPECT('(',_("'(' in while statement"))
+ ADVANCE
+
+ ref<expression> cond = parseExpression(first,last);
+ EXPECT(')',_("')' in while statement"))
+ first++;
+
+ ref<expression> loop_expr = parseInstruction(first,last);
+
+ if (label.size()) {
+ result = new js_while(cond,loop_expr,label,loc);
+ label = "";
+ }
+ else
+ result = new js_while(cond,loop_expr,loc);
+ }
+ else if (first->Type == TT_JS_DO) {
+ code_location loc(*first);
+
+ ADVANCE
+ ref<expression> loop_expr = parseInstruction(first,last);
+
+ EXPECT(TT_JS_WHILE,_("'while' in do-while"))
+ ADVANCE
+
+ EXPECT('(',_("'(' in do-while statement"))
+ ADVANCE
+
+ ref<expression> cond = parseExpression(first,last);
+ EXPECT(')',_("')' in do-while statement"))
+ first++;
+
+ if (label.size()) {
+ result = new js_do_while(cond,loop_expr,label,loc);
+ label = "";
+ }
+ else
+ result = new js_do_while(cond,loop_expr,loc);
+ }
+ else if (first->Type == TT_JS_FOR) {
+ code_location loc(*first);
+
+ ADVANCE
+
+ EXPECT('(',_("'(' in for statement"))
+ ADVANCE
+
+ ref<expression> init_expr;
+ if (first->Type == TT_JS_VAR) {
+ ADVANCE
+
+ init_expr = parseVariableDeclaration(first,last);
+ }
+ else
+ init_expr = parseExpression(first,last);
+
+ if (first->Type == TT_JS_IN) {
+ // for (iterator in list)
+ ADVANCE
+ ref<expression> array_expr = parseExpression(first,last);
+
+ EXPECT(')',_("')' in for statement"))
+ first++;
+
+ ref<expression> loop_expr = parseInstruction(first,last);
+
+ if (label.size()) {
+ result = new js_for_in(init_expr,array_expr,loop_expr,label,loc);
+ label = "";
+ }
+ else
+ result = new js_for_in(init_expr,array_expr,loop_expr,label,loc);
+ }
+ else {
+ // for (;;) ...
+ EXPECT(';',_("';' in for statement"))
+ ADVANCE
+
+ ref<expression> cond_expr = parseExpression(first,last);
+
+ EXPECT(';',_("';' in for statement"))
+ ADVANCE
+
+ ref<expression> update_expr = parseExpression(first,last);
+
+ EXPECT(')',_("')' in for statement"))
+ first++;
+
+ ref<expression> loop_expr = parseInstruction(first,last);
+
+ if (label.size()) {
+ result = new js_for(init_expr,cond_expr,update_expr,loop_expr,label,loc);
+ label = "";
+ }
+ else
+ result = new js_for(init_expr,cond_expr,update_expr,loop_expr,loc);
+ }
+ }
+ else if (first->Type == TT_JS_RETURN) {
+ code_location loc(*first);
+ ADVANCE
+
+ if (first->Type != ';')
+ result = new js_return(parseExpression(first,last),loc);
+ else
+ result = new js_return(makeConstantExpression(makeNull(),loc),loc);
+
+ EXPECT(';',"';'")
+ first++;
+ }
+ else if (first->Type == TT_JS_BREAK) {
+ code_location loc(*first);
+ ADVANCE
+
+ if (first->Type != ';') {
+ EXPECT(TT_JS_IDENTIFIER,_("break label"))
+ result = new js_break(first->Text,loc);
+ ADVANCE
+ }
+ else
+ result = new js_break(loc);
+
+ EXPECT(';',"';'")
+ first++;
+ }
+ else if (first->Type == TT_JS_CONTINUE) {
+ code_location loc(*first);
+ ADVANCE
+
+ if (first->Type != ';') {
+ EXPECT(TT_JS_IDENTIFIER,_("continue label"))
+ result = new js_continue(first->Text,loc);
+ ADVANCE
+ }
+ else
+ result = new js_continue(loc);
+
+ EXPECT(';',"';'")
+ first++;
+ }
+ else if (first->Type == ';') {
+ first++;
+ result = makeConstantExpression(ref<value>(NULL),*first);
+ }
+ else {
+ // was nothing else, must be expression
+ result = parseExpression(first,last);
+ EXPECT(';',"';'")
+ first++;
+ }
+
+ if (label.size()) {
+ result = new break_label(label,result,*first);
+ }
+
+ return result;
+ }
+
+
+
+
+ namespace {
+ int const
+ PREC_COMMA = 10, // , (if implemented)
+ PREC_THROW = 20, // throw (if implemented)
+ PREC_ASSIGN = 30, // += and friends [ok]
+ PREC_CONDITIONAL = 40, // ?: [ok]
+ PREC_LOG_OR = 50, // || [ok]
+ PREC_LOG_AND = 60, // && [ok]
+ PREC_BIT_OR = 70, // | [ok]
+ PREC_BIT_XOR = 80, // ^ [ok]
+ PREC_BIT_AND = 90, // & [ok]
+ PREC_EQUAL = 100, // == != === !=== [ok]
+ PREC_COMP = 110, // < <= > >= [ok]
+ PREC_SHIFT = 120, // << >> [ok]
+ PREC_ADD = 130, // + - [ok]
+ PREC_MULT = 140, // * / % [ok]
+ PREC_UNARY = 160, // new + - ++ -- ! ~
+ PREC_FUNCALL = 170, // ()
+ PREC_SUBSCRIPT = 180, // [] .
+ PREC_TERM = 200; // literal identifier
+ }
+
+
+
+
+ ref<expression>
+ parseExpression(scanner::token_iterator &first,scanner::token_iterator const &last,int precedence) {
+ /*
+ precedence:
+ the called routine will continue parsing as long as the encountered
+ operators all have precedence greater than or equal to the given parameter.
+ */
+
+ // an EOF condition cannot legally occur inside
+ // or at the end of an expression.
+
+ if (first == last) EXJS_THROW(ECJS_UNEXPECTED_EOF)
+
+ ref<expression> expr;
+
+ // parse prefix unaries -----------------------------------------------------
+ if (precedence <= PREC_UNARY) {
+ if (first->Type == TT_JS_NEW) {
+ code_location loc(*first);
+ ADVANCE
+
+ ref<expression> cls = parseExpression(first,last,PREC_SUBSCRIPT);
+
+ EXPECT('(',_("'(' in 'new' expression"))
+ ADVANCE
+
+ function_call::parameter_expression_list pexps;
+ while (first->Type != ')') {
+ pexps.push_back(parseExpression(first,last));
+
+ if (first->Type == ',') {
+ ADVANCE
+ }
+ }
+
+ EXPECT(')',_("')' in 'new' expression"))
+ ADVANCE
+
+ expr = new construction(cls,pexps,loc);
+ }
+ if (first->Type == TT_JS_INCREMENT || first->Type == TT_JS_DECREMENT) {
+ code_location loc(*first);
+ value::operator_id op = value::token2operator(*first,true,true);
+ ADVANCE
+ expr = new modifying_unary_operator(op,parseExpression(first,last,PREC_UNARY),loc);
+ }
+ if (first->Type == '+' ||first->Type == '-'
+ || first->Type == '!' || first->Type == '~') {
+ code_location loc(*first);
+ value::operator_id op = value::token2operator(*first,true,true);
+ ADVANCE
+ expr = new unary_operator(op,parseExpression(first,last,PREC_UNARY),loc);
+ }
+ }
+
+ // parse parentheses --------------------------------------------------------
+ if (first->Type == '(') {
+ ADVANCE
+ expr = parseExpression(first,last);
+ EXPECT(')',"')'")
+ ADVANCE
+ }
+
+ // parse term ---------------------------------------------------------------
+ if (expr.get() == NULL && precedence <= PREC_TERM) {
+ if (first->Type == TT_JS_LIT_INT) {
+ expr = makeConstantExpression(makeConstant(evalUnsigned(first->Text)),*first);
+ ADVANCE
+ }
+ else if (first->Type == TT_JS_LIT_FLOAT) {
+ expr = makeConstantExpression(makeConstant(evalFloat(first->Text)),*first);
+ ADVANCE
+ }
+ else if (first->Type == TT_JS_LIT_STRING) {
+ expr = makeConstantExpression(makeConstant(parseCEscapes(
+ first->Text.substr(1,first->Text.size()-2)
+ )),*first);
+ ADVANCE
+ }
+ else if (first->Type == TT_JS_LIT_TRUE) {
+ expr = makeConstantExpression(makeConstant(true),*first);
+ ADVANCE
+ }
+ else if (first->Type == TT_JS_LIT_FALSE) {
+ expr = makeConstantExpression(makeConstant(false),*first);
+ ADVANCE
+ }
+ else if (first->Type == TT_JS_LIT_UNDEFINED) {
+ expr = makeConstantExpression(makeUndefined(),*first);
+ ADVANCE
+ }
+ else if (first->Type == TT_JS_IDENTIFIER) {
+ expr = new lookup_operation(first->Text,*first);
+ ADVANCE
+ }
+ else if (first->Type == TT_JS_NULL) {
+ expr = makeConstantExpression(makeNull(),*first);
+ ADVANCE
+ }
+ }
+
+ if (expr.get() == NULL)
+ EXJS_THROWINFOTOKEN(ECJS_UNEXPECTED,("'"+first->Text+"' instead of expression").c_str(),*first)
+
+ bool parsed_something;
+ do {
+ parsed_something = false;
+
+ // parse postfix "subscripts" ---------------------------------------------
+ if (first->Type == '(' && precedence <= PREC_FUNCALL) {
+ code_location loc(*first);
+ ADVANCE
+
+ function_call::parameter_expression_list pexps;
+ while (first->Type != ')') {
+ pexps.push_back(parseExpression(first,last));
+
+ if (first->Type == ',') {
+ ADVANCE
+ }
+ }
+
+ EXPECT(')',_("')' in function call"))
+ ADVANCE
+
+ expr = new function_call(expr,pexps,loc);
+ parsed_something = true;
+ }
+ // parse postfix unary ----------------------------------------------------
+ else if ((first->Type == TT_JS_INCREMENT || first->Type == TT_JS_DECREMENT) && precedence <= PREC_UNARY) {
+ value::operator_id op = value::token2operator(*first,true);
+ expr = new modifying_unary_operator(op,expr,*first);
+ parsed_something = true;
+ ADVANCE
+ }
+ // parse special binary operators -----------------------------------------
+ else if (first->Type == '.' && precedence <= PREC_SUBSCRIPT) {
+ ADVANCE
+ expr = new lookup_operation(expr,first->Text,*first);
+ ADVANCE
+ parsed_something = true;
+ }
+ else if (first->Type == '[' && precedence <= PREC_SUBSCRIPT) {
+ code_location loc(*first);
+ ADVANCE
+
+ ref<expression> index = parseExpression(first,last);
+
+ EXPECT(']',_("']' in subscript"))
+ ADVANCE
+
+ expr = new subscript_operation(expr,index,loc);
+
+ parsed_something = true;
+ }
+
+ // parse regular binary operators -----------------------------------------
+ #define BINARY_OP(PRECEDENCE,EXPRESSION,TYPE) \
+ else if ((EXPRESSION) && precedence <= PRECEDENCE) { \
+ code_location loc(*first); \
+ value::operator_id op = value::token2operator(*first); \
+ ADVANCE \
+ ref<expression> right = parseExpression(first,last,PRECEDENCE); \
+ expr = new TYPE##_operator(op,expr,right,loc); \
+ parsed_something = true; \
+ }
+
+ BINARY_OP(PREC_MULT,first->Type == '*' || first->Type == '/' || first->Type == '%',binary)
+ BINARY_OP(PREC_ADD,first->Type == '+' || first->Type == '-',binary)
+ BINARY_OP(PREC_SHIFT,first->Type == TT_JS_LEFT_SHIFT || first->Type == TT_JS_RIGHT_SHIFT,binary)
+ BINARY_OP(PREC_COMP,first->Type == '>' || first->Type == '<'
+ || first->Type == TT_JS_LESS_EQUAL || first->Type == TT_JS_GREATER_EQUAL
+ || first->Type == TT_JS_IDENTICAL || first->Type == TT_JS_NOT_IDENTICAL,binary)
+ BINARY_OP(PREC_EQUAL,first->Type == TT_JS_EQUAL || first->Type == TT_JS_NOT_EQUAL,binary)
+ BINARY_OP(PREC_BIT_AND,first->Type == '&',binary)
+ BINARY_OP(PREC_BIT_XOR,first->Type == '^',binary)
+ BINARY_OP(PREC_BIT_OR,first->Type == '|',binary)
+ BINARY_OP(PREC_LOG_AND,first->Type == TT_JS_LOGICAL_AND,binary_shortcut)
+ BINARY_OP(PREC_LOG_OR,first->Type == TT_JS_LOGICAL_OR,binary_shortcut)
+ else if (first->Type == '?') {
+ code_location loc(*first);
+ ADVANCE
+ ref<expression> op2 = parseExpression(first,last);
+ if (first->Type != ':')
+ EXJS_THROWINFO(ECJS_UNEXPECTED,(first->Text+" instead of ':'").c_str())
+ ADVANCE
+ ref<expression> op3 = parseExpression(first,last,PREC_CONDITIONAL);
+ expr = new ternary_operator(expr,op2,op3,loc);
+ parsed_something = true;
+ }
+ else if (first->Type == '=' && precedence <= PREC_ASSIGN) {
+ code_location loc(*first);
+ ADVANCE
+ ref<expression> op2 = parseExpression(first,last);
+ expr = new assignment(expr,op2,loc);
+ parsed_something = true;
+ }
+ BINARY_OP(PREC_ASSIGN,first->Type == TT_JS_PLUS_ASSIGN
+ || first->Type == TT_JS_MINUS_ASSIGN
+ || first->Type == TT_JS_MULTIPLY_ASSIGN
+ || first->Type == TT_JS_DIVIDE_ASSIGN
+ || first->Type == TT_JS_MODULO_ASSIGN
+ || first->Type == TT_JS_BIT_XOR_ASSIGN
+ || first->Type == TT_JS_BIT_AND_ASSIGN
+ || first->Type == TT_JS_BIT_OR_ASSIGN
+ || first->Type == TT_JS_LEFT_SHIFT_ASSIGN
+ || first->Type == TT_JS_RIGHT_SHIFT_ASSIGN,modifying_binary)
+ } while (parsed_something);
+
+ return expr;
+ }
+ }
+
+
+
+
+// interpreter -----------------------------------------------------------------
+interpreter::interpreter() {
+ RootScope = new list_scope;
+
+ ref<value> ac = new js_array_constructor();
+ RootScope->addMember("Array",ac);
+ }
+
+
+
+
+interpreter::~interpreter() {
+ }
+
+
+
+
+ref<expression> interpreter::parse(string const &str) {
+ // *** FIXME: this works around a bug in istrstream
+ if (str.size() == 0) {
+ return ref<expression>(NULL);
+ }
+ istrstream strm(str.data(),str.size());
+ return parse(strm);
+ }
+
+
+
+
+ref<expression> interpreter::parse(istream &istr) {
+ jsFlexLexer lexer(&istr);
+ scanner scanner(lexer);
+
+ scanner::token_list tokenlist = scanner.scan();
+ scanner::token_iterator text = tokenlist.begin();
+ return parseInstructionList(text,tokenlist.end(),false);
+ }
+
+
+
+
+ref<value> interpreter::execute(string const &str) {
+ return execute(parse(str));
+ }
+
+
+
+
+ref<value> interpreter::execute(istream &istr) {
+ return execute(parse(istr));
+ }
+
+
+
+
+ref<value> interpreter::execute(ref<expression> expr) {
+ if (expr.get() == NULL) return ref<value>(NULL);
+ return evaluateCatchExits(expr);
+ }
+
+
+
+
+ref<value> interpreter::evaluateCatchExits(ref<expression> expr) {
+ ref<value> result;
+ try {
+ context ctx(RootScope);
+ result = expr->evaluate(ctx);
+ }
+ catch (return_exception &re) {
+ EXJS_THROWINFOLOCATION(ECJS_INVALID_NON_LOCAL_EXIT,"return",re.Location)
+ }
+ catch (break_exception &be) {
+ if (be.HasLabel)
+ EXJS_THROWINFOLOCATION(ECJS_INVALID_NON_LOCAL_EXIT,("break "+be.Label).c_str(),be.Location)
+ else
+ EXJS_THROWINFOLOCATION(ECJS_INVALID_NON_LOCAL_EXIT,"break",be.Location)
+ }
+ catch (continue_exception &ce) {
+ if (ce.HasLabel)
+ EXJS_THROWINFOLOCATION(ECJS_INVALID_NON_LOCAL_EXIT,("continue "+ce.Label).c_str(),ce.Location)
+ else
+ EXJS_THROWINFOLOCATION(ECJS_INVALID_NON_LOCAL_EXIT,"continue",ce.Location)
+ }
+ return result;
+ }
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript interpreter library
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+#include <cmath>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <ixlib_js_internals.hh>
+#include <ixlib_numconv.hh>
+#include <ixlib_random.hh>
+
+
+
+
+using namespace ixion;
+using namespace javascript;
+
+
+
+
+namespace {
+ class eval : public value {
+ protected:
+ interpreter &Interpreter;
+
+ public:
+ value_type getType() const {
+ return VT_FUNCTION;
+ }
+ eval(interpreter &interpreter)
+ : Interpreter(interpreter) {
+ }
+ ref<value> call(parameter_list const ¶meters);
+ };
+
+ class Math : public value_with_methods {
+ private:
+ typedef value_with_methods super;
+
+ protected:
+ float_random RNG;
+
+ public:
+ value_type getType() const {
+ return VT_BUILTIN;
+ }
+
+ ref<value> duplicate() const;
+
+ ref<value> lookup(string const &identifier);
+ ref<value> callMethod(string const &identifier,parameter_list const ¶meters);
+ };
+ }
+
+
+
+
+// eval -----------------------------------------------------------------------
+ref<value>
+eval::
+call(parameter_list const ¶meters) {
+ if (parameters.size() != 1) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"eval")
+ }
+ if (parameters[0]->getType() != VT_STRING) return parameters[0];
+ return Interpreter.execute(parameters[0]->toString());
+ }
+
+
+
+
+// parseInt -------------------------------------------------------------------
+IXLIB_JS_DECLARE_FUNCTION(parseInt) {
+ if (parameters.size() != 1 && parameters.size() != 2) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"parseInt")
+ }
+ unsigned radix = 10;
+ if (parameters.size() == 2)
+ radix = parameters[1]->toInt();
+ return makeConstant(evalSigned(parameters[0]->toString(),radix));
+ }
+
+
+
+
+// parseFloat -----------------------------------------------------------------
+IXLIB_JS_DECLARE_FUNCTION(parseFloat) {
+ if (parameters.size() != 1) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"parseFloat")
+ }
+ return makeConstant(evalFloat(parameters[0]->toString()));
+ }
+
+
+
+
+// isNaN ----------------------------------------------------------------------
+#ifdef ADVANCED_MATH_AVAILABLE
+IXLIB_JS_DECLARE_FUNCTION(isNaN) {
+ if (parameters.size() != 1) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"isNaN")
+ }
+ int classification = fpclassify(parameters[0]->toFloat());
+ return makeConstant(classification == FP_NAN);
+ }
+#endif
+
+
+
+
+// isFinite -------------------------------------------------------------------
+#ifdef ADVANCED_MATH_AVAILABLE
+IXLIB_JS_DECLARE_FUNCTION(isFinite) {
+ if (parameters.size() != 1) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"isFinite")
+ }
+ int classification = fpclassify(parameters[0]->toFloat());
+ return makeConstant(classification != FP_NAN && classification != FP_INFINITE);
+ }
+#endif
+
+
+
+
+// Math -----------------------------------------------------------------------
+ref<value> Math::duplicate() const {
+ // Math is not mutable
+ return const_cast<Math *>(this);
+ }
+
+
+
+
+ref<value> Math::lookup(string const &identifier) {
+ #define MATH_CONSTANT(NAME,VALUE) \
+ if (identifier == NAME) return makeConstant(VALUE);
+
+ MATH_CONSTANT("E",2.7182818284590452354)
+ MATH_CONSTANT("LN10",2.30258509299404568402)
+ MATH_CONSTANT("LN2",0.69314718055994530942)
+ MATH_CONSTANT("LOG2E",1.4426950408889634074)
+ MATH_CONSTANT("LOG10E,",0.43429448190325182765)
+ MATH_CONSTANT("PI",3.14159265358979323846)
+ MATH_CONSTANT("SQRT1_2",0.70710678118654752440)
+ MATH_CONSTANT("SQRT2",1.41421356237309504880)
+
+ return super::lookup(identifier);
+ }
+
+
+
+
+ref<value> Math::callMethod(string const &identifier,parameter_list const ¶meters) {
+ #define MATH_FUNCTION(NAME,C_NAME) \
+ if (identifier == NAME) { \
+ if (parameters.size() != 1) { \
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"Math." NAME) \
+ } \
+ return makeConstant(C_NAME(parameters[0]->toFloat())); \
+ }
+
+ MATH_FUNCTION("abs",NUM_ABS)
+ MATH_FUNCTION("acos",acos)
+ MATH_FUNCTION("asin",asin)
+ MATH_FUNCTION("atan",atan)
+ MATH_FUNCTION("ceil",ceil)
+ MATH_FUNCTION("cos",cos)
+ MATH_FUNCTION("exp",exp)
+ MATH_FUNCTION("floor",floor)
+ MATH_FUNCTION("log",log)
+ #ifdef ADVANCED_MATH_AVAILABLE
+ MATH_FUNCTION("round",round)
+ #endif
+ MATH_FUNCTION("sin",sin)
+ MATH_FUNCTION("sqrt",sqrt)
+ MATH_FUNCTION("tan",tan)
+ if (identifier == "atan2") {
+ if (parameters.size() != 2) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"Math.atan2")
+ }
+ return makeConstant(atan2(parameters[0]->toFloat(),parameters[1]->toFloat()));
+ }
+ if (identifier == "pow") {
+ if (parameters.size() != 2) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"Math.pow")
+ }
+ return makeConstant(pow(parameters[0]->toFloat(),parameters[1]->toFloat()));
+ }
+ if (identifier == "random") {
+ if (parameters.size() != 0) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"Math.random")
+ }
+ return makeConstant(RNG());
+ }
+ // *** FIXME this is non-compliant, but there is no equivalent standard function
+ if (identifier == "initRandom") {
+ if (parameters.size() >= 2) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS,"Math.initRandom")
+ }
+ if (parameters.size() == 0)
+ RNG.init();
+ else if (parameters.size() == 1)
+ RNG.init(parameters[0]->toFloat());
+ return makeNull();
+ }
+
+ // *** FIXME: implement max, min
+ EXJS_THROWINFO(ECJS_UNKNOWN_IDENTIFIER,("Math." + identifier).c_str())
+ }
+
+
+
+
+// external interface functions -----------------------------------------------
+#define ADD_GLOBAL_OBJECT(NAME,TYPE) \
+ { ref<value> x = new TYPE(); \
+ ip.RootScope->addMember(NAME,x); \
+ }
+
+
+
+
+void javascript::addGlobal(interpreter &ip) {
+ ref<value> ev = new eval(ip);
+ ip.RootScope->addMember("eval",ev);
+
+ ADD_GLOBAL_OBJECT("parseInt",parseInt)
+ ADD_GLOBAL_OBJECT("parseFloat",parseFloat)
+ #ifdef ADVANCED_MATH_AVAILABLE
+ ADD_GLOBAL_OBJECT("isNaN",isNaN)
+ ADD_GLOBAL_OBJECT("isFinite",isFinite)
+ #endif
+
+ // *** FIXME hope this is portable
+ float zero = 0;
+ ip.RootScope->addMember("NaN",makeConstant(0.0/zero));
+ ip.RootScope->addMember("Infinity",makeConstant(1.0/zero));
+ ip.RootScope->addMember("undefined",makeUndefined());
+ }
+
+
+
+
+void javascript::addMath(interpreter &ip) {
+ ADD_GLOBAL_OBJECT("Math",Math)
+ }
+
+
+
+
+void javascript::addStandardLibrary(interpreter &ip) {
+ addGlobal(ip);
+ addMath(ip);
+ }
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Javascript interpreter
+// ----------------------------------------------------------------------------
+// (c) Copyright 2000 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <cstdio>
+#include <ixlib_i18n.hh>
+#include <ixlib_numconv.hh>
+#include <ixlib_re.hh>
+#include <ixlib_string.hh>
+#include <ixlib_js_internals.hh>
+#include <ixlib_token_javascript.hh>
+
+
+using namespace std;
+using namespace ixion;
+using namespace javascript;
+
+
+
+
+// value ----------------------------------------------------------------------
+string value::toString() const {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_CANNOT_CONVERT,
+ (valueType2string(getType())+string(_("-> string"))).c_str())
+ }
+
+
+
+
+int value::toInt() const {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_CANNOT_CONVERT,
+ (valueType2string(getType())+_(" -> int")).c_str())
+ }
+
+
+
+
+double value::toFloat() const {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_CANNOT_CONVERT,
+ (valueType2string(getType())+_(" -> float")).c_str())
+ }
+
+
+
+
+bool value::toBoolean() const {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_CANNOT_CONVERT,
+ (valueType2string(getType())+_(" -> bool")).c_str())
+ }
+
+
+
+
+string value::stringify() const {
+ try {
+ return toString();
+ }
+ catch (...) {
+ return string("#<")+valueType2string(getType())+">";
+ }
+ }
+
+
+
+
+ref<value> value::eliminateWrappers() {
+ return this;
+ }
+
+
+
+
+ref<value> value::duplicate() {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+_(": duplication")).c_str())
+ }
+
+
+
+
+ref<value>
+value::lookup(string const &identifier) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+_(": lookup of ")+identifier).c_str())
+ }
+
+
+
+
+ref<value>
+value::subscript(value const &index) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+_(": subscript")).c_str())
+ }
+
+
+
+
+ref<value>
+value::call(parameter_list const ¶meters) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+_(": call")).c_str())
+ }
+
+
+
+
+ref<value>
+value::callAsMethod(ref<value> instance,parameter_list const ¶meters) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+_(": call as method")).c_str())
+ }
+
+
+
+
+ref<value>
+value::construct(parameter_list const ¶meters) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+_(": construction")).c_str())
+ }
+
+
+
+
+ref<value> value::assign(ref<value> op2) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+_(": assignment")).c_str())
+ }
+
+
+
+
+ref<value>
+value::operatorUnary(operator_id op) const {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+_(": operator ")+operator2string(op)).c_str())
+ }
+
+
+
+
+ref<value>
+value::operatorBinary(operator_id op,ref<value> op2) const {
+ if (op == OP_EQUAL) {
+ if (getType() == VT_NULL)
+ return makeConstant(op2->getType() == VT_NULL);
+ if (op2->getType() == VT_NULL)
+ return makeConstant(getType() == VT_NULL);
+ }
+ if (op == OP_NOT_EQUAL) {
+ if (getType() == VT_NULL)
+ return makeConstant(op2->getType() != VT_NULL);
+ if (op2->getType() == VT_NULL)
+ return makeConstant(getType() != VT_NULL);
+ }
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+" "+string(operator2string(op))+" "+valueType2string(op2->getType())).c_str())
+ }
+
+
+
+
+ref<value>
+value::operatorBinaryShortcut(operator_id op,expression const &op2,context const &ctx) const {
+ if (op == OP_LOGICAL_OR)
+ return makeConstant(toBoolean() || op2.evaluate(ctx)->toBoolean());
+ if (op == OP_LOGICAL_AND)
+ return makeConstant(toBoolean() && op2.evaluate(ctx)->toBoolean());
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (string(operator2string(op))+_(" on ")+valueType2string(getType())).c_str())
+ }
+
+
+
+
+ref<value>
+value::operatorUnaryModifying(operator_id op) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (string(operator2string(op))+_(" on ")+valueType2string(getType())).c_str())
+ }
+
+
+
+
+ref<value>
+value::operatorBinaryModifying(operator_id op,ref<value> op2) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_INVALID_OPERATION,
+ (valueType2string(getType())+" "+string(operator2string(op))+" "+valueType2string(op2->getType())).c_str())
+ }
+
+
+
+
+value::operator_id
+value::token2operator(scanner::token const &token,bool unary,bool prefix) {
+ switch (token.Type) {
+ case TT_JS_INCREMENT: return prefix ? OP_PRE_INCREMENT : OP_POST_INCREMENT;
+ case TT_JS_DECREMENT: return prefix ? OP_PRE_DECREMENT : OP_POST_DECREMENT;
+ case '+': return unary ? OP_UNARY_PLUS : OP_PLUS;
+ case '-': return unary ? OP_UNARY_MINUS : OP_MINUS;
+ case '!': return OP_LOG_NOT;
+ case '~': return OP_BIN_NOT;
+ case TT_JS_PLUS_ASSIGN: return OP_PLUS_ASSIGN;
+ case TT_JS_MINUS_ASSIGN: return OP_MINUS_ASSIGN;
+ case TT_JS_MULTIPLY_ASSIGN: return OP_MUTLIPLY_ASSIGN;
+ case TT_JS_DIVIDE_ASSIGN: return OP_DIVIDE_ASSIGN;
+ case TT_JS_MODULO_ASSIGN: return OP_MODULO_ASSIGN;
+ case TT_JS_BIT_AND_ASSIGN: return OP_BIT_AND_ASSIGN;
+ case TT_JS_BIT_OR_ASSIGN: return OP_BIT_OR_ASSIGN;
+ case TT_JS_BIT_XOR_ASSIGN: return OP_BIT_XOR_ASSIGN;
+ case TT_JS_LEFT_SHIFT_ASSIGN: return OP_LEFT_SHIFT_ASSIGN;
+ case TT_JS_RIGHT_SHIFT_ASSIGN: return OP_RIGHT_SHIFT_ASSIGN;
+ case '*': return OP_MULTIPLY;
+ case '/': return OP_DIVIDE;
+ case '%': return OP_MODULO;
+ case '&': return OP_BIT_AND;
+ case '|': return OP_BIT_OR;
+ case '^': return OP_BIT_XOR;
+ case TT_JS_LEFT_SHIFT: return OP_LEFT_SHIFT;
+ case TT_JS_RIGHT_SHIFT: return OP_RIGHT_SHIFT;
+ case TT_JS_LOGICAL_OR: return OP_LOGICAL_OR;
+ case TT_JS_LOGICAL_AND: return OP_LOGICAL_AND;
+ case TT_JS_EQUAL: return OP_EQUAL;
+ case TT_JS_NOT_EQUAL: return OP_NOT_EQUAL;
+ case TT_JS_IDENTICAL: return OP_IDENTICAL;
+ case TT_JS_NOT_IDENTICAL: return OP_NOT_IDENTICAL;
+ case TT_JS_LESS_EQUAL: return OP_LESS_EQUAL;
+ case TT_JS_GREATER_EQUAL: return OP_GREATER_EQUAL;
+ case '<': return OP_LESS;
+ case '>': return OP_GREATER;
+ default: EXJS_THROWINFO(ECJS_UNKNOWN_OPERATOR,token.Text.c_str())
+ }
+ }
+
+
+
+
+string
+value::operator2string(operator_id op) {
+ switch (op) {
+ case OP_PRE_INCREMENT: return _("prefix ++");
+ case OP_POST_INCREMENT: return _("postfix ++");
+ case OP_PRE_DECREMENT: return _("prefix --");
+ case OP_POST_DECREMENT: return _("postfix ++");
+
+ case OP_UNARY_PLUS: return _("unary +");
+ case OP_UNARY_MINUS: return _("unary -");
+ case OP_LOG_NOT: return "!";
+ case OP_BIN_NOT: return "~";
+
+ case OP_PLUS_ASSIGN: return "+=";
+ case OP_MINUS_ASSIGN: return "-=";
+ case OP_MUTLIPLY_ASSIGN: return "*=";
+ case OP_DIVIDE_ASSIGN: return "/=";
+ case OP_MODULO_ASSIGN: return "%=";
+
+ case OP_BIT_AND_ASSIGN: return "&=";
+ case OP_BIT_OR_ASSIGN: return "|=";
+ case OP_BIT_XOR_ASSIGN: return "^=";
+ case OP_LEFT_SHIFT_ASSIGN: return "<<=";
+ case OP_RIGHT_SHIFT_ASSIGN: return ">>=";
+
+ case OP_PLUS: return "+";
+ case OP_MINUS: return "-";
+ case OP_MULTIPLY: return "*";
+ case OP_DIVIDE: return "/";
+ case OP_MODULO: return "%";
+
+ case OP_BIT_AND: return "&";
+ case OP_BIT_OR: return "|";
+ case OP_BIT_XOR: return "^";
+ case OP_LEFT_SHIFT: return "<<";
+ case OP_RIGHT_SHIFT: return ">>";
+
+ case OP_LOGICAL_OR: return "|";
+ case OP_LOGICAL_AND: return "&";
+ case OP_EQUAL: return "==";
+ case OP_NOT_EQUAL: return "!=";
+ case OP_IDENTICAL: return "===";
+ case OP_NOT_IDENTICAL: return "!==";
+ case OP_LESS_EQUAL: return "<=";
+ case OP_GREATER_EQUAL: return ">=";
+ case OP_LESS: return "<";
+ case OP_GREATER: return ">";
+
+ case OP_ASSIGN: return "=";
+ default: EXJS_THROW(ECJS_UNKNOWN_OPERATOR)
+ }
+ }
+
+
+
+
+string value::valueType2string(value_type vt) {
+ switch (vt) {
+ case VT_UNDEFINED: return _("undefined");
+ case VT_NULL: return _("null");
+ case VT_INTEGER: return _("integer");
+ case VT_FLOATING_POINT: return _("floating point");
+ case VT_STRING: return _("string");
+ case VT_FUNCTION: return _("function");
+ case VT_OBJECT: return _("object");
+ case VT_BUILTIN: return _("built-in object");
+ case VT_HOST: return _("host object");
+ case VT_SCOPE: return _("scope");
+ case VT_BOUND_METHOD: return _("bound method");
+ case VT_TYPE: return _("type");
+ default: return _("unknown value type");
+ }
+ }
+
+
+
+
+// value_with_methods ---------------------------------------------------------
+value_with_methods::bound_method::
+bound_method(string const &identifier,ref<value_with_methods,value> parent)
+ : Identifier(identifier),Parent(parent) {
+ }
+
+
+
+
+ref<value>
+value_with_methods::bound_method::duplicate() {
+ // bound_methods are immutable
+ return this;
+ }
+
+
+
+
+ref<value>
+value_with_methods::bound_method::
+call(parameter_list const ¶meters) {
+ return Parent->callMethod(Identifier,parameters);
+ }
+
+
+
+
+ref<value>
+value_with_methods::
+lookup(string const &identifier) {
+ ref<value> result = new bound_method(identifier,this);
+ return result;
+ }
+
+
+
+
+// null -----------------------------------------------------------------------
+value::value_type null::getType() const {
+ return VT_NULL;
+ }
+
+
+
+
+bool null::toBoolean() const {
+ return false;
+ }
+
+
+
+
+ref<value> null::duplicate() {
+ return makeNull();
+ }
+
+
+
+
+// const_floating_point -------------------------------------------------------
+const_floating_point::const_floating_point(double value)
+ : Value(value) {
+ }
+
+
+
+
+value::value_type const_floating_point::getType() const {
+ return VT_FLOATING_POINT;
+ }
+
+
+
+
+int const_floating_point::toInt() const {
+ return (int) Value;
+ }
+
+
+
+
+double const_floating_point::toFloat() const {
+ return (double) Value;
+ }
+
+
+
+
+bool const_floating_point::toBoolean() const {
+ return (bool) Value;
+ }
+
+
+
+
+string const_floating_point::toString() const {
+ return float2dec(Value);
+ }
+
+
+
+
+ref<value> const_floating_point::duplicate() {
+ return makeValue(Value);
+ }
+
+
+
+
+ref<value>
+const_floating_point::
+callMethod(string const &identifier,parameter_list const ¶meters) {
+ IXLIB_JS_IF_METHOD("toInt",0,0)
+ return makeConstant((signed long) Value);
+ IXLIB_JS_IF_METHOD("toFloat",0,0)
+ return makeConstant(Value);
+ IXLIB_JS_IF_METHOD("toString",0,1) {
+ unsigned radix = 10;
+ if (parameters.size() == 1) radix = parameters[0]->toInt();
+ if (radix == 10)
+ return makeConstant(float2dec(Value));
+ else
+ return makeConstant(signed2base((int) Value,0,radix));
+ }
+ IXLIB_JS_IF_METHOD("toFixed",0,1) {
+ unsigned digits = 0;
+ if (parameters.size() == 1) digits = parameters[0]->toInt();
+
+ char buffer[1024];
+ sprintf(buffer,("%."+unsigned2dec(digits)+"f").c_str(),Value);
+ return makeConstant(buffer);
+ }
+ IXLIB_JS_IF_METHOD("toExponential",0,1) {
+ char buffer[1024];
+ if (parameters.size() == 1)
+ sprintf(buffer,("%."+unsigned2dec(parameters[0]->toInt())+"e").c_str(),Value);
+ else
+ sprintf(buffer,"%e",Value);
+ return makeConstant(buffer);
+ }
+ IXLIB_JS_IF_METHOD("toPrecision",0,1) {
+ if (parameters.size() == 1)
+ return makeConstant(float2dec(Value,parameters[0]->toInt()));
+ else
+ return makeConstant(float2dec(Value));
+ }
+ EXJS_THROWINFO_NO_LOCATION(ECJS_UNKNOWN_IDENTIFIER,("float." + identifier).c_str())
+ }
+
+
+
+
+ref<value>
+const_floating_point::operatorUnary(operator_id op) const {
+ switch (op) {
+ case OP_UNARY_PLUS: return makeConstant(+Value);
+ case OP_UNARY_MINUS: return makeConstant(-Value);
+ case OP_LOG_NOT: return makeConstant(!Value);
+ case OP_BIN_NOT: return makeConstant(~ (long) Value);
+ default:
+ return super::operatorUnary(op);
+ }
+ }
+
+
+
+
+ref<value>
+const_floating_point::operatorBinary(operator_id op,ref<value> op2) const {
+ #define FLOAT_OPERATOR(OP) \
+ if (op2->getType() == VT_FLOATING_POINT || op2->getType() == VT_INTEGER) \
+ return makeConstant(Value OP op2->toFloat());
+ #define PASS_UP \
+ return super::operatorBinary(op,op2);
+
+ switch (op) {
+ case OP_PLUS:
+ FLOAT_OPERATOR(+)
+ PASS_UP
+ case OP_MINUS:
+ FLOAT_OPERATOR(-)
+ PASS_UP
+ case OP_MULTIPLY:
+ FLOAT_OPERATOR(*)
+ PASS_UP
+ case OP_DIVIDE:
+ if (op2->getType() == VT_FLOATING_POINT || op2->getType() == VT_INTEGER) {
+ double op2value = op2->toFloat();
+ if (op2value == 0)
+ EXJS_THROW(ECJS_DIVISION_BY_ZERO)
+ return makeConstant(Value / op2value);
+ }
+ PASS_UP
+ case OP_EQUAL:
+ FLOAT_OPERATOR(==)
+ PASS_UP
+ case OP_NOT_EQUAL:
+ FLOAT_OPERATOR(!=)
+ PASS_UP
+ case OP_LESS_EQUAL:
+ FLOAT_OPERATOR(<=)
+ PASS_UP
+ case OP_GREATER_EQUAL:
+ FLOAT_OPERATOR(>=)
+ PASS_UP
+ case OP_LESS:
+ FLOAT_OPERATOR(<)
+ PASS_UP
+ case OP_GREATER:
+ FLOAT_OPERATOR(>)
+ PASS_UP
+ default:
+ return super::operatorBinary(op,op2);
+ }
+ #undef FLOAT_OPERATOR
+ #undef PASS_UP
+ }
+
+
+
+
+// floating_point -------------------------------------------------------------
+floating_point::floating_point(double val)
+ : const_floating_point(val) {
+ }
+
+
+
+
+ref<value>
+floating_point::operatorUnaryModifying(operator_id op) {
+ switch (op) {
+ case OP_PRE_INCREMENT:
+ Value++;
+ return ref<value>(this);
+ case OP_POST_INCREMENT:
+ // *** FIXME this should be an lvalue
+ return makeConstant(Value++);
+ case OP_PRE_DECREMENT:
+ Value--;
+ return ref<value>(this);
+ case OP_POST_DECREMENT:
+ // *** FIXME this should be an lvalue
+ return makeConstant(Value--);
+ default:
+ return super::operatorUnaryModifying(op);
+ }
+ }
+
+
+
+
+ref<value>
+floating_point::operatorBinaryModifying(operator_id op,ref<value> op2) {
+ int val;
+ switch (op) {
+ case OP_PLUS_ASSIGN:
+ Value += op2->toFloat();
+ return ref<value>(this);
+ case OP_MINUS_ASSIGN:
+ Value -= op2->toFloat();
+ return ref<value>(this);
+ case OP_MUTLIPLY_ASSIGN:
+ Value *= op2->toFloat();
+ return ref<value>(this);
+ case OP_DIVIDE_ASSIGN: {
+ double op2value = op2->toFloat();
+ if (op2value == 0)
+ EXJS_THROW(ECJS_DIVISION_BY_ZERO)
+ Value /= op2value;
+ return ref<value>(this);
+ }
+ case OP_MODULO_ASSIGN:
+ val = (int) Value;
+ val %= (int) op2->toFloat();
+ Value = val;
+ return ref<value>(this);
+ case OP_BIT_AND_ASSIGN:
+ val = (int) Value;
+ val &= (int) op2->toFloat();
+ Value = val;
+ return ref<value>(this);
+ case OP_BIT_OR_ASSIGN:
+ val = (int) Value;
+ val |= (int) op2->toFloat();
+ Value = val;
+ return ref<value>(this);
+ case OP_BIT_XOR_ASSIGN:
+ val = (int) Value;
+ val ^= (int) op2->toFloat();
+ Value = val;
+ return ref<value>(this);
+ case OP_LEFT_SHIFT_ASSIGN:
+ val = (int) Value;
+ val <<= (int) op2->toFloat();
+ Value = val;
+ return ref<value>(this);
+ case OP_RIGHT_SHIFT_ASSIGN:
+ val = (int) Value;
+ val >>= (int) op2->toFloat();
+ Value = val;
+ return ref<value>(this);
+ default:
+ return super::operatorBinaryModifying(op,op2);
+ }
+ }
+
+
+
+
+// const_integer --------------------------------------------------------------
+const_integer::const_integer(long value)
+ : Value(value) {
+ }
+
+
+
+
+value::value_type const_integer::getType() const {
+ return VT_INTEGER;
+ }
+
+
+
+
+int const_integer::toInt() const {
+ return (int) Value;
+ }
+
+
+
+
+double const_integer::toFloat() const {
+ return (double) Value;
+ }
+
+
+
+
+bool const_integer::toBoolean() const {
+ return (bool) Value;
+ }
+
+
+
+
+string const_integer::toString() const {
+ return signed2dec(Value);
+ }
+
+
+
+
+ref<value> const_integer::duplicate() {
+ return makeValue(Value);
+ }
+
+
+
+
+ref<value>
+const_integer::
+callMethod(string const &identifier,parameter_list const ¶meters) {
+ IXLIB_JS_IF_METHOD("toInt",0,0)
+ return makeConstant(Value);
+ IXLIB_JS_IF_METHOD("toFloat",0,0)
+ return makeConstant((double) Value);
+ IXLIB_JS_IF_METHOD("toString",0,1) {
+ unsigned radix = 10;
+ if (parameters.size() == 1) radix = parameters[0]->toInt();
+ return makeConstant(signed2base(Value,0,radix));
+ }
+ EXJS_THROWINFO_NO_LOCATION(ECJS_UNKNOWN_IDENTIFIER,("integer." + identifier).c_str())
+ }
+
+
+
+
+ref<value>
+const_integer::operatorUnary(operator_id op) const {
+ switch (op) {
+ case OP_UNARY_PLUS: return makeConstant(+Value);
+ case OP_UNARY_MINUS: return makeConstant(-Value);
+ case OP_LOG_NOT: return makeConstant(!Value);
+ case OP_BIN_NOT: return makeConstant(~ (long) Value);
+ default:
+ return super::operatorUnary(op);
+ }
+ }
+
+
+
+
+ref<value>
+const_integer::operatorBinary(operator_id op,ref<value> op2) const {
+ #define FLOAT_OPERATOR(OP) \
+ if (op2->getType() == VT_FLOATING_POINT) \
+ return makeConstant(toFloat() OP op2->toFloat());
+ #define INT_OPERATOR(OP) \
+ if (op2->getType() == VT_INTEGER) \
+ return makeConstant(Value OP op2->toInt());
+ #define PASS_UP \
+ return super::operatorBinary(op,op2);
+
+ switch (op) {
+ case OP_PLUS:
+ FLOAT_OPERATOR(+)
+ INT_OPERATOR(+)
+ PASS_UP
+ case OP_MINUS:
+ FLOAT_OPERATOR(-)
+ INT_OPERATOR(-)
+ PASS_UP
+ case OP_MULTIPLY:
+ FLOAT_OPERATOR(*)
+ INT_OPERATOR(*)
+ PASS_UP
+ case OP_DIVIDE:
+ if (op2->toFloat() == 0)
+ EXJS_THROW(ECJS_DIVISION_BY_ZERO)
+ FLOAT_OPERATOR(/)
+ INT_OPERATOR(/)
+ PASS_UP
+ case OP_MODULO:
+ INT_OPERATOR(%)
+ PASS_UP
+ case OP_BIT_AND:
+ INT_OPERATOR(&)
+ PASS_UP
+ case OP_BIT_OR:
+ INT_OPERATOR(|)
+ PASS_UP
+ case OP_BIT_XOR:
+ INT_OPERATOR(^)
+ PASS_UP
+ case OP_LEFT_SHIFT:
+ INT_OPERATOR(<<)
+ PASS_UP
+ case OP_RIGHT_SHIFT:
+ INT_OPERATOR(>>)
+ PASS_UP
+ case OP_EQUAL:
+ FLOAT_OPERATOR(==)
+ INT_OPERATOR(==)
+ PASS_UP
+ case OP_NOT_EQUAL:
+ FLOAT_OPERATOR(!=)
+ INT_OPERATOR(!=)
+ PASS_UP
+ case OP_LESS_EQUAL:
+ FLOAT_OPERATOR(<=)
+ INT_OPERATOR(<=)
+ PASS_UP
+ case OP_GREATER_EQUAL:
+ FLOAT_OPERATOR(>=)
+ INT_OPERATOR(>=)
+ PASS_UP
+ case OP_LESS:
+ FLOAT_OPERATOR(<)
+ INT_OPERATOR(<)
+ PASS_UP
+ case OP_GREATER:
+ FLOAT_OPERATOR(>)
+ INT_OPERATOR(>)
+ PASS_UP
+ default:
+ PASS_UP
+ }
+ #undef FLOAT_OPERATOR
+ #undef INT_OPERATOR
+ #undef PASS_UP
+ }
+
+
+
+
+// integer --------------------------------------------------------------------
+integer::integer(long val)
+ : const_integer(val) {
+ }
+
+
+
+
+ref<value>
+integer::operatorUnaryModifying(operator_id op) {
+ switch (op) {
+ case OP_PRE_INCREMENT:
+ Value++;
+ return ref<value>(this);
+ case OP_POST_INCREMENT:
+ // *** FIXME this should be an lvalue
+ return makeConstant(Value++);
+ case OP_PRE_DECREMENT:
+ Value--;
+ return ref<value>(this);
+ case OP_POST_DECREMENT:
+ // *** FIXME this should be an lvalue
+ return makeConstant(Value--);
+ default:
+ return super::operatorUnaryModifying(op);
+ }
+ }
+
+
+
+
+ref<value>
+integer::operatorBinaryModifying(operator_id op,ref<value> op2) {
+ int val;
+ int op2value = op2->toInt();
+ switch (op) {
+ case OP_PLUS_ASSIGN:
+ Value += op2value;
+ return ref<value>(this);
+ case OP_MINUS_ASSIGN:
+ Value -= op2value;
+ return ref<value>(this);
+ case OP_MUTLIPLY_ASSIGN:
+ Value *= op2value;
+ return ref<value>(this);
+ case OP_DIVIDE_ASSIGN:
+ if (op2value == 0)
+ EXJS_THROW(ECJS_DIVISION_BY_ZERO)
+ Value /= op2value;
+ return ref<value>(this);
+ case OP_MODULO_ASSIGN:
+ val = Value;
+ val %= op2value;
+ Value = val;
+ return ref<value>(this);
+ case OP_BIT_AND_ASSIGN:
+ val = Value;
+ val &= op2value;
+ Value = val;
+ return ref<value>(this);
+ case OP_BIT_OR_ASSIGN:
+ val = Value;
+ val |= op2value;
+ Value = val;
+ return ref<value>(this);
+ case OP_BIT_XOR_ASSIGN:
+ val = Value;
+ val ^= op2value;
+ Value = val;
+ return ref<value>(this);
+ case OP_LEFT_SHIFT_ASSIGN:
+ val = Value;
+ val <<= op2value;
+ Value = val;
+ return ref<value>(this);
+ case OP_RIGHT_SHIFT_ASSIGN:
+ val = Value;
+ val >>= op2value;
+ Value = val;
+ return ref<value>(this);
+ default:
+ return super::operatorBinaryModifying(op,op2);
+ }
+ }
+
+
+
+
+// js_string ------------------------------------------------------------------
+js_string::js_string(string const &value)
+ : Value(value) {
+ }
+
+
+
+
+value::value_type js_string::getType() const {
+ return VT_STRING;
+ }
+
+
+
+
+string js_string::toString() const {
+ return Value;
+ }
+
+
+
+
+bool js_string::toBoolean() const {
+ return Value.size() == 0;
+ }
+
+
+
+
+string js_string::stringify() const {
+ return '"'+Value+'"';
+ }
+
+
+
+
+ref<value> js_string::duplicate() {
+ return makeValue(Value);
+ }
+
+
+
+
+ref<value> js_string::lookup(string const &identifier) {
+ if (identifier == "length") return makeConstant(Value.size());
+ return super::lookup(identifier);
+ }
+
+
+
+
+ref<value> js_string::callMethod(string const &identifier,parameter_list const ¶meters) {
+ IXLIB_JS_IF_METHOD("toString",0,0)
+ return makeConstant(Value);
+ IXLIB_JS_IF_METHOD("charAt",1,1)
+ return makeConstant(string(1,Value.at(parameters[0]->toInt())));
+ IXLIB_JS_IF_METHOD("charCodeAt",1,1)
+ return makeConstant(Value.at(parameters[0]->toInt()));
+ if (identifier == "concat") {
+ string result = Value;
+ FOREACH_CONST(first,parameters,parameter_list)
+ Value += (*first)->toString();
+ return makeConstant(Value);
+ }
+ IXLIB_JS_IF_METHOD("indexOf",1,2) {
+ string::size_type startpos = 0;
+ if (parameters.size() == 2) startpos = parameters[1]->toInt();
+ string::size_type result = Value.find(parameters[0]->toString(),startpos);
+ if (result == string::npos) return makeConstant(-1);
+ else return makeConstant(result);
+ }
+ IXLIB_JS_IF_METHOD("lastIndexOf",1,2) {
+ string::size_type startpos = string::npos;
+ if (parameters.size() == 2) startpos = parameters[1]->toInt();
+ string::size_type result = Value.rfind(parameters[0]->toString(),startpos);
+ if (result == string::npos) return makeConstant(-1);
+ else return makeConstant(result);
+ }
+ // *** FIXME we need proper regexps
+ IXLIB_JS_IF_METHOD("match",1,1) {
+ regex_string re(parameters[0]->toString());
+ return makeConstant(re.matchAt(Value,0));
+ }
+ IXLIB_JS_IF_METHOD("replace",2,2) {
+ regex_string re(parameters[0]->toString());
+ return makeConstant(re.replaceAll(Value,parameters[1]->toString()));
+ }
+ IXLIB_JS_IF_METHOD("search",1,1) {
+ regex_string re(parameters[0]->toString());
+ return makeConstant(re.match(Value));
+ }
+ IXLIB_JS_IF_METHOD("slice",2,2) {
+ TIndex start = parameters[0]->toInt(),end = parameters[1]->toInt();
+ return makeConstant(string(Value,start,end-start));
+ }
+
+ /*
+ Allow 2 parameters here, the first one is the separator and the second
+ one is the maximum allowed number of elements of the resulting array
+ if the function is called without a parameter the string is split
+ into a character array.
+ The second parameter sets the maximum number of elements of the
+ resulting array.
+ */
+
+ IXLIB_JS_IF_METHOD("split", 0, 2 ) {
+ string::size_type start = 0, last = 0;
+ int count = 0;
+ int max = -1;
+
+ if (parameters.size() == 2)
+ max = parameters[1]->toInt();
+
+ string sep;
+
+ auto_ptr<js_array> result(new js_array(0));
+
+ if (parameters.size() == 0 || (sep = parameters[0]->toString()).empty()) {
+ for (string::size_type i = 0; i < Value.size(); ++i) {
+ string s;
+ s += Value[i];
+ result->push_back(makeValue(s));
+ }
+ }
+ else {
+ while (true) {
+ if (max > 0)
+ count++;
+
+ if (count >= max && max > 0) {
+ result->push_back(makeValue(Value.substr(last)));
+ break;
+ }
+
+ start = Value.find(sep, last);
+
+ if (start == string::npos) {
+ result->push_back(makeValue(Value.substr(last)));
+ break;
+ }
+
+ result->push_back(makeValue(Value.substr(last, start - last)));
+ last = start + sep.size();
+ }
+ }
+
+ return result.release();
+ }
+
+ IXLIB_JS_IF_METHOD("substring",2,2) {
+ TIndex start = parameters[0]->toInt(),end = parameters[1]->toInt();
+ if (start > end) swap(start,end);
+ return makeConstant(string(Value,start,end-start));
+ }
+ IXLIB_JS_IF_METHOD("toLowerCase",0,0) {
+ return makeConstant(lower(Value));
+ }
+ IXLIB_JS_IF_METHOD("toUpperCase",0,0) {
+ return makeConstant(upper(Value));
+ }
+ EXJS_THROWINFO_NO_LOCATION(ECJS_UNKNOWN_IDENTIFIER,("String." + identifier).c_str())
+ }
+
+
+
+
+ref<value> js_string::operatorBinary(operator_id op,ref<value> op2) const {
+ switch (op) {
+ case OP_PLUS: return makeConstant(Value+op2->toString());
+ case OP_EQUAL:
+ if (op2->getType() == VT_STRING) return makeConstant(Value == op2->toString());
+ else return super::operatorBinary(op,op2);
+ case OP_NOT_EQUAL:
+ if (op2->getType() == VT_STRING) return makeConstant(Value != op2->toString());
+ else return super::operatorBinary(op,op2);
+ case OP_LESS_EQUAL:
+ if (op2->getType() == VT_STRING) return makeConstant(Value <= op2->toString());
+ else return super::operatorBinary(op,op2);
+ case OP_GREATER_EQUAL:
+ if (op2->getType() == VT_STRING) return makeConstant(Value >= op2->toString());
+ else return super::operatorBinary(op,op2);
+ case OP_LESS:
+ if (op2->getType() == VT_STRING) return makeConstant(Value < op2->toString());
+ else return super::operatorBinary(op,op2);
+ case OP_GREATER:
+ if (op2->getType() == VT_STRING) return makeConstant(Value > op2->toString());
+ else return super::operatorBinary(op,op2);
+ default:
+ return super::operatorBinary(op,op2);
+ }
+ }
+
+
+
+
+ref<value> js_string::operatorBinaryModifying(operator_id op,ref<value> op2) {
+ switch (op) {
+ case OP_PLUS_ASSIGN:
+ Value += op2->toString();
+ return ref<value>(this);
+ default:
+ return super::operatorBinaryModifying(op,op2);
+ }
+ }
+
+
+
+
+// lvalue ---------------------------------------------------------------------
+lvalue::lvalue(ref<value> ref)
+ : Reference(ref) {
+ }
+
+
+
+
+value::value_type lvalue::getType() const {
+ return Reference->getType();
+ }
+
+
+
+
+string lvalue::toString() const {
+ return Reference->toString();
+ }
+
+
+
+
+int lvalue::toInt() const {
+ return Reference->toInt();
+ }
+
+
+
+
+double lvalue::toFloat() const {
+ return Reference->toFloat();
+ }
+
+
+
+
+bool lvalue::toBoolean() const {
+ return Reference->toBoolean();
+ }
+
+
+
+
+string lvalue::stringify() const {
+ return Reference->stringify();
+ }
+
+
+
+
+ref<value> lvalue::eliminateWrappers() {
+ return Reference.get();
+ }
+
+
+
+
+ref<value> lvalue::duplicate() {
+ return makeLValue(Reference->duplicate());
+ }
+
+
+
+
+ref<value> lvalue::lookup(string const &identifier) {
+ return Reference->lookup(identifier);
+ }
+
+
+
+
+ref<value> lvalue::subscript(value const &index) {
+ return Reference->subscript(index);
+ }
+
+
+
+
+ref<value> lvalue::call(parameter_list const ¶meters) {
+ return Reference->call(parameters);
+ }
+
+
+
+
+ref<value>
+lvalue::callAsMethod(ref<value> instance,parameter_list const ¶meters) {
+ return Reference->callAsMethod(instance,parameters);
+ }
+
+
+
+
+ref<value>
+lvalue::construct(parameter_list const ¶meters) {
+ return Reference->construct(parameters);
+ }
+
+
+
+
+ref<value> lvalue::assign(ref<value> op2) {
+ Reference = op2;
+ return this;
+ }
+
+
+
+
+ref<value> lvalue::operatorUnary(operator_id op) const {
+ return Reference->operatorUnary(op);
+ }
+
+
+
+
+ref<value> lvalue::operatorBinary(operator_id op,ref<value> op2) const {
+ return Reference->operatorBinary(op,op2);
+ }
+
+
+
+
+ref<value> lvalue::operatorBinaryShortcut(operator_id op,expression const &op2,context const &ctx) const {
+ return Reference->operatorBinaryShortcut(op,op2,ctx);
+ }
+
+
+
+
+#define LVALUE_RETURN(VALUE) \
+ ref<value> __result = VALUE; \
+ if (__result.get() == Reference.get()) \
+ return this; \
+ else \
+ return __result;
+
+
+
+
+ref<value> lvalue::operatorUnaryModifying(operator_id op) {
+ LVALUE_RETURN(Reference->operatorUnaryModifying(op))
+ }
+
+
+
+
+ref<value> lvalue::operatorBinaryModifying(operator_id op,ref<value> op2) {
+ LVALUE_RETURN(Reference->operatorBinaryModifying(op,op2))
+ }
+
+
+
+
+// constant_wrapper -----------------------------------------------------------
+constant_wrapper::constant_wrapper(ref<value> val)
+ : Constant(val) {
+ }
+
+
+
+
+value::value_type constant_wrapper::getType() const {
+ return Constant->getType();
+ }
+
+
+
+
+string constant_wrapper::toString() const {
+ return Constant->toString();
+ }
+
+
+
+
+int constant_wrapper::toInt() const {
+ return Constant->toInt();
+ }
+
+
+
+
+double constant_wrapper::toFloat() const {
+ return Constant->toFloat();
+ }
+
+
+
+
+bool constant_wrapper::toBoolean() const {
+ return Constant->toBoolean();
+ }
+
+
+
+
+string constant_wrapper::stringify() const {
+ return Constant->stringify();
+ }
+
+
+
+
+ref<value>
+constant_wrapper::eliminateWrappers() {
+ return Constant.get();
+ }
+
+
+
+
+ref<value>
+constant_wrapper::duplicate() {
+ return wrapConstant(Constant->duplicate());
+ }
+
+
+
+
+ref<value>
+constant_wrapper::lookup(string const &identifier) {
+ return Constant->lookup(identifier);
+ }
+
+
+
+
+ref<value>
+constant_wrapper::subscript(value const &index) {
+ return Constant->subscript(index);
+ }
+
+
+
+
+ref<value>
+constant_wrapper::call(parameter_list const ¶meters) const {
+ return Constant->call(parameters);
+ }
+
+
+
+
+ref<value>
+constant_wrapper::callAsMethod(ref<value> instance,parameter_list const ¶meters) {
+ return Constant->callAsMethod(instance,parameters);
+ }
+
+
+
+
+ref<value>
+constant_wrapper::construct(parameter_list const ¶meters) {
+ return Constant->construct(parameters);
+ }
+
+
+
+
+ref<value>
+constant_wrapper::assign(ref<value> value) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_CANNOT_MODIFY_RVALUE,_("by assignment"))
+ }
+
+
+
+
+ref<value>
+constant_wrapper::operatorUnary(operator_id op) const {
+ return Constant->operatorUnary(op);
+ }
+
+
+
+
+ref<value>
+constant_wrapper::operatorBinary(operator_id op,ref<value> op2) const {
+ return Constant->operatorBinary(op,op2);
+ }
+
+
+
+
+ref<value>
+constant_wrapper::operatorBinaryShortcut(operator_id op,expression const &op2,context const &ctx) const {
+ return Constant->operatorBinaryShortcut(op,op2,ctx);
+ }
+
+
+
+ref<value>
+constant_wrapper::operatorUnaryModifying(operator_id op) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_CANNOT_MODIFY_RVALUE,operator2string(op).c_str())
+ }
+
+
+
+ref<value>
+constant_wrapper::operatorBinaryModifying(operator_id op,ref<value> op2) {
+ EXJS_THROWINFO_NO_LOCATION(ECJS_CANNOT_MODIFY_RVALUE,operator2string(op).c_str())
+ }
+
+
+
+
+// list_scope -----------------------------------------------------------------
+ref<value>
+list_scope::lookup(string const &identifier) {
+ member_map::iterator item = MemberMap.find(identifier);
+ if (item != MemberMap.end())
+ return item->second;
+
+ FOREACH_CONST(first,SwallowedList,swallowed_list) {
+ try {
+ return (*first)->lookup(identifier);
+ }
+ catch (...) { }
+ }
+ EXJS_THROWINFO_NO_LOCATION(ECJS_UNKNOWN_IDENTIFIER,identifier.c_str())
+ }
+
+
+
+
+void list_scope::unite(ref<value> scope) {
+ SwallowedList.push_back(scope);
+ }
+
+
+
+
+void list_scope::separate(ref<value> scope) {
+ FOREACH(first,SwallowedList,swallowed_list) {
+ if (*first == scope) {
+ SwallowedList.erase(first);
+ return;
+ }
+ }
+ EXGEN_THROW(EC_ITEMNOTFOUND)
+ }
+
+
+
+
+void list_scope::clearScopes() {
+ SwallowedList.clear();
+ }
+
+
+
+
+bool list_scope::hasMember(string const &name) const {
+ member_map::const_iterator item = MemberMap.find(name);
+ return item != MemberMap.end();
+ }
+
+
+
+
+void list_scope::addMember(string const &name,ref<value> member) {
+ if (hasMember(name))
+ EXJS_THROWINFO_NO_LOCATION(ECJS_CANNOT_REDECLARE,name.c_str())
+
+ MemberMap[name] = member;
+ }
+
+
+
+
+void list_scope::removeMember(string const &name) {
+ MemberMap.erase(name);
+ }
+
+
+
+
+void list_scope::clearMembers() {
+ MemberMap.clear();
+ }
+
+
+
+
+void list_scope::clear() {
+ clearScopes();
+ clearMembers();
+ }
+
+
+
+
+// callable_with_parameters ---------------------------------------------------
+callable_with_parameters::callable_with_parameters(parameter_name_list const &pnames)
+ : ParameterNameList(pnames) {
+ }
+
+
+
+
+void callable_with_parameters::addParametersTo(list_scope &scope,parameter_list const ¶meters) const {
+ parameter_list::const_iterator
+ firstp = parameters.begin(),
+ lastp = parameters.end();
+
+ FOREACH_CONST(first,ParameterNameList,parameter_name_list) {
+ if (firstp == lastp)
+ scope.addMember(*first,makeLValue(makeNull()));
+ else
+ scope.addMember(*first,makeLValue((*firstp)->eliminateWrappers()->duplicate()));
+
+ firstp++;
+ }
+ }
+
+
+
+
+ref<value> callable_with_parameters::evaluateBody(expression &body,context const &ctx) {
+ ref<value> result;
+
+ try {
+ result = body.evaluate(ctx);
+ }
+ catch (return_exception &fr) {
+ result = fr.ReturnValue;
+ }
+ catch (break_exception &be) {
+ if (be.HasLabel)
+ EXJS_THROWINFOLOCATION(ECJS_INVALID_NON_LOCAL_EXIT,("break "+be.Label).c_str(),be.Location)
+ else
+ EXJS_THROWINFOLOCATION(ECJS_INVALID_NON_LOCAL_EXIT,"break",be.Location)
+ }
+ catch (continue_exception &ce) {
+ if (ce.HasLabel)
+ EXJS_THROWINFOLOCATION(ECJS_INVALID_NON_LOCAL_EXIT,("continue "+ce.Label).c_str(),ce.Location)
+ else
+ EXJS_THROWINFOLOCATION(ECJS_INVALID_NON_LOCAL_EXIT,"continue",ce.Location)
+ }
+ if (result.get()) return result->eliminateWrappers()->duplicate();
+ return ref<value>(NULL);
+ }
+
+
+
+
+// function -------------------------------------------------------------------
+function::function(parameter_name_list const &pnames,ref<expression> body,ref<value> lex_scope)
+ : super(pnames),Body(body),LexicalScope(lex_scope) {
+ }
+
+
+
+
+ref<value> function::duplicate() {
+ // functions are not mutable
+ return this;
+ }
+
+
+
+
+ref<value>
+function::
+call(parameter_list const ¶meters) {
+ ref<list_scope,value> scope = new list_scope;
+ scope->unite(LexicalScope);
+
+ addParametersTo(*scope,parameters);
+ return evaluateBody(*Body,context(scope));
+
+ // ATTENTION: this is a scope cancellation point.
+ }
+
+
+
+
+// method ---------------------------------------------------------------------
+method::method(parameter_name_list const &pnames,ref<expression> body,ref<value> lex_scope)
+ : super(pnames),Body(body),LexicalScope(lex_scope) {
+ }
+
+
+
+
+ref<value> method::duplicate() {
+ // methods are not mutable
+ return this;
+ }
+
+
+
+
+ref<value>
+method::
+callAsMethod(ref<value> instance,parameter_list const ¶meters) {
+ ref<list_scope,value> scope = new list_scope;
+ scope->unite(instance);
+ scope->unite(LexicalScope);
+ scope->addMember("this",instance);
+
+ addParametersTo(*scope,parameters);
+ return evaluateBody(*Body,context(scope));
+
+ // ATTENTION: this is a scope cancellation point.
+ }
+
+
+
+
+// constructor ----------------------------------------------------------------
+constructor::constructor(parameter_name_list const &pnames,ref<expression> body,ref<value> lex_scope)
+ : super(pnames),Body(body),LexicalScope(lex_scope) {
+ }
+
+
+
+
+ref<value> constructor::duplicate() {
+ // constructors are not mutable
+ return this;
+ }
+
+
+
+
+ref<value>
+constructor::
+callAsMethod(ref<value> instance,parameter_list const ¶meters) {
+ ref<list_scope,value> scope = new list_scope;
+ scope->unite(LexicalScope);
+ scope->unite(instance);
+ scope->addMember("this",instance);
+
+ addParametersTo(*scope,parameters);
+ return evaluateBody(*Body,context(scope));
+
+ // ATTENTION: this is a scope cancellation point.
+ }
+
+
+
+
+// js_class -------------------------------------------------------------------
+js_class::super_instance_during_construction::super_instance_during_construction(
+ref<value> super_class)
+ : SuperClass(super_class) {
+ }
+
+
+
+
+ref<value> js_class::super_instance_during_construction::call(parameter_list const ¶meters) {
+ if (SuperClassInstance.get())
+ EXJS_THROW_NO_LOCATION(ECJS_DOUBLE_CONSTRUCTION)
+
+ SuperClassInstance = SuperClass->construct(parameters);
+ return SuperClassInstance;
+ }
+
+
+
+
+ref<value> js_class::super_instance_during_construction::lookup(string const &identifier) {
+ return getSuperClassInstance()->lookup(identifier);
+ }
+
+
+
+
+ref<value> js_class::super_instance_during_construction::getSuperClassInstance() {
+ if (SuperClassInstance.get())
+ return SuperClassInstance;
+
+ SuperClassInstance = SuperClass->construct(parameter_list());
+ return SuperClassInstance;
+ }
+
+
+
+
+js_class::js_class(ref<value> lex_scope,ref<value> super_class,ref<value> constructor,
+ref<value> static_method_scope,ref<value> method_scope,
+ref<value> static_variable_scope,declaration_list const &variable_list)
+ : LexicalScope(lex_scope),SuperClass(super_class),Constructor(constructor),
+ StaticMethodScope(static_method_scope),
+ MethodScope(method_scope),StaticVariableScope(static_variable_scope),
+ VariableList(variable_list) {
+ }
+
+
+
+
+ref<value> js_class::duplicate() {
+ // classes are not mutable
+ return this;
+ }
+
+
+
+
+ref<value> js_class::lookup(string const &identifier) {
+ try {
+ return lookupLocal(identifier);
+ }
+ catch (...) { }
+
+ if (SuperClass.get())
+ return SuperClass->lookup(identifier);
+
+ EXJS_THROWINFO_NO_LOCATION(ECJS_UNKNOWN_IDENTIFIER,identifier.c_str())
+ }
+
+
+
+
+ref<value> js_class::lookupLocal(string const &identifier) {
+ try {
+ return StaticMethodScope->lookup(identifier);
+ }
+ catch (...) { }
+
+ return StaticVariableScope->lookup(identifier);
+ }
+
+
+
+
+ref<value> js_class::construct(parameter_list const ¶meters) {
+ ref<list_scope,value> vl(new list_scope);
+
+ ref<js_class_instance,value> instance(
+ new js_class_instance(this,MethodScope,vl));
+
+ ref<list_scope,value> construction_scope(new list_scope);
+ construction_scope->unite(LexicalScope);
+ construction_scope->unite(instance);
+
+ FOREACH_CONST(first,VariableList,declaration_list)
+ (*first)->evaluate(context(vl,construction_scope));
+
+ ref<super_instance_during_construction,value> temp_super;
+ if (SuperClass.get()) {
+ temp_super = new super_instance_during_construction(SuperClass);
+ vl->addMember("super",temp_super);
+ }
+
+ if (Constructor.get())
+ Constructor->callAsMethod(instance,parameters);
+
+ if (temp_super.get()) {
+ ref<value> super = temp_super->getSuperClassInstance();
+ vl->removeMember("super");
+ instance->setSuperClassInstance(super);
+ vl->addMember("super",super);
+ }
+ return instance;
+ }
+
+
+
+
+// js_class_instance ----------------------------------------------------------
+js_class_instance::bound_method::bound_method(ref<value> instance,ref<value> method)
+ : Instance(instance),Method(method) {
+ }
+
+
+
+
+ref<value> js_class_instance::bound_method::call(parameter_list const ¶meters) {
+ return Method->callAsMethod(Instance,parameters);
+ }
+
+
+
+
+js_class_instance::js_class_instance(ref<js_class,value> cls,
+ref<value> method_scope,ref<value> variable_scope)
+ : Class(cls),MethodScope(method_scope),VariableScope(variable_scope) {
+ }
+
+
+
+
+void js_class_instance::setSuperClassInstance(ref<value> super_class_instance) {
+ SuperClassInstance = super_class_instance;
+ }
+
+
+
+
+ref<value> js_class_instance::duplicate() {
+ return this;
+ }
+
+
+
+
+ref<value> js_class_instance::lookup(string const &identifier) {
+ try {
+ ref<value> method = MethodScope->lookup(identifier);
+ ref<value> bound = new bound_method(this,method);
+ return bound;
+ }
+ catch (...) { }
+
+ try {
+ return VariableScope->lookup(identifier);
+ }
+ catch (...) { }
+
+ try {
+ return Class->lookupLocal(identifier);
+ }
+ catch (...) { }
+
+ if (SuperClassInstance.get())
+ return SuperClassInstance->lookup(identifier);
+
+ EXJS_THROWINFO_NO_LOCATION(ECJS_UNKNOWN_IDENTIFIER,identifier.c_str())
+ }
+
+
+
+
+// value creation -------------------------------------------------------------
+ref<value>
+javascript::makeUndefined() {
+ // *** FIXME: this is non-compliant
+ ref<value> result(new null());
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeNull() {
+ ref<value> result(new null());
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeValue(signed int val) {
+ ref<value> result(new integer(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeConstant(signed int val) {
+ ref<value> result(new const_integer(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeValue(unsigned int val) {
+ ref<value> result(new integer(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeConstant(unsigned int val) {
+ ref<value> result(new const_integer(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeValue(signed long val) {
+ ref<value> result(new integer(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeConstant(signed long val) {
+ ref<value> result(new const_integer(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeValue(unsigned long val) {
+ ref<value> result(new integer(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeConstant(unsigned long val) {
+ ref<value> result(new const_integer(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeValue(double val) {
+ ref<value> result(new floating_point(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeConstant(double val) {
+ ref<value> result(new const_floating_point(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeValue(string const &val) {
+ ref<value> result(new js_string(val));
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::makeConstant(string const &val) {
+ return wrapConstant(makeValue(val));
+ }
+
+
+
+
+ref<value> javascript::makeArray(TSize size) {
+ auto_ptr<js_array> result(new js_array(size));
+ return result.release();
+ }
+
+
+
+
+ref<value>
+javascript::makeLValue(ref<value> target) {
+ ref<value> result = new lvalue(target);
+ return result;
+ }
+
+
+
+
+ref<value>
+javascript::wrapConstant(ref<value> val) {
+ ref<value> result(new constant_wrapper(val));
+ return result;
+ }
--- /dev/null
+#define yyFlexLexer jsFlexLexer
+
+#line 4 "lex.javascript.cc"
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header$
+ */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#include <fstream>
+using std::istream;
+using std::ostream;
+#include <unistd.h>
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else /* ! __cplusplus */
+
+#if __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+#endif /* __STDC__ */
+#endif /* ! __cplusplus */
+
+#ifdef __TURBOC__
+ #pragma warn -rch
+ #pragma warn -use
+#include <io.h>
+#include <stdlib.h>
+#define YY_USE_CONST
+#define YY_USE_PROTOS
+#endif
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index. If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition. This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state. The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator). This
+ * avoids problems with code like:
+ *
+ * if ( condition_holds )
+ * yyless( 5 );
+ * else
+ * do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+ do \
+ { \
+ /* Undo effects of setting up yytext. */ \
+ *yy_cp = yy_hold_char; \
+ YY_RESTORE_YY_MORE_OFFSET \
+ yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+ YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+ } \
+ while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+/* The following is because we cannot portably get our hands on size_t
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
+typedef unsigned int yy_size_t;
+
+
+struct yy_buffer_state
+ {
+ istream* yy_input_file;
+
+ char *yy_ch_buf; /* input buffer */
+ char *yy_buf_pos; /* current position in input buffer */
+
+ /* Size of input buffer in bytes, not including room for EOB
+ * characters.
+ */
+ yy_size_t yy_buf_size;
+
+ /* Number of characters read into yy_ch_buf, not including EOB
+ * characters.
+ */
+ int yy_n_chars;
+
+ /* Whether we "own" the buffer - i.e., we know we created it,
+ * and can realloc() it to grow it, and should free() it to
+ * delete it.
+ */
+ int yy_is_our_buffer;
+
+ /* Whether this is an "interactive" input source; if so, and
+ * if we're using stdio for input, then we want to use getc()
+ * instead of fread(), to make sure we stop fetching input after
+ * each newline.
+ */
+ int yy_is_interactive;
+
+ /* Whether we're considered to be at the beginning of a line.
+ * If so, '^' rules will be active on the next match, otherwise
+ * not.
+ */
+ int yy_at_bol;
+
+ /* Whether to try to fill the input buffer when we reach the
+ * end of it.
+ */
+ int yy_fill_buffer;
+
+ int yy_buffer_status;
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+ /* When an EOF's been seen but there's still some text to process
+ * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+ * shouldn't try reading from the input source any more. We might
+ * still have a bunch of tokens to match, though, because of
+ * possible backing-up.
+ *
+ * When we actually see the EOF, we change the status to "new"
+ * (via yyrestart()), so that the user can continue scanning by
+ * just pointing yyin at a new input file.
+ */
+#define YY_BUFFER_EOF_PENDING 2
+ };
+
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+
+static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+#define yy_set_interactive(is_interactive) \
+ { \
+ if ( ! yy_current_buffer ) \
+ yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+ yy_current_buffer->yy_is_interactive = is_interactive; \
+ }
+
+#define yy_set_bol(at_bol) \
+ { \
+ if ( ! yy_current_buffer ) \
+ yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+ yy_current_buffer->yy_at_bol = at_bol; \
+ }
+
+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+
+
+#define YY_USES_REJECT
+
+#define yywrap() 1
+#define YY_SKIP_YYWRAP
+typedef unsigned char YY_CHAR;
+#define yytext_ptr yytext
+
+#include <FlexLexer.h>
+
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+ yytext_ptr = yy_bp; \
+ yyleng = (int) (yy_cp - yy_bp); \
+ yy_hold_char = *yy_cp; \
+ *yy_cp = '\0'; \
+ yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 86
+#define YY_END_OF_BUFFER 87
+static yyconst short int yy_acclist[314] =
+ { 0,
+ 87, 85, 86, 84, 85, 86, 84, 86, 26, 85,
+ 86, 85, 86, 21, 85, 86, 23, 85, 86, 85,
+ 86, 13, 85, 86, 14, 85, 86, 19, 85, 86,
+ 17, 85, 86, 30, 85, 86, 18, 85, 86, 31,
+ 85, 86, 20, 85, 86, 80, 85, 86, 80, 85,
+ 86, 16, 85, 86, 10, 85, 86, 28, 85, 86,
+ 27, 85, 86, 29, 85, 86, 15, 85, 86, 83,
+ 85, 86, 11, 85, 86, 12, 85, 86, 22, 85,
+ 86, 83, 85, 86, 83, 85, 86, 83, 85, 86,
+ 83, 85, 86, 83, 85, 86, 83, 85, 86, 83,
+
+ 85, 86, 83, 85, 86, 83, 85, 86, 83, 85,
+ 86, 83, 85, 86, 83, 85, 86, 83, 85, 86,
+ 8, 85, 86, 24, 85, 86, 9, 85, 86, 25,
+ 85, 86, 3, 86, 4, 86, 3, 86, 7, 86,
+ 6, 86, 6, 7, 86, 84, 47, 82, 36, 50,
+ 38, 82, 34, 52, 32, 53, 33, 81, 1, 5,
+ 35, 81, 80, 80, 40, 48, 46, 49, 41, 83,
+ 37, 83, 83, 83, 83, 83, 61, 83, 83, 83,
+ 83, 83, 83, 59, 83, 73, 83, 83, 83, 83,
+ 83, 83, 83, 83, 83, 83, 83, 83, 39, 51,
+
+ 2, 6, 45, 81, 80, 42, 44, 43, 83, 83,
+ 83, 83, 83, 83, 83, 83, 63, 83, 83, 83,
+ 54, 83, 83, 83, 83, 83, 83, 83, 83, 57,
+ 83, 83, 81, 83, 66, 83, 83, 83, 83, 83,
+ 62, 83, 83, 83, 83, 83, 58, 83, 83, 83,
+ 83, 55, 83, 70, 83, 83, 83, 68, 83, 75,
+ 83, 74, 83, 83, 83, 83, 71, 83, 83, 83,
+ 83, 83, 83, 83, 60, 83, 83, 83, 83, 83,
+ 83, 83, 64, 83, 78, 83, 65, 83, 83, 83,
+ 83, 69, 83, 76, 83, 83, 83, 83, 83, 67,
+
+ 83, 56, 83, 83, 83, 83, 77, 83, 72, 83,
+ 83, 79, 83
+ } ;
+
+static yyconst short int yy_accept[225] =
+ { 0,
+ 1, 1, 1, 1, 1, 1, 1, 2, 4, 7,
+ 9, 12, 14, 17, 20, 22, 25, 28, 31, 34,
+ 37, 40, 43, 46, 49, 52, 55, 58, 61, 64,
+ 67, 70, 73, 76, 79, 82, 85, 88, 91, 94,
+ 97, 100, 103, 106, 109, 112, 115, 118, 121, 124,
+ 127, 130, 133, 135, 137, 139, 141, 143, 146, 147,
+ 148, 148, 149, 149, 150, 151, 152, 152, 153, 153,
+ 154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
+ 164, 164, 164, 164, 165, 166, 167, 168, 169, 170,
+ 171, 172, 173, 174, 175, 176, 177, 179, 180, 181,
+
+ 182, 183, 184, 186, 188, 189, 190, 191, 192, 193,
+ 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
+ 204, 204, 204, 204, 204, 204, 204, 205, 206, 207,
+ 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
+ 219, 220, 221, 223, 224, 225, 226, 227, 228, 229,
+ 230, 232, 233, 233, 233, 233, 233, 233, 234, 235,
+ 237, 238, 239, 240, 241, 243, 244, 245, 246, 247,
+ 249, 250, 251, 252, 254, 256, 257, 258, 258, 258,
+ 258, 258, 260, 262, 264, 265, 266, 267, 269, 270,
+ 271, 272, 273, 274, 275, 277, 278, 279, 280, 281,
+
+ 282, 283, 285, 287, 289, 290, 291, 292, 294, 296,
+ 297, 298, 299, 300, 302, 304, 305, 306, 307, 309,
+ 311, 312, 314, 314
+ } ;
+
+static yyconst int yy_ec[256] =
+ { 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
+ 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 2, 5, 6, 1, 1, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 19,
+ 19, 19, 19, 19, 19, 20, 20, 21, 22, 23,
+ 24, 25, 26, 1, 27, 27, 27, 27, 28, 27,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 30, 29, 29,
+ 31, 32, 33, 34, 29, 1, 35, 36, 37, 38,
+
+ 39, 40, 29, 41, 42, 29, 43, 44, 45, 46,
+ 47, 48, 29, 49, 50, 51, 52, 53, 54, 55,
+ 29, 29, 56, 57, 58, 59, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1
+ } ;
+
+static yyconst int yy_meta[60] =
+ { 0,
+ 1, 1, 2, 1, 1, 3, 1, 1, 4, 1,
+ 1, 1, 1, 1, 1, 1, 1, 5, 5, 6,
+ 1, 1, 1, 1, 1, 4, 6, 6, 7, 7,
+ 1, 4, 1, 1, 5, 5, 6, 6, 6, 5,
+ 7, 7, 7, 7, 7, 8, 7, 7, 8, 7,
+ 8, 7, 8, 7, 8, 1, 1, 1, 1
+ } ;
+
+static yyconst short int yy_base[234] =
+ { 0,
+ 0, 0, 57, 58, 59, 61, 393, 394, 64, 69,
+ 368, 68, 367, 67, 67, 394, 394, 366, 64, 394,
+ 63, 61, 72, 74, 87, 394, 394, 59, 365, 61,
+ 394, 0, 394, 394, 364, 338, 73, 62, 66, 76,
+ 72, 92, 347, 44, 73, 339, 349, 342, 394, 73,
+ 394, 394, 394, 394, 365, 394, 121, 129, 132, 357,
+ 110, 394, 119, 394, 394, 394, 130, 131, 127, 394,
+ 394, 394, 394, 394, 129, 394, 394, 394, 132, 157,
+ 170, 146, 0, 175, 356, 394, 355, 394, 354, 0,
+ 394, 338, 326, 340, 328, 333, 0, 322, 320, 326,
+
+ 320, 322, 0, 0, 322, 312, 321, 313, 328, 320,
+ 319, 308, 321, 309, 315, 394, 394, 394, 150, 394,
+ 137, 0, 183, 0, 192, 160, 198, 0, 394, 394,
+ 394, 321, 316, 304, 133, 318, 313, 312, 300, 0,
+ 312, 309, 0, 303, 294, 294, 293, 293, 303, 302,
+ 0, 296, 181, 213, 211, 245, 203, 206, 289, 0,
+ 281, 275, 283, 260, 0, 265, 264, 228, 228, 0,
+ 227, 233, 237, 0, 0, 231, 231, 135, 202, 149,
+ 195, 0, 0, 220, 222, 223, 228, 0, 220, 213,
+ 214, 222, 217, 215, 0, 204, 203, 196, 196, 197,
+
+ 207, 0, 0, 0, 193, 201, 198, 0, 0, 190,
+ 198, 189, 155, 0, 0, 158, 134, 123, 0, 0,
+ 70, 0, 394, 285, 293, 301, 309, 313, 319, 325,
+ 329, 331, 333
+ } ;
+
+static yyconst short int yy_def[234] =
+ { 0,
+ 223, 1, 224, 224, 225, 225, 223, 223, 223, 223,
+ 223, 226, 223, 223, 227, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 228, 223, 223, 223, 228, 228, 228, 228, 228,
+ 228, 228, 228, 228, 228, 228, 228, 228, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 226, 223, 229, 223, 223, 223, 227, 227, 230, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 231, 223, 223, 223, 223, 223, 223, 228,
+ 223, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+
+ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+ 228, 228, 228, 228, 228, 223, 223, 223, 223, 223,
+ 226, 232, 227, 233, 223, 223, 223, 231, 223, 223,
+ 223, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+ 228, 228, 226, 226, 227, 227, 223, 223, 228, 228,
+ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+ 228, 228, 228, 228, 228, 228, 228, 226, 226, 227,
+ 227, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+
+ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
+ 228, 228, 0, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223
+ } ;
+
+static yyconst short int yy_nxt[454] =
+ { 0,
+ 8, 9, 10, 9, 11, 12, 13, 14, 15, 16,
+ 17, 18, 19, 20, 21, 22, 23, 24, 25, 25,
+ 26, 27, 28, 29, 30, 31, 32, 32, 32, 32,
+ 33, 8, 34, 35, 32, 36, 37, 38, 39, 40,
+ 32, 41, 32, 32, 32, 42, 32, 32, 43, 44,
+ 45, 46, 47, 48, 32, 49, 50, 51, 52, 54,
+ 54, 57, 58, 57, 58, 59, 59, 59, 55, 55,
+ 59, 59, 59, 62, 65, 68, 71, 73, 75, 75,
+ 75, 85, 86, 76, 88, 89, 74, 72, 77, 79,
+ 66, 80, 80, 81, 109, 78, 116, 110, 69, 63,
+
+ 96, 82, 79, 83, 84, 84, 84, 93, 97, 98,
+ 100, 103, 82, 111, 82, 62, 94, 104, 222, 95,
+ 99, 112, 101, 119, 119, 82, 105, 102, 83, 117,
+ 106, 119, 119, 59, 59, 59, 121, 121, 68, 68,
+ 62, 63, 62, 107, 123, 123, 75, 75, 75, 75,
+ 75, 75, 119, 119, 153, 153, 125, 68, 126, 125,
+ 126, 69, 69, 127, 127, 127, 63, 125, 63, 221,
+ 125, 220, 79, 122, 80, 80, 81, 127, 127, 127,
+ 69, 124, 162, 163, 82, 79, 62, 81, 81, 81,
+ 79, 68, 84, 84, 84, 82, 219, 82, 178, 178,
+
+ 155, 155, 82, 68, 157, 218, 157, 62, 82, 158,
+ 158, 158, 63, 82, 69, 127, 127, 127, 62, 68,
+ 158, 158, 158, 158, 158, 158, 69, 217, 180, 180,
+ 179, 179, 179, 63, 216, 215, 214, 213, 212, 179,
+ 179, 211, 69, 210, 63, 209, 208, 179, 179, 179,
+ 179, 179, 179, 68, 207, 206, 205, 204, 203, 202,
+ 201, 200, 181, 181, 181, 199, 198, 197, 196, 195,
+ 194, 181, 181, 193, 192, 191, 69, 190, 189, 181,
+ 181, 181, 181, 181, 181, 53, 53, 53, 53, 53,
+ 53, 53, 53, 56, 56, 56, 56, 56, 56, 56,
+
+ 56, 61, 188, 61, 61, 61, 61, 61, 61, 67,
+ 187, 186, 67, 67, 67, 67, 67, 90, 90, 90,
+ 90, 61, 61, 61, 185, 184, 61, 67, 67, 67,
+ 183, 182, 67, 128, 128, 154, 154, 156, 156, 177,
+ 176, 175, 174, 173, 172, 171, 170, 169, 168, 167,
+ 166, 165, 164, 161, 160, 159, 152, 151, 150, 149,
+ 148, 147, 146, 145, 144, 143, 142, 141, 140, 139,
+ 138, 137, 136, 135, 134, 133, 132, 131, 130, 129,
+ 120, 118, 115, 114, 113, 108, 92, 91, 87, 70,
+ 64, 60, 223, 7, 223, 223, 223, 223, 223, 223,
+
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223
+ } ;
+
+static yyconst short int yy_chk[454] =
+ { 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
+ 4, 5, 5, 6, 6, 9, 9, 9, 3, 4,
+ 10, 10, 10, 12, 14, 15, 19, 21, 22, 22,
+ 22, 28, 28, 23, 30, 30, 21, 19, 23, 24,
+ 14, 24, 24, 24, 44, 23, 50, 44, 15, 12,
+
+ 38, 24, 25, 24, 25, 25, 25, 37, 38, 39,
+ 40, 41, 24, 45, 25, 61, 37, 41, 221, 37,
+ 39, 45, 40, 57, 57, 25, 42, 40, 24, 50,
+ 42, 58, 58, 59, 59, 59, 63, 63, 67, 68,
+ 178, 61, 121, 42, 69, 69, 75, 75, 75, 79,
+ 79, 79, 119, 119, 121, 121, 75, 180, 82, 79,
+ 82, 67, 68, 82, 82, 82, 178, 75, 121, 218,
+ 79, 217, 80, 63, 80, 80, 80, 126, 126, 126,
+ 180, 69, 135, 135, 80, 81, 153, 81, 81, 81,
+ 84, 123, 84, 84, 84, 80, 216, 81, 153, 153,
+
+ 123, 123, 84, 181, 125, 213, 125, 179, 81, 125,
+ 125, 125, 153, 84, 123, 127, 127, 127, 154, 155,
+ 157, 157, 157, 158, 158, 158, 181, 212, 155, 155,
+ 154, 154, 154, 179, 211, 210, 207, 206, 205, 154,
+ 154, 201, 155, 200, 154, 199, 198, 154, 154, 154,
+ 154, 154, 154, 156, 197, 196, 194, 193, 192, 191,
+ 190, 189, 156, 156, 156, 187, 186, 185, 184, 177,
+ 176, 156, 156, 173, 172, 171, 156, 169, 168, 156,
+ 156, 156, 156, 156, 156, 224, 224, 224, 224, 224,
+ 224, 224, 224, 225, 225, 225, 225, 225, 225, 225,
+
+ 225, 226, 167, 226, 226, 226, 226, 226, 226, 227,
+ 166, 164, 227, 227, 227, 227, 227, 228, 228, 228,
+ 228, 229, 229, 229, 163, 162, 229, 230, 230, 230,
+ 161, 159, 230, 231, 231, 232, 232, 233, 233, 152,
+ 150, 149, 148, 147, 146, 145, 144, 142, 141, 139,
+ 138, 137, 136, 134, 133, 132, 115, 114, 113, 112,
+ 111, 110, 109, 108, 107, 106, 105, 102, 101, 100,
+ 99, 98, 96, 95, 94, 93, 92, 89, 87, 85,
+ 60, 55, 48, 47, 46, 43, 36, 35, 29, 18,
+ 13, 11, 7, 223, 223, 223, 223, 223, 223, 223,
+
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223
+ } ;
+
+#define REJECT \
+{ \
+*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
+yy_cp = yy_full_match; /* restore poss. backed-over text */ \
+++yy_lp; \
+goto find_rule; \
+}
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+#line 1 "lex.javascript.yy"
+#define INITIAL 0
+/* -------- definitions ------- */
+#line 6 "lex.javascript.yy"
+#include <ixlib_js_internals.hh>
+#include <ixlib_token_javascript.hh>
+
+using namespace ixion;
+using namespace javascript;
+/* higher-level entities ------------------------------------------------------
+*/
+/* literals -------------------------------------------------------------------
+*/
+/* Contexts -------------------------------------------------------------------
+*/
+#define Comment 1
+
+#define LineComment 2
+
+/* Rules ----------------------------------------------------------------------
+*/
+#line 569 "lex.javascript.cc"
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap YY_PROTO(( void ));
+#else
+extern int yywrap YY_PROTO(( void ));
+#endif
+#endif
+
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+#endif
+
+#ifndef YY_NO_INPUT
+#endif
+
+#if YY_STACK_USED
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+#ifndef YY_NO_PUSH_STATE
+static void yy_push_state YY_PROTO(( int new_state ));
+#endif
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state YY_PROTO(( void ));
+#endif
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state YY_PROTO(( void ));
+#endif
+
+#else
+#define YY_NO_PUSH_STATE 1
+#define YY_NO_POP_STATE 1
+#define YY_NO_TOP_STATE 1
+#endif
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines. This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+#define ECHO LexerOutput( yytext, yyleng )
+#endif
+
+/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+ if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
+ YY_FATAL_ERROR( "input in flex scanner failed" );
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) LexerError( msg )
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL int yyFlexLexer::yylex()
+#endif
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+#define YY_RULE_SETUP \
+ YY_USER_ACTION
+
+YY_DECL
+ {
+ register yy_state_type yy_current_state;
+ register char *yy_cp, *yy_bp;
+ register int yy_act;
+
+#line 72 "lex.javascript.yy"
+
+
+#line 699 "lex.javascript.cc"
+
+ if ( yy_init )
+ {
+ yy_init = 0;
+
+#ifdef YY_USER_INIT
+ YY_USER_INIT;
+#endif
+
+ if ( ! yy_start )
+ yy_start = 1; /* first start state */
+
+ if ( ! yyin )
+ yyin = &cin;
+
+ if ( ! yyout )
+ yyout = &cout;
+
+ if ( ! yy_current_buffer )
+ yy_current_buffer =
+ yy_create_buffer( yyin, YY_BUF_SIZE );
+
+ yy_load_buffer_state();
+ }
+
+ while ( 1 ) /* loops until end-of-file is reached */
+ {
+ yy_cp = yy_c_buf_p;
+
+ /* Support of yytext. */
+ *yy_cp = yy_hold_char;
+
+ /* yy_bp points to the position in yy_ch_buf of the start of
+ * the current run.
+ */
+ yy_bp = yy_cp;
+
+ yy_current_state = yy_start;
+ yy_state_ptr = yy_state_buf;
+ *yy_state_ptr++ = yy_current_state;
+yy_match:
+ do
+ {
+ register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 224 )
+ yy_c = yy_meta[(unsigned int) yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+ *yy_state_ptr++ = yy_current_state;
+ ++yy_cp;
+ }
+ while ( yy_current_state != 223 );
+
+yy_find_action:
+ yy_current_state = *--yy_state_ptr;
+ yy_lp = yy_accept[yy_current_state];
+find_rule: /* we branch to this label when backing up */
+ for ( ; ; ) /* until we find what rule we matched */
+ {
+ if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
+ {
+ yy_act = yy_acclist[yy_lp];
+ {
+ yy_full_match = yy_cp;
+ break;
+ }
+ }
+ --yy_cp;
+ yy_current_state = *--yy_state_ptr;
+ yy_lp = yy_accept[yy_current_state];
+ }
+
+ YY_DO_BEFORE_ACTION;
+
+ if ( yy_act != YY_END_OF_BUFFER )
+ {
+ int yyl;
+ for ( yyl = 0; yyl < yyleng; ++yyl )
+ if ( yytext[yyl] == '\n' )
+ ++yylineno;
+ }
+
+do_action: /* This label is used only to access EOF actions. */
+
+
+ switch ( yy_act )
+ { /* beginning of action switch */
+case 1:
+YY_RULE_SETUP
+#line 74 "lex.javascript.yy"
+BEGIN(Comment);
+ YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 75 "lex.javascript.yy"
+BEGIN(INITIAL);
+ YY_BREAK
+case YY_STATE_EOF(Comment):
+#line 76 "lex.javascript.yy"
+EXJS_THROW(ECJS_UNTERMINATED_COMMENT)
+ YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 77 "lex.javascript.yy"
+/* nothing */
+ YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 78 "lex.javascript.yy"
+/* nothing */
+ YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 79 "lex.javascript.yy"
+BEGIN(LineComment);
+ YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 80 "lex.javascript.yy"
+BEGIN(INITIAL);
+ YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 81 "lex.javascript.yy"
+/* nothing */
+ YY_BREAK
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(LineComment):
+#line 83 "lex.javascript.yy"
+return TT_EOF;
+ YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 85 "lex.javascript.yy"
+return '{';
+ YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 86 "lex.javascript.yy"
+return '}';
+ YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 87 "lex.javascript.yy"
+return ';';
+ YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 89 "lex.javascript.yy"
+return '[';
+ YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 90 "lex.javascript.yy"
+return ']';
+ YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 91 "lex.javascript.yy"
+return '(';
+ YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 92 "lex.javascript.yy"
+return ')';
+ YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 93 "lex.javascript.yy"
+return '?';
+ YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 94 "lex.javascript.yy"
+return ':';
+ YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 95 "lex.javascript.yy"
+return '+';
+ YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 96 "lex.javascript.yy"
+return '-';
+ YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 97 "lex.javascript.yy"
+return '*';
+ YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 98 "lex.javascript.yy"
+return '/';
+ YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 99 "lex.javascript.yy"
+return '%';
+ YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 100 "lex.javascript.yy"
+return '^';
+ YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 101 "lex.javascript.yy"
+return '&';
+ YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 102 "lex.javascript.yy"
+return '|';
+ YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 103 "lex.javascript.yy"
+return '~';
+ YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 104 "lex.javascript.yy"
+return '!';
+ YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 105 "lex.javascript.yy"
+return '=';
+ YY_BREAK
+case 28:
+YY_RULE_SETUP
+#line 106 "lex.javascript.yy"
+return '<';
+ YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 107 "lex.javascript.yy"
+return '>';
+ YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 108 "lex.javascript.yy"
+return ',';
+ YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 109 "lex.javascript.yy"
+return '.';
+ YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 110 "lex.javascript.yy"
+return TT_JS_PLUS_ASSIGN;
+ YY_BREAK
+case 33:
+YY_RULE_SETUP
+#line 111 "lex.javascript.yy"
+return TT_JS_MINUS_ASSIGN;
+ YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 112 "lex.javascript.yy"
+return TT_JS_MULTIPLY_ASSIGN;
+ YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 113 "lex.javascript.yy"
+return TT_JS_DIVIDE_ASSIGN;
+ YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 114 "lex.javascript.yy"
+return TT_JS_MODULO_ASSIGN;
+ YY_BREAK
+case 37:
+YY_RULE_SETUP
+#line 115 "lex.javascript.yy"
+return TT_JS_BIT_XOR_ASSIGN;
+ YY_BREAK
+case 38:
+YY_RULE_SETUP
+#line 116 "lex.javascript.yy"
+return TT_JS_BIT_AND_ASSIGN;
+ YY_BREAK
+case 39:
+YY_RULE_SETUP
+#line 117 "lex.javascript.yy"
+return TT_JS_BIT_OR_ASSIGN;
+ YY_BREAK
+case 40:
+YY_RULE_SETUP
+#line 118 "lex.javascript.yy"
+return TT_JS_LEFT_SHIFT;
+ YY_BREAK
+case 41:
+YY_RULE_SETUP
+#line 119 "lex.javascript.yy"
+return TT_JS_RIGHT_SHIFT;
+ YY_BREAK
+case 42:
+YY_RULE_SETUP
+#line 120 "lex.javascript.yy"
+return TT_JS_LEFT_SHIFT_ASSIGN;
+ YY_BREAK
+case 43:
+YY_RULE_SETUP
+#line 121 "lex.javascript.yy"
+return TT_JS_RIGHT_SHIFT_ASSIGN;
+ YY_BREAK
+case 44:
+YY_RULE_SETUP
+#line 122 "lex.javascript.yy"
+return TT_JS_IDENTICAL;
+ YY_BREAK
+case 45:
+YY_RULE_SETUP
+#line 123 "lex.javascript.yy"
+return TT_JS_NOT_IDENTICAL;
+ YY_BREAK
+case 46:
+YY_RULE_SETUP
+#line 124 "lex.javascript.yy"
+return TT_JS_EQUAL;
+ YY_BREAK
+case 47:
+YY_RULE_SETUP
+#line 125 "lex.javascript.yy"
+return TT_JS_NOT_EQUAL;
+ YY_BREAK
+case 48:
+YY_RULE_SETUP
+#line 126 "lex.javascript.yy"
+return TT_JS_LESS_EQUAL;
+ YY_BREAK
+case 49:
+YY_RULE_SETUP
+#line 127 "lex.javascript.yy"
+return TT_JS_GREATER_EQUAL;
+ YY_BREAK
+case 50:
+YY_RULE_SETUP
+#line 128 "lex.javascript.yy"
+return TT_JS_LOGICAL_AND;
+ YY_BREAK
+case 51:
+YY_RULE_SETUP
+#line 129 "lex.javascript.yy"
+return TT_JS_LOGICAL_OR;
+ YY_BREAK
+case 52:
+YY_RULE_SETUP
+#line 130 "lex.javascript.yy"
+return TT_JS_INCREMENT;
+ YY_BREAK
+case 53:
+YY_RULE_SETUP
+#line 131 "lex.javascript.yy"
+return TT_JS_DECREMENT;
+ YY_BREAK
+case 54:
+YY_RULE_SETUP
+#line 133 "lex.javascript.yy"
+return TT_JS_NEW;
+ YY_BREAK
+case 55:
+YY_RULE_SETUP
+#line 135 "lex.javascript.yy"
+return TT_JS_THIS;
+ YY_BREAK
+case 56:
+YY_RULE_SETUP
+#line 136 "lex.javascript.yy"
+return TT_JS_FUNCTION;
+ YY_BREAK
+case 57:
+YY_RULE_SETUP
+#line 137 "lex.javascript.yy"
+return TT_JS_VAR;
+ YY_BREAK
+case 58:
+YY_RULE_SETUP
+#line 138 "lex.javascript.yy"
+return TT_JS_NULL;
+ YY_BREAK
+case 59:
+YY_RULE_SETUP
+#line 139 "lex.javascript.yy"
+return TT_JS_IF;
+ YY_BREAK
+case 60:
+YY_RULE_SETUP
+#line 140 "lex.javascript.yy"
+return TT_JS_WHILE;
+ YY_BREAK
+case 61:
+YY_RULE_SETUP
+#line 141 "lex.javascript.yy"
+return TT_JS_DO;
+ YY_BREAK
+case 62:
+YY_RULE_SETUP
+#line 142 "lex.javascript.yy"
+return TT_JS_ELSE;
+ YY_BREAK
+case 63:
+YY_RULE_SETUP
+#line 143 "lex.javascript.yy"
+return TT_JS_FOR;
+ YY_BREAK
+case 64:
+YY_RULE_SETUP
+#line 144 "lex.javascript.yy"
+return TT_JS_RETURN;
+ YY_BREAK
+case 65:
+YY_RULE_SETUP
+#line 145 "lex.javascript.yy"
+return TT_JS_SWITCH;
+ YY_BREAK
+case 66:
+YY_RULE_SETUP
+#line 146 "lex.javascript.yy"
+return TT_JS_CASE;
+ YY_BREAK
+case 67:
+YY_RULE_SETUP
+#line 147 "lex.javascript.yy"
+return TT_JS_CONTINUE;
+ YY_BREAK
+case 68:
+YY_RULE_SETUP
+#line 148 "lex.javascript.yy"
+return TT_JS_BREAK;
+ YY_BREAK
+case 69:
+YY_RULE_SETUP
+#line 149 "lex.javascript.yy"
+return TT_JS_DEFAULT;
+ YY_BREAK
+case 70:
+YY_RULE_SETUP
+#line 150 "lex.javascript.yy"
+return TT_JS_LIT_TRUE;
+ YY_BREAK
+case 71:
+YY_RULE_SETUP
+#line 151 "lex.javascript.yy"
+return TT_JS_LIT_FALSE;
+ YY_BREAK
+case 72:
+YY_RULE_SETUP
+#line 152 "lex.javascript.yy"
+return TT_JS_LIT_UNDEFINED;
+ YY_BREAK
+case 73:
+YY_RULE_SETUP
+#line 153 "lex.javascript.yy"
+return TT_JS_IN;
+ YY_BREAK
+case 74:
+YY_RULE_SETUP
+#line 154 "lex.javascript.yy"
+return TT_JS_CONST;
+ YY_BREAK
+case 75:
+YY_RULE_SETUP
+#line 155 "lex.javascript.yy"
+return TT_JS_CLASS;
+ YY_BREAK
+case 76:
+YY_RULE_SETUP
+#line 156 "lex.javascript.yy"
+return TT_JS_EXTENDS;
+ YY_BREAK
+case 77:
+YY_RULE_SETUP
+#line 157 "lex.javascript.yy"
+return TT_JS_NAMESPACE;
+ YY_BREAK
+case 78:
+YY_RULE_SETUP
+#line 158 "lex.javascript.yy"
+return TT_JS_STATIC;
+ YY_BREAK
+case 79:
+YY_RULE_SETUP
+#line 159 "lex.javascript.yy"
+return TT_JS_CONSTRUCTOR;
+ YY_BREAK
+case 80:
+YY_RULE_SETUP
+#line 161 "lex.javascript.yy"
+return TT_JS_LIT_INT;
+ YY_BREAK
+case 81:
+YY_RULE_SETUP
+#line 162 "lex.javascript.yy"
+return TT_JS_LIT_FLOAT;
+ YY_BREAK
+case 82:
+YY_RULE_SETUP
+#line 163 "lex.javascript.yy"
+return TT_JS_LIT_STRING;
+ YY_BREAK
+case 83:
+YY_RULE_SETUP
+#line 165 "lex.javascript.yy"
+return TT_JS_IDENTIFIER;
+ YY_BREAK
+case 84:
+YY_RULE_SETUP
+#line 167 "lex.javascript.yy"
+/* nothing */
+ YY_BREAK
+case 85:
+YY_RULE_SETUP
+#line 168 "lex.javascript.yy"
+EXJS_THROWINFOLOCATION(ECJS_INVALID_TOKEN,YYText(),code_location(lineno()))
+ YY_BREAK
+case 86:
+YY_RULE_SETUP
+#line 169 "lex.javascript.yy"
+ECHO;
+ YY_BREAK
+#line 1229 "lex.javascript.cc"
+
+ case YY_END_OF_BUFFER:
+ {
+ /* Amount of text matched not including the EOB char. */
+ int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+
+ /* Undo the effects of YY_DO_BEFORE_ACTION. */
+ *yy_cp = yy_hold_char;
+ YY_RESTORE_YY_MORE_OFFSET
+
+ if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+ {
+ /* We're scanning a new file or input source. It's
+ * possible that this happened because the user
+ * just pointed yyin at a new source and called
+ * yylex(). If so, then we have to assure
+ * consistency between yy_current_buffer and our
+ * globals. Here is the right place to do so, because
+ * this is the first action (other than possibly a
+ * back-up) that will match for the new input source.
+ */
+ yy_n_chars = yy_current_buffer->yy_n_chars;
+ yy_current_buffer->yy_input_file = yyin;
+ yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+ }
+
+ /* Note that here we test for yy_c_buf_p "<=" to the position
+ * of the first EOB in the buffer, since yy_c_buf_p will
+ * already have been incremented past the NUL character
+ * (since all states make transitions on EOB to the
+ * end-of-buffer state). Contrast this with the test
+ * in input().
+ */
+ if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+ { /* This was really a NUL. */
+ yy_state_type yy_next_state;
+
+ yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state();
+
+ /* Okay, we're now positioned to make the NUL
+ * transition. We couldn't have
+ * yy_get_previous_state() go ahead and do it
+ * for us because it doesn't know how to deal
+ * with the possibility of jamming (and we don't
+ * want to build jamming into it because then it
+ * will run more slowly).
+ */
+
+ yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+ yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+ if ( yy_next_state )
+ {
+ /* Consume the NUL. */
+ yy_cp = ++yy_c_buf_p;
+ yy_current_state = yy_next_state;
+ goto yy_match;
+ }
+
+ else
+ {
+ yy_cp = yy_c_buf_p;
+ goto yy_find_action;
+ }
+ }
+
+ else switch ( yy_get_next_buffer() )
+ {
+ case EOB_ACT_END_OF_FILE:
+ {
+ yy_did_buffer_switch_on_eof = 0;
+
+ if ( yywrap() )
+ {
+ /* Note: because we've taken care in
+ * yy_get_next_buffer() to have set up
+ * yytext, we can now set up
+ * yy_c_buf_p so that if some total
+ * hoser (like flex itself) wants to
+ * call the scanner after we return the
+ * YY_NULL, it'll still work - another
+ * YY_NULL will get returned.
+ */
+ yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+ yy_act = YY_STATE_EOF(YY_START);
+ goto do_action;
+ }
+
+ else
+ {
+ if ( ! yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
+ }
+ break;
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ yy_c_buf_p =
+ yytext_ptr + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state();
+
+ yy_cp = yy_c_buf_p;
+ yy_bp = yytext_ptr + YY_MORE_ADJ;
+ goto yy_match;
+
+ case EOB_ACT_LAST_MATCH:
+ yy_c_buf_p =
+ &yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+ yy_current_state = yy_get_previous_state();
+
+ yy_cp = yy_c_buf_p;
+ yy_bp = yytext_ptr + YY_MORE_ADJ;
+ goto yy_find_action;
+ }
+ break;
+ }
+
+ default:
+ YY_FATAL_ERROR(
+ "fatal flex scanner internal error--no action found" );
+ } /* end of action switch */
+ } /* end of scanning one token */
+ } /* end of yylex */
+
+yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )
+ {
+ yyin = arg_yyin;
+ yyout = arg_yyout;
+ yy_c_buf_p = 0;
+ yy_init = 1;
+ yy_start = 0;
+ yy_flex_debug = 0;
+ yylineno = 1; // this will only get updated if %option yylineno
+
+ yy_did_buffer_switch_on_eof = 0;
+
+ yy_looking_for_trail_begin = 0;
+ yy_more_flag = 0;
+ yy_more_len = 0;
+ yy_more_offset = yy_prev_more_offset = 0;
+
+ yy_start_stack_ptr = yy_start_stack_depth = 0;
+ yy_start_stack = 0;
+
+ yy_current_buffer = 0;
+
+#ifdef YY_USES_REJECT
+ yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];
+#else
+ yy_state_buf = 0;
+#endif
+ }
+
+yyFlexLexer::~yyFlexLexer()
+ {
+ delete yy_state_buf;
+ yy_delete_buffer( yy_current_buffer );
+ }
+
+void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )
+ {
+ if ( new_in )
+ {
+ yy_delete_buffer( yy_current_buffer );
+ yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
+ }
+
+ if ( new_out )
+ yyout = new_out;
+ }
+
+#ifdef YY_INTERACTIVE
+int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
+#else
+int yyFlexLexer::LexerInput( char* buf, int max_size )
+#endif
+ {
+ if ( yyin->eof() || yyin->fail() )
+ return 0;
+
+#ifdef YY_INTERACTIVE
+ yyin->get( buf[0] );
+
+ if ( yyin->eof() )
+ return 0;
+
+ if ( yyin->bad() )
+ return -1;
+
+ return 1;
+
+#else
+ (void) yyin->read( buf, max_size );
+
+ if ( yyin->bad() )
+ return -1;
+ else
+ return yyin->gcount();
+#endif
+ }
+
+void yyFlexLexer::LexerOutput( const char* buf, int size )
+ {
+ (void) yyout->write( buf, size );
+ }
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ * EOB_ACT_LAST_MATCH -
+ * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ * EOB_ACT_END_OF_FILE - end of file
+ */
+
+int yyFlexLexer::yy_get_next_buffer()
+ {
+ register char *dest = yy_current_buffer->yy_ch_buf;
+ register char *source = yytext_ptr;
+ register int number_to_move, i;
+ int ret_val;
+
+ if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+ YY_FATAL_ERROR(
+ "fatal flex scanner internal error--end of buffer missed" );
+
+ if ( yy_current_buffer->yy_fill_buffer == 0 )
+ { /* Don't try to fill the buffer, so this is an EOF. */
+ if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+ {
+ /* We matched a single character, the EOB, so
+ * treat this as a final EOF.
+ */
+ return EOB_ACT_END_OF_FILE;
+ }
+
+ else
+ {
+ /* We matched some text prior to the EOB, first
+ * process it.
+ */
+ return EOB_ACT_LAST_MATCH;
+ }
+ }
+
+ /* Try to read more data. */
+
+ /* First move last chars to start of buffer. */
+ number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+
+ for ( i = 0; i < number_to_move; ++i )
+ *(dest++) = *(source++);
+
+ if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+ /* don't do the read, it's not guaranteed to return an EOF,
+ * just force an EOF
+ */
+ yy_current_buffer->yy_n_chars = yy_n_chars = 0;
+
+ else
+ {
+ int num_to_read =
+ yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+ while ( num_to_read <= 0 )
+ { /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+ YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+ /* just a shorter name for the current buffer */
+ YY_BUFFER_STATE b = yy_current_buffer;
+
+ int yy_c_buf_p_offset =
+ (int) (yy_c_buf_p - b->yy_ch_buf);
+
+ if ( b->yy_is_our_buffer )
+ {
+ int new_size = b->yy_buf_size * 2;
+
+ if ( new_size <= 0 )
+ b->yy_buf_size += b->yy_buf_size / 8;
+ else
+ b->yy_buf_size *= 2;
+
+ b->yy_ch_buf = (char *)
+ /* Include room in for 2 EOB chars. */
+ yy_flex_realloc( (void *) b->yy_ch_buf,
+ b->yy_buf_size + 2 );
+ }
+ else
+ /* Can't grow it, we don't own it. */
+ b->yy_ch_buf = 0;
+
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR(
+ "fatal error - scanner input buffer overflow" );
+
+ yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+ num_to_read = yy_current_buffer->yy_buf_size -
+ number_to_move - 1;
+#endif
+ }
+
+ if ( num_to_read > YY_READ_BUF_SIZE )
+ num_to_read = YY_READ_BUF_SIZE;
+
+ /* Read in more data. */
+ YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+ yy_n_chars, num_to_read );
+
+ yy_current_buffer->yy_n_chars = yy_n_chars;
+ }
+
+ if ( yy_n_chars == 0 )
+ {
+ if ( number_to_move == YY_MORE_ADJ )
+ {
+ ret_val = EOB_ACT_END_OF_FILE;
+ yyrestart( yyin );
+ }
+
+ else
+ {
+ ret_val = EOB_ACT_LAST_MATCH;
+ yy_current_buffer->yy_buffer_status =
+ YY_BUFFER_EOF_PENDING;
+ }
+ }
+
+ else
+ ret_val = EOB_ACT_CONTINUE_SCAN;
+
+ yy_n_chars += number_to_move;
+ yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+ yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+ yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+
+ return ret_val;
+ }
+
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+yy_state_type yyFlexLexer::yy_get_previous_state()
+ {
+ register yy_state_type yy_current_state;
+ register char *yy_cp;
+
+ yy_current_state = yy_start;
+ yy_state_ptr = yy_state_buf;
+ *yy_state_ptr++ = yy_current_state;
+
+ for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+ {
+ register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 224 )
+ yy_c = yy_meta[(unsigned int) yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+ *yy_state_ptr++ = yy_current_state;
+ }
+
+ return yy_current_state;
+ }
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ * next_state = yy_try_NUL_trans( current_state );
+ */
+
+yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
+ {
+ register int yy_is_jam;
+
+ register YY_CHAR yy_c = 1;
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 224 )
+ yy_c = yy_meta[(unsigned int) yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+ yy_is_jam = (yy_current_state == 223);
+ if ( ! yy_is_jam )
+ *yy_state_ptr++ = yy_current_state;
+
+ return yy_is_jam ? 0 : yy_current_state;
+ }
+
+
+void yyFlexLexer::yyunput( int c, register char* yy_bp )
+ {
+ register char *yy_cp = yy_c_buf_p;
+
+ /* undo effects of setting up yytext */
+ *yy_cp = yy_hold_char;
+
+ if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+ { /* need to shift things up to make room */
+ /* +2 for EOB chars. */
+ register int number_to_move = yy_n_chars + 2;
+ register char *dest = &yy_current_buffer->yy_ch_buf[
+ yy_current_buffer->yy_buf_size + 2];
+ register char *source =
+ &yy_current_buffer->yy_ch_buf[number_to_move];
+
+ while ( source > yy_current_buffer->yy_ch_buf )
+ *--dest = *--source;
+
+ yy_cp += (int) (dest - source);
+ yy_bp += (int) (dest - source);
+ yy_current_buffer->yy_n_chars =
+ yy_n_chars = yy_current_buffer->yy_buf_size;
+
+ if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+ YY_FATAL_ERROR( "flex scanner push-back overflow" );
+ }
+
+ *--yy_cp = (char) c;
+
+ if ( c == '\n' )
+ --yylineno;
+
+ yytext_ptr = yy_bp;
+ yy_hold_char = *yy_cp;
+ yy_c_buf_p = yy_cp;
+ }
+
+
+int yyFlexLexer::yyinput()
+ {
+ int c;
+
+ *yy_c_buf_p = yy_hold_char;
+
+ if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+ {
+ /* yy_c_buf_p now points to the character we want to return.
+ * If this occurs *before* the EOB characters, then it's a
+ * valid NUL; if not, then we've hit the end of the buffer.
+ */
+ if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+ /* This was really a NUL. */
+ *yy_c_buf_p = '\0';
+
+ else
+ { /* need more input */
+ int offset = yy_c_buf_p - yytext_ptr;
+ ++yy_c_buf_p;
+
+ switch ( yy_get_next_buffer() )
+ {
+ case EOB_ACT_LAST_MATCH:
+ /* This happens because yy_g_n_b()
+ * sees that we've accumulated a
+ * token and flags that we need to
+ * try matching the token before
+ * proceeding. But for input(),
+ * there's no matching to consider.
+ * So convert the EOB_ACT_LAST_MATCH
+ * to EOB_ACT_END_OF_FILE.
+ */
+
+ /* Reset buffer status. */
+ yyrestart( yyin );
+
+ /* fall through */
+
+ case EOB_ACT_END_OF_FILE:
+ {
+ if ( yywrap() )
+ return EOF;
+
+ if ( ! yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
+#ifdef __cplusplus
+ return yyinput();
+#else
+ return input();
+#endif
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ yy_c_buf_p = yytext_ptr + offset;
+ break;
+ }
+ }
+ }
+
+ c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
+ *yy_c_buf_p = '\0'; /* preserve yytext */
+ yy_hold_char = *++yy_c_buf_p;
+
+ if ( c == '\n' )
+ ++yylineno;
+
+ return c;
+ }
+
+
+void yyFlexLexer::yyrestart( istream* input_file )
+ {
+ if ( ! yy_current_buffer )
+ yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+ yy_init_buffer( yy_current_buffer, input_file );
+ yy_load_buffer_state();
+ }
+
+
+void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+ {
+ if ( yy_current_buffer == new_buffer )
+ return;
+
+ if ( yy_current_buffer )
+ {
+ /* Flush out information for old buffer. */
+ *yy_c_buf_p = yy_hold_char;
+ yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+ yy_current_buffer->yy_n_chars = yy_n_chars;
+ }
+
+ yy_current_buffer = new_buffer;
+ yy_load_buffer_state();
+
+ /* We don't actually know whether we did this switch during
+ * EOF (yywrap()) processing, but the only time this flag
+ * is looked at is after yywrap() is called, so it's safe
+ * to go ahead and always set it.
+ */
+ yy_did_buffer_switch_on_eof = 1;
+ }
+
+
+void yyFlexLexer::yy_load_buffer_state()
+ {
+ yy_n_chars = yy_current_buffer->yy_n_chars;
+ yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+ yyin = yy_current_buffer->yy_input_file;
+ yy_hold_char = *yy_c_buf_p;
+ }
+
+
+YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )
+ {
+ YY_BUFFER_STATE b;
+
+ b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+ b->yy_buf_size = size;
+
+ /* yy_ch_buf has to be 2 characters longer than the size given because
+ * we need to put in 2 end-of-buffer characters.
+ */
+ b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+ b->yy_is_our_buffer = 1;
+
+ yy_init_buffer( b, file );
+
+ return b;
+ }
+
+
+void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
+ {
+ if ( ! b )
+ return;
+
+ if ( b == yy_current_buffer )
+ yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+ if ( b->yy_is_our_buffer )
+ yy_flex_free( (void *) b->yy_ch_buf );
+
+ yy_flex_free( (void *) b );
+ }
+
+
+extern "C" int isatty YY_PROTO(( int ));
+void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )
+
+ {
+ yy_flush_buffer( b );
+
+ b->yy_input_file = file;
+ b->yy_fill_buffer = 1;
+
+ b->yy_is_interactive = 0;
+ }
+
+
+void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
+ {
+ if ( ! b )
+ return;
+
+ b->yy_n_chars = 0;
+
+ /* We always need two end-of-buffer characters. The first causes
+ * a transition to the end-of-buffer state. The second causes
+ * a jam in that state.
+ */
+ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+ b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+ b->yy_buf_pos = &b->yy_ch_buf[0];
+
+ b->yy_at_bol = 1;
+ b->yy_buffer_status = YY_BUFFER_NEW;
+
+ if ( b == yy_current_buffer )
+ yy_load_buffer_state();
+ }
+
+
+#ifndef YY_NO_SCAN_BUFFER
+#endif
+
+
+#ifndef YY_NO_SCAN_STRING
+#endif
+
+
+#ifndef YY_NO_SCAN_BYTES
+#endif
+
+
+#ifndef YY_NO_PUSH_STATE
+void yyFlexLexer::yy_push_state( int new_state )
+ {
+ if ( yy_start_stack_ptr >= yy_start_stack_depth )
+ {
+ yy_size_t new_size;
+
+ yy_start_stack_depth += YY_START_STACK_INCR;
+ new_size = yy_start_stack_depth * sizeof( int );
+
+ if ( ! yy_start_stack )
+ yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+ else
+ yy_start_stack = (int *) yy_flex_realloc(
+ (void *) yy_start_stack, new_size );
+
+ if ( ! yy_start_stack )
+ YY_FATAL_ERROR(
+ "out of memory expanding start-condition stack" );
+ }
+
+ yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+ BEGIN(new_state);
+ }
+#endif
+
+
+#ifndef YY_NO_POP_STATE
+void yyFlexLexer::yy_pop_state()
+ {
+ if ( --yy_start_stack_ptr < 0 )
+ YY_FATAL_ERROR( "start-condition stack underflow" );
+
+ BEGIN(yy_start_stack[yy_start_stack_ptr]);
+ }
+#endif
+
+
+#ifndef YY_NO_TOP_STATE
+int yyFlexLexer::yy_top_state()
+ {
+ return yy_start_stack[yy_start_stack_ptr - 1];
+ }
+#endif
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+
+void yyFlexLexer::LexerError( yyconst char msg[] )
+ {
+ cerr << msg << '\n';
+ exit( YY_EXIT_FAILURE );
+ }
+
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+ do \
+ { \
+ /* Undo effects of setting up yytext. */ \
+ yytext[yyleng] = yy_hold_char; \
+ yy_c_buf_p = yytext + n; \
+ yy_hold_char = *yy_c_buf_p; \
+ *yy_c_buf_p = '\0'; \
+ yyleng = n; \
+ } \
+ while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+yyconst char *s2;
+int n;
+#endif
+ {
+ register int i;
+ for ( i = 0; i < n; ++i )
+ s1[i] = s2[i];
+ }
+#endif
+
+#ifdef YY_NEED_STRLEN
+#ifdef YY_USE_PROTOS
+static int yy_flex_strlen( yyconst char *s )
+#else
+static int yy_flex_strlen( s )
+yyconst char *s;
+#endif
+ {
+ register int n;
+ for ( n = 0; s[n]; ++n )
+ ;
+
+ return n;
+ }
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( yy_size_t size )
+#else
+static void *yy_flex_alloc( size )
+yy_size_t size;
+#endif
+ {
+ return (void *) malloc( size );
+ }
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, yy_size_t size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+yy_size_t size;
+#endif
+ {
+ /* The cast to (char *) in the following accommodates both
+ * implementations that use char* generic pointers, and those
+ * that use void* generic pointers. It works with the latter
+ * because both ANSI C and C++ allow castless assignment from
+ * any pointer type to void*, and deal with argument conversions
+ * as though doing an assignment.
+ */
+ return (void *) realloc( (char *) ptr, size );
+ }
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+ {
+ free( ptr );
+ }
+
+#if YY_MAIN
+int main()
+ {
+ yylex();
+ return 0;
+ }
+#endif
+#line 169 "lex.javascript.yy"
--- /dev/null
+/* -------- definitions ------- */
+
+%option c++ yylineno noyywrap prefix="js" outfile="lex.javascript.cc" batch
+
+%{
+#include <ixlib_js_internals.hh>
+#include <ixlib_token_javascript.hh>
+
+using namespace ixion;
+using namespace javascript;
+%}
+
+WHITESPACE [ \t\n\r]
+
+DIGIT [0-9]
+DIGIT_NZ [1-9]
+DIGIT_OCT [0-7]
+DIGIT_HEX [0-9a-fA-F]
+DIGIT_SEQ {DIGIT}+
+
+NONDIGIT [_a-zA-Z]
+ID_COMPONENT [_a-zA-Z0-9]
+
+ESCAPE_SIMPLE \\['"?\\abfnrtv]
+ESCAPE_OCTAL \\{DIGIT_OCT}{1,3}
+ESCAPE_HEX \\x{DIGIT_HEX}{1,2}
+ESCAPE {ESCAPE_SIMPLE}|{ESCAPE_OCTAL}|{ESCAPE_HEX}
+S_CHAR [^"\\\n]|{ESCAPE}
+
+SIGN \+|\-
+SIGNopt {SIGN}?
+
+
+
+
+/* higher-level entities ------------------------------------------------------
+*/
+IDENTIFIER {NONDIGIT}{ID_COMPONENT}*
+
+
+
+
+/* literals -------------------------------------------------------------------
+*/
+LIT_DECIMAL {DIGIT_NZ}{DIGIT}*
+LIT_OCTAL 0{DIGIT_OCT}*
+LIT_HEX 0[xX]{DIGIT_HEX}+
+LIT_INT ({LIT_DECIMAL}|{LIT_OCTAL}|{LIT_HEX})
+
+LIT_STRING \"{S_CHAR}*\"|\'{S_CHAR}*\'
+
+LIT_FRACTION {DIGIT_SEQ}?\.{DIGIT_SEQ}|{DIGIT_SEQ}\.
+LIT_EXPONENT [eE]{SIGNopt}{DIGIT_SEQ}
+LIT_FLOAT {LIT_FRACTION}{LIT_EXPONENT}?|{DIGIT_SEQ}{LIT_EXPONENT}
+
+
+
+
+
+
+/* Contexts -------------------------------------------------------------------
+*/
+
+%x Comment
+%x LineComment
+
+
+
+
+/* Rules ----------------------------------------------------------------------
+*/
+%%
+
+\/\* BEGIN(Comment);
+<Comment>\*\/ BEGIN(INITIAL);
+<Comment><<EOF>> EXJS_THROW(ECJS_UNTERMINATED_COMMENT)
+<Comment>. /* nothing */
+<Comment>\n /* nothing */
+\/\/ BEGIN(LineComment);
+<LineComment>[\n\r]+ BEGIN(INITIAL);
+<LineComment>. /* nothing */
+
+<<EOF>> return TT_EOF;
+
+\{ return '{';
+\} return '}';
+\; return ';';
+
+\[ return '[';
+\] return ']';
+\( return '(';
+\) return ')';
+\? return '?';
+\: return ':';
+\+ return '+';
+\- return '-';
+\* return '*';
+\/ return '/';
+\% return '%';
+\^ return '^';
+\& return '&';
+\| return '|';
+\~ return '~';
+\! return '!';
+\= return '=';
+\< return '<';
+\> return '>';
+\, return ',';
+\. return '.';
+\+\= return TT_JS_PLUS_ASSIGN;
+\-\= return TT_JS_MINUS_ASSIGN;
+\*\= return TT_JS_MULTIPLY_ASSIGN;
+\/\= return TT_JS_DIVIDE_ASSIGN;
+\%\= return TT_JS_MODULO_ASSIGN;
+\^\= return TT_JS_BIT_XOR_ASSIGN;
+\&\= return TT_JS_BIT_AND_ASSIGN;
+\|\= return TT_JS_BIT_OR_ASSIGN;
+\<\< return TT_JS_LEFT_SHIFT;
+\>\> return TT_JS_RIGHT_SHIFT;
+\<\<\= return TT_JS_LEFT_SHIFT_ASSIGN;
+\>\>\= return TT_JS_RIGHT_SHIFT_ASSIGN;
+\=\=\= return TT_JS_IDENTICAL;
+\!\=\= return TT_JS_NOT_IDENTICAL;
+\=\= return TT_JS_EQUAL;
+\!\= return TT_JS_NOT_EQUAL;
+\<\= return TT_JS_LESS_EQUAL;
+\>\= return TT_JS_GREATER_EQUAL;
+\&\& return TT_JS_LOGICAL_AND;
+\|\| return TT_JS_LOGICAL_OR;
+\+\+ return TT_JS_INCREMENT;
+\-\- return TT_JS_DECREMENT;
+
+new return TT_JS_NEW;
+
+this return TT_JS_THIS;
+function return TT_JS_FUNCTION;
+var return TT_JS_VAR;
+null return TT_JS_NULL;
+if return TT_JS_IF;
+while return TT_JS_WHILE;
+do return TT_JS_DO;
+else return TT_JS_ELSE;
+for return TT_JS_FOR;
+return return TT_JS_RETURN;
+switch return TT_JS_SWITCH;
+case return TT_JS_CASE;
+continue return TT_JS_CONTINUE;
+break return TT_JS_BREAK;
+default return TT_JS_DEFAULT;
+true return TT_JS_LIT_TRUE;
+false return TT_JS_LIT_FALSE;
+undefined return TT_JS_LIT_UNDEFINED;
+in return TT_JS_IN;
+const return TT_JS_CONST;
+class return TT_JS_CLASS;
+extends return TT_JS_EXTENDS;
+namespace return TT_JS_NAMESPACE;
+static return TT_JS_STATIC;
+constructor return TT_JS_CONSTRUCTOR;
+
+{LIT_INT} return TT_JS_LIT_INT;
+{LIT_FLOAT} return TT_JS_LIT_FLOAT;
+{LIT_STRING} return TT_JS_LIT_STRING;
+
+{IDENTIFIER} return TT_JS_IDENTIFIER;
+
+{WHITESPACE}+ /* nothing */
+. EXJS_THROWINFOLOCATION(ECJS_INVALID_TOKEN,YYText(),code_location(lineno()))
--- /dev/null
+#include <ixlib_js_internals.hh>
+#include <ixlib_exbase.hh>
+#include <ixlib_javascript.hh>
+
+#include <fstream>
+
+using namespace ixion;
+using namespace ixion::javascript;
+
+IXLIB_JS_DECLARE_FUNCTION(write)
+{
+ if (parameters.size() != 1) {
+ EXJS_THROWINFO(ECJS_INVALID_NUMBER_OF_ARGUMENTS, "write");
+ }
+ std::cout << parameters[0]->toString();
+ return makeConstant(parameters[0]->toString());
+}
+
+int main (int ac, char ** av) {
+ interpreter *jsint = new interpreter();
+ addStandardLibrary(*jsint);
+ ref<value> x = new write();
+ jsint->RootScope->addMember("write", x);
+
+ if (ac == 1) {
+ std::cerr << "Usage: " << av[0] << "<file+>" << std::endl;
+ exit(1);
+ }
+ for (int i = 1; i < ac; i++) {
+ std::ifstream input(av[i]);
+ try {
+ ref<value> result = jsint->execute(input);
+ std::cout << av[i] << " returned " << result->stringify() << std::endl;
+ } catch (base_exception &ex) {
+ std::cerr << ex.getText() << ex.what() << std::endl;
+ }
+ input.close();
+ }
+ delete jsint;
+}
+
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Numeric conversions
+// ----------------------------------------------------------------------------
+// (c) Copyright 1999 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <ixlib_exgen.hh>
+#include <ixlib_numconv.hh>
+#include <stdio.h>
+
+
+
+
+using namespace std;
+using namespace ixion;
+
+
+
+
+// data objects --------------------------------------------------------------
+static string numChars = IXLIB_NUMCHARS;
+
+
+
+
+// exported subroutines -------------------------------------------------------
+string ixion::float2dec(double value) {
+ char buf[255];
+ sprintf((char *)&buf,"%f",value);
+ return string(buf);
+ }
+
+
+
+
+string ixion::float2dec(double value, unsigned int precision) {
+ char buf[255];
+ string cmd("%.");
+
+ cmd += unsigned2dec(precision) + "f";
+ sprintf((char *)&buf,cmd.c_str(),value);
+ return string(buf);
+ }
+
+
+
+
+string ixion::unsigned2base(unsigned long value,char digits,char radix) {
+ string temp;
+ do {
+ temp = numChars[value % radix]+temp;
+ value /= radix;
+ if (digits) digits--;
+ } while (value || digits);
+ return temp;
+ }
+
+
+
+
+string ixion::signed2base(signed long value,char digits,char radix) {
+ if (value < 0) return "-"+unsigned2base(-value,digits,radix);
+ else return unsigned2base(value,digits,radix);
+ }
+
+
+
+
+string ixion::bytes2dec(TSize bytes) {
+ if (bytes>(TSize) 10*1024*1024)
+ return unsigned2dec(bytes / ((TSize) 1024*1024))+" MB";
+ if (bytes>(TSize) 10*1024)
+ return unsigned2dec(bytes / ((TSize) 1024))+" KB";
+ return unsigned2dec(bytes)+" Byte";
+ }
+
+
+
+
+unsigned long ixion::evalNumeral(string const &numeral,unsigned radix) {
+ string numstr = upper(numeral);
+
+ if (numstr.size() == 0) return 0;
+ unsigned long value = 0, mulvalue = 1;
+ TIndex index = numstr.size()-1;
+
+ do {
+ string::size_type digvalue = numChars.find(numstr[index]);
+ if (digvalue == string::npos)
+ EXGEN_THROWINFO(EC_CANNOTEVALUATE,numstr.c_str())
+ value += mulvalue * digvalue;
+ mulvalue *= radix;
+ } while (index--);
+
+ return value;
+ }
+
+
+
+
+double ixion::evalFloat(string const &numeral) {
+ double result;
+ int count = sscanf(numeral.c_str(), "%le", &result);
+ if (count == 0) EXGEN_THROWINFO(EC_CANNOTEVALUATE,numeral.c_str())
+ else return result;
+ }
+
+
+
+
+unsigned long ixion::evalUnsigned(string const &numeral,unsigned default_base) {
+ if (numeral.size() == 0) return 0;
+
+ if (numeral.substr(0,2) == "0X" || numeral.substr(0,2) == "0x")
+ return evalNumeral(numeral.substr(2),0x10);
+ if (numeral.substr(0,1) == "$")
+ return evalNumeral(numeral.substr(1),0x10);
+
+ char lastchar = numeral[numeral.size()-1];
+ if (lastchar == 'H' || lastchar == 'h') return evalNumeral(numeral.substr(0,numeral.size()-1),0x10);
+ if (lastchar == 'B' || lastchar == 'b') return evalNumeral(numeral.substr(0,numeral.size()-1),2);
+ if (lastchar == 'D' || lastchar == 'd') return evalNumeral(numeral.substr(0,numeral.size()-1),10);
+ if (lastchar == 'O' || lastchar == 'o') return evalNumeral(numeral.substr(0,numeral.size()-1),8);
+
+ return evalNumeral(numeral,default_base);
+ }
+
+
+
+
+signed long ixion::evalSigned(string const &numeral,unsigned default_base) {
+ if (numeral.size() == 0) return 0;
+ if (numeral[0] == '-')
+ return - (signed long) evalUnsigned(numeral.substr(1),default_base);
+ else {
+ if (numeral[0] == '+')
+ return evalUnsigned(numeral.substr(1),default_base);
+ else
+ return evalUnsigned(numeral,default_base);
+ }
+ }
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Numeric / order processing
+// ----------------------------------------------------------------------------
+// (c) Copyright 1998 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <ixlib_numeric.hh>
+
+
+
+
+// BCD encoding ---------------------------------------------------------------
+unsigned long ixion::unsigned2BCD(unsigned long value)
+{
+ unsigned long bcdvalue = 0,bcdshift = 0;
+ while (value) {
+ bcdvalue += (value % 10) << bcdshift;
+ bcdshift += 4;
+ value /= 10;
+ }
+ return bcdvalue;
+}
+
+
+
+
+unsigned long ixion::BCD2unsigned(unsigned long value)
+{
+ unsigned long decvalue = 0;
+ for (unsigned long i = 1;value;i *= 10) {
+ decvalue += (value & 0xf) * i;
+ value >>= 4;
+ }
+ return decvalue;
+}
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Regular expressions string object.
+// ----------------------------------------------------------------------------
+// (c) Copyright 1998 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <stack>
+#include <cctype>
+#include "ixlib_i18n.hh"
+#include <ixlib_exgen.hh>
+#include <ixlib_numeric.hh>
+#include <ixlib_numconv.hh>
+#include <ixlib_re.hh>
+#include <ixlib_re_impl.hh>
+
+
+
+
+using namespace std;
+using namespace ixion;
+
+
+
+
+// Template instantiations ----------------------------------------------------
+template regex<string>;
+
+
+
+
+// Error texts ----------------------------------------------------------------
+static char *RegexPlainText[] = {
+ N_("Invalid quantifier"),
+ N_("Unbalanced backreference"),
+ N_("Invalid escape sequence"),
+ N_("Invalid backreference"),
+ N_("Unterminated character class"),
+ N_("Unable to match without expression"),
+ };
+
+
+
+
+// regex_exception ------------------------------------------------------------
+regex_exception::regex_exception(TErrorCode error,
+ char const *info,char *module,TIndex line)
+: base_exception(error,info,module,line,"RE") {
+ }
+
+
+
+
+char *regex_exception::getText() const {
+ return _(RegexPlainText[Error]);
+ }
+
+
+
+
+// regex_string::class_matcher ------------------------------------------------
+regex_string::class_matcher::class_matcher()
+ : Negated(false) {
+ MatchLength = 1;
+ }
+
+
+
+
+regex_string::class_matcher::class_matcher(string const &cls)
+ : Negated(false) {
+ MatchLength = 1;
+
+ if (cls.size() && cls[0] == XSTRRE_CLASSNEG) {
+ expandClass(cls.substr(1));
+ Negated = true;
+ }
+ else
+ expandClass(cls);
+ }
+
+
+
+
+ixion::regex<string>::matcher *ixion::regex_string::class_matcher::duplicate() const {
+ class_matcher *dupe = new class_matcher();
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+bool regex_string::class_matcher::match(backref_stack &brstack,string const &candidate,TIndex at) {
+ if (at >= candidate.size()) return false;
+
+ bool result = Set[candidate[at]];
+ if (Negated) result = !result;
+
+ return result && matchNext(brstack,candidate,at+1);
+ }
+
+
+
+
+void regex_string::class_matcher::expandClass(string const &cls) {
+ memset(&Set,0,sizeof(Set));
+
+ if (cls.size() == 0) return;
+ Set[cls[0]] = true;
+ char lastchar = cls[0];
+
+ for (TIndex index = 1;index < cls.size();index++) {
+ if ((cls[index] == XSTRRE_CLASSRANGE) && (index < cls.size()-1)) {
+ for (char ch = lastchar+1;ch < cls[index+1];ch++)
+ Set[ch] = true;
+ }
+ else Set[cls[index]] = true;
+ lastchar = cls[index];
+ }
+ }
+
+
+
+
+void ixion::regex_string::class_matcher::copy(class_matcher const *src) {
+ super::copy(src);
+ for (TIndex i = 0;i < CharValues;i++)
+ Set[i] = src->Set[i];
+ Negated = src->Negated;
+ }
+
+
+
+
+// regex_string::special_class_matcher ----------------------------------------
+regex_string::special_class_matcher::special_class_matcher(type tp)
+ : Type(tp) {
+ MatchLength = 1;
+ }
+
+
+
+
+ixion::regex<string>::matcher *ixion::regex_string::special_class_matcher::duplicate() const {
+ special_class_matcher *dupe = new special_class_matcher(Type);
+ dupe->copy(this);
+ return dupe;
+ }
+
+
+
+
+bool regex_string::special_class_matcher::match(backref_stack &brstack,string const &candidate,TIndex at) {
+ if (at >= candidate.size()) return false;
+ enum type { DIGIT,NONDIGIT,ALNUM,NONALNUM,SPACE,NONSPACE };
+
+ bool result;
+ switch (Type) {
+ case DIGIT: result = isdigit(candidate[at]);
+ break;
+ case NONDIGIT: result = !isdigit(candidate[at]);
+ break;
+ case ALNUM: result = isalnum(candidate[at]);
+ break;
+ case NONALNUM: result = !isalnum(candidate[at]);
+ break;
+ case SPACE: result = isspace(candidate[at]);
+ break;
+ case NONSPACE: result = !isspace(candidate[at]);
+ break;
+ default:
+ EX_THROW(regex,ECRE_INVESCAPE)
+ }
+
+ return result && matchNext(brstack,candidate,at+1);
+ }
+
+
+
+
+// regex_string ---------------------------------------------------------------
+void regex_string::parse(string const &expr) {
+ auto_ptr<matcher> new_re(parseRegex(expr));
+ ParsedRegex = new_re;
+ }
+
+
+
+
+string regex_string::replaceAll(string const &candidate,string const &replacement,TIndex from) {
+ string result;
+ string tempreplacement;
+
+ LastCandidate = candidate;
+ if (ParsedRegex.get() == NULL)
+ EX_THROW(regex,ECRE_NOPATTERN)
+
+ for (TIndex index = from;index < candidate.size();) {
+ BackrefStack.clear();
+ if (ParsedRegex->match(BackrefStack,candidate,index)) {
+ TIndex matchlength = ParsedRegex->subsequentMatchLength();
+ tempreplacement = replacement;
+
+ TSize backrefs = BackrefStack.size();
+ for (TIndex i = 0;i < backrefs;i++)
+ tempreplacement = findReplace(tempreplacement,XSTRRE_BACKREF+unsigned2dec(i),
+ BackrefStack.get(i,LastCandidate));
+
+ result += tempreplacement;
+ index += matchlength;
+ }
+ else result += candidate[index++];
+ }
+ return result;
+ }
+
+
+
+
+regex_string::matcher *regex_string::parseRegex(string const &expr) {
+ if (!expr.size()) return NULL;
+ TIndex index = 0;
+ matcher *firstobject,*lastobject = NULL;
+ alternative_matcher *alternative = NULL;
+
+ while (index < expr.size()) {
+ matcher *object = NULL;
+ quantifier *quantifier = NULL;
+ bool quantified = true;
+ char ch;
+
+ // several objects may be inserted in one loop run
+ switch (expr[index++]) {
+ // case XSTRRE_BACKREF: (dupe)
+ // case XSTRRE_ESCAPESEQ: (dupe)
+ case XSTRRE_LITERAL: {
+ if (index >= expr.size()) EX_THROW(regex,ECRE_INVESCAPE)
+
+ ch = expr[index++];
+ if (isdigit(ch))
+ object = new backref_matcher(ch-'0');
+ else {
+ switch (ch) {
+ case 'd': object = new special_class_matcher(special_class_matcher::DIGIT);
+ break;
+ case 'D': object = new special_class_matcher(special_class_matcher::NONDIGIT);
+ break;
+ case 'w': object = new special_class_matcher(special_class_matcher::ALNUM);
+ break;
+ case 'W': object = new special_class_matcher(special_class_matcher::NONALNUM);
+ break;
+ case 's': object = new special_class_matcher(special_class_matcher::SPACE);
+ break;
+ case 'S': object = new special_class_matcher(special_class_matcher::NONSPACE);
+ break;
+ default: object = new sequence_matcher(string(1,ch));
+ }
+ }
+ break;
+ }
+ case XSTRRE_ANYCHAR:
+ object = new any_matcher;
+ break;
+ case XSTRRE_START:
+ quantified = false;
+ object = new start_matcher;
+ break;
+ case XSTRRE_END:
+ quantified = false;
+ object = new end_matcher;
+ break;
+ case XSTRRE_ALTERNATIVE: {
+ if (!alternative)
+ alternative = new alternative_matcher;
+ alternative->addAlternative(firstobject);
+ firstobject = NULL;
+ lastobject = NULL;
+ break;
+ }
+ case XSTRRE_CLASSSTART: {
+ TIndex classend = expr.find(XSTRRE_CLASSSTOP,index);
+ if (classend == string::npos)
+ EX_THROW(regex,ECRE_UNTERMCLASS)
+ object = new class_matcher(expr.substr(index,classend-index));
+
+ index = classend+1;
+ break;
+ }
+ case XSTRRE_BACKREFSTART: {
+ matcher *parsed;
+
+ TSize brlevel = 1;
+ for (TIndex searchstop = index;searchstop < expr.size();searchstop++) {
+ if ((expr[searchstop] == XSTRRE_BACKREFSTART) &&
+ (expr[searchstop-1] != XSTRRE_LITERAL))
+ brlevel++;
+ if ((expr[searchstop] == XSTRRE_BACKREFSTOP) &&
+ (expr[searchstop-1] != XSTRRE_LITERAL)) {
+ brlevel--;
+ if (brlevel == 0) {
+ parsed = parseRegex(expr.substr(index,searchstop-index));
+ if (!parsed) EX_THROW(regex,ECRE_INVBACKREF)
+
+ index = searchstop+1;
+ break;
+ }
+ }
+ }
+
+ if (!parsed) EX_THROW(regex,ECRE_UNBALBACKREF)
+
+ object = new backref_open_matcher;
+ object->setNext(parsed);
+
+ matcher *closer = new backref_close_matcher;
+
+ matcher *searchlast = parsed,*foundlast;
+ while (searchlast) {
+ foundlast = searchlast;
+ searchlast = searchlast->getNext();
+ }
+ foundlast->setNext(closer);
+
+ break;
+ }
+ case XSTRRE_BACKREFSTOP:
+ EX_THROW(regex,ECRE_UNBALBACKREF)
+ default:
+ object = new sequence_matcher(expr.substr(index-1,1));
+ break;
+ }
+
+ if (object) {
+ if (quantified) quantifier = parseQuantifier(expr,index);
+ if (quantifier) {
+ quantifier->setQuantified(object);
+ if (lastobject) lastobject->setNext(quantifier);
+ else firstobject = quantifier;
+ }
+ else {
+ if (lastobject) lastobject->setNext(object);
+ else firstobject = object;
+ }
+ }
+
+ // we need this for the alternative matcher, which also inserts
+ // its connector
+ matcher *searchlast = quantifier ? quantifier : object;
+ while (searchlast) {
+ lastobject = searchlast;
+ searchlast = searchlast->getNext();
+ }
+ }
+ if (alternative) {
+ alternative->addAlternative(firstobject);
+ return alternative;
+ }
+ else return firstobject;
+ }
+
+
+
+
+regex_string::quantifier *regex_string::parseQuantifier(string const &expr,TIndex &at) {
+ quantifier *quant = NULL;
+ if (at == expr.size()) return NULL;
+ if (expr[at] == XSTRREQ_0PLUS) {
+ quant = new quantifier(isGreedy(expr,++at),0);
+ return quant;
+ }
+ if (expr[at] == XSTRREQ_1PLUS) {
+ quant = new quantifier(isGreedy(expr,++at),1);
+ return quant;
+ }
+ if (expr[at] == XSTRREQ_01) {
+ quant = new quantifier(isGreedy(expr,++at),0,1);
+ return quant;
+ }
+ if (expr[at] == XSTRREQ_START) {
+ TSize min,max;
+
+ at++;
+ TIndex endindex;
+ endindex = expr.find(XSTRREQ_STOP,at);
+ if (endindex == string::npos)
+ EXGEN_THROW(ECRE_INVQUANTIFIER)
+
+ string quantspec = expr.substr(at,endindex-at);
+ at = endindex+1;
+
+ try {
+ string::size_type rangeindex = quantspec.find(XSTRREQ_RANGE);
+ if (rangeindex == string::npos) {
+ min = evalUnsigned(quantspec);
+ quant = new quantifier(isGreedy(expr,at),min,min);
+ }
+ else if (rangeindex == quantspec.size()-1) {
+ min = evalUnsigned(quantspec.substr(0,rangeindex));
+ quant = new quantifier(isGreedy(expr,at),min);
+ }
+ else {
+ min = evalUnsigned(quantspec.substr(0,rangeindex));
+ max = evalUnsigned(quantspec.substr(rangeindex+1));
+ quant = new quantifier(isGreedy(expr,at),min,max);
+ }
+ return quant;
+ }
+ EX_CONVERT(generic,EC_CANNOTEVALUATE,regex,ECRE_INVQUANTIFIER)
+ }
+ return NULL;
+ }
+
+
+
+
+bool regex_string::isGreedy(string const &expr,TIndex &at)
+{
+ if (at == expr.size()) return true;
+ if (expr[at] == XSTRREQ_NONGREEDY) {
+ at++;
+ return false;
+ }
+ else return true;
+}
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : Scanner for xTextFile
+// ----------------------------------------------------------------------------
+// (c) Copyright 1999 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <FlexLexer.h>
+#include "ixlib_i18n.hh"
+#include <ixlib_numconv.hh>
+#include <ixlib_token_lex.hh>
+#include <ixlib_scanner.hh>
+
+
+
+
+using namespace std;
+using namespace ixion;
+
+
+
+
+// Plain text rendering table -------------------------------------------------
+static char *(PlainText[]) = {
+ N_("Unknown token"),
+ N_("End of input")
+ };
+
+
+
+
+// scanner_exception ----------------------------------------------------------
+scanner_exception::scanner_exception(TErrorCode error, TIndex line,
+string const &info)
+: base_exception(error, NULL, NULL, 0, "SCAN") {
+ HasInfo = true;
+ try {
+ string temp = "line ";
+ temp += unsigned2dec(line);
+ if (info != "") {
+ temp += " : ";
+ temp += info;
+ }
+ strcpy(Info, temp.c_str());
+ }
+ catch (...) { }
+ }
+
+
+
+
+char *scanner_exception::getText() const {
+ return PlainText[Error];
+ }
+
+
+
+
+// scanner --------------------------------------------------------------------
+scanner::scanner(FlexLexer &lexer)
+: Lexer(lexer) {
+ }
+
+
+
+
+scanner::token_list scanner::scan() {
+ CurrentToken.Type = Lexer.yylex();
+ CurrentToken.Line = Lexer.lineno();
+ CurrentToken.Text = Lexer.YYText();
+
+ token_list tokenlist;
+ while (!reachedEOF()) {
+ tokenlist.push_back(getNextToken());
+ }
+ return tokenlist;
+ }
+
+
+
+
+scanner::token scanner::getNextToken() {
+ if (!reachedEOF()) {
+ token lasttoken = CurrentToken;
+
+ CurrentToken.Type = Lexer.yylex();
+ CurrentToken.Line = Lexer.lineno();
+ CurrentToken.Text = Lexer.YYText();
+
+ if (CurrentToken.Type == TT_UNKNOWN)
+ throw scanner_exception(ECSCAN_UNKNOWN_TOKEN,CurrentToken.Line,CurrentToken.Text);
+ else return lasttoken;
+ }
+ throw scanner_exception(ECSCAN_UNKNOWN_TOKEN, CurrentToken.Line, "");
+ }
+
+
+
+
+bool scanner::reachedEOF() const {
+ return (CurrentToken.Type == TT_EOF);
+ }
+
+
+
+
--- /dev/null
+// ----------------------------------------------------------------------------
+// Description : String object
+// ----------------------------------------------------------------------------
+// (c) Copyright 1999 by iXiONmedia, all rights reserved.
+// ----------------------------------------------------------------------------
+
+
+
+
+#include <cstring>
+#include <cctype>
+#include <ixlib_numconv.hh>
+#include <ixlib_string.hh>
+
+
+
+
+using namespace std;
+using namespace ixion;
+
+
+
+
+// String utility functions ---------------------------------------------------
+string ixion::findReplace(string const &target,string const &src,string const &dest) {
+ string result = target;
+ TIndex foundpos = string::npos;
+ TIndex n = src.size();
+ while ((foundpos = result.find(src)) != string::npos)
+ result.replace(foundpos,n,dest);
+ return result;
+ }
+
+
+
+
+string ixion::findReplace(string const &target,char* src,char *dest) {
+ string result = target;
+ TSize foundpos = string::npos;
+ TSize n = strlen(src);
+ while ((foundpos = result.find(src)) != string::npos)
+ result.replace(foundpos,n,dest);
+ return result;
+ }
+
+
+
+
+string ixion::findReplace(string const &target,char src,char dest) {
+ string result = target;
+ string::iterator first = result.begin(),last = result.end();
+
+ while (first != last) {
+ if (*first == src) *first = dest;
+ first++;
+ }
+ return result;
+ }
+
+
+
+
+string ixion::upper(string const &original) {
+ string temp(original);
+ string::iterator first = temp.begin(),last = temp.end();
+
+ while (first != last) {
+ *first = toupper(*first);
+ first++;
+ }
+ return temp;
+ }
+
+
+
+
+string ixion::lower(string const &original) {
+ string temp(original);
+ string::iterator first = temp.begin(),last = temp.end();
+
+ while (first != last) {
+ *first = tolower(*first);
+ first++;
+ }
+ return temp;
+ }
+
+
+
+
+string ixion::removeLeading(string const &original,char ch) {
+ string copy(original);
+ string::iterator first = copy.begin(), last = copy.end();
+
+ while (first != last && *first == ch) first++;
+ if (first != copy.begin()) copy.erase(copy.begin(),first);
+ return copy;
+ }
+
+
+
+
+string ixion::removeTrailing(string const &original,char ch) {
+ string copy(original);
+ string::iterator first = copy.begin(), last = copy.end();
+
+ if (first != last) {
+ last--;
+ while (first != last && *last == ch) last--;
+ if (*last != ch) last++;
+ }
+
+ if (last != copy.end()) copy.erase(last,copy.end());
+ return copy;
+ }
+
+
+
+
+string ixion::removeLeadingTrailing(string const &original,char ch) {
+ string copy(original);
+ string::iterator first = copy.begin(), last = copy.end();
+
+ while (first != last && *first == ch) first++;
+ if (first != copy.begin()) copy.erase(copy.begin(),first);
+
+ first = copy.begin();
+ last = copy.end();
+
+ if (first != last) {
+ last--;
+ while (first != last && *last == ch) last--;
+ if (*last != ch) last++;
+ }
+
+ if (last != copy.end()) copy.erase(last,copy.end());
+ return copy;
+ }
+
+
+
+
+string ixion::parseCEscapes(string const &original) {
+ string result = "";
+ string::const_iterator first = original.begin(),last = original.end();
+ while (first != last) {
+ if (*first == '\\') {
+ first++;
+ if (first == last) {
+ result += '\\';
+ break;
+ }
+
+ #define GET_TEMP_STRING(LENGTH) \
+ if (original.end()-first < LENGTH) \
+ EXGEN_THROWINFO(EC_INVALIDPAR,"invalid escape sequence") \
+ tempstring = string(first,first+LENGTH); \
+ first += LENGTH;
+
+ char value;
+ string tempstring;
+ switch (*first) {
+ case 'b': result += '\b'; first++; break;
+ case 'f': result += '\f'; first++; break;
+ case 'n': result += '\n'; first++; break;
+ case 't': result += '\t'; first++; break;
+ case 'v': result += '\v'; first++; break;
+ case 'X':
+ case 'x': first++;
+ GET_TEMP_STRING(2)
+ value = evalNumeral(tempstring,16);
+ result += value;
+ break;
+ case 'u': first++;
+ GET_TEMP_STRING(4)
+ value = evalNumeral(tempstring,16);
+ result += value;
+ break;
+ case '0':
+ GET_TEMP_STRING(3)
+ value = evalNumeral(tempstring,8);
+ result += value;
+ break;
+ default: result += *first++;
+ }
+ }
+ else result += *first++;
+ }
+ return result;
+ }
+
+
+
+
+namespace {
+ TByte const B64_INVALID = 0xff;
+ TByte const B64_PAD = 0xfe;
+ char const B64_PAD_CHAR = '=';
+ char Base64EncodeTable[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ TByte Base64DecodeTable[] = { // based at 0
+ // see test/invertmap.js on how to generate this table
+ B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,
+ B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,
+ B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,
+ B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,
+ B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,
+ B64_INVALID,B64_INVALID,B64_INVALID,62,B64_INVALID,B64_INVALID,B64_INVALID,63,52,53,54,
+ 55,56,57,58,59,60,61,B64_INVALID,B64_INVALID,B64_INVALID,B64_PAD,B64_INVALID,
+ B64_INVALID,B64_INVALID,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
+ 19,20,21,22,23,24,25,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,
+ B64_INVALID,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,
+ 44,45,46,47,48,49,50,51,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,B64_INVALID,
+ };
+
+ }
+
+
+
+
+TSize ixion::getMaxBase64DecodedSize(TSize encoded) {
+ return ((encoded+3)/4)*3;
+ }
+
+
+
+
+TSize ixion::base64decode(TByte *data,string const &base64) {
+ string::const_iterator first = base64.begin(),last = base64.end();
+
+ TByte *data_start = data;
+
+ TUnsigned32 block;
+ TByte a,b,c,d;
+
+ while (first != last) {
+ a = Base64DecodeTable[*(first++)];
+ b = Base64DecodeTable[*(first++)];
+ c = Base64DecodeTable[*(first++)];
+ d = Base64DecodeTable[*(first++)];
+ if (c == B64_PAD) {
+ block = a << 3*6 | b << 2*6;
+ *data++ = (block >> 16) & 0xff;
+ }
+ else if (d == B64_PAD) {
+ block = a << 3*6 | b << 2*6 | c << 1*6;
+ *data++ = (block >> 16) & 0xff;
+ *data++ = (block >> 8) & 0xff;
+ }
+ else {
+ block = a << 3*6 | b << 2*6 | c << 1*6 | d << 0*6;
+ *data++ = (block >> 16) & 0xff;
+ *data++ = (block >> 8) & 0xff;
+ *data++ = (block >> 0) & 0xff;
+ }
+ }
+ return data-data_start;
+ }
+
+
+
+
+void ixion::base64encode(string &base64,TByte const *data,TSize size) {
+ base64.resize((size+2)/3*4);
+
+ TUnsigned32 block;
+ TByte a,b,c,d;
+
+ TByte const *end = data+size;
+ string::iterator first = base64.begin();
+ while (data < end)
+ if (data+1 == end) {
+ block = data[0] << 16;
+ a = (block >> 3*6) & 0x3f;
+ b = (block >> 2*6) & 0x3f;
+ *first++ = Base64EncodeTable[a];
+ *first++ = Base64EncodeTable[b];
+ *first++ = B64_PAD_CHAR;
+ *first++ = B64_PAD_CHAR;
+ data++;
+ }
+ else if (data+2 == end) {
+ block = data[0] << 16 | data[1] << 8;
+ a = (block >> 3*6) & 0x3f;
+ b = (block >> 2*6) & 0x3f;
+ c = (block >> 1*6) & 0x3f;
+ *first++ = Base64EncodeTable[a];
+ *first++ = Base64EncodeTable[b];
+ *first++ = Base64EncodeTable[c];
+ *first++ = B64_PAD_CHAR;
+ data += 2;
+ }
+ else {
+ block = data[0] << 16 | data[1] << 8 | data[2];
+ a = (block >> 3*6) & 0x3f;
+ b = (block >> 2*6) & 0x3f;
+ c = (block >> 1*6) & 0x3f;
+ d = (block >> 0*6) & 0x3f;
+ *first++ = Base64EncodeTable[a];
+ *first++ = Base64EncodeTable[b];
+ *first++ = Base64EncodeTable[c];
+ *first++ = Base64EncodeTable[d];
+ data += 3;
+ }
+ }
+
+
+
+
+// string_hash ----------------------------------------------------------------
+unsigned long ixion::string_hash::operator()(string const &str) const {
+ // the sgi stl uses the same hash algorithm
+ unsigned long h = 0;
+ FOREACH_CONST(first,str,string)
+ h = 5*h + *first;
+ return h;
+ }
projects / simgear.git / commitdiff