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

Diff for /pegasus/src/Pegasus/Common/XmlReader.cpp between version 1.70 and 1.86

version 1.70, 2002/08/25 06:43:56 version 1.86, 2003/08/12 17:51:08
Line 45 
Line 45 
 #include "CIMInstance.h" #include "CIMInstance.h"
 #include "CIMObject.h" #include "CIMObject.h"
 #include "CIMParamValue.h" #include "CIMParamValue.h"
   #include "System.h"
   #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
   #include "OS400ConvertChar.h"
   #endif
   // l10n
   #include <Pegasus/Common/MessageLoader.h>
  
 //#define PEGASUS_SINT64_MIN (-PEGASUS_SINT64_LITERAL(9223372036854775808))  #define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000))
 //#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(18446744073709551615)  #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)
 #define PEGASUS_SINT64_MIN (-PEGASUS_SINT64_LITERAL((Sint64) 0x8000000000000000))  
 #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL((Uint64) 0xFFFFFFFFFFFFFFFF)  
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 75 
Line 79 
         entry.type != XmlEntry::XML_DECLARATION ||         entry.type != XmlEntry::XML_DECLARATION ||
         strcmp(entry.text, "xml") != 0)         strcmp(entry.text, "xml") != 0)
     {     {
         throw XmlValidationError(parser.getLine(),  
             "Expected <?xml ... ?> style declaration");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Expected <?xml ... ?> style declaration");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE",
                                    "Expected $0 style declaration",
                                    "<?xml ... ?>");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     if (!entry.getAttributeValue("version", xmlVersion))      if (!entry.getAttributeValue("version", xmlVersion)) {
         throw XmlValidationError(  
             parser.getLine(), "missing xml.version attribute");        // l10n
   
         // throw XmlValidationError(
         //   parser.getLine(), "missing xml.version attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "missing $0 attribute",
                                    "xml.version");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
  
     if (!entry.getAttributeValue("encoding", xmlEncoding))     if (!entry.getAttributeValue("encoding", xmlEncoding))
     {     {
Line 125 
Line 149 
         entry.type != XmlEntry::START_TAG ||         entry.type != XmlEntry::START_TAG ||
         strcmp(entry.text, tagName) != 0)         strcmp(entry.text, tagName) != 0)
     {     {
         char message[MESSAGE_SIZE];        // l10n
         sprintf(message, "Expected open of %s element", tagName);  
         throw XmlValidationError(parser.getLine(), message);        // char message[MESSAGE_SIZE];
         // sprintf(message, "Expected open of %s element", tagName);
         // throw XmlValidationError(parser.getLine(), message);
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",
                                    "Expected open of $0 element",
                                    tagName);
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
Line 145 
Line 177 
         entry.type != XmlEntry::END_TAG ||         entry.type != XmlEntry::END_TAG ||
         strcmp(entry.text, tagName) != 0)         strcmp(entry.text, tagName) != 0)
     {     {
         char message[MESSAGE_SIZE];  
         sprintf(message, "Expected close of %s element, got %s instead",        // l10n
   
         // char message[MESSAGE_SIZE];
         // sprintf(message, "Expected close of %s element, got %s instead",
         //     tagName,entry.text);
         // throw XmlValidationError(parser.getLine(), message);
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLOSE",
                                    "Expected close of $0 element, got $1 instead",
               tagName,entry.text);               tagName,entry.text);
         throw XmlValidationError(parser.getLine(), message);  
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
Line 168 
Line 209 
         entry.type != XmlEntry::EMPTY_TAG) ||         entry.type != XmlEntry::EMPTY_TAG) ||
         strcmp(entry.text, tagName) != 0)         strcmp(entry.text, tagName) != 0)
     {     {
         char message[MESSAGE_SIZE];        // l10n
         sprintf(message,  
             "Expected either open or open/close %s element", tagName);        // char message[MESSAGE_SIZE];
         throw XmlValidationError(parser.getLine(), message);        // sprintf(message,
         //   "Expected either open or open/close %s element", tagName);
         // throw XmlValidationError(parser.getLine(), message);
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPENCLOSE",
                                    "Expected either open or open/close $0 element",
                                    tagName);
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
Line 189 
Line 238 
         (entry.type != XmlEntry::CONTENT &&         (entry.type != XmlEntry::CONTENT &&
         entry.type != XmlEntry::CDATA))         entry.type != XmlEntry::CDATA))
     {     {
         throw XmlValidationError(parser.getLine(),        // l10n
             "Expected content of CDATA");  
         // throw XmlValidationError(parser.getLine(),
         //               "Expected content of CDATA");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA",
                                    "Expected content of $0", "CDATA");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     return true;     return true;
Line 302 
Line 359 
     XmlEntry entry;     XmlEntry entry;
     XmlReader::expectStartTag(parser, entry, "CIM");     XmlReader::expectStartTag(parser, entry, "CIM");
  
     if (!entry.getAttributeValue("CIMVERSION", cimVersion))      if (!entry.getAttributeValue("CIMVERSION", cimVersion)) {
         throw XmlValidationError(  
             parser.getLine(), "missing CIM.CIMVERSION attribute");        // l10n
   
     if (!entry.getAttributeValue("DTDVERSION", dtdVersion))        // throw XmlValidationError(
         throw XmlValidationError(        //   parser.getLine(), "missing CIM.CIMVERSION attribute");
             parser.getLine(), "missing CIM.DTDVERSION attribute");  
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "missing $0 attribute",
                                    "CIM.CIMVERSION");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
   
       if (!entry.getAttributeValue("DTDVERSION", dtdVersion)){
   
         // l10n
   
         // throw XmlValidationError(
         //   parser.getLine(), "missing CIM.DTDVERSION attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "missing $0 attribute",
                                    "CIM.DTDVERSION");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 319 
Line 396 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 String XmlReader::getCimNameAttribute(  CIMName XmlReader::getCimNameAttribute(
     Uint32 lineNumber,     Uint32 lineNumber,
     const XmlEntry& entry,     const XmlEntry& entry,
     const char* elementName,     const char* elementName,
Line 329 
Line 406 
  
     if (!entry.getAttributeValue("NAME", name))     if (!entry.getAttributeValue("NAME", name))
     {     {
   
           // l10n
   
           // char buffer[MESSAGE_SIZE];
           // sprintf(buffer, "missing %s.NAME attribute", elementName);
           // throw XmlValidationError(lineNumber, buffer);
   
         char buffer[MESSAGE_SIZE];         char buffer[MESSAGE_SIZE];
         sprintf(buffer, "missing %s.NAME attribute", elementName);          sprintf(buffer, "%s.NAME", elementName);
         throw XmlValidationError(lineNumber, buffer);          MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                      "missing $0 attribute",
                                      buffer);
   
           throw XmlValidationError(lineNumber, mlParms);
     }     }
  
     if (acceptNull && name.size() == 0)     if (acceptNull && name.size() == 0)
         return name;          return CIMName ();
  
     if (!CIMName::legal(name))     if (!CIMName::legal(name))
     {     {
   #ifdef PEGASUS_SNIA_INTEROP_TEST
       // In testing, replace illegal CIMName with this value to avoid the
       // exception and let xml parsing continue.  THIS IS TEMP.
       name = "BADNAMESUBSTITUTEDBYPEGASUSCLIENT";
   #else
   
       // l10n
   
       // char buffer[MESSAGE_SIZE];
       // sprintf(buffer, "Illegal value for %s.NAME attribute", elementName);
       // throw XmlSemanticError(lineNumber, buffer);
   
         char buffer[MESSAGE_SIZE];         char buffer[MESSAGE_SIZE];
         sprintf(buffer, "Illegal value for %s.NAME attribute", elementName);      sprintf(buffer, "%s.NAME", elementName);
         throw XmlSemanticError(lineNumber, buffer);  
     }  
  
     return name;      MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
                                  "Illegal value for $0 attribute",
                                  buffer);
   
       throw XmlSemanticError(lineNumber, mlParms);
   
   #endif
       }
       return CIMName (name);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 364 
Line 470 
  
     if (!entry.getAttributeValue("CLASSNAME", name))     if (!entry.getAttributeValue("CLASSNAME", name))
     {     {
   
   
         // l10n
   
         // char buffer[MESSAGE_SIZE];
         // sprintf(buffer, "missing %s.CLASSNAME attribute", elementName);
         // throw XmlValidationError(lineNumber, buffer);
   
         char buffer[MESSAGE_SIZE];         char buffer[MESSAGE_SIZE];
         sprintf(buffer, "missing %s.CLASSNAME attribute", elementName);        sprintf(buffer, "%s.CLASSNAME", elementName);
         throw XmlValidationError(lineNumber, buffer);  
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "missing $0 attribute",
                                    buffer);
   
         throw XmlValidationError(lineNumber, mlParms);
   
     }     }
  
     if (!CIMName::legal(name))     if (!CIMName::legal(name))
     {     {
         // l10n
   
         // char buffer[MESSAGE_SIZE];
         // sprintf(buffer,
         //   "Illegal value for %s.CLASSNAME attribute", elementName);
         // throw XmlSemanticError(lineNumber, buffer);
   
         char buffer[MESSAGE_SIZE];         char buffer[MESSAGE_SIZE];
         sprintf(buffer,        sprintf(buffer, "%s.CLASSNAME", elementName);
             "Illegal value for %s.CLASSNAME attribute", elementName);  
         throw XmlSemanticError(lineNumber, buffer);        MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
                                    "Illegal value for $0 attribute",
                                    buffer);
   
         throw XmlSemanticError(lineNumber, mlParms);
   
     }     }
  
     return name;     return name;
