2 #include <simgear/compiler.h>
4 #include <stdlib.h> // atof() atoi()
6 #include <simgear/sg_inlines.h>
7 #include <simgear/debug/logstream.hxx>
8 #include <simgear/misc/sg_path.hxx>
9 #include <simgear/xml/easyxml.hxx>
12 #include "props_io.hxx"
20 SG_USING_STD(istream);
21 SG_USING_STD(ifstream);
22 SG_USING_STD(ostream);
23 SG_USING_STD(ofstream);
28 #define DEFAULT_MODE (SGPropertyNode::READ|SGPropertyNode::WRITE)
32 ////////////////////////////////////////////////////////////////////////
33 // Property list visitor, for XML parsing.
34 ////////////////////////////////////////////////////////////////////////
36 class PropsVisitor : public XMLVisitor
40 PropsVisitor (SGPropertyNode * root, const string &base)
41 : _root(root), _level(0), _base(base), _hasException(false) {}
43 virtual ~PropsVisitor () {}
47 void startElement (const char * name, const XMLAttributes &atts);
48 void endElement (const char * name);
49 void data (const char * s, int length);
50 void warning (const char * message, int line, int column);
52 bool hasException () const { return _hasException; }
53 sg_io_exception &getException () { return _exception; }
54 void setException (const sg_io_exception &exception) {
55 _exception = exception;
63 State () : node(0), type(""), mode(DEFAULT_MODE) {}
64 State (SGPropertyNode * _node, const char * _type, int _mode)
65 : node(_node), type(_type), mode(_mode) {}
66 SGPropertyNode * node;
69 map<string,int> counters;
72 State &state () { return _state_stack[_state_stack.size() - 1]; }
74 void push_state (SGPropertyNode * node, const char * type, int mode) {
76 _state_stack.push_back(State(node, "unspecified", mode));
78 _state_stack.push_back(State(node, type, mode));
84 _state_stack.pop_back();
89 SGPropertyNode * _root;
91 vector<State> _state_stack;
93 sg_io_exception _exception;
98 PropsVisitor::startXML ()
101 _state_stack.resize(0);
105 PropsVisitor::endXML ()
108 _state_stack.resize(0);
113 * Check a yes/no flag, with default.
116 checkFlag (const char * flag, bool defaultState = true)
120 else if (!strcmp(flag, "y"))
122 else if (!strcmp(flag, "n"))
125 string message = "Unrecognized flag value '";
128 // FIXME: add location info
129 throw sg_io_exception(message, "SimGear Property Reader");
134 PropsVisitor::startElement (const char * name, const XMLAttributes &atts)
139 if (strcmp(name, "PropertyList")) {
140 string message = "Root element name is ";
142 message += "; expected PropertyList";
143 throw sg_io_exception(message, "SimGear Property Reader");
146 // Check for an include.
147 attval = atts.getValue("include");
149 SGPath path(SGPath(_base).dir());
152 readProperties(path.str(), _root);
153 } catch (sg_io_exception &e) {
158 push_state(_root, "", DEFAULT_MODE);
164 attval = atts.getValue("n");
167 index = atoi(attval);
168 st.counters[name] = SG_MAX2(st.counters[name], index+1);
170 index = st.counters[name];
174 // Got the index, so grab the node.
175 SGPropertyNode * node = st.node->getChild(name, index, true);
177 // Get the access-mode attributes,
178 // but don't set yet (in case they
179 // prevent us from recording the value).
182 attval = atts.getValue("read");
183 if (checkFlag(attval, true))
184 mode |= SGPropertyNode::READ;
185 attval = atts.getValue("write");
186 if (checkFlag(attval, true))
187 mode |= SGPropertyNode::WRITE;
188 attval = atts.getValue("archive");
189 if (checkFlag(attval, false))
190 mode |= SGPropertyNode::ARCHIVE;
191 attval = atts.getValue("trace-read");
192 if (checkFlag(attval, false))
193 mode |= SGPropertyNode::TRACE_READ;
194 attval = atts.getValue("trace-write");
195 if (checkFlag(attval, false))
196 mode |= SGPropertyNode::TRACE_WRITE;
198 // Check for an alias.
199 attval = atts.getValue("alias");
201 if (!node->alias(attval))
202 SG_LOG(SG_INPUT, SG_ALERT, "Failed to set alias to " << attval);
205 // Check for an include.
206 attval = atts.getValue("include");
208 SGPath path(SGPath(_base).dir());
211 readProperties(path.str(), node);
212 } catch (sg_io_exception &e) {
217 const char *type = atts.getValue("type");
220 push_state(node, type, mode);
225 PropsVisitor::endElement (const char * name)
230 // If there are no children and it's
231 // not an alias, then it's a leaf value.
232 if (st.node->nChildren() == 0 && !st.node->isAlias()) {
233 if (st.type == "bool") {
234 if (_data == "true" || atoi(_data.c_str()) != 0)
235 ret = st.node->setBoolValue(true);
237 ret = st.node->setBoolValue(false);
238 } else if (st.type == "int") {
239 ret = st.node->setIntValue(atoi(_data.c_str()));
240 } else if (st.type == "long") {
241 ret = st.node->setLongValue(strtol(_data.c_str(), 0, 0));
242 } else if (st.type == "float") {
243 ret = st.node->setFloatValue(atof(_data.c_str()));
244 } else if (st.type == "double") {
245 ret = st.node->setDoubleValue(strtod(_data.c_str(), 0));
246 } else if (st.type == "string") {
247 ret = st.node->setStringValue(_data.c_str());
248 } else if (st.type == "unspecified") {
249 ret = st.node->setUnspecifiedValue(_data.c_str());
251 string message = "Unrecognized data type '";
254 // FIXME: add location information
255 throw sg_io_exception(message, "SimGear Property Reader");
258 SG_LOG(SG_INPUT, SG_ALERT, "readProperties: Failed to set "
259 << st.node->getPath() << " to value \""
260 << _data << "\" with type " << st.type);
263 // Set the access-mode attributes now,
264 // once the value has already been
266 st.node->setAttributes(st.mode);
272 PropsVisitor::data (const char * s, int length)
274 if (state().node->nChildren() == 0)
275 _data.append(string(s, length));
279 PropsVisitor::warning (const char * message, int line, int column)
281 SG_LOG(SG_INPUT, SG_ALERT, "readProperties: warning: "
282 << message << " at line " << line << ", column " << column);
287 ////////////////////////////////////////////////////////////////////////
288 // Property list reader.
289 ////////////////////////////////////////////////////////////////////////
293 * Read properties from an input stream.
295 * @param input The input stream containing an XML property file.
296 * @param start_node The root node for reading properties.
297 * @param base A base path for resolving external include references.
298 * @return true if the read succeeded, false otherwise.
301 readProperties (istream &input, SGPropertyNode * start_node,
304 PropsVisitor visitor(start_node, base);
305 readXML(input, visitor, base);
306 if (visitor.hasException())
307 throw visitor.getException();
312 * Read properties from a file.
314 * @param file A string containing the file path.
315 * @param start_node The root node for reading properties.
316 * @return true if the read succeeded, false otherwise.
319 readProperties (const string &file, SGPropertyNode * start_node)
321 PropsVisitor visitor(start_node, file);
322 readXML(file, visitor);
323 if (visitor.hasException())
324 throw visitor.getException();
329 * Read properties from an in-memory buffer.
331 * @param buf A character buffer containing the xml data.
332 * @param size The size/length of the buffer in bytes
333 * @param start_node The root node for reading properties.
334 * @return true if the read succeeded, false otherwise.
336 void readProperties (const char *buf, const int size,
337 SGPropertyNode * start_node)
339 PropsVisitor visitor(start_node, "");
340 readXML(buf, size, visitor);
341 if (visitor.hasException())
342 throw visitor.getException();
346 ////////////////////////////////////////////////////////////////////////
347 // Property list writer.
348 ////////////////////////////////////////////////////////////////////////
350 #define INDENT_STEP 2
353 * Return the type name.
356 getTypeName (SGPropertyNode::Type type)
359 case SGPropertyNode::UNSPECIFIED:
360 return "unspecified";
361 case SGPropertyNode::BOOL:
363 case SGPropertyNode::INT:
365 case SGPropertyNode::LONG:
367 case SGPropertyNode::FLOAT:
369 case SGPropertyNode::DOUBLE:
371 case SGPropertyNode::STRING:
373 case SGPropertyNode::ALIAS:
374 case SGPropertyNode::NONE:
375 return "unspecified";
378 // keep the compiler from squawking
379 return "unspecified";
384 * Escape characters for output.
387 writeData (ostream &output, const string &data)
389 for (int i = 0; i < (int)data.size(); i++) {
408 doIndent (ostream &output, int indent)
410 while (indent-- > 0) {
417 writeAtts (ostream &output, const SGPropertyNode * node)
419 int index = node->getIndex();
422 output << " n=\"" << index << '"';
425 if (!node->getAttribute(SGPropertyNode::READ))
426 output << " read=\"n\"";
428 if (!node->getAttribute(SGPropertyNode::WRITE))
429 output << " write=\"n\"";
431 if (node->getAttribute(SGPropertyNode::ARCHIVE))
432 output << " archive=\"y\"";
439 * Test whether a node is archivable or has archivable descendants.
442 isArchivable (const SGPropertyNode * node)
444 // FIXME: it's inefficient to do this all the time
445 if (node->getAttribute(SGPropertyNode::ARCHIVE))
448 int nChildren = node->nChildren();
449 for (int i = 0; i < nChildren; i++)
450 if (isArchivable(node->getChild(i)))
458 writeNode (ostream &output, const SGPropertyNode * node,
459 bool write_all, int indent)
461 // Don't write the node or any of
462 // its descendants unless it is
463 // allowed to be archived.
464 if (!write_all && !isArchivable(node))
465 return true; // Everything's OK, but we won't write.
467 const string name = node->getName();
468 int nChildren = node->nChildren();
470 // If there is a literal value,
472 if (node->hasValue() && (write_all || node->getAttribute(SGPropertyNode::ARCHIVE))) {
473 doIndent(output, indent);
474 output << '<' << name;
475 writeAtts(output, node);
476 if (node->isAlias() && node->getAliasTarget() != 0) {
477 output << " alias=\"" << node->getAliasTarget()->getPath()
480 if (node->getType() != SGPropertyNode::UNSPECIFIED)
481 output << " type=\"" << getTypeName(node->getType()) << '"';
483 writeData(output, node->getStringValue());
484 output << "</" << name << '>' << endl;
488 // If there are children, write them next.
490 doIndent(output, indent);
491 output << '<' << name;
492 writeAtts(output, node);
493 output << '>' << endl;
494 for (int i = 0; i < nChildren; i++)
495 writeNode(output, node->getChild(i), write_all, indent + INDENT_STEP);
496 doIndent(output, indent);
497 output << "</" << name << '>' << endl;
505 writeProperties (ostream &output, const SGPropertyNode * start_node,
508 int nChildren = start_node->nChildren();
510 output << "<?xml version=\"1.0\"?>" << endl << endl;
511 output << "<PropertyList>" << endl;
513 for (int i = 0; i < nChildren; i++) {
514 writeNode(output, start_node->getChild(i), write_all, INDENT_STEP);
517 output << "</PropertyList>" << endl;
522 writeProperties (const string &file, const SGPropertyNode * start_node,
525 ofstream output(file.c_str());
527 writeProperties(output, start_node, write_all);
529 throw sg_io_exception("Cannot open file", sg_location(file));
535 ////////////////////////////////////////////////////////////////////////
536 // Copy properties from one tree to another.
537 ////////////////////////////////////////////////////////////////////////
541 * Copy one property tree to another.
543 * @param in The source property tree.
544 * @param out The destination property tree.
545 * @return true if all properties were copied, false if some failed
546 * (for example, if the property's value is tied read-only).
549 copyProperties (const SGPropertyNode *in, SGPropertyNode *out)
553 // First, copy the actual value,
555 if (in->hasValue()) {
556 switch (in->getType()) {
557 case SGPropertyNode::BOOL:
558 if (!out->setBoolValue(in->getBoolValue()))
561 case SGPropertyNode::INT:
562 if (!out->setIntValue(in->getIntValue()))
565 case SGPropertyNode::LONG:
566 if (!out->setLongValue(in->getLongValue()))
569 case SGPropertyNode::FLOAT:
570 if (!out->setFloatValue(in->getFloatValue()))
573 case SGPropertyNode::DOUBLE:
574 if (!out->setDoubleValue(in->getDoubleValue()))
577 case SGPropertyNode::STRING:
578 if (!out->setStringValue(in->getStringValue()))
581 case SGPropertyNode::UNSPECIFIED:
582 if (!out->setUnspecifiedValue(in->getStringValue()))
588 string message = "Unknown internal SGPropertyNode type";
589 message += in->getType();
590 throw sg_error(message, "SimGear Property Reader");
594 // copy the attributes.
595 out->setAttributes( in->getAttributes() );
597 // Next, copy the children.
598 int nChildren = in->nChildren();
599 for (int i = 0; i < nChildren; i++) {
600 const SGPropertyNode * in_child = in->getChild(i);
601 SGPropertyNode * out_child = out->getChild(in_child->getName(),
602 in_child->getIndex(),
604 if (!copyProperties(in_child, out_child))
611 // end of props_io.cxx