axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r438460 [1/2] - in /webservices/axis2/trunk/c/xdocs: coding_conventions.html docs/architecture_notes.html docs/om_tutorial.html docs/userguide.html
Date Wed, 30 Aug 2006 11:07:24 GMT
Author: samisa
Date: Wed Aug 30 04:07:24 2006
New Revision: 438460

URL: http://svn.apache.org/viewvc?rev=438460&view=rev
Log:
Applied patch by Ishan

Modified:
    webservices/axis2/trunk/c/xdocs/coding_conventions.html
    webservices/axis2/trunk/c/xdocs/docs/architecture_notes.html
    webservices/axis2/trunk/c/xdocs/docs/om_tutorial.html
    webservices/axis2/trunk/c/xdocs/docs/userguide.html

Modified: webservices/axis2/trunk/c/xdocs/coding_conventions.html
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xdocs/coding_conventions.html?rev=438460&r1=438459&r2=438460&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xdocs/coding_conventions.html (original)
+++ webservices/axis2/trunk/c/xdocs/coding_conventions.html Wed Aug 30 04:07:24 2006
@@ -1,133 +1,295 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-  <meta http-equiv="Content-Type" content="">
-  <title>Axis2/C Coding Conventions</title>
-</head>
-<body>
-<h1>Axis2/C Coding Conventions</h1>
-<p> </p>
-<h2>Contents</h2>
-<ul>
-<li><a href="#1_Naming_conventions_">Naming Conventions</a></li>
-<ul>
-<li><a href="#1.1_Variables">Variables</a</li>
-<li><a href="#1.2_Functions_">Functions</a></li>
-<li><a href="#1.3_Structures_and_user_defined_data">Structures
-and User defined data types</a></li>
-<li><a href="#1.4_Macros">Macros</a></li>
-<li><a href="#1.5_Enumerations">Enumerations</a></li>
-</ul>
-<li><a href="#2_Indentation">Indentation</a></li>
-<li><a href="#3_Comments">Comments</a></li>
-<li><a href="#4_Function_parameters_and_Return_Value">Function parameters
-and Return value conventions</a></li>
-<li><a href="#5_Include_directives">Include directives</a></li>
-</ul>
-<a name="1_Naming_conventions_"></a>
-<h2>1. Naming conventions </h2>
-<ul>
-  <li>Namespace validation is done using the <strong>axis2_</strong>
-prefix. </li>
-  <li>Underscore should be used to separate individual words in
-identifiers.</li>
-  <li>All identifiers should be meaningful and abbreviations must be
-avoided whenever possible.</li>
-</ul>
-<a name="1.1_Variables"></a>
-<h3> 1.1 Variables</h3>
-<ul>
-  <li>Use meaningful nouns.</li>
-  <li>Make sure to use all lowercase letters for private &amp; public
-variables.</li>
-  <li>If it is a local variable or a member of a struct, there's no
-need to prefix it with axis2_.</li>
-e.g.
-  <pre>int count = 0;<br>char *prefix = NULL;<br></pre>
-</ul>
-<a name="1.2_Functions_"></a>
-<h3>1.2 Functions </h3>
-<ul>
-  <li>Function names should always start with the prefix axis2_ except
-for members of a struct.</li>
-e.g.
-  <pre><p>axis2_om_node_t * axis2_om_node_create(axis2_environment_t *environment);</p></pre>
-</ul>
-<a name="1.3_Structures_and_user_defined_data"></a>
-<h3>1.3 Structures
-and user defined data types </h3>
-<ul>
-  <li>Note the _t suffix in the type name.</li>
-e.g.
-  <pre>typedef struct axis2_om_namespace {<br>	char *uri;<br>	char *prefix;<br>} axis2_om_namespace_t;<br></pre>
-</ul>
-<a name="1.4_Macros"></a>
-<h3>1.4 Macros</h3>
-<ul>
-  <li>Macro names should be in all uppercase letters, except when it is
-a macro
-to help hide the complexity of the use of function pointers in
-operation
-structs or when it is a type definition. </li>
-e.g.
-  <pre>#define AXIS2_H<br><br>#define axis2_error_get_message(error) ((error)-&gt;ops-&gt;get_message())<br></pre>
-</ul>
-<a name="1.5_Enumerations"></a>
-<h3>1.5 Enumerations</h3>
-<ul>
-e.g.
-  <pre>typedef enum axis2_status_codes {<br>	AXIS2_FAILURE = 0,<br>	AXIS2_SUCCESS<br>} axis2_status_codes_t;<br></pre>
-</ul>
-<a name="2_Indentation"></a>
-<h2>2. Indentation</h2>
-<ul>
-Indentation rules are defined in terms of GNU indent options:
-</ul>
-<ul>
-indent -nbad -bap -nbc -bbo -bl -bli0 -bls -ncdb -nce -cp1 -cs -di2
--ndj
--nfc1 -nfca -hnl -i4 -ip5 -lp -pcs -nprs -psl -saf -sai -saw -nsc -nsob
--ts4
--nut -nbfda
-</ul>
-<a name="3_Comments"></a>
-<h2>3. Comments</h2>
-<ul>
-  <a href="http://www.stack.nl/%7Edimitri/doxygen/docblocks.html" target="_blank">Doxygen
-style comments</a> should be used to help auto generate API
-documentation.
-All structs as well as functions including parameters and return types
-should
-be documented.
-</ul>
-<a name="4_Function_parameters_and_Return_Value"></a>
-<h2>4. Function
-parameters and Return Value conventions</h2>
-<ul>
-Each function should be passed a pointer to an instance of
-axis2_environment_t struct as the first parameter. If the function is
-tightly
-bound to a struct, the second parameter is a pointer to an instance of
-that struct.
-</ul>
-<ul>
-Functions returning pointers should return NULL in case of an error.
-The developer should make sure to set the relavant error code in
-environment's
-error struct.
-</ul>
-<ul>
-Functions returning none pointer values should always return
-AXIS2_FAILURE status code on error whenever possible, or some defined
-error value (in case of returning a struct may be). A relavant error code must also be set
-in environment's error struct.</ul>
-<a name="5_Include_directives"></a>
-<h2>5. Include directives</h2>
-<ul>
-It is prefereable to include header files in the following fashion:
-</ul>
-<ul>
-  <pre>&lt;standard header files&gt;<br>&lt;other system headers&gt;<br>"local header files"<br></pre>
-</ul>
-</body>
-</html>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+
+
+  
+  <meta http-equiv="Content-Type" content="">
+
+  
+  <title>Axis2/C Coding Conventions</title>
+</head>
+
+
+<body>
+
+
+<h1>Axis2/C Coding Conventions</h1>
+
+
+<p> </p>
+
+
+<h2>Contents</h2>
+
+
+<ul>
+
+
+  <li><a href="#1_Naming_conventions_">Naming
+Conventions</a></li>
+
+
+  
+  <ul>
+
+
+    <li><a href="#1.1_Variables">Variables</a></li>
+
+
+    <li><a href="#1.2_Functions_">Functions</a></li>
+
+
+    <li><a href="#1.3_Structures_and_user_defined_data">Structures
+and User defined data types</a></li>
+
+
+    <li><a href="#1.4_Macros">Macros</a></li>
+
+
+    <li><a href="#1.5_Enumerations">Enumerations</a></li>
+
+
+  
+  </ul>
+
+
+  <li><a href="#2_Indentation">Indentation</a></li>
+
+
+  <li><a href="#3_Comments">Comments</a></li>
+
+
+  <li><a href="#4_Function_parameters_and_Return_Value">Function
+parameters
+and Return value conventions</a></li>
+
+
+  <li><a href="#5_Include_directives">Include
+directives</a></li>
+
+
+</ul>
+
+
+<a name="1_Naming_conventions_"></a>
+<h2>1. Naming conventions </h2>
+
+
+<ul>
+
+
+  <li>Namespace validation is done using the <code><strong>axis2_</strong></code>
+prefix. </li>
+
+
+  <li>Underscore should be used to separate individual words in
+identifiers.</li>
+
+
+  <li>All identifiers should be meaningful and abbreviations must
+be
+avoided whenever possible.</li>
+
+
+</ul>
+
+
+<a name="1.1_Variables"></a>
+<h3> 1.1 Variables</h3>
+
+
+<ul>
+
+
+  <li>Use meaningful nouns.</li>
+
+
+  <li>Make sure to use all lowercase letters for private
+&amp; public
+variables.</li>
+
+
+  <li>If it is a local variable or a member of a struct, there's
+no
+need to prefix it with <code>axis2_</code>.</li>
+
+
+e.g.
+  
+  <pre>int count = 0;<br>char *prefix = NULL;<br></pre>
+
+
+</ul>
+
+
+<a name="1.2_Functions_"></a>
+<h3>1.2 Functions </h3>
+
+
+<ul>
+
+
+  <li>Function names should always start with the prefix <code>axis2_</code>
+except
+for members of a struct.</li>
+
+
+e.g.
+  
+  <pre><p>axis2_om_node_t * axis2_om_node_create(axis2_environment_t *environment);</p></pre>
+
+
+</ul>
+
+
+<a name="1.3_Structures_and_user_defined_data"></a>
+<h3>1.3 Structures
+and user defined data types </h3>
+
+
+<ul>
+
+
+  <li>Note the _t suffix in the type name.</li>
+
+
+e.g.
+  
+  <pre>typedef struct axis2_om_namespace {<br>	char *uri;<br>	char *prefix;<br>} axis2_om_namespace_t;<br></pre>
+
+
+</ul>
+
+
+<a name="1.4_Macros"></a>
+<h3>1.4 Macros</h3>
+
+
+<ul>
+
+
+  <li>Macro names should be in all uppercase letters. </li>
+
+
+e.g.
+  
+  <pre>#define AXIS2_H<br><br>#define AXIS2_ERROR_GET_MESSAGE(error) ((error)-&gt;ops-&gt;get_message(error))<br></pre>
+
+
+</ul>
+
+
+<a name="1.5_Enumerations"></a>
+<h3>1.5 Enumerations</h3>
+
+
+<ul>
+
+
+e.g.
+  
+  <pre>typedef enum axis2_status_codes {<br>	AXIS2_FAILURE = 0,<br>	AXIS2_SUCCESS<br>} axis2_status_codes_t;<br></pre>
+
+
+</ul>
+
+
+<a name="2_Indentation"></a>
+<h2>2. Indentation</h2>
+
+
+<ul>
+
+
+Indentation rules are defined in terms of GNU indent options:
+</ul>
+
+
+<ul>
+
+
+indent -nbad -bap -nbc -bbo -bl -bli0 -bls -ncdb -nce -cp1 -cs -di2
+-ndj
+-nfc1 -nfca -hnl -i4 -ip5 -lp -pcs -nprs -psl -saf -sai -saw -nsc -nsob
+-ts4
+-nut -nbfda
+</ul>
+
+
+<a name="3_Comments"></a>
+<h2>3. Comments</h2>
+
+
+<ul>
+
+
+  <a href="http://www.stack.nl/%7Edimitri/doxygen/docblocks.html" target="_blank">Doxygen
+style comments</a> should be used to help auto generate API
+documentation.
+All structs as well as functions including parameters and return types
+should
+be documented.
+</ul>
+
+
+<a name="4_Function_parameters_and_Return_Value"></a>
+<h2>4. Function
+parameters and Return Value conventions</h2>
+
+
+<ul>
+
+
+Each function should be passed a pointer to an instance of <code>axis2_environment_t</code>
+struct as the first parameter. If the function is
+tightly
+bound to a struct, the second parameter is a pointer to an instance of
+that struct.
+</ul>
+
+
+<ul>
+
+
+Functions returning pointers should return NULL in case of an error.
+The developer should make sure to set the relavant error code in
+the environment's
+error struct.
+</ul>
+
+
+<ul>
+
+
+Functions returning none pointer values should always return
+  <code>AXIS2_FAILURE</code> status code on error whenever possible, or some defined
+error value (in case of returning a struct may be). A relavant error
+code must also be set
+in environment's error struct.
+</ul>
+
+
+<a name="5_Include_directives"></a>
+<h2>5. Include directives</h2>
+
+
+<ul>
+
+
+It is prefereable to include header files in the following fashion:
+</ul>
+
+
+<ul>
+
+
+  
+  <pre>&lt;standard header files&gt;<br>&lt;other system headers&gt;<br>"local header files"<br></pre>
+
+
+</ul>
+
+
+</body>
+</html>

