Index: modules/xml/guththila/src/namespace.h
===================================================================
--- modules/xml/guththila/src/namespace.h	(revision 292912)
+++ modules/xml/guththila/src/namespace.h	(working copy)
@@ -18,8 +18,8 @@
  */
 
 
-#ifndef __NAMESPACE__INCLUDED__
-#define __NAMESPACE__INCLUDED__
+#ifndef NAMESPACE_H
+#define NAMESPACE_H
 #include "token.h"
 
 typedef struct namespace
@@ -32,4 +32,4 @@
 
 
 
-#endif
+#endif /* NAMESPACE_H */
Index: modules/xml/guththila/src/reader.h
===================================================================
--- modules/xml/guththila/src/reader.h	(revision 292912)
+++ modules/xml/guththila/src/reader.h	(working copy)
@@ -18,8 +18,8 @@
  */
 
 
-#ifndef __READER__INCLUDED__
-#define __READER__INCLUDED__
+#ifndef READER_H
+#define READER_H
 #include <stdio.h>
 #include <stdlib.h>
 #include "buffer.h"
@@ -36,4 +36,4 @@
 int Reader_setInputStream (READER *r, FILE *fp);
 void Reader_freeReader (READER *r);
 
-#endif
+#endif /* READER_H */
Index: modules/xml/guththila/src/attribute.h
===================================================================
--- modules/xml/guththila/src/attribute.h	(revision 292912)
+++ modules/xml/guththila/src/attribute.h	(working copy)
@@ -17,8 +17,8 @@
  * @author Dinesh Premalal (xydinesh@gmail.com, premalwd@cse.mrt.ac.lk)	
  */
 
-#ifndef __ATTRIBUTE_INCLUDED__
-#define __ATTRIBUTE_INCLUDED__
+#ifndef ATTRIBUTE_H
+#define ATTRIBUTE_H
 #include "token.h"
 
 typedef struct attribute
@@ -28,4 +28,4 @@
   TOKEN *value;
 }ATTRIBUTE;
 
-#endif /* finish Attribute included */
+#endif /* ATTRIBUTE_H */
Index: modules/xml/guththila/src/depth.h
===================================================================
--- modules/xml/guththila/src/depth.h	(revision 292912)
+++ modules/xml/guththila/src/depth.h	(working copy)
@@ -18,8 +18,8 @@
  */
 
 
-#ifndef __DEPTH__INCLUDED__
-#define __DEPTH__INCLUDED__
+#ifndef DEPTH_H
+#define DEPTH_H
 
 typedef struct depth
 {
@@ -29,4 +29,4 @@
 }DEPTH;
 
 
-#endif /* end DEPTH__INCLUDED */
+#endif /* DEPTH_H*/
Index: modules/xml/guththila/src/stack.h
===================================================================
--- modules/xml/guththila/src/stack.h	(revision 292912)
+++ modules/xml/guththila/src/stack.h	(working copy)
@@ -18,8 +18,9 @@
  */
 
 
-#ifndef __STACK_INCLUDED__
-#define __STACK_INCLUDED__
+#ifndef STACK_H
+#define STACK_H
+
 #include "token.h"
 #include "attribute.h"
 #include "namespace.h"
@@ -34,7 +35,7 @@
 
 typedef struct element ELEMENT;
 
-struct element
+typedef struct element
 {
   TOKEN *token;
   ATTRIBUTE *attribute;
@@ -67,4 +68,4 @@
 ELEMENT *Stack_get (STACK *st, int i);
 
 
-#endif /* end of__STACK_INCLUDED__ */
+#endif /* STACK_H */
Index: modules/xml/guththila/src/xmlpullparser.c
===================================================================
--- modules/xml/guththila/src/xmlpullparser.c	(revision 292912)
+++ modules/xml/guththila/src/xmlpullparser.c	(working copy)
@@ -17,13 +17,13 @@
  * @author Dinesh Premalal (xydinesh@gmail.com, premalwd@cse.mrt.ac.lk)	
  */
 
-
 #include "xmlpullparser.h"
 
-XML_PULLPARSER
-XML_PullParser_createPullParser (READER *r)
+XML_PullParser *
+XML_PullParser_createPullParser (READER * r)
 {
-  XML_PullParser *parser = (XML_PullParser *) malloc (sizeof (XML_PullParser));
+  XML_PullParser *parser =
+    (XML_PullParser *) malloc (sizeof (XML_PullParser));
   parser->buffer = Buffer_createBuffer (1024);
   parser->stack = Stack_createStack ();
   parser->attrib = Stack_createStack ();
@@ -43,10 +43,10 @@
 
 
 void
-XML_PullParser_freePullParser (XML_PullParser *parser)
+XML_PullParser_freePullParser (XML_PullParser * parser)
 {
   if (parser->buffer)
-    free ((void *)parser->buffer);
+    free ((void *) parser->buffer);
   if (parser->reader)
     free (parser->reader);
   if (parser->stack)
@@ -57,11 +57,11 @@
     Stack_free (parser->namesp);
   if (parser->dep)
     Stack_free (parser->dep);
-    free ((void *)parser);
+  free ((void *) parser);
 }
 
 
-PRIVATE int 
+int
 XML_PullParser_Exception (char *file, int line)
 {
   printf ("Throws XML_PullParser_Exception \t %s \t %d \n", file, line);
@@ -69,11 +69,11 @@
 }
 
 
-PRIVATE void
-XML_PullParser_relocateTokens (XML_PullParser *parser, int offset)
+void
+XML_PullParser_relocateTokens (XML_PullParser * parser, int offset)
 {
   ELEMENT *el;
-  int isize; 
+  int isize;
   isize = Stack_size (parser->stack);
   el = Stack_last (parser->stack);
   for (; isize > 0; isize--)
@@ -84,20 +84,21 @@
 }
 
 
-PRIVATE void
-XML_PullParser_shift (XML_PullParser *parser)
+void
+XML_PullParser_shift (XML_PullParser * parser)
 {
-  memmove (parser->buffer->buff, parser->buffer->buff+(parser->offset), (parser->_next) - (parser->offset));
-  parser-> _next -= parser->offset;
+  memmove (parser->buffer->buff, parser->buffer->buff + (parser->offset),
+	   (parser->_next) - (parser->offset));
+  parser->_next -= parser->offset;
   parser->last -= parser->offset;
   parser->offset = 0;
 }
 
 
-PRIVATE int
-XML_PullParser_read (XML_PullParser *parser)
+int
+XML_PullParser_read (XML_PullParser * parser)
 {
- int c = 0;
+  int c = 0;
   if (parser->_next == parser->buffer->size)
     {
       if (parser->offset > 0)
@@ -110,19 +111,22 @@
 	  BUFFER *b;
 	  b = parser->buffer;
 	  parser->buffer = Buffer_grow (parser->buffer);
-	  XML_PullParser_relocateTokens (parser, (b->size - parser->buffer->size));
+	  XML_PullParser_relocateTokens (parser,
+					 (b->size - parser->buffer->size));
 	}
     }
-  c = Reader_read ((parser->buffer->buff), (parser->_next), (parser->buffer->size)-(parser->_next), parser->reader);
+  c =
+    Reader_read ((parser->buffer->buff), (parser->_next),
+		 (parser->buffer->size) - (parser->_next), parser->reader);
   parser->last += c;
   return !c;
 }
 
 
-PRIVATE int
-XML_PullParser_from_utf16 (XML_PullParser *parser, int eof)
+int
+XML_PullParser_from_utf16 (XML_PullParser * parser, int eof)
 {
-  int c = parser->buffer->buff [parser->_next++];
+  int c = parser->buffer->buff[parser->_next++];
   if (((parser->_next) > (parser->last)) && XML_PullParser_read (parser))
     {
       if (eof)
@@ -131,13 +135,13 @@
 	XML_PullParser_Exception (p_FILE, LINE);
     }
   while (!c)
-    c = parser->buffer->buff [parser->_next++];
+    c = parser->buffer->buff[parser->_next++];
   return c;
 }
 
 
-PRIVATE int
-XML_PullParser_nextChar (XML_PullParser *parser, int eof)
+int
+XML_PullParser_nextChar (XML_PullParser * parser, int eof)
 {
   if (((parser->_next) > (parser->last)) && XML_PullParser_read (parser))
     {
@@ -148,21 +152,21 @@
     }
   if (parser->_next == 0)
     {
-      UTF8_char iu = (UTF8_char) parser->buffer->buff [parser->_next++];
+      UTF8_char iu = (UTF8_char) parser->buffer->buff[parser->_next++];
 
       if (0xff == iu
-	  && 0xfe == (UTF8_char) parser->buffer->buff [parser->_next++])
-	{	  
+	  && 0xfe == (UTF8_char) parser->buffer->buff[parser->_next++])
+	{
 	  parser->unicode_state = LE;
 	}
       else if (0xfe == iu
-	       && 0xff == (UTF8_char) parser->buffer->buff [parser->_next++])
+	       && 0xff == (UTF8_char) parser->buffer->buff[parser->_next++])
 	{
 	  parser->unicode_state = BE;
 	}
       else if (0xef == iu
-	       && 0xbb == (UTF8_char) parser->buffer->buff [parser->_next++]
-	       && 0xbf == (UTF8_char) parser->buffer->buff [parser->_next++])
+	       && 0xbb == (UTF8_char) parser->buffer->buff[parser->_next++]
+	       && 0xbf == (UTF8_char) parser->buffer->buff[parser->_next++])
 	{
 	  parser->unicode_state = None;
 	}
@@ -180,15 +184,15 @@
 }
 
 