Line 398 
Line 530 
     if (!entry.getAttributeValue("CLASSORIGIN", name))     if (!entry.getAttributeValue("CLASSORIGIN", name))
         return CIMName();         return CIMName();
  
       // KS 200209 This may be temp but we are adding test for form
       // CLASSNAME = "" for Wbemservices interoperability.  Returns same
       // as if attribute did not exist.
       if (name.size() == 0)
           return CIMName();
   
     if (!CIMName::legal(name))     if (!CIMName::legal(name))
     {     {
         // l10n
   
         // char buffer[MESSAGE_SIZE];
         // sprintf(buffer,
         //    "Illegal value for %s.CLASSORIGIN attribute", tagName);
         // throw XmlSemanticError(lineNumber, buffer);
   
         char buffer[MESSAGE_SIZE];         char buffer[MESSAGE_SIZE];
         sprintf(buffer,        sprintf(buffer, "%s.CLASSORIGIN", tagName);
             "Illegal value for %s.CLASSORIGIN attribute", tagName);  
         throw XmlSemanticError(lineNumber, buffer);        MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
                                    "Illegal value for $0 attribute",
                                    buffer);
   
         throw XmlSemanticError(lineNumber, mlParms);
     }     }
  
     return name;     return name;
Line 429 
Line 578 
  
     if (!CIMName::legal(name))     if (!CIMName::legal(name))
     {     {
   #ifdef PEGASUS_SNIA_INTEROP_TEST
       name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME";
       return name;
   #endif
   
       // l10n
   
       // char buffer[MESSAGE_SIZE];
       // sprintf(buffer,
       //     "Illegal value for %s.REFERENCECLASS attribute", elementName);
       // throw XmlSemanticError(lineNumber, buffer);
   
         char buffer[MESSAGE_SIZE];         char buffer[MESSAGE_SIZE];
         sprintf(buffer,      sprintf(buffer, "%s.REFERENCECLASS", elementName);
             "Illegal value for %s.REFERENCECLASS attribute", elementName);  
         throw XmlSemanticError(lineNumber, buffer);      MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
                                  "Illegal value for $0 attribute",
                                  buffer);
   
       throw XmlSemanticError(lineNumber, mlParms);
     }     }
  
     return name;     return name;
Line 458 
Line 623 
  
     if (!CIMName::legal(superClass))     if (!CIMName::legal(superClass))
     {     {
   
         // l10n
   
         // char buffer[MESSAGE_SIZE];
         // sprintf(
         //   buffer, "Illegal value for %s.SUPERCLASS attribute", tagName);
         // throw XmlSemanticError(lineNumber, buffer);
   
         char buffer[MESSAGE_SIZE];         char buffer[MESSAGE_SIZE];
         sprintf(        sprintf(buffer, "%s.SUPERCLASS", tagName);
             buffer, "Illegal value for %s.SUPERCLASS attribute", tagName);  
         throw XmlSemanticError(lineNumber, buffer);        MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
                                    "Illegal value for $0 attribute",
                                    buffer);
   
         throw XmlSemanticError(lineNumber, mlParms);
     }     }
  
     return superClass;     return superClass;
Line 499 
Line 676 
     {     {
         if (required)         if (required)
         {         {
   
             // l10n
   
             // char message[MESSAGE_SIZE];
             // sprintf(message, "missing %s.%s attribute", tagName, attributeName);
             // throw XmlValidationError(lineNumber, message);
   
             char message[MESSAGE_SIZE];             char message[MESSAGE_SIZE];
             sprintf(message, "missing %s.%s attribute", tagName, attributeName);            sprintf(message, "%s.%s", tagName, attributeName);
             throw XmlValidationError(lineNumber, message);  
             MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                        "missing $0 attribute",
                                        message);
   
             throw XmlValidationError(lineNumber, mlParms);
   
         }         }
         else         else
         {         {
Line 548 
Line 738 
         ((type == CIMTYPE_REFERENCE) &&         ((type == CIMTYPE_REFERENCE) &&
          (strcmp(attributeName, "PARAMTYPE") != 0)))          (strcmp(attributeName, "PARAMTYPE") != 0)))
     {     {
         char message[MESSAGE_SIZE];        // l10n
         sprintf(message, "Illegal value for %s.%s attribute", tagName,  
                 attributeName);        // char message[MESSAGE_SIZE];
         throw XmlSemanticError(lineNumber, message);        // sprintf(message, "Illegal value for %s.%s attribute", tagName,
         //       attributeName);
         // throw XmlSemanticError(lineNumber, message);
   
         char buffer[MESSAGE_SIZE];
         sprintf(buffer, "%s.%s", tagName, attributeName);
   
         MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
                                    "Illegal value for $0 attribute",
                                    buffer);
   
         throw XmlSemanticError(lineNumber, mlParms);
     }     }
  
     cimType = type;     cimType = type;
Line 579 
Line 780 
         if (!required)         if (!required)
             return defaultValue;             return defaultValue;
  
           // l10n
   
           // char buffer[62];
           // sprintf(buffer, "missing required %s.%s attribute",
           // attributeName, tagName);
   
           // throw XmlValidationError(lineNumber, buffer);
   
         char buffer[62];         char buffer[62];
         sprintf(buffer, "missing required %s.%s attribute",          sprintf(buffer, "%s.%s", attributeName, tagName);
             attributeName, tagName);  
           MessageLoaderParms mlParms("Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",
                                      "missing required $0 attribute",
                                      buffer);
  
         throw XmlValidationError(lineNumber, buffer);          throw XmlValidationError(lineNumber, mlParms);
     }     }
  
     if (strcmp(tmp, "true") == 0)     if (strcmp(tmp, "true") == 0)
Line 591 
Line 803 
     else if (strcmp(tmp, "false") == 0)     else if (strcmp(tmp, "false") == 0)
         return false;         return false;
  
       // l10n
   
       // char buffer[62];
       // sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName);
       // throw XmlSemanticError(lineNumber, buffer);
   
     char buffer[62];     char buffer[62];
     sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName);      sprintf(buffer, "%s.%s", attributeName, tagName);
     throw XmlSemanticError(lineNumber, buffer);  
       MessageLoaderParms mlParms("Common.XmlReader.INVALID_ATTRIBUTE",
                                  "Invalid $0 attribute value",
                                  buffer);
   
       throw XmlSemanticError(lineNumber, mlParms);
   
     return false;     return false;
 } }
  