Modified: webservices/axis2/trunk/c/xdocs/docs/architecture_notes.html
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xdocs/docs/architecture_notes.html?rev=438460&r1=438459&r2=438460&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xdocs/docs/architecture_notes.html (original)
+++ webservices/axis2/trunk/c/xdocs/docs/architecture_notes.html Wed Aug 30 04:07:24 2006
@@ -1,6 +1,11 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
+  <meta content="text/html; charset=iso-8859-1">
+  <meta content="text/html; charset=iso-8859-1">
+  <meta content="text/html; charset=iso-8859-1">
+  <meta content="text/html; charset=iso-8859-1">
+  <meta content="text/html; charset=iso-8859-1">
   <meta content="text/html; charset=iso-8859-1" http-equiv="content-type">
   <title>Architecture_notes.html</title>
 </head>
@@ -30,7 +35,7 @@
 <p>One of the main design goals of Axis2/C is the re-useability of the
 library and the ability to plug into different platforms. There are many
 features that allow Axis2/C to be pluggable in to different platforms as well
-as to enable the extension of the functionality of the Axis2/C.</p>
+as to enable the extension of the functionality of Axis2/C.</p>
 <a name="Axis2_Environment"></a>
 
 <h2>Axis2 Environment</h2>
@@ -85,16 +90,21 @@
 selecting a set of modules. The modules can either be compiled at the source
 tree of Axis2 or separately. These modules should be compiled as Dynamic
 Shared Objects (DSOs) that exist separately. Services are also loaded
-dynamically by reading the contents of the services folder . This dynamic
+dynamically by reading the contents of the services folder. This dynamic
 loading is mandatory in order to provide hot deployment / update as well as
 to facilitate the runtime selection of transports.</p>
 
 <p>The DSO support for loading individual Axis2 components is based on the
-component named <code>class_loader</code> which must be statically compiled
-with Axis2 core components (in the <code>util</code> package). But the
-disadvantage of this approach is that the <code>class_loader</code>
-completely depends on the DSO functionality of the underlying operating
-system, which limits the portability.</p>
+component named <code>class_loader</code>, which must be statically compiled
+with Axis2 core components (in the <code>util</code> package). To abstract
+the <code>class_loader</code> from the DSO loading functionality of the
+underlying operating system, a set of platform independent macros such as
+<code>AXIS2_PLATFORM_LOADLIB</code> and <code>AXIS2_PLATFORM_UNLOADLIB</code>
+are used. These macros will be mapped to platform specific system calls in a
+platform specific header file (e.g. <code>axis2_unix.h</code>). The file
+<code>axis2_platform_auto_sense.h</code> will include the correct platform
+specific header file, based on the compiler directives available at compile
+time. </p>
 <a name="Transport_Abstraction"></a>
 
 <h2>Transport Abstraction</h2>
@@ -109,8 +119,8 @@
 Simple HTTP server provided by Axis2 or the Axis2 Apache2 module. The
 transport sender uses sockets to connect and send the SOAP Message.</p>
 
