(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.1.1.1 and 1.17.8.1

version 1.1.1.1, 2001/01/14 19:53:23 version 1.17.8.1, 2002/12/05 01:47:13
Line 1 
Line 1 
 //BEGIN_LICENSE  //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a  // Permission is hereby granted, free of charge, to any person obtaining a copy
 // copy of this software and associated documentation files (the "Software"),  // of this software and associated documentation files (the "Software"), to
 // to deal in the Software without restriction, including without limitation  // deal in the Software without restriction, including without limitation the
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // and/or sell copies of the Software, and to permit persons to whom the  // sell copies of the Software, and to permit persons to whom the Software is
 // Software is furnished to do so, subject to the following conditions:  // furnished to do so, subject to the following conditions:
   //
   // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
   // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
   // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
   // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
   // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
   // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  //==============================================================================
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL  
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  
 // DEALINGS IN THE SOFTWARE.  
 // //
 //END_LICENSE  // Author: Mike Brasher (mbrasher@bmc.com)
 //BEGIN_HISTORY  
 // //
 // Author:  // Modified By:
 // //
 // $Log$  //%/////////////////////////////////////////////////////////////////////////////
 // Revision 1.1.1.1  2001/01/14 19:53:23  mike  
 // Pegasus import  
 //  
 //  
 //END_HISTORY  
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 52 
Line 50 
 //              &quot - full quote //              &quot - full quote
 //              &apos - apostrophe //              &apos - apostrophe
 // //
   //             as well as character (numeric) references:
   
   //              1 - decimal reference for character '1'
   //              1 - hexadecimal reference for character '1'
   //
 //          4. Element names and attribute names take the following form: //          4. Element names and attribute names take the following form:
 // //
 //              [A-Za-z_][A-Za-z_0-9-.:] //              [A-Za-z_][A-Za-z_0-9-.:]
Line 71 
Line 74 
 // //
 // TODO: // TODO:
 // //
   //      ATTN: KS P1 4 Mar 2002. Review the following TODOs to see if there is work.
 //      Handle <!DOCTYPE...> sections which are complicated (containing //      Handle <!DOCTYPE...> sections which are complicated (containing
 //        rules rather than references to files). //        rules rather than references to files).
 // //
 //      Handle reference of this form: "&#913;"  
 //  
 //      Remove newlines from string literals: //      Remove newlines from string literals:
 // //
 //          Example: <xyz x="hello //          Example: <xyz x="hello
Line 83 
Line 85 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
   #include <Pegasus/Common/Config.h>
 #include <cctype> #include <cctype>
 #include <cassert>  
 #include <cstdio> #include <cstdio>
 #include <cstdlib> #include <cstdlib>
 #include <cstring> #include <cstring>
 #include "XmlParser.h" #include "XmlParser.h"
   #include "Logger.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   #define PEGASUS_ARRAY_T XmlEntry
   # include "ArrayImpl.h"
   #undef PEGASUS_ARRAY_T
   
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // Static helper functions // Static helper functions
Line 103 
Line 111 
     for (; *p; p++)     for (; *p; p++)
     {     {
         if (*p == '\n')         if (*p == '\n')
             std::cout << "\\n";              PEGASUS_STD(cout) << "\\n";
         else if (*p == '\r')         else if (*p == '\r')
             std::cout << "\\r";              PEGASUS_STD(cout) << "\\r";
         else if (*p == '\t')         else if (*p == '\t')
             std::cout << "\\t";              PEGASUS_STD(cout) << "\\t";
         else         else
             std::cout << *p;              PEGASUS_STD(cout) << *p;
     }     }
 } }
  
