(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.85 and 1.121

version 1.85, 2003/08/01 14:42:55 version 1.121, 2006/10/30 13:02:53
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 27 
Line 35 
 //                  (carolann_graves@hp.com) //                  (carolann_graves@hp.com)
 //              Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) //              Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
   //              Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3103
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
   #include <errno.h>
 #include <cctype> #include <cctype>
 #include <cstdio> #include <cstdio>
 #include <cstdlib> #include <cstdlib>
 #if defined(PEGASUS_OS_TYPE_UNIX)  #if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)
 #include <errno.h> #include <errno.h>
 #endif #endif
 #include "CIMName.h" #include "CIMName.h"
Line 46 
Line 57 
 #include "CIMObject.h" #include "CIMObject.h"
 #include "CIMParamValue.h" #include "CIMParamValue.h"
 #include "System.h" #include "System.h"
   #include "XmlConstants.h"
   #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM
   #include "EBCDIC_OS400.h"
   #endif
 // l10n // l10n
 #include <Pegasus/Common/MessageLoader.h> #include <Pegasus/Common/MessageLoader.h>
   #include <Pegasus/Common/AutoPtr.h>
   #include "CIMNameUnchecked.h"
  
 #define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000)) #define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000))
 #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF) #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)
Line 84 
Line 100 
       //   "Expected <?xml ... ?> style declaration");       //   "Expected <?xml ... ?> style declaration");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE",       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE",
                                  "Expected $0 style declaration",                                   "Expected <?xml ... ?> style declaration");
                                  "<?xml ... ?>");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 98 
Line 113 
       // throw XmlValidationError(       // throw XmlValidationError(
       //   parser.getLine(), "missing xml.version attribute");       //   parser.getLine(), "missing xml.version attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_XML_ATTRIBUTE",
                                  "missing $0 attribute",                                   "missing xml.version attribute");
                                  "xml.version");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 242 
Line 256 
       //               "Expected content of CDATA");       //               "Expected content of CDATA");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA",       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA",
                                  "Expected content of $0", "CDATA");                                   "Expected content of CDATA");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 319 
Line 333 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // testStartTagOrEmptyTag()
   //
   //------------------------------------------------------------------------------
   
   Boolean XmlReader::testStartTagOrEmptyTag(
       XmlParser& parser,
       XmlEntry& entry)
   {
       if (!parser.next(entry) ||
           (entry.type != XmlEntry::START_TAG &&
            entry.type != XmlEntry::EMPTY_TAG))
       {
           parser.putBack(entry);
           return false;
       }
   
       return true;
   }
   
   //------------------------------------------------------------------------------
   //
 // testContentOrCData() // testContentOrCData()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 364 
Line 399 
       // throw XmlValidationError(       // throw XmlValidationError(
       //   parser.getLine(), "missing CIM.CIMVERSION attribute");       //   parser.getLine(), "missing CIM.CIMVERSION attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",
                                  "missing $0 attribute",                                   "missing CIM.CIMVERSION attribute");
                                  "CIM.CIMVERSION");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 378 
Line 412 
       // throw XmlValidationError(       // throw XmlValidationError(
       //   parser.getLine(), "missing CIM.DTDVERSION attribute");       //   parser.getLine(), "missing CIM.DTDVERSION attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",
                                  "missing $0 attribute",                                   "missing CIM.DTDVERSION attribute");
                                  "CIM.DTDVERSION");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 448 
Line 481 
  
 #endif #endif
     }     }
     return CIMName (name);      return CIMNameUnchecked(name);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 528 
Line 561 
     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       // l10n
Line 558 
Line 585 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // getEmbeddedObjectAttribute()
   //
   //     <!ENTITY % EmbeddedObject "EMBEDDEDOBJECT (object | instance) #IMPLIED">
   //
   //------------------------------------------------------------------------------
   
   String XmlReader::getEmbeddedObjectAttribute(
       Uint32 lineNumber,
       const XmlEntry& entry,
       const char* elementName)
   {
       String embeddedObject;
   
       if (!entry.getAttributeValue("EMBEDDEDOBJECT", embeddedObject))
           return String();
   
       // The embeddedObject attribute, if present, must have the string
       // value "object" or "instance".
       if (!(String::equal(embeddedObject, "object") ||
             String::equal(embeddedObject, "instance")
             )
           )
       {
         // l10n
   
         // char buffer[MESSAGE_SIZE];
         // sprintf(buffer,
         //   "Illegal value for %s.EMBEDDEDOBJECT attribute", elementName);
         // throw XmlSemanticError(lineNumber, buffer);
   
         char buffer[MESSAGE_SIZE];
         sprintf(buffer, "%s.EMBEDDEDOBJECT", elementName);
   
         MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",
                                    "Illegal value for $0 attribute",
                                    buffer);
   
         throw XmlSemanticError(lineNumber, mlParms);
   
       }
   
       return embeddedObject;
   }
   
   //------------------------------------------------------------------------------
   //
 // getReferenceClassAttribute() // getReferenceClassAttribute()
 // //
 //     <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED"> //     <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">
Line 730 
Line 803 
         type = CIMTYPE_REAL64;         type = CIMTYPE_REAL64;
     else if (strcmp(typeName, "reference") == 0)     else if (strcmp(typeName, "reference") == 0)
         type = CIMTYPE_REFERENCE;         type = CIMTYPE_REFERENCE;
   //  PEP 194:
   //  Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a
   //  Pegasus internal representation of an embedded object, so it won't be found here.
     else unrecognizedType = true;     else unrecognizedType = true;
  
     if (unrecognizedType ||     if (unrecognizedType ||
Line 903 
Line 979 
     return true;     return true;
 } }
  
 inline Uint8 _hexCharToNumeric(const char c)  inline Uint8 _xmlReader_hexCharToNumeric(const char c)
 { {
     Uint8 n;     Uint8 n;
  
Line 918 
Line 994 
 } }
  
 // See http://www.ietf.org/rfc/rfc2396.txt section 2 // See http://www.ietf.org/rfc/rfc2396.txt section 2
   //
   // Also see the "CIM Operations over HTTP" spec, section 3.3.2 and
   // 3.3.3, for the treatment of non US-ASCII chars (UTF-8)
 String XmlReader::decodeURICharacters(String uriString) String XmlReader::decodeURICharacters(String uriString)
 { {
     String decodedString;  
     Uint32 i;     Uint32 i;
  
       Array<Uint8> utf8Chars;
   
     for (i=0; i<uriString.size(); i++)     for (i=0; i<uriString.size(); i++)
     {     {
         if (uriString[i] == '%')         if (uriString[i] == '%')
Line 933 
Line 1013 
  
               // throw ParseError("Invalid URI encoding");               // throw ParseError("Invalid URI encoding");
  
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING",                MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING",
                                          "Invalid $0 encoding", "URI");                                           "Invalid URI encoding");
  
               throw ParseError(MessageLoader::getMessage(mlParms));               throw ParseError(MessageLoader::getMessage(mlParms));
  
             }             }
  
             Uint8 digit1 = _hexCharToNumeric(char(uriString[++i]));              Uint8 digit1 = _xmlReader_hexCharToNumeric(char(uriString[++i]));
             Uint8 digit2 = _hexCharToNumeric(char(uriString[++i]));              Uint8 digit2 = _xmlReader_hexCharToNumeric(char(uriString[++i]));
             if ( (digit1 > 15) || (digit2 > 15) )             if ( (digit1 > 15) || (digit2 > 15) )
             {             {
               // l10n               // l10n
  
               // throw ParseError("Invalid URI encoding");               // throw ParseError("Invalid URI encoding");
  
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING",                MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING",
                                          "Invalid $0 encoding", "URI");                                           "Invalid URI encoding");
  
               throw ParseError(MessageLoader::getMessage(mlParms));               throw ParseError(MessageLoader::getMessage(mlParms));
             }             }
  
             // ATTN: Handle non-UTF-8 character sets  
             Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);             Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);
             decodedString.append(Char16(decodedChar));              utf8Chars.append((Uint8)decodedChar);
         }         }
         else         else
         {         {
             decodedString.append(uriString[i]);              utf8Chars.append((Uint8)uriString[i]);
         }         }
     }     }
  
     return decodedString;      // If there was a string to decode...
       if (uriString.size() > 0)
       {
           // Convert UTF-8 to UTF-16 and return the String
           utf8Chars.append('\0');
           return String((char *)utf8Chars.getData());
       }
       else
       {
           return String();
       }
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1021 
Line 1110 
                 x = x << 4;                 x = x << 4;
  
                 // Make sure we don't overflow when we add the next digit                 // Make sure we don't overflow when we add the next digit
                 Sint64 newDigit = Sint64(_hexCharToNumeric(*p++));                  Sint64 newDigit = Sint64(_xmlReader_hexCharToNumeric(*p++));
                 if (PEGASUS_SINT64_MIN - x > -newDigit)                 if (PEGASUS_SINT64_MIN - x > -newDigit)
                 {                 {
                     return false;                     return false;
Line 1141 
Line 1230 
                 x = x << 4;                 x = x << 4;
  
                 // We can't overflow when we add the next digit                 // We can't overflow when we add the next digit
                 Uint64 newDigit = Uint64(_hexCharToNumeric(*p++));                  Uint64 newDigit = Uint64(_xmlReader_hexCharToNumeric(*p++));
                 if (PEGASUS_UINT64_MAX - x < newDigit)                 if (PEGASUS_UINT64_MAX - x < newDigit)
                 {                 {
                     return false;                     return false;
Line 1224 
Line 1313 
               //  throw XmlSemanticError(               //  throw XmlSemanticError(
               //             lineNumber, "Invalid boolean value");               //             lineNumber, "Invalid boolean value");
  
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",                MessageLoaderParms mlParms("Common.XmlReader.INVALID_BOOLEAN_VALUE",
                                          "Invalid $0 value",                                           "Invalid boolean value");
                                          "boolean");  
  
               throw XmlSemanticError(lineNumber, mlParms);               throw XmlSemanticError(lineNumber, mlParms);
  
Line 1240 
Line 1328 
  
         case CIMTYPE_CHAR16:         case CIMTYPE_CHAR16:
         {         {
   
   // remove this test, utf-8 can be up to 6 bytes per char
   /*
           if (strlen(valueString) != 1) {           if (strlen(valueString) != 1) {
               // l10n
   
               // throw XmlSemanticError(lineNumber, "Invalid char16 value");
   
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE",
                                          "Invalid char16 value");
  
               throw XmlSemanticError(lineNumber, mlParms);
             }
   */
             // Converts UTF-8 to UTF-16
             String tmp(valueString);
             if (tmp.size() != 1)
             {
             // l10n             // l10n
  
             // throw XmlSemanticError(lineNumber, "Invalid char16 value");             // throw XmlSemanticError(lineNumber, "Invalid char16 value");
  
             MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",              MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE",
                                        "Invalid $0 value",                                         "Invalid char16 value");
                                        "char16");  
  
             throw XmlSemanticError(lineNumber, mlParms);             throw XmlSemanticError(lineNumber, mlParms);
           }           }
  
             return CIMValue(Char16(valueString[0]));              return CIMValue(tmp[0]);
         }         }
  
         case CIMTYPE_UINT8:         case CIMTYPE_UINT8:
