- Moved some property specific code into simgear/props/

- Split out the condition code from fgfs/src/Main/fg_props and put it
  in it's own source file in simgear/props/
- Created a scene subdirectory for scenery, model, and material property
  related code.
- Moved location.[ch]xx into simgear/scene/model/
- The location and condition code had dependencies on flightgear's global
  state (all the globals-> stuff, the flightgear property tree, etc.)  SimGear
  code can't depend on it so that data has to be passed as parameters to the
  functions/methods/constructors.

simgear/props/Makefile.am

@@ -0,0 +1,24 @@
+includedir = @includedir@/props
+
+lib_LIBRARIES = libsgprops.a
+
+include_HEADERS = \
+	condition.hxx \
+	props.hxx \
+	props_io.hxx
+
+libsgprops_a_SOURCES = \
+	condition.cxx \
+	props.cxx \
+        props_io.cxx
+
+noinst_PROGRAMS = props_test
+
+props_test_SOURCES = props_test.cxx
+props_test_LDADD = \
+	$(top_builddir)/simgear/props/libsgprops.a \
+	$(top_builddir)/simgear/xml/libsgxml.a \
+	$(top_builddir)/simgear/misc/libsgmisc.a \
+	$(top_builddir)/simgear/debug/libsgdebug.a
+
+INCLUDES = -I$(top_srcdir)

simgear/props/condition.cxx