Line 695 
Line 919 
     return n;     return n;
 } }
  
   // See http://www.ietf.org/rfc/rfc2396.txt section 2
   String XmlReader::decodeURICharacters(String uriString)
   {
       String decodedString;
       Uint32 i;
   
       for (i=0; i<uriString.size(); i++)
       {
           if (uriString[i] == '%')
           {
               if (i+2 >= uriString.size())
               {
                 // l10n
   
                 // throw ParseError("Invalid URI encoding");
   
                 MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING",
                                            "Invalid $0 encoding", "URI");
   
                 throw ParseError(MessageLoader::getMessage(mlParms));
   
               }
   
               Uint8 digit1 = _hexCharToNumeric(char(uriString[++i]));
               Uint8 digit2 = _hexCharToNumeric(char(uriString[++i]));
               if ( (digit1 > 15) || (digit2 > 15) )
               {
                 // l10n
   
                 // throw ParseError("Invalid URI encoding");
   
                 MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING",
                                            "Invalid $0 encoding", "URI");
   
                 throw ParseError(MessageLoader::getMessage(mlParms));
               }
   
               // ATTN: Handle non-UTF-8 character sets
               Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);
               decodedString.append(Char16(decodedChar));
           }
           else
           {
               decodedString.append(uriString[i]);
           }
       }
   
       return decodedString;
   }
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // stringToSignedInteger // stringToSignedInteger
Line 941 
Line 1215 
     {     {
         case CIMTYPE_BOOLEAN:         case CIMTYPE_BOOLEAN:
         {         {
             if (CompareNoCase(valueString, "TRUE") == 0)              if (System::strcasecmp(valueString, "TRUE") == 0)
                 return CIMValue(true);                 return CIMValue(true);
             else if (CompareNoCase(valueString, "FALSE") == 0)              else if (System::strcasecmp(valueString, "FALSE") == 0)
                 return CIMValue(false);                 return CIMValue(false);
             else              else {
                 throw XmlSemanticError(  
                     lineNumber, "Invalid boolean value");                // l10n
   
                 //  throw XmlSemanticError(
                 //             lineNumber, "Invalid boolean value");
   
                 MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",
                                            "Invalid $0 value",
                                            "boolean");
   
                 throw XmlSemanticError(lineNumber, mlParms);
   
               }
         }         }
  
         case CIMTYPE_STRING:         case CIMTYPE_STRING:
         {         {
             return CIMValue(String(valueString));              return CIMValue(String(valueString, STRING_FLAG_UTF8));
         }         }
  
         case CIMTYPE_CHAR16:         case CIMTYPE_CHAR16:
         {         {
             if (strlen(valueString) != 1)            if (strlen(valueString) != 1) {
                 throw XmlSemanticError(lineNumber, "Invalid char16 value");  
               // l10n
   
               // throw XmlSemanticError(lineNumber, "Invalid char16 value");
   
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",
                                          "Invalid $0 value",
                                          "char16");
   
               throw XmlSemanticError(lineNumber, mlParms);
             }
  
             return CIMValue(Char16(valueString[0]));             return CIMValue(Char16(valueString[0]));
         }         }
Line 972 
Line 1267 
  
             if (!stringToUnsignedInteger(valueString, x))             if (!stringToUnsignedInteger(valueString, x))
             {             {
                 throw XmlSemanticError(  
                     lineNumber, "Invalid unsigned integer value");                // l10n
   
                 // throw XmlSemanticError(
                 //   lineNumber, "Invalid unsigned integer value");
   
                 MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",
                                            "Invalid $0 value",
                                            "unsigned integer");
   
                 throw XmlSemanticError(lineNumber, mlParms);
   
             }             }
  
             switch (type)             switch (type)
Line 982 
Line 1287 
                 {                 {
                     if (x >= (Uint64(1)<<8))                     if (x >= (Uint64(1)<<8))
                     {                     {
                         throw XmlSemanticError(  
                             lineNumber, "Uint8 value out of range");                        // l10n
   
                         // throw XmlSemanticError(
                         //   lineNumber, "Uint8 value out of range");
   
                         MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",
                                                    "$0 value out of range",
                                                    "Uint8");
   
                         throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
                     return CIMValue(Uint8(x));                     return CIMValue(Uint8(x));
                 }                 }
Line 991 
Line 1305 
                 {                 {
                     if (x >= (Uint64(1)<<16))                     if (x >= (Uint64(1)<<16))
                     {                     {
                         throw XmlSemanticError(  
                             lineNumber, "Uint16 value out of range");                        // l10n
   
                         // throw XmlSemanticError(
                         //             lineNumber, "Uint16 value out of range");
   
                         MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",
                                                    "$0 value out of range",
                                                    "Uint16");
   
                         throw XmlSemanticError(lineNumber, mlParms);
   
                     }                     }
                     return CIMValue(Uint16(x));                     return CIMValue(Uint16(x));
                 }                 }
Line 1000 
Line 1324 
                 {                 {
                     if (x >= (Uint64(1)<<32))                     if (x >= (Uint64(1)<<32))
                     {                     {
                         throw XmlSemanticError(  
                             lineNumber, "Uint32 value out of range");                        // l10n
   
                         // throw XmlSemanticError(
                         //   lineNumber, "Uint32 value out of range");
   
                         MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",
                                                    "$0 value out of range",
                                                    "Uint32");
   
                         throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
                     return CIMValue(Uint32(x));                     return CIMValue(Uint32(x));
                 }                 }
Line 1019 
Line 1352 
  
             if (!stringToSignedInteger(valueString, x))             if (!stringToSignedInteger(valueString, x))
             {             {
                 throw XmlSemanticError(  
                     lineNumber, "Invalid signed integer value");                // l10n
   
                 // throw XmlSemanticError(
                 //   lineNumber, "Invalid signed integer value");
   
                 MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",
                                            "Invalid $0 value",
                                            "signed integer");
   
                 throw XmlSemanticError(lineNumber, mlParms);
   
             }             }
  
             switch (type)             switch (type)
Line 1029 
Line 1372 
                 {                 {
                     if(  (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )                     if(  (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )
                     {                     {
                         throw XmlSemanticError(  
                             lineNumber, "Sint8 value out of range");                        // l10n
   
                         // throw XmlSemanticError(
                         //   lineNumber, "Sint8 value out of range");
   
                         MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",
                                                    "$0 value out of range",
                                                    "Sint8");
   
                         throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
                     return CIMValue(Sint8(x));                     return CIMValue(Sint8(x));
                 }                 }
Line 1038 
Line 1390 
                 {                 {
                     if(  (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )                     if(  (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )
                     {                     {
                         throw XmlSemanticError(  
                             lineNumber, "Sint16 value out of range");                        // l10n
   
                         // throw XmlSemanticError(
                         //   lineNumber, "Sint16 value out of range");
   
                         MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",
                                                    "$0 value out of range",
                                                    "Sint16");
   
                         throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
                     return CIMValue(Sint16(x));                     return CIMValue(Sint16(x));
                 }                 }
Line 1047 
Line 1408 
                 {                 {
                     if(  (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )                     if(  (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )
                     {                     {
                         throw XmlSemanticError(  
                             lineNumber, "Sint32 value out of range");                        // l10n
   
                         // throw XmlSemanticError(
                         //   lineNumber, "Sint32 value out of range");
   
                         MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",
                                                    "$0 value out of range",
                                                    "Sint32");
   
                         throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
                     return CIMValue(Sint32(x));                     return CIMValue(Sint32(x));
                 }                 }
Line 1063 
Line 1433 
  
             try             try
             {             {
               // KS 20021002 - Exception if no datatime value. Test for
               // zero length and leave the NULL value in the variable
               // Bugzilla 137  Adds the following if line.
               // Expect this to become permanent but test only for now
   #ifdef PEGASUS_SNIA_INTEROP_TEST
               if (strlen(valueString) != 0)
   #endif
                 tmp.set(valueString);                 tmp.set(valueString);
             }             }
             catch (InvalidDateTimeFormatException&)             catch (InvalidDateTimeFormatException&)
             {             {
                 throw XmlSemanticError(lineNumber, "Invalid datetime value");  
                 // l10n
   
                 // throw XmlSemanticError(lineNumber, "Invalid datetime value");
   
                 MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",
                                            "Invalid $0 value",
                                            "datetime");
   
                 throw XmlSemanticError(lineNumber, mlParms);
             }             }
  
             return CIMValue(tmp);             return CIMValue(tmp);
Line 1077 
Line 1463 
         {         {
             Real64 x;             Real64 x;
  
             if (!stringToReal(valueString, x))              if (!stringToReal(valueString, x)) {
                 throw XmlSemanticError(lineNumber, "Invalid real number value");  
                 // l10n
  
                 // throw XmlSemanticError(lineNumber, "Invalid real number value");
   
                 MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",
                                            "Invalid $0 value",
                                            "real number");
   
                 throw XmlSemanticError(lineNumber, mlParms);
               }
             return CIMValue(Real32(x));             return CIMValue(Real32(x));
         }         }
  
Line 1087 
Line 1482 
         {         {
             Real64 x;             Real64 x;
  
             if (!stringToReal(valueString, x))              if (!stringToReal(valueString, x)) {
                 throw XmlSemanticError(lineNumber, "Invalid real number value");  
                 // l10n
  
                 // throw XmlSemanticError(lineNumber, "Invalid real number value");
   
                 MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",
                                            "Invalid $0 value",
                                            "real number");
   
                 throw XmlSemanticError(lineNumber, mlParms);
               }
             return CIMValue(x);             return CIMValue(x);
         }         }
  
Line 1097 
Line 1501 
             break;             break;
     }     }
  
     throw XmlSemanticError(lineNumber, "malformed XML");      // l10n
   
       // throw XmlSemanticError(lineNumber, "malformed XML");
   
       MessageLoaderParms mlParms("Common.XmlReader.MALFORMED_XML",
                                  "malformed XML");
   
       throw XmlSemanticError(lineNumber, mlParms);
   
     return false;     return false;
 } }
  
Line 1133 
Line 1545 
  
         expectEndTag(parser, "VALUE");         expectEndTag(parser, "VALUE");
     }     }
   #ifdef PEGASUS_SNIA_INTEROP_TEST
       // KS 20021004 - tries to put value in even if empty.
       // Think this is general problem with empty value
       // Need to check meaning of (#PCDATA) - Does it allow empty.
       // Bugzilla tbd
       if (!empty)
   #endif
     value = stringToValue(parser.getLine(), valueString,type);     value = stringToValue(parser.getLine(), valueString,type);
  
     return true;     return true;