Line 1271 
Line 1374 
               // throw XmlSemanticError(               // throw XmlSemanticError(
               //   lineNumber, "Invalid unsigned integer value");               //   lineNumber, "Invalid unsigned integer value");
  
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",                MessageLoaderParms mlParms("Common.XmlReader.INVALID_UI_VALUE",
                                          "Invalid $0 value",                                           "Invalid unsigned integer value");
                                          "unsigned integer");  
  
               throw XmlSemanticError(lineNumber, mlParms);               throw XmlSemanticError(lineNumber, mlParms);
  
Line 1291 
Line 1393 
                       // throw XmlSemanticError(                       // throw XmlSemanticError(
                       //   lineNumber, "Uint8 value out of range");                       //   lineNumber, "Uint8 value out of range");
  
                       MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",                        MessageLoaderParms mlParms("Common.XmlReader.U8_VALUE_OUT_OF_RANGE",
                                                  "$0 value out of range",                                                   "Uint8 value out of range");
                                                  "Uint8");  
  
                       throw XmlSemanticError(lineNumber, mlParms);                       throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
Line 1309 
Line 1410 
                       // throw XmlSemanticError(                       // throw XmlSemanticError(
                       //             lineNumber, "Uint16 value out of range");                       //             lineNumber, "Uint16 value out of range");
  
                       MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",                        MessageLoaderParms mlParms("Common.XmlReader.U16_VALUE_OUT_OF_RANGE",
                                                  "$0 value out of range",                                                   "Uint16 value out of range");
                                                  "Uint16");  
  
                       throw XmlSemanticError(lineNumber, mlParms);                       throw XmlSemanticError(lineNumber, mlParms);
  
Line 1328 
Line 1428 
                       // throw XmlSemanticError(                       // throw XmlSemanticError(
                       //   lineNumber, "Uint32 value out of range");                       //   lineNumber, "Uint32 value out of range");
  
                       MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",                        MessageLoaderParms mlParms("Common.XmlReader.U32_VALUE_OUT_OF_RANGE",
                                                  "$0 value out of range",                                                   "Uint32 value out of range");
                                                  "Uint32");  
  
                       throw XmlSemanticError(lineNumber, mlParms);                       throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
Line 1356 
Line 1455 
               // throw XmlSemanticError(               // throw XmlSemanticError(
               //   lineNumber, "Invalid signed integer value");               //   lineNumber, "Invalid signed integer value");
  
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",                MessageLoaderParms mlParms("Common.XmlReader.INVALID_SI_VALUE",
                                          "Invalid $0 value",                                           "Invalid signed integer value");
                                          "signed integer");  
  
               throw XmlSemanticError(lineNumber, mlParms);               throw XmlSemanticError(lineNumber, mlParms);
  
Line 1376 
Line 1474 
                       // throw XmlSemanticError(                       // throw XmlSemanticError(
                       //   lineNumber, "Sint8 value out of range");                       //   lineNumber, "Sint8 value out of range");
  
                       MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",                        MessageLoaderParms mlParms("Common.XmlReader.S8_VALUE_OUT_OF_RANGE",
                                                  "$0 value out of range",                                                   "Sint8 value out of range");
                                                  "Sint8");  
  
                       throw XmlSemanticError(lineNumber, mlParms);                       throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
Line 1394 
Line 1491 
                       // throw XmlSemanticError(                       // throw XmlSemanticError(
                       //   lineNumber, "Sint16 value out of range");                       //   lineNumber, "Sint16 value out of range");
  
                       MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",                        MessageLoaderParms mlParms("Common.XmlReader.S16_VALUE_OUT_OF_RANGE",
                                                  "$0 value out of range",                                                   "Sint16 value out of range");
                                                  "Sint16");  
  
                       throw XmlSemanticError(lineNumber, mlParms);                       throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
Line 1412 
Line 1508 
                       // throw XmlSemanticError(                       // throw XmlSemanticError(
                       //   lineNumber, "Sint32 value out of range");                       //   lineNumber, "Sint32 value out of range");
  
                       MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",                        MessageLoaderParms mlParms("Common.XmlReader.S32_VALUE_OUT_OF_RANGE",
                                                  "$0 value out of range",                                                   "Sint32 value out of range");
                                                  "Sint32");  
  
                       throw XmlSemanticError(lineNumber, mlParms);                       throw XmlSemanticError(lineNumber, mlParms);
                     }                     }
Line 1447 
Line 1542 
  
               // throw XmlSemanticError(lineNumber, "Invalid datetime value");               // throw XmlSemanticError(lineNumber, "Invalid datetime value");
  
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",                MessageLoaderParms mlParms("Common.XmlReader.INVALID_DATETIME_VALUE",
                                          "Invalid $0 value",                                           "Invalid datetime value");
                                          "datetime");  
  
               throw XmlSemanticError(lineNumber, mlParms);               throw XmlSemanticError(lineNumber, mlParms);
             }             }
