gameswf_xml.cpp

一个开源的Flash 播放器,可以在Windows/Linux 上运行

// gameswf_xml.h      -- Rob Savoye <[e-mail]> 2005

// This source code has been donated to the Public Domain.  Do
// whatever you want with it.


#include <sys/types.h>
#include <sys/stat.h>

#include "gameswf_log.h"
#include "gameswf_action.h"
#include "gameswf_impl.h"
#include "gameswf_log.h"
#include "base/smart_ptr.h"
#include "gameswf_string.h"
#include "base/tu_config.h"

#ifdef HAVE_LIBXML

#include <unistd.h>
#include "gameswf_xml.h"
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/xmlreader.h>

namespace gameswf
{
  
  //#define DEBUG_MEMORY_ALLOCATION 1
  
array<as_object *> _xmlobjs;    // FIXME: hack alert

XMLAttr::XMLAttr()
{
#ifdef DEBUG_MEMORY_ALLOCATION
  log_msg("\t\tCreating XMLAttr data at %p \n", this);
#endif
  _name = 0;
  _value = 0;
}

XMLAttr::~XMLAttr()
{
#ifdef DEBUG_MEMORY_ALLOCATION
  log_msg("\t\tDeleting XMLAttr data %s at %p \n", this->_name, this);
#endif
  //log_msg("%s: %p \n", __FUNCTION__, this);
  if (_name) {
    delete _name;
  }
  if (_value) {
    delete _value;
  }  
}
  
XMLNode::XMLNode()
{
  //log_msg("%s: %p \n", __FUNCTION__, this);
#ifdef DEBUG_MEMORY_ALLOCATION
  log_msg("\tCreating XMLNode data at %p \n", this);
#endif
  _name = 0;
  _value = 0;
}

XMLNode::~XMLNode()
{
  int i;
  //log_msg("%s: %p \n", __FUNCTION__, this);
#ifdef DEBUG_MEMORY_ALLOCATION
  log_msg("\tDeleting XMLNode data %s at %p\n", this->_name, this);
#endif
  
  for (i=0; i<_children.size(); i++) {
//     if (_children[i]->_name) {
//       delete _children[i]->_name;
//     }
//     if (_children[i]->_value) {
//       delete _children[i]->_value;
//     }
    delete _children[i];
  }

  for (i=0; i<_attributes.size(); i++) {
    //     if (_attributes[i]->_name) {
//       delete _attributes[i]->_name;
//     }
//     if (_attributes[i]->_value) {
//       delete _attributes[i]->_value;
//     }
    delete _attributes[i];
  }

  _children.clear();
  _attributes.clear();

  if (_name) {
    delete _name;
  }
  if (_value) {
    delete _value;
  }
  //  _value.set_undefined();
}

XML::XML()
{
#ifdef DEBUG_MEMORY_ALLOCATION
  log_msg("Creating XML data at %p \n", this);
#endif
  //log_msg("%s: %p \n", __FUNCTION__, this);
  _loaded = false;
  _nodename = 0;
}


// Parse the ASCII XML string into memory
XML::XML(tu_string xml_in)
{
#ifdef DEBUG_MEMORY_ALLOCATION
  log_msg("Creating XML data at %p \n", this);
#endif
  //log_msg("%s: %p \n", __FUNCTION__, this);
  //memset(&_nodes, 0, sizeof(XMLNode));
  parseXML(xml_in);
}

XML::XML(struct node *childNode)
{
#ifdef DEBUG_MEMORY_ALLOCATION
  log_msg("\tCreating XML data at %p \n", this);
#endif
  //log_msg("%s: %p \n", __FUNCTION__, this);
}


XML::~XML()
{
#ifdef DEBUG_MEMORY_ALLOCATION
  if (this->_nodes) {
    log_msg("\tDeleting XML top level node %s at %p \n", this->_nodes->_name, this);
  } else {
    log_msg("\tDeleting XML top level node at %p \n", this);
  }
#endif
  
  //log_msg("%s: %p \n", __FUNCTION__, this);
  delete _nodes;
}

// Dispatch event handler(s), if any.
bool
XML::on_event(event_id id)
{
  // Keep m_as_environment alive during any method calls!
  //  smart_ptr<as_object_interface>	this_ptr(this);
  
#if 0
  // First, check for built-in event handler.
  as_value	method;
  if (get_event_handler(event_id(id), &method))
    {/
      // Dispatch.
      call_method0(method, &m_as_environment, this);
          return true;
    }
  
  // Check for member function.
  // In ActionScript 2.0, event method names are CASE SENSITIVE.
  // In ActionScript 1.0, event method names are CASE INSENSITIVE.
  const tu_string&	method_name = id.get_function_name();
  if (method_name.length() > 0)hostByNameGet
    {
      as_value	method;
      if (get_member(method_name, &method))
        {
          call_method0(method, &m_as_environment, this);
          return true;
        }
    }
#endif
  return false;
}

void
XML::on_event_load()
{
  // Do the events that (appear to) happen as the movie
  // loads.  frame1 tags and actions are executed (even
  // before advance() is called).  Then the onLoad event
  // is triggered.
  {
    on_event(event_id::LOAD);
  }
}

XMLNode*
XML::extractNode(xmlNodePtr node, bool mem)
{
  xmlAttrPtr attr;
  xmlNodePtr childnode;
  xmlChar *ptr = NULL;
  XMLNode *element, *child;
  int len;

  element = new XMLNode;
            
  //log_msg("Created new element for %s at %p\n", node->name, element);
  memset(element, 0, sizeof (XMLNode));

  //log_msg("%s: extracting node %s\n", __FUNCTION__, node->name);

  // See if we have any Attributes (properties)
  attr = node->properties;
  while (attr != NULL) {
    //log_msg("extractNode %s has property %s, value is %s\n",
    //          node->name, attr->name, attr->children->content);
    XMLAttr *attrib = new XMLAttr;
    len = memadjust(strlen(reinterpret_cast<const char *>(attr->name))+1);
    attrib->_name = (char *)new char[len];
    memset(attrib->_name, 0, len);
    strcpy(attrib->_name, reinterpret_cast<const char *>(attr->name));
    len = memadjust(strlen(reinterpret_cast<const char *>(attr->children->content))+1);
    attrib->_value = (char *)new char[len];
    memset(attrib->_value, 0, len);
    strcpy(attrib->_value, reinterpret_cast<const char *>(attr->children->content));
    //log_msg("\tPushing attribute %s for element %s has value %s\n",
    //        attr->name, node->name, attr->children->content);
    element->_attributes.push_back(attrib);
    attr = attr->next;
  }

  len = memadjust(strlen(reinterpret_cast<const char *>(node->name))+1);
  element->_name = (char *)new char[len];
  memset(element->_name, 0, len);
  strcpy(element->_name, reinterpret_cast<const char *>(node->name));
  //element->_name = reinterpret_cast<const char *>(node->name);
  if (node->children) {
    //ptr = node->children->content;
    ptr = xmlNodeGetContent(node->children);
    if (ptr != NULL) {
      if ((strchr((const char *)ptr, '\n') == 0) && (ptr[0] != 0))
      {
        if (node->children->content == NULL) {
          //log_msg("Node %s has no contents\n", node->name);
        } else {
          //log_msg("extractChildNode from text for %s has contents %s\n", node->name, ptr);
          len = memadjust(strlen(reinterpret_cast<const char *>(ptr))+1);
          element->_value = (char *)new char[len];
          memset(element->_value, 0, len);
          strcpy(element->_value, reinterpret_cast<const char *>(ptr));
          //element->_value = reinterpret_cast<const char *>(ptr);
        }
      }
      xmlFree(ptr);
    }
  }

  // See if we have any data (content)
  childnode = node->children;

  while (childnode != NULL) {
    if (childnode->type == XML_ELEMENT_NODE) {
      //log_msg("\t\t extracting node %s\n", childnode->name);
      child = extractNode(childnode, mem);
      //if (child->_value.get_type() != as_value::UNDEFINED) {
      if (child->_value != 0) {
        //log_msg("\tPushing childNode %s, value %s on element %p\n", child->_name.c_str(), child->_value.to_string(), element);
      } else {
        //log_msg("\tPushing childNode %s on element %p\n", child->_name.c_str(), element);
      }
      element->_children.push_back(child);
    }
    childnode = childnode->next;
  }

  return element;
}

// Read in an XML document from the specified source
bool
XML::parseDoc(xmlDocPtr document, bool mem)
{
  XMLNode *top;
  xmlNodePtr cur;

  if (document == 0) {
    log_error("Can't load XML file!\n");
    return false;
  }

  cur = xmlDocGetRootElement(document);
  
  if (cur != NULL) {
    top = extractNode(cur, mem);
    //_nodes->_name = reinterpret_cast<const char *>(cur->name);
    _nodes = top;
    //_node_data.push_back(top);
    //cur = cur->next;
  }  

  _loaded = true;
  return true;
}

// This reads in an XML file from disk and parses into into a memory resident
// tree which can be walked through later.
bool
XML::parseXML(tu_string xml_in)
{
  bool ret = true;
  //log_msg("Parse XML from memory: %s\n", xml_in.c_str());

  if (xml_in.size() == 0) {
    log_error("XML data is empty!\n");
    return false;
  }

#ifndef USE_DMALLOC
  //dump_memory_stats(__FUNCTION__, __LINE__, "before xmlParseMemory");
#endif

#ifdef USE_XMLREADER
  XMLNode *node = 0;
  xmlTextReaderPtr reader;

  reader = xmlReaderForMemory(xml_in.c_str(), xml_in.size(), NULL, NULL, 0);
  if (reader != NULL) {
    ret = true;
    while (ret) {
      ret = xmlTextReaderRead(reader);
      node = processNode(reader, node);
    }
    xmlFreeTextReader(reader);
    if (ret != false) {
      log_error("%s : couldn't parse\n", xml_in.c_str());
      return false;
    }
  } else {
    log_error("Unable to open %s\n", xml_in.c_str());
      return false;
  }
  xmlCleanupParser();
  return true;
#else
#ifdef USE_DOM
  xmlInitParser();
  
  _doc = xmlParseMemory(xml_in.c_str(), xml_in.size());
  if (_doc == 0) {
    log_error("Can't parse XML data!\n");
    return false;
  }
  ret = parseDoc(_doc, true);
  xmlCleanupParser();
  xmlFreeDoc(_doc);
  xmlMemoryDump();
#endif
#ifndef USE_DMALLOC
  //dump_memory_stats(__FUNCTION__, __LINE__, "after xmlParseMemory");
#endif

  return ret;
#endif
  
}

//     XML_READER_TYPE_NONE = 0
//     XML_READER_TYPE_ELEMENT = 1,
//     XML_READER_TYPE_ATTRIBUTE = 2,
//     XML_READER_TYPE_TEXT = 3,
//     XML_READER_TYPE_COMMENT = 8,
//     XML_READER_TYPE_SIGNIFICANT_WHITESPACE = 14,
//     XML_READER_TYPE_END_ELEMENT = 15,
//
// processNode:
// 2 1 IP 0
// processNode:
// 3 3 #text 0 192.168.2.50
// processNode:
// 2 15 IP 0
// processNode:
// 2 14 #text 0
const char *tabs[] = {
  "",
  "\t",
  "\t\t",
  "\t\t\t",
  "\t\t\t",
  "\t\t\t\t",
};

#ifdef USE_XMLREADER
// This is an xmlReader (SAX) based parser. For some reason it core dumps
// when compiled with GCC 3.x, but works just fine with GCC 4.x.
XMLNode*
XML::processNode(xmlTextReaderPtr reader, XMLNode *node)
{
  //log_msg("%s: node is %p\n", __FUNCTION__, node);
  static XMLNode *parent[10];
  xmlChar *name, *value;
  int   depth;
  XMLNode *element;
  //static int previous_depth = 0;
  xmlReaderTypes type;

  if (node == 0) {
    memset(parent, 0, sizeof(XMLNode *));
  }
  type = (xmlReaderTypes)xmlTextReaderNodeType(reader);
  depth = xmlTextReaderDepth(reader);
  value = xmlTextReaderValue(reader);
  name = xmlTextReaderName(reader);
  
  if (name == NULL)
    name = xmlStrdup(BAD_CAST "--");

#if 0
  printf("%d %d %s %d\n",
         depth,
         (int)type,
         name,
         xmlTextReaderIsEmptyElement(reader));  
#endif

  
  //child = node->_children[0];
  switch(xmlTextReaderNodeType(reader)) {
  case XML_READER_TYPE_NONE:
    break;
  case XML_READER_TYPE_SIGNIFICANT_WHITESPACE: // This is an empty text node
    //log_msg("\tWhitespace at depth %d\n", depth);
    break;
  case XML_READER_TYPE_END_ELEMENT:
     if (depth == 0) {          // This is the last node in the file
       element = node;
       break;
     }
     parent[depth]->_children.push_back(element);
//       log_msg("Pushing element %s on node %s\n", node->_name, parent[depth]->_name);
//       log_msg("End element at depth %d is %s for parent %s %p\n", depth, name,
//               parent[depth]->_name, parent[depth]);
     element = parent[depth];
    break;
  case XML_READER_TYPE_ELEMENT:
    element = new XMLNode;
//      log_msg("%sElement at depth %d is %s for node at %p\n", tabs[depth], depth, name, element);
    element->_name = (char *)new char[strlen(reinterpret_cast<const char *>(name))+1];
    memset(element->_name, 0, strlen(reinterpret_cast<const char *>(name))+1);
    strcpy(element->_name, reinterpret_cast<const char *>(name));
    if (node == 0) {
      _nodes = element;
      parent[0] = element;