Line 1156 
Line 1574 
  
     if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))     if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
     {     {
         if (required)        if (required) {
             throw XmlValidationError(parser.getLine(),"Expected VALUE element");  
           // l10n
   
           // throw XmlValidationError(parser.getLine(),"Expected VALUE element");
   
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                      "Expected $0 element", "VALUE");
   
           throw XmlValidationError(parser.getLine(), mlParms);
   
   
         }
         return false;         return false;
     }     }
  
Line 1173 
Line 1602 
         expectEndTag(parser, "VALUE");         expectEndTag(parser, "VALUE");
     }     }
  
     str = valueString;      str = String(valueString,STRING_FLAG_UTF8);
     return true;     return true;
 } }
  
Line 1524 
Line 1953 
  
     // Get QUALIFIER.NAME attribute:     // Get QUALIFIER.NAME attribute:
  
     String name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
  
     // Get QUALIFIER.TYPE attribute:     // Get QUALIFIER.TYPE attribute:
  
Line 1579 
Line 2008 
         }         }
         catch (AlreadyExistsException&)         catch (AlreadyExistsException&)
         {         {
             throw XmlSemanticError(parser.getLine(), "duplicate qualifier");  
             // l10n
   
             // throw XmlSemanticError(parser.getLine(), "duplicate qualifier");
   
             MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE",
                                        "duplicate $0", "qualifier");
   
             throw XmlSemanticError(parser.getLine(), mlParms);
         }         }
     }     }
 } }
Line 1608 
Line 2045 
  
     // Get PROPERTY.NAME attribute:     // Get PROPERTY.NAME attribute:
  
     String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
  
     // Get PROPERTY.CLASSORIGIN attribute:     // Get PROPERTY.CLASSORIGIN attribute:
  
Line 1673 
Line 2110 
  
     if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)     if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)
     {     {
         // l10n
   
         // char message[128];
         // sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");
         // throw XmlSemanticError(lineNumber, message);
   
         char message[128];         char message[128];
         sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");        sprintf(message, "%s.%s", tagName, "ARRAYSIZE");
         throw XmlSemanticError(lineNumber, message);  
         MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE",
                                    "Illegal value for $0",
                                    message);
   
         throw XmlSemanticError(lineNumber, mlParms);
     }     }
  
     value = Uint32(arraySize);     value = Uint32(arraySize);
Line 1711 
Line 2159 
  
     // Get PROPERTY.NAME attribute:     // Get PROPERTY.NAME attribute:
  
     String name =      CIMName name =
         getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");         getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
  
     // Get PROPERTY.TYPE attribute:     // Get PROPERTY.TYPE attribute:
Line 1752 
Line 2200 
         {         {
             if (arraySize && arraySize != value.getArraySize())             if (arraySize && arraySize != value.getArraySize())
             {             {
                 throw XmlSemanticError(parser.getLine(),  
                     "ARRAYSIZE attribute and value-array size are different");                // l10n
   
                 // throw XmlSemanticError(parser.getLine(),
                 //   "ARRAYSIZE attribute and value-array size are different");
   
                 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT",
                                            "$0 attribute and $1 size are different",
                                            "ARRAYSIZE", "value-array");
   
                 throw XmlSemanticError(parser.getLine(), mlParms);
             }             }
  
             property.setValue(value);             property.setValue(value);
Line 1781 
Line 2238 
  
     if (!testStartTag(parser, entry, "HOST"))     if (!testStartTag(parser, entry, "HOST"))
         return false;         return false;
   #ifdef PEGASUS_SNIA_INTEROP_TEST
       // Temp code to allow empty HOST field.
       // SNIA CIMOMs return empty field particularly on enumerateinstance.
       // Simply substitute a string for the empty.
           if (!parser.next(entry))
               throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
  
     if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)          if (entry.type == XmlEntry::CONTENT)
               host = String(entry.text,STRING_FLAG_UTF8);
           else
     {     {
         throw XmlValidationError(parser.getLine(),              parser.putBack(entry);
             "expected content of HOST element");          host = "HOSTNAMEINSERTEDBYPEGASUSCLIENT";
     }     }
  
     host = entry.text;  #else
   
       if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)
       {
   
         // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //               "expected content of HOST element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT",
                                    "expected content of $0 element", "HOST");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
       }
  
       host = String(entry.text,STRING_FLAG_UTF8);
   #endif
     expectEndTag(parser, "HOST");     expectEndTag(parser, "HOST");
     return true;     return true;
 } }
Line 1805 
Line 2287 
  
 Boolean XmlReader::getNameSpaceElement( Boolean XmlReader::getNameSpaceElement(
     XmlParser& parser,     XmlParser& parser,
     String& nameSpaceComponent)      CIMName& nameSpaceComponent)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 1840 
Line 2322 
     if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))     if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))
         return false;         return false;
  
     String nameSpaceComponent;      CIMName nameSpaceComponent;
  
     while (getNameSpaceElement(parser, nameSpaceComponent))     while (getNameSpaceElement(parser, nameSpaceComponent))
     {     {
         if (nameSpace.size())         if (nameSpace.size())
             nameSpace += '/';              nameSpace.append('/');
  
         nameSpace += nameSpaceComponent;          nameSpace.append(nameSpaceComponent.getString());
     }     }
  
     if (!nameSpace.size())     if (!nameSpace.size())
     {     {
         throw XmlValidationError(parser.getLine(),  
             "Expected one or more NAMESPACE elements within "        // l10n
             "LOCALNAMESPACEPATH element");  
         // throw XmlValidationError(parser.getLine(),
         //   "Expected one or more NAMESPACE elements within "
         //   "LOCALNAMESPACEPATH element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",
                                    "Expected one or more $0 elements within $1 element",
                                    "NAMESPACE", "LOCALNAMESPACEPATH");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
   
     }     }
  
     expectEndTag(parser, "LOCALNAMESPACEPATH");     expectEndTag(parser, "LOCALNAMESPACEPATH");