Line 120 
Line 128 
     char replacement;     char replacement;
 }; };
  
   // ATTN: Add support for more entity references
 static EntityReference _references[] = static EntityReference _references[] =
 { {
     { "&amp;", 5, '&' },     { "&amp;", 5, '&' },
Line 195 
Line 204 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 static char* _xmlMessages[] =  static const char* _xmlMessages[] =
 { {
     "Bad opening element",     "Bad opening element",
     "Bad closing element",     "Bad closing element",
Line 225 
Line 234 
     result.append(": on line ");     result.append(": on line ");
     result.append(buffer);     result.append(buffer);
  
     if (message.getLength())      if (message.size())
     {     {
         result.append(": ");         result.append(": ");
         result.append(message);         result.append(message);
Line 266 
Line 275 
 XmlSemanticError::XmlSemanticError( XmlSemanticError::XmlSemanticError(
     Uint32 lineNumber,     Uint32 lineNumber,
     const String& message)     const String& message)
     : XmlException(XmlException::VALIDATION_ERROR, lineNumber, message)      : XmlException(XmlException::SEMANTIC_ERROR, lineNumber, message)
 { {
  
 } }
Line 393 
Line 402 
 Boolean XmlParser::_getElementName(char*& p) Boolean XmlParser::_getElementName(char*& p)
 { {
     if (!isalpha(*p) && *p != '_')     if (!isalpha(*p) && *p != '_')
     {  
         std::cout << __LINE__ << std::endl;  
         throw XmlException(XmlException::BAD_START_TAG, _line);         throw XmlException(XmlException::BAD_START_TAG, _line);
     }  
  
     while (*p &&     while (*p &&
         (isalnum(*p) || *p == '_' || *p == '-' || *p == ':' || *p == '.'))         (isalnum(*p) || *p == '_' || *p == '-' || *p == ':' || *p == '.'))
Line 424 
Line 430 
     openCloseElement = false;     openCloseElement = false;
  
     if (!isalpha(*p) && *p != '_')     if (!isalpha(*p) && *p != '_')
     {  
         std::cout << __LINE__ << std::endl;  
         throw XmlException(XmlException::BAD_START_TAG, _line);         throw XmlException(XmlException::BAD_START_TAG, _line);
     }  
  
     while (*p &&     while (*p &&
         (isalnum(*p) || *p == '_' || *p == '-' || *p == ':' || *p == '.'))         (isalnum(*p) || *p == '_' || *p == '-' || *p == ':' || *p == '.'))
Line 461 
Line 464 
 void XmlParser::_getAttributeNameAndEqual(char*& p) void XmlParser::_getAttributeNameAndEqual(char*& p)
 { {
     if (!isalpha(*p) && *p != '_')     if (!isalpha(*p) && *p != '_')
     {  
         std::cout << __LINE__ << std::endl;  
         throw XmlException(XmlException::BAD_ATTRIBUTE_NAME, _line);         throw XmlException(XmlException::BAD_ATTRIBUTE_NAME, _line);
     }  
  
     while (*p &&     while (*p &&
         (isalnum(*p) || *p == '_' || *p == '-' || *p == ':' || *p == '.'))         (isalnum(*p) || *p == '_' || *p == '-' || *p == ':' || *p == '.'))
Line 475 
Line 475 
     _skipWhitespace(p);     _skipWhitespace(p);
  
     if (*p != '=')     if (*p != '=')
     {  
         std::cout << __LINE__ << std::endl;  
         throw XmlException(XmlException::BAD_ATTRIBUTE_NAME, _line);         throw XmlException(XmlException::BAD_ATTRIBUTE_NAME, _line);
     }  
  
     p++;     p++;
  
Line 492 
Line 489 
     // ATTN-B: handle values contained in semiquotes:     // ATTN-B: handle values contained in semiquotes:
  
     if (*p != '"' && *p != '\'')     if (*p != '"' && *p != '\'')
     {  
         std::cout << __LINE__ << std::endl;  
         throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);         throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);
     }  
  
     char startChar = *p++;     char startChar = *p++;
  
Line 503 
Line 497 
         p++;         p++;
  
     if (*p != startChar)     if (*p != startChar)
     {  
         std::cout << __LINE__ << std::endl;  
         throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);         throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);
     }  
  
     *p++ = '\0';     *p++ = '\0';
 } }
Line 594 
Line 585 
     {     {
         if (*p == '&')         if (*p == '&')
         {         {
             // Look for predefined entity reference:              // Process character or entity reference
  
             Boolean found = false;              Uint16 referenceChar = 0;
               Uint32 referenceLength = 0;
               XmlException::Code code = XmlException::MALFORMED_REFERENCE;
  
             for (Uint32 i = 0; i < _REFERENCES_SIZE; i++)              if (*(p+1) == '#')
             {             {
                 Uint32 length = _references[i].length;                  // Found a character (numeric) reference
                 const char* match = _references[i].match;                  // Determine whether it is decimal or hex
                   if (*(p+2) == 'x')
                   {
                       // Decode a hexadecimal character reference
                       char* q = p+3;
  
                 if (strncmp(p, _references[i].match, length) == 0)                      // At most four digits are allowed, plus trailing ';'
                       Uint32 numDigits;
                       for (numDigits = 0; numDigits < 5; numDigits++, q++)
                 {                 {
                     found = true;                          if (isdigit(*q))
                     *p = _references[i].replacement;                          {
                     char* q = p + length;                              referenceChar = (referenceChar << 4);
                     rem = rem - length + 1;                              referenceChar += (*q - '0');
                     memmove(p + 1, q, rem);                          }
                           else if ((*q >= 'A') && (*q <= 'F'))
                           {
                               referenceChar = (referenceChar << 4);
                               referenceChar += (*q - 'A' + 10);
                           }
                           else if ((*q >= 'a') && (*q <= 'f'))
                           {
                               referenceChar = (referenceChar << 4);
                               referenceChar += (*q - 'a' + 10);
                           }
                           else if (*q == ';')
                           {
                               break;
                           }
                           else
                           {
                               throw XmlException(code, _line);
                 }                 }
             }             }
  
             // If not found, then at least make sure it is well formed:                      // Hex number must be 1 - 4 digits
                       if ((numDigits == 0) || (numDigits > 4))
                       {
                           throw XmlException(code, _line);
                       }
  
             if (!found)                      // ATTN: Currently do not support 16-bit characters
                       if (referenceChar > 0xff)
             {             {
                 char* start = p;                          // ATTN: Is there a good way to say "unsupported"?
                 p++;                          throw XmlException(code, _line);
                       }
  
                 XmlException::Code code = XmlException::MALFORMED_REFERENCE;                      referenceLength = numDigits + 4;
                   }
                   else
                   {
                       // Decode a decimal character reference
                       Uint32 newChar = 0;
                       char* q = p+2;
  
                 if (isalpha(*p) || *p == '_')                      // At most five digits are allowed, plus trailing ';'
                       Uint32 numDigits;
                       for (numDigits = 0; numDigits < 6; numDigits++, q++)
                       {
                           if (isdigit(*q))
                 {                 {
                     for (p++; *p && *p != ';'; p++)                              newChar = (newChar * 10);
                               newChar += (*q - '0');
                           }
                           else if (*q == ';')
                           {
                               break;
                           }
                           else
                     {                     {
                         if (!isalnum(*p) && *p != '_')  
                             throw XmlException(code, _line);                             throw XmlException(code, _line);
                     }                     }
                 }                 }
                 else if (*p == '#')  
                       // Decimal number must be 1 - 5 digits and fit in 16 bits
                       if ((numDigits == 0) || (numDigits > 5) ||
                           (newChar > 0xffff))
                 {                 {
                     for (p++ ; *p && *p != ';'; p++)                          throw XmlException(code, _line);
                       }
   
                       // ATTN: Currently do not support 16-bit characters
                       if (newChar > 0xff)
                     {                     {
                         if (!isdigit(*p))                          // ATTN: Is there a good way to say "unsupported"?
                             throw XmlException(code, _line);                             throw XmlException(code, _line);
                     }                     }
   
                       referenceChar = Uint16(newChar);
                       referenceLength = numDigits + 4;
                   }
               }
               else
               {
                   // Check for entity reference
                   // ATTN: Inefficient if many entity references are supported
                   Uint32 i;
                   for (i = 0; i < _REFERENCES_SIZE; i++)
                   {
                       Uint32 length = _references[i].length;
                       const char* match = _references[i].match;
   
                       if (strncmp(p, _references[i].match, length) == 0)
                       {
                           referenceChar = _references[i].replacement;
                           referenceLength = length;
                           break;
                       }
                 }                 }
  
                 if (*p != ';')                  if (i == _REFERENCES_SIZE)
                   {
                       // Didn't recognize the entity reference
                       // ATTN: Is there a good way to say "unsupported"?
                     throw XmlException(code, _line);                     throw XmlException(code, _line);
   
                 rem -= p - start;  
             }             }
         }         }
   
               // Replace the reference with the correct character
               *p = (char)referenceChar;
               char* q = p + referenceLength;
               rem = rem - referenceLength + 1;
               memmove(p + 1, q, rem);
           }
     }     }
 } }
  
Line 705 
Line 779 
         entry.text = ++p;         entry.text = ++p;
  
         if (!_getElementName(p))         if (!_getElementName(p))
         {  
             std::cout << __LINE__ << std::endl;  
             throw(XmlException(XmlException::BAD_END_TAG, _line));             throw(XmlException(XmlException::BAD_END_TAG, _line));
         }  
  
         return;         return;
     }     }
