New Version: 3.2.0

Using just 0 as prefix for octal number can lead to confusion
where numbers could be interpreted the wrong way (oct instead of
dec).
Lets follow the same convention as Python 3 and Ecma 262 level 6
and use '0o' as prefix which can not be confused inadvertently.

.gitignore

@@ -0,0 +1,16 @@
+.*
+*~
+Makefile
+*.o
+lib*.a
+.*.swp
+cmake_install.cmake
+CMakeFiles
+CMakeCache.txt
+CPackConfig.cmake
+CPackSourceConfig.cmake
+cmake_uninstall.cmake
+CTestTestfile.cmake
+install_manifest.txt
+build*
+Build

3rdparty/CMakeLists.txt

@@ -0,0 +1,4 @@
+if (NOT SYSTEM_EXPAT)
+	add_subdirectory(expat)
+endif()
+

3rdparty/expat/CMakeLists.txt

@@ -0,0 +1,33 @@
+
+configure_file (
+    "${PROJECT_SOURCE_DIR}/3rdparty/expat/expat_config_cmake.in"
+    "${PROJECT_BINARY_DIR}/3rdparty/expat/expat_config.h"
+)
+
+set(expat_sources 
+	asciitab.h
+        hashtable.h
+        iasciitab.h
+        latin1tab.h
+        nametab.h
+        utf8tab.h
+        xmldef.h
+        xmlparse.h
+        xmlrole.h
+        xmltok.h
+        xmltok_impl.h
+        hashtable.c
+        xmlparse.c
+        xmlrole.c
+        xmltok.c
+        internal.h
+        ascii.h
+        sg_expat.h
+        sg_expat_external.h 
+	)
+
+foreach(s ${expat_sources})
+	set_property(GLOBAL
+		APPEND PROPERTY LOCAL_EXPAT_SOURCES 
+        "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+endforeach()

3rdparty/expat/Expat.COPYING

@@ -0,0 +1,22 @@
+Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+                               and Clark Cooper
+Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Expat maintainers.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

3rdparty/expat/ascii.h

@@ -0,0 +1,92 @@
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
+*/
+
+#define ASCII_A 0x41
+#define ASCII_B 0x42
+#define ASCII_C 0x43
+#define ASCII_D 0x44
+#define ASCII_E 0x45
+#define ASCII_F 0x46
+#define ASCII_G 0x47
+#define ASCII_H 0x48
+#define ASCII_I 0x49
+#define ASCII_J 0x4A
+#define ASCII_K 0x4B
+#define ASCII_L 0x4C
+#define ASCII_M 0x4D
+#define ASCII_N 0x4E
+#define ASCII_O 0x4F
+#define ASCII_P 0x50
+#define ASCII_Q 0x51
+#define ASCII_R 0x52
+#define ASCII_S 0x53
+#define ASCII_T 0x54
+#define ASCII_U 0x55
+#define ASCII_V 0x56
+#define ASCII_W 0x57
+#define ASCII_X 0x58
+#define ASCII_Y 0x59
+#define ASCII_Z 0x5A
+
+#define ASCII_a 0x61
+#define ASCII_b 0x62
+#define ASCII_c 0x63
+#define ASCII_d 0x64
+#define ASCII_e 0x65
+#define ASCII_f 0x66
+#define ASCII_g 0x67
+#define ASCII_h 0x68
+#define ASCII_i 0x69
+#define ASCII_j 0x6A
+#define ASCII_k 0x6B
+#define ASCII_l 0x6C
+#define ASCII_m 0x6D
+#define ASCII_n 0x6E
+#define ASCII_o 0x6F
+#define ASCII_p 0x70
+#define ASCII_q 0x71
+#define ASCII_r 0x72
+#define ASCII_s 0x73
+#define ASCII_t 0x74
+#define ASCII_u 0x75
+#define ASCII_v 0x76
+#define ASCII_w 0x77
+#define ASCII_x 0x78
+#define ASCII_y 0x79
+#define ASCII_z 0x7A
+
+#define ASCII_0 0x30
+#define ASCII_1 0x31
+#define ASCII_2 0x32
+#define ASCII_3 0x33
+#define ASCII_4 0x34
+#define ASCII_5 0x35
+#define ASCII_6 0x36
+#define ASCII_7 0x37
+#define ASCII_8 0x38
+#define ASCII_9 0x39
+
+#define ASCII_TAB 0x09
+#define ASCII_SPACE 0x20
+#define ASCII_EXCL 0x21
+#define ASCII_QUOT 0x22
+#define ASCII_AMP 0x26
+#define ASCII_APOS 0x27
+#define ASCII_MINUS 0x2D
+#define ASCII_PERIOD 0x2E
+#define ASCII_COLON 0x3A
+#define ASCII_SEMI 0x3B
+#define ASCII_LT 0x3C
+#define ASCII_EQUALS 0x3D
+#define ASCII_GT 0x3E
+#define ASCII_LSQB 0x5B
+#define ASCII_RSQB 0x5D
+#define ASCII_UNDERSCORE 0x5F
+#define ASCII_LPAREN 0x28
+#define ASCII_RPAREN 0x29
+#define ASCII_FF 0x0C
+#define ASCII_SLASH 0x2F
+#define ASCII_HASH 0x23
+#define ASCII_PIPE 0x7C
+#define ASCII_COMMA 0x2C

3rdparty/expat/asciitab.h

@@ -0,0 +1,62 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+/* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
+/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,

3rdparty/expat/expat_config_cmake.in

@@ -0,0 +1,41 @@
+
+#ifndef EXPAT_CONFIG_H
+#define EXPAT_CONFIG_H
+
+#cmakedefine HAVE_WINDOWS_H
+
+#ifdef HAVE_WINDOWS_H
+    #define WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+    #undef WIN32_LEAN_AND_MEAN
+#endif
+
+/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
+#define BYTEORDER  1234
+
+/* Define to 1 if you have the `bcopy' function. */
+#cmakedefine HAVE_BCOPY
+
+/* Define to 1 if you have the `memmove' function. */
+#define HAVE_MEMMOVE
+
+/* Define to 1 if you have a working `mmap' system call. */
+#cmakedefine HAVE_MMAP
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#cmakedefine HAVE_UNISTD_H
+
+/* whether byteorder is bigendian */
+#undef WORDS_BIGENDIAN
+
+/* Define to specify how much context to retain around the current parse
+   point. */
+#define XML_CONTEXT_BYTES 1024
+
+/* Define to make parameter entity parsing functionality available. */
+#define XML_DTD
+
+/* Define to make XML Namespaces functionality available. */
+#define XML_NS
+
+#endif /* ifndef EXPAT_CONFIG_H */

3rdparty/expat/hashtable.c

@@ -0,0 +1,151 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+#include "xmldef.h"
+
+#ifdef XML_UNICODE_WCHAR_T
+#ifndef XML_UNICODE
+#define XML_UNICODE
+#endif
+#endif
+
+#include "hashtable.h"
+
+#define INIT_SIZE 64
+
+static
+int keyeq(KEY s1, KEY s2)
+{
+  for (; *s1 == *s2; s1++, s2++)
+    if (*s1 == 0)
+      return 1;
+  return 0;
+}
+
+static
+unsigned long hash(KEY s)
+{
+  unsigned long h = 0;
+  while (*s)
+    h = (h << 5) + h + (unsigned char)*s++;
+  return h;
+}
+
+NAMED *lookup(HASH_TABLE *table, KEY name, size_t createSize)
+{
+  size_t i;
+  if (table->size == 0) {
+    if (!createSize)
+      return 0;
+    table->v = calloc(INIT_SIZE, sizeof(NAMED *));
+    if (!table->v)
+      return 0;
+    table->size = INIT_SIZE;
+    table->usedLim = INIT_SIZE / 2;
+    i = hash(name) & (table->size - 1);
+  }
+  else {
+    unsigned long h = hash(name);
+    for (i = h & (table->size - 1);
+         table->v[i];
+         i == 0 ? i = table->size - 1 : --i) {
+      if (keyeq(name, table->v[i]->name))
+	return table->v[i];
+    }
+    if (!createSize)
+      return 0;
+    if (table->used == table->usedLim) {
+      /* check for overflow */
+      size_t newSize = table->size * 2;
+      NAMED **newV = calloc(newSize, sizeof(NAMED *));
+      if (!newV)
+	return 0;
+      for (i = 0; i < table->size; i++)
+	if (table->v[i]) {
+	  size_t j;
+	  for (j = hash(table->v[i]->name) & (newSize - 1);
+	       newV[j];
+	       j == 0 ? j = newSize - 1 : --j)
+	    ;
+	  newV[j] = table->v[i];
+	}
+      free(table->v);
+      table->v = newV;
+      table->size = newSize;
+      table->usedLim = newSize/2;
+      for (i = h & (table->size - 1);
+	   table->v[i];
+	   i == 0 ? i = table->size - 1 : --i)
+	;
+    }
+  }
+  table->v[i] = calloc(1, createSize);
+  if (!table->v[i])
+    return 0;
+  table->v[i]->name = name;
+  (table->used)++;
+  return table->v[i];
+}
+
+void hashTableDestroy(HASH_TABLE *table)
+{
+  size_t i;
+  for (i = 0; i < table->size; i++) {
+    NAMED *p = table->v[i];
+    if (p)
+      free(p);
+  }
+  free(table->v);
+}
+
+void hashTableInit(HASH_TABLE *p)
+{
+  p->size = 0;
+  p->usedLim = 0;
+  p->used = 0;
+  p->v = 0;
+}
+
+void hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table)
+{
+  iter->p = table->v;
+  iter->end = iter->p + table->size;
+}
+
+NAMED *hashTableIterNext(HASH_TABLE_ITER *iter)
+{
+  while (iter->p != iter->end) {
+    NAMED *tem = *(iter->p)++;
+    if (tem)
+      return tem;
+  }
+  return 0;
+}
+

3rdparty/expat/hashtable.h

@@ -0,0 +1,69 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+
+#include <stddef.h>
+
+#ifdef XML_UNICODE
+
+#ifdef XML_UNICODE_WCHAR_T
+typedef const wchar_t *KEY;
+#else /* not XML_UNICODE_WCHAR_T */
+typedef const unsigned short *KEY;
+#endif /* not XML_UNICODE_WCHAR_T */
+
+#else /* not XML_UNICODE */
+
+typedef const char *KEY;
+
+#endif /* not XML_UNICODE */
+
+typedef struct {
+  KEY name;
+} NAMED;
+
+typedef struct {
+  NAMED **v;
+  size_t size;
+  size_t used;
+  size_t usedLim;
+} HASH_TABLE;
+
+NAMED *lookup(HASH_TABLE *table, KEY name, size_t createSize);
+void hashTableInit(HASH_TABLE *);
+void hashTableDestroy(HASH_TABLE *);
+
+typedef struct {
+  NAMED **p;
+  NAMED **end;
+} HASH_TABLE_ITER;
+
+void hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
+NAMED *hashTableIterNext(HASH_TABLE_ITER *);

3rdparty/expat/iasciitab.h

@@ -0,0 +1,63 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+/* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
+/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+/* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
+/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,

3rdparty/expat/internal.h

@@ -0,0 +1,73 @@
+/* internal.h
+
+   Internal definitions used by Expat.  This is not needed to compile
+   client code.
+
+   The following calling convention macros are defined for frequently
+   called functions:
+
+   FASTCALL    - Used for those internal functions that have a simple
+                 body and a low number of arguments and local variables.
+
+   PTRCALL     - Used for functions called though function pointers.
+
+   PTRFASTCALL - Like PTRCALL, but for low number of arguments.
+
+   inline      - Used for selected internal functions for which inlining
+                 may improve performance on some platforms.
+
+   Note: Use of these macros is based on judgement, not hard rules,
+         and therefore subject to change.
+*/
+
+#if defined(__GNUC__) && defined(__i386__) && !defined(__MINGW32__)
+/* We'll use this version by default only where we know it helps.
+
+   regparm() generates warnings on Solaris boxes.   See SF bug #692878.
+
+   Instability reported with egcs on a RedHat Linux 7.3.
+   Let's comment out:
+   #define FASTCALL __attribute__((stdcall, regparm(3)))
+   and let's try this:
+*/
+#define FASTCALL __attribute__((regparm(3)))
+#define PTRFASTCALL __attribute__((regparm(3)))
+#endif
+
+/* Using __fastcall seems to have an unexpected negative effect under
+   MS VC++, especially for function pointers, so we won't use it for
+   now on that platform. It may be reconsidered for a future release
+   if it can be made more effective.
+   Likely reason: __fastcall on Windows is like stdcall, therefore
+   the compiler cannot perform stack optimizations for call clusters.
+*/
+
+/* Make sure all of these are defined if they aren't already. */
+
+#ifndef FASTCALL
+#define FASTCALL
+#endif
+
+#ifndef PTRCALL
+#define PTRCALL
+#endif
+
+#ifndef PTRFASTCALL
+#define PTRFASTCALL
+#endif
+
+#ifndef XML_MIN_SIZE
+#if !defined(__cplusplus) && !defined(inline)
+#ifdef __GNUC__
+#define inline __inline
+#endif /* __GNUC__ */
+#endif
+#endif /* XML_MIN_SIZE */
+
+#ifdef __cplusplus
+#define inline inline
+#else
+#ifndef inline
+#define inline
+#endif
+#endif

3rdparty/expat/latin1tab.h

@@ -0,0 +1,62 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+/* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+/* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
+/* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+/* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,

3rdparty/expat/nametab.h

@@ -0,0 +1,150 @@
+static const unsigned namingBitmap[] = {
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0x00000000, 0x04000000, 0x87FFFFFE, 0x07FFFFFE,
+0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
+0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFE00F, 0xFC31FFFF,
+0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
+0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
+0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
+0xFFFF0003, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
+0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
+0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF,
+0x00000000, 0x07FFFFFE, 0x000007FE, 0xFFFE0000,
+0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
+0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003,
+0xFFF99FE0, 0x03C5FDFF, 0xB0000000, 0x00030003,
+0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
+0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001,
+0xFFF99FE0, 0x23CDFDFF, 0xB0000000, 0x00000003,
+0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
+0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003,
+0xFFFDDFE0, 0x03EFFDFF, 0x40000000, 0x00000003,
+0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFE, 0x000D7FFF, 0x0000003F, 0x00000000,
+0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
+0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF,
+0x0007DAED, 0x50000000, 0x82315001, 0x002C62AB,
+0x40000000, 0xF580C900, 0x00000007, 0x02010800,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0x0FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x03FFFFFF,
+0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
+0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF,
+0x00000000, 0x00004C40, 0x00000000, 0x00000000,
+0x00000007, 0x00000000, 0x00000000, 0x00000000,
+0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF,
+0x001FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x07FFFFFF,
+0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+0xFFFFFFFF, 0x0000000F, 0x00000000, 0x00000000,
+0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
+0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF,
+0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
+0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
+0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003,
+0xFFFFD7C0, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
+0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
+0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
+0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
+0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
+0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF,
+0xFFFFFFFF, 0x7CFFFFFF, 0xFFEF7FFF, 0x03FF3DFF,
+0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
+0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF,
+0xFFF987E4, 0xD36DFDFF, 0x5E003987, 0x001FFFC0,
+0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
+0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3,
+0xD63DC7EC, 0xC3BFC718, 0x00803DC7, 0x0000FF80,
+0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
+0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3,
+0xFFFDDFEC, 0xC3FFFDFF, 0x00803DCF, 0x0000FFC3,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000,
+0xFEF02596, 0x3BFF6CAE, 0x03FF3F5F, 0x00000000,
+0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
+0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x00000000, 0x00000000,
+0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
+0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF,
+0x661FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x77FFFFFF,
+};
+static const unsigned char nmstrtPages[] = {
+0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00,
+0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
+0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+static const unsigned char namePages[] = {
+0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00,
+0x00, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
+0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
+0x26, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};

3rdparty/expat/sg_expat_external.h

@@ -0,0 +1,115 @@
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
+*/
+
+#ifndef Expat_External_INCLUDED
+#define Expat_External_INCLUDED 1
+
+/* External API definitions */
+
+#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
+#define XML_USE_MSC_EXTENSIONS 1
+#endif
+
+/* Expat tries very hard to make the API boundary very specifically
+   defined.  There are two macros defined to control this boundary;
+   each of these can be defined before including this header to
+   achieve some different behavior, but doing so it not recommended or
+   tested frequently.
+
+   XMLCALL    - The calling convention to use for all calls across the
+                "library boundary."  This will default to cdecl, and
+                try really hard to tell the compiler that's what we
+                want.
+
+   XMLIMPORT  - Whatever magic is needed to note that a function is
+                to be imported from a dynamically loaded library
+                (.dll, .so, or .sl, depending on your platform).
+
+   The XMLCALL macro was added in Expat 1.95.7.  The only one which is
+   expected to be directly useful in client code is XMLCALL.
+
+   Note that on at least some Unix versions, the Expat library must be
+   compiled with the cdecl calling convention as the default since
+   system headers may assume the cdecl convention.
+*/
+#ifndef XMLCALL
+#if defined(_MSC_VER)
+#define XMLCALL __cdecl
+#elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)
+#define XMLCALL __attribute__((cdecl))
+#else
+/* For any platform which uses this definition and supports more than
+   one calling convention, we need to extend this definition to
+   declare the convention used on that platform, if it's possible to
+   do so.
+
+   If this is the case for your platform, please file a bug report
+   with information on how to identify your platform via the C
+   pre-processor and how to specify the same calling convention as the
+   platform's malloc() implementation.
+*/
+#define XMLCALL
+#endif
+#endif  /* not defined XMLCALL */
+
+
+#if !defined(XML_STATIC) && !defined(XMLIMPORT)
+#ifndef XML_BUILDING_EXPAT
+/* using Expat from an application */
+
+#ifdef XML_USE_MSC_EXTENSIONS
+#define XMLIMPORT __declspec(dllimport)
+#endif
+
+#endif
+#endif  /* not defined XML_STATIC */
+
+
+/* If we didn't define it above, define it away: */
+#ifndef XMLIMPORT
+#define XMLIMPORT
+#endif
+
+
+#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef XML_UNICODE_WCHAR_T
+#define XML_UNICODE
+#endif
+
+#ifdef XML_UNICODE     /* Information is UTF-16 encoded. */
+#ifdef XML_UNICODE_WCHAR_T
+typedef wchar_t XML_Char;
+typedef wchar_t XML_LChar;
+#else
+typedef unsigned short XML_Char;
+typedef char XML_LChar;
+#endif /* XML_UNICODE_WCHAR_T */
+#else                  /* Information is UTF-8 encoded. */
+typedef char XML_Char;
+typedef char XML_LChar;
+#endif /* XML_UNICODE */
+
+#ifdef XML_LARGE_SIZE  /* Use large integers for file/stream positions. */
+#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
+typedef __int64 XML_Index; 
+typedef unsigned __int64 XML_Size;
+#else
+typedef long long XML_Index;
+typedef unsigned long long XML_Size;
+#endif
+#else
+typedef long XML_Index;
+typedef unsigned long XML_Size;
+#endif /* XML_LARGE_SIZE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not Expat_External_INCLUDED */

3rdparty/expat/utf8tab.h

@@ -0,0 +1,63 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+
+/* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
+/* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,

3rdparty/expat/xmldef.h

@@ -0,0 +1,63 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+#include <string.h>
+
+#ifdef XML_WINLIB
+
+#define WIN32_LEAN_AND_MEAN
+#define STRICT
+#include <windows.h>
+
+#define malloc(x) HeapAlloc(GetProcessHeap(), 0, (x))
+#define calloc(x, y) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (x)*(y))
+#define free(x) HeapFree(GetProcessHeap(), 0, (x))
+#define realloc(x, y) HeapReAlloc(GetProcessHeap(), 0, x, y)
+#define abort() /* as nothing */
+
+#else /* not XML_WINLIB */
+
+#include <stdlib.h>
+
+#endif /* not XML_WINLIB */
+
+/* This file can be used for any definitions needed in
+particular environments. */
+
+#ifdef MOZILLA
+
+#include <nspr.h>
+#define malloc(x) PR_Malloc(x)
+#define realloc(x, y) PR_Realloc((x), (y))
+#define calloc(x, y) PR_Calloc((x),(y))
+#define free(x) PR_Free(x)
+#define int int32
+
+#endif /* MOZILLA */

3rdparty/expat/xmlparse.h

@@ -0,0 +1,482 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+#ifndef XmlParse_INCLUDED
+#define XmlParse_INCLUDED 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef XMLPARSEAPI
+#define XMLPARSEAPI /* as nothing */
+#endif
+
+typedef void *XML_Parser;
+
+#ifdef XML_UNICODE_WCHAR_T
+
+/* XML_UNICODE_WCHAR_T will work only if sizeof(wchar_t) == 2 and wchar_t
+uses Unicode. */
+/* Information is UTF-16 encoded as wchar_ts */
+
+#ifndef XML_UNICODE
+#define XML_UNICODE
+#endif
+
+#include <stddef.h>
+typedef wchar_t XML_Char;
+typedef wchar_t XML_LChar;
+
+#else /* not XML_UNICODE_WCHAR_T */
+
+#ifdef XML_UNICODE
+
+/* Information is UTF-16 encoded as unsigned shorts */
+typedef unsigned short XML_Char;
+typedef char XML_LChar;
+
+#else /* not XML_UNICODE */
+
+/* Information is UTF-8 encoded. */
+typedef char XML_Char;
+typedef char XML_LChar;
+
+#endif /* not XML_UNICODE */
+
+#endif /* not XML_UNICODE_WCHAR_T */
+
+
+/* Constructs a new parser; encoding is the encoding specified by the external
+protocol or null if there is none specified. */
+
+XML_Parser XMLPARSEAPI
+XML_ParserCreate(const XML_Char *encoding);
+
+/* Constructs a new parser and namespace processor.  Element type names
+and attribute names that belong to a namespace will be expanded;
+unprefixed attribute names are never expanded; unprefixed element type
+names are expanded only if there is a default namespace. The expanded
+name is the concatenation of the namespace URI, the namespace separator character,
+and the local part of the name.  If the namespace separator is '\0' then
+the namespace URI and the local part will be concatenated without any
+separator.  When a namespace is not declared, the name and prefix will be
+passed through without expansion. */
+
+XML_Parser XMLPARSEAPI
+XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
+
+
+/* atts is array of name/value pairs, terminated by 0;
+   names and values are 0 terminated. */
+
+typedef void (*XML_StartElementHandler)(void *userData,
+					const XML_Char *name,
+					const XML_Char **atts);
+
+typedef void (*XML_EndElementHandler)(void *userData,
+				      const XML_Char *name);
+
+/* s is not 0 terminated. */
+typedef void (*XML_CharacterDataHandler)(void *userData,
+					 const XML_Char *s,
+					 int len);
+
+/* target and data are 0 terminated */
+typedef void (*XML_ProcessingInstructionHandler)(void *userData,
+						 const XML_Char *target,
+						 const XML_Char *data);
+
+/* data is 0 terminated */
+typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data);
+
+typedef void (*XML_StartCdataSectionHandler)(void *userData);
+typedef void (*XML_EndCdataSectionHandler)(void *userData);
+
+/* This is called for any characters in the XML document for
+which there is no applicable handler.  This includes both
+characters that are part of markup which is of a kind that is
+not reported (comments, markup declarations), or characters
+that are part of a construct which could be reported but
+for which no handler has been supplied. The characters are passed
+exactly as they were in the XML document except that
+they will be encoded in UTF-8.  Line boundaries are not normalized.
+Note that a byte order mark character is not passed to the default handler.
+There are no guarantees about how characters are divided between calls
+to the default handler: for example, a comment might be split between
+multiple calls. */
+
+typedef void (*XML_DefaultHandler)(void *userData,
+				   const XML_Char *s,
+				   int len);
+
+/* This is called for a declaration of an unparsed (NDATA)
+entity.  The base argument is whatever was set by XML_SetBase.
+The entityName, systemId and notationName arguments will never be null.
+The other arguments may be. */
+
+typedef void (*XML_UnparsedEntityDeclHandler)(void *userData,
+					      const XML_Char *entityName,
+					      const XML_Char *base,
+					      const XML_Char *systemId,
+					      const XML_Char *publicId,
+					      const XML_Char *notationName);
+
+/* This is called for a declaration of notation.
+The base argument is whatever was set by XML_SetBase.
+The notationName will never be null.  The other arguments can be. */
+
+typedef void (*XML_NotationDeclHandler)(void *userData,
+					const XML_Char *notationName,
+					const XML_Char *base,
+					const XML_Char *systemId,
+					const XML_Char *publicId);
+
+/* When namespace processing is enabled, these are called once for
+each namespace declaration. The call to the start and end element
+handlers occur between the calls to the start and end namespace
+declaration handlers. For an xmlns attribute, prefix will be null.
+For an xmlns="" attribute, uri will be null. */
+
+typedef void (*XML_StartNamespaceDeclHandler)(void *userData,
+					      const XML_Char *prefix,
+					      const XML_Char *uri);
+
+typedef void (*XML_EndNamespaceDeclHandler)(void *userData,
+					    const XML_Char *prefix);
+
+/* This is called if the document is not standalone (it has an
+external subset or a reference to a parameter entity, but does not
+have standalone="yes"). If this handler returns 0, then processing
+will not continue, and the parser will return a
+XML_ERROR_NOT_STANDALONE error. */
+
+typedef int (*XML_NotStandaloneHandler)(void *userData);
+
+/* This is called for a reference to an external parsed general entity.
+The referenced entity is not automatically parsed.
+The application can parse it immediately or later using
+XML_ExternalEntityParserCreate.
+The parser argument is the parser parsing the entity containing the reference;
+it can be passed as the parser argument to XML_ExternalEntityParserCreate.
+The systemId argument is the system identifier as specified in the entity declaration;
+it will not be null.
+The base argument is the system identifier that should be used as the base for
+resolving systemId if systemId was relative; this is set by XML_SetBase;
+it may be null.
+The publicId argument is the public identifier as specified in the entity declaration,
+or null if none was specified; the whitespace in the public identifier
+will have been normalized as required by the XML spec.
+The context argument specifies the parsing context in the format
+expected by the context argument to
+XML_ExternalEntityParserCreate; context is valid only until the handler
+returns, so if the referenced entity is to be parsed later, it must be copied.
+The handler should return 0 if processing should not continue because of
+a fatal error in the handling of the external entity.
+In this case the calling parser will return an XML_ERROR_EXTERNAL_ENTITY_HANDLING
+error.
+Note that unlike other handlers the first argument is the parser, not userData. */
+
+typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser,
+					    const XML_Char *context,
+					    const XML_Char *base,
+					    const XML_Char *systemId,
+					    const XML_Char *publicId);
+
+/* This structure is filled in by the XML_UnknownEncodingHandler
+to provide information to the parser about encodings that are unknown
+to the parser.
+The map[b] member gives information about byte sequences
+whose first byte is b.
+If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar value c.
+If map[b] is -1, then the byte sequence is malformed.
+If map[b] is -n, where n >= 2, then b is the first byte of an n-byte
+sequence that encodes a single Unicode scalar value.
+The data member will be passed as the first argument to the convert function.
+The convert function is used to convert multibyte sequences;
+s will point to a n-byte sequence where map[(unsigned char)*s] == -n.
+The convert function must return the Unicode scalar value
+represented by this byte sequence or -1 if the byte sequence is malformed.
+The convert function may be null if the encoding is a single-byte encoding,
+that is if map[b] >= -1 for all bytes b.
+When the parser is finished with the encoding, then if release is not null,
+it will call release passing it the data member;
+once release has been called, the convert function will not be called again.
+
+Expat places certain restrictions on the encodings that are supported
+using this mechanism.
+
+1. Every ASCII character that can appear in a well-formed XML document,
+other than the characters
+
+  $@\^`{}~
+
+must be represented by a single byte, and that byte must be the
+same byte that represents that character in ASCII.
+
+2. No character may require more than 4 bytes to encode.
+
+3. All characters encoded must have Unicode scalar values <= 0xFFFF,
+(ie characters that would be encoded by surrogates in UTF-16
+are  not allowed).  Note that this restriction doesn't apply to
+the built-in support for UTF-8 and UTF-16.
+
+4. No Unicode character may be encoded by more than one distinct sequence
+of bytes. */
+
+typedef struct {
+  int map[256];
+  void *data;
+  int (*convert)(void *data, const char *s);
+  void (*release)(void *data);
+} XML_Encoding;
+
+/* This is called for an encoding that is unknown to the parser.
+The encodingHandlerData argument is that which was passed as the
+second argument to XML_SetUnknownEncodingHandler.
+The name argument gives the name of the encoding as specified in
+the encoding declaration.
+If the callback can provide information about the encoding,
+it must fill in the XML_Encoding structure, and return 1.
+Otherwise it must return 0.
+If info does not describe a suitable encoding,
+then the parser will return an XML_UNKNOWN_ENCODING error. */
+
+typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData,
+					  const XML_Char *name,
+					  XML_Encoding *info);
+
+void XMLPARSEAPI
+XML_SetElementHandler(XML_Parser parser,
+		      XML_StartElementHandler start,
+		      XML_EndElementHandler end);
+
+void XMLPARSEAPI
+XML_SetCharacterDataHandler(XML_Parser parser,
+			    XML_CharacterDataHandler handler);
+
+void XMLPARSEAPI
+XML_SetProcessingInstructionHandler(XML_Parser parser,
+				    XML_ProcessingInstructionHandler handler);
+void XMLPARSEAPI
+XML_SetCommentHandler(XML_Parser parser,
+                      XML_CommentHandler handler);
+
+void XMLPARSEAPI
+XML_SetCdataSectionHandler(XML_Parser parser,
+			   XML_StartCdataSectionHandler start,
+			   XML_EndCdataSectionHandler end);
+
+/* This sets the default handler and also inhibits expansion of internal entities.
+The entity reference will be passed to the default handler. */
+
+void XMLPARSEAPI
+XML_SetDefaultHandler(XML_Parser parser,
+		      XML_DefaultHandler handler);
+
+/* This sets the default handler but does not inhibit expansion of internal entities.
+The entity reference will not be passed to the default handler. */
+
+void XMLPARSEAPI
+XML_SetDefaultHandlerExpand(XML_Parser parser,
+		            XML_DefaultHandler handler);
+
+void XMLPARSEAPI
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+				 XML_UnparsedEntityDeclHandler handler);
+
+void XMLPARSEAPI
+XML_SetNotationDeclHandler(XML_Parser parser,
+			   XML_NotationDeclHandler handler);
+
+void XMLPARSEAPI
+XML_SetNamespaceDeclHandler(XML_Parser parser,
+			    XML_StartNamespaceDeclHandler start,
+			    XML_EndNamespaceDeclHandler end);
+
+void XMLPARSEAPI
+XML_SetNotStandaloneHandler(XML_Parser parser,
+			    XML_NotStandaloneHandler handler);
+
+void XMLPARSEAPI
+XML_SetExternalEntityRefHandler(XML_Parser parser,
+				XML_ExternalEntityRefHandler handler);
+
+/* If a non-null value for arg is specified here, then it will be passed
+as the first argument to the external entity ref handler instead
+of the parser object. */
+void XMLPARSEAPI
+XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg);
+
+void XMLPARSEAPI
+XML_SetUnknownEncodingHandler(XML_Parser parser,
+			      XML_UnknownEncodingHandler handler,
+			      void *encodingHandlerData);
+
+/* This can be called within a handler for a start element, end element,
+processing instruction or character data.  It causes the corresponding
+markup to be passed to the default handler. */
+void XMLPARSEAPI XML_DefaultCurrent(XML_Parser parser);
+
+/* This value is passed as the userData argument to callbacks. */
+void XMLPARSEAPI
+XML_SetUserData(XML_Parser parser, void *userData);
+
+/* Returns the last value set by XML_SetUserData or null. */
+#define XML_GetUserData(parser) (*(void **)(parser))
+
+/* This is equivalent to supplying an encoding argument
+to XML_CreateParser. It must not be called after XML_Parse
+or XML_ParseBuffer. */
+
+int XMLPARSEAPI
+XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
+
+/* If this function is called, then the parser will be passed
+as the first argument to callbacks instead of userData.
+The userData will still be accessible using XML_GetUserData. */
+
+void XMLPARSEAPI
+XML_UseParserAsHandlerArg(XML_Parser parser);
+
+/* Sets the base to be used for resolving relative URIs in system identifiers in
+declarations.  Resolving relative identifiers is left to the application:
+this value will be passed through as the base argument to the
+XML_ExternalEntityRefHandler, XML_NotationDeclHandler
+and XML_UnparsedEntityDeclHandler. The base argument will be copied.
+Returns zero if out of memory, non-zero otherwise. */
+
+int XMLPARSEAPI
+XML_SetBase(XML_Parser parser, const XML_Char *base);
+
+const XML_Char XMLPARSEAPI *
+XML_GetBase(XML_Parser parser);
+
+/* Returns the number of the attributes passed in last call to the
+XML_StartElementHandler that were specified in the start-tag rather
+than defaulted. */
+
+int XMLPARSEAPI XML_GetSpecifiedAttributeCount(XML_Parser parser);
+
+/* Parses some input. Returns 0 if a fatal error is detected.
+The last call to XML_Parse must have isFinal true;
+len may be zero for this call (or any other). */
+int XMLPARSEAPI
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
+
+void XMLPARSEAPI *
+XML_GetBuffer(XML_Parser parser, int len);
+
+int XMLPARSEAPI
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
+
+/* Creates an XML_Parser object that can parse an external general entity;
+context is a '\0'-terminated string specifying the parse context;
+encoding is a '\0'-terminated string giving the name of the externally specified encoding,
+or null if there is no externally specified encoding.
+The context string consists of a sequence of tokens separated by formfeeds (\f);
+a token consisting of a name specifies that the general entity of the name
+is open; a token of the form prefix=uri specifies the namespace for a particular
+prefix; a token of the form =uri specifies the default namespace.
+This can be called at any point after the first call to an ExternalEntityRefHandler
+so longer as the parser has not yet been freed.
+The new parser is completely independent and may safely be used in a separate thread.
+The handlers and userData are initialized from the parser argument.
+Returns 0 if out of memory.  Otherwise returns a new XML_Parser object. */
+XML_Parser XMLPARSEAPI
+XML_ExternalEntityParserCreate(XML_Parser parser,
+			       const XML_Char *context,
+			       const XML_Char *encoding);
+
+enum XML_Error {
+  XML_ERROR_NONE,
+  XML_ERROR_NO_MEMORY,
+  XML_ERROR_SYNTAX,
+  XML_ERROR_NO_ELEMENTS,
+  XML_ERROR_INVALID_TOKEN,
+  XML_ERROR_UNCLOSED_TOKEN,
+  XML_ERROR_PARTIAL_CHAR,
+  XML_ERROR_TAG_MISMATCH,
+  XML_ERROR_DUPLICATE_ATTRIBUTE,
+  XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
+  XML_ERROR_PARAM_ENTITY_REF,
+  XML_ERROR_UNDEFINED_ENTITY,
+  XML_ERROR_RECURSIVE_ENTITY_REF,
+  XML_ERROR_ASYNC_ENTITY,
+  XML_ERROR_BAD_CHAR_REF,
+  XML_ERROR_BINARY_ENTITY_REF,
+  XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
+  XML_ERROR_MISPLACED_XML_PI,
+  XML_ERROR_UNKNOWN_ENCODING,
+  XML_ERROR_INCORRECT_ENCODING,
+  XML_ERROR_UNCLOSED_CDATA_SECTION,
+  XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+  XML_ERROR_NOT_STANDALONE
+};
+
+/* If XML_Parse or XML_ParseBuffer have returned 0, then XML_GetErrorCode
+returns information about the error. */
+
+enum XML_Error XMLPARSEAPI XML_GetErrorCode(XML_Parser parser);
+
+/* These functions return information about the current parse location.
+They may be called when XML_Parse or XML_ParseBuffer return 0;
+in this case the location is the location of the character at which
+the error was detected.
+They may also be called from any other callback called to report
+some parse event; in this the location is the location of the first
+of the sequence of characters that generated the event. */
+
+int XMLPARSEAPI XML_GetCurrentLineNumber(XML_Parser parser);
+int XMLPARSEAPI XML_GetCurrentColumnNumber(XML_Parser parser);
+long XMLPARSEAPI XML_GetCurrentByteIndex(XML_Parser parser);
+
+/* Return the number of bytes in the current event.
+Returns 0 if the event is in an internal entity. */
+
+int XMLPARSEAPI XML_GetCurrentByteCount(XML_Parser parser);
+
+/* For backwards compatibility with previous versions. */
+#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
+#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
+#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
+
+/* Frees memory used by the parser. */
+void XMLPARSEAPI
+XML_ParserFree(XML_Parser parser);
+
+/* Returns a string describing the error. */
+const XML_LChar XMLPARSEAPI *XML_ErrorString(int code);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlParse_INCLUDED */