Line 1882 
Line 2375 
     if (!testStartTag(parser, entry, "NAMESPACEPATH"))     if (!testStartTag(parser, entry, "NAMESPACEPATH"))
         return false;         return false;
  
     if (!getHostElement(parser, host))      if (!getHostElement(parser, host)) {
         throw XmlValidationError(parser.getLine(), "expected HOST element");  
         // l10n
   
         // throw XmlValidationError(parser.getLine(), "expected HOST element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "HOST");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
  
     if (!getLocalNameSpacePathElement(parser, nameSpace))     if (!getLocalNameSpacePathElement(parser, nameSpace))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected LOCALNAMESPACEPATH element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected LOCALNAMESPACEPATH element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "LOCALNAMESPACEPATH");
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
  
     expectEndTag(parser, "NAMESPACEPATH");     expectEndTag(parser, "NAMESPACEPATH");
Line 1907 
Line 2417 
  
 Boolean XmlReader::getClassNameElement( Boolean XmlReader::getClassNameElement(
     XmlParser& parser,     XmlParser& parser,
     String& className,      CIMName& className,
     Boolean required)     Boolean required)
 { {
     XmlEntry entry;     XmlEntry entry;
Line 1916 
Line 2426 
     {     {
         if (required)         if (required)
         {         {
             throw XmlValidationError(parser.getLine(),  
                 "expected CLASSNAME element");            // l10n
   
             // throw XmlValidationError(parser.getLine(),
             // "expected CLASSNAME element");
   
             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                        "expected $0 element", "CLASSNAME");
   
             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
         else         else
             return false;             return false;
     }     }
   
     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
  
     className = getCimNameAttribute(     className = getCimNameAttribute(
         parser.getLine(), entry, "CLASSNAME", true);          parser.getLine(), entry, "CLASSNAME", false);
  
     if (!empty)     if (!empty)
         expectEndTag(parser, "CLASSNAME");         expectEndTag(parser, "CLASSNAME");
Line 1942 
Line 2459 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 KeyBinding::Type XmlReader::getValueTypeAttribute(  CIMKeyBinding::Type XmlReader::getValueTypeAttribute(
     Uint32 lineNumber,     Uint32 lineNumber,
     const XmlEntry& entry,     const XmlEntry& entry,
     const char* elementName)     const char* elementName)
Line 1950 
Line 2467 
     String tmp;     String tmp;
  
     if (!entry.getAttributeValue("VALUETYPE", tmp))     if (!entry.getAttributeValue("VALUETYPE", tmp))
         return KeyBinding::STRING;          return CIMKeyBinding::STRING;
  
     if (String::equal(tmp, "string"))     if (String::equal(tmp, "string"))
         return KeyBinding::STRING;          return CIMKeyBinding::STRING;
     else if (String::equal(tmp, "boolean"))     else if (String::equal(tmp, "boolean"))
         return KeyBinding::BOOLEAN;          return CIMKeyBinding::BOOLEAN;
     else if (String::equal(tmp, "numeric"))     else if (String::equal(tmp, "numeric"))
         return KeyBinding::NUMERIC;          return CIMKeyBinding::NUMERIC;
   
       // char buffer[MESSAGE_SIZE];
   
       // sprintf(buffer,
       // "Illegal value for %s.VALUETYPE attribute; "
       // "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",
       // elementName);
   
       // throw XmlSemanticError(lineNumber, buffer);
   
  
     char buffer[MESSAGE_SIZE];     char buffer[MESSAGE_SIZE];
       sprintf(buffer, "%s.VALUETYPE", elementName);
   
       MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",
                                  "Illegal value for $0 attribute; $1 must be one of $2, $3, or $4",
                                  buffer, "CIMValue", "\"string\"", "\"boolean\"", "\"numeric\"");
  
     sprintf(buffer,      throw XmlSemanticError(lineNumber, mlParms);
         "Illegal value for %s.VALUETYPE attribute; "  
         "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",  
         elementName);  
  
     throw XmlSemanticError(lineNumber, buffer);      return CIMKeyBinding::BOOLEAN;
     return KeyBinding::BOOLEAN;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1982 
Line 2510 
  
 Boolean XmlReader::getKeyValueElement( Boolean XmlReader::getKeyValueElement(
     XmlParser& parser,     XmlParser& parser,
     KeyBinding::Type& type,      CIMKeyBinding::Type& type,
     String& value)     String& value)
 { {
     XmlEntry entry;     XmlEntry entry;
Line 2002 
Line 2530 
             throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());             throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
  
         if (entry.type == XmlEntry::CONTENT)         if (entry.type == XmlEntry::CONTENT)
             value = entry.text;              value = String(entry.text,STRING_FLAG_UTF8);
         else         else
             parser.putBack(entry);             parser.putBack(entry);
  
Line 2024 
Line 2552 
  
 Boolean XmlReader::getKeyBindingElement( Boolean XmlReader::getKeyBindingElement(
     XmlParser& parser,     XmlParser& parser,
     String& name,      CIMName& name,
     String& value,     String& value,
     KeyBinding::Type& type)      CIMKeyBinding::Type& type)
 { {
     XmlEntry entry;     XmlEntry entry;
  
Line 2041 
Line 2569 
  
         if (!getValueReferenceElement(parser, reference))         if (!getValueReferenceElement(parser, reference))
         {         {
             throw XmlValidationError(parser.getLine(),  
                       "Expected KEYVALUE or VALUE.REFERENCE element");            // l10n
   
             // throw XmlValidationError(parser.getLine(),
             //          "Expected KEYVALUE or VALUE.REFERENCE element");
   
             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",
                                        "Expected $0 or $1 element", "KEYVALUE", "VALUE.REFERENCE");
   
             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
  
         type = KeyBinding::REFERENCE;          type = CIMKeyBinding::REFERENCE;
         value = reference.toString();         value = reference.toString();
     }     }
  
Line 2069 
Line 2605 
 Boolean XmlReader::getInstanceNameElement( Boolean XmlReader::getInstanceNameElement(
     XmlParser& parser,     XmlParser& parser,
     String& className,     String& className,
     Array<KeyBinding>& keyBindings)      Array<CIMKeyBinding>& keyBindings)
 { {
     className.clear();     className.clear();
     keyBindings.clear();     keyBindings.clear();
Line 2088 
Line 2624 
         return true;         return true;
     }     }
  
     String name;      CIMName name;
     KeyBinding::Type type;      CIMKeyBinding::Type type;
     String value;     String value;
     CIMObjectPath reference;     CIMObjectPath reference;
  
     if (getKeyValueElement(parser, type, value))     if (getKeyValueElement(parser, type, value))
     {     {
         // Use empty key name because none was specified         // Use empty key name because none was specified
         keyBindings.append(KeyBinding(name, value, type));          keyBindings.append(CIMKeyBinding(name, value, type));
     }     }
     else if (getValueReferenceElement(parser, reference))     else if (getValueReferenceElement(parser, reference))
     {     {
         // Use empty key name because none was specified         // Use empty key name because none was specified
         type = KeyBinding::REFERENCE;          type = CIMKeyBinding::REFERENCE;
         value = reference.toString();         value = reference.toString();
         keyBindings.append(KeyBinding(name, value, type));          keyBindings.append(CIMKeyBinding(name, value, type));
     }     }
     else     else
     {     {
         while (getKeyBindingElement(parser, name, value, type))         while (getKeyBindingElement(parser, name, value, type))
             keyBindings.append(KeyBinding(name, value, type));              keyBindings.append(CIMKeyBinding(name, value, type));
     }     }
  
     expectEndTag(parser, "INSTANCENAME");     expectEndTag(parser, "INSTANCENAME");
Line 2121 
Line 2657 
     CIMObjectPath& instanceName)     CIMObjectPath& instanceName)
 { {
     String className;     String className;
     Array<KeyBinding> keyBindings;      Array<CIMKeyBinding> keyBindings;
  
     if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))     if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))
         return false;         return false;
