parse.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <vector>
#include <map>

#include <archon/util/text.H>
#include <archon/util/unicode.H>

#include <archon/x3d/server/script.H>
#include <archon/x3d/server/parse.H>

using namespace std;

namespace Archon
{
  using namespace Utilities;

  namespace X3D
  {
    bool Parser::validateIdentifier(string s)
    {
      ustring t = Unicode::decodeUtf8(s);
      if(!t.size()) return false;
      for(unsigned i=0; i<t.size(); ++i)
      {
        uchar u = t[i];
        if(u >= 0x80) continue;
        if(u <= 0x20 ||
           i == 0 && '0' <= u && u <= '9' ||
           u == '"' || u == '#' || u == '\'' ||
           '+' <= u && u <= '.' ||               //  + , - .
           '[' <= u && u <= ']' ||               //  [ \ ]
           u == '{' || u == '}' || u == 0x7f)
          return false;
      }
      return true;
    }

    void Parser::addNamedNode(string name, Ref<NodeBase> node)
    {
      try
      {
        node->setName(name);
      }
      catch(NodeNameInUseException &)
      {
        warning("Attempt to reuse node name '" + name + "'");
      }
    }

    void Parser::addRootGroupChild(Ref<ChildNode> c, Time stamp)
    {
      rootGroup->add(GroupingNode::childrenField, c, stamp);
    }

    void Parser::addRoute(string sourceNodeName, string sourceFieldName,
                          string targetNodeName, string targetFieldName)
    {
      const FieldBase *sourceField = 0;
      const FieldBase *targetField = 0;

      bool skip = false;

      Ref<NodeBase> sourceNode = lookupNode(sourceNodeName);
      if(!sourceNode)
      {
        warning("Undefined source node name '" + sourceNodeName +
                "' (route ignored)");
        skip = true;
      }
      else
      {
        sourceField = sourceNode->lookupField(sourceFieldName);
        if(!sourceField)
        {
          warning("Source node type '" + sourceNode->getType()->getName() +
                  "' has no field named '" + sourceFieldName +
                  "' (route ignored)");
          skip = true;
        }
        else if(!sourceField->getIsEventSource())
        {
          warning(sourceNode->getType()->getName() + "." +
                  sourceField->getName() +
                  " cannot generate events (route ignored)");
          skip = true;
        }
      }

      Ref<NodeBase> targetNode = lookupNode(targetNodeName);
      if(!targetNode)
      {
        warning("Undefined target node name '" + targetNodeName +
                "' (route ignored)");
        skip = true;
      }
      else
      {
        targetField = targetNode->lookupField(targetFieldName);
        if(!targetField)
        {
          warning("Target node type '" + targetNode->getType()->getName() +
                  "' has no field named '" + targetFieldName +
                  "' (route ignored)");
          skip = true;
        }
        else if(!targetField->getIsEventTarget())
        {
          warning(targetNode->getType()->getName() + "." +
                  targetField->getName() +
                  " cannot receive events (route ignored)");
          skip = true;
        }
      }

      // Self reference
      if(sourceField && targetField &&
         sourceNode == targetNode && sourceField == targetField)
      {
        const string s = sourceNode->getName() + "." + sourceField->getName();
        warning("Illegal route, source field '" + s +
                "' and target field '" + s + "' is the same (route ignored)");
        skip = true;
      }

      const FieldType *fieldType = 0;

      // Type conformance
      if(sourceField && targetField)
      {
        fieldType = sourceField->getType();
        const FieldType *targetFieldType   = targetField->getType();

        if(fieldType != targetFieldType)
        {
          warning("Type mismatch, source field type is '" +
                  fieldType->getName() +
                  "' and target field type is '" +
                  targetFieldType->getName() + "' (route ignored)");
          skip = true;
        }
      
        if(const NodeFieldBase *sourceNodeField =
           dynamic_cast<const NodeFieldBase *>(sourceField))
        {
          const NodeFieldBase *targetNodeField =
            dynamic_cast<const NodeFieldBase *>(targetField);
          if(!sourceNodeField->getNodeType()->
             isDerivedFrom(targetNodeField->getNodeType()))
          {
            warning("Type mismatch, source field type is '" +
                    sourceNodeField->getNodeType()->getName() +
                    "' and target field type is '" +
                    targetNodeField->getNodeType()->getName() +
                    "' (route ignored)");
            skip = true;
          }
        }
      }

      if(skip) return;

      Route::add(sourceNode, sourceField, targetNode, targetField);

      /*
      logger->log("ROUTE:" + fieldType->getName() +
                  " " + sourceNode->getName() +
                  ":" + sourceNode->getType()->getName() +
                  "." + sourceField->getName() +
                  " TO " + targetNode->getName() +
                  ":" + targetNode->getType()->getName() +
                  "." + targetField->getName());
      */
    }


    int Parser::getNextCustomFieldIndex(Ref<CustomFieldNode> n)
    {
      return n->getNumberOfCustomFields();
    }

    void Parser::addScriptField(Ref<CustomFieldNode> n, Ref<CustomFieldBase> f)
    {
      if(!n->addCustomField(f))
        warning("Name of new field '" + f->getName() + "' clashes with "
                "existing fields of the " + n->getType()->getName() +
                " node (field ignored)");
    }
  }
}

---