Line 1467 
Line 1561 
  
               // throw XmlSemanticError(lineNumber, "Invalid real number value");               // throw XmlSemanticError(lineNumber, "Invalid real number value");
  
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",                MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE",
                                          "Invalid $0 value",                                           "Invalid real number value");
                                          "real number");  
  
               throw XmlSemanticError(lineNumber, mlParms);               throw XmlSemanticError(lineNumber, mlParms);
             }             }
Line 1486 
Line 1579 
  
               // throw XmlSemanticError(lineNumber, "Invalid real number value");               // throw XmlSemanticError(lineNumber, "Invalid real number value");
  
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",                MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE",
                                          "Invalid $0 value",                                           "Invalid real number value");
                                          "real number");  
  
               throw XmlSemanticError(lineNumber, mlParms);               throw XmlSemanticError(lineNumber, mlParms);
             }             }
             return CIMValue(x);             return CIMValue(x);
         }         }
  
   //  PEP 194:
   //  Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but just a
   //  Pegasus internal representation of an embedded object. However, this case is
   //  used when decoding string representations of embedded objects.
       case CIMTYPE_OBJECT:
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       case CIMTYPE_INSTANCE:
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       {
           CIMObject x;
   
           if (*valueString == '\0')
           {
               return CIMValue(type, false, 0);
           }
           else
           {
               // Convert the non-NULL string to a CIMObject (containing either a
               // CIMInstance or a CIMClass).
   
               // First we need to create a new "temporary" XmlParser that is
               // just the value of the Embedded Object in String representation.
               AutoArrayPtr<char> tmp_buffer(new char[strlen(valueString) + 1]);
               strcpy(tmp_buffer.get(), valueString);
               XmlParser tmp_parser(tmp_buffer.get());
   
               // The next bit of logic constructs a CIMObject from the Embedded Object String.
               // It is similar to the method XmlReader::getValueObjectElement().
               CIMInstance cimInstance;
               CIMClass cimClass;
   
               if (XmlReader::getInstanceElement(tmp_parser, cimInstance))
               {
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
                   if(type == CIMTYPE_INSTANCE)
                     return CIMValue(cimInstance);
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
                   x = CIMObject(cimInstance);
               }
               else if (XmlReader::getClassElement(tmp_parser, cimClass))
               {
                   x = CIMObject(cimClass);
               }
               else
               {
                   // l10n
   
                   // throw XmlValidationError(parser.getLine(),
                   //   "Expected INSTANCE or CLASS element");
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
                   if(type == CIMTYPE_OBJECT)
                   {
                       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
                           "Expected INSTANCE or CLASS element"); // change "element" to "embedded object"
   
                       throw XmlValidationError(lineNumber, mlParms);
                   }
                   else
                   {
                       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
                           "Expected INSTANCE element"); // change "element" to "embedded object"
                       throw XmlValidationError(lineNumber, mlParms);
                   }
   #else
                   MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
                       "Expected INSTANCE or CLASS element"); // change "element" to "embedded object"
                   throw XmlValidationError(lineNumber, mlParms);
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               }
               // Ok, now we can delete the storage for the temporary XmlParser.
               tmp_buffer.reset();
           }
           return CIMValue(x);
       }
   
         default:         default:
             break;             break;
     }     }
Line 1513 
Line 1680 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // skipElement()
   //
   //------------------------------------------------------------------------------
   void XmlReader::skipElement(
       XmlParser& parser,
       XmlEntry& entry)
   {
       const char * tag_name = entry.text;
   
       if (entry.type == XmlEntry::EMPTY_TAG)
       {
           return;
       }
   
       while (testStartTagOrEmptyTag(parser, entry))
       {
           skipElement(parser, entry);
       }
   
       if (testContentOrCData(parser, entry))
       {
           ; // skip
       }
   
       expectEndTag(parser, tag_name);
       return;
   }
   
   //------------------------------------------------------------------------------
   //
 // getValueElement() // getValueElement()
 // //
 //     <!ELEMENT VALUE (#PCDATA)> //     <!ELEMENT VALUE (#PCDATA)>
Line 1530 
Line 1727 
  
     XmlEntry entry;     XmlEntry entry;
     if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))     if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))
       {
         return false;         return false;
       }
  
     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;     Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
  
Line 1539 
Line 1738 
     if (!empty)     if (!empty)
     {     {
         if (testContentOrCData(parser, entry))         if (testContentOrCData(parser, entry))
           {
             valueString = entry.text;             valueString = entry.text;
           }
  
         expectEndTag(parser, "VALUE");         expectEndTag(parser, "VALUE");
     }     }
Line 1578 
Line 1779 
  
         // throw XmlValidationError(parser.getLine(),"Expected VALUE element");         // throw XmlValidationError(parser.getLine(),"Expected VALUE element");
  
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",          MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
                                    "Expected $0 element", "VALUE");                                     "Expected VALUE element");
  
         throw XmlValidationError(parser.getLine(), mlParms);         throw XmlValidationError(parser.getLine(), mlParms);
  
Line 1600 
Line 1801 
         expectEndTag(parser, "VALUE");         expectEndTag(parser, "VALUE");
     }     }
  
     str = valueString;      str = String(valueString);
     return true;     return true;
 } }
  
Line 1737 
Line 1938 
         case CIMTYPE_REAL64:         case CIMTYPE_REAL64:
             return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);             return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);
  
   //  PEP 194:
   //  Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but just a
   //  Pegasus internal representation of an embedded object. However, this case is
   //  used when decoding string representations of embedded objects.
       case CIMTYPE_OBJECT:
               return StringArrayToValueAux(lineNumber, array, type, (CIMObject*)0);
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       case CIMTYPE_INSTANCE:
               return StringArrayToValueAux(lineNumber, array, type, (CIMInstance*)0);
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   
         default:         default:
             break;             break;
     }     }
Line 1946 
Line 2158 
     // Get QUALIFIER element:     // Get QUALIFIER element:
  
     XmlEntry entry;     XmlEntry entry;
     if (!testStartTag(parser, entry, "QUALIFIER"))      if (!testStartTagOrEmptyTag(parser, entry, "QUALIFIER"))
         return false;         return false;
  
       Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
   
     // Get QUALIFIER.NAME attribute:     // Get QUALIFIER.NAME attribute:
  
     CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");     CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");
Line 1971 
Line 2185 
  
     CIMValue value;     CIMValue value;
  
       if (empty)
       {
           value.setNullValue(type, false);
       }
       else
       {
     if (!getValueElement(parser, type, value) &&     if (!getValueElement(parser, type, value) &&
         !getValueArrayElement(parser, type, value))         !getValueArrayElement(parser, type, value))
     {     {
Line 1980 
Line 2200 
     // Expect </QUALIFIER>:     // Expect </QUALIFIER>:
  
     expectEndTag(parser, "QUALIFIER");     expectEndTag(parser, "QUALIFIER");
       }
  
     // Build qualifier:     // Build qualifier:
  
Line 2011 
Line 2232 
  
           // throw XmlSemanticError(parser.getLine(), "duplicate qualifier");           // throw XmlSemanticError(parser.getLine(), "duplicate qualifier");
  
           MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE",            MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_QUALIFIER",
                                      "duplicate $0", "qualifier");                                       "duplicate qualifier");
  
           throw XmlSemanticError(parser.getLine(), mlParms);           throw XmlSemanticError(parser.getLine(), mlParms);
         }         }
Line 2028 
Line 2249 
 //         %CIMName; //         %CIMName;
 //         %ClassOrigin; //         %ClassOrigin;
 //         %Propagated; //         %Propagated;
   //         %EmbeddedObject; #IMPLIED
 //         %CIMType; #REQUIRED> //         %CIMType; #REQUIRED>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 2055 
Line 2277 
     Boolean propagated = getCimBooleanAttribute(     Boolean propagated = getCimBooleanAttribute(
         parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);         parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);
  
       // Get PROPERTY.EMBEDDEDOBJECT attribute:
   
       String embeddedObject = getEmbeddedObjectAttribute(
           parser.getLine(), entry, "PROPERTY");
   
     // Get PROPERTY.TYPE attribute:     // Get PROPERTY.TYPE attribute:
  
     CIMType type;     CIMType type;
