gameswf_xml.cpp

一个开源的嵌入式flash播放器的源代码

    } else {
      parent[depth] = node;
      parent[depth+1] = node;
    }
    //  xmlTextReaderAttributeCount(reader);
    if (xmlTextReaderHasAttributes(reader)) {
      // log_msg("Has Attributes!\n");
      xmlTextReaderMoveToFirstAttribute(reader);
      processNode(reader, element);
      while(xmlTextReaderMoveToNextAttribute(reader)) {
        processNode(reader, element);
      }
    }
    break;
  case XML_READER_TYPE_TEXT:
    element = node;
//      log_msg("%sValue at depth %d is \"%s\" for node at %p\n", tabs[depth], depth, value, element);
    element->_value = (char *)new char[strlen(reinterpret_cast<const char *>(value))+1];
    memset(element->_value, 0, strlen(reinterpret_cast<const char *>(value))+1);
    strcpy(element->_value, reinterpret_cast<const char *>(value));
    break;
  case XML_READER_TYPE_ATTRIBUTE:
    element = node;
    XMLAttr *attrib = new XMLAttr;
    attrib->_name = (char *)new char[strlen(reinterpret_cast<const char *>(name))+1];
    memset(attrib->_name, 0, strlen(reinterpret_cast<const char *>(name))+1);
    strcpy(attrib->_name, reinterpret_cast<const char *>(name));
    attrib->_value = (char *)new char[strlen(reinterpret_cast<const char *>(value))+1];
    memset(attrib->_value, 0, strlen(reinterpret_cast<const char *>(value))+1);
    strcpy(attrib->_value, reinterpret_cast<const char *>(value));
//     log_msg("%sPushing attribute %s, value \"%s\" for node %s\n", tabs[depth], name, value, element->_name);
    element->_attributes.push_back(attrib);
    break;
  default:   // FIXME: why does this break GCC 3.3.3 but not 3.4.3 ?
    log_error("Unsupported XML type %d\n!", type);
    break;
  };

  xmlFree(name);
  if (value != NULL) {
    xmlFree(value);
  }
  //previous_depth = depth;
  return element;
}
#endif

// This reads in an XML file from disk and parses into into a memory resident
// tree which can be walked through later.
bool
XML::load(const char *filespec)
{
  bool ret = true;
  log_msg("Load disk XML file: %s\n", filespec);
  
  //log_msg("%s: mem is %d\n", __FUNCTION__, mem);

#ifdef USE_XMLREADER
  XMLNode *node = 0;
  xmlTextReaderPtr reader;  
  
  reader = xmlNewTextReaderFilename(filespec);
  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", filespec);
      return false;
    }
  } else {
    log_error("Unable to open %s\n", filespec);
      return false;
  }
  xmlCleanupParser();
  return true;
#else
#ifdef USE_DOM
  xmlInitParser();
  _doc = xmlParseFile(filespec);
  if (_doc == 0) {
    log_error("Can't load XML file: %s!\n", filespec);
    return false;
  }
  ret = parseDoc(_doc, false);
  xmlCleanupParser();
  xmlFreeDoc(_doc);
  xmlMemoryDump();
  return true;
#else
#error "You have to enable either a DOM or an xmlReader XML parser"
#endif
#endif
}

bool
XML::onLoad()
{
  log_msg("%s: FIXME: onLoad Default event handler\n", __FUNCTION__);

  return(_loaded);
}

XMLNode *
XML::operator [] (int x) {
  log_msg("%s:\n", __FUNCTION__);

  return _nodes->_children[x];
}

void
XML::cleanupStackFrames(XMLNode *xml)
{
}

