Main Page   Modules   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

ACEXML_Parser Class Reference

A SAX based parser. More...

#include "ACEXML/parser/parser/Parser.h"

Inheritance diagram for ACEXML_Parser:

Inheritance graph
[legend]
Collaboration diagram for ACEXML_Parser:

Collaboration graph
[legend]
List of all members.

Public Methods

 ACEXML_Parser (void)
 Default constructor. More...

virtual ~ACEXML_Parser (void)
 Destructor. More...

virtual ACEXML_ContentHandlergetContentHandler (void) const
virtual ACEXML_DTDHandlergetDTDHandler (void) const
virtual ACEXML_EntityResolvergetEntityResolver (void) const
virtual ACEXML_ErrorHandlergetErrorHandler (void) const
virtual int getFeature (const ACEXML_Char *name ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXNotRecognizedException
virtual void setFeature (const ACEXML_Char *name, int boolean_value ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXNotRecognizedException
virtual void * getProperty (const ACEXML_Char *name ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXNotRecognizedException
virtual void setProperty (const ACEXML_Char *name, void *value ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXNotRecognizedException
virtual void parse (ACEXML_InputSource *input ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
virtual void parse (const ACEXML_Char *systemId ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
virtual void setContentHandler (ACEXML_ContentHandler *handler)
virtual void setDTDHandler (ACEXML_DTDHandler *handler)
virtual void setEntityResolver (ACEXML_EntityResolver *resolver)
virtual void setErrorHandler (ACEXML_ErrorHandler *handler)
ACEXML_Char skip_whitespace (ACEXML_Char **whitespace)
int skip_whitespace_count (ACEXML_Char *peek=0)
int is_whitespace (ACEXML_Char c)
int is_whitespace_or_equal (ACEXML_Char c)
int is_nonname (ACEXML_Char c)
int skip_equal (void)
int get_quoted_string (ACEXML_Char *&str)
int parse_processing_instruction (ACEXML_ENV_SINGLE_ARG_DECL)
int grok_comment ()
ACEXML_Charread_name (ACEXML_Char ch=0)
int parse_doctypedecl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
void parse_element (int is_root ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
void parse_xml_prolog (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int parse_char_reference (ACEXML_Char *buf, size_t len)
const ACEXML_Stringparse_reference (void)
int parse_cdata (ACEXML_ENV_SINGLE_ARG_DECL)
int parse_internal_dtd (ACEXML_ENV_SINGLE_ARG_DECL)
int parse_element_decl (ACEXML_ENV_SINGLE_ARG_DECL)
int parse_entity_decl (ACEXML_ENV_SINGLE_ARG_DECL)
int parse_attlist_decl (ACEXML_ENV_SINGLE_ARG_DECL)
int parse_notation_decl (ACEXML_ENV_SINGLE_ARG_DECL)
int parse_external_id_and_ref (ACEXML_Char *&publicId, ACEXML_Char *&systemId ACEXML_ENV_ARG_DECL)
int parse_children_definition (ACEXML_ENV_SINGLE_ARG_DECL)
int parse_child (int skip_open_paren ACEXML_ENV_ARG_DECL)

Public Attributes

virtual int ACEXML_SAXNotSupportedException
virtual void ACEXML_SAXNotSupportedException
virtual void * ACEXML_SAXNotSupportedException

Protected Methods

ACEXML_Char get (void)
 Get a character. More...

ACEXML_Char peek (void)
 Peek a character. More...

int try_grow_cdata (size_t size, size_t &len ACEXML_ENV_ARG_DECL)

Static Protected Attributes

const ACEXML_Char simple_parsing_feature_ [] = { 'S', 'i', 'm', 'p', 'l', 'e', 0 }
const ACEXML_Char namespaces_feature_ [] = {'h', 't', 't', 'p', ':', '/', '/', 'x', 'm', 'l', '.', 'o', 'r', 'g', '/', 's', 'a', 'x', '/', 'f', 'e', 'a', 't', 'u', 'r', 'e', 's', '/', 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', 's', 0 }
const ACEXML_Char namespace_prefixes_feature_ [] = {'h', 't', 't', 'p', ':', '/', '/', 'x', 'm', 'l', '.', 'o', 'r', 'g', '/', 's', 'a', 'x', '/', 'f', 'e', 'a', 't', 'u', 'r', 'e', 's', '/', 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '-', 'p', 'r', 'e', 'f', 'i', 'x', 'e', 's', 0 }

Private Methods

void report_error (const ACEXML_Char *message ACEXML_ENV_ARG_DECL)
void report_warning (const ACEXML_Char *message ACEXML_ENV_ARG_DECL)
void report_fatal_error (const ACEXML_Char *message ACEXML_ENV_ARG_DECL)
void report_prefix_mapping (const ACEXML_Char *prefix, const ACEXML_Char *uri, const ACEXML_Char *name, int start ACEXML_ENV_ARG_DECL)
int parse_token (const ACEXML_Char *keyword)

Private Attributes

ACEXML_DTDHandlerdtd_handler_
 Keeping track of the handlers. We do not manage the memory for handlers. More...

ACEXML_EntityResolverentity_resolver_
ACEXML_ContentHandlercontent_handler_
ACEXML_ErrorHandlererror_handler_
ACEXML_CharStreaminstream_
 Feature and properties management structure here. Current input char stream. More...

ACEXML_Chardoctype_
 My doctype, if any. More...

ACEXML_Chardtd_system_
 External DTD System Literal, if any. More...

ACEXML_Chardtd_public_
 External DTD Public Literal, if any. More...

ACE_Obstack_T< ACEXML_Charobstack_
ACEXML_NamespaceSupport xml_namespace_
ACEXML_Entity_Manager entities_
ACEXML_LocatorImpl locator_
int simple_parsing_
int namespaces_
int namespace_prefixes_

Detailed Description

A SAX based parser.

Definition at line 41 of file Parser.h.


Constructor & Destructor Documentation

ACEXML_Parser::ACEXML_Parser void   
 

Default constructor.

Definition at line 24 of file Parser.cpp.

00025   :   dtd_handler_ (0),
00026       entity_resolver_ (0),
00027       content_handler_ (0),
00028       error_handler_ (0),
00029       instream_ (0),
00030       doctype_ (0),
00031       dtd_system_ (0),
00032       dtd_public_ (0),
00033       locator_(),
00034       simple_parsing_ (0),
00035       namespaces_(1),
00036       namespace_prefixes_ (0)
00037 {
00038 }

ACEXML_Parser::~ACEXML_Parser void    [virtual]
 

Destructor.

Definition at line 40 of file Parser.cpp.

00041 {
00042 }


Member Function Documentation

ACEXML_INLINE ACEXML_Char ACEXML_Parser::get void    [protected]
 

Get a character.

Definition at line 110 of file Parser.i.

References ACEXML_Char, ACEXML_CharStream::get, ACEXML_LocatorImpl::incrColumnNumber, ACEXML_LocatorImpl::incrLineNumber, instream_, locator_, and ACEXML_LocatorImpl::setColumnNumber.

00111 {
00112   // Using an extra level of indirection so we can
00113   // manage document location in the future.
00114 
00115   if (this->instream_ != 0)
00116     {
00117       ACEXML_Char ch;
00118       if (this->instream_->get (ch) == -1)
00119         return 0;
00120       this->locator_.incrColumnNumber();
00121       if (ch == 0x0A) {
00122         this->locator_.incrLineNumber();
00123         this->locator_.setColumnNumber (0);
00124       }
00125       return ch;
00126     }
00127   return 0;
00128 }

int ACEXML_Parser::get_quoted_string ACEXML_Char *&    str
 

Get a quoted string. Quoted strings are used to specify attribute values and this routine will replace character and entity references on-the-fly. Parameter entities are not allowed (or replaced) in this function. (But regular entities are.)

Parameters:
str  returns the un-quoted string.
Return values:
0  on success, -1 otherwise.

ACEXML_INLINE ACEXML_ContentHandler * ACEXML_Parser::getContentHandler void    const [virtual]
 

Return the current content handler.

Implements ACEXML_XMLReader.

Definition at line 12 of file Parser.i.

References content_handler_.

00013 {
00014   return this->content_handler_;
00015 }

ACEXML_INLINE ACEXML_DTDHandler * ACEXML_Parser::getDTDHandler void    const [virtual]
 

Return the current DTD handler.

Implements ACEXML_XMLReader.

Definition at line 18 of file Parser.i.

References dtd_handler_.

00019 {
00020   return this->dtd_handler_;
00021 }

ACEXML_INLINE ACEXML_EntityResolver * ACEXML_Parser::getEntityResolver void    const [virtual]
 

Return the current entity resolver.

Implements ACEXML_XMLReader.

Definition at line 24 of file Parser.i.

References entity_resolver_.

00025 {
00026   return this->entity_resolver_;
00027 }

ACEXML_INLINE ACEXML_ErrorHandler * ACEXML_Parser::getErrorHandler void    const [virtual]
 

Return the current error handler.

Implements ACEXML_XMLReader.

Definition at line 30 of file Parser.i.

References error_handler_.

00031 {
00032   return this->error_handler_;
00033 }

int ACEXML_Parser::getFeature const ACEXML_Char *name    ACEXML_ENV_ARG_DECL [virtual]
 

Look up the value of a feature. This method allows programmers to check whether a specific feature has been activated in the parser.

Reimplemented from ACEXML_XMLReader.

virtual void* ACEXML_Parser::getProperty const ACEXML_Char *name    ACEXML_ENV_ARG_DECL [virtual]
 

Look up the value of a property.

Reimplemented from ACEXML_XMLReader.

int ACEXML_Parser::grok_comment  
 

Skip over a comment. The first character encountered should always be the first '-' in the comment prefix "<@!--".

ACEXML_INLINE int ACEXML_Parser::is_nonname ACEXML_Char    c
 

Check if a character c is a valid character for nonterminal NAME.

Return values:
1  if true, 0 otherwise.

Definition at line 82 of file Parser.i.

References ACEXML_Char, and is_whitespace_or_equal.

00083 {
00084   // Handle this separately as doing so avoids code duplication and enables
00085   // setting of line and column numbers in one place.
00086   if (is_whitespace_or_equal (c))
00087     return 1;
00088 
00089   switch (c)
00090     {
00091     case '/':
00092     case '?':
00093     case '>':
00094     case '<':
00095     case ')':
00096     case '(':
00097     case '+':
00098     case '*':
00099     case '\'':
00100     case '"':
00101     case ',':
00102     case '|':
00103       return 1;
00104     default:
00105       return 0;
00106     }
00107 }

ACEXML_INLINE int ACEXML_Parser::is_whitespace ACEXML_Char    c
 

Check if a character c is a whitespace.

Return values:
1  if c is a valid white space character. 0 otherwise.

Definition at line 60 of file Parser.i.

References ACEXML_Char.

Referenced by is_whitespace_or_equal.

00061 {
00062   switch (c)
00063     {
00064     case 0xa:
00065     case 0x20:
00066     case 0x9:
00067     case 0xd:
00068       return 1;
00069     default:
00070       return 0;
00071     }
00072 }

ACEXML_INLINE int ACEXML_Parser::is_whitespace_or_equal ACEXML_Char    c
 

Check if a character c is a whitespace or '='.

Return values:
1  if true, 0 otherwise.

Definition at line 76 of file Parser.i.

References ACEXML_Char, and is_whitespace.

Referenced by is_nonname.

00077 {
00078   return (is_whitespace (c) || c == '=') ? 1 : 0;
00079 }

virtual void ACEXML_Parser::parse const ACEXML_Char *systemId    ACEXML_ENV_ARG_DECL [virtual]
 

Parse an XML document from a system identifier (URI).

Implements ACEXML_XMLReader.

virtual void ACEXML_Parser::parse ACEXML_InputSource *input    ACEXML_ENV_ARG_DECL [virtual]
 

Parse an XML document.

Implements ACEXML_XMLReader.

int ACEXML_Parser::parse_attlist_decl ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse an "ATTLIST" decl. Thse first character this method expects is always the 'A' (the first char) in the word "ATTLIST".

Return values:
0  on success, -1 otherwise.

int ACEXML_Parser::parse_cdata ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse a CDATA section. The first character should always be the first '[' in CDATA definition.

Return values:
0  on success.
-1  if fail.

int ACEXML_Parser::parse_char_reference ACEXML_Char   buf,
size_t    len
 

Parse a character reference, i.e., "&x20;" or "&#30;". The first character encountered should be the '#' char.

Parameters:
buf  points to a character buffer for the result.
len  specifies the capacities of the buffer.
Return values:
0  on success and -1 otherwise.

int ACEXML_Parser::parse_child int skip_open_paren    ACEXML_ENV_ARG_DECL
 

Parse a cp non-terminal. cp can either be a seq or a choice. This function calls itself recursively.

Parameters:
skip_open_paren  when non-zero, it indicates that the open paren of the seq or choice has already been removed from the input stream.
Return values:
0  on success, -1 otherwise.

int ACEXML_Parser::parse_children_definition ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse the "children" and "Mixed" non-terminals in contentspec.

The first character this function sees must be the first open paren '(' in children.

Return values:
0  on success, -1 otherwise.

int ACEXML_Parser::parse_doctypedecl ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse the DOCTYPE declaration. The first character encountered should always be 'D' in doctype prefix: "<@!DOCTYPE".

void ACEXML_Parser::parse_element int is_root    ACEXML_ENV_ARG_DECL
 

Parse an XML element. The first character encountered should be the first character of the element "Name".

Parameters:
is_root  If not 0, then we are expecting to see the "root" element now, and the next element's name need to match the name defined in DOCTYPE definition, i.e., this->doctype_.
Todo:
Instead of simply checking for the root element based on the argument is_root, we should instead either pass in some sort of validator or allow the function to return the element name so it can be used in a validator.

int ACEXML_Parser::parse_element_decl ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse an "ELEMENT" decl. The first character this method expects is always the 'L' (the second char) in the word "ELEMENT".

Return values:
0  on success, -1 otherwise.

int ACEXML_Parser::parse_entity_decl ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse an "ENTITY" decl. The first character this method expects is always the 'N' (the second char) in the word "ENTITY".

Return values:
0  on success, -1 otherwise.

int ACEXML_Parser::parse_external_id_and_ref ACEXML_Char *&    publicId,
ACEXML_Char *&systemId    ACEXML_ENV_ARG_DECL
 

Parse an ExternalID or a reference to PUBLIC ExternalID. Possible cases are in the forms of:

SYSTEM 'quoted string representing system resource' PUBLIC 'quoted name of public ID' 'quoted resource' PUBLIC 'quoted name we are referring to'

The first character this function sees must be either 'S' or 'P'. When the function finishes parsing, the input stream points at the first non-whitespace character.

Parameters:
publicId  returns the unquoted publicId read. If none is available, it will be reset to 0.
systemId  returns the unquoted systemId read. If none is available, it will be reset to 0.
Return values:
0  on success, -1 otherwise.

int ACEXML_Parser::parse_internal_dtd ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse a "markupdecl" section, this includes both "markupdecl" and "DeclSep" sections in XML specification

int ACEXML_Parser::parse_notation_decl ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse a "NOTATION" decl. The first character this method expects is always the 'N' (the first char) in the word "NOTATION".

Return values:
0  on success, -1 otherwise.

int ACEXML_Parser::parse_processing_instruction ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse a PI statement. The first character encountered should always be '?' in the PI prefix "<?".

Return values:
0  on success, -1 otherwise.

const ACEXML_String* ACEXML_Parser::parse_reference void   
 

Parse an entity reference, i.e., "&". The first character encountered should be the character following '&'.

Returns:
A pointer to the resolved const ACEXML_String if success (previously defined), 0 otherwise.

int ACEXML_Parser::parse_token const ACEXML_Char   keyword [private]
 

Parse a keyword.

void ACEXML_Parser::parse_xml_prolog ACEXML_ENV_SINGLE_ARG_DECL   
 

Parse XML Prolog.

ACEXML_INLINE ACEXML_Char ACEXML_Parser::peek void    [protected]
 

Peek a character.

Definition at line 131 of file Parser.i.

References instream_, and ACEXML_CharStream::peek.

00132 {
00133   // Using an extra level of indirection so we can
00134   // manage document location in the future.
00135 
00136   if (this->instream_ != 0)
00137     return this->instream_->peek ();
00138   return 0;
00139 
00140 }

ACEXML_Char* ACEXML_Parser::read_name ACEXML_Char    ch = 0
 

Read a name from the input CharStream (until white space). If ch @!= 0, then we have already consumed the first name character from the input CharStream, otherwise, read_name will use this->get() to acquire the initial character.

Returns:
A pointer to the string in the obstack, 0 if it's not a valid name.

void ACEXML_Parser::report_error const ACEXML_Char *message    ACEXML_ENV_ARG_DECL [private]
 

Dispatch errors to ErrorHandler.

void ACEXML_Parser::report_fatal_error const ACEXML_Char *message    ACEXML_ENV_ARG_DECL [private]
 

Dispatch fatal errors to ErrorHandler.

void ACEXML_Parser::report_prefix_mapping const ACEXML_Char   prefix,
const ACEXML_Char   uri,
const ACEXML_Char   name,
int start    ACEXML_ENV_ARG_DECL
[private]
 

Dispatch prefix mapping calls to the ContentHandler.

Parameters:
prefix  Namespace prefix
uri  Namespace URI
name  Local name
start  1 => startPrefixMapping 0 => endPrefixMapping

void ACEXML_Parser::report_warning const ACEXML_Char *message    ACEXML_ENV_ARG_DECL [private]
 

Dispatch warnings to ErrorHandler.

ACEXML_INLINE void ACEXML_Parser::setContentHandler ACEXML_ContentHandler   handler [virtual]
 

Allow an application to register a content event handler.

Implements ACEXML_XMLReader.

Definition at line 36 of file Parser.i.

References content_handler_.

00037 {
00038   this->content_handler_ = handler;
00039 }

ACEXML_INLINE void ACEXML_Parser::setDTDHandler ACEXML_DTDHandler   handler [virtual]
 

Allow an application to register a DTD event handler.

Implements ACEXML_XMLReader.

Definition at line 42 of file Parser.i.

References dtd_handler_.

00043 {
00044   this->dtd_handler_ = handler;
00045 }

ACEXML_INLINE void ACEXML_Parser::setEntityResolver ACEXML_EntityResolver   resolver [virtual]
 

Allow an application to register an entity resolver.

Implements ACEXML_XMLReader.

Definition at line 48 of file Parser.i.

References entity_resolver_.

00049 {
00050   this->entity_resolver_ = resolver;
00051 }

ACEXML_INLINE void ACEXML_Parser::setErrorHandler ACEXML_ErrorHandler   handler [virtual]
 

Allow an application to register an error event handler.

Implements ACEXML_XMLReader.

Definition at line 54 of file Parser.i.

References error_handler_.

00055 {
00056   this->error_handler_ = handler;
00057 }

virtual void ACEXML_Parser::setFeature const ACEXML_Char   name,
int boolean_value    ACEXML_ENV_ARG_DECL
[virtual]
 

Activating or deactivating a feature.

Reimplemented from ACEXML_XMLReader.

virtual void ACEXML_Parser::setProperty const ACEXML_Char   name,
void *value    ACEXML_ENV_ARG_DECL
[virtual]
 

Set the value of a property.

Reimplemented from ACEXML_XMLReader.

int ACEXML_Parser::skip_equal void   
 

Skip an equal sign.

Return values:
0  when succeeds, -1 if no equal sign is found.

ACEXML_Char ACEXML_Parser::skip_whitespace ACEXML_Char **    whitespace
 

Skip any whitespaces encountered until the first non-whitespace character is encountered and consumed from the current input CharStream.

Parameters:
whitespace  Return a pointer to the string of skipped whitespace after proper conversion. Null if there's no whitespace found.
Returns:
The first none-white space characters (which will be consumed from the CharStream.) If no whitespace is found, it returns 0.
See also:
skip_whitespace_count

int ACEXML_Parser::skip_whitespace_count ACEXML_Char   peek = 0
 

Skip any whitespaces encountered until the first non-whitespace character. The first non-whitespace character is not consumed. This method does peek into the input CharStream and therefore is more expensive than skip_whitespace.

Parameters:
peek  If non-null, peek points to a ACEXML_Char where skip_whitespace_count stores the first non-whitespace character it sees (character is not removed from the stream.)
Returns:
The number of whitespace characters consumed.
See also:
skip_whitespace

int ACEXML_Parser::try_grow_cdata size_t    size,
size_t &len    ACEXML_ENV_ARG_DECL
[protected]
 

Check if more data can be added to a character buffer in obstack. If not, the existing data in the buffer will be cleared out by freezing the segment and pass it out thru a content_handler_->characters () call. counter records the length of the existing data in obstack.


Member Data Documentation

virtual void* ACEXML_Parser::ACEXML_SAXNotSupportedException
 

Reimplemented from ACEXML_XMLReader.

Definition at line 92 of file Parser.h.

virtual void ACEXML_Parser::ACEXML_SAXNotSupportedException
 

Reimplemented from ACEXML_XMLReader.

Definition at line 100 of file Parser.h.

void ACEXML_Parser::ACEXML_SAXNotSupportedException
 

Reimplemented from ACEXML_XMLReader.

Definition at line 100 of file Parser.h.

ACEXML_ContentHandler* ACEXML_Parser::content_handler_ [private]
 

Definition at line 478 of file Parser.h.

Referenced by getContentHandler, and setContentHandler.

ACEXML_Char* ACEXML_Parser::doctype_ [private]
 

My doctype, if any.

Definition at line 486 of file Parser.h.

ACEXML_DTDHandler* ACEXML_Parser::dtd_handler_ [private]
 

Keeping track of the handlers. We do not manage the memory for handlers.

Definition at line 476 of file Parser.h.

Referenced by getDTDHandler, and setDTDHandler.

ACEXML_Char* ACEXML_Parser::dtd_public_ [private]
 

External DTD Public Literal, if any.

Definition at line 492 of file Parser.h.

ACEXML_Char* ACEXML_Parser::dtd_system_ [private]
 

External DTD System Literal, if any.

Definition at line 489 of file Parser.h.

ACEXML_Entity_Manager ACEXML_Parser::entities_ [private]
 

Definition at line 498 of file Parser.h.

ACEXML_EntityResolver* ACEXML_Parser::entity_resolver_ [private]
 

Definition at line 477 of file Parser.h.

Referenced by getEntityResolver, and setEntityResolver.

ACEXML_ErrorHandler* ACEXML_Parser::error_handler_ [private]
 

Definition at line 479 of file Parser.h.

Referenced by getErrorHandler, and setErrorHandler.

ACEXML_CharStream* ACEXML_Parser::instream_ [private]
 

Feature and properties management structure here. Current input char stream.

@

Definition at line 483 of file Parser.h.

Referenced by get, and peek.

ACEXML_LocatorImpl ACEXML_Parser::locator_ [private]
 

Definition at line 501 of file Parser.h.

Referenced by get.

int ACEXML_Parser::namespace_prefixes_ [private]
 

Definition at line 506 of file Parser.h.

int ACEXML_Parser::namespaces_ [private]
 

Definition at line 505 of file Parser.h.

ACE_Obstack_T<ACEXML_Char> ACEXML_Parser::obstack_ [private]
 

Definition at line 494 of file Parser.h.

int ACEXML_Parser::simple_parsing_ [private]
 

Definition at line 504 of file Parser.h.

ACEXML_NamespaceSupport ACEXML_Parser::xml_namespace_ [private]
 

Definition at line 496 of file Parser.h.


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 13:27:22 2003 for ACEXML by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002