Updated dsp/dsw files for MSVC.

be loaded 5 times! for a lot of wasted texture RAM.  Thanks to Erik H. for
noticing the problem.

.cvsignore

@@ -2,6 +2,7 @@ Makefile
 Makefile.in
 SimGear.spec
 aclocal.m4
+autom4te.cache
 config.cache
 config.log
 config.status

Doxyfile

@@ -22,7 +22,7 @@ PROJECT_NAME           = SimGear
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = 0.0.19pre2
+PROJECT_NUMBER         = 0.3.2
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 
@@ -64,14 +64,14 @@ EXTRACT_STATIC         = NO
 # various overviews, but no documentation section is generated. 
 # This option has no effect if EXTRACT_ALL is enabled. 
 
-HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_MEMBERS     = YES
 
 # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
 # undocumented classes that are normally visible in the class hierarchy. 
 # If set to NO (the default) these class will be included in the various 
 # overviews. This option has no effect if EXTRACT_ALL is enabled. 
 
-HIDE_UNDOC_CLASSES     = NO
+HIDE_UNDOC_CLASSES     = YES
 
 # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
 # include brief member descriptions after the members that are listed in 
@@ -298,6 +298,7 @@ WARN_LOGFILE           =
 # with spaces. 
 
 INPUT                  = \
+        DoxygenMain.cxx \
 	simgear/bucket \
 	simgear/compiler.h \
 	simgear/constants.h \
@@ -308,12 +309,11 @@ INPUT                  = \
 	simgear/math \
 	simgear/misc \
 	simgear/route \
+	simgear/scene \
 	simgear/screen \
 	simgear/serial \
 	simgear/sg_inlines.h \
 	simgear/sg_traits.hxx \
-	simgear/sg_zlib.h \
-	simgear/sky \
 	simgear/threads \
 	simgear/timing \
 	simgear/xml
@@ -335,7 +335,7 @@ RECURSIVE              = YES
 # excluded from the INPUT source files. This way you can easily exclude a 
 # subdirectory from a directory tree whose root is specified with the INPUT tag. 
 
-EXCLUDE                = simgear/metakit simgear/zlib
+EXCLUDE                = simgear/scene/sky/clouds3d
 
 # If the value of the INPUT tag contains directories, you can use the 
 # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
@@ -385,7 +385,7 @@ FILTER_SOURCE_FILES    = NO
 # of all compounds will be generated. Enable this if the project 
 # contains a lot of classes, structs, unions or interfaces. 
 
-ALPHABETICAL_INDEX     = NO
+ALPHABETICAL_INDEX     = YES
 
 # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
 # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
@@ -514,7 +514,7 @@ COMPACT_LATEX          = NO
 # by the printer. Possible values are: a4, a4wide, letter, legal and 
 # executive. If left blank a4wide will be used. 
 
-PAPER_TYPE             = a4wide
+PAPER_TYPE             = letter
 
 # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX 
 # packages that should be included in the LaTeX output. 

DoxygenMain.cxx

@@ -0,0 +1,78 @@
+/* This is a dummy code file that only contains doxygen main page
+   documentation.  It has a .cxx extension so that emacs will happily
+   autoindent correctly. */
+
+/** \mainpage SimGear
+ * Simulation, Visualization, and Game development libraries.
+
+ * \section intro Introduction
+ *
+ * SimGear is a collection of libraries which provide a variety of
+ * functionality useful for building simulations, visualizations, and
+ * even games.  All the SimGear code is designed to be portable across
+ * a wide variety of platforms and compilers.  It has primarily been
+ * developed in support of the FlightGear project, but as development
+ * moves forward, we are generalizing the code to make more of it
+ * useful for other types of applications.
+ *
+ * Some of the functionality provide includes
+ *
+ * - Compiler and platform abstractions for many tricky differences.
+ * - A whole earth tiling/indexing scheme.
+ * - A console debugging output scheme that tracks severity and
+ *   category that can be completely compiled out for a final build release.
+ * - Code to manage "real" time and time zones.
+ * - Code to calculate accurate positions of sun, moon, stars, and
+ *   planets for a given time, date, season, earth location, etc.
+ * - Simple serial, file, and network I/O abstractions
+ * - Code to calculate magnetic variation.
+ * - A variety of coordinate conversion, vector, matrix type math routines.
+ * - An abstraction to hide platform dependent path naming schemes.
+ * - A C++ streams wrapper to handle compress input/output streams.
+ * - An optimized "property manager" which associates ascii property
+ *   names with their corresponding value.  This can be a great way to build
+ *   loose linkages between modules, or build linkages/connections that can
+ *   be determined from config files or at runtime.
+ * - Scene management and drawing routines:
+ *   - material property management
+ *   - object management
+ *   - terrain tile management and paging
+ *   - sky dome rendering (with ephemeral objects)
+ * - Code to handle screen dumps (and ultra-hires tile rendered screen dumps)
+ * - A sound effects manager.
+ * - A threading abstraction.
+ * - A simple but highly functional XML parser that interfaces nicely
+ *   with the property manager.
+
+ * \section supports Supported Platforms
+ * SimGear has been built on the following platforms:
+ *
+ *   - Linux (x86)
+ *   - Windows (MSVC, Cygwin, Mingwin)
+ *   - SGI (native compilers)
+ *   - Mac OS X
+ *   - FreeBSD
+ 
+ * \section depends Dependencies
+ *
+ * SimGear depends on several other open source packages.  These must
+ * be installed before SimGear can be installed:
+ *
+ *   - glut and opengl
+ *   - plib (http://plib.sf.net)
+ *   - metakit
+ *   - zlib
+ *   - libjpeg (optional)
+ *   - pthread (optional)
+ 
+ * \section license Licensing
+ *
+ * SimGear is licensed under the terms of the LGPL
+
+ * \section install Installation
+ *
+ * \subsection step1 Step 1: Opening the box
+ *  
+ * etc...
+ */
+

Makefile.am

@@ -1,7 +1,7 @@
 EXTRA_DIST = \
 	acinclude.m4 \
 	autogen.sh \
-	mksymlinks.sh \
+	DoxygenMain.cxx
 	README.MSVC \
 	README.metakit \
 	README.zlib \

NEWS

@@ -1,3 +1,51 @@
+New in 0.3.2
+* June 2, 2003
+
+* Moved quite a bit of low level model management and "state"
+  management code from FlightGear into SimGear and did a substantial
+  amount of restructuring and dependency clean up in the process.
+  Created a "scene" subdirectory with sub-subdirectories for material
+  management, basic model and model animation management, sky
+  rendering, and low level loaders for the "TerraGear" tile object format.
+* Removed support of the flat shaded and non-textured material
+  property varients.  You can still do these things, but extra states
+  are no longer set up automatically.
+* Removed 3d clouds from the default build ... these need a maintainer
+  or better yet, a complete plib-based rewrite.
+* Moved the FlightGear sound effect manager code over to SimGear.
+* Updated the cloud layer surface to better follow the inverted bowl
+  shape.
+* Much work on cloud/sky coloring, and also much work on
+  sunset/sunrise coloring.
+* Fixed an obscure bug in cloud texture loading which caused each
+  cloud texture to be loaded 5 times.  Ouch!
+* Various class and function renaming to make them better fit into the
+  standard SimGear naming scheme.
+* Added some additional convenience functions to the SGPath class.
+* Upgraded the distributed version of metakit.
+* FreeBSD fixes.
+* Irix fixes (better STL/ISO C++ header support.)
+* Mingwin fixes.
+* Better MacOS support
+* MSVC fixes.
+
+
+New in 0.3.1
+* December 4, 2002
+
+* Fix a major packaging blunder with several missing files.
+
+
+New in 0.3.0
+* December 3, 2002
+
+* removed interpreter subdir
+* NOMINAX fix for Cygwin/gcc-3.2
+* Added some prototype 3d clouds based on Mark Harris's demos.
+* Simplified the command manager interface
+* Allow an "include" attribute on root PropertyList element.
+
+
 New in 0.2.0
 * September 6, 2002
 

TODO

@@ -0,0 +1 @@
+03/25/2001 - Resolve location of Sky dome implimentation documentation.

configure.ac

@@ -1,16 +1,16 @@
-dnl Process this file with aclocal ; automake -a ; autoconf to produce a 
-dnl working configure script.
+dnl Process this file with autoget.sh to produce a working configure
+dnl script.
 dnl
 dnl $Id$
 
 AC_INIT
 AC_CONFIG_SRCDIR([simgear/bucket/newbucket.cxx])
 
-# Require at least automake 2.52
+dnl Require at least automake 2.52
 AC_PREREQ(2.52)
 
 dnl Initialize the automake stuff
-AM_INIT_AUTOMAKE(SimGear, 0.2.0)
+AM_INIT_AUTOMAKE(SimGear, 0.3.2)
 
 dnl Specify KAI C++ compiler and flags.
 dnl Borrowed with slight modification from blitz distribution.
@@ -38,21 +38,24 @@ AC_PROG_RANLIB
 AC_PROG_INSTALL
 AC_PROG_LN_S
 
+dnl set the $host variable based on local machine/os
+AC_CANONICAL_HOST
 
-# Used on the Irix platform
+dnl Used on the Irix platform
 AR="ar"
 ARFLAGS="cru"