3rdparty/expat/xmlrole.h

@@ -0,0 +1,114 @@
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
+*/
+
+#ifndef XmlRole_INCLUDED
+#define XmlRole_INCLUDED 1
+
+#ifdef __VMS
+/*      0        1         2         3      0        1         2         3
+        1234567890123456789012345678901     1234567890123456789012345678901 */
+#define XmlPrologStateInitExternalEntity    XmlPrologStateInitExternalEnt
+#endif
+
+#include "xmltok.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  XML_ROLE_ERROR = -1,
+  XML_ROLE_NONE = 0,
+  XML_ROLE_XML_DECL,
+  XML_ROLE_INSTANCE_START,
+  XML_ROLE_DOCTYPE_NONE,
+  XML_ROLE_DOCTYPE_NAME,
+  XML_ROLE_DOCTYPE_SYSTEM_ID,
+  XML_ROLE_DOCTYPE_PUBLIC_ID,
+  XML_ROLE_DOCTYPE_INTERNAL_SUBSET,
+  XML_ROLE_DOCTYPE_CLOSE,
+  XML_ROLE_GENERAL_ENTITY_NAME,
+  XML_ROLE_PARAM_ENTITY_NAME,
+  XML_ROLE_ENTITY_NONE,
+  XML_ROLE_ENTITY_VALUE,
+  XML_ROLE_ENTITY_SYSTEM_ID,
+  XML_ROLE_ENTITY_PUBLIC_ID,
+  XML_ROLE_ENTITY_COMPLETE,
+  XML_ROLE_ENTITY_NOTATION_NAME,
+  XML_ROLE_NOTATION_NONE,
+  XML_ROLE_NOTATION_NAME,
+  XML_ROLE_NOTATION_SYSTEM_ID,
+  XML_ROLE_NOTATION_NO_SYSTEM_ID,
+  XML_ROLE_NOTATION_PUBLIC_ID,
+  XML_ROLE_ATTRIBUTE_NAME,
+  XML_ROLE_ATTRIBUTE_TYPE_CDATA,
+  XML_ROLE_ATTRIBUTE_TYPE_ID,
+  XML_ROLE_ATTRIBUTE_TYPE_IDREF,
+  XML_ROLE_ATTRIBUTE_TYPE_IDREFS,
+  XML_ROLE_ATTRIBUTE_TYPE_ENTITY,
+  XML_ROLE_ATTRIBUTE_TYPE_ENTITIES,
+  XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN,
+  XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS,
+  XML_ROLE_ATTRIBUTE_ENUM_VALUE,
+  XML_ROLE_ATTRIBUTE_NOTATION_VALUE,
+  XML_ROLE_ATTLIST_NONE,
+  XML_ROLE_ATTLIST_ELEMENT_NAME,
+  XML_ROLE_IMPLIED_ATTRIBUTE_VALUE,
+  XML_ROLE_REQUIRED_ATTRIBUTE_VALUE,
+  XML_ROLE_DEFAULT_ATTRIBUTE_VALUE,
+  XML_ROLE_FIXED_ATTRIBUTE_VALUE,
+  XML_ROLE_ELEMENT_NONE,
+  XML_ROLE_ELEMENT_NAME,
+  XML_ROLE_CONTENT_ANY,
+  XML_ROLE_CONTENT_EMPTY,
+  XML_ROLE_CONTENT_PCDATA,
+  XML_ROLE_GROUP_OPEN,
+  XML_ROLE_GROUP_CLOSE,
+  XML_ROLE_GROUP_CLOSE_REP,
+  XML_ROLE_GROUP_CLOSE_OPT,
+  XML_ROLE_GROUP_CLOSE_PLUS,
+  XML_ROLE_GROUP_CHOICE,
+  XML_ROLE_GROUP_SEQUENCE,
+  XML_ROLE_CONTENT_ELEMENT,
+  XML_ROLE_CONTENT_ELEMENT_REP,
+  XML_ROLE_CONTENT_ELEMENT_OPT,
+  XML_ROLE_CONTENT_ELEMENT_PLUS,
+  XML_ROLE_PI,
+  XML_ROLE_COMMENT,
+#ifdef XML_DTD
+  XML_ROLE_TEXT_DECL,
+  XML_ROLE_IGNORE_SECT,
+  XML_ROLE_INNER_PARAM_ENTITY_REF,
+#endif /* XML_DTD */
+  XML_ROLE_PARAM_ENTITY_REF
+};
+
+typedef struct prolog_state {
+  int (PTRCALL *handler) (struct prolog_state *state,
+                          int tok,
+                          const char *ptr,
+                          const char *end,
+                          const ENCODING *enc);
+  unsigned level;
+  int role_none;
+#ifdef XML_DTD
+  unsigned includeLevel;
+  int documentEntity;
+  int inEntityValue;
+#endif /* XML_DTD */
+} PROLOG_STATE;
+
+void XmlPrologStateInit(PROLOG_STATE *);
+#ifdef XML_DTD
+void XmlPrologStateInitExternalEntity(PROLOG_STATE *);
+#endif /* XML_DTD */
+
+#define XmlTokenRole(state, tok, ptr, end, enc) \
+ (((state)->handler)(state, tok, ptr, end, enc))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlRole_INCLUDED */

3rdparty/expat/xmltok.h

@@ -0,0 +1,316 @@
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
+*/
+
+#ifndef XmlTok_INCLUDED
+#define XmlTok_INCLUDED 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The following token may be returned by XmlContentTok */
+#define XML_TOK_TRAILING_RSQB -5 /* ] or ]] at the end of the scan; might be
+                                    start of illegal ]]> sequence */
+/* The following tokens may be returned by both XmlPrologTok and
+   XmlContentTok.
+*/
+#define XML_TOK_NONE -4          /* The string to be scanned is empty */
+#define XML_TOK_TRAILING_CR -3   /* A CR at the end of the scan;
+                                    might be part of CRLF sequence */
+#define XML_TOK_PARTIAL_CHAR -2  /* only part of a multibyte sequence */
+#define XML_TOK_PARTIAL -1       /* only part of a token */
+#define XML_TOK_INVALID 0
+
+/* The following tokens are returned by XmlContentTok; some are also
+   returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok.
+*/
+#define XML_TOK_START_TAG_WITH_ATTS 1
+#define XML_TOK_START_TAG_NO_ATTS 2
+#define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag <e/> */
+#define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4
+#define XML_TOK_END_TAG 5
+#define XML_TOK_DATA_CHARS 6
+#define XML_TOK_DATA_NEWLINE 7
+#define XML_TOK_CDATA_SECT_OPEN 8
+#define XML_TOK_ENTITY_REF 9
+#define XML_TOK_CHAR_REF 10               /* numeric character reference */
+
+/* The following tokens may be returned by both XmlPrologTok and
+   XmlContentTok.
+*/
+#define XML_TOK_PI 11                     /* processing instruction */
+#define XML_TOK_XML_DECL 12               /* XML decl or text decl */
+#define XML_TOK_COMMENT 13
+#define XML_TOK_BOM 14                    /* Byte order mark */
+
+/* The following tokens are returned only by XmlPrologTok */
+#define XML_TOK_PROLOG_S 15
+#define XML_TOK_DECL_OPEN 16              /* <!foo */
+#define XML_TOK_DECL_CLOSE 17             /* > */
+#define XML_TOK_NAME 18
+#define XML_TOK_NMTOKEN 19
+#define XML_TOK_POUND_NAME 20             /* #name */
+#define XML_TOK_OR 21                     /* | */
+#define XML_TOK_PERCENT 22
+#define XML_TOK_OPEN_PAREN 23
+#define XML_TOK_CLOSE_PAREN 24
+#define XML_TOK_OPEN_BRACKET 25
+#define XML_TOK_CLOSE_BRACKET 26
+#define XML_TOK_LITERAL 27
+#define XML_TOK_PARAM_ENTITY_REF 28
+#define XML_TOK_INSTANCE_START 29
+
+/* The following occur only in element type declarations */
+#define XML_TOK_NAME_QUESTION 30          /* name? */
+#define XML_TOK_NAME_ASTERISK 31          /* name* */
+#define XML_TOK_NAME_PLUS 32              /* name+ */
+#define XML_TOK_COND_SECT_OPEN 33         /* <![ */
+#define XML_TOK_COND_SECT_CLOSE 34        /* ]]> */
+#define XML_TOK_CLOSE_PAREN_QUESTION 35   /* )? */
+#define XML_TOK_CLOSE_PAREN_ASTERISK 36   /* )* */
+#define XML_TOK_CLOSE_PAREN_PLUS 37       /* )+ */
+#define XML_TOK_COMMA 38
+
+/* The following token is returned only by XmlAttributeValueTok */
+#define XML_TOK_ATTRIBUTE_VALUE_S 39
+
+/* The following token is returned only by XmlCdataSectionTok */
+#define XML_TOK_CDATA_SECT_CLOSE 40
+
+/* With namespace processing this is returned by XmlPrologTok for a
+   name with a colon.
+*/
+#define XML_TOK_PREFIXED_NAME 41
+
+#ifdef XML_DTD
+#define XML_TOK_IGNORE_SECT 42
+#endif /* XML_DTD */
+
+#ifdef XML_DTD
+#define XML_N_STATES 4
+#else /* not XML_DTD */
+#define XML_N_STATES 3
+#endif /* not XML_DTD */
+
+#define XML_PROLOG_STATE 0
+#define XML_CONTENT_STATE 1
+#define XML_CDATA_SECTION_STATE 2
+#ifdef XML_DTD
+#define XML_IGNORE_SECTION_STATE 3
+#endif /* XML_DTD */
+
+#define XML_N_LITERAL_TYPES 2
+#define XML_ATTRIBUTE_VALUE_LITERAL 0
+#define XML_ENTITY_VALUE_LITERAL 1
+
+/* The size of the buffer passed to XmlUtf8Encode must be at least this. */
+#define XML_UTF8_ENCODE_MAX 4
+/* The size of the buffer passed to XmlUtf16Encode must be at least this. */
+#define XML_UTF16_ENCODE_MAX 2
+
+typedef struct position {
+  /* first line and first column are 0 not 1 */
+  XML_Size lineNumber;
+  XML_Size columnNumber;
+} POSITION;
+
+typedef struct {
+  const char *name;
+  const char *valuePtr;
+  const char *valueEnd;
+  char normalized;
+} ATTRIBUTE;
+
+struct encoding;
+typedef struct encoding ENCODING;
+
+typedef int (PTRCALL *SCANNER)(const ENCODING *,
+                               const char *,
+                               const char *,
+                               const char **);
+
+struct encoding {
+  SCANNER scanners[XML_N_STATES];
+  SCANNER literalScanners[XML_N_LITERAL_TYPES];
+  int (PTRCALL *sameName)(const ENCODING *,
+                          const char *,
+                          const char *);
+  int (PTRCALL *nameMatchesAscii)(const ENCODING *,
+                                  const char *,
+                                  const char *,
+                                  const char *);
+  int (PTRFASTCALL *nameLength)(const ENCODING *, const char *);
+  const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *);
+  int (PTRCALL *getAtts)(const ENCODING *enc,
+                         const char *ptr,
+                         int attsMax,
+                         ATTRIBUTE *atts);
+  int (PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
+  int (PTRCALL *predefinedEntityName)(const ENCODING *,
+                                      const char *,
+                                      const char *);
+  void (PTRCALL *updatePosition)(const ENCODING *,
+                                 const char *ptr,
+                                 const char *end,
+                                 POSITION *);
+  int (PTRCALL *isPublicId)(const ENCODING *enc,
+                            const char *ptr,
+                            const char *end,
+                            const char **badPtr);
+  void (PTRCALL *utf8Convert)(const ENCODING *enc,
+                              const char **fromP,
+                              const char *fromLim,
+                              char **toP,
+                              const char *toLim);
+  void (PTRCALL *utf16Convert)(const ENCODING *enc,
+                               const char **fromP,
+                               const char *fromLim,
+                               unsigned short **toP,
+                               const unsigned short *toLim);
+  int minBytesPerChar;
+  char isUtf8;
+  char isUtf16;
+};
+
+/* Scan the string starting at ptr until the end of the next complete
+   token, but do not scan past eptr.  Return an integer giving the
+   type of token.
+
+   Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set.
+
+   Return XML_TOK_PARTIAL when the string does not contain a complete
+   token; nextTokPtr will not be set.
+
+   Return XML_TOK_INVALID when the string does not start a valid
+   token; nextTokPtr will be set to point to the character which made
+   the token invalid.
+
+   Otherwise the string starts with a valid token; nextTokPtr will be
+   set to point to the character following the end of that token.
+
+   Each data character counts as a single token, but adjacent data
+   characters may be returned together.  Similarly for characters in
+   the prolog outside literals, comments and processing instructions.
+*/
+
+
+#define XmlTok(enc, state, ptr, end, nextTokPtr) \
+  (((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
+
+#define XmlPrologTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
+
+#define XmlContentTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
+
+#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
+
+#ifdef XML_DTD
+
+#define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
+
+#endif /* XML_DTD */
+
+/* This is used for performing a 2nd-level tokenization on the content
+   of a literal that has already been returned by XmlTok.
+*/
+#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr) \
+  (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))
+
+#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr) \
+   XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlEntityValueTok(enc, ptr, end, nextTokPtr) \
+   XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlSameName(enc, ptr1, ptr2) (((enc)->sameName)(enc, ptr1, ptr2))
+
+#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \
+  (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
+
+#define XmlNameLength(enc, ptr) \
+  (((enc)->nameLength)(enc, ptr))
+
+#define XmlSkipS(enc, ptr) \
+  (((enc)->skipS)(enc, ptr))
+
+#define XmlGetAttributes(enc, ptr, attsMax, atts) \
+  (((enc)->getAtts)(enc, ptr, attsMax, atts))
+
+#define XmlCharRefNumber(enc, ptr) \
+  (((enc)->charRefNumber)(enc, ptr))
+
+#define XmlPredefinedEntityName(enc, ptr, end) \
+  (((enc)->predefinedEntityName)(enc, ptr, end))
+
+#define XmlUpdatePosition(enc, ptr, end, pos) \
+  (((enc)->updatePosition)(enc, ptr, end, pos))
+
+#define XmlIsPublicId(enc, ptr, end, badPtr) \
+  (((enc)->isPublicId)(enc, ptr, end, badPtr))
+
+#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim) \
+  (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
+
+#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim) \
+  (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
+
+typedef struct {
+  ENCODING initEnc;
+  const ENCODING **encPtr;
+} INIT_ENCODING;
+
+int XmlParseXmlDecl(int isGeneralTextEntity,
+                    const ENCODING *enc,
+                    const char *ptr,
+                    const char *end,
+                    const char **badPtr,
+                    const char **versionPtr,
+                    const char **versionEndPtr,
+                    const char **encodingNamePtr,
+                    const ENCODING **namedEncodingPtr,
+                    int *standalonePtr);
+
+int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
+const ENCODING *XmlGetUtf8InternalEncoding(void);
+const ENCODING *XmlGetUtf16InternalEncoding(void);
+int FASTCALL XmlUtf8Encode(int charNumber, char *buf);
+int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);
+int XmlSizeOfUnknownEncoding(void);
+
+
+typedef int (XMLCALL *CONVERTER) (void *userData, const char *p);
+
+ENCODING *
+XmlInitUnknownEncoding(void *mem,
+                       int *table,
+                       CONVERTER convert,
+                       void *userData);
+
+int XmlParseXmlDeclNS(int isGeneralTextEntity,
+                      const ENCODING *enc,
+                      const char *ptr,
+                      const char *end,
+                      const char **badPtr,
+                      const char **versionPtr,
+                      const char **versionEndPtr,
+                      const char **encodingNamePtr,
+                      const ENCODING **namedEncodingPtr,
+                      int *standalonePtr);
+
+int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
+const ENCODING *XmlGetUtf8InternalEncodingNS(void);
+const ENCODING *XmlGetUtf16InternalEncodingNS(void);
+ENCODING *
+XmlInitUnknownEncodingNS(void *mem,
+                         int *table,
+                         CONVERTER convert,
+                         void *userData);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlTok_INCLUDED */

3rdparty/expat/xmltok_impl.h

@@ -0,0 +1,71 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+enum {
+  BT_NONXML,
+  BT_MALFORM,
+  BT_LT,
+  BT_AMP,
+  BT_RSQB,
+  BT_LEAD2,
+  BT_LEAD3,
+  BT_LEAD4,
+  BT_TRAIL,
+  BT_CR,
+  BT_LF,
+  BT_GT,
+  BT_QUOT,
+  BT_APOS,
+  BT_EQUALS,
+  BT_QUEST,
+  BT_EXCL,
+  BT_SOL,
+  BT_SEMI,
+  BT_NUM,
+  BT_LSQB,
+  BT_S,
+  BT_NMSTRT,
+  BT_COLON,
+  BT_HEX,
+  BT_DIGIT,
+  BT_NAME,
+  BT_MINUS,
+  BT_OTHER, /* known not to be a name or name start character */
+  BT_NONASCII, /* might be a name or name start character */
+  BT_PERCNT,
+  BT_LPAR,
+  BT_RPAR,
+  BT_AST,
+  BT_PLUS,
+  BT_COMMA,
+  BT_VERBAR
+};
+
+#include <stddef.h>

3rdparty/expat/xmltok_ns.c

@@ -0,0 +1,115 @@
+/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+   See the file COPYING for copying permission.
+*/
+
+/* This file is included! */
+#ifdef XML_TOK_NS_C
+
+const ENCODING *
+NS(XmlGetUtf8InternalEncoding)(void)
+{
+  return &ns(internal_utf8_encoding).enc;
+}
+
+const ENCODING *
+NS(XmlGetUtf16InternalEncoding)(void)
+{
+#if BYTEORDER == 1234
+  return &ns(internal_little2_encoding).enc;
+#elif BYTEORDER == 4321
+  return &ns(internal_big2_encoding).enc;
+#else
+  const short n = 1;
+  return (*(const char *)&n
+          ? &ns(internal_little2_encoding).enc
+          : &ns(internal_big2_encoding).enc);
+#endif
+}
+
+static const ENCODING * const NS(encodings)[] = {
+  &ns(latin1_encoding).enc,
+  &ns(ascii_encoding).enc,
+  &ns(utf8_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(little2_encoding).enc,
+  &ns(utf8_encoding).enc /* NO_ENC */
+};
+
+static int PTRCALL
+NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc,
+                  XML_PROLOG_STATE, ptr, end, nextTokPtr);
+}
+
+static int PTRCALL
+NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc,
+                  XML_CONTENT_STATE, ptr, end, nextTokPtr);
+}
+
+int
+NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
+                    const char *name)
+{
+  int i = getEncodingIndex(name);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  SET_INIT_ENC_INDEX(p, i);
+  p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
+  p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
+  p->initEnc.updatePosition = initUpdatePosition;
+  p->encPtr = encPtr;
+  *encPtr = &(p->initEnc);
+  return 1;
+}
+
+static const ENCODING *
+NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
+{
+#define ENCODING_MAX 128
+  char buf[ENCODING_MAX];
+  char *p = buf;
+  int i;
+  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
+  if (ptr != end)
+    return 0;
+  *p = 0;
+  if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
+    return enc;
+  i = getEncodingIndex(buf);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  return NS(encodings)[i];
+}
+
+int
+NS(XmlParseXmlDecl)(int isGeneralTextEntity,
+                    const ENCODING *enc,
+                    const char *ptr,
+                    const char *end,
+                    const char **badPtr,
+                    const char **versionPtr,
+                    const char **versionEndPtr,
+                    const char **encodingName,
+                    const ENCODING **encoding,
+                    int *standalone)
+{
+  return doParseXmlDecl(NS(findEncoding),
+                        isGeneralTextEntity,
+                        enc,
+                        ptr,
+                        end,
+                        badPtr,
+                        versionPtr,
+                        versionEndPtr,
+                        encodingName,
+                        encoding,
+                        standalone);
+}
+
+#endif /* XML_TOK_NS_C */

AUTHORS

@@ -0,0 +1 @@
+Curtis Olsen and others.

CMakeLists.txt

