pegasus/src/Pegasus/Common/XmlReader.cpp - diff

Return to XmlReader.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/XmlReader.cpp between version 1.61 and 1.92

version 1.61, 2002/07/25 16:19:45

version 1.92, 2003/10/16 23:25:03

Line 45

#include "CIMInstance.h"

#include "CIMObject.h"

#include "CIMParamValue.h"

#include "System.h"

#include "XmlConstants.h"

#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM

#include "OS400ConvertChar.h"

#endif

// l10n

#include <Pegasus/Common/MessageLoader.h>

#define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000))

#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

Line 70

Line 80

entry.type != XmlEntry::XML_DECLARATION ||

strcmp(entry.text, "xml") != 0)

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected <?xml ... ?> style declaration");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE",

"Expected <?xml ... ?> style declaration");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (!entry.getAttributeValue("version", xmlVersion))

if (!entry.getAttributeValue("version", xmlVersion)) {

throw XmlValidationError(

parser.getLine(), "missing xml.version attribute");

// l10n

// throw XmlValidationError(

// parser.getLine(), "missing xml.version attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_XML_ATTRIBUTE",

"missing xml.version attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (!entry.getAttributeValue("encoding", xmlEncoding))

{

Line 120

Line 148

entry.type != XmlEntry::START_TAG ||

strcmp(entry.text, tagName) != 0)

{

char message[MESSAGE_SIZE];

// l10n

sprintf(message, "Expected open of %s element", tagName);

throw XmlValidationError(parser.getLine(), message);

// char message[MESSAGE_SIZE];

// sprintf(message, "Expected open of %s element", tagName);

// throw XmlValidationError(parser.getLine(), message);

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN",

"Expected open of $0 element",

tagName);

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 140

Line 176

entry.type != XmlEntry::END_TAG ||

strcmp(entry.text, tagName) != 0)

{

char message[MESSAGE_SIZE];

sprintf(message, "Expected close of %s element, got %s instead",

// l10n

// char message[MESSAGE_SIZE];

// sprintf(message, "Expected close of %s element, got %s instead",

// tagName,entry.text);

// throw XmlValidationError(parser.getLine(), message);

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLOSE",

"Expected close of $0 element, got $1 instead",

tagName,entry.text);

throw XmlValidationError(parser.getLine(), message);

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 163

Line 208

entry.type != XmlEntry::EMPTY_TAG) ||

strcmp(entry.text, tagName) != 0)

{

char message[MESSAGE_SIZE];

// l10n

sprintf(message,

"Expected either open or open/close %s element", tagName);

// char message[MESSAGE_SIZE];

throw XmlValidationError(parser.getLine(), message);

// sprintf(message,

// "Expected either open or open/close %s element", tagName);

// throw XmlValidationError(parser.getLine(), message);

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPENCLOSE",

"Expected either open or open/close $0 element",

tagName);

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 184

Line 237

(entry.type != XmlEntry::CONTENT &&

entry.type != XmlEntry::CDATA))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected content of CDATA");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA",

"Expected content of CDATA");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

Line 297

Line 358

XmlEntry entry;

XmlReader::expectStartTag(parser, entry, "CIM");

if (!entry.getAttributeValue("CIMVERSION", cimVersion))

if (!entry.getAttributeValue("CIMVERSION", cimVersion)) {

throw XmlValidationError(

parser.getLine(), "missing CIM.CIMVERSION attribute");

// l10n

if (!entry.getAttributeValue("DTDVERSION", dtdVersion))

// throw XmlValidationError(

throw XmlValidationError(

// parser.getLine(), "missing CIM.CIMVERSION attribute");

parser.getLine(), "missing CIM.DTDVERSION attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",

"missing CIM.CIMVERSION attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (!entry.getAttributeValue("DTDVERSION", dtdVersion)){

// l10n

// throw XmlValidationError(

// parser.getLine(), "missing CIM.DTDVERSION attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",

"missing CIM.DTDVERSION attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

//------------------------------------------------------------------------------

Line 314

Line 393

//------------------------------------------------------------------------------

String XmlReader::getCimNameAttribute(

CIMName XmlReader::getCimNameAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName,

Line 324

Line 403

if (!entry.getAttributeValue("NAME", name))

{

// l10n

// char buffer[MESSAGE_SIZE];

// sprintf(buffer, "missing %s.NAME attribute", elementName);

// throw XmlValidationError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

sprintf(buffer, "missing %s.NAME attribute", elementName);

sprintf(buffer, "%s.NAME", elementName);

throw XmlValidationError(lineNumber, buffer);

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

buffer);

throw XmlValidationError(lineNumber, mlParms);

}

if (acceptNull && name.size() == 0)

return name;

return CIMName ();

if (!CIMName::legal(name))

{

#ifdef PEGASUS_SNIA_INTEROP_TEST

// In testing, replace illegal CIMName with this value to avoid the

// exception and let xml parsing continue. THIS IS TEMP.

name = "BADNAMESUBSTITUTEDBYPEGASUSCLIENT";

#else

// l10n

// char buffer[MESSAGE_SIZE];

// sprintf(buffer, "Illegal value for %s.NAME attribute", elementName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

sprintf(buffer, "Illegal value for %s.NAME attribute", elementName);

sprintf(buffer, "%s.NAME", elementName);

throw XmlSemanticError(lineNumber, buffer);

}

return name;

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

#endif

}

return CIMName (name);

}

//------------------------------------------------------------------------------

Line 359

Line 467

if (!entry.getAttributeValue("CLASSNAME", name))

{

// l10n

// char buffer[MESSAGE_SIZE];

// sprintf(buffer, "missing %s.CLASSNAME attribute", elementName);

// throw XmlValidationError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

sprintf(buffer, "missing %s.CLASSNAME attribute", elementName);

sprintf(buffer, "%s.CLASSNAME", elementName);

throw XmlValidationError(lineNumber, buffer);

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

buffer);

throw XmlValidationError(lineNumber, mlParms);

}

if (!CIMName::legal(name))

{

// l10n

// char buffer[MESSAGE_SIZE];

// sprintf(buffer,

// "Illegal value for %s.CLASSNAME attribute", elementName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

sprintf(buffer,

sprintf(buffer, "%s.CLASSNAME", elementName);

"Illegal value for %s.CLASSNAME attribute", elementName);

throw XmlSemanticError(lineNumber, buffer);

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return name;

Line 383

Line 517

//------------------------------------------------------------------------------

String XmlReader::getClassOriginAttribute(

CIMName XmlReader::getClassOriginAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

Line 391

Line 525

String name;

if (!entry.getAttributeValue("CLASSORIGIN", name))

return String();

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))