-PRIVATE char *
-XML_PullParser_lastChar (XML_PullParser *parser)
+char *
+XML_PullParser_lastChar (XML_PullParser * parser)
 {
-  return parser->buffer->buff + (parser->_next-1);
+  return parser->buffer->buff + (parser->_next - 1);
 }
 
 
-PRIVATE void
-XML_PullParser_openToken (XML_PullParser *parser)
+void
+XML_PullParser_openToken (XML_PullParser * parser)
 {
   TOKEN *t = (TOKEN *) malloc (sizeof (TOKEN));
   t->type = Unknown;
@@ -197,18 +201,18 @@
 }
 
 
-PRIVATE void
-XML_PullParser_closeToken (XML_PullParser *parser, int t, int refer)
+void
+XML_PullParser_closeToken (XML_PullParser * parser, int t, int refer)
 {
-  ELEMENT *e= Stack_last (parser->stack);
+  ELEMENT *e = Stack_last (parser->stack);
   e->token->type = t;
   e->token->ref = refer;
-  e->token->end = XML_PullParser_lastChar (parser)-1;
+  e->token->end = XML_PullParser_lastChar (parser) - 1;
 }
 
 
-PRIVATE int
-XML_PullParser_skipS (XML_PullParser *parser, int c)
+int
+XML_PullParser_skipS (XML_PullParser * parser, int c)
 {
   while (0x20 == c || 0x9 == c || 0xD == c || 0xA == c)
     c = XML_PullParser_nextChar (parser, 0);
@@ -216,11 +220,11 @@
 }
 
 
-PRIVATE int
-XML_PullParser_processEq (XML_PullParser *parser, int c)
+int
+XML_PullParser_processEq (XML_PullParser * parser, int c)
 {
   int ic;
-  if ( 0x3D == XML_PullParser_skipS (parser, c))
+  if (0x3D == XML_PullParser_skipS (parser, c))
     {
       ic = XML_PullParser_nextChar (parser, 0);
       return XML_PullParser_skipS (parser, ic);
@@ -231,8 +235,8 @@
 }
 
 
-PRIVATE int 
-XML_PullParser_processVersionInfo (XML_PullParser *parser)
+int
+XML_PullParser_processVersionInfo (XML_PullParser * parser)
 {
   int ic;
   int quote;
@@ -252,10 +256,10 @@
 	  ic = XML_PullParser_nextChar (parser, 0);
 	  XML_PullParser_closeToken (parser, Attribute, 0);
 	  quote = XML_PullParser_processEq (parser, ic);
-	  nc = XML_PullParser_nextChar (parser, 0); 
+	  nc = XML_PullParser_nextChar (parser, 0);
 	  /* 0, since we don't expect EOF line here */
 	  XML_PullParser_openToken (parser);
-	  while ( quote != nc)
+	  while (quote != nc)
 	    nc = XML_PullParser_nextChar (parser, 0);
 	  XML_PullParser_closeToken (parser, AttValue, 0);
 	  nc = XML_PullParser_nextChar (parser, 0);
@@ -264,26 +268,26 @@
       else
 	XML_PullParser_Exception (p_FILE, LINE);
     }
-	else
+  else
     XML_PullParser_Exception (p_FILE, LINE);
   return 0;
 }
 
 