-OS=`uname -s`
-if test "$OS" = "IRIX" -o "$OS" = "IRIX64"; then
+case "${host}" in
+*-*-irix*)
     if test "$CXX" = "CC"; then
         AR="CC -ar"
         ARFLAGS="-o"
+        CXXFLAGS="$CXXFLAGS -I$(top_srcdir)/simgear/compatibility"
     fi
-fi
+    ;;
+esac
 AC_SUBST(AR)
 AC_SUBST(ARFLAGS)
 
-
 if echo $includedir | egrep "simgear$" > /dev/null; then
     echo "includedir is" $includedir "libdir is" $libdir
 else
@@ -60,8 +63,7 @@ else
     echo "includedir changed to" $includedir "libdir is" $libdir
 fi
          
-# set logging default value
-# with_logging=yes
+dnl set logging; default value of with_logging=yes
 AC_ARG_WITH(logging, [  --with-logging          Include logging output (default)])
 if test "x$with_logging" = "xno" ; then
     AC_DEFINE([FG_NDEBUG], 1, [Define for no logging output])
@@ -90,38 +92,26 @@ fi
 AM_CONDITIONAL(ENABLE_JPEG_SERVER, test "x$with_jpeg_factory" = "xyes")
 
 
-dnl Check for MS Windows environment
-AC_CHECK_HEADER(windows.h)
+dnl Determine an extra directories to add to include/lib search paths
+case "${host}" in
+*-apple-darwin* | *-*-mingw32*)
+    echo no EXTRA_DIRS for $host
+    ;;
 
-AC_EGREP_CPP(yes,
-[#ifdef __MINGW32__
- yes
- #endif
-],is_mingw=yes, is_mingw=no)
-
-echo "IS_MINGW = $is_mingw"
-AM_CONDITIONAL(IS_MINGW, test "x$is_mingw" = "xyes")
-
-AC_EGREP_CPP(yes,
-[#ifdef __CYGWIN__
- yes
- #endif
-],is_cygwin=yes, is_cygwin=no)
-
-echo "IS_CYGWIN = $is_cygwin"
-AM_CONDITIONAL(IS_CYGWIN, test "x$is_cygwin" = "xyes")
-
-if test "x$HOSTTYPE" != "xmacintosh" -a "x$is_mingw" != "xyes"; then
-    dnl extra library and include directories
-    EXTRA_DIRS="/usr/local /usr/X11R6"
-
-    if test -d /opt/X11R6 ; then
-        EXTRA_DIRS="$EXTRA_DIRS /opt/X11R6"
+*)
+    if test -d /usr/X11R6 ; then
+        EXTRA_DIR1="/usr/X11R6"
     fi
-fi
+    if test -d /opt/X11R6 ; then
+        EXTRA_DIR2="/opt/X11R6"
+    fi
+    EXTRA_DIRS="$EXTRA_DIR1 $EXTRA_DIR2"
+    ;;
 
+esac
 wi_EXTRA_DIRS(no, ${EXTRA_DIRS})
 
+
 dnl Using AM_CONDITIONAL is a step out of the protected little 
 dnl automake fold so it is potentially dangerous.  But, we are
 dnl beginning to run into cases where the standard checks are not
@@ -129,11 +119,18 @@ dnl enough.  AM_CONDITIONALS are then referenced to conditionally
 dnl build a Makefile.in from a Makefile.am which lets us define custom
 dnl includes, compile alternative source files, etc.
 
-dnl X11 might be installed on Mac OS X, don't want to use it if it is.
-if test "x$HOSTTYPE" != "xmacintosh" ; then
-    dnl Check for X11 (fancy)
+dnl X11 might be installed on Mac OS X or cygwin/mingwin, we don't want
+dnl to use it if it is.
+case "${host}" in
+*-apple-darwin* | *-*-cygwin* | *-*-mingw32*)
+    echo no fancy X11 check
+    ;;
+
+*)
     AC_PATH_XTRA
-fi
+    ;;
+
+esac
 
 dnl Checks for libraries.
 
@@ -150,12 +147,74 @@ if test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h
     CXXFLAGS="$CXXFLAGS -D_REENTRANT"
     CFLAGS="$CFLAGS -D_REENTRANT"
 fi
+if test "x$ac_cv_lib_pthread_pthread_exit" != "xyes" -a "x$ac_cv_header_pthread_h" = "xyes"; then
+    dnl FreeBSD: System has pthread.h, but -lpthread library check
+    dnl fails.  See if we need -pthread instead of -lpthread and look
+    dnl for the functions in libc_r.
+    save_CXXFLAGS="$CXXFLAGS"
+    save_CFLAGS="$CFLAGS"
+    CXXFLAGS="-pthread $CXXFLAGS"
+    CFLAGS="-pthread $FLAGS"
+    save_LIBS=$LIBS
+    AC_CHECK_LIB(c_r, pthread_exit)
+    if test "x$ac_cv_lib_c_r_pthread_exit" != "xyes"; then
+	CXXFLAGS=$save_CXXFLAGS
+	CFLAGS=$save_CFLAGS
+    else
+	dnl This is cheating a bit. pthread_exit comes with using -pthread, not -lpthread
+	ac_cv_lib_pthread_pthread_exit="yes"
+    fi
+    LIBS=$save_LIBS
+fi
 AM_CONDITIONAL(HAVE_THREADS, test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h" = "xyes")
 
 AC_CHECK_LIB(socket, socket)
 
-dnl X11 might be installed, but we don't want to use it for OSX -dw-
-if test "x$HOSTTYPE" != "xmacintosh" ; then
+dnl check for glut location
+AC_CHECK_HEADER(GL/glut.h)
+if test "x$ac_cv_header_GL_glut_h" = "xyes"; then
+    AC_DEFINE([GLUT_H], "GL/glut.h", [Define as glut.h include location])
+else
+    AC_CHECK_HEADER(GLUT/glut.h)
+    if test "x$ac_cv_header_GLUT_glut_h" = "xyes"; then
+        AC_DEFINE([GLUT_H], "GLUT/glut.h", [Define as glut.h include location])
+    else
+        echo "Neither GL/glut.h nor GLUT/glut.h found.  Cannot continue"
+        exit
+    fi
+fi
+
+dnl check for OpenGL related libraries
+case "${host}" in
+*-*-cygwin* | *-*-mingw32*)
+    dnl CygWin under Windoze.
+
+    echo Win32 specific hacks...
+    AC_DEFINE([WIN32], 1, [Define for Win32 platforms])
+    AC_DEFINE([NOMINMAX], 1, [Define for Win32 platforms])
+
+    LIBS="$LIBS -lglut32 -lglu32 -lopengl32"
+    LIBS="$LIBS -luser32 -lgdi32 -lwinmm"
+
+    dnl add -lwsock32 for mingwin
+    case "${host}" in
+    *-*-mingw32*)
+        base_LIBS="$base_LIBS -lws2_32"
+        ;;
+    esac
+
+    echo "Will link apps with $LIBS"
+    ;;
+
+*-apple-darwin*)
+    dnl Mac OS X
+
+    LIBS="$LIBS -framework GLUT -framework OpenGL -framework Carbon -lobjc"
+    ;;
+
+*)
+    dnl X-Windows based machines
+
     AC_CHECK_LIB(X11, XCreateWindow)
     AC_CHECK_LIB(Xext, XShmCreateImage)
     AC_CHECK_LIB(Xi, XGetExtensionVersion)
@@ -163,16 +222,7 @@ if test "x$HOSTTYPE" != "xmacintosh" ; then
     AC_CHECK_LIB(SM, SmcOpenConnection)
     AC_CHECK_LIB(Xt, XtMalloc)
     AC_CHECK_LIB(Xmu, XmuLookupStandardColormap)
-fi
-
-dnl check for OpenGL related libraries
-
-if test "x$HOSTTYPE" = "xmacintosh" ; then
-    dnl Macintosh OSX
-    LIBS="$LIBS -framework OpenGL -framework GLUT"
-elif test "x$ac_cv_header_windows_h" != "xyes" ; then
-    dnl Reasonable stuff for X-Windows based machines
-
+    
     AC_CHECK_LIB(GLcore, glNewList)
     if test "x$ac_cv_lib_GLcore_glNewList" = "xno" ; then
 	dnl if no GLcore, check for GL
@@ -201,61 +251,10 @@ elif test "x$ac_cv_header_windows_h" != "xyes" ; then
 	AC_CHECK_LIB(MesaGLU, gluLookAt)
     fi
 
-    dnl check for glut
-    AC_CHECK_LIB(glut, glutGetModifiers)
+    LIBS="$LIBS -lglut"
+    ;;
 