Line 727 
Line 798 
         }         }
     }     }
     else     else
     {  
         std::cout << __LINE__ << std::endl;  
         throw XmlException(XmlException::BAD_START_TAG, _line);         throw XmlException(XmlException::BAD_START_TAG, _line);
     }  
  
     //--------------------------------------------------------------------------     //--------------------------------------------------------------------------
     // Grab all the attributes:     // Grab all the attributes:
Line 763 
Line 831 
         _getAttributeNameAndEqual(p);         _getAttributeNameAndEqual(p);
  
         if (*p != '"' && *p != '\'')         if (*p != '"' && *p != '\'')
         {  
             std::cout << __LINE__ << std::endl;  
             throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);             throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);
         }  
  
         attr.value = p + 1;         attr.value = p + 1;
         _getAttributeValue(p);         _getAttributeValue(p);
Line 777 
Line 842 
  
             if (!(p[0] == '?' && p[1] == '>') && !isspace(*p))             if (!(p[0] == '?' && p[1] == '>') && !isspace(*p))
             {             {
                 std::cout << __LINE__ << std::endl;  
                 throw XmlException(                 throw XmlException(
                     XmlException::BAD_ATTRIBUTE_VALUE, _line);                     XmlException::BAD_ATTRIBUTE_VALUE, _line);
             }             }