Line 2067 
Line 2294 
  
     if (!empty)     if (!empty)
     {     {
         // Get qualifiers:              // Get qualifiers. We need to do this before checking for the property as an
           // embedded object, because we need to also check for the EmbeddedObject qualifier.
         getQualifierElements(parser, property);         getQualifierElements(parser, property);
       }
   
       Boolean embeddedObjectQualifierValue = false;
       Uint32 ix = property.findQualifier(CIMName("EmbeddedObject"));
       if (ix != PEG_NOT_FOUND)
       {
           property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);
       }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       String embeddedInstanceQualifierValue;
       ix = property.findQualifier(CIMName("EmbeddedInstance"));
       if (ix != PEG_NOT_FOUND)
       {
           property.getQualifier(ix).getValue().get(embeddedInstanceQualifierValue);
       }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       // If the EMBEDDEDOBJECT attribute is present with value "object"
       // or the EmbeddedObject qualifier exists on this property with value "true"
       // then
       //     Convert the EmbeddedObject-encoded string into a CIMObject
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       Boolean isEmbeddedObject = String::equal(embeddedObject, "object") ||
         embeddedObjectQualifierValue;
       Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance") ||
         embeddedInstanceQualifierValue.size() > 0;
       if (isEmbeddedObject || isEmbeddedInstance)
       {
           // The EMBEDDEDOBJECT attribute is only valid on Properties of type string
           if (type == CIMTYPE_STRING)
           {
               if(isEmbeddedObject)
                 type = CIMTYPE_OBJECT;
               else
                 type = CIMTYPE_INSTANCE;
               CIMValue new_value(type, false);
               CIMProperty new_property = CIMProperty(name, new_value, 0, CIMName(), classOrigin, propagated);
   
               // Copy the qualifiers from the String property to the CIMObject property.
               for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)
               {
                   // All properties are copied, including the EmbeddedObject qualifier.
                   // This way we don't have to keep track to know that the EmbeddedObject
                   // qualifier needs to be added back during the encode step.
                   new_property.addQualifier(property.getQualifier(ix));
               }
  
         // Get value:  Insert value if getValueElement exists (returns True)              value = new_value;
               property = new_property;
           }
           else
           {
               // Error -- throw exception
               // (the EmbeddedObject attribute may be applied only to entities that have the type String)
   
               // l10n
   
               // throw XmlValidationError(parser.getLine(),
               //   "expected string type");
   
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
                                "The EMBEDDEDOBJECT attribute is only valid on string types.");
   
               throw XmlValidationError(parser.getLine(), mlParms);
           }
       }
   #else
       if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)
       {
           // The EMBEDDEDOBJECT attribute is only valid on Properties of type string
           if (type == CIMTYPE_STRING)
           {
               type = CIMTYPE_OBJECT;
               CIMValue new_value(type, false);
               CIMProperty new_property = CIMProperty(name, new_value, 0, CIMName(), classOrigin, propagated);
   
               // Copy the qualifiers from the String property to the CIMObject property.
               for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)
               {
                   // All properties are copied, including the EmbeddedObject qualifier.
                   // This way we don't have to keep track to know that the EmbeddedObject
                   // qualifier needs to be added back during the encode step.
                   new_property.addQualifier(property.getQualifier(ix));
               }
   
               value = new_value;
               property = new_property;
           }
           else
           {
               // Error -- throw exception
               // (the EmbeddedObject attribute may be applied only to entities that have the type String)
  
               // l10n
   
               // throw XmlValidationError(parser.getLine(),
               //   "expected string type");
   
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
                                "The EMBEDDEDOBJECT attribute is only valid on string types.");
   
               throw XmlValidationError(parser.getLine(), mlParms);
           }
       }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       // Continue on to get property value, if not empty.
       if (!empty)
       {
         if (getValueElement(parser, type, value))         if (getValueElement(parser, type, value))
             property.setValue(value);             property.setValue(value);
   
         expectEndTag(parser, "PROPERTY");         expectEndTag(parser, "PROPERTY");
     }     }
  
Line 2138 
Line 2468 
 //             %CIMType; #REQUIRED //             %CIMType; #REQUIRED
 //             %ArraySize; //             %ArraySize;
 //             %ClassOrigin; //             %ClassOrigin;
 //             %Propagated;>  //             %Propagated;
   //             %EmbeddedObject; #IMPLIED>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
Line 2172 
Line 2503 
  
     // Get PROPERTY.CLASSORIGIN attribute:     // Get PROPERTY.CLASSORIGIN attribute:
  
     CIMName classOrigin      CIMName classOrigin = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");
         = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");  
  
     // Get PROPERTY.ARRAY.PROPAGATED     // Get PROPERTY.ARRAY.PROPAGATED
  
     Boolean propagated = getCimBooleanAttribute(      Boolean propagated = getCimBooleanAttribute(parser.getLine()
         parser.getLine(), entry, "PROPERTY.ARRAY", "PROPAGATED", false, false);                                                  ,entry
                                                   ,"PROPERTY.ARRAY"
                                                   ,"PROPAGATED"
                                                   ,false
                                                   ,false);
   
       // Get PROPERTY.EMBEDDEDOBJECT attribute:
   
       String embeddedObject = getEmbeddedObjectAttribute(parser.getLine()
                                                          ,entry
                                                          ,"PROPERTY.ARRAY");
  
     // Create property:     // Create property:
  
     CIMValue value(type, true, arraySize);     CIMValue value(type, true, arraySize);
     property = CIMProperty(      property = CIMProperty(name, value, arraySize, CIMName(), classOrigin, propagated);
         name, value, arraySize, CIMName(), classOrigin, propagated);  
  
     if (!empty)     if (!empty)
     {     {
         // Get qualifiers:         // Get qualifiers:
   
         getQualifierElements(parser, property);         getQualifierElements(parser, property);
       }
   
       Boolean embeddedObjectQualifierValue = false;
       Uint32 ix = property.findQualifier(CIMName("EmbeddedObject"));
       if (ix != PEG_NOT_FOUND)
       {
           property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);
       }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       String embeddedInstanceQualifierValue;
       ix = property.findQualifier(CIMName("EmbeddedInstance"));
       if (ix != PEG_NOT_FOUND)
       {
           property.getQualifier(ix).getValue().get(embeddedInstanceQualifierValue);
       }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       // If the EMBEDDEDOBJECT attribute is present with value "object"
       // or the EmbeddedObject qualifier exists on this property with value "true"
       // then
       //     Convert the EmbeddedObject-encoded string into a CIMObject
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       Boolean isEmbeddedObject = String::equal(embeddedObject, "object") ||
         embeddedObjectQualifierValue;
       Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance") ||
         embeddedInstanceQualifierValue.size() > 0;
       if (isEmbeddedObject || isEmbeddedInstance)
       {
           // The EMBEDDEDOBJECT attribute is only valid on Properties of type string
           if (type == CIMTYPE_STRING)
           {
               if(isEmbeddedObject)
                 type = CIMTYPE_OBJECT;
               else
                 type = CIMTYPE_INSTANCE;
               CIMValue new_value(type, true, arraySize);
               CIMProperty new_property = CIMProperty(name, new_value, arraySize, CIMName(), classOrigin, propagated);
   
               // Copy the qualifiers from the String property to the CIMObject property.
               for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)
               {
                   // All properties are copied, including the EmbeddedObject qualifier.
                   // This way we don't have to keep track to know that the EmbeddedObject
                   // qualifier needs to be added back during the encode step.
                   new_property.addQualifier(property.getQualifier(ix));
               }
   
               value = new_value;
               property = new_property;
           }
           else
           {
               // Error -- throw exception
               // (the EmbeddedObject attribute may be applied only to entities that have the type String)
   
               // l10n
   
               // throw XmlValidationError(parser.getLine(),
               //   "expected string type");
  
         // Get value:              MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
                                "The EMBEDDEDOBJECT attribute is only valid on string types.");
   
               throw XmlValidationError(parser.getLine(), mlParms);
           }
       }
   #else
       if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)
       {
           // The EMBEDDEDOBJECT attribute is only valid on Properties of type string
           if (type == CIMTYPE_STRING)
           {
               type = CIMTYPE_OBJECT;
               CIMValue new_value(type, true, arraySize);
               CIMProperty new_property = CIMProperty(name, new_value, arraySize, CIMName(), classOrigin, propagated);
   
               // Copy the qualifiers from the String property to the CIMObject property.
               for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)
               {
                   // All properties are copied, including the EmbeddedObject qualifier.
                   // This way we don't have to keep track to know that the EmbeddedObject
                   // qualifier needs to be added back during the encode step.
                   new_property.addQualifier(property.getQualifier(ix));
               }
   
               value = new_value;
               property = new_property;
           }
           else
           {
               // Error -- throw exception
               // (the EmbeddedObject attribute may be applied only to entities that have the type String)
  
               // l10n
   
               // throw XmlValidationError(parser.getLine(),
               //   "expected string type");
   
               MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
                                "The EMBEDDEDOBJECT attribute is only valid on string types.");
   
               throw XmlValidationError(parser.getLine(), mlParms);
           }
       }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
       // Continue on to get property array value, if not empty.
       // Else not an embedded object, if not empty, get the property array value.
       if (!empty)
       {
         if (getValueArrayElement(parser, type, value))         if (getValueArrayElement(parser, type, value))
         {         {
             if (arraySize && arraySize != value.getArraySize())             if (arraySize && arraySize != value.getArraySize())
Line 2205 
Line 2648 
               //   "ARRAYSIZE attribute and value-array size are different");               //   "ARRAYSIZE attribute and value-array size are different");
  
               MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT",               MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT",
                                          "$0 attribute and $1 size are different",                           "ARRAYSIZE attribute and value-array size are different");
                                          "ARRAYSIZE", "value-array");  
  
               throw XmlSemanticError(parser.getLine(), mlParms);               throw XmlSemanticError(parser.getLine(), mlParms);
             }             }
  
             property.setValue(value);             property.setValue(value);
         }         }
   
         expectEndTag(parser, "PROPERTY.ARRAY");         expectEndTag(parser, "PROPERTY.ARRAY");
     }     }
  
