mxml_node * node_identify( void * doc, const mxml_char_t * str, parsing_context *ctx )
{
mxml_node * doc_node = (mxml_node *)doc;
mxml_node * ident_node = NULL;
UNUSED_ARG( ctx );
if ( !doc_node )
return NULL;
if ( is_declaration ( str ) )
ident_node = create_declaration( doc_node );
else if ( is_comment( str ) )
ident_node = create_comment( doc_node );
else if ( is_unknown( str ) )
ident_node = create_unknown( doc_node );
else if ( is_element( str ) )
ident_node = create_element( XML_T(""), doc_node );
else if ( is_text( str ) )
ident_node = create_text( doc_node );
else
ident_node = create_unknown( doc_node );
return ident_node;
}
/*
** do_comments ()
*/
char
do_comments()
{
char menu_ans ;
do
{
if (canonAns == EOS)
{
disp_prompt(NEW_CANON,&menu_ans,NEW_CANON_A);
}
else
{
menu_ans = canonAns;
}
if ((menu_ans == 'c')||(menu_ans == 'C'))
{
create_comment();
}
} while ((menu_ans == 'c')||(menu_ans == 'C'));
insert_comment();
return(menu_ans);
} /* end of do_comments () */
std::vector<DomNode> DomDocument::load(
IODevice &input,
bool eat_whitespace,
DomNode insert_point)
{
clear_all();
XMLTokenizer tokenizer(input);
tokenizer.set_eat_whitespace(eat_whitespace);
if (insert_point.is_element() == false)
insert_point = *this;
std::vector<DomNode> node_stack;
node_stack.push_back(insert_point);
std::vector<DomNode> result;
try
{
XMLToken cur_token;
tokenizer.next(&cur_token);
while (cur_token.type != XMLToken::NULL_TOKEN)
{
switch (cur_token.type)
{
case XMLToken::TEXT_TOKEN:
node_stack.back().append_child(create_text_node(cur_token.value));
if (node_stack.back() == insert_point)
result.push_back(node_stack.back().get_last_child());
break;
case XMLToken::CDATA_SECTION_TOKEN:
node_stack.back().append_child(create_cdata_section(cur_token.value));
if (node_stack.back() == insert_point)
result.push_back(node_stack.back().get_last_child());
break;
case XMLToken::ELEMENT_TOKEN:
if (cur_token.variant != XMLToken::END)
{
DomString namespace_uri = DomDocument_Impl::find_namespace_uri(cur_token.name, cur_token, node_stack.back());
DomElement element = create_element_ns(namespace_uri, cur_token.name);
node_stack.back().append_child(element);
if (node_stack.back() == insert_point)
result.push_back(node_stack.back().get_last_child());
int size = (int)cur_token.attributes.size();
for (int i = 0; i < size; i++)
{
XMLToken::Attribute &attribute = cur_token.attributes[i];
DomString attribute_namespace_uri = DomDocument_Impl::find_namespace_uri(attribute.first, cur_token, node_stack.back());
element.set_attribute_ns(
attribute_namespace_uri,
attribute.first,
attribute.second);
}
if (cur_token.variant == XMLToken::BEGIN)
node_stack.push_back(element);
}
else
{
node_stack.pop_back();
if (node_stack.empty()) throw Exception("Malformed XML tree!");
}
break;
case XMLToken::NULL_TOKEN:
break;
case XMLToken::ENTITY_REFERENCE_TOKEN:
break;
case XMLToken::ENTITY_TOKEN:
break;
case XMLToken::COMMENT_TOKEN:
node_stack.back().append_child(create_comment(cur_token.value));
if (node_stack.back() == insert_point)
result.push_back(node_stack.back().get_last_child());
break;
case XMLToken::DOCUMENT_TYPE_TOKEN:
break;
case XMLToken::NOTATION_TOKEN:
break;
case XMLToken::PROCESSING_INSTRUCTION_TOKEN:
node_stack.back().append_child(create_processing_instruction(cur_token.name, cur_token.value));
if (node_stack.back() == insert_point)
result.push_back(node_stack.back().get_last_child());
break;
}
tokenizer.next(&cur_token);
}
}
catch (const Exception& e)
{
for (auto & elem : result)
{
insert_point.remove_child(elem);
}
throw;
}
return result;
}
DomNode DomDocument::import_node(const DomNode &node, bool deep)
{
DomNode imported_node;
switch (node.get_node_type())
{
case NULL_NODE:
return imported_node;
case ELEMENT_NODE:
imported_node = create_element_ns(node.get_namespace_uri(), node.get_node_name());
break;
case ATTRIBUTE_NODE:
imported_node = create_attribute_ns(node.get_namespace_uri(), node.get_node_name());
imported_node.set_node_value(node.get_node_value());
break;
case TEXT_NODE:
imported_node = create_text_node(node.get_node_value());
break;
case CDATA_SECTION_NODE:
imported_node = create_cdata_section(node.get_node_value());
break;
case ENTITY_REFERENCE_NODE:
imported_node = create_entity_reference(node.get_node_name());
break;
case ENTITY_NODE:
return imported_node;
case PROCESSING_INSTRUCTION_NODE:
imported_node = create_processing_instruction(node.to_processing_instruction().get_target(), node.to_processing_instruction().get_data());
break;
case COMMENT_NODE:
imported_node = create_comment(node.get_node_value());
break;
case DOCUMENT_NODE:
imported_node = create_document_fragment();
break;
case DOCUMENT_TYPE_NODE:
return imported_node;
case DOCUMENT_FRAGMENT_NODE:
imported_node = create_document_fragment();
break;
case NOTATION_NODE:
return imported_node;
}
if (node.is_element())
{
DomElement import_element = imported_node.to_element();
DomNamedNodeMap node_attributes = node.get_attributes();
int size = node_attributes.get_length();
for (int index = 0; index < size; index++)
{
DomNode attr = node_attributes.item(index);
import_element.set_attribute_node_ns(import_node(attr, deep).to_attr());
}
}
if (deep)
{
DomNode cur = node.get_first_child();
while (!cur.is_null())
{
imported_node.append_child(import_node(cur, true));
cur = cur.get_next_sibling();
}
}
return imported_node;
}
IXMLDOMNode *create_node( xmlNodePtr node )
{
IUnknown *pUnk;
IXMLDOMNode *ret;
HRESULT hr;
if ( !node )
return NULL;
TRACE("type %d\n", node->type);
switch(node->type)
{
case XML_ELEMENT_NODE:
pUnk = create_element( node );
break;
case XML_ATTRIBUTE_NODE:
pUnk = create_attribute( node );
break;
case XML_TEXT_NODE:
pUnk = create_text( node );
break;
case XML_CDATA_SECTION_NODE:
pUnk = create_cdata( node );
break;
case XML_ENTITY_REF_NODE:
pUnk = create_doc_entity_ref( node );
break;
case XML_PI_NODE:
pUnk = create_pi( node );
break;
case XML_COMMENT_NODE:
pUnk = create_comment( node );
break;
case XML_DOCUMENT_NODE:
pUnk = create_domdoc( node );
break;
case XML_DOCUMENT_FRAG_NODE:
pUnk = create_doc_fragment( node );
break;
case XML_DTD_NODE:
pUnk = create_doc_type( node );
break;
default: {
unknode *new_node;
FIXME("only creating basic node for type %d\n", node->type);
new_node = heap_alloc(sizeof(unknode));
if(!new_node)
return NULL;
new_node->IXMLDOMNode_iface.lpVtbl = &unknode_vtbl;
new_node->ref = 1;
init_xmlnode(&new_node->node, node, &new_node->IXMLDOMNode_iface, NULL);
pUnk = (IUnknown*)&new_node->IXMLDOMNode_iface;
}
}
hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
IUnknown_Release(pUnk);
if(FAILED(hr)) return NULL;
return ret;
}