-    dnl test for glutGameModeString, but avoid adding glut a second time into
-    dnl the list of libraries
-    save_LIBS="$LIBS"
-    AC_CHECK_LIB(glut, glutGameModeString)
-    LIBS="$save_LIBS"
-else
-    dnl Win32 libs
-
-    echo Win32 specific hacks...
-    AC_DEFINE([WIN32], 1, [Define for Win32 platforms])
-
-    dnl just define these to true and hope for the best
-    ac_cv_lib_glut_glutGetModifiers="yes"
-    ac_cv_lib_glut_glutGameModeString="yes"
-
-    if test "x$with_sgi_opengl" = "xyes" ; then
-        echo "Building with glut.dll, glu.dll, and opengl.dll"
-	WIN32_GLUT=glut
-	WIN32_GLU=glu
-	WIN32_OPENGL=opengl
-    else 
-	echo "Building with glut32.dll, glu32.dll, and opengl32.dll"
-	WIN32_GLUT=glut32
-	WIN32_GLU=glu32
-	WIN32_OPENGL=opengl32
-    fi
-
-    LIBS="$LIBS -l${WIN32_GLUT} -l${WIN32_GLU} -l${WIN32_OPENGL}"
-    LIBS="$LIBS -luser32 -lgdi32"
-    if test "x$is_mingw" = "xyes" ; then
-        EXTRA_DIRS="${EXTRA_DIRS}"
-    fi
-    echo "Will link apps with $LIBS"
-fi
-
-if test "x$ac_cv_lib_glut_glutGetModifiers" = "xno"; then
-    echo 
-    echo "Unable to find the necessary OpenGL or GLUT libraries."
-    echo "See config.log for automated test details and results ..."
-    exit 1
-fi
-
-if test "x$ac_cv_lib_glut_glutGameModeString" = "xno"; then
-    echo
-    echo "Your version of glut doesn't support game mode."
-    echo "You need to install the latest version of glut.  If your"
-    echo "distribution doesn't provide a newer version, you can get the source"
-    echo "code from:"
-    echo
-    echo "    http://reality.sgi.com/opengl/glut3/glut3.html"
-    exit 1
-fi
+esac
 
 opengl_LIBS="$LIBS"
 LIBS="$base_LIBS"
@@ -263,7 +262,9 @@ LIBS="$base_LIBS"
 AC_SUBST(base_LIBS)
 AC_SUBST(opengl_LIBS)
 
-AM_CONDITIONAL(HAVE_XWINDOWS, test "x$ac_cv_lib_X11_XCreateWindow" = "xyes" )
+dnl Check for MS Windows environment
+AC_CHECK_HEADER(windows.h)
+AM_CONDITIONAL(EXTGL_NEEDED, test "x$ac_cv_header_windows_h" = "xyes")
 
 # The following are C++ items that need to be tested for with the c++
 # compiler
@@ -306,33 +307,79 @@ int main() {
   AC_MSG_RESULT(yes)
 )
 
-dnl Check for system installed metakit
+dnl Check for MetaKit
 AC_CHECK_HEADER(mk4.h)
 if test "x$ac_cv_header_mk4_h" != "xyes"; then
-    echo 
-    echo "Metakit not found, you will need to install this first."
-    echo "Please read the README.metakit for more information."
+    echo
+    echo "MetaKit library not found."
+    echo
+    echo "If your OS does not provide an installable package for MetaKit"
+    echo "you will have to compile and install it first yourself.  A copy"
+    echo "of metakit-$(VERSION).tar.gz is included with SimGear.  You will"
+    echo "have to untar this source code, and follow its included instructions"
+    echo "to compile and install on your system."
+    echo
+    echo "configure aborted."
     exit
 fi
 
-AC_LANG_POP
+AC_MSG_CHECKING([for metakit 2.4.3 or newer])
+saved_LIBS="$LIBS"
+LIBS="$saved_LIBS -lmk4"
+AC_TRY_RUN([
+#include <mk4.h>
 
-dnl Specify if we want logging (testing build) or not (release build)
+#define MIN_MK4_VERSION 243
+
+int main() {
+    int major, minor, micro;
+
+    if ( d4_MetaKitLibraryVersion < MIN_MK4_VERSION ) {
+	 return -1;
+    }
+
+    return 0;
+}
+
+],
+  AC_MSG_RESULT(yes),
+  [AC_MSG_RESULT(wrong version);
+   AC_MSG_ERROR([
+
+Install metakit 2.4.3 or later first.
+
+Or, the compiler may not be finding your libmk4.so library.
+Please check the config.log file for specific details of the
+failure if you believe you have the correct metakit version.
+Also, look up this issue in the FlightGear FAQ.])],
+  AC_MSG_RESULT(yes)
+)
+
+LIBS="$saved_LIBS"
+
+AC_LANG_POP
 
 dnl Check for system installed zlib
 AC_CHECK_HEADER(zlib.h)
 if test "x$ac_cv_header_zlib_h" != "xyes"; then
-    echo 
-    echo "zlib not found, you will need to install this first."
-    echo "Please read the README.zlib for more information."
-    exit
+    echo
+    echo "zlib library not found."
+    echo
+    echo "If your OS does not provide an installable package for zlib"
+    echo "you will have to compile and install it first yourself.  A copy"
+    echo "of zlib-1.1.4.tar.gz is included with SimGear.  You will"
+    echo "have to untar this source code, and follow its included instructions"
+    echo "to compile and install on your system."
+    echo
+    echo "configure aborted."
+    echo
 fi
 
 dnl Checks for header files.
 AC_HEADER_STDC
 AC_CHECK_HEADERS( \
 	fcntl.h getopt.h malloc.h memory.h stdint.h stdlib.h sys/param.h \
-	sys/stat.h sys/time.h sys/timeb.h unistd.h windows.h winbase.h values.h )
+	sys/stat.h sys/time.h sys/timeb.h unistd.h values.h )
 
 if test "x$ac_cv_header_stdint_h" = "xyes"; then
     AC_DEFINE([HAVE_STDINT_H], 1, [Define if stdint.h exists])
@@ -347,7 +394,8 @@ AC_STRUCT_TM
 dnl Checks for library functions.
 AC_TYPE_SIGNAL
 AC_FUNC_VPRINTF