Line 2244 
Line 2685 
             throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());             throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());
  
         if (entry.type == XmlEntry::CONTENT)         if (entry.type == XmlEntry::CONTENT)
             host = entry.text;              host = String(entry.text);
         else         else
     {     {
             parser.putBack(entry);             parser.putBack(entry);
Line 2262 
Line 2703 
       //               "expected content of HOST element");       //               "expected content of HOST element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT",       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT",
                                  "expected content of $0 element", "HOST");                                   "expected content of HOST element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
     }     }
  
     host = entry.text;      host = String(entry.text);
 #endif #endif
     expectEndTag(parser, "HOST");     expectEndTag(parser, "HOST");
     return true;     return true;
Line 2340 
Line 2781 
       //   "LOCALNAMESPACEPATH element");       //   "LOCALNAMESPACEPATH element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",
                                  "Expected one or more $0 elements within $1 element",                                   "Expected one or more NAMESPACE elements within LOCALNAMESPACEPATH element");
                                  "NAMESPACE", "LOCALNAMESPACEPATH");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 2379 
Line 2819 
  
       // throw XmlValidationError(parser.getLine(), "expected HOST element");       // throw XmlValidationError(parser.getLine(), "expected HOST element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_HOST_ELEMENT",
                                  "expected $0 element", "HOST");                                   "expected HOST element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 2393 
Line 2833 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected LOCALNAMESPACEPATH element");       //   "expected LOCALNAMESPACEPATH element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
                                  "expected $0 element", "LOCALNAMESPACEPATH");                                   "expected LOCALNAMESPACEPATH element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 2430 
Line 2870 
           // throw XmlValidationError(parser.getLine(),           // throw XmlValidationError(parser.getLine(),
           // "expected CLASSNAME element");           // "expected CLASSNAME element");
  
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",            MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
                                      "expected $0 element", "CLASSNAME");                                       "expected CLASSNAME element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
         }         }
Line 2488 
Line 2928 
     sprintf(buffer, "%s.VALUETYPE", elementName);     sprintf(buffer, "%s.VALUETYPE", elementName);
  
     MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",     MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",
                                "Illegal value for $0 attribute; $1 must be one of $2, $3, or $4",                                 "Illegal value for $0 attribute; CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", buffer);
                                buffer, "CIMValue", "\"string\"", "\"boolean\"", "\"numeric\"");  
  
     throw XmlSemanticError(lineNumber, mlParms);     throw XmlSemanticError(lineNumber, mlParms);
  
Line 2528 
Line 2967 
             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);
         else         else
             parser.putBack(entry);             parser.putBack(entry);
  
Line 2573 
Line 3012 
           // throw XmlValidationError(parser.getLine(),           // throw XmlValidationError(parser.getLine(),
           //          "Expected KEYVALUE or VALUE.REFERENCE element");           //          "Expected KEYVALUE or VALUE.REFERENCE element");
  
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",            MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",
                                      "Expected $0 or $1 element", "KEYVALUE", "VALUE.REFERENCE");                                       "Expected KEYVALUE or VALUE.REFERENCE element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
         }         }
Line 2692 
Line 3131 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected NAMESPACEPATH element");       //   "expected NAMESPACEPATH element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
                                  "expected $0 element", "NAMESPACEPATH");                                   "expected NAMESPACEPATH element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 2711 
Line 3150 
       //   "expected INSTANCENAME element");       //   "expected INSTANCENAME element");
  
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
                                  "expected $0 element", "INSTANCENAME");                                   "expected INSTANCENAME element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 2751 
Line 3190 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected LOCALNAMESPACEPATH element");       //   "expected LOCALNAMESPACEPATH element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
                                  "expected $0 element", "LOCALNAMESPACEPATH");                                   "expected LOCALNAMESPACEPATH element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 2769 
Line 3208 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected INSTANCENAME element");       //   "expected INSTANCENAME element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
                                  "expected $0 element", "INSTANCENAME");                                   "expected INSTANCENAME element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 2810 
Line 3249 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //    "expected NAMESPACEPATH element");       //    "expected NAMESPACEPATH element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",
                                  "expected $0 element", "NAMESPACEPATH");                                   "expected NAMESPACEPATH element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 2827 
Line 3266 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected CLASSNAME element");       //   "expected CLASSNAME element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
                                  "expected $0 element", "CLASSNAME");                                   "expected CLASSNAME element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 2867 
Line 3306 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //    "expected LOCALNAMESPACEPATH element");       //    "expected LOCALNAMESPACEPATH element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",
                                  "expected $0 element", "LOCALNAMESPACEPATH");                                   "expected LOCALNAMESPACEPATH element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 2884 
Line 3323 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected CLASSNAME element");       //   "expected CLASSNAME element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",
                                  "expected $0 element", "CLASSNAME");                                   "expected CLASSNAME element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 2932 
Line 3371 
       //    "LOCALINSTANCEPATH, INSTANCENAME");       //    "LOCALINSTANCEPATH, INSTANCENAME");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS",       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS",
                                  "Expected one of the following start tags: $0", "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME");                                   "Expected one of the following start tags: CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 3109 
Line 3548 
  
           // throw XmlSemanticError(parser.getLine(), "duplicate property");           // throw XmlSemanticError(parser.getLine(), "duplicate property");
  
           MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE",            MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PROPERTY",
                                      "duplicate $0", "property");                                       "duplicate property");
  
           throw XmlSemanticError(parser.getLine(), mlParms);           throw XmlSemanticError(parser.getLine(), mlParms);
         }         }
Line 3339 
Line 3778 
  
           // throw XmlSemanticError(parser.getLine(), "duplicate parameter");           // throw XmlSemanticError(parser.getLine(), "duplicate parameter");
  
           MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE",            MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PARAMETER",
                                      "duplicate $0", "parameter");                                       "duplicate parameter");
  
           throw XmlSemanticError(parser.getLine(), mlParms);           throw XmlSemanticError(parser.getLine(), mlParms);
         }         }
Line 3425 
Line 3864 
               //    "ISARRAY attribute");               //    "ISARRAY attribute");
  
               MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY",               MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY",
                                          "$0 element encountered without $1 attribute",                                           "VALUE.ARRAY element encountered without ISARRAY attribute");
                                          "VALUE.ARRAY", "ISARRAY");  
  
               throw XmlSemanticError(parser.getLine(), mlParms);               throw XmlSemanticError(parser.getLine(), mlParms);
             }             }