Line 2152 
Line 2688 
  
     if (!getNameSpacePathElement(parser, host, nameSpace))     if (!getNameSpacePathElement(parser, host, nameSpace))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected NAMESPACEPATH element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected NAMESPACEPATH element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "NAMESPACEPATH");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     String className;     String className;
     Array<KeyBinding> keyBindings;      Array<CIMKeyBinding> keyBindings;
  
     if (!getInstanceNameElement(parser, className, keyBindings))     if (!getInstanceNameElement(parser, className, keyBindings))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected INSTANCENAME element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected INSTANCENAME element");
   
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "INSTANCENAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     reference.set(host, nameSpace, className, keyBindings);     reference.set(host, nameSpace, className, keyBindings);
Line 2192 
Line 2747 
  
     if (!getLocalNameSpacePathElement(parser, nameSpace))     if (!getLocalNameSpacePathElement(parser, nameSpace))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected LOCALNAMESPACEPATH element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected LOCALNAMESPACEPATH element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "LOCALNAMESPACEPATH");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     String className;     String className;
     Array<KeyBinding> keyBindings;      Array<CIMKeyBinding> keyBindings;
  
     if (!getInstanceNameElement(parser, className, keyBindings))     if (!getInstanceNameElement(parser, className, keyBindings))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected INSTANCENAME element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected INSTANCENAME element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "INSTANCENAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     reference.set(String(), nameSpace, className, keyBindings);     reference.set(String(), nameSpace, className, keyBindings);
Line 2233 
Line 2806 
  
     if (!getNameSpacePathElement(parser, host, nameSpace))     if (!getNameSpacePathElement(parser, host, nameSpace))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected NAMESPACEPATH element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //    "expected NAMESPACEPATH element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "NAMESPACEPATH");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     String className;      CIMName className;
  
     if (!getClassNameElement(parser, className))     if (!getClassNameElement(parser, className))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected CLASSNAME element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected CLASSNAME element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "CLASSNAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     reference.set(host, nameSpace, className);     reference.set(host, nameSpace, className);
Line 2272 
Line 2863 
  
     if (!getLocalNameSpacePathElement(parser, nameSpace))     if (!getLocalNameSpacePathElement(parser, nameSpace))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected LOCALNAMESPACEPATH element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //    "expected LOCALNAMESPACEPATH element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "LOCALNAMESPACEPATH");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     String className;      CIMName className;
  
     if (!getClassNameElement(parser, className))     if (!getClassNameElement(parser, className))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected CLASSNAME element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected CLASSNAME element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "CLASSNAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     reference.set(String(), nameSpace, className);     reference.set(String(), nameSpace, className);
Line 2316 
Line 2925 
     if (entry.type != XmlEntry::START_TAG &&     if (entry.type != XmlEntry::START_TAG &&
         entry.type != XmlEntry::EMPTY_TAG)         entry.type != XmlEntry::EMPTY_TAG)
     {     {
         throw XmlValidationError(parser.getLine(),  
             "Expected one of the following start tags: "        // l10n
             "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "  
             "LOCALINSTANCEPATH, INSTANCENAME");        // throw XmlValidationError(parser.getLine(),
         //   "Expected one of the following start tags: "
         //    "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "
         //    "LOCALINSTANCEPATH, INSTANCENAME");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS",
                                    "Expected one of the following start tags: $0", "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     if (strcmp(entry.text, "CLASSPATH") == 0)     if (strcmp(entry.text, "CLASSPATH") == 0)
Line 2335 
Line 2953 
     else if (strcmp(entry.text, "CLASSNAME") == 0)     else if (strcmp(entry.text, "CLASSNAME") == 0)
     {     {
         parser.putBack(entry);         parser.putBack(entry);
         String className;          CIMName className;
         getClassNameElement(parser, className);         getClassNameElement(parser, className);
         reference.set(String(), CIMNamespaceName(), className);         reference.set(String(), CIMNamespaceName(), className);
     }     }
Line 2353 
Line 2971 
     {     {
         parser.putBack(entry);         parser.putBack(entry);
         String className;         String className;
         Array<KeyBinding> keyBindings;          Array<CIMKeyBinding> keyBindings;
         getInstanceNameElement(parser, className, keyBindings);         getInstanceNameElement(parser, className, keyBindings);
         reference.set(String(), CIMNamespaceName(), className, keyBindings);         reference.set(String(), CIMNamespaceName(), className, keyBindings);
     }     }
Line 2427 
Line 3045 
  
     // Get PROPERTY.NAME attribute:     // Get PROPERTY.NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "PROPERTY.REFERENCE");         parser.getLine(), entry, "PROPERTY.REFERENCE");
  
     // Get PROPERTY.REFERENCECLASS attribute:     // Get PROPERTY.REFERENCECLASS attribute:
Line 2488 
Line 3106 
         }         }
         catch (AlreadyExistsException&)         catch (AlreadyExistsException&)
         {         {
             throw XmlSemanticError(parser.getLine(), "duplicate property");  
             // l10n
   
             // throw XmlSemanticError(parser.getLine(), "duplicate property");
   
             MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE",
                                        "duplicate $0", "property");
   
             throw XmlSemanticError(parser.getLine(), mlParms);
         }         }
     }     }
 } }
Line 2517 
Line 3143 
  
     // Get PARAMETER.NAME attribute:     // Get PARAMETER.NAME attribute:
  
     String name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");
  
     // Get PARAMETER.TYPE attribute:     // Get PARAMETER.TYPE attribute:
  
Line 2563 
Line 3189 
  
     // Get PARAMETER.ARRAY.NAME attribute:     // Get PARAMETER.ARRAY.NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "PARAMETER.ARRAY");         parser.getLine(), entry, "PARAMETER.ARRAY");
  
     // Get PARAMETER.ARRAY.TYPE attribute:     // Get PARAMETER.ARRAY.TYPE attribute:
Line 2614 
Line 3240 
  
     // Get PARAMETER.NAME attribute:     // Get PARAMETER.NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "PARAMETER.REFERENCE");         parser.getLine(), entry, "PARAMETER.REFERENCE");
  
     // Get PARAMETER.REFERENCECLASS attribute:     // Get PARAMETER.REFERENCECLASS attribute:
Line 2660 
Line 3286 
  
     // Get PARAMETER.NAME attribute:     // Get PARAMETER.NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "PARAMETER.REFARRAY");         parser.getLine(), entry, "PARAMETER.REFARRAY");
  
     // Get PARAMETER.REFERENCECLASS attribute:     // Get PARAMETER.REFERENCECLASS attribute:
Line 2710 
Line 3336 
         }         }
         catch (AlreadyExistsException&)         catch (AlreadyExistsException&)
         {         {
             throw XmlSemanticError(parser.getLine(), "duplicate parameter");  
             // l10n
   
             // throw XmlSemanticError(parser.getLine(), "duplicate parameter");
   
             MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE",
                                        "duplicate $0", "parameter");
   
             throw XmlSemanticError(parser.getLine(), mlParms);
         }         }
     }     }
 } }
Line 2742 
Line 3376 
  
     // Get NAME attribute:     // Get NAME attribute:
  
     String name = getCimNameAttribute(      CIMName name = getCimNameAttribute(
         parser.getLine(), entry, "QUALIFIER.DECLARATION");         parser.getLine(), entry, "QUALIFIER.DECLARATION");
  
     // Get TYPE attribute:     // Get TYPE attribute:
Line 2785 
Line 3419 
         {         {
             if (!isArray)             if (!isArray)
             {             {
                 throw XmlSemanticError(parser.getLine(),  
                     "VALUE.ARRAY element encountered without "                // l10n
                     "ISARRAY attribute");  
                 // throw XmlSemanticError(parser.getLine(),
                 //    "VALUE.ARRAY element encountered without "
                 //    "ISARRAY attribute");
   
                 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY",
                                            "$0 element encountered without $1 attribute",
                                            "VALUE.ARRAY", "ISARRAY");
   
                 throw XmlSemanticError(parser.getLine(), mlParms);
             }             }
  
             if (arraySize && arraySize != value.getArraySize())             if (arraySize && arraySize != value.getArraySize())
             {             {
                 throw XmlSemanticError(parser.getLine(),  
                     "VALUE.ARRAY size is not the same as "                // l10n
                     "ARRAYSIZE attribute");  
                 // throw XmlSemanticError(parser.getLine(),
                 //   "VALUE.ARRAY size is not the same as "
                 //    "ARRAYSIZE attribute");
   
                 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME",
                                            "$0 size is not the same as $1 attribute",
                                            "VALUE.ARRAY", "ARRAYSIZE");
   
                 throw XmlSemanticError(parser.getLine(), mlParms);
             }             }
  
             gotValue = true;             gotValue = true;