-<p>Inside the HTTP transport,  the receivers and clients are abstracted so
-that the user can easily plug in their own senders and receivers (eg: A
+<p>Inside the HTTP transport,&nbsp; the receivers and clients are abstracted
+so that the user can easily plug in their own senders and receivers (eg: A
 <code>libcurl</code> based client can be implemented instead of the simple
 http client available in the axis2 distribution)</p>
 <a name="Stream_Abstraction"></a>
@@ -136,7 +146,7 @@
 <h2>Threading Model</h2>
 
 <p>Axis2 core functions, such as hot deployment / update, asynchronous
-invocation, concurrent request processing in simple axis2 server, etc 
+invocation, concurrent request processing in simple axis2 server, etc&nbsp;
 heavily depends on threads. At the same time these threads should be platform
 independent inside the Axis2 core components. Another important requirement
 in threading model is the ability to pool the threads. This thread pooling
@@ -158,7 +168,7 @@
 <h2>Parser Abstraction</h2>
 
 <p>Axis2 architecture depends on the XML pull model. But in C there is no
-such API (such as StAX API). Therefore XML pull API, which is specific to
+such API (such as StAX API). Therefore, an XML pull API, which is specific to
 Axis2 is defined in as <code>axis2_xml_reader</code> and
 <code>axis2_xml_writer.</code> Any implementation of this API can be plugged
 into the Axis2 core as long as they follow the API strictly. If an external

Modified: webservices/axis2/trunk/c/xdocs/docs/om_tutorial.html
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/xdocs/docs/om_tutorial.html?rev=438460&r1=438459&r2=438460&view=diff
==============================================================================
--- webservices/axis2/trunk/c/xdocs/docs/om_tutorial.html (original)
+++ webservices/axis2/trunk/c/xdocs/docs/om_tutorial.html Wed Aug 30 04:07:24 2006
@@ -3,9 +3,10 @@
        "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
 <html>
 <head>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
   <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
   <title>Axis2/C OM Tutorial</title>
-  <meta name="generator" content="amaya 9.4, see http://www.w3.org/Amaya/" />
+  <meta name="generator" content="amaya 8.5, see http://www.w3.org/Amaya/" />
 </head>
 
 <body>
@@ -20,16 +21,21 @@
       Tutorial</a></li>
       <li><a href="#What_is_Pull_Parsing">What is Pull Parsing</a></li>
       <li><a href="#Features_of_OM">Features of OM</a></li>
-      <li><a href="#Where_Does_SOAP_Come_into_Play?">Where Does SOAP Come
-        into Play?</a></li>
+      <li><a href="#Where_Does_SOAP_Come_into_Play?">Where does SOAP come
+        into play?</a></li>
     </ul>
   </li>
   <li><a href="#Working_with_OM">Working with OM</a>
     <ul>
+      <li><a href="#Env">Axis2/C environment</a></li>
       <li><a href="#Creation">Creation</a></li>
-      <li><a href="#Addition_and_Detaching_of_Nodes">Addition and Detaching
-        of Nodes</a></li>
+      <li><a href="#Addition_and_Detaching_of_Nodes">Adding and Detaching
+        Nodes</a></li>
       <li><a href="#Traversing">Traversing</a></li>
+      <li><a href="#Serialization">Serialization</a></li>
+      <li><a href="#Reader_and_Writer">Using axis2_xml_reader and axis2_xml_writer</a></li>
+      <li><a href="#Mem_Leaks">How to avoid memory leaks and double frees when using OM</a></li>
+      <li><a href="#Complete_Sample">Complete Sample</a></li>
     </ul>
   </li>
 </ul>
@@ -51,7 +57,7 @@
 <p>The objective of this tutorial is to introduce the basics of OM C and
 explain best practices while using OM.</p>
 
-<p>AXIOM C is a C implementation of AXIOM java. We have tried to get almost
+<p>AXIOM C is a C implementation of AXIOM Java. We have tried to get almost
 the same kind of API in C.</p>
 <a id="For_Whom_is_This_Tutorial"></a>
 
@@ -66,45 +72,50 @@
 
 <h3>What is Pull Parsing ?</h3>
 Pull parsing is a new trend in XML processing. The previously popular XML
-processing frameworks such as DOM were "push-based" which means the control
-of the parsing was with the parser itself. This approach is fine and easy to
-use but it is not efficient in handling large XML documents since a complete
-memory model will be generated in the memory. Pull parsing inverts the
-control and hence the parser only proceeds at the users command. The user can
-decide to store or discard events generated from the parser. OM is based on
-pull parsing. To learn more about XML pull parsing see the <a
+processing frameworks such as DOM were "push-based", which means that the
+control of parsing was with the parser itself. This approach is fine and easy
+to use but it is not efficient in handling large XML documents since a
+complete memory model will be generated in the memory. Pull parsing inverts
+the control and hence the parser only proceeds at the users command. The user
+can decide to store or discard events generated from the parser. OM is based
+on pull parsing. To learn more about XML pull parsing see the <a
 href="http://www.bearcave.com/software/java/xml/xmlpull.html">XML pull
-parsing introduction</a>. <a id="Features_of_OM"></a>
+parsing introduction</a>.
 
+<a id="Features_of_OM"></a>
 <h3>Features of OM</h3>
 
-<p>OM is a lightweight, differed built XML info set representation based on
+<p>OM is a lightweight, differed built XML infoset representation based on
 StAX API derived form (<a
 href="http://www.jcp.org/aboutJava/communityprocess/first/jsr173/">JSR
 173</a>), which is the standard streaming pull parser API. OM can be
-manipulated as flexibly as any other object model (Such as <a
+manipulated as flexibly as any other object model (such as <a
 href="http://www.jdom.org/">JDOM</a>), but underneath the objects will be
 created only when they are absolutely required. This leads to much less
-memory intensive programming. Following is a short feature overview of OM.</p>
+memory intensive programming.</p>
+
+<p>Following is a short feature overview of OM.</p>
 <ul>
   <li>Lightweight: OM is specifically targeted to be lightweight. This is
-    achieved by reducing the depth of the hierarchy, number of methods and
-    the attributes enclosed in the objects. This makes the objects less
+    achieved by reducing the depth of the hierarchy, the number of methods
+    and the attributes enclosed in the objects. This makes the objects less
     memory intensive.</li>
   <li>Differed building: By far this is the most important feature of OM. The
     objects are not made unless a need arises for them. This passes the
-    control of building over to the object model itself rather than an
-    external builder.</li>
+    control of building to the object model itself rather than an external
+    builder.</li>
   <li>Pull based: For a differed building mechanism a pull based parser is
     required. OM is based on StAX, the standard pull parser API.
-    <p>Since different XML parsers offer different kinds of pull parser APIs
+    <p>Since different XML parsers offer different kinds of pull parser APIs,
     we define an API derived from StAX. That API is defined in
-    axis2_xml_reader.h , similarly we define an xml writer api in
-    axis2_xml_writer.h. These two APIs work as an abstarction layer between
-    any XML parser and OM. So any parser that is going to be used for OM
-    should implement the axis2_xml_reader API and axis2_xml_writer API using
-    a wrapper layer.</p>
-    <p>Currenly we use Libxml2 as our default XML parser.</p>
+    <code>axis2_xml_reader.h</code>. Similarly we define an xml writer API in
+    <code>axis2_xml_writer.h</code>. These two APIs work as an abstarction
+    layer between any XML parser and OM. So any parser that is going to be
+    used for OM should implement the <code>axis2_xml_reader</code> API and
+    <code>axis2_xml_writer</code> API using a wrapper layer.</p>
+    <p></p>
+    <p>Currenly we use <code>libxml2</code> as our default XML parser.</p>
+    <p></p>
   </li>
 </ul>
 <!-- Special section -->
@@ -114,18 +125,18 @@
 height="282" /></p>
 <!--  End of Image -->
 
-<p>OM Builder wraps the raw xml character stream through the axis2_xml_reader
-API. Hence the complexities of the pull event stream is covered</p>
-<a id="Where_Does_SOAP_Come_into_Play?"></a>
+<p>OM Builder wraps the raw xml character stream through the
+<code>axis2_xml_reader</code> API. Hence the complexities of the pull event
+stream are covered.</p>
 
-<h3>Where Does SOAP Come into Play?</h3>
+<a id="Where_Does_SOAP_Come_into_Play?"></a>
+<h3>Where does SOAP come into play?</h3>
 
-<p>In a nutshell SOAP is a information exchange protocol based on XML. SOAP
+<p>In a nutshell SOAP is an information exchange protocol based on XML. SOAP
 has a defined set of XML elements that should be used in messages. Since Axis
-is a "SOAP Engine" and OM is built for Axis, A SOAP specific API was
+is a "SOAP Engine" and OM is built for Axis, a SOAP specific API was
 implemented on top of OM.We have defined a number of structs to represent
-SOAP constructs like Envelope etc.. These structs wraps general OM
-structures. See <a
+SOAP constructs like Envelope etc., which wraps general OM structures. See <a
 href="http://www.w3schools.com/SOAP/soap_intro.asp">here</a> to learn more
 about SOAP.</p>
 <!--<p>This abstraction provides</p>
@@ -138,56 +149,70 @@
 <a id="Working_with_OM"></a>
 
 <h2>Working with OM</h2>
-<a id="Creation">Axis2c environment</a>
 
-<p>Before starting the discussion on om, it is necessary to get a good
-understanding of the basics of axis2c. Axis2c is designed to be plugble to
-any system written in C or C++ and therefore axis2 has abstracted the
+<p></p>
+
+<a id="Env"></a>
+<h3>Axis2/C environment</h3>
+
+<p>Before starting the discussion on OM, it is necessary to get a good
+understanding of the basics of Axis2/C. Axis2/C is designed to be plugble to
+any system written in C or C++ and therefore Axis2 has abstracted the
 functionalities that differ from system to system in to a structure
-"axis2_env_t" which we refer to as axis2 environment . The environment holds
-axis2_allocater_t [ used for memory allocation/deallocation ] , axis2_error_t
-[ error reporting mechanism ] axis2_log_t [ logging mechanism ] and
-axis2_thread_t [threading mechnism ]. axis2_allocator_t has function pointers
-to malloc, realloc and free functions and all memory allocation and
-deallocation is done using the allocator. So by pluging in a different
-allocator, a user can make the entire Axis2 system to use different memory
-management functions.</p>
+<code>axis2_env_t</code>, which we refer to as axis2 environment . The
+environment holds <code>axis2_allocater_t</code> [ used for memory
+allocation/deallocation ] , <code>axis2_error_t</code> [ error reporting
+mechanism ], <code>axis2_log_t</code> [ logging mechanism ] and
+<code>axis2_thread_t</code> [threading mechnism ].
+<code>axis2_allocator_t</code> has function pointers to <code>malloc</code>,
+<code>realloc</code> and <code>free</code> functions and all memory
+allocation and deallocation is done using the allocator. Therefore, by
+pluging in a different allocator, a user can make the entire Axis2 system to
+use different memory management functions.</p>
 
-<p>How to create the axis2 environment</p>
+<p></p>
 
-<p><b>creating the allocator</b></p>
+<p>When creating the axis2 environment, the first thing is to create the
+allocator.</p>
 
-<p>axis2_allocator_t *allocator = NULL;</p>
+<p><code>axis2_allocator_t *allocator = NULL;</code></p>
 
-<p>allocator = axis2_allocator_init(NULL);</p>
+<p><code>allocator = axis2_allocator_init(NULL);</code></p>
 
 <p></p>
 
-<p>We parse NULL to the above function to use the default allocator. Then the
-allocators function pointers point to malloc, realloc and free functons. If
+<p>We parse <code>NULL</code> to the above function to use the default
+allocator. Then the allocators function pointers point to
+<code>malloc</code>, <code>realloc</code> and <code>free</code> functons. If
 you have your own allocator structure, you may pass it instead.</p>
 
-<p>Convinent macros are defined to use allocator functions as follows (refer
-to axis2_allocator.h for more information).</p>
+<p></p>
 
-<p>AXIS2_MALLOC , AXIS2_REALLOC and AXIS2_FREE .</p>
+<p>Convinent macros <code>AXIS2_MALLOC</code>, <code>AXIS2_REALLOC</code> and
+<code>AXIS2_FREE</code> are defined to use allocator functions (refer to
+<code>axis2_allocator.h</code> for more information).</p>
+
+<p></p>
 
 <p>In a similar fashion, you can create the error and log structures.</p>
 
-<p>axis2_log_t *log = NULL;</p>
+<p><code>axis2_log_t *log = NULL;</code></p>
 
-<p>axis2_error_t *error = NULL;</p>
+<p><code>axis2_error_t *error = NULL;</code></p>
 
-<p>log = axis2_log_create(allocator, NULL, NULL);</p>
+<p><code>log = axis2_log_create(allocator, NULL, NULL);</code></p>
 
-<p>log = axis2_log_create(allocator, NULL, "mylog.log");</p>
+<p><code>log = axis2_log_create(allocator, NULL, "mylog.log");</code></p>
+
+<p></p>
 
 <p>Now we can create the environment by parsing the allocator, error and log
-to axis2_env_create_with_error_log() function.</p>
+to <code>axis2_env_create_with_error_log()</code> function.</p>
 
-<p>axis2_env_t *env = NULL;</p>
+<p><code>axis2_env_t *env = NULL;</code></p>
 
-<p>env = axis2_env_create_with_error_log(allocator, error, log);</p>
+<p><code>env = axis2_env_create_with_error_log(allocator, error,
+log);</code></p>
 
 <p></p>
 
@@ -195,95 +220,109 @@
 ANSI C complient. Further, platform dependent funtions are also
 abstracted.</p>
 
-<p>As a rule of thumb, all "create" functions take a pointer to the
-environment as its first argument and all other functions take pointer to
-'this' struct as the first argument and a pointer to the environment as
-the second argument. (Please refer to our coding convention page to learn
-more about this)</p>
+<p></p>
 
-<p>eg.</p>
+<p>As a rule of thumb, all "<code>create</code>" functions take a pointer to
+the environment as its first argument and all other functions take pointer to
+'this' struct as the first argument and a pointer to the environment as the
+second argument. (Please refer to our <a
+href="../coding_conventions.html">coding convention page</a> to learn more
+about this)</p>
 
-<p>axiom_node_t *node = NULL;</p>
+<p>Eg.</p>
 
-<p>axiom_node_t *child = NULL;</p>
+<p><code>axiom_node_t *node = NULL;</code></p>
 
-<p>node = axiom_node_create(env);</p>
+<p><code>axiom_node_t *child = NULL;</code></p>
 
-<p>child = AXIOM_NODE_GET_FIRST_CHILD(node, env);</p>
+<p><code>node = axiom_node_create(env);</code></p>
 
-<p>Note that we are passing the node (pointer to axiom_node_t ) as the first
-argument and the pointer to the environment as the second.</p>
+<p><code>child = AXIOM_NODE_GET_FIRST_CHILD(node, env);</code></p>
+
+<p>Note that we are passing the node (pointer to <code>axiom_node_t</code> )
+as the first argument and the pointer to the environment as the second.</p>
 
 <p></p>
 
 <p>All functions return a pointer to a struct or a status code [
-AXIS2_SUCCESS , AXIS2_FAILURE]. So if NULL is returned by a function</p>
+<code>AXIS2_SUCCESS</code> , <code>AXIS2_FAILURE</code>]. So if
+<code>NULL</code> is returned by a function it is either because there is
+nothing to return or an error has occured.</p>
 
-<p>it is either because there is nothing to return or an error has
-occured.</p>
+<p></p>
+
+<a id="Creation"></a>
 
 <h3>Creation</h3>
 
 <p>Creation is the first and foremost action when using an Object
-representation. This part explains how OM can be built from either an
+representation. This part explains how OM can be built either from an
 existing document or programmatically. OM provides a notion of a builder to
 create objects. Since OM is tightly bound to StAX, a StAX compliant reader
 should be created first with the desired input stream.</p>
 
-<p>In our OM implementation we define a struct 'axiom_node_t' which acts
-as the container of the other structs and it maintains the links that form
-the Link List OM in C.</p>
-
-<p>So to traverse the structure the functions defined in axiom_node.h must
-be used. To access xml information, the 'data element' struct stored in
-axiom_node_t must be obtained using the AXIOM_NODE_GET_DATA_ELEMENT
-macro. The type of the struct stored in the 'axiom_node_t' struct can be
-obtained by AXIOM_NODE_GET_NODE_TYPE macro. When we create
-axiom_element_t , axiom_text_t etc .., it is required to parse a double
-pointer to the node struct as the last parameter of the create function so
-that the correponding node struct can be referenced using that pointer.</p>
-
-<p>Ex.</p>
-
-<p>axiom_node_t *my_node = NULL;</p>
+<p>In our OM implementation we define a struct '<code>axiom_node_t</code>'
+which acts as the container of the other structs and it maintains the links
+that form the Link List OM in C.</p>
+
+<p>To traverse this structure, the functions defined in
+<code>axiom_node.h</code> must be used. To access xml information, the 'data
+element' struct stored in <code>axiom_node_t</code> must be obtained using
+the <code>AXIOM_NODE_GET_DATA_ELEMENT</code> macro. The type of the struct
+stored in the '<code>axiom_node_t'</code> struct can be obtained by
+<code>AXIOM_NODE_GET_NODE_TYPE</code> macro. When we create
+<code>axiom_element_t</code> , <code>axiom_text_t</code> etc .., it is
+required to parse a double pointer to the node struct as the last parameter
+of the <code>create</code> function so that the correponding node struct can
+be referenced using that pointer.</p>
+
+<p>Eg.</p>
 
-<p>axiom_element_t *my_ele = NULL;</p>
+<p><code>axiom_node_t *my_node = NULL;</code></p>
 
-<p>my_ele = axiom_element_create(env, NULL, "MY_ELEMENT", NULL,
-&amp;my_node);</p>
+<p><code>axiom_element_t *my_ele = NULL;</code></p>
 
-<p>Now if we call AXIOM_NODE_GET_NODE_TYPE macro on 'my_node' pointer we
-will get the value as AXIOM_ELEMENT .</p>
+<p><code>my_ele = axiom_element_create(env, NULL, "MY_ELEMENT", NULL,
+&amp;my_node);</code></p>
+
+<p></p>
+
+<p>Now if we call <code>AXIOM_NODE_GET_NODE_TYPE</code> macro on
+'<code>my_node</code>' pointer we will get the value as
+<code>AXIOM_ELEMENT</code> .</p>
 
 <div>
+<p></p>
+
 <p><b>Code Listing 1</b></p>
 </div>
-<pre>axis2_xml_reader_t *xml_reader = NULL;<br />
-axiom_stax_builder_t *om_builder = NULL;<br />
-axiom_soap_builder_t *soap_builder = NULL;<br />
-axiom_soap_envelope_t *soap_envelope = NULL;<br />
-<i>/** create the parser */</i><br />
-axis2_xml_reader_t *xml_reader = axis2_xml_reader_create_for_file(env, "test_soap.xml",NULL);<br />
-<i>/** create the OM builder */</i><br />
-om_builder = axiom_stax_builder_create(env, xml_reader);<br />
-<i>/** create SOAP builder */</i><br />
-soap_builder = axiom_soap_builder_create(env, om_builder , AXIOM_SOAP_ENVELOPE_NAMESPACE_URI);<br />
-<i>/** get soap envelope */</i><br />
-soap_envelope = AXIOM_SOAP_BUILDER_GET_SOAP_ENVELOPE(soap_builder, env);<br /></pre>
+<pre>axis2_xml_reader_t&nbsp;*xml_reader&nbsp;=&nbsp;NULL;<br />
+axiom_stax_builder_t&nbsp;*om_builder&nbsp;=&nbsp;NULL;<br />
+axiom_soap_builder_t&nbsp;*soap_builder&nbsp;=&nbsp;NULL;<br />
+axiom_soap_envelope_t&nbsp;*soap_envelope&nbsp;=&nbsp;NULL;<br />
+<i>/**&nbsp;create&nbsp;the&nbsp;parser&nbsp;*/</i><br />
+axis2_xml_reader_t&nbsp;*xml_reader&nbsp;=&nbsp;axis2_xml_reader_create_for_file(env,&nbsp;"test_soap.xml",NULL);<br />
+<i>/**&nbsp;create&nbsp;the&nbsp;OM&nbsp;builder&nbsp;*/</i><br />
+om_builder&nbsp;=&nbsp;axiom_stax_builder_create(env,&nbsp;xml_reader);<br />
+<i>/**&nbsp;create&nbsp;SOAP&nbsp;builder&nbsp;*/</i><br />
+soap_builder&nbsp;=&nbsp;axiom_soap_builder_create(env,&nbsp;om_builder&nbsp;,&nbsp;AXIOM_SOAP_ENVELOPE_NAMESPACE_URI);<br />
+<i>/**&nbsp;get&nbsp;soap&nbsp;envelope&nbsp;*/</i><br />
+soap_envelope&nbsp;=&nbsp;AXIOM_SOAP_BUILDER_GET_SOAP_ENVELOPE(soap_builder,&nbsp;env);<br /></pre>
 <br />
 
 
-<p>As the example shows, creating an OM from xml_reader is pretty straight
-forward. However elements and nodes can be created programmatically to modify
-the structure as well. Currently OM has two builders, namely the
-axiom_stax_builder_t and the axiom_soap_builder_t. These builders provide
-the necessary information to the XML info set model to build itself.</p>
+<p>As the example shows, creating an OM from <code>xml_reader</code> is
+pretty straight forward. However, elements and nodes can be created
+programmatically to modify the structure as well. Currently OM has two
+builders, namely the <code>axiom_stax_builder_t</code> and the
+<code>axiom_soap_builder_t</code>. These builders provide the necessary
+information to the XML infoset model to build itself.</p>
 
 <div>
+<p></p>
+
 <p><b>Code Listing 2</b></p>
 </div>
-
-<p class="img-title"><b></b></p>
 <pre class="code">axiom_namespace_t *ns1 = NULL;
 axiom_namespace_t *ns2 = NULL;
 
@@ -296,33 +335,34 @@
 ns1 = axiom_namespace_create(env, "bar", "x");
 ns2 = axiom_namespace_create(env, "bar1", "y");
 
-
 root_ele = axiom_element_create(env, NULL, "root", ns1, &amp;root_ele_node);
 ele1     = axiom_element_create(env, root_node, "foo1", ns2, &amp;ele1_node);</pre>
 
+<p></p>
+
 <p>Several differences exist between a programmatically created
-axiom_node_t and a conventionally built axiom_node_t. The most
-important difference is that the latter will have a pointer to its builder,
-where as the former does not have that information. As stated earlier in this
-tutorial, since the OM is built as and when required, each and every
-axiom_node_t struct should have a reference to its builder. If this
-information is not available, it is due to the struct being created without a
-builder.</p>
+<code>axiom_node_t</code> and a conventionally built
+<code>axiom_node_t</code>. The most important difference is that the latter
+will have a pointer to its builder, where as the former does not have that
+information. As stated earlier in this tutorial, since the OM is built as and
+when required, each and every <code>axiom_node_t</code> struct should have a
+reference to its builder. If this information is not available, it is due to
+the struct being created without a builder.</p>
 
 <p></p>
 
 <p>The SOAP struct hierarchy is made in the most natural way for a
 programmer. It acts as a wrapper layer on top of OM implementation. The SOAP
-structs wraps the correspoding axiom_node_t structs to store information in
-xml.</p>
+structs wraps the correspoding <code>axiom_node_t</code> structs to store
+information in xml.</p>
 <!--  The following illustration of the actual class diagram will be helpful in understanding this.
 Need an image here -->
 <a id="Addition_and_Detaching_of_Nodes"></a>
 
-<h3>Addition and Detaching of Nodes</h3>
+<h3>Adding and Detaching Nodes</h3>
 
-<p>Addition and removal methods are defined in the axiom_node.h header.
-The following are the most important in adding nodes.</p>
+<p>Addition and removal methods are defined in the <code>axiom_node.h</code>
+header. The following are the most important in adding nodes.</p>
 
 <div>
 <p><b>Code Listing 3</b></p>
@@ -358,30 +398,37 @@
 foo_ele = axiom_element_create(env, NULL, "FOO", NULL, &amp;foo_node);
 bar_ele = axiom_element_create(env, NULL, "BAR", NULL. &amp;bar_node); </pre>
 
+<p></p>
+
 <p>Now if we want to make 'BAR' element, a child of 'FOO' element we can use
-add_child MACRO.</p>
+add child macro.</p>
 <pre class="code"> AXIOM_NODE_ADD_CHILD(foo_node, env, bar_node); </pre>
 
-<p>Or we can parse the foo_node as the parent node at the time of creating to
-bar_ele as follows.</p>
+<p></p>
+
+<p>Or we can parse the <code>foo_node</code> as the parent node at the time
+of creating to <code>bar_ele</code> as follows.</p>
 <pre> bar_ele = axiom_element_create(env, foo_node, "BAR", NULL, &amp;bar_node);</pre>
 <ul>
-  <li>add_child function will always add the child as the first child of the
-    parent.</li>
-  <li><p>A given node can be removed from the tree by calling the detach()
-    method. A node can also be removed from the tree by calling the remove
-    method of the returned iterator which will also call the detach method of
-    the particular node internally.</p>
+  <li><code>add_child</code> function will always add the child as the first
+    child of the parent.</li>
+  <li><p>A given node can be removed from the tree by calling the
+    <code>detach()</code> method. A node can also be removed from the tree by
+    calling the <code>remove</code> method of the returned iterator which
+    will also call the <code>detach</code> method of the particular node
+    internally.</p>
   </li>
   <li>Namespaces are a tricky part of any XML object model and is the same in
     OM. However the interface to the namespace have been made very simple.
-    axiom_namespace_t * is the struct that represents a namespace and we
-    do not have setter functions. This makes the axiom_namespace
-  immutable.</li>
+    <code>axiom_namespace_t</code> is the struct that represents a namespace
+    and we do not have setter functions. This makes the axiom namespace
+    immutable.</li>
 </ul>
 
-<p>Following are the important methods available in axiom_element to
-handle namespaces.</p>
+<p></p>
+
+<p>Following are the important methods available in
+<code>axiom_element</code> to handle namespaces.</p>
 
 <div>
 <p><b>Code Listing 5</b></p>
@@ -411,29 +458,32 @@
                                axis2_namespace_t *ns,
                                axiom_node_t *element_node);</pre>
 