{

// l10n

// char buffer[MESSAGE_SIZE];

// sprintf(buffer,

// "Illegal value for %s.CLASSORIGIN attribute", tagName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

sprintf(buffer,

sprintf(buffer, "%s.CLASSORIGIN", tagName);

"Illegal value for %s.CLASSORIGIN attribute", tagName);

throw XmlSemanticError(lineNumber, buffer);

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return name;

Line 412

Line 563

//------------------------------------------------------------------------------

String XmlReader::getReferenceClassAttribute(

CIMName XmlReader::getReferenceClassAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

Line 420

Line 571

String name;

if (!entry.getAttributeValue("REFERENCECLASS", name))

return String();

return CIMName();

if (!CIMName::legal(name))

{

#ifdef PEGASUS_SNIA_INTEROP_TEST

name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME";

return name;

#endif

// l10n

// char buffer[MESSAGE_SIZE];

// sprintf(buffer,

// "Illegal value for %s.REFERENCECLASS attribute", elementName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

sprintf(buffer,

sprintf(buffer, "%s.REFERENCECLASS", elementName);

"Illegal value for %s.REFERENCECLASS attribute", elementName);

throw XmlSemanticError(lineNumber, buffer);

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return name;

Line 441

Line 608

//------------------------------------------------------------------------------

String XmlReader::getSuperClassAttribute(

CIMName XmlReader::getSuperClassAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

Line 449

Line 616

String superClass;

if (!entry.getAttributeValue("SUPERCLASS", superClass))

return String();

return CIMName();

if (!CIMName::legal(superClass))

{

// l10n

// char buffer[MESSAGE_SIZE];

// sprintf(

// buffer, "Illegal value for %s.SUPERCLASS attribute", tagName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

sprintf(

sprintf(buffer, "%s.SUPERCLASS", tagName);

buffer, "Illegal value for %s.SUPERCLASS attribute", tagName);

throw XmlSemanticError(lineNumber, buffer);

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return superClass;

Line 480

Line 659

//------------------------------------------------------------------------------

CIMType XmlReader::getCimTypeAttribute(

Boolean XmlReader::getCimTypeAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

CIMType& cimType, // Output parameter

const char* tagName,

const char* attributeName,

Boolean required)

Line 493

Line 673

{

if (required)

{

// l10n

// char message[MESSAGE_SIZE];

// sprintf(message, "missing %s.%s attribute", tagName, attributeName);

// throw XmlValidationError(lineNumber, message);

char message[MESSAGE_SIZE];

sprintf(message, "missing %s.%s attribute", tagName, attributeName);

sprintf(message, "%s.%s", tagName, attributeName);

throw XmlValidationError(lineNumber, message);

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

message);

throw XmlValidationError(lineNumber, mlParms);

}

else

{

return CIMTYPE_NONE;

return false;

}

CIMType type = CIMTYPE_NONE;

CIMType type = CIMTYPE_BOOLEAN;

Boolean unrecognizedType = false;

if (strcmp(typeName, "boolean") == 0)

type = CIMTYPE_BOOLEAN;

Line 535

Line 729

type = CIMTYPE_REAL64;

else if (strcmp(typeName, "reference") == 0)

type = CIMTYPE_REFERENCE;

else unrecognizedType = true;

if ((type == CIMTYPE_NONE) ||

if (unrecognizedType ||

((type == CIMTYPE_REFERENCE) &&

(strcmp(attributeName, "PARAMTYPE") != 0)))

{

char message[MESSAGE_SIZE];

// l10n

sprintf(message, "Illegal value for %s.%s attribute", tagName,

attributeName);

// char message[MESSAGE_SIZE];

throw XmlSemanticError(lineNumber, message);

// sprintf(message, "Illegal value for %s.%s attribute", tagName,

// attributeName);

// throw XmlSemanticError(lineNumber, message);

char buffer[MESSAGE_SIZE];

sprintf(buffer, "%s.%s", tagName, attributeName);

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return type;

cimType = type;

return true;

}

//------------------------------------------------------------------------------

Line 570

Line 777

if (!required)

return defaultValue;

// l10n

// char buffer[62];

// sprintf(buffer, "missing required %s.%s attribute",

// attributeName, tagName);

// throw XmlValidationError(lineNumber, buffer);

char buffer[62];

sprintf(buffer, "missing required %s.%s attribute",

sprintf(buffer, "%s.%s", attributeName, tagName);

attributeName, tagName);

MessageLoaderParms mlParms("Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",

"missing required $0 attribute",

buffer);

throw XmlValidationError(lineNumber, buffer);

throw XmlValidationError(lineNumber, mlParms);

}

if (strcmp(tmp, "true") == 0)

Line 582

Line 800

else if (strcmp(tmp, "false") == 0)

return false;

// l10n

// char buffer[62];

// sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[62];

sprintf(buffer, "Bad %s.%s attribute value", attributeName, tagName);

sprintf(buffer, "%s.%s", attributeName, tagName);

throw XmlSemanticError(lineNumber, buffer);

MessageLoaderParms mlParms("Common.XmlReader.INVALID_ATTRIBUTE",

"Invalid $0 attribute value",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

return false;

}

Line 672

Line 902

return true;

}

inline Uint8 _hexCharToNumeric(const char c)

static inline Uint8 _hexCharToNumeric(const char c)

{

Uint8 n;

Line 686

Line 916

return n;

}

// 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)

{

Uint32 i;

Array<Uint8> utf8Chars;

for (i=0; i<uriString.size(); i++)

{

if (uriString[i] == '%')

{

if (i+2 >= uriString.size())

{

// l10n

// throw ParseError("Invalid URI encoding");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING",

"Invalid URI encoding");

throw ParseError(MessageLoader::getMessage(mlParms));

}

Uint8 digit1 = _hexCharToNumeric(char(uriString[++i]));

Uint8 digit2 = _hexCharToNumeric(char(uriString[++i]));

if ( (digit1 > 15) || (digit2 > 15) )

{

// l10n

// throw ParseError("Invalid URI encoding");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING",

"Invalid URI encoding");

throw ParseError(MessageLoader::getMessage(mlParms));

}

Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);

utf8Chars.append((Uint8)decodedChar);

}

else

{

utf8Chars.append((Uint8)uriString[i]);

}

// 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(),STRING_FLAG_UTF8);

}

else

{

return String();

}

//------------------------------------------------------------------------------

// stringToSignedInteger

Line 733

Line 1026

while (isxdigit(*p))

{

// Make sure we won't overflow when we multiply by 16

if (x < PEGASUS_LLONG_MIN/16)

if (x < PEGASUS_SINT64_MIN/16)

{

return false;

}

Line 741

Line 1034

// Make sure we don't overflow when we add the next digit

Sint64 newDigit = Sint64(_hexCharToNumeric(*p++));

if (PEGASUS_LLONG_MIN - x > -newDigit)

if (PEGASUS_SINT64_MIN - x > -newDigit)

{

return false;

}

Line 756

Line 1049

// overflow error

if (!negative)

{

if (x == PEGASUS_LLONG_MIN)

if (x == PEGASUS_SINT64_MIN)

{

return false;

}

Line 784

Line 1077

while (isdigit(*p))

{

// Make sure we won't overflow when we multiply by 10

if (x < PEGASUS_LLONG_MIN/10)

if (x < PEGASUS_SINT64_MIN/10)

{

return false;

}

Line 792

Line 1085

// Make sure we won't overflow when we add the next digit

Sint64 newDigit = (*p++ - '0');

if (PEGASUS_LLONG_MIN - x > -newDigit)

if (PEGASUS_SINT64_MIN - x > -newDigit)

{

return false;

}

Line 807

Line 1100

// overflow error

if (!negative)

{

if (x == PEGASUS_LLONG_MIN)

if (x == PEGASUS_SINT64_MIN)

{

return false;

}

Line 853

Line 1146

while (isxdigit(*p))

{

// Make sure we won't overflow when we multiply by 16

if (x > PEGASUS_ULLONG_MAX/16)

if (x > PEGASUS_UINT64_MAX/16)

{

return false;

}

Line 861

Line 1154

// We can't overflow when we add the next digit

Uint64 newDigit = Uint64(_hexCharToNumeric(*p++));

if (PEGASUS_ULLONG_MAX - x < newDigit)

if (PEGASUS_UINT64_MAX - x < newDigit)

{

return false;

}

Line 887

Line 1180

while (isdigit(*p))

{

// Make sure we won't overflow when we multiply by 10

if (x > PEGASUS_ULLONG_MAX/10)

if (x > PEGASUS_UINT64_MAX/10)

{

return false;

}

Line 895

Line 1188

// Make sure we won't overflow when we add the next digit

Uint64 newDigit = (*p++ - '0');

if (PEGASUS_ULLONG_MAX - x < newDigit)

if (PEGASUS_UINT64_MAX - x < newDigit)

{

return false;

}

Line 932

Line 1225

{

case CIMTYPE_BOOLEAN:

{

if (CompareNoCase(valueString, "TRUE") == 0)

if (System::strcasecmp(valueString, "TRUE") == 0)

return CIMValue(true);

else if (CompareNoCase(valueString, "FALSE") == 0)

else if (System::strcasecmp(valueString, "FALSE") == 0)

return CIMValue(false);

else

else {

throw XmlSemanticError(

lineNumber, "Bad boolean value");

// l10n

// throw XmlSemanticError(

// lineNumber, "Invalid boolean value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_BOOLEAN_VALUE",

"Invalid boolean value");

throw XmlSemanticError(lineNumber, mlParms);

}

case CIMTYPE_STRING:

{

return CIMValue(String(valueString));

return CIMValue(String(valueString, STRING_FLAG_UTF8));

}

case CIMTYPE_CHAR16:

{

if (strlen(valueString) != 1)

throw XmlSemanticError(lineNumber, "Bad char16 value");

return CIMValue(Char16(valueString[0]));

// remove this test, utf-8 can be up to 6 bytes per char

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, STRING_FLAG_UTF8);

if (tmp.size() != 1)

{

// l10n

// throw XmlSemanticError(lineNumber, "Invalid char16 value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE",

"Invalid char16 value");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(tmp[0]);

}

case CIMTYPE_UINT8:

Line 963

Line 1291

if (!stringToUnsignedInteger(valueString, x))

{

throw XmlSemanticError(

lineNumber, "Bad unsigned integer value");

// l10n

// throw XmlSemanticError(

// lineNumber, "Invalid unsigned integer value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_UI_VALUE",

"Invalid unsigned integer value");

throw XmlSemanticError(lineNumber, mlParms);

}

switch (type)

Line 973

Line 1310

{

if (x >= (Uint64(1)<<8))

{

throw XmlSemanticError(

lineNumber, "Uint8 value out of range");

// l10n

// throw XmlSemanticError(

// lineNumber, "Uint8 value out of range");

MessageLoaderParms mlParms("Common.XmlReader.U8_VALUE_OUT_OF_RANGE",

"Uint8 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint8(x));

}

Line 982

Line 1327

{

if (x >= (Uint64(1)<<16))

{

throw XmlSemanticError(

lineNumber, "Uint16 value out of range");

// l10n

// throw XmlSemanticError(

// lineNumber, "Uint16 value out of range");

MessageLoaderParms mlParms("Common.XmlReader.U16_VALUE_OUT_OF_RANGE",

"Uint16 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint16(x));

}

Line 991

Line 1345

{

if (x >= (Uint64(1)<<32))

{

throw XmlSemanticError(

lineNumber, "Uint32 value out of range");

// l10n

// throw XmlSemanticError(

// lineNumber, "Uint32 value out of range");

MessageLoaderParms mlParms("Common.XmlReader.U32_VALUE_OUT_OF_RANGE",

"Uint32 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint32(x));

}

Line 1010

Line 1372

if (!stringToSignedInteger(valueString, x))

{

throw XmlSemanticError(

lineNumber, "Bad signed integer value");

// l10n

// throw XmlSemanticError(

// lineNumber, "Invalid signed integer value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_SI_VALUE",

"Invalid signed integer value");

throw XmlSemanticError(lineNumber, mlParms);

}

switch (type)

Line 1020

Line 1391

{

if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )

{

throw XmlSemanticError(

lineNumber, "Sint8 value out of range");

// l10n

// throw XmlSemanticError(

// lineNumber, "Sint8 value out of range");

MessageLoaderParms mlParms("Common.XmlReader.S8_VALUE_OUT_OF_RANGE",

"Sint8 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint8(x));

}

Line 1029

Line 1408

{

if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )

{

throw XmlSemanticError(

lineNumber, "Sint16 value out of range");

// l10n

// throw XmlSemanticError(

// lineNumber, "Sint16 value out of range");

MessageLoaderParms mlParms("Common.XmlReader.S16_VALUE_OUT_OF_RANGE",

"Sint16 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint16(x));

}

Line 1038

Line 1425

{

if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )

{

throw XmlSemanticError(

lineNumber, "Sint32 value out of range");

// l10n

// throw XmlSemanticError(

// lineNumber, "Sint32 value out of range");

MessageLoaderParms mlParms("Common.XmlReader.S32_VALUE_OUT_OF_RANGE",

"Sint32 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint32(x));

}

Line 1054

Line 1449

try

{

// KS 20021002 - Exception if no datatime value. Test for

// zero length and leave the NULL value in the variable

// Bugzilla 137 Adds the following if line.

// Expect this to become permanent but test only for now

#ifdef PEGASUS_SNIA_INTEROP_TEST

if (strlen(valueString) != 0)

#endif

tmp.set(valueString);

}

catch (BadDateTimeFormat&)

catch (InvalidDateTimeFormatException&)

{

throw XmlSemanticError(lineNumber, "Bad datetime value");

// l10n

// throw XmlSemanticError(lineNumber, "Invalid datetime value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_DATETIME_VALUE",

"Invalid datetime value");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(tmp);

Line 1068

Line 1478

{

Real64 x;

if (!stringToReal(valueString, x))

if (!stringToReal(valueString, x)) {

throw XmlSemanticError(lineNumber, "Bad real number value");

// l10n

// throw XmlSemanticError(lineNumber, "Invalid real number value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE",

"Invalid real number value");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Real32(x));

}

Line 1078

Line 1496

{

Real64 x;

if (!stringToReal(valueString, x))

if (!stringToReal(valueString, x)) {

throw XmlSemanticError(lineNumber, "Bad real number value");

// l10n

// throw XmlSemanticError(lineNumber, "Invalid real number value");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE",

"Invalid real number value");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(x);

}

Line 1088

Line 1514

break;

}

throw XmlSemanticError(lineNumber, "malformed XML");

// l10n

// throw XmlSemanticError(lineNumber, "malformed XML");

MessageLoaderParms mlParms("Common.XmlReader.MALFORMED_XML",

"malformed XML");

throw XmlSemanticError(lineNumber, mlParms);

return false;

}

Line 1124

Line 1558

expectEndTag(parser, "VALUE");

}

#ifdef PEGASUS_SNIA_INTEROP_TEST

// KS 20021004 - tries to put value in even if empty.

// Think this is general problem with empty value

// Need to check meaning of (#PCDATA) - Does it allow empty.

// Bugzilla tbd

if (!empty)

#endif

value = stringToValue(parser.getLine(), valueString,type);

return true;

Line 1147

Line 1587

if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))

{

if (required)

if (required) {

throw XmlValidationError(parser.getLine(),"Expected VALUE element");

// l10n

// throw XmlValidationError(parser.getLine(),"Expected VALUE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"Expected VALUE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

return false;

}

Line 1164

Line 1615

expectEndTag(parser, "VALUE");

}

str = valueString;

str = String(valueString,STRING_FLAG_UTF8);

return true;

}

Line 1375

Line 1826

//------------------------------------------------------------------------------

Uint32 XmlReader::getFlavor(

CIMFlavor XmlReader::getFlavor(

XmlEntry& entry,

Uint32 lineNumber,

const char* tagName)

Line 1402

Line 1853

// Start with CIMFlavor::NONE. Defaults are specified in the

// getCimBooleanAttribute() calls above.

Uint32 flavor = CIMFlavor::NONE;

CIMFlavor flavor = CIMFlavor (CIMFlavor::NONE);

if (overridable)

flavor |= CIMFlavor::OVERRIDABLE;

flavor.addFlavor (CIMFlavor::OVERRIDABLE);

else

flavor |= CIMFlavor::DISABLEOVERRIDE;

flavor.addFlavor (CIMFlavor::DISABLEOVERRIDE);

if (toSubClass)

flavor |= CIMFlavor::TOSUBCLASS;

flavor.addFlavor (CIMFlavor::TOSUBCLASS);

else

flavor |= CIMFlavor::RESTRICTED;

flavor.addFlavor (CIMFlavor::RESTRICTED);

if (toInstance)

flavor |= CIMFlavor::TOINSTANCE;

flavor.addFlavor (CIMFlavor::TOINSTANCE);

if (translatable)

flavor |= CIMFlavor::TRANSLATABLE;

flavor.addFlavor (CIMFlavor::TRANSLATABLE);

return flavor;

}

Line 1440

Line 1891

//------------------------------------------------------------------------------

Uint32 XmlReader::getOptionalScope(XmlParser& parser)

CIMScope XmlReader::getOptionalScope(XmlParser& parser)

{

XmlEntry entry;

CIMScope scope;

if (!parser.next(entry))

return false;

return scope; // No SCOPE element found; return the empty scope

Boolean isEmptyTag = entry.type == XmlEntry::EMPTY_TAG;

Line 1453

Line 1905

entry.type != XmlEntry::START_TAG) ||

strcmp(entry.text, "SCOPE") != 0)

{

// No SCOPE element found; return the empty scope

parser.putBack(entry);

return 0;

return scope;

}

Uint32 line = parser.getLine();

Uint32 scope = 0;

if (getCimBooleanAttribute(line, entry, "SCOPE", "CLASS", false, false))

scope |= CIMScope::CLASS;

scope.addScope (CIMScope::CLASS);

if (getCimBooleanAttribute(

line, entry, "SCOPE", "ASSOCIATION", false, false))

scope |= CIMScope::ASSOCIATION;

scope.addScope (CIMScope::ASSOCIATION);

if (getCimBooleanAttribute(

line, entry, "SCOPE", "REFERENCE", false, false))

scope |= CIMScope::REFERENCE;

scope.addScope (CIMScope::REFERENCE);

if (getCimBooleanAttribute(line, entry, "SCOPE", "PROPERTY", false, false))

scope |= CIMScope::PROPERTY;

scope.addScope (CIMScope::PROPERTY);

if (getCimBooleanAttribute(line, entry, "SCOPE", "METHOD", false, false))

scope |= CIMScope::METHOD;

scope.addScope (CIMScope::METHOD);

if (getCimBooleanAttribute(line, entry, "SCOPE", "PARAMETER", false, false))

scope |= CIMScope::PARAMETER;

scope.addScope (CIMScope::PARAMETER);

if (getCimBooleanAttribute(line, entry, "SCOPE", "INDICATION",false, false))

scope |= CIMScope::INDICATION;

scope.addScope (CIMScope::INDICATION);

if (!isEmptyTag)

expectEndTag(parser, "SCOPE");

Line 1514

Line 1966

// Get QUALIFIER.NAME attribute:

String name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");

CIMName name = getCimNameAttribute(parser.getLine(), entry, "QUALIFIER");

// Get QUALIFIER.TYPE attribute:

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "QUALIFIER");

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER");

// Get QUALIFIER.PROPAGATED

Line 1527

Line 1980

// Get flavor oriented attributes:

Uint32 flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");

CIMFlavor flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");

// Get VALUE or VALUE.ARRAY element:

Line 1566

Line 2019

{

container.addQualifier(qualifier);

}

catch (AlreadyExists&)

catch (AlreadyExistsException&)

{

throw XmlSemanticError(parser.getLine(), "duplicate qualifier");

// l10n

// throw XmlSemanticError(parser.getLine(), "duplicate qualifier");

MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_QUALIFIER",

"duplicate qualifier");

throw XmlSemanticError(parser.getLine(), mlParms);

}

Line 1597

Line 2058

// Get PROPERTY.NAME attribute:

String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");

CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");

// Get PROPERTY.CLASSORIGIN attribute:

String classOrigin =

CIMName classOrigin =

getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");

// Get PROPERTY.PROPAGATED

Line 1611

Line 2072

// Get PROPERTY.TYPE attribute:

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");

// Create property: Sets type and !isarray

CIMValue value(type, false);

property = CIMProperty(name, value, 0, String(), classOrigin, propagated);

property = CIMProperty(name, value, 0, CIMName(), classOrigin, propagated);

if (!empty)

{

Line 1661

Line 2123

if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)

{

// l10n

// char message[128];

// sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");

// throw XmlSemanticError(lineNumber, message);

char message[128];

sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");

sprintf(message, "%s.%s", tagName, "ARRAYSIZE");

throw XmlSemanticError(lineNumber, message);

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE",

"Illegal value for $0",

message);

throw XmlSemanticError(lineNumber, mlParms);

}

value = Uint32(arraySize);

Line 1699

Line 2172

// Get PROPERTY.NAME attribute:

String name =

CIMName name =

getCimNameAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");

// Get PROPERTY.TYPE attribute:

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY.ARRAY");

// Get PROPERTY.ARRAYSIZE attribute:

Line 1713

Line 2187

// Get PROPERTY.CLASSORIGIN attribute:

String classOrigin

CIMName classOrigin

= getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");

// Get PROPERTY.ARRAY.PROPAGATED

Line 1725

Line 2199

CIMValue value(type, true, arraySize);

property = CIMProperty(

name, value, arraySize, String(), classOrigin, propagated);

name, value, arraySize, CIMName(), classOrigin, propagated);

if (!empty)

{

Line 1739

Line 2213

{

if (arraySize && arraySize != value.getArraySize())

{

throw XmlSemanticError(parser.getLine(),

// l10n

// throw XmlSemanticError(parser.getLine(),

// "ARRAYSIZE attribute and value-array size are different");

MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT",

"ARRAYSIZE attribute and value-array size are different");

throw XmlSemanticError(parser.getLine(), mlParms);

}

property.setValue(value);

Line 1768

Line 2250

if (!testStartTag(parser, entry, "HOST"))

return false;

#ifdef PEGASUS_SNIA_INTEROP_TEST

// Temp code to allow empty HOST field.

// SNIA CIMOMs return empty field particularly on enumerateinstance.

// Simply substitute a string for the empty.

if (!parser.next(entry))

throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());

if (entry.type == XmlEntry::CONTENT)

host = String(entry.text,STRING_FLAG_UTF8);

else

{

parser.putBack(entry);

host = "HOSTNAMEINSERTEDBYPEGASUSCLIENT";

}

#else

if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected content of HOST element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT",

"expected content of HOST element");

}

host = entry.text;

throw XmlValidationError(parser.getLine(), mlParms);

}

host = String(entry.text,STRING_FLAG_UTF8);

#endif

expectEndTag(parser, "HOST");

return true;

}