-AC_CHECK_FUNCS( ftime gettimeofday timegm memcpy bcopy mktime strstr rand \
+AC_CHECK_FUNCS( \
+        ftime gettimeofday timegm memcpy bcopy mktime strstr rand \
 	random drand48 setitimer getitimer signal GetLocalTime rint getrusage )
 
 AM_CONFIG_HEADER(simgear/simgear_config.h)
@@ -358,19 +406,25 @@ AC_CONFIG_FILES([ \
 	src-libs/Makefile \
 	simgear/Makefile \
 	simgear/version.h \
+	simgear/compatibility/Makefile \
 	simgear/bucket/Makefile \
 	simgear/debug/Makefile \
 	simgear/ephemeris/Makefile \
-	simgear/interpreter/Makefile \
 	simgear/io/Makefile \
 	simgear/magvar/Makefile \
 	simgear/math/Makefile \
 	simgear/metar/Makefile \
 	simgear/misc/Makefile \
+	simgear/props/Makefile \
 	simgear/route/Makefile \
+	simgear/scene/Makefile \
+	simgear/scene/material/Makefile \
+	simgear/scene/model/Makefile \
+	simgear/scene/sky/Makefile \
+	simgear/scene/tgdb/Makefile \
 	simgear/screen/Makefile \
 	simgear/serial/Makefile \
-	simgear/sky/Makefile \
+	simgear/sound/Makefile \
 	simgear/threads/Makefile \
 	simgear/timing/Makefile \
 	simgear/xgl/Makefile \
@@ -391,9 +445,16 @@ else
     echo "Debug messages: yes"
 fi
 
-echo -n "Automake version: ($AUTO_MAKE_VERSION) "
+echo -n "Automake version: "
 automake --version | head -1
 
+if test "x$ac_cv_header_GL_glut_h" = "xyes"; then
+   echo "With GL/glut.h"
+fi
+if test "x$ac_cv_header_GLUT_glut_h" = "xyes"; then
+   echo "With GLUT/glut.h"
+fi
+
 if test "x$with_jpeg_factory" = "xyes"; then
    echo "With JPEG Factory support"
 else
@@ -405,3 +466,4 @@ if test "x$ac_cv_lib_pthread_pthread_exit" = "xyes" -a "x$ac_cv_header_pthread_h
 else
    echo "Threads: no threads (pthread lib not found.)"
 fi
+

mksymlinks.sh

@@ -1,42 +0,0 @@
-#! /bin/sh
-
-echo ""
-echo "running $0 to rebuild simgear include links"
-
-# toast the old directory
-rm -rf src/simgear
-mkdir src/simgear
-mkdir src/simgear/bucket
-mkdir src/simgear/debug
-mkdir src/simgear/math
-mkdir src/simgear/misc
-mkdir src/simgear/screen
-mkdir src/simgear/serial
-mkdir src/simgear/xgl
-mkdir src/simgear/zlib
-
-# build new links
-ln -s ../include/compiler.h src/simgear/compiler.h
-ln -s ../include/constants.h src/simgear/constants.h
-ln -s ../include/fg_traits.hxx src/simgear/fg_traits.hxx
-ln -s ../include/fg_zlib.h src/simgear/fg_zlib.h
-ln -s ../include/version.h src/simgear/version.h
-
-ln -s ../../bucket/newbucket.hxx src/simgear/bucket/newbucket.hxx
-
-ln -s ../../debug/debug_types.h src/simgear/debug/debug_types.h
-ln -s ../../debug/logstream.hxx src/simgear/debug/logstream.hxx
-
-ln -s ../../math/fg_memory.h src/simgear/math/fg_memory.h
-ln -s ../../math/fg_types.hxx src/simgear/math/fg_types.hxx
-ln -s ../../math/point3d.hxx src/simgear/math/point3d.hxx
-ln -s ../../math/polar3d.hxx src/simgear/math/polar3d.hxx
-
-ln -s ../../misc/fgpath.hxx src/simgear/misc/fgpath.hxx
-ln -s ../../misc/fgstream.hxx src/simgear/misc/fgstream.hxx
-ln -s ../../misc/zfstream.hxx src/simgear/misc/zfstream.hxx
-
-ln -s ../../xgl/xgl.h src/simgear/xgl/xgl.h
-
-ln -s ../../zlib/zlib.h src/simgear/zlib/zlib.h
-ln -s ../../zlib/zconf.h src/simgear/zlib/zconf.h

simgear/.cvsignore

@@ -4,4 +4,5 @@ simgear_config.h
 simgear_config.h.in
 stamp-h
 stamp-h.in
+stamp-h1
 version.h

simgear/Makefile.am

@@ -10,9 +10,10 @@ METAR_DIRS = metar
 EXTRA_DIST = simgear_config.h.vc5 version.h.in
 
 include_HEADERS = \
-	compiler.h constants.h sg_inlines.h sg_traits.hxx sg_zlib.h version.h
+	compiler.h constants.h sg_inlines.h sg_traits.hxx version.h
 
 SUBDIRS = \
+	compatibility \
 	xml \
 	debug \
 	misc \
@@ -22,12 +23,14 @@ SUBDIRS = \
 	magvar \
 	math \
 	$(METAR_DIRS) \
+	props \
 	route \
+	scene \
 	screen \
 	serial \
-	sky \
+	sound \
 	$(SGTHREAD_DIR) \
 	timing \
 	xgl
 
-DIST_SUBDIRS = $(SUBDIRS) interpreter
+DIST_SUBDIRS = $(SUBDIRS)

simgear/bucket/newbucket.cxx

@@ -24,6 +24,10 @@
  **************************************************************************/
 
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
 #include <math.h>
 
 #include <simgear/misc/sg_path.hxx>

simgear/bucket/newbucket.hxx

@@ -54,10 +54,7 @@ SG_USING_STD(fabs);
 #include STL_STRING
 
 SG_USING_STD(string);
-
-#if ! defined( SG_HAVE_NATIVE_SGI_COMPILERS )
 SG_USING_STD(ostream);
-#endif
 
 
 /**

simgear/compatibility/.cvsignore

@@ -0,0 +1,2 @@
+Makefile
+Makefile.in

simgear/compatibility/Makefile.am

@@ -0,0 +1,31 @@
+includedir = @includedir@/compatibility
+
+EXTRA_DIST = README
+
+include_HEADERS	= \
+	cfloat \
+	csetjmp \
+	cstdio \
+	cwchar \
+	iostream \
+	strstream \
+	sstream \
+	cassert \
+	climits \
+	csignal \
+	cstdlib \
+	cwctype \
+	istream \
+	cctype \
+	clocale \
+	cstdarg \
+	cstring \
+	fstream \
+	iterator \
+	cerrno \
+	cmath \
+	cstddef \
+	ctime \
+	iomanip \
+	new \
+	streambuf

simgear/compatibility/README

@@ -0,0 +1,9 @@
+
+The following header files where taken from the boost clib package
+(http://www.boost.org):
+
+cassert climits  csignal   cstdlib   cwctype
+cctype  clocale  cstdarg   cstring
+cerrno  cmath    cstddef   ctime
+cfloat  csetjmp  cstdio    cwchar
+

simgear/compatibility/cassert

@@ -0,0 +1,10 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CASSERT_HEADER
+#define __CASSERT_HEADER
+
+#include <assert.h>
+
+#endif // CASSERT_HEADER

simgear/compatibility/cctype

@@ -0,0 +1,26 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CCTYPE_HEADER
+#define __CCTYPE_HEADER
+
+#include <ctype.h>
+
+namespace std {
+  using ::isalnum;
+  using ::isdigit;
+  using ::isprint;
+  using ::isupper;
+  using ::tolower;
+  using ::isalpha;
+  using ::isgraph;
+  using ::ispunct;
+  using ::isxdigit;
+  using ::toupper;
+  using ::iscntrl;
+  using ::islower;
+  using ::isspace;
+}
+
+#endif // CCTYPE_HEADER

simgear/compatibility/cerrno

@@ -0,0 +1,10 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CERRNO_HEADER
+#define __CERRNO_HEADER
+
+#include <errno.h>
+
+#endif // CERRNO_HEADER

simgear/compatibility/cfloat

@@ -0,0 +1,10 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CFLOAT_HEADER
+#define __CFLOAT_HEADER
+
+#include <float.h>
+
+#endif // CFLOAT_HEADER

simgear/compatibility/climits

@@ -0,0 +1,10 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CLIMITS_HEADER
+#define __CLIMITS_HEADER
+
+#include <limits.h>
+
+#endif // CLIMITS_HEADER

simgear/compatibility/clocale

@@ -0,0 +1,16 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CLOCALE_HEADER
+#define __CLOCALE_HEADER
+
+#include <locale.h>
+
+namespace std {
+  using ::lconv;
+  using ::localeconv;
+  using ::setlocale;
+}
+
+#endif // CLOCALE_HEADER

simgear/compatibility/cmath

@@ -0,0 +1,35 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CMATH_HEADER
+#define __CMATH_HEADER
+
+#include <math.h>
+
+namespace std {
+  using ::acos;
+  using ::cos;
+  using ::fmod;
+  using ::modf;
+  using ::tan;
+  using ::asin;
+  using ::cosh;
+  using ::frexp;
+  using ::pow;
+  using ::tanh;
+  using ::atan;
+  using ::exp;
+  using ::ldexp;
+  using ::sin;
+  using ::atan2;
+  using ::fabs;
+  using ::log;
+  using ::sinh;
+  using ::ceil;
+  using ::floor;
+  using ::log10;
+  using ::sqrt;
+}
+
+#endif // CMATH_HEADER

simgear/compatibility/csetjmp

@@ -0,0 +1,15 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSETJMP_HEADER
+#define __CSETJMP_HEADER
+
+#include <setjmp.h>
+
+namespace std {
+  using ::jmp_buf;
+  using ::longjmp;
+}
+
+#endif // CSETJMP_HEADER

simgear/compatibility/csignal

@@ -0,0 +1,16 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSIGNAL_HEADER
+#define __CSIGNAL_HEADER
+
+#include <signal.h>
+
+namespace std {
+  using ::sig_atomic_t;
+  using ::raise;
+  using ::signal;
+}
+
+#endif // CSIGNAL_HEADER

simgear/compatibility/cstdarg

@@ -0,0 +1,14 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTDARG_HEADER
+#define __CSTDARG_HEADER
+
+#include <stdarg.h>
+
+namespace std {
+  using ::va_list;
+}
+
+#endif // CSTDARG_HEADER

simgear/compatibility/cstddef

@@ -0,0 +1,15 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTDDEF_HEADER
+#define __CSTDDEF_HEADER
+
+#include <stddef.h>
+
+namespace std {
+  using ::ptrdiff_t;
+  using ::size_t;
+}
+
+#endif // CSTDDEF_HEADER

simgear/compatibility/cstdio

@@ -0,0 +1,57 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTDIO_HEADER
+#define __CSTDIO_HEADER
+
+#include <stdio.h>
+
+namespace std {
+  using ::FILE;
+  using ::fpos_t;
+  using ::size_t;
+  using ::clearerr;
+  using ::fgets;
+  using ::fscanf;
+  using ::gets;
+  using ::rename;
+  using ::tmpfile;
+  using ::fclose;
+  using ::fopen;
+  using ::fseek;
+  using ::perror;
+  using ::rewind;
+  using ::tmpnam;
+  using ::feof;
+  using ::fprintf;
+  using ::fsetpos;
+  using ::printf;
+  using ::scanf;
+  using ::ungetc;
+  using ::ferror;
+  using ::fputc;
+  using ::ftell;
+  using ::putc;
+  using ::setbuf;
+  using ::vfprintf;
+  using ::fflush;
+  using ::fputs;
+  using ::fwrite;
+  using ::putchar;
+  using ::setvbuf;
+  using ::vprintf;
+  using ::fgetc;
+  using ::fread;
+  using ::getc;
+  using ::puts;
+  using ::sprintf;
+  using ::vsprintf;
+  using ::fgetpos;
+  using ::freopen;
+  using ::getchar;
+  using ::remove;
+  using ::sscanf;
+}
+
+#endif // CSTDIO_HEADER

simgear/compatibility/cstdlib

@@ -0,0 +1,43 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTDLIB_HEADER
+#define __CSTDLIB_HEADER
+
+#include <stdlib.h>
+
+namespace std {
+  using ::abort;
+  using ::atexit;
+  using ::exit;
+  using ::getenv;
+  using ::system;
+  using ::calloc;
+  using ::malloc;
+  using ::free;
+  using ::realloc;
+  using ::atol;
+  using ::mblen;
+  using ::strtod;
+  using ::wctomb;
+  using ::atof;
+  using ::mbstowcs;
+  using ::strtol;
+  using ::wcstombs;
+  using ::atoi;
+  using ::mbtowc;
+  using ::strtoul;
+  using ::bsearch;
+  using ::qsort;
+  using ::div_t;
+  using ::ldiv_t;
+  using ::abs;
+  using ::labs;
+  using ::srand;
+  using ::div;
+  using ::ldiv;
+  using ::rand;
+}
+
+#endif // CSTDLIB_HEADER

simgear/compatibility/cstring

@@ -0,0 +1,36 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CSTRING_HEADER
+#define __CSTRING_HEADER
+
+#include <string.h>
+
+namespace std {
+  using ::size_t;
+  using ::memchr;
+  using ::strcat;
+  using ::strcspn;
+  using ::strncpy;
+  using ::strtok;
+  using ::memcmp;
+  using ::strchr;
+  using ::strerror;
+  using ::strpbrk;
+  using ::strxfrm;
+  using ::memcpy;
+  using ::strcmp;
+  using ::strlen;
+  using ::strrchr;
+  using ::memmove;
+  using ::strcoll;
+  using ::strncat;
+  using ::strspn;
+  using ::memset;
+  using ::strcpy;
+  using ::strncmp;
+  using ::strstr;
+}
+
+#endif // CSTRING_HEADER

simgear/compatibility/ctime

@@ -0,0 +1,26 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CTIME_HEADER
+#define __CTIME_HEADER
+
+#include <time.h>
+
+namespace std {
+  using ::size_t;
+  using ::clock_t;
+  using ::time_t;
+  using ::tm;
+  using ::asctime;
+  using ::clock;
+  using ::difftime;
+  using ::localtime;
+  using ::strftime;
+  using ::ctime;
+  using ::gmtime;
+  using ::mktime;
+  using ::time;
+}
+
+#endif // CTIME_HEADER

simgear/compatibility/cwchar

@@ -0,0 +1,156 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CWCHAR_HEADER
+#define __CWCHAR_HEADER
+
+#include <wchar.h>
+
+namespace std {
+  using ::mbstate_t;
+  using ::wint_t;
+  using ::size_t;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::btowc;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::getwchar;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::ungetwc;
+#endif
+  using ::wcscpy;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wcsrtombs;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemchr;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::fgetwc;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::mbrlen;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::vfwprintf;
+#endif
+#endif
+  using ::wcscspn;
+  using ::wcsspn;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemcmp;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::fgetws;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::mbrtowc;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::vswprintf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::wcsftime;
+#endif
+  using ::wcsstr;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemcpy;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::fputwc;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::mbsinit;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::vwprintf;
+#endif
+#endif
+  using ::wcslen;
+  using ::wcstod;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemmove;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::fputws;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::mbsrtowcs;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wcrtomb;
+#endif
+  using ::wcsncat;
+  using ::wcstok;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wmemset;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__DECCXX_VER) && __DECCXX_VER <= 60290024)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::fwide;
+#endif
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::putwc;
+#endif
+  using ::wcscat;
+  using ::wcsncmp;
+  using ::wcstol;
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wprintf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::fwprintf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::putwchar;
+#endif
+  using ::wcschr;
+  using ::wcsncpy;
+  using ::wcstoul;
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wscanf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::fwscanf;
+#endif
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::swprintf;
+#endif
+#endif
+  using ::wcscmp;
+  using ::wcspbrk;
+  using ::wcsxfrm;
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+  using ::getwc;
+#endif
+#if !(defined(__linux) && defined(__DECCXX_VER) && __DECCXX_VER <= 60390005)
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::swscanf;
+#endif
+#endif
+  using ::wcscoll;
+  using ::wcsrchr;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wctob;
+#endif
+}
+
+#endif // CWCHAR_HEADER

simgear/compatibility/cwctype

@@ -0,0 +1,39 @@
+// This file is automatically generated. Do not edit.
+// ['../../../libs/compatibility/generate_cpp_c_headers.py']
+// Mon Apr 16 15:16:00 2001 ('PST', 'PDT')
+
+#ifndef __CWCTYPE_HEADER
+#define __CWCTYPE_HEADER
+
+#include <wctype.h>
+
+namespace std {
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wctrans_t;
+#endif
+  using ::wctype_t;
+  using ::wint_t;
+  using ::iswalnum;
+  using ::iswctype;
+  using ::iswlower;
+  using ::iswspace;
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::towctrans;
+#endif
+#if !(defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
+  using ::wctrans;
+#endif
+  using ::iswalpha;
+  using ::iswdigit;
+  using ::iswprint;
+  using ::iswupper;
+  using ::towlower;
+  using ::wctype;
+  using ::iswcntrl;
+  using ::iswgraph;
+  using ::iswpunct;
+  using ::iswxdigit;
+  using ::towupper;
+}
+
+#endif // CWCTYPE_HEADER

simgear/compatibility/fstream

@@ -0,0 +1,19 @@
+
+#ifndef __SG_FSTREAM
+#define __SG_FSTREAM 1
+
+# if defined(sgi) && !defined(__GNUC__)
+
+# include <fstream.h>
+
+  namespace std {
+    using ::fstream;
+    using ::ifstream;
+    using ::ofstream;
+  };
+
+
+# endif
+
+#endif // !__SG_FSTREAM
+

simgear/compatibility/iomanip

@@ -0,0 +1,12 @@
+
+#ifndef __SG_IOMANIP
+#define __SG_IOMANIP 1
+
+# include <iomanip.h>
+
+namespace std {
+   using ::setw;
+};
+
+#endif // !__SG_IOMANIP
+

simgear/compatibility/iostream

@@ -0,0 +1,40 @@
+
+#ifndef __SG_IOSTREAM
+#define __SG_IOSTREAM 1
+
+# include <fstream>
+
+# if defined(sgi) && !defined(__GNUC__)
+
+# include <iostream.h>
+
+  class ios_base : public ios {
+  public:
+
+    typedef int  openmode;
+    typedef int  seekdir;
+
+    enum { binary = 0 };
+  };
+
+  namespace std {
+    using ::cin;
+    using ::cout;
+    using ::cerr;
+    using ::clog;
+    using ::endl;
+
+    using ::ios;
+    using ::ios_base;
+    using ::iostream;
+    using ::istream;
+    using ::ostream;
+
+    using ::dec;
+    using ::hex;
+  };
+
+# endif
+
+#endif // !__SG_IOSTREAM
+

simgear/compatibility/istream

@@ -0,0 +1,17 @@
+
+#ifndef __SG_ISTREAM
+#define __SG_ISTREAM 1
+
+# include <iostream>
+
+# if defined(sgi) && !defined(__GNUC__)
+
+# include <stream.h>
+# include <string>
+
+  using std::getline;
+
+# endif
+
+#endif // !__SG_ISTREAM
+

simgear/compatibility/iterator

@@ -0,0 +1,8 @@
+
+#ifndef __SG_ITERATOR
+#define __SG_ITERATOR 1
+
+# include <iterator.h>
+
+#endif // !__SG_ITERATOR
+

simgear/compatibility/new

@@ -0,0 +1,12 @@
+
+#ifndef __SG_NEW
+#define __SG_NEW 1
+
+#if defined(sgi) && !defined(__GNUC__)
+
+# include <new.h>
+
+#endif
+
+#endif // !__SG_NEW
+

simgear/compatibility/sstream

@@ -0,0 +1,13 @@
+
+#ifndef __SG_SSTREAM
+#define __SG_SSTREAM 1
+
+# include <strstream>
+
+namespace std {
+   typedef ::ostrstream ostringstream;
+   typedef ::istrstream istringstream;
+};
+
+#endif // !__SG_SSTREAM
+

simgear/compatibility/streambuf

@@ -0,0 +1,38 @@
+
+#ifndef __SG_STREAMBUF
+#define __SG_STREAMBUF 1
+
+# include <iostream>
+# include <char_traits.h>
+
+//
+// Until we find a good way to rename the original streambuf class
+// and derive our own streambuf class from that, define this variable
+// for now so the code can inherit our streambuf class instead.
+//
+# define SG_NEED_STREAMBUF_HACK  1
+
+class __streambuf : virtual public streambuf {
+public:
+
+  typedef std::char_traits<char>            traits_type;
+  typedef std::char_traits<char>::int_type  int_type;
+
+  typedef streampos  pos_type;
+  typedef streamoff  off_type;
+};
+
+
+# if defined(sgi) && !defined(__GNUC__)
+
+# define pubsync  sync
+
+  namespace std {
+    using ::streambuf;
+    using ::streampos;
+    using ::streamoff;
+  };
+# endif
+
+#endif // !__SG_STREAMBUF
+

simgear/compatibility/strstream

@@ -0,0 +1,20 @@
+
+#ifndef __SG_STRSTREAM
+#define __SG_STRSTREAM 1
+
+# include <strstream.h>
+
+# if defined(sgi) && !defined(__GNUC__)
+
+  namespace std {
+    using ::ends;
+
+    using ::strstream;
+    using ::istrstream;
+    using ::ostrstream;
+  };
+
+# endif
+
+#endif // !__SG_STRSTREAM
+

simgear/compiler.h

@@ -141,7 +141,6 @@
 #      define STL_STDEXCEPT  <stdexcept>
 #      define STL_STRING     <string>
 #      define STL_STRSTREAM  <strstream>
-
 #  else
 #    error Time to upgrade. GNU compilers < 2.7 not supported
 #  endif
@@ -292,28 +291,24 @@
 #  define SG_HAVE_NATIVE_SGI_COMPILERS
 
 #  define SG_EXPLICIT_FUNCTION_TMPL_ARGS
+#  define SG_CLASS_PARTIAL_SPECIALIZATION
 #  define SG_NEED_AUTO_PTR
 #  define SG_MEMBER_TEMPLATES
 #  define SG_NAMESPACES
 #  define SG_HAVE_STD
-#  define SG_CLASS_PARTIAL_SPECIALIZATION
+#  define SG_HAVE_STREAMBUF
 #  define SG_HAVE_TRAITS
+#  define SG_HAVE_STD_INCLUDES
 
 #  define STL_ALGORITHM  <algorithm>
 #  define STL_FUNCTIONAL <functional>
-#  define STL_IOMANIP    <iomanip.h>
-#  define STL_IOSTREAM   <iostream.h>
-#  define STL_ITERATOR   <iterator.h>
-#  define STL_FSTREAM    <fstream.h>
+#  define STL_IOMANIP    <iomanip>
+#  define STL_IOSTREAM   <iostream>
+#  define STL_ITERATOR   <iterator>
+#  define STL_FSTREAM    <fstream>
 #  define STL_STDEXCEPT  <stdexcept>
 #  define STL_STRING     <string>
-#  define STL_STRSTREAM  <strstream.h>
-
-// #  define __STL_FUNCTION_TMPL_PARTIAL_ORDER
-// typedef void PFNGLPOINTPARAMETERFEXTPROC
-
-#define glPointParameterfEXT	glPointParameterfSGIS
-#define glPointParameterfvEXT	glPointParameterfvSGIS
+#  define STL_STRSTREAM  <strstream>
 
 #pragma set woff 1001,1012,1014,1116,1155,1172,1174
 #pragma set woff 1401,1460,1551,1552,1681
@@ -322,7 +317,7 @@
 #pragma set woff 1682,3303
 #endif
 
-#  define SG_COMPILER_STR "SGI Irix compiler version " SG_STRINGIZE(_COMPILER_VERSION)
+#  define SG_COMPILER_STR "SGI MipsPro compiler version " SG_STRINGIZE(_COMPILER_VERSION)
 
 #endif // Native SGI compilers
 

simgear/debug/debug_types.h

@@ -23,7 +23,8 @@ typedef enum {
     SG_IO        = 0x00001000,
     SG_CLIPPER   = 0x00002000,
     SG_NETWORK   = 0x00004000,
-    SG_UNDEFD    = 0x00008000, // For range checking
+    SG_ATC       = 0x00008000,
+    SG_UNDEFD    = 0x00010000, // For range checking
 
     SG_ALL     = 0xFFFFFFFF
 } sgDebugClass;
@@ -33,11 +34,12 @@ typedef enum {
  * Define the possible logging priorities (and their order).
  */
 typedef enum {
-    SG_BULK,	    // For frequent messages
-    SG_DEBUG, 	    // Less frequent debug type messages
-    SG_INFO,        // Informatory messages
-    SG_WARN,	    // Possible impending problem
-    SG_ALERT       // Very possible impending problem
+    SG_BULK = 1,       // For frequent messages
+    SG_DEBUG,          // Less frequent debug type messages
+    SG_INFO,           // Informatory messages
+    SG_WARN,           // Possible impending problem
+    SG_ALERT           // Very possible impending problem
     // SG_EXIT,        // Problem (no core)
     // SG_ABORT        // Abandon ship (core)
 } sgDebugPriority;
+

simgear/debug/logstream.hxx

@@ -28,11 +28,6 @@
 
 #include <simgear/compiler.h>
 
-// At least Irix needs this
-#ifdef SG_HAVE_NATIVE_SGI_COMPILERS
-#include <char_traits.h>
-#endif
-
 #ifdef SG_HAVE_STD_INCLUDES
 # include <streambuf>
 # include <iostream>
@@ -43,14 +38,11 @@
 
 #include <simgear/debug/debug_types.h>
 
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
 SG_USING_STD(streambuf);
 SG_USING_STD(ostream);
+SG_USING_STD(cout);
 SG_USING_STD(cerr);
 SG_USING_STD(endl);
-#else
-SG_USING_STD(char_traits);
-#endif
 
 #ifdef __MWERKS__
 SG_USING_STD(iostream);
@@ -69,7 +61,11 @@ SG_USING_STD(iostream);
  * messages at runtime. Only messages with priority >= logbuf::logPriority
  * and debugClass == logbuf::logClass are output.
  */
+#ifdef SG_NEED_STREAMBUF_HACK
+class logbuf : public __streambuf
+#else
 class logbuf : public streambuf
+#endif
 {
 public:
 

simgear/ephemeris/stardata.cxx

@@ -27,7 +27,7 @@
 
 #include "stardata.hxx"
 
-#if defined (_MSC_VER) || defined (SG_HAVE_NATIVE_SGI_COMPILERS)
+#if defined (_MSC_VER)
   SG_USING_STD(getline);
 #endif
 

simgear/interpreter/Makefile.am

@@ -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)

simgear/interpreter/exbase.cc

@@ -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;
-  }

simgear/interpreter/exgen.cc

@@ -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]);
-  }