+<p></p>
+
 <p>An om_element has a namespace list [declared namespaces] and a pointer to
 its own namespace if one exists.</p>
 
-<p>The declare_namespace function is straight forward. It adds a namespace to
-namespace declarations section. Note that a namespace declaration that is
-already added will not be added twice.</p>
-
-<p>find_namespace is a very handy method to locate a namespace higher up the
-tree. It searches for a matching namespace in its own declarations section
-and jumps to the parent if it's not found. The search progresses up the tree
-until a matching namespace is found or the root has been reached.</p>
-
-<p>find_declared_namespace can be used to search for a namespace in the
-current element's namespace declarations section.</p>
-
-<p>set_namespace an om_elements own namespace , [ Note that an element's own
-namespace should be declared in its own namespace declarations section or its
-one of its parent element. ] This method first searches for a matching
-namespace using find_namespace and if a matching namespace is not found
-anamespace is declared to this om_element's namespace declarations section
-before seting the own namespace reference.</p>
+<p>The <code>declare_namespace</code> function is straight forward. It adds a
+namespace to namespace declarations section. Note that a namespace
+declaration that is already added will not be added twice.</p>
+
+<p><code>find_namespace</code> is a very handy method to locate a namespace
+higher up the tree. It searches for a matching namespace in its own
+declarations section and jumps to the parent if it's not found. The search
+progresses up the tree until a matching namespace is found or the root has
+been reached.</p>
+
+<p><code>find_declared_namespace</code> can be used to search for a namespace
+in the current element's namespace declarations section.</p>
+
+<p><code>set_namespace</code> sets an om_elements own namespace. [ Note that
+an element's own namespace should be declared in its own namespace
+declarations section or in one of its parent elements. ] This method first
+searches for a matching namespace using <code>find_namespace</code> and if a
+matching namespace is not found anamespace is declared to this om_element's
+namespace declarations section before seting the own namespace reference.</p>
 
