#include <ACEXML/parser/parser/Parser.h>
Inheritance diagram for ACEXML_Parser:
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) |
| virtual void | setFeature (const ACEXML_Char *name, int boolean_value ACEXML_ENV_ARG_DECL) |
| virtual void * | getProperty (const ACEXML_Char *name ACEXML_ENV_ARG_DECL) |
| virtual void | setProperty (const ACEXML_Char *name, void *value ACEXML_ENV_ARG_DECL) |
| virtual void | parse (ACEXML_InputSource *input ACEXML_ENV_ARG_DECL) |
| virtual void | parse (const ACEXML_Char *systemId ACEXML_ENV_ARG_DECL) |
| virtual void | setContentHandler (ACEXML_ContentHandler *handler) |
| virtual void | setDTDHandler (ACEXML_DTDHandler *handler) |
| virtual void | setEntityResolver (ACEXML_EntityResolver *resolver) |
| virtual void | setErrorHandler (ACEXML_ErrorHandler *handler) |
Protected Member Functions | |
| void | parse_xml_prolog (ACEXML_ENV_SINGLE_ARG_DECL) |
| void | parse_version_info (ACEXML_ENV_SINGLE_ARG_DECL) |
| void | parse_encoding_decl (ACEXML_ENV_SINGLE_ARG_DECL) |
| void | parse_xml_decl (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_text_decl (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_processing_instruction (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_doctypedecl (ACEXML_ENV_SINGLE_ARG_DECL) |
| void | parse_element (int is_root ACEXML_ENV_ARG_DECL) |
| int | parse_content (const ACEXML_Char *startname, const ACEXML_Char *&ns_uri, const ACEXML_Char *&ns_lname, int ns_flag ACEXML_ENV_ARG_DECL) |
| int | parse_char_reference (ACEXML_Char *buf, size_t &len) |
| ACEXML_Char * | parse_reference_name (void) |
| int | parse_cdata (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_internal_dtd (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_comment (void) |
| 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_atttype (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_notation_decl (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_external_id (ACEXML_Char *&publicId, ACEXML_Char *&systemId ACEXML_ENV_ARG_DECL) |
| int | parse_external_dtd (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_external_subset (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_markup_decl (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_conditional_section (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_includesect (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_ignoresect (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_PE_reference (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_entity_reference (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_entity_value (ACEXML_Char *&str ACEXML_ENV_ARG_DECL) |
| int | parse_defaultdecl (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_children_definition (ACEXML_ENV_SINGLE_ARG_DECL) |
| int | parse_child (int skip_open_paren ACEXML_ENV_ARG_DECL) |
| 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) |
| int | parse_attvalue (ACEXML_Char *&str ACEXML_ENV_ARG_DECL) |
| int | parse_tokenized_type (ACEXML_ENV_SINGLE_ARG_DECL) |
| 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) |
| void | warning (const ACEXML_Char *msg ACEXML_ENV_ARG_DECL) |
| void | fatal_error (const ACEXML_Char *msg ACEXML_ENV_ARG_DECL) |
| void | prefix_mapping (const ACEXML_Char *prefix, const ACEXML_Char *uri, int start ACEXML_ENV_ARG_DECL) |
| int | parse_token (const ACEXML_Char *keyword) |
| int | push_context (ACEXML_Parser_Context *context) |
| size_t | 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") |
Definition at line 45 of file Parser.h.
|
|
Default constructor.
Definition at line 33 of file Parser.cpp. References MAXPATHLEN.
00034 : dtd_handler_ (0), 00035 entity_resolver_ (0), 00036 content_handler_ (0), 00037 error_handler_ (0), 00038 doctype_ (0), 00039 current_ (0), 00040 alt_stack_ (MAXPATHLEN), 00041 nested_namespace_ (0), 00042 ref_state_ (ACEXML_ParserInt::INVALID), 00043 external_subset_ (0), 00044 external_entity_ (0), 00045 has_pe_refs_ (0), 00046 standalone_ (0), 00047 external_dtd_ (0), 00048 internal_dtd_ (0), 00049 simple_parsing_ (0), 00050 validate_ (1), 00051 namespaces_(1), 00052 namespace_prefixes_ (0) 00053 { 00054 } |
|
|
Destructor.
Definition at line 56 of file Parser.cpp.
00057 {
00058
00059 }
|
|
|
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.
Definition at line 1445 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, external_subset_, fatal_error(), get(), parse_PE_reference(), peek(), pop_context(), and skip_whitespace_count(). Referenced by parse_attlist_decl(), parse_atttype(), parse_child(), parse_children_definition(), parse_element_decl(), and parse_notation_decl().
01446 {
01447 ACEXML_Char fwd = '\xFF';
01448 // Skip any leading whitespaces and store the number of such chars skipped
01449 int count = this->skip_whitespace_count (&fwd);
01450 if (fwd == 0)
01451 {
01452 this->get(); // Consume the 0
01453 this->pop_context (0 ACEXML_ENV_ARG_PARAMETER);
01454 ACEXML_CHECK_RETURN (-1);
01455 fwd = this->peek();
01456 }
01457 if (fwd == '%')
01458 {
01459 this->get(); // Consume the %
01460 if (this->external_subset_)
01461 {
01462 this->parse_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01463 ACEXML_CHECK_RETURN (-1);
01464 }
01465 else
01466 {
01467 this->fatal_error(ACE_TEXT ("Illegal PERef within markupDecl")
01468 ACEXML_ENV_ARG_PARAMETER);
01469 ACEXML_CHECK_RETURN (-1);
01470 }
01471 }
01472 if (count)
01473 {
01474 // We have atleast one whitespace. So just skip any more whitespaces
01475 // and return the count
01476 this->skip_whitespace_count();
01477 return count;
01478 }
01479 return this->skip_whitespace_count();
01480 }
|
|
|
Dispatch errors to ErrorHandler. Definition at line 3065 of file Parser.cpp. References ACE_NEW_NORETURN, ACEXML_Char, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_RAISE, ACEXML_ErrorHandler::error(), and error_handler_.
03066 {
03067 ACEXML_SAXParseException* exception = 0;
03068 ACE_NEW_NORETURN (exception, ACEXML_SAXParseException (msg));
03069 if (this->error_handler_)
03070 this->error_handler_->error (*exception ACEXML_ENV_ARG_PARAMETER);
03071 else
03072 ACEXML_ENV_RAISE (exception);
03073 return;
03074 }
|
|
|
|
|
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.)
|
|
|
Return the current content handler. Implements ACEXML_XMLReader. Definition at line 12 of file Parser.inl. References content_handler_.
00013 {
00014 return this->content_handler_;
00015 }
|
|
|
Return the current DTD handler. Implements ACEXML_XMLReader. Definition at line 18 of file Parser.inl. References dtd_handler_.
00019 {
00020 return this->dtd_handler_;
00021 }
|
|
|
Return the current entity resolver. Implements ACEXML_XMLReader. Definition at line 24 of file Parser.inl. References entity_resolver_.
00025 {
00026 return this->entity_resolver_;
00027 }
|
|
|
Return the current error handler. Implements ACEXML_XMLReader. Definition at line 30 of file Parser.inl. References error_handler_.
00031 {
00032 return this->error_handler_;
00033 }
|
|
|
Look up the value of a feature. This method allows programmers to check whether a specific feature has been activated in the parser. Implements ACEXML_XMLReader. Definition at line 2996 of file Parser.cpp. References ACEXML_Char, ACEXML_THROW_RETURN, namespace_prefixes_, namespace_prefixes_feature_, namespaces_, namespaces_feature_, simple_parsing_, simple_parsing_feature_, ACE_OS::strcmp(), validate_, and validation_feature_.
02997 {
02998 if (ACE_OS::strcmp (name, ACEXML_Parser::simple_parsing_feature_) == 0)
02999 {
03000 return this->simple_parsing_;
03001 }
03002 else if (ACE_OS::strcmp (name, ACEXML_Parser::namespaces_feature_) == 0)
03003 {
03004 return this->namespaces_;
03005 }
03006 else if (ACE_OS::strcmp (name,
03007 ACEXML_Parser::namespace_prefixes_feature_) == 0)
03008 {
03009 return this->namespace_prefixes_;
03010 }
03011 else if (ACE_OS::strcmp (name, ACEXML_Parser::validation_feature_) == 0)
03012 {
03013 return this->validate_;
03014 }
03015 ACEXML_THROW_RETURN (ACEXML_SAXNotRecognizedException (name), -1);
03016 }
|
|
|
Look up the value of a property. Implements ACEXML_XMLReader. Definition at line 3050 of file Parser.cpp. References ACEXML_Char, and ACEXML_THROW_RETURN.
03051 {
03052 ACEXML_THROW_RETURN (ACEXML_SAXNotSupportedException (name), 0);
03053 }
|
|
|
Initialize the parser state.
Definition at line 62 of file Parser.cpp. References ACE_ERROR, ACE_TEXT, ACEXML_Entity_Manager::add_entity(), ACEXML_InputSource::getSystemId(), ACEXML_NamespaceSupport::init(), LM_DEBUG, LM_ERROR, predef_entities_, switch_input(), and xml_namespace_. Referenced by parse().
00063 {
00064 // Initialize namespace support
00065 if (this->xml_namespace_.init() == -1)
00066 {
00067 ACE_ERROR ((LM_ERROR,
00068 ACE_TEXT ("Error initializing namespace support\n")));
00069 return -1;
00070 }
00071 for (int i = 0; i < 5; ++i)
00072 {
00073 if (this->predef_entities_.add_entity (ACEXML_ParserInt::predef_ent_[i],
00074 ACEXML_ParserInt::predef_val_[i])
00075 != 0)
00076 {
00077 ACE_ERROR ((LM_DEBUG,
00078 ACE_TEXT ("Error adding entity %s to Manager\n"),
00079 ACEXML_ParserInt::predef_ent_[i]));
00080 return -1;
00081 }
00082 }
00083 return this->switch_input (input, input->getSystemId());
00084 }
|
|
|
Check if a character c is a whitespace.
Definition at line 161 of file Parser.inl. References ACEXML_Char. Referenced by parse_tokenized_type(), skip_equal(), skip_whitespace(), and skip_whitespace_count().
00162 {
00163 switch (c)
00164 {
00165 case '\x0A': case '\x20':
00166 case '\x09': case '\x0D':
00167 return 1;
00168 default:
00169 return 0;
00170 }
00171 }
|
|
|
Check if a character c is a BaseChar.
Definition at line 82 of file Parser.inl. References ACEXML_Char. Referenced by isLetter().
00083 {
00084 #if defined (ACE_USES_WCHAR)
00085 return ACEXML_ParserInt::isBasechar_i (c);
00086 #else
00087 return ACEXML_ParserInt::base_char_table_[(int) c];
00088 #endif /* ACE_USES_WCHAR */
00089 }
|
|
|
Check if a character c is a valid Char.
Definition at line 60 of file Parser.inl. References ACEXML_UCS4. Referenced by parse_char_reference().
00061 {
00062 return (c == 0x9 || c == 0xA || c == 0xD ||
00063 c >= 0x20 && c <= 0xD7FF ||
00064 c >= 0xE000 && c <= 0xFFFD ||
00065 c >= 0x10000 && c <= 0x10FFFF);
00066 }
|
|
|
Check if a character c is a valid CharRef character.
Definition at line 69 of file Parser.inl. References ACEXML_Char. Referenced by parse_char_reference().
00070 {
00071 return ((c >= 'a' && c <= 'f') ||
00072 (c >= 'A' && c <= 'F'));
00073 }
|
|
|
Check if a character c is a CombiningChar.
Definition at line 103 of file Parser.inl. References ACEXML_Char. Referenced by isNameChar().
00104 {
00105 #if defined (ACE_USES_WCHAR)
00106 return ACEXML_ParserInt::isCombiningchar_i (c);
00107 #else
00108 ACE_UNUSED_ARG (c);
00109 return 0;
00110 #endif /* ACE_USES_WCHAR */
00111 }
|
|
|
Check if a character c is a Digit.
Definition at line 114 of file Parser.inl. References ACEXML_Char, and isNormalDigit(). Referenced by isNameChar().
00115 {
00116 #if defined (ACE_USES_WCHAR)
00117 return ACEXML_ParserInt::isDigit_i (c);
00118 #else
00119 return (this->isNormalDigit (c));
00120 #endif /* ACE_USES_WCHAR */
00121 }
|
|
|
Check if a character c is an Extender.
Definition at line 124 of file Parser.inl. References ACEXML_Char. Referenced by isNameChar().
00125 {
00126 #if defined (ACE_USES_WCHAR)
00127 return ACEXML_ParserInt::isExtender_i (c);
00128 #else
00129 return (c == '\xB7');
00130 #endif /* ACE_USES_WCHAR */
00131 }
|
|
|
Check if a character c is a Ideographic.
Definition at line 92 of file Parser.inl. References ACEXML_Char. Referenced by isLetter().
00093 {
00094 #if defined (ACE_USES_WCHAR)
00095 return ACEXML_ParserInt::isIdeographic_i (c);
00096 #else
00097 ACE_UNUSED_ARG (c);
00098 return 0;
00099 #endif /* ACE_USES_WCHAR */
00100 }
|
|
|
Check if a character c is a Letter.
Definition at line 134 of file Parser.inl. References ACEXML_Char, isBasechar(), and isIdeographic(). Referenced by isNameChar(), parse_name(), and parse_reference_name().
00135 {
00136 return (this->isBasechar (c) || this->isIdeographic (c));
00137 }
|
|
|
Check if a character is an acceptable NameChar.
Definition at line 140 of file Parser.inl. References ACEXML_Char, isCombiningchar(), isDigit(), isExtender(), and isLetter(). Referenced by parse_name(), parse_nmtoken(), and parse_reference_name().
00141 {
00142 return (this->isLetter (c) || this->isDigit (c) || c == '.' || c == '-' ||
00143 c == '_' || c == ':' || this->isCombiningchar (c) ||
00144 this->isExtender (c));
00145 }
|
|
|
Check if a character c is a Digit.
Definition at line 76 of file Parser.inl. References ACEXML_Char. Referenced by isDigit(), and parse_char_reference().
00077 {
00078 return (c >= '\x30' && c <= '\x39');
00079 }
|
|
|
Check if a character is a PubidChar.
Definition at line 148 of file Parser.inl. References ACEXML_Char. Referenced by parse_pubid_literal().
00149 {
00150 return (c == '\x20' || c == '\x0D' || c == '\x0A' ||
00151 (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
00152 (c >= '0' && c <= '9') || c == '-' || c == '\'' || c == '(' ||
00153 c == ')' || c == '+' || c == ',' || c == '.' || c == '/' ||
00154 c == ':' || c == '=' || c == '?' || c == ';' || c == '!' ||
00155 c == '*' || c == '#' || c == '@' || c == '$' || c == '_' ||
00156 c == '%');
00157 }
|
|
|
Very trivial, non-conformant normalization of a systemid. Definition at line 780 of file Parser.cpp. References ACE_ASSERT, ACE_DIRECTORY_SEPARATOR_CHAR, ACE_NEW_RETURN, ACE_TEXT, ACEXML_Char, ACEXML_Parser_Context::getLocator(), ACEXML_LocatorImpl::getSystemId(), ACE_OS::strcpy(), ACE_OS::strlen(), ACE_OS::strncpy(), ACE_OS::strrchr(), and ACE_OS::strstr(). Referenced by parse_entity_reference(), parse_external_dtd(), and parse_PE_reference().
00781 {
00782 if (ACE_OS::strstr (systemId, ACE_TEXT("ftp://")) != 0 ||
00783 ACE_OS::strstr (systemId, ACE_TEXT ("http://")) != 0 ||
00784 ACE_OS::strstr (systemId, ACE_TEXT ("file://")) != 0)
00785 return 0;
00786 else
00787 {
00788 ACEXML_Char* normalized_uri = 0;
00789 const ACEXML_Char* baseURI = this->current_->getLocator()->getSystemId();
00790 ACE_ASSERT (baseURI);
00791 const ACEXML_Char* temp = 0;
00792 if (ACE_OS::strstr (baseURI, ACE_TEXT ("http://")) != 0)
00793 // baseURI is a HTTP URL and systemId is relative. Note that this
00794 // is not compliant with RFC2396. Caveat Emptor !
00795 temp = ACE_OS::strrchr (baseURI, '/');
00796 else
00797 // baseURI is a local file and systemId is relative
00798 // Unlike the HTTP one, this will work always.
00799 temp = ACE_OS::strrchr (baseURI,ACE_DIRECTORY_SEPARATOR_CHAR);
00800 if (temp)
00801 {
00802 size_t pos = temp - baseURI + 1;
00803 size_t len = pos + ACE_OS::strlen (systemId) + 1;
00804 ACE_NEW_RETURN (normalized_uri, ACEXML_Char[len], 0);
00805 ACE_OS::strncpy (normalized_uri, baseURI, pos);
00806 ACE_OS::strcpy (normalized_uri + pos, systemId);
00807 return normalized_uri;
00808 }
00809 return 0;
00810 }
00811 }
|
|
|
Parse an XML document from a system identifier (URI). Implements ACEXML_XMLReader. Definition at line 87 of file Parser.cpp. References ACE_NEW, ACEXML_Char, ACEXML_ENV_ARG_PARAMETER, and parse().
00088 {
00089 ACEXML_InputSource* input = 0;
00090 ACE_NEW (input, ACEXML_InputSource (systemId));
00091 this->parse (input ACEXML_ENV_ARG_PARAMETER);
00092 }
|
|
|
Parse an XML document. Implements ACEXML_XMLReader. Definition at line 95 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, content_handler_, dtd_handler_, ACEXML_ContentHandler::endDocument(), fatal_error(), get(), initialize(), parse_comment(), parse_doctypedecl(), parse_element(), parse_processing_instruction(), parse_xml_decl(), peek(), reset(), ACEXML_ContentHandler::setDocumentLocator(), skip_whitespace(), ACEXML_ContentHandler::startDocument(), validate_, and warning(). Referenced by parse().
00096 {
00097 if (input == 0)
00098 {
00099 this->fatal_error(ACE_TEXT ("Invalid input source")
00100 ACEXML_ENV_ARG_PARAMETER);
00101 ACEXML_CHECK;
00102 }
00103 if (this->content_handler_ == 0)
00104 {
00105 this->fatal_error (ACE_TEXT ("No content handlers defined. Exiting..")
00106 ACEXML_ENV_ARG_PARAMETER);
00107 ACEXML_CHECK;
00108 }
00109
00110 if (this->validate_ && this->dtd_handler_ == 0)
00111 {
00112 this->fatal_error (ACE_TEXT ("No DTD handlers defined. Exiting..")
00113 ACEXML_ENV_ARG_PARAMETER);
00114 ACEXML_CHECK;
00115 }
00116
00117
00118 if (this->initialize(input) == -1)
00119 {
00120 this->fatal_error (ACE_TEXT ("Failed to initialize parser state")
00121 ACEXML_ENV_ARG_PARAMETER);
00122 ACEXML_CHECK;
00123 }
00124 // Set up Locator.
00125 this->content_handler_->setDocumentLocator (this->current_->getLocator());
00126
00127 int xmldecl_defined = 0;
00128 ACEXML_Char fwd = this->get(); // Consume '<'
00129 if (fwd == '<' && this->peek() == '?')
00130 {
00131 this->get(); // Consume '?'
00132 fwd = this->peek();
00133 if (fwd == 'x' && !xmldecl_defined)
00134 {
00135 this->parse_xml_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00136 ACEXML_CHECK;
00137 xmldecl_defined = 1;
00138 }
00139 }
00140 // We need a XMLDecl in a Valid XML document
00141 if (this->validate_ && !xmldecl_defined)
00142 {
00143 this->fatal_error (ACE_TEXT ("Expecting an XMLDecl at the beginning of")
00144 ACE_TEXT (" a valid document")
00145 ACEXML_ENV_ARG_PARAMETER);
00146 ACEXML_CHECK;
00147 }
00148 this->content_handler_->startDocument (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00149 ACEXML_CHECK;
00150
00151 int doctype_defined = 0;
00152 for (int prolog_done = 0; prolog_done == 0; )
00153 {
00154 // Expect a '<' only if we have encountered a XMLDecl, or we are
00155 // looping through Misc blocks.
00156 if (xmldecl_defined)
00157 {
00158 if (this->skip_whitespace () != '<')
00159 {
00160 this->fatal_error (ACE_TEXT ("Expecting '<' at the beginning of ")
00161 ACE_TEXT ("Misc section")
00162 ACEXML_ENV_ARG_PARAMETER);
00163 ACEXML_CHECK;
00164 }
00165 fwd = this->peek();
00166 }
00167 switch (fwd)
00168 {
00169 case '?':
00170 this->get();
00171 this->parse_processing_instruction (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00172 ACEXML_CHECK;
00173 xmldecl_defined = 1;
00174 break;
00175 case '!':
00176 this->get();
00177 fwd = this->peek ();
00178 if (fwd == 'D' && !doctype_defined) // DOCTYPE
00179 {
00180 // This will also take care of the trailing MISC block if any.
00181 this->parse_doctypedecl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00182 ACEXML_CHECK;
00183 doctype_defined = 1;
00184 // Now that we have a DOCTYPE Decl defined, we shouldn't
00185 // accept XML Decl any longer
00186 xmldecl_defined = 1;
00187 }
00188 else if (fwd == 'D')
00189 {
00190 this->fatal_error (ACE_TEXT ("Duplicate DOCTYPE declaration")
00191 ACEXML_ENV_ARG_PARAMETER);
00192 ACEXML_CHECK;
00193 }
00194 else if (fwd == '-') // COMMENT
00195 {
00196 if (this->parse_comment () < 0)
00197 {
00198 this->fatal_error(ACE_TEXT ("Invalid comment in document")
00199 ACEXML_ENV_ARG_PARAMETER);
00200 ACEXML_CHECK;
00201 }
00202 xmldecl_defined = 1;
00203 }
00204 break;
00205 case 0:
00206 this->fatal_error (ACE_TEXT ("Unexpected end-of-file")
00207 ACEXML_ENV_ARG_PARAMETER);
00208 ACEXML_CHECK;
00209 default: // Root element begins
00210 prolog_done = 1;
00211 break;
00212 }
00213 }
00214
00215 if (this->validate_ && !doctype_defined)
00216 {
00217 this->warning (ACE_TEXT ("No doctypeDecl in valid document")
00218 ACEXML_ENV_ARG_PARAMETER);
00219 ACEXML_CHECK;
00220 }
00221
00222 // Now parse root element.
00223 this->parse_element (1 ACEXML_ENV_ARG_PARAMETER);
00224 ACEXML_CHECK;
00225
00226 this->content_handler_->endDocument (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00227 ACEXML_CHECK;
00228
00229 // Reset the parser state
00230 this->reset();
00231
00232 }
|
|
|
Parse an "ATTLIST" decl. Thse first character this method expects is always the 'A' (the first char) in the word "ATTLIST".
Definition at line 1367 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, check_for_PE_reference(), fatal_error(), get(), parse_attname(), parse_atttype(), parse_defaultdecl(), parse_name(), parse_token(), and skip_whitespace_count(). Referenced by parse_markup_decl().
01368 {
01369 if (this->parse_token (ACE_TEXT ("ATTLIST")) < 0)
01370 {
01371 this->fatal_error(ACE_TEXT ("Expecting keyword 'ATTLIST'")
01372 ACEXML_ENV_ARG_PARAMETER);
01373 ACEXML_CHECK_RETURN (-1);
01374 }
01375 int count = check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01376 ACEXML_CHECK_RETURN (-1);
01377 if (!count)
01378 {
01379 this->fatal_error(ACE_TEXT ("Expecting space between ATTLIST and ")
01380 ACE_TEXT ("element name") ACEXML_ENV_ARG_PARAMETER);
01381 ACEXML_CHECK_RETURN (-1);
01382 }
01383
01384 ACEXML_Char *element_name = this->parse_name ();
01385 if (element_name == 0)
01386 {
01387 this->fatal_error(ACE_TEXT ("Invalid element Name in attlistDecl")
01388 ACEXML_ENV_ARG_PARAMETER);
01389 ACEXML_CHECK_RETURN (-1);
01390 }
01391 ACEXML_Char fwd = 0;
01392 count = this->skip_whitespace_count (&fwd);
01393 // Parse AttDef*
01394 while (fwd != '>')
01395 {
01396 if (!this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER)
01397 && !count)
01398 this->fatal_error(ACE_TEXT ("Expecting space between element ")
01399 ACE_TEXT ("name and AttDef")
01400 ACEXML_ENV_ARG_PARAMETER);
01401 ACEXML_CHECK_RETURN (-1);
01402 this->skip_whitespace_count (&fwd);
01403 if (fwd == '>')
01404 break;
01405
01406 count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01407 ACEXML_CHECK_RETURN (-1);
01408
01409 this->parse_attname (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01410 ACEXML_CHECK_RETURN (-1);
01411
01412 count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01413 ACEXML_CHECK_RETURN (-1);
01414 if (!count)
01415 {
01416 this->fatal_error(ACE_TEXT ("Expecting space between AttName and ")
01417 ACE_TEXT ("AttType") ACEXML_ENV_ARG_PARAMETER);
01418 ACEXML_CHECK_RETURN (-1);
01419 }
01420 this->parse_atttype (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01421 ACEXML_CHECK_RETURN (-1);
01422
01423 count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01424 ACEXML_CHECK_RETURN (-1);
01425 if (!count)
01426 {
01427 this->fatal_error(ACE_TEXT ("Expecting space between AttType and")
01428 ACE_TEXT (" DefaultDecl")
01429 ACEXML_ENV_ARG_PARAMETER);
01430 ACEXML_CHECK_RETURN (-1);
01431 }
01432 this->parse_defaultdecl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01433 ACEXML_CHECK_RETURN (-1);
01434
01435 count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01436 ACEXML_CHECK_RETURN (-1);
01437 this->skip_whitespace_count(&fwd);
01438 }
01439 this->get (); // consume closing '>'
01440 return 0;
01441 }
|
|
|
Parse an attribute name.
Definition at line 1483 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, fatal_error(), and parse_name(). Referenced by parse_attlist_decl().
01484 {
01485 // Parse attribute name
01486 ACEXML_Char *att_name = this->parse_name ();
01487 if (att_name == 0)
01488 {
01489 this->fatal_error(ACE_TEXT ("Invalid AttName")
01490 ACEXML_ENV_ARG_PARAMETER);
01491 ACEXML_CHECK_RETURN (0);
01492 }
01493 return att_name;
01494 }
|
|
|
Parse a AttType declaration. Definition at line 1693 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, check_for_PE_reference(), fatal_error(), get(), parse_name(), parse_nmtoken(), parse_token(), parse_tokenized_type(), peek(), and skip_whitespace_count(). Referenced by parse_attlist_decl().
01694 {
01695 ACEXML_Char nextch = this->peek();
01696 switch (nextch)
01697 {
01698 case 'C': // CDATA
01699 if (this->parse_token (ACE_TEXT ("CDATA")) < 0)
01700 {
01701 this->fatal_error(ACE_TEXT ("Expecting keyword 'CDATA'")
01702 ACEXML_ENV_ARG_PARAMETER);
01703 ACEXML_CHECK_RETURN (-1);
01704 }
01705 // Else, we have successfully identified the type of the
01706 // attribute as CDATA
01707 // @@ Set up validator appropriately here.
01708 break;
01709 case 'I': case 'E': // ID, IDREF, IDREFS, ENTITY or ENTITIES
01710 this->parse_tokenized_type (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01711 ACEXML_CHECK_RETURN (-1);
01712 break;
01713 case 'N': // NMTOKEN, NMTOKENS, or NOTATION
01714 this->get();
01715 nextch = this->peek();
01716 if (nextch != 'M' && nextch != 'O')
01717 {
01718 this->fatal_error (ACE_TEXT ("Expecting keyword 'NMTOKEN', ")
01719 ACE_TEXT ("'NMTOKENS' or 'NOTATION'")
01720 ACEXML_ENV_ARG_PARAMETER);
01721 ACEXML_CHECK_RETURN (-1);
01722 }
01723 if (nextch == 'M')
01724 {
01725 this->parse_tokenized_type (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01726 ACEXML_CHECK_RETURN (-1);
01727 break;
01728 }
01729 else // NOTATION
01730 {
01731 if (this->parse_token (ACE_TEXT ("OTATION")) < 0)
01732 {
01733 this->fatal_error(ACE_TEXT ("Expecting keyword `NOTATION'")
01734 ACEXML_ENV_ARG_PARAMETER);
01735 ACEXML_CHECK_RETURN (-1);
01736 }
01737 int count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01738 ACEXML_CHECK_RETURN (-1);
01739 if (!count)
01740 {
01741 this->fatal_error (ACE_TEXT ("Expecting space between keyword ")
01742 ACE_TEXT ("NOTATION and '('")
01743 ACEXML_ENV_ARG_PARAMETER);
01744 ACEXML_CHECK_RETURN (-1);
01745 }
01746 if (this->get () != '(')
01747 {
01748 this->fatal_error(ACE_TEXT ("Expecting '(' in NotationType")
01749 ACEXML_ENV_ARG_PARAMETER);
01750 ACEXML_CHECK_RETURN (-1);
01751 }
01752 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01753 ACEXML_CHECK_RETURN (-1);
01754 do {
01755 this->skip_whitespace_count();
01756 ACEXML_Char *notation_name = this->parse_name ();
01757 if (notation_name == 0)
01758 {
01759 this->fatal_error(ACE_TEXT ("Invalid notation name")
01760 ACEXML_ENV_ARG_PARAMETER);
01761 ACEXML_CHECK_RETURN (-1);
01762 }
01763 // @@ get another notation name, set up validator as such
01764 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01765 ACEXML_CHECK_RETURN (-1);
01766 nextch = this->get();
01767 } while (nextch == '|');
01768 if (nextch != ')')
01769 {
01770 this->fatal_error (ACE_TEXT ("Expecting a ')' after a ")
01771 ACE_TEXT ("NotationType declaration")
01772 ACEXML_ENV_ARG_PARAMETER);
01773 ACEXML_CHECK_RETURN (-1);
01774 }
01775 }
01776 break;
01777 case '(': // EnumeratedType - Enumeration
01778 this->get();
01779 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01780 ACEXML_CHECK_RETURN (-1);
01781 do {
01782 this->skip_whitespace_count();
01783 ACEXML_Char *token_name = this->parse_nmtoken ();
01784 if (token_name == 0)
01785 {
01786 this->fatal_error(ACE_TEXT ("Invalid enumeration name")
01787 ACEXML_ENV_ARG_PARAMETER);
01788 ACEXML_CHECK_RETURN (-1);
01789 }
01790 // @@ get another nmtoken, set up validator as such
01791 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01792 ACEXML_CHECK_RETURN (-1);
01793 nextch = this->get();
01794 } while (nextch == '|');
01795 if (nextch != ')')
01796 {
01797 this->fatal_error (ACE_TEXT ("Expecting a ')' after a ")
01798 ACE_TEXT ("Enumeration declaration")
01799 ACEXML_ENV_ARG_PARAMETER);
01800 ACEXML_CHECK_RETURN (-1);
01801 }
01802 break;
01803 default:
01804 {
01805 this->fatal_error(ACE_TEXT ("Invalid AttType")
01806 ACEXML_ENV_ARG_PARAMETER);
01807 ACEXML_CHECK_RETURN (-1);
01808 }
01809 ACE_NOTREACHED (break);
01810 }
01811 return 0;
01812 }
|
|
|
Parse an attribute value.
Definition at line 2254 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, fatal_error(), ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), obstack_, parse_char_reference(), parse_entity_reference(), peek(), pop_context(), and ref_state_. Referenced by parse_defaultdecl(), and parse_element().
02255 {
02256 ACEXML_Char quote = this->get ();
02257 if (quote != '\'' && quote != '"') // Not a quoted string.
02258 return -1;
02259 ACEXML_Char ch = this->get ();
02260 while (1)
02261 {
02262 if (ch == quote)
02263 {
02264 ACEXML_Char* temp = this->obstack_.freeze ();
02265 // If the attribute type is not CDATA, then the XML processor
02266 // must further process the normalized attribute value by
02267 // discarding any leading and trailing space (#x20) characters,
02268 // and by replacing sequences of space (#x20) characters by a
02269 // single space (#x20) character.
02270
02271 // if (atttype != CDATA) {
02272 // ACEXML_Char* start = temp;
02273 // ACEXML_Char* end = temp + ACE_OS::strlen (temp);
02274 // while (*start == '\x20')
02275 // start++;
02276 // if (start == end) // String which is all spaces
02277 // str = start;
02278 // while (*start != 0)
02279 // {
02280 // this->obstack_.grow (*start);
02281 // start++;
02282 // while (*start == '\x20')
02283 // start++;
02284 // }
02285 // str = this->obstack_.freeze();
02286 // }
02287 str = temp;
02288 return 0;
02289 }
02290 switch (ch)
02291 {
02292 case '&':
02293 if (this->peek () == '#')
02294 {
02295 ACEXML_Char buf[7];
02296 size_t len = sizeof (buf);
02297 if (this->parse_char_reference (buf, len) != 0)
02298 {
02299 // [WFC: Legal Character]
02300 this->fatal_error (ACE_TEXT ("Invalid CharacterRef")
02301 ACEXML_ENV_ARG_PARAMETER);
02302 ACEXML_CHECK_RETURN (-1);
02303 }
02304 for (size_t j = 0; j < len; ++j)
02305 this->obstack_.grow (buf[j]);
02306 }
02307 else
02308 {
02309 this->ref_state_ = ACEXML_ParserInt::IN_ATT_VALUE;
02310 this->parse_entity_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
02311 ACEXML_CHECK_RETURN (-1);
02312 }
02313 break;
02314 case '\x20': case '\x0D': case '\x0A': case '\x09':
02315 this->obstack_.grow ('\x20');
02316 break;
02317 case '<': // [WFC: No < in Attribute Values]
02318 this->fatal_error (ACE_TEXT ("Illegal '<' in AttValue")
02319 ACEXML_ENV_ARG_PARAMETER);
02320 ACEXML_CHECK_RETURN (-1);
02321 break;
02322 case 0:
02323 this->pop_context (1 ACEXML_ENV_ARG_PARAMETER);
02324 ACEXML_CHECK_RETURN (-1);
02325 break;
02326 default:
02327 this->obstack_.grow (ch);
02328 break;
02329 }
02330 ch = this->get();
02331 }
02332 }
|
|
|
Parse a CDATA section. The first character should always be the first '[' in CDATA definition.
Definition at line 1161 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ContentHandler::characters(), content_handler_, fatal_error(), ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), obstack_, parse_token(), peek(), and ACE_Obstack_T< ACEXML_Char >::unwind(). Referenced by parse_content().
01162 {
01163 if (this->parse_token (ACE_TEXT ("[CDATA[")) < 0)
01164 {
01165 this->fatal_error(ACE_TEXT ("Expecting '[CDATA[' at beginning of CDATA ")
01166 ACE_TEXT ("section")
01167 ACEXML_ENV_ARG_PARAMETER);
01168 ACEXML_CHECK_RETURN (-1);
01169 }
01170
01171 ACEXML_Char ch;
01172 int datalen = 0;
01173 ACEXML_Char *cdata = 0;
01174 while (1)
01175 {
01176 ch = this->get ();
01177 // Anything goes except the sequence "]]>".
01178 if (ch == ']' && this->peek() == ']')
01179 {
01180 ACEXML_Char temp = ch;
01181 ch = this->get();
01182 if (ch == ']' && this->peek() == '>')
01183 {
01184 ch = this->get();
01185 cdata = this->obstack_.freeze ();
01186 this->content_handler_->characters (cdata, 0, datalen
01187 ACEXML_ENV_ARG_PARAMETER);
01188 ACEXML_CHECK_RETURN (-1);
01189 this->obstack_.unwind(cdata);
01190 return 0;
01191 }
01192 this->obstack_.grow (temp);
01193 ++datalen;
01194 }
01195 this->obstack_.grow (ch);
01196 ++datalen;
01197 };
01198 ACE_NOTREACHED (return -1);
01199 }
|
|
||||||||||||
|
Parse a character reference, i.e., " " or "". The first character encountered should be the '#' char.
Definition at line 2183 of file Parser.cpp. References ACEXML_Char, ACEXML_UCS4, get(), isChar(), isCharRef(), isNormalDigit(), peek(), ACE_OS::strtol(), ACEXML_Transcoder::ucs42utf16(), and ACEXML_Transcoder::ucs42utf8(). Referenced by parse_attvalue(), parse_content(), and parse_entity_value().
02184 {
02185 if (len < 7) // Max size of a CharRef plus terminating '\0'
02186 return -1;
02187 ACEXML_Char ch = this->get();
02188 if (ch != '#') // Internal error.
02189 return -1;
02190 int hex = 0;
02191 ch = this->peek();
02192 if (ch == 'x')
02193 {
02194 hex = 1;
02195 this->get ();
02196 }
02197 size_t i = 0;
02198 int more_digit = 0;
02199 ch = this->get ();
02200 for ( ; i < len &&
02201 (this->isNormalDigit (ch) || (hex ? this->isCharRef(ch): 0)); ++i)
02202 {
02203 buf[i] = ch;
02204 ch = this->get();
02205 ++more_digit;
02206 }
02207 if (ch != ';' || !more_digit)
02208 return -1;
02209 buf[i] = 0;
02210 ACEXML_UCS4 sum = (ACEXML_UCS4) ACE_OS::strtol (buf, 0, (hex ? 16 : 10));
02211 // [WFC: Legal Character]
02212 if (!this->isChar (sum))
02213 return -1;
02214 int clen;
02215 #if defined (ACE_USES_WCHAR)
02216 # if (ACE_SIZEOF_WCHAR == 2) // UTF-16
02217 if ((clen = ACEXML_Transcoder::ucs42utf16 (sum, buf, len)) < 0)
02218 return -1;
02219 # elif (ACE_SIZEOF_WCHAR == 4) // UCS 4
02220 buf [0] = sum;
02221 buf [1] = 0;
02222 clen = 2;
02223 # endif /* ACE_SIZEOF_WCHAR */
02224
02225 #else // or UTF-8
02226 if ((clen = ACEXML_Transcoder::ucs42utf8 (sum, buf, len)) < 0)
02227 return -1;
02228 #endif
02229 buf [clen] = 0;
02230 len = clen;
02231 return 0;
02232 }
|
|
|
Parse a
Definition at line 2046 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, check_for_PE_reference(), fatal_error(), get(), parse_name(), peek(), and skip_whitespace_count(). Referenced by parse_children_definition().
02047 {
02048 // Conditionally consume the open paren.
02049 if (skip_open_paren == 0 && this->get () != '(')
02050 {
02051 this->fatal_error(ACE_TEXT ("Expecting '(' at beginning of children")
02052 ACEXML_ENV_ARG_PARAMETER);
02053 ACEXML_CHECK_RETURN (-1);
02054 }
02055
02056 ACEXML_Char node_type = 0;
02057 ACEXML_Char nextch;
02058
02059 do {
02060 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
02061 ACEXML_CHECK_RETURN (-1);
02062 this->skip_whitespace_count (&nextch);
02063 switch (nextch)
02064 {
02065 case '(':
02066 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
02067 ACEXML_CHECK_RETURN (-1);
02068 this->parse_child (0 ACEXML_ENV_ARG_PARAMETER);
02069 ACEXML_CHECK_RETURN (-1);
02070 break;
02071 default:
02072 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
02073 ACEXML_CHECK_RETURN (-1);
02074 // must be an element name here.
02075 ACEXML_Char *subelement = this->parse_name ();
02076 if (subelement == 0)
02077 {
02078 this->fatal_error(ACE_TEXT ("Invalid subelement name")
02079 ACEXML_ENV_ARG_PARAMETER);
02080 ACEXML_CHECK_RETURN (-1);
02081 }
02082 // Check for trailing '?', '*', '+'
02083 nextch = this->peek ();
02084 switch (nextch)
02085 {
02086 case '?':
02087 // @@ Consume the character and inform validator as such,
02088 this->get ();
02089 break;
02090 case '*':
02091 // @@ Consume the character and inform validator as such,
02092 this->get ();
02093 break;
02094 case '+':
02095 // @@ Consume the character and inform validator as such,
02096 this->get ();
02097 break;
02098 default:
02099 break; // not much to do.
02100 }
02101
02102 // @@ Inform validator of the new element here.
02103 break;
02104 }
02105 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
02106 ACEXML_CHECK_RETURN (-1);
02107 this->skip_whitespace_count (&nextch);
02108 switch (nextch)
02109 {
02110 case '|':
02111 switch (node_type)
02112 {
02113 case 0:
02114 node_type = '|';
02115 // @@ inform validator of this new type??
02116 break;
02117 case '|':
02118 break;
02119 default:
02120 this->fatal_error (ACE_TEXT ("Expecting `,', `|', or `)' ")
02121 ACE_TEXT ("while defining an element")
02122 ACEXML_ENV_ARG_PARAMETER);
02123 ACEXML_CHECK_RETURN (-1);
02124 }
02125 break;
02126 case ',':
02127 switch (node_type)
02128 {
02129 case 0:
02130 node_type = ',';
02131 // @@ inform validator of this new type??
02132 break;
02133 case ',':
02134 break;
02135 default:
02136 this->fatal_error (ACE_TEXT ("Expecting `,', `|', or `)' ")
02137 ACE_TEXT ("while defining an element")
02138 ACEXML_ENV_ARG_PARAMETER);
02139 ACEXML_CHECK_RETURN (-1);
02140 }
02141 break;
02142 case ')':
02143 break;
02144 default:
02145 this->fatal_error (ACE_TEXT ("Expecting `,', `|', or `)' ")
02146 ACE_TEXT ("while defining an element")
02147 ACEXML_ENV_ARG_PARAMETER);
02148 ACEXML_CHECK_RETURN (-1);
02149 }
02150 nextch = this->get(); // Consume the `,' or `|' or `)'
02151 if (nextch == ')')
02152 break;
02153 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
02154 ACEXML_CHECK_RETURN (-1);
02155 this->skip_whitespace_count (&nextch);
02156 } while (nextch != ')');
02157
02158 // Check for trailing '?', '*', '+'
02159 nextch = this->peek ();
02160 switch (nextch)
02161 {
02162 case '?':
02163 // @@ Consume the character and inform validator as such,
02164 this->get ();
02165 break;
02166 case '*':
02167 // @@ Consume the character and inform validator as such,
02168 this->get ();
02169 break;
02170 case '+':
02171 // @@ Consume the character and inform validator as such,
02172 this->get ();
02173 break;
02174 default:
02175 break; // not much to do.
02176 }
02177
02178
02179 return 0;
02180 }
|
|
|
Parse the "children" and "Mixed" non-terminals in contentspec. The first character this function sees must be the first open paren '(' in children.
Definition at line 1974 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, check_for_PE_reference(), fatal_error(), get(), parse_child(), parse_name(), parse_token(), peek(), and skip_whitespace(). Referenced by parse_element_decl().
01975 {
01976 this->get (); // consume the '('
01977 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01978 ACEXML_CHECK_RETURN (-1);
01979 int subelement_number = 0;
01980 ACEXML_Char nextch = this->peek();
01981 switch (nextch)
01982 {
01983 case '#': // Mixed element,
01984 if (this->parse_token (ACE_TEXT ("#PCDATA")) < 0)
01985 {
01986 this->fatal_error(ACE_TEXT ("Expecting keyword '#PCDATA'")
01987 ACEXML_ENV_ARG_PARAMETER);
01988 ACEXML_CHECK_RETURN (-1);
01989 }
01990 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01991 ACEXML_CHECK_RETURN (-1);
01992 nextch = this->get();
01993 while (nextch == '|')
01994 {
01995 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01996 ACEXML_CHECK_RETURN (-1);
01997 ACEXML_Char *name = this->parse_name ();
01998 // @@ name will be used in the Validator later.
01999 ACE_UNUSED_ARG (name);
02000 ++subelement_number;
02001 // @@ Install Mixed element name into the validator.
02002 this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
02003 ACEXML_CHECK_RETURN (-1);
02004 nextch = this->skip_whitespace();
02005 }
02006 if (nextch != ')' ||
02007 (subelement_number && this->get () != '*'))
02008 {
02009 this->fatal_error(ACE_TEXT ("Expecing ')' or ')*' at end of Mixed")
02010 ACE_TEXT (" element") ACEXML_ENV_ARG_PARAMETER);
02011 ACEXML_CHECK_RETURN (-1);
02012 }
02013 // @@ close the element definition in the validator.
02014 break;
02015 default:
02016 int status = this->parse_child (1 ACEXML_ENV_ARG_PARAMETER);
02017 ACEXML_CHECK_RETURN (-1);
02018 if (status != 0)
02019 return -1;
02020 }
02021
02022 // Check for trailing '?', '*', '+'
02023 nextch = this->peek ();
02024 switch (nextch)
02025 {
02026 case '?':
02027 // @@ Consume the character and inform validator as such,
02028 this->get ();
02029 break;
02030 case '*':
02031 // @@ Consume the character and inform validator as such,
02032 this->get ();
02033 break;
02034 case '+':
02035 // @@ Consume the character and inform validator as such,
02036 this->get ();
02037 break;
02038 default:
02039 break; // not much to do.
02040 }
02041
02042 return 0;
02043 }
|
|
|
Skip over a comment. The first character encountered should always be the first '-' in the comment prefix "@<@!--". Definition at line 3238 of file Parser.cpp. References ACEXML_Char, and get(). Referenced by parse(), parse_content(), and parse_markup_decl().
03239 {
03240 int state = 0;
03241
03242 if (this->get () != '-' || // Skip the opening "<!--"
03243 this->get () != '-' || // completely.
03244 this->get () == '-') // and at least something not '-'.
03245 return -1;
03246
03247 while (state < 3)
03248 // Waiting for the trailing three character '-->'. Notice that
03249 // according to the spec, '--->' is not a valid closing comment
03250 // sequence. But we'll let it pass anyway.
03251 {
03252 ACEXML_Char fwd = this->get ();
03253 if ((fwd == '-' && state < 2) ||
03254 (fwd == '>' && state == 2))
03255 state += 1;
03256 else
03257 state = 0; // Reset parse state.
03258 }
03259 return 0;
03260 }
|
|
|
Parse a conditionalSect declaration. Definition at line 469 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, fatal_error(), get(), parse_ignoresect(), parse_includesect(), parse_PE_reference(), parse_token(), pop_context(), skip_whitespace(), and skip_whitespace_count(). Referenced by parse_external_subset(), and parse_includesect().
00470 {
00471 ACEXML_Char ch = this->get ();
00472 int include = 0;
00473 if (ch != '[')
00474 {
00475 this->fatal_error(ACE_TEXT ("Internal Parser Error")
00476 ACEXML_ENV_ARG_PARAMETER);
00477 ACEXML_CHECK_RETURN (-1);
00478 }
00479 ch = this->skip_whitespace();
00480 if (ch == '%')
00481 {
00482 this->parse_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00483 ACEXML_CHECK_RETURN (-1);
00484 ch = this->skip_whitespace();
00485 }
00486 if (ch == 'I')
00487 {
00488 ch = this->get();
00489 switch (ch)
00490 {
00491 case 'N':
00492 if (this->parse_token (ACE_TEXT ("CLUDE")) < 0)
00493 {
00494 this->fatal_error (ACE_TEXT ("Expecting keyword INCLUDE in ")
00495 ACE_TEXT ("conditionalSect")
00496 ACEXML_ENV_ARG_PARAMETER);
00497 ACEXML_CHECK_RETURN (-1);
00498 }
00499 include = 1;
00500 break;
00501 case 'G':
00502 if (this->parse_token (ACE_TEXT ("GNORE")) < 0)
00503 {
00504 this->fatal_error (ACE_TEXT ("Expecting keyword IGNORE in ")
00505 ACE_TEXT ("conditionalSect")
00506 ACEXML_ENV_ARG_PARAMETER);
00507 ACEXML_CHECK_RETURN (-1);
00508 }
00509 include = 0;
00510 break;
00511 default:
00512 this->fatal_error (ACE_TEXT ("Invalid conditionalSect")
00513 ACEXML_ENV_ARG_PARAMETER);
00514 ACEXML_CHECK_RETURN (-1);
00515 }
00516 ACEXML_Char fwd = '\xFF';
00517 this->skip_whitespace_count (&fwd);
00518 if (fwd == 0)
00519 {
00520 this->get(); // Consume the 0
00521 this->pop_context (0 ACEXML_ENV_ARG_PARAMETER);
00522 ACEXML_CHECK_RETURN (-1);
00523 }
00524 }
00525 else
00526 {
00527 this->fatal_error (ACE_TEXT ("Invalid conditionalSect")
00528 ACEXML_ENV_ARG_PARAMETER);
00529 ACEXML_CHECK_RETURN (-1);
00530 }
00531 if (this->skip_whitespace() != '[')
00532 {
00533 this->fatal_error (ACE_TEXT ("Expecting '[' in conditionalSect")
00534 ACEXML_ENV_ARG_PARAMETER);
00535 ACEXML_CHECK_RETURN (-1);
00536 }
00537 if (include)
00538 this->parse_includesect (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00539 else
00540 this->parse_ignoresect (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00541 ACEXML_CHECK_RETURN (-1);
00542 return 0;
00543 }
|
|
||||||||||||||||||||
|
Parse a content declaration. Definition at line 979 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, ACEXML_ContentHandler::characters(), content_handler_, ACEXML_ContentHandler::endElement(), fatal_error(), ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), namespaces_, nested_namespace_, obstack_, parse_cdata(), parse_char_reference(), parse_comment(), parse_element(), parse_entity_reference(), parse_name(), parse_processing_instruction(), peek(), pop_context(), ACEXML_NamespaceSupport::popContext(), prefix_mapping(), ref_state_, skip_whitespace(), ACE_OS::strcmp(), ACE_Obstack_T< ACEXML_Char >::unwind(), and xml_namespace_. Referenced by parse_element().
00982 {
00983 ACEXML_Char *cdata;
00984 size_t cdata_length = 0;
00985
00986 // Parse element contents.
00987 while (1)
00988 {
00989 ACEXML_Char ch = this->get ();
00990 switch (ch)
00991 {
00992 case 0:
00993 this->pop_context (1 ACEXML_ENV_ARG_PARAMETER);
00994 ACEXML_CHECK_RETURN (-1);
00995 break;
00996 case '<':
00997 // Push out old 'characters' event.
00998 if (cdata_length != 0)
00999 {
01000 cdata = this->obstack_.freeze ();
01001 this->content_handler_->characters (cdata, 0, cdata_length
01002 ACEXML_ENV_ARG_PARAMETER);
01003 ACEXML_CHECK_RETURN (-1);
01004 this->obstack_.unwind (cdata);
01005 cdata_length = 0;
01006 }
01007 ch = this->peek();
01008 switch (ch)
01009 {
01010 case '!': // a comment or a CDATA section.
01011 this->get (); // consume '!'
01012 ch = this->peek ();
01013 if (ch == '-') // a comment
01014 {
01015 if (this->parse_comment () < 0)
01016 {
01017 this->fatal_error(ACE_TEXT ("Invalid comment in ")
01018 ACE_TEXT ("document")
01019 ACEXML_ENV_ARG_PARAMETER);
01020 ACEXML_CHECK_RETURN (-1);
01021 }
01022 }
01023 else if (ch == '[') // a CDATA section.
01024 {
01025 this->parse_cdata (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01026 ACEXML_CHECK_RETURN (-1);
01027 }
01028 else
01029 {
01030 this->fatal_error(ACE_TEXT ("Expecting a CDATA section ")
01031 ACE_TEXT ("or a comment section")
01032 ACEXML_ENV_ARG_PARAMETER);
01033 ACEXML_CHECK_RETURN (-1);
01034 }
01035 break;
01036 case '?': // a PI.
01037 this->get(); // consume the '?'
01038 this->parse_processing_instruction
01039 (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01040 ACEXML_CHECK_RETURN (-1);
01041 break;
01042 case '/': // an ETag.
01043 {
01044 this->get (); // consume '/'
01045 ACEXML_Char* endname = this->parse_name ();
01046 if (endname == 0 ||
01047 ACE_OS::strcmp (startname, endname) != 0)
01048 {
01049 this->fatal_error(ACE_TEXT ("Name in ETag doesn't ")
01050 ACE_TEXT ("match name in STag")
01051 ACEXML_ENV_ARG_PARAMETER);
01052 ACEXML_CHECK_RETURN (-1);
01053 }
01054 if (this->skip_whitespace () != '>')
01055 {
01056 this->fatal_error(ACE_TEXT ("Expecting '>' at end ")
01057 ACE_TEXT ("of element")
01058 ACEXML_ENV_ARG_PARAMETER);
01059 return -1;
01060 }
01061 this->content_handler_->endElement (ns_uri, ns_lname,
01062 endname
01063 ACEXML_ENV_ARG_PARAMETER);
01064 ACEXML_CHECK_RETURN (-1);
01065 this->prefix_mapping (this->xml_namespace_.getPrefix(ns_uri),
01066 ns_uri, 0
01067 ACEXML_ENV_ARG_PARAMETER);
01068 ACEXML_CHECK_RETURN (-1);
01069 if (this->namespaces_ && ns_flag)
01070 {
01071 if (this->nested_namespace_ >= 1)
01072 {
01073 this->xml_namespace_.popContext ();
01074 this->nested_namespace_--;
01075 }
01076 }
01077 return 0;
01078 }
01079 default: // a new nested element?
01080 this->parse_element (0 ACEXML_ENV_ARG_PARAMETER);
01081 ACEXML_CHECK_RETURN (-1);
01082 break;
01083 }
01084 break;
01085 case '&':
01086 if (this->peek () == '#')
01087 {
01088 ACEXML_Char buf[7];
01089 size_t len = 0;
01090 do
01091 {
01092 len = sizeof (buf);
01093 if (this->parse_char_reference (buf, len) != 0)
01094 {
01095 // [WFC: Legal Character]
01096 this->fatal_error (ACE_TEXT ("Invalid CharRef")
01097 ACEXML_ENV_ARG_PARAMETER);
01098 ACEXML_CHECK_RETURN (-1);
01099 }
01100 } while (buf[0] == '&' && this->peek() == '#');
01101 for (size_t j = 0; j < len; ++j)
01102 this->obstack_.grow (buf[j]);
01103 cdata_length += len;
01104 }
01105 else
01106 {
01107 this->ref_state_ = ACEXML_ParserInt::IN_CONTENT;
01108 int length = this->parse_entity_reference(ACEXML_ENV_SINGLE_ARG_PARAMETER);
01109 ACEXML_CHECK_RETURN (-1);
01110 if (length == 1)
01111 cdata_length++;
01112 }
01113 break;
01114 case '\x20': case '\x0D': case '\x0A': case '\x09':
01115 // if (this->validate_)
01116 // {
01117 // // Flush out any non-whitespace characters
01118 // if (cdata_length != 0)
01119 // {
01120 // cdata = this->obstack_.freeze ();
01121 // this->content_handler_->characters(cdata, 0, cdata_length
01122 // ACEXML_ENV_ARG_PARAMETER);
01123 // ACEXML_CHECK_RETURN (-1);
01124 // this->obstack_.unwind (cdata);
01125 // cdata_length = 0;
01126 // }
01127 // ++cdata_length;
01128 // this->obstack_.grow (ch);
01129 // while (1)
01130 // {
01131 // ch = this->peek();
01132 // if (ch == '\x20' || ch == '\x0D' || ch == '\x0A' ||
01133 // ch == '\x09')
01134 // {
01135 // ch = this->get();
01136 // this->obstack_.grow (ch);
01137 // continue;
01138 // }
01139 // break;
01140 // }
01141 // cdata = this->obstack_.freeze ();
01142 // this->content_handler_->ignorableWhitespace (cdata, 0,
01143 // cdata_length
01144 // ACEXML_ENV_ARG_PARAMETER);
01145 // ACEXML_CHECK_RETURN (-1);
01146 // this->obstack_.unwind (cdata);
01147 // cdata_length = 0;
01148 // break;
01149 // }
01150 // Fall thru...
01151 default:
01152 ++cdata_length;
01153 this->obstack_.grow (ch);
01154 }
01155 }
01156 ACE_NOTREACHED (return 0;)
01157 }
|
|
|
Parse a DefaultDecl specification. Definition at line 1497 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, fatal_error(), get(), parse_attvalue(), parse_token(), peek(), and skip_whitespace_count(). Referenced by parse_attlist_decl().
01498 {
01499 // DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
01500 ACEXML_Char nextch = this->peek ();
01501 ACEXML_Char *fixed_attr = 0;
01502 switch (nextch)
01503 {
01504 case '#':
01505 this->get (); // consume the '#'
01506 switch (this->get ())
01507 {
01508 case 'R':
01509 if (this->parse_token (ACE_TEXT ("EQUIRED")) < 0)
01510 {
01511 this->fatal_error(ACE_TEXT ("Expecting keyword REQUIRED")
01512 ACEXML_ENV_ARG_PARAMETER);
01513 ACEXML_CHECK_RETURN (-1);
01514 }
01515 // We now know this attribute is required
01516 // @@ Set up the validator as such.
01517 break;
01518 case 'I':
01519 if (this->parse_token (ACE_TEXT ("MPLIED")) < 0)
01520 {
01521 this->fatal_error(ACE_TEXT ("Expecting keyword IMPLIED")
01522 ACEXML_ENV_ARG_PARAMETER);
01523 ACEXML_CHECK_RETURN (-1);
01524 }
01525 // We now know this attribute is implied.
01526 // @@ Set up the validator as such.
01527 break;
01528 case 'F':
01529 if (this->parse_token (ACE_TEXT ("IXED")) < 0 ||
01530 this->skip_whitespace_count () == 0)
01531 {
01532 this->fatal_error(ACE_TEXT ("Expecting keyword FIXED")
01533 ACEXML_ENV_ARG_PARAMETER);
01534 ACEXML_CHECK_RETURN (-1);
01535 }
01536 // We now know this attribute is fixed.
01537 if (this->parse_attvalue (fixed_attr
01538 ACEXML_ENV_ARG_PARAMETER) != 0)
01539 {
01540 this->fatal_error(ACE_TEXT ("Invalid Default AttValue")
01541 ACEXML_ENV_ARG_PARAMETER);
01542 ACEXML_CHECK_RETURN (-1);
01543 }
01544 // @@ set up validator
01545 break;
01546 default:
01547 this->fatal_error (ACE_TEXT ("Invalid DefaultDecl")
01548 ACEXML_ENV_ARG_PARAMETER);
01549 ACEXML_CHECK_RETURN (-1);
01550 }
01551 break;
01552 case '\'':
01553 case '"':
01554 if (this->parse_attvalue (fixed_attr ACEXML_ENV_ARG_PARAMETER) != 0)
01555 {
01556 this->fatal_error(ACE_TEXT ("Invalid AttValue")
01557 ACEXML_ENV_ARG_PARAMETER);
01558 ACEXML_CHECK_RETURN (-1);
01559 }
01560 // @@ set up validator
01561 break;
01562 default:
01563 this->fatal_error (ACE_TEXT ("Invalid DefaultDecl")
01564 ACEXML_ENV_ARG_PARAMETER);
01565 ACEXML_CHECK_RETURN (-1);
01566 break;
01567 }
01568 return 0;
01569 }
|
|
|
Parse the DOCTYPE declaration. The first character encountered should always be 'D' in doctype prefix: "@<@!DOCTYPE". Definition at line 235 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, doctype_, external_dtd_, fatal_error(), internal_dtd_, parse_external_dtd(), parse_internal_dtd(), parse_name(), parse_token(), skip_whitespace(), skip_whitespace_count(), and validate_. Referenced by parse().
00236 {
00237 if (this->parse_token (ACE_TEXT ("DOCTYPE")) < 0)
00238 {
00239 this->fatal_error(ACE_TEXT ("Expecting keyword DOCTYPE in a doctypedecl")
00240 ACEXML_ENV_ARG_PARAMETER);
00241 ACEXML_CHECK_RETURN (-1);
00242 }
00243
00244 ACEXML_Char nextch = 0;
00245 if (this->skip_whitespace_count (&nextch) == 0)
00246 {
00247 this->fatal_error(ACE_TEXT ("Expecting a space between DOCTYPE keyword ")
00248 ACE_TEXT ("and name") ACEXML_ENV_ARG_PARAMETER);
00249 ACEXML_CHECK_RETURN (-1);
00250 }
00251
00252 this->doctype_ = this->parse_name ();
00253 if (this->doctype_ == 0)
00254 {
00255 this->fatal_error(ACE_TEXT ("Invalid DOCTYPE name")
00256 ACEXML_ENV_ARG_PARAMETER);
00257 ACEXML_CHECK_RETURN (-1);
00258 }
00259 int count = this->skip_whitespace_count (&nextch);
00260
00261 if (nextch == 'S' || nextch == 'P') // ExternalID defined
00262 {
00263 if (count == 0)
00264 {
00265 this->fatal_error(ACE_TEXT ("Expecting a space between DOCTYPE")
00266 ACE_TEXT ("keyword and name")
00267 ACEXML_ENV_ARG_PARAMETER);
00268 ACEXML_CHECK_RETURN (-1);
00269 }
00270 this->external_dtd_ = 1;
00271 this->parse_external_dtd (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00272 ACEXML_CHECK_RETURN (-1);
00273 }
00274
00275 nextch = this->skip_whitespace ();
00276 switch (nextch)
00277 {
00278 case '[':
00279 this->internal_dtd_ = 1; // Internal DTD definition
00280 this->parse_internal_dtd (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00281 ACEXML_CHECK_RETURN (-1);
00282 break;
00283 case '>': // End of DTD definition
00284 // This is an XML document without a doctypedecl.
00285 if (this->validate_ && !this->external_dtd_)
00286 {
00287 this->fatal_error (ACE_TEXT ("No DTD defined")
00288 ACEXML_ENV_ARG_PARAMETER);
00289 ACEXML_CHECK_RETURN (-1);
00290 }
00291 return 0;
00292 case '0':
00293 this->fatal_error (ACE_TEXT ("Unexpected end-of-file")
00294 ACEXML_ENV_ARG_PARAMETER);
00295 ACEXML_CHECK_RETURN (-1);
00296 default:
00297 break;
00298 }
00299
00300 if (this->skip_whitespace() != '>')
00301 {
00302 this->fatal_error(ACE_TEXT ("Expecting '>' at end of doctypedecl")
00303 ACEXML_ENV_ARG_PARAMETER);
00304 ACEXML_CHECK_RETURN (-1);
00305 }
00306 return 0;
00307 }
|
|
|
Parse an XML element. The first character encountered should be the first character of the element "Name".
Definition at line 814 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK, ACEXML_ENV_ARG_PARAMETER, ACEXML_AttributesImpl::addAttribute(), content_handler_, ACEXML_NamespaceSupport::declarePrefix(), default_attribute_type, doctype_, empty_string, ACEXML_ContentHandler::endElement(), fatal_error(), get(), namespace_prefixes_, namespaces_, nested_namespace_, parse_attvalue(), parse_content(), parse_name(), ACEXML_NamespaceSupport::popContext(), prefix_mapping(), ACEXML_NamespaceSupport::processName(), ACEXML_NamespaceSupport::pushContext(), skip_equal(), skip_whitespace(), ACEXML_ContentHandler::startElement(), ACE_OS::strchr(), ACE_OS::strcmp(), ACE_OS::strncmp(), and xml_namespace_. Referenced by parse(), and parse_content().
00815 {
00816 // Parse STag.
00817 const ACEXML_Char *startname = this->parse_name ();
00818 if (startname == 0)
00819 {
00820 this->fatal_error (ACE_TEXT ("Unexpected end-of-file")
00821 ACEXML_ENV_ARG_PARAMETER);
00822 return;
00823 }
00824 if (is_root && this->doctype_ != 0
00825 && ACE_OS::strcmp (startname, this->doctype_) != 0)
00826 {
00827 this->fatal_error (ACE_TEXT ("Root element different from DOCTYPE")
00828 ACEXML_ENV_ARG_PARAMETER);
00829 return ;
00830 }
00831 ACEXML_AttributesImpl attributes;
00832 ACEXML_Char ch;
00833 int ns_flag = 0; // Push only one namespace context onto the stack
00834 // if there are multiple namespaces declared.
00835
00836 const ACEXML_Char* ns_uri = 0;
00837 const ACEXML_Char* ns_lname = 0; // namespace URI and localName
00838 for (int start_element_done = 0; start_element_done == 0;)
00839 {
00840 ch = this->skip_whitespace ();
00841
00842 switch (ch)
00843 {
00844 case 0:
00845 this->fatal_error(ACE_TEXT ("Internal Parser error")
00846 ACEXML_ENV_ARG_PARAMETER);
00847 return;
00848 case '/':
00849 if (this->get () != '>')
00850 {
00851 this->fatal_error(ACE_TEXT ("Expecting '>' at end of element ")
00852 ACE_TEXT ("definition")
00853 ACEXML_ENV_ARG_PARAMETER);
00854 return;
00855 }
00856 this->xml_namespace_.processName(startname, ns_uri,
00857 ns_lname, 0);
00858 this->prefix_mapping (this->xml_namespace_.getPrefix(ns_uri),
00859 ns_uri, 1
00860 ACEXML_ENV_ARG_PARAMETER);
00861 ACEXML_CHECK;
00862 this->content_handler_->startElement(ns_uri, ns_lname,
00863 startname, &attributes
00864 ACEXML_ENV_ARG_PARAMETER);
00865 ACEXML_CHECK;
00866 this->content_handler_->endElement (ns_uri, ns_lname, startname
00867 ACEXML_ENV_ARG_PARAMETER);
00868 ACEXML_CHECK;
00869 this->prefix_mapping (this->xml_namespace_.getPrefix(ns_uri),
00870 ns_uri, 0
00871 ACEXML_ENV_ARG_PARAMETER);
00872 ACEXML_CHECK;
00873 if (ns_flag)
00874 {
00875 this->xml_namespace_.popContext ();
00876 this->nested_namespace_--;
00877 }
00878 return;
00879 case '>':
00880 this->xml_namespace_.processName (startname, ns_uri,
00881 ns_lname, 0);
00882 this->prefix_mapping (this->xml_namespace_.getPrefix(ns_uri),
00883 ns_uri, 1
00884 ACEXML_ENV_ARG_PARAMETER);
00885 ACEXML_CHECK;
00886 this->content_handler_->startElement(ns_uri, ns_lname, startname,
00887 &attributes
00888 ACEXML_ENV_ARG_PARAMETER);
00889 ACEXML_CHECK;
00890 start_element_done = 1;
00891 break;
00892 default:
00893 ACEXML_Char *attvalue = 0;
00894 ACEXML_Char *attname = this->parse_name (ch);
00895
00896 if (attname == 0 ||
00897 this->skip_equal () != 0 ||
00898 this->parse_attvalue (attvalue ACEXML_ENV_ARG_PARAMETER) != 0)
00899 {
00900 this->fatal_error(ACE_TEXT ("Error reading attribute value")
00901 ACEXML_ENV_ARG_PARAMETER);
00902 return;
00903 }
00904
00905 // Handling new namespace if any. Notice that the order of
00906 // namespace declaration does matter.
00907 if (ACE_OS::strncmp (attname, ACE_TEXT("xmlns"), 5) == 0)
00908 {
00909 if (this->namespaces_)
00910 {
00911 if (!ns_flag)
00912 {
00913 this->xml_namespace_.pushContext ();
00914 this->nested_namespace_++;
00915 ns_flag = 1;
00916 }
00917
00918 ACEXML_Char* name = ACE_OS::strchr (attname, ':');
00919 const ACEXML_Char* ns_name = (name == 0)?
00920 empty_string:name+1;
00921 if (this->xml_namespace_.declarePrefix (ns_name,
00922 attvalue) == -1)
00923 {
00924 this->fatal_error(ACE_TEXT ("Duplicate definition of ")
00925 ACE_TEXT ("prefix")
00926 ACEXML_ENV_ARG_PARAMETER);
00927 return;
00928 }
00929 }
00930 if (this->namespace_prefixes_)
00931 {
00932 // Namespace_prefixes_feature_ is required. So add the
00933 // xmlns:foo to the list of attributes.
00934 if (attributes.addAttribute (ACE_TEXT (""), ACE_TEXT (""),
00935 attname,
00936 default_attribute_type,
00937 attvalue) == -1)
00938 {
00939 this->fatal_error(ACE_TEXT ("Duplicate attribute ")
00940 ACE_TEXT ("definition. Hint: Try ")
00941 ACE_TEXT ("setting namespace_prefix")
00942 ACE_TEXT ("es feature to 0")
00943 ACEXML_ENV_ARG_PARAMETER);
00944 return;
00945 }
00946 }
00947 if (!this->namespaces_ && !this->namespace_prefixes_)
00948 {
00949 this->fatal_error(ACE_TEXT ("One of namespaces or ")
00950 ACE_TEXT ("namespace_prefixes should be")
00951 ACE_TEXT (" declared")
00952 ACEXML_ENV_ARG_PARAMETER);
00953 return;
00954 }
00955 }
00956 else
00957 {
00958 const ACEXML_Char *uri, *lName;
00959 this->xml_namespace_.processName (attname, uri, lName, 1);
00960 if (attributes.addAttribute (uri, lName, attname,
00961 default_attribute_type,
00962 attvalue) == -1)
00963 {
00964 this->fatal_error(ACE_TEXT ("Duplicate attribute ")
00965 ACE_TEXT ("definition")
00966 ACEXML_ENV_ARG_PARAMETER);
00967 return;
00968 }
00969 }
00970 break;
00971 }
00972 }
00973 if (this->parse_content (startname, ns_uri, ns_lname, ns_flag
00974 ACEXML_ENV_ARG_PARAMETER) != 0)
00975 return;
00976 }
|
|
|
Parse an "ELEMENT" decl. The first character this method expects is always the 'L' (the second char) in the word "ELEMENT".
Definition at line 1900 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, check_for_PE_reference(), fatal_error(), parse_children_definition(), parse_name(), parse_token(), peek(), and skip_whitespace(). Referenced by parse_markup_decl().
01901 {
01902 if (this->parse_token (ACE_TEXT ("LEMENT")) < 0)
01903 {
01904 this->fatal_error (ACE_TEXT ("Expecting keyword ELEMENT")
01905 ACEXML_ENV_ARG_PARAMETER);
01906 ACEXML_CHECK_RETURN (-1);
01907 }
01908 int count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01909 ACEXML_CHECK_RETURN (-1);
01910 if (!count)
01911 {
01912 this->fatal_error (ACE_TEXT ("Expecting a space between keyword ELEMENT")
01913 ACE_TEXT (" and element name")
01914 ACEXML_ENV_ARG_PARAMETER);
01915 ACEXML_CHECK_RETURN (-1);
01916 }
01917 ACEXML_Char *element_name = this->parse_name ();
01918 if (element_name == 0)
01919 {
01920 this->fatal_error (ACE_TEXT ("Invalid element name")
01921 ACEXML_ENV_ARG_PARAMETER);
01922 ACEXML_CHECK_RETURN (-1);
01923 }
01924 count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01925 ACEXML_CHECK_RETURN (-1);
01926 if (!count)
01927 {
01928 this->fatal_error (ACE_TEXT ("Expecting a space between element name ")
01929 ACE_TEXT ("and element definition")
01930 ACEXML_ENV_ARG_PARAMETER);
01931 ACEXML_CHECK_RETURN (-1);
01932 }
01933 ACEXML_Char nextch = this->peek();
01934 switch (nextch)
01935 {
01936 case 'E': // EMPTY
01937 if (this->parse_token (ACE_TEXT ("EMPTY")) < 0)
01938 {
01939 this->fatal_error (ACE_TEXT ("Expecting keyword EMPTY")
01940 ACEXML_ENV_ARG_PARAMETER);
01941 ACEXML_CHECK_RETURN (-1);
01942 }
01943 break;
01944 case 'A': // ANY
01945 if (this->parse_token (ACE_TEXT ("ANY")) < 0)
01946 {
01947 this->fatal_error (ACE_TEXT ("Expecting keyword ANY")
01948 ACEXML_ENV_ARG_PARAMETER);
01949 ACEXML_CHECK_RETURN (-1);
01950 }
01951 break;
01952 case '(': // children
01953 this->parse_children_definition (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01954 ACEXML_CHECK_RETURN (-1);
01955 break;
01956 default: // error
01957 this->fatal_error (ACE_TEXT ("Invalid element definition")
01958 ACEXML_ENV_ARG_PARAMETER);
01959 ACEXML_CHECK_RETURN (-1);
01960 }
01961 count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01962 ACEXML_CHECK_RETURN (-1);
01963 if (this->skip_whitespace () != '>')
01964 {
01965 this->fatal_error (ACE_TEXT ("Expecting '>' after element defintion")
01966 ACEXML_ENV_ARG_PARAMETER);
01967 ACEXML_CHECK_RETURN (-1);
01968 }
01969 return 0;
01970 }
|
|
|
Parse the encoding name in an XML Prolog section.
Definition at line 2811 of file Parser.cpp. References ACEXML_Char, ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), and obstack_. Referenced by parse_encoding_decl().
02812 {
02813 const ACEXML_Char quote = this->get ();
02814 if (quote != '\'' && quote != '"') // Not a quoted string.
02815 return -1;
02816 int numchars = 0;
02817 while (1)
02818 {
02819 ACEXML_Char ch = this->get ();
02820 if (ch == quote && !numchars)
02821 return -1;
02822 else if (ch == quote)
02823 {
02824 str = this->obstack_.freeze ();
02825 return 0;
02826 }
02827 // [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
02828 if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
02829 && !numchars)
02830 return -1;
02831 if (ch == '-' || ((ch >= 'a' && ch <= 'z') ||
02832 (ch >= 'A' && ch <= 'Z') ||
02833 (ch >= '0' && ch <= '9') ||
02834 (ch == '_' || ch == '.')))
02835 {
02836 this->obstack_.grow (ch);
02837 numchars++;
02838 }
02839 else
02840 return -1;
02841 }
02842 }
|
|
|
Parse a EncodingDecl declaration. Definition at line 3120 of file Parser.cpp. References ACE_ERROR, ACE_TEXT, ACEXML_Char, ACEXML_CHECK, ACEXML_ENV_ARG_PARAMETER, fatal_error(), ACEXML_InputSource::getEncoding(), ACEXML_Parser_Context::getInputSource(), LM_ERROR, parse_encname(), parse_token(), skip_equal(), ACE_OS::strcmp(), and warning(). Referenced by parse_text_decl(), and parse_xml_decl().
03121 {
03122 ACEXML_Char* astring = 0;
03123 if ((this->parse_token (ACE_TEXT("ncoding")) < 0)
03124 || this->skip_equal () != 0
03125 || this->parse_encname (astring) != 0)
03126 {
03127 this->fatal_error (ACE_TEXT ("Invalid EncodingDecl specification")
03128 ACEXML_ENV_ARG_PARAMETER);
03129 ACEXML_CHECK;
03130 }
03131 const ACEXML_Char* encoding = this->current_->getInputSource()->getEncoding();
03132 if (encoding != 0 && ACE_OS::strcmp (astring, encoding) != 0)
03133 {
03134 ACE_ERROR ((LM_ERROR, ACE_TEXT ("Detected Encoding is %s ")
03135 ACE_TEXT (": Declared Encoding is %s\n"),
03136 encoding, astring));
03137 this->warning (ACE_TEXT ("Declared encoding differs from detected ")
03138 ACE_TEXT ("encoding") ACEXML_ENV_ARG_PARAMETER);
03139 }
03140 }
|
|
|
Parse an "ENTITY" decl. The first character this method expects is always the 'N' (the second char) in the word "ENTITY".
Definition at line 1203 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_Entity_Manager::add_entity(), dtd_handler_, external_GE_, external_PE_, fatal_error(), get(), internal_GE_, internal_PE_, notations_, parse_entity_value(), parse_external_id(), parse_name(), parse_token(), ACEXML_Entity_Manager::resolve_entity(), skip_whitespace(), skip_whitespace_count(), ACEXML_DTDHandler::unparsedEntityDecl(), validate_, and warning(). Referenced by parse_markup_decl().
01204 {
01205 ACEXML_Char nextch = 0;
01206
01207 if ((this->parse_token (ACE_TEXT ("NTITY")) < 0) ||
01208 this->skip_whitespace_count (&nextch) == 0)
01209 {
01210 this->fatal_error (ACE_TEXT ("Expecting keyword ENTITY followed by a ")
01211 ACE_TEXT ("space") ACEXML_ENV_ARG_PARAMETER);
01212 ACEXML_CHECK_RETURN (-1);
01213 }
01214
01215 int is_GEDecl = 1;
01216 if (nextch == '%') // This is a PEDecl.
01217 {
01218 is_GEDecl = 0;
01219 this->get (); // consume the '%'
01220 if (this->skip_whitespace_count (&nextch) == 0)
01221 {
01222 this->fatal_error (ACE_TEXT ("Expecting space between % and ")
01223 ACE_TEXT ("entity name")
01224 ACEXML_ENV_ARG_PARAMETER);
01225 ACEXML_CHECK_RETURN (-1);
01226 }
01227 }
01228
01229 ACEXML_Char *entity_name = this->parse_name ();
01230 if (entity_name == 0)
01231 {
01232 this->fatal_error (ACE_TEXT ("Invalid entity name")
01233 ACEXML_ENV_ARG_PARAMETER);
01234 ACEXML_CHECK_RETURN (-1);
01235 }
01236
01237 if (this->skip_whitespace_count (&nextch) == 0)
01238 {
01239 this->fatal_error (ACE_TEXT ("Expecting space between entity name and ")
01240 ACE_TEXT ("entityDef")
01241 ACEXML_ENV_ARG_PARAMETER);
01242 ACEXML_CHECK_RETURN (-1);
01243 }
01244 int retval = 0;
01245 if (nextch == '\'' || nextch == '"')
01246 {
01247 ACEXML_Char *entity_value = 0;
01248 if (this->parse_entity_value (entity_value
01249 ACEXML_ENV_ARG_PARAMETER) != 0)
01250 {
01251 this->fatal_error(ACE_TEXT ("Invalid EntityValue")
01252 ACEXML_ENV_ARG_PARAMETER);
01253 ACEXML_CHECK_RETURN (-1);
01254 }
01255 if (is_GEDecl)
01256 retval = this->internal_GE_.add_entity (entity_name,
01257 entity_value);
01258 else
01259 retval = this->internal_PE_.add_entity (entity_name,
01260 entity_value);
01261 if (retval < 0)
01262 {
01263 this->fatal_error (ACE_TEXT ("Internal Parser Error in adding")
01264 ACE_TEXT ("Entity to map")
01265 ACEXML_ENV_ARG_PARAMETER);
01266 ACEXML_CHECK_RETURN (-1);
01267 }
01268 else if (retval == 1)
01269 {
01270 this->warning (ACE_TEXT ("Duplicate entity found")
01271 ACEXML_ENV_ARG_PARAMETER);
01272 ACEXML_CHECK_RETURN (-1);
01273 }
01274 }
01275 else
01276 {
01277 ACEXML_Char *systemid, *publicid;
01278
01279 this->parse_external_id (publicid, systemid
01280 ACEXML_ENV_ARG_PARAMETER);
01281 ACEXML_CHECK_RETURN (-1);
01282 if (systemid == 0)
01283 {
01284 this->fatal_error(ACE_TEXT ("Invalid SystemLiteral")
01285 ACEXML_ENV_ARG_PARAMETER);
01286 ACEXML_CHECK_RETURN (-1);
01287 }
01288 this->skip_whitespace_count (&nextch);
01289 if (nextch == 'N') // NDATA section followed
01290 {
01291 if (is_GEDecl == 0)
01292 {
01293 this->fatal_error(ACE_TEXT ("Invalid NDataDecl in PEDef")
01294 ACEXML_ENV_ARG_PARAMETER);
01295 ACEXML_CHECK_RETURN (-1);
01296 }
01297
01298 if ((this->parse_token (ACE_TEXT ("NDATA")) < 0) ||
01299 this->skip_whitespace_count (&nextch) == 0)
01300 {
01301 this->fatal_error(ACE_TEXT ("Expecting keyword NDATA followed ")
01302 ACE_TEXT ("by a space") ACEXML_ENV_ARG_PARAMETER);
01303 ACEXML_CHECK_RETURN (-1);
01304 }
01305
01306 ACEXML_Char *ndata = this->parse_name ();
01307 if (this->validate_) // [VC: Notation Declared]
01308 {
01309 if (!this->notations_.resolve_entity (ndata))
01310 {
01311 this->fatal_error (ACE_TEXT ("Undeclared Notation name")
01312 ACEXML_ENV_ARG_PARAMETER);
01313 ACEXML_CHECK_RETURN (-1);
01314 }
01315 this->dtd_handler_->unparsedEntityDecl(entity_name, publicid,
01316 systemid, ndata
01317 ACEXML_ENV_ARG_PARAMETER);
01318 ACEXML_CHECK_RETURN (-1);
01319 }
01320 }
01321 else
01322 {
01323 if (is_GEDecl)
01324 retval = this->external_GE_.add_entity (entity_name,
01325 systemid);
01326 else
01327 retval = this->external_PE_.add_entity (entity_name,
01328 systemid);
01329 if (retval < 0)
01330 {
01331 this->fatal_error(ACE_TEXT ("Internal Parser Error")
01332 ACEXML_ENV_ARG_PARAMETER);
01333 ACEXML_CHECK_RETURN (-1);
01334 }
01335 else if (retval == 1)
01336 this->warning(ACE_TEXT ("Duplicate external entity")
01337 ACEXML_ENV_ARG_PARAMETER);
01338 if (is_GEDecl)
01339 retval = this->external_GE_.add_entity (entity_name,
01340 publicid);
01341 else
01342 retval = this->external_PE_.add_entity (entity_name,
01343 publicid);
01344 if (retval < 0)
01345 {
01346 this->fatal_error(ACE_TEXT ("Internal Parser Error")
01347 ACEXML_ENV_ARG_PARAMETER);
01348 ACEXML_CHECK_RETURN (-1);
01349 }
01350 else if (retval == 1)
01351 this->warning (ACE_TEXT ("Duplicate entity definition")
01352 ACEXML_ENV_ARG_PARAMETER);
01353 }
01354 }
01355
01356 // End of ENTITY definition
01357 if (this->skip_whitespace() != '>')
01358 {
01359 this->fatal_error(ACE_TEXT ("Expecting '>' at end of entityDef")
01360 ACEXML_ENV_ARG_PARAMETER);
01361 ACEXML_CHECK_RETURN (-1);
01362 }
01363 return 0;
01364 }
|
|
|
Parse a Reference. Definition at line 2337 of file Parser.cpp. References ACE_NEW_RETURN, ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, content_handler_, ACEXML_StreamFactory::create_stream(), entity_resolver_, external_dtd_, external_entity_, external_GE_, fatal_error(), GE_reference_, ACE_Obstack_T< ACEXML_Char >::grow(), has_pe_refs_, ACE_Unbounded_Stack< ACEXML_Char * >::insert(), internal_dtd_, internal_GE_, normalize_systemid(), obstack_, ACEXML_StrCharStream::open(), parse_reference_name(), ACE_Unbounded_Stack< ACEXML_Char * >::pop(), predef_entities_, ref_state_, ACEXML_Entity_Manager::resolve_entity(), ACEXML_EntityResolver::resolveEntity(), ACEXML_ContentHandler::skippedEntity(), standalone_, switch_input(), unparsed_entities_, and validate_. Referenced by parse_attvalue(), and parse_content().
02338 {
02339 ACEXML_Char* replace = this->parse_reference_name ();
02340 if (replace == 0)
02341 {
02342 this->fatal_error (ACE_TEXT ("Invalid Reference name")
02343 ACEXML_ENV_ARG_PARAMETER);
02344 ACEXML_CHECK_RETURN (-1);
02345 }
02346
02347 // [WFC: Parsed Entity]
02348 if (this->unparsed_entities_.resolve_entity (replace)) {
02349 this->fatal_error (ACE_TEXT ("EntityRef refers to unparsed entity")
02350 ACEXML_ENV_ARG_PARAMETER);
02351 ACEXML_CHECK_RETURN (-1);
02352 }
02353 // Look in the internal general entities set first.
02354 const ACEXML_Char* entity = this->internal_GE_.resolve_entity(replace);
02355
02356 // Look in the predefined entities.
02357 if (!entity)
02358 {
02359 entity = this->predef_entities_.resolve_entity (replace);
02360 if (entity)
02361 {
02362 // Special case to return the length in case of predefined entities
02363 this->obstack_.grow (*entity);
02364 return 1;
02365 }
02366 }
02367
02368 if (!this->validate_)
02369 {
02370 if (this->standalone_)
02371 {
02372 // [WFC: Entity Declared]
02373 this->fatal_error (ACE_TEXT ("Undeclared Entity reference")
02374 ACEXML_ENV_ARG_PARAMETER);
02375 ACEXML_CHECK_RETURN (-1);
02376 }
02377 else
02378 {
02379 this->content_handler_->skippedEntity (replace
02380 ACEXML_ENV_ARG_PARAMETER);
02381 ACEXML_CHECK_RETURN (-1);
02382 return 0;
02383 }
02384 }
02385
02386 // No match in internal subset
02387 if (!entity
02388 // or No DTDs
02389 && (!(this->internal_dtd_ || this->external_dtd_)
02390 // or Only Internal DTD and no parameter entity references
02391 || (this->internal_dtd_ && !this->external_dtd_
02392 && !this->has_pe_refs_)
02393 // or Standalone = 'yes'
02394 || this->standalone_))
02395 {
02396 // [WFC: Entity Declared]
02397 this->fatal_error (ACE_TEXT ("Undeclared Entity reference")
02398 ACEXML_ENV_ARG_PARAMETER);
02399 ACEXML_CHECK_RETURN (-1);
02400 }
02401
02402 ACEXML_Char* systemId = 0;
02403 ACEXML_Char* publicId = 0;
02404 if (!entity)
02405 {
02406 if (this->external_GE_.resolve_entity (replace, systemId, publicId) < 0)
02407 {
02408 this->fatal_error (ACE_TEXT ("Undeclared Entity reference")
02409 ACEXML_ENV_ARG_PARAMETER);
02410 ACEXML_CHECK_RETURN (-1);
02411 }
02412 if (this->ref_state_ == ACEXML_ParserInt::IN_ATT_VALUE)
02413 {
02414 this->fatal_error (ACE_TEXT ("External EntityRef in Attribute Value")
02415 ACEXML_ENV_ARG_PARAMETER);
02416 ACEXML_CHECK_RETURN (-1);
02417 }
02418 this->external_entity_++;
02419 }
02420
02421
02422 // [WFC: No Recursion]
02423 ACEXML_Char* ref_name = replace;
02424 int present = this->GE_reference_.insert (ref_name);
02425 if (present == 1 || present == -1)
02426 {
02427 while (this->GE_reference_.pop(ref_name) != -1)
02428 ;
02429 this->fatal_error (ACE_TEXT ("Recursion in resolving entity")
02430 ACEXML_ENV_ARG_PARAMETER);
02431 ACEXML_CHECK_RETURN (-1);
02432 }
02433
02434 if (!this->external_entity_)
02435 {
02436 ACEXML_StrCharStream* str = 0;
02437 ACE_NEW_RETURN (str, ACEXML_StrCharStream, -1);
02438 if (str->open (entity, replace) < 0
02439 || this->switch_input (str, replace) != 0)
02440 {
02441 this->fatal_error (ACE_TEXT ("Unable to create internal input ")
02442 ACE_TEXT ("stream")
02443 ACEXML_ENV_ARG_PARAMETER);
02444 ACEXML_CHECK_RETURN (-1);
02445 }
02446 return 0;
02447 }
02448 else
02449 {
02450 ACEXML_Char* uri = this->normalize_systemid (systemId);
02451 ACE_Auto_Basic_Array_Ptr<ACEXML_Char> cleanup_uri (uri);
02452 ACEXML_InputSource* ip = 0;
02453 if (this->entity_resolver_)
02454 {
02455 ip = this->entity_resolver_->resolveEntity (publicId,
02456 (uri ? uri : systemId)
02457 ACEXML_ENV_ARG_PARAMETER);
02458 ACEXML_CHECK_RETURN (-1);
02459 if (ip)
02460 {
02461 if (this->switch_input (ip, (uri ? uri : systemId),
02462 publicId) != 0)
02463 {
02464 this->fatal_error (ACE_TEXT ("Internal Parser Error")
02465 ACEXML_ENV_ARG_PARAMETER);
02466 ACEXML_CHECK_RETURN (-1);
02467 }
02468 return 0;
02469 }
02470 }
02471 ACEXML_StreamFactory factory;
02472 ACEXML_CharStream* cstream = factory.create_stream (uri ? uri: systemId);
02473 if (!cstream) {
02474 this->fatal_error (ACE_TEXT ("Invalid input source")
02475 ACEXML_ENV_ARG_PARAMETER);
02476 ACEXML_CHECK_RETURN (-1);
02477 }
02478 if (this->switch_input (cstream, systemId, publicId) != 0)
02479 {
02480 this->fatal_error (ACE_TEXT ("Internal Parser Error")
02481 ACEXML_ENV_ARG_PARAMETER);
02482 ACEXML_CHECK_RETURN (-1);
02483 }
02484 }
02485 return 0;
02486 }
|
|
|
Parse an entityValue. Definition at line 2629 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, external_entity_, fatal_error(), ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), obstack_, parse_char_reference(), parse_PE_reference(), peek(), pop_context(), and ref_state_. Referenced by parse_entity_decl().
02631 {
02632 ACEXML_ParserInt::ReferenceState temp = this->ref_state_;
02633 ACEXML_Char quote = this->get ();
02634 if (quote != '\'' && quote != '"') // Not a quoted string.
02635 return -1;
02636 ACEXML_Char ch = this->get ();
02637 while (1)
02638 {
02639 if (ch == quote)
02640 {
02641 str = this->obstack_.freeze ();
02642 this->ref_state_ = temp;
02643 return 0;
02644 }
02645 switch (ch)
02646 {
02647 case '&':
02648 if (this->peek () == '#')
02649 {
02650 if (!this->external_entity_)
02651 {
02652 ACEXML_Char buf[7];
02653 size_t len = sizeof (buf);
02654 if (this->parse_char_reference (buf, len) != 0)
02655 {
02656 // [WFC: Legal Character]
02657 this->fatal_error (ACE_TEXT ("Invalid character ")
02658 ACE_TEXT ("reference")
02659 ACEXML_ENV_ARG_PARAMETER);
02660 return -1;
02661 }
02662 for (size_t j = 0; j < len; ++j)
02663 this->obstack_.grow (buf[j]);
02664 break;
02665 }
02666 }
02667 this->obstack_.grow (ch);
02668 break;
02669 case '%':
02670 if (!this->external_entity_)
02671 {
02672 this->ref_state_ = ACEXML_ParserInt::IN_ENTITY_VALUE;
02673 this->parse_PE_reference(ACEXML_ENV_SINGLE_ARG_PARAMETER);
02674 ACEXML_CHECK_RETURN (-1);
02675 break;
02676 }
02677 this->obstack_.grow (ch);
02678 break;
02679 case 0:
02680 this->pop_context (0 ACEXML_ENV_ARG_PARAMETER);
02681 ACEXML_CHECK_RETURN (-1);
02682 break;
02683 default:
02684 this->obstack_.grow (ch);
02685 break;
02686 }
02687 ch = this->get();
02688 }
02689 }
|
|
|
Parse an external DTD. Definition at line 364 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, ACEXML_StreamFactory::create_stream(), entity_resolver_, fatal_error(), normalize_systemid(), parse_external_id(), parse_external_subset(), ref_state_, ACEXML_EntityResolver::resolveEntity(), switch_input(), and validate_. Referenced by parse_doctypedecl().
00365 {
00366 this->ref_state_ = ACEXML_ParserInt::IN_EXT_DTD;
00367 ACEXML_Char* publicId = 0;
00368 ACEXML_Char* systemId = 0;
00369 if (this->parse_external_id (publicId, systemId
00370 ACEXML_ENV_ARG_PARAMETER) != 0)
00371 {
00372 this->fatal_error (ACE_TEXT ("Error in parsing ExternalID")
00373 ACEXML_ENV_ARG_PARAMETER);
00374 ACEXML_CHECK_RETURN (-1);
00375 }
00376 if (this->validate_)
00377 {
00378 ACEXML_Char* uri = this->normalize_systemid (systemId);
00379 ACE_Auto_Basic_Array_Ptr<ACEXML_Char> cleanup_uri (uri);
00380 ACEXML_InputSource* ip = 0;
00381 if (this->entity_resolver_)
00382 {
00383 ip = this->entity_resolver_->resolveEntity (publicId,
00384 (uri ? uri : systemId)
00385 ACEXML_ENV_ARG_PARAMETER);
00386 ACEXML_CHECK_RETURN (-1);
00387 }
00388 if (ip)
00389 {
00390 if (this->switch_input (ip, (uri ? uri : systemId), publicId) != 0)
00391 return -1;
00392 }
00393 else
00394 {
00395 ACEXML_StreamFactory factory;
00396 ACEXML_CharStream* cstream = factory.create_stream (uri ?
00397 uri: systemId);
00398 if (!cstream) {
00399 this->fatal_error (ACE_TEXT ("Invalid input source")
00400 ACEXML_ENV_ARG_PARAMETER);
00401 ACEXML_CHECK_RETURN (-1);
00402 }
00403 if (this->switch_input (cstream, systemId, publicId) != 0)
00404 return -1;
00405 }
00406 this->parse_external_subset (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00407 ACEXML_CHECK_RETURN (-1);
00408 }
00409 return 0;
00410 }
|
|
||||||||||||
|
Parse an ExternalID or a reference to PUBLIC ExternalID. Possible cases are in the forms of:
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.
Definition at line 715 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, fatal_error(), get(), parse_pubid_literal(), parse_system_literal(), parse_token(), ref_state_, and skip_whitespace_count(). Referenced by parse_entity_decl(), parse_external_dtd(), and parse_notation_decl().
00718 {
00719 publicId = systemId = 0;
00720 ACEXML_Char nextch = this->get ();
00721 ACEXML_Char fwd = 0;
00722 switch (nextch)
00723 {
00724 case 'S': // External SYSTEM id.
00725 if (this->parse_token (ACE_TEXT ("YSTEM")) < 0 ||
00726 this->skip_whitespace_count () < 1)
00727 {
00728 this->fatal_error(ACE_TEXT ("Expecting keyword SYSTEM")
00729 ACEXML_ENV_ARG_PARAMETER);
00730 ACEXML_CHECK_RETURN (-1);
00731 }
00732 if (this->parse_system_literal (systemId) != 0)
00733 {
00734 this->fatal_error(ACE_TEXT ("Invalid systemLiteral")
00735 ACEXML_ENV_ARG_PARAMETER);
00736 ACEXML_CHECK_RETURN (-1);
00737 }
00738 break;
00739 case 'P': // External PUBLIC id or previously defined PUBLIC id.
00740 if (this->parse_token (ACE_TEXT ("UBLIC")) < 0 ||
00741 this->skip_whitespace_count () < 1)
00742 {
00743 this->fatal_error(ACE_TEXT ("Expecing keyword PUBLIC")
00744 ACEXML_ENV_ARG_PARAMETER);
00745 ACEXML_CHECK_RETURN (-1);
00746 }
00747 if (this->parse_pubid_literal (publicId) != 0)
00748 {
00749 this->fatal_error(ACE_TEXT ("Invalid PubidLiteral")
00750 ACEXML_ENV_ARG_PARAMETER);
00751 ACEXML_CHECK_RETURN (-1);
00752 }
00753 this->skip_whitespace_count(&fwd);
00754 if (fwd == '\'' || fwd == '"')
00755 {
00756 if (this->parse_system_literal (systemId) != 0)
00757 {
00758 this->fatal_error(ACE_TEXT ("Invalid systemLiteral")
00759 ACEXML_ENV_ARG_PARAMETER);
00760 ACEXML_CHECK_RETURN (-1);
00761 }
00762 }
00763 else if (this->ref_state_ != ACEXML_ParserInt::IN_NOTATION)
00764 {
00765 this->fatal_error(ACE_TEXT ("Expecting systemLiteral after a ")
00766 ACE_TEXT ("PUBLIC keyword")
00767 ACEXML_ENV_ARG_PARAMETER);
00768 ACEXML_CHECK_RETURN (-1);
00769 }
00770 break;
00771 default:
00772 this->fatal_error(ACE_TEXT ("Invalid system/public Literal")
00773 ACEXML_ENV_ARG_PARAMETER);
00774 ACEXML_CHECK_RETURN (-1);
00775 }
00776 return 0;
00777 }
|
|
|
Parse an external subset. This does the actual parsing of an external subset and is called by
Definition at line 414 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, external_subset_, fatal_error(), get(), parse_conditional_section(), parse_markup_decl(), parse_PE_reference(), parse_processing_instruction(), parse_text_decl(), peek(), pop_context(), ref_state_, and skip_whitespace(). Referenced by parse_external_dtd().
00415 {
00416 this->ref_state_ = ACEXML_ParserInt::IN_EXT_DTD;
00417 this->external_subset_ = 1;
00418 size_t nrelems = 0;
00419 ACEXML_Char nextch = this->skip_whitespace();
00420 do {
00421 switch (nextch)
00422 {
00423 case '<':
00424 nextch = this->get();
00425 switch (nextch)
00426 {
00427 case '!':
00428 nextch = this->peek();
00429 if (nextch == '[')
00430 this->parse_conditional_section (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00431 else
00432 this->parse_markup_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00433 ACEXML_CHECK_RETURN (-1);
00434 break;
00435 case '?':
00436 nextch = this->peek();
00437 if (nextch == 'x')
00438 this->parse_text_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00439 else
00440 this->parse_processing_instruction (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00441 ACEXML_CHECK_RETURN (-1);
00442 break;
00443 default:
00444 this->fatal_error (ACE_TEXT ("Invalid content in external DTD")
00445 ACEXML_ENV_ARG_PARAMETER);
00446 ACEXML_CHECK_RETURN (-1);
00447 }
00448 break;
00449 case '%':
00450 this->parse_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00451 ACEXML_CHECK_RETURN (-1);
00452 break;
00453 case 0:
00454 nrelems = this->pop_context (0 ACEXML_ENV_ARG_PARAMETER);
00455 ACEXML_CHECK_RETURN (-1);
00456 if (nrelems == 1)
00457 return 0;
00458 break;
00459 default:
00460 this->fatal_error (ACE_TEXT ("Invalid content in external DTD")
00461 ACEXML_ENV_ARG_PARAMETER);
00462 ACEXML_CHECK_RETURN (-1);
00463 }
00464 nextch = this->skip_whitespace();
00465 } while (1);
00466 }
|
|
|
Parse a ignoreSect declaration. Definition at line 546 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, fatal_error(), get(), peek(), and skip_whitespace(). Referenced by parse_conditional_section().
00547 {
00548 ACEXML_Char nextch = this->skip_whitespace();
00549 int count = 0;
00550 int done = 0;
00551 do {
00552 switch (nextch)
00553 {
00554 case '<':
00555 if (this->peek() == '!')
00556 {
00557 this->get();
00558 if (this->peek() == '[')
00559 {
00560 this->get();
00561 count++;
00562 }
00563 }
00564 break;
00565 case ']':
00566 if (this->peek() == ']')
00567 {
00568 this->get();
00569 if (this->peek() == '>')
00570 {
00571 this->get();
00572 if (count)
00573 {
00574 --count;
00575 break;
00576 }
00577 done = 1;
00578 }
00579 }
00580 break;
00581 case 0: // [VC: Proper Conditional Section/PE Nesting]
00582 if (count != 0)
00583 {
00584 this->fatal_error (ACE_TEXT ("Invalid Conditional Section/PE ")
00585 ACE_TEXT ("Nesting ")
00586 ACEXML_ENV_ARG_PARAMETER);
00587 ACEXML_CHECK_RETURN (-1);
00588 }
00589 default:
00590 break;
00591 }
00592 if (done)
00593 break;
00594 nextch = this->get();
00595 } while (1);
00596
00597 return 0;
00598 }
|
|
|
Parse a includeSect declaration. Definition at line 601 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, fatal_error(), get(), parse_conditional_section(), parse_markup_decl(), parse_PE_reference(), parse_processing_instruction(), peek(), and skip_whitespace(). Referenced by parse_conditional_section().
00602 {
00603 ACEXML_Char nextch = this->skip_whitespace();
00604 do {
00605 switch (nextch)
00606 {
00607 case '<':
00608 nextch = this->get();
00609 switch (nextch)
00610 {
00611 case '!':
00612 nextch = this->peek();
00613 if (nextch == '[')
00614 this->parse_conditional_section (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00615 else
00616 this->parse_markup_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00617 ACEXML_CHECK_RETURN (-1);
00618 break;
00619 case '?':
00620 nextch = this->peek();
00621 this->parse_processing_instruction (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00622 ACEXML_CHECK_RETURN (-1);
00623 break;
00624 default:
00625 this->fatal_error (ACE_TEXT ("Invalid includeSect")
00626 ACEXML_ENV_ARG_PARAMETER);
00627 ACEXML_CHECK_RETURN (-1);
00628 }
00629 break;
00630 case '%':
00631 this->parse_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00632 ACEXML_CHECK_RETURN (-1);
00633 break;
00634 case 0: // [VC: Proper Conditional Section/PE Nesting]
00635 this->fatal_error (ACE_TEXT ("Invalid Conditional Section/PE ")
00636 ACE_TEXT ("Nesting ")
00637 ACEXML_ENV_ARG_PARAMETER);
00638 ACEXML_CHECK_RETURN (-1);
00639 case ']':
00640 if (this->peek() == ']')
00641 {
00642 nextch = this->get();
00643 if (this->peek() == '>')
00644 {
00645 nextch = this->get();
00646 return 0;
00647 }
00648 }
00649 default:
00650 this->fatal_error (ACE_TEXT ("Invalid includeSect")
00651 ACEXML_ENV_ARG_PARAMETER);
00652 ACEXML_CHECK_RETURN (-1);
00653 }
00654 nextch = this->skip_whitespace();
00655 } while (1);
00656 }
|
|
|
Parse a "markupdecl" section, this includes both "markupdecl" and "DeclSep" sections in XML specification Definition at line 310 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, fatal_error(), get(), has_pe_refs_, parse_markup_decl(), parse_PE_reference(), parse_processing_instruction(), pop_context(), ref_state_, and skip_whitespace(). Referenced by parse_doctypedecl().
00311 {
00312 this->ref_state_ = ACEXML_ParserInt::IN_INT_DTD;
00313 ACEXML_Char nextch = this->skip_whitespace ();
00314 do {
00315 switch (nextch)
00316 {
00317 case '<':
00318 nextch = this->get();
00319 switch (nextch)
00320 {
00321 case '!':
00322 this->parse_markup_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00323 ACEXML_CHECK_RETURN (-1);
00324 break;
00325 case '?':
00326 this->parse_processing_instruction (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00327 ACEXML_CHECK_RETURN (-1);
00328 break;
00329 default:
00330 this->fatal_error (ACE_TEXT ("Invalid internal subset")
00331 ACEXML_ENV_ARG_PARAMETER);
00332 ACEXML_CHECK_RETURN (-1);
00333 break;
00334 }
00335 break;
00336 case '%':
00337 this->has_pe_refs_ = 1;
00338 this->parse_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00339 ACEXML_CHECK_RETURN (-1);
00340 break;
00341 case ']': // End of internal definitions.
00342 return 0;
00343 case '&':
00344 this->fatal_error (ACE_TEXT ("Invalid Reference in internal DTD")
00345 ACEXML_ENV_ARG_PARAMETER);
00346 ACEXML_CHECK_RETURN (-1);
00347 break;
00348 case 0:
00349 this->pop_context (0 ACEXML_ENV_ARG_PARAMETER);
00350 ACEXML_CHECK_RETURN (-1);
00351 break;
00352 default:
00353 this->fatal_error (ACE_TEXT ("Invalid content in internal subset")
00354 ACEXML_ENV_ARG_PARAMETER);
00355 ACEXML_CHECK_RETURN (-1);
00356 };
00357 nextch = this->skip_whitespace ();
00358 } while (1);
00359
00360 ACE_NOTREACHED (return -1);
00361 }
|
|
|
Parse a markupDecl section. Definition at line 659 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, fatal_error(), get(), parse_attlist_decl(), parse_comment(), parse_element_decl(), parse_entity_decl(), parse_notation_decl(), and peek(). Referenced by parse_external_subset(), parse_includesect(), and parse_internal_dtd().
00660 {
00661 ACEXML_Char nextch = this->peek ();
00662 switch (nextch)
00663 {
00664 case 'E': // An ELEMENT or ENTITY decl
00665 this->get ();
00666 nextch = this->peek ();
00667 switch (nextch)
00668 {
00669 case 'L':
00670 this->parse_element_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00671 ACEXML_CHECK_RETURN (-1);
00672 break;
00673 case 'N':
00674 this->parse_entity_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00675 ACEXML_CHECK_RETURN (-1);
00676 break;
00677 default:
00678 this->fatal_error(ACE_TEXT ("Expecting keyword ELEMENT/ENTITY")
00679 ACEXML_ENV_ARG_PARAMETER);
00680 ACEXML_CHECK_RETURN (-1);
00681 }
00682 break;
00683
00684 case 'A': // An ATTLIST decl
00685 this->parse_attlist_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00686 ACEXML_CHECK_RETURN (-1);
00687 break;
00688
00689 case 'N': // A NOTATION decl
00690 this->parse_notation_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
00691 ACEXML_CHECK_RETURN (-1);
00692 break;
00693
00694 case '-': // a comment.
00695 if (this->parse_comment () < 0)
00696 {
00697 this->fatal_error(ACE_TEXT ("Invalid comment")
00698 ACEXML_ENV_ARG_PARAMETER);
00699 ACEXML_CHECK_RETURN (-1);
00700 }
00701 break;
00702 case 0: // [VC: Proper Declaration/PE Nesting]
00703 this->fatal_error (ACE_TEXT ("Unexpected end-of-file")
00704 ACEXML_ENV_ARG_PARAMETER);
00705 ACEXML_CHECK_RETURN (-1);
00706 default:
00707 this->fatal_error (ACE_TEXT ("Invalid markupDecl")
00708 ACEXML_ENV_ARG_PARAMETER);
00709 ACEXML_CHECK_RETURN (-1);
00710 }
00711 return 0;
00712 }
|
|
|
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.
Definition at line 2692 of file Parser.cpp. References ACEXML_Char, ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), isLetter(), isNameChar(), obstack_, and peek(). Referenced by parse_attlist_decl(), parse_attname(), parse_atttype(), parse_child(), parse_children_definition(), parse_content(), parse_doctypedecl(), parse_element(), parse_element_decl(), parse_entity_decl(), parse_notation_decl(), and parse_processing_instruction().
02693 {
02694 if (ch == 0)
02695 ch = this->get ();
02696 if (!this->isLetter (ch) && ch != '_' && ch != ':')
02697 return 0;
02698 while (ch) {
02699 this->obstack_.grow (ch);
02700 ch = this->peek ();
02701 if (!this->isNameChar (ch))
02702 break;
02703 ch = this->get ();
02704 };
02705 return this->obstack_.freeze ();
02706 }
|
|
|
Parse a NMTOKEN from the input stream.
Definition at line 2709 of file Parser.cpp. References ACEXML_Char, ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), isNameChar(), obstack_, and peek(). Referenced by parse_atttype().
02710 {
02711 if (ch == 0)
02712 ch = this->get ();
02713 if (!this->isNameChar (ch))
02714 return 0;
02715 while (ch) {
02716 this->obstack_.grow (ch);
02717 ch = this->peek ();
02718 if (!this->isNameChar (ch))
02719 break;
02720 ch = this->get ();
02721 };
02722 return this->obstack_.freeze ();
02723 }
|
|
|
Parse a "NOTATION" decl. The first character this method expects is always the 'N' (the first char) in the word "NOTATION".
Definition at line 1815 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, ACEXML_Entity_Manager::add_entity(), check_for_PE_reference(), dtd_handler_, fatal_error(), ACEXML_DTDHandler::notationDecl(), notations_, parse_external_id(), parse_name(), parse_token(), ref_state_, skip_whitespace(), and validate_. Referenced by parse_markup_decl().
01816 {
01817 if (this->parse_token (ACE_TEXT ("NOTATION")) < 0)
01818 {
01819 this->fatal_error(ACE_TEXT ("Expecting Keyword 'NOTATION'")
01820 ACEXML_ENV_ARG_PARAMETER);
01821 ACEXML_CHECK_RETURN (-1);
01822 }
01823 int count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01824 ACEXML_CHECK_RETURN (-1);
01825 if (!count)
01826 {
01827 this->fatal_error (ACE_TEXT ("Expecting a space between keyword NOTATION")
01828 ACE_TEXT (" and notation name")
01829 ACEXML_ENV_ARG_PARAMETER);
01830 ACEXML_CHECK_RETURN (-1);
01831 }
01832 ACEXML_Char *notation = this->parse_name ();
01833 if (notation == 0)
01834 {
01835 this->fatal_error(ACE_TEXT ("Invalid Notation name")
01836 ACEXML_ENV_ARG_PARAMETER);
01837 ACEXML_CHECK_RETURN (-1);
01838 }
01839 count = this->check_for_PE_reference (ACEXML_ENV_SINGLE_ARG_PARAMETER);
01840 ACEXML_CHECK_RETURN (-1);
01841 if (!count)
01842 {
01843 this->fatal_error (ACE_TEXT ("Expecting a space between notation name ")
01844 ACE_TEXT ("and ExternalID/PublicID")
01845 ACEXML_ENV_ARG_PARAMETER);
01846 ACEXML_CHECK_RETURN (-1);
01847 }
01848
01849 ACEXML_Char *systemid, *publicid;
01850
01851 // Gross hack but otherwise we need to go around a lot of loops to parse,
01852 // When the ExternalID starts with 'PUBLIC' we cannot distinguish a
01853 // PublicId from a ExternalID by looking using a one character read-ahead
01854 ACEXML_ParserInt::ReferenceState temp = this->ref_state_;
01855 this->ref_state_ = ACEXML_ParserInt::IN_NOTATION;
01856
01857 this->parse_external_id (publicid, systemid
01858 ACEXML_ENV_ARG_PARAMETER);
01859 ACEXML_CHECK_RETURN (-1);
01860 // Restore the original value.
01861 this->ref_state_ = temp;
01862
01863 // [VC: Unique Notation Name]
01864 if (systemid && this->notations_.add_entity (notation, systemid) != 0
01865 && this->validate_)
01866 {
01867 this->fatal_error(ACE_TEXT ("Internal Parser Error")
01868 ACEXML_ENV_ARG_PARAMETER);
01869 ACEXML_CHECK_RETURN (-1);
01870 }
01871 if (publicid)
01872 {
01873 int retval = this->notations_.add_entity (notation, publicid);
01874 if (retval != 0 && !systemid && this->validate_)
01875 {
01876 this->fatal_error(ACE_TEXT ("Internal Parser Error")
01877 ACEXML_ENV_ARG_PARAMETER);
01878 ACEXML_CHECK_RETURN (-1);
01879 }
01880 }
01881
01882 if (this->skip_whitespace() != '>')
01883 {
01884 this->fatal_error(ACE_TEXT ("Expecting '>' at end of NotationDecl")
01885 ACEXML_ENV_ARG_PARAMETER);
01886 ACEXML_CHECK_RETURN (-1);
01887 }
01888
01889 if (this->validate_ && this->dtd_handler_)
01890 {
01891 this->dtd_handler_->notationDecl (notation,
01892 publicid,
01893 systemid ACEXML_ENV_ARG_PARAMETER);
01894 ACEXML_CHECK_RETURN (-1);
01895 }
01896 return 0;
01897 }
|
|
|
Parse a PEReference. Definition at line 2489 of file Parser.cpp. References ACE_NEW_RETURN, ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, ACEXML_String, ACEXML_StreamFactory::create_stream(), entity_resolver_, external_dtd_, external_entity_, external_PE_, fatal_error(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), ACE_Unbounded_Stack< ACEXML_Char * >::insert(), internal_PE_, normalize_systemid(), obstack_, ACEXML_StrCharStream::open(), parse_reference_name(), parse_text_decl(), PE_reference_, peek(), ACE_Unbounded_Stack< ACEXML_Char * >::pop(), ref_state_, ACEXML_Entity_Manager::resolve_entity(), ACEXML_EntityResolver::resolveEntity(), standalone_, switch_input(), and validate_. Referenced by check_for_PE_reference(), parse_conditional_section(), parse_entity_value(), parse_external_subset(), parse_includesect(), and parse_internal_dtd().
02490 {
02491 ACEXML_Char* replace = this->parse_reference_name ();
02492 if (replace == 0)
02493 {
02494 this->fatal_error (ACE_TEXT ("Invalid PEReference name")
02495 ACEXML_ENV_ARG_PARAMETER);
02496 ACEXML_CHECK_RETURN (-1);
02497 }
02498
02499 // Look in the internal general entities set first.
02500 const ACEXML_Char* entity = this->internal_PE_.resolve_entity(replace);
02501
02502 if (!entity && // No match in internal
02503 (!this->external_dtd_ || // or No External DTDs
02504 this->standalone_)) // or Standalone
02505 {
02506 // [VC: Entity Declared]
02507 this->fatal_error (ACE_TEXT ("Undefined Internal PEReference")
02508 ACEXML_ENV_ARG_PARAMETER);
02509 ACEXML_CHECK_RETURN (-1);
02510 }
02511
02512 ACEXML_Char* systemId = 0;
02513 ACEXML_Char* publicId = 0;
02514 if (!entity && this->validate_)
02515 {
02516 if (this->external_PE_.resolve_entity (replace, systemId, publicId) < 0)
02517 {
02518 this->fatal_error (ACE_TEXT ("Undefined PEReference")
02519 ACEXML_ENV_ARG_PARAMETER);
02520 ACEXML_CHECK_RETURN (-1);
02521 }
02522 this->external_entity_++;
02523 }
02524
02525 // [WFC: No Recursion]
02526 ACEXML_Char* ref_name = replace;
02527 int present = this->PE_reference_.insert (ref_name);
02528 if (present == 1 || present == -1)
02529 {
02530 while (this->PE_reference_.pop(ref_name) != -1)
02531 ;
02532 this->fatal_error (ACE_TEXT ("Recursion in resolving entity")
02533 ACEXML_ENV_ARG_PARAMETER);
02534 ACEXML_CHECK_RETURN (-1);
02535 }
02536
02537 if (entity && !this->external_entity_)
02538 {
02539 ACEXML_StrCharStream* sstream = 0;
02540 ACEXML_String str (entity);
02541 if (this->ref_state_ != ACEXML_ParserInt::IN_ENTITY_VALUE)
02542 {
02543 const ACEXML_Char* ch = ACE_TEXT (" ");
02544 str = ch + str + ch;
02545 }
02546 // ACE_DEBUG ((LM_DEBUG,
02547 // ACE_TEXT ("Entity is %s\n Replacement Text is : %s\n"),
02548 // replace, str.c_str()));
02549 ACE_NEW_RETURN (sstream, ACEXML_StrCharStream, -1);
02550 if (sstream->open (str.c_str(), replace) < 0
02551 || this->switch_input (sstream, replace) != 0)
02552 {
02553 this->fatal_error (ACE_TEXT ("Error in switching InputSource")
02554 ACEXML_ENV_ARG_PARAMETER);
02555 ACEXML_CHECK_RETURN (-1);
02556 }
02557 return 0;
02558 }
02559 else if (this->external_entity_ && this->validate_)
02560 {
02561 ACEXML_Char* uri = this->normalize_systemid (systemId);
02562 ACE_Auto_Basic_Array_Ptr<ACEXML_Char> cleanup_uri (uri);
02563 ACEXML_InputSource* ip = 0;
02564 if (this->entity_resolver_)
02565 {
02566 ip = this->entity_resolver_->resolveEntity (publicId,
02567 (uri ? uri : systemId)
02568 ACEXML_ENV_ARG_PARAMETER);
02569 ACEXML_CHECK_RETURN (-1);
02570 }
02571 if (ip)
02572 {
02573 if (this->switch_input (ip, (uri ? uri : systemId), publicId) != 0)
02574 {
02575 this->fatal_error (ACE_TEXT ("Error in switching InputSource")
02576 ACEXML_ENV_ARG_PARAMETER);
02577 ACEXML_CHECK_RETURN (-1);
02578 }
02579 return 0;
02580 }
02581 else
02582 {
02583 ACEXML_StreamFactory factory;
02584 ACEXML_CharStream* cstream = factory.create_stream (uri ? uri: systemId);
02585 if (!cstream) {
02586 this->fatal_error (ACE_TEXT ("Invalid input source")
02587 ACEXML_ENV_ARG_PARAMETER);
02588 ACEXML_CHECK_RETURN (-1);
02589 }
02590 if (this->switch_input (cstream, systemId, publicId) != 0)
02591 {
02592 this->fatal_error (ACE_TEXT ("Error in switching InputSource")
02593 ACEXML_ENV_ARG_PARAMETER);
02594 ACEXML_CHECK_RETURN (-1);
02595 }
02596 if (this->ref_state_ == ACEXML_ParserInt::IN_ENTITY_VALUE)
02597 {
02598 ACEXML_Char less, mark;
02599 if (this->peek() == '<')
02600 {
02601 less = this->get();
02602 if (this->peek() == '?')
02603 {
02604 mark = this->get();
02605 if (this->peek() == 'x')
02606 {
02607 this->parse_text_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
02608 ACEXML_CHECK_RETURN (-1);
02609 }
02610 else
02611 {
02612 this->obstack_.grow (less);
02613 this->obstack_.grow (mark);
02614 }
02615 }
02616 this->obstack_.grow (less);
02617 }
02618 }
02619 return 0;
02620 }
02621 }
02622 this->fatal_error (ACE_TEXT ("Undefined PEReference")
02623 ACEXML_ENV_ARG_PARAMETER);
02624 ACEXML_CHECK_RETURN (-1);
02625 return -1;
02626 }
|
|
|
Parse a PI statement. The first character encountered should always be '?' in the PI prefix "@<?".
Definition at line 3263 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, content_handler_, fatal_error(), ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), obstack_, parse_name(), ACEXML_ContentHandler::processingInstruction(), skip_whitespace(), ACE_OS::strcasecmp(), and ACE_Obstack_T< ACEXML_Char >::unwind(). Referenced by parse(), parse_content(), parse_external_subset(), parse_includesect(), and parse_internal_dtd().
03264 {
03265 const ACEXML_Char *pitarget = this->parse_name ();
03266 ACEXML_Char *instruction = 0;
03267
03268 if (!ACE_OS::strcasecmp (ACE_TEXT ("xml"), pitarget))
03269 {
03270 // Invalid PITarget name.
03271 this->fatal_error(ACE_TEXT ("PI can't have 'xml' in PITarget")
03272 ACEXML_ENV_ARG_PARAMETER);
03273 ACEXML_CHECK_RETURN (-1);
03274 }
03275
03276 int state = 0;
03277
03278 ACEXML_Char ch = this->skip_whitespace();
03279 while (state < 2)
03280 {
03281 switch (ch)
03282 {
03283 case '?':
03284 if (state == 0)
03285 state = 1;
03286 break;
03287 case '>':
03288 if (state == 1)
03289 {
03290 instruction = this->obstack_.freeze ();
03291 this->content_handler_->processingInstruction (pitarget,
03292 instruction
03293 ACEXML_ENV_ARG_PARAMETER);
03294 ACEXML_CHECK_RETURN (-1);
03295 this->obstack_.unwind (const_cast<ACEXML_Char*> (pitarget));
03296 return 0;
03297 }
03298 break;
03299 case 0x0A:
03300 // Fall thru...
03301 default:
03302 if (state == 1)
03303 this->obstack_.grow ('?');
03304 this->obstack_.grow (ch);
03305 state = 0;
03306 }
03307 ch = this->get ();
03308 }
03309 return -1;
03310 }
|
|
|
Parse a PubidLiteral.
Definition at line 2790 of file Parser.cpp. References ACEXML_Char, ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), isPubidChar(), and obstack_. Referenced by parse_external_id().
02791 {
02792 const ACEXML_Char quote = this->get();
02793 if (quote != '\'' && quote != '"') // Not a quoted string.
02794 return -1;
02795 while (1)
02796 {
02797 ACEXML_Char ch = this->get ();
02798 if (ch == quote)
02799 {
02800 str = this->obstack_.freeze ();
02801 return 0;
02802 }
02803 else if (this->isPubidChar (ch))
02804 this->obstack_.grow (ch);
02805 else
02806 return -1;
02807 }
02808 }
|
|
|
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
Definition at line 2235 of file Parser.cpp. References ACEXML_Char, alt_stack_, ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), isLetter(), isNameChar(), and peek(). Referenced by parse_entity_reference(), and parse_PE_reference().
02236 {
02237 ACEXML_Char ch = this->get ();
02238 if (!this->isLetter (ch) && (ch != '_' || ch != ':'))
02239 return 0;
02240 while (ch) {
02241 this->alt_stack_.grow (ch);
02242 ch = this->peek ();
02243 if (!this->isNameChar (ch))
02244 break;
02245 ch = this->get ();
02246 };
02247 if (ch != ';')
02248 return 0;
02249 ch = this->get();
02250 return this->alt_stack_.freeze ();
02251 }
|
|
|
Parse a SDDecl string.
Definition at line 2845 of file Parser.cpp. References ACEXML_Char, ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), and obstack_. Referenced by parse_xml_decl().
02846 {
02847 ACEXML_Char quote = this->get ();
02848 if (quote != '\'' && quote != '"') // Not a quoted string.
02849 return -1;
02850 int numchars = 0;
02851 while (1)
02852 {
02853 ACEXML_Char ch = this->get ();
02854 if (ch == quote && numchars < 2)
02855 return -1;
02856 else if (ch == quote)
02857 {
02858 str = this->obstack_.freeze ();
02859 return 0;
02860 }
02861 // [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'")
02862 // | ('"' ('yes' | 'no') '"'))
02863 switch (ch)
02864 {
02865 case 'y': case 'e': case 's': case 'n': case 'o':
02866 this->obstack_.grow (ch);
02867 numchars++;
02868 break;
02869 default:
02870 return -1;
02871 }
02872 }
02873 }
|
|
|
Parse a SystemLiteral.
Definition at line 2757 of file Parser.cpp. References ACE_ERROR, ACE_TEXT, ACEXML_Char, ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), LM_ERROR, and obstack_. Referenced by parse_external_id().
02758 {
02759 const ACEXML_Char quote = this->get();
02760 if (quote != '\'' && quote != '"') // Not a quoted string.
02761 return -1;
02762 while (1)
02763 {
02764 ACEXML_Char ch = this->get ();
02765 if (ch == quote)
02766 {
02767 str = this->obstack_.freeze ();
02768 return 0;
02769 }
02770 switch (ch)
02771 {
02772 case '\x00': case '\x01': case '\x02': case '\x03': case '\x04':
02773 case '\x05': case '\x06': case '\x07': case '\x08': case '\x09':
02774 case '\x0A': case '\x0B': case '\x0C': case '\x0D': case '\x0E':
02775 case '\x0F': case '\x10': case '\x11': case '\x12': case '\x13':
02776 case '\x14': case '\x15': case '\x16': case '\x17': case '\x18':
02777 case '\x19': case '\x1A': case '\x1B': case '\x1C': case '\x1D':
02778 case '\x1E': case '\x1F': case '\x7F': case '\x20': case '<':
02779 case '>': case '#': case '%':
02780 ACE_ERROR ((LM_ERROR,
02781 ACE_TEXT ("Invalid char %c in SystemLiteral\n"), ch));
02782 return -1;
02783 default:
02784 this->obstack_.grow (ch);
02785 }
02786 }
02787 }
|
|
|
Parse a TextDecl declaration. Definition at line 3143 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, fatal_error(), get(), parse_encoding_decl(), parse_token(), parse_version_info(), and skip_whitespace(). Referenced by parse_external_subset(), and parse_PE_reference().
03144 {
03145 // Read xml
03146 if (this->parse_token (ACE_TEXT("xml")) < 0)
03147 {
03148 this->fatal_error(ACE_TEXT ("Expecting keyword 'xml' in TextDecl")
03149 ACEXML_ENV_ARG_PARAMETER);
03150 ACEXML_CHECK_RETURN (-1);
03151 }
03152
03153 ACEXML_Char fwd = this->skip_whitespace();
03154 // Read version
03155 if (fwd == 'v')
03156 {
03157 this->parse_version_info (ACEXML_ENV_SINGLE_ARG_PARAMETER);
03158 ACEXML_CHECK_RETURN (-1);
03159 fwd = this->skip_whitespace();
03160 }
03161
03162 if (fwd == 'e')
03163 {
03164 this->parse_encoding_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
03165 ACEXML_CHECK_RETURN (-1);
03166 fwd = this->skip_whitespace();
03167 }
03168 else
03169 {
03170 this->fatal_error (ACE_TEXT ("Missing encodingDecl in TextDecl")
03171 ACEXML_ENV_ARG_PARAMETER);
03172 ACEXML_CHECK_RETURN (-1);
03173 }
03174
03175 if (fwd == '?' && this->get() == '>')
03176 return 0;
03177 // All the rules fail. So return an error.
03178 this->fatal_error (ACE_TEXT ("Invalid TextDecl") ACEXML_ENV_ARG_PARAMETER);
03179 ACEXML_CHECK_RETURN (-1);
03180 return -1;
03181 }
|
|
|
Parse a keyword. Definition at line 246 of file Parser.inl. References ACEXML_Char, and get(). Referenced by parse_attlist_decl(), parse_atttype(), parse_cdata(), parse_children_definition(), parse_conditional_section(), parse_defaultdecl(), parse_doctypedecl(), parse_element_decl(), parse_encoding_decl(), parse_entity_decl(), parse_external_id(), parse_notation_decl(), parse_text_decl(), parse_tokenized_type(), parse_version_info(), and parse_xml_decl().
00247 {
00248 if (keyword == 0)
00249 return -1;
00250 const ACEXML_Char* ptr = keyword;
00251 for (; *ptr != 0 && (this->get() == *ptr); ++ptr)
00252 ;
00253 if (*ptr == 0)
00254 return 0;
00255 else
00256 return -1;
00257 }
|
|
|
Parse a tokenized type attribute.
Definition at line 1572 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, fatal_error(), get(), is_whitespace(), parse_token(), and peek(). Referenced by parse_atttype().
01573 {
01574 ACEXML_Char ch = this->get();
01575 switch (ch)
01576 {
01577 case 'I':
01578 if (this->get () == 'D')
01579 {
01580 if (this->peek() != 'R' && this->is_whitespace (this->peek()))
01581 {
01582 // We have successfully identified the type of the
01583 // attribute as ID
01584 // @@ Set up validator as such.
01585 break;
01586 }
01587 if (this->parse_token (ACE_TEXT ("REF")) == 0)
01588 {
01589 if (this->peek() != 'S' && this->is_whitespace (this->peek()))
01590 {
01591 // We have successfully identified the type of
01592 // the attribute as IDREF
01593 // @@ Set up validator as such.
01594 break;
01595 }
01596 else if (this->peek() == 'S'
01597 && this->get() // consume the 'S'
01598 && this->is_whitespace (this->peek()))
01599 {
01600 // We have successfully identified the type of
01601 // the attribute as IDREFS
01602 // @@ Set up validator as such.
01603 break;
01604 }
01605 }
01606 }
01607 // Admittedly, this error message is not precise enough
01608 this->fatal_error(ACE_TEXT ("Expecting keyword `ID', `IDREF', or")
01609 ACE_TEXT ("`IDREFS'") ACEXML_ENV_ARG_PARAMETER);
01610 ACEXML_CHECK_RETURN (-1);
01611 case 'E': // ENTITY or ENTITIES
01612 if (this->parse_token (ACE_TEXT ("NTIT")) == 0)
01613 {
01614 ACEXML_Char nextch = this->get ();
01615 if (nextch == 'Y')
01616 {
01617 // We have successfully identified the type of
01618 // the attribute as ENTITY
01619 // @@ Set up validator as such.
01620 }
01621 else if (this->parse_token (ACE_TEXT ("IES")) == 0)
01622 {
01623 // We have successfully identified the type of
01624 // the attribute as ENTITIES
01625 // @@ Set up validator as such.
01626 }
01627 if (this->is_whitespace (this->peek()))
01628 {
01629 // success
01630 break;
01631 }
01632 }
01633 // Admittedly, this error message is not precise enough
01634 this->fatal_error(ACE_TEXT ("Expecting keyword `ENTITY', or")
01635 ACE_TEXT ("`ENTITIES'") ACEXML_ENV_ARG_PARAMETER);
01636 ACEXML_CHECK_RETURN (-1);
01637 case 'M':
01638 if (this->parse_token (ACE_TEXT ("TOKEN")) == 0)
01639 {
01640 if (this->is_whitespace (this->peek()))
01641 {
01642 // We have successfully identified the type of
01643 // the attribute as NMTOKEN
01644 // @@ Set up validator as such.
01645 break;
01646 }
01647 else if (this->peek() == 'S'
01648 && this->get()
01649 && this->is_whitespace (this->peek()))
01650 {
01651 // We have successfully identified the type of
01652 // the attribute as NMTOKENS
01653 // @@ Set up validator as such.
01654 break;
01655 }
01656 }
01657 this->fatal_error(ACE_TEXT ("Expecting keyword `NMTOKEN' or `NMTO")
01658 ACE_TEXT ("KENS'") ACEXML_ENV_ARG_PARAMETER);
01659 ACEXML_CHECK_RETURN (-1);
01660 break;
01661 default:
01662 this->fatal_error (ACE_TEXT ("Internal Parser Error")
01663 ACEXML_ENV_ARG_PARAMETER);
01664 ACEXML_CHECK_RETURN (-1);
01665 break;
01666 }
01667 return 0;
01668 }
|
|
|
Parse the version string in an XML Prolog section.
|
|
|
Parse VersionInfo declaration. Definition at line 3100 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_ENV_ARG_PARAMETER, fatal_error(), parse_token(), parse_version_num(), skip_equal(), and ACE_OS::strcmp(). Referenced by parse_text_decl(), and parse_xml_decl().
03101 {
03102 ACEXML_Char* astring;
03103 if (this->parse_token (ACE_TEXT("ersion")) < 0
03104 || this->skip_equal () != 0
03105 || this->parse_version_num (astring) != 0)
03106 {
03107 this->fatal_error (ACE_TEXT ("Invalid VersionInfo specification")
03108 ACEXML_ENV_ARG_PARAMETER);
03109 return;
03110 }
03111 if (ACE_OS::strcmp (astring, ACE_TEXT ("1.0")) != 0)
03112 {
03113 this->fatal_error (ACE_TEXT ("ACEXML Parser supports XML version 1.0 ")
03114 ACE_TEXT ("documents only") ACEXML_ENV_ARG_PARAMETER);
03115 return;
03116 }
03117 }
|
|
|
Parse the version number in a VersionInfo declaration. Definition at line 2726 of file Parser.cpp. References ACEXML_Char, ACE_Obstack_T< ACEXML_Char >::freeze(), get(), ACE_Obstack_T< ACEXML_Char >::grow(), and obstack_. Referenced by parse_version_info().
02727 {
02728 ACEXML_Char quote = this->get ();
02729 if (quote != '\'' && quote != '"') // Not a quoted string.
02730 return -1;
02731 int numchars = 0;
02732 while (1)
02733 {
02734 ACEXML_Char ch = this->get ();
02735 if (ch == quote && !numchars)
02736 return -1;
02737 else if (ch == quote)
02738 {
02739 str = this->obstack_.freeze ();
02740 return 0;
02741 }
02742 // [26] VersionNum ::= ([a-zA-Z0-9_.:] | '-')+
02743 if (ch == '-' || ((ch >= 'a' && ch <= 'z') ||
02744 (ch >= 'A' && ch <= 'Z') ||
02745 (ch >= '0' && ch <= '9') ||
02746 (ch == '_' || ch == '.' || ch == ':')))
02747 {
02748 this->obstack_.grow (ch);
02749 numchars++;
02750 }
02751 else
02752 return -1;
02753 }
02754 }
|
|
|
Parse a XMLDecl declaration. Definition at line 3184 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK, ACEXML_ENV_ARG_PARAMETER, ACEXML_ENV_SINGLE_ARG_PARAMETER, fatal_error(), get(), parse_encoding_decl(), parse_sddecl(), parse_token(), parse_version_info(), skip_equal(), skip_whitespace(), standalone_, and ACE_OS::strcmp(). Referenced by parse().
03185 {
03186 // Read <?xml
03187 if (this->parse_token (ACE_TEXT("xml")) < 0)
03188 {
03189 this->fatal_error(ACE_TEXT ("Expecting keyword xml in XMLDecl")
03190 ACEXML_ENV_ARG_PARAMETER);
03191 ACEXML_CHECK;
03192 }
03193
03194 ACEXML_Char fwd = this->skip_whitespace();
03195
03196 // Read version
03197 if (fwd != 'v')
03198 {
03199 this->fatal_error (ACE_TEXT ("Expecting VersionInfo declaration")
03200 ACEXML_ENV_ARG_PARAMETER);
03201 ACEXML_CHECK;
03202 }
03203
03204 this->parse_version_info (ACEXML_ENV_SINGLE_ARG_PARAMETER);
03205 ACEXML_CHECK;
03206
03207 fwd = this->skip_whitespace();
03208 if (fwd != '?')
03209 {
03210 if (fwd == 'e')
03211 {
03212 this->parse_encoding_decl (ACEXML_ENV_SINGLE_ARG_PARAMETER);
03213 ACEXML_CHECK;
03214 fwd = this->skip_whitespace();
03215 }
03216 if (fwd == 's')
03217 {
03218 ACEXML_Char* astring;
03219 if ((this->parse_token (ACE_TEXT("tandalone")) == 0) &&
03220 this->skip_equal () == 0 &&
03221 this->parse_sddecl (astring) == 0)
03222 {
03223 if (ACE_OS::strcmp (astring, ACE_TEXT ("yes")) == 0)
03224 this->standalone_ = 1;
03225 fwd = this->skip_whitespace();
03226 }
03227 }
03228 }
03229 if (fwd == '?' && this->get() == '>')
03230 return;
03231 // All the rules fail. So return an error.
03232 this->fatal_error (ACE_TEXT ("Invalid XMLDecl declaration")
03233 ACEXML_ENV_ARG_PARAMETER);
03234 ACEXML_CHECK;
03235 }
|
|
|
Parse XML Prolog. |
|
|
Peek a character.
Definition at line 234 of file Parser.inl. References ACEXML_Char, ACEXML_InputSource::getCharStream(), ACEXML_Parser_Context::getInputSource(), and ACEXML_CharStream::peek(). Referenced by check_for_PE_reference(), parse(), parse_atttype(), parse_attvalue(), parse_cdata(), parse_char_reference(), parse_child(), parse_children_definition(), parse_content(), parse_defaultdecl(), parse_element_decl(), parse_entity_value(), parse_external_subset(), parse_ignoresect(), parse_includesect(), parse_markup_decl(), parse_name(), parse_nmtoken(), parse_PE_reference(), parse_reference_name(), and parse_tokenized_type().
00235 {
00236 // Using an extra level of indirection so we can
00237 // manage document location in the future.
00238 ACEXML_Char ch = 0;
00239 const ACEXML_InputSource* ip = this->current_->getInputSource();
00240 ACEXML_CharStream* instream = ip->getCharStream();
00241 ch = static_cast<ACEXML_Char> (instream->peek ());
00242 return (ch > 0 ? ch : 0);
00243 }
|
|
|
Pop the top element in the stack and replace current context with that. Definition at line 2941 of file Parser.cpp. References ACE_TEXT, ACEXML_Char, ACEXML_CHECK_RETURN, ACEXML_ENV_ARG_PARAMETER, content_handler_, ctx_stack_, external_entity_, fatal_error(), GE_reference_, PE_reference_, ACE_Unbounded_Stack< ACEXML_Char * >::pop(), ACE_Unbounded_Stack< ACEXML_Parser_Context * >::pop(), ACEXML_ContentHandler::setDocumentLocator(), ACE_Unbounded_Stack< ACEXML_Char * >::size(), ACE_Unbounded_Stack< ACEXML_Parser_Context * >::size(), and ACE_Unbounded_Stack< ACEXML_Parser_Context * >::top(). Referenced by check_for_PE_reference(), parse_attvalue(), parse_conditional_section(), parse_content(), parse_entity_value(), parse_external_subset(), and parse_internal_dtd().
02942 {
02943 size_t nrelems = this->ctx_stack_.size();
02944 if (nrelems <= 1)
02945 {
02946 this->fatal_error(ACE_TEXT ("Unexpected end-of-file")
02947 ACEXML_ENV_ARG_PARAMETER);
02948 ACEXML_CHECK_RETURN (-1);
02949 }
02950
02951 ACEXML_Parser_Context* temp = 0;
02952 int retval = this->ctx_stack_.pop (temp);
02953 if (retval != 0)
02954 {
02955 this->fatal_error (ACE_TEXT ("Unable to pop element of the input stack")
02956 ACEXML_ENV_ARG_PARAMETER);
02957 ACEXML_CHECK_RETURN (-1);
02958 }
02959 delete temp;
02960 if (this->ctx_stack_.top (this->current_) != 0)
02961 {
02962 this->fatal_error (ACE_TEXT ("Unable to read top element of input stack")
02963 ACEXML_ENV_ARG_PARAMETER);
02964 ACEXML_CHECK_RETURN (-1);
02965 }
02966 ACEXML_Char* reference = 0;
02967 if (GE_ref == 1 && this->GE_reference_.size() > 0)
02968 {
02969 if (this->GE_reference_.pop (reference) < 0)
02970 {
02971 this->fatal_error (ACE_TEXT ("Internal Parser Error")
02972 ACEXML_ENV_ARG_PARAMETER);
02973 ACEXML_CHECK_RETURN (-1);
02974 }
02975 }
02976 else if (GE_ref == 0 && this->PE_reference_.size() > 0)
02977 {
02978 if (this->PE_reference_.pop (reference) < 0)
02979 {
02980 this->fatal_error (ACE_TEXT ("Internal Parser Error")
02981 ACEXML_ENV_ARG_PARAMETER);
02982 ACEXML_CHECK_RETURN (-1);
02983 }
02984 }
02985 nrelems = this->ctx_stack_.size();
02986
02987 if (this->external_entity_ && (GE_ref == 0 || GE_ref == 1))
02988 this->external_entity_--;
02989
02990 this->content_handler_->setDocumentLocator (this->current_->getLocator());
02991
02992 return nrelems;
02993 }
|
|
||||||||||||||||
|
Dispatch prefix mapping calls to the ContentHandler.
Definition at line 2876 of file Parser.cpp. References ACEXML_Char, ACEXML_CHECK, ACEXML_ENV_ARG_PARAMETER, content_handler_, empty_string, ACEXML_ContentHandler::endPrefixMapping(), namespaces_, and ACEXML_ContentHandler::startPrefixMapping(). Referenced by parse_content(), and parse_element().
02879 {
02880 if (this->namespaces_)
02881 {
02882 const ACEXML_Char* temp = (prefix == 0) ? empty_string : prefix;
02883 if (start) {
02884 this->content_handler_->startPrefixMapping (temp, uri
02885 ACEXML_ENV_ARG_PARAMETER);
02886 ACEXML_CHECK;
02887 }
02888 else
02889 {
02890 this->content_handler_->endPrefixMapping(temp
02891 ACEXML_ENV_ARG_PARAMETER);
02892 ACEXML_CHECK;
02893 }
02894 }
02895 }
|
|
|
Push the current context on to the stack. Definition at line 2930 of file Parser.cpp. References ACE_ERROR, ctx_stack_, LM_ERROR, and ACE_Unbounded_Stack< ACEXML_Parser_Context * >::push(). Referenced by switch_input().
02931 {
02932 if (this->ctx_stack_.push (context) < 0)
02933 {
02934 ACE_ERROR ((LM_ERROR, "Unable to push input source onto the stack"));
02935 return -1;
02936 }
02937 return 0;
02938 }
|
|
|
|
Allow an application to register a content event handler. Implements ACEXML_XMLReader. Definition at line 36 of file Parser.inl. References content_handler_.
00037 {
00038 this->content_handler_ = handler;
00039 }
|
|
|
Allow an application to register a DTD event handler. Implements ACEXML_XMLReader. Definition at line 42 of file Parser.inl. References dtd_handler_.
00043 {
00044 this->dtd_handler_ = handler;
00045 }
|
|
|
Allow an application to register an entity resolver. Implements ACEXML_XMLReader. Definition at line 48 of file Parser.inl. References entity_resolver_.
00049 {
00050 this->entity_resolver_ = resolver;
00051 }
|
|
|
Allow an application to register an error event handler. Implements ACEXML_XMLReader. Definition at line 54 of file Parser.inl. References error_handler_.
00055 {
00056 this->error_handler_ = handler;
00057 }
|
|
||||||||||||
|
Activating or deactivating a feature. Implements ACEXML_XMLReader. Definition at line 3021 of file Parser.cpp. References ACEXML_Char, ACEXML_THROW, namespace_prefixes_, namespace_prefixes_feature_, namespaces_, namespaces_feature_, simple_parsing_, simple_parsing_feature_, ACE_OS::strcmp(), validate_, and validation_feature_.
03023 {
03024 if (ACE_OS::strcmp (name, ACEXML_Parser::simple_parsing_feature_) == 0)
03025 {
03026 this->simple_parsing_ = (boolean_value == 0 ? 0 : 1);
03027 return;
03028 }
03029 else if (ACE_OS::strcmp (name, ACEXML_Parser::namespaces_feature_) == 0)
03030 {
03031 this->namespaces_ = (boolean_value == 0 ? 0 : 1);
03032 return;
03033 }
03034 else if (ACE_OS::strcmp (name,
03035 ACEXML_Parser::namespace_prefixes_feature_) == 0)
03036 {
03037 this->namespace_prefixes_ = (boolean_value == 0 ? 0 : 1);
03038 return;
03039 }
03040 else if (ACE_OS::strcmp (name, ACEXML_Parser::validation_feature_) == 0)
03041 {
03042 this->validate_ = (boolean_value == 0 ? 0 : 1);
03043 return;
03044 }
03045
03046 ACEXML_THROW (ACEXML_SAXNotRecognizedException (name));
03047 }
|
|
||||||||||||
|
Set the value of a property. Implements ACEXML_XMLReader. Definition at line 3056 of file Parser.cpp. References ACEXML_Char, and ACEXML_THROW.
03058 {
03059 ACE_UNUSED_ARG (value);
03060
03061 ACEXML_THROW (ACEXML_SAXNotSupportedException (name));
03062 }
|
|
|
Skip an equal sign.
Definition at line 196 of file Parser.inl. References get(), is_whitespace(), and skip_whitespace(). Referenced by parse_element(), parse_encoding_decl(), parse_version_info(), and parse_xml_decl().
00197 {
00198 if (this->skip_whitespace() != '=')
00199 return -1;
00200 while (this->is_whitespace (this->peek()))
00201 this->get();
00202 return 0;
00203 }
|
|
|
Skip any whitespaces encountered until the first non-whitespace character is encountered.
Definition at line 174 of file Parser.inl. References ACEXML_Char, get(), and is_whitespace(). Referenced by parse(), parse_children_definition(), parse_conditional_section(), parse_content(), parse_doctypedecl(), parse_element(), parse_element_decl(), parse_entity_decl(), parse_external_subset(), parse_ignoresect(), parse_includesect(), parse_internal_dtd(), parse_notation_decl(), parse_processing_instruction(), parse_text_decl(), parse_xml_decl(), and skip_equal().
00175 {
00176 ACEXML_Char ch = this->get();
00177 while (this->is_whitespace (ch))
00178 ch = this->get ();
00179 return ch;
00180 }
|
|
|
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.
Definition at line 184 of file Parser.inl. References ACEXML_Char, get(), and is_whitespace(). Referenced by check_for_PE_reference(), parse_attlist_decl(), parse_atttype(), parse_child(), parse_conditional_section(), parse_defaultdecl(), parse_doctypedecl(), parse_entity_decl(), and parse_external_id().
00185 {
00186 int wscount = 0;
00187 ACEXML_Char dummy;
00188 ACEXML_Char &forward = (peeky == 0 ? dummy : *peeky);
00189
00190 for (;this->is_whitespace ((forward = this->peek ())); ++wscount)
00191 this->get ();
00192 return wscount;
00193 }
|
|
||||||||||||||||
|
Create a new ACEXML_InputSource from systemId and publicId and replace the current input source with the newly created InputSource. Definition at line 2908 of file Parser.cpp. References ACE_ERROR, ACE_NEW_RETURN, ACEXML_Char, content_handler_, ACEXML_InputSource::getSystemId(), LM_ERROR, push_context(), and ACEXML_ContentHandler::setDocumentLocator().
02911 {
02912 ACEXML_LocatorImpl* locator = 0;
02913 if (!systemId)
02914 systemId = input->getSystemId();
02915 ACE_NEW_RETURN (locator, ACEXML_LocatorImpl (systemId, publicId), -1);
02916 ACEXML_Parser_Context* new_context = 0;
02917 ACE_NEW_RETURN (new_context, ACEXML_Parser_Context(input, locator), -1);
02918 if (this->push_context (new_context) != 0)
02919 {
02920 ACE_ERROR ((LM_ERROR, "Unable to switch input streams"));
02921 delete new_context;
02922 return -1;
02923 }
02924 this->current_ = new_context;
02925 this->content_handler_->setDocumentLocator (this->current_->getLocator());
02926 return 0;
02927 }
|
|
||||||||||||||||
|
Create a new ACEXML_CharStream from systemId and publicId and replace the current input stream with the newly created stream. Definition at line 2898 of file Parser.cpp. References ACE_NEW_RETURN, and ACEXML_Char. Referenced by initialize(), parse_entity_reference(), parse_external_dtd(), and parse_PE_reference().
02901 {
02902 ACEXML_InputSource* input = 0;
02903 ACE_NEW_RETURN (input, ACEXML_InputSource (cstream), -1);
02904 return this->switch_input (input, systemId, publicId);
02905 }
|
|
|
Dispatch warnings to ErrorHandler. Definition at line 3077 of file Parser.cpp. References ACE_NEW_NORETURN, ACEXML_Char, ACEXML_ENV_ARG_PARAMETER, error_handler_, and ACEXML_ErrorHandler::warning(). Referenced by parse(), parse_encoding_decl(), and parse_entity_decl().
03078 {
03079 ACEXML_SAXParseException* exception = 0;
03080 ACE_NEW_NORETURN (exception, ACEXML_SAXParseException (msg));
03081 if (this->error_handler_)
03082 this->error_handler_->warning (*exception ACEXML_ENV_ARG_PARAMETER);
03083 delete exception;
03084 return;
03085 }
|
|
|
Alternative obstack used to hold any strings when the original is in use.
Definition at line 786 of file Parser.h. Referenced by parse_reference_name(), and reset(). |
|
|
Definition at line 757 of file Parser.h. Referenced by getContentHandler(), parse(), parse_cdata(), parse_content(), parse_element(), parse_entity_reference(), parse_processing_instruction(), pop_context(), prefix_mapping(), setContentHandler(), and switch_input(). |
|
|
Stack used to hold the Parser_Context.
Definition at line 767 of file Parser.h. Referenced by pop_context(), push_context(), and reset(). |
|
|
Current parser context.
|
|
|
Document Type.
Definition at line 761 of file Parser.h. Referenced by parse_doctypedecl(), parse_element(), and reset(). |
|
|
Keeping track of the handlers. We do not manage the memory for handlers. Definition at line 755 of file Parser.h. Referenced by getDTDHandler(), parse(), parse_entity_decl(), parse_notation_decl(), and setDTDHandler(). |
|
|
Definition at line 756 of file Parser.h. Referenced by getEntityResolver(), parse_entity_reference(), parse_external_dtd(), parse_PE_reference(), and setEntityResolver(). |
|
|
Definition at line 758 of file Parser.h. Referenced by error(), fatal_error(), getErrorHandler(), setErrorHandler(), and warning(). |
|
|
If set, the document has an external DTD subset.
Definition at line 831 of file Parser.h. Referenced by parse_doctypedecl(), parse_entity_reference(), parse_PE_reference(), and reset(). |
|
|
T => We are parsing an external entity value.
Definition at line 822 of file Parser.h. Referenced by parse_entity_reference(), parse_entity_value(), parse_PE_reference(), pop_context(), and reset(). |
|
|
Set of external parsed general entities in the document.
Definition at line 798 of file Parser.h. Referenced by parse_entity_decl(), parse_entity_reference(), and reset(). |
|
|
Set of external parsed parameter entities in the document.
Definition at line 810 of file Parser.h. Referenced by parse_entity_decl(), parse_PE_reference(), and reset(). |
|
|
T => We are parsing an external subset.
Definition at line 819 of file Parser.h. Referenced by check_for_PE_reference(), parse_external_subset(), and reset(). |
|
|
Set used to hold the general entity references that are active.
Definition at line 777 of file Parser.h. Referenced by parse_entity_reference(), pop_context(), and reset(). |
|
|
T => Internal DTD has parameter entity references.
Definition at line 825 of file Parser.h. Referenced by parse_entity_reference(), parse_internal_dtd(), and reset(). |
|
|
If set, the document has an internal DTD.
Definition at line 834 of file Parser.h. Referenced by parse_doctypedecl(), parse_entity_reference(), and reset(). |
|
|
Set of internal parsed general entities in the document.
Definition at line 795 of file Parser.h. Referenced by parse_entity_decl(), parse_entity_reference(), and reset(). |
|
|
Set of internal parsed parameter entities in the document.
Definition at line 807 of file Parser.h. Referenced by parse_entity_decl(), parse_PE_reference(), and reset(). |
|
|
If set, the parser should include namespace declarations in the list of attributes of an element. Definition at line 848 of file Parser.h. Referenced by getFeature(), parse_element(), and setFeature(). |
|
|
If set, the parser should allow access by namespace qualified names.
Definition at line 844 of file Parser.h. Referenced by getFeature(), parse_content(), parse_element(), prefix_mapping(), and setFeature(). |
|
|
T => We are processing a nested namespace.
Definition at line 792 of file Parser.h. Referenced by parse_content(), parse_element(), and reset(). |
|
|
Set of notations declared in the document.
Definition at line 813 of file Parser.h. Referenced by parse_entity_decl(), parse_notation_decl(), and reset(). |
|
|
Obstack used by the parser to hold all the strings parsed.
Definition at line 783 of file Parser.h. Referenced by parse_attvalue(), parse_cdata(), parse_content(), parse_encname(), parse_entity_reference(), parse_entity_value(), parse_name(), parse_nmtoken(), parse_PE_reference(), parse_processing_instruction(), parse_pubid_literal(), parse_sddecl(), parse_system_literal(), parse_version_num(), and reset(). |
|
|
Set used to hold the parameter entity references that are active.
Definition at line 780 of file Parser.h. Referenced by parse_PE_reference(), pop_context(), and reset(). |
|
|
Set of predefined entities used by the parser.
Definition at line 804 of file Parser.h. Referenced by initialize(), parse_entity_reference(), and reset(). |
|
|
State of the parser when it encounters a reference.
Definition at line 816 of file Parser.h. Referenced by parse_attvalue(), parse_content(), parse_entity_reference(), parse_entity_value(), parse_external_dtd(), parse_external_id(), parse_external_subset(), parse_internal_dtd(), parse_notation_decl(), parse_PE_reference(), and reset(). |
|
|
Feature flags If set, the parser should parse a document without a prolog Definition at line 838 of file Parser.h. Referenced by getFeature(), and setFeature(). |
|
|
If set, the document is a standalone XML document.
Definition at line 828 of file Parser.h. Referenced by parse_entity_reference(), parse_PE_reference(), parse_xml_decl(), and reset(). |
|
|
Set of unparsed entities in the document.
Definition at line 801 of file Parser.h. Referenced by parse_entity_reference(), and reset(). |
|
|
If set, the parser should also validate.
Definition at line 841 of file Parser.h. Referenced by getFeature(), parse(), parse_doctypedecl(), parse_entity_decl(), parse_entity_reference(), parse_external_dtd(), parse_notation_decl(), parse_PE_reference(), and setFeature(). |
|
|
Namespace stack used by the parser to implement support for Namespaces.
Definition at line 789 of file Parser.h. Referenced by initialize(), parse_content(), parse_element(), and reset(). |
1.3.6