simgear/interpreter/interpreter.cxx

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

simgear/interpreter/interpreter.hxx

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

simgear/interpreter/ixlib_base.hh

@@ -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

simgear/interpreter/ixlib_exbase.hh

@@ -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

simgear/interpreter/ixlib_exgen.hh

@@ -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

simgear/interpreter/ixlib_garbage.hh

@@ -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

simgear/interpreter/ixlib_i18n.hh

@@ -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

simgear/interpreter/ixlib_javascript.hh

@@ -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

simgear/interpreter/ixlib_js_internals.hh

@@ -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

simgear/interpreter/ixlib_numconv.hh

@@ -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

simgear/interpreter/ixlib_numeric.hh

@@ -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

simgear/interpreter/ixlib_random.hh

@@ -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

simgear/interpreter/ixlib_re.hh

@@ -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

simgear/interpreter/ixlib_re_impl.hh

@@ -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;
-  }

simgear/interpreter/ixlib_scanjs.hh

@@ -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

simgear/interpreter/ixlib_scanner.hh

@@ -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

simgear/interpreter/ixlib_string.hh

@@ -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

simgear/interpreter/ixlib_token_javascript.hh

@@ -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

simgear/interpreter/ixlib_token_lex.hh

@@ -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

simgear/interpreter/js_array.cc