-<p>The following simple code segment shows how the namespaces are dealt with
+<p>The following sample code segment shows how the namespaces are dealt with
 in OM</p>
 
 <div>
@@ -459,15 +509,16 @@
 ele1     = axiom_element_create(env, root_node, "foo", ns2, &amp;ele1_node);
 om_text  = axiom_text_create(env, ele1_node, "blah", &amp;text_node);</pre>
 
+<p></p>
+
 <p>Serilization of the root element produces the following XML</p>
 <pre class="xml">&lt;x:root xmlns:x="bar"&gt;
   &lt;y:foo xmlns:y="bar1"&gt;
         blah
   &lt;/y:foo&gt;
 &lt;/x:root&gt;</pre>
-<a id="Traversing"></a>
 
-<p>if we want to produce</p>
+<p>If we want to produce</p>
 <pre class="xml">&lt;x:foo xmlns:x="bar" xmlns:y="bar1"&gt;Test&lt;/x:foo&gt;</pre>
 
 <p>we can use set_namespace and declare namespace functions as follows</p>
@@ -488,10 +539,13 @@
 
 AXIOM_ELEMENT_SET_TEXT(foo_ele, env, "Test", &amp;foo_node);</pre>
 
+<p></p>
+
+<a id="Traversing"></a>
 <h3>Traversing</h3>
 
 <p>Traversing the OM structure can be done by obtaining an iterator struct.
