(file) Return to XmlParser.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/XmlParser.cpp between version 1.43.2.14 and 1.44

version 1.43.2.14, 2008/04/12 00:14:17 version 1.44, 2008/04/11 18:02:26
Line 172 
Line 172 
     "Unterminated comment",     "Unterminated comment",
     "Unterminated CDATA block",     "Unterminated CDATA block",
     "Unterminated DOCTYPE",     "Unterminated DOCTYPE",
       "Too many attributes: parser only handles 10",
     "Malformed reference",     "Malformed reference",
     "Expected a comment or CDATA following \"<!\" sequence",     "Expected a comment or CDATA following \"<!\" sequence",
     "Closing element does not match opening element",     "Closing element does not match opening element",
     "One or more tags are still open",     "One or more tags are still open",
     "More than one root element was encountered",     "More than one root element was encountered",
     "Validation error",     "Validation error",
     "Semantic error",      "Semantic error"
     "Namespace not declared"  
 }; };
  
 static const char* _xmlKeys[] = static const char* _xmlKeys[] =
Line 193 
Line 193 
     "Common.XmlParser.UNTERMINATED_COMMENT",     "Common.XmlParser.UNTERMINATED_COMMENT",
     "Common.XmlParser.UNTERMINATED_CDATA",     "Common.XmlParser.UNTERMINATED_CDATA",
     "Common.XmlParser.UNTERMINATED_DOCTYPE",     "Common.XmlParser.UNTERMINATED_DOCTYPE",
       "Common.XmlParser.TOO_MANY_ATTRIBUTES",
     "Common.XmlParser.MALFORMED_REFERENCE",     "Common.XmlParser.MALFORMED_REFERENCE",
     "Common.XmlParser.EXPECTED_COMMENT_OR_CDATA",     "Common.XmlParser.EXPECTED_COMMENT_OR_CDATA",
     "Common.XmlParser.START_END_MISMATCH",     "Common.XmlParser.START_END_MISMATCH",
     "Common.XmlParser.UNCLOSED_TAGS",     "Common.XmlParser.UNCLOSED_TAGS",
     "Common.XmlParser.MULTIPLE_ROOTS",     "Common.XmlParser.MULTIPLE_ROOTS",
     "Common.XmlParser.VALIDATION_ERROR",     "Common.XmlParser.VALIDATION_ERROR",
     "Common.XmlParser.SEMANTIC_ERROR",      "Common.XmlParser.SEMANTIC_ERROR"
     "Common.XmlParser.UNDECLARED_NAMESPACE"  
 }; };
  
   // l10n replace _formMessage (comment out the old one)
   /*
   static String _formMessage(Uint32 code, Uint32 line, const String& message)
   {
       String result = _xmlMessages[Uint32(code) - 1];
   
       char buffer[32];
       sprintf(buffer, "%d", line);
       result.append(": on line ");
       result.append(buffer);
   
       if (message.size())
       {
           result.append(": ");
           result.append(message);
       }
   
       return result;
   }
   */
  
 static MessageLoaderParms _formMessage( static MessageLoaderParms _formMessage(
     Uint32 code,     Uint32 code,
Line 308 
Line 328 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 XmlParser::XmlParser(char* text, XmlNamespace* ns)  XmlParser::XmlParser(char* text)
     : _line(1),     : _line(1),
       _current(text),       _current(text),
       _restoreChar('\0'),       _restoreChar('\0'),
       _foundRoot(false),        _foundRoot(false)
       _supportedNamespaces(ns),  
       // Start valid indexes with -2. -1 is reserved for not found.  
       _currentUnsupportedNSType(-2)  
 { {
 } }
  
Line 476 
Line 493 
     // the last character of p, though, if p is an empty string.     // the last character of p, though, if p is an empty string.
     Boolean adjust_q = (p != start) && _isspace(p[-1]);     Boolean adjust_q = (p != start) && _isspace(p[-1]);
  
     // We encountered the end_char or a zero-terminator.      // We encountered a the end_char or a zero-terminator.
   
     *q = *p;     *q = *p;
  
     if (adjust_q)     if (adjust_q)
Line 492 
Line 510 
     }     }
 } }
  
 Boolean XmlParser::next(  Boolean XmlParser::next(XmlEntry& entry, Boolean includeComment)
     XmlEntry& entry,  
     Boolean includeComment)  
 { {
     if (!_putBackStack.isEmpty())     if (!_putBackStack.isEmpty())
     {     {
Line 516 
Line 532 
         _restoreChar = '\0';         _restoreChar = '\0';
     }     }
  
     entry.attributes.clear();  
   
     if (_supportedNamespaces)  
     {  
         // Remove namespaces of a deeper scope level from the stack.  
         while (!_nameSpaces.isEmpty() &&  
                _nameSpaces.top().scopeLevel > _stack.size())  
         {  
             _nameSpaces.pop();  
         }  
     }  
   
     // Loop until we are done with comments if includeComment is false.     // Loop until we are done with comments if includeComment is false.
     do     do
     {     {
Line 596 
Line 600 
         }         }
     } while (!includeComment && entry.type == XmlEntry::COMMENT);     } while (!includeComment && entry.type == XmlEntry::COMMENT);
  
     if (_supportedNamespaces &&  
         (entry.type == XmlEntry::START_TAG ||  
          entry.type == XmlEntry::EMPTY_TAG ||  
          entry.type == XmlEntry::END_TAG))  
     {  
         // Determine the namespace type for this entry  
   
         if (entry.type == XmlEntry::START_TAG ||  
             entry.type == XmlEntry::EMPTY_TAG)  
         {  
             // Process namespace declarations and determine the namespace type  
             // for the attributes.  
   
             Uint32 scopeLevel = _stack.size();  
             if (entry.type == XmlEntry::EMPTY_TAG)  
             {  
                 // Empty tags are deeper scope, but not pushed onto the stack  
                 scopeLevel++;  
             }  
   
             for (unsigned int i = 0; i < entry.attributes.size(); i++)  
             {  
                 XmlAttribute& attr = entry.attributes[i];  
                 if ((strncmp(attr.name, "xmlns:", 6) == 0) ||  
                     (strcmp(attr.name, "xmlns") == 0))  
                 {  
                     // Process a namespace declaration  
                     XmlNamespace ns;  
                     if (attr.name[5] == ':')  
                     {  
                         ns.localName = attr.localName;  
                     }  
                     else  
                     {  
                         // Default name space has no local name  
                         ns.localName = 0;  
                     }  
                     ns.extendedName = attr.value;  
                     ns.scopeLevel = scopeLevel;  
                     ns.type = _getSupportedNamespaceType(ns.extendedName);  
   
                     // If the namespace is not supported, assign it a unique  
                     // negative identifier.  
                     if (ns.type == -1)  
                     {  
                         ns.type = _currentUnsupportedNSType--;  
                     }  
   
                     _nameSpaces.push(ns);  
                 }  
                 else  
                 {  
                     // Get the namespace type for this attribute.  
                     attr.nsType = _getNamespaceType(attr.name);  
                 }  
             }  
         }  
   
         entry.nsType = _getNamespaceType(entry.text);  
     }  
     else  
     {  
         entry.nsType = -1;  
     }  
   
     return true;     return true;
 } }
  
 // Get the namespace type of the given tag  
 int XmlParser::_getNamespaceType(const char* tag)  
 {  
     const char* pos = strchr(tag, ':');  
   
     // If ':' is not found, the tag is not namespace qualified and we  
     // need to look for the default name space.  
   
     // Search the namespace stack from the top  
     for (int i = _nameSpaces.size() - 1; i >=0; i--)  
     {  
         // If ':' is found, look for the name space with the matching  
         // local name...  
         if ((pos && _nameSpaces[i].localName &&  
              !strncmp(_nameSpaces[i].localName, tag, pos - tag)) ||  
             // ... otherwise look for the default name space. It's the  
             // one with localName set to NULL  
             (!pos && !_nameSpaces[i].localName))  
         {  
             return _nameSpaces[i].type;  
         }  
     }  
   
     // If the tag is namespace qualified, but the name space has not been  
     // declared, it's malformed XML and we must throw an exception.  
     // Note:  The "xml" namespace is specifically defined by the W3C as a  
     // reserved prefix ("http://www.w3.org/XML/1998/namespace").  
     if (pos && (strncmp(tag, "xml:", 4) != 0))  
     {  
         throw XmlException(XmlException::UNDECLARED_NAMESPACE, _line);  
     }  
   
     // Otherwise it's OK not to have a name space.  
     return -1;  
 }  
   
 // Given the extended namespace name, find it in the table of supported  
 // namespaces and return its type.  
 int XmlParser::_getSupportedNamespaceType(const char* extendedName)  
 {  
     for (int i = 0;  
          _supportedNamespaces[i].localName != 0;  
          i++)  
     {  
         PEGASUS_ASSERT(_supportedNamespaces[i].type == i);  
         if (!strcmp(_supportedNamespaces[i].extendedName, extendedName))  
         {  
             return _supportedNamespaces[i].type;  
         }  
     }  
     return -1;  
 }  
   
 XmlNamespace* XmlParser::getNamespace(int nsType)  
 {  
     for (int i = _nameSpaces.size() - 1; i >=0; i--)  
     {  
         if (_nameSpaces[i].type == nsType)  
         {  
             return &_nameSpaces[i];  
         }  
     }  
     return 0;  
 }  
   
 void XmlParser::putBack(XmlEntry& entry) void XmlParser::putBack(XmlEntry& entry)
 { {
     _putBackStack.push(entry);     _putBackStack.push(entry);
Line 739 
Line 613 
     // Nothing to do!     // Nothing to do!
 } }
  
 // A-Za-z0-9_-.  (Note that ':' is not included and must be checked separately)  // A-Za-z0-9_-:.
 static unsigned char _isInnerElementChar[] = static unsigned char _isInnerElementChar[] =
 { {
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
     0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,      0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,
     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
     1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,     1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
Line 751 
Line 625 
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 }; };
  
 inline Boolean _getQName(char*& p, const char*& localName)  Boolean XmlParser::_getElementName(char*& p)
 { {
     localName = p;  
   
     if (!CharSet::isAlNumUnder(Uint8(*p)))     if (!CharSet::isAlNumUnder(Uint8(*p)))
         return false;          throw XmlException(XmlException::BAD_START_TAG, _line);
   
     p++;  
   
     while (*p && _isInnerElementChar[Uint8(*p)])  
         p++;  
   
     // We've validated the prefix, now validate the local name  
     if (*p == ':')  
     {  
         localName = ++p;  
   
         if (!CharSet::isAlNumUnder(Uint8(*p)))  
             return false;  
  
         p++;         p++;
  
         while (*p && _isInnerElementChar[Uint8(*p)])         while (*p && _isInnerElementChar[Uint8(*p)])
             p++;             p++;
     }  
   
     return true;  
 }  
   
 Boolean XmlParser::_getElementName(char*& p, const char*& localName)  
 {  
     if (!_getQName(p, localName))  
         throw XmlException(XmlException::BAD_START_TAG, _line);  
  
     // The next character must be a space:     // The next character must be a space:
  
Line 802 
Line 652 
     return false;     return false;
 } }
  
 Boolean XmlParser::_getOpenElementName(  Boolean XmlParser::_getOpenElementName(char*& p, Boolean& openCloseElement)
     char*& p,  
     const char*& localName,  
     Boolean& openCloseElement)  
 { {
     openCloseElement = false;     openCloseElement = false;
  
     if (!_getQName(p, localName))      if (!CharSet::isAlNumUnder(Uint8(*p)))
         throw XmlException(XmlException::BAD_START_TAG, _line);         throw XmlException(XmlException::BAD_START_TAG, _line);
  
       p++;
   
       while (*p && _isInnerElementChar[Uint8(*p)])
           p++;
   
     // The next character must be a space:     // The next character must be a space:
  
     if (_isspace(*p))     if (_isspace(*p))
Line 837 
Line 689 
     return false;     return false;
 } }
  
 void XmlParser::_getAttributeNameAndEqual(char*& p, const char*& localName)  void XmlParser::_getAttributeNameAndEqual(char*& p)
 { {
     if (!_getQName(p, localName))      if (!CharSet::isAlNumUnder((Uint8)*p))
         throw XmlException(XmlException::BAD_ATTRIBUTE_NAME, _line);         throw XmlException(XmlException::BAD_ATTRIBUTE_NAME, _line);
  
       p++;
   
       while (*p && _isInnerElementChar[Uint8(*p)])
           p++;
   
     char* term = p;     char* term = p;
  
     _skipWhitespace(_line, p);     _skipWhitespace(_line, p);
Line 922 
Line 779 
  
 void XmlParser::_getElement(char*& p, XmlEntry& entry) void XmlParser::_getElement(char*& p, XmlEntry& entry)
 { {
       entry.attributeCount = 0;
   
     //--------------------------------------------------------------------------     //--------------------------------------------------------------------------
     // Get the element name (expect one of these: '?', '!', [A-Za-z_])     // Get the element name (expect one of these: '?', '!', [A-Za-z_])
     //--------------------------------------------------------------------------     //--------------------------------------------------------------------------
Line 933 
Line 792 
  
         Boolean openCloseElement = false;         Boolean openCloseElement = false;
  
         if (_getElementName(p, entry.localName))          if (_getElementName(p))
             return;             return;
     }     }
     else if (*p == '!')     else if (*p == '!')
Line 972 
Line 831 
         entry.type = XmlEntry::END_TAG;         entry.type = XmlEntry::END_TAG;
         entry.text = ++p;         entry.text = ++p;
  
         if (!_getElementName(p, entry.localName))          if (!_getElementName(p))
             throw(XmlException(XmlException::BAD_END_TAG, _line));             throw(XmlException(XmlException::BAD_END_TAG, _line));
  
         return;         return;
Line 986 
Line 845 
  
         Boolean openCloseElement = false;         Boolean openCloseElement = false;
  
         if (_getOpenElementName(p, entry.localName, openCloseElement))          if (_getOpenElementName(p, openCloseElement))
         {         {
             if (openCloseElement)             if (openCloseElement)
                 entry.type = XmlEntry::EMPTY_TAG;                 entry.type = XmlEntry::EMPTY_TAG;
Line 1023 
Line 882 
         }         }
  
         XmlAttribute attr;         XmlAttribute attr;
         attr.nsType = -1;  
         attr.name = p;         attr.name = p;
         _getAttributeNameAndEqual(p, attr.localName);          _getAttributeNameAndEqual(p);
  
         // Get the attribute value (e.g., "some value")         // Get the attribute value (e.g., "some value")
         {         {
Line 1069 
Line 927 
  
         _skipWhitespace(_line, p);         _skipWhitespace(_line, p);
  
         entry.attributes.append(attr);          if (entry.attributeCount == XmlEntry::MAX_ATTRIBUTES)
               throw XmlException(XmlException::TOO_MANY_ATTRIBUTES, _line);
   
           entry.attributes[entry.attributeCount++] = attr;
     }     }
 } }
  