@@ -0,0 +1,435 @@
+// condition.hxx - Declarations and inline methods for property conditions.
+// Written by David Megginson, started 2000.
+// CLO May 2003 - Split out condition specific code.
+//
+// This file is in the Public Domain, and comes with no warranty.
+//
+// $Id$
+
+#ifdef HAVE_CONFIG_H
+#  include <simgear/compiler.h>
+#endif
+
+// #include STL_IOSTREAM
+
+#include <simgear/misc/exception.hxx>
+
+#include "props.hxx"
+
+#include "condition.hxx"
+
+SG_USING_STD(istream);
+SG_USING_STD(ostream);
+
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGCondition.
+////////////////////////////////////////////////////////////////////////
+
+FGCondition::FGCondition ()
+{
+}
+
+FGCondition::~FGCondition ()
+{
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGPropertyCondition.
+////////////////////////////////////////////////////////////////////////
+
+FGPropertyCondition::FGPropertyCondition ( SGPropertyNode *prop_root,
+                                           const char *propname )
+    : _node( prop_root->getNode(propname, true) )
+{
+    cout << "FGPropertyCondition::FGPropertyCondition()" << endl;
+    cout << "  prop_root = " << prop_root << endl;
+    cout << "  propname = " << propname << endl;
+    _node = prop_root->getNode(propname, true);
+    cout << "  _node = " << _node << endl;
+}
+
+FGPropertyCondition::~FGPropertyCondition ()
+{
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGNotCondition.
+////////////////////////////////////////////////////////////////////////
+
+FGNotCondition::FGNotCondition (FGCondition * condition)
+  : _condition(condition)
+{
+}
+
+FGNotCondition::~FGNotCondition ()
+{
+  delete _condition;
+}
+
+bool
+FGNotCondition::test () const
+{
+  return !(_condition->test());
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGAndCondition.
+////////////////////////////////////////////////////////////////////////
+
+FGAndCondition::FGAndCondition ()
+{
+}
+
+FGAndCondition::~FGAndCondition ()
+{
+  for (unsigned int i = 0; i < _conditions.size(); i++)
+    delete _conditions[i];
+}
+
+bool
+FGAndCondition::test () const
+{
+  int nConditions = _conditions.size();
+  for (int i = 0; i < nConditions; i++) {
+    if (!_conditions[i]->test())
+      return false;
+  }
+  return true;
+}
+
+void
+FGAndCondition::addCondition (FGCondition * condition)
+{
+  _conditions.push_back(condition);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGOrCondition.
+////////////////////////////////////////////////////////////////////////
+
+FGOrCondition::FGOrCondition ()
+{
+}
+
+FGOrCondition::~FGOrCondition ()
+{
+  for (unsigned int i = 0; i < _conditions.size(); i++)
+    delete _conditions[i];
+}
+
+bool
+FGOrCondition::test () const
+{
+  int nConditions = _conditions.size();
+  for (int i = 0; i < nConditions; i++) {
+    if (_conditions[i]->test())
+      return true;
+  }
+  return false;
+}
+
+void
+FGOrCondition::addCondition (FGCondition * condition)
+{
+  _conditions.push_back(condition);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGComparisonCondition.
+////////////////////////////////////////////////////////////////////////
+
+static int
+doComparison (const SGPropertyNode * left, const SGPropertyNode *right)
+{
+  switch (left->getType()) {
+  case SGPropertyNode::BOOL: {
+    bool v1 = left->getBoolValue();
+    bool v2 = right->getBoolValue();
+    if (v1 < v2)
+      return FGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return FGComparisonCondition::GREATER_THAN;
+    else
+      return FGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::INT: {
+    int v1 = left->getIntValue();
+    int v2 = right->getIntValue();
+    if (v1 < v2)
+      return FGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return FGComparisonCondition::GREATER_THAN;
+    else
+      return FGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::LONG: {
+    long v1 = left->getLongValue();
+    long v2 = right->getLongValue();
+    if (v1 < v2)
+      return FGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return FGComparisonCondition::GREATER_THAN;
+    else
+      return FGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::FLOAT: {
+    float v1 = left->getFloatValue();
+    float v2 = right->getFloatValue();
+    if (v1 < v2)
+      return FGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return FGComparisonCondition::GREATER_THAN;
+    else
+      return FGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::DOUBLE: {
+    double v1 = left->getDoubleValue();
+    double v2 = right->getDoubleValue();
+    if (v1 < v2)
+      return FGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return FGComparisonCondition::GREATER_THAN;
+    else
+      return FGComparisonCondition::EQUALS;
+    break;
+  }
+  case SGPropertyNode::STRING: 
+  case SGPropertyNode::NONE:
+  case SGPropertyNode::UNSPECIFIED: {
+    string v1 = left->getStringValue();
+    string v2 = right->getStringValue();
+    if (v1 < v2)
+      return FGComparisonCondition::LESS_THAN;
+    else if (v1 > v2)
+      return FGComparisonCondition::GREATER_THAN;
+    else
+      return FGComparisonCondition::EQUALS;
+    break;
+  }
+  }
+  throw sg_exception("Unrecognized node type");
+  return 0;
+}
+
+
+FGComparisonCondition::FGComparisonCondition (Type type, bool reverse)
+  : _type(type),
+    _reverse(reverse),
+    _left_property(0),
+    _right_property(0),
+    _right_value(0)
+{
+}
+
+FGComparisonCondition::~FGComparisonCondition ()
+{
+  delete _right_value;
+}
+
+bool
+FGComparisonCondition::test () const
+{
+				// Always fail if incompletely specified
+  if (_left_property == 0 ||
+      (_right_property == 0 && _right_value == 0))
+    return false;
+
+				// Get LESS_THAN, EQUALS, or GREATER_THAN
+  int cmp =
+    doComparison(_left_property,
+		 (_right_property != 0 ? _right_property : _right_value));
+  if (!_reverse)
+    return (cmp == _type);
+  else
+    return (cmp != _type);
+}
+
+void
+FGComparisonCondition::setLeftProperty( SGPropertyNode *prop_root,
+                                        const char * propname )
+{
+  _left_property = prop_root->getNode(propname, true);
+}
+
+void
+FGComparisonCondition::setRightProperty( SGPropertyNode *prop_root,
+                                         const char * propname )
+{
+  delete _right_value;
+  _right_value = 0;
+  _right_property = prop_root->getNode(propname, true);
+}
+
+void
+FGComparisonCondition::setRightValue (const SGPropertyNode *node)
+{
+  _right_property = 0;
+  delete _right_value;
+  _right_value = new SGPropertyNode(*node);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Read a condition and use it if necessary.
+////////////////////////////////////////////////////////////////////////
+
+                                // Forward declaration
+static FGCondition * readCondition( SGPropertyNode *prop_root,
+                                    const SGPropertyNode *node );
+
+static FGCondition *
+readPropertyCondition( SGPropertyNode *prop_root,
+                       const SGPropertyNode *node )
+{
+  return new FGPropertyCondition( prop_root, node->getStringValue() );
+}
+
+static FGCondition *
+readNotCondition( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  int nChildren = node->nChildren();
+  for (int i = 0; i < nChildren; i++) {
+    const SGPropertyNode * child = node->getChild(i);
+    FGCondition * condition = readCondition(prop_root, child);
+    if (condition != 0)
+      return new FGNotCondition(condition);
+  }
+  SG_LOG(SG_COCKPIT, SG_ALERT, "Panel: empty 'not' condition");
+  return 0;
+}
+
+static FGCondition *
+readAndConditions( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  FGAndCondition * andCondition = new FGAndCondition;
+  int nChildren = node->nChildren();
+  for (int i = 0; i < nChildren; i++) {
+    const SGPropertyNode * child = node->getChild(i);
+    FGCondition * condition = readCondition(prop_root, child);
+    if (condition != 0)
+      andCondition->addCondition(condition);
+  }
+  return andCondition;
+}
+
+static FGCondition *
+readOrConditions( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  FGOrCondition * orCondition = new FGOrCondition;
+  int nChildren = node->nChildren();
+  for (int i = 0; i < nChildren; i++) {
+    const SGPropertyNode * child = node->getChild(i);
+    FGCondition * condition = readCondition(prop_root, child);
+    if (condition != 0)
+      orCondition->addCondition(condition);
+  }
+  return orCondition;
+}
+
+static FGCondition *
+readComparison( SGPropertyNode *prop_root,
+                const SGPropertyNode *node,
+                FGComparisonCondition::Type type,
+		bool reverse)
+{
+  FGComparisonCondition * condition = new FGComparisonCondition(type, reverse);
+  condition->setLeftProperty(prop_root, node->getStringValue("property[0]"));
+  if (node->hasValue("property[1]"))
+    condition->setRightProperty(prop_root, node->getStringValue("property[1]"));
+  else
+    condition->setRightValue(node->getChild("value", 0));
+
+  return condition;
+}
+
+static FGCondition *
+readCondition( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  const string &name = node->getName();
+  if (name == "property")
+    return readPropertyCondition(prop_root, node);
+  else if (name == "not")
+    return readNotCondition(prop_root, node);
+  else if (name == "and")
+    return readAndConditions(prop_root, node);
+  else if (name == "or")
+    return readOrConditions(prop_root, node);
+  else if (name == "less-than")
+    return readComparison(prop_root, node, FGComparisonCondition::LESS_THAN,
+                          false);
+  else if (name == "less-than-equals")
+    return readComparison(prop_root, node, FGComparisonCondition::GREATER_THAN,
+                          true);
+  else if (name == "greater-than")
+    return readComparison(prop_root, node, FGComparisonCondition::GREATER_THAN,
+                          false);
+  else if (name == "greater-than-equals")
+    return readComparison(prop_root, node, FGComparisonCondition::LESS_THAN,
+                          true);
+  else if (name == "equals")
+    return readComparison(prop_root, node, FGComparisonCondition::EQUALS,
+                          false);
+  else if (name == "not-equals")
+    return readComparison(prop_root, node, FGComparisonCondition::EQUALS, true);
+  else
+    return 0;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGConditional.
+////////////////////////////////////////////////////////////////////////
+
+FGConditional::FGConditional ()
+  : _condition (0)
+{
+}
+
+FGConditional::~FGConditional ()
+{
+  delete _condition;
+}
+
+void
+FGConditional::setCondition (FGCondition * condition)
+{
+  delete _condition;
+  _condition = condition;
+}
+
+bool
+FGConditional::test () const
+{
+  return ((_condition == 0) || _condition->test());
+}
+
+
+
+// The top-level is always an implicit 'and' group
+FGCondition *
+fgReadCondition( SGPropertyNode *prop_root, const SGPropertyNode *node )
+{
+  return readAndConditions(prop_root, node);
+}
+
+
+// end of fg_props.cxx

simgear/props/condition.hxx

@@ -0,0 +1,176 @@
+// condition.hxx - Declarations and inline methods for property conditions.
+// Written by David Megginson, started 2000.
+// CLO May 2003 - Split out condition specific code.
+//
+// This file is in the Public Domain, and comes with no warranty.
+
+#ifndef __SG_CONDITION_HXX
+#define __SG_CONDITION_HXX
+
+#include <simgear/debug/logstream.hxx>
+#include <simgear/props/props.hxx>
+#include <simgear/props/props_io.hxx>
+
+
+////////////////////////////////////////////////////////////////////////
+// Conditions.
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * An encoded condition.
+ *
+ * This class encodes a single condition of some sort, possibly
+ * connected with properties.
+ *
+ * This class should migrate to somewhere more general.
+ */
+class FGCondition
+{
+public:
+  FGCondition ();
+  virtual ~FGCondition ();
+  virtual bool test () const = 0;
+};
+
+
+/**
+ * Condition for a single property.
+ *
+ * This condition is true only if the property returns a boolean
+ * true value.
+ */
+class FGPropertyCondition : public FGCondition
+{
+public:
+  FGPropertyCondition ( SGPropertyNode *prop_root,
+                        const char * propname  );
+  virtual ~FGPropertyCondition ();
+  virtual bool test () const { return _node->getBoolValue(); }
+private:
+  const SGPropertyNode * _node;
+};
+
+
+/**
+ * Condition for a 'not' operator.
+ *
+ * This condition is true only if the child condition is false.
+ */
+class FGNotCondition : public FGCondition
+{
+public:
+				// transfer pointer ownership
+  FGNotCondition (FGCondition * condition);
+  virtual ~FGNotCondition ();
+  virtual bool test () const;
+private:
+  FGCondition * _condition;
+};
+
+
+/**
+ * Condition for an 'and' group.
+ *
+ * This condition is true only if all of the conditions
+ * in the group are true.
+ */
+class FGAndCondition : public FGCondition
+{
+public:
+  FGAndCondition ();
+  virtual ~FGAndCondition ();
+  virtual bool test () const;
+				// transfer pointer ownership
+  virtual void addCondition (FGCondition * condition);
+private:
+  vector<FGCondition *> _conditions;
+};
+
+
+/**
+ * Condition for an 'or' group.
+ *
+ * This condition is true if at least one of the conditions in the
+ * group is true.
+ */
+class FGOrCondition : public FGCondition
+{
+public:
+  FGOrCondition ();
+  virtual ~FGOrCondition ();
+  virtual bool test () const;
+				// transfer pointer ownership
+  virtual void addCondition (FGCondition * condition);
+private:
+  vector<FGCondition *> _conditions;
+};
+
+
+/**
+ * Abstract base class for property comparison conditions.
+ */
+class FGComparisonCondition : public FGCondition
+{
+public:
+  enum Type {
+    LESS_THAN,
+    GREATER_THAN,
+    EQUALS
+  };
+  FGComparisonCondition (Type type, bool reverse = false);
+  virtual ~FGComparisonCondition ();
+  virtual bool test () const;
+  virtual void setLeftProperty( SGPropertyNode *prop_root,
+                                const char * propname );
+  virtual void setRightProperty( SGPropertyNode *prop_root,
+                                 const char * propname );
+				// will make a local copy
+  virtual void setRightValue (const SGPropertyNode * value);
+private:
+  Type _type;
+  bool _reverse;
+  const SGPropertyNode * _left_property;
+  const SGPropertyNode * _right_property;
+  const SGPropertyNode * _right_value;
+};
+
+
+/**
+ * Base class for a conditional components.
+ *
+ * This class manages the conditions and tests; the component should
+ * invoke the test() method whenever it needs to decide whether to
+ * active itself, draw itself, and so on.
+ */
+class FGConditional
+{
+public:
+  FGConditional ();
+  virtual ~FGConditional ();
+				// transfer pointer ownership
+  virtual void setCondition (FGCondition * condition);
+  virtual const FGCondition * getCondition () const { return _condition; }
+  virtual bool test () const;
+private:
+  FGCondition * _condition;
+};
+
+
+/**
+ * Global function to make a condition out of properties.
+ *
+ * The top-level is always an implicit 'and' group, whatever the
+ * node's name (it should usually be "condition").
+ *
+ * @param node The top-level condition node (usually named "condition").
+ * @return A pointer to a newly-allocated condition; it is the
+ *         responsibility of the caller to delete the condition when
+ *         it is no longer needed.
+ */
+FGCondition * fgReadCondition( SGPropertyNode *prop_root,
+                               const SGPropertyNode *node );
+
+
+#endif // __SG_CONDITION_HXX
+

simgear/props/props_io.cxx

@@ -0,0 +1,586 @@
+
+#include <simgear/compiler.h>
+
+#include <stdlib.h>		// atof() atoi()
+
+#include <simgear/sg_inlines.h>
+#include <simgear/debug/logstream.hxx>
+#include <simgear/misc/sg_path.hxx>
+#include <simgear/xml/easyxml.hxx>
+
+#include "props.hxx"
+#include "props_io.hxx"
+
+#include STL_IOSTREAM
+#include STL_FSTREAM
+#include STL_STRING
+#include <vector>
+#include <map>
+
+SG_USING_STD(istream);
+SG_USING_STD(ifstream);
+SG_USING_STD(ostream);
+SG_USING_STD(ofstream);
+SG_USING_STD(string);
+SG_USING_STD(vector);
+SG_USING_STD(map);
+
+#define DEFAULT_MODE (SGPropertyNode::READ|SGPropertyNode::WRITE)
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Property list visitor, for XML parsing.
+////////////////////////////////////////////////////////////////////////
+
+class PropsVisitor : public XMLVisitor
+{
+public:
+
+  PropsVisitor (SGPropertyNode * root, const string &base)
+    : _root(root), _level(0), _base(base), _hasException(false) {}
+
+  virtual ~PropsVisitor () {}
+
+  void startXML ();
+  void endXML ();
+  void startElement (const char * name, const XMLAttributes &atts);
+  void endElement (const char * name);
+  void data (const char * s, int length);
+  void warning (const char * message, int line, int column);
+
+  bool hasException () const { return _hasException; }
+  sg_io_exception &getException () { return _exception; }
+  void setException (const sg_io_exception &exception) {
+    _exception = exception;
+    _hasException = true;
+  }
+
+private:
+
+  struct State
+  {
+    State () : node(0), type(""), mode(DEFAULT_MODE) {}
+    State (SGPropertyNode * _node, const char * _type, int _mode)
+      : node(_node), type(_type), mode(_mode) {}
+    SGPropertyNode * node;
+    string type;
+    int mode;
+    map<string,int> counters;
+  };
+
+  State &state () { return _state_stack[_state_stack.size() - 1]; }
+
+  void push_state (SGPropertyNode * node, const char * type, int mode) {
+    if (type == 0)
+      _state_stack.push_back(State(node, "unspecified", mode));
+    else
+      _state_stack.push_back(State(node, type, mode));
+    _level++;
+    _data = "";
+  }
+
+  void pop_state () {
+    _state_stack.pop_back();
+    _level--;
+  }
+
+  string _data;
+  SGPropertyNode * _root;
+  int _level;
+  vector<State> _state_stack;
+  string _base;
+  sg_io_exception _exception;
+  bool _hasException;
+};
+
+void
+PropsVisitor::startXML ()
+{
+  _level = 0;
+  _state_stack.resize(0);
+}
+
+void
+PropsVisitor::endXML ()
+{
+  _level = 0;
+  _state_stack.resize(0);
+}
+
+
+/**
+ * Check a yes/no flag, with default.
+ */
+static bool
+checkFlag (const char * flag, bool defaultState = true)
+{
+  if (flag == 0)
+    return defaultState;
+  else if (string(flag) == "y")
+    return true;
+  else if (string(flag) == "n")
+    return false;
+  else {
+    string message = "Unrecognized flag value '";
+    message += flag;
+    message += '\'';
+				// FIXME: add location info
+    throw sg_io_exception(message, "SimGear Property Reader");
+  }
+}
+
+void
+PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
+{
+  State &st = state();
+  const char * attval;
+
+  if (_level == 0) {
+    if (string(name) != (string)"PropertyList") {
+      string message = "Root element name is ";
+      message += name;
+      message += "; expected PropertyList";
+      throw sg_io_exception(message, "SimGear Property Reader");
+    }
+
+				// Check for an include.
+    attval = atts.getValue("include");
+    if (attval != 0) {
+      SGPath path(SGPath(_base).dir());
+      path.append(attval);
+      try {
+	readProperties(path.str(), _root);
+      } catch (sg_io_exception &e) {
+	setException(e);
+      }
+    }
+
+    push_state(_root, "", DEFAULT_MODE);
+  }
+
+  else {
+				// Get the index.
+    attval = atts.getValue("n");
+    int index = 0;
+    if (attval != 0) {
+      index = atoi(attval);
+      st.counters[name] = SG_MAX2(st.counters[name], index+1);
+    } else {
+      index = st.counters[name];
+      st.counters[name]++;
+    }
+
+				// Got the index, so grab the node.
+    SGPropertyNode * node = st.node->getChild(name, index, true);
+
+				// Get the access-mode attributes,
+				// but don't set yet (in case they
+				// prevent us from recording the value).
+    int mode = 0;
+
+    attval = atts.getValue("read");
+    if (checkFlag(attval, true))
+      mode |= SGPropertyNode::READ;
+    attval = atts.getValue("write");
+    if (checkFlag(attval, true))
+      mode |= SGPropertyNode::WRITE;
+    attval = atts.getValue("archive");
+    if (checkFlag(attval, false))
+      mode |= SGPropertyNode::ARCHIVE;
+    attval = atts.getValue("trace-read");
+    if (checkFlag(attval, false))
+      mode |= SGPropertyNode::TRACE_READ;
+    attval = atts.getValue("trace-write");
+    if (checkFlag(attval, false))
+      mode |= SGPropertyNode::TRACE_WRITE;
+
+				// Check for an alias.
+    attval = atts.getValue("alias");
+    if (attval != 0) {
+      if (!node->alias(attval))
+	SG_LOG(SG_INPUT, SG_ALERT, "Failed to set alias to " << attval);
+    }
+
+				// Check for an include.
+    attval = atts.getValue("include");
+    if (attval != 0) {
+      SGPath path(SGPath(_base).dir());
+      path.append(attval);
+      try {
+	readProperties(path.str(), node);
+      } catch (sg_io_exception &e) {
+	setException(e);
+      }
+    }
+
+    push_state(node, atts.getValue("type"), mode);
+  }
+}
+
+void
+PropsVisitor::endElement (const char * name)
+{
+  State &st = state();
+  bool ret;
+
+				// If there are no children and it's
+				// not an alias, then it's a leaf value.
+  if (st.node->nChildren() == 0 && !st.node->isAlias()) {
+    if (st.type == "bool") {
+      if (_data == "true" || atoi(_data.c_str()) != 0)
+	ret = st.node->setBoolValue(true);
+      else
+	ret = st.node->setBoolValue(false);
+    } else if (st.type == "int") {
+      ret = st.node->setIntValue(atoi(_data.c_str()));
+    } else if (st.type == "long") {
+      ret = st.node->setLongValue(strtol(_data.c_str(), 0, 0));
+    } else if (st.type == "float") {
+      ret = st.node->setFloatValue(atof(_data.c_str()));
+    } else if (st.type == "double") {
+      ret = st.node->setDoubleValue(strtod(_data.c_str(), 0));
+    } else if (st.type == "string") {
+      ret = st.node->setStringValue(_data.c_str());
+    } else if (st.type == "unspecified") {
+      ret = st.node->setUnspecifiedValue(_data.c_str());
+    } else {
+      string message = "Unrecognized data type '";
+      message += st.type;
+      message += '\'';
+				// FIXME: add location information
+      throw sg_io_exception(message, "SimGear Property Reader");
+    }
+    if (!ret)
+      SG_LOG(SG_INPUT, SG_ALERT, "readProperties: Failed to set "
+	     << st.node->getPath() << " to value \""
+	     << _data << "\" with type " << st.type);
+  }
+
+				// Set the access-mode attributes now,
+				// once the value has already been 
+				// assigned.
+  st.node->setAttributes(st.mode);
+
+  pop_state();
+}
+
+void
+PropsVisitor::data (const char * s, int length)
+{
+  if (state().node->nChildren() == 0)
+    _data.append(string(s, length));
+}
+
+void
+PropsVisitor::warning (const char * message, int line, int column)
+{
+  SG_LOG(SG_INPUT, SG_ALERT, "readProperties: warning: "
+	 << message << " at line " << line << ", column " << column);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Property list reader.
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Read properties from an input stream.
+ *
+ * @param input The input stream containing an XML property file.
+ * @param start_node The root node for reading properties.
+ * @param base A base path for resolving external include references.
+ * @return true if the read succeeded, false otherwise.
+ */
+void
+readProperties (istream &input, SGPropertyNode * start_node,
+		const string &base)
+{
+  PropsVisitor visitor(start_node, base);
+  readXML(input, visitor, base);
+  if (visitor.hasException())
+    throw visitor.getException();
+}
+
+
+/**
+ * Read properties from a file.
+ *
+ * @param file A string containing the file path.
+ * @param start_node The root node for reading properties.
+ * @return true if the read succeeded, false otherwise.
+ */
+void
+readProperties (const string &file, SGPropertyNode * start_node)
+{
+  PropsVisitor visitor(start_node, file);
+  readXML(file, visitor);
+  if (visitor.hasException())
+    throw visitor.getException();
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Property list writer.
+////////////////////////////////////////////////////////////////////////
+
+#define INDENT_STEP 2
+
+/**
+ * Return the type name.
+ */
+static const char *
+getTypeName (SGPropertyNode::Type type)
+{
+  switch (type) {
+  case SGPropertyNode::UNSPECIFIED:
+    return "unspecified";
+  case SGPropertyNode::BOOL:
+    return "bool";
+  case SGPropertyNode::INT:
+    return "int";
+  case SGPropertyNode::LONG:
+    return "long";
+  case SGPropertyNode::FLOAT:
+    return "float";
+  case SGPropertyNode::DOUBLE:
+    return "double";
+  case SGPropertyNode::STRING:
+    return "string";
+  case SGPropertyNode::ALIAS:
+  case SGPropertyNode::NONE:
+    return "unspecified";
+  }
+
+  // keep the compiler from squawking
+  return "unspecified";
+}
+
+
+/**
+ * Escape characters for output.
+ */
+static void
+writeData (ostream &output, const string &data)
+{
+  for (int i = 0; i < (int)data.size(); i++) {
+    switch (data[i]) {
+    case '&':
+      output << "&amp;";
+      break;
+    case '<':
+      output << "&lt;";
+      break;
+    case '>':
+      output << "&gt;";
+      break;
+    default:
+      output << data[i];
+      break;
+    }
+  }
+}
+
+static void
+doIndent (ostream &output, int indent)
+{
+  while (indent-- > 0) {
+    output << ' ';
+  }
+}
+
+
+static void
+writeAtts (ostream &output, const SGPropertyNode * node)
+{
+  int index = node->getIndex();
+
+  if (index != 0)
+    output << " n=\"" << index << '"';
+
+#if 0
+  if (!node->getAttribute(SGPropertyNode::READ))
+    output << " read=\"n\"";
+
+  if (!node->getAttribute(SGPropertyNode::WRITE))
+    output << " write=\"n\"";
+
+  if (node->getAttribute(SGPropertyNode::ARCHIVE))
+    output << " archive=\"y\"";
+#endif
+
+}
+
+
+/**
+ * Test whether a node is archivable or has archivable descendants.
+ */
+static bool
+isArchivable (const SGPropertyNode * node)
+{
+  // FIXME: it's inefficient to do this all the time
+  if (node->getAttribute(SGPropertyNode::ARCHIVE))
+    return true;
+  else {
+    int nChildren = node->nChildren();
+    for (int i = 0; i < nChildren; i++)
+      if (isArchivable(node->getChild(i)))
+	return true;
+  }
+  return false;
+}
+
+
+static bool
+writeNode (ostream &output, const SGPropertyNode * node,
+	   bool write_all, int indent)
+{
+				// Don't write the node or any of
+				// its descendants unless it is
+				// allowed to be archived.
+  if (!write_all && !isArchivable(node))
+    return true;		// Everything's OK, but we won't write.
+
+  const string name = node->getName();
+  int nChildren = node->nChildren();
+
+				// If there is a literal value,
+				// write it first.
+  if (node->hasValue() && (write_all || node->getAttribute(SGPropertyNode::ARCHIVE))) {
+    doIndent(output, indent);
+    output << '<' << name;
+    writeAtts(output, node);
+    if (node->isAlias() && node->getAliasTarget() != 0) {
+      output << " alias=\"" << node->getAliasTarget()->getPath()
+	     << "\"/>" << endl;
+    } else {
+      if (node->getType() != SGPropertyNode::UNSPECIFIED)
+	output << " type=\"" << getTypeName(node->getType()) << '"';
+      output << '>';
+      writeData(output, node->getStringValue());
+      output << "</" << name << '>' << endl;
+    }
+  }
+
+				// If there are children, write them next.
+  if (nChildren > 0 || node->isAlias()) {
+    doIndent(output, indent);
+    output << '<' << name;
+    writeAtts(output, node);
+    output << '>' << endl;
+    for (int i = 0; i < nChildren; i++)
+      writeNode(output, node->getChild(i), write_all, indent + INDENT_STEP);
+    doIndent(output, indent);
+    output << "</" << name << '>' << endl;
+  }
+
+  return true;
+}
+
+
+void
+writeProperties (ostream &output, const SGPropertyNode * start_node,
+		 bool write_all)
+{
+  int nChildren = start_node->nChildren();
+
+  output << "<?xml version=\"1.0\"?>" << endl << endl;
+  output << "<PropertyList>" << endl;
+
+  for (int i = 0; i < nChildren; i++) {
+    writeNode(output, start_node->getChild(i), write_all, INDENT_STEP);
+  }
+
+  output << "</PropertyList>" << endl;
+}
+
+
+void
+writeProperties (const string &file, const SGPropertyNode * start_node,
+		 bool write_all)
+{
+  ofstream output(file.c_str());
+  if (output.good()) {
+    writeProperties(output, start_node, write_all);
+  } else {
+    throw sg_io_exception("Cannot open file", sg_location(file));
+  }
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Copy properties from one tree to another.
+////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Copy one property tree to another.
+ * 
+ * @param in The source property tree.
+ * @param out The destination property tree.
+ * @return true if all properties were copied, false if some failed
+ *  (for example, if the property's value is tied read-only).
+ */
+bool
+copyProperties (const SGPropertyNode *in, SGPropertyNode *out)
+{
+  bool retval = true;
+
+				// First, copy the actual value,
+				// if any.
+  if (in->hasValue()) {
+    switch (in->getType()) {
+    case SGPropertyNode::BOOL:
+      if (!out->setBoolValue(in->getBoolValue()))
+	retval = false;
+      break;
+    case SGPropertyNode::INT:
+      if (!out->setIntValue(in->getIntValue()))
+	retval = false;
+      break;
+    case SGPropertyNode::LONG:
+      if (!out->setLongValue(in->getLongValue()))
+	retval = false;
+      break;
+    case SGPropertyNode::FLOAT:
+      if (!out->setFloatValue(in->getFloatValue()))
+	retval = false;
+      break;
+    case SGPropertyNode::DOUBLE:
+      if (!out->setDoubleValue(in->getDoubleValue()))
+	retval = false;
+      break;
+    case SGPropertyNode::STRING:
+      if (!out->setStringValue(in->getStringValue()))
+	retval = false;
+      break;
+    case SGPropertyNode::UNSPECIFIED:
+      if (!out->setUnspecifiedValue(in->getStringValue()))
+	retval = false;
+      break;
+    default:
+      string message = "Unknown internal SGPropertyNode type";
+      message += in->getType();
+      throw sg_error(message, "SimGear Property Reader");
+    }
+  }
+
+				// Next, copy the children.
+  int nChildren = in->nChildren();
+  for (int i = 0; i < nChildren; i++) {
+    const SGPropertyNode * in_child = in->getChild(i);
+    SGPropertyNode * out_child = out->getChild(in_child->getName(),
+					       in_child->getIndex(),
+					       true);
+    if (!copyProperties(in_child, out_child))
+      retval = false;
+  }
+
+  return retval;
+}
+
+// end of props_io.cxx

simgear/props/props_io.hxx

@@ -0,0 +1,66 @@
+/**
+ * \file props_io.hxx
+ * Interface definition for property list io.
+ * Started Fall 2000 by David Megginson, david@megginson.com
+ * This code is released into the Public Domain.
+ *
+ * See props.html for documentation [replace with URL when available].
+ *
+ * $Id$
+ */
+
+#ifndef __PROPS_IO_HXX
+#define __PROPS_IO_HXX
+
+#include <simgear/compiler.h>
+#include <simgear/props/props.hxx>
+
+#include <stdio.h>
+
+#include STL_STRING
+#include <vector>
+#include <map>
+#include STL_IOSTREAM
+
+SG_USING_STD(string);
+SG_USING_STD(vector);
+SG_USING_STD(map);
+SG_USING_STD(istream);
+SG_USING_STD(ostream);
+
+/**
+ * Read properties from an XML input stream.
+ */
+void readProperties (istream &input, SGPropertyNode * start_node,
+		     const string &base = "");
+
+
+/**
+ * Read properties from an XML file.
+ */
+void readProperties (const string &file, SGPropertyNode * start_node);
+
+
+/**
+ * Write properties to an XML output stream.
+ */
+void writeProperties (ostream &output, const SGPropertyNode * start_node,
+		      bool write_all = false);
+
+
+/**
+ * Write properties to an XML file.
+ */
+void writeProperties (const string &file, const SGPropertyNode * start_node,
+		      bool write_all = false);
+
+
+/**
+ * Copy properties from one node to another.
+ */
+bool copyProperties (const SGPropertyNode *in, SGPropertyNode *out);
+
+
+#endif // __PROPS_IO_HXX
+
+// end of props_io.hxx

simgear/props/props_test.cxx

@@ -0,0 +1,346 @@
+
+////////////////////////////////////////////////////////////////////////
+// Test harness.
+////////////////////////////////////////////////////////////////////////
+
+#include <simgear/compiler.h>
+
+#include STL_IOSTREAM
+#include "props.hxx"
+#include "props_io.hxx"
+
+SG_USING_STD(cout);
+SG_USING_STD(cerr);
+SG_USING_STD(endl);
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Sample object.
+////////////////////////////////////////////////////////////////////////
+
+class Stuff {
+public:
+  Stuff () : _stuff(199.0) {}
+  virtual float getStuff () const { return _stuff; }
+  virtual void setStuff (float stuff) { _stuff = stuff; }
+  virtual float getStuff (int index) const { return _stuff * index; }
+  virtual void setStuff (int index, float val) {
+    _stuff = val / index;
+  }
+private:
+  float _stuff;
+};
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Sample function.
+////////////////////////////////////////////////////////////////////////
+
+static int get100 () { return 100; }
+
+static double getNum (int index) { return 1.0 / index; }
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Show a value.
+////////////////////////////////////////////////////////////////////////
+
+static void
+show_values (const SGPropertyNode * node)
+{
+  cout << "Bool: " << (node->getBoolValue() ? "true" : "false") << endl;
+  cout << "Int: " << node->getIntValue() << endl;
+  cout << "Float: " << node->getFloatValue() << endl;
+  cout << "Double: " << node->getDoubleValue() << endl;
+  cout << "String: " << node->getStringValue() << endl;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Test individual values.
+////////////////////////////////////////////////////////////////////////
+
+static void
+test_value ()
+{
+  SGPropertyNode * node;
+
+  cout << endl << "Value" << endl << endl;
+
+  //
+  // Test coercion for getters.
+  //
+
+  cout << "Testing coercion from bool (expect true)" << endl;
+  node = new SGPropertyNode;
+  node->setBoolValue(true);
+  show_values(node);
+  delete node;
+  cout << endl;
+
+  cout << "Testing coercion from int (expect 128)" << endl;
+  node = new SGPropertyNode;
+  node->setIntValue(128);
+  show_values(node);
+  delete node;
+  cout << endl;
+
+  cout << "Testing coercion from float (expect 1.0/3.0)" << endl;
+  node = new SGPropertyNode;
+  node->setFloatValue(1.0/3.0);
+  show_values(node);
+  delete node;
+  cout << endl;
+
+  cout << "Testing coercion from double (expect 1.0/3.0)" << endl;
+  node = new SGPropertyNode;
+  node->setDoubleValue(1.0/3.0);
+  show_values(node);
+  delete node;
+  cout << endl;
+
+  cout << "Testing coercion from string (expect 10e4)" << endl;
+  node = new SGPropertyNode;
+  node->setStringValue("10e4");
+  show_values(node);
+  delete node;
+  cout << endl;
+
+  cout << "Testing coercion from unspecified (expect -10e-4)" << endl;
+  node = new SGPropertyNode;
+  node->setUnspecifiedValue("-10e-4");
+  show_values(node);
+  delete node;
+  cout << endl;
+
+  //
+  // Test coercion for setters.
+  //
+
+  node = new SGPropertyNode;
+
+  cout << "Testing coercion to bool from bool (expect false)" << endl;
+  node->setBoolValue(false);
+  show_values(node);
+  cout << endl;
+
+  cout << "Testing coercion to bool from int (expect 1)" << endl;
+  node->setIntValue(1);
+  show_values(node);
+  cout << endl;
+
+  cout << "Testing coercion to bool from float (expect 1.1)" << endl;
+  node->setFloatValue(1.1);
+  show_values(node);
+  cout << endl;
+
+  cout << "Testing coercion to bool from double (expect 1.1)" << endl;
+  node->setDoubleValue(1.1);
+  show_values(node);
+  cout << endl;
+
+  cout << "Testing coercion to bool from string (expect 1e10)" << endl;
+  node->setStringValue("1e10");
+  show_values(node);
+  cout << endl;
+
+  cout << "Testing coercion to bool from unspecified (expect 1e10)" << endl;
+  node->setUnspecifiedValue("1e10");
+  show_values(node);
+  cout << endl;
+
+  // Test tying to a pointer.
+
+  static int myValue = 10;
+
+  cout << "Testing tying to a pointer (expect 10)" << endl;
+  if (!node->tie(SGRawValuePointer<int>(&myValue), false))
+    cout << "*** FAILED TO TIE VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  cout << "Changing base variable (expect -5)" << endl;
+  myValue = -5;
+  show_values(node);
+  if (!node->untie())
+    cout << "*** FAILED TO UNTIE VALUE!!!" << endl;
+  cout << endl;
+
+
+  // Test tying to static functions.
+
+  cout << "Create a new int value (expect 10)" << endl;
+  node->setIntValue(10);
+  show_values(node);
+  cout << endl;
+
+  cout << "Testing tying to static getter (expect 100)" << endl;
+  if (!node->tie(SGRawValueFunctions<int>(get100)))
+    cout << "*** FAILED TO TIE VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  cout << "Try changing value with no setter (expect 100)" << endl;
+  if (node->setIntValue(200))
+    cout << "*** setIntValue did not return false!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  cout << "Untie value (expect 100)" << endl;
+  if (!node->untie())
+    cout << "*** FAILED TO UNTIE VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  cout << "Try changing value (expect 200)" << endl;
+  if (!node->setIntValue(200))
+    cout << "*** setIntValue RETURNED FALSE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  // Test tying to indexed static functions.
+
+  cout << "Create a new int value (expect 10)" << endl;
+  node->setIntValue(10);
+  show_values(node);
+  cout << endl;
+
+  cout << "Testing tying to indexed static getter (0.3333...)" << endl;
+  if (!node->tie(SGRawValueFunctionsIndexed<double>(3, getNum)))
+    cout << "*** FAILED TO TIE VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  cout << "Untie value (expect 0.3333...)" << endl;
+  if (!node->untie())
+    cout << "*** FAILED TO UNTIE VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+
+  // Test methods.
+
+  cout << "Try tying to an object without defaults (expect 199)" << endl;
+  Stuff stuff;
+  SGRawValueMethods<class Stuff,float> tiedstuff(stuff,
+						 &Stuff::getStuff,
+						 &Stuff::setStuff);
+  if (!node->tie(tiedstuff, false))
+    cout << "*** FAILED TO TIE VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  cout << "Try untying from object (expect 199)" << endl;
+  if (!node->untie())
+    cout << "*** FAILED TO UNTIE VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  cout << "Try tying to an indexed method (expect 199)" << endl;
+  if (!node->tie(SGRawValueMethodsIndexed<class Stuff, float>
+		  (stuff, 2, &Stuff::getStuff, &Stuff::setStuff)))
+    cout << "*** FAILED TO TIE VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  node->untie();
+
+  cout << "Change value (expect 50)" << endl;
+  if (!node->setIntValue(50))
+    cout << "*** FAILED TO SET VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  cout << "Try tying to an object with defaults (expect 50)" << endl;
+  if (!node->tie(tiedstuff, true))
+    cout << "*** FAILED TO TIE VALUE!!!" << endl;
+  show_values(node);
+  cout << endl;
+
+  delete node;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Check property nodes.
+////////////////////////////////////////////////////////////////////////
+
+static void
+dump_node (const SGPropertyNode * node)
+{
+  writeProperties(cout, node, true);
+}
+
+static void
+test_property_nodes ()
+{
+  SGPropertyNode root;
+  cout << "Created root node " << root.getPath() << endl;
+
+  SGPropertyNode * child = root.getChild("foo", 0, true);
+
+  SGPropertyNode *grandchild = child->getChild("bar", 0, true);
+  grandchild->setDoubleValue(100);
+  grandchild = child->getChild("bar", 1, true);
+  grandchild->setDoubleValue(200);
+  grandchild = child->getChild("bar", 2, true);
+  grandchild->setDoubleValue(300);
+  grandchild = child->getChild("bar", 3, true);
+  grandchild->setDoubleValue(400);
+
+  child = root.getChild("hack", 0, true);
+
+  grandchild = child->getChild("bar", 0, true);
+  grandchild->setDoubleValue(100);
+  grandchild = child->getChild("bar", 3, true);
+  grandchild->setDoubleValue(200);
+  grandchild = child->getChild("bar", 1, true);
+  grandchild->setDoubleValue(300);
+  grandchild = child->getChild("bar", 2, true);
+  grandchild->setDoubleValue(400);
+  dump_node(&root);
+
+  cout << "Trying path (expect /foo[0]/bar[0])" << endl;
+  grandchild = root.getNode("/hack/../foo/./bar[0]");
+  cout << "Path is " << grandchild->getPath() << endl;
+  cout << endl;
+
+  cout << "Looking for all /hack[0]/bar children" << endl;
+  vector<SGPropertyNode_ptr> bar = child->getChildren("bar");
+  cout << "There are " << bar.size() << " matches" << endl;
+  for (int i = 0; i < (int)bar.size(); i++)
+    cout << bar[i]->getName() << '[' << bar[i]->getIndex() << ']' << endl;
+  cout << endl;
+
+  cout << "Testing addition of a totally empty node" << endl;
+  if (root.getNode("/a/b/c", true) == 0)
+    cerr << "** failed to create /a/b/c" << endl;
+  dump_node(&root);
+  cout << endl;
+}
+
+
+int main (int ac, char ** av)
+{
+  test_value();
+  test_property_nodes();
+
+  for (int i = 1; i < ac; i++) {
+    try {
+      cout << "Reading " << av[i] << endl;
+      SGPropertyNode root;
+      readProperties(av[i], &root);
+      writeProperties(cout, &root, true);
+      cout << endl;
+    } catch (string &message) {
+      cout << "Aborted with " << message << endl;
+    }
+  }
+
+  return 0;
+}