-You can either call the appropriate function on OM element or create the
+You can either call the appropriate function on an OM element or create the
 iterator manually. OM C offers three iterators to traverse the OM structure.
 They are</p>
 <ul>
@@ -500,10 +554,12 @@
   <li>axiom_children_qname_iterator_t</li>
 </ul>
 
-<p>The Iterator supports the 'OM way' of accessing elements and is more
+<p></p>
+
+<p>The iterator supports the 'OM way' of accessing elements and is more
 convenient than a list for sequential access. The following code sample shows
-how the children can be accessed. The children can be of type AXIOM_TEXT
-or AXIOM_ELEMENT.</p>
+how the children can be accessed. The children can be of type
+<code>AXIOM_TEXT</code> or <code>AXIOM_ELEMENT</code>.</p>
 
 <div>
 <p><b>Code Listing 7</b></p>
@@ -527,16 +583,22 @@
     }
 }</pre>
 
-<p>Apart from this, every axiom_node_t struct has links to its siblings.
-If a thorough navigation is needed the AXIOM_NODE_GET_NEXT_SIBLING() and
-AXIOM_NODE_GET_PREVIOUS_SIBLING() macros can be used. A restrictive set
-can be chosen by using AXIOM_ELEMENT_XXX_WITH_QNAME() methods. The
-AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME() method returns the first child
-that matches the given axis2_qname_t and
-AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME() returns
-axiom_children_qname_iterator_t which can be used to travese all the
-matching children. The advantage of these iterators are that they won't build
-the whole object structure at once; it builds only what is required.</p>
+<p></p>
+
+<p>Apart from this, every <code>axiom_node_t</code> struct has links to its
+siblings. If a thorough navigation is needed the
+<code>AXIOM_NODE_GET_NEXT_SIBLING()</code> and
+<code>AXIOM_NODE_GET_PREVIOUS_SIBLING()</code> macros can be used. A
+restrictive set can be chosen by using
+<code>AXIOM_ELEMENT_XXX_WITH_QNAME()</code> methods. The
+<code>AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME()</code> method returns the
+first child that matches the given <code>axis2_qname_t</code> and
+<code>AXIOM_ELEMENT_GET_CHILDREN_WITH_QNAME()</code> returns
+<code>axiom_children_qname_iterator_t</code> which can be used to travese all
+the matching children. The advantage of these iterators are that they won't
+build the whole object structure at once; it builds only what is required.</p>
+
+<p></p>
 <!-- Special section -->
 
 <table width="100%">
@@ -545,18 +607,24 @@
       <td><img src="images/OM005.gif" alt="" width="35" height="57" /></td>
       <td class="special-td">All iterator implementations internally stay one
         step ahead of their apparent location to provide the correct value
-        for the HAS_NEXT() function . This hidden advancement can build
-        elements that are not intended to be built at all.</td>
+        for the <code>HAS_NEXT()</code> function . This hidden advancement
+        can build elements that are not intended to be built at all.</td>
       <td></td>
     </tr>
   </tbody>
 </table>
 <!-- End of special section -->
 
-<p><b>Serialization</b></p>
+<p></p>
+
+<a id="Serialization"></a>
+<h3><b>Serialization</b></h3>
 
-<p>OM can be serialized using AXIOM_NODE_SERIALIZE macro .The
-serialization uses axis2_xml_writer.h and axiom_output.h APIs.</p>
+<p>OM can be serialized using <code>AXIOM_NODE_SERIALIZE</code> macro .The
+serialization uses <code>axis2_xml_writer.h</code> and
+<code>axiom_output.h</code> APIs.</p>
+
+<p></p>
 
 <p>Here is an example that shows how to write the output to the console, (We
 serialize the SOAP envelope created in code listing 1).</p>
@@ -577,7 +645,12 @@
 buffer = (axis2_char_t*)AXIS2_XML_WRITER_GET_XML(xml_writer, env);
 printf("%s ", buffer);</pre>
 
-<p>An easy way to serialize is to use the to_string function in om_element</p>
+<p></p>
+
+<p>An easy way to serialize is to use the <code>to_string</code> function in
+om_element</p>
+
+<p></p>
 
 <p><b>Code Listing 9</b></p>
 <pre class="code">axis2_char_t *xml_output = NULL; 
@@ -596,223 +669,242 @@
 printf("%s", xml_output);
 AXIS2_FREE(env-&gt;allocator, xml_output);</pre>
 
-<p>Note that freing the returned buffer is users responsibility</p>
-
 <p></p>
 
-<p><b>Using axis2_xml_reader and axis2_xml_writer</b></p>
+<p>Note that freeing the returned buffer is user's responsibility.</p>
 
-<p>axis2_xml_reader provides three create functions that and can be used for
-different xml input sources.</p>
+<p></p>
 
-<p>axis2_xml_reader_create_for_file() functon can be used to read from a
-file.</p>
+<a id="Reader_and_Writer"></a>
+<h3><b>Using axis2_xml_reader and axis2_xml_writer</b></h3>
 
-<p>axis2_xml_reader_create_for_io uses a user defined callback function to
-pull xml.</p>
+<p><code>axis2_xml_reader</code> provides three create functions that and can
+be used for different xml input sources.</p>
+<ul>
+  <li><code>axis2_xml_reader_create_for_file</code> functon can be used to
+    read from a file.</li>
+  <li><code>axis2_xml_reader_create_for_io</code> uses a user defined
+    callback function to pull xml.</li>
+  <li><code>axis2_xml_reader_create_for_memory</code> can be used to read
+    from an xml string that is in a character buffer.</li>
+</ul>
 
-<p>axis2_xml_reader_create_for_memory can be used to read from an xml string
-that is in a character buffer.</p>
+<p></p>
 
-<p>Similarly xml_writer provides two create functions,</p>
+<p>Similarly <code>axis2_xml_writer</code> provides two create functions.</p>
+<ul>
+  <li><code>axis2_xml_writer_create_for_file</code> can be used to write to a
+    file.</li>
+  <li><code>axis2_xml_writer_create_for_memory</code> can be used to write to
+    an internal memory buffer and obtain the xml string to a charcater buffer
+    as the output.</li>
+</ul>
 
-<p>axis2_xml_writer_create_for_file can be used to write to a file.</p>
+<p></p>
 
-<p>axis2_xml_writer_create_for_memory can be used to write to an internal
-memory buffer and obtain the xml string to a charcater buffer as</p>
+<p>Please refer to <code>axis2_xml_reader.h</code> and
+<code>axis2_xml_writer.h</code> for more information.</p>
 
-<p>the output. Please refer to axis2_xml_reader.h and axis2_xml_writer.h for
-more information.</p>
+<p></p>
 