Line 1101 
Line 962 
  
     PEGASUS_STD(cout) << '\n';     PEGASUS_STD(cout) << '\n';
  
     for (Uint32 i = 0; i < attributes.size(); i++)      for (Uint32 i = 0; i < attributeCount; i++)
     {     {
         PEGASUS_STD(cout) << "    " << attributes[i].name << "=\"";         PEGASUS_STD(cout) << "    " << attributes[i].name << "=\"";
         _printValue(attributes[i].value);         _printValue(attributes[i].value);
Line 1112 
Line 973 
 const XmlAttribute* XmlEntry::findAttribute( const XmlAttribute* XmlEntry::findAttribute(
     const char* name) const     const char* name) const
 { {
     for (Uint32 i = 0; i < attributes.size(); i++)      for (Uint32 i = 0; i < attributeCount; i++)
     {     {
         if (strcmp(attributes[i].name, name) == 0)         if (strcmp(attributes[i].name, name) == 0)
             return &attributes[i];             return &attributes[i];
Line 1121 
Line 982 
     return 0;     return 0;
 } }
  
 const XmlAttribute* XmlEntry::findAttribute(  
     int nsType,  
     const char* name) const  
 {  
     for (Uint32 i = 0; i < attributes.size(); i++)  
     {  
         if ((attributes[i].nsType == nsType) &&  
             (strcmp(attributes[i].localName, name) == 0))  
         {  
             return &attributes[i];  
         }  
     }  
   
     return 0;  
 }  
   
 // Find first non-whitespace character (set first) and last non-whitespace // Find first non-whitespace character (set first) and last non-whitespace
 // character (set last one past this). For example, consider this string: // character (set last one past this). For example, consider this string:
 // //

Legend:
Removed from v.1.43.2.14  
changed lines
  Added in v.1.44
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2