FGFS-4.1/simgear
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed simgear/interpreter directory; most likely we will use the new

Browse Source 
PSL interpreted language in plib.
This commit is contained in:
david 2002-09-18 20:27:17 +00:00
parent 01ccdd3ae1
commit 8d63c300e2
39 changed files with 0 additions and 11544 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
configure.ac
View File

@ -363,7 +363,6 @@ AC_CONFIG_FILES([ \
simgear/bucket/Makefile \ simgear/bucket/Makefile \
simgear/debug/Makefile \ simgear/debug/Makefile \
simgear/ephemeris/Makefile \ simgear/ephemeris/Makefile \
simgear/interpreter/Makefile \
simgear/io/Makefile \ simgear/io/Makefile \
simgear/magvar/Makefile \ simgear/magvar/Makefile \
simgear/math/Makefile \ simgear/math/Makefile \

3
simgear/interpreter/.cvsignore
View File

@ -1,3 +0,0 @@
.deps
Makefile
Makefile.in

33
simgear/interpreter/Makefile.am
View File

@ -1,33 +0,0 @@
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
INCLUDES = -I$(top_srcdir)

77
simgear/interpreter/exbase.cc
View File

@ -1,77 +0,0 @@
// ----------------------------------------------------------------------------
// 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;
}

46
simgear/interpreter/exgen.cc
View File

@ -1,46 +0,0 @@
// ----------------------------------------------------------------------------
// 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]);
}

9
simgear/interpreter/interpreter.cxx
View File

@ -1,9 +0,0 @@
#include "interpreter.hxx"
SGInterpreter::SGInterpreter ()
{
}
SGInterpreter::~SGInterpreter ()
{
}

13
simgear/interpreter/interpreter.hxx
View File

@ -1,13 +0,0 @@
#ifndef __INTERPRETER_HXX
#define __INTERPRETER_HXX 1
class SGInterpreter
{
public:
SGInterpreter ();
virtual ~SGInterpreter ();
};
#endif

107
simgear/interpreter/ixlib_base.hh
View File