Line 1792

Line 2299

Boolean XmlReader::getNameSpaceElement(

XmlParser& parser,

String& nameSpaceComponent)

CIMName& nameSpaceComponent)

{

XmlEntry entry;

Line 1827

Line 2334

if (!testStartTag(parser, entry, "LOCALNAMESPACEPATH"))

return false;

String nameSpaceComponent;

CIMName nameSpaceComponent;

while (getNameSpaceElement(parser, nameSpaceComponent))

{

if (nameSpace.size())

nameSpace += '/';

nameSpace.append('/');

nameSpace += nameSpaceComponent;

nameSpace.append(nameSpaceComponent.getString());

}

if (!nameSpace.size())

{

throw XmlValidationError(parser.getLine(),

"Expected one or more NAMESPACE elements within "

// l10n

"LOCALNAMESPACEPATH element");

// throw XmlValidationError(parser.getLine(),

// "Expected one or more NAMESPACE elements within "

// "LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",

"Expected one or more NAMESPACE elements within LOCALNAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

expectEndTag(parser, "LOCALNAMESPACEPATH");

Line 1869

Line 2386

if (!testStartTag(parser, entry, "NAMESPACEPATH"))

return false;

if (!getHostElement(parser, host))

if (!getHostElement(parser, host)) {

throw XmlValidationError(parser.getLine(), "expected HOST element");

if (!getLocalNameSpacePathElement(parser, nameSpace))

// l10n

{

throw XmlValidationError(parser.getLine(),

// throw XmlValidationError(parser.getLine(), "expected HOST element");

"expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_HOST_ELEMENT",

"expected HOST element");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

expectEndTag(parser, "NAMESPACEPATH");

Line 1894

Line 2428

Boolean XmlReader::getClassNameElement(

XmlParser& parser,

String& className,

CIMName& className,

Boolean required)

{

XmlEntry entry;

Line 1903

Line 2437

{

if (required)

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

else

return false;

}

Boolean empty = entry.type == XmlEntry::EMPTY_TAG;

className = getCimNameAttribute(

parser.getLine(), entry, "CLASSNAME", true);

parser.getLine(), entry, "CLASSNAME", false);

if (!empty)

expectEndTag(parser, "CLASSNAME");

Line 1929

Line 2470

//------------------------------------------------------------------------------

KeyBinding::Type XmlReader::getValueTypeAttribute(

CIMKeyBinding::Type XmlReader::getValueTypeAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

Line 1937

Line 2478

String tmp;

if (!entry.getAttributeValue("VALUETYPE", tmp))

return KeyBinding::STRING;

return CIMKeyBinding::STRING;

if (String::equal(tmp, "string"))

return KeyBinding::STRING;

return CIMKeyBinding::STRING;

else if (String::equal(tmp, "boolean"))

return KeyBinding::BOOLEAN;

return CIMKeyBinding::BOOLEAN;

else if (String::equal(tmp, "numeric"))

return KeyBinding::NUMERIC;

return CIMKeyBinding::NUMERIC;

// char buffer[MESSAGE_SIZE];

// sprintf(buffer,

// "Illegal value for %s.VALUETYPE attribute; "

// "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",

// elementName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

sprintf(buffer, "%s.VALUETYPE", elementName);

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",

"Illegal value for $0 attribute; CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", buffer);

sprintf(buffer,

throw XmlSemanticError(lineNumber, mlParms);

"Illegal value for %s.VALUETYPE attribute; "

"CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",

elementName);

throw XmlSemanticError(lineNumber, buffer);

return CIMKeyBinding::BOOLEAN;

return KeyBinding::BOOLEAN;

}

//------------------------------------------------------------------------------

Line 1969

Line 2520

Boolean XmlReader::getKeyValueElement(

XmlParser& parser,

KeyBinding::Type& type,

CIMKeyBinding::Type& type,

String& value)

{

XmlEntry entry;

Line 1989

Line 2540

throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());

if (entry.type == XmlEntry::CONTENT)

value = entry.text;

value = String(entry.text,STRING_FLAG_UTF8);

else

parser.putBack(entry);

Line 2011

Line 2562

Boolean XmlReader::getKeyBindingElement(

XmlParser& parser,

String& name,

CIMName& name,

String& value,

KeyBinding::Type& type)

CIMKeyBinding::Type& type)

{

XmlEntry entry;

Line 2028

Line 2579

if (!getValueReferenceElement(parser, reference))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected KEYVALUE or VALUE.REFERENCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",

"Expected KEYVALUE or VALUE.REFERENCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

type = KeyBinding::REFERENCE;

type = CIMKeyBinding::REFERENCE;

value = reference.toString();

}

Line 2056

Line 2615

Boolean XmlReader::getInstanceNameElement(

XmlParser& parser,

String& className,

Array<KeyBinding>& keyBindings)

Array<CIMKeyBinding>& keyBindings)

{

className.clear();

keyBindings.clear();

Line 2075

Line 2634

return true;

}

String name;

CIMName name;

KeyBinding::Type type;

CIMKeyBinding::Type type;

String value;

CIMObjectPath reference;

if (getKeyValueElement(parser, type, value))

{

// Use empty key name because none was specified

keyBindings.append(KeyBinding(name, value, type));

keyBindings.append(CIMKeyBinding(name, value, type));

}

else if (getValueReferenceElement(parser, reference))

{

// Use empty key name because none was specified

type = KeyBinding::REFERENCE;

type = CIMKeyBinding::REFERENCE;

value = reference.toString();

keyBindings.append(KeyBinding(name, value, type));

keyBindings.append(CIMKeyBinding(name, value, type));

}

else

{

while (getKeyBindingElement(parser, name, value, type))

keyBindings.append(KeyBinding(name, value, type));

keyBindings.append(CIMKeyBinding(name, value, type));

}

expectEndTag(parser, "INSTANCENAME");

Line 2108

Line 2667

CIMObjectPath& instanceName)