-<p><b>How to avoid memory leaks and double frees when using om</b></p>
+<a id="Mem_Leaks"></a>
+<h3><b>How to avoid memory leaks and double frees when using OM</b></h3>
 
-<p>You have to be extremly carefull when using om in order to avoid memory
-leaks and double free errors. Following guide lines will be very useful.</p>
+<p>You have to be extremely carefull when using om in order to avoid memory
+leaks and double free errors. Following guidelines will be very useful.</p>
 
-<p>1. om_element_t struct keeps a list of attributes and a list of
-namespaces, when a namespace pointer is added to this list , it will be freed
-when this om_element is freed, Therefore same pointer to a namespace or an
-attribute should not be passed twice to a create , add or set function.</p>
+<p>1. <code>om_element_t</code> struct keeps a list of attributes and a list
+of namespaces, when a namespace pointer is added to this list , it will be
+freed when this om_element is freed, Therefore same pointer to a namespace or
+an attribute should not be passed twice to a <code>create</code> , add or
+<code>set</code> function.</p>
 
 <p>To avoid the inconvenience, clone functions have been implemented for both
 axiom_namespace and axiom_attribute structures.</p>
 
-<p>2. OM returns shallow references to its string values , Therefore when
-using the returned values , AXIS2_STRDUP () function should be used</p>
+<p></p>
+
+<p>2. OM returns shallow references to its string values. Therefore when
+using the returned values, AXIS2_STRDUP () function should be used to avoid
+double free errors, if the returned value is going to be set to another
+struct.</p>
 
-<p>if the returned value is going to be set to another struct to avoid double
-free errors.</p>
+<p>Eg.:</p>
 
-<p>Example:</p>
+<p><code>axiom_namespace_t *ns = NULL;</code></p>
 
-<p>axiom_namespace_t *ns = NULL;</p>
+<p><code>axis2_char_t *uri = NULL;</code></p>
 
-<p>axis2_char_t *uri = NULL;</p>
+<p><code>ns = axiom_namespace_create(env, "http://ws.apache.org",
+"om");</code></p>
 
-<p>ns = axiom_namespace_create(env, "http://ws.apache.org", "om");</p>
+<p><code>uri = AXIOM_NAMESPACE_GET_URI(ns, env);</code></p>
 
-<p>uri = AXIOM_NAMESPACE_GET_URI(ns, env);</p>
+<p><code>/** now uri points to the same place where namespace structs uri
+pointer is pointing */</code></p>
 
-<p>/** now uri points to the same place where namespace structs uri pointer
-is pointing */</p>
+<p><code>Therefore following will cause a double free */</code></p>
 
-<p>Therefore following will cause a double free */</p>
+<p><code>AXIS2_FREE(env-&gt;allocator, uri);</code></p>
 
-<p>AXIS2_FREE(env-&gt;allocator, uri);</p>
+<p><code>AXIOM_NAMESPACE_FREE(ns, env);</code></p>
 
-<p>AXIOM_NAMESPACE_FREE(ns, env);</p>
+<p></p>
 
 <p>3. when creating om programatically , if you are declaring a namespace to
-an om elment it is advisible to find whether the namespace is already
-availble in the elements scope, using find_namespace function; if available,
+an om elment, it is advisible to find whether the namespace is already
+availble in the elements scope using find_namespace function. If available,
 that pointer can be used instead of creating another namespace struct
 instance to prevent memory leaks.</p>
 
-<p><b>Complete code for the OM based document building and
-serialization</b></p>
+<p></p>
+
+<a id="Complete_Sample"></a>
+<h3><b>Complete code for the OM based document building and
+serialization</b></h3>
 
 <p>The following code segment shows how to use the OM for completely building
 a document and then serializing it into text pushing the output to the
 console.</p>
 
 <div>
-<p><b>Code Listing 10</b></p>
-
 <p></p>
+
+<p><b>Code Listing 10</b></p>
 </div>
-<pre>#include &lt;axiom_node.h&gt;
-#include &lt;axis2.h&gt;
-#include &lt;axis2_env.h&gt;
-#include &lt;axiom_element.h&gt;
-#include &lt;axiom_document.h&gt;
-#include &lt;axiom_stax_builder.h&gt;
-#include &lt;axis2_xml_reader.h&gt;
-#include &lt;axis2_log_default.h&gt;
-#include &lt;axis2_error_default.h&gt;
-#include &lt;axis2_xml_writer.h&gt;
-#include &lt;axiom_output.h&gt;
-#include &lt;stdio.h&gt;
+<pre>#include&nbsp;&lt;axiom_node.h&gt;
+#include&nbsp;&lt;axis2.h&gt;
+#include&nbsp;&lt;axis2_env.h&gt;
+#include&nbsp;&lt;axiom_element.h&gt;
+#include&nbsp;&lt;axiom_document.h&gt;
+#include&nbsp;&lt;axiom_stax_builder.h&gt;
+#include&nbsp;&lt;axis2_xml_reader.h&gt;
+#include&nbsp;&lt;axis2_log_default.h&gt;
+#include&nbsp;&lt;axis2_error_default.h&gt;
+#include&nbsp;&lt;axis2_xml_writer.h&gt;
+#include&nbsp;&lt;axiom_output.h&gt;
+#include&nbsp;&lt;stdio.h&gt;
 
 
-FILE *f = NULL;
-int read_input_callback(char *buffer, int size, void* ctx)
+FILE&nbsp;*f&nbsp;=&nbsp;NULL;
+int&nbsp;read_input_callback(char&nbsp;*buffer,&nbsp;int&nbsp;size,&nbsp;void*&nbsp;ctx)
 
 {
-    <b>return</b> fread(buffer, <b>sizeof</b>(char), size, f);
+&nbsp;&nbsp;&nbsp;&nbsp;<b>return</b>&nbsp;fread(buffer,&nbsp;<b>sizeof</b>(char),&nbsp;size,&nbsp;f);
 }
-int close_input_callback(void *ctx)
+int&nbsp;close_input_callback(void *ctx)
 {
-    <b>return</b> fclose(f);
+&nbsp;&nbsp;&nbsp;&nbsp;<b>return</b>&nbsp;fclose(f);
 }
 
-axis2_env_t * create_environment()
+axis2_env_t&nbsp;*&nbsp;create_environment()
 
 {
-    axis2_allocator_t *allocator = NULL;
-    axis2_env_t *env = NULL;
-    axis2_log_t *log = NULL;
-
-    axis2_error_t *error = NULL;
-    allocator = axis2_allocator_init(NULL);
-    log = axis2_log_create(allocator, NULL, NULL);
-
-    error = axis2_error_create(allocator);
-    env = axis2_env_create_with_error_log(allocator, error, log);
-    <b>return</b> env;
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_allocator_t&nbsp;*allocator&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_env_t&nbsp;*env&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_log_t&nbsp;*log&nbsp;=&nbsp;NULL;
+
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_error_t&nbsp;*error&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;allocator&nbsp;=&nbsp;axis2_allocator_init(NULL);
+&nbsp;&nbsp;&nbsp;&nbsp;log&nbsp;=&nbsp;axis2_log_create(allocator,&nbsp;NULL,&nbsp;NULL);
+
+&nbsp;&nbsp;&nbsp;&nbsp;error&nbsp;=&nbsp;axis2_error_create(allocator);
+&nbsp;&nbsp;&nbsp;&nbsp;env&nbsp;=&nbsp;axis2_env_create_with_error_log(allocator,&nbsp;error, log);
+&nbsp;&nbsp;&nbsp;&nbsp;<b>return</b>&nbsp;env;
 }
 