@@ -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();
-    }
-  }

simgear/interpreter/js_declaration.cc

@@ -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);
-  }

simgear/interpreter/js_expression.cc

@@ -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
-  }

simgear/interpreter/js_instruction.cc

@@ -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);
-  }

simgear/interpreter/js_library.cc

@@ -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);
-  }

simgear/interpreter/lex.javascript.yy

@@ -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()))

simgear/interpreter/main.cc

@@ -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;
-}
-   

simgear/interpreter/numconv.cc

@@ -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);
-    }
-  }

simgear/interpreter/numeric.cc

@@ -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;
-}

simgear/interpreter/re.cc

@@ -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;
-}

simgear/interpreter/scanner.cc

@@ -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);
-  }
-
-
-
-

simgear/interpreter/string.cc

@@ -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;
-  }

simgear/io/Makefile.am

@@ -22,12 +22,6 @@ libsgio_a_SOURCES = \
 
 INCLUDES = -I$(top_srcdir)
 
-if IS_MINGW
-NETWORK_LIB = -lwsock32
-else
-NETWORK_LIB =
-endif
-
 noinst_PROGRAMS = decode_binobj socktest lowtest tcp_server tcp_client
 
 tcp_server_SOURCES = tcp_server.cxx
@@ -38,7 +32,7 @@ tcp_server_LDADD = \
 	$(top_builddir)/simgear/bucket/libsgbucket.a \
 	$(top_builddir)/simgear/misc/libsgmisc.a \
 	$(top_builddir)/simgear/xml/libsgxml.a \
-	-lplibnet -lplibul -lz $(NETWORK_LIB)
+	-lplibnet -lplibul -lz
 
 tcp_client_SOURCES = tcp_client.cxx
 
@@ -48,7 +42,7 @@ tcp_client_LDADD = \
 	$(top_builddir)/simgear/bucket/libsgbucket.a \
 	$(top_builddir)/simgear/misc/libsgmisc.a \
         $(top_builddir)/simgear/xml/libsgxml.a \
-	-lplibnet -lplibul -lz $(NETWORK_LIB)
+	-lplibnet -lplibul -lz
 
 socktest_SOURCES = socktest.cxx
 
@@ -58,7 +52,7 @@ socktest_LDADD = \
 	$(top_builddir)/simgear/debug/libsgdebug.a \
 	$(top_builddir)/simgear/misc/libsgmisc.a \
 	$(top_builddir)/simgear/xml/libsgxml.a \
-	-lplibnet -lplibul -lz $(NETWORK_LIB)
+	-lplibnet -lplibul -lz
 
 lowtest_SOURCES = lowtest.cxx
 

simgear/io/decode_binobj.cxx

@@ -3,12 +3,10 @@
 #include <unistd.h>
 #include STL_IOSTREAM
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
+#include "sg_binobj.hxx"
+
 SG_USING_STD(cout);
 SG_USING_STD(endl);