{

String className;

Array<KeyBinding> keyBindings;

Array<CIMKeyBinding> keyBindings;

if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))

return false;

instanceName.set(String(), String(), className, keyBindings);

instanceName.set(String(), CIMNamespaceName(), className, keyBindings);

return true;

}

Line 2139

Line 2698

if (!getNameSpacePathElement(parser, host, nameSpace))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected NAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

"expected NAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

String className;

Array<KeyBinding> keyBindings;

Array<CIMKeyBinding> keyBindings;

if (!getInstanceNameElement(parser, className, keyBindings))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

reference.set(host, nameSpace, className, keyBindings);

Line 2179

Line 2757

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

String className;

Array<KeyBinding> keyBindings;

Array<CIMKeyBinding> keyBindings;

if (!getInstanceNameElement(parser, className, keyBindings))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

reference.set(String(), nameSpace, className, keyBindings);

Line 2220

Line 2816

if (!getNameSpacePathElement(parser, host, nameSpace))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected NAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

"expected NAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

String className;

CIMName className;

if (!getClassNameElement(parser, className))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

reference.set(host, nameSpace, className);

Line 2259

Line 2873

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

String className;

CIMName className;

if (!getClassNameElement(parser, className))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

reference.set(String(), nameSpace, className);

Line 2303

