#include <simgear/compiler.h>
-#include <stdlib.h> // atof() atoi()
+#include <stdlib.h> // atof() atoi()
#include <simgear/sg_inlines.h>
#include <simgear/debug/logstream.hxx>
-#include <simgear/math/SGMath.hxx>
#include <simgear/misc/sg_path.hxx>
#include <simgear/xml/easyxml.hxx>
+#include <simgear/misc/ResourceManager.hxx>
#include "props.hxx"
#include "props_io.hxx"
+#include "vectorPropTemplates.hxx"
#include <iostream>
#include <fstream>
#include <string>
-#include <cstring> // strcmp()
+#include <cstring> // strcmp()
#include <vector>
#include <map>
#define DEFAULT_MODE (SGPropertyNode::READ|SGPropertyNode::WRITE)
+// Name of special node containing unused attributes
+const std::string ATTR = "_attr_";
+
-\f
////////////////////////////////////////////////////////////////////////
// Property list visitor, for XML parsing.
////////////////////////////////////////////////////////////////////////
State () : node(0), type(""), mode(DEFAULT_MODE), omit(false) {}
State (SGPropertyNode * _node, const char * _type, int _mode, bool _omit)
: node(_node), type(_type), mode(_mode), omit(_omit) {}
+ bool hasChildren() const
+ {
+ int n_children = node->nChildren();
+ return n_children > 1
+ || (n_children == 1 && node->getChild(0)->getNameString() != ATTR);
+ }
SGPropertyNode * node;
string type;
int mode;
/**
- * Check a yes/no flag, with default.
+ * Set/unset a yes/no flag.
*/
-static bool
-checkFlag (const char * flag, bool defaultState = true)
+static void
+setFlag( int& mode,
+ int mask,
+ const std::string& flag,
+ const sg_location& location )
{
- if (flag == 0)
- return defaultState;
- else if (!strcmp(flag, "y"))
- return true;
- else if (!strcmp(flag, "n"))
- return false;
- else {
+ if( flag == "y" )
+ mode |= mask;
+ else if( flag == "n" )
+ mode &= ~mask;
+ else
+ {
string message = "Unrecognized flag value '";
message += flag;
message += '\'';
// FIXME: add location info
- throw sg_io_exception(message, "SimGear Property Reader");
+ throw sg_io_exception(message, location, "SimGear Property Reader");
}
}
PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
{
const char * attval;
+ const sg_location location(getPath(), getLine(), getColumn());
if (_level == 0) {
if (strcmp(name, "PropertyList")) {
string message = "Root element name is ";
message += name;
message += "; expected PropertyList";
- throw sg_io_exception(message, "SimGear Property Reader");
+ throw sg_io_exception(message, location, "SimGear Property Reader");
}
- // Check for an include.
+ // Check for an include.
attval = atts.getValue("include");
if (attval != 0) {
- SGPath path(SGPath(_base).dir());
- path.append(attval);
try {
- readProperties(path.str(), _root, 0, _extended);
+ SGPath path = simgear::ResourceManager::instance()->findPath(attval, SGPath(_base).dir());
+ if (path.isNull())
+ {
+ string message ="Cannot open file ";
+ message += attval;
+ throw sg_io_exception(message, location,
+ "SimGear Property Reader");
+ }
+ readProperties(path.str(), _root, 0, _extended);
} catch (sg_io_exception &e) {
- setException(e);
+ setException(e);
}
}
else {
State &st = state();
- // Get the index.
+
+ // Get the index.
attval = atts.getValue("n");
int index = 0;
+ string strName(name);
if (attval != 0) {
index = atoi(attval);
- st.counters[name] = SG_MAX2(st.counters[name], index+1);
+ st.counters[strName] = SG_MAX2(st.counters[strName], index+1);
} else {
- index = st.counters[name];
- st.counters[name]++;
+ index = st.counters[strName];
+ st.counters[strName]++;
}
- // Got the index, so grab the node.
- SGPropertyNode * node = st.node->getChild(name, index, true);
+ // Got the index, so grab the node.
+ SGPropertyNode * node = st.node->getChild(strName, index, true);
if (!node->getAttribute(SGPropertyNode::WRITE)) {
SG_LOG(SG_INPUT, SG_ALERT, "Not overwriting write-protected property "
- << node->getPath(true));
+ << node->getPath(true) << "\n at " << location.asString());
node = &null;
}
- // Get the access-mode attributes,
- // but don't set yet (in case they
- // prevent us from recording the value).
- int mode = _default_mode;
-
- 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;
- attval = atts.getValue("userarchive");
- if (checkFlag(attval, false))
- mode |= SGPropertyNode::USERARCHIVE;
-
- // 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);
- }
+ // TODO use correct default mode (keep for now to match past behavior)
+ int mode = _default_mode | SGPropertyNode::READ | SGPropertyNode::WRITE;
+ int omit = false;
+ const char* type = 0;
+
+ SGPropertyNode* attr_node = NULL;
+
+ for(int i = 0; i < atts.size(); ++i)
+ {
+ const std::string att_name = atts.getName(i);
+ const std::string val = atts.getValue(i);
+
+ // Get the access-mode attributes,
+ // but don't set yet (in case they
+ // prevent us from recording the value).
+ if( att_name == "read" )
+ setFlag(mode, SGPropertyNode::READ, val, location);
+ else if( att_name == "write" )
+ setFlag(mode, SGPropertyNode::WRITE, val, location);
+ else if( att_name == "archive" )
+ setFlag(mode, SGPropertyNode::ARCHIVE, val, location);
+ else if( att_name == "trace-read" )
+ setFlag(mode, SGPropertyNode::TRACE_READ, val, location);
+ else if( att_name == "trace-write" )
+ setFlag(mode, SGPropertyNode::TRACE_WRITE, val, location);
+ else if( att_name == "userarchive" )
+ setFlag(mode, SGPropertyNode::USERARCHIVE, val, location);
+ else if( att_name == "preserve" )
+ setFlag(mode, SGPropertyNode::PRESERVE, val, location);
+
+ // Check for an alias.
+ else if( att_name == "alias" )
+ {
+ if( !node->alias(val) )
+ SG_LOG
+ (
+ SG_INPUT,
+ SG_ALERT,
+ "Failed to set alias to " << val << "\n at " << location.asString()
+ );
+ }
- // Check for an include.
- bool omit = false;
- attval = atts.getValue("include");
- if (attval != 0) {
- SGPath path(SGPath(_base).dir());
- path.append(attval);
- try {
- readProperties(path.str(), node, 0, _extended);
- } catch (sg_io_exception &e) {
- setException(e);
+ // Check for an include.
+ else if( att_name == "include" )
+ {
+ try
+ {
+ SGPath path = simgear::ResourceManager::instance()
+ ->findPath(val, SGPath(_base).dir());
+ if (path.isNull())
+ {
+ string message ="Cannot open file ";
+ message += val;
+ throw sg_io_exception(message, location, "SimGear Property Reader");
+ }
+ readProperties(path.str(), node, 0, _extended);
+ }
+ catch (sg_io_exception &e)
+ {
+ setException(e);
+ }
}
- attval = atts.getValue("omit-node");
- omit = checkFlag(attval, false);
- }
+ else if( att_name == "omit-node" )
+ setFlag(omit, 1, val, location);
+ else if( att_name == "type" )
+ {
+ type = atts.getValue(i);
+
+ // if a type is given and the node is tied,
+ // don't clear the value because
+ // clearValue() unties the property
+ if( !node->isTied() )
+ node->clearValue();
+ }
+ else if( att_name != "n" )
+ {
+ // Store all additional attributes in a special node named _attr_
+ if( !attr_node )
+ attr_node = node->getChild(ATTR, 0, true);
- const char *type = atts.getValue("type");
- if (type)
- node->clearValue();
+ attr_node->setUnspecifiedValue(att_name.c_str(), val.c_str());
+ }
+ }
push_state(node, type, mode, omit);
}
}
{
State &st = state();
bool ret;
+ const sg_location location(getPath(), getLine(), getColumn());
- // 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 there are no children and it's
+ // not an alias, then it's a leaf value.
+ if( !st.hasChildren() && !st.node->isAlias() )
+ {
if (st.type == "bool") {
if (_data == "true" || atoi(_data.c_str()) != 0)
- ret = st.node->setBoolValue(true);
+ ret = st.node->setBoolValue(true);
else
- ret = st.node->setBoolValue(false);
+ ret = st.node->setBoolValue(false);
} else if (st.type == "int") {
ret = st.node->setIntValue(atoi(_data.c_str()));
} else if (st.type == "long") {
string message = "Unrecognized data type '";
message += st.type;
message += '\'';
- // FIXME: add location information
- throw sg_io_exception(message, "SimGear Property Reader");
+ // FIXME: add location information
+ throw sg_io_exception(message, location, "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);
+ if( !ret )
+ SG_LOG
+ (
+ SG_INPUT,
+ SG_ALERT,
+ "readProperties: Failed to set " << st.node->getPath()
+ << " to value \"" << _data
+ << "\" with type " << st.type
+ << "\n at " << location.asString()
+ );
}
- // Set the access-mode attributes now,
- // once the value has already been
- // assigned.
+ // Set the access-mode attributes now,
+ // once the value has already been
+ // assigned.
st.node->setAttributes(st.mode);
if (st.omit) {
SGPropertyNode *dst = parent.node->getChild(name, index, true);
copyProperties(src, dst);
}
- parent.node->removeChild(st.node->getName(), st.node->getIndex(), false);
+ parent.node->removeChild(st.node->getName(), st.node->getIndex());
}
pop_state();
}
void
PropsVisitor::data (const char * s, int length)
{
- if (state().node->nChildren() == 0)
+ if( !state().hasChildren() )
_data.append(string(s, length));
}
}
-\f
////////////////////////////////////////////////////////////////////////
// Property list reader.
////////////////////////////////////////////////////////////////////////
throw visitor.getException();
}
-\f
+
////////////////////////////////////////////////////////////////////////
// Property list writer.
////////////////////////////////////////////////////////////////////////
case props::ALIAS:
case props::NONE:
return "unspecified";
+ default: // avoid compiler warning
+ break;
}
// keep the compiler from squawking
static void
-writeAtts (ostream &output, const SGPropertyNode * node, bool forceindex)
+writeAtts( std::ostream &output,
+ const SGPropertyNode* node,
+ bool forceindex,
+ const SGPropertyNode* attr = NULL )
{
int index = node->getIndex();
if (index != 0 || forceindex)
output << " n=\"" << index << '"';
+ if( attr )
+ for(int i = 0; i < attr->nChildren(); ++i)
+ {
+ output << ' ' << attr->getChild(i)->getName() << "=\"";
+
+ const std::string data = attr->getChild(i)->getStringValue();
+ for(int j = 0; j < (int)data.size(); ++j)
+ {
+ switch(data[j])
+ {
+ case '"':
+ output << "\\\"";
+ break;
+ case '\\':
+ output << "\\\\";
+ break;
+ default:
+ output << data[i];
+ break;
+ }
+ }
+
+ output << '"';
+ }
+
#if 0
if (!node->getAttribute(SGPropertyNode::READ))
output << " read=\"n\"";
static bool
-writeNode (ostream &output, const SGPropertyNode * node,
- bool write_all, int indent, SGPropertyNode::Attribute archive_flag)
+writeNode( std::ostream &output,
+ const SGPropertyNode * node,
+ bool write_all,
+ int indent,
+ SGPropertyNode::Attribute archive_flag )
{
- // Don't write the node or any of
- // its descendants unless it is
- // allowed to be archived.
+ // Don't write the node or any of
+ // its descendants unless it is
+ // allowed to be archived.
if (!write_all && !isArchivable(node, archive_flag))
- return true; // Everything's OK, but we won't write.
+ return true; // Everything's OK, but we won't write.
const string name = node->getName();
int nChildren = node->nChildren();
- bool node_has_value = false;
+ const SGPropertyNode* attr_node = node->getChild(ATTR, 0);
+ bool attr_written = false,
+ node_has_value = false;
- // If there is a literal value,
- // write it first.
+ // If there is a literal value,
+ // write it first.
if (node->hasValue() && (write_all || node->getAttribute(archive_flag))) {
doIndent(output, indent);
output << '<' << name;
- writeAtts(output, node, nChildren != 0);
+ writeAtts(output, node, nChildren != 0, attr_node);
+ attr_written = true;
if (node->isAlias() && node->getAliasTarget() != 0) {
output << " alias=\"" << node->getAliasTarget()->getPath()
- << "\"/>" << endl;
+ << "\"/>" << endl;
} else {
if (node->getType() != simgear::props::UNSPECIFIED)
- output << " type=\"" << getTypeName(node->getType()) << '"';
+ output << " type=\"" << getTypeName(node->getType()) << '"';
output << '>';
writeData(output, node->getStringValue());
output << "</" << name << '>' << endl;
node_has_value = true;
}
- // If there are children, write them next.
- if (nChildren > 0) {
+ // If there are children, write them next.
+ if( nChildren > (attr_node ? 1 : 0) )
+ {
doIndent(output, indent);
output << '<' << name;
- writeAtts(output, node, node_has_value);
+ writeAtts(output, node, node_has_value, attr_written ? attr_node : NULL);
output << '>' << endl;
- for (int i = 0; i < nChildren; i++)
- writeNode(output, node->getChild(i), write_all, indent + INDENT_STEP, archive_flag);
+ for(int i = 0; i < nChildren; i++)
+ {
+ if( node->getChild(i)->getNameString() != ATTR )
+ writeNode( output,
+ node->getChild(i),
+ write_all,
+ indent + INDENT_STEP,
+ archive_flag );
+ }
doIndent(output, indent);
output << "</" << name << '>' << endl;
}
bool write_all, SGPropertyNode::Attribute archive_flag)
{
SGPath path(file.c_str());
- path.create_dir(0777);
+ path.create_dir(0755);
ofstream output(file.c_str());
if (output.good()) {
}
}
+// Another variation, useful when called from gdb
+void
+writeProperties (const char* file, const SGPropertyNode * start_node)
+{
+ writeProperties(string(file), start_node, true);
+}
+
-\f
////////////////////////////////////////////////////////////////////////
// Copy properties from one tree to another.
////////////////////////////////////////////////////////////////////////
+bool
+copyPropertyValue(const SGPropertyNode *in, SGPropertyNode *out)
+{
+ using namespace simgear;
+ bool retval = true;
+
+ if (!in->hasValue()) {
+ return true;
+ }
+
+ switch (in->getType()) {
+ case props::BOOL:
+ if (!out->setBoolValue(in->getBoolValue()))
+ retval = false;
+ break;
+ case props::INT:
+ if (!out->setIntValue(in->getIntValue()))
+ retval = false;
+ break;
+ case props::LONG:
+ if (!out->setLongValue(in->getLongValue()))
+ retval = false;
+ break;
+ case props::FLOAT:
+ if (!out->setFloatValue(in->getFloatValue()))
+ retval = false;
+ break;
+ case props::DOUBLE:
+ if (!out->setDoubleValue(in->getDoubleValue()))
+ retval = false;
+ break;
+ case props::STRING:
+ if (!out->setStringValue(in->getStringValue()))
+ retval = false;
+ break;
+ case props::UNSPECIFIED:
+ if (!out->setUnspecifiedValue(in->getStringValue()))
+ retval = false;
+ break;
+ case props::VEC3D:
+ if (!out->setValue(in->getValue<SGVec3d>()))
+ retval = false;
+ break;
+ case props::VEC4D:
+ if (!out->setValue(in->getValue<SGVec4d>()))
+ retval = false;
+ break;
+ default:
+ if (in->isAlias())
+ break;
+ string message = "Unknown internal SGPropertyNode type";
+ message += in->getType();
+ throw sg_error(message, "SimGear Property Reader");
+ }
+
+ return retval;
+}
+
/**
* Copy one property tree to another.
*
copyProperties (const SGPropertyNode *in, SGPropertyNode *out)
{
using namespace simgear;
- bool retval = true;
-
- // First, copy the actual value,
- // if any.
- if (in->hasValue()) {
- switch (in->getType()) {
- case props::BOOL:
- if (!out->setBoolValue(in->getBoolValue()))
- retval = false;
- break;
- case props::INT:
- if (!out->setIntValue(in->getIntValue()))
- retval = false;
- break;
- case props::LONG:
- if (!out->setLongValue(in->getLongValue()))
- retval = false;
- break;
- case props::FLOAT:
- if (!out->setFloatValue(in->getFloatValue()))
- retval = false;
- break;
- case props::DOUBLE:
- if (!out->setDoubleValue(in->getDoubleValue()))
- retval = false;
- break;
- case props::STRING:
- if (!out->setStringValue(in->getStringValue()))
- retval = false;
- break;
- case props::UNSPECIFIED:
- if (!out->setUnspecifiedValue(in->getStringValue()))
- retval = false;
- break;
- case props::VEC3D:
- if (!out->setValue(in->getValue<SGVec3d>()))
- retval = false;
- break;
- case props::VEC4D:
- if (!out->setValue(in->getValue<SGVec4d>()))
- retval = false;
- break;
- default:
- if (in->isAlias())
- break;
- string message = "Unknown internal SGPropertyNode type";
- message += in->getType();
- throw sg_error(message, "SimGear Property Reader");
- }
+ bool retval = copyPropertyValue(in, out);
+ if (!retval) {
+ return false;
}
-
- // copy the attributes.
+
+ // copy the attributes.
out->setAttributes( in->getAttributes() );
- // Next, copy the children.
+ // 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;
+ SGPropertyNode * out_child = out->getChild(in_child->getNameString(),
+ in_child->getIndex(),
+ false);
+ if (!out_child)
+ {
+ out_child = out->getChild(in_child->getNameString(),
+ in_child->getIndex(),
+ true);
+ }
+
+ if (out_child && !copyProperties(in_child, out_child))
+ retval = false;
}
return retval;
}
+
+bool
+copyPropertiesWithAttribute(const SGPropertyNode *in, SGPropertyNode *out,
+ SGPropertyNode::Attribute attr)
+{
+ bool retval = copyPropertyValue(in, out);
+ if (!retval) {
+ return false;
+ }
+ out->setAttributes( in->getAttributes() );
+
+ // if attribute is set directly on this node, we don't require it on
+ // descendent nodes. (Allows setting an attribute on an entire sub-tree
+ // of nodes)
+ if ((attr != SGPropertyNode::NO_ATTR) && out->getAttribute(attr)) {
+ attr = SGPropertyNode::NO_ATTR;
+ }
+
+ int nChildren = in->nChildren();
+ for (int i = 0; i < nChildren; i++) {
+ const SGPropertyNode* in_child = in->getChild(i);
+ if ((attr != SGPropertyNode::NO_ATTR) && !isArchivable(in_child, attr))
+ continue;
+
+ SGPropertyNode* out_child = out->getChild(in_child->getNameString(),
+ in_child->getIndex(),
+ true);
+
+ bool ok = copyPropertiesWithAttribute(in_child, out_child, attr);
+ if (!ok) {
+ return false;
+ }
+ }// of children iteration
+
+ return true;
+}
+
// end of props_io.cxx
projects / simgear.git / blobdiff