Line 3441 
Line 3879 
               //    "ARRAYSIZE attribute");               //    "ARRAYSIZE attribute");
  
               MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME",               MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME",
                                          "$0 size is not the same as $1 attribute",                                           "VALUE.ARRAY size is not the same as ARRAYSIZE attribute");
                                          "VALUE.ARRAY", "ARRAYSIZE");  
  
               throw XmlSemanticError(parser.getLine(), mlParms);               throw XmlSemanticError(parser.getLine(), mlParms);
             }             }
Line 3460 
Line 3897 
               //    "ISARRAY attribute used but VALUE element encountered");               //    "ISARRAY attribute used but VALUE element encountered");
  
               MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",               MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",
                                          "$0 attribute used but $1 element encountered",                                           "ISARRAY attribute used but VALUE element encountered");
                                          "ISARRAY", "VALUE");  
  
               throw XmlSemanticError(parser.getLine(), mlParms);               throw XmlSemanticError(parser.getLine(), mlParms);
             }             }
Line 3549 
Line 3985 
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "CLASS"))      if (!testStartTagOrEmptyTag(parser, entry, "CLASS"))
         return false;         return false;
  
     CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");     CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");
Line 3558 
Line 3994 
  
     cimClass = CIMClass(name, superClass);     cimClass = CIMClass(name, superClass);
  
           if(entry.type != XmlEntry::EMPTY_TAG)
           {
   
     // Get QUALIFIER elements:     // Get QUALIFIER elements:
  
     getQualifierElements(parser, cimClass);     getQualifierElements(parser, cimClass);
Line 3576 
Line 4015 
     // Get CLASS end tag:     // Get CLASS end tag:
  
     expectEndTag(parser, "CLASS");     expectEndTag(parser, "CLASS");
           }
  
     return true;     return true;
 } }
Line 3596 
Line 4036 
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "INSTANCE"))      if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE"))
         return false;         return false;
  
       Boolean empty = entry.type == XmlEntry::EMPTY_TAG;
   
     String className = getClassNameAttribute(     String className = getClassNameAttribute(
         parser.getLine(), entry, "INSTANCE");         parser.getLine(), entry, "INSTANCE");
  
     cimInstance = CIMInstance(className);     cimInstance = CIMInstance(className);
  
       if (!empty)
       {
     // Get QUALIFIER elements:     // Get QUALIFIER elements:
   
     getQualifierElements(parser, cimInstance);     getQualifierElements(parser, cimInstance);
  
     // Get PROPERTY elements:     // Get PROPERTY elements:
   
     GetPropertyElements(parser, cimInstance);     GetPropertyElements(parser, cimInstance);
  
     // Get INSTANCE end tag:     // Get INSTANCE end tag:
   
     expectEndTag(parser, "INSTANCE");     expectEndTag(parser, "INSTANCE");
       }
  
     return true;     return true;
 } }
Line 3647 
Line 4089 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //    "expected INSTANCENAME element");       //    "expected INSTANCENAME element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",
                                  "expected $0 element", "INSTANCENAME");                                   "expected INSTANCENAME element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3664 
Line 4106 
       //   "expected INSTANCE element");       //   "expected INSTANCE element");
  
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
                                  "expected $0 element", "INSTANCE");                                   "expected INSTANCE element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3695 
Line 4137 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected CLASS element");       //   "expected CLASS element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
                                  "expected $0 element", "CLASS");                                   "expected CLASS element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3718 
Line 4160 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected INSTANCE element");       //   "expected INSTANCE element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
                                  "expected $0 element", "INSTANCE");                                   "expected INSTANCE element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3741 
Line 4183 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected QUALIFIER.DECLARATION element");       //   "expected QUALIFIER.DECLARATION element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",
                                  "expected $0 element", "QUALIFIER.DECLARATION");                                   "expected QUALIFIER.DECLARATION element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3773 
Line 4215 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Invalid or missing MESSAGE.ID attribute");       //   "Invalid or missing MESSAGE.ID attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",
                                  "Invalid or missing $0 attribute", "MESSAGE.ID");                                   "Invalid or missing MESSAGE.ID attribute");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3789 
Line 4231 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");       //   "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",
                                  "Invalid or missing $0 attribute", "MESSAGE.PROTOCOLVERSION");                                   "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3823 
Line 4265 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Missing IMETHODCALL.NAME attribute");       //   "Missing IMETHODCALL.NAME attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",
                                  "Missing $0 attribute",                                   "Missing IMETHODCALL.NAME attribute");
                                  "IMETHODCALL.NAME");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3842 
Line 4283 
  
 Boolean XmlReader::getIMethodResponseStartTag( Boolean XmlReader::getIMethodResponseStartTag(
     XmlParser& parser,     XmlParser& parser,
     const char*& name)      const char*& name,
       Boolean& isEmptyTag)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "IMETHODRESPONSE"))      if (!testStartTagOrEmptyTag(parser, entry, "IMETHODRESPONSE"))
         return false;         return false;
  
       isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
   
     // Get IMETHODRESPONSE.NAME attribute:     // Get IMETHODRESPONSE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name)) {     if (!entry.getAttributeValue("NAME", name)) {
Line 3858 
Line 4302 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Missing IMETHODRESPONSE.NAME attribute");       //   "Missing IMETHODRESPONSE.NAME attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",
                                  "Missing $0 attribute",                                   "Missing IMETHODRESPONSE.NAME attribute");
                                  "IMETHODRESPONSE.NAME");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3877 
Line 4320 
  
 Boolean XmlReader::getIParamValueTag( Boolean XmlReader::getIParamValueTag(
     XmlParser& parser,     XmlParser& parser,
     const char*& name)      const char*& name,
       Boolean& isEmptyTag)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "IPARAMVALUE"))      if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE"))
         return false;         return false;
  
       isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
   
     // Get IPARAMVALUE.NAME attribute:     // Get IPARAMVALUE.NAME attribute:
  
     if (!entry.getAttributeValue("NAME", name)) {     if (!entry.getAttributeValue("NAME", name)) {
Line 3893 
Line 4339 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Missing IPARAMVALUE.NAME attribute");       //   "Missing IPARAMVALUE.NAME attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",
                                  "Missing $0 attribute",                                   "Missing IPARAMVALUE.NAME attribute");
                                  "IPARAMVALUE.NAME");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 3905 
Line 4350 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // rejectNullIParamValue()
   //
   //------------------------------------------------------------------------------
   
   void XmlReader::rejectNullIParamValue(
       XmlParser& parser,
       Boolean isEmptyTag,
       const char* paramName)
   {
       if (isEmptyTag)
       {
           MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE",
               "A null value is not valid for IPARAMVALUE \"$0\".",
               paramName);
           throw XmlValidationError(parser.getLine(), mlParms);
       }
   }
   
   //------------------------------------------------------------------------------
   //
 // getBooleanValueElement() // getBooleanValueElement()
 // //
 //     Get an elements like: "<VALUE>FALSE</VALUE>" //     Get an elements like: "<VALUE>FALSE</VALUE>"
Line 3928 
Line 4393 
           // throw XmlValidationError(parser.getLine(),           // throw XmlValidationError(parser.getLine(),
           // "Expected VALUE element");           // "Expected VALUE element");
  
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",            MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
                                      "Expected $0 element", "VALUE");                                       "Expected VALUE element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
         }         }
Line 3950 
Line 4415 
       //   "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");       //   "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
  
       MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",       MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",
                                  "Invalid value for $0 element: must be $1 or $2",                                   "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");
                                  "VALUE", "\"TRUE\"", "\"FALSE\"");  
  
       throw XmlSemanticError(parser.getLine(), mlParms);       throw XmlSemanticError(parser.getLine(), mlParms);
     }     }
Line 3963 
Line 4427 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // getErrorElement()  //     DMTF CR Pending
 // //
 //     <!ELEMENT ERROR EMPTY>  //     <!ELEMENT ERROR (INSTANCE*)>
 //     <!ATTLIST ERROR //     <!ATTLIST ERROR
 //         CODE CDATA #REQUIRED //         CODE CDATA #REQUIRED
 //         DESCRIPTION CDATA #IMPLIED> //         DESCRIPTION CDATA #IMPLIED>