as_object *
XML::setupFrame(as_object *obj, XMLNode *xml, bool mem)
{
  int           child, i;
  const char    *nodename;
  //const char    *nodevalue;
  //AS_value      nodevalue;
  int           length;
  as_value      inum;
  XMLNode       *childnode;
  xmlnode_as_object *xmlchildnode_obj;
  xmlattr_as_object* attr_obj;

  //log_msg("\t%s: processing node %s for object %p, mem is %d\n", __FUNCTION__, xml->_name, obj, mem);
  
  // Get the data for this node
  nodename   = xml->_name;
  //nodename   = xml->_name.c_str();
  //nodevalue  = xml->_value;
  length     = xml->length();

  // Set these members in the top level object passed in. This are used
  // primarily by the disk based XML parser, where at least in all my current
  // test cases this is referenced with firstChild first, then nodeName and
  // childNodes.
  obj->set_member("nodeName",           nodename);
  obj->set_member("length",             length);
  if (xml->_value != 0) {
    obj->set_member("nodeValue",        xml->_value);
    //log_msg("\tnodevalue for %s is: %s\n", nodename, xml->_value);
  } else {
    obj->set_member("nodeValue", as_value::UNDEFINED);
  }

//   if (nodevalue.get_type() != as_value::UNDEFINED) {
//     obj->set_member("nodeValue",        nodevalue.to_string());
//     log_msg("\tnodevalue for %s is: %s\n", nodename, nodevalue.to_string());
//   } else {
//     // If there is no value, we want to define it as an empty
//     // string.
//     obj->set_member("nodeValue", "");
//   }

  
  // Process the attributes, if any
  if (xml->_attributes.size() == 0) {
    //log_msg("\t\tNo attributes for node %s, created empty object at %p\n", nodename, attr_obj);
//     log_msg("\t\tNo attributes for node %s\n", nodename);
  } else {
    attr_obj = new xmlattr_as_object;
    for (i=0; i<xml->_attributes.size(); i++) {
      attr_obj->set_member(xml->_attributes[i]->_name, xml->_attributes[i]->_value);
//        log_msg("\t\tAdding attribute as member %s, value is %s to node %s (%p)\n",
//                xml->_attributes[i]->_name,
//                xml->_attributes[i]->_value, nodename, obj);
    }
    obj->set_member("attributes", attr_obj);
  }

  //xml->_attributes.resize(0);
  //obj->set_member("attributes", attr_obj);

  // Process the children, if there are any
  if (length) {
    //log_msg("\tProcessing %d children nodes for %s\n", length, nodename);
    inum = 0;
    for (child=0; child<length; child++) {
      // Create a new AS object for this node's children
      xmlchildnode_obj = new xmlnode_as_object;
      // When parsing XML from memory, the test movies I have expect the firstChild
      // to be the first element of the array instead.
      if (mem) {
        childnode = xml;
        //obj->set_member(inum.to_string(), obj);
        //inum += 1;
        //childnode = xml->_children[child];
      } else {
        childnode = xml->_children[child];
      }
      setupFrame(xmlchildnode_obj, childnode, false); // setup child node
      obj->set_member(inum.to_string(), xmlchildnode_obj);
      inum += 1;
    }
  } else {
    //log_msg("\tNode %s has no children\n", nodename);
  }  

  return obj;
}
  
//
// Callbacks. These are the wrappers for the C++ functions so they'll work as
// callbacks from within gameswf.
//
void
xml_load(const fn_call& fn)
{
  as_value	method;
  as_value	val;
  bool          ret;
  struct stat   stats;


  //log_msg("%s:\n", __FUNCTION__);
  
  xml_as_object *xml_obj = (xml_as_object*)fn.this_ptr;
  
  assert(ptr);
  const tu_string filespec = fn.env->bottom(fn.first_arg_bottom_index).to_string();

  // If the file doesn't exist, don't try to do anything.
  if (stat(filespec.c_str(), &stats) < 0) {
    fprintf(stderr, "ERROR: doesn't exist.%s\n", filespec.c_str());
    fn.result->set(false);
    return;
  }
  
  // Set the argument to the function event handler based on whether the load
  // was successful or failed.
  ret = xml_obj->obj.load(filespec);
  fn.result->set(ret);

  if (ret == false) {
    return;
  }
    
  //env->bottom(first_arg) = ret;
  array<with_stack_entry> with_stack;
  array<with_stack_entry> dummy_stack;
  //  struct node *first_node = ptr->obj.firstChildGet();
  
  //const char *name = ptr->obj.nodeNameGet();

  if (xml_obj->obj.hasChildNodes() == false) {
    log_error("%s: No child nodes!\n", __FUNCTION__);
  }  
  xml_obj->obj.setupFrame(xml_obj, xml_obj->obj.firstChild(), false);
  
#if 1
  if (fn.this_ptr->get_member("onLoad", &method)) {
    //    log_msg("FIXME: Found onLoad!\n");
    fn.env->set_variable("success", true, 0);
    fn.env->bottom(fn.first_arg_bottom_index) = true;
    as_c_function_ptr	func = method.to_c_function();
    if (func)
      {
        // It's a C function.  Call it.
        log_msg("Calling C function for onLoad\n");
        (*func)(fn_call(&val, xml_obj, fn.env, fn.nargs, fn.first_arg_bottom_index)); // was this_ptr instead of node
      }
    else if (as_as_function* as_func = method.to_as_function())
      {
        // It's an ActionScript function.  Call it.
        log_msg("Calling ActionScript function for onLoad\n");
        (*as_func)(fn_call(&val, xml_obj, fn.env, fn.nargs, fn.first_arg_bottom_index)); // was this_ptr instead of node
      } else {
        log_error("error in call_method(): method is not a function\n");
      }
  } else {
    log_msg("Couldn't find onLoad event handler, setting up callback\n");
    // ptr->set_event_handler(event_id::XML_LOAD, (as_c_function_ptr)&xml_onload);
  }
#else
  xml_obj->set_event_handler(event_id::XML_LOAD, &xml_onload);

#endif

  fn.result->set(true);
}