-PRIVATE int
-XML_PullParser_processEncodingDecl (XML_PullParser *parser)
+int
+XML_PullParser_processEncodingDecl (XML_PullParser * parser)
 {
   int quote;
   int nc;
   int ic;
   XML_PullParser_openToken (parser);
-  if ( 'n' == XML_PullParser_nextChar (parser, 0)
-       && 'c' == XML_PullParser_nextChar (parser, 0)
-       && 'o' == XML_PullParser_nextChar (parser, 0)
-       && 'd' == XML_PullParser_nextChar (parser, 0)
-       && 'i' == XML_PullParser_nextChar (parser, 0)
-       && 'n' == XML_PullParser_nextChar (parser, 0)
-       && 'g' == XML_PullParser_nextChar (parser, 0))
+  if ('n' == XML_PullParser_nextChar (parser, 0)
+      && 'c' == XML_PullParser_nextChar (parser, 0)
+      && 'o' == XML_PullParser_nextChar (parser, 0)
+      && 'd' == XML_PullParser_nextChar (parser, 0)
+      && 'i' == XML_PullParser_nextChar (parser, 0)
+      && 'n' == XML_PullParser_nextChar (parser, 0)
+      && 'g' == XML_PullParser_nextChar (parser, 0))
     {
       ic = XML_PullParser_nextChar (parser, 0);
       XML_PullParser_closeToken (parser, Attribute, 0);
@@ -302,33 +306,33 @@
 }
 
 
-PRIVATE int
-XML_PullParser_processSDDecl (XML_PullParser *parser)
+int
+XML_PullParser_processSDDecl (XML_PullParser * parser)
 {
   int quote = 0;
   int nc = 0;
   int ic = 0;
   XML_PullParser_openToken (parser);
-  if ( 't' == XML_PullParser_nextChar (parser, 0)
-       && 'a' == XML_PullParser_nextChar (parser, 0)
-       && 'n' == XML_PullParser_nextChar (parser, 0)
-       && 'd' == XML_PullParser_nextChar (parser, 0)
-       && 'a' == XML_PullParser_nextChar (parser, 0)
-       && 'l' == XML_PullParser_nextChar (parser, 0)
-       && 'o' == XML_PullParser_nextChar (parser, 0)
-       && 'n' == XML_PullParser_nextChar (parser, 0)
-       && 'e' == XML_PullParser_nextChar (parser, 0))
-  ic = XML_PullParser_nextChar (parser, 0);
+  if ('t' == XML_PullParser_nextChar (parser, 0)
+      && 'a' == XML_PullParser_nextChar (parser, 0)
+      && 'n' == XML_PullParser_nextChar (parser, 0)
+      && 'd' == XML_PullParser_nextChar (parser, 0)
+      && 'a' == XML_PullParser_nextChar (parser, 0)
+      && 'l' == XML_PullParser_nextChar (parser, 0)
+      && 'o' == XML_PullParser_nextChar (parser, 0)
+      && 'n' == XML_PullParser_nextChar (parser, 0)
+      && 'e' == XML_PullParser_nextChar (parser, 0))
+    ic = XML_PullParser_nextChar (parser, 0);
   XML_PullParser_closeToken (parser, Attribute, 0);
   quote = XML_PullParser_processEq (parser, ic);
   nc = XML_PullParser_nextChar (parser, 0);
   XML_PullParser_openToken (parser);
   while (quote != nc)
     {
-      if ( 'y' == nc)
+      if ('y' == nc)
 	{
-	  if ( 'e' != XML_PullParser_nextChar (parser, 0)
-	       || 's' != XML_PullParser_nextChar (parser, 0))
+	  if ('e' != XML_PullParser_nextChar (parser, 0)
+	      || 's' != XML_PullParser_nextChar (parser, 0))
 	    XML_PullParser_Exception (p_FILE, LINE);
 	  else
 	    nc = XML_PullParser_nextChar (parser, 0);
@@ -337,7 +341,7 @@
 	{
 	  if ('o' != XML_PullParser_nextChar (parser, 0))
 	    XML_PullParser_Exception (p_FILE, LINE);
-	  else 
+	  else
 	    nc = XML_PullParser_nextChar (parser, 0);
 	}
       else
@@ -349,13 +353,13 @@
 }
 
 
-PRIVATE int 
-XML_PullParser_processXmlDecl (XML_PullParser *parser)
+int
+XML_PullParser_processXmlDecl (XML_PullParser * parser)
 {
   int ix;
-  if ( 'x' == XML_PullParser_nextChar (parser, 0) 
-       && 'm' == XML_PullParser_nextChar (parser, 0)
-       && 'l' == XML_PullParser_nextChar (parser, 0))
+  if ('x' == XML_PullParser_nextChar (parser, 0)
+      && 'm' == XML_PullParser_nextChar (parser, 0)
+      && 'l' == XML_PullParser_nextChar (parser, 0))
     {
       ix = XML_PullParser_processVersionInfo (parser);
 
@@ -366,7 +370,7 @@
 	ix = XML_PullParser_processSDDecl (parser);
 
       if ('?' == ix)
-	 {
+	{
 	  if ('>' != XML_PullParser_nextChar (parser, 0))
 	    XML_PullParser_Exception (p_FILE, LINE);
 	  else
@@ -379,8 +383,8 @@
 }
 
 
-PRIVATE void
-XML_PullParser_reset (XML_PullParser *parser)
+void
+XML_PullParser_reset (XML_PullParser * parser)
 {
   parser->offset = parser->_next;
   parser->name = NULL;
@@ -393,18 +397,18 @@
 }
 
 
-PRIVATE int
+int
 XML_PullParser_isS (int c)
 {
-  if (0x20 == c || 0xD == c|| 0xA == c || 0x9 == c)
+  if (0x20 == c || 0xD == c || 0xA == c || 0x9 == c)
     return 1;
-  else 
+  else
     return 0;
 }
 
 
-PRIVATE int
-XML_PullParser_is_valid_starting_char (XML_PullParser *parser, int c)
+int
+XML_PullParser_is_valid_starting_char (XML_PullParser * parser, int c)
 {
   if (isalpha (c) || '_' == c || ':' == c)
     return 1;
@@ -413,43 +417,45 @@
 }
 
 
-PRIVATE int
-XML_PullParser_processName (XML_PullParser *parser)
+int
+XML_PullParser_processName (XML_PullParser * parser)
 {
   int c;
   char *x;
   x = XML_PullParser_lastChar (parser);
   if (!XML_PullParser_is_valid_starting_char (parser, x[0]))
-  XML_PullParser_Exception (p_FILE, LINE);
+    XML_PullParser_Exception (p_FILE, LINE);
 
   XML_PullParser_openToken (parser);
   c = XML_PullParser_nextChar (parser, 0);
-  while (!(XML_PullParser_isS (c) || '/' == c || '=' == c || '?' == c || '>' == c))
-  {
-    if ( ':' == c)
-      {
-	XML_PullParser_closeToken (parser, Prefix, 0);
+  while (!
+	 (XML_PullParser_isS (c) || '/' == c || '=' == c || '?' == c
+	  || '>' == c))
+    {
+      if (':' == c)
+	{
+	  XML_PullParser_closeToken (parser, Prefix, 0);
+	  c = XML_PullParser_nextChar (parser, 0);
+	  XML_PullParser_openToken (parser);
+	}
+      else
 	c = XML_PullParser_nextChar (parser, 0);
-	XML_PullParser_openToken (parser);
-      }
-    else 
-      c = XML_PullParser_nextChar (parser, 0);
-  }
+    }
   XML_PullParser_closeToken (parser, Name, 0);
 
   return c;
 }
 
 
-PRIVATE int
-XML_PullParser_processAttValue (XML_PullParser *parser, int quote)
+int
+XML_PullParser_processAttValue (XML_PullParser * parser, int quote)
 {
   int c = 0;
-  if ( '\'' == quote || '\"' == quote)
+  if ('\'' == quote || '\"' == quote)
     {
       c = XML_PullParser_nextChar (parser, 0);
       XML_PullParser_openToken (parser);
-      do 
+      do
 	{
 	  c = XML_PullParser_nextChar (parser, 0);
 	  if (quote == c)
@@ -466,8 +472,8 @@
 }
 
 
-PRIVATE int
-XML_PullParser_processAttribute (XML_PullParser *parser, int c)
+int
+XML_PullParser_processAttribute (XML_PullParser * parser, int c)
 {
   int q;
   q = XML_PullParser_skipS (parser, c);
@@ -478,8 +484,8 @@
 }
 
 
-PRIVATE int
-XML_PullParser_processSTagOrEmptyElem (XML_PullParser *parser)
+int
+XML_PullParser_processSTagOrEmptyElem (XML_PullParser * parser)
 {
   int c;
   c = XML_PullParser_processName (parser);
@@ -490,7 +496,7 @@
       if ('/' == c)
 	{
 	  EVENT = EMPTY_ELEMENT;
-	  if ( '>' == XML_PullParser_nextChar (parser, 0))
+	  if ('>' == XML_PullParser_nextChar (parser, 0))
 	    return c;
 	  else
 	    XML_PullParser_Exception (p_FILE, LINE);
@@ -503,8 +509,8 @@
 }
 
 
-PRIVATE int
-XML_PullParser_processCharData (XML_PullParser *parser)
+int
+XML_PullParser_processCharData (XML_PullParser * parser)
 {
   int c;
   int ref = 0;
@@ -519,8 +525,8 @@
 
       if (c == -1)
 	{
-	XML_PullParser_closeToken (parser, CharData, ref);
-	return 0;
+	  XML_PullParser_closeToken (parser, CharData, ref);
+	  return 0;
 	}
     }
   while (c != '<');
@@ -529,8 +535,8 @@
 }
 
 
-PRIVATE int
-XML_PullParser_processETag (XML_PullParser *parser)
+int
+XML_PullParser_processETag (XML_PullParser * parser)
 {
   int c;
   c = XML_PullParser_nextChar (parser, 0);
@@ -544,8 +550,8 @@
 }
 
 
-PRIVATE int
-XML_PullParser_processPI (XML_PullParser *parser)
+int
+XML_PullParser_processPI (XML_PullParser * parser)
 {
   int c;
   EVENT = COMMENT;
@@ -556,12 +562,12 @@
 }
 
 
-PRIVATE int 
-XML_PullParser_processComment (XML_PullParser *parser)
+int
+XML_PullParser_processComment (XML_PullParser * parser)
 {
   int c;
-  if ( '-' == XML_PullParser_nextChar (parser, 0)
-       && '-' == XML_PullParser_nextChar (parser, 0))
+  if ('-' == XML_PullParser_nextChar (parser, 0)
+      && '-' == XML_PullParser_nextChar (parser, 0))
     {
       c = XML_PullParser_nextChar (parser, 0);
       while (1)
@@ -572,7 +578,7 @@
 	      c = XML_PullParser_nextChar (parser, 0);
 	      if ('-' == c)
 		{
-		  if ( '>' == XML_PullParser_nextChar (parser, 0))
+		  if ('>' == XML_PullParser_nextChar (parser, 0))
 		    {
 		      EVENT = COMMENT;
 		      while ('<' != c)
@@ -593,42 +599,42 @@
     {
       c = XML_PullParser_nextChar (parser, 0);
       while ('<' != c)
-	  c = XML_PullParser_nextChar (parser, -1);
+	c = XML_PullParser_nextChar (parser, -1);
     }
   return 0;
 }
 
 
-PRIVATE int
-XML_PullParser_tokenize (XML_PullParser *parser)
+int
+XML_PullParser_tokenize (XML_PullParser * parser)
 {
-  do 
+  do
     {
       int c;
       c = XML_PullParser_nextChar (parser, -1);
       if (c == -1)
 	return -1;
-      
+
       switch (parser->STATUS)
 	{
 	case S_1:
 	  if ('<' == c)
 	    parser->STATUS = S_2;
-	  else 
+	  else
 	    parser->STATUS = S_0;
 	  break;
 	case S_2:
 	  {
-	  if ( '?' == c)
-	    {
-	      XML_PullParser_processXmlDecl (parser);
-	      parser->STATUS = S_3;
-	    }
-	  else if ('!' == c)
-	    {
-	    XML_PullParser_processComment (parser);
-	    parser->STATUS = S_4;
-	    }
+	    if ('?' == c)
+	      {
+		XML_PullParser_processXmlDecl (parser);
+		parser->STATUS = S_3;
+	      }
+	    else if ('!' == c)
+	      {
+		XML_PullParser_processComment (parser);
+		parser->STATUS = S_4;
+	      }
 	    else
 	      {
 		XML_PullParser_processSTagOrEmptyElem (parser);
@@ -637,19 +643,19 @@
 	  }
 	  break;
 	case S_3:
-	  if ( '<' == c)
+	  if ('<' == c)
 	    parser->STATUS = S_4;
 	  else
 	    {
-	      c =  XML_PullParser_processCharData (parser);
-	      if ( '<' == c)
+	      c = XML_PullParser_processCharData (parser);
+	      if ('<' == c)
 		{
 		  parser->STATUS = S_4;
 		  return EVENT;
 		}
-	      else if ( '\0' == c)
+	      else if ('\0' == c)
 		parser->STATUS = S_3;
-	      else 
+	      else
 		parser->STATUS = S_0;
 	    }
 	  break;
@@ -659,7 +665,7 @@
 	      XML_PullParser_processETag (parser);
 	      parser->STATUS = S_3;
 	    }
-	  else if ( '?' == c) 
+	  else if ('?' == c)
 	    XML_PullParser_processPI (parser);
 	  else if ('!' == c)
 	    XML_PullParser_processComment (parser);
@@ -678,8 +684,8 @@
 }
 
 
-int XMLPARSERAPI
-XML_PullParser_next (XML_PullParser *parser)
+int
+XML_PullParser_next (XML_PullParser * parser)
 {
   int ix;
   XML_PullParser_reset (parser);
@@ -691,23 +697,23 @@
 
     case START_DOCUMENT:
       {
-      int ix;
-      ELEMENT *e;
-      TOKEN *att_name;
-      TOKEN *att_value;
-      ix  = Stack_size (parser->stack);
-      for (; ix > 0; ix--)
-	{
-	  e = Stack_pull (parser->stack);
-	  if (e->token->type == AttValue)
-	    {
-	      att_value = e->token;
-	      e = Stack_pull (parser->stack);
-	      ix --;
-	      att_name = e->token;
-	      XML_PullParser_addAttribute (parser, att_name, att_value);
-	    }
-	}
+	int ix;
+	ELEMENT *e;
+	TOKEN *att_name;
+	TOKEN *att_value;
+	ix = Stack_size (parser->stack);
+	for (; ix > 0; ix--)
+	  {
+	    e = Stack_pull (parser->stack);
+	    if (e->token->type == AttValue)
+	      {
+		att_value = e->token;
+		e = Stack_pull (parser->stack);
+		ix--;
+		att_name = e->token;
+		XML_PullParser_addAttribute (parser, att_name, att_value);
+	      }
+	  }
       }
       break;
     case START_ELEMENT:
@@ -727,10 +733,11 @@
 	      {
 		value = e->token;
 		e = Stack_pull (parser->stack);
-		is --;
+		is--;
 		name = e->token;
-		if (!Token_compare (e->token, "xmlns", 5, parser->unicode_state))
-		    XML_PullParser_addNamespace (parser, name, value);
+		if (!Token_compare
+		    (e->token, "xmlns", 5, parser->unicode_state))
+		  XML_PullParser_addNamespace (parser, name, value);
 		else
 		  XML_PullParser_addAttribute (parser, name, value);
 	      }
@@ -739,24 +746,33 @@
 		name = e->token;
 		parser->name = name;
 		parser->prefix = NULL;
-		    
+
 	      }
 	    else if (e->token->type == Prefix)
 	      {
 		ELEMENT *ex;
-		if (!Token_compare (e->token, "xmlns", 5, parser->unicode_state))
+		if (!Token_compare
+		    (e->token, "xmlns", 5, parser->unicode_state))
 		  {
 		    ex = Stack_pull (parser->attrib);
-		    XML_PullParser_addNamespace (parser, ex->attribute->name, ex->attribute->value);
+		    XML_PullParser_addNamespace (parser, ex->attribute->name,
+						 ex->attribute->value);
 		  }
 		else
 		  {
 		    if (parser->name)
-			parser->prefix = e->token;
+		      parser->prefix = e->token;
 		    else
 		      {
 			ex = Stack_pull (parser->attrib);
-			XML_PullParser_addAttribute_with_prefix (parser, e->token, ex->attribute->name, ex->attribute->value); 
+			XML_PullParser_addAttribute_with_prefix (parser,
+								 e->token,
+								 ex->
+								 attribute->
+								 name,
+								 ex->
+								 attribute->
+								 value);
 		      }
 		  }
 	      }
@@ -788,14 +804,14 @@
       break;
     case COMMENT:
       break;
-  
+
     };
   return EVENT;
 }
 
 
-PRIVATE void 
-XML_PullParser_openElement (XML_PullParser *parser)
+void
+XML_PullParser_openElement (XML_PullParser * parser)
 {
   int ii;
   DEPTH *m = (DEPTH *) malloc (sizeof (DEPTH));
@@ -821,8 +837,8 @@
 }
 
 
-PRIVATE void
-XML_PullParser_closeElement (XML_PullParser *parser)
+void
+XML_PullParser_closeElement (XML_PullParser * parser)
 {
   ELEMENT *d;
   ELEMENT *e;
@@ -842,8 +858,9 @@
 }
 
 
-PRIVATE void
-XML_PullParser_addAttribute (XML_PullParser *parser, TOKEN *name, TOKEN *value)
+void
+XML_PullParser_addAttribute (XML_PullParser * parser, TOKEN * name,
+			     TOKEN * value)
 {
   ATTRIBUTE *att;
   att = (ATTRIBUTE *) malloc (sizeof (ATTRIBUTE));
@@ -854,21 +871,24 @@
 }
 
 
-PRIVATE void
-XML_PullParser_addAttribute_with_prefix (XML_PullParser *parser, TOKEN *prefix, TOKEN *name, TOKEN *value)
+void
+XML_PullParser_addAttribute_with_prefix (XML_PullParser * parser,
+					 TOKEN * prefix, TOKEN * name,
+					 TOKEN * value)
 {
   ATTRIBUTE *att;
   att = (ATTRIBUTE *) malloc (sizeof (ATTRIBUTE));
   att->name = name;
   att->value = value;
   att->prefix = prefix;
-  Stack_push (parser->attrib, NULL, att); 
+  Stack_push (parser->attrib, NULL, att);
   /* Element can keep , tokens and attributes here token set to null */
 }
 
 
-PRIVATE void
-XML_PullParser_addNamespace (XML_PullParser *parser, TOKEN *name, TOKEN *uri)
+void
+XML_PullParser_addNamespace (XML_PullParser * parser, TOKEN * name,
+			     TOKEN * uri)
 {
   NAMESPACE *ns;
   ns = (NAMESPACE *) malloc (sizeof (NAMESPACE));
@@ -880,15 +900,15 @@
 }
 
 
-int XMLPARSERAPI
-XML_PullParser_getAttributeCount (XML_PullParser *parser)
+int
+XML_PullParser_getAttributeCount (XML_PullParser * parser)
 {
   return Stack_size (parser->attrib);
 }
 
 
-ATTRIBUTE *XMLPARSERAPI
-XML_PullParser_getAttribute (XML_PullParser *parser)
+ATTRIBUTE *
+XML_PullParser_getAttribute (XML_PullParser * parser)
 {
   ELEMENT *e;
   e = Stack_pull (parser->attrib);
@@ -899,8 +919,8 @@
 }
 
 
-char* XMLPARSERAPI
-XML_PullParser_getAttributeName (XML_PullParser *parser, ATTRIBUTE *att)
+char *
+XML_PullParser_getAttributeName (XML_PullParser * parser, ATTRIBUTE * att)
 {
   if (!att)
     XML_PullParser_Exception (p_FILE, LINE);
@@ -910,8 +930,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getAttributeValue (XML_PullParser *parser, ATTRIBUTE *att)
+char *
+XML_PullParser_getAttributeValue (XML_PullParser * parser, ATTRIBUTE * att)
 {
   if (!att)
     XML_PullParser_Exception (p_FILE, LINE);
@@ -921,8 +941,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getAttributePrefix (XML_PullParser *parser, ATTRIBUTE *att)
+char *
+XML_PullParser_getAttributePrefix (XML_PullParser * parser, ATTRIBUTE * att)
 {
   if (!att)
     XML_PullParser_Exception (p_FILE, LINE);
@@ -932,8 +952,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getAttributePrefix_by_number (XML_PullParser *parser, int i)
+char *
+XML_PullParser_getAttributePrefix_by_number (XML_PullParser * parser, int i)
 {
   int ix = parser->attrib->pointer;
   ELEMENT *e;
@@ -955,8 +975,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getAttributeName_by_number (XML_PullParser *parser, int i)
+char *
+XML_PullParser_getAttributeName_by_number (XML_PullParser * parser, int i)
 {
   int ix = parser->attrib->pointer;
   ELEMENT *e;
@@ -978,8 +998,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getAttributeValue_by_number (XML_PullParser *parser, int i)
+char *
+XML_PullParser_getAttributeValue_by_number (XML_PullParser * parser, int i)
 {
   int ix = parser->attrib->pointer;
   ELEMENT *e;
@@ -1001,8 +1021,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getName (XML_PullParser *parser)
+char *
+XML_PullParser_getName (XML_PullParser * parser)
 {
   if (parser->name->end)
     return Token_toString (parser->name, parser->unicode_state);
@@ -1010,8 +1030,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getValue (XML_PullParser *parser)
+char *
+XML_PullParser_getValue (XML_PullParser * parser)
 {
   if (parser->value->end)
     return Token_toString (parser->value, parser->unicode_state);
@@ -1019,8 +1039,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getPrefix (XML_PullParser *parser)
+char *
+XML_PullParser_getPrefix (XML_PullParser * parser)
 {
   if (parser->prefix)
     return Token_toString (parser->prefix, parser->unicode_state);
@@ -1028,8 +1048,8 @@
 }
 
 
-int XMLPARSERAPI
-XML_PullParser_getNamespaceCount (XML_PullParser *parser)
+int
+XML_PullParser_getNamespaceCount (XML_PullParser * parser)
 {
   if (parser->namesp)
     return Stack_size (parser->namesp);
@@ -1038,8 +1058,8 @@
 }
 
 
-NAMESPACE *XMLPARSERAPI
-XML_PullParser_getNamespace (XML_PullParser *parser)
+NAMESPACE *
+XML_PullParser_getNamespace (XML_PullParser * parser)
 {
   ELEMENT *e;
   e = Stack_pull_current (parser->namesp);
@@ -1050,8 +1070,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getNamespacePrefix (XML_PullParser *parser, NAMESPACE *ns)
+char *
+XML_PullParser_getNamespacePrefix (XML_PullParser * parser, NAMESPACE * ns)
 {
   if (ns)
     return strdup (ns->name);
@@ -1060,18 +1080,18 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getNamespaceUri (XML_PullParser *parser, NAMESPACE *ns)
+char *
+XML_PullParser_getNamespaceUri (XML_PullParser * parser, NAMESPACE * ns)
 {
   if (ns)
-    return strdup(ns->uri);
+    return strdup (ns->uri);
   else
     return NULL;
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getNamespacePrefix_by_number (XML_PullParser *parser, int i)
+char *
+XML_PullParser_getNamespacePrefix_by_number (XML_PullParser * parser, int i)
 {
   int ix = parser->namesp->pointer;
   ELEMENT *e;
@@ -1088,8 +1108,8 @@
 }
 
 
-char *XMLPARSERAPI
-XML_PullParser_getNamespaceUri_by_number (XML_PullParser *parser, int i)
+char *
+XML_PullParser_getNamespaceUri_by_number (XML_PullParser * parser, int i)
 {
   int ix = parser->namesp->pointer;
   ELEMENT *e;
@@ -1106,3 +1126,28 @@
 }
 
 
+char *
+XML_PullParser_getAttributeNamespace_by_number (XML_PullParser *parser, int i)
+{
+  char *att_prefix;
+  int ii;
+  int ix = parser->namesp->pointer;
+  ELEMENT *e;
+  NAMESPACE *ns = NULL;
+  att_prefix = XML_PullParser_getAttributePrefix_by_number (parser, i);
+    
+  for (ii = 0; ii <= ix; ii++)
+    {
+      e = Stack_get (parser->namesp, ii);
+      if (e)
+	{
+	  if (e->namespace && att_prefix)
+	    {
+	      ns = e->namespace;
+	      if (!(strcmp (ns->name, att_prefix)))
+		return strdup (ns->uri);
+	    }
+	}
+    }
+  return 0;
+}
Index: modules/xml/guththila/src/response.xml
===================================================================
--- modules/xml/guththila/src/response.xml	(revision 292912)
+++ modules/xml/guththila/src/response.xml	(working copy)
@@ -1,7 +1,7 @@
 <!-- this is a comments -->
 <SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
 <SOAP-ENV:Body>
-<ns1:addResponse xmlns:ns1="http://localhost/axis/Calculator">
+<ns1:addResponse testAttribute = "real test" xmlns:ns1="http://localhost/axis/Calculator">
 <!-- this is a comments	
 now we want to test it more
 Because each XML entity not accompanied by external encoding information and not in  UTF-8 and UTF-16 encoding must begin with an XML encoding declaration, in which the first characters must be -
Index: modules/xml/guththila/src/buffer.h
===================================================================
--- modules/xml/guththila/src/buffer.h	(revision 292912)
+++ modules/xml/guththila/src/buffer.h	(working copy)
@@ -21,6 +21,7 @@
 #ifndef __BUFFER__INCLUDED__
 #define __BUFFER__INCLUDED__
 #include <stdlib.h>
+
 struct Buffer
 {
   int size;
@@ -29,6 +30,7 @@
   int offset;
   char *buff;
 };
+
 typedef struct Buffer BUFFER;
 BUFFER *Buffer_createBuffer (int size);
 void Buffer_freeBuffer (BUFFER *name);
Index: modules/xml/guththila/src/xmlpullparser.h
===================================================================
--- modules/xml/guththila/src/xmlpullparser.h	(revision 292912)
+++ modules/xml/guththila/src/xmlpullparser.h	(working copy)
@@ -17,8 +17,9 @@
  * @author Dinesh Premalal (xydinesh@gmail.com, premalwd@cse.mrt.ac.lk)	
  */
 
-#ifndef __XML_PULLPARSER__INCLUDED__
-#define __XML_PULLPARSER__INCLUDED__
+#ifndef XML_PULLPARSER_H
+#define XML_PULLPARSER_H
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -31,38 +32,34 @@
 #include "stack.h"
 #include "unicode.h"
 
-#ifndef XMLPARSERAPI
-#define XMLPARSERAPI		/* as nothing */
-#endif
-
-#ifndef PRIVATE
-#define PRIVATE 		/* as nothing */
-#endif
-
 #define p_FILE __FILE__		/* file name */
 #define LINE __LINE__		/* line number */
 
-typedef void *XML_PULLPARSER;
+/*NOTE:
+ *-----
+ *The above defined p_FILE and LINE should provide as parameters when
+ *   throwing Xml_PullParser_Exception
+ */
 
 enum status
-  {
-    S_0 = 0,
-    S_1,
-    S_2,
-    S_3,
-    S_4
-  };
+{
+  S_0 = 0,
+  S_1,
+  S_2,
+  S_3,
+  S_4
+};
 
-enum event_types 
-  {
-    START_DOCUMENT = 10, 
-    START_ELEMENT = 20, 
-    END_ELEMENT = 30, 
-    EMPTY_ELEMENT = 40, 
-    CHARACTER = 50, 
-    ENTITY_REFERANCE = 60, 
-    COMMENT = 70
-  };
+enum event_types
+{
+  START_DOCUMENT = 10,
+  START_ELEMENT = 20,
+  END_ELEMENT = 30,
+  EMPTY_ELEMENT = 40,
+  CHARACTER = 50,
+  ENTITY_REFERANCE = 60,
+  COMMENT = 70
+};
 enum event_types EVENT;
 
 
@@ -82,61 +79,66 @@
   int last;
   int unicode_state;
   enum status STATUS;
-}XML_PullParser;
+} XML_PullParser;
 
 
-PRIVATE int XML_PullParser_read (XML_PullParser *p);
-PRIVATE int XML_PullParser_nextChar (XML_PullParser *p, int eof);
-PRIVATE int XML_PullParser_tokenize (XML_PullParser *p);
-PRIVATE int XML_PullParser_Exception (char *s, int line);
-PRIVATE int XML_PullParser_skipS (XML_PullParser *p, int c);
-PRIVATE int XML_PullParser_processXmlDecl (XML_PullParser *p);
-PRIVATE int XML_PullParser_processVersionInfo (XML_PullParser *p);
-PRIVATE int XML_PullParser_processEncodingDecl (XML_PullParser *p);
-PRIVATE int XML_PullParser_processSDDecl (XML_PullParser *p);
-PRIVATE void XML_PullParser_openToken (XML_PullParser *p);
-PRIVATE void XML_PullParser_closeToken (XML_PullParser *p, int t, int refer);
-PRIVATE char* XML_PullParser_lastChar (XML_PullParser *p);
-PRIVATE int XML_PullParser_processEq (XML_PullParser *p, int c);
-PRIVATE void XML_PullParser_addAttribute (XML_PullParser *p, TOKEN *name, TOKEN *value);
-PRIVATE void XML_PullParser_addAttribute_with_prefix (XML_PullParser *p, TOKEN *prefix, TOKEN *name, TOKEN *value);
-PRIVATE int XML_PullParser_processCharData (XML_PullParser *p);
-PRIVATE int XML_PullParser_processSTagOrEmtyElem (XML_PullParser *p);
-PRIVATE int XML_PullParser_processComment (XML_PullParser *p);
-PRIVATE int XML_PullParser_processPI (XML_PullParser *p);
-PRIVATE int XML_PullParser_processETag (XML_PullParser *p);
-PRIVATE void XML_PullParser_reset (XML_PullParser *p);
-PRIVATE int XML_PullParser_processName (XML_PullParser *p);
-PRIVATE int XML_PullParser_processAttribute (XML_PullParser *p, int c);
-PRIVATE int XML_PullParser_processAttValue (XML_PullParser *p, int c);
-PRIVATE int XML_PullParser_isS (int c);
-PRIVATE void XML_PullParser_relocateTokens (XML_PullParser *p, int offset);
-PRIVATE void XML_PullParser_shift (XML_PullParser *p);
-PRIVATE void XML_PullParser_addNamespace (XML_PullParser *p, TOKEN *name, TOKEN *uri);
-PRIVATE void XML_PullParser_openElement (XML_PullParser *p);
-PRIVATE void XML_PullParser_closeElement (XML_PullParser *p);
-PRIVATE int XML_PullParser_from_utf16 (XML_PullParser *p, int eof);
-PRIVATE int XML_PullParser_is_valid_starting_char (XML_PullParser *p, int c);
+int XML_PullParser_read (XML_PullParser * p);
+int XML_PullParser_nextChar (XML_PullParser * p, int eof);
+int XML_PullParser_tokenize (XML_PullParser * p);
+int XML_PullParser_Exception (char *s, int line);
+int XML_PullParser_skipS (XML_PullParser * p, int c);
+int XML_PullParser_processXmlDecl (XML_PullParser * p);
+int XML_PullParser_processVersionInfo (XML_PullParser * p);
+int XML_PullParser_processEncodingDecl (XML_PullParser * p);
+int XML_PullParser_processSDDecl (XML_PullParser * p);
+void XML_PullParser_openToken (XML_PullParser * p);
+void XML_PullParser_closeToken (XML_PullParser * p, int t, int refer);
+char *XML_PullParser_lastChar (XML_PullParser * p);
+int XML_PullParser_processEq (XML_PullParser * p, int c);
+void XML_PullParser_addAttribute (XML_PullParser * p, TOKEN * name,
+				  TOKEN * value);
+void XML_PullParser_addAttribute_with_prefix (XML_PullParser * p,
+					      TOKEN * prefix, TOKEN * name,
+					      TOKEN * value);
+int XML_PullParser_processCharData (XML_PullParser * p);
+int XML_PullParser_processSTagOrEmtyElem (XML_PullParser * p);
+int XML_PullParser_processComment (XML_PullParser * p);
+int XML_PullParser_processPI (XML_PullParser * p);
+int XML_PullParser_processETag (XML_PullParser * p);
+void XML_PullParser_reset (XML_PullParser * p);
+int XML_PullParser_processName (XML_PullParser * p);
+int XML_PullParser_processAttribute (XML_PullParser * p, int c);
+int XML_PullParser_processAttValue (XML_PullParser * p, int c);
+int XML_PullParser_isS (int c);
+void XML_PullParser_relocateTokens (XML_PullParser * p, int offset);
+void XML_PullParser_shift (XML_PullParser * p);
+void XML_PullParser_addNamespace (XML_PullParser * p, TOKEN * name,
+				  TOKEN * uri);
+void XML_PullParser_openElement (XML_PullParser * p);
+void XML_PullParser_closeElement (XML_PullParser * p);
+int XML_PullParser_from_utf16 (XML_PullParser * p, int eof);
+int XML_PullParser_is_valid_starting_char (XML_PullParser * p, int c);
 
-int XMLPARSERAPI XML_PullParser_next (XML_PullParser *p);
-XML_PULLPARSER XMLPARSERAPI XML_PullParser_createPullParser (READER *r);
-void XMLPARSERAPI XML_PullParser_freePullParser ();
-int XMLPARSERAPI XML_PullParser_getAttributeCount (XML_PullParser *p);
-char *XMLPARSERAPI XML_PullParser_getAttributeName (XML_PullParser *p, ATTRIBUTE *att);
-char *XMLPARSERAPI XML_PullParser_getAttributeValue (XML_PullParser *p, ATTRIBUTE *att);
-char *XMLPARSERAPI XML_PullParser_getAttributePrefix (XML_PullParser *p, ATTRIBUTE *att);
-ATTRIBUTE *XMLPARSERAPI XML_PullParser_getAttribute (XML_PullParser *p);
-char *XMLPARSERAPI XML_PullParser_getAttributeName_by_number (XML_PullParser *p, int i);
-char *XMLPARSERAPI XML_PullParser_getAttributeValue_by_number (XML_PullParser *p, int i);
-char *XMLPARSERAPI XML_PullParser_getAttributePrefix_by_number (XML_PullParser *p, int i);
-char *XMLPARSERAPI XML_PullParser_getName (XML_PullParser *p);
-char *XMLPARSERAPI XML_PullParser_getPrefix (XML_PullParser *p);
-char *XMLPARSERAPI XML_PullParser_getValue (XML_PullParser *p);
-NAMESPACE *XMLPARSERAPI XML_PullParser_getNamespace (XML_PullParser *p);
-int XMLPARSERAPI XML_PullParser_getNamespaceCount (XML_PullParser *p);
-char *XMLPARSERAPI XML_PullParser_getNamespaceUri (XML_PullParser *p, NAMESPACE *ns);
-char *XMLPARSERAPI XML_PullParser_getNamespacePrefix (XML_PullParser *p, NAMESPACE *ns);
-char *XMLPARSERAPI XML_PullParser_getNamespacePrefix_by_number (XML_PullParser *p, int i);
-char *XMLPARSERAPI XML_PullParser_getNamespaceUri_by_number (XML_PullParser *p, int i);
+int XML_PullParser_next (XML_PullParser * p);
+XML_PullParser *XML_PullParser_createPullParser (READER * r);
+void XML_PullParser_freePullParser ();
+int XML_PullParser_getAttributeCount (XML_PullParser * p);
+char *XML_PullParser_getAttributeName (XML_PullParser * p, ATTRIBUTE * att);
+char *XML_PullParser_getAttributeValue (XML_PullParser * p, ATTRIBUTE * att);
+char *XML_PullParser_getAttributePrefix (XML_PullParser * p, ATTRIBUTE * att);
+ATTRIBUTE *XML_PullParser_getAttribute (XML_PullParser * p);
+char *XML_PullParser_getAttributeName_by_number (XML_PullParser * p, int i);
+char *XML_PullParser_getAttributeValue_by_number (XML_PullParser * p, int i);
+char *XML_PullParser_getAttributePrefix_by_number (XML_PullParser * p, int i);
+char *XML_PullParser_getName (XML_PullParser * p);
+char *XML_PullParser_getPrefix (XML_PullParser * p);
+char *XML_PullParser_getValue (XML_PullParser * p);
+NAMESPACE *XML_PullParser_getNamespace (XML_PullParser * p);
+int XML_PullParser_getNamespaceCount (XML_PullParser * p);
+char *XML_PullParser_getNamespaceUri (XML_PullParser * p, NAMESPACE * ns);
+char *XML_PullParser_getNamespacePrefix (XML_PullParser * p, NAMESPACE * ns);
+char *XML_PullParser_getNamespacePrefix_by_number (XML_PullParser * p, int i);
+char *XML_PullParser_getNamespaceUri_by_number (XML_PullParser * p, int i);
+char *XML_PullParser_getAttributeNamespace_by_number (XML_PullParser *p, int i);
 
-#endif 
+#endif /* XML_PULLPARSER_H */
Index: modules/xml/guththila/src/main.c
===================================================================
--- modules/xml/guththila/src/main.c	(revision 292912)
+++ modules/xml/guththila/src/main.c	(working copy)
@@ -2,7 +2,7 @@
 int main (int argc, char *argv[])
 {
   READER *red;
-  FILE *fp = fopen (argv[1], "r");
+  FILE *fp = fopen ("response.xml", "r");
   red = Reader_createReader (fp);
   XML_PullParser *parser = XML_PullParser_createPullParser (red);
   XML_PullParser_read (parser);
@@ -51,7 +51,9 @@
 	    ia = XML_PullParser_getAttributeCount (parser);
 	    for ( ; ia > 0; ia--)
 	      {
-		p = XML_PullParser_getAttributePrefix_by_number (parser, ia);
+		/* p = XML_PullParser_getAttributePrefix_by_number
+		   (parser, ia); */
+		p = XML_PullParser_getAttributeNamespace_by_number (parser, ia);
 		if (p)
 		  {
 		    printf (" %s:", p);
Index: modules/xml/guththila/src/token.h
===================================================================
--- modules/xml/guththila/src/token.h	(revision 292912)
+++ modules/xml/guththila/src/token.h	(working copy)
@@ -18,8 +18,8 @@
  */
 
 
-#ifndef __TOKEN__INCLUDED__
-#define __TOKEN__INCLUDED__
+#ifndef TOKEN_H
+#define TOKEN_H
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -64,4 +64,5 @@
 int Token_length_utf16 (unsigned int utf16_ch);
 char *Token_build_utf8 (unsigned int utf16_ch, int length);
 char *Token_char_ref (char *buffer);
-#endif
+
+#endif /* TOKEN_H */
Index: modules/xml/guththila/src/unicode.h
===================================================================
--- modules/xml/guththila/src/unicode.h	(revision 292912)
+++ modules/xml/guththila/src/unicode.h	(working copy)
@@ -18,8 +18,8 @@
  */
 
 
-#ifndef __UNICODE__INCLUDED__
-#define __UNICODE__INCLUDED__
+#ifndef UNICODE_H
+#define UNICODE_H
 
 typedef unsigned char UTF8_char;
 typedef unsigned short UTF16_char;
@@ -44,4 +44,4 @@
 #endif /* __UNICODE__FUNCTIONS__ */
 
 
-#endif /* __UNICODE__INCLUDED__ */
+#endif /* UNICODE_H */