-#endif
-
-#include "sg_binobj.hxx"
 
 
 int main( int argc, char **argv ) {

simgear/io/lowtest.cxx

@@ -3,16 +3,14 @@
 #include STL_IOSTREAM
 #include "lowlevel.hxx"
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
-SG_USING_STD(cout);
-SG_USING_STD(endl);
-#endif
-
 
 static const int sgEndianTest = 1;
 #define sgIsLittleEndian (*((char *) &sgEndianTest ) != 0)
 #define sgIsBigEndian    (*((char *) &sgEndianTest ) == 0)
 
+SG_USING_STD(cout);
+SG_USING_STD(endl);
+
 
 int main() {
     cout << "This machine is ";

simgear/io/sg_binobj.cxx

@@ -22,7 +22,12 @@
 //
 
 
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
 #include <simgear/compiler.h>
+#include <simgear/debug/logstream.hxx>
 
 #include <stdio.h>
 #include <time.h>
@@ -39,11 +44,6 @@
 SG_USING_STD( string );
 SG_USING_STD( vector );
 
-#if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
-SG_USING_STD( cout );
-SG_USING_STD( endl );
-#endif
-
 
 enum {
     SG_BOUNDING_SPHERE = 0,
@@ -89,7 +89,7 @@ public:
 	while ( size < s ) {
 	    size *= 2;
 	}
-	cout << "Creating a new buffer of size = " << size << endl;
+        SG_LOG(SG_EVENT, SG_DEBUG, "Creating a new buffer of size = " << size);
 	ptr = new char[size];
     }
 
@@ -107,7 +107,7 @@ public:
 	    while ( size < s ) {
 		size *= 2;
 	    }
-	    cout << "resizing buffer to size = " << size << endl;
+            SG_LOG(SG_EVENT, SG_DEBUG, "resizing buffer to size = " << size);
 	    ptr = new char[size];
 	}
     }