// This executes the event handler for XML::XML_LOAD if it's been defined,
// and the XML file has loaded sucessfully.
void
xml_onload(const fn_call& fn)
{
  //log_msg("%s:\n", __FUNCTION__);
    
  as_value	method;
  as_value      val;
  static bool first = true;     // This event handler should only be executed once.
  array<with_stack_entry>	empty_with_stack;
  xml_as_object*	ptr = (xml_as_object*) (as_object*) fn.this_ptr;
  assert(ptr);
  
  if ((ptr->obj.loaded()) && (first)) {
    // env->set_variable("success", true, 0);
    //as_value bo(true);
    //env->push_val(bo);

    first = false;
    log_msg("The XML file has been loaded successfully!\n");
    // ptr->on_event(event_id::XML_LOAD);
    //env->set_variable("success", true, 0);
    //env->bottom(0) = true;
    
    if (fn.this_ptr->get_member("onLoad", &method)) {
      // log_msg("FIXME: Found onLoad!\n");
      as_c_function_ptr	func = method.to_c_function();
      if (func)
        {
          // It's a C function.  Call it.
          log_msg("Calling C function for onLoad\n");
          (*func)(fn_call(&val, fn.this_ptr, fn.env, 0, 0));
        }
      else if (as_as_function* as_func = method.to_as_function())
        {
          // It's an ActionScript function.  Call it.
          log_msg("Calling ActionScript function for onLoad\n");
        (*as_func)(fn_call(&val, fn.this_ptr, fn.env, 0, 0));
        }
      else
        {
          log_error("error in call_method(): method is not a function\n");
        }    
    } else {
      log_msg("FIXME: Couldn't find onLoad!\n");
    }
  }
      
  fn.result->set(&val);
}

// This is the default event handler, and is usually redefined in the SWF script
void
xml_ondata(const fn_call& fn)
{
  log_msg("%s:\n", __FUNCTION__);
    
  as_value	method;
  as_value	val;
  static bool first = true;     // FIXME: ugly hack!
  
  xml_as_object*	ptr = (xml_as_object*)fn.this_ptr;
  assert(ptr);
  
  if ((ptr->obj.loaded()) && (first)) {
    if (fn.this_ptr->get_member("onData", &method)) {
      log_msg("FIXME: Found onData!\n");
      as_c_function_ptr	func = method.to_c_function();
      fn.env->set_variable("success", true, 0);
      if (func)
        {
          // It's a C function.  Call it.
          log_msg("Calling C function for onData\n");
          (*func)(fn_call(&val, fn.this_ptr, fn.env, 0, 0));
      }
      else if (as_as_function* as_func = method.to_as_function())
        {
          // It's an ActionScript function.  Call it.
          log_msg("Calling ActionScript function for onData\n");
          (*as_func)(fn_call(&val, fn.this_ptr, fn.env, 0, 0));
        }
      else
        {
          log_error("error in call_method(): method is not a function\n");
        }    
    } else {
      log_msg("FIXME: Couldn't find onData!\n");
    }
  }

  fn.result->set(&val);
}

void
xml_new(const fn_call& fn)
{
  as_value      inum;
  xml_as_object *xml_obj;
  //const char    *data;
  
  //log_msg("%s: nargs=%d\n", __FUNCTION__, nargs);
  
  if (fn.nargs > 0) {
    if (fn.env->top(0).get_type() == as_value::STRING) {
      xml_obj = new xml_as_object;
      //log_msg("\tCreated New XML object at %p\n", xml_obj);
      tu_string datain = fn.env->top(0).to_tu_string();
      xml_obj->obj.parseXML(datain);
      //log_msg("*** Start setting up the stack frames ***\n");
      xml_obj->obj.setupFrame(xml_obj, xml_obj->obj.firstChild(), true);
      //xml_obj->obj.clear();
      //delete xml_obj->obj.firstChild();
    } else {
      xml_as_object*	xml_obj = (xml_as_object*)fn.env->top(0).to_object();
      //log_msg("\tCloned the XML object at %p\n", xml_obj);
      //result->set(xml_obj);
      fn.result->set_as_object_interface(xml_obj);
      return;
    }
  } else {
    xml_obj = new xml_as_object;
    //log_msg("\tCreated New XML object at %p\n", xml_obj);
    xml_obj->set_member("load", &xml_load);
    xml_obj->set_member("loaded", &xml_loaded);
  }

  fn.result->set_as_object_interface(xml_obj);
}

//
// SWF Property of this class. These are "accessors" into the private data
// of the class.
//

// determines whether the document-loading process initiated by the XML.load()
// call has completed. If the process completes successfully, the method
// returns true; otherwise, it returns false.
void
xml_loaded(const fn_call& fn)
{
  as_value	method;
  as_value	val;

  log_msg("%s:\n", __FUNCTION__);
    
  xml_as_object*	ptr = (xml_as_object*) (as_object*) fn.this_ptr;
  assert(ptr);
  tu_string filespec = fn.env->bottom(fn.first_arg_bottom_index).to_string();
  fn.result->set(ptr->obj.loaded());
}

int
memadjust(int x)
{
  return (x + (4 - x % 4));
}


} // end of gameswf namespace


// HAVE_LIBXML
#endif