Line 3987 
Line 4451 
  
         // throw XmlValidationError(parser.getLine(),"Expected ERROR element");         // throw XmlValidationError(parser.getLine(),"Expected ERROR element");
  
         MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",          MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ERROR_ELEMENT",
                                    "Expected $0 element", "ERROR");                                     "Expected ERROR element");
  
         throw XmlValidationError(parser.getLine(), mlParms);         throw XmlValidationError(parser.getLine(), mlParms);
  
Line 4010 
Line 4474 
       // throw XmlValidationError(       // throw XmlValidationError(
       //       parser.getLine(), "missing ERROR.CODE attribute");       //       parser.getLine(), "missing ERROR.CODE attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",
                                  "missing $0 attribute",                                   "missing ERROR.CODE attribute");
                                  "ERROR.CODE");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 4024 
Line 4487 
  
     entry.getAttributeValue("DESCRIPTION", tmpDescription);     entry.getAttributeValue("DESCRIPTION", tmpDescription);
  
       cimException =
           PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);
   
     if (!empty)     if (!empty)
       {
           CIMInstance instance;
   
           while (getInstanceElement(parser, instance))
           {
               cimException.addError(instance);
           }
   
         expectEndTag(parser, "ERROR");         expectEndTag(parser, "ERROR");
       }
  
     cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);  
     return true;     return true;
 } }
  
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // getValueObjectElement() // getValueObjectElement()
 // //
Line 4055 
Line 4528 
     {     {
         object = CIMObject(cimInstance);         object = CIMObject(cimInstance);
     }     }
     else if (!XmlReader::getClassElement(parser, cimClass))      else if (XmlReader::getClassElement(parser, cimClass))
     {     {
         object = CIMObject(cimClass);         object = CIMObject(cimClass);
     }     }
Line 4067 
Line 4540 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Expected INSTANCE or CLASS element");       //   "Expected INSTANCE or CLASS element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",
                                  "Expected $0 or $1 element", "INSTANCE", "CLASS");                                   "Expected INSTANCE or CLASS element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 4103 
Line 4576 
     else if (!XmlReader::getClassPathElement(parser, reference))     else if (!XmlReader::getClassPathElement(parser, reference))
     {     {
  
       // l10n        // l10n 485
  
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //    "Expected INSTANCEPATH or CLASSPATH element");       //    "Expected INSTANCEPATH or CLASSPATH element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
                                  "Expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH");                                   "Expected INSTANCEPATH or CLASSPATH element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 4126 
Line 4599 
           // throw XmlValidationError(parser.getLine(),           // throw XmlValidationError(parser.getLine(),
           //               "Expected INSTANCE element");           //               "Expected INSTANCE element");
  
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",            MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
                                      "Expected $0 element", "INSTANCE");                                       "Expected INSTANCE element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
         }         }
Line 4146 
Line 4619 
           // throw XmlValidationError(parser.getLine(),           // throw XmlValidationError(parser.getLine(),
           // "Expected CLASS element");           // "Expected CLASS element");
  
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",            MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
                                      "Expected $0 element", "CLASS");                                       "Expected CLASS element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
         }         }
Line 4190 
Line 4663 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");       //   "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",        //l10n updated
                                  "Expected $0 or $1 element", "LOCALINSTANCEPATH", "LOCALCLASSPATH");        MessageLoaderParms mlParms("Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",
                                                                                                                   MISSING_ELEMENT_LOCALPATH);
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
Line 4209 
Line 4683 
           // throw XmlValidationError(parser.getLine(),           // throw XmlValidationError(parser.getLine(),
           //               "Expected INSTANCE element");           //               "Expected INSTANCE element");
  
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",            MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",
                                      "Expected $0 element", "INSTANCE");                                       "Expected INSTANCE element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
  
Line 4230 
Line 4704 
           // throw XmlValidationError(parser.getLine(),           // throw XmlValidationError(parser.getLine(),
           // "Expected CLASS element");           // "Expected CLASS element");
  
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",            MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",
                                      "Expected $0 element", "CLASS");                                       "Expected CLASS element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
  
Line 4310 
Line 4784 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected CLASSNAME or INSTANCENAME element");       //   "expected CLASSNAME or INSTANCENAME element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",
                                  "Expected $0 or $1 element", "CLASSNAME", "INSTANCENAME");                                   "Expected CLASSNAME or INSTANCENAME element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
  
     }     }
  
     return false;      PEGASUS_UNREACHABLE( return false; )
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 4353 
Line 4827 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "expected INSTANCEPATH or CLASSPATH element");       //   "expected INSTANCEPATH or CLASSPATH element");
  
       MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",        MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",
                                  "expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH");                                   "expected INSTANCEPATH or CLASSPATH element");
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 4387 
Line 4861 
         // throw XmlValidationError(parser.getLine(),         // throw XmlValidationError(parser.getLine(),
         // "Missing EXPMETHODCALL.NAME attribute");         // "Missing EXPMETHODCALL.NAME attribute");
  
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",          MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",
                                    "Missing $0 attribute",                                     "Missing EXPMETHODCALL.NAME attribute");
                                    "EXPMETHODCALL.NAME");  
  
         throw XmlValidationError(parser.getLine(), mlParms);         throw XmlValidationError(parser.getLine(), mlParms);
       }       }
Line 4405 
Line 4878 
  
 Boolean XmlReader::getEMethodResponseStartTag( Boolean XmlReader::getEMethodResponseStartTag(
     XmlParser& parser,     XmlParser& parser,
     const char*& name)      const char*& name,
       Boolean& isEmptyTag)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "EXPMETHODRESPONSE"))      if (!testStartTagOrEmptyTag(parser, entry, "EXPMETHODRESPONSE"))
         return false;         return false;
  
       isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
   
     // Get EXPMETHODRESPONSE.NAME attribute:     // Get EXPMETHODRESPONSE.NAME attribute:
  
  
Line 4421 
Line 4897 
         // throw XmlValidationError(         // throw XmlValidationError(
         //   parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute");         //   parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute");
  
         MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",          MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",
                                    "Missing $0 attribute",                                     "Missing EXPMETHODRESPONSE.NAME attribute");
                                    "EXPMETHODRESPONSE.NAME");  
  
         throw XmlValidationError(parser.getLine(), mlParms);         throw XmlValidationError(parser.getLine(), mlParms);
       }       }
Line 4456 
Line 4931 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Missing EXPPARAMVALUE.NAME attribute");       //   "Missing EXPPARAMVALUE.NAME attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",
                                  "Missing $0 attribute",                                   "Missing EXPPARAMVALUE.NAME attribute");
                                  "EXPPARAMVALUE.NAME");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 4493 
Line 4967 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //               "Missing METHODCALL.NAME attribute");       //               "Missing METHODCALL.NAME attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",
                                  "Missing $0 attribute",                                   "Missing METHODCALL.NAME attribute");
                                  "METHODCALL.NAME");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 4512 
Line 4985 
  
 Boolean XmlReader::getMethodResponseStartTag( Boolean XmlReader::getMethodResponseStartTag(
     XmlParser& parser,     XmlParser& parser,
     const char*& name)      const char*& name,
       Boolean& isEmptyTag)
 { {
     XmlEntry entry;     XmlEntry entry;
  
     if (!testStartTag(parser, entry, "METHODRESPONSE"))      if (!testStartTagOrEmptyTag(parser, entry, "METHODRESPONSE"))
         return false;         return false;
  
       isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);
   
     // Get METHODRESPONSE.NAME attribute:     // Get METHODRESPONSE.NAME attribute:
  
  
Line 4529 
Line 5005 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Missing METHODRESPONSE.NAME attribute");       //   "Missing METHODRESPONSE.NAME attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",
                                  "Missing $0 attribute",                                   "Missing METHODRESPONSE.NAME attribute");
                                  "METHODRESPONSE.NAME");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