Line 2803 
Line 3455 
         {         {
             if (isArray)             if (isArray)
             {             {
                 throw XmlSemanticError(parser.getLine(),  
                     "ISARRAY attribute used but VALUE element encountered");                // l10n
   
                 // throw XmlSemanticError(parser.getLine(),
                 //    "ISARRAY attribute used but VALUE element encountered");
   
                 MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",
                                            "$0 attribute used but $1 element encountered",
                                            "ISARRAY", "VALUE");
   
                 throw XmlSemanticError(parser.getLine(), mlParms);
             }             }
  
             gotValue = true;             gotValue = true;
Line 2850 
Line 3511 
  
     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
  
     String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");
  
     CIMType type;     CIMType type;
     getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");     getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");
Line 2893 
Line 3554 
     if (!testStartTag(parser, entry, "CLASS"))     if (!testStartTag(parser, entry, "CLASS"))
         return false;         return false;
  
     String name = getCimNameAttribute(parser.getLine(), entry, "CLASS");      CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
  
     CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");     CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");
  
Line 2982 
Line 3643 
  
     if (!getInstanceNameElement(parser, instanceName))     if (!getInstanceNameElement(parser, instanceName))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected INSTANCENAME element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //    "expected INSTANCENAME element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "INSTANCENAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
  
     // Get INSTANCE elements:     // Get INSTANCE elements:
  
     if (!getInstanceElement(parser, namedInstance))     if (!getInstanceElement(parser, namedInstance))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected INSTANCE element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected INSTANCE element");
   
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "INSTANCE");
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
  
     // Get VALUE.NAMEDINSTANCE end tag:     // Get VALUE.NAMEDINSTANCE end tag:
Line 3013 
Line 3691 
 { {
     if (!getClassElement(parser, x))     if (!getClassElement(parser, x))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected CLASS element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected CLASS element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "CLASS");
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
Line 3028 
Line 3714 
 { {
     if (!getInstanceElement(parser, x))     if (!getInstanceElement(parser, x))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected INSTANCE element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected INSTANCE element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "INSTANCE");
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
Line 3043 
Line 3737 
 { {
     if (!getQualifierDeclElement(parser, x))     if (!getQualifierDeclElement(parser, x))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected QUALIFIER.DECLARATION element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected QUALIFIER.DECLARATION element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                    "expected $0 element", "QUALIFIER.DECLARATION");
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
 } }
  
Line 3066 
Line 3768 
  
     // Get MESSAGE.ID:     // Get MESSAGE.ID:
  
     if (!entry.getAttributeValue("ID", id))      if (!entry.getAttributeValue("ID", id)) {
         throw XmlValidationError(parser.getLine(),  
             "Invalid or missing MESSAGE.ID attribute");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Invalid or missing MESSAGE.ID attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_ATTRIBUTE",
                                    "Invalid or missing $0 attribute", "MESSAGE.ID");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
   
  
     // Get MESSAGE.PROTOCOLVERSION:     // Get MESSAGE.PROTOCOLVERSION:
  
     if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))      if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion)) {
         throw XmlValidationError(parser.getLine(),  
             "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_ATTRIBUTE",
                                    "Invalid or missing $0 attribute", "MESSAGE.PROTOCOLVERSION");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
  
     return true;     return true;
 } }
Line 3096 
Line 3817 
  
     // Get IMETHODCALL.NAME attribute:     // Get IMETHODCALL.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name))  
         throw XmlValidationError(parser.getLine(),      if (!entry.getAttributeValue("NAME", name)) {
             "Missing IMETHODCALL.NAME attribute");  
         // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Missing IMETHODCALL.NAME attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "Missing $0 attribute",
                                    "IMETHODCALL.NAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
   
  
     return true;     return true;
 } }
Line 3120 
Line 3853 
  
     // Get IMETHODRESPONSE.NAME attribute:     // Get IMETHODRESPONSE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name))      if (!entry.getAttributeValue("NAME", name)) {
         throw XmlValidationError(parser.getLine(),  
             "Missing IMETHODRESPONSE.NAME attribute");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Missing IMETHODRESPONSE.NAME attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "Missing $0 attribute",
                                    "IMETHODRESPONSE.NAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
   
  
     return true;     return true;
 } }
Line 3144 
Line 3888 
  
     // Get IPARAMVALUE.NAME attribute:     // Get IPARAMVALUE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name))      if (!entry.getAttributeValue("NAME", name)) {
         throw XmlValidationError(parser.getLine(),  
             "Missing IPARAMVALUE.NAME attribute");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Missing IPARAMVALUE.NAME attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "Missing $0 attribute",
                                    "IPARAMVALUE.NAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
  
     return true;     return true;
 } }
Line 3170 
Line 3924 
     {     {
         if (required)         if (required)
         {         {
             throw XmlValidationError(parser.getLine(),  
                 "Expected VALUE element");            // l10n
   
             // throw XmlValidationError(parser.getLine(),
             // "Expected VALUE element");
   
             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                        "Expected $0 element", "VALUE");
   
             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
         return false;         return false;
     }     }
  
     expectContentOrCData(parser, entry);     expectContentOrCData(parser, entry);
  
     if (CompareNoCase(entry.text, "TRUE") == 0)      if (System::strcasecmp(entry.text, "TRUE") == 0)
         result = true;         result = true;
     else if (CompareNoCase(entry.text, "FALSE") == 0)      else if (System::strcasecmp(entry.text, "FALSE") == 0)
         result = false;         result = false;
     else      else {
         throw XmlSemanticError(parser.getLine(),  
             "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");        // l10n
   
         // throw XmlSemanticError(parser.getLine(),
         //   "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
   
         MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",
                                    "Invalid value for $0 element: must be $1 or $2",
                                    "VALUE", "\"TRUE\"", "\"FALSE\"");
   
         throw XmlSemanticError(parser.getLine(), mlParms);
       }
  
     expectEndTag(parser, "VALUE");     expectEndTag(parser, "VALUE");
  
Line 3211 
Line 3983 
  
     if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))     if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))
     {     {
         if (required)        if (required) {
             throw XmlValidationError(parser.getLine(),"Expected ERROR element");  
           // l10n
   
           // throw XmlValidationError(parser.getLine(),"Expected ERROR element");
   
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                      "Expected $0 element", "ERROR");
   
           throw XmlValidationError(parser.getLine(), mlParms);
   
         }
         return false;         return false;
     }     }
  
Line 3222 
Line 4004 
  
     Uint32 tmpCode;     Uint32 tmpCode;
  
     if (!entry.getAttributeValue("CODE", tmpCode))      if (!entry.getAttributeValue("CODE", tmpCode)) {
         throw XmlValidationError(  
             parser.getLine(), "missing ERROR.CODE attribute");  
         // l10n
   
         // throw XmlValidationError(
         //       parser.getLine(), "missing ERROR.CODE attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "missing $0 attribute",
                                    "ERROR.CODE");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
       }
  
     // Get ERROR.DESCRIPTION:     // Get ERROR.DESCRIPTION:
  