Line 2935

if (entry.type != XmlEntry::START_TAG &&

entry.type != XmlEntry::EMPTY_TAG)

{

throw XmlValidationError(parser.getLine(),

"Expected one of the following start tags: "

// l10n

"CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "

"LOCALINSTANCEPATH, INSTANCENAME");

// throw XmlValidationError(parser.getLine(),

// "Expected one of the following start tags: "

// "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "

// "LOCALINSTANCEPATH, INSTANCENAME");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS",

"Expected one of the following start tags: CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (strcmp(entry.text, "CLASSPATH") == 0)

Line 2322

Line 2963

else if (strcmp(entry.text, "CLASSNAME") == 0)

{

parser.putBack(entry);

String className;

CIMName className;

getClassNameElement(parser, className);

reference.set(String(), String(), className);

reference.set(String(), CIMNamespaceName(), className);

}

else if (strcmp(entry.text, "INSTANCEPATH") == 0)

{

Line 2340

Line 2981

{

parser.putBack(entry);

String className;

Array<KeyBinding> keyBindings;

Array<CIMKeyBinding> keyBindings;

getInstanceNameElement(parser, className, keyBindings);

reference.set(String(), String(), className, keyBindings);

reference.set(String(), CIMNamespaceName(), className, keyBindings);

}

expectEndTag(parser, "VALUE.REFERENCE");

Line 2414

Line 3055

// Get PROPERTY.NAME attribute:

String name = getCimNameAttribute(

CIMName name = getCimNameAttribute(

parser.getLine(), entry, "PROPERTY.REFERENCE");

// Get PROPERTY.REFERENCECLASS attribute:

String referenceClass = getReferenceClassAttribute(

CIMName referenceClass = getReferenceClassAttribute(

parser.getLine(), entry, "PROPERTY.REFERENCE");

// Get PROPERTY.CLASSORIGIN attribute:

String classOrigin =

CIMName classOrigin =

getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.REFERENCE");

// Get PROPERTY.PROPAGATED

Line 2473

Line 3114

{

container.addProperty(property);

}

catch (AlreadyExists&)

catch (AlreadyExistsException&)

{

throw XmlSemanticError(parser.getLine(), "duplicate property");

// l10n

// throw XmlSemanticError(parser.getLine(), "duplicate property");

MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PROPERTY",

"duplicate property");

throw XmlSemanticError(parser.getLine(), mlParms);

}

Line 2504

Line 3153

// Get PARAMETER.NAME attribute:

String name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");

CIMName name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");

// Get PARAMETER.TYPE attribute:

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PARAMETER");

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER");

// Create parameter:

Line 2549

Line 3199

// Get PARAMETER.ARRAY.NAME attribute:

String name = getCimNameAttribute(

CIMName name = getCimNameAttribute(

parser.getLine(), entry, "PARAMETER.ARRAY");

// Get PARAMETER.ARRAY.TYPE attribute:

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY");

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER.ARRAY");

// Get PARAMETER.ARRAYSIZE attribute:

Line 2599

Line 3250

// Get PARAMETER.NAME attribute:

String name = getCimNameAttribute(

CIMName name = getCimNameAttribute(

parser.getLine(), entry, "PARAMETER.REFERENCE");

// Get PARAMETER.REFERENCECLASS attribute:

String referenceClass = getReferenceClassAttribute(

CIMName referenceClass = getReferenceClassAttribute(

parser.getLine(), entry, "PARAMETER.REFERENCE");

// Create parameter:

Line 2645

Line 3296

// Get PARAMETER.NAME attribute:

String name = getCimNameAttribute(

CIMName name = getCimNameAttribute(

parser.getLine(), entry, "PARAMETER.REFARRAY");

// Get PARAMETER.REFERENCECLASS attribute:

String referenceClass = getReferenceClassAttribute(

CIMName referenceClass = getReferenceClassAttribute(

parser.getLine(), entry, "PARAMETER.REFARRAY");

// Get PARAMETER.ARRAYSIZE attribute:

Line 2693

Line 3344

{

container.addParameter(parameter);

}

catch (AlreadyExists&)

catch (AlreadyExistsException&)

{

throw XmlSemanticError(parser.getLine(), "duplicate parameter");

// l10n

// throw XmlSemanticError(parser.getLine(), "duplicate parameter");

MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PARAMETER",

"duplicate parameter");

throw XmlSemanticError(parser.getLine(), mlParms);

}

Line 2727

Line 3386

// Get NAME attribute:

String name = getCimNameAttribute(

CIMName name = getCimNameAttribute(

parser.getLine(), entry, "QUALIFIER.DECLARATION");

// Get TYPE attribute:

CIMType type = getCimTypeAttribute(

CIMType type;

parser.getLine(), entry, "QUALIFIER.DECLARATION");

getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER.DECLARATION");

// Get ISARRAY attribute:

Line 2749

Line 3408

// Get flavor oriented attributes:

Uint32 flavor = getFlavor(entry,parser.getLine(), "QUALIFIER.DECLARATION");

CIMFlavor flavor = getFlavor (entry, parser.getLine (),

"QUALIFIER.DECLARATION");

// No need to look for interior elements if empty tag:

Uint32 scope = CIMScope::NONE;

CIMScope scope = CIMScope ();

CIMValue value;

Boolean gotValue = false;

if (!empty)

{

Line 2768

Line 3429

{

if (!isArray)

{

throw XmlSemanticError(parser.getLine(),

"VALUE.ARRAY element encountered without "

// l10n

"ISARRAY attribute");

// throw XmlSemanticError(parser.getLine(),

// "VALUE.ARRAY element encountered without "

// "ISARRAY attribute");

MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY",

"VALUE.ARRAY element encountered without ISARRAY attribute");

throw XmlSemanticError(parser.getLine(), mlParms);

}

if (arraySize && arraySize != value.getArraySize())

{

throw XmlSemanticError(parser.getLine(),

"VALUE.ARRAY size is not the same as "

// l10n

"ARRAYSIZE attribute");

// throw XmlSemanticError(parser.getLine(),

// "VALUE.ARRAY size is not the same as "

// "ARRAYSIZE attribute");

MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME",

"VALUE.ARRAY size is not the same as ARRAYSIZE attribute");

throw XmlSemanticError(parser.getLine(), mlParms);

}

gotValue = true;

}

else if (getValueElement(parser, type, value))

{

if (isArray)

{

throw XmlSemanticError(parser.getLine(),

// l10n

// throw XmlSemanticError(parser.getLine(),

// "ISARRAY attribute used but VALUE element encountered");

MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",

"ISARRAY attribute used but VALUE element encountered");

throw XmlSemanticError(parser.getLine(), mlParms);

}

gotValue = true;

}

// Now get the closing tag:

Line 2794

Line 3483

expectEndTag(parser, "QUALIFIER.DECLARATION");

}

if (value.getType() == CIMTYPE_NONE)

if (!gotValue)

{

if (isArray)

value.setNullValue(type, true, arraySize);

Line 2829

Line 3518

Boolean empty = entry.type == XmlEntry::EMPTY_TAG;

String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");

CIMName name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY");

String classOrigin =

CIMName classOrigin =

getClassOriginAttribute(parser.getLine(), entry, "PROPERTY");

Boolean propagated = getCimBooleanAttribute(

Line 2871

Line 3561

if (!testStartTag(parser, entry, "CLASS"))

return false;

String name = getCimNameAttribute(parser.getLine(), entry, "CLASS");

CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS");

String superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");

CIMName superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");

cimClass = CIMClass(name, superClass);

Line 2915

Line 3605

{

XmlEntry entry;

if (!testStartTag(parser, entry, "INSTANCE"))

if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE"))

return false;

Boolean empty = entry.type == XmlEntry::EMPTY_TAG;

String className = getClassNameAttribute(

parser.getLine(), entry, "INSTANCE");

cimInstance = CIMInstance(className);

if (!empty)

{

// Get QUALIFIER elements:

getQualifierElements(parser, cimInstance);

// Get PROPERTY elements:

GetPropertyElements(parser, cimInstance);

// Get INSTANCE end tag:

expectEndTag(parser, "INSTANCE");

}

return true;

}

Line 2960

Line 3652

if (!getInstanceNameElement(parser, instanceName))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get INSTANCE elements:

if (!getInstanceElement(parser, namedInstance))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"expected INSTANCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get VALUE.NAMEDINSTANCE end tag:

Line 2991

Line 3700

{

if (!getClassElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"expected CLASS element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 3006

Line 3723

{

if (!getInstanceElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"expected INSTANCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 3021

Line 3746

{

if (!getQualifierDeclElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected QUALIFIER.DECLARATION element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",

"expected QUALIFIER.DECLARATION element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 3044

Line 3777

// Get MESSAGE.ID:

if (!entry.getAttributeValue("ID", id))

if (!entry.getAttributeValue("ID", id)) {

throw XmlValidationError(parser.getLine(),

"Bad or missing MESSAGE.ID attribute");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Invalid or missing MESSAGE.ID attribute");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",

"Invalid or missing MESSAGE.ID attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get MESSAGE.PROTOCOLVERSION:

if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))

if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion)) {

throw XmlValidationError(parser.getLine(),

"Bad or missing MESSAGE.PROTOCOLVERSION attribute");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Invalid or missing MESSAGE.PROTOCOLVERSION attribute");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",

"Invalid or missing MESSAGE.PROTOCOLVERSION attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3074

Line 3826

// Get IMETHODCALL.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

if (!entry.getAttributeValue("NAME", name)) {

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing IMETHODCALL.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",

"Missing IMETHODCALL.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3098

Line 3861

// Get IMETHODRESPONSE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

if (!entry.getAttributeValue("NAME", name)) {

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing IMETHODRESPONSE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",

"Missing IMETHODRESPONSE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3122

Line 3895

// Get IPARAMVALUE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

if (!entry.getAttributeValue("NAME", name)) {

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing IPARAMVALUE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",

"Missing IPARAMVALUE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3148

Line 3930

{

if (required)

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected VALUE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"Expected VALUE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

return false;

}

expectContentOrCData(parser, entry);

if (CompareNoCase(entry.text, "TRUE") == 0)

if (System::strcasecmp(entry.text, "TRUE") == 0)

result = true;

else if (CompareNoCase(entry.text, "FALSE") == 0)

else if (System::strcasecmp(entry.text, "FALSE") == 0)

result = false;

else

else {

throw XmlSemanticError(parser.getLine(),

"Bad value for VALUE element: must be \"TRUE\" or \"FALSE\"");

// l10n

// throw XmlSemanticError(parser.getLine(),

// "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",

"Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");

throw XmlSemanticError(parser.getLine(), mlParms);

}

expectEndTag(parser, "VALUE");

Line 3189

Line 3988

if (!testStartTagOrEmptyTag(parser, entry, "ERROR"))

{

if (required)

if (required) {

throw XmlValidationError(parser.getLine(),"Expected ERROR element");

// l10n

// throw XmlValidationError(parser.getLine(),"Expected ERROR element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ERROR_ELEMENT",

"Expected ERROR element");

throw XmlValidationError(parser.getLine(), mlParms);

}

return false;

}

Line 3200

Line 4009

Uint32 tmpCode;

if (!entry.getAttributeValue("CODE", tmpCode))

if (!entry.getAttributeValue("CODE", tmpCode)) {

throw XmlValidationError(

parser.getLine(), "missing ERROR.CODE attribute");

// l10n

// throw XmlValidationError(

// parser.getLine(), "missing ERROR.CODE attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",

"missing ERROR.CODE attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get ERROR.DESCRIPTION:

Line 3247

Line 4067

}

else

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE or CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element");

throw XmlValidationError(parser.getLine(), mlParms);

}

expectEndTag(parser, "VALUE.OBJECT");

Line 3279

Line 4108

isInstance = true;

else if (!XmlReader::getClassPathElement(parser, reference))

{

throw XmlValidationError(parser.getLine(),

// l10n 485

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCEPATH or CLASSPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

"Expected INSTANCEPATH or CLASSPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

if (isInstance)

Line 3289

Line 4126

if (!XmlReader::getInstanceElement(parser, cimInstance))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"Expected INSTANCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

objectWithPath = CIMObject (cimInstance);

objectWithPath.setPath (reference);

Line 3301

Line 4146

if (!XmlReader::getClassElement(parser, cimClass))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"Expected CLASS element");

throw XmlValidationError(parser.getLine(), mlParms);

}

objectWithPath = CIMObject (cimClass);

objectWithPath.setPath (reference);

Line 3337

Line 4190

isInstance = true;

else if (!XmlReader::getLocalClassPathElement(parser, reference))

{

throw XmlValidationError(parser.getLine(),

"Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");

//l10n updated

MessageLoaderParms mlParms("Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",

MISSING_ELEMENT_LOCALPATH);

throw XmlValidationError(parser.getLine(), mlParms);

}

if (isInstance)

Line 3347

Line 4210

if (!XmlReader::getInstanceElement(parser, cimInstance))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"Expected INSTANCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

objectWithPath = CIMObject (cimInstance);

objectWithPath.setPath (reference);

Line 3359

Line 4231

if (!XmlReader::getClassElement(parser, cimClass))

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"Expected CLASS element");

throw XmlValidationError(parser.getLine(), mlParms);

}

objectWithPath = CIMObject (cimClass);

objectWithPath.setPath (reference);

Line 3418

Line 4300

XmlParser& parser,

CIMObjectPath& objectName)

{

String className;

CIMName className;

if (getClassNameElement(parser, className, false))

{

objectName.set(String(), String(), className);

objectName.set(String(), CIMNamespaceName(), className);

return true;

}

else if (getInstanceNameElement(parser, objectName))

return true;

else

{

throw XmlValidationError(parser.getLine(),

"expected CLASSNAME or INSTANCENAME element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME or INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",

"Expected CLASSNAME or INSTANCENAME element");

throw XmlValidationError(parser.getLine(), mlParms);

}

return false;

Line 3463

Line 4354

}

else

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCEPATH or CLASSPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

"expected INSTANCEPATH or CLASSPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

PEGASUS_UNREACHABLE ( return false; )

Line 3487

Line 4386

// Get EXPMETHODCALL.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

if (!entry.getAttributeValue("NAME", name)) {

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing EXPMETHODCALL.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",

"Missing EXPMETHODCALL.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3511

Line 4420

// Get EXPMETHODRESPONSE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

if (!entry.getAttributeValue("NAME", name)) {

// l10n

// throw XmlValidationError(

// parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",

"Missing EXPMETHODRESPONSE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

//------------------------------------------------------------------------------

// getEParamValueTag()

//------------------------------------------------------------------------------

Boolean XmlReader::getEParamValueTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "EXPPARAMVALUE"))

return false;

// Get EXPPARAMVALUE.NAME attribute:

if (!entry.getAttributeValue("NAME", name)) {

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing EXPPARAMVALUE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",

"Missing EXPPARAMVALUE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3535

Line 4489

// Get METHODCALL.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

if (!entry.getAttributeValue("NAME", name)) {

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing METHODCALL.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",

"Missing METHODCALL.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3559

Line 4524

// Get METHODRESPONSE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

if (!entry.getAttributeValue("NAME", name)) {

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing METHODRESPONSE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",

"Missing METHODRESPONSE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

return true;

}

Line 3593

Line 4568

// Get PARAMVALUE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

if (!entry.getAttributeValue("NAME", name)) {

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing PARAMVALUE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",

"Missing PARAMVALUE.NAME attribute");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get PARAMVALUE.PARAMTYPE attribute:

type = getCimTypeAttribute(parser.getLine(), entry, "PARAMVALUE",

Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,

"PARAMTYPE", false);

"PARAMVALUE", "PARAMTYPE", false);

if (!empty)

{

// Parse VALUE.REFERENCE and VALUE.REFARRAY type

if ( (type == CIMTYPE_REFERENCE) || (type == CIMTYPE_NONE) )

if ( (type == CIMTYPE_REFERENCE) || !gotType )

{

CIMObjectPath reference;

if (XmlReader::getValueReferenceElement(parser, reference))

{

value.set(reference);

type = CIMTYPE_REFERENCE;

gotType = true;

}

else if (XmlReader::getValueReferenceArrayElement(parser, value))

{

type = CIMTYPE_REFERENCE;

gotType = true;

}

// If type==reference but no VALUE.REFERENCE found, use null value

}

Line 3623

Line 4610

// Parse non-reference value

if ( type != CIMTYPE_REFERENCE )

{

// If we don't know what type the value is, read it as a String

CIMType effectiveType;

CIMType effectiveType = type;

if (!gotType)

if ( effectiveType == CIMTYPE_NONE)

{

// If we don't know what type the value is, read it as a String

effectiveType = CIMTYPE_STRING;

}

else

{

effectiveType = type;

}

if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&

!XmlReader::getValueElement(parser, effectiveType, value) )

Line 3640

Line 4631

expectEndTag(parser, "PARAMVALUE");

}

paramValue = CIMParamValue(name, value, Boolean(type!=CIMTYPE_NONE));

paramValue = CIMParamValue(name, value, gotType);

return true;

}

Line 3669

Line 4660

// Get RETURNVALUE.PARAMTYPE attribute:

// NOTE: Array type return values are not allowed (2/20/02)

type = getCimTypeAttribute(parser.getLine(), entry, "RETURNVALUE",

Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,

"PARAMTYPE", false);

"RETURNVALUE", "PARAMTYPE", false);

// Parse VALUE.REFERENCE type

if ( (type == CIMTYPE_REFERENCE) || (type == CIMTYPE_NONE) )

if ( (type == CIMTYPE_REFERENCE) || !gotType )

{

CIMObjectPath reference;

if (XmlReader::getValueReferenceElement(parser, reference))

{

returnValue.set(reference);

type = CIMTYPE_REFERENCE;

gotType = true;

}

else if (type == CIMTYPE_REFERENCE)

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected VALUE.REFERENCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",

"expected VALUE.REFERENCE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Parse non-reference return value

if ( type != CIMTYPE_REFERENCE )

{

// If we don't know what type the value is, read it as a String

if (!gotType)

if ( type == CIMTYPE_NONE)

{

// If we don't know what type the value is, read it as a String

type = CIMTYPE_STRING;

}

if ( !XmlReader::getValueElement(parser, type, returnValue) )

{

throw XmlValidationError(parser.getLine(),

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected VALUE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"expected VALUE element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Legend:

Removed from v.1.61
changed lines
	Added in v.1.92

No CVS admin address has been configured