@ -1,107 +0,0 @@
/* ----------------------------------------------------------------------------
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

72
simgear/interpreter/ixlib_exbase.hh
View File

@ -1,72 +0,0 @@
// ----------------------------------------------------------------------------
// 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

67
simgear/interpreter/ixlib_exgen.hh
View File

@ -1,67 +0,0 @@
// ----------------------------------------------------------------------------
// 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

491
simgear/interpreter/ixlib_garbage.hh
View File

@ -1,491 +0,0 @@
// ----------------------------------------------------------------------------
// 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

23
simgear/interpreter/ixlib_i18n.hh
View File

@ -1,23 +0,0 @@
// ----------------------------------------------------------------------------
// 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

380
simgear/interpreter/ixlib_javascript.hh
View File

@ -1,380 +0,0 @@
// ----------------------------------------------------------------------------
// 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 &parameters); \
}; \
} \
ixion::ref<ixion::javascript::value> NAME::call(parameter_list const &parameters)
#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 &parameters);
virtual ref<value> callAsMethod(ref<value> instance,parameter_list const &parameters);
virtual ref<value> construct(parameter_list const &parameters);
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 &parameters);
};
public:
ref<value> lookup(std::string const &identifier);
virtual ref<value> callMethod(std::string const &identifier,parameter_list const &parameters) = 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 &parameters);
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

760
simgear/interpreter/ixlib_js_internals.hh
View File

@ -1,760 +0,0 @@
// ----------------------------------------------------------------------------
// 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 &parameters);
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 &parameters);
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 &parameters);
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 &parameters);
ref<value> callAsMethod(ref<value> instance,parameter_list const &parameters);
ref<value> construct(parameter_list const &parameters);
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 &parameters) const;
ref<value> callAsMethod(ref<value> instance,parameter_list const &parameters);
ref<value> construct(parameter_list const &parameters);
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 &parameters) 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 &parameters);
};
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 &parameters);
};
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 &parameters);
};
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 &parameters);
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 &parameters);
};
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 &parameters);
};
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 &parameters);
};
// 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

62
simgear/interpreter/ixlib_numconv.hh
View File

@ -1,62 +0,0 @@
// ----------------------------------------------------------------------------
// 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

127
simgear/interpreter/ixlib_numeric.hh
View File

@ -1,127 +0,0 @@
// ----------------------------------------------------------------------------
// 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

82
simgear/interpreter/ixlib_random.hh
View File

@ -1,82 +0,0 @@
// ----------------------------------------------------------------------------
// 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

493
simgear/interpreter/ixlib_re.hh
View File

@ -1,493 +0,0 @@
// ----------------------------------------------------------------------------
// 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

652
simgear/interpreter/ixlib_re_impl.hh
View File

@ -1,652 +0,0 @@
// ----------------------------------------------------------------------------
// 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;
}

24
simgear/interpreter/ixlib_scanjs.hh
View File

@ -1,24 +0,0 @@
// ----------------------------------------------------------------------------
// 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

75
simgear/interpreter/ixlib_scanner.hh
View File

@ -1,75 +0,0 @@
// ----------------------------------------------------------------------------
// 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

64
simgear/interpreter/ixlib_string.hh
View File

@ -1,64 +0,0 @@
// ----------------------------------------------------------------------------
// 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

85
simgear/interpreter/ixlib_token_javascript.hh
View File

@ -1,85 +0,0 @@
// ----------------------------------------------------------------------------
// 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

25
simgear/interpreter/ixlib_token_lex.hh
View File

@ -1,25 +0,0 @@
// ----------------------------------------------------------------------------
// 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

201
simgear/interpreter/js_array.cc
View File

@ -1,201 +0,0 @@
// ----------------------------------------------------------------------------
// 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 &parameters) {
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 &parameters) {
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();
}
}

216
simgear/interpreter/js_declaration.cc
View File

@ -1,216 +0,0 @@
// ----------------------------------------------------------------------------
// 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);
}

310
simgear/interpreter/js_expression.cc
View File

@ -1,310 +0,0 @@
// ----------------------------------------------------------------------------
// 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
}

413
simgear/interpreter/js_instruction.cc
View File

@ -1,413 +0,0 @@
// ----------------------------------------------------------------------------
// 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);
}

1133
simgear/interpreter/js_interpreter.cc
View File

File diff suppressed because it is too large Load Diff

259
simgear/interpreter/js_library.cc
View File

@ -1,259 +0,0 @@
// ----------------------------------------------------------------------------
// 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 &parameters);
};
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 &parameters);
};
}
// eval -----------------------------------------------------------------------
ref<value>
eval::
call(parameter_list const &parameters) {
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 &parameters) {
#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);
}

1967
simgear/interpreter/js_value.cc
View File

File diff suppressed because it is too large Load Diff

2031
simgear/interpreter/lex.javascript.cc
View File

File diff suppressed because it is too large Load Diff

168
simgear/interpreter/lex.javascript.yy
View File

@ -1,168 +0,0 @@
/* -------- 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()))

41
simgear/interpreter/main.cc
View File

@ -1,41 +0,0 @@
#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;
}

144
simgear/interpreter/numconv.cc
View File

@ -1,144 +0,0 @@
// ----------------------------------------------------------------------------
// 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);
}
}

38
simgear/interpreter/numeric.cc
View File

@ -1,38 +0,0 @@
// ----------------------------------------------------------------------------
// 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;
}

427
simgear/interpreter/re.cc
View File

@ -1,427 +0,0 @@
// ----------------------------------------------------------------------------
// 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;
}

108
simgear/interpreter/scanner.cc
View File

@ -1,108 +0,0 @@
// ----------------------------------------------------------------------------
// 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);
}

317
simgear/interpreter/string.cc
View File

@ -1,317 +0,0 @@
// ----------------------------------------------------------------------------
// 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;
}