Line 3269 
Line 4063 
     }     }
     else     else
     {     {
         throw XmlValidationError(parser.getLine(),  
             "Expected INSTANCE or CLASS element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Expected INSTANCE or CLASS element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",
                                    "Expected $0 or $1 element", "INSTANCE", "CLASS");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     expectEndTag(parser, "VALUE.OBJECT");     expectEndTag(parser, "VALUE.OBJECT");
Line 3301 
Line 4104 
         isInstance = true;         isInstance = true;
     else if (!XmlReader::getClassPathElement(parser, reference))     else if (!XmlReader::getClassPathElement(parser, reference))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "Expected INSTANCEPATH or CLASSPATH element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //    "Expected INSTANCEPATH or CLASSPATH element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",
                                    "Expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH");
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
  
     if (isInstance)     if (isInstance)
Line 3311 
Line 4122 
  
         if (!XmlReader::getInstanceElement(parser, cimInstance))         if (!XmlReader::getInstanceElement(parser, cimInstance))
         {         {
             throw XmlValidationError(parser.getLine(),  
                 "Expected INSTANCE element");            // l10n
   
             // throw XmlValidationError(parser.getLine(),
             //               "Expected INSTANCE element");
   
             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                        "Expected $0 element", "INSTANCE");
   
             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
         objectWithPath = CIMObject (cimInstance);         objectWithPath = CIMObject (cimInstance);
         objectWithPath.setPath (reference);         objectWithPath.setPath (reference);
Line 3323 
Line 4142 
  
         if (!XmlReader::getClassElement(parser, cimClass))         if (!XmlReader::getClassElement(parser, cimClass))
         {         {
             throw XmlValidationError(parser.getLine(),  
                 "Expected CLASS element");            // l10n
   
             // throw XmlValidationError(parser.getLine(),
             // "Expected CLASS element");
   
             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                        "Expected $0 element", "CLASS");
   
             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
         objectWithPath = CIMObject (cimClass);         objectWithPath = CIMObject (cimClass);
         objectWithPath.setPath (reference);         objectWithPath.setPath (reference);
Line 3359 
Line 4186 
         isInstance = true;         isInstance = true;
     else if (!XmlReader::getLocalClassPathElement(parser, reference))     else if (!XmlReader::getLocalClassPathElement(parser, reference))
     {     {
         throw XmlValidationError(parser.getLine(),  
             "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",
                                    "Expected $0 or $1 element", "LOCALINSTANCEPATH", "LOCALCLASSPATH");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     if (isInstance)     if (isInstance)
Line 3369 
Line 4205 
  
         if (!XmlReader::getInstanceElement(parser, cimInstance))         if (!XmlReader::getInstanceElement(parser, cimInstance))
         {         {
             throw XmlValidationError(parser.getLine(),  
                 "Expected INSTANCE element");            // l10n
   
             // throw XmlValidationError(parser.getLine(),
             //               "Expected INSTANCE element");
   
             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                        "Expected $0 element", "INSTANCE");
   
             throw XmlValidationError(parser.getLine(), mlParms);
   
         }         }
         objectWithPath = CIMObject (cimInstance);         objectWithPath = CIMObject (cimInstance);
         objectWithPath.setPath (reference);         objectWithPath.setPath (reference);
Line 3381 
Line 4226 
  
         if (!XmlReader::getClassElement(parser, cimClass))         if (!XmlReader::getClassElement(parser, cimClass))
         {         {
             throw XmlValidationError(parser.getLine(),  
                 "Expected CLASS element");            // l10n
   
             // throw XmlValidationError(parser.getLine(),
             // "Expected CLASS element");
   
             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                        "Expected $0 element", "CLASS");
   
             throw XmlValidationError(parser.getLine(), mlParms);
   
   
         }         }
         objectWithPath = CIMObject (cimClass);         objectWithPath = CIMObject (cimClass);
         objectWithPath.setPath (reference);         objectWithPath.setPath (reference);
Line 3440 
Line 4295 
     XmlParser& parser,     XmlParser& parser,
     CIMObjectPath& objectName)     CIMObjectPath& objectName)
 { {
     String className;      CIMName className;
  
     if (getClassNameElement(parser, className, false))     if (getClassNameElement(parser, className, false))
     {     {
Line 3451 
Line 4306 
         return true;         return true;
     else     else
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected CLASSNAME or INSTANCENAME element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected CLASSNAME or INSTANCENAME element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",
                                    "Expected $0 or $1 element", "CLASSNAME", "INSTANCENAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
   
     }     }
  
     return false;     return false;
Line 3485 
Line 4349 
     }     }
     else     else
     {     {
         throw XmlValidationError(parser.getLine(),  
             "expected INSTANCEPATH or CLASSPATH element");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "expected INSTANCEPATH or CLASSPATH element");
   
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",
                                    "expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH");
   
         throw XmlValidationError(parser.getLine(), mlParms);
     }     }
  
     PEGASUS_UNREACHABLE ( return false; )     PEGASUS_UNREACHABLE ( return false; )
Line 3509 
Line 4381 
  
     // Get EXPMETHODCALL.NAME attribute:     // Get EXPMETHODCALL.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name))  
         throw XmlValidationError(parser.getLine(),        if (!entry.getAttributeValue("NAME", name)) {
             "Missing EXPMETHODCALL.NAME attribute");  
           // l10n
   
           // throw XmlValidationError(parser.getLine(),
           // "Missing EXPMETHODCALL.NAME attribute");
   
           MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                      "Missing $0 attribute",
                                      "EXPMETHODCALL.NAME");
   
           throw XmlValidationError(parser.getLine(), mlParms);
         }
  
     return true;     return true;
 } }
Line 3533 
Line 4416 
  
     // Get EXPMETHODRESPONSE.NAME attribute:     // Get EXPMETHODRESPONSE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name))  
         throw XmlValidationError(parser.getLine(),        if (!entry.getAttributeValue("NAME", name)) {
             "Missing EXPMETHODRESPONSE.NAME attribute");          // l10n
   
           // throw XmlValidationError(
           //   parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute");
   
           MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                      "Missing $0 attribute",
                                      "EXPMETHODRESPONSE.NAME");
   
           throw XmlValidationError(parser.getLine(), mlParms);
         }
   
       return true;
   }
   
   //------------------------------------------------------------------------------
   //
   // getEParamValueTag()
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::getEParamValueTag(
       XmlParser& parser,
       const char*& name)
   {
       XmlEntry entry;
   
       if (!testStartTag(parser, entry, "EXPPARAMVALUE"))
           return false;
   
       // Get EXPPARAMVALUE.NAME attribute:
   
   
       if (!entry.getAttributeValue("NAME", name)) {
   
         // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Missing EXPPARAMVALUE.NAME attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "Missing $0 attribute",
                                    "EXPPARAMVALUE.NAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
   
   
  
     return true;     return true;
 } }
Line 3557 
Line 4487 
  
     // Get METHODCALL.NAME attribute:     // Get METHODCALL.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name))  
         throw XmlValidationError(parser.getLine(),      if (!entry.getAttributeValue("NAME", name)) {
             "Missing METHODCALL.NAME attribute");  
         // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //               "Missing METHODCALL.NAME attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "Missing $0 attribute",
                                    "METHODCALL.NAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
   
  
     return true;     return true;
 } }
Line 3581 
Line 4523 
  
     // Get METHODRESPONSE.NAME attribute:     // Get METHODRESPONSE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name))  
         throw XmlValidationError(parser.getLine(),      if (!entry.getAttributeValue("NAME", name)) {
             "Missing METHODRESPONSE.NAME attribute");  
         // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Missing METHODRESPONSE.NAME attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "Missing $0 attribute",
                                    "METHODRESPONSE.NAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
  
     return true;     return true;
 } }
Line 3615 
Line 4568 
  
     // Get PARAMVALUE.NAME attribute:     // Get PARAMVALUE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name))      if (!entry.getAttributeValue("NAME", name)) {
         throw XmlValidationError(parser.getLine(),  
             "Missing PARAMVALUE.NAME attribute");        // l10n
   
         // throw XmlValidationError(parser.getLine(),
         //   "Missing PARAMVALUE.NAME attribute");
   
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",
                                    "Missing $0 attribute",
                                    "PARAMVALUE.NAME");
   
         throw XmlValidationError(parser.getLine(), mlParms);
       }
   
  
     // Get PARAMVALUE.PARAMTYPE attribute:     // Get PARAMVALUE.PARAMTYPE attribute:
  
Line 3712 
Line 4676 
         }         }
         else if (type == CIMTYPE_REFERENCE)         else if (type == CIMTYPE_REFERENCE)
         {         {
             throw XmlValidationError(parser.getLine(),  
                 "expected VALUE.REFERENCE element");            // l10n
   
             // throw XmlValidationError(parser.getLine(),
             //   "expected VALUE.REFERENCE element");
   
             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                        "expected $0 element", "VALUE.REFERENCE");
   
             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
     }     }
  
Line 3728 
Line 4700 
  
         if ( !XmlReader::getValueElement(parser, type, returnValue) )         if ( !XmlReader::getValueElement(parser, type, returnValue) )
         {         {
             throw XmlValidationError(parser.getLine(),  
                 "expected VALUE element");            // l10n
   
             // throw XmlValidationError(parser.getLine(),
             //   "expected VALUE element");
   
             MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",
                                        "expected $0 element", "VALUE");
   
             throw XmlValidationError(parser.getLine(), mlParms);
         }         }
     }     }
  

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