Line 786 
Line 850 
         {         {
             // The next thing must be a space or a '>':             // The next thing must be a space or a '>':
  
             std::cout << __LINE__ << std::endl;  
             throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);             throw XmlException(XmlException::BAD_ATTRIBUTE_VALUE, _line);
         }         }
  
Line 814 
Line 877 
  
 void XmlEntry::print() const void XmlEntry::print() const
 { {
     std::cout << "=== " << _typeStrings[type] << " ";      PEGASUS_STD(cout) << "=== " << _typeStrings[type] << " ";
  
     Boolean needQuotes = type == XmlEntry::CDATA || type == XmlEntry::CONTENT;     Boolean needQuotes = type == XmlEntry::CDATA || type == XmlEntry::CONTENT;
  
     if (needQuotes)     if (needQuotes)
         std::cout << "\"";          PEGASUS_STD(cout) << "\"";
  
     _printValue(text);     _printValue(text);
  
     if (needQuotes)     if (needQuotes)
         std::cout << "\"";          PEGASUS_STD(cout) << "\"";
  
     std::cout << '\n';      PEGASUS_STD(cout) << '\n';
  
     for (Uint32 i = 0; i < attributeCount; i++)     for (Uint32 i = 0; i < attributeCount; i++)
     {     {
         std::cout << "    " << attributes[i].name << "=\"";          PEGASUS_STD(cout) << "    " << attributes[i].name << "=\"";
         _printValue(attributes[i].value);         _printValue(attributes[i].value);
         std::cout << "\"" << std::endl;          PEGASUS_STD(cout) << "\"" << PEGASUS_STD(endl);
     }     }
 } }
  
Line 948 
Line 1011 
     return true;     return true;
 } }
  
   void XmlAppendCString(Array<Sint8>& out, const char* str)
   {
       out.append(str, strlen(str));
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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