Line 4546 
Line 5021 
 // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?> // <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
 // <!ATTLIST PARAMVALUE // <!ATTLIST PARAMVALUE
 //      %CIMName; //      %CIMName;
   //      %EmbeddedObject; #IMPLIED
 //      %ParamType;> //      %ParamType;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 4556 
Line 5032 
 { {
     XmlEntry entry;     XmlEntry entry;
     const char* name;     const char* name;
     CIMType type;      CIMType type=CIMTYPE_BOOLEAN;
     CIMValue value;     CIMValue value;
  
     if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))     if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))
Line 4573 
Line 5049 
       // throw XmlValidationError(parser.getLine(),       // throw XmlValidationError(parser.getLine(),
       //   "Missing PARAMVALUE.NAME attribute");       //   "Missing PARAMVALUE.NAME attribute");
  
       MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",        MessageLoaderParms mlParms("Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",
                                  "Missing $0 attribute",                                   "Missing PARAMVALUE.NAME attribute");
                                  "PARAMVALUE.NAME");  
  
       throw XmlValidationError(parser.getLine(), mlParms);       throw XmlValidationError(parser.getLine(), mlParms);
     }     }
  
       // Get PROPERTY.EMBEDDEDOBJECT
   
       String embeddedObject = getEmbeddedObjectAttribute(
           parser.getLine(), entry, "PARAMVALUE");
  
     // Get PARAMVALUE.PARAMTYPE attribute:     // Get PARAMVALUE.PARAMTYPE attribute:
  
     Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,     Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,
                                           "PARAMVALUE", "PARAMTYPE", false);                                           "PARAMVALUE", "PARAMTYPE", false);
  
     if (!empty)      if (empty)
       {
           gotType = false; // Can't distinguish array and non-array types
       }
       else
     {     {
         // Parse VALUE.REFERENCE and VALUE.REFARRAY type         // Parse VALUE.REFERENCE and VALUE.REFARRAY type
         if ( (type == CIMTYPE_REFERENCE) || !gotType )         if ( (type == CIMTYPE_REFERENCE) || !gotType )
Line 4620 
Line 5103 
                 effectiveType = type;                 effectiveType = type;
             }             }
  
               // If the EMBEDDEDOBJECT attribute is present with value "object"
               // then
               //     Convert the EmbeddedObject-encoded string into a CIMObject
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               Boolean isEmbeddedObject = String::equal(embeddedObject, "object");
               Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance");
               if(isEmbeddedObject || isEmbeddedInstance)
               {
                   // The EMBEDDEDOBJECT attribute is only valid on Parameters of type string
                   // The type must have been specified.
                   if (gotType && (type == CIMTYPE_STRING))
                   {
                     if(isEmbeddedObject)
                       effectiveType = CIMTYPE_OBJECT; // Used below by getValueElement() or getValueArrayElement()
                     else
                       effectiveType = CIMTYPE_INSTANCE;
                   }
                   else
                   {
                       // Error -- throw exception
                       // (the EmbeddedObject attribute may be applied only to entities that have the type String)
   
                       // l10n
   
                       // throw XmlValidationError(parser.getLine(),
                       //   "expected string type");
   
                       MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
                                        "The EMBEDDEDOBJECT attribute is only valid on string types.");
   
                       throw XmlValidationError(parser.getLine(), mlParms);
                   }
               }
   #else
               if (String::equal(embeddedObject, "object"))
               {
                   // The EMBEDDEDOBJECT attribute is only valid on Parameters of type string
                   // The type must have been specified.
                   if (gotType && (type == CIMTYPE_STRING))
                   {
                       // Used below by getValueElement() or getValueArrayElement()
                       effectiveType = CIMTYPE_OBJECT;
                   }
                   else
                   {
                       // Error -- throw exception
                       // (the EmbeddedObject attribute may be applied only to entities that have the type String)
   
                       // l10n
   
                       // throw XmlValidationError(parser.getLine(),
                       //   "expected string type");
   
                       MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
                                        "The EMBEDDEDOBJECT attribute is only valid on string types.");
   
                       throw XmlValidationError(parser.getLine(), mlParms);
                   }
               }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   
             if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&             if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&
                  !XmlReader::getValueElement(parser, effectiveType, value) )                  !XmlReader::getValueElement(parser, effectiveType, value) )
             {             {
                   gotType = false; // Can't distinguish array and non-array types
                 value.clear();    // Isn't necessary; should already be cleared                 value.clear();    // Isn't necessary; should already be cleared
             }             }
   
         }         }
  
         expectEndTag(parser, "PARAMVALUE");         expectEndTag(parser, "PARAMVALUE");
     }     }
  
   
     paramValue = CIMParamValue(name, value, gotType);     paramValue = CIMParamValue(name, value, gotType);
  
     return true;     return true;
Line 4641 
Line 5188 
 // //
 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)> // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
 // <!ATTLIST RETURNVALUE // <!ATTLIST RETURNVALUE
   //      %EmbeddedObject; #IMPLIED
 //      %ParamType;> //      %ParamType;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 4656 
Line 5204 
     if (!testStartTag(parser, entry, "RETURNVALUE"))     if (!testStartTag(parser, entry, "RETURNVALUE"))
         return false;         return false;
  
       // Get PROPERTY.EMBEDDEDOBJECT
   
       String embeddedObject = getEmbeddedObjectAttribute(
           parser.getLine(), entry, "RETURNVALUE");
   
     // Get RETURNVALUE.PARAMTYPE attribute:     // Get RETURNVALUE.PARAMTYPE attribute:
     // NOTE: Array type return values are not allowed (2/20/02)     // NOTE: Array type return values are not allowed (2/20/02)
  
Line 4680 
Line 5233 
           // throw XmlValidationError(parser.getLine(),           // throw XmlValidationError(parser.getLine(),
           //   "expected VALUE.REFERENCE element");           //   "expected VALUE.REFERENCE element");
  
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",            MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",
                                      "expected $0 element", "VALUE.REFERENCE");                                       "expected VALUE.REFERENCE element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
         }         }
Line 4695 
Line 5248 
             // If we don't know what type the value is, read it as a String             // If we don't know what type the value is, read it as a String
             type = CIMTYPE_STRING;             type = CIMTYPE_STRING;
         }         }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           Boolean isEmbeddedObject = String::equal(embeddedObject, "object");
           Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance");
           if(isEmbeddedObject || isEmbeddedInstance)
           {
               if (gotType && (type == CIMTYPE_STRING))
               {
                   if(isEmbeddedObject)
                     type = CIMTYPE_OBJECT; // Used below by getValueElement() or getValueArrayElement()
                   else
                     type = CIMTYPE_INSTANCE;
               }
               else
               {
                   // Error -- throw exception
                   // (the EmbeddedObject attribute may be applied only to entities that have the type String)
  
                   // l10n
   
                   // throw XmlValidationError(parser.getLine(),
                   //   "expected string type");
   
                   MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
                                    "The EMBEDDEDOBJECT attribute is only valid on string types.");
   
                   throw XmlValidationError(parser.getLine(), mlParms);
               }
           }
   #else
           if (String::equal(embeddedObject, "object"))
           {
               if (gotType && (type == CIMTYPE_STRING))
               {
                   type = CIMTYPE_OBJECT;  // Used below by getValueElement()
               }
               else
               {
                   // Error -- throw exception
                   // (the EmbeddedObject attribute may be applied only to entities that have the type String)
   
                   // l10n
   
                   // throw XmlValidationError(parser.getLine(),
                   //   "expected string type");
   
                   MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",
                                    "The EMBEDDEDOBJECT attribute is only valid on string types.");
   
                   throw XmlValidationError(parser.getLine(), mlParms);
               }
           }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
         if ( !XmlReader::getValueElement(parser, type, returnValue) )         if ( !XmlReader::getValueElement(parser, type, returnValue) )
         {         {
  
Line 4704 
Line 5308 
           // throw XmlValidationError(parser.getLine(),           // throw XmlValidationError(parser.getLine(),
           //   "expected VALUE element");           //   "expected VALUE element");
  
           MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",                  MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",
                                      "expected $0 element", "VALUE");                                       "expected VALUE element");
  
           throw XmlValidationError(parser.getLine(), mlParms);           throw XmlValidationError(parser.getLine(), mlParms);
         }         }

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