@@ -0,0 +1,401 @@
+cmake_minimum_required (VERSION 2.6.4)
+include (CheckFunctionExists)
+include (CheckIncludeFile)
+include (CheckCXXSourceCompiles)
+include (CheckCXXCompilerFlag)
+
+project(SimGear)
+
+# read 'version' file into a variable (stripping any newlines or spaces)
+file(READ version versionFile)
+string(STRIP ${versionFile} SIMGEAR_VERSION)
+
+set(FIND_LIBRARY_USE_LIB64_PATHS ON)
+
+# use simgear version also as the SO version (if building SOs)
+SET(SIMGEAR_SOVERSION ${SIMGEAR_VERSION})
+
+# Warning when build is not an out-of-source build.
+string(COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" InSourceBuild)
+if(InSourceBuild)
+    message(WARNING  "Avoid building inside the source tree!")
+    message(WARNING  "Create a separate build directory instead (i.e. 'sgbuild') and call CMake from there: ")
+    message(WARNING  "  mkdir ../sgbuild && cd ../sgbuild && cmake ${CMAKE_SOURCE_DIR}")
+endif(InSourceBuild)
+
+#packaging
+SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/COPYING")
+SET(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README")
+SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simulation support libraries for FlightGear and related projects")
+SET(CPACK_PACKAGE_VENDOR "The FlightGear project")
+SET(CPACK_GENERATOR "TBZ2")
+SET(CPACK_INSTALL_CMAKE_PROJECTS  ${CMAKE_CURRENT_BINARY_DIR};SimGear;ALL;/)
+
+
+# split version string into components, note CMAKE_MATCH_0 is the entire regexp match
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)\\.([0-9]+)" CPACK_PACKAGE_VERSION ${SIMGEAR_VERSION} )
+set(CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1}) 
+set(CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+set(CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+
+message(STATUS "version is ${CPACK_PACKAGE_VERSION_MAJOR} dot ${CPACK_PACKAGE_VERSION_MINOR} dot ${CPACK_PACKAGE_VERSION_PATCH}")
+
+set(CPACK_SOURCE_GENERATOR TBZ2)
+set(CPACK_SOURCE_PACKAGE_FILE_NAME "simgear-${SIMGEAR_VERSION}" CACHE INTERNAL "tarball basename")
+set(CPACK_SOURCE_IGNORE_FILES
+  "^${PROJECT_SOURCE_DIR}/.git;\\\\.gitignore;Makefile.am;~$;${CPACK_SOURCE_IGNORE_FILES}")
+
+message(STATUS "ignoring: ${CPACK_SOURCE_IGNORE_FILES}")
+
+include (CPack)
+
+# We have some custom .cmake scripts not in the official distribution.
+set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules;${CMAKE_MODULE_PATH}")
+
+# Change the default build type to something fast
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING
+      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
+      FORCE)
+endif(NOT CMAKE_BUILD_TYPE)
+
+# Determine name of library installation directory, i.e. "lib" vs "lib64", which
+# differs between all Debian-based vs all other Linux distros.
+# See cmake bug #11964, http://cmake.org/gitweb?p=cmake.git;a=commit;h=126c993d
+# GNUInstallDirs requires CMake >= 2.8.5, use own file for older cmake
+if(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
+  include(GNUInstallDirs)
+else(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
+  include(OldGNUInstallDirs)
+endif(${CMAKE_VERSION} VERSION_GREATER 2.8.4)
+message(STATUS "Library installation directory: ${CMAKE_INSTALL_LIBDIR}")
+
+#####################################################################################
+# Configure library search paths
+#####################################################################################
+
+if(NOT "${CMAKE_LIBRARY_ARCHITECTURE}" STREQUAL "")
+    # Workaround for Ubuntu/Debian which introduced the "multiarch" library
+    # directory structure, which is unsupported by CMake < 2.8.10, so we need to
+    # add paths manually
+    # see http://www.cmake.org/Bug/view.php?id=12049 and
+    # http://www.cmake.org/Bug/view.php?id=12037
+    list(APPEND ADDITIONAL_LIBRARY_PATHS
+         /usr/local/lib/${CMAKE_LIBRARY_ARCHITECTURE}
+         /usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}
+         /lib/${CMAKE_LIBRARY_ARCHITECTURE})
+    message(STATUS "additional library directories: ${ADDITIONAL_LIBRARY_PATHS}")
+endif()
+
+#####################################################################################
+
+if (NOT MSVC)
+option(SIMGEAR_SHARED   "Set to ON to build SimGear as a shared library/framework" OFF)
+option(SYSTEM_EXPAT     "Set to ON to build SimGear using the system libExpat" OFF)
+else()
+# Building SimGear DLLs is currently not supported for MSVC.
+set(SIMGEAR_SHARED OFF)
+# Using a system expat is currently not supported for MSVC - it would require shared simgear (DLL).
+set(SYSTEM_EXPAT OFF)
+endif()
+
+option(SIMGEAR_HEADLESS "Set to ON to build SimGear without GUI/graphics support" OFF)
+option(ENABLE_RTI       "Set to ON to build SimGear with RTI support" OFF)
+option(ENABLE_TESTS     "Set to OFF to disable building SimGear's test applications" ON)
+option(ENABLE_SOUND     "Set to OFF to disable building SimGear's sound support" ON)
+option(ENABLE_PKGUTIL   "Set to ON to build the sg_pkgutil application (default)" ON)
+
+if (MSVC)
+  GET_FILENAME_COMPONENT(PARENT_DIR ${PROJECT_BINARY_DIR} PATH)
+  if (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty.x64")
+  else (CMAKE_CL_64)
+    SET(TEST_3RDPARTY_DIR "${PARENT_DIR}/3rdparty")
+  endif (CMAKE_CL_64)
+  if (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT ${PARENT_DIR} CACHE PATH "Location where the third-party dependencies are extracted")
+  else (EXISTS ${TEST_3RDPARTY_DIR})
+    set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+  endif (EXISTS ${TEST_3RDPARTY_DIR})
+else (MSVC)
+  set(MSVC_3RDPARTY_ROOT NOT_FOUND CACHE PATH "Location where the third-party dependencies are extracted")
+endif (MSVC)
+
+if (MSVC AND MSVC_3RDPARTY_ROOT)
+  message(STATUS "3rdparty files located in ${MSVC_3RDPARTY_ROOT}")
+  set( OSG_MSVC "msvc" )
+  if (${MSVC_VERSION} EQUAL 1700)
+      set( OSG_MSVC ${OSG_MSVC}110 )
+  elseif (${MSVC_VERSION} EQUAL 1600)
+      set( OSG_MSVC ${OSG_MSVC}100 )
+  else (${MSVC_VERSION} EQUAL 1700)
+      set( OSG_MSVC ${OSG_MSVC}90 )
+  endif (${MSVC_VERSION} EQUAL 1700)
+  if (CMAKE_CL_64)
+      set( OSG_MSVC ${OSG_MSVC}-64 )
+      set( MSVC_3RDPARTY_DIR 3rdParty.x64 )
+  else (CMAKE_CL_64)
+      set( MSVC_3RDPARTY_DIR 3rdParty )
+  endif (CMAKE_CL_64)
+
+  set (CMAKE_LIBRARY_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/lib ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenRTI/lib )
+  set (CMAKE_INCLUDE_PATH ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenScenegraph/include ${MSVC_3RDPARTY_ROOT}/install/${OSG_MSVC}/OpenRTI/include)
+  find_path(BOOST_ROOT boost/version.hpp
+			${MSVC_3RDPARTY_ROOT}/boost
+			${MSVC_3RDPARTY_ROOT}/boost_1_52_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_51_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_50_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_49_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_48_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_47_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_46_1
+			${MSVC_3RDPARTY_ROOT}/boost_1_46_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_45_0
+			${MSVC_3RDPARTY_ROOT}/boost_1_44_0
+			)
+  # set (BOOST_ROOT ${MSVC_3RDPARTY_ROOT}/boost_1_44_0)
+  message(STATUS "BOOST_ROOT is ${BOOST_ROOT}")
+  set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
+  set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib)
+endif (MSVC AND MSVC_3RDPARTY_ROOT)
+
+if(APPLE)
+  find_library(COCOA_LIBRARY Cocoa)
+endif()
+
+# Somehow this only works if included before searching for Boost...
+include(BoostTestTargets)
+
+find_package(Boost REQUIRED)
+set (BOOST_CXX_FLAGS "-DBOOST_MULTI_INDEX_DISABLE_SERIALIZATION -DBOOST_BIMAP_DISABLE_SERIALIZATION")
+
+if(SIMGEAR_HEADLESS)
+    message(STATUS "SimGear mode: HEADLESS")
+    set(ENABLE_SOUND 0)
+else()
+    message(STATUS "SimGear mode: NORMAL")
+    find_package(OpenGL REQUIRED)
+    
+    if (ENABLE_SOUND)
+        find_package(OpenAL REQUIRED)
+        message(STATUS "Sound support: ENABLED")
+    endif(ENABLE_SOUND)
+    
+    find_package(OpenSceneGraph 3.2.0 REQUIRED osgText osgSim osgDB osgParticle osgGA osgUtil)
+endif(SIMGEAR_HEADLESS)
+
+find_package(ZLIB REQUIRED)
+find_package(Threads REQUIRED)
+
+if (SYSTEM_EXPAT)
+    message(STATUS "Requested to use system Expat library, forcing SIMGEAR_SHARED to true")
+    set(SIMGEAR_SHARED ON)
+    find_package(EXPAT REQUIRED)
+
+else()
+    message(STATUS "Using built-in expat code")
+    # XML_STATIC is important to avoid sg_expat_external.h
+    # declaring symbols as declspec(import)
+    add_definitions(-DHAVE_EXPAT_CONFIG_H -DXML_STATIC)
+    set(EXPAT_INCLUDE_DIRS 
+	    ${PROJECT_SOURCE_DIR}/3rdparty/expat 
+	    ${PROJECT_BINARY_DIR}/3rdparty/expat)
+endif(SYSTEM_EXPAT)
+
+include_directories(${EXPAT_INCLUDE_DIRS})
+
+check_include_file(inttypes.h HAVE_INTTYPES_H)
+check_include_file(sys/time.h HAVE_SYS_TIME_H)
+check_include_file(sys/timeb.h HAVE_SYS_TIMEB_H)
+check_include_file(unistd.h HAVE_UNISTD_H)
+check_include_file(windows.h HAVE_WINDOWS_H)
+
+if(HAVE_INTTYPES_H)
+  # ShivaVG needs inttypes.h
+  add_definitions(-DHAVE_INTTYPES_H)
+endif()
+
+if(ENABLE_RTI)
+    # See if we have any rti library variant installed
+    message(STATUS "RTI: ENABLED")
+    find_package(RTI)
+else()
+    message(STATUS "RTI: DISABLED")
+endif(ENABLE_RTI)
+
+check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
+check_function_exists(ftime HAVE_FTIME)
+check_function_exists(timegm HAVE_TIMEGM)
+check_function_exists(rint HAVE_RINT)
+check_function_exists(mkdtemp HAVE_MKDTEMP)
+check_function_exists(bcopy HAVE_BCOPY)
+check_function_exists(mmap HAVE_MMAP)
+
+if(HAVE_UNISTD_H)
+    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
+    check_cxx_source_compiles(
+       "#include <unistd.h>
+        #if !defined(_POSIX_TIMERS) || (0 >= _POSIX_TIMERS)
+            #error clock_gettime is not supported
+        #endif
+
+        int main() { return 0; }
+        "
+        HAVE_CLOCK_GETTIME)
+endif(HAVE_UNISTD_H)
+
+set(RT_LIBRARY "")
+if(HAVE_CLOCK_GETTIME)
+    check_library_exists(rt clock_gettime "" HAVE_RT)
+    if(HAVE_RT)
+        set(RT_LIBRARY rt)
+    endif(HAVE_RT)
+endif(HAVE_CLOCK_GETTIME)
+
+set(DL_LIBRARY "")
+check_cxx_source_compiles(
+    "#include <dlfcn.h>
+    int main(void) {
+        return 0;
+    }
+    "
+    HAVE_DLFCN_H)
+
+if(HAVE_DLFCN_H)
+    check_library_exists(dl dlerror "" HAVE_DL)
+    if(HAVE_DL)
+        set(DL_LIBRARY "dl")
+    endif()
+endif()
+
+SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "add a postfix, usually 'd' on windows")
+SET(CMAKE_RELEASE_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
+SET(CMAKE_RELWITHDEBINFO_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
+SET(CMAKE_MINSIZEREL_POSTFIX "" CACHE STRING "add a postfix, usually empty on windows")
+
+# isnan might not be real symbol, so can't check using function_exists
+check_cxx_source_compiles(
+    "#include <cmath> 
+    void f() { isnan(0.0);} "
+    HAVE_ISNAN)
+
+check_cxx_source_compiles(
+    "#include <cmath> 
+    void f() { std::isnan(0.0);} "
+    HAVE_STD_ISNAN)
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+    set(WARNING_FLAGS_CXX "-Wall")
+    set(WARNING_FLAGS_C   "-Wall")
+
+    # certain GCC versions don't provide the atomic builds, and hence
+    # require is to provide them in SGAtomic.cxx
+    set(CMAKE_REQUIRED_INCLUDES ${CMAKE_INCLUDE_PATH})
+    check_cxx_source_compiles(
+       "int main() { unsigned mValue; return __sync_add_and_fetch(&mValue, 1); }"
+        GCC_ATOMIC_BUILTINS_FOUND)
+endif(CMAKE_COMPILER_IS_GNUCXX)
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+   set(WARNING_FLAGS_CXX "-Wall -Wno-overloaded-virtual")
+   set(WARNING_FLAGS_C   "-Wall")
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+# boost goes haywire wrt static asserts
+    check_cxx_compiler_flag(-Wno-unused-local-typedefs HAS_NOWARN_UNUSED_TYPEDEFS)
+    if(HAS_NOWARN_UNUSED_TYPEDEFS)
+        set(WARNING_FLAGS_CXX " ${WARNING_FLAGS_CXX} -Wno-unused-local-typedefs")
+    endif()
+endif()
+
+if(WIN32)
+
+    if(MINGW)
+        add_definitions(-D_WIN32_WINNT=0x501)
+    endif()
+
+    if(MSVC)
+        # turn off various warnings
+        # foreach(warning 4244 4251 4267 4275 4290 4786 4305 4996)
+        #     SET(WARNING_FLAGS "${WARNING_FLAGS} /wd${warning}")
+        # endforeach(warning)
+        
+        set(MSVC_FLAGS "-DWIN32 -DNOMINMAX -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D__CRT_NONSTDC_NO_WARNINGS /wd4996 /wd4250 -Dstrdup=_strdup")
+        if (${MSVC_VERSION} GREATER 1599)
+            set( MSVC_LD_FLAGS "/FORCE:MULTIPLE" )
+        endif (${MSVC_VERSION} GREATER 1599)
+    endif(MSVC)
+    
+    # assumed on Windows
+    set(HAVE_GETLOCALTIME 1)
+    
+    set( WINSOCK_LIBRARY "ws2_32.lib" )
+    set( RT_LIBRARY "winmm" )
+endif(WIN32)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS_C} ${MSVC_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS_CXX} ${MSVC_FLAGS} ${BOOST_CXX_FLAGS}")
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${MSVC_LD_FLAGS}")
+
+# use BEFORE to ensure local directories are used first, 
+# ahead of system-installed libs
+include_directories(BEFORE ${PROJECT_SOURCE_DIR})
+include_directories(BEFORE ${PROJECT_SOURCE_DIR}/simgear/canvas/ShivaVG/include)
+include_directories(BEFORE ${PROJECT_BINARY_DIR}/simgear)
+
+include_directories(${OPENSCENEGRAPH_INCLUDE_DIRS} 
+    ${Boost_INCLUDE_DIRS} 
+    ${ZLIB_INCLUDE_DIR} 
+    ${OPENAL_INCLUDE_DIR}
+)
+
+add_definitions(-DHAVE_CONFIG_H)
+
+# configure a header file to pass some of the CMake settings
+# to the source code
+configure_file (
+  "${PROJECT_SOURCE_DIR}/simgear/simgear_config_cmake.h.in"
+  "${PROJECT_BINARY_DIR}/simgear/simgear_config.h"
+  )
+
+if(ENABLE_TESTS)
+    # enable CTest / make test target
+    message(STATUS "Tests: ENABLED")
+
+    include (Dart)
+    enable_testing()
+else()
+    message(STATUS "Tests: DISABLED")
+endif(ENABLE_TESTS)
+
+# always set TEST_LIBS as it is also used by other tools/applications
+set(TEST_LIBS_INTERNAL_CORE
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${ZLIB_LIBRARY}
+    ${WINSOCK_LIBRARY}
+    ${RT_LIBRARY}
+    ${DL_LIBRARY}
+    ${COCOA_LIBRARY})
+set(TEST_LIBS SimGearCore ${TEST_LIBS_INTERNAL_CORE})
+
+if(NOT SIMGEAR_HEADLESS)
+    set(TEST_LIBS SimGearScene ${OPENGL_LIBRARIES} ${TEST_LIBS})
+endif()
+
+install (FILES ${PROJECT_BINARY_DIR}/simgear/simgear_config.h  DESTINATION include/simgear/)
+
+add_subdirectory(3rdparty)
+add_subdirectory(simgear)
+
+#-----------------------------------------------------------------------------
+### uninstall target
+#-----------------------------------------------------------------------------
+CONFIGURE_FILE(
+  "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/cmake_uninstall.cmake.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+  IMMEDIATE @ONLY)
+ADD_CUSTOM_TARGET(uninstall
+  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+  
+

CMakeModules/BoostTestTargets.cmake

@@ -0,0 +1,256 @@
+# - Add tests using boost::test
+#
+# Add this line to your test files in place of including a basic boost test header:
+#  #include <BoostTestTargetConfig.h>
+#
+# If you cannot do that and must use the included form for a given test,
+# include the line
+#  // OVERRIDE_BOOST_TEST_INCLUDED_WARNING
+# in the same file with the boost test include.
+#
+#  include(BoostTestTargets)
+#  add_boost_test(<testdriver_name> SOURCES <source1> [<more sources...>]
+#   [FAIL_REGULAR_EXPRESSION <additional fail regex>]
+#   [LAUNCHER <generic launcher script>]
+#   [LIBRARIES <library> [<library>...]]
+#   [RESOURCES <resource> [<resource>...]]
+#   [TESTS <testcasename> [<testcasename>...]])
+#
+#  If for some reason you need access to the executable target created,
+#  it can be found in ${${testdriver_name}_TARGET_NAME} as specified when
+#  you called add_boost_test
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Requires:
+# 	GetForceIncludeDefinitions
+# 	CopyResourcesToBuildTree
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__add_boost_test)
+	return()
+endif()
+set(__add_boost_test YES)
+
+set(BOOST_TEST_TARGET_PREFIX "test")
+
+if(NOT Boost_FOUND)
+	find_package(Boost 1.34.0 QUIET)
+endif()
+if("${Boost_VERSION}0" LESS "1034000")
+	set(_shared_msg
+		"NOTE: boost::test-based targets and tests cannot "
+		"be added: boost >= 1.34.0 required but not found. "
+		"(found: '${Boost_VERSION}'; want >=103400) ")
+	if(BUILD_TESTING)
+		message(FATAL_ERROR
+			${_shared_msg}
+			"You may disable BUILD_TESTING to continue without the "
+			"tests.")
+	else()
+		message(STATUS
+			${_shared_msg}
+			"BUILD_TESTING disabled, so continuing anyway.")
+	endif()
+endif()
+
+include(GetForceIncludeDefinitions)
+include(CopyResourcesToBuildTree)
+
+if(Boost_FOUND AND NOT "${Boost_VERSION}0" LESS "1034000")
+	set(_boosttesttargets_libs)
+	set(_boostConfig "BoostTestTargetsIncluded.h")
+	if(NOT Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
+		find_package(Boost 1.34.0 QUIET COMPONENTS unit_test_framework)
+	endif()
+	if(Boost_UNIT_TEST_FRAMEWORK_LIBRARY)
+		set(_boosttesttargets_libs "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}")
+		if(Boost_USE_STATIC_LIBS)
+			set(_boostConfig "BoostTestTargetsStatic.h")
+		else()
+			set(_boostConfig "BoostTestTargetsDynamic.h")
+		endif()
+	endif()
+	get_filename_component(_moddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+	configure_file("${_moddir}/${_boostConfig}"
+		"${CMAKE_CURRENT_BINARY_DIR}/BoostTestTargetConfig.h"
+		COPYONLY)
+	include_directories("${CMAKE_CURRENT_BINARY_DIR}")
+endif()
+
+function(add_boost_test _name)
+	if(NOT BUILD_TESTING)
+		return()
+	endif()
+
+	# parse arguments
+	set(_nowhere)
+	set(_curdest _nowhere)
+	set(_val_args
+		SOURCES
+		FAIL_REGULAR_EXPRESSION
+		LAUNCHER
+		LIBRARIES
+		RESOURCES
+		TESTS)
+	set(_bool_args
+		USE_COMPILED_LIBRARY)
+	foreach(_arg ${_val_args} ${_bool_args})
+		set(${_arg})
+	endforeach()
+	foreach(_element ${ARGN})
+		list(FIND _val_args "${_element}" _val_arg_find)
+		list(FIND _bool_args "${_element}" _bool_arg_find)
+		if("${_val_arg_find}" GREATER "-1")
+			set(_curdest "${_element}")
+		elseif("${_bool_arg_find}" GREATER "-1")
+			set("${_element}" ON)
+			set(_curdest _nowhere)
+		else()
+			list(APPEND ${_curdest} "${_element}")
+		endif()
+	endforeach()
+
+	if(_nowhere)
+		message(FATAL_ERROR "Syntax error in use of add_boost_test!")
+	endif()
+
+	if(NOT SOURCES)
+		message(FATAL_ERROR
+			"Syntax error in use of add_boost_test: at least one source file required!")
+	endif()
+
+	if(Boost_FOUND AND NOT "${Boost_VERSION}0" LESS "1034000")
+
+		include_directories(${Boost_INCLUDE_DIRS})
+
+		set(includeType)
+		foreach(src ${SOURCES})
+			file(READ ${src} thefile)
+			if("${thefile}" MATCHES ".*BoostTestTargetConfig.h.*")
+				set(includeType CONFIGURED)
+				set(includeFileLoc ${src})
+				break()
+			elseif("${thefile}" MATCHES ".*boost/test/included/unit_test.hpp.*")
+				set(includeType INCLUDED)
+				set(includeFileLoc ${src})
+				set(_boosttesttargets_libs)	# clear this out - linking would be a bad idea
+				if(NOT
+					"${thefile}"
+					MATCHES
+					".*OVERRIDE_BOOST_TEST_INCLUDED_WARNING.*")
+					message("Please replace the include line in ${src} with this alternate include line instead:")
+					message("  \#include <BoostTestTargetConfig.h>")
+					message("Once you've saved your changes, re-run CMake. (See BoostTestTargets.cmake for more info)")
+				endif()
+				break()
+			endif()
+		endforeach()
+
+		if(NOT _boostTestTargetsNagged${_name} STREQUAL "${includeType}")
+			if("includeType" STREQUAL "CONFIGURED")
+				message(STATUS
+					"Test '${_name}' uses the CMake-configurable form of the boost test framework - congrats! (Including File: ${includeFileLoc})")
+			elseif("${includeType}" STREQUAL "INCLUDED")
+				message("In test '${_name}': ${includeFileLoc} uses the 'included' form of the boost unit test framework.")
+			else()
+				message("In test '${_name}': Didn't detect the CMake-configurable boost test include.")
+				message("Please replace your existing boost test include in that test with the following:")
+				message("  \#include <BoostTestTargetConfig.h>")
+				message("Once you've saved your changes, re-run CMake. (See BoostTestTargets.cmake for more info)")
+			endif()
+		endif()
+		set(_boostTestTargetsNagged${_name}
+			"${includeType}"
+			CACHE
+			INTERNAL
+			""
+			FORCE)
+
+
+		if(RESOURCES)
+			list(APPEND SOURCES ${RESOURCES})
+		endif()
+
+		# Generate a unique target name, using the relative binary dir
+		# and provided name. (transform all / into _ and remove all other
+		# non-alphabet characters)
+		file(RELATIVE_PATH
+			targetpath
+			"${CMAKE_BINARY_DIR}"
+			"${CMAKE_CURRENT_BINARY_DIR}")
+		string(REGEX REPLACE "[^A-Za-z/_]" "" targetpath "${targetpath}")
+		string(REPLACE "/" "_" targetpath "${targetpath}")
+
+		set(_target_name ${BOOST_TEST_TARGET_PREFIX}-${targetpath}-${_name})
+		set(${_name}_TARGET_NAME "${_target_name}" PARENT_SCOPE)
+
+		# Build the test.
+		add_executable(${_target_name} ${SOURCES})
+
+		list(APPEND LIBRARIES ${_boosttesttargets_libs})
+
+		if(LIBRARIES)
+			target_link_libraries(${_target_name} ${LIBRARIES})
+		endif()
+
+		if(RESOURCES)
+			set_property(TARGET ${_target_name} PROPERTY RESOURCE ${RESOURCES})
+			copy_resources_to_build_tree(${_target_name})
+		endif()
+
+		if(NOT Boost_TEST_FLAGS)
+#			set(Boost_TEST_FLAGS --catch_system_error=yes --output_format=XML)
+			set(Boost_TEST_FLAGS --catch_system_error=yes)
+		endif()
+
+		# TODO: Figure out why only recent boost handles individual test running properly
+
+		if(LAUNCHER)
+			set(_test_command ${LAUNCHER} "\$<TARGET_FILE:${_target_name}>")
+		else()
+			set(_test_command ${_target_name})
+		endif()
+
+		if(TESTS AND ( "${Boost_VERSION}" VERSION_GREATER "103799" ))
+			foreach(_test ${TESTS})
+				add_test(
+					${_name}-${_test}
+					${_test_command} --run_test=${_test} ${Boost_TEST_FLAGS}
+				)
+				if(FAIL_REGULAR_EXPRESSION)
+					set_tests_properties(${_name}-${_test}
+						PROPERTIES
+						FAIL_REGULAR_EXPRESSION
+						"${FAIL_REGULAR_EXPRESSION}")
+				endif()
+			endforeach()
+		else()
+			add_test(
+				${_name}-boost_test
+				${_test_command} ${Boost_TEST_FLAGS}
+			)
+			if(FAIL_REGULAR_EXPRESSION)
+				set_tests_properties(${_name}-boost_test
+					PROPERTIES
+					FAIL_REGULAR_EXPRESSION
+					"${FAIL_REGULAR_EXPRESSION}")
+			endif()
+		endif()
+
+		# CppCheck the test if we can.
+		if(COMMAND add_cppcheck)
+			add_cppcheck(${_target_name} STYLE UNUSED_FUNCTIONS)
+		endif()
+
+	endif()
+endfunction()

CMakeModules/BoostTestTargetsDynamic.h

@@ -0,0 +1,8 @@
+// Small header computed by CMake to set up boost test.
+// include AFTER #define BOOST_TEST_MODULE whatever
+// but before any other boost test includes.
+
+// Using the Boost UTF dynamic library
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>

CMakeModules/BoostTestTargetsIncluded.h

@@ -0,0 +1,7 @@
+// Small header computed by CMake to set up boost test.
+// include AFTER #define BOOST_TEST_MODULE whatever
+// but before any other boost test includes.
+
+// Using the Boost UTF included framework
+
+#include <boost/test/included/unit_test.hpp>

CMakeModules/BoostTestTargetsStatic.h

@@ -0,0 +1,7 @@
+// Small header computed by CMake to set up boost test.
+// include AFTER #define BOOST_TEST_MODULE whatever
+// but before any other boost test includes.
+
+// Using the Boost UTF static library
+
+#include <boost/test/unit_test.hpp>

CMakeModules/CopyResourcesToBuildTree.cmake

@@ -0,0 +1,83 @@
+# - Copy the resources your app needs to the build tree.
+#
+#  copy_resources_to_build_tree(<target_name>)
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__copy_resources_to_build_tree)
+	return()
+endif()
+set(__copy_resources_to_build_tree YES)
+
+function(copy_resources_to_build_tree _target)
+	get_target_property(_resources ${_target} RESOURCE)
+	if(NOT _resources)
+		# Bail if no resources
+		message(STATUS
+			"Told to copy resources for target ${_target}, but "
+			"no resources are set!")
+		return()
+	endif()
+
+	get_target_property(_path ${_target} LOCATION)
+	get_filename_component(_path "${_path}" PATH)
+
+	if(NOT MSVC AND NOT "${CMAKE_GENERATOR}" MATCHES "Makefiles")
+		foreach(_config ${CMAKE_CONFIGURATION_TYPES})
+			get_target_property(_path${_config} ${_target} LOCATION_${_config})
+			get_filename_component(_path${_config} "${_path${_config}}" PATH)
+			add_custom_command(TARGET ${_target}
+						POST_BUILD
+						COMMAND
+						${CMAKE_COMMAND}
+						ARGS -E make_directory "${_path${_config}}/"
+						COMMENT "Creating directory ${_path${_config}}/")
+		endforeach()
+	endif()
+
+	foreach(_res ${_resources})
+		if(NOT IS_ABSOLUTE "${_res}")
+			get_filename_component(_res "${_res}" ABSOLUTE)
+		endif()
+		get_filename_component(_name "${_res}" NAME)
+
+		if(MSVC)
+			# Working dir is solution file dir, not exe file dir.
+			add_custom_command(TARGET ${_target}
+				POST_BUILD
+				COMMAND
+				${CMAKE_COMMAND}
+				ARGS -E copy "${_res}" "${CMAKE_BINARY_DIR}/"
+				COMMENT "Copying ${_name} to ${CMAKE_BINARY_DIR}/ for MSVC")
+		else()
+			if("${CMAKE_GENERATOR}" MATCHES "Makefiles")
+				add_custom_command(TARGET ${_target}
+					POST_BUILD
+					COMMAND
+					${CMAKE_COMMAND}
+					ARGS -E copy "${_res}" "${_path}/"
+					COMMENT "Copying ${_name} to ${_path}/")
+			else()
+				foreach(_config ${CMAKE_CONFIGURATION_TYPES})
+					add_custom_command(TARGET ${_target}
+						POST_BUILD
+						COMMAND
+						${CMAKE_COMMAND}
+						ARGS -E copy "${_res}" "${_path${_config}}"
+						COMMENT "Copying ${_name} to ${_path${_config}}")
+				endforeach()
+
+			endif()
+		endif()
+	endforeach()
+endfunction()

CMakeModules/GetForceIncludeDefinitions.cmake

@@ -0,0 +1,44 @@
+# - Get the platform-appropriate flags to add to force inclusion of a file
+#
+# The most common use of this is to use a generated config.h-type file
+# placed out of the source tree in all files.
+#
+#  get_force_include_definitions(var forcedincludefiles...) -
+#   where var is the name of  your desired output variable, and everything
+#   else is a source file to forcibly include.
+#   a list item to be filtered.
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_force_include_definitions)
+	return()
+endif()
+set(__get_force_include_definitions YES)
+
+function(get_force_include_definitions var)
+	set(_flagprefix)
+	if(CMAKE_COMPILER_IS_GNUCXX)
+		set(_flag "-include")
+	elseif(MSVC)
+		set(_flag "/FI")
+	else()
+		message(SEND_ERROR "You don't seem to be using MSVC or GCC, but")
+		message(SEND_ERROR "the project called get_force_include_definitions.")
+		message(SEND_ERROR "Contact this project with the name of your")
+		message(FATAL_ERROR "compiler and preferably the flag to force includes")
+	endif()
+
+	set(_out)
+	foreach(_item ${ARGN})
+		list(APPEND _out "${_flag} \"${_item}\"")
+	endforeach()
+	set(${var} "${_out}" PARENT_SCOPE)
+endfunction()

CMakeModules/OldGNUInstallDirs.cmake

@@ -0,0 +1,182 @@
+# - Define GNU standard installation directories
+# Provides install directory variables as defined for GNU software:
+#  http://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+# Inclusion of this module defines the following variables:
+#  CMAKE_INSTALL_<dir>      - destination for files of a given type
+#  CMAKE_INSTALL_FULL_<dir> - corresponding absolute path
+# where <dir> is one of:
+#  BINDIR           - user executables (bin)
+#  SBINDIR          - system admin executables (sbin)
+#  LIBEXECDIR       - program executables (libexec)
+#  SYSCONFDIR       - read-only single-machine data (etc)
+#  SHAREDSTATEDIR   - modifiable architecture-independent data (com)
+#  LOCALSTATEDIR    - modifiable single-machine data (var)
+#  LIBDIR           - object code libraries (lib or lib64)
+#  INCLUDEDIR       - C header files (include)
+#  OLDINCLUDEDIR    - C header files for non-gcc (/usr/include)
+#  DATAROOTDIR      - read-only architecture-independent data root (share)
+#  DATADIR          - read-only architecture-independent data (DATAROOTDIR)
+#  INFODIR          - info documentation (DATAROOTDIR/info)
+#  LOCALEDIR        - locale-dependent data (DATAROOTDIR/locale)
+#  MANDIR           - man documentation (DATAROOTDIR/man)
+#  DOCDIR           - documentation root (DATAROOTDIR/doc/PROJECT_NAME)
+# Each CMAKE_INSTALL_<dir> value may be passed to the DESTINATION options of
+# install() commands for the corresponding file type.  If the includer does
+# not define a value the above-shown default will be used and the value will
+# appear in the cache for editing by the user.
+# Each CMAKE_INSTALL_FULL_<dir> value contains an absolute path constructed
+# from the corresponding destination by prepending (if necessary) the value
+# of CMAKE_INSTALL_PREFIX.
+
+#=============================================================================
+# Copyright 2011 Nikita Krupen'ko <krnekit@gmail.com>
+# Copyright 2011 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Installation directories
+#
+if(NOT DEFINED CMAKE_INSTALL_BINDIR)
+  set(CMAKE_INSTALL_BINDIR "bin" CACHE PATH "user executables (bin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SBINDIR)
+  set(CMAKE_INSTALL_SBINDIR "sbin" CACHE PATH "system admin executables (sbin)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBEXECDIR)
+  set(CMAKE_INSTALL_LIBEXECDIR "libexec" CACHE PATH "program executables (libexec)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SYSCONFDIR)
+  set(CMAKE_INSTALL_SYSCONFDIR "etc" CACHE PATH "read-only single-machine data (etc)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_SHAREDSTATEDIR)
+  set(CMAKE_INSTALL_SHAREDSTATEDIR "com" CACHE PATH "modifiable architecture-independent data (com)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LOCALSTATEDIR)
+  set(CMAKE_INSTALL_LOCALSTATEDIR "var" CACHE PATH "modifiable single-machine data (var)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+  set(_LIBDIR_DEFAULT "lib")
+  # Override this default 'lib' with 'lib64' iff:
+  #  - we are on Linux system but NOT cross-compiling
+  #  - we are NOT on debian
+  #  - we are on a 64 bits system
+  # reason is: amd64 ABI: http://www.x86-64.org/documentation/abi.pdf
+  # Note that the future of multi-arch handling may be even
+  # more complicated than that: http://wiki.debian.org/Multiarch
+  if(CMAKE_SYSTEM_NAME MATCHES "Linux"
+      AND NOT CMAKE_CROSSCOMPILING
+      AND NOT EXISTS "/etc/debian_version")
+    if(NOT DEFINED CMAKE_SIZEOF_VOID_P)
+      message(AUTHOR_WARNING
+        "Unable to determine default CMAKE_INSTALL_LIBDIR directory because no target architecture is known. "
+        "Please enable at least one language before including GNUInstallDirs.")
+    else()
+      if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+        set(_LIBDIR_DEFAULT "lib64")
+      endif()
+    endif()
+  endif()
+  set(CMAKE_INSTALL_LIBDIR "${_LIBDIR_DEFAULT}" CACHE PATH "object code libraries (${_LIBDIR_DEFAULT})")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR)
+  set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE PATH "C header files (include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_OLDINCLUDEDIR)
+  set(CMAKE_INSTALL_OLDINCLUDEDIR "/usr/include" CACHE PATH "C header files for non-gcc (/usr/include)")
+endif()
+
+if(NOT DEFINED CMAKE_INSTALL_DATAROOTDIR)
+  set(CMAKE_INSTALL_DATAROOTDIR "share" CACHE PATH "read-only architecture-independent data root (share)")
+endif()
+
+#-----------------------------------------------------------------------------
+# Values whose defaults are relative to DATAROOTDIR.  Store empty values in
+# the cache and store the defaults in local variables if the cache values are
+# not set explicitly.  This auto-updates the defaults as DATAROOTDIR changes.
+
+if(NOT CMAKE_INSTALL_DATADIR)
+  set(CMAKE_INSTALL_DATADIR "" CACHE PATH "read-only architecture-independent data (DATAROOTDIR)")
+  set(CMAKE_INSTALL_DATADIR "${CMAKE_INSTALL_DATAROOTDIR}")
+endif()
+
+if(NOT CMAKE_INSTALL_INFODIR)
+  set(CMAKE_INSTALL_INFODIR "" CACHE PATH "info documentation (DATAROOTDIR/info)")
+  set(CMAKE_INSTALL_INFODIR "${CMAKE_INSTALL_DATAROOTDIR}/info")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCALEDIR)
+  set(CMAKE_INSTALL_LOCALEDIR "" CACHE PATH "locale-dependent data (DATAROOTDIR/locale)")
+  set(CMAKE_INSTALL_LOCALEDIR "${CMAKE_INSTALL_DATAROOTDIR}/locale")
+endif()
+
+if(NOT CMAKE_INSTALL_MANDIR)
+  set(CMAKE_INSTALL_MANDIR "" CACHE PATH "man documentation (DATAROOTDIR/man)")
+  set(CMAKE_INSTALL_MANDIR "${CMAKE_INSTALL_DATAROOTDIR}/man")
+endif()
+
+if(NOT CMAKE_INSTALL_DOCDIR)
+  set(CMAKE_INSTALL_DOCDIR "" CACHE PATH "documentation root (DATAROOTDIR/doc/PROJECT_NAME)")
+  set(CMAKE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME}")
+endif()
+
+#-----------------------------------------------------------------------------
+
+mark_as_advanced(
+  CMAKE_INSTALL_BINDIR
+  CMAKE_INSTALL_SBINDIR
+  CMAKE_INSTALL_LIBEXECDIR
+  CMAKE_INSTALL_SYSCONFDIR
+  CMAKE_INSTALL_SHAREDSTATEDIR
+  CMAKE_INSTALL_LOCALSTATEDIR
+  CMAKE_INSTALL_LIBDIR
+  CMAKE_INSTALL_INCLUDEDIR
+  CMAKE_INSTALL_OLDINCLUDEDIR
+  CMAKE_INSTALL_DATAROOTDIR
+  CMAKE_INSTALL_DATADIR
+  CMAKE_INSTALL_INFODIR
+  CMAKE_INSTALL_LOCALEDIR
+  CMAKE_INSTALL_MANDIR
+  CMAKE_INSTALL_DOCDIR
+  )
+
+# Result directories
+#
+foreach(dir
+    BINDIR
+    SBINDIR
+    LIBEXECDIR
+    SYSCONFDIR
+    SHAREDSTATEDIR
+    LOCALSTATEDIR
+    LIBDIR
+    INCLUDEDIR
+    OLDINCLUDEDIR
+    DATAROOTDIR
+    DATADIR
+    INFODIR
+    LOCALEDIR
+    MANDIR
+    DOCDIR
+    )
+  if(NOT IS_ABSOLUTE ${CMAKE_INSTALL_${dir}})
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_${dir}}")
+  else()
+    set(CMAKE_INSTALL_FULL_${dir} "${CMAKE_INSTALL_${dir}}")
+  endif()
+endforeach()

CMakeModules/SimGearComponent.cmake

@@ -0,0 +1,29 @@
+
+macro(simgear_component_common name includePath sourcesList sources headers)
+    set(fc${sourcesList} ${name})
+    set(fh${sourcesList} ${name})
+    foreach(s ${sources})
+        set_property(GLOBAL
+            APPEND PROPERTY ${sourcesList} "${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+        set(fc${sourcesList} "${fc${sourcesList}}#${CMAKE_CURRENT_SOURCE_DIR}/${s}")
+    endforeach()
+
+	foreach(h ${headers})
+		set_property(GLOBAL
+			APPEND PROPERTY PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
+        set(fh${sourcesList} "${fh${sourcesList}}#${CMAKE_CURRENT_SOURCE_DIR}/${h}")
+	endforeach()
+
+    set_property(GLOBAL APPEND PROPERTY FG_GROUPS_${sourcesList}_C "${fc${sourcesList}}@")
+    set_property(GLOBAL APPEND PROPERTY FG_GROUPS_${sourcesList}_H "${fh${sourcesList}}@")
+    
+    install (FILES ${headers}  DESTINATION include/simgear/${includePath})
+endmacro()
+
+function(simgear_component name includePath sources headers)
+    simgear_component_common(${name} ${includePath} CORE_SOURCES "${sources}" "${headers}")
+endfunction()
+
+function(simgear_scene_component name includePath sources headers)
+    simgear_component_common(${name} ${includePath} SCENE_SOURCES "${sources}" "${headers}")
+endfunction()

CMakeModules/cmake_uninstall.cmake.in

@@ -0,0 +1,22 @@
+IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+    MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
+ENDIF()
+
+FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+STRING(REGEX REPLACE "\n" ";" files "${files}")
+
+FOREACH(file ${files})
+    MESSAGE(STATUS "Uninstalling \"${file}\"")
+    IF(EXISTS "${file}")
+        EXEC_PROGRAM(
+            "@CMAKE_COMMAND@" ARGS "-E remove \"${file}\""
+            OUTPUT_VARIABLE rm_out
+            RETURN_VALUE rm_retval
+            )
+        IF(NOT "${rm_retval}" STREQUAL 0)
+            MESSAGE(FATAL_ERROR "Problem when removing \"${file}\"")
+        ENDIF()
+    ELSE()
+        MESSAGE(STATUS "File \"${file}\" does not exist.")
+    ENDIF()
+ENDFOREACH()

COPYING

@@ -0,0 +1,481 @@
+                  GNU LIBRARY GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+ 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+                  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

DoxygenMain.cxx

@@ -0,0 +1,108 @@
+/* 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.
+ *   (compiler.h)
+ *
+ * - A whole earth tiling/indexing scheme.  (SGBucket)
+ *
+ * - A console debugging output scheme that tracks severity and
+ *   category that can be completely compiled out for a final build release.
+ *   (logstream.hxx)
+ *
+ * - Code to manage "real" time (SGTime), time zones (SGTimeZone), and
+ *   millesecond time differences (SGTimeStamp).
+ *
+ * - Code to calculate accurate positions of sun, moon, stars, and
+ *   planets for a given time, date, season, earth location, etc.
+ *   (SGEphemeris)
+ *
+ * - Code to render a realistic sky dome, cloud layers, sun, moon,
+ *   stars, and planets all with realistic day/night/sunset/sunrise
+ *   effects.  Includes things like correct moon phase, textured moon,
+ *   sun halo, etc. (SGSky is built on top of SGCloudLayer ...)
+ *
+ * - Simple serial (SGSerial), file (SGFile), socket (SGSocket), and
+ *   UDP socket (SGSocketUDP) I/O abstractions.
+ *
+ * - Code to calculate magnetic variation. (SGMagVar)
+ *
+ * - A variety of classes and functions for interpolation tables
+ *   (SGInterpTable), least squares computation (leastsqs.hxx), 3D
+ *   point/vectors (Point3D), 3D polar math and conversions (polar3d.hxx),
+ *   WGS-84 math and conversions (sg_geodesy.hxx), random number abstraction
+ *   (sg_random.h), STL conglomerates for common list types (sg_types.hxx),
+ *   and other vector and linear algebra routines (vector.hxx)
+ *
+ * - An abstraction to hide platform dependent path naming schemes. (SGPath)
+ *
+ * - A C++ streams wrapper to handle compress input/output streams.
+ *   (sg_gzifstream)
+ *
+ * - 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.  (SGPropertyNode)
+ *   Also included is a set of functions to dump the property tree into a
+ *   standard xml file and subsequently read/parse a standard xml file and
+ *   rebuild the associated property tree.  (props_io.hxx)
+ *
+ * - 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 (screen-dump.hxx) and ultra-hires
+ *   tile rendered screen dumps (tr.h)
+ *
+ * - A sound effects manager.  (SGSoundMgr, SGSimpleSound, SGSound)
+ *
+ * - A threading abstraction.  (SGThread)
+ *
+ * - A simple but highly functional XML parser that interfaces nicely
+ *   with the property manager.  (easyxml.hxx)
+
+ * \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
+
+ */
+

INSTALL

@@ -0,0 +1,56 @@
+How to build SimGear
+====================
+
+SimGear uses the CMake build system to generate a platform-specific
+build environment.  CMake reads the CMakeLists.txt files that you'll
+find throughout the source directories, checks for installed
+dependencies and then generates the appropriate build system.
+
+If you don't already have CMake installed on your system you can grab
+it from http://www.cmake.org, use version 2.6.4 or later.
+
+Under unices (i.e. Linux, Solaris, Free-BSD, HP-Ux, OSX) use the cmake
+or ccmake command-line utils. Preferably, create an out-of-source
+build directory and run cmake or ccmake from there. The advantage to
+this approach is that the temporary files created by CMake won't
+clutter the source directory, and also makes it possible to have
+multiple independent build targets by creating multiple build
+directories. In a directory alongside the SimGear source directory
+use:
+
+    mkdir sgbuild
+    cd sgbuild
+    cmake ../simgear -DCMAKE_BUILD_TYPE=Release
+    make
+    sudo make install
+
+
+Build Dependencies
+==================
+SimGear depends on a number of 3rd party libraries, the most notable
+being:
+
+* OpenSceneGraph (OSG) - see README.OSG
+* zlib compression library - see README.zlib
+* Open Audio Library (OpenAL) - see README.OpenAL
+* Subversion Client Library (optional dependency)
+
+
+Further information
+===================
+* README.cmake
+  for more detailed CMake instructions
+
+* README.msvc
+  in the FlightGear source package for more Windows-specific instructions
+
+* FlightGear Wiki
+  http://wiki.flightgear.org/Building_Flightgear
+
+* FlightGear Forums
+  For help on building see: http://www.flightgear.org/forums
+  => Support/Compiling
+
+* FlightGear Mailing lists
+  http://wiki.flightgear.org/index.php/Mailing_list
+

Makefile.am

@@ -1,6 +0,0 @@
-EXTRA_DIST = mksymlinks.sh
-
-dist-hook:
-	tar cf - src/metar | (cd $(distdir); tar xvf -)
-
-SUBDIRS = src

NEWS

@@ -0,0 +1,439 @@
+Version 1.9.0
+* Thu Dec 18 15:12:15 CST 2008
+
+
+Version 1.8.6
+* Mon Dec  1 14:02:47 CST 2008
+
+
+Version 1.8.5
+* October 30, 2008 (source code snapshot release)
+
+
+New in 0.3.10
+* April 5, 2006
+
+* Add a small accessor function to expose local timezone offset.
+* Improved exception handling and made output more helpful in various places.
+* Better pbuffer runtime detection.
+* Add directory creation capability to file/path library.
+* Added a basic reference counting class to improve robustness of
+  memory management in places.  Use this for all scenegraph
+  references, sgmaterial references, sgmatmodel references, and
+  sgsoundsample references.
+* Add support for point sprites.
+* Updates to rain cone rendering.
+* Add a new vector library and integrate that with improved coordinate
+  system conversion code.
+* Mutex locking and cleanup improvements in the threading abstraction
+  library.
+* Add MacOS RenderTexture support.
+* Add a Nasal based io libarary that is not activated by default.
+* Added a set of MS-VC8 project files.
+
+* Various platform related bug fixes.
+* Various compiler related bug/warning fixes.
+* Clean up some things that triggered valgrind warnings.
+* Fix a Nasal cmp() bug.
+* Removed ancient version of zlib from distribution.
+
+
+New in 0.3.9
+* November 17, 2005
+
+* Add support for OpenAL 1.1 (with a separate alut library.)
+* Add support for volumetric shadows.  Aircraft can cast shadows on themselves
+  as well as onto the ground (by Harald Johnsen.)
+* New 3d volumetric clouds by Harald Johnsen (along with several rounds of
+  followup fixes and improvements.)
+* Remove Mark Harris's old 3d clouds because they were never properly
+  integrated.  And we now have new 3d clouds.
+* Add support for seasonal textures (with a set of winter textures added
+  to FlightGear.)
+* Updated Nasal scripting system.  Adds several new syntax convenience
+  features, fixes parser bugs, fixes several internal bugs.
+* Our 3d cockpit jitter problem is fixed (woohoo!)
+* Add code to support rendering to a texture.
+* Allow "tip" popups to pop themselves down after the appropriate
+  timeout, even if the sim time is paused.
+* Various low model level animation fixes and additions ... color,
+  transparency, 'chrome' effects, randomized spin, etc.
+* Create our own portable stdint.h implementation.
+* Fixed several memory leaks.
+* removeChildren() added to the property system.
+* Fix many cases of 'const'.
+* Fixes for cygwin, solaris/sun, Mac OS X, MSVC, gcc-3.4.x.
+
+
+New in 0.3.8
+* January 18, 2005
+
+* Configure script does a sanity check for the existence of openal.
+* Better pthreads detection for FreeBSD.
+* Abstract out the location of gl.h, glu.h, and glut.h so we can more
+  easily support MacOS which puts these in an oddball location.
+* Added two new debug output types for instrumentation and systems.
+* Add a name parameter to the waypoint class for supporting a route
+  manager in the flightgear gps module.
+* Make display list usage optional.
+* Event manager: specifying a zero delay will force event execution in
+  the next frame rather than entering an infinite loop.
+* gcc-4.0 fix.
+* Fixes to property tree loading and saving.
+* Make volume inaudible at startup.
+* Solaris fixes.
+* For low density cloud coverage, blend the layer to nothing as we pass
+  through instead of fully engulfing the aircraft in the cloud.
+* Add several new capabilities to the texture management code for building
+  normal maps and doing some simple on-the-fly effects on textures.
+* Better error message for sound problems.
+* Add support for binding a thread to a specific CPU.
+
+
+New in 0.3.7
+* October 12, 2004
+
+* Add support for parsing xml from an in memory buffer, not just a file.
+* Don't reduce visibility for a "clear" cloud layer.
+* Add support for audio orientation (direction and cone) for internal
+  view and tower view.
+* Add support for drawing from display lists rather than in immediate mode.
+  This provides a big performance improvement on many systems.
+
+
+New in 0.3.6
+* July 29, 2004
+
+* Better MinGW support
+* A bit better handling of OpenAL under Cygwin
+* Switched audio system from plib's "sl/sm" to OpenAL.
+* Add support for scaling an object based on distance.  The scaling
+  factor is determined by a lookup table based on distance.
+* Add a "flash" animation type.
+* Fix cloud positioning/animation bugs.
+* Fix an off-by-one error in props_io.cxx
+* Clip audio gain (volume) to 1.0
+
+
+New in 0.3.5
+* March 26, 2004
+
+* Added Andy's nasal interpreter for small built in scripting tasks.
+  Nasal integrates nicely with FlightGear's property system.
+* Added new (much simpler) metar parsing code (removed older more
+  complex code.)
+* Support VASI/PAPI lights correctly.
+* Fixes to cloud animation.
+* Updates to sky dome coloring as well as sun/moon coloring.
+* Vary environment lighting with visibility (subtlety.)
+* Support control of alpha test in model animation.
+* Complete rewrite of the event manager.
+* Updates to low level socket code to make it more flexible.
+* Win32 serial port communication fixes.
+* sg_geodesy rewritten to be more accurate and robust and symmetric.
+
+
+New in 0.3.4
+* October 22, 2003
+
+* Removed Metakit, FlightGear no longer uses it.
+* Removed all glut dependencies from SimGear.
+* Moved FGEventMgr and FGSubsystemMgr over to SimGear.
+* Some more incremental work on 3D clouds.
+* Added some "fastmath" functions.
+* Some lighting tweaks and fixes (especially for taxiways.)
+* Added support for "blend" and "scale" and "texture" animations.
+* Added support for animating rotations around an arbitrary axis (so the
+  aircraft designer isn't forced to figure out animations as a combination
+  of rotations around X, Y, and X axes.
+* Updates to sky dome modeling and make cloud layers follow the curve
+  of the earth (sort of.)
+* Updates to sky dome, cloud, and sunrise/sunset color and lighting
+  effects to make them more realistic and lifelike.
+* Better support for detecting and using OpenGL extensions at run time.
+* Add support for win32-pthreads in MSVC.NET
+* Various MSVC fixes.
+* Various Solaris fixes.
+* Various cygwin/mingwin fixes.
+* Various Mac OS X fixes.
+* Various Irix fixes.
+
+
+New in 0.3.3
+* June 3, 2003
+
+* Fix a compile problem for cygwin
+* Updated/tweaked doxygen documentation in several areas
+
+
+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 variants.  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
+
+* Modernized the autoconf/make scripts, plus lots of tweaks and enhancements.
+* Removed efence support (in favor of valgrind.)
+
+* Added a javascript interpreter.
+* SGSocket reimplemented on top of plib/net libs.
+* Added a new random number generation algorithm.
+* Total rewrite of the strutils package.
+
+* Patch for the random number seed.
+* IA-64 w/ Intel compiler fixes.
+* MSVC/MINGW fixes.
+* Mac OS X fixes.
+* Irix fixes.
+* Code clean ups to remove warning messages.
+* Optimizations in sg_binobj to reduce the amount of memory copying
+  needed when loading a binobj format file.
+* Fixed a couple places where variables could be used before they were
+  initialized.
+* Various property manager fixes and improvements.
+* Fixes to cloud layer management code.
+* Made the sky dome more flexible to facilitate use in other applications.
+
+
+New in 0.0.18
+* April 20, 2002
+
+* Created a src/libs subdirectory for several packages that need to be
+  installed by the user but are used by many other packages and may already
+  be installed.  So we just bundle the source separately as a convenience
+  if the user needs to build and install these.
+* Upgrade to zlib-1.1.4 (security fix)
+* Upgrade to metakit-2.4.2-32.tar.gz (latest upstream release)
+* Added support for point objects in the scenery file format.
+* Additions to the binary file format to make it *much* more flexible.
+  For each major primitive type: points, triangles, fans, and strips, you
+  can specify an index list of vertices, normals, colors, and texture
+  coordinates.  You can skip any of these you like to save on space.
+* Added support for new file features in the binary -> ascii scenery file
+  decoder.
+* Various code clean ups.
+* Separate XML I/O operations into a separate header file.
+* Major property manager rewrite, then lots of followup cleaning and
+  improvements.
+
+
+New in 0.0.17 (final)
+* February 16, 2002
+
+* Explicitely reset the glBlendFunc() after drawing the moon for the
+  Voodoo2 linux driver since it seems to have a bug in glPopAttrib().
+
+
+New in 0.0.17pre2
+* February 13, 2002
+
+* Replaced some cout's with SG_LOG's
+
+
+New in 0.0.17pre1
+* February 12, 2002
+
+* Removed metakit and zlib from build process.  Tarballs are still included
+  for those who's systems don't provide these packages.
+* MSVC fixes.
+* IRIX fixes.
+* Mingwin fixes.
+* Mac OS X fixes.
+* FreeBSD fixes.
+* Added support for Intel's C++ compiler under Linux.
+* Attempt to build in support for various non-compatible automake/autoconf
+  versions.
+* Fix for a problem that could lead to a bogus build for people with voodoo
+  cards.
+* Added Norman's jpegfactory code which can create jpeg format screen shots
+  of a live running application.
+* implemented set/get_log_classes and set/get_log_priority.
+* Socket library improvements.
+* Added a C++ exception abstraction.
+* Property manager fixes and improvements including node path caching
+  and debug tracing of property reads/writes.
+* Updates/fixes to xml handling.
+
+
+New in 0.0.16
+* July 12, 2001
+* Various changes to the property manager implementation to better support
+  dumping out the desired portions of the property tree to file.
+* Don't compile the metakit demos by default (causes problems for Irix)'
+* Other various tweaks for Irix.
+* Added a virtual destructor to XMLVisitor to fix a warning message.
+* Check for valid hostname lookup in sg_socket.cxx
+* Add a function to return modified julian date without creating an
+  entire SGTime class.  This avoids an extraneous warning about not
+  being able to find a timezone.
+* Created a mailing list for cvs commit messages.
+* Fixed a potential array under/over run bug in interpolator.cxx
+* Removed all references to SGValue from the property manager.  Added
+  support for an "archive" bit in the property manager to control
+  which values get written out.
+* Added SGCommandState class so that commands can compile and save
+  copies of their arguments for efficiency if they are called multiple
+  times.
+* Added Brian Baul's "tr" tiled rendering low level support library.
+  This along with some higher level code in flightgear allows us to do
+  ultra-hires tiled screen dumps suitable for large format printers.
+  (Norman Vine)
+
+
+New in 0.0.15
+* June 20, 2001
+* Various bug fixes, tweaks, and optimizations.
+* Added a command manager (analogous to the property manager)
+* Better Irix Mips support.
+* Various gcc-3.0 fixes.
+* Various MSVC fixes.
+* Added MSVC project files (automatically generated from the unix
+  automake configuration files.)
+* Removed total size limitation on interpolation table module.
+* Various Cygwin fixes.
+* Added some convenience functions to point3d.
+* Various compiler warning fixes.
+* Added a thread wrapper class (currently only supports pthreads)
+* Added IO routines for a lowlevel, native simgear binary 3d file
+  format optimized for TerraGear terrain.
+* Better endianness checking and support for the binary file
+  read/write routines.
+* Added doxygen comments for all public interface code.  Documentation
+  can be accessed via the SimGear web page.
+* Many FG -> SG name space changes for better consistency throughout
+  this package.
+* Added property aliases, repeated name tags, and a general xml
+  inclusion facilities.  Many other property manager clean ups
+  following a complete rewrite.
+* Fixed some critical null pointer bugs in property manager.
+* Magnetic variation can now be fetched for any arbitrary location.
+
+
+New in 0.0.14
+* December 14, 2000
+* Added a module to manage waypoints and routes, calculate bearing and
+  distance to next waypoint, lateral distance off route, etc.
+* Moved some of the basic time management code over from flightgear.
+* Bucket dimensions can be returned in meters
+* Added SOCK_STREAM (TCP) socket support to the networking code.
+* Updated random number generator interface so application can provide
+  it's own seed value as well as use the default time seed.
+* Added a routine to calculate the distance between a point and a line segment.
+* Updates to the property manager and the property list loader/saver.
+* Added an explanation of the rational behind our terrain texture coordinate
+  generation code.
+* Fixed sky dome so that the color at the horizon will always match
+  the specified fog color.
+* Did a fair amount of fg -> sg name space updating (lots left to do.)
+* Added support for KAI C++ on linux.
+* MSVC tweaks.
+* MacOS tweaks.
+* FreeBSD tweaks.
+
+
+New in 0.0.13
+* September 14, 2000
+* Added support for reading and writing xml files (easyxml)
+* Then updates to property manager and xml code.
+* Update magnetic variation code.
+* Sky code now uses glPushAttrib and glPopAttrib so it plays better with
+  other ssg based apps.
+* MacOS tweaks.
+* MSVC tweaks.
+
+
+New in 0.0.12
+* July 19, 2000
+* Converted project license from GPL to LGPL.
+* Moved low level IO (socket, file, serial) code over to SimGear.
+* Moved ephemeral code into simgear
+* Moved basic world time code into simgear
+* Added a property manager (registry)
+* Some documentation added.
+
+
+New in 0.0.11
+* July 3, 2000
+* Replaced gdbm with metakit
+* Added drop in sky (depends on plib)
+* Added spherical course and dist given two points calculations
+* MSVC5 fixes
+* Math/bucket/tiling tweaks from Norman Vine
+
+
+New in 0.0.7
+* March 29, 2000
+* Added support for RedHat package building contributed by Habibie 
+  <habibie@MailandNews.com>
+* Added gdbm to SimGear.  Many systems will already have gdbm installed so
+  it is only built if it doesn't already exist on the user's platform.
+  gdbm is a set of database routines that use extendible hashing and works
+  similar to the standard UNIX dbm routines.  This guarantees the availability
+  of gdbm to any application that uses SimGear.
+* Optimizations and bullet proofing of magnetic variation code by Norman 
+  Vine and Ed Williams
+
+
+New in 0.0.6
+* March 27, 2000
+* Added Nima World Magnetic Model 2000 contributed by Ed Williams
+* Fixes for MSVC++
+
+
+New in 0.0.5
+* March 17, 2000
+* Restructured directory layout to facilitate windows/mac IDE builds.
+
+
+New in 0.0.4
+* Removed mat3.h and friends (we now use plib's sg lib for these sorts of 
+  things.)
+
+
+New in 0.0.3
+* Release that coincides with FlightGear-0.7.2

README

@@ -0,0 +1,15 @@
+SimGear - Simulator Construction Tools
+======================================
+http://www.flightgear.org
+
+SimGear is a set of open-source libraries designed to be used as building
+blocks for quickly assembling 3d simulations, games, and visualization
+applications.
+
+SimGear is developed by the FlightGear project and also provides the base
+for the FlightGear Flight Simulator.
+
+Source code for SimGear is released under the GNU Library General Public
+License (LGPL) - see COPYING for license details.
+
+See INSTALL file for help on building SimGear.

README.OSG

@@ -0,0 +1,26 @@
+[This file is mirrored in both the FlightGear and SimGear packages.]
+
+You *must* have OpenSceneGraph (OSG) installed to build this version of
+FlightGear.
+
+Notice that this version of SimGear/FlightGear requires at least OSG 3.0.0.
+
+You can get the latest version of OSG from:
+
+http://www.openscenegraph.org/
+
+Build notes:
+
+Unzip the file OpenSceneGraph-x.x.zip and install using the following
+commands:
+
+unzip OpenSceneGraph-x.x
+cd OpenSceneGraph
+ccmake .
+
+[ While running ccmake: press 'c' to configure, press 'c' once more, and
+  then press 'g' to generate and exit ]
+
+make
+sudo make install
+

README.OpenAL

@@ -0,0 +1,20 @@
+[This file is mirrored in both the FlightGear and SimGear packages.]
+
+You *must* have the development components of OpenAL installed on your system
+to build FlightGear!"  You can get a copy here:
+
+      http://connect.creativelabs.com/openal/default.aspx
+
+Build notes:
+
+You can download a versioned release of the openal library from 
+http://www.openal.org/downloads.html. Download the openal source,
+release 0.0.8 (dated February 11, 2006) and run:  
+tar xjvf openal-soft-1.5.304.tar.bz2
+cd openal-soft-1.5.304/
+ccmake .
+
+[ While running ccmake: press 'c' to configure, press 'c' once more, and
+  then press 'g' to generate and exit ]
+
+

README.cmake

@@ -0,0 +1,161 @@
+Getting started with CMake
+==========================
+
+(These instructions apply to Unix-like systems, including Cygwin and Mac. To
+build using Visual Studio or some other IDE supported by CMake, most of the
+information below still applies. Otherwise see
+http://wiki.flightgear.org/Building_Flightgear for Windows specific build
+instructions.)
+
+Always compile in a separate directory to the code. For example, if the
+code (eg, from Git) is at /home/curt/projects/simgear, you might create
+/home/curt/projects/sgbuild. Change into the new directory, and run
+
+    cmake ../simgear
+
+To generate standard Unix Makefiles in sgbuild.
+
+Probably you want to specify an install prefix:
+
+    cmake ../simgear -DCMAKE_INSTALL_PREFIX=/usr
+
+Note the install prefix is automatically searched for required libraries
+and header files, so if you install OpenSceneGraph to the same prefix,
+most configuration options are unnecessary.
+
+If for some reason you have a dependency (or several) at a different prefix,
+you can specify one or more via CMAKE_PREFIX_PATH:
+
+    cmake ../simgear -DCMAKE_PREFIX_PATH="/opt/local;/opt/fgfs"
+
+(note the use of semi-colons to specify multiple prefix paths)
+
+Standard prefixes are searched automatically (/usr, /usr/local, /opt/local)
+
+Most dependencies also expose an environment variable to specify their
+installation directory explicitly eg OSG_DIR. Any of the methods
+described above will work, but specifying an INSTALL_PREFIX or PREFIX_PATH is
+usually simpler.
+
+By default, we select a release build. To create a debug build, use
+
+    cmake ../simgear -DCMAKE_BUILD_TYPE=Debug
+
+(or MinSizeRel, or RelWithDbg)
+
+Debug builds will automatically use corresponding debug builds of required
+libraries, if they are available. For example you can install debug builds of
+OpenSceneGraph, and a debug SimGear build will use them.
+
+(Debug builds of libraries have the 'd' suffix by default - Release builds
+have no additional suffix)
+
+Note most IDE projects (eg Xcode and Visual Studio) support building all the
+build types from the same project, so you can omit the CMAKE_BUILD_TYPE option
+when running cmake, and simply pick the build configuration as normal in the
+IDE.
+
+It's common to have several build directories with different build
+configurations, eg
+
+    /home/curt/projects/simgear (the git clone)
+    /home/curt/projects/sgdebug
+    /home/curt/projects/sgrelease
+    /home/curt/projects/sg-with-svn-osg
+
+To set an optional feature, do
+
+    cmake ../simgear -DFEATURE_NAME=ON
+
+(or 'OFF' to disable )
+
+To see the variables that can be configured / are currently defined, you can
+run one of the GUI front ends, or the following command:
+
+    cmake ../simgear -L
+
+Add 'A' to see all the options (including advanced options), or 'H' to see
+the help for each option (similar to running configure --help under autoconf):
+
+    cmake ../simgear -LH
+
+
+Build Targets
+=============
+
+For a Unix makefile build, 'make dist', 'make uninstall' and 'make test' are
+all available and should work as expected. 'make clean' is also as normal,
+but there is *no* 'make distclean' target. The equivalent is to completely
+remove your build directory, and start with a fresh one.
+
+Adding new files to the build
+
+Add source files to the SOURCES list, and headers to the HEADERS list. Note
+technically you only need to add source files, but omitting headers confuses
+project generation and distribution / packaging targets.
+
+For target conditional files, you can append to the SOURCES or HEADERS lists
+inside an if() test, for example:
+
+    if(APPLE)
+        list(APPEND SOURCES extraFile1.cxx extraFile2.cxx)
+    endif()
+
+Setting include directories
+
+In any CMakeList.txt, you can do the following:
+
+    include_directories(${PROJECT_SOURCE_DIR}/some/path)
+
+For example, this can be done in particular subdirectory, or at the project
+root, or an intermediate level.
+
+Setting target specific compile flags, includes or defines
+
+Use set_target_property(), for example
+
+    set_target_property(fgfs PROPERTIES
+            COMPILE_DEFINITIONS FOO BAR=1)
+
+You can set a property on an individual source file:
+
+    set_property(SOURCE myfile.cxx PROPERTY COMPILE_FLAGS "-Wno-unsigned-compare")
+
+Detecting Features / Libraries
+
+For most standard libraries (Gtk, wxWidget, Python, GDAL, Qt, libXml, Boost),
+cmake provides a standard helper. To see the available modules, run:
+
+     cmake --help-module-list
+
+In the root CMakeLists file, use a statement like:
+
+    find_package(OpenGL REQUIRED)
+
+Each package helper sets various variables such aaa_FOUND, aaa_INCLUDE_DIR,
+and aaa_LIBRARY. Depending on the complexity of the package, these variables
+might have different names (eg, OPENSCENEGRAPH_LIBRARIES).
+
+If there's no standard helper for a library you need, find a similar one, copy
+it to CMakeModules/FindABC.cmake, and modify the code to fit. Generally this
+is pretty straightforward. The built-in modules reside in the Cmake 'share'
+directory, eg /usr/share/cmake/modules on Unix systems.
+
+Note libraries support by pkg-config can be handled directly, with no need
+to create a custom FindABC helper.
+
+Adding a new executable target
+
+    add_executable(myexecutable ${SOURCES} ${HEADERS})
+    target_link_libraries(myexecutable .... libraries ... )
+    install(TARGETS myexecutable RUNTIME DESTINATION bin)
+
+(If the executable should not be installed, omit the final line above)
+
+If you add an additional line
+
+    add_test(testname ${EXECUTABLE_OUTPUT_PATH}/myexecutable)
+
+Then running 'make test' will run your executable as a unit test. The
+executable should return either a success or failure result code.
+

README.zlib

@@ -0,0 +1,8 @@
+zlib is prerequisite for compiling SimGear and FlightGear.  You can fetch
+the latest version of zlib from:
+
+    http://www.zlib.net
+
+Most modern unix distributions (and cygwin) come with a version of zlib
+already installed or available to install as a package.
+

SimGear.spec.in

@@ -0,0 +1,76 @@
+%define ver	@VERSION@
+%define rel	1
+%define prefix	/usr
+
+Summary:	Simulator Construction Gear.
+Name:		@PACKAGE@
+Version:	%ver
+Release:	%rel
+Copyright:	LGPL
+Group:		Libraries/Graphics
+Source:		%{name}-%{version}.tar.gz
+#URL:		
+BuildRoot:	/tmp/%{name}-%{version}-%{rel}-root
+Packager:	Fill In As You Wish
+Docdir:		%{prefix}/doc
+
+%description
+This package contains a tools and libraries useful for constructing 
+simulation and visualization applications such as FlightGear or TerraGear. 
+
+Authors:
+	N/A
+
+%prep
+%setup -n %{name}-%{version}
+
+
+%build
+# Needed for snapshot releases.
+if [ ! -f configure ]; then
+	CFLAGS="$RPM_OPT_FLAGS" ./autogen.sh --prefix=%prefix
+else
+	CFLAGS="$RPM_OPT_FLAGS" ./configure --prefix=%prefix
+fi
+
+if [ "$SMP" != "" ]; then
+	JSMP	= '"MAKE=make -k -j $SMP"'
+fi
+
+make ${JSMP};
+
+
+%install
+[ -d ${RPM_BUILD_ROOT} ] && rm -rf ${RPM_BUILD_ROOT}
+
+make prefix=${RPM_BUILD_ROOT}%{prefix} install
+
+#
+# Generating file lists and store them in file-lists
+# Starting with the directory listings
+#
+find ${RPM_BUILD_ROOT}%{prefix}/{bin,include,lib} -type d | sed "s#^${RPM_BUILD_ROOT}#\%attr (-\,root\,root) \%dir #" > file-lists
+%{?ETCDR:find ${RPM_BUILD_ROOT}%{!?SYSCF:%{prefix}}/etc -type d | sed "s#^${RPM_BUILD_ROOT}#\%attr (-\,root\,root) \%dir #" >> file-lists}
+
+#
+# Then, the file listings
+#
+echo "%defattr (-, root, root)" >> file-lists
+%{?ETCDR:find ${RPM_BUILD_ROOT}%{!?SYSCF:%{prefix}}/etc/%{name}.conf -type f | sed -e "s#^${RPM_BUILD_ROOT}#%config #g" >> file-lists}
+find ${RPM_BUILD_ROOT}%{prefix} -type f | sed -e "s#^${RPM_BUILD_ROOT}##g" >> file-lists
+
+
+%clean
+(cd ..; rm -rf %{name}-%{version} ${RPM_BUILD_ROOT})
+
+
+%files -f file-lists
+%defattr (-, root, root)
+%doc AUTHORS
+%doc COPYING
+%doc ChangeLog
+%doc INSTALL
+%doc NEWS
+%doc README
+%doc %{name}.spec.in
+

Thanks

@@ -0,0 +1,205 @@
+A very special thanks is due to the following people and groups.
+
+Note: as hard as we've tried, it is impossible to perfectly maintain
+this file.  If you are aware of someone who you think should be
+included here, PLEASE let me know.  Projects like this are made
+possible only by the help and hard work of others.  I want to properly
+credit everyone who has contributed to this project.
+
+
+Raul Alonzo <amil@las.es>
+  Mr. Alonzo is the author of Ssystem and provided his kind permission 
+  for using the moon texture. I also used parts of his code as a template
+  when adding the texture.  Ssystem Homepage can be found at:
+  http://www1.las.es/~amil/ssystem
+
+
+Paul Bleisch <pbleisch@acm.org>
+  Paul redid the "debug" system so that it would be much more flexible,
+  so it could be easily disabled for production system, and so that 
+  messages for certain subsystems could be selectively enabled.
+  Also contributed a first stab at a config file/command line parsing
+  system.
+
+
+Bernie Bright <bbright@c031.aone.net.au>
+  Many C++ style, usage, and implementation improvements.  
+  STL portability, tons o' stuff. :-)
+  Currently trying to get a BeOS port together but life keeps getting 
+  in the way!
+
+
+Gene Buckle <geneb@deltasoft.com>
+  Gene has done a lot of work getting FG to compile with the MSVC++
+  compiler.  Also, he has pushed, proded, and bugged me endlessly to
+  do my stuff right.  (I mean that in a good way, because sometimes
+  when the little nudge in the right direction isn't working, I need
+  a good hard shove.) :-)
+
+
+John Check <j4strngs@rockfish.net>
+  Cloud textures
+
+
+Jean-Francois Doue
+  Vector 2D, 3D, 4D and Matrix 3D and 4D inlined C++ classes.  (Based on
+  Graphics Gems IV ed. Paul S. Heckbert)
+  http://www.animats.com/simpleppp/ftp/public_html/topics/developers.html
+
+
+Melchior Franz
+  METAR parser and fetcher. "material" animation (based on Jim Wilsons's
+  "emission" animation). Debugging and extension of property listener
+  features. Addition of removeChildren.
+
+
+Mathias Froehlich
+  Reworked and cleaned up large parts of the infrastructure, of math
+  files, animations and rendering in preparation of a transition to
+  the OSG library. Added new handlers for shared and referenced objects.
+
+
+Bruce Finney <bfinney@gte.net>
+  MSVC5 compatibility.
+
+
+Jean-loup Gailly and Mark Adler <zlib@gzip.org>
+  Authors of the zlib library.  Used for on-the-fly compression and
+  decompression routines.
+  http://www.cdrom.com/pub/infozip/zlib/
+
+
+Thomas Gellekum <tg@ihf.rwth-aachen.de>
+  Changes and updates for compiling on FreeBSD
+
+
+Habibie <habibie@MailandNews.com>
+  RedHat package building changes for SimGear.
+
+
+Bruce Jackson of NASA <e.b.jackson@larc.nasa.gov> 
+  Developed the LaRCsim code under funding by NASA which we use to provide
+  the flight model. Bruce has patiently answered my many, many questions.
+  http://dcb.larc.nasa.gov/www/DCBStaff/ebj/ebj.html
+
+
+Maik Justus
+  Fixed an old bug in the SGPropertyNode class.
+
+
+Richard Kaszeta <bofh@me.umn.edu>
+  Contributed screen buffer to ppm screen shot routine.
+  Rich has also helped in the early development of the Flight Gear "altitude 
+  hold autopilot module" by teaching Curt Olson the basics of Control Theory 
+  and helping him code and debug early versions. Curt's "Boss" Bob Hain
+  also contributed <bob@me.umn.edu>.  Further details available at:
+  http://www.menet.umn.edu/~curt/fgfs/Docs/Autopilot/AltitudeHold/AltitudeHold.html
+  Rich's Homepage: http://www.menet.umn.edu/~kaszeta
+
+
+Tom Knienieder <tom@knienieder.com>
+  Ported Steve's Audio library first to OpenBSD and IRIX and
+  after that also to Win32
+
+
+David Megginson <david@megginson.com>
+  SimGear property manager/registry
+
+
+Tim Moore
+  Ported the (chrome) "shader" animation to OSG, and helped with porting
+  the "material" animation.
+
+
+Curt Olson http://www.flightgear.org/~curt/
+  Curt is responsible for overall project and source code management.
+  He has his hands in many of the areas.
+
+
+Petter Reinholdtsen <pere@games.no>
+  Incorporated the Gnu automake/autoconf system (with libtool).
+  This should streamline and standardize the build process for all
+  Unix-like platforms.  It should have little effect on IDE type 
+  environments since these don't use the Unix make system.
+
+
+Paul Schlyter <pausch@saaf.se>  
+  Mr. Schlyter provided Durk Talsma with all the information 
+  he needed to write the astro code. Mr. S. is also willing 
+  to answer astro-related questions whenever one needs to.
+  http://welcome.to/pausch
+
+
+Durk Talsma <d.talsma@chello.nl>
+  Accurate Sun, Moon, and Planets. 
+  Sun changes color based on position in sky.
+  Moon has correct phase and blends well into the sky.
+  Planets are correctly positioned and have proper magnitude.
+  Added time zone support in the SGTime class.
+  Help with time functions, gui, and other misc stuff.
+  http://people.a2000.nl/dtals
+
+
+Mark Vallevand <Mark.Vallevand@UNISYS.com>
+  Contributed some METAR parsing code.
+  Contributed some win32 screen printing routines.
+
+
+Gary R. Van Sickle <tiberius@braemarinc.com>
+  Contributed some initial GameGLUT support and other fixes.
+  Has done some interesting preliminary work on a binary file format
+  http://www.woodsoup.org/projs/ORKiD/fgfs.htm
+
+  Has set up a 'Cygwin Tips' site that has been very helpful to many 
+  people in getting a Cygwin Unix-on-Windows build environment set up
+  so they can build FG effectively. 
+  http://www.woodsoup.org/projs/ORKiD/cygwin.htm
+
+
+Norman Vine <nhv@yahoo.com>
+  Provided more than uncountable URL's to the "FlightGear Community".
+  Many performance optimizations throughout the code.  
+  Lots of windoze related contributions.
+  Contributed wgs84 distance and course routines.
+  Contributed a great circle route autopilot mode based on wgs84 routines.
+
+
+Ed Williams <Ed_Williams@compuserve.com>
+  Contributed magnetic variation code (impliments Nima WMM 2000)
+  We've also borrowed from Ed's wonderful aviation formulary at various
+  times as well.
+  http://www.best.com/~williams/index.html
+
+
+Jean-Claude Wippler <jcw@equi4.com>
+  Author of MetaKit - a portable, embeddible database with a portable
+  data file format.  This software is not GPL'd but the author is kindly
+  allowing us to bundle MetaKit with our code.  MetaKit has a liberal
+  X/MIT-style license.  Please see the following URL for more info:
+  http://www.equi4.com/metakit
+
+
+WoodSoup Project  http://www.woodsoup.org
+  Provided computing resources and services so that the Flight Gear 
+  project could have real home.  This includes, web services, 
+  ftp services, shell accounts, email lists, dns services, etc.
+
+
+Robert Allan Zeh <raz@cmg.FCNBD.COM>
+  Helped me tremendously in figuring out the Cygnus win32 compiler and
+  how to link with .dll's.  With out him the first runable win32
+  version of FG would have been impossible.
+
+
+
+NOTE:
+----
+
+THIS DOCUMENT WAS INITIALLY WRITTEN BY 
+Curt L. Olson  <http://www.flightgear.org/~curt>
+
+
+05 Jul 2000 Removed non-SimGear entries (CLO)
+
+08 Mar 2000 CONTENTS RESEARCHED AND UPDATED by 
+            Oliver Delise  <delise@mail.isis.de>

VERSION.in

@@ -1 +0,0 @@
-@VERSION@

acconfig.h

@@ -1,324 +0,0 @@
-/* acconfig.h
-   This file is in the public domain.
-
-   Descriptive text for the C preprocessor macros that
-   the distributed Autoconf macros can define.
-   No software package will use all of them; autoheader copies the ones
-   your configure.in uses into your configuration header file templates.
-
-   The entries are in sort -df order: alphabetical, case insensitive,
-   ignoring punctuation (such as underscores).  Although this order
-   can split up related entries, it makes it easier to check whether
-   a given entry is in the file.
-
-   Leave the following blank line there!!  Autoheader needs it.  */
-
-
-/* Define if on AIX 3.
-   System headers sometimes define this.
-   We just want to avoid a redefinition error message.  */
-#ifndef _ALL_SOURCE
-#undef _ALL_SOURCE
-#endif
-
-/* Define if using alloca.c.  */
-#undef C_ALLOCA
-
-/* Define if type char is unsigned and you are not using gcc.  */
-#ifndef __CHAR_UNSIGNED__
-#undef __CHAR_UNSIGNED__
-#endif
-
-/* Define if the closedir function returns void instead of int.  */
-#undef CLOSEDIR_VOID
-
-/* Define to empty if the keyword does not work.  */
-#undef const
-
-/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems.
-   This function is required for alloca.c support on those systems.  */
-#undef CRAY_STACKSEG_END
-
-/* Define for DGUX with <sys/dg_sys_info.h>.  */
-#undef DGUX
-
-/* Define if you have <dirent.h>.  */
-#undef DIRENT
-
-/* Define to enable audio support */
-#undef ENABLE_AUDIO_SUPPORT
-
-/* Define to enable GLUT joystick support (limited to 3 axes) */
-#undef ENABLE_GLUT_JOYSTICK
-   
-/* Define to enable plib joystick support (recommended) */
-#undef ENABLE_PLIB_JOYSTICK
-   
-/* Define to eliminate all trace of debugging messages such as for a 
-   release build */
-#undef FG_NDEBUG
-   
-/* Define to include Oliver's networking support */
-#undef FG_NETWORK_OLK
-   
-/* Define to avoid Christian's new weather code */
-#undef FG_OLD_WEATHER
-   
-/* Define if we are building FGFS (should always be defined) */
-#undef FGFS
-   
-/* Define to enable 3dfx/glide render in a window hack under unix.
-   This probably won't work under windows. */
-#undef XMESA
-#undef FX
-
-/* Define to the type of elements in the array set by `getgroups'.
-   Usually this is either `int' or `gid_t'.  */
-#undef GETGROUPS_T
-
-/* Define if the `getloadavg' function needs to be run setuid or setgid.  */
-#undef GETLOADAVG_PRIVILEGED
-
-/* Define if the `getpgrp' function takes no argument.  */
-#undef GETPGRP_VOID
-
-/* Define to `int' if <sys/types.h> doesn't define.  */
-#undef gid_t
-
-/* Define if you have alloca, as a function or macro.  */
-#undef HAVE_ALLOCA
-
-/* Define if you have <alloca.h> and it should be used (not on Ultrix).  */
-#undef HAVE_ALLOCA_H
-
-/* Define if you external variables daylight.  */
-#undef HAVE_DAYLIGHT
-
-/* Define if you don't have vprintf but do have _doprnt.  */
-#undef HAVE_DOPRNT
-
-/* Define if your system has a working fnmatch function.  */
-#undef HAVE_FNMATCH
-
-/* Define if your system has its own `getloadavg' function.  */
-#undef HAVE_GETLOADAVG
-
-/* Define if you have getrusage() */
-#undef HAVE_GETRUSAGE
-
-/* Define if you have the getmntent function.  */
-#undef HAVE_GETMNTENT
-
-/* Define if you have the gpc library and headers installed.  */
-#undef HAVE_GPC_H
-
-/* Define if the `long double' type works.  */
-#undef HAVE_LONG_DOUBLE
-
-/* Define if you support file names longer than 14 characters.  */
-#undef HAVE_LONG_FILE_NAMES
-
-/* Define if you have a working `mmap' system call.  */
-#undef HAVE_MMAP
-
-/* Define if system calls automatically restart after interruption
-   by a signal.  */
-#undef HAVE_RESTARTABLE_SYSCALLS
-
-/* Define if you have rint() which rounds to closest int but returns
-   result as a double data type.  */
-#undef HAVE_RINT
-
-/* Define if your struct stat has st_blksize.  */
-#undef HAVE_ST_BLKSIZE
-
-/* Define if your struct stat has st_blocks.  */
-#undef HAVE_ST_BLOCKS
-
-/* Define if you have the strcoll function and it is properly defined.  */
-#undef HAVE_STRCOLL
-
-/* Define if your struct stat has st_rdev.  */
-#undef HAVE_ST_RDEV
-
-/* Define if you have the strftime function.  */
-#undef HAVE_STRFTIME
-
-/* Define if you have <sys/param.h>  */
-#undef HAVE_SYS_PARAM_H
-
-/* Define if you have <sys/stat.h> that is POSIX.1 compatible.  */
-#undef HAVE_SYS_STAT_H
-
-/* Define if you have <sys/wait.h> that is POSIX.1 compatible.  */
-#undef HAVE_SYS_WAIT_H
-
-/* Define if you have timegm() */
-#undef HAVE_TIMEGM
-
-/* Define if you external variables timezone.  */
-#undef HAVE_TIMEZONE
-
-/* Define if your struct tm has tm_zone.  */
-#undef HAVE_TM_ZONE
-
-/* Define if you don't have tm_zone but do have the external array
-   tzname.  */
-#undef HAVE_TZNAME
-
-/* Define if you have <unistd.h>.  */
-#undef HAVE_UNISTD_H
-
-/* Define if utime(file, NULL) sets file's timestamp to the present.  */
-#undef HAVE_UTIME_NULL
-
-/* Define if you have <vfork.h>.  */
-#undef HAVE_VFORK_H
-
-/* Define if you have the vprintf function.  */
-#undef HAVE_VPRINTF
-
-/* Define if you have the wait3 system call.  */
-#undef HAVE_WAIT3
-
-/* Define as __inline if that's what the C compiler calls it.  */
-#undef inline
-
-/* Define if int is 16 bits instead of 32.  */
-#undef INT_16_BITS
-
-/* Define if long int is 64 bits.  */
-#undef LONG_64_BITS
-
-/* Define if major, minor, and makedev are declared in <mkdev.h>.  */
-#undef MAJOR_IN_MKDEV
-
-/* Define if major, minor, and makedev are declared in <sysmacros.h>.  */
-#undef MAJOR_IN_SYSMACROS
-
-/* Define if on MINIX.  */
-#undef _MINIX
-
-/* Define to `int' if <sys/types.h> doesn't define.  */
-#undef mode_t
-
-/* Define if you don't have <dirent.h>, but have <ndir.h>.  */
-#undef NDIR
-
-/* Define if you have <memory.h>, and <string.h> doesn't declare the
-   mem* functions.  */
-#undef NEED_MEMORY_H
-
-/* Define if your struct nlist has an n_un member.  */
-#undef NLIST_NAME_UNION
-
-/* Define if you have <nlist.h>.  */
-#undef NLIST_STRUCT
-
-/* Define if your C compiler doesn't accept -c and -o together.  */
-#undef NO_MINUS_C_MINUS_O
-
-/* Define to `long' if <sys/types.h> doesn't define.  */
-#undef off_t
-
-/* Define to package name */
-#undef PACKAGE
-
-/* Define to `int' if <sys/types.h> doesn't define.  */
-#undef pid_t
-
-/* Define if the system does not provide POSIX.1 features except
-   with this defined.  */
-#undef _POSIX_1_SOURCE
-
-/* Define if you need to in order for stat and other things to work.  */
-#undef _POSIX_SOURCE
-
-/* Define as the return type of signal handlers (int or void).  */
-#undef RETSIGTYPE
-
-/* Define if the `setpgrp' function takes no argument.  */
-#undef SETPGRP_VOID
-
-/* Define if the setvbuf function takes the buffering type as its second
-   argument and the buffer pointer as the third, as on System V
-   before release 3.  */
-#undef SETVBUF_REVERSED
-
-/* Define to `unsigned' if <sys/types.h> doesn't define.  */
-#undef size_t
-
-/* If using the C implementation of alloca, define if you know the
-   direction of stack growth for your system; otherwise it will be
-   automatically deduced at run-time.
-	STACK_DIRECTION > 0 => grows toward higher addresses
-	STACK_DIRECTION < 0 => grows toward lower addresses
-	STACK_DIRECTION = 0 => direction of growth unknown
- */
-#undef STACK_DIRECTION
-
-/* Define if the `S_IS*' macros in <sys/stat.h> do not work properly.  */
-#undef STAT_MACROS_BROKEN
-
-/* Define if you have the ANSI C header files.  */
-#undef STDC_HEADERS
-
-/* Define on System V Release 4.  */
-#undef SVR4
-
-/* Define if you don't have <dirent.h>, but have <sys/dir.h>.  */
-#undef SYSDIR
-
-/* Define if you don't have <dirent.h>, but have <sys/ndir.h>.  */
-#undef SYSNDIR
-
-/* Define if `sys_siglist' is declared by <signal.h>.  */
-#undef SYS_SIGLIST_DECLARED
-
-/* Define if you can safely include both <sys/time.h> and <time.h>.  */
-#undef TIME_WITH_SYS_TIME
-
-/* Define if your <sys/time.h> declares struct tm.  */
-#undef TM_IN_SYS_TIME
-
-/* Define to `int' if <sys/types.h> doesn't define.  */
-#undef uid_t
-
-/* Define for Encore UMAX.  */
-#undef UMAX
-
-/* Define for Encore UMAX 4.3 that has <inq_status/cpustats.h>
-   instead of <sys/cpustats.h>.  */
-#undef UMAX4_3
-
-/* Define if you do not have <strings.h>, index, bzero, etc..  */
-#undef USG
-
-/* Define to version number */
-#undef VERSION
-
-/* Define vfork as fork if vfork does not work.  */
-#undef vfork
-
-/* Define if the closedir function returns void instead of int.  */
-#undef VOID_CLOSEDIR
-
-/* Define if compiling on a Winbloze (95, NT, etc.) platform */
-#undef WIN32
-
-/* Define if your processor stores words with the most significant
-   byte first (like Motorola and SPARC, unlike Intel and VAX).  */
-#undef WORDS_BIGENDIAN
-
-/* Define if the X Window System is missing or not being used.  */
-#undef X_DISPLAY_MISSING
-
-/* Define if lex declares yytext as a char * by default, not a char[].  */
-#undef YYTEXT_POINTER
-
-
-/* Leave that blank line there!!  Autoheader needs it.
-   If you're adding to this file, keep in mind:
-   The entries are in sort -df order: alphabetical, case insensitive,
-   ignoring punctuation (such as underscores).  */
-

aclocal.m4

@@ -1,149 +0,0 @@
-dnl aclocal.m4 generated automatically by aclocal 1.3
-
-dnl Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
-dnl This Makefile.in is free software; the Free Software Foundation
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-dnl This program is distributed in the hope that it will be useful,
-dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without
-dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-dnl PARTICULAR PURPOSE.
-
-# Do all the work for Automake.  This macro actually does too much --
-# some checks are only needed if your package does certain things.
-# But this isn't really a big deal.
-
-# serial 1
-
-dnl Usage:
-dnl AM_INIT_AUTOMAKE(package,version, [no-define])
-
-AC_DEFUN(AM_INIT_AUTOMAKE,
-[AC_REQUIRE([AM_PROG_INSTALL])
-PACKAGE=[$1]
-AC_SUBST(PACKAGE)
-VERSION=[$2]
-AC_SUBST(VERSION)
-dnl test to see if srcdir already configured
-if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
-  AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
-fi
-ifelse([$3],,
-AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE")
-AC_DEFINE_UNQUOTED(VERSION, "$VERSION"))
-AC_REQUIRE([AM_SANITY_CHECK])
-AC_REQUIRE([AC_ARG_PROGRAM])
-dnl FIXME This is truly gross.
-missing_dir=`cd $ac_aux_dir && pwd`
-AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
-AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
-AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
-AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
-AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
-AC_REQUIRE([AC_PROG_MAKE_SET])])
-
-
-# serial 1
-
-AC_DEFUN(AM_PROG_INSTALL,
-[AC_REQUIRE([AC_PROG_INSTALL])
-test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
-AC_SUBST(INSTALL_SCRIPT)dnl
-])
-
-#
-# Check to make sure that the build environment is sane.
-#
-
-AC_DEFUN(AM_SANITY_CHECK,
-[AC_MSG_CHECKING([whether build environment is sane])
-# Just in case
-sleep 1
-echo timestamp > conftestfile
-# Do `set' in a subshell so we don't clobber the current shell's
-# arguments.  Must try -L first in case configure is actually a
-# symlink; some systems play weird games with the mod time of symlinks
-# (eg FreeBSD returns the mod time of the symlink's containing
-# directory).
-if (
-   set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
-   if test "[$]*" = "X"; then
-      # -L didn't work.
-      set X `ls -t $srcdir/configure conftestfile`
-   fi
-   if test "[$]*" != "X $srcdir/configure conftestfile" \
-      && test "[$]*" != "X conftestfile $srcdir/configure"; then
-
-      # If neither matched, then we have a broken ls.  This can happen
-      # if, for instance, CONFIG_SHELL is bash and it inherits a
-      # broken ls alias from the environment.  This has actually
-      # happened.  Such a system could not be considered "sane".
-      AC_MSG_ERROR([ls -t appears to fail.  Make sure there is not a broken
-alias in your environment])
-   fi
-
-   test "[$]2" = conftestfile
-   )
-then
-   # Ok.
-   :
-else
-   AC_MSG_ERROR([newly created file is older than distributed files!
-Check your system clock])
-fi
-rm -f conftest*
-AC_MSG_RESULT(yes)])
-
-dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)
-dnl The program must properly implement --version.
-AC_DEFUN(AM_MISSING_PROG,
-[AC_MSG_CHECKING(for working $2)
-# Run test in a subshell; some versions of sh will print an error if
-# an executable is not found, even if stderr is redirected.
-# Redirect stdin to placate older versions of autoconf.  Sigh.
-if ($2 --version) < /dev/null > /dev/null 2>&1; then
-   $1=$2
-   AC_MSG_RESULT(found)
-else
-   $1="$3/missing $2"
-   AC_MSG_RESULT(missing)
-fi
-AC_SUBST($1)])
-
-# Define a conditional.
-
-AC_DEFUN(AM_CONDITIONAL,
-[AC_SUBST($1_TRUE)
-AC_SUBST($1_FALSE)
-if $2; then
-  $1_TRUE=
-  $1_FALSE='#'
-else
-  $1_TRUE='#'
-  $1_FALSE=
-fi])
-
-# Like AC_CONFIG_HEADER, but automatically create stamp file.
-
-AC_DEFUN(AM_CONFIG_HEADER,
-[AC_PREREQ([2.12])
-AC_CONFIG_HEADER([$1])
-dnl When config.status generates a header, we must update the stamp-h file.
-dnl This file resides in the same directory as the config header
-dnl that is generated.  We must strip everything past the first ":",
-dnl and everything past the last "/".
-AC_OUTPUT_COMMANDS(changequote(<<,>>)dnl
-ifelse(patsubst(<<$1>>, <<[^ ]>>, <<>>), <<>>,
-<<test -z "<<$>>CONFIG_HEADERS" || echo timestamp > patsubst(<<$1>>, <<^\([^:]*/\)?.*>>, <<\1>>)stamp-h<<>>dnl>>,
-<<am_indx=1
-for am_file in <<$1>>; do
-  case " <<$>>CONFIG_HEADERS " in
-  *" <<$>>am_file "*<<)>>
-    echo timestamp > `echo <<$>>am_file | sed -e 's%:.*%%' -e 's%[^/]*$%%'`stamp-h$am_indx
-    ;;
-  esac
-  am_indx=`expr "<<$>>am_indx" + 1`
-done<<>>dnl>>)
-changequote([,]))])
-

acsite.m4

@@ -1,394 +0,0 @@
-dnl
-dnl originally from ncftp 2.3.0
-dnl added wi_EXTRA_PDIR and wi_ANSI_C
-dnl $Id$
-dnl
-AC_DEFUN(wi_EXTRA_IDIR, [
-incdir="$1"
-if test -r $incdir ; then
-	case "$CPPFLAGS" in
-		*-I${incdir}*)
-			# echo "   + already had $incdir" 1>&6
-			;;
-		*)
-			if test "$CPPFLAGS" = "" ; then
-				CPPFLAGS="-I$incdir"
-			else
-				CPPFLAGS="$CPPFLAGS -I$incdir"
-			fi
-			echo "   + found $incdir" 1>&6
-			;;
-	esac
-fi
-])
-dnl
-dnl
-dnl
-dnl
-AC_DEFUN(wi_EXTRA_LDIR, [
-mylibdir="$1"
-if test -r $mylibdir ; then
-	case "$LDFLAGS" in
-		*-L${mylibdir}*)
-			# echo "   + already had $mylibdir" 1>&6
-			;;
-		*)
-			if test "$LDFLAGS" = "" ; then
-				LDFLAGS="-L$mylibdir"
-			else
-				LDFLAGS="$LDFLAGS -L$mylibdir"
-			fi
-			echo "   + found $mylibdir" 1>&6
-			;;
-	esac
-fi
-])
-dnl
-dnl __FP__
-dnl
-dnl
-AC_DEFUN(wi_EXTRA_PDIR, [
-progdir="$1"
-if test -r $progdir ; then
-	case "$PATH" in
-		*:${progdir}*)
-			# echo "   + already had $progdir" 1>&6
-			;;
-		*${progdir}:*)
-			# echo "   + already had $progdir" 1>&6
-			;;
-		*)
-			if test "$PATH" = "" ; then
-				PATH="$progdir"
-			else
-				PATH="$PATH:$progdir"
-			fi
-			echo "   + found $progdir" 1>&6
-			;;
-	esac
-fi
-])
-dnl
-dnl
-dnl If you want to also look for include and lib subdirectories in the
-dnl $HOME tree, you supply "yes" as the first argument to this macro.
-dnl
-dnl If you want to look for subdirectories in include/lib directories,
-dnl you pass the names in argument 3, otherwise pass a dash.
-dnl
-AC_DEFUN(wi_EXTRA_DIRS, [echo "checking for extra include and lib directories..." 1>&6
-ifelse([$1], yes, [dnl
-b1=`cd .. ; pwd`
-b2=`cd ../.. ; pwd`
-exdirs="$HOME $j $b1 $b2 $prefix $2"
-],[dnl
-exdirs="$prefix $2"
-])
-subexdirs="$3"
-if test "$subexdirs" = "" ; then
-	subexdirs="-"
-fi
-for subexdir in $subexdirs ; do
-if test "$subexdir" = "-" ; then
-	subexdir=""
-else
-	subexdir="/$subexdir"
-fi
-for exdir in $exdirs ; do
-	if test "$exdir" != "/usr" || test "$subexdir" != ""; then
-		incdir="${exdir}/include${subexdir}"
-		wi_EXTRA_IDIR($incdir)
-
-		mylibdir="${exdir}/lib${subexdir}"
-		wi_EXTRA_LDIR($mylibdir)
-
-		progdir="${exdir}/bin${subexdirr}"
-		wi_EXTRA_PDIR($progdir)
-	fi
-done
-done
-])
-dnl
-dnl
-dnl
-AC_DEFUN(wi_HPUX_CFLAGS,
-[AC_MSG_CHECKING(if HP-UX ansi C compiler flags are needed)
-AC_REQUIRE([AC_PROG_CC])
-os=`uname -s | tr '[A-Z]' '[a-z]'`
-ac_cv_hpux_flags=no
-if test "$os" = hp-ux ; then
-	if test "$ac_cv_prog_gcc" = yes ; then
-		if test "$CFLAGS" != "" ; then
-			# Shouldn't be in there.
-			CFLAGS=`echo "$CFLAGS" | sed 's/-Aa//g'`
-		fi
-	else
-		# If you're not using gcc, then you better have a cc/c89
-		# that is usable.  If you have the barebones compiler, it
-		# won't work.  The good compiler uses -Aa for the ANSI
-		# compatible stuff.
-		x=`echo $CFLAGS | grep 'Aa' 2>/dev/null`
-		if test "$x" = "" ; then
-			CFLAGS="$CFLAGS -Aa"
-		fi
-		ac_cv_hpux_flags=yes
-	fi
-	# Also add _HPUX_SOURCE to get the extended namespace.
-	x=`echo $CFLAGS | grep '_HPUX_SOURCE' 2>/dev/null`
-	if test "$x" = "" ; then
-		CFLAGS="$CFLAGS -D_HPUX_SOURCE"
-	fi
-fi
-AC_MSG_RESULT($ac_cv_hpux_flags)
-])
-dnl
-dnl
-dnl
-AC_DEFUN(wi_CFLAGS, [AC_REQUIRE([AC_PROG_CC])
-wi_HPUX_CFLAGS
-	if test "$CFLAGS" = "" ; then
-		CFLAGS="-O"
-	elif test "$ac_cv_prog_gcc" = "yes" ; then
-		case "$CFLAGS" in
-			*"-g -O"*)
-				#echo "using -g as default gcc CFLAGS" 1>&6
-				CFLAGS=`echo $CFLAGS | sed 's/-g\ -O/-O/'`
-				;;
-			*"-O -g"*)
-				# Leave the -g, but remove all -O options.
-				#echo "using -g as default gcc CFLAGS" 1>&6
-				CFLAGS=`echo $CFLAGS | sed 's/-O\ -g/-O/'`
-				;;
-		esac
-	fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN(wi_PROTOTYPES, [
-AC_MSG_CHECKING(if the compiler supports function prototypes)
-AC_TRY_COMPILE(,[extern void exit(int status);],[wi_cv_prototypes=yes
-AC_DEFINE(PROTOTYPES)],wi_cv_prototypes=no)
-AC_MSG_RESULT($wi_cv_prototypes)
-])
-dnl
-dnl
-dnl
-AC_DEFUN(wi_ANSI_C, [
-AC_MSG_CHECKING(ANSI-style function definitions)
-AC_TRY_COMPILE(,[int blubb(int x) { return 0; }],[wi_cv_ansi_funcs=yes
-AC_DEFINE(ANSI_FUNCS)],wi_cv_ansi_funcs=no)
-AC_MSG_RESULT($wi_cv_ansi_funcs)
-])
-dnl
-dnl
-dnl
-AC_DEFUN(wi_HEADER_SYS_SELECT_H, [
-# See if <sys/select.h> is includable after <sys/time.h>
-if test "$ac_cv_header_sys_time_h" = no ; then
-AC_CHECK_HEADERS(sys/time.h sys/select.h)
-else
-AC_CHECK_HEADERS(sys/select.h)
-fi
-if test "$ac_cv_header_sys_select_h" = yes ; then
-	AC_MSG_CHECKING([if <sys/select.h> is compatible with <sys/time.h>])
-	selecth=yes
-	if test "$ac_cv_header_sys_time_h" = yes ; then
-		AC_TRY_COMPILE([#include <sys/time.h>
-		#include <sys/select.h>],[
-		fd_set a;
-		struct timeval tmval;
-
-		tmval.tv_sec = 0;],selecth=yes,selecth=no)
-
-		if test "$selecth" = yes ; then
-			AC_DEFINE(CAN_USE_SYS_SELECT_H)
-		fi
-	fi
-	AC_MSG_RESULT($selecth)
-fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN(wi_LIB_RESOLV, [
-# See if we could access two well-known sites without help of any special
-# libraries, like resolv.
-
-AC_TRY_RUN([
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netdb.h>
- 
-main()
-{
-	struct hostent *hp1, *hp2;
-	int result;
-
-	hp1 = gethostbyname("gatekeeper.dec.com");
-	hp2 = gethostbyname("ftp.ncsa.uiuc.edu");
-	result = ((hp1 != (struct hostent *) 0) && (hp2 != (struct hostent *) 0));
-	exit(! result);
-}],look_for_resolv=no,look_for_resolv=yes,look_for_resolv=yes)
-
-AC_MSG_CHECKING([if we need to look for -lresolv])
-AC_MSG_RESULT($look_for_resolv)
-if test "$look_for_resolv" = yes ; then
-AC_CHECK_LIB(resolv,main)
-else
-	ac_cv_lib_resolv=no
-fi
-])
-dnl
-dnl
-dnl
-
-AC_DEFUN(wi_LIB_NSL, [
-AC_MSG_CHECKING(if we can use -lnsl)
-ac_save_LIBS="$LIBS";
-LIBS="$LIBS -lnsl";
-AC_CACHE_VAL(r_cv_use_libnsl, [
-AC_TRY_RUN(
-main() { if (getpwuid(getuid())) exit(0); exit(-1); },
-nc_cv_use_libnsl=yes, nc_cv_use_libnsl=no, nc_cv_use_libnsl=no)
-])
-if test "$nc_cv_use_libnsl" = "no"; then LIBS="$ac_save_LIBS"; fi
-AC_MSG_RESULT($nc_cv_use_libnsl)
-])dnl
-
-dnl
-dnl
-dnl
-
-AC_DEFUN(nc_PATH_PROG_ZCAT, [
-AC_PATH_PROG(GZCAT,gzcat)
-AC_PATH_PROG(ZCAT,zcat)
-if test "x$GZCAT" = x ; then
-	if test "x$ZCAT" != x ; then
-		# See if zcat is really gzcat.  gzcat has a --version option, regular
-		# zcat does not.
-		AC_MSG_CHECKING(if zcat is really gzcat in disguise)
-		if $ZCAT --version 2> /dev/null ; then
-			AC_DEFINE_UNQUOTED(GZCAT, "$ZCAT")
-			AC_MSG_RESULT(yes)
-		else
-			AC_MSG_RESULT(no)
-		fi
-	fi
-else
-	AC_DEFINE_UNQUOTED(GZCAT, "$GZCAT")
-fi
-
-if test "x$ZCAT" != x ; then
-	AC_DEFINE_UNQUOTED(ZCAT, "$ZCAT")
-fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN(wi_SYSV_EXTRA_DIRS, [
-# Use System V because their curses extensions are required.  This must
-# be done early so we use the -I and -L in the library checks also.
-# This is mostly a Solaris/SunOS hack.  Note that doing this will also
-# use all of the other System V libraries and headers.
-
-AC_MSG_CHECKING(for alternative System V libraries)
-if test -f /usr/5include/curses.h ; then
-	CPPFLAGS="$CPPFLAGS -I/usr/5include"
-	LDFLAGS="$LDFLAGS -L/usr/5lib"
-	AC_MSG_RESULT(yes)
-else
-	AC_MSG_RESULT(no)
-fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN(wi_DEFINE_UNAME, [
-# Get first 127 chars of all uname information.  Some folks have
-# way too much stuff there, so grab only the first 127.
-unam=`uname -a 2>/dev/null | cut -c1-127`
-if test "$unam" != "" ; then
-	AC_DEFINE_UNQUOTED(UNAME, "$unam")
-fi
-])
-dnl
-dnl
-dnl
-AC_DEFUN(wi_READLINE_WITH_NCURSES, [
-# Readline and Ncurses could both define "backspace".
-# Warn about this if we have both things in our definitions list.
-
-if test "$ac_cv_lib_readline" = yes && test "$ac_cv_lib_ncurses" = yes ; then
-
-AC_MSG_CHECKING(if readline and ncurses will link together)
-j="$LIBS"
-LIBS="-lreadline -lncurses"
-AC_TRY_LINK(,[
-readline("prompt");
-endwin();
-],k=yes,k=no)
-if test "$k" = no ; then
-	AC_MSG_RESULT(no)
-	# Remove '-lreadline' from LIBS.
-	LIBS=`echo $j | sed s/-lreadline//g`
-	ac_cv_lib_readline=no
-	AC_WARN([The versions of GNU readline and ncurses you have installed on this system
-can't be used together, because they use the same symbol, backspace. If
-possible, recompile one of the libraries with -Dbackspace=back_space, then
-re-run configure.])
-
-else
-	AC_MSG_RESULT(yes)
-	LIBS="$j"
-fi
-
-fi
-])
-dnl
-dnl
-dnl
-
-dnl AC_EXT_DAYLIGHT
-dnl Check for an external variable daylight. Stolen from w3c-libwww.
-AC_DEFUN(AC_EXT_DAYLIGHT,
-[ AC_MSG_CHECKING(int daylight variable)
-AC_TRY_COMPILE([#include <time.h>], [return daylight;],
-  have_daylight=yes,
-  have_daylight=no)
-AC_MSG_RESULT($have_daylight)
-])dnl
-
-dnl AC_EXT_TIMEZONE
-dnl Check for an external variable timezone. Stolen from tcl-8.0.
-AC_DEFUN(AC_EXT_TIMEZONE,
-[
-#
-# Its important to include time.h in this check, as some systems (like convex)
-# have timezone functions, etc.
-#
-have_timezone=no
-AC_MSG_CHECKING([long timezone variable])
-AC_TRY_COMPILE([#include <time.h>],
-        [extern long timezone;
-         timezone += 1;
-         exit (0);],
-        [have_timezone=yes
-         AC_MSG_RESULT(yes)],
-         AC_MSG_RESULT(no))
-
-#
-# On some systems (eg IRIX 6.2), timezone is a time_t and not a long.
-#
-if test "$have_timezone" = no; then
-   AC_MSG_CHECKING([time_t timezone variable])
-   AC_TRY_COMPILE([#include <time.h>],
-        [extern time_t timezone;
-         timezone += 1;
-         exit (0);],
-        [have_timezone=yes
-         AC_MSG_RESULT(yes)],
-         AC_MSG_RESULT(no))
-fi
-])dnl

configure.in

@@ -1,259 +0,0 @@
-dnl Process this file with aclocal ; automake -a ; autoconf to produce a 
-dnl working configure script.
-dnl
-dnl $Id$
-
-AC_INIT(src/bucket/newbucket.cxx)
-
-dnl Initialize the automake stuff
-AM_INIT_AUTOMAKE(SimGear, 0.0.1)
-
-dnl Checks for programs.
-AC_PROG_MAKE_SET
-AC_PROG_CC
-AC_PROG_CXX
-AC_PROG_RANLIB
-AC_PROG_INSTALL
-AC_PROG_LN_S
-
-if echo $includedir | egrep "simgear$" > /dev/null; then
-    echo "includedir is" $includedir "libdir is" $libdir
-else
-    includedir="${includedir}/simgear"
-    echo "includedir changed to" $includedir "libdir is" $libdir
-fi
-
-
-dnl Specify if we want logging (testing build) or not (release build)
-# set logging default value
-# with_logging=yes
-AC_ARG_WITH(logging, [  --with-logging          Include logging output (default)])
-if test "x$with_logging" = "xno" ; then
-    AC_DEFINE(FG_NDEBUG)
-fi
-
-dnl specify if we are building with "checker"
-AC_ARG_WITH(efence, [  --with-efence           Specify if we are building with "electric-fence"])
-
-if test "x$with_efence" = "xyes" ; then
-    echo "Building with efence"
-    LIBS= "$LIBS -lefence"
-fi
-
-dnl Check for MS Windows environment
-AC_CHECK_HEADER(windows.h)
-
-dnl extra library and include directories
-EXTRA_DIRS="/usr/local /usr/local/plib /usr/X11R6"
-
-if test -d /opt/X11R6 ; then
-     EXTRA_DIRS="$EXTRA_DIRS /opt/X11R6"
-fi
-
-if test "x$ac_cv_header_windows_h" = "xyes" ; then
-    EXTRA_DIRS="${EXTRA_DIRS} `pwd`/Win32"
-# elif test `uname -s` = "SunOS" ; then
-#   EXTRA_DIRS="${EXTRA_DIRS} `pwd`/SunOS"
-fi
-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
-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 Enable serial support on Unix type systems
-AM_CONDITIONAL(ENABLE_UNIX_SERIAL, true)
-
-dnl Check for X11 (fancy)
-AC_PATH_XTRA
-
-dnl Checks for libraries.
-
-null_LIBS="$LIBS"
-
-AC_CHECK_LIB(m, cos)
-
-base_LIBS="$LIBS"
-
-AC_CHECK_LIB(socket, socket)
-AC_CHECK_LIB(X11, XCreateWindow)
-AC_CHECK_LIB(Xext, XShmCreateImage)
-AC_CHECK_LIB(Xi, XGetExtensionVersion)
-AC_CHECK_LIB(ICE, IceOpenConnection)
-AC_CHECK_LIB(SM, SmcOpenConnection)
-AC_CHECK_LIB(Xt, XtMalloc)
-AC_CHECK_LIB(Xmu, XmuLookupStandardColormap)
-
-dnl check for OpenGL related libraries
-
-if test "x$ac_cv_header_windows_h" != "xyes" ; then
-    dnl Reasonable stuff for non-windoze variants ... :-)
-
-    AC_CHECK_LIB(GLcore, glNewList)
-    if test "x$ac_cv_lib_GLcore_glNewList" = "xno" ; then
-	dnl if no GLcore, check for GL
-	AC_CHECK_LIB(GL, glNewList)
-	if test "x$ac_cv_lib_GL_glNewList" = "xno" ; then
-	    dnl if no GL, check for MesaGL
-	    AC_CHECK_LIB(MesaGL, glNewList)
-	fi
-    else
-	dnl if GLcore found, then also check for GL
-	AC_CHECK_LIB(GL, glXCreateContext)
-    fi
-
-    dnl if using mesa, check for xmesa.h
-    if test "x$ac_cv_lib_MesaGL_glNewList" = "xyes" ; then
-	AC_CHECK_HEADER(GL/xmesa.h)
-	if test "x$ac_cv_header_GL_xmesa_h" = "xyes"; then
-	    AC_DEFINE( XMESA )
-            AC_DEFINE( FX )
-        fi
-    fi
-
-    AC_CHECK_LIB(GLU, gluLookAt)
-    if test "x$ac_cv_lib_GLU_gluLookAt" = "xno" ; then
-	dnl if no GLU, check for MesaGLU
-	AC_CHECK_LIB(MesaGLU, gluLookAt)
-    fi
-
-    dnl check for glut
-    AC_CHECK_LIB(glut, glutGetModifiers)
-
-    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 is a little wierd because it has to try to handle the various
-    dnl winbloze-isms.  We'll just do this manually for now.
-
-    echo Win32 specific hacks...
-    AC_DEFINE(WIN32)
-
-    dnl force a failed check since we will be building under windoze
-    AM_CONDITIONAL(ENABLE_XMESA_FX, test "no" = "yes")
-
-    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"
-    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 fetch and install the latest version of glut from:"
-    echo
-    echo "    http://reality.sgi.com/opengl/glut3/glut3.html"
-    exit 1
-fi
-
-opengl_LIBS="$LIBS"
-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 "plib" without which we cannot go on
-AC_CHECK_HEADER(plib/pu.h)
-if test "x$ac_cv_header_plib_pu_h" != "xyes"; then
-    echo
-    echo "You *must* have the plib library installed on your system to build"
-    echo "the FGFS simulator!"
-    echo
-    echo "Please see README.plib for more details."
-    echo
-    echo "configure aborted."
-    exit
-fi
-
-dnl Check for system installed zlib
-AC_CHECK_HEADER(zlib.h)
-if test "x$ac_cv_header_zlib_h" != "xyes"; then
-    echo "no zlib found, building."
-fi
-AM_CONDITIONAL(HAVE_ZLIB, test "x$ac_cv_header_zlib_h" = "xyes" )
-
-dnl Checks for header files.
-AC_HEADER_STDC
-AC_CHECK_HEADERS( \
-	fcntl.h getopt.h malloc.h memory.h stdlib.h sys/param.h sys/stat.h \
-        sys/time.h sys/timeb.h unistd.h windows.h winbase.h values.h )
-
-dnl Checks for typedefs, structures, and compiler characteristics.
-AC_C_CONST
-AC_TYPE_SIZE_T
-AC_HEADER_TIME
-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 \
-	random setitimer getitimer signal GetLocalTime rint getrusage )
-
-AM_CONFIG_HEADER(src/include/config.h)
-
-AC_OUTPUT( \
-	VERSION \
-	Makefile \
-	src/Makefile \
-	src/include/Makefile \
-	src/bucket/Makefile \
-	src/debug/Makefile \
-	src/math/Makefile \
-	src/misc/Makefile \
-	src/screen/Makefile \
-	src/serial/Makefile \
-	src/xgl/Makefile \
-	src/zlib/Makefile \
-)
-
-AC_OUTPUT_COMMANDS([./mksymlinks.sh])
-
-echo ""
-echo "Configure Summary"
-echo "================="
-
-echo "Prefix: $prefix"
-
-if test "x$with_logging" != "x"; then
-    echo "Debug messages: $with_logging"
-else
-    echo "Debug messages: yes"
-fi
-
-if test "x$with_efence" != "x"; then
-    echo "Electric fence: $with_efence"
-else
-    echo "Electric fence: no"
-fi

mksymlinks.sh

@@ -1,39 +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 ../../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/mat3.h src/simgear/math/mat3.h
-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

package/RedHat/README

@@ -0,0 +1,13 @@
+Building a SimGear RPM package for Red Hat
+
+Please see the "package/openSUSE" directory for an
+example how to build a SimGear RPM package with
+shared SimGear libraries.
+
+You may need to adapt the names (exact spelling) of some
+of the package dependencies in the openSUSE RPM spec,
+since these may slightly differ for Red Hat.
+
+(If you have a working and tested Red Hat RPM spec,
+you're welcome to contribute it to this project.)
+

package/openSUSE/README

@@ -0,0 +1,23 @@
+Building a SimGear RPM package for openSUSE
+
+(Last tested with openSUSE 11.4+12.1)
+
+This directory contains the files which, along with
+the source code tar files, can be used to build
+an RPM package targeted at an openSUSE Linux system.
+
+To build SimGear from source do the following:
+
+1. obtain simgear-2.8.0.tar.bz2 (adapt version if
+    necessary) and copy it into ~/rpmbuild/SOURCES
+
+2. look in the BuildRequires section of SimGear.spec
+   and check that all the packages referred to are
+   installed (note, some of these packages may be part
+   of openSUSE's "games" repository).
+
+3. run 'rpmbuild -ba simgear.spec' and find the RPM
+   build result in ~/rpmbuild/RPMS
+
+That's all!
+

package/openSUSE/SimGear.spec

@@ -0,0 +1,63 @@
+Summary:    Simulator Construction Gear
+Name:       SimGear
+Version:    2.8.0
+Release:    1
+License:    LGPL
+URL:        http://www.flightgear.org
+Group:      Amusements/Games/3D/Simulation
+Source:     http://mirrors.ibiblio.org/pub/mirrors/flightgear/ftp/Source/simgear-%{version}.tar.bz2
+BuildRoot:  %{_tmppath}/%{name}-%{version}-build
+
+BuildRequires: gcc, gcc-c++, cmake
+BuildRequires: libopenal1-soft, openal-soft
+BuildRequires: libOpenSceneGraph-devel >= 3.0
+BuildRequires: zlib, zlib-devel
+BuildRequires: libjpeg62, libjpeg62-devel
+BuildRequires: boost-devel >= 1.37
+BuildRequires: subversion-devel, libapr1-devel
+Requires:      OpenSceneGraph-plugins >= 3.0
+
+%description
+This package contains a tools and libraries useful for constructing
+simulation and visualization applications such as FlightGear or TerraGear.
+
+%package devel
+Group:         Development/Libraries/Other
+Summary:       Development header files for SimGear
+Requires:      SimGear = %{version}
+
+%description devel
+Development headers and libraries for building applications against SimGear.
+
+%prep
+%setup -T -q -n simgear-%{version} -b 0
+
+%build
+export CFLAGS="$RPM_OPT_FLAGS"
+export CXXFLAGS="$RPM_OPT_FLAGS"
+# build SHARED simgear libraries
+cmake -DCMAKE_INSTALL_PREFIX=%{_prefix} -DSIMGEAR_SHARED:BOOL=ON -DENABLE_TESTS:BOOL=OFF -DJPEG_FACTORY:BOOL=ON
+make %{?_smp_mflags}
+
+%install
+make DESTDIR=%{buildroot} install
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+%files
+%defattr (-, root, root, -)
+%doc AUTHORS COPYING ChangeLog NEWS README
+%{_libdir}/libSimGear*.so.*
+
+%files devel
+%defattr(-,root,root,-)
+%dir %{_includedir}/simgear
+%{_includedir}/simgear/*
+%{_libdir}/libSimGear*.so
+
+%changelog
+* Mon Jul 02 2012 thorstenb@flightgear.org
+- Initial version
+

simgear/.gitignore

@@ -0,0 +1,2 @@
+simgear_config.h
+version.h

simgear/CMakeLists.txt

@@ -0,0 +1,143 @@
+
+file(WRITE ${PROJECT_BINARY_DIR}/simgear/version.h "#define SIMGEAR_VERSION ${SIMGEAR_VERSION}")
+
+foreach( mylibfolder 
+        bucket
+        bvh
+        debug
+        ephemeris
+        io
+        magvar
+        math
+        misc
+        nasal
+        nasal/cppbind
+        props
+        serial
+        structure
+        threads
+        timing
+        xml
+        package
+    )
+
+    add_subdirectory(${mylibfolder})
+
+endforeach( mylibfolder )
+
+if(NOT SIMGEAR_HEADLESS)
+    add_subdirectory(canvas)
+    add_subdirectory(environment)
+    add_subdirectory(screen)
+    add_subdirectory(scene)
+    add_subdirectory(sound)
+endif(NOT SIMGEAR_HEADLESS)
+
+
+if(ENABLE_RTI)
+    add_subdirectory(hla)
+endif(ENABLE_RTI)
+
+
+set(HEADERS compiler.h constants.h sg_inlines.h ${PROJECT_BINARY_DIR}/simgear/version.h)
+install (FILES ${HEADERS}  DESTINATION include/simgear/)
+
+get_property(coreSources GLOBAL PROPERTY CORE_SOURCES)
+get_property(sceneSources GLOBAL PROPERTY SCENE_SOURCES)
+get_property(publicHeaders GLOBAL PROPERTY PUBLIC_HEADERS)
+get_property(localExpatSources GLOBAL PROPERTY LOCAL_EXPAT_SOURCES)
+
+if(SIMGEAR_SHARED)
+    message(STATUS "Library building mode: SHARED LIBRARIES")
+    add_library(SimGearCore SHARED ${coreSources} ${localExpatSources})
+
+    set_property(TARGET SimGearCore PROPERTY LINKER_LANGUAGE CXX)
+    set_property(TARGET SimGearCore PROPERTY VERSION   ${SIMGEAR_VERSION})
+    set_property(TARGET SimGearCore PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
+    install(TARGETS SimGearCore EXPORT SimGearCoreConfig LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    install(EXPORT SimGearCoreConfig DESTINATION share/SimGearCore)
+    
+    if(NOT SIMGEAR_HEADLESS)
+        add_library(SimGearScene SHARED ${sceneSources})
+        set_property(TARGET SimGearScene PROPERTY LINKER_LANGUAGE CXX)
+        set_property(TARGET SimGearScene PROPERTY VERSION   ${SIMGEAR_VERSION})
+        set_property(TARGET SimGearScene PROPERTY SOVERSION ${SIMGEAR_SOVERSION})
+
+        # EXPORT SimGearSceneConfig
+        install(TARGETS SimGearScene LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} )
+    #    install(EXPORT SimGearSceneConfig DESTINATION share/SimGearScene)
+    endif()
+    
+else()
+    message(STATUS "Library building mode: STATIC LIBRARIES")
+
+	get_property(FG_GROUPS_CORE_SOURCES_C GLOBAL PROPERTY FG_GROUPS_CORE_SOURCES_C)
+	string(REPLACE "@" ";" groups ${FG_GROUPS_CORE_SOURCES_C} )
+	foreach(g ${groups})
+		string(REPLACE "#" ";" g2 ${g})
+		list(GET g2 0 name)
+		list(REMOVE_AT g2 0)
+		source_group("${name}\\Sources" FILES ${g2})
+	endforeach()
+
+	get_property(FG_GROUPS_CORE_SOURCES_H GLOBAL PROPERTY FG_GROUPS_CORE_SOURCES_H)
+	string(REPLACE "@" ";" groups ${FG_GROUPS_CORE_SOURCES_H} )
+	foreach(g ${groups})
+		string(REPLACE "#" ";" g2 ${g})
+		list(GET g2 0 name)
+		list(REMOVE_AT g2 0)
+		source_group("${name}\\Headers" FILES ${g2})
+	endforeach()
+
+    add_library(SimGearCore STATIC ${coreSources} ${localExpatSources})
+    install(TARGETS SimGearCore ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    
+    if(NOT SIMGEAR_HEADLESS)
+		get_property(FG_GROUPS_SCENE_SOURCES_C GLOBAL PROPERTY FG_GROUPS_SCENE_SOURCES_C)
+		string(REPLACE "@" ";" groups ${FG_GROUPS_SCENE_SOURCES_C} )
+		foreach(g ${groups})
+			string(REPLACE "#" ";" g2 ${g})
+			list(GET g2 0 name)
+			list(REMOVE_AT g2 0)
+			source_group("${name}\\Sources" FILES ${g2})
+		endforeach()
+
+		get_property(FG_GROUPS_SCENE_SOURCES_H GLOBAL PROPERTY FG_GROUPS_SCENE_SOURCES_H)
+		string(REPLACE "@" ";" groups ${FG_GROUPS_SCENE_SOURCES_H} )
+		foreach(g ${groups})
+			string(REPLACE "#" ";" g2 ${g})
+			list(GET g2 0 name)
+			list(REMOVE_AT g2 0)
+			source_group("${name}\\Headers" FILES ${g2})
+		endforeach()
+
+        add_library(SimGearScene STATIC ${sceneSources})
+        install(TARGETS SimGearScene ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    endif(NOT SIMGEAR_HEADLESS)
+endif(SIMGEAR_SHARED)
+
+target_link_libraries(SimGearCore
+    ${ZLIB_LIBRARY}
+    ${RT_LIBRARY}
+    ${DL_LIBRARY}
+    ${EXPAT_LIBRARIES}
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${COCOA_LIBRARY})
+
+if(NOT SIMGEAR_HEADLESS)
+    target_link_libraries(SimGearScene
+        SimGearCore
+        ${ZLIB_LIBRARY}
+        ${OPENSCENEGRAPH_LIBRARIES}
+        ${OPENAL_LIBRARY}
+        ${OPENGL_LIBRARY}
+        ${JPEG_LIBRARY})
+endif()
+
+if(ENABLE_RTI)
+    # Ugly first aid to make hla compile agian
+    set_property(SOURCE hla/RTI13InteractionClass.cxx hla/RTI13ObjectClass.cxx
+        hla/RTI13ObjectInstance.cxx hla/RTI13Federate.cxx
+        hla/RTI13FederateFactory.cxx
+        APPEND PROPERTY COMPILE_FLAGS "-I${RTI_INCLUDE_DIR}")
+endif(ENABLE_RTI)

simgear/Makefile.am

@@ -1,27 +0,0 @@
-if ENABLE_UNIX_SERIAL
-SERIAL_DIRS = serial
-else
-SERIAL_DIRS =
-endif
-
-if HAVE_ZLIB
-ZLIB_DIRS =
-else
-ZLIB_DIRS = zlib
-endif
-
-METAR_DIRS =
-# METAR_DIRS = metar
-
-SUBDIRS = \
-	include \
-	bucket \
-	debug \
-	math \
-	$(METAR_DIRS) \
-	misc \
-	screen \
-	$(SERIAL_DIRS) \
-	xgl \
-	$(ZLIB_DIRS)
-

simgear/bucket/CMakeLists.txt

@@ -0,0 +1,16 @@
+
+include (SimGearComponent)
+
+set(HEADERS newbucket.hxx)
+set(SOURCES newbucket.cxx)
+
+simgear_component(bucket bucket "${SOURCES}" "${HEADERS}")
+
+
+if(ENABLE_TESTS)
+
+add_executable(test_bucket test_bucket.cxx)
+add_test(test_bucket ${EXECUTABLE_OUTPUT_PATH}/test_bucket)
+target_link_libraries(test_bucket ${TEST_LIBS})
+
+endif(ENABLE_TESTS)

simgear/bucket/Makefile.am

@@ -1,17 +0,0 @@
-includedir = @includedir@/bucket
-
-lib_LIBRARIES = libsgbucket.a
-
-include_HEADERS = newbucket.hxx
-
-libsgbucket_a_SOURCES = newbucket.cxx
-
-# noinst_PROGRAMS = testbucket
-
-# testbucket_SOURCES = testbucket.cxx
-
-# testbucket_LDADD = \
-# 	$(top_builddir)/bucket/libsgbucket.a \
-# 	$(top_builddir)/misc/libsgmisc.a
-
-INCLUDES += -I$(top_builddir)/src

simgear/bucket/newbucket.cxx

@@ -3,40 +3,189 @@
  *
  * Written by Curtis L. Olson, started February 1999.
  *
- * Copyright (C) 1999  Curtis L. Olson - curt@flightgear.org
+ * Copyright (C) 1999  Curtis L. Olson - http://www.flightgear.org/~curt/
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
  *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
+ * Library General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
  * $Id$
  **************************************************************************/
 
 
 #ifdef HAVE_CONFIG_H
-#  include <config.h>
+#  include <simgear_config.h>
 #endif
 
+#include <cmath>
+#include <cstdio> // some platforms need this for ::snprintf
+#include <iostream>
 
-#include <math.h>
-
-#include <simgear/misc/fgpath.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/debug/logstream.hxx>
 
 #include "newbucket.hxx"
 
 
+// default constructor
+SGBucket::SGBucket() :
+    lon(-1000),
+    lat(-1000),
+    x(0),
+    y(0)
+{
+}
+
+bool SGBucket::isValid() const
+{
+    // The most northerly valid latitude is 89, not 90. There is no tile
+    // whose *bottom* latitude is 90. Similar there is no tile whose left egde
+    // is 180 longitude.
+    return (lon >= -180) &&
+            (lon < 180) &&
+            (lat >= -90) &&
+            (lat < 90) &&
+            (x < 8) && (y < 8);
+}
+
+void SGBucket::make_bad()
+{
+    lon = -1000;
+    lat = -1000;
+}
+
+#ifndef NO_DEPRECATED_API
+
+// constructor for specified location
+SGBucket::SGBucket(const double dlon, const double dlat) {
+    set_bucket(dlon, dlat);
+}
+#endif
+
+SGBucket::SGBucket(const SGGeod& geod) {
+    innerSet(geod.getLongitudeDeg(),
+             geod.getLatitudeDeg());
+}
+
+// Parse a unique scenery tile index and find the lon, lat, x, and y
+SGBucket::SGBucket(const long int bindex) {
+    long int index = bindex;
+	
+    lon = index >> 14;
+    index -= lon << 14;
+    lon -= 180;
+
+    lat = index >> 6;
+    index -= lat << 6;
+    lat -= 90;
+
+    y = index >> 3;
+    index -= y << 3;
+
+    x = index;
+}
+
+/* Calculate the greatest integral value less than
+ * or equal to the given value (floor(x)),
+ * but attribute coordinates close to the boundary to the next
+ * (increasing) integral
+ */
+static int floorWithEpsilon(double x)
+{
+    return static_cast<int>(floor(x + SG_EPSILON));
+}
+
+#ifndef NO_DEPRECATED_API
+
+void SGBucket::set_bucket(double dlon, double dlat)
+{
+    innerSet(dlon, dlat);
+}
+
+
+void SGBucket::set_bucket(const SGGeod& geod)
+{
+    innerSet(geod.getLongitudeDeg(), geod.getLatitudeDeg());
+}
+
+#endif
+
+// Set the bucket params for the specified lat and lon
+void SGBucket::innerSet( double dlon, double dlat )
+{
+    if ((dlon < -180.0) || (dlon >= 180.0)) {
+        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed longitude:" << dlon);
+        dlon = SGMiscd::normalizePeriodic(-180.0, 180.0, dlon);
+    }
+    
+    if ((dlat < -90.0) || (dlat > 90.0)) {
+        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::set_bucket: passed latitude" << dlat);
+        dlat = SGMiscd::clip(dlat, -90.0, 90.0);
+    }
+    
+    //
+    // longitude first
+    //
+    double span = sg_bucket_span( dlat );
+    // we do NOT need to special case lon=180 here, since
+    // normalizePeriodic will never return 180; it will
+    // return -180, which is what we want.
+    lon = floorWithEpsilon(dlon);
+    
+    // find subdivision or super lon if needed
+    if ( span <= 1.0 ) {
+        /* We have more than one tile per degree of
+         * longitude, so we need an x offset.
+         */
+        x = floorWithEpsilon((dlon - lon) / span);
+    } else {
+        /* We have one or more degrees per tile,
+         * so we need to find the base longitude
+         * of that tile.
+         *
+         * First we calculate the integral base longitude
+         * (e.g. -85.5 => -86) and then find the greatest
+         * multiple of span that is less than or equal to
+         * that longitude.
+         *
+         * That way, the Greenwich Meridian is always
+         * a tile border.
+         */
+        lon=static_cast<int>(floor(lon / span) * span);
+        x = 0;
+    }
+
+    //
+    // then latitude
+    //
+    lat = floorWithEpsilon(dlat);
+    
+    // special case when passing in the north pole point (possibly due to
+    // clipping latitude above). Ensures we generate a valid bucket in this
+    // scenario
+    if (lat == 90) {
+        lat = 89;
+        y = 7;
+    } else {
+        /* Latitude base and offset are easier, as
+         * tiles always are 1/8 degree of latitude wide.
+         */
+        y = floorWithEpsilon((dlat - lat) * 8);
+    }
+}
+
 // Build the path name for this bucket
-string FGBucket::gen_base_path() const {
+std::string SGBucket::gen_base_path() const {
     // long int index;
     int top_lon, top_lat, main_lon, main_lat;
     char hem, pole;
@@ -74,29 +223,117 @@ string FGBucket::gen_base_path() const {
 	main_lat *= -1;
     }
 
-    sprintf(raw_path, "%c%03d%c%02d/%c%03d%c%02d", 
+    ::snprintf(raw_path, 256, "%c%03d%c%02d/%c%03d%c%02d",
 	    hem, top_lon, pole, top_lat, 
 	    hem, main_lon, pole, main_lat);
 
-    FGPath path( raw_path );
+    SGPath path( raw_path );
 
     return path.str();
 }
 
 
+// return width of the tile in degrees
+double SGBucket::get_width() const {
+    return sg_bucket_span( get_center_lat() );
+}
+
+
+// return height of the tile in degrees
+double SGBucket::get_height() const {
+    return SG_BUCKET_SPAN;
+}
+
+double SGBucket::get_highest_lat() const
+{
+    unsigned char adjustedY = y;
+    if (lat >= 0) {
+        // tile is north of the equator, so we want the top edge. Add one
+        // to y to achieve this.
+        ++adjustedY;
+    }
+    
+	return lat + (adjustedY / 8.0);
+}
+
+
+// return width of the tile in meters. This function is used by the
+// tile-manager to estimate how many tiles are in the view distance, so
+// we care about the smallest width, which occurs at the highest latitude.
+double SGBucket::get_width_m() const
+{
+    double clat_rad = get_highest_lat() * SGD_DEGREES_TO_RADIANS;
+    double cos_lat = cos( clat_rad );
+    if (fabs(cos_lat) < SG_EPSILON) {
+        // happens for polar tiles, since we pass in a latitude of 90
+        // return an arbitrary small value so all tiles are loaded
+        return 10.0;
+    }
+    
+    double local_radius = cos_lat * SG_EQUATORIAL_RADIUS_M;
+    double local_perimeter = local_radius * SGD_2PI;
+    double degree_width = local_perimeter / 360.0;
+
+    return get_width() * degree_width;
+}
+
+
+// return height of the tile in meters
+double SGBucket::get_height_m() const {
+    double perimeter = SG_EQUATORIAL_RADIUS_M * SGD_2PI;
+    double degree_height = perimeter / 360.0;
+
+    return SG_BUCKET_SPAN * degree_height;
+}
+
+SGBucket SGBucket::sibling(int dx, int dy) const
+{
+    if (!isValid()) {
+        SG_LOG(SG_TERRAIN, SG_WARN, "SGBucket::sibling: requesting sibling of invalid bucket");
+        return SGBucket();
+    }
+    
+    double clat = get_center_lat() + dy * SG_BUCKET_SPAN;
+    // return invalid here instead of clipping, so callers can discard
+    // invalid buckets without having to check if it's an existing one
+    if ((clat < -90.0) || (clat > 90.0)) {
+        return SGBucket();
+    }
+    
+    // find the lon span for the new latitude
+    double span = sg_bucket_span( clat );
+    
+    double tmp = get_center_lon() + dx * span;
+    tmp = SGMiscd::normalizePeriodic(-180.0, 180.0, tmp);
+    
+    SGBucket b;
+    b.innerSet(tmp, clat);
+    return b;
+}
+
+std::string SGBucket::gen_index_str() const
+{
+	char tmp[20];
+	::snprintf(tmp, 20, "%ld",
+                 (((long)lon + 180) << 14) + ((lat + 90) << 6)
+                 + (y << 3) + x);
+	return (std::string)tmp;
+}
+
+#ifndef NO_DEPRECATED_API
 // find the bucket which is offset by the specified tile units in the
 // X & Y direction.  We need the current lon and lat to resolve
 // ambiguities when going from a wider tile to a narrower one above or
 // below.  This assumes that we are feeding in
-FGBucket fgBucketOffset( double dlon, double dlat, int dx, int dy ) {
-    FGBucket result( dlon, dlat );
-    double clat = result.get_center_lat() + dy * FG_BUCKET_SPAN;
+SGBucket sgBucketOffset( double dlon, double dlat, int dx, int dy ) {
+    SGBucket result( dlon, dlat );
+    double clat = result.get_center_lat() + dy * SG_BUCKET_SPAN;
 
     // walk dy units in the lat direction
     result.set_bucket( dlon, clat );
 
     // find the lon span for the new latitude
-    double span = bucket_span( clat );
+    double span = sg_bucket_span( clat );
 
     // walk dx units in the lon direction
     double tmp = dlon + dx * span;
@@ -110,10 +347,10 @@ FGBucket fgBucketOffset( double dlon, double dlat, int dx, int dy ) {
 
     return result;
 }
-
+#endif
 
 // calculate the offset between two buckets
-void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy ) {
+void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy ) {
 
     // Latitude difference
     double c1_lat = b1.get_center_lat();
@@ -121,26 +358,42 @@ void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy ) {
     double diff_lat = c2_lat - c1_lat;
 
 #ifdef HAVE_RINT
-    *dy = (int)rint( diff_lat / FG_BUCKET_SPAN );
+    *dy = (int)rint( diff_lat / SG_BUCKET_SPAN );
 #else
     if ( diff_lat > 0 ) {
-	*dy = (int)( diff_lat / FG_BUCKET_SPAN + 0.5 );
+	*dy = (int)( diff_lat / SG_BUCKET_SPAN + 0.5 );
     } else {
-	*dy = (int)( diff_lat / FG_BUCKET_SPAN - 0.5 );
+	*dy = (int)( diff_lat / SG_BUCKET_SPAN - 0.5 );
     }
 #endif
 
     // longitude difference
-    double c1_lon = b1.get_center_lon();
-    double c2_lon = b2.get_center_lon();
-    double diff_lon = c2_lon - c1_lon;
-    double span;
-    if ( bucket_span(c1_lat) <= bucket_span(c2_lat) ) {
-	span = bucket_span(c1_lat);
+    double diff_lon=0.0;
+    double span=0.0;
+
+    SGBucket tmp_bucket;
+    // To handle crossing the bucket size boundary
+    //  we need to account for different size buckets.
+
+    if ( sg_bucket_span(c1_lat) <= sg_bucket_span(c2_lat) )
+    {
+	span = sg_bucket_span(c1_lat);
     } else {
-	span = bucket_span(c2_lat);
+	span = sg_bucket_span(c2_lat);
     }
 
+    diff_lon = b2.get_center_lon() - b1.get_center_lon();
+
+    if (diff_lon <0.0)
+    {
+       diff_lon -= b1.get_width()*0.5 + b2.get_width()*0.5 - span;
+    } 
+    else
+    {
+       diff_lon += b1.get_width()*0.5 + b2.get_width()*0.5 - span;
+    }
+
+
 #ifdef HAVE_RINT
     *dx = (int)rint( diff_lon / span );
 #else
@@ -152,4 +405,25 @@ void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy ) {
 #endif
 }
 
+void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>& list ) {
+    double lon, lat, span;
+
+    for (lat = min.getLatitudeDeg(); lat < max.getLatitudeDeg()+SG_BUCKET_SPAN; lat += SG_BUCKET_SPAN) {
+        span = sg_bucket_span( lat );
+        for (lon = min.getLongitudeDeg(); lon <= max.getLongitudeDeg(); lon += span)
+        {
+            SGBucket b(SGGeod::fromDeg(lon, lat));
+            if (!b.isValid()) {
+                continue;
+            }
+            
+            list.push_back(b);
+        }
+    }
+}
+
+std::ostream& operator<< ( std::ostream& out, const SGBucket& b )
+{
+    return out << b.lon << ":" << (int)b.x << ", " << b.lat << ":" << (int)b.y;
+}
 

simgear/bucket/newbucket.hxx

@@ -3,132 +3,63 @@
  *
  * Written by Curtis L. Olson, started February 1999.
  *
- * Copyright (C) 1999  Curtis L. Olson - curt@flightgear.org
+ * Copyright (C) 1999  Curtis L. Olson - http://www.flightgear.org/~curt
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
  *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
+ * Library General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
  * $Id$
  **************************************************************************/
 
+/** \file newbucket.hxx
+ * A class and associated utiltity functions to manage world scenery tiling.
+ *
+ * Tile borders are aligned along circles of latitude and longitude.
+ * All tiles are 1/8 degree of latitude high and their width in degrees
+ * longitude depends on their latitude, adjusted in such a way that
+ * all tiles cover about the same amount of area of the earth surface.
+ */
 
 #ifndef _NEWBUCKET_HXX
 #define _NEWBUCKET_HXX
 
 #include <simgear/compiler.h>
 #include <simgear/constants.h>
+#include <simgear/math/SGMath.hxx>
 
-#ifdef FG_HAVE_STD_INCLUDES
-#  include <cmath>
-#  include <cstdio> // sprintf()
-#  include <iostream>
-#else
-#  include <math.h>
-#  include <stdio.h> // sprintf()
-#  include <iostream.h>
-#endif
+#include <cmath>
+#include <string>
+#include <iosfwd>
+#include <vector>
 
-// I don't understand ... <math.h> or <cmath> should be included
-// already depending on how you defined FG_HAVE_STD_INCLUDES, but I
-// can go ahead and add this -- CLO
-#ifdef __MWERKS__
-#  include <math.h> // needed fabs()
-#endif
+// #define NO_DEPRECATED_API
 
-#include STL_STRING
+/**
+ * standard size of a bucket in degrees (1/8 of a degree)
+ */
+#define SG_BUCKET_SPAN      0.125
 
-FG_USING_STD(string);
-
-#if ! defined( FG_HAVE_NATIVE_SGI_COMPILERS )
-FG_USING_STD(ostream);
-#endif
-
-
-
-#define FG_BUCKET_SPAN      0.125   // 1/8 of a degree
-#define FG_HALF_BUCKET_SPAN 0.0625  // 1/2 of 1/8 of a degree = 1/16 = 0.0625
-
-class FGBucket;
-ostream& operator<< ( ostream&, const FGBucket& );
-bool operator== ( const FGBucket&, const FGBucket& );
-
-class FGBucket {
-
-private:
-    double cx, cy;  // centerpoint (lon, lat) in degrees of bucket
-    int lon;        // longitude index (-180 to 179)
-    int lat;        // latitude index (-90 to 89)
-    int x;          // x subdivision (0 to 7)
-    int y;          // y subdivision (0 to 7)
-
-public:
-    
-    // default constructor
-    FGBucket();
-
-    // create a bucket which would contain the specified lon/lat
-    FGBucket(const double lon, const double lat);
-
-    // create a bucket based on "long int" index
-    FGBucket(const long int bindex);
-
-    // create an impossible bucket if false
-    FGBucket(const bool is_good);
-
-    ~FGBucket();
-
-    // Set the bucket params for the specified lat and lon
-    void set_bucket( double dlon, double dlat );
-    void make_bad ( void );
-
-    // Generate the unique scenery tile index for this bucket
-    long int gen_index();
-    string gen_index_str() const;
-
-    // Build the path name for this bucket
-    string gen_base_path() const;
-
-    // return the center lon of a tile
-    double get_center_lon() const;
-
-    // return width of the tile
-    double get_width() const;
-
-    // return the center lat of a tile
-    double get_center_lat() const;
-
-    // return height of the tile
-    double get_height() const;
-
-    // Informational methods
-    inline int get_lon() const { return lon; }
-    inline int get_lat() const { return lat; }
-    inline int get_x() const { return x; }
-    inline int get_y() const { return y; }
-
-    // friends
-    friend ostream& operator<< ( ostream&, const FGBucket& );
-    friend bool operator== ( const FGBucket&, const FGBucket& );
-};
+/**
+ * half of a standard SG_BUCKET_SPAN
+ */
+#define SG_HALF_BUCKET_SPAN ( 0.5 * SG_BUCKET_SPAN )
 
 
 // return the horizontal tile span factor based on latitude
-inline double bucket_span( double l ) {
+static double sg_bucket_span( double l ) {
     if ( l >= 89.0 ) {
-	return 360.0;
-    } else if ( l >= 88.0 ) {
-	return 8.0;
+	return 12.0;
     } else if ( l >= 86.0 ) {
 	return 4.0;
     } else if ( l >= 83.0 ) {
@@ -149,195 +80,274 @@ inline double bucket_span( double l ) {
 	return 1.0;
     } else if ( l >= -86.0 ) {
 	return 2.0;
-    } else if ( l >= -88.0 ) {
-	return 4.0;
     } else if ( l >= -89.0 ) {
-	return 8.0;
+	return 4.0;
     } else {
-	return 360.0;
+	return 12.0;
     }
 }
 
 
-// Set the bucket params for the specified lat and lon
-inline void FGBucket::set_bucket( double dlon, double dlat ) {
-    //
-    // latitude first
-    //
-    double span = bucket_span( dlat );
-    double diff = dlon - (double)(int)dlon;
+/**
+ * A class to manage world scenery tiling.
+ * This class encapsulates the world tiling scheme.  It provides ways
+ * to calculate a unique tile index from a lat/lon, and it can provide
+ * information such as the dimensions of a given tile.
+ */
 
-    // cout << "diff = " << diff << "  span = " << span << endl;
+class SGBucket {
 
-    if ( (dlon >= 0) || (fabs(diff) < FG_EPSILON) ) {
-	lon = (int)dlon;
-    } else {
-	lon = (int)dlon - 1;
+private:
+    short lon;        // longitude index (-180 to 179)
+    short lat;        // latitude index (-90 to 89)
+    unsigned char x;          // x subdivision (0 to 7)
+    unsigned char y;          // y subdivision (0 to 7)
+
+    void innerSet( double dlon, double dlat );
+public:
+
+    /**
+     * Default constructor, creates an invalid SGBucket
+     */
+    SGBucket();
+
+    /**
+     * Check if this bucket refers to a valid tile, or not.
+     */
+    bool isValid() const;
+    
+#ifndef NO_DEPRECATED_API
+    /**
+     * Construct a bucket given a specific location.
+     * @param dlon longitude specified in degrees
+     * @param dlat latitude specified in degrees
+     */
+    SGBucket(const double dlon, const double dlat);
+#endif
+    
+    /**
+     * Construct a bucket given a specific location.
+     * @param dlon longitude specified in degrees
+     * @param dlat latitude specified in degrees
+     */
+    SGBucket(const SGGeod& geod);
+
+    /** Construct a bucket given a unique bucket index number.
+     * @param bindex unique bucket index
+     */
+    SGBucket(const long int bindex);
+
+#ifndef NO_DEPRECATED_API
+    /**
+     * Reset a bucket to represent a new lat and lon
+     * @param dlon longitude specified in degrees
+     * @param dlat latitude specified in degrees
+     */
+    void set_bucket(const SGGeod& geod);
+
+
+    /**
+     * Reset a bucket to represent a new lat and lon
+     * @param dlon longitude specified in degrees
+     * @param dlat latitude specified in degrees
+     */
+    void set_bucket( double dlon, double dlat );
+#endif
+    
+    /**
+     * Create an impossible bucket.
+     * This is useful if you are comparing cur_bucket to last_bucket
+     * and you want to make sure last_bucket starts out as something
+     * impossible.
+     */
+    void make_bad();
+    
+    /**
+     * Generate the unique scenery tile index for this bucket
+     *
+     * The index is constructed as follows:
+     * 
+     * 9 bits - to represent 360 degrees of longitude (-180 to 179)
+     * 8 bits - to represent 180 degrees of latitude (-90 to 89)
+     *
+     * Each 1 degree by 1 degree tile is further broken down into an 8x8
+     * grid.  So we also need:
+     *
+     * 3 bits - to represent x (0 to 7)
+     * 3 bits - to represent y (0 to 7)
+     * @return tile index
+     */
+    inline long int gen_index() const {
+	return ((lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x;
     }
 
-    // find subdivision or super lon if needed
-    if ( span < FG_EPSILON ) {
-	// polar cap
-	lon = 0;
-	x = 0;
-    } else if ( span <= 1.0 ) {
-	x = (int)((dlon - lon) / span);
-    } else {
-	if ( (dlon >= 0) || (fabs(diff) < FG_EPSILON) ) {
-	    lon = (int)( (int)(lon / span) * span);
+    /**
+     * Generate the unique scenery tile index for this bucket in ascii
+     * string form.
+     * @return tile index in string form
+     */
+    std::string gen_index_str() const;
+    
+    /**
+     * Build the base path name for this bucket.
+     * @return base path in string form
+     */
+    std::string gen_base_path() const;
+
+    /**
+     * @return the center lon of a tile.
+     */
+    inline double get_center_lon() const {
+	double span = sg_bucket_span( lat + y / 8.0 + SG_HALF_BUCKET_SPAN );
+
+	if ( span >= 1.0 ) {
+	    return lon + get_width() / 2.0;
 	} else {
-	    // cout << " lon = " << lon 
-	    //  << "  tmp = " << (int)((lon-1) / span) << endl;
-	    lon = (int)( (int)((lon + 1) / span) * span - span);
-	    if ( lon < -180 ) {
-		lon = -180;
-	    }
+	    return lon + x * span + get_width() / 2.0;
 	}
-	x = 0;
     }
 
-    //
-    // then latitude
-    //
-    diff = dlat - (double)(int)dlat;
-
-    if ( (dlat >= 0) || (fabs(diff) < FG_EPSILON) ) {
-	lat = (int)dlat;
-    } else {
-	lat = (int)dlat - 1;
+    /**
+     * @return the center lat of a tile.
+     */
+    inline double get_center_lat() const {
+	return lat + y / 8.0 + SG_HALF_BUCKET_SPAN;
     }
-    y = (int)((dlat - lat) * 8);
-}
 
+    /**
+     * @return the highest (furthest from the equator) latitude of this
+     * tile. This is the top edge for tiles north of the equator, and
+     * the bottom edge for tiles south
+     */
+    double get_highest_lat() const;
+    
+    /**
+     * @return the width of the tile in degrees.
+     */
+    double get_width() const;
 
-// default constructor
-inline FGBucket::FGBucket() {}
+    /**
+     * @return the height of the tile in degrees.
+     */
+    double get_height() const;
 
+    /**
+     * @return the width of the tile in meters.
+     */
+    double get_width_m() const; 
 
-// constructor for specified location
-inline FGBucket::FGBucket(const double dlon, const double dlat) {
-    set_bucket(dlon, dlat);
-}
+    /**
+     * @return the height of the tile in meters.
+     */
+    double get_height_m() const;
 
+    /**
+     * @return the center of the bucket in geodetic coordinates.
+     */
+    SGGeod get_center() const
+    { return SGGeod::fromDeg(get_center_lon(), get_center_lat()); }
 
-// create an impossible bucket if false
-inline FGBucket::FGBucket(const bool is_good) {
-    set_bucket(0.0, 0.0);
-    if ( !is_good ) {
-	lon = -1000;
+    /**
+     * @return the center of the bucket in geodetic coordinates.
+     */
+    SGGeod get_corner(unsigned num) const
+    {
+        double lonFac = ((num + 1) & 2) ? 0.5 : -0.5;
+        double latFac = ((num    ) & 2) ? 0.5 : -0.5;
+        return SGGeod::fromDeg(get_center_lon() + lonFac*get_width(),
+                               get_center_lat() + latFac*get_height());
     }
-}
+
+    // Informational methods.
+
+    /**
+     * @return the lon of the lower left corner of 
+     * the 1x1 chunk containing this tile.
+     */
+    inline int get_chunk_lon() const { return lon; }
+
+    /**
+     * @return the lat of the lower left corner of 
+     * the 1x1 chunk containing this tile.
+     */
+    inline int get_chunk_lat() const { return lat; }
+
+    /**
+     * @return the x coord within the 1x1 degree chunk this tile.
+     */
+    inline int get_x() const { return x; }
+
+    /**
+     * @return the y coord within the 1x1 degree chunk this tile.
+     */
+    inline int get_y() const { return y; }
+
+    /**
+     * @return bucket offset from this by dx,dy
+     */
+    SGBucket sibling(int dx, int dy) const;
     
+    // friends
 
-// Parse a unique scenery tile index and find the lon, lat, x, and y
-inline FGBucket::FGBucket(const long int bindex) {
-    long int index = bindex;
+    friend std::ostream& operator<< ( std::ostream&, const SGBucket& );
+    friend bool operator== ( const SGBucket&, const SGBucket& );
+};
 
-    lon = index >> 14;
-    index -= lon << 14;
-    lon -= 180;
-    
-    lat = index >> 6;
-    index -= lat << 6;
-    lat -= 90;
-    
-    y = index >> 3;
-    index -= y << 3;
-
-    x = index;
-}
-
-
-// default destructor
-inline FGBucket::~FGBucket() {}
-
-
-// Generate the unique scenery tile index for this bucket
-// 
-// The index is constructed as follows:
-// 
-// 9 bits - to represent 360 degrees of longitude (-180 to 179)
-// 8 bits - to represent 180 degrees of latitude (-90 to 89)
-//
-// Each 1 degree by 1 degree tile is further broken down into an 8x8
-// grid.  So we also need:
-//
-// 3 bits - to represent x (0 to 7)
-// 3 bits - to represent y (0 to 7)
-
-inline long int FGBucket::gen_index() {
-    return ((lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x;
-}
-
-inline string FGBucket::gen_index_str() const {
-    char tmp[20];
-    sprintf(tmp, "%ld", 
-	    (((long)lon + 180) << 14) + ((lat + 90) << 6) + (y << 3) + x);
-    return (string)tmp;
-}
-
-
-// return the center lon of a tile
-inline double FGBucket::get_center_lon() const {
-    double span = bucket_span( lat + y / 8.0 + FG_HALF_BUCKET_SPAN );
-
-    if ( span >= 1.0 ) {
-	return lon + span / 2.0;
-    } else {
-	return lon + x * span + span / 2.0;
+inline bool operator!= (const SGBucket& lhs, const SGBucket& rhs)
+    {
+        return !(lhs == rhs);
     }
-}
+
+#ifndef NO_DEPRECATED_API
+/**
+ * \relates SGBucket
+ * Return the bucket which is offset from the specified dlon, dlat by
+ * the specified tile units in the X & Y direction.
+ * @param dlon starting lon in degrees
+ * @param dlat starting lat in degrees
+ * @param x number of bucket units to offset in x (lon) direction
+ * @param y number of bucket units to offset in y (lat) direction
+ * @return offset bucket
+ */
+SGBucket sgBucketOffset( double dlon, double dlat, int x, int y );
+#endif
 
 
-// return the center lat of a tile
-inline double FGBucket::get_center_lat() const {
-    return lat + y / 8.0 + FG_HALF_BUCKET_SPAN;
-}
+/**
+ * \relates SGBucket
+ * Calculate the offset between two buckets (in quantity of buckets).
+ * @param b1 bucket 1
+ * @param b2 bucket 2
+ * @param dx offset distance (lon) in tile units
+ * @param dy offset distance (lat) in tile units
+ */
+void sgBucketDiff( const SGBucket& b1, const SGBucket& b2, int *dx, int *dy );
 
 
-// return width of the tile
-inline double FGBucket::get_width() const {
-    return bucket_span( get_center_lat() );
-}
-
-
-// return height of the tile
-inline double FGBucket::get_height() const {
-    return FG_BUCKET_SPAN;
-}
-
-
-// create an impossible bucket
-inline void FGBucket::make_bad( void ) {
-    set_bucket(0.0, 0.0);
-	lon = -1000;
-}
-    
-
-// offset a bucket struct by the specified tile units in the X & Y
-// direction
-FGBucket fgBucketOffset( double dlon, double dlat, int x, int y );
-
-
-// calculate the offset between two buckets
-void fgBucketDiff( const FGBucket& b1, const FGBucket& b2, int *dx, int *dy );
-
-
-/*
-// Given a lat/lon, fill in the local tile index array
-void fgBucketGenIdxArray(fgBUCKET *p1, fgBUCKET *tiles, int width, int height);
-*/
-
-
-inline ostream&
-operator<< ( ostream& out, const FGBucket& b )
-{
-    return out << b.lon << ":" << b.x << ", " << b.lat << ":" << b.y;
-}
+/**
+ * \relates SGBucket
+ * retrieve a list of buckets in the given bounding box
+ * @param min min lon,lat of bounding box in degrees
+ * @param max max lon,lat of bounding box in degrees
+ * @param list standard vector of buckets within the bounding box
+ */
+void sgGetBuckets( const SGGeod& min, const SGGeod& max, std::vector<SGBucket>& list );
 
+/**
+ * Write the bucket lon, lat, x, and y to the output stream.
+ * @param out output stream
+ * @param b bucket
+ */
+std::ostream& operator<< ( std::ostream& out, const SGBucket& b );
 
+/**
+ * Compare two bucket structures for equality.
+ * @param b1 bucket 1
+ * @param b2 bucket 2
+ * @return comparison result
+ */
 inline bool
-operator== ( const FGBucket& b1, const FGBucket& b2 )
+operator== ( const SGBucket& b1, const SGBucket& b2 )
 {
     return ( b1.lon == b2.lon &&
 	     b1.lat == b2.lat &&

simgear/bucket/test_bucket.cxx

@@ -0,0 +1,283 @@
+/**************************************************************************
+ * test_bucket.cxx -- unit-tests for SGBucket class
+ *
+ * Copyright (C) 2014  James Turner - <zakalawe@mac.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Id$
+ **************************************************************************/
+
+#include <simgear/compiler.h>
+
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+
+using std::cout;
+using std::cerr;
+using std::endl;
+
+#include <simgear/bucket/newbucket.hxx>
+#include <simgear/misc/test_macros.hxx>
+
+void testBucketSpans()
+{
+    COMPARE(sg_bucket_span(0.0), 0.125);
+    COMPARE(sg_bucket_span(-20), 0.125);
+    COMPARE(sg_bucket_span(-40), 0.25);
+    COMPARE(sg_bucket_span(89.9), 12.0);
+    COMPARE(sg_bucket_span(88.1), 4.0);
+    COMPARE(sg_bucket_span(-89.9), 12.0);
+}
+
+void testBasic()
+{
+    SGBucket b1(5.1, 55.05);
+    COMPARE(b1.get_chunk_lon(), 5);
+    COMPARE(b1.get_chunk_lat(), 55);
+    COMPARE(b1.get_x(), 0);
+    COMPARE(b1.get_y(), 0);
+    COMPARE(b1.gen_index(), 3040320);
+    COMPARE(b1.gen_base_path(), "e000n50/e005n55");
+    VERIFY(b1.isValid());
+    
+    SGBucket b2(-10.1, -43.8);
+    COMPARE(b2.get_chunk_lon(), -11);
+    COMPARE(b2.get_chunk_lat(), -44);
+    COMPARE(b2.get_x(), 3);
+    COMPARE(b2.get_y(), 1); // latitude chunks numbered bottom to top, it seems
+    COMPARE(b2.gen_base_path(), "w020s50/w011s44");
+    VERIFY(b2.isValid());
+    
+    SGBucket b3(123.48, 9.01);
+    COMPARE(b3.get_chunk_lon(), 123);
+    COMPARE(b3.get_chunk_lat(), 9);
+    COMPARE(b3.get_x(), 3);
+    COMPARE(b3.get_y(), 0);
+    COMPARE(b3.gen_base_path(), "e120n00/e123n09");
+    VERIFY(b3.isValid());
+    
+    SGBucket defBuck;
+    VERIFY(!defBuck.isValid());
+    
+    b3.make_bad();
+    VERIFY(!b3.isValid());
+
+    SGBucket atAntiMeridian(180.0, 12.3);
+    VERIFY(atAntiMeridian.isValid());
+    COMPARE(atAntiMeridian.get_chunk_lon(), -180);
+    COMPARE(atAntiMeridian.get_x(), 0);
+    
+    SGBucket atAntiMeridian2(-180.0, -78.1);
+    VERIFY(atAntiMeridian2.isValid());
+    COMPARE(atAntiMeridian2.get_chunk_lon(), -180);
+    COMPARE(atAntiMeridian2.get_x(), 0);
+    
+// check comparisom operator overload
+    SGBucket b4(5.11, 55.1);
+    VERIFY(b1 == b4); // should be equal
+    VERIFY(b1 == b1);
+    VERIFY(b1 != defBuck);
+    VERIFY(b1 != b2);
+    
+// check wrapping/clipping of inputs
+    SGBucket wrapMeridian(-200.0, 45.0);
+    COMPARE(wrapMeridian.get_chunk_lon(), 160);
+    
+    SGBucket clipPole(48.9, 91);
+    COMPARE(clipPole.get_chunk_lat(), 89);
+}
+
+void testPolar()
+{
+    SGBucket b1(0.0, 89.92);
+    SGBucket b2(10.0, 89.96);
+    COMPARE(b1.get_chunk_lat(), 89);
+    COMPARE(b1.get_chunk_lon(), 0);
+    COMPARE(b1.get_x(), 0);
+    COMPARE(b1.get_y(), 7);
+    
+    COMPARE_EP(b1.get_highest_lat(), 90.0);
+    COMPARE_EP(b1.get_width_m(), 10.0);
+    
+    COMPARE(b2.get_chunk_lat(), 89);
+    COMPARE(b2.get_chunk_lon(), 0);
+    COMPARE(b2.get_x(), 0);
+    COMPARE(b2.get_y(), 7);
+    
+    COMPARE(b1.gen_index(), b2.gen_index());
+    
+    SGGeod actualNorthPole1 = b1.get_corner(2);
+    SGGeod actualNorthPole2 = b1.get_corner(3);
+    COMPARE_EP(actualNorthPole1.getLatitudeDeg(), 90.0);
+    COMPARE_EP(actualNorthPole1.getLongitudeDeg(), 12.0);
+    COMPARE_EP(actualNorthPole2.getLatitudeDeg(), 90.0);
+    COMPARE_EP(actualNorthPole2.getLongitudeDeg(), 0.0);
+
+    SGBucket b3(-2, 89.88);
+    SGBucket b4(-7, 89.88);
+    COMPARE(b3.gen_index(), b4.gen_index());
+    
+    // south pole
+    SGBucket b5(-170, -89.88);
+    SGBucket b6(-179, -89.88);
+    
+    COMPARE(b5.get_chunk_lat(), -90);
+    COMPARE(b5.get_chunk_lon(), -180);
+    COMPARE(b5.get_x(), 0);
+    COMPARE(b5.get_y(), 0);
+    COMPARE(b5.gen_index(), b6.gen_index());
+    COMPARE_EP(b5.get_highest_lat(), -90.0);
+    COMPARE_EP(b5.get_width_m(), 10.0);
+    
+    SGGeod actualSouthPole1 = b5.get_corner(0);
+    SGGeod actualSouthPole2 = b5.get_corner(1);
+    COMPARE_EP(actualSouthPole1.getLatitudeDeg(), -90.0);
+    COMPARE_EP(actualSouthPole1.getLongitudeDeg(), -180);
+    COMPARE_EP(actualSouthPole2.getLatitudeDeg(), -90.0);
+    COMPARE_EP(actualSouthPole2.getLongitudeDeg(), -168);
+    
+    SGBucket b7(200, 89.88);
+    COMPARE(b7.get_chunk_lon(), -168);
+
+}
+
+// test the tiles just below the pole (between 86 & 89 degrees N/S)
+void testNearPolar()
+{
+    SGBucket b1(1, 88.5);
+    SGBucket b2(-1, 88.8);
+    COMPARE(b1.get_chunk_lon(), 0);
+    COMPARE(b1.get_chunk_lat(), 88);
+    VERIFY(b1.gen_index() != b2.gen_index());
+
+    SGBucket b3(176.1, 88.5);
+    COMPARE(b3.get_chunk_lon(), 176);
+    
+    SGBucket b4(-178, 88.5);
+    COMPARE(b4.get_chunk_lon(), -180);
+}
+
+void testOffset()
+{
+    // bucket just below the 22 degree cutoff, so the next tile north
+    // is twice the width
+    SGBucket b1(-59.8, 21.9);
+    COMPARE(b1.get_chunk_lat(), 21);
+    COMPARE(b1.get_chunk_lon(), -60);
+    COMPARE(b1.get_x(), 1);
+    COMPARE(b1.get_y(), 7);
+    
+    // offset vertically
+    SGBucket b2(b1.sibling(0, 1));
+    COMPARE(b2.get_chunk_lat(), 22);
+    COMPARE(b2.get_chunk_lon(), -60);
+    COMPARE(b2.get_x(), 0);
+    COMPARE(b2.get_y(), 0);
+
+    COMPARE(b2.gen_index(), sgBucketOffset(-59.8, 21.9, 0, 1));
+    
+    // offset vertically and horizontally. We compute horizontal (x)
+    // movement at the target latitude, so this should move 0.25 * -3 degrees,
+    // NOT 0.125 * -3 degrees.
+    SGBucket b3(b1.sibling(-3, 1));
+    COMPARE(b3.get_chunk_lat(), 22);
+    COMPARE(b3.get_chunk_lon(), -61);
+    COMPARE(b3.get_x(), 1);
+    COMPARE(b3.get_y(), 0);
+    
+    COMPARE(b3.gen_index(), sgBucketOffset(-59.8, 21.9, -3, 1));
+}
+
+void testPolarOffset()
+{
+    SGBucket b1(-11.7, -89.6);
+    COMPARE(b1.get_chunk_lat(), -90);
+    COMPARE(b1.get_chunk_lon(), -12);
+    COMPARE(b1.get_x(), 0);
+    COMPARE(b1.get_y(), 3);
+    
+    // offset horizontally
+    SGBucket b2(b1.sibling(-2, 0));
+    COMPARE(b2.get_chunk_lat(), -90);
+    COMPARE(b2.get_chunk_lon(), -36);
+    COMPARE(b2.get_x(), 0);
+    COMPARE(b2.get_y(), 3);
+    
+    COMPARE(b2.gen_index(), sgBucketOffset(-11.7, -89.6, -2, 0));
+    
+// offset and wrap
+    SGBucket b3(-170, 89.1);
+    SGBucket b4(b3.sibling(-1, 0));
+    COMPARE(b4.get_chunk_lat(), 89);
+    COMPARE(b4.get_chunk_lon(), 168);
+    COMPARE(b4.get_x(), 0);
+    COMPARE(b4.get_y(), 0);
+    
+    COMPARE(b4.gen_index(), sgBucketOffset(-170, 89.1, -1, 0));
+
+    
+    SGBucket b5(177, 87.3);
+    SGBucket b6(b5.sibling(1, 1));
+    COMPARE(b6.get_chunk_lat(), 87);
+    COMPARE(b6.get_chunk_lon(), -180);
+    COMPARE(b6.get_x(), 0);
+    COMPARE(b6.get_y(), 3);
+    
+    COMPARE(b6.gen_index(), sgBucketOffset(177, 87.3, 1, 1));
+
+    // offset vertically towards the pole
+    SGBucket b7(b1.sibling(0, -5));
+    VERIFY(!b7.isValid());
+    
+    VERIFY(!SGBucket(0, 90).sibling(0, 1).isValid());
+}
+
+// test behaviour of bucket-offset near the anti-meridian (180-meridian)
+void testOffsetWrap()
+{
+    // near the equator
+    SGBucket b1(-179.8, 16.8);
+    COMPARE(b1.get_chunk_lat(), 16);
+    COMPARE(b1.get_chunk_lon(), -180);
+    COMPARE(b1.get_x(), 1);
+    COMPARE(b1.get_y(), 6);
+    
+    SGBucket b2(b1.sibling(-2, 0));
+    COMPARE(b2.get_chunk_lat(), 16);
+    COMPARE(b2.get_chunk_lon(), 179);
+    COMPARE(b2.get_x(), 7);
+    COMPARE(b2.get_y(), 6);
+    COMPARE(b2.gen_index(), sgBucketOffset(-179.8, 16.8, -2, 0));
+    
+    
+}
+
+int main(int argc, char* argv[])
+{
+    testBucketSpans();
+    
+    testBasic();
+    testPolar();
+    testNearPolar();
+    testOffset();
+    testOffsetWrap();
+    testPolarOffset();
+    
+    cout << "all tests passed OK" << endl;
+    return 0; // passed
+}
+

simgear/bvh/.gitignore

@@ -0,0 +1,2 @@
+bvhtest
+

simgear/bvh/BVHBoundingBoxVisitor.hxx

@@ -0,0 +1,83 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHBoundingBoxVisitor_hxx
+#define BVHBoundingBoxVisitor_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+#include "BVHPageNode.hxx"
+#include "BVHTransform.hxx"
+#include "BVHMotionTransform.hxx"
+#include "BVHLineGeometry.hxx"
+
+#include "BVHStaticData.hxx"
+
+#include "BVHStaticNode.hxx"
+#include "BVHStaticTriangle.hxx"
+#include "BVHStaticBinary.hxx"
+#include "BVHStaticGeometry.hxx"
+
+namespace simgear {
+
+class BVHBoundingBoxVisitor : public BVHVisitor {
+public:
+    virtual ~BVHBoundingBoxVisitor() {}
+    
+    void clear()
+    { _box.clear(); }
+    
+    virtual void apply(BVHGroup& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHPageNode& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHTransform& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHMotionTransform& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHLineGeometry& node)
+    { expandBy(node.getBoundingSphere()); }
+    virtual void apply(BVHStaticGeometry& node)
+    { expandBy(node.getBoundingSphere()); }
+    
+    virtual void apply(const BVHStaticBinary& node, const BVHStaticData& data)
+    { expandBy(node.getBoundingBox()); }
+    virtual void apply(const BVHStaticTriangle& node, const BVHStaticData& data)
+    { expandBy(node.computeBoundingBox(data)); }
+    
+    const SGBoxf& getBox() const
+    { return _box; }
+    
+private:
+    void expandBy(const SGSphered& sphere)
+    {
+        SGVec3f v0(sphere.getCenter() - sphere.getRadius()*SGVec3d(1, 1, 1));
+        SGVec3f v1(sphere.getCenter() + sphere.getRadius()*SGVec3d(1, 1, 1));
+        _box.expandBy(SGBoxf(v0, v1));
+    }
+    void expandBy(const SGBoxf& box)
+    { _box.expandBy(box); }
+    
+    SGBoxf _box;
+};
+
+}
+
+#endif

simgear/bvh/BVHGroup.cxx

@@ -0,0 +1,92 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include "BVHGroup.hxx"
+
+#include <algorithm>
+
+namespace simgear {
+
+BVHGroup::BVHGroup()
+{
+}
+
+BVHGroup::~BVHGroup()
+{
+    ChildList::iterator i;
+    for (i = _children.begin(); i != _children.end(); ++i) {
+        (*i)->removeParent(this);
+        *i = 0;
+    }
+}
+
+void
+BVHGroup::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+BVHGroup::clear()
+{
+    _children.clear();
+    invalidateBound();
+}
+
+void
+BVHGroup::addChild(BVHNode* child)
+{
+    if (!child)
+        return;
+    ChildList::iterator i;
+    i = std::find(_children.begin(), _children.end(), child);
+    if (i != _children.end())
+        return;
+    invalidateBound();
+    child->addParent(this);
+    _children.push_back(child);
+}
+
+void
+BVHGroup::removeChild(BVHNode* child)
+{
+    if (!child)
+        return;
+    ChildList::iterator i;
+    i = std::find(_children.begin(), _children.end(), child);
+    if (i == _children.end())
+        return;
+    invalidateBound();
+    child->removeParent(this);
+    _children.erase(i);
+}
+
+SGSphered
+BVHGroup::computeBoundingSphere() const
+{
+    SGSphered sphere;
+    ChildList::const_iterator i;
+    for (i = _children.begin(); i != _children.end(); ++i)
+        sphere.expandBy((*i)->getBoundingSphere());
+    return sphere;
+}
+
+}

simgear/bvh/BVHGroup.hxx

@@ -0,0 +1,61 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHGroup_hxx
+#define BVHGroup_hxx
+
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "BVHNode.hxx"
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+class BVHGroup : public BVHNode {
+public:
+    BVHGroup();
+    virtual ~BVHGroup();
+    
+    virtual void accept(BVHVisitor& visitor);
+    
+    void traverse(BVHVisitor& visitor)
+    {
+        ChildList::const_iterator i;
+        for (i = _children.begin(); i != _children.end(); ++i)
+            (*i)->accept(visitor);
+    }
+    
+    void clear();
+    void addChild(BVHNode* child);
+    void removeChild(BVHNode* child);
+    
+    unsigned getNumChildren() const
+    { return _children.size(); }
+    const BVHNode* getChild(unsigned i) const
+    { if (_children.size() <= i) return 0; return _children[i]; }
+    BVHNode* getChild(unsigned i)
+    { if (_children.size() <= i) return 0; return _children[i]; }
+    
+    virtual SGSphered computeBoundingSphere() const;
+    
+private:
+    typedef std::vector<SGSharedPtr<BVHNode> > ChildList;
+    ChildList _children;
+};
+
+}
+
+#endif

simgear/bvh/BVHLineGeometry.cxx

@@ -0,0 +1,49 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHLineGeometry.hxx"
+
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+BVHLineGeometry::BVHLineGeometry(const SGLineSegmentf& lineSegment, Type type) :
+    _lineSegment(lineSegment),
+    _type(type)
+{
+}
+
+BVHLineGeometry::~BVHLineGeometry()
+{
+}
+
+void
+BVHLineGeometry::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+SGSphered
+BVHLineGeometry::computeBoundingSphere() const
+{
+    SGSphered sphere;
+    sphere.expandBy(SGVec3d(_lineSegment.getStart()));
+    sphere.expandBy(SGVec3d(_lineSegment.getEnd()));
+    return sphere;
+}
+
+}

simgear/bvh/BVHLineGeometry.hxx

@@ -0,0 +1,53 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHLineGeometry_hxx
+#define BVHLineGeometry_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+#include "BVHNode.hxx"
+
+namespace simgear {
+
+class BVHLineGeometry : public BVHNode {
+public:
+    enum Type {
+        CarrierCatapult,
+        CarrierWire
+    };
+
+    BVHLineGeometry(const SGLineSegmentf& lineSegment, Type type);
+    virtual ~BVHLineGeometry();
+
+    virtual void accept(BVHVisitor& visitor);
+
+    const SGLineSegmentf& getLineSegment() const
+    { return _lineSegment; }
+
+    Type getType() const
+    { return _type; }
+
+    virtual SGSphered computeBoundingSphere() const;
+
+private:
+    SGLineSegmentf _lineSegment;
+    Type _type;
+};
+
+}
+
+#endif

simgear/bvh/BVHLineSegmentVisitor.cxx

@@ -0,0 +1,166 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include "BVHLineSegmentVisitor.hxx"
+
+#include <simgear/math/SGGeometry.hxx>
+
+#include "BVHVisitor.hxx"
+
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+#include "BVHPageNode.hxx"
+#include "BVHTransform.hxx"
+#include "BVHMotionTransform.hxx"
+#include "BVHLineGeometry.hxx"
+#include "BVHStaticGeometry.hxx"
+
+#include "BVHStaticData.hxx"
+
+#include "BVHStaticNode.hxx"
+#include "BVHStaticTriangle.hxx"
+#include "BVHStaticBinary.hxx"
+
+namespace simgear {
+
+void
+BVHLineSegmentVisitor::apply(BVHGroup& group)
+{
+    if (!intersects(_lineSegment, group.getBoundingSphere()))
+        return;
+    group.traverse(*this);
+}
+
+void
+BVHLineSegmentVisitor::apply(BVHPageNode& pageNode)
+{
+    if (!intersects(_lineSegment, pageNode.getBoundingSphere()))
+        return;
+    pageNode.traverse(*this);
+}
+    
+void
+BVHLineSegmentVisitor::apply(BVHTransform& transform)
+{
+    if (!intersects(_lineSegment, transform.getBoundingSphere()))
+        return;
+    
+    bool haveHit = _haveHit;
+    _haveHit = false;
+    
+    // Push the line segment
+    SGLineSegmentd lineSegment = getLineSegment();
+    _lineSegment = transform.lineSegmentToLocal(lineSegment);
+    
+    transform.traverse(*this);
+    
+    if (_haveHit) {
+        _linearVelocity = transform.vecToWorld(_linearVelocity);
+        _angularVelocity = transform.vecToWorld(_angularVelocity);
+        SGVec3d point(transform.ptToWorld(_lineSegment.getEnd()));
+        _lineSegment.set(lineSegment.getStart(), point);
+        _normal = transform.vecToWorld(_normal);
+    } else {
+        _lineSegment = lineSegment;
+        _haveHit = haveHit;
+    }
+}
+
+void
+BVHLineSegmentVisitor::apply(BVHMotionTransform& transform)
+{
+    if (!intersects(_lineSegment, transform.getBoundingSphere()))
+        return;
+    
+    bool haveHit = _haveHit;
+    _haveHit = false;
+
+    // Push the line segment
+    SGLineSegmentd lineSegment = getLineSegment();
+    SGMatrixd toLocal = transform.getToLocalTransform(_time);
+    _lineSegment = lineSegment.transform(toLocal);
+    
+    transform.traverse(*this);
+    
+    if (_haveHit) {
+        SGMatrixd toWorld = transform.getToWorldTransform(_time);
+        SGVec3d localStart = _lineSegment.getStart();
+        _linearVelocity += transform.getLinearVelocityAt(localStart);
+        _angularVelocity += transform.getAngularVelocity();
+        _linearVelocity = toWorld.xformVec(_linearVelocity);
+        _angularVelocity = toWorld.xformVec(_angularVelocity);
+        SGVec3d localEnd = _lineSegment.getEnd();
+        _lineSegment.set(lineSegment.getStart(), toWorld.xformPt(localEnd));
+        _normal = toWorld.xformVec(_normal);
+        if (!_id)
+            _id = transform.getId();
+    } else {
+        _lineSegment = lineSegment;
+        _haveHit = haveHit;
+    }
+}
+
+void
+BVHLineSegmentVisitor::apply(BVHLineGeometry&)
+{
+}
+    
+void
+BVHLineSegmentVisitor::apply(BVHStaticGeometry& node)
+{
+    if (!intersects(_lineSegment, node.getBoundingSphere()))
+        return;
+    node.traverse(*this);
+}
+
+void
+BVHLineSegmentVisitor::apply(const BVHStaticBinary& node,
+                             const BVHStaticData& data)
+{
+    if (!intersects(SGLineSegmentf(_lineSegment), node.getBoundingBox()))
+        return;
+    
+    // The first box to enter is the one the startpoint is in.
+    // this increases the probability, that on exit of that box we do not
+    // even need to walk the other one, since the line segment is
+    // then already short enough to not intersect the other one anymore.
+    node.traverse(*this, data, _lineSegment.getStart());
+}
+
+void
+BVHLineSegmentVisitor::apply(const BVHStaticTriangle& triangle,
+                             const BVHStaticData& data)
+{
+    SGTrianglef tri = triangle.getTriangle(data);
+    SGVec3f point;
+    if (!intersects(point, tri, SGLineSegmentf(_lineSegment), 1e-4f))
+        return;
+    setLineSegmentEnd(SGVec3d(point));
+    _normal = SGVec3d(tri.getNormal());
+    _linearVelocity = SGVec3d::zeros();
+    _angularVelocity = SGVec3d::zeros();
+    _material = data.getMaterial(triangle.getMaterialIndex());
+    _id = 0;
+    _haveHit = true;
+}
+
+
+}

simgear/bvh/BVHLineSegmentVisitor.hxx

@@ -0,0 +1,100 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHLineSegmentVisitor_hxx
+#define BVHLineSegmentVisitor_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+
+namespace simgear {
+
+class BVHMaterial;
+
+class BVHLineSegmentVisitor : public BVHVisitor {
+public:
+    BVHLineSegmentVisitor(const SGLineSegmentd& lineSegment,
+                          const double& t = 0) :
+        _lineSegment(lineSegment),
+        _time(t),
+        _material(0),
+        _id(0),
+        _haveHit(false)
+    { }
+    virtual ~BVHLineSegmentVisitor()
+    { }
+    
+    bool empty() const
+    { return !_haveHit; }
+    
+    const SGLineSegmentd& getLineSegment() const
+    { return _lineSegment; }
+    
+    SGVec3d getPoint() const
+    { return _lineSegment.getEnd(); }
+    const SGVec3d& getNormal() const
+    { return _normal; }
+    const SGVec3d& getLinearVelocity() const
+    { return _linearVelocity; }
+    const SGVec3d& getAngularVelocity() const
+    { return _angularVelocity; }
+    const BVHMaterial* getMaterial() const
+    { return _material; }
+    BVHNode::Id getId() const
+    { return _id; }
+
+    virtual void apply(BVHGroup& group);
+    virtual void apply(BVHPageNode& node);
+    virtual void apply(BVHTransform& transform);
+    virtual void apply(BVHMotionTransform& transform);
+    virtual void apply(BVHLineGeometry&);
+    virtual void apply(BVHStaticGeometry& node);
+    
+    virtual void apply(const BVHStaticBinary&, const BVHStaticData&);
+    virtual void apply(const BVHStaticTriangle&, const BVHStaticData&);
+    
+protected:
+    void setLineSegmentEnd(const SGVec3d& end)
+    {
+        // Ok, you need to make sure that the new end is in the previous
+        // direction and that the line segment is not enlarged by that call.
+#ifndef _NDEBUG
+        // FIXME insert code to check this...
+#endif
+        _lineSegment.set(_lineSegment.getStart(), end);
+    }
+    
+private:
+    SGLineSegmentd _lineSegment;
+    double _time;
+    
+    // belongs in a derived class
+    SGVec3d _normal;
+    SGVec3d _linearVelocity;
+    SGVec3d _angularVelocity;
+    const BVHMaterial* _material;
+    BVHNode::Id _id;
+    
+    bool _haveHit;
+};
+
+}
+
+#endif

simgear/bvh/BVHMaterial.cxx

@@ -0,0 +1,35 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHMaterial.hxx"
+
+namespace simgear {
+
+BVHMaterial::BVHMaterial() :
+    _solid(true),
+    _friction_factor(1),
+    _rolling_friction(0.02),
+    _bumpiness(0),
+    _load_resistance(1e30)
+{
+}
+
+BVHMaterial::~BVHMaterial()
+{
+}
+
+}

simgear/bvh/BVHMaterial.hxx

@@ -0,0 +1,75 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHMaterial_hxx
+#define BVHMaterial_hxx
+
+#include <simgear/structure/SGReferenced.hxx>
+
+namespace simgear {
+
+class BVHMaterial : public SGReferenced {
+public:
+    BVHMaterial();
+    virtual ~BVHMaterial();
+
+    /**
+     * Return if the surface material is solid, if it is not solid, a fluid
+     * can be assumed, that is usually water.
+     */
+    bool get_solid () const { return _solid; }
+    
+    /**
+     * Get the friction factor for that material
+     */
+    double get_friction_factor () const { return _friction_factor; }
+    
+    /**
+     * Get the rolling friction for that material
+     */
+    double get_rolling_friction () const { return _rolling_friction; }
+    
+    /**
+     * Get the bumpines for that material
+     */
+    double get_bumpiness () const { return _bumpiness; }
+    
+    /**
+     * Get the load resistance
+     */
+    double get_load_resistance () const { return _load_resistance; }
+
+protected:    
+    // True if the material is solid, false if it is a fluid
+    bool _solid;
+    
+    // the friction factor of that surface material
+    double _friction_factor;
+    
+    // the rolling friction of that surface material
+    double _rolling_friction;
+    
+    // the bumpiness of that surface material
+    double _bumpiness;
+    
+    // the load resistance of that surface material
+    double _load_resistance;
+};
+
+}
+
+#endif

simgear/bvh/BVHMotionTransform.cxx

@@ -0,0 +1,120 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear_config.h>
+#endif
+
+#include "BVHMotionTransform.hxx"
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+
+namespace simgear {
+
+BVHMotionTransform::BVHMotionTransform() :
+    _toWorldReference(SGMatrixd::unit()),
+    _toLocalReference(SGMatrixd::unit()),
+    _toWorldAmplification(1),
+    _toLocalAmplification(1),
+    _linearVelocity(0, 0, 0),
+    _angularVelocity(0, 0, 0),
+    _referenceTime(0),
+    _startTime(0),
+    _endTime(0),
+    _id(0)
+{
+}
+
+BVHMotionTransform::~BVHMotionTransform()
+{
+}
+
+void
+BVHMotionTransform::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+void
+BVHMotionTransform::setTransform(const BVHMotionTransform& transform)
+{
+    _toWorldReference = transform._toWorldReference;
+    _toLocalReference = transform._toLocalReference;
+    _toWorldAmplification = transform._toWorldAmplification;
+    _toLocalAmplification = transform._toLocalAmplification;
+    _linearVelocity = transform._linearVelocity;
+    _angularVelocity = transform._angularVelocity;
+    _referenceTime = transform._referenceTime;
+    _startTime = transform._startTime;
+    _endTime = transform._endTime;
+    _id = transform._id;
+    invalidateParentBound();
+}
+
+void
+BVHMotionTransform::setToWorldTransform(const SGMatrixd& transform)
+{
+    _toWorldReference = transform;
+    invert(_toLocalReference, transform);
+    updateAmplificationFactors();
+    invalidateParentBound();
+}
+
+void
+BVHMotionTransform::setToLocalTransform(const SGMatrixd& transform)
+{
+    _toLocalReference = transform;
+    invert(_toWorldReference, transform);
+    updateAmplificationFactors();
+    invalidateParentBound();
+}
+
+SGSphered
+BVHMotionTransform::computeBoundingSphere() const
+{
+    SGSphered sphere(BVHGroup::computeBoundingSphere());
+    if (sphere.empty())
+        return sphere;
+    SGMatrixd toWorldStart = getToWorldTransform(_startTime);
+    SGVec3d centerStart = toWorldStart.xformPt(sphere.getCenter());
+    SGMatrixd toWorldEnd = getToWorldTransform(_endTime);
+    SGVec3d centerEnd = toWorldEnd.xformPt(sphere.getCenter());
+    double rad = 0.5*length(centerStart - centerEnd) + sphere.getRadius();
+    rad *= _toWorldAmplification;
+    return SGSphered(0.5*(centerStart + centerEnd), rad);
+}
+
+void
+BVHMotionTransform::updateAmplificationFactors()
+{
+    // Hmm, this is just a hint, true?
+    // But anyway, almost all transforms in a scenegraph will
+    // have them equal to 1 ...
+    double r = norm(_toWorldReference.xformVec(SGVec3d(1, 0, 0)));
+	r = SGMiscd::max(r, norm(_toWorldReference.xformVec(SGVec3d(0, 1, 0))));
+    r = SGMiscd::max(r, norm(_toWorldReference.xformVec(SGVec3d(0, 0, 1))));
+    _toWorldAmplification = r;
+    
+    r = norm(_toLocalReference.xformVec(SGVec3d(1, 0, 0)));
+    r = SGMiscd::max(r, norm(_toLocalReference.xformVec(SGVec3d(0, 1, 0))));
+    r = SGMiscd::max(r, norm(_toLocalReference.xformVec(SGVec3d(0, 0, 1))));
+    _toLocalAmplification = r;
+}
+
+}

simgear/bvh/BVHMotionTransform.hxx

@@ -0,0 +1,126 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHMotionTransform_hxx
+#define BVHMotionTransform_hxx
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+
+namespace simgear {
+
+class BVHMotionTransform : public BVHGroup {
+public:
+    BVHMotionTransform();
+    virtual ~BVHMotionTransform();
+
+    virtual void accept(BVHVisitor& visitor);
+
+    void setTransform(const BVHMotionTransform& transform);
+    void setToWorldTransform(const SGMatrixd& transform);
+    void setToLocalTransform(const SGMatrixd& transform);
+
+    void setLinearVelocity(const SGVec3d& linearVelocity)
+    { _linearVelocity = linearVelocity; }
+    const SGVec3d& getLinearVelocity() const
+    { return _linearVelocity; }
+
+    void setAngularVelocity(const SGVec3d& angularVelocity)
+    { _angularVelocity = angularVelocity; }
+    const SGVec3d& getAngularVelocity() const
+    { return _angularVelocity; }
+
+    void setReferenceTime(const double& referenceTime)
+    { _referenceTime = referenceTime; }
+    const double& getReferenceTime() const
+    { return _referenceTime; }
+
+    void setStartTime(const double& startTime)
+    { _startTime = startTime; }
+    const double& getStartTime() const
+    { return _startTime; }
+
+    void setEndTime(const double& endTime)
+    { _endTime = endTime; }
+    const double& getEndTime() const
+    { return _endTime; }
+    
+    SGMatrixd getToWorldTransform(const double& t) const
+    {
+        if (t == _referenceTime)
+            return _toWorldReference;
+        double dt = t - _referenceTime;
+        SGMatrixd matrix(_toWorldReference);
+        matrix.postMultRotate(SGQuatd::fromAngleAxis(dt*_angularVelocity));
+        matrix.postMultTranslate(dt*_linearVelocity);
+        return matrix;
+    }
+    SGMatrixd getToLocalTransform(const double& t) const
+    {
+        if (t == _referenceTime)
+            return _toLocalReference;
+        double dt = _referenceTime - t;
+        SGMatrixd matrix(_toLocalReference);
+        matrix.preMultRotate(SGQuatd::fromAngleAxis(dt*_angularVelocity));
+        matrix.preMultTranslate(dt*_linearVelocity);
+        return matrix;
+    }
+
+    const SGMatrixd& getToWorldReferenceTransform() const
+    { return _toWorldReference; }
+    const SGMatrixd& getToLocalReferenceTransform() const
+    { return _toLocalReference; }
+
+    SGVec3d getLinearVelocityAt(const SGVec3d& reference) const
+    { return _linearVelocity + cross(_angularVelocity, reference); }
+
+    SGSphered sphereToLocal(const SGSphered& sphere, const double& t) const
+    {
+        SGMatrixd matrix = getToLocalTransform(t);
+        SGVec3d center = matrix.xformPt(sphere.getCenter());
+        double radius = _toLocalAmplification*sphere.getRadius();
+        return SGSphered(center, radius);
+    }
+
+    void setId(Id id)
+    { _id = id; }
+    Id getId() const
+    { return _id; }
+
+private:
+    virtual SGSphered computeBoundingSphere() const;
+    void updateAmplificationFactors();
+    
+    SGMatrixd _toWorldReference;
+    SGMatrixd _toLocalReference;
+    double _toWorldAmplification;
+    double _toLocalAmplification;
+
+    SGVec3d _linearVelocity;
+    SGVec3d _angularVelocity;
+
+    double _referenceTime;
+    double _startTime;
+    double _endTime;
+
+    Id _id;
+};
+
+}
+
+#endif

simgear/bvh/BVHNearestPointVisitor.hxx

@@ -0,0 +1,173 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHNearestPointVisitor_hxx
+#define BVHNearestPointVisitor_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+
+#include "BVHVisitor.hxx"
+
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+#include "BVHPageNode.hxx"
+#include "BVHTransform.hxx"
+#include "BVHLineGeometry.hxx"
+#include "BVHStaticGeometry.hxx"
+
+#include "BVHStaticData.hxx"
+
+#include "BVHStaticNode.hxx"
+#include "BVHStaticTriangle.hxx"
+#include "BVHStaticBinary.hxx"
+
+namespace simgear {
+
+class BVHNearestPointVisitor : public BVHVisitor {
+public:
+    BVHNearestPointVisitor(const SGSphered& sphere, const double& t) :
+        _sphere(sphere),
+        _time(t),
+        _material(0),
+        _id(0),
+        _havePoint(false)
+    { }
+    
+    virtual void apply(BVHGroup& leaf)
+    {
+        if (!intersects(_sphere, leaf.getBoundingSphere()))
+            return;
+        leaf.traverse(*this);
+    }
+    virtual void apply(BVHPageNode& leaf)
+    {
+        if (!intersects(_sphere, leaf.getBoundingSphere()))
+            return;
+        leaf.traverse(*this);
+    }
+    virtual void apply(BVHTransform& transform)
+    {
+        if (!intersects(_sphere, transform.getBoundingSphere()))
+            return;
+        
+        SGSphered sphere = _sphere;
+        _sphere = transform.sphereToLocal(sphere);
+        bool havePoint = _havePoint;
+        _havePoint = false;
+        
+        transform.traverse(*this);
+        
+        if (_havePoint) {
+            _point = transform.ptToWorld(_point);
+            _linearVelocity = transform.vecToWorld(_linearVelocity);
+            _angularVelocity = transform.vecToWorld(_angularVelocity);
+        }
+        _havePoint |= havePoint;
+        _sphere.setCenter(sphere.getCenter());
+    }
+    virtual void apply(BVHMotionTransform& transform)
+    {
+        if (!intersects(_sphere, transform.getBoundingSphere()))
+            return;
+        
+        SGSphered sphere = _sphere;
+        _sphere = transform.sphereToLocal(sphere, _time);
+        bool havePoint = _havePoint;
+        _havePoint = false;
+        
+        transform.traverse(*this);
+        
+        if (_havePoint) {
+            SGMatrixd toWorld = transform.getToWorldTransform(_time);
+            SGVec3d localCenter = _sphere.getCenter();
+            _linearVelocity += transform.getLinearVelocityAt(localCenter);
+            _angularVelocity += transform.getAngularVelocity();
+            _linearVelocity = toWorld.xformVec(_linearVelocity);
+            _angularVelocity = toWorld.xformVec(_angularVelocity);
+            _point = toWorld.xformPt(_point);
+            if (!_id)
+                _id = transform.getId();
+        }
+        _havePoint |= havePoint;
+        _sphere.setCenter(sphere.getCenter());
+    }
+    virtual void apply(BVHLineGeometry& node)
+    { }
+    virtual void apply(BVHStaticGeometry& node)
+    {
+        if (!intersects(_sphere, node.getBoundingSphere()))
+            return;
+        node.traverse(*this);
+    }
+    
+    virtual void apply(const BVHStaticBinary& node, const BVHStaticData& data)
+    {
+        if (!intersects(_sphere, node.getBoundingBox()))
+            return;
+        node.traverse(*this, data, _sphere.getCenter());
+    }
+    virtual void apply(const BVHStaticTriangle& node, const BVHStaticData& data)
+    {
+        SGVec3f center(_sphere.getCenter());
+        SGVec3d closest(closestPoint(node.getTriangle(data), center));
+        if (!intersects(_sphere, closest))
+            return;
+        _point = closest;
+        _linearVelocity = SGVec3d::zeros();
+        _angularVelocity = SGVec3d::zeros();
+        _material = data.getMaterial(node.getMaterialIndex());
+        // The trick is to decrease the radius of the search sphere.
+        _sphere.setRadius(length(closest - _sphere.getCenter()));
+        _havePoint = true;
+        _id = 0;
+    }
+    
+    void setSphere(const SGSphered& sphere)
+    { _sphere = sphere; }
+    const SGSphered& getSphere() const
+    { return _sphere; }
+    
+    const SGVec3d& getPoint() const
+    { return _point; }
+    const SGVec3d& getLinearVelocity() const
+    { return _linearVelocity; }
+    const SGVec3d& getAngularVelocity() const
+    { return _angularVelocity; }
+    const BVHMaterial* getMaterial() const
+    { return _material; }
+    BVHNode::Id getId() const
+    { return _id; }
+    
+    bool empty() const
+    { return !_havePoint; }
+    
+private:
+    SGSphered _sphere;
+    double _time;
+
+    SGVec3d _point;
+    SGVec3d _linearVelocity;
+    SGVec3d _angularVelocity;
+    const BVHMaterial* _material;
+    BVHNode::Id _id;
+
+    bool _havePoint;
+};
+
+}
+
+#endif

simgear/bvh/BVHNode.cxx

@@ -0,0 +1,80 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHNode.hxx"
+
+#include <algorithm>
+#include <simgear/structure/SGAtomic.hxx>
+#include <simgear/math/SGGeometry.hxx>
+
+namespace simgear {
+
+BVHNode::BVHNode() :
+    _dirtyBoundingSphere(true)
+{
+}
+
+BVHNode::~BVHNode()
+{
+}
+
+BVHNode::Id
+BVHNode::getNewId()
+{
+    static SGAtomic id(0);
+    return ++id;
+}
+
+void
+BVHNode::addParent(BVHNode* parent)
+{
+    // should not happen, but be paranoid ...
+    ParentList::iterator i;
+    i = std::find(_parents.begin(), _parents.end(), parent);
+    if (i != _parents.end())
+        return;
+    // add to the parents list ...
+    _parents.push_back(parent);
+}
+
+void
+BVHNode::removeParent(BVHNode* parent)
+{
+    ParentList::iterator i;
+    i = std::find(_parents.begin(), _parents.end(), parent);
+    if (i == _parents.end())
+        return;
+    _parents.erase(i);
+}
+
+void
+BVHNode::invalidateParentBound()
+{
+    for (ParentList::iterator i = _parents.begin(); i != _parents.end(); ++i)
+        (*i)->invalidateBound();
+}
+
+void
+BVHNode::invalidateBound()
+{
+    if (_dirtyBoundingSphere)
+        return;
+    invalidateParentBound();
+    _dirtyBoundingSphere = true;
+}
+
+}

simgear/bvh/BVHNode.hxx

@@ -0,0 +1,76 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHNode_hxx
+#define BVHNode_hxx
+
+#include <vector>
+#include <simgear/math/SGGeometry.hxx>
+#include <simgear/structure/SGReferenced.hxx>
+
+namespace simgear {
+
+class BVHGroup;
+class BVHVisitor;
+class BVHPageNode;
+
+// Base for the tree nodes
+class BVHNode : public SGReferenced {
+public:
+    BVHNode();
+    virtual ~BVHNode();
+    
+    // visitors ...
+    virtual void accept(BVHVisitor& visitor) = 0;
+    
+    const SGSphered& getBoundingSphere() const
+    {
+        if (_dirtyBoundingSphere) {
+            _boundingSphere = computeBoundingSphere();
+            _dirtyBoundingSphere = false;
+        }
+        return _boundingSphere;
+    }
+    virtual SGSphered computeBoundingSphere() const = 0;
+
+    /// A unique id for some kind of BVHNodes.
+    /// Currently only motions transforms.
+    typedef unsigned Id;
+
+    // Factory to get a new id
+    static Id getNewId();
+    
+protected:
+    friend class BVHGroup;
+    friend class BVHPageNode;
+    void addParent(BVHNode* parent);
+    void removeParent(BVHNode* parent);
+    
+    void invalidateParentBound();
+    virtual void invalidateBound();
+    
+private:
+    mutable bool _dirtyBoundingSphere;
+    mutable SGSphered _boundingSphere;
+    
+    typedef std::vector<BVHNode*> ParentList;
+    ParentList _parents;
+};
+
+}
+
+#endif

simgear/bvh/BVHPageNode.cxx

@@ -0,0 +1,40 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHPageNode.hxx"
+
+#include "BVHPager.hxx"
+
+namespace simgear {
+
+BVHPageNode::BVHPageNode() :
+    _useStamp(0),
+    _requested(false)
+{
+}
+
+BVHPageNode::~BVHPageNode()
+{
+}
+
+void
+BVHPageNode::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+}

simgear/bvh/BVHPageNode.hxx

@@ -0,0 +1,66 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHPageNode_hxx
+#define BVHPageNode_hxx
+
+#include <list>
+
+#include <simgear/structure/SGSharedPtr.hxx>
+
+#include "BVHGroup.hxx"
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+class BVHPager;
+class BVHPageRequest;
+
+class BVHPageNode : public BVHGroup {
+public:
+    BVHPageNode();
+    virtual ~BVHPageNode();
+    
+    virtual void accept(BVHVisitor& visitor);
+
+    /// Return the usage stamp of the last access
+    unsigned getUseStamp() const
+    { return _useStamp; }
+
+    virtual SGSphered computeBoundingSphere() const = 0;
+
+    virtual BVHPageRequest* newRequest() = 0;
+
+protected:
+    virtual void invalidateBound() = 0;
+
+    bool getRequested() const
+    { return _requested; }
+    void setRequested(bool requested)
+    { _requested = requested; }
+
+private:
+    friend class BVHPager;
+
+    std::list<SGSharedPtr<BVHPageNode> >::iterator _iterator;
+    unsigned _useStamp;
+    bool _requested;
+};
+
+}
+
+#endif

simgear/bvh/BVHPageRequest.cxx

@@ -0,0 +1,26 @@
+// Copyright (C) 2008 - 2012 Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHPageRequest.hxx"
+
+namespace simgear {
+
+BVHPageRequest::~BVHPageRequest()
+{
+}
+
+}

simgear/bvh/BVHPageRequest.hxx

@@ -0,0 +1,42 @@
+// Copyright (C) 2008 - 2012 Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHPageRequest_hxx
+#define BVHPageRequest_hxx
+
+#include <simgear/structure/SGReferenced.hxx>
+
+namespace simgear {
+
+class BVHPageNode;
+
+class BVHPageRequest : public SGReferenced {
+public:
+    virtual ~BVHPageRequest();
+
+    /// Happens in the pager thread, do not modify the calling bvh tree
+    virtual void load() = 0;
+    /// Happens in the bvh main thread where the bvh is actually used.
+    /// So inside here it is safe to modify the paged node
+    virtual void insert() = 0;
+    /// The page node this request is for
+    virtual BVHPageNode* getPageNode() = 0;
+};
+
+}
+
+#endif

simgear/bvh/BVHPager.cxx

@@ -0,0 +1,236 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHPager.hxx"
+
+#include <list>
+
+#include <simgear/threads/SGThread.hxx>
+#include <simgear/threads/SGGuard.hxx>
+
+#include "BVHPageNode.hxx"
+#include "BVHPageRequest.hxx"
+
+namespace simgear {
+
+struct BVHPager::_PrivateData : protected SGThread {
+    typedef SGSharedPtr<BVHPageRequest> _Request;
+    typedef std::list<_Request> _RequestList;
+    typedef std::list<SGSharedPtr<BVHPageNode> > _PageNodeList;
+    
+    struct _LockedQueue {
+        void _push(const _Request& request)
+        {
+            SGGuard<SGMutex> scopeLock(_mutex);
+            _requestList.push_back(request);
+        }
+        _Request _pop()
+        {
+            SGGuard<SGMutex> scopeLock(_mutex);
+            if (_requestList.empty())
+                return _Request();
+            _Request request;
+            request.swap(_requestList.front());
+            _requestList.pop_front();
+            return request;
+        }
+    private:
+        SGMutex _mutex;
+        _RequestList _requestList;
+    };
+    
+    struct _WorkQueue {
+        void _stop()
+        {
+            _push(_Request());
+        }
+        void _push(const _Request& request)
+        {
+            SGGuard<SGMutex> scopeLock(_mutex);
+            bool needSignal = _requestList.empty();
+            _requestList.push_back(request);
+            if (needSignal)
+                _waitCondition.signal();
+        }
+        _Request _pop()
+        {
+            SGGuard<SGMutex> scopeLock(_mutex);
+            while (_requestList.empty())
+                _waitCondition.wait(_mutex);
+            _Request request;
+            request.swap(_requestList.front());
+            _requestList.pop_front();
+            return request;
+        }
+    private:
+        SGMutex _mutex;
+        SGWaitCondition _waitCondition;
+        _RequestList _requestList;
+    };
+
+    _PrivateData() :
+        _started(false),
+        _useStamp(0)
+    {
+    }
+    virtual ~_PrivateData()
+    {
+        _stop();
+    }
+
+    virtual void run()
+    {
+        for (;;) {
+            _Request request = _pendingRequests._pop();
+            // This means stop working
+            if (!request.valid())
+                return;
+            request->load();
+            _processedRequests._push(request);
+        }
+    }
+
+    bool _start()
+    {
+        if (_started)
+            return true;
+        if (!start())
+            return false;
+        _started = true;
+        return true;
+    }
+    
+    void _stop()
+    {
+        if (!_started)
+            return;
+        // send a stop request ...
+        _pendingRequests._stop();
+        // ... and wait for the thread to finish
+        join();
+        _started = false;
+    }
+
+    void _use(BVHPageNode& pageNode)
+    {
+        if (pageNode._requested) {
+            // move it forward in the lru list
+            _pageNodeList.splice(_pageNodeList.end(), _pageNodeList,
+                                 pageNode._iterator);
+        } else {
+            _Request request = pageNode.newRequest();
+            if (!request.valid())
+                return;
+
+            pageNode._iterator = _pageNodeList.insert(_pageNodeList.end(),
+                                                      &pageNode);
+            pageNode._requested = true;
+
+            if (_started) {
+                _pendingRequests._push(request);
+            } else {
+                request->load();
+                request->insert();
+            }
+        }
+        pageNode._useStamp = _useStamp;
+    }
+
+    void _update(unsigned expiry)
+    {
+        // Insert all processed requests
+        for (;;) {
+            SGSharedPtr<BVHPageRequest> request;
+            request = _processedRequests._pop();
+            if (!request.valid())
+                break;
+            request->insert();
+        }
+
+        // ... and throw away stuff that is not used for a long time
+        unsigned useStamp = _useStamp - expiry;
+        _PageNodeList::iterator i = _pageNodeList.begin();
+        while (i != _pageNodeList.end()) {
+            // Ok, this means if the highest bit in the below difference
+            // is set which is aequivalent to having a negative difference
+            // but being wraparound save.
+            unsigned diff = (*i)->_useStamp - useStamp;
+            // test the sign bit of the difference
+            if (!(diff & (~((~0u) >> 1))))
+                break;
+            (*i)->clear();
+            (*i)->_requested = false;
+            i = _pageNodeList.erase(i);
+        }
+    }
+
+    bool _started;
+    unsigned _useStamp;
+    _WorkQueue _pendingRequests;
+    _LockedQueue _processedRequests;
+    // Store the rcu list of loaded nodes so that they can expire
+    _PageNodeList _pageNodeList;
+};
+
+BVHPager::BVHPager() :
+    _privateData(new _PrivateData)
+{
+}
+
+BVHPager::~BVHPager()
+{
+    delete _privateData;
+    _privateData = 0;
+}
+
+bool
+BVHPager::start()
+{
+    return _privateData->_start();
+}
+
+void
+BVHPager::stop()
+{
+    _privateData->_stop();
+}
+
+void
+BVHPager::use(BVHPageNode& pageNode)
+{
+    _privateData->_use(pageNode);
+}
+
+void
+BVHPager::update(unsigned expiry)
+{
+    _privateData->_update(expiry);
+}
+
+void
+BVHPager::setUseStamp(unsigned stamp)
+{
+    _privateData->_useStamp = stamp;
+}
+
+unsigned
+BVHPager::getUseStamp() const
+{
+    return _privateData->_useStamp;
+}
+
+}

simgear/bvh/BVHPager.hxx

@@ -0,0 +1,60 @@
+// Copyright (C) 2008 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHPager_hxx
+#define BVHPager_hxx
+
+#include <simgear/structure/SGSharedPtr.hxx>
+
+namespace simgear {
+
+class BVHPageNode;
+class BVHPageRequest;
+
+class BVHPager {
+public:
+    BVHPager();
+    ~BVHPager();
+
+    /// Starts the pager thread
+    bool start();
+
+    /// Stops the pager thread
+    void stop();
+
+    /// Use this page node, if loaded make it as used, if not loaded schedule
+    void use(BVHPageNode& pageNode);
+
+    /// Call this from the main thread to incorporate the processed page
+    /// requests into the bounding volume tree
+    void update(unsigned expiry);
+
+    /// The usage stamp to mark usage of BVHPageNodes
+    void setUseStamp(unsigned stamp);
+    unsigned getUseStamp() const;
+
+private:
+    BVHPager(const BVHPager&);
+    BVHPager& operator=(const BVHPager&);
+
+    struct _PrivateData;
+    _PrivateData* _privateData;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticBinary.cxx

@@ -0,0 +1,45 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHStaticBinary.hxx"
+
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+BVHStaticBinary::BVHStaticBinary(unsigned splitAxis,
+                                   const BVHStaticNode* leftChild,
+                                   const BVHStaticNode* rightChild,
+                                   const SGBoxf& boundingBox) :
+  _splitAxis(splitAxis),
+  _leftChild(leftChild),
+  _rightChild(rightChild),
+  _boundingBox(boundingBox)
+{
+}
+
+BVHStaticBinary::~BVHStaticBinary()
+{
+}
+
+void
+BVHStaticBinary::accept(BVHVisitor& visitor, const BVHStaticData& data) const
+{
+  visitor.apply(*this, data);
+}
+
+}

simgear/bvh/BVHStaticBinary.hxx

@@ -0,0 +1,78 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHStaticBinary_hxx
+#define BVHStaticBinary_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include "BVHStaticNode.hxx"
+
+namespace simgear {
+
+class BVHStaticBinary : public BVHStaticNode {
+public:
+  BVHStaticBinary(unsigned splitAxis, const BVHStaticNode* leftChild,
+                   const BVHStaticNode* rightChild, const SGBoxf& box);
+  virtual ~BVHStaticBinary();
+  virtual void accept(BVHVisitor& visitor, const BVHStaticData& data) const;
+
+  void traverse(BVHVisitor& visitor, const BVHStaticData& data) const
+  {
+    _leftChild->accept(visitor, data);
+    _rightChild->accept(visitor, data);
+  }
+
+  // Traverse call that first enters the child node that is potentially closer
+  // to the given point than the other.
+  template<typename T>
+  void traverse(BVHVisitor& visitor, const BVHStaticData& data,
+                const SGVec3<T>& pt) const
+  {
+    float center = 0.5f*(_boundingBox.getMin()[_splitAxis]
+                         + _boundingBox.getMax()[_splitAxis]);
+    if (pt[_splitAxis] < center) {
+      _leftChild->accept(visitor, data);
+      _rightChild->accept(visitor, data);
+    } else {
+      _rightChild->accept(visitor, data);
+      _leftChild->accept(visitor, data);
+    }
+  }
+
+  unsigned getSplitAxis() const
+  { return _splitAxis; }
+
+  const BVHStaticNode* getLeftChild() const
+  { return _leftChild; }
+  const BVHStaticNode* getRightChild() const
+  { return _rightChild; }
+
+  const SGBoxf& getBoundingBox() const
+  { return _boundingBox; }
+
+private:
+  // Note the order of the members, this is to avoid padding
+  unsigned _splitAxis;
+  SGSharedPtr<const BVHStaticNode> _leftChild;
+  SGSharedPtr<const BVHStaticNode> _rightChild;
+  SGBoxf _boundingBox;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticData.hxx

@@ -0,0 +1,57 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHStaticData_hxx
+#define BVHStaticData_hxx
+
+#include <vector>
+#include <simgear/structure/SGReferenced.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+#include <simgear/math/SGGeometry.hxx>
+#include "BVHMaterial.hxx"
+
+namespace simgear {
+
+class BVHStaticData : public SGReferenced {
+public:
+    virtual ~BVHStaticData() {}
+    
+    unsigned addVertex(const SGVec3f& vertex)
+    { _vertices.push_back(vertex); return _vertices.size() - 1; }
+    const SGVec3f& getVertex(unsigned i) const
+    { return _vertices[i]; }
+    
+    
+    unsigned addMaterial(const BVHMaterial* material)
+    { _materials.push_back(material); return _materials.size() - 1; }
+    const BVHMaterial* getMaterial(unsigned i) const
+    { if (_materials.size() <= i) return 0; return _materials[i]; }
+
+    void trim()
+    {
+        std::vector<SGVec3f>(_vertices).swap(_vertices);
+        std::vector<SGSharedPtr<const BVHMaterial> >(_materials).swap(_materials);
+    }
+    
+private:
+    std::vector<SGVec3f> _vertices;
+    std::vector<SGSharedPtr<const BVHMaterial> > _materials;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticGeometry.cxx

@@ -0,0 +1,51 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHStaticGeometry.hxx"
+
+#include "BVHBoundingBoxVisitor.hxx"
+
+namespace simgear {
+
+BVHStaticGeometry::BVHStaticGeometry(const BVHStaticNode* staticNode,
+                                     const BVHStaticData* staticData) :
+    _staticNode(staticNode),
+    _staticData(staticData)
+{
+}
+
+BVHStaticGeometry::~BVHStaticGeometry()
+{
+}
+
+void
+BVHStaticGeometry::accept(BVHVisitor& visitor)
+{
+    visitor.apply(*this);
+}
+
+SGSphered
+BVHStaticGeometry::computeBoundingSphere() const
+{
+    BVHBoundingBoxVisitor bbv;
+    _staticNode->accept(bbv, *_staticData);
+    SGSphered sphere;
+    sphere.expandBy(SGBoxd(bbv.getBox()));
+    return sphere;
+}
+
+}

simgear/bvh/BVHStaticGeometry.hxx

@@ -0,0 +1,56 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHStaticGeometry_hxx
+#define BVHStaticGeometry_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHStaticData.hxx"
+#include "BVHStaticNode.hxx"
+
+namespace simgear {
+
+class BVHStaticGeometry : public BVHNode {
+public:
+    BVHStaticGeometry(const BVHStaticNode* staticNode,
+                      const BVHStaticData* staticData);
+    virtual ~BVHStaticGeometry();
+    
+    virtual void accept(BVHVisitor& visitor);
+    
+    void traverse(BVHVisitor& visitor) const
+    { _staticNode->accept(visitor, *_staticData); }
+    
+    const BVHStaticData* getStaticData() const
+    { return _staticData; }
+    const BVHStaticNode* getStaticNode() const
+    { return _staticNode; }
+    
+    virtual SGSphered computeBoundingSphere() const;
+    
+private:
+    SGSharedPtr<const BVHStaticNode> _staticNode;
+    SGSharedPtr<const BVHStaticData> _staticData;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticGeometryBuilder.hxx

@@ -0,0 +1,228 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHStaticGeometryBuilder_hxx
+#define BVHStaticGeometryBuilder_hxx
+
+#include <algorithm>
+#include <map>
+#include <set>
+
+#include <simgear/structure/SGReferenced.hxx>
+#include <simgear/structure/SGSharedPtr.hxx>
+
+#include "BVHVisitor.hxx"
+#include "BVHNode.hxx"
+#include "BVHGroup.hxx"
+#include "BVHTransform.hxx"
+
+#include "BVHStaticData.hxx"
+
+#include "BVHStaticNode.hxx"
+#include "BVHStaticLeaf.hxx"
+#include "BVHStaticTriangle.hxx"
+#include "BVHStaticBinary.hxx"
+#include "BVHStaticGeometry.hxx"
+
+namespace simgear {
+
+class BVHStaticGeometryBuilder : public SGReferenced {
+public:
+    BVHStaticGeometryBuilder() :
+        _staticData(new BVHStaticData),
+        _currentMaterial(0),
+        _currentMaterialIndex(~0u)
+    { }
+    virtual ~BVHStaticGeometryBuilder()
+    { }
+
+    struct LeafRef {
+        LeafRef(const BVHStaticLeaf* leaf, const BVHStaticData& data) :
+            _leaf(leaf),
+            _box(_leaf->computeBoundingBox(data)),
+            _center(_leaf->computeCenter(data))
+        { }
+        SGSharedPtr<const BVHStaticLeaf> _leaf;
+        SGBoxf _box;
+        SGVec3f _center;
+    };
+    typedef std::list<LeafRef> LeafRefList;
+
+    struct LeafRefLess : public std::binary_function<LeafRef, LeafRef, bool> {
+        LeafRefLess(unsigned sortAxis) : _sortAxis(sortAxis) {}
+        bool operator()(const LeafRef& x, const LeafRef& y)
+        { return x._center[_sortAxis] < y._center[_sortAxis]; }
+        unsigned _sortAxis;
+    };
+
+    SGSharedPtr<BVHStaticData> _staticData;
+    LeafRefList _leafRefList;
+
+    typedef std::map<SGVec3f, unsigned> VertexMap;
+    VertexMap _vertexMap;
+
+    typedef std::set<SGVec3<unsigned> > TriangleSet;
+    TriangleSet _triangleSet;
+
+    void setCurrentMaterial(const BVHMaterial* material)
+    {
+        _currentMaterial = material;
+        _currentMaterialIndex = addMaterial(material);
+    }
+    const BVHMaterial* getCurrentMaterial() const
+    {
+        return _currentMaterial;
+    }
+    unsigned addMaterial(const BVHMaterial* material)
+    {
+        MaterialMap::const_iterator i = _materialMap.find(material);
+        if (i != _materialMap.end())
+            return i->second;
+        unsigned index = _staticData->addMaterial(material);
+        _materialMap[material] = index;
+        return index;
+    }
+
+    typedef std::map<const BVHMaterial*, unsigned> MaterialMap;
+    MaterialMap _materialMap;
+    const BVHMaterial* _currentMaterial;
+    unsigned _currentMaterialIndex;
+
+    void addTriangle(const SGVec3f& v1, const SGVec3f& v2, const SGVec3f& v3)
+    {
+        unsigned indices[3] = { addVertex(v1), addVertex(v2), addVertex(v3) };
+        std::sort(indices, indices + 3);
+        SGVec3<unsigned> indexKey(indices);
+        if (_triangleSet.find(indexKey) != _triangleSet.end())
+            return;
+        _triangleSet.insert(indexKey);
+        BVHStaticTriangle* staticTriangle;
+        staticTriangle = new BVHStaticTriangle(_currentMaterialIndex, indices);
+        _leafRefList.push_back(LeafRef(staticTriangle, *_staticData));
+    }
+    unsigned addVertex(const SGVec3f& v)
+    {
+        VertexMap::const_iterator i = _vertexMap.find(v);
+        if (i != _vertexMap.end())
+            return i->second;
+        unsigned index = _staticData->addVertex(v);
+        _vertexMap[v] = index;
+        return index;
+    }
+
+    BVHStaticGeometry* buildTree()
+    {
+        const BVHStaticNode* tree = buildTreeRecursive(_leafRefList);
+        if (!tree)
+            return 0;
+        _staticData->trim();
+        return new BVHStaticGeometry(tree, _staticData);
+    }
+
+private:
+    static void
+    centerSplitLeafs(unsigned splitAxis, const double& splitValue,
+                     LeafRefList& leafs, LeafRefList split[2])
+    {
+        while (!leafs.empty()) {
+            if (leafs.front()._center[splitAxis] < splitValue) {
+                split[0].splice(split[0].begin(), leafs, leafs.begin());
+            } else {
+                split[1].splice(split[1].begin(), leafs, leafs.begin());
+            }
+        }
+    }
+
+    static void
+    equalSplitLeafs(unsigned splitAxis, LeafRefList& leafs,
+                    LeafRefList split[2])
+    {
+        leafs.sort(LeafRefLess(splitAxis));
+        while (true) {
+            if (leafs.empty())
+                break;
+            split[0].splice(split[0].begin(), leafs, leafs.begin());
+            
+            if (leafs.empty())
+                break;
+            split[1].splice(split[1].begin(), leafs, --leafs.end());
+        }
+    }
+    
+    static const BVHStaticNode* buildTreeRecursive(LeafRefList& leafs)
+    {
+        // recursion termination
+        if (leafs.empty())
+            return 0;
+        // FIXME size is O(n)!!!
+        //   if (leafs.size() == 1)
+        if (++leafs.begin() == leafs.end())
+            return leafs.front()._leaf;
+        
+        SGBoxf box;
+        for (LeafRefList::const_iterator i = leafs.begin();
+             i != leafs.end(); ++i)
+            box.expandBy(i->_box);
+        
+        //   // FIXME ...
+        //   if (length(box.getSize()) < 1)
+        //     return new BVHBox(box);
+        
+        if (box.empty())
+            return 0;
+        
+        unsigned splitAxis = box.getBroadestAxis();
+        LeafRefList splitLeafs[2];
+        double splitValue = box.getCenter()[splitAxis];
+        centerSplitLeafs(splitAxis, splitValue, leafs, splitLeafs);
+        
+        if (splitLeafs[0].empty() || splitLeafs[1].empty()) {
+            for (unsigned i = 0; i < 3 ; ++i) {
+                if (i == splitAxis)
+                    continue;
+                
+                leafs.swap(splitLeafs[0]);
+                leafs.splice(leafs.begin(), splitLeafs[1]);
+                splitValue = box.getCenter()[i];
+                centerSplitLeafs(i, splitValue, leafs, splitLeafs);
+                
+                if (!splitLeafs[0].empty() && !splitLeafs[1].empty()) {
+                    splitAxis = i;
+                    break;
+                }
+            }
+        }
+        if (splitLeafs[0].empty() || splitLeafs[1].empty()) {
+            leafs.swap(splitLeafs[0]);
+            leafs.splice(leafs.begin(), splitLeafs[1]);
+            equalSplitLeafs(splitAxis, leafs, splitLeafs);
+        }
+        
+        const BVHStaticNode* child0 = buildTreeRecursive(splitLeafs[0]);
+        const BVHStaticNode* child1 = buildTreeRecursive(splitLeafs[1]);
+        if (!child0)
+            return child1;
+        if (!child1)
+            return child0;
+        
+        return new BVHStaticBinary(splitAxis, child0, child1, box);
+    }
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticLeaf.cxx

@@ -0,0 +1,27 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHStaticLeaf.hxx"
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+BVHStaticLeaf::~BVHStaticLeaf()
+{
+}
+
+}

simgear/bvh/BVHStaticLeaf.hxx

@@ -0,0 +1,38 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHStaticLeaf_hxx
+#define BVHStaticLeaf_hxx
+
+#include <simgear/math/SGGeometry.hxx>
+#include "BVHStaticNode.hxx"
+
+namespace simgear {
+
+class BVHStaticLeaf : public BVHStaticNode {
+public:
+  virtual ~BVHStaticLeaf();
+
+  virtual void accept(BVHVisitor& visitor, const BVHStaticData& data) const = 0;
+
+  virtual SGBoxf computeBoundingBox(const BVHStaticData&) const = 0;
+  virtual SGVec3f computeCenter(const BVHStaticData&) const = 0;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticNode.cxx

@@ -0,0 +1,26 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHStaticNode.hxx"
+
+namespace simgear {
+
+BVHStaticNode::~BVHStaticNode()
+{
+}
+
+}

simgear/bvh/BVHStaticNode.hxx

@@ -0,0 +1,37 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#ifndef BVHStaticNode_hxx
+#define BVHStaticNode_hxx
+
+#include <simgear/structure/SGReferenced.hxx>
+
+namespace simgear {
+
+class BVHStaticData;
+class BVHVisitor;
+
+class BVHStaticNode : public SGReferenced {
+public:
+  virtual ~BVHStaticNode();
+
+  virtual void accept(BVHVisitor&, const BVHStaticData&) const = 0;
+};
+
+}
+
+#endif

simgear/bvh/BVHStaticTriangle.cxx

@@ -0,0 +1,58 @@
+// Copyright (C) 2008 - 2009  Mathias Froehlich - Mathias.Froehlich@web.de
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
+#include "BVHStaticTriangle.hxx"
+
+#include "BVHVisitor.hxx"
+
+namespace simgear {
+
+BVHStaticTriangle::BVHStaticTriangle(unsigned material,
+                                       const unsigned indices[3]) :
+  _material(material)
+{
+    for (unsigned i = 0; i < 3; ++i)
+        _indices[i] = indices[i];
+}
+
+BVHStaticTriangle::~BVHStaticTriangle()
+{
+}
+
+void
+BVHStaticTriangle::accept(BVHVisitor& visitor, const BVHStaticData& data) const
+{
+    visitor.apply(*this, data);
+}
+
+SGBoxf
+BVHStaticTriangle::computeBoundingBox(const BVHStaticData& data) const
+{
+    SGBoxf box;
+    box.expandBy(data.getVertex(_indices[0]));
+    box.expandBy(data.getVertex(_indices[1]));
+    box.expandBy(data.getVertex(_indices[2]));
+    return box;
+}
+
+SGVec3f
+BVHStaticTriangle::computeCenter(const BVHStaticData& data) const
+{
+    return getTriangle(data).getCenter();
+}
+
+}