You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by sa...@apache.org on 2007/09/28 12:22:36 UTC
svn commit: r580284 [5/12] - in /webservices/axis2/trunk/c/axiom:
src/attachments/ src/om/ src/parser/ src/parser/guththila/
src/parser/libxml2/ src/soap/ src/util/ test/om/ test/soap/
Modified: webservices/axis2/trunk/c/axiom/src/om/om_stax_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/om/om_stax_builder.c?rev=580284&r1=580283&r2=580284&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_stax_builder.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_stax_builder.c Fri Sep 28 03:22:20 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -28,20 +29,27 @@
struct axiom_stax_builder
{
+
/** pull parser instance used by the om_builder */
axiom_xml_reader_t *parser;
+
/** last node the om_builder found */
axiom_node_t *lastnode;
axiom_node_t *root_node;
+
/** document associated with the om_builder */
axiom_document_t *document;
+
/** done building the document? */
axis2_bool_t done;
+
/** parser was accessed? */
axis2_bool_t parser_accessed;
+
/** caching enabled? */
axis2_bool_t cache;
+
/** current event */
int current_event;
@@ -50,15 +58,17 @@
};
AXIS2_EXTERN axiom_stax_builder_t *AXIS2_CALL
-axiom_stax_builder_create(const axutil_env_t *env,
- axiom_xml_reader_t *parser)
+axiom_stax_builder_create(
+ const axutil_env_t * env,
+ axiom_xml_reader_t * parser)
{
axiom_stax_builder_t *om_builder = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, parser, NULL);
- om_builder = (axiom_stax_builder_t *)AXIS2_MALLOC(env->allocator,
- sizeof(axiom_stax_builder_t));
+ om_builder = (axiom_stax_builder_t *) AXIS2_MALLOC(env->allocator,
+ sizeof
+ (axiom_stax_builder_t));
if (!om_builder)
{
@@ -88,11 +98,11 @@
return om_builder;
}
-
axis2_status_t
-axiom_stax_builder_process_attributes(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env,
- axiom_node_t *element_node)
+axiom_stax_builder_process_attributes(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env,
+ axiom_node_t * element_node)
{
int i = 0;
int attribute_count;
@@ -105,34 +115,37 @@
axutil_string_t *attr_name_str = NULL;
axutil_string_t *attr_value_str = NULL;
-
axis2_status_t status = AXIS2_SUCCESS;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, element_node, AXIS2_FAILURE);
attribute_count = axiom_xml_reader_get_attribute_count(om_builder->parser,
- env);
- for (i = 1; i <= attribute_count ; i++)
+ env);
+ for (i = 1; i <= attribute_count; i++)
{
- axiom_element_t *temp_ele = NULL;
+ axiom_element_t *temp_ele = NULL;
uri =
- axiom_xml_reader_get_attribute_namespace_by_number(om_builder->parser,
- env, i);
+ axiom_xml_reader_get_attribute_namespace_by_number(om_builder->
+ parser, env, i);
- prefix = axiom_xml_reader_get_attribute_prefix_by_number(om_builder->parser,
- env, i);
+ prefix =
+ axiom_xml_reader_get_attribute_prefix_by_number(om_builder->parser,
+ env, i);
if (uri)
{
if (axutil_strcmp(uri, "") != 0)
{
axiom_element_t *om_ele = NULL;
- om_ele = (axiom_element_t*)axiom_node_get_data_element(element_node, env);
+ om_ele =
+ (axiom_element_t *)
+ axiom_node_get_data_element(element_node, env);
if (om_ele)
{
- ns = axiom_element_find_namespace(om_ele ,
- env , element_node, uri, prefix);
+ ns = axiom_element_find_namespace(om_ele,
+ env, element_node, uri,
+ prefix);
/* newly added to handle "xml:*" attributes" (axutil_strcmp(prefix, "xml") == 0) && */
if (!ns)
@@ -143,40 +156,47 @@
}
}
- attr_name = axiom_xml_reader_get_attribute_name_by_number(
- om_builder->parser, env, i);
+ attr_name =
+ axiom_xml_reader_get_attribute_name_by_number(om_builder->parser,
+ env, i);
-#ifdef WIN32
- attr_name_str = axutil_string_create(env, attr_name);
- axiom_xml_reader_xml_free(om_builder->parser, env, attr_name);
+#ifdef WIN32
+ attr_name_str = axutil_string_create(env, attr_name);
+ axiom_xml_reader_xml_free(om_builder->parser, env, attr_name);
#else
- attr_name_str = axutil_string_create_assume_ownership(env, &attr_name);
+ attr_name_str = axutil_string_create_assume_ownership(env, &attr_name);
#endif
-
- attr_value = axiom_xml_reader_get_attribute_value_by_number(
- om_builder->parser, env, i);
+ attr_value =
+ axiom_xml_reader_get_attribute_value_by_number(om_builder->parser,
+ env, i);
-#ifdef WIN32
- attr_value_str = axutil_string_create(env, attr_value);
- axiom_xml_reader_xml_free(om_builder->parser, env, attr_value);
+#ifdef WIN32
+ attr_value_str = axutil_string_create(env, attr_value);
+ axiom_xml_reader_xml_free(om_builder->parser, env, attr_value);
#else
- attr_value_str = axutil_string_create_assume_ownership(env, &attr_value);
+ attr_value_str =
+ axutil_string_create_assume_ownership(env, &attr_value);
#endif
if (attr_name)
{
- attribute = axiom_attribute_create_str(env, attr_name_str, attr_value_str, ns);
+ attribute =
+ axiom_attribute_create_str(env, attr_name_str, attr_value_str,
+ ns);
if (!attribute)
{
return AXIS2_FAILURE;
}
- temp_ele = (axiom_element_t*)axiom_node_get_data_element(element_node, env);
+ temp_ele =
+ (axiom_element_t *) axiom_node_get_data_element(element_node,
+ env);
if (temp_ele)
{
status = axiom_element_add_attribute(temp_ele,
- env, attribute, element_node);
+ env, attribute,
+ element_node);
}
}
if (uri)
@@ -201,11 +221,12 @@
}
axiom_node_t *
-axiom_stax_builder_create_om_text(axiom_stax_builder_t * om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_create_om_text(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
axis2_char_t *temp_value = NULL;
- axutil_string_t *temp_value_str = NULL;
+ axutil_string_t *temp_value_str = NULL;
axiom_node_t *node = NULL;
AXIS2_ENV_CHECK(env, NULL);
@@ -213,31 +234,30 @@
if (!om_builder->lastnode)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_BUILDER_STATE_LAST_NODE_NULL, AXIS2_FAILURE);
+ AXIS2_ERROR_INVALID_BUILDER_STATE_LAST_NODE_NULL,
+ AXIS2_FAILURE);
return NULL;
}
temp_value = axiom_xml_reader_get_value(om_builder->parser, env);
if (!temp_value)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_VALUE_NULL,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return NULL;
}
-
-#ifdef WIN32
- temp_value_str = axutil_string_create(env, temp_value);
- axiom_xml_reader_xml_free(om_builder->parser, env, temp_value);
+#ifdef WIN32
+ temp_value_str = axutil_string_create(env, temp_value);
+ axiom_xml_reader_xml_free(om_builder->parser, env, temp_value);
#else
temp_value_str = axutil_string_create_assume_ownership(env, &temp_value);
#endif
-
if (axiom_node_is_complete(om_builder->lastnode, env))
{
axiom_text_create_str(env,
- axiom_node_get_parent(om_builder->lastnode, env),
- temp_value_str, &node);
+ axiom_node_get_parent(om_builder->lastnode, env),
+ temp_value_str, &node);
}
else
@@ -245,17 +265,17 @@
axiom_text_create_str(env, om_builder->lastnode, temp_value_str, &node);
}
- axiom_node_set_complete(node , env, AXIS2_TRUE);
+ axiom_node_set_complete(node, env, AXIS2_TRUE);
om_builder->lastnode = node;
- axutil_string_free(temp_value_str, env);
+ axutil_string_free(temp_value_str, env);
return node;
}
-
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_stax_builder_discard_current_element(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_discard_current_element(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
axiom_node_t *element = NULL;
axiom_node_t *prev_node = NULL;
@@ -268,7 +288,8 @@
if (axiom_node_is_complete(element, env) || !(om_builder->cache))
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_BUILDER_STATE_CANNOT_DISCARD, AXIS2_FAILURE);
+ AXIS2_ERROR_INVALID_BUILDER_STATE_CANNOT_DISCARD,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
@@ -276,7 +297,7 @@
do
{
while (axiom_xml_reader_next(om_builder->parser, env)
- != AXIOM_XML_READER_END_ELEMENT);
+ != AXIOM_XML_READER_END_ELEMENT);
}
while (!(axiom_node_is_complete(element, env)));
@@ -301,9 +322,10 @@
}
axis2_status_t
-axiom_stax_builder_process_namespaces(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env,
- axiom_node_t *node,
+axiom_stax_builder_process_namespaces(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env,
+ axiom_node_t * node,
int is_soap_element)
{
axis2_status_t status = AXIS2_SUCCESS;
@@ -312,7 +334,7 @@
/* temp values */
axis2_char_t *temp_prefix = NULL;
axis2_char_t *temp_ns_prefix = NULL;
- axis2_char_t *temp_ns_uri = NULL;
+ axis2_char_t *temp_ns_uri = NULL;
axutil_string_t *temp_ns_prefix_str = NULL;
axutil_string_t *temp_ns_uri_str = NULL;
@@ -320,42 +342,51 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- namespace_count = axiom_xml_reader_get_namespace_count(om_builder->parser, env);
+ namespace_count =
+ axiom_xml_reader_get_namespace_count(om_builder->parser, env);
for (i = 1; i <= namespace_count; i++)
{
- temp_ns_prefix = axiom_xml_reader_get_namespace_prefix_by_number(
- om_builder->parser, env, i);
+ temp_ns_prefix =
+ axiom_xml_reader_get_namespace_prefix_by_number(om_builder->parser,
+ env, i);
+
+ temp_ns_uri =
+ axiom_xml_reader_get_namespace_uri_by_number(om_builder->parser,
+ env, i);
- temp_ns_uri = axiom_xml_reader_get_namespace_uri_by_number(
- om_builder->parser, env , i);
-
-#ifdef WIN32
- temp_ns_prefix_str = axutil_string_create(env, temp_ns_prefix);
+#ifdef WIN32
+ temp_ns_prefix_str = axutil_string_create(env, temp_ns_prefix);
#else
- temp_ns_prefix_str = axutil_string_create_assume_ownership(env, &temp_ns_prefix);
+ temp_ns_prefix_str =
+ axutil_string_create_assume_ownership(env, &temp_ns_prefix);
#endif
#ifdef WIN32
- temp_ns_uri_str = axutil_string_create(env, temp_ns_uri);
+ temp_ns_uri_str = axutil_string_create(env, temp_ns_uri);
#else
- temp_ns_uri_str = axutil_string_create_assume_ownership(env, &temp_ns_uri);
+ temp_ns_uri_str =
+ axutil_string_create_assume_ownership(env, &temp_ns_uri);
#endif
if (!temp_ns_prefix || axutil_strcmp(temp_ns_prefix, "xmlns") == 0)
{
+
/** default namespace case */
+
/** !temp_ns_prefix is for guththila */
axiom_element_t *om_ele = NULL;
- if(temp_ns_prefix_str)
+ if (temp_ns_prefix_str)
{
axutil_string_free(temp_ns_prefix_str, env);
temp_ns_prefix_str = NULL;
- }
-
+ }
+
temp_ns_prefix_str = axutil_string_create(env, "");
- om_ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+ om_ele = (axiom_element_t *) axiom_node_get_data_element(node, env);
- om_ns = axiom_namespace_create_str(env, temp_ns_uri_str, temp_ns_prefix_str);
+ om_ns =
+ axiom_namespace_create_str(env, temp_ns_uri_str,
+ temp_ns_prefix_str);
if (!om_ns || !om_ele)
{
return AXIS2_FAILURE;
@@ -373,26 +404,30 @@
{
axiom_element_t *om_ele = NULL;
axis2_char_t *prefix = NULL;
- om_ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+ om_ele = (axiom_element_t *) axiom_node_get_data_element(node, env);
- om_ns = axiom_namespace_create_str(env, temp_ns_uri_str, temp_ns_prefix_str);
+ om_ns =
+ axiom_namespace_create_str(env, temp_ns_uri_str,
+ temp_ns_prefix_str);
if (!om_ns || !om_ele)
{
return AXIS2_FAILURE;
}
- status = axiom_element_declare_namespace_assume_param_ownership(om_ele,
- env, om_ns);
+ status =
+ axiom_element_declare_namespace_assume_param_ownership(om_ele,
+ env,
+ om_ns);
prefix = axiom_namespace_get_prefix(om_ns, env);
axutil_hash_set(om_builder->declared_namespaces,
- prefix, AXIS2_HASH_KEY_STRING, om_ns);
+ prefix, AXIS2_HASH_KEY_STRING, om_ns);
}
-
+
axutil_string_free(temp_ns_uri_str, env);
axutil_string_free(temp_ns_prefix_str, env);
-#ifdef WIN32
- axiom_xml_reader_xml_free(om_builder->parser, env, temp_ns_uri);
- axiom_xml_reader_xml_free(om_builder->parser, env, temp_ns_prefix);
+#ifdef WIN32
+ axiom_xml_reader_xml_free(om_builder->parser, env, temp_ns_uri);
+ axiom_xml_reader_xml_free(om_builder->parser, env, temp_ns_prefix);
#endif
if (!om_ns)
{
@@ -405,21 +440,23 @@
if (temp_prefix)
{
om_ns = axutil_hash_get(om_builder->declared_namespaces,
- temp_prefix, AXIS2_HASH_KEY_STRING);
+ temp_prefix, AXIS2_HASH_KEY_STRING);
if (om_ns)
{
axiom_element_t *om_ele = NULL;
- om_ele = (axiom_element_t *)axiom_node_get_data_element(node, env);
+ om_ele = (axiom_element_t *) axiom_node_get_data_element(node, env);
if (om_ele)
{
- axiom_element_set_namespace_assume_param_ownership(om_ele, env, om_ns);
+ axiom_element_set_namespace_assume_param_ownership(om_ele, env,
+ om_ns);
}
}
else
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_INVALID_DOCUMENT_STATE_UNDEFINED_NAMESPACE, AXIS2_FAILURE);
+ AXIS2_ERROR_INVALID_DOCUMENT_STATE_UNDEFINED_NAMESPACE,
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
}
@@ -431,8 +468,9 @@
}
axiom_node_t *
-axiom_stax_builder_create_om_element(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_create_om_element(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
axiom_node_t *element_node = NULL;
axiom_element_t *om_ele = NULL;
@@ -442,27 +480,30 @@
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, om_builder, NULL);
- temp_localname = axiom_xml_reader_get_name(om_builder->parser, env);
+ temp_localname = axiom_xml_reader_get_name(om_builder->parser, env);
if (!temp_localname)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_ELEMENT_NULL,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return NULL;
}
-
-#ifdef WIN32
- temp_localname_str = axutil_string_create(env, temp_localname);
- axiom_xml_reader_xml_free(om_builder->parser, env, temp_localname);
+
+#ifdef WIN32
+ temp_localname_str = axutil_string_create(env, temp_localname);
+ axiom_xml_reader_xml_free(om_builder->parser, env, temp_localname);
#else
- temp_localname_str = axutil_string_create_assume_ownership(env, &temp_localname);
+ temp_localname_str =
+ axutil_string_create_assume_ownership(env, &temp_localname);
#endif
-
+
om_builder->element_level++;
if (!(om_builder->lastnode))
{
- om_ele = axiom_element_create_str(env , NULL, temp_localname_str, NULL, &element_node);
+ om_ele =
+ axiom_element_create_str(env, NULL, temp_localname_str, NULL,
+ &element_node);
if (!om_ele)
{
return NULL;
@@ -476,14 +517,16 @@
{
axiom_node_set_document(element_node, env, om_builder->document);
axiom_document_set_root_element(om_builder->document,
- env, element_node);
+ env, element_node);
}
}
else if (axiom_node_is_complete(om_builder->lastnode, env))
{
om_ele = axiom_element_create_str(env,
- axiom_node_get_parent(om_builder->lastnode, env),
- temp_localname_str, NULL, &element_node);
+ axiom_node_get_parent(om_builder->
+ lastnode, env),
+ temp_localname_str, NULL,
+ &element_node);
if (!om_ele)
{
return NULL;
@@ -492,24 +535,22 @@
if (element_node)
{
axiom_node_set_next_sibling(om_builder->lastnode,
- env, element_node);
+ env, element_node);
axiom_node_set_previous_sibling(element_node,
- env, om_builder->lastnode);
- axiom_node_set_document(element_node,
- env, om_builder->document);
- axiom_node_set_builder(element_node,
- env, om_builder);
+ env, om_builder->lastnode);
+ axiom_node_set_document(element_node, env, om_builder->document);
+ axiom_node_set_builder(element_node, env, om_builder);
}
}
else
{
om_ele = axiom_element_create_str(env, om_builder->lastnode,
- temp_localname_str, NULL, &element_node);
+ temp_localname_str, NULL,
+ &element_node);
if (element_node)
{
- axiom_node_set_first_child(om_builder->lastnode,
- env, element_node);
- axiom_node_set_parent(element_node , env, om_builder->lastnode);
+ axiom_node_set_first_child(om_builder->lastnode, env, element_node);
+ axiom_node_set_parent(element_node, env, om_builder->lastnode);
axiom_node_set_document(element_node, env, om_builder->document);
axiom_node_set_builder(element_node, env, om_builder);
}
@@ -526,54 +567,54 @@
return element_node;
}
-
axiom_node_t *
-axiom_stax_builder_create_om_comment(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_create_om_comment(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
axiom_node_t *comment_node = NULL;
axis2_char_t *comment_value = NULL;
AXIS2_ENV_CHECK(env, NULL);
- comment_value = axiom_xml_reader_get_value(om_builder->parser, env);
+ comment_value = axiom_xml_reader_get_value(om_builder->parser, env);
if (!comment_value)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_ELEMENT_NULL,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return NULL;
}
if (!(om_builder->lastnode))
{
/* do nothing */
- axiom_xml_reader_xml_free(om_builder->parser , env, comment_value);
+ axiom_xml_reader_xml_free(om_builder->parser, env, comment_value);
return NULL;
}
else if (axiom_node_is_complete(om_builder->lastnode, env))
{
axiom_comment_create(env,
- axiom_node_get_parent(om_builder->lastnode, env),
- comment_value , &comment_node);
+ axiom_node_get_parent(om_builder->lastnode, env),
+ comment_value, &comment_node);
axiom_node_set_next_sibling(om_builder->lastnode, env, comment_node);
- axiom_node_set_previous_sibling(comment_node , env,
- om_builder->lastnode);
+ axiom_node_set_previous_sibling(comment_node, env,
+ om_builder->lastnode);
axiom_node_set_builder(comment_node, env, om_builder);
axiom_node_set_document(comment_node, env, om_builder->document);
}
else
{
axiom_comment_create(env, om_builder->lastnode,
- comment_value , &comment_node);
+ comment_value, &comment_node);
- axiom_node_set_first_child(om_builder->lastnode , env, comment_node);
- axiom_node_set_parent(comment_node , env, om_builder->lastnode);
+ axiom_node_set_first_child(om_builder->lastnode, env, comment_node);
+ axiom_node_set_parent(comment_node, env, om_builder->lastnode);
axiom_node_set_builder(comment_node, env, om_builder);
axiom_node_set_document(comment_node, env, om_builder->document);
}
om_builder->element_level++;
- axiom_xml_reader_xml_free(om_builder->parser , env, comment_value);
+ axiom_xml_reader_xml_free(om_builder->parser, env, comment_value);
om_builder->lastnode = comment_node;
@@ -581,8 +622,9 @@
}
axiom_node_t *
-axiom_stax_builder_create_om_doctype(axiom_stax_builder_t * om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_create_om_doctype(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
axiom_node_t *doctype_node = NULL;
axis2_char_t *doc_value = NULL;
@@ -600,7 +642,7 @@
if (om_builder->document)
{
axiom_document_set_root_element(om_builder->document,
- env, doctype_node);
+ env, doctype_node);
}
}
om_builder->lastnode = doctype_node;
@@ -609,56 +651,60 @@
}
axiom_node_t *
-axiom_stax_builder_create_om_processing_instruction(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_create_om_processing_instruction(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
axiom_node_t *pi_node = NULL;
axis2_char_t *target = NULL;
- axis2_char_t *value = NULL;
+ axis2_char_t *value = NULL;
AXIS2_ENV_CHECK(env, NULL);
target = axiom_xml_reader_get_pi_target(om_builder->parser, env);
- value = axiom_xml_reader_get_pi_data(om_builder->parser, env);
+ value = axiom_xml_reader_get_pi_data(om_builder->parser, env);
if (!target)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_XML_READER_ELEMENT_NULL,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return NULL;
}
if (!(om_builder->lastnode))
{
/* do nothing */
- axiom_xml_reader_xml_free(om_builder->parser , env, target);
- axiom_xml_reader_xml_free(om_builder->parser , env, value);
+ axiom_xml_reader_xml_free(om_builder->parser, env, target);
+ axiom_xml_reader_xml_free(om_builder->parser, env, value);
return NULL;
}
else if (axiom_node_is_complete(om_builder->lastnode, env) ||
- (axiom_node_get_node_type(om_builder->lastnode, env) == AXIOM_TEXT))
+ (axiom_node_get_node_type(om_builder->lastnode, env) ==
+ AXIOM_TEXT))
{
axiom_processing_instruction_create(env,
- axiom_node_get_parent(om_builder->lastnode, env),
- target, value, &pi_node);
+ axiom_node_get_parent(om_builder->
+ lastnode,
+ env), target,
+ value, &pi_node);
axiom_node_set_next_sibling(om_builder->lastnode, env, pi_node);
- axiom_node_set_previous_sibling(pi_node , env, om_builder->lastnode);
+ axiom_node_set_previous_sibling(pi_node, env, om_builder->lastnode);
}
else
{
axiom_processing_instruction_create(env, om_builder->lastnode,
- target, value, &pi_node);
- axiom_node_set_first_child(om_builder->lastnode , env, pi_node);
- axiom_node_set_parent(pi_node , env, om_builder->lastnode);
+ target, value, &pi_node);
+ axiom_node_set_first_child(om_builder->lastnode, env, pi_node);
+ axiom_node_set_parent(pi_node, env, om_builder->lastnode);
}
om_builder->element_level++;
if (target)
{
- axiom_xml_reader_xml_free(om_builder->parser , env, target);
+ axiom_xml_reader_xml_free(om_builder->parser, env, target);
}
if (value)
{
- axiom_xml_reader_xml_free(om_builder->parser , env, value);
+ axiom_xml_reader_xml_free(om_builder->parser, env, value);
}
om_builder->lastnode = pi_node;
@@ -666,8 +712,9 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_stax_builder_end_element(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_end_element(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
axiom_node_t *parent = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -691,7 +738,7 @@
}
if (om_builder->root_node)
{
- if (axiom_node_is_complete(om_builder->root_node , env))
+ if (axiom_node_is_complete(om_builder->root_node, env))
{
om_builder->done = AXIS2_TRUE;
}
@@ -699,10 +746,10 @@
return AXIS2_SUCCESS;
}
-
-AXIS2_EXTERN axiom_node_t * AXIS2_CALL
-axiom_stax_builder_next(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+axiom_stax_builder_next(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
int token = 0;
axiom_node_t *node = NULL;
@@ -717,7 +764,8 @@
if (om_builder->done)
{
AXIS2_ERROR_SET(env->error,
- AXIS2_ERROR_BUILDER_DONE_CANNOT_PULL, AXIS2_FAILURE);
+ AXIS2_ERROR_BUILDER_DONE_CANNOT_PULL,
+ AXIS2_FAILURE);
return NULL;
}
@@ -736,64 +784,64 @@
switch (token)
{
- case AXIOM_XML_READER_START_DOCUMENT:
- /*Do nothing */
- break;
-
- case AXIOM_XML_READER_START_ELEMENT:
- node = axiom_stax_builder_create_om_element(om_builder, env);
- break;
+ case AXIOM_XML_READER_START_DOCUMENT:
+ /*Do nothing */
+ break;
- case AXIOM_XML_READER_EMPTY_ELEMENT:
- node = axiom_stax_builder_create_om_element(om_builder, env);
+ case AXIOM_XML_READER_START_ELEMENT:
+ node = axiom_stax_builder_create_om_element(om_builder, env);
+ break;
- case AXIOM_XML_READER_END_ELEMENT:
- axiom_stax_builder_end_element(om_builder, env);
- break;
+ case AXIOM_XML_READER_EMPTY_ELEMENT:
+ node = axiom_stax_builder_create_om_element(om_builder, env);
+ case AXIOM_XML_READER_END_ELEMENT:
+ axiom_stax_builder_end_element(om_builder, env);
+ break;
- case AXIOM_XML_READER_SPACE:
- node = axiom_stax_builder_create_om_text(om_builder, env);
- break;
+ case AXIOM_XML_READER_SPACE:
+ node = axiom_stax_builder_create_om_text(om_builder, env);
+ break;
- case AXIOM_XML_READER_CHARACTER:
- node = axiom_stax_builder_create_om_text(om_builder, env);
- break;
+ case AXIOM_XML_READER_CHARACTER:
+ node = axiom_stax_builder_create_om_text(om_builder, env);
+ break;
- case AXIOM_XML_READER_ENTITY_REFERENCE:
- break;
+ case AXIOM_XML_READER_ENTITY_REFERENCE:
+ break;
- case AXIOM_XML_READER_COMMENT:
+ case AXIOM_XML_READER_COMMENT:
- node = axiom_stax_builder_create_om_comment(om_builder, env);
- axiom_stax_builder_end_element(om_builder, env);
- break;
+ node = axiom_stax_builder_create_om_comment(om_builder, env);
+ axiom_stax_builder_end_element(om_builder, env);
+ break;
- case AXIOM_XML_READER_PROCESSING_INSTRUCTION:
+ case AXIOM_XML_READER_PROCESSING_INSTRUCTION:
- node =
- axiom_stax_builder_create_om_processing_instruction(om_builder,
- env);
- axiom_stax_builder_end_element(om_builder, env);
- break;
+ node =
+ axiom_stax_builder_create_om_processing_instruction(om_builder,
+ env);
+ axiom_stax_builder_end_element(om_builder, env);
+ break;
- case AXIOM_XML_READER_CDATA:
- break;
+ case AXIOM_XML_READER_CDATA:
+ break;
- case AXIOM_XML_READER_DOCUMENT_TYPE:
- break;
+ case AXIOM_XML_READER_DOCUMENT_TYPE:
+ break;
- default:
- break;
+ default:
+ break;
}
}
while (!node);
return node;
}
-AXIS2_EXTERN void AXIS2_CALL
-axiom_stax_builder_free(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+AXIS2_EXTERN void AXIS2_CALL
+axiom_stax_builder_free(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
if (!om_builder)
@@ -820,85 +868,89 @@
}
}
- if (om_builder->parser)
+ if (om_builder->parser)
{
axiom_xml_reader_free(om_builder->parser, env);
om_builder->parser = NULL;
}
AXIS2_FREE(env->allocator, om_builder);
-
+
return;
}
-AXIS2_EXTERN void AXIS2_CALL
-axiom_stax_builder_free_self(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+AXIS2_EXTERN void AXIS2_CALL
+axiom_stax_builder_free_self(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
-
+
axiom_node_t *temp_node = NULL;
axiom_node_t *nodes[256];
- axiom_node_t *om_node = NULL;
+ axiom_node_t *om_node = NULL;
int count = 0;
- om_node = om_builder->root_node;
+ om_node = om_builder->root_node;
nodes[count++] = om_node;
-
- if(om_node){
- do {
-
- axiom_node_set_builder(om_node, env, NULL);
- axiom_node_set_document(om_node, env, NULL);
-
- temp_node = axiom_node_get_first_child(om_node, env);
- /* serialize children of this node */
- if (temp_node)
- {
- om_node = temp_node;
- nodes[count++] = om_node;
- }
- else
- {
- temp_node = axiom_node_get_next_sibling(om_node, env);
- if (temp_node)
- {
- om_node = temp_node;
- nodes[count -1] = om_node;
- }
- else
- {
- while (count > 1 && !temp_node)
- {
- count--;
- om_node = nodes[count -1];
- temp_node = axiom_node_get_next_sibling(om_node, env);
- }
- if (temp_node && count > 1)
- {
- om_node = temp_node;
- nodes[count -1] = om_node;
- }
- else
- {
- count--;
- }
- }
- }
- } while(count > 0);
- }
+
+ if (om_node)
+ {
+ do
+ {
+
+ axiom_node_set_builder(om_node, env, NULL);
+ axiom_node_set_document(om_node, env, NULL);
+
+ temp_node = axiom_node_get_first_child(om_node, env);
+ /* serialize children of this node */
+ if (temp_node)
+ {
+ om_node = temp_node;
+ nodes[count++] = om_node;
+ }
+ else
+ {
+ temp_node = axiom_node_get_next_sibling(om_node, env);
+ if (temp_node)
+ {
+ om_node = temp_node;
+ nodes[count - 1] = om_node;
+ }
+ else
+ {
+ while (count > 1 && !temp_node)
+ {
+ count--;
+ om_node = nodes[count - 1];
+ temp_node = axiom_node_get_next_sibling(om_node, env);
+ }
+ if (temp_node && count > 1)
+ {
+ om_node = temp_node;
+ nodes[count - 1] = om_node;
+ }
+ else
+ {
+ count--;
+ }
+ }
+ }
+ }
+ while (count > 0);
+ }
if (om_builder->declared_namespaces)
{
axutil_hash_free(om_builder->declared_namespaces, env);
om_builder->declared_namespaces = NULL;
}
- if (om_builder->parser)
+ if (om_builder->parser)
{
axiom_xml_reader_free(om_builder->parser, env);
om_builder->parser = NULL;
}
- if (om_builder->document)
+ if (om_builder->document)
{
axiom_document_free_self(om_builder->document, env);
om_builder->document = NULL;
@@ -907,10 +959,10 @@
return;
}
-
-AXIS2_EXTERN axiom_document_t* AXIS2_CALL
-axiom_stax_builder_get_document(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_document_t *AXIS2_CALL
+axiom_stax_builder_get_document(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
return om_builder->document;
}
@@ -920,8 +972,9 @@
*/
AXIS2_EXTERN int AXIS2_CALL
-axiom_stax_builder_get_current_event(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_get_current_event(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
AXIS2_PARAM_CHECK(env->error, om_builder, AXIS2_FAILURE);
return om_builder->current_event;
@@ -930,9 +983,10 @@
/**
This is an internal function
*/
-AXIS2_EXTERN axiom_node_t* AXIS2_CALL
-axiom_stax_builder_get_lastnode(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+AXIS2_EXTERN axiom_node_t *AXIS2_CALL
+axiom_stax_builder_get_lastnode(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
AXIS2_PARAM_CHECK(env->error, om_builder, NULL);
return om_builder->lastnode;
@@ -942,8 +996,9 @@
This is an internal function
*/
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-axiom_stax_builder_is_complete(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_is_complete(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FALSE);
return om_builder->done;
@@ -953,9 +1008,10 @@
This is an internal function to be used by soap om_builder only
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_stax_builder_set_lastnode(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env,
- axiom_node_t *om_node)
+axiom_stax_builder_set_lastnode(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env,
+ axiom_node_t * om_node)
{
AXIS2_PARAM_CHECK(env->error, om_node, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, om_builder, AXIS2_FAILURE);
@@ -968,8 +1024,9 @@
internal function for soap om_builder only
*/
AXIS2_EXTERN int AXIS2_CALL
-axiom_stax_builder_get_element_level(axiom_stax_builder_t* om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_get_element_level(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
AXIS2_PARAM_CHECK(env->error, om_builder, -1);
return om_builder->element_level;
@@ -979,8 +1036,9 @@
internal function for soap om_builder only
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_stax_builder_set_element_level(axiom_stax_builder_t* om_builder,
- const axutil_env_t *env,
+axiom_stax_builder_set_element_level(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env,
int element_level)
{
AXIS2_PARAM_CHECK(env->error, om_builder, AXIS2_FAILURE);
@@ -989,8 +1047,9 @@
}
int AXIS2_CALL
-axiom_stax_builder_next_with_token(axiom_stax_builder_t *om_builder,
- const axutil_env_t *env)
+axiom_stax_builder_next_with_token(
+ axiom_stax_builder_t * om_builder,
+ const axutil_env_t * env)
{
int token = 0;
void *val = NULL;
@@ -1002,7 +1061,8 @@
if (om_builder->done)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_BUILDER_DONE_CANNOT_PULL, AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_BUILDER_DONE_CANNOT_PULL,
+ AXIS2_FAILURE);
return -1;
}
@@ -1012,7 +1072,7 @@
}
token = axiom_xml_reader_next(om_builder->parser, env);
-
+
om_builder->current_event = token;
if (token == -1)
@@ -1027,78 +1087,74 @@
}
switch (token)
{
- case AXIOM_XML_READER_START_DOCUMENT:
- /*Do nothing */
- break;
+ case AXIOM_XML_READER_START_DOCUMENT:
+ /*Do nothing */
+ break;
- case AXIOM_XML_READER_START_ELEMENT:
- val = axiom_stax_builder_create_om_element(om_builder, env);
- if (!val)
- {
- return -1;
- }
- break;
+ case AXIOM_XML_READER_START_ELEMENT:
+ val = axiom_stax_builder_create_om_element(om_builder, env);
+ if (!val)
+ {
+ return -1;
+ }
+ break;
- case AXIOM_XML_READER_EMPTY_ELEMENT:
- val = axiom_stax_builder_create_om_element(
- om_builder, env);
- if (!val)
- {
- return -1;
- }
- case AXIOM_XML_READER_END_ELEMENT:
- axiom_stax_builder_end_element(om_builder, env);
- break;
+ case AXIOM_XML_READER_EMPTY_ELEMENT:
+ val = axiom_stax_builder_create_om_element(om_builder, env);
+ if (!val)
+ {
+ return -1;
+ }
+ case AXIOM_XML_READER_END_ELEMENT:
+ axiom_stax_builder_end_element(om_builder, env);
+ break;
- case AXIOM_XML_READER_SPACE:
- val = axiom_stax_builder_create_om_text(om_builder, env);
- if (!val)
- {
- return -1;
- }
- break;
+ case AXIOM_XML_READER_SPACE:
+ val = axiom_stax_builder_create_om_text(om_builder, env);
+ if (!val)
+ {
+ return -1;
+ }
+ break;
- case AXIOM_XML_READER_CHARACTER:
- val = axiom_stax_builder_create_om_text(om_builder, env);
- if (!val)
- {
- return -1;
- }
- break;
+ case AXIOM_XML_READER_CHARACTER:
+ val = axiom_stax_builder_create_om_text(om_builder, env);
+ if (!val)
+ {
+ return -1;
+ }
+ break;
- case AXIOM_XML_READER_ENTITY_REFERENCE:
- break;
+ case AXIOM_XML_READER_ENTITY_REFERENCE:
+ break;
- case AXIOM_XML_READER_COMMENT:
- val = axiom_stax_builder_create_om_comment(om_builder, env);
- if (!val)
- {
- return -1;
- }
- axiom_stax_builder_end_element(om_builder, env);
- break;
+ case AXIOM_XML_READER_COMMENT:
+ val = axiom_stax_builder_create_om_comment(om_builder, env);
+ if (!val)
+ {
+ return -1;
+ }
+ axiom_stax_builder_end_element(om_builder, env);
+ break;
- case AXIOM_XML_READER_PROCESSING_INSTRUCTION:
- val = axiom_stax_builder_create_om_processing_instruction(om_builder,
- env);
- if (!val)
- {
- return -1;
- }
- axiom_stax_builder_end_element(om_builder, env);
- break;
+ case AXIOM_XML_READER_PROCESSING_INSTRUCTION:
+ val = axiom_stax_builder_create_om_processing_instruction(om_builder,
+ env);
+ if (!val)
+ {
+ return -1;
+ }
+ axiom_stax_builder_end_element(om_builder, env);
+ break;
- case AXIOM_XML_READER_CDATA:
- break;
+ case AXIOM_XML_READER_CDATA:
+ break;
- case AXIOM_XML_READER_DOCUMENT_TYPE:
- break;
+ case AXIOM_XML_READER_DOCUMENT_TYPE:
+ break;
- default:
- break;
+ default:
+ break;
}
return token;
}
-
-
-
Modified: webservices/axis2/trunk/c/axiom/src/om/om_text.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/om/om_text.c?rev=580284&r1=580283&r2=580284&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/om/om_text.c (original)
+++ webservices/axis2/trunk/c/axiom/src/om/om_text.c Fri Sep 28 03:22:20 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -25,19 +26,21 @@
#include <axiom_namespace.h>
#include <axutil_base64.h>
-static axis2_bool_t AXIS2_CALL
-axiom_text_get_is_binary(axiom_text_t *om_text,
- const axutil_env_t *env);
-
-static axis2_status_t AXIS2_CALL
-axiom_text_serialize_start_part(axiom_text_t *om_text,
- const axutil_env_t *env,
- axiom_output_t *om_output);
+static axis2_bool_t AXIS2_CALL axiom_text_get_is_binary(
+ axiom_text_t * om_text,
+ const axutil_env_t * env);
+
+static axis2_status_t AXIS2_CALL axiom_text_serialize_start_part(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
+ axiom_output_t * om_output);
struct axiom_text
{
+
/** Text value */
axutil_string_t *value;
+
/** The following fields are for MTOM */
axis2_char_t *mime_type;
axis2_bool_t optimize;
@@ -50,10 +53,11 @@
};
AXIS2_EXTERN axiom_text_t *AXIS2_CALL
-axiom_text_create(const axutil_env_t *env,
+axiom_text_create(
+ const axutil_env_t * env,
axiom_node_t * parent,
const axis2_char_t * value,
- axiom_node_t **node)
+ axiom_node_t ** node)
{
axiom_text_t *om_text = NULL;
AXIS2_ENV_CHECK(env, NULL);
@@ -67,7 +71,7 @@
return NULL;
}
om_text = (axiom_text_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axiom_text_t));
+ sizeof(axiom_text_t));
if (!om_text)
{
AXIS2_FREE(env->allocator, *node);
@@ -106,17 +110,18 @@
}
AXIS2_EXTERN axiom_text_t *AXIS2_CALL
-axiom_text_create_with_data_handler(const axutil_env_t *env,
+axiom_text_create_with_data_handler(
+ const axutil_env_t * env,
axiom_node_t * parent,
- axiom_data_handler_t* data_handler,
- axiom_node_t **node)
+ axiom_data_handler_t * data_handler,
+ axiom_node_t ** node)
{
axiom_text_t *om_text = NULL;
AXIS2_ENV_CHECK(env, NULL);
AXIS2_PARAM_CHECK(env->error, data_handler, NULL);
- om_text = (axiom_text_t*)axiom_text_create(env, parent, NULL, node);
+ om_text = (axiom_text_t *) axiom_text_create(env, parent, NULL, node);
if (!om_text)
{
return NULL;
@@ -129,8 +134,9 @@
}
AXIS2_EXTERN void AXIS2_CALL
-axiom_text_free(axiom_text_t * om_text,
- const axutil_env_t *env)
+axiom_text_free(
+ axiom_text_t * om_text,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, void);
@@ -164,9 +170,10 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_text_serialize(axiom_text_t *om_text,
- const axutil_env_t *env,
- axiom_output_t *om_output)
+axiom_text_serialize(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
+ axiom_output_t * om_output)
{
int status = AXIS2_SUCCESS;
axis2_char_t *attribute_value = NULL;
@@ -181,7 +188,9 @@
if (om_text->value)
{
status = axiom_output_write(om_output, env,
- AXIOM_TEXT, 1, axutil_string_get_buffer(om_text->value, env));
+ AXIOM_TEXT, 1,
+ axutil_string_get_buffer(om_text->value,
+ env));
}
}
else
@@ -191,7 +200,8 @@
{
if (!(axiom_text_get_content_id(om_text, env)))
{
- axis2_char_t *content_id = axiom_output_get_next_content_id(om_output, env);
+ axis2_char_t *content_id =
+ axiom_output_get_next_content_id(om_output, env);
if (content_id)
{
om_text->content_id = axutil_strdup(env, content_id);
@@ -200,14 +210,15 @@
attribute_value = axutil_stracat(env, "cid:", om_text->content_id);
- /*send binary as MTOM optimised*/
+ /*send binary as MTOM optimised */
if (om_text->om_attribute)
{
axiom_attribute_free(om_text->om_attribute, env);
om_text->om_attribute = NULL;
}
- om_text->om_attribute = axiom_attribute_create(env, "href", attribute_value, NULL);
+ om_text->om_attribute =
+ axiom_attribute_create(env, "href", attribute_value, NULL);
AXIS2_FREE(env->allocator, attribute_value);
attribute_value = NULL;
@@ -221,17 +232,19 @@
else
{
text = axiom_text_get_text(om_text, env);
- axiom_xml_writer_write_characters(om_output_xml_writer, env, (axis2_char_t*)text);
+ axiom_xml_writer_write_characters(om_output_xml_writer, env,
+ (axis2_char_t *) text);
}
}
return status;
}
AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
-axiom_text_get_value(axiom_text_t *om_text,
- const axutil_env_t *env)
+axiom_text_get_value(
+ axiom_text_t * om_text,
+ const axutil_env_t * env)
{
- if (om_text->value)
+ if (om_text->value)
{
return axutil_string_get_buffer(om_text->value, env);
}
@@ -239,12 +252,13 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_text_set_value(axiom_text_t *om_text,
- const axutil_env_t *env,
- const axis2_char_t *value)
+axiom_text_set_value(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
+ const axis2_char_t * value)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, om_text, AXIS2_FAILURE);
if (om_text->value)
{
@@ -252,11 +266,10 @@
om_text->value = NULL;
}
- om_text->value = axutil_string_create(env, value);
+ om_text->value = axutil_string_create(env, value);
if (!om_text->value)
{
- AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY,
- AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
return AXIS2_SUCCESS;
@@ -265,96 +278,106 @@
/*Following has been implemented for the MTOM support*/
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-axiom_text_get_mime_type(axiom_text_t *om_text,
- const axutil_env_t *env)
+axiom_text_get_mime_type(
+ axiom_text_t * om_text,
+ const axutil_env_t * env)
{
return om_text->mime_type;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_text_set_mime_type(axiom_text_t *om_text,
- const axutil_env_t *env,
- const axis2_char_t *mime_type)
+axiom_text_set_mime_type(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
+ const axis2_char_t * mime_type)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, om_text, AXIS2_FAILURE);
if (om_text->mime_type)
{
AXIS2_FREE(env->allocator, om_text->mime_type);
}
- om_text->mime_type = (axis2_char_t*)axutil_strdup(env, mime_type);
+ om_text->mime_type = (axis2_char_t *) axutil_strdup(env, mime_type);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-axiom_text_get_optimize(axiom_text_t *om_text,
- const axutil_env_t *env)
+axiom_text_get_optimize(
+ axiom_text_t * om_text,
+ const axutil_env_t * env)
{
return om_text->optimize;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_text_set_optimize(axiom_text_t *om_text,
- const axutil_env_t *env,
+axiom_text_set_optimize(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
axis2_bool_t optimize)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, om_text, AXIS2_FAILURE);
om_text->optimize = optimize;
return AXIS2_SUCCESS;
}
static axis2_bool_t AXIS2_CALL
-axiom_text_get_is_binary(axiom_text_t *om_text,
- const axutil_env_t *env)
+axiom_text_get_is_binary(
+ axiom_text_t * om_text,
+ const axutil_env_t * env)
{
return om_text->is_binary;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_text_set_is_binary(axiom_text_t *om_text,
- const axutil_env_t *env,
+axiom_text_set_is_binary(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
const axis2_bool_t is_binary)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, om_text, AXIS2_FAILURE);
om_text->is_binary = is_binary;
return AXIS2_SUCCESS;
}
AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
-axiom_text_get_localname(axiom_text_t *om_text,
- const axutil_env_t *env)
+axiom_text_get_localname(
+ axiom_text_t * om_text,
+ const axutil_env_t * env)
{
return om_text->localname;
}
AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-axiom_text_get_content_id(axiom_text_t *om_text,
- const axutil_env_t *env)
+axiom_text_get_content_id(
+ axiom_text_t * om_text,
+ const axutil_env_t * env)
{
return om_text->content_id;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_text_set_content_id(axiom_text_t *om_text,
- const axutil_env_t *env,
- const axis2_char_t *content_id)
+axiom_text_set_content_id(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
+ const axis2_char_t * content_id)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error , om_text, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, om_text, AXIS2_FAILURE);
if (om_text->content_id)
{
AXIS2_FREE(env->allocator, om_text->content_id);
}
- om_text->content_id = (axis2_char_t*)axutil_strdup(env, content_id);
+ om_text->content_id = (axis2_char_t *) axutil_strdup(env, content_id);
return AXIS2_SUCCESS;
}
static axis2_status_t AXIS2_CALL
-axiom_text_serialize_start_part(axiom_text_t *om_text,
- const axutil_env_t *env,
- axiom_output_t *om_output)
+axiom_text_serialize_start_part(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
+ axiom_output_t * om_output)
{
axis2_char_t *namespace_uri = NULL;
axis2_char_t *prefix = NULL;
@@ -363,7 +386,8 @@
local_name = axiom_text_get_localname(om_text, env);
om_text->ns = axiom_namespace_create(env,
- "http://www.w3.org/2004/08/xop/include", "xop");
+ "http://www.w3.org/2004/08/xop/include",
+ "xop");
if (om_text->ns)
{
@@ -375,24 +399,22 @@
if (prefix)
{
axiom_output_write(om_output, env, AXIOM_ELEMENT, 3,
- local_name, namespace_uri, prefix);
+ local_name, namespace_uri, prefix);
}
else
{
axiom_output_write(om_output, env, AXIOM_ELEMENT, 2,
- local_name, namespace_uri);
+ local_name, namespace_uri);
}
}
else
{
- axiom_output_write(om_output, env, AXIOM_ELEMENT, 1,
- local_name);
+ axiom_output_write(om_output, env, AXIOM_ELEMENT, 1, local_name);
}
}
else
{
- axiom_output_write(om_output, env, AXIOM_TEXT, 1,
- local_name);
+ axiom_output_write(om_output, env, AXIOM_TEXT, 1, local_name);
}
if (om_text->om_attribute)
{
@@ -407,10 +429,11 @@
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_text_serialize_attribute(axiom_text_t *om_text,
- const axutil_env_t *env,
- axiom_output_t *om_output,
- axiom_attribute_t *om_attribute)
+axiom_text_serialize_attribute(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
+ axiom_output_t * om_output,
+ axiom_attribute_t * om_attribute)
{
axiom_xml_writer_t *xml_writer = NULL;
axiom_namespace_t *om_namespace = NULL;
@@ -423,8 +446,8 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
- AXIS2_XML_PARSER_TYPE_BUFFER);
- om_namespace = axiom_namespace_create(env, "" , "");
+ AXIS2_XML_PARSER_TYPE_BUFFER);
+ om_namespace = axiom_namespace_create(env, "", "");
namespace_uri = axiom_namespace_get_uri(om_text->ns, env);
attribute_local_name = axiom_attribute_get_localname(om_attribute, env);
@@ -435,27 +458,33 @@
attribute_value = axiom_attribute_get_value(om_attribute, env);
if (prefix)
{
- axiom_xml_writer_write_attribute(xml_writer, env, attribute_local_name, attribute_value);
+ axiom_xml_writer_write_attribute(xml_writer, env,
+ attribute_local_name,
+ attribute_value);
}
else
{
axiom_xml_writer_write_attribute_with_namespace(xml_writer, env,
- attribute_local_name, attribute_value, namespace_uri);
+ attribute_local_name,
+ attribute_value,
+ namespace_uri);
}
}
else
{
- axiom_xml_writer_write_attribute(xml_writer, env, attribute_local_name, attribute_value);
+ axiom_xml_writer_write_attribute(xml_writer, env, attribute_local_name,
+ attribute_value);
}
axiom_namespace_free(om_namespace, env);
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_text_serialize_namespace(axiom_text_t *om_text,
- const axutil_env_t *env,
- const axiom_namespace_t *om_namespace,
- axiom_output_t *om_output)
+axiom_text_serialize_namespace(
+ axiom_text_t * om_text,
+ const axutil_env_t * env,
+ const axiom_namespace_t * om_namespace,
+ axiom_output_t * om_output)
{
axiom_xml_writer_t *xml_writer = NULL;
axis2_char_t *namespace_uri = NULL;
@@ -464,22 +493,25 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
- AXIS2_XML_PARSER_TYPE_BUFFER);
- om_namespace = axiom_namespace_create(env, "" , "");
+ AXIS2_XML_PARSER_TYPE_BUFFER);
+ om_namespace = axiom_namespace_create(env, "", "");
if (om_namespace)
{
namespace_uri = axiom_namespace_get_uri(om_text->ns, env);
namespace_prefix = axiom_namespace_get_prefix(om_text->ns, env);
- axiom_xml_writer_write_namespace(xml_writer, env, namespace_prefix, namespace_uri);
- axiom_xml_writer_set_prefix(xml_writer, env, namespace_prefix, namespace_uri);
+ axiom_xml_writer_write_namespace(xml_writer, env, namespace_prefix,
+ namespace_uri);
+ axiom_xml_writer_set_prefix(xml_writer, env, namespace_prefix,
+ namespace_uri);
}
return AXIS2_SUCCESS;
}
AXIS2_EXTERN const axis2_char_t *AXIS2_CALL
-axiom_text_get_text(axiom_text_t *om_text,
- const axutil_env_t *env)
+axiom_text_get_text(
+ axiom_text_t * om_text,
+ const axutil_env_t * env)
{
if (om_text->value)
{
@@ -494,15 +526,18 @@
int encoded_len = 0;
axis2_char_t *encoded_str = NULL;
axiom_data_handler_read_from(om_text->data_handler, env,
- &data_handler_stream, &data_handler_stream_size);
+ &data_handler_stream,
+ &data_handler_stream_size);
if (data_handler_stream)
{
- encoded_len = axutil_base64_encode_len(data_handler_stream_size);
+ encoded_len =
+ axutil_base64_encode_len(data_handler_stream_size);
encoded_str = AXIS2_MALLOC(env->allocator, encoded_len + 2);
if (encoded_str)
{
encoded_len = axutil_base64_encode(encoded_str,
- data_handler_stream, data_handler_stream_size);
+ data_handler_stream,
+ data_handler_stream_size);
encoded_str[encoded_len] = '\0';
return encoded_str;
}
@@ -513,17 +548,19 @@
}
AXIS2_EXTERN axiom_data_handler_t *AXIS2_CALL
-axiom_text_get_data_handler(axiom_text_t *om_text,
- const axutil_env_t *env)
+axiom_text_get_data_handler(
+ axiom_text_t * om_text,
+ const axutil_env_t * env)
{
return om_text->data_handler;
}
AXIS2_EXTERN axiom_text_t *AXIS2_CALL
- axiom_text_create_str(const axutil_env_t *env,
- axiom_node_t *parent,
- axutil_string_t *value,
- axiom_node_t ** node)
+axiom_text_create_str(
+ const axutil_env_t * env,
+ axiom_node_t * parent,
+ axutil_string_t * value,
+ axiom_node_t ** node)
{
axiom_text_t *om_text = NULL;
AXIS2_ENV_CHECK(env, NULL);
@@ -537,7 +574,7 @@
return NULL;
}
om_text = (axiom_text_t *) AXIS2_MALLOC(env->allocator,
- sizeof(axiom_text_t));
+ sizeof(axiom_text_t));
if (!om_text)
{
AXIS2_FREE(env->allocator, *node);
@@ -575,28 +612,28 @@
return om_text;
}
-
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_text_set_value_str(struct axiom_text *om_text,
- const axutil_env_t *env,
- axutil_string_t *value)
-{
- if (om_text->value)
- {
- axutil_string_free(om_text->value, env);
- om_text->value = NULL;
- }
- if (value)
+axiom_text_set_value_str(
+ struct axiom_text * om_text,
+ const axutil_env_t * env,
+ axutil_string_t * value)
+{
+ if (om_text->value)
+ {
+ axutil_string_free(om_text->value, env);
+ om_text->value = NULL;
+ }
+ if (value)
{
om_text->value = axutil_string_clone(value, env);
}
- return AXIS2_SUCCESS;
+ return AXIS2_SUCCESS;
}
AXIS2_EXTERN axutil_string_t *AXIS2_CALL
-axiom_text_get_value_str(struct axiom_text *om_text,
- const axutil_env_t *env)
+axiom_text_get_value_str(
+ struct axiom_text * om_text,
+ const axutil_env_t * env)
{
- return om_text->value;
+ return om_text->value;
}
-
Modified: webservices/axis2/trunk/c/axiom/src/parser/guththila/guththila_xml_reader_wrapper.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/parser/guththila/guththila_xml_reader_wrapper.c?rev=580284&r1=580283&r2=580284&view=diff
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/parser/guththila/guththila_xml_reader_wrapper.c (original)
+++ webservices/axis2/trunk/c/axiom/src/parser/guththila/guththila_xml_reader_wrapper.c Fri Sep 28 03:22:20 2007
@@ -1,3 +1,4 @@
+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -15,7 +16,6 @@
* limitations under the License.
*/
-
#include <axiom_xml_reader.h>
#include <axutil_env.h>
#include <axutil_utils.h>
@@ -23,95 +23,100 @@
/**************** function prototypes ******************************************/
-
-
-int AXIS2_CALL
-guththila_xml_reader_wrapper_next(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-void AXIS2_CALL
-guththila_xml_reader_wrapper_free(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-int AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_count(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_name_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+int AXIS2_CALL guththila_xml_reader_wrapper_next(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+void AXIS2_CALL guththila_xml_reader_wrapper_free(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+int AXIS2_CALL guththila_xml_reader_wrapper_get_attribute_count(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL
+guththila_xml_reader_wrapper_get_attribute_name_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i);
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_prefix_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_attribute_prefix_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i);
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_value_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_attribute_value_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i);
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_namespace_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_attribute_namespace_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i);
-axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_value(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-int AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_count(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
+axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_value(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+int AXIS2_CALL guththila_xml_reader_wrapper_get_namespace_count(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_uri_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_namespace_uri_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i);
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_prefix_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_namespace_prefix_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i);
-axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_prefix(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_name(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_pi_target(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_pi_data(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_dtd(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-void AXIS2_CALL
-guththila_xml_reader_wrapper_xml_free(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_prefix(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_name(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_pi_target(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_pi_data(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_dtd(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+void AXIS2_CALL guththila_xml_reader_wrapper_xml_free(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
void *data);
-axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_char_set_encoding(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
-
-axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_uri(axiom_xml_reader_t *parser,
- const axutil_env_t *env);
+axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_char_set_encoding(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
+
+axis2_char_t *AXIS2_CALL guththila_xml_reader_wrapper_get_namespace_uri(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env);
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_uri_by_prefix(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
- axis2_char_t *prefix);
+guththila_xml_reader_wrapper_get_namespace_uri_by_prefix(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
+ axis2_char_t * prefix);
/*********** guththila_xml_reader_wrapper_impl_t wrapper struct *******************/
@@ -133,19 +138,24 @@
/**********End macros -- event_map initializing function *********************/
-static axis2_status_t guththila_xml_reader_wrapper_init_map(
-guththila_xml_reader_wrapper_impl_t *parser)
+static axis2_status_t
+guththila_xml_reader_wrapper_init_map(
+ guththila_xml_reader_wrapper_impl_t * parser)
{
if (parser)
{
- parser->event_map[GUTHTHILA_START_DOCUMENT] = AXIOM_XML_READER_START_DOCUMENT;
- parser->event_map[GUTHTHILA_START_ELEMENT] = AXIOM_XML_READER_START_ELEMENT;
- parser->event_map[GUTHTHILA_END_ELEMENT] = AXIOM_XML_READER_END_ELEMENT;
- parser->event_map[GUTHTHILA_SPACE] = AXIOM_XML_READER_SPACE;
- parser->event_map[GUTHTHILA_EMPTY_ELEMENT] = AXIOM_XML_READER_EMPTY_ELEMENT;
- parser->event_map[GUTHTHILA_CHARACTER] = AXIOM_XML_READER_CHARACTER;
- parser->event_map[GUTHTHILA_ENTITY_REFERANCE] = AXIOM_XML_READER_ENTITY_REFERENCE;
- parser->event_map[GUTHTHILA_COMMENT] = AXIOM_XML_READER_COMMENT;
+ parser->event_map[GUTHTHILA_START_DOCUMENT] =
+ AXIOM_XML_READER_START_DOCUMENT;
+ parser->event_map[GUTHTHILA_START_ELEMENT] =
+ AXIOM_XML_READER_START_ELEMENT;
+ parser->event_map[GUTHTHILA_END_ELEMENT] = AXIOM_XML_READER_END_ELEMENT;
+ parser->event_map[GUTHTHILA_SPACE] = AXIOM_XML_READER_SPACE;
+ parser->event_map[GUTHTHILA_EMPTY_ELEMENT] =
+ AXIOM_XML_READER_EMPTY_ELEMENT;
+ parser->event_map[GUTHTHILA_CHARACTER] = AXIOM_XML_READER_CHARACTER;
+ parser->event_map[GUTHTHILA_ENTITY_REFERANCE] =
+ AXIOM_XML_READER_ENTITY_REFERENCE;
+ parser->event_map[GUTHTHILA_COMMENT] = AXIOM_XML_READER_COMMENT;
return AXIS2_SUCCESS;
}
return AXIS2_FAILURE;
@@ -173,29 +183,31 @@
guththila_xml_reader_wrapper_get_namespace_uri,
guththila_xml_reader_wrapper_get_namespace_uri_by_prefix
};
+
/********************************************************************************/
AXIS2_EXTERN axiom_xml_reader_t *AXIS2_CALL
-axiom_xml_reader_create_for_file(const axutil_env_t *env,
- char* filename,
- const axis2_char_t *encoding)
+axiom_xml_reader_create_for_file(
+ const axutil_env_t * env,
+ char *filename,
+ const axis2_char_t * encoding)
{
guththila_xml_reader_wrapper_impl_t *guththila_impl = NULL;
guththila_t *guththila = NULL;
AXIS2_ENV_CHECK(env, NULL);
- guththila_impl =
- AXIS2_MALLOC(env->allocator, sizeof(guththila_xml_reader_wrapper_impl_t));
+ guththila_impl =
+ AXIS2_MALLOC(env->allocator,
+ sizeof(guththila_xml_reader_wrapper_impl_t));
if (!guththila_impl)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
-
- guththila_impl->reader =
- guththila_reader_create_for_file(filename, env);
+
+ guththila_impl->reader = guththila_reader_create_for_file(filename, env);
if (!(guththila_impl->reader))
{
@@ -204,7 +216,8 @@
return NULL;
}
- guththila = (guththila_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_t));
+ guththila =
+ (guththila_t *) AXIS2_MALLOC(env->allocator, sizeof(guththila_t));
guththila_init(guththila, guththila_impl->reader, env);
if (!guththila)
{
@@ -215,8 +228,9 @@
guththila_impl->guththila_parser = guththila;
guththila_impl->parser.ops = NULL;
- guththila_impl->parser.ops = (axiom_xml_reader_ops_t*)AXIS2_MALLOC(env->allocator,
- sizeof(axiom_xml_reader_ops_t));
+ guththila_impl->parser.ops =
+ (axiom_xml_reader_ops_t *) AXIS2_MALLOC(env->allocator,
+ sizeof(axiom_xml_reader_ops_t));
if (!(guththila_impl->parser.ops))
{
guththila_free(guththila, env);
@@ -225,10 +239,8 @@
return NULL;
}
-
guththila_xml_reader_wrapper_init_map(guththila_impl);
-
/************** ops *****/
guththila_impl->parser.ops = &axiom_xml_reader_ops_var;
return &(guththila_impl->parser);
@@ -236,22 +248,22 @@
/****** pull parser for io create function ***************************/
-
-axiom_xml_reader_t * AXIS2_CALL
-axiom_xml_reader_create_for_io(const axutil_env_t *env,
+axiom_xml_reader_t *AXIS2_CALL
+axiom_xml_reader_create_for_io(
+ const axutil_env_t * env,
AXIS2_READ_INPUT_CALLBACK read_input_callback,
AXIS2_CLOSE_INPUT_CALLBACK close_input_callback,
void *ctx,
const char *encoding)
{
guththila_xml_reader_wrapper_impl_t *guththila_impl = NULL;
- /*axutil_allocator_t *allocator = NULL;*/
+ /*axutil_allocator_t *allocator = NULL; */
guththila_t *guththila = NULL;
AXIS2_ENV_CHECK(env, NULL);
guththila_impl = AXIS2_MALLOC(env->allocator,
- sizeof(guththila_xml_reader_wrapper_impl_t));
+ sizeof(guththila_xml_reader_wrapper_impl_t));
if (!guththila_impl)
{
@@ -259,7 +271,7 @@
return NULL;
}
- /*allocator = axutil_allocator_init(NULL);*/
+ /*allocator = axutil_allocator_init(NULL); */
/*-------difference of two create function is here--------*/
guththila_impl->reader =
@@ -272,7 +284,8 @@
return NULL;
}
- guththila = (guththila_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_t));
+ guththila =
+ (guththila_t *) AXIS2_MALLOC(env->allocator, sizeof(guththila_t));
guththila_init(guththila, guththila_impl->reader, env);
if (!guththila)
{
@@ -281,12 +294,10 @@
return NULL;
}
-
guththila_impl->guththila_parser = guththila;
guththila_impl->parser.ops = NULL;
- guththila_impl->parser.ops = (axiom_xml_reader_ops_t*)
- AXIS2_MALLOC(env->allocator,
- sizeof(axiom_xml_reader_ops_t));
+ guththila_impl->parser.ops = (axiom_xml_reader_ops_t *)
+ AXIS2_MALLOC(env->allocator, sizeof(axiom_xml_reader_ops_t));
if (!(guththila_impl->parser.ops))
{
guththila_free(guththila, env);
@@ -295,10 +306,8 @@
return NULL;
}
-
guththila_xml_reader_wrapper_init_map(guththila_impl);
-
/************** ops *****/
guththila_impl->parser.ops = &axiom_xml_reader_ops_var;
return &(guththila_impl->parser);
@@ -306,33 +315,37 @@
/* ####################################################################### */
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_xml_reader_init()
+axiom_xml_reader_init(
+ )
{
return AXIS2_SUCCESS;
}
AXIS2_EXTERN axis2_status_t AXIS2_CALL
-axiom_xml_reader_cleanup()
+axiom_xml_reader_cleanup(
+ )
{
return AXIS2_SUCCESS;
}
+
/* ######################################################################## */
-AXIS2_EXTERN axiom_xml_reader_t * AXIS2_CALL
-axiom_xml_reader_create_for_memory(const axutil_env_t *env,
+AXIS2_EXTERN axiom_xml_reader_t *AXIS2_CALL
+axiom_xml_reader_create_for_memory(
+ const axutil_env_t * env,
void *buffer,
int size,
const char *encoding,
int type)
{
guththila_xml_reader_wrapper_impl_t *guththila_impl = NULL;
- /*axutil_allocator_t *allocator = NULL;*/
+ /*axutil_allocator_t *allocator = NULL; */
guththila_t *guththila = NULL;
AXIS2_ENV_CHECK(env, NULL);
guththila_impl = AXIS2_MALLOC(env->allocator,
- sizeof(guththila_xml_reader_wrapper_impl_t));
+ sizeof(guththila_xml_reader_wrapper_impl_t));
if (!guththila_impl)
{
@@ -340,7 +353,7 @@
return NULL;
}
- /*allocator = axutil_allocator_init(NULL);*/
+ /*allocator = axutil_allocator_init(NULL); */
/*-------difference of two create function is here--------*/
guththila_impl->reader =
@@ -353,7 +366,8 @@
return NULL;
}
- guththila = (guththila_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_t));
+ guththila =
+ (guththila_t *) AXIS2_MALLOC(env->allocator, sizeof(guththila_t));
guththila_init(guththila, guththila_impl->reader, env);
if (!guththila)
{
@@ -362,12 +376,10 @@
return NULL;
}
-
guththila_impl->guththila_parser = guththila;
guththila_impl->parser.ops = NULL;
- guththila_impl->parser.ops = (axiom_xml_reader_ops_t*)
- AXIS2_MALLOC(env->allocator,
- sizeof(axiom_xml_reader_ops_t));
+ guththila_impl->parser.ops = (axiom_xml_reader_ops_t *)
+ AXIS2_MALLOC(env->allocator, sizeof(axiom_xml_reader_ops_t));
if (!(guththila_impl->parser.ops))
{
guththila_free(guththila, env);
@@ -376,18 +388,17 @@
return NULL;
}
-
guththila_xml_reader_wrapper_init_map(guththila_impl);
-
/************** ops *****/
guththila_impl->parser.ops = &axiom_xml_reader_ops_var;
return &(guththila_impl->parser);
}
int AXIS2_CALL
-guththila_xml_reader_wrapper_next(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_next(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
int i = -1;
AXIS2_ENV_CHECK(env, -1);
@@ -396,8 +407,9 @@
}
void AXIS2_CALL
-guththila_xml_reader_wrapper_free(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_free(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
guththila_xml_reader_wrapper_impl_t *parser_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
@@ -416,152 +428,182 @@
}
int AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_count(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_attribute_count(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- return guththila_get_attribute_count(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env);
+ return guththila_get_attribute_count(AXIS2_INTF_TO_IMPL(parser)->
+ guththila_parser, env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_name_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_attribute_name_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i)
{
AXIS2_ENV_CHECK(env, NULL);
- return guththila_get_attribute_name_by_number(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, i, env);
+ return guththila_get_attribute_name_by_number(AXIS2_INTF_TO_IMPL(parser)->
+ guththila_parser, i, env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_prefix_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_attribute_prefix_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i)
{
AXIS2_ENV_CHECK(env, NULL);
- return guththila_get_attribute_prefix_by_number(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, i, env);
+ return guththila_get_attribute_prefix_by_number(AXIS2_INTF_TO_IMPL(parser)->
+ guththila_parser, i, env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_value_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_attribute_value_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i)
{
AXIS2_ENV_CHECK(env, NULL);
- return guththila_get_attribute_value_by_number(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, i, env);
+ return guththila_get_attribute_value_by_number(AXIS2_INTF_TO_IMPL(parser)->
+ guththila_parser, i, env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_attribute_namespace_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_attribute_namespace_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i)
{
AXIS2_ENV_CHECK(env, NULL);
- return guththila_get_attribute_namespace_by_number(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, i, env);
+ return
+ guththila_get_attribute_namespace_by_number(AXIS2_INTF_TO_IMPL(parser)->
+ guththila_parser, i, env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_value(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_value(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, NULL);
- return guththila_get_value(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env);
+ return guththila_get_value(AXIS2_INTF_TO_IMPL(parser)->guththila_parser,
+ env);
}
int AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_count(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_namespace_count(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- return guththila_get_namespace_count(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env);
+ return guththila_get_namespace_count(AXIS2_INTF_TO_IMPL(parser)->
+ guththila_parser, env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_uri_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_namespace_uri_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i)
{
AXIS2_ENV_CHECK(env, NULL);
- return guththila_get_namespace_uri_by_number(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, i, env);
+ return guththila_get_namespace_uri_by_number(AXIS2_INTF_TO_IMPL(parser)->
+ guththila_parser, i, env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_prefix_by_number(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_get_namespace_prefix_by_number(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
int i)
{
AXIS2_ENV_CHECK(env, NULL);
- return guththila_get_namespace_prefix_by_number(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, i, env);
+ return guththila_get_namespace_prefix_by_number(AXIS2_INTF_TO_IMPL(parser)->
+ guththila_parser, i, env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_prefix(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_prefix(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, NULL);
- return guththila_get_prefix(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env);
+ return guththila_get_prefix(AXIS2_INTF_TO_IMPL(parser)->guththila_parser,
+ env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_name(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_name(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
AXIS2_ENV_CHECK(env, NULL);
- return guththila_get_name(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env);
+ return guththila_get_name(AXIS2_INTF_TO_IMPL(parser)->guththila_parser,
+ env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_pi_target(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_pi_target(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
- /* guththila_does not support pi's yet*/
+ /* guththila_does not support pi's yet */
return NULL;
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_pi_data(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_pi_data(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
/* guththila_dose not support yet */
return NULL;
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_dtd(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_dtd(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
printf("not implemented in guththila");
return NULL;
}
void AXIS2_CALL
-guththila_xml_reader_wrapper_xml_free(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
+guththila_xml_reader_wrapper_xml_free(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
void *data)
{
/*if (data)
- AXIS2_FREE(env->allocator, data);*/
+ AXIS2_FREE(env->allocator, data); */
}
-
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_char_set_encoding(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_char_set_encoding(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
- return guththila_get_encoding(AXIS2_INTF_TO_IMPL(parser)->guththila_parser, env);
+ return guththila_get_encoding(AXIS2_INTF_TO_IMPL(parser)->guththila_parser,
+ env);
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_uri(axiom_xml_reader_t *parser,
- const axutil_env_t *env)
+guththila_xml_reader_wrapper_get_namespace_uri(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env)
{
- return (axis2_char_t *)NULL;
+ return (axis2_char_t *) NULL;
}
axis2_char_t *AXIS2_CALL
-guththila_xml_reader_wrapper_get_namespace_uri_by_prefix(axiom_xml_reader_t *parser,
- const axutil_env_t *env,
- axis2_char_t *prefix)
+guththila_xml_reader_wrapper_get_namespace_uri_by_prefix(
+ axiom_xml_reader_t * parser,
+ const axutil_env_t * env,
+ axis2_char_t * prefix)
{
- return (axis2_char_t *)NULL;
+ return (axis2_char_t *) NULL;
}
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org