Main Page | Modules | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class 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:

[legend]
Collaboration diagram for ACEXML_Parser:

[legend]
List of all members.

## Public Member Functions
| ACEXML_Parser (void)
| Default constructor.
virtual | ~ACEXML_Parser (void)
| Destructor.
int | initialize (ACEXML_InputSource *input)
virtual ACEXML_ContentHandler * | getContentHandler (void) const
virtual ACEXML_DTDHandler * | getDTDHandler (void) const
virtual ACEXML_EntityResolver * | getEntityResolver (void) const
virtual ACEXML_ErrorHandler * | getErrorHandler (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)
## Public Attributes
virtual int | ACEXML_SAXNotSupportedException
virtual void | ACEXML_SAXNotSupportedException
virtual void * | ACEXML_SAXNotSupportedException
## Protected Member Functions
void | parse_xml_prolog (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
void | parse_version_info (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
void | parse_encoding_decl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
void | parse_xml_decl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_text_decl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_processing_instruction (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
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))
int | parse_content (const ACEXML_Char *startname, const ACEXML_Char *&ns_uri, const ACEXML_Char *&ns_lname, int ns_flag ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_char_reference (ACEXML_Char *buf, size_t &len)
ACEXML_Char * | parse_reference_name (void)
int | parse_cdata (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_internal_dtd (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_comment (void)
int | parse_element_decl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_entity_decl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_attlist_decl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_atttype (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_notation_decl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_external_id (ACEXML_Char *&publicId, ACEXML_Char *&systemId ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_external_dtd (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_external_subset (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_markup_decl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_conditional_section (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_includesect (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_ignoresect (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_PE_reference (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_entity_reference (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_entity_value (ACEXML_Char *&str ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_defaultdecl (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_children_definition (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_child (int skip_open_paren ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
ACEXML_Char * | parse_name (ACEXML_Char ch=0)
ACEXML_Char * | parse_nmtoken (ACEXML_Char ch=0)
int | parse_version (ACEXML_Char *&str)
int | parse_version_num (ACEXML_Char *&str)
int | parse_encname (ACEXML_Char *&str)
int | parse_sddecl (ACEXML_Char *&str)
ACEXML_Char * | parse_attname (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_attvalue (ACEXML_Char *&str ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_tokenized_type (ACEXML_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_system_literal (ACEXML_Char *&str)
int | parse_pubid_literal (ACEXML_Char *&str)
int | is_whitespace (const ACEXML_Char c) const
int | isChar (ACEXML_UCS4 c) const
int | isCharRef (const ACEXML_Char c) const
int | isBasechar (const ACEXML_Char c) const
int | isIdeographic (const ACEXML_Char c) const
int | isCombiningchar (const ACEXML_Char c) const
int | isDigit (const ACEXML_Char c) const
int | isExtender (const ACEXML_Char c) const
int | isLetter (const ACEXML_Char c) const
int | isNameChar (const ACEXML_Char c) const
int | isPubidChar (const ACEXML_Char c) const
virtual ACEXML_Char | get (void)
| Get a character.
virtual ACEXML_Char | peek (void)
| Peek a character.
## Private Member Functions
ACEXML_Char | skip_whitespace (void)
int | skip_whitespace_count (ACEXML_Char *peek=0)
int | skip_equal (void)
int | get_quoted_string (ACEXML_Char *&str)
int | isNormalDigit (const ACEXML_Char c) const
void | error (const ACEXML_Char *msg ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
void | warning (const ACEXML_Char *msg ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
void | fatal_error (const ACEXML_Char *msg ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
void | prefix_mapping (const ACEXML_Char *prefix, const ACEXML_Char *uri, int start ACEXML_ENV_ARG_DECL) ACE_THROW_SPEC((ACEXML_SAXException))
int | parse_token (const ACEXML_Char *keyword)
int | push_context (ACEXML_Parser_Context *context)
int | pop_context (int GE_ref ACEXML_ENV_ARG_DECL)
virtual int | switch_input (ACEXML_CharStream *cstream, const ACEXML_Char *systemId, const ACEXML_Char *publicId=0)
virtual int | switch_input (ACEXML_InputSource *input, const ACEXML_Char *systemId, const ACEXML_Char *publicId=0)
int | check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_DECL)
void | reset (void)
ACEXML_Char * | normalize_systemid (const ACEXML_Char *systemId)
## Private Attributes
ACEXML_DTDHandler * | dtd_handler_
ACEXML_EntityResolver * | entity_resolver_
ACEXML_ContentHandler * | content_handler_
ACEXML_ErrorHandler * | error_handler_
ACEXML_Char * | doctype_
| Document Type.
ACEXML_Parser_Context * | current_
| Current parser context.
ACE_Unbounded_Stack< ACEXML_Parser_Context * > | ctx_stack_
| Stack used to hold the Parser_Context.
ACE_Unbounded_Stack< ACEXML_Char * > | GE_reference_
| Set used to hold the general entity references that are active.
ACE_Unbounded_Stack< ACEXML_Char * > | PE_reference_
| Set used to hold the parameter entity references that are active.
ACE_Obstack_T< ACEXML_Char > | obstack_
| Obstack used by the parser to hold all the strings parsed.
ACE_Obstack_T< ACEXML_Char > | alt_stack_
| Alternative obstack used to hold any strings when the original is in use.
ACEXML_NamespaceSupport | xml_namespace_
| Namespace stack used by the parser to implement support for Namespaces.
int | nested_namespace_
| T => We are processing a nested namespace.
ACEXML_Entity_Manager | internal_GE_
| Set of internal parsed general entities in the document.
ACEXML_Entity_Manager | external_GE_
| Set of external parsed general entities in the document.
ACEXML_Entity_Manager | unparsed_entities_
| Set of unparsed entities in the document.
ACEXML_Entity_Manager | predef_entities_
| Set of predefined entities used by the parser.
ACEXML_Entity_Manager | internal_PE_
| Set of internal parsed parameter entities in the document.
ACEXML_Entity_Manager | external_PE_
| Set of external parsed parameter entities in the document.
ACEXML_Entity_Manager | notations_
| Set of notations declared in the document.
ACEXML_ParserInt::ReferenceState | ref_state_
| State of the parser when it encounters a reference.
int | external_subset_
| T => We are parsing an external subset.
int | external_entity_
| T => We are parsing an external entity value.
int | has_pe_refs_
| T => Internal DTD has parameter entity references.
int | standalone_
| If set, the document is a standalone XML document.
int | external_dtd_
| If set, the document has an external DTD subset.
int | internal_dtd_
| If set, the document has an internal DTD.
int | simple_parsing_
int | validate_
| If set, the parser should also validate.
int | namespaces_
| If set, the parser should allow access by namespace qualified names.
int | namespace_prefixes_
## Static Private Attributes
const ACEXML_Char | simple_parsing_feature_ [] = ACE_TEXT ("Simple")
const ACEXML_Char | namespaces_feature_ [] = ACE_TEXT ("http://xml.org/sax/features/namespaces")
const ACEXML_Char | namespace_prefixes_feature_ [] = ACE_TEXT ("http://xml.org/sax/features/namespace-prefixes")
const ACEXML_Char | validation_feature_ [] = ACE_TEXT ("http://xml.org/sax/features/validation")

## Detailed Description

A SAX based parser.

## Constructor & Destructor Documentation

ACEXML_Parser::ACEXML_Parser | ( | void |  | ) |

| Default constructor.

ACEXML_Parser::~ACEXML_Parser | ( | void |  | ) | `[virtual]`

| Destructor.

## Member Function Documentation

int ACEXML_Parser::check_for_PE_reference | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[private]`

  | Check for a parameter entity reference. This is used to check for the occurence of a PE Reference withing markupDecl. Additionally this function consumes any leading or trailing whitespace around the PE Reference. Return values:
  | Number | of whitespace characters skipped.

void ACEXML_Parser::error | ( | const ACEXML_Char *msg | ACEXML_ENV_ARG_DECL | ) | `[private]`

| Dispatch errors to ErrorHandler.

void ACEXML_Parser::fatal_error | ( | const ACEXML_Char *msg | ACEXML_ENV_ARG_DECL | ) | `[private]`

| Dispatch fatal errors to ErrorHandler.

ACEXML_INLINE ACEXML_Char ACEXML_Parser::get | ( | void |  | ) | `[protected, virtual]`

| Get a character.

int ACEXML_Parser::get_quoted_string | ( | ACEXML_Char *& | str | ) | `[private]`

  | 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.

ACEXML_INLINE ACEXML_DTDHandler * ACEXML_Parser::getDTDHandler | ( | void |  | ) | const`[virtual]`

| Return the current DTD handler. Implements ACEXML_XMLReader.

ACEXML_INLINE ACEXML_EntityResolver * ACEXML_Parser::getEntityResolver | ( | void |  | ) | const`[virtual]`

| Return the current entity resolver. Implements ACEXML_XMLReader.

ACEXML_INLINE ACEXML_ErrorHandler * ACEXML_Parser::getErrorHandler | ( | void |  | ) | const`[virtual]`

| Return the current error handler. Implements ACEXML_XMLReader.

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::initialize | ( | ACEXML_InputSource * | input | ) |

  | Initialize the parser state. Return values:
  | 0 | if parser was initialized correctly else -1.

ACEXML_INLINE int ACEXML_Parser::is_whitespace | ( | const ACEXML_Char | c | ) | const`[protected]`

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

ACEXML_INLINE int ACEXML_Parser::isBasechar | ( | const ACEXML_Char | c | ) | const`[protected]`

  | Check if a character c is a BaseChar. Return values:
  | 1 | if c is a valid BaseChar character, 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isChar | ( | ACEXML_UCS4 | c | ) | const`[protected]`

  | Check if a character c is a valid Char. Return values:
  | 1 | if c is a valid character. 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isCharRef | ( | const ACEXML_Char | c | ) | const`[protected]`

  | Check if a character c is a valid CharRef character. Return values:
  | 1 | if c is a valid character reference character, 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isCombiningchar | ( | const ACEXML_Char | c | ) | const`[protected]`

  | Check if a character c is a CombiningChar. Return values:
  | 1 | if c is a valid CombiningChar character, 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isDigit | ( | const ACEXML_Char | c | ) | const`[protected]`

  | Check if a character c is a Digit. Return values:
  | 1 | if c is a valid Digit character, 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isExtender | ( | const ACEXML_Char | c | ) | const`[protected]`

  | Check if a character c is an Extender. Return values:
  | 1 | if c is a valid Extender character, 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isIdeographic | ( | const ACEXML_Char | c | ) | const`[protected]`

  | Check if a character c is a Ideographic. Return values:
  | 1 | if c is a valid Ideographic character, 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isLetter | ( | const ACEXML_Char | c | ) | const`[protected]`

  | Check if a character c is a Letter. Return values:
  | 1 | if c is a valid Letter character, 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isNameChar | ( | const ACEXML_Char | c | ) | const`[protected]`

  | Check if a character is an acceptable NameChar. Return values:
  | 1 | if c is a valid NameChar character, 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isNormalDigit | ( | const ACEXML_Char | c | ) | const`[private]`

  | Check if a character c is a Digit. Return values:
  | 1 | if c is a valid Digit character, 0 otherwise.

ACEXML_INLINE int ACEXML_Parser::isPubidChar | ( | const ACEXML_Char | c | ) | const`[protected]`

  | Check if a character is a PubidChar. Return values:
  | 1 | if c is a valid PubidChar character, 0 otherwise.

ACEXML_Char * ACEXML_Parser::normalize_systemid | ( | const ACEXML_Char * | systemId | ) | `[private]`

| Very trivial, non-conformant normalization of a systemid.

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.

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 |  | ) | `[protected]`

  | 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.

ACEXML_Char * ACEXML_Parser::parse_attname | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

  | Parse an attribute name. Return values:
  | str | String containing the value of the attribute name if successful.
  | 0 | otherwise.

int ACEXML_Parser::parse_atttype | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a AttType declaration.

int ACEXML_Parser::parse_attvalue | ( | ACEXML_Char *&str | ACEXML_ENV_ARG_DECL | ) | `[protected]`

  | Parse an attribute value. Parameters:
  | str | String containing the value of the attribute if successful.
Returns: 0 if attribute value was read successfully, -1 otherwise.

int ACEXML_Parser::parse_cdata | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

  | 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
| ) | `[protected]`

  | 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 | In/out argument which initially specifies the size of the buffer and is later set to the no. of characters in the reference.
  Return values:
  | 0 | on success and -1 otherwise.

int ACEXML_Parser::parse_child | ( | int skip_open_paren | ACEXML_ENV_ARG_DECL | ) | `[protected]`

  | 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 |  | ) | `[protected]`

  | 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_comment | ( | void |  | ) | `[protected]`

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

int ACEXML_Parser::parse_conditional_section | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a conditionalSect declaration.

int ACEXML_Parser::parse_content | ( | const ACEXML_Char * | startname,
|  | const ACEXML_Char *& | ns_uri,
|  | const ACEXML_Char *& | ns_lname,
|  | int ns_flag | ACEXML_ENV_ARG_DECL
| ) | `[protected]`

| Parse a content declaration.

int ACEXML_Parser::parse_defaultdecl | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a DefaultDecl specification.

int ACEXML_Parser::parse_doctypedecl | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| 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 | ) | `[protected]`

  | 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 |  | ) | `[protected]`

  | 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_encname | ( | ACEXML_Char *& | str | ) | `[protected]`

  | Parse the encoding name in an XML Prolog section. Parameters:
  | str | String containing the encoding name if successful.
Returns: 0 if the string was read successfully, 0 otherwise.

void ACEXML_Parser::parse_encoding_decl | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a EncodingDecl declaration.

int ACEXML_Parser::parse_entity_decl | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

  | 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_entity_reference | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a Reference.

int ACEXML_Parser::parse_entity_value | ( | ACEXML_Char *&str | ACEXML_ENV_ARG_DECL | ) | `[protected]`

| Parse an entityValue.

int ACEXML_Parser::parse_external_dtd | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse an external DTD.

int ACEXML_Parser::parse_external_id | ( | ACEXML_Char *& | publicId,
|  | ACEXML_Char *&systemId | ACEXML_ENV_ARG_DECL
| ) | `[protected]`

  | 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_external_subset | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse an external subset. This does the actual parsing of an external subset and is called by See also: parse_external_dtd.

int ACEXML_Parser::parse_ignoresect | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a ignoreSect declaration.

int ACEXML_Parser::parse_includesect | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a includeSect declaration.

int ACEXML_Parser::parse_internal_dtd | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

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

int ACEXML_Parser::parse_markup_decl | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a markupDecl section.

ACEXML_Char * ACEXML_Parser::parse_name | ( | ACEXML_Char | ch = `0` | ) | `[protected]`

| Parse a name from the input CharStream. If ch @!= 0, then we have already consumed the first name character from the input CharStream, otherwise, parse_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.

ACEXML_Char * ACEXML_Parser::parse_nmtoken | ( | ACEXML_Char | ch = `0` | ) | `[protected]`

| Parse a NMTOKEN from the input stream. Returns: A pointer to the string in the obstack, 0 if it's not a valid NMTOKEN.

int ACEXML_Parser::parse_notation_decl | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

  | 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_PE_reference | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a PEReference.

int ACEXML_Parser::parse_processing_instruction | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

  | Parse a PI statement. The first character encountered should always be '?' in the PI prefix "@<?". Return values:
  | 0 | on success, -1 otherwise.

int ACEXML_Parser::parse_pubid_literal | ( | ACEXML_Char *& | str | ) | `[protected]`

  | Parse a PubidLiteral. Parameters:
  | str | String containing the PubidLiteral if successful.
Returns: 0 if the string was read successfully, 0 otherwise.

ACEXML_Char * ACEXML_Parser::parse_reference_name | ( | void |  | ) | `[protected]`

  | Parse a reference name, i.e., foo in "&foo;" or "%foo;". The first character encountered should be the character following '&' or '%'. Effectively the same as See also: parse_name but we don't use the parser's obstack. Caller is responsible for deleting the memory. Return values:
  | A | pointer to name of reference, 0 otherwise.

int ACEXML_Parser::parse_sddecl | ( | ACEXML_Char *& | str | ) | `[protected]`

  | Parse a SDDecl string. Parameters:
  | str | String containing the encoding name if successful.
Returns: 0 if the string was read successfully, -1 otherwise.

int ACEXML_Parser::parse_system_literal | ( | ACEXML_Char *& | str | ) | `[protected]`

  | Parse a SystemLiteral. Parameters:
  | str | String containing the SystemLiteral if successful.
Returns: 0 if the string was read successfully, 0 otherwise.

int ACEXML_Parser::parse_text_decl | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a TextDecl declaration.

ACEXML_INLINE int ACEXML_Parser::parse_token | ( | const ACEXML_Char * | keyword | ) | `[private]`

| Parse a keyword.

int ACEXML_Parser::parse_tokenized_type | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a tokenized type attribute. Returns: 0 if attribute type was read successfully, -1 otherwise.

int ACEXML_Parser::parse_version | ( | ACEXML_Char *& | str | ) | `[protected]`

  | Parse the version string in an XML Prolog section. Parameters:
  | str | String containing the version number if successful.
Returns: 0 if the string was read successfully, 0 otherwise.

void ACEXML_Parser::parse_version_info | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse VersionInfo declaration.

int ACEXML_Parser::parse_version_num | ( | ACEXML_Char *& | str | ) | `[protected]`

| Parse the version number in a VersionInfo declaration.

void ACEXML_Parser::parse_xml_decl | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse a XMLDecl declaration.

void ACEXML_Parser::parse_xml_prolog | ( | ACEXML_ENV_SINGLE_ARG_DECL |  | ) | `[protected]`

| Parse XML Prolog.

ACEXML_INLINE ACEXML_Char ACEXML_Parser::peek | ( | void |  | ) | `[protected, virtual]`

| Peek a character.

int ACEXML_Parser::pop_context | ( | int GE_ref | ACEXML_ENV_ARG_DECL | ) | `[private]`

| Pop the top element in the stack and replace current context with that.

void ACEXML_Parser::prefix_mapping | ( | const ACEXML_Char * | prefix,
|  | const ACEXML_Char * | uri,
|  | 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

int ACEXML_Parser::push_context | ( | ACEXML_Parser_Context * | context | ) | `[private]`

| Push the current context on to the stack.

void ACEXML_Parser::reset | ( | void |  | ) | `[private]`

| Reset the parser state.

ACEXML_INLINE void ACEXML_Parser::setContentHandler | ( | ACEXML_ContentHandler * | handler | ) | `[virtual]`

| Allow an application to register a content event handler. Implements ACEXML_XMLReader.

ACEXML_INLINE void ACEXML_Parser::setDTDHandler | ( | ACEXML_DTDHandler * | handler | ) | `[virtual]`

| Allow an application to register a DTD event handler. Implements ACEXML_XMLReader.

ACEXML_INLINE void ACEXML_Parser::setEntityResolver | ( | ACEXML_EntityResolver * | resolver | ) | `[virtual]`

| Allow an application to register an entity resolver. Implements ACEXML_XMLReader.

ACEXML_INLINE void ACEXML_Parser::setErrorHandler | ( | ACEXML_ErrorHandler * | handler | ) | `[virtual]`

| Allow an application to register an error event handler. Implements ACEXML_XMLReader.

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.

ACEXML_INLINE int ACEXML_Parser::skip_equal | ( | void |  | ) | `[private]`

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

ACEXML_INLINE ACEXML_Char ACEXML_Parser::skip_whitespace | ( | void |  | ) | `[private]`

| Skip any whitespaces encountered until the first non-whitespace character is encountered. Returns: The next non-whitespace character from the CharStream. See also: skip_whitespace_count

ACEXML_INLINE int ACEXML_Parser::skip_whitespace_count | ( | ACEXML_Char * | peek = `0` | ) | `[private]`

  | 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::switch_input | ( | ACEXML_InputSource * | input,
|  | const ACEXML_Char * | systemId,
|  | const ACEXML_Char * | publicId = `0`
| ) | `[private, virtual]`

| Create a new ACEXML_InputSource from systemId and publicId and replace the current input source with the newly created InputSource.

int ACEXML_Parser::switch_input | ( | ACEXML_CharStream * | cstream,
|  | const ACEXML_Char * | systemId,
|  | const ACEXML_Char * | publicId = `0`
| ) | `[private, virtual]`

| Create a new ACEXML_CharStream from systemId and publicId and replace the current input stream with the newly created stream.

void ACEXML_Parser::warning | ( | const ACEXML_Char *msg | ACEXML_ENV_ARG_DECL | ) | `[private]`

| Dispatch warnings to ErrorHandler.

## Member Data Documentation

virtual void* ACEXML_Parser::ACEXML_SAXNotSupportedException

| Reimplemented from ACEXML_XMLReader.

virtual void ACEXML_Parser::ACEXML_SAXNotSupportedException

| Reimplemented from ACEXML_XMLReader.

void ACEXML_Parser::ACEXML_SAXNotSupportedException

| Reimplemented from ACEXML_XMLReader.

ACE_Obstack_T<ACEXML_Char> ACEXML_Parser::alt_stack_`[private]`

| Alternative obstack used to hold any strings when the original is in use.

ACEXML_ContentHandler* ACEXML_Parser::content_handler_`[private]`

ACE_Unbounded_Stack<ACEXML_Parser_Context*> ACEXML_Parser::ctx_stack_`[private]`

| Stack used to hold the Parser_Context.

ACEXML_Parser_Context* ACEXML_Parser::current_`[private]`

| Current parser context.

ACEXML_Char* ACEXML_Parser::doctype_`[private]`

| Document Type.

ACEXML_DTDHandler* ACEXML_Parser::dtd_handler_`[private]`

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

ACEXML_EntityResolver* ACEXML_Parser::entity_resolver_`[private]`

ACEXML_ErrorHandler* ACEXML_Parser::error_handler_`[private]`

int ACEXML_Parser::external_dtd_`[private]`

| If set, the document has an external DTD subset.

int ACEXML_Parser::external_entity_`[private]`

| T => We are parsing an external entity value.

ACEXML_Entity_Manager ACEXML_Parser::external_GE_`[private]`

| Set of external parsed general entities in the document.

ACEXML_Entity_Manager ACEXML_Parser::external_PE_`[private]`

| Set of external parsed parameter entities in the document.

int ACEXML_Parser::external_subset_`[private]`

| T => We are parsing an external subset.

ACE_Unbounded_Stack<ACEXML_Char*> ACEXML_Parser::GE_reference_`[private]`

| Set used to hold the general entity references that are active.

int ACEXML_Parser::has_pe_refs_`[private]`

| T => Internal DTD has parameter entity references.

int ACEXML_Parser::internal_dtd_`[private]`

| If set, the document has an internal DTD.

ACEXML_Entity_Manager ACEXML_Parser::internal_GE_`[private]`

| Set of internal parsed general entities in the document.

ACEXML_Entity_Manager ACEXML_Parser::internal_PE_`[private]`

| Set of internal parsed parameter entities in the document.

int ACEXML_Parser::namespace_prefixes_`[private]`

| If set, the parser should include namespace declarations in the list of attributes of an element.

int ACEXML_Parser::namespaces_`[private]`

| If set, the parser should allow access by namespace qualified names.

int ACEXML_Parser::nested_namespace_`[private]`

| T => We are processing a nested namespace.

ACEXML_Entity_Manager ACEXML_Parser::notations_`[private]`

| Set of notations declared in the document.

ACE_Obstack_T<ACEXML_Char> ACEXML_Parser::obstack_`[private]`

| Obstack used by the parser to hold all the strings parsed.

ACE_Unbounded_Stack<ACEXML_Char*> ACEXML_Parser::PE_reference_`[private]`

| Set used to hold the parameter entity references that are active.

ACEXML_Entity_Manager ACEXML_Parser::predef_entities_`[private]`

| Set of predefined entities used by the parser.

ACEXML_ParserInt::ReferenceState ACEXML_Parser::ref_state_`[private]`

| State of the parser when it encounters a reference.

int ACEXML_Parser::simple_parsing_`[private]`

| Feature flags If set, the parser should parse a document without a prolog

int ACEXML_Parser::standalone_`[private]`

| If set, the document is a standalone XML document.

ACEXML_Entity_Manager ACEXML_Parser::unparsed_entities_`[private]`

| Set of unparsed entities in the document.

int ACEXML_Parser::validate_`[private]`

| If set, the parser should also validate.

ACEXML_NamespaceSupport ACEXML_Parser::xml_namespace_`[private]`

| Namespace stack used by the parser to implement support for Namespaces.

The documentation for this class was generated from the following files:

- Parser.h
- Parser.cpp
- Parser.i