@@ -321,8 +321,8 @@ bool SGBinObject::read_bin( const string& file ) {
     if ( (fp = gzopen( file.c_str(), "rb" )) == NULL ) {
 	string filegz = file + ".gz";
 	if ( (fp = gzopen( filegz.c_str(), "rb" )) == NULL ) {
-	    cout << "ERROR: opening " << file << " or " << filegz
-	         << "for reading!" << endl;
+            SG_LOG( SG_EVENT, SG_ALERT,
+               "ERROR: opening " << file << " or " << filegz << "for reading!");
 
 	    return false;
 	}
@@ -360,7 +360,7 @@ bool SGBinObject::read_bin( const string& file ) {
     local_tm = localtime( &calendar_time );
     char time_str[256];
     strftime( time_str, 256, "%a %b %d %H:%M:%S %Z %Y", local_tm);
-    cout << "File created on " << time_str << endl;
+    SG_LOG( SG_EVENT, SG_DEBUG, "File created on " << time_str);
 #endif
 
     // read number of top level objects

simgear/io/sg_serial.hxx

@@ -55,7 +55,7 @@ class SGSerial : public SGIOChannel {
 
     string device;
     string baud;
-    FGSerialPort port;
+    SGSerialPort port;
 
     char save_buf[ 2 * SG_IO_MAX_MSG_SIZE ];
     int save_len;

simgear/io/socktest.cxx

@@ -6,15 +6,14 @@
 #include "sg_socket.hxx"
 #include "lowlevel.hxx"
 
-#if !defined(SG_HAVE_NATIVE_SGI_COMPILERS)
-SG_USING_STD(cout);
-SG_USING_STD(endl);
-#endif
-
 static const int sgEndianTest = 1;
 #define sgIsLittleEndian (*((char *) &sgEndianTest ) != 0)
 #define sgIsBigEndian    (*((char *) &sgEndianTest ) == 0)
 
+SG_USING_STD(cout);
+SG_USING_STD(endl);
+
+
 int main() {
 
     if ( sgIsLittleEndian ) {

simgear/io/tcp_client.cxx

@@ -11,9 +11,6 @@
 
 #include "sg_socket.hxx"
 
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
-using std::cout;
-#endif
 
 class TcpClient
 {

simgear/io/tcp_server.cxx

@@ -5,10 +5,8 @@
 
 #include "sg_socket.hxx"
 
-using std::string;
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
-using std::cout;
-#endif
+SG_USING_STD(string);
+SG_USING_STD(cout);
 
 class TcpServer
 {

simgear/math/interpolater.cxx

@@ -30,7 +30,6 @@
 
 #include STL_STRING
 
-// depricated - #include <simgear/sg_zlib.h>
 #include <simgear/debug/logstream.hxx>
 #include <simgear/misc/sgstream.hxx>
 

simgear/math/linintp2.inl

@@ -48,7 +48,7 @@ mgcLinInterp2D<T>::mgcLinInterp2D (int _numPoints, double* x, double* y,
         return;
     }
 
-    cout << "[ 20%] allocating memory                                              \r";
+    // cout << "[ 20%] allocating memory                                              \r";
 
     point = new double*[numPoints];
     tmppoint = new double*[numPoints+3];
@@ -66,7 +66,7 @@ mgcLinInterp2D<T>::mgcLinInterp2D (int _numPoints, double* x, double* y,
 	f[i] = _f[i];
     }
 
-    cout << "[ 30%] creating delaunay diagram                                      \r";
+    // cout << "[ 30%] creating delaunay diagram                                      \r";
 
     Delaunay2D();
 }
@@ -279,7 +279,7 @@ int mgcLinInterp2D<T>::Delaunay2D ()
     nts = 1;  // number of triangles
     i4 = 1;
 
-    cout << "[ 40%] create triangulation                                     \r";
+    // cout << "[ 40%] create triangulation                                     \r";
 
     // compute triangulation
     for (i0 = 0; i0 < numPoints; i0++)
@@ -372,7 +372,7 @@ Corner3:;
     }
 
     // count the number of triangles
-    cout << "[ 50%] count the number of triangles                                  \r";
+    // cout << "[ 50%] count the number of triangles                                  \r";
 
     numTriangles = 0;
     i0 = -1;
@@ -394,7 +394,7 @@ Corner3:;
     }
 
     // create the triangles
-    cout << "[ 60%] create the triangles                                         \r";
+    // cout << "[ 60%] create the triangles                                         \r";
 
     triangle = new Triangle[numTriangles];
 
@@ -428,7 +428,7 @@ Corner3:;
     }
 
     // build edge table
-    cout << "[ 70%] build the edge table                                       \r";
+    // cout << "[ 70%] build the edge table                                       \r";
 
     numEdges = 0;
     edge = new Edge[3*numTriangles];
@@ -436,8 +436,8 @@ Corner3:;
     int j, j0, j1;
     for (i = 0; i < numTriangles; i++)
     {
-	if ( (i%500) == 0)
-	    cout << "[ 7" << 10*i/numTriangles << "%] build the edge table                                       \r";
+	// if ( (i%500) == 0)
+	    // cout << "[ 7" << 10*i/numTriangles << "%] build the edge table                                       \r";
 
         Triangle& t = triangle[i];
 
@@ -470,7 +470,7 @@ Corner3:;
     }
 
     // establish links between adjacent triangles
-    cout << "[ 80%] establishing links between adjacent triangles                                       \r";
+    // cout << "[ 80%] establishing links between adjacent triangles                                       \r";
 
     for (i = 0; i < numEdges; i++)
     {
@@ -494,7 +494,7 @@ ExitDelaunay:;
     delete[] ccr[0];
     delete[] ccr;
 
-    cout << "[ 90%] finsishes delauney triangulation                            \r";
+    // cout << "[ 90%] finsishes delauney triangulation                            \r";
 
     return result;
 }

simgear/math/point3d.hxx

@@ -61,10 +61,8 @@
 SG_USING_NAMESPACE(std);
 #endif
 
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
 SG_USING_STD(ostream);
 SG_USING_STD(istream);
-#endif
 
 
 const double fgPoint3_Epsilon = 0.0000001;

simgear/math/sg_geodesy.cxx

@@ -27,12 +27,10 @@
 #include "localconsts.hxx"
 
 
-#ifndef SG_HAVE_NATIVE_SGI_COMPILERS
 SG_USING_STD(cout);
-#endif
 
 
-#define DOMAIN_ERR_DEBUG 1
+// #define DOMAIN_ERR_DEBUG 1
 
 
 // sgGeocToGeod(lat_geoc, radius, *lat_geod, *alt, *sea_level_r)
@@ -47,8 +45,8 @@ SG_USING_STD(cout);
 //                      local vertical (surface normal) of C.G. (meters)
 
 
-void sgGeocToGeod( double lat_geoc, double radius, double
-		   *lat_geod, double *alt, double *sea_level_r )
+void sgGeocToGeod( const double& lat_geoc, const double& radius,
+                   double *lat_geod, double *alt, double *sea_level_r )
 {
 #ifdef DOMAIN_ERR_DEBUG
     errno = 0;			// start with error zero'd
@@ -134,7 +132,7 @@ void sgGeocToGeod( double lat_geoc, double radius, double
 //
 
 
-void sgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
+void sgGeodToGeoc( const double& lat_geod, const double& alt, double *sl_radius,
 		      double *lat_geoc )
 {
     double lambda_sl, sin_lambda_sl, cos_lambda_sl, sin_mu, cos_mu, px, py;
@@ -184,7 +182,7 @@ void sgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
 
 // for WGS_84 a = 6378137.000, rf = 298.257223563;
 
-static double M0( double e2 ) {
+static inline double M0( double e2 ) {
     //double e4 = e2*e2;
     return GEOD_INV_PI*(1.0 - e2*( 1.0/4.0 + e2*( 3.0/64.0 + 
 						  e2*(5.0/256.0) )))/2.0;
@@ -193,8 +191,10 @@ static double M0( double e2 ) {
 
 // given, alt, lat1, lon1, az1 and distance (s), calculate lat2, lon2
 // and az2.  Lat, lon, and azimuth are in degrees.  distance in meters
-int geo_direct_wgs_84 ( double alt, double lat1, double lon1, double az1, 
-			double s, double *lat2, double *lon2,  double *az2 )
+int geo_direct_wgs_84 ( const double& alt, const double& lat1,
+                        const double& lon1, const double& az1,
+                        const double& s, double *lat2, double *lon2,
+                        double *az2 )
 {
     double a = 6378137.000, rf = 298.257223563;
     double RADDEG = (GEOD_INV_PI)/180.0, testv = 1.0E-10;
@@ -275,7 +275,8 @@ int geo_direct_wgs_84 ( double alt, double lat1, double lon1, double az1,
     } else {			// phi1 == 90 degrees, polar origin
 	double dM = a*M0(e2) - s;
 	double paz = ( phi1 < 0.0 ? 180.0 : 0.0 );
-	return geo_direct_wgs_84( alt, 0.0, lon1, paz, dM,lat2,lon2,az2 );
+        double zero = 0.0f;
+	return geo_direct_wgs_84( alt, zero, lon1, paz, dM, lat2, lon2, az2 );
     } 
 }
 
@@ -283,8 +284,10 @@ int geo_direct_wgs_84 ( double alt, double lat1, double lon1, double az1,
 // given alt, lat1, lon1, lat2, lon2, calculate starting and ending
 // az1, az2 and distance (s).  Lat, lon, and azimuth are in degrees.
 // distance in meters
-int geo_inverse_wgs_84( double alt, double lat1, double lon1, double lat2,
-			double lon2, double *az1, double *az2, double *s )
+int geo_inverse_wgs_84( const double& alt, const double& lat1,
+                        const double& lon1, const double& lat2,
+			const double& lon2, double *az1, double *az2,
+                        double *s )
 {
     double a = 6378137.000, rf = 298.257223563;
     int iter=0;
@@ -311,8 +314,9 @@ int geo_inverse_wgs_84( double alt, double lat1, double lon1, double lat2,
 	return 0;
     } else if( fabs(cosphi2) < testv ) {
 	// terminal point is polar
-	int k = geo_inverse_wgs_84( alt, lat1,lon1,lat1,lon1+180.0, 
-				    az1,az2,s );
+        double _lon1 = lon1 + 180.0f;
+	int k = geo_inverse_wgs_84( alt, lat1, lon1, lat1, _lon1, 
+				    az1, az2, s );
 	k = k; // avoid compiler error since return result is unused
 	*s /= 2.0;
 	*az2 = *az1 + 180.0;

simgear/math/sg_geodesy.hxx

@@ -31,8 +31,8 @@
  * @param sea_level_r (out) radius from earth center to sea level at
  *        local vertical (surface normal) of C.G. (meters)
  */
-void sgGeocToGeod( double lat_geoc, double radius, double
-		   *lat_geod, double *alt, double *sea_level_r );
+void sgGeocToGeod( const double& lat_geoc, const double& radius,
+                   double *lat_geod, double *alt, double *sea_level_r );
 
 
 /**
@@ -43,8 +43,8 @@ void sgGeocToGeod( double lat_geoc, double radius, double
  *        (add Altitude to get true distance from earth center.
  * @param lat_geoc (out) Geocentric latitude, radians, + = North
  */
-void sgGeodToGeoc( double lat_geod, double alt, double *sl_radius,
-		      double *lat_geoc );
+void sgGeodToGeoc( const double& lat_geod, const double& alt,
+                   double *sl_radius, double *lat_geoc );
 
 
 /**
@@ -82,15 +82,19 @@ inline Point3D sgGeodToCart(const Point3D& geod) {
  * @param lon2 (out) degrees
  * @param az2 (out) return course in degrees
  */
-int geo_direct_wgs_84 ( double alt, double lat1, double lon1, double az1, 
-			double s, double *lat2, double *lon2,  double *az2 );
+int geo_direct_wgs_84 ( const double& alt, const double& lat1,
+                        const double& lon1, const double& az1, 
+			const double& s, double *lat2, double *lon2,
+                        double *az2 );
 
 
 // given alt, lat1, lon1, lat2, lon2, calculate starting and ending
 // az1, az2 and distance (s).  Lat, lon, and azimuth are in degrees.
 // distance in meters
-int geo_inverse_wgs_84( double alt, double lat1, double lon1, double lat2,
-			double lon2, double *az1, double *az2, double *s );
+int geo_inverse_wgs_84( const double& alt, const double& lat1,
+                        const double& lon1, const double& lat2,
+			const double& lon2, double *az1, double *az2,
+                        double *s );
 
 
 /***************************************************************************

simgear/math/sg_types.hxx

@@ -49,6 +49,11 @@ typedef vector < int > int_list;
 typedef int_list::iterator int_list_iterator;
 typedef int_list::const_iterator const_int_list_iterator;
 
+/** STL vector list of doubles */
+typedef vector < double > double_list;
+typedef double_list::iterator double_list_iterator;
+typedef double_list::const_iterator const_double_list_iterator;
+
 /** STL vector list of Point3D */
 typedef vector < Point3D > point_list;
 typedef point_list::iterator point_list_iterator;

simgear/math/sphrintp.inl

@@ -45,8 +45,8 @@ SphereInterpolate<T>::SphereInterpolate (int n, const double* x,
     // For complete spherical coverage, include the two antipodal points
     // (0,0,1,f(0,0,1)) and (0,0,-1,f(0,0,-1)) in the data set.
     
-    cout << "Initialising spherical interpolator.\n";
-    cout << "[  0%] Allocating memory                                           \r";
+    // cout << "Initialising spherical interpolator.\n";
+    // cout << "[  0%] Allocating memory                                           \r";
 
     theta = new double[3*n];
     phi = new double[3*n];
@@ -63,7 +63,7 @@ SphereInterpolate<T>::SphereInterpolate (int n, const double* x,
     }
     
     // use periodicity to get wrap-around in the Delaunay triangulation
-    cout << "[ 10%] copying vertices for wrap-around\r";
+    // cout << "[ 10%] copying vertices for wrap-around\r";
     int j, k;
     for (i = 0, j = n, k = 2*n; i < n; i++, j++, k++)
     {
@@ -77,7 +77,7 @@ SphereInterpolate<T>::SphereInterpolate (int n, const double* x,
     
     pInterp = new mgcLinInterp2D<T>(3*n,theta,phi,func);
 
-    cout << "[100%] Finished initialising spherical interpolator.                   \n";
+    // cout << "[100%] Finished initialising spherical interpolator.                   \n";
 }
 
 template<class T>
@@ -86,15 +86,15 @@ SphereInterpolate<T>::SphereInterpolate (int n, const sgVec2* p, const T* f)
     // Assumes (x[i],y[i],z[i]) is unit length for all 0 <= i < n.
     // For complete spherical coverage, include the two antipodal points
     // (0,0,1,f(0,0,1)) and (0,0,-1,f(0,0,-1)) in the data set.
-    cout << "Initialising spherical interpolator.\n";
-    cout << "[  0%] Allocating memory                                           \r";
+    // cout << "Initialising spherical interpolator.\n";
+    // cout << "[  0%] Allocating memory                                           \r";
 
     theta = new double[3*n];
     phi = new double[3*n];
     func = new T[3*n];
 
     // convert data to spherical coordinates
-    cout << "[ 10%] copying vertices for wrap-around                              \r";
+    // cout << "[ 10%] copying vertices for wrap-around                              \r";
 
     int i, j, k;
     for (i = 0, j = n, k = 2*n; i < n; i++, j++, k++)
@@ -114,7 +114,7 @@ SphereInterpolate<T>::SphereInterpolate (int n, const sgVec2* p, const T* f)
     
     pInterp = new mgcLinInterp2D<T>(3*n,theta,phi,func);
 
-    cout << "[100%] Finished initialising spherical interpolator.                   \n";
+    // cout << "[100%] Finished initialising spherical interpolator.                   \n";
 }
 //---------------------------------------------------------------------------
 template<class T>

simgear/metar/MetarReport.cpp

@@ -7,10 +7,8 @@
 #include "MetarReport.h"
 #include "Metar.h"
 
-#if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(endl);
 SG_USING_STD(ostream);
-#endif
 
 CMetarReport::CMetarReport(
    char *s ) :

simgear/metar/MetarStation.cpp

@@ -8,11 +8,9 @@
 #include "MetarStation.h"
 #include <algorithm>
 
-#if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
 SG_USING_STD(ostream);
 SG_USING_STD(cout);
 SG_USING_STD(endl);
-#endif
 
 
 double CMetarStation::decodeDMS( char *b )