-build_and_serialize_om(axis2_env_t **env)
+build_and_serialize_om(axis2_env_t&nbsp;**env)
 {
-    axiom_node_t *root_node = NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;axiom_node_t&nbsp;*root_node&nbsp;=&nbsp;NULL;
 
-    axiom_element_t *root_ele = NULL;
-    axiom_document_t *document = NULL;
-    axiom_stax_builder_t *om_builder = NULL;
-
-    axis2_xml_reader_t *xml_reader = NULL;
-    axis2_xml_writer_t *xml_writer = NULL;
-    axiom_output_t *om_output = NULL;
-
-    axis2_char_t *buffer = NULL;
-    
-    f = fopen("test.xml","r");
-    xml_reader = axis2_xml_reader_create_for_io(env, read_input_callback,
-                                                    close_input_callback, NULL, NULL);
-    <b>if</b>(!xml_reader)
-        <b>return</b> -1;
-
-    om_builder = axiom_stax_builder_create(env, xml_reader);
-    <b>if</b>(!om_builder)
-    {
-        AXIS2_XML_READER_FREE(xml_reader, env);
-        <b>return</b> AXIS2_FAILURE;
-    }
-    document = AXIOM_STAX_BUILDER_GET_DOCUMENT(om_builder, env);
-    <b>if</b>(!document)
-    {
-        AXIOM_STAX_BUILDER_FREE(om_builder, env);
-        <b>return</b> AXIS2_FAILURE;
-    }
-    
-    root_node = AXIOM_DOCUMENT_GET_ROOT_ELEMENT(document, env);
-    <b>if</b>(!root_node)
-    {
-        AXIOM_STAX_BUILDER_FREE(om_builder, env);
-        <b>return</b> AXIS2_FAILURE;
-    }        
-    <b>if</b>(root_node)
-    {
-        <b>if</b>(AXIOM_NODE_GET_NODE_TYPE(root_node, env) == AXIOM_ELEMENT)
-        {
-            root_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT (root_node, env);
-            <b>if</b>(root_ele)
-            {
-                printf(" %s" , AXIOM_ELEMENT_GET_LOCALNAME(root_ele, env));
-            }
-        }
-    }
-    AXIOM_DOCUMENT_BUILD_ALL(document, env);
-    
-    xml_writer = axis2_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, AXIS2_XML_PARSER_TYPE_BUFFER);
-    
-    om_output = axiom_output_create(env, xml_writer);
-    
-    AXIOM_NODE_SERIALIZE(root_node, env, om_output);
-    buffer = (axis2_char_t*)AXIS2_XML_WRITER_GET_XML(xml_writer, env);
-
-    printf("The output XML is -&gt;&gt;&gt;&gt;\n %s ", buffer);
-
-    
-    <i>/** when om_output is freed xml_writer is also freed */</i>
-    
-    AXIOM_OUTPUT_FREE(om_output, env);
-    
-    <i>/** when om_builder is freed , the builder, om_document and the entire om structure is freed */</i>
-    AXIOM_STAX_BUILDER_FREE(om_builder, env);
-    
-    AXIS2_FREE(env-&gt;allocator, buffer);
-    
-    <b>return</b> AXIS2_SUCCESS;
-    
+&nbsp;&nbsp;&nbsp;&nbsp;axiom_element_t&nbsp;*root_ele&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;axiom_document_t&nbsp;*document&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;axiom_stax_builder_t&nbsp;*om_builder&nbsp;=&nbsp;NULL;
+
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_xml_reader_t&nbsp;*xml_reader&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_xml_writer_t&nbsp;*xml_writer&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;axiom_output_t&nbsp;*om_output&nbsp;=&nbsp;NULL;
+
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_char_t&nbsp;*buffer&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;f&nbsp;=&nbsp;fopen("test.xml","r");
+&nbsp;&nbsp;&nbsp;&nbsp;xml_reader&nbsp;=&nbsp;axis2_xml_reader_create_for_io(env,&nbsp;read_input_callback,
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;close_input_callback,&nbsp;NULL,&nbsp;NULL);
+&nbsp;&nbsp;&nbsp;&nbsp;<b>if</b>(!xml_reader)
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>return</b>&nbsp;-1;
+
+&nbsp;&nbsp;&nbsp;&nbsp;om_builder&nbsp;=&nbsp;axiom_stax_builder_create(env,&nbsp;xml_reader);
+&nbsp;&nbsp;&nbsp;&nbsp;<b>if</b>(!om_builder)
+&nbsp;&nbsp;&nbsp;&nbsp;{
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;AXIS2_XML_READER_FREE(xml_reader,&nbsp;env);
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>return</b>&nbsp;AXIS2_FAILURE;
+&nbsp;&nbsp;&nbsp;&nbsp;}
+&nbsp;&nbsp;&nbsp;&nbsp;document&nbsp;=&nbsp;AXIOM_STAX_BUILDER_GET_DOCUMENT(om_builder, env);
+&nbsp;&nbsp;&nbsp;&nbsp;<b>if</b>(!document)
+&nbsp;&nbsp;&nbsp;&nbsp;{
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;AXIOM_STAX_BUILDER_FREE(om_builder,&nbsp;env);
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>return</b>&nbsp;AXIS2_FAILURE;
+&nbsp;&nbsp;&nbsp;&nbsp;}
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;root_node&nbsp;=&nbsp;AXIOM_DOCUMENT_GET_ROOT_ELEMENT(document,&nbsp;env);
+&nbsp;&nbsp;&nbsp;&nbsp;<b>if</b>(!root_node)
+&nbsp;&nbsp;&nbsp;&nbsp;{
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;AXIOM_STAX_BUILDER_FREE(om_builder,&nbsp;env);
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>return</b>&nbsp;AXIS2_FAILURE;
+&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;<b>if</b>(root_node)
+&nbsp;&nbsp;&nbsp;&nbsp;{
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>if</b>(AXIOM_NODE_GET_NODE_TYPE(root_node,&nbsp;env)&nbsp;==&nbsp;AXIOM_ELEMENT)
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;root_ele&nbsp;=&nbsp;(axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT&nbsp;(root_node,&nbsp;env);
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>if</b>(root_ele)
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf("&nbsp;%s"&nbsp;,&nbsp;AXIOM_ELEMENT_GET_LOCALNAME(root_ele,&nbsp;env));
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}
+&nbsp;&nbsp;&nbsp;&nbsp;}
+&nbsp;&nbsp;&nbsp;&nbsp;AXIOM_DOCUMENT_BUILD_ALL(document,&nbsp;env);
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;xml_writer&nbsp;=&nbsp;axis2_xml_writer_create_for_memory(env,&nbsp;NULL,&nbsp;AXIS2_TRUE,&nbsp;0, AXIS2_XML_PARSER_TYPE_BUFFER);
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;om_output&nbsp;=&nbsp;axiom_output_create(env,&nbsp;xml_writer);
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;AXIOM_NODE_SERIALIZE(root_node,&nbsp;env,&nbsp;om_output);
+&nbsp;&nbsp;&nbsp;&nbsp;buffer&nbsp;=&nbsp;(axis2_char_t*)AXIS2_XML_WRITER_GET_XML(xml_writer,&nbsp;env);
+
+&nbsp;&nbsp;&nbsp;&nbsp;printf("The&nbsp;output&nbsp;XML&nbsp;is&nbsp;-&gt;&gt;&gt;&gt;\n&nbsp;%s&nbsp;",&nbsp;buffer);
+
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;<i>/**&nbsp;when&nbsp;om_output&nbsp;is&nbsp;freed&nbsp;xml_writer&nbsp;is&nbsp;also&nbsp;freed&nbsp;*/</i>
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;AXIOM_OUTPUT_FREE(om_output,&nbsp;env);
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;<i>/**&nbsp;when&nbsp;om_builder&nbsp;is&nbsp;freed&nbsp;,&nbsp;the&nbsp;builder,&nbsp;om_document&nbsp;and&nbsp;the&nbsp;entire&nbsp;om&nbsp;structure&nbsp;is&nbsp;freed&nbsp;*/</i>
+&nbsp;&nbsp;&nbsp;&nbsp;AXIOM_STAX_BUILDER_FREE(om_builder,&nbsp;env);
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;AXIS2_FREE(env-&gt;allocator,&nbsp;buffer);
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;<b>return</b>&nbsp;AXIS2_SUCCESS;
+&nbsp;&nbsp;&nbsp;&nbsp;
 }
-int main()
+int&nbsp;main()
 {
-    int status = AXIS2_SUCCESS;
-    
-    axis2_env_t *env = NULL;
-    axis2_allocator_t *allocator = NULL;
-    env = create_environment();
+&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;status&nbsp;=&nbsp;AXIS2_SUCCESS;
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_env_t&nbsp;*env&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_allocator_t&nbsp;*allocator&nbsp;=&nbsp;NULL;
+&nbsp;&nbsp;&nbsp;&nbsp;env&nbsp;=&nbsp;create_environment();
 <br />
-    status = build_and_serialize_om(env);
+&nbsp;&nbsp;&nbsp;&nbsp;status&nbsp;=&nbsp;build_and_serialize_om(env);
 
-    <b>if</b>(status == AXIS2_FAILURE)
-    {
-        printf(" build om failed");
-    }
-    
-    axis2_env_free(env);
-    
-    <b>return</b> 0;
+&nbsp;&nbsp;&nbsp;&nbsp;<b>if</b>(status&nbsp;==&nbsp;AXIS2_FAILURE)
+&nbsp;&nbsp;&nbsp;&nbsp;{
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf("&nbsp;build&nbsp;om&nbsp;failed");
+&nbsp;&nbsp;&nbsp;&nbsp;}
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;axis2_env_free(env);
+&nbsp;&nbsp;&nbsp;&nbsp;
+&nbsp;&nbsp;&nbsp;&nbsp;<b>return</b>&nbsp;0;
 }</pre>
 </body>
 </html>



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message