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.18 and 1.84.6.1

version 1.18, 2001/07/01 21:40:38

version 1.84.6.1, 2003/08/13 19:39:51

Line 1

//%/////////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 22

Line 23

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By:

// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

//%/////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/Config.h>

#include <cassert>

#include <cctype>

#include <cstdio>

#include <cstdlib>

#if defined(PEGASUS_OS_TYPE_UNIX)

#include <errno.h>

#endif

#include "CIMName.h"

#include "XmlReader.h"

#include "XmlWriter.h"

Line 37

Line 43

#include "CIMQualifierDecl.h"

#include "CIMClass.h"

#include "CIMInstance.h"

#include "CIMObject.h"

#include "CIMParamValue.h"

#include "System.h"

#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM

#include "OS400ConvertChar.h"

#endif

// l10n

#include <Pegasus/Common/MessageLoader.h>

#define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000))

#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

static const Uint32 MESSAGE_SIZE = 128;

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

// expectXmlDeclaration()

// getXmlDeclaration()

// <?xml version="1.0" encoding="utf-8"?>

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

void XmlReader::getXmlDeclaration(

XmlParser& parser,

const char*& xmlVersion,

const char*& xmlEncoding)

{

XmlEntry entry;

if (!parser.next(entry) ||

entry.type != XmlEntry::XML_DECLARATION ||

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

{

// l10n

// throw XmlValidationError(parser.getLine(),

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

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE",

"Expected $0 style declaration",

"<?xml ... ?>");

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

}

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

// l10n

// throw XmlValidationError(

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

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

"xml.version");

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

}

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

{

// ATTN-RK-P3-20020403: Is there a default encoding?

}

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

// testXmlDeclaration ()

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

void XmlReader::expectXmlDeclaration(

Boolean XmlReader::testXmlDeclaration (

XmlParser& parser,

XmlEntry& entry)

{

Line 56

Line 127

entry.type != XmlEntry::XML_DECLARATION ||

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

{

throw XmlValidationError(parser.getLine(),

parser.putBack (entry);

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

return false;

}

return true;

}

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

Line 76

Line 149

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 96

Line 177

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 119

Line 209

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 140

Line 238

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

entry.type != XmlEntry::CDATA))

{

throw XmlValidationError(parser.getLine(),

// l10n

"Expected content of CDATA");

// throw XmlValidationError(parser.getLine(),

// "Expected content of CDATA");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA",

"Expected content of $0", "CDATA");

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

}

return true;

Line 171

Line 277

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

// testEndTag>()

// testEndTag()

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

Line 236

Line 342

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

// testCimStartTag()

// getCimStartTag()

// <!ELEMENT CIM (MESSAGE|DECLARATION)>

// <!ATTRLIST CIM

Line 245

Line 351

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

void XmlReader::testCimStartTag(XmlParser& parser)

void XmlReader::getCimStartTag(

XmlParser& parser,

const char*& cimVersion,

const char*& dtdVersion)

{

XmlEntry entry;

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

const char* cimVersion;

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

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

// l10n

throw XmlValidationError(

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

if (strcmp(cimVersion, "2.0") != 0)

// throw XmlValidationError(

throw XmlValidationError(parser.getLine(),

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

"CIM.CIMVERSION attribute must be \"2.0\"");

const char* dtdVersion;

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

"CIM.CIMVERSION");

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

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

throw XmlValidationError(

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

if (strcmp(dtdVersion, "2.0") != 0)

throw XmlValidationError(parser.getLine(),

"CIM.DTDVERSION attribute must be \"2.0\"");

}

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

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

// getIsArrayAttribute()

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

Boolean XmlReader::getIsArrayAttribute(

// l10n

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName,

Boolean& value)

{

const char* tmp;

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

// throw XmlValidationError(

return false;

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

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

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

{

"missing $0 attribute",

value = true;

"CIM.DTDVERSION");

return true;

}

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

{

value = false;

return true;

}

char buffer[62];

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

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

}

throw XmlSemanticError(lineNumber, buffer);

return false;

}

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

Line 313

Line 396

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

String XmlReader::getCimNameAttribute(

CIMName XmlReader::getCimNameAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName,

Line 323

Line 406

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 358

Line 470

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 382

Line 520

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

String XmlReader::getClassOriginAttribute(

CIMName XmlReader::getClassOriginAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

Line 390

Line 528

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 411

Line 566

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

String XmlReader::getReferenceClassAttribute(

CIMName XmlReader::getReferenceClassAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

Line 419

Line 574

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 440

Line 611

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

String XmlReader::getSuperClassAttribute(

CIMName XmlReader::getSuperClassAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

Line 448

Line 619

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 465

Line 648

// getCimTypeAttribute()

// This method can be used to get a TYPE attribute or a PARAMTYPE attribute.

// The only significant difference is that PARAMTYPE may specify a value of

// "reference" type. This method recognizes these attributes by name, and

// does not allow a "TYPE" attribute to be of "reference" type.

// <!ENTITY % ParamType "PARAMTYPE (boolean|string|char16|uint8|sint8

// |reference)">

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

CIMType XmlReader::getCimTypeAttribute(

Boolean XmlReader::getCimTypeAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

CIMType& cimType, // Output parameter

const char* tagName,

const char* attributeName,

Boolean required)

{

const char* typeName;

if (!entry.getAttributeValue("TYPE", typeName))

if (!entry.getAttributeValue(attributeName, typeName))

{

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.TYPE attribute", tagName);

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 false;

}

CIMType type = CIMType::NONE;

CIMType type = CIMTYPE_BOOLEAN;

Boolean unrecognizedType = false;

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

type = CIMType::BOOLEAN;

type = CIMTYPE_BOOLEAN;

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

type = CIMType::STRING;

type = CIMTYPE_STRING;

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

type = CIMType::CHAR16;

type = CIMTYPE_CHAR16;

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

type = CIMType::UINT8;

type = CIMTYPE_UINT8;

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

type = CIMType::SINT8;

type = CIMTYPE_SINT8;

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

type = CIMType::UINT16;

type = CIMTYPE_UINT16;

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

type = CIMType::SINT16;

type = CIMTYPE_SINT16;

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

type = CIMType::UINT32;

type = CIMTYPE_UINT32;

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

type = CIMType::SINT32;

type = CIMTYPE_SINT32;

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

type = CIMType::UINT64;

type = CIMTYPE_UINT64;

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

type = CIMType::SINT64;

type = CIMTYPE_SINT64;

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

type = CIMType::DATETIME;

type = CIMTYPE_DATETIME;

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

type = CIMType::REAL32;

type = CIMTYPE_REAL32;

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

type = CIMType::REAL64;

type = CIMTYPE_REAL64;

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

type = CIMType::REFERENCE;

type = CIMTYPE_REFERENCE;

else unrecognizedType = true;

// ATTN: "reference" is not legal according to the DTD; however, it is

if (unrecognizedType ||

// used by the XML version of the CIM schema.

((type == CIMTYPE_REFERENCE) &&

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

{

// l10n

// char message[MESSAGE_SIZE];

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

// attributeName);

// throw XmlSemanticError(lineNumber, message);

if (type == CIMType::NONE)

char buffer[MESSAGE_SIZE];

{

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

char message[MESSAGE_SIZE];

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

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

throw XmlSemanticError(lineNumber, message);

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return type;

cimType = type;

return true;

}

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

Line 551

Line 780

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 563

Line 803

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 580

Line 832

Boolean XmlReader::stringToReal(const char* stringValue, Real64& x)

{

// Check the string against the DMTF-defined grammar

const char* p = stringValue;

if (!*p)

Line 636

Line 891

if (*p)

return false;

// Do the conversion

char* end;

errno = 0;

x = strtod(stringValue, &end);

if (*end || (errno == ERANGE))

{

return false;

}

return true;

}

inline Uint8 _hexCharToNumeric(const char c)

{

Uint8 n;

if (isdigit(c))

n = (c - '0');

else if (isupper(c))

n = (c - 'A' + 10);

else // if (islower(c))

n = (c - 'a' + 10);

return n;

}

// See http://www.ietf.org/rfc/rfc2396.txt section 2

String XmlReader::decodeURICharacters(String uriString)

{

String decodedString;

Uint32 i;

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

{

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

{

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

{

// l10n

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING",

"Invalid $0 encoding", "URI");

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

}

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

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

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

{

// l10n

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING",

"Invalid $0 encoding", "URI");

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

}

// ATTN: Handle non-UTF-8 character sets

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

decodedString.append(Char16(decodedChar));

}

else

{

decodedString.append(uriString[i]);

}

return decodedString;

}

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

// stringToSignedInteger

// [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )

// or

// [ "+" | "-" ] ( "0x" | "0X" ) 1*hexDigit

// ATTN-B: handle conversion from hexadecimal.

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

Boolean XmlReader::stringToSignedInteger(

Line 657

Line 986

x = 0;

const char* p = stringValue;

if (!*p)

if (!p || !*p)

return false;

// Skip optional sign:

Line 667

Line 996

if (negative || *p == '+')

p++;

// If the next thing is a zero, then it must be the last:

if (*p == '0')

return p[1] == '\0';

{

if ( (p[1] == 'x') || (p[1] == 'X') )

// Expect a positive decimal digit:

{

// Convert a hexadecimal string

const char* first = p;

// Skip over the "0x"

p+=2;

if (!isdigit(*p) || *p == '0')

// At least one hexadecimal digit is required

if (!isxdigit(*p))

return false;

p++;

// Build the Sint64 as a negative number, regardless of the

// eventual sign (negative numbers can be bigger than positive ones)

// Expect zero or more digits:

// Add on each digit, checking for overflow errors

while (isxdigit(*p))

{

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

if (x < PEGASUS_SINT64_MIN/16)

{

return false;

}

x = x << 4;

while (isdigit(*p))

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

p++;

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

if (PEGASUS_SINT64_MIN - x > -newDigit)

{

return false;

}

x = x - newDigit;

}

// If we found a non-hexadecimal digit, report an error

if (*p)

return false;

const char* last = p;

// Return the integer to positive, if necessary, checking for an

// overflow error

if (!negative)

{

if (x == PEGASUS_SINT64_MIN)

{

return false;

}

x = -x;

}

return true;

}

else

{

// A decimal string that starts with '0' must be exactly "0".

return p[1] == '\0';

}

// Expect a positive decimal digit:

// At least one decimal digit is required

if (!isdigit(*p))

return false;

while (first != last)

// Build the Sint64 as a negative number, regardless of the

x = 10 * x + (*first++ - '0');

// eventual sign (negative numbers can be bigger than positive ones)

if (negative)

// Add on each digit, checking for overflow errors

x = -x;

while (isdigit(*p))

{

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

if (x < PEGASUS_SINT64_MIN/10)

{

return false;

}

x = 10 * x;

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

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

if (PEGASUS_SINT64_MIN - x > -newDigit)

{

return false;

}

x = x - newDigit;

}

// If we found a non-decimal digit, report an error

if (*p)

return false;

// Return the integer to positive, if necessary, checking for an

// overflow error

if (!negative)

{

if (x == PEGASUS_SINT64_MIN)

{

return false;

}

x = -x;

}

return true;

}

Line 704

Line 1103

// stringToUnsignedInteger

// [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )

// ( positiveDecimalDigit *decimalDigit | "0" )

// or

// ( "0x" | "0X" ) 1*hexDigit

// ATTN-B: handle conversion from hexadecimal.

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

Boolean XmlReader::stringToUnsignedInteger(

Line 716

Line 1116

x = 0;

const char* p = stringValue;

if (!*p)

if (!p || !*p)

return false;

// Skip optional sign:

if (*p == '0')

{

if ( (p[1] == 'x') || (p[1] == 'X') )

{

// Convert a hexadecimal string

if (*p == '-')

// Skip over the "0x"

return false;

p+=2;

if (*p == '+')

// At least one hexadecimal digit is required

p++;

if (!*p)

return false;

// If the next thing is a zero, then it must be the last:

// Add on each digit, checking for overflow errors

while (isxdigit(*p))

{

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

if (x > PEGASUS_UINT64_MAX/16)

{

return false;

}

x = x << 4;

if (*p == '0')

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

return p[1] == '\0';

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

if (PEGASUS_UINT64_MAX - x < newDigit)

// Expect a positive decimal digit:

{

return false;

const char* first = p;

}

x = x + newDigit;

}

if (!isdigit(*p) || *p == '0')

// If we found a non-hexadecimal digit, report an error

if (*p)

return false;

p++;

return true;

}

else

{

// A decimal string that starts with '0' must be exactly "0".

return p[1] == '\0';

}

// Expect zero or more digits:

// Expect a positive decimal digit:

// Add on each digit, checking for overflow errors

while (isdigit(*p))

p++;

{

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

if (*p)

if (x > PEGASUS_UINT64_MAX/10)

{

return false;

}

x = 10 * x;

const char* last = p;

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

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

if (PEGASUS_UINT64_MAX - x < newDigit)

{

return false;

}

x = x + newDigit;

}

while (first != last)

// If we found a non-decimal digit, report an error

x = 10 * x + (*first++ - '0');

if (*p)

return false;

return true;

}

Line 761

Line 1196

// stringToValue()

// ATTN-C: note that integers are truncated without warning. What should be

// Return: CIMValue. If the string input is zero length creates a CIMValue

// done in this case? In C they are truncated without warning by design.

// with value defined by the type. Else the value is inserted.

// Note that this does not set the CIMValue Null if the string is empty.

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

Line 773

Line 1210

{

// ATTN-B: accepting only UTF-8 for now! (affects string and char16):

//SNIA

// Create value per type

if (strlen(valueString)==0) {

switch (type) {

case CIMType::BOOLEAN: return CIMValue(false);

case CIMType::STRING: return CIMValue(valueString);

case CIMType::CHAR16: return CIMValue(Char16('\0'));

case CIMType::UINT8: return CIMValue(Uint8(0));

case CIMType::UINT16: return CIMValue(Uint16(0));

case CIMType::UINT32: return CIMValue(Uint32(0));

case CIMType::UINT64: return CIMValue(Uint64(0));

case CIMType::SINT8: return CIMValue(Sint8(0));

case CIMType::SINT16: return CIMValue(Sint16(0));

case CIMType::SINT32: return CIMValue(Sint32(0));

case CIMType::SINT64: return CIMValue(Sint64(0));

case CIMType::REAL32: return CIMValue(Real32(0));

case CIMType::REAL64: return CIMValue(Real64(0));

}

// end of SNIA

switch (type)

{

case CIMType::BOOLEAN:

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_VALUE",

"Invalid $0 value",

"boolean");

throw XmlSemanticError(lineNumber, mlParms);

}

case CIMType::STRING:

case CIMTYPE_STRING:

{

return CIMValue(valueString);

return CIMValue(String(valueString, STRING_FLAG_UTF8));

}

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

{

if (strlen(valueString) != 1)

if (strlen(valueString) != 1) {

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

// l10n

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",

"Invalid $0 value",

"char16");

throw XmlSemanticError(lineNumber, mlParms);

}

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

}

case CIMType::UINT8:

case CIMTYPE_UINT8:

case CIMType::UINT16:

case CIMTYPE_UINT16:

case CIMType::UINT32:

case CIMTYPE_UINT32:

case CIMType::UINT64:

case CIMTYPE_UINT64:

{

Uint64 x;

if (!stringToUnsignedInteger(valueString, x))

{

throw XmlSemanticError(

lineNumber, "Bad unsigned integer value");

// l10n

// throw XmlSemanticError(

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",

"Invalid $0 value",

"unsigned integer");

throw XmlSemanticError(lineNumber, mlParms);

}

switch (type)

{

case CIMType::UINT8: return CIMValue(Uint8(x));

case CIMTYPE_UINT8:

case CIMType::UINT16: return CIMValue(Uint16(x));

{

case CIMType::UINT32: return CIMValue(Uint32(x));

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

case CIMType::UINT64: return CIMValue(Uint64(x));

{

// l10n

// throw XmlSemanticError(

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

MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",

"$0 value out of range",

"Uint8");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint8(x));

}

case CIMTYPE_UINT16:

{

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

{

// l10n

// throw XmlSemanticError(

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

MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",

"$0 value out of range",

"Uint16");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint16(x));

}

case CIMTYPE_UINT32:

{

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

{

// l10n

// throw XmlSemanticError(

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

MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",

"$0 value out of range",

"Uint32");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint32(x));

}

case CIMTYPE_UINT64: return CIMValue(Uint64(x));

default: break;

}

case CIMType::SINT8:

case CIMTYPE_SINT8:

case CIMType::SINT16:

case CIMTYPE_SINT16:

case CIMType::SINT32:

case CIMTYPE_SINT32:

case CIMType::SINT64:

case CIMTYPE_SINT64:

{

Sint64 x;

if (!stringToSignedInteger(valueString, x))

{

throw XmlSemanticError(

lineNumber, "Bad signed integer value");

// l10n

// throw XmlSemanticError(

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",

"Invalid $0 value",

"signed integer");

throw XmlSemanticError(lineNumber, mlParms);

}

switch (type)

{

case CIMType::SINT8: return CIMValue(Sint8(x));

case CIMTYPE_SINT8:

case CIMType::SINT16: return CIMValue(Sint16(x));

{

case CIMType::SINT32: return CIMValue(Sint32(x));

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

case CIMType::SINT64: return CIMValue(Sint64(x));

{

// l10n

// throw XmlSemanticError(

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

MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",

"$0 value out of range",

"Sint8");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint8(x));

}

case CIMTYPE_SINT16:

{

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

{

// l10n

// throw XmlSemanticError(

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

MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",

"$0 value out of range",

"Sint16");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint16(x));

}

case CIMTYPE_SINT32:

{

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

{

// l10n

// throw XmlSemanticError(

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

MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE",

"$0 value out of range",

"Sint32");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint32(x));

}

case CIMTYPE_SINT64: return CIMValue(Sint64(x));

default: break;

}

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

{

CIMDateTime tmp;

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_VALUE",

"Invalid $0 value",

"datetime");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(tmp);

}

case CIMType::REAL32:

case CIMTYPE_REAL32:

{

Real64 x;

if (!stringToReal(valueString, x))

if (!stringToReal(valueString, x)) {

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

// l10n

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",

"Invalid $0 value",

"real number");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Real32(x));

}

case CIMType::REAL64:

case CIMTYPE_REAL64:

{

Real64 x;

if (!stringToReal(valueString, x))

if (!stringToReal(valueString, x)) {

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

// l10n

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE",

"Invalid $0 value",

"real number");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(x);

}

Line 905

Line 1501

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 915

Line 1519

// <!ELEMENT VALUE (#PCDATA)>

// Return: false if no value element.

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

Boolean XmlReader::getValueElement(

Line 922

Line 1528

CIMType type,

CIMValue& value)

{

// Get VALUE start tag:

// Get VALUE start tag: Return false if no VALUE start Tag

XmlEntry entry;

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

Line 930

Line 1536

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

// Get VALUE content:

const char* valueString = "";

// cout << "DEBUG XMLReader:getValueElement " << __LINE__ ;

if (!empty)

{

if (testContentOrCData(parser, entry))

valueString = entry.text;

//cout << "DEBUG XMLReader:getValueElement " << __LINE__

// << " valueString " << valueString ;

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

//cout << "DEBUG XMLReader:getValueElement " << __LINE__

// << " value " << value;

return true;

}

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

// getStringValueElement()

// <!ELEMENT VALUE (#PCDATA)>

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

Boolean XmlReader::getStringValueElement(

XmlParser& parser,

String& str,

Boolean required)

{

XmlEntry entry;

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

{

if (required) {

// l10n

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

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"Expected $0 element", "VALUE");

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

}

return false;

}

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

const char* valueString = "";

if (!empty)

{

if (testContentOrCData(parser, entry))

valueString = entry.text;

expectEndTag(parser, "VALUE");

}

str = String(valueString,STRING_FLAG_UTF8);

return true;

}

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

// getPropertyValue

// Use: Decode property value from getPropertyResponse

// Use: Decode property value from SetProperty request and

// Expect (ERROR|IRETURNVALUE).!ELEMENT VALUE (#PCDATA)>

// GetProperty response.

// PropertyValue is one of:

// PropertyValue:

// <!ELEMENT VALUE>

// <!ELEMENT VALUE.ARRAY (VALUE*)>

// <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|

// <!ELEMENT VALUE.ARRAY (VALUE*)>

// <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|

// INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>

// <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>

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

Boolean XmlReader::getPropertyValue(

XmlParser& parser,

CIMValue& cimValue)

{

//Test for Element value type

// Can not test for value type, so assume String

CIMType type = CIMType::STRING;

const CIMType type = CIMTYPE_STRING;

// Test for VALUE element

if (XmlReader::getValueElement(parser, type, cimValue))

{

//cout << "DEBUG xmlReader::getPropertyValue " << __LINE__

// << " CimValue = " << cimValue.toString << endl;

return true;

}

//Test for Element.array value

// Test for VALUE.ARRAY element

if(XmlReader::getValueArrayElement(parser, type, cimValue))

{

return true;

}

// Test for Value.reference type

// Test for VALUE.REFERENCE element

// ATTN:This returns a different type (CIMReference)

CIMObjectPath reference;

// ATTN: Possibly change to simply return result after

// we figure out the type differences.

CIMReference reference;

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

{

cimValue.set(reference);

return true;

}

// Test for VALUE.REFARRAY element

if (XmlReader::getValueReferenceArrayElement(parser, cimValue))

{

return true;

}

return false;

}

Line 1032

Line 1697

{

switch (type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

return StringArrayToValueAux(lineNumber, array, type, (Boolean*)0);

case CIMType::STRING:

case CIMTYPE_STRING:

return StringArrayToValueAux(lineNumber, array, type, (String*)0);

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

return StringArrayToValueAux(lineNumber, array, type, (Char16*)0);

case CIMType::UINT8:

case CIMTYPE_UINT8:

return StringArrayToValueAux(lineNumber, array, type, (Uint8*)0);

case CIMType::UINT16:

case CIMTYPE_UINT16:

return StringArrayToValueAux(lineNumber, array, type, (Uint16*)0);

case CIMType::UINT32:

case CIMTYPE_UINT32:

return StringArrayToValueAux(lineNumber, array, type, (Uint32*)0);

case CIMType::UINT64:

case CIMTYPE_UINT64:

return StringArrayToValueAux(lineNumber, array, type, (Uint64*)0);

case CIMType::SINT8:

case CIMTYPE_SINT8:

return StringArrayToValueAux(lineNumber, array, type, (Sint8*)0);

case CIMType::SINT16:

case CIMTYPE_SINT16:

return StringArrayToValueAux(lineNumber, array, type, (Sint16*)0);

case CIMType::SINT32:

case CIMTYPE_SINT32:

return StringArrayToValueAux(lineNumber, array, type, (Sint32*)0);

case CIMType::SINT64:

case CIMTYPE_SINT64:

return StringArrayToValueAux(lineNumber, array, type, (Sint64*)0);

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

return StringArrayToValueAux(lineNumber, array, type, (CIMDateTime*)0);

case CIMType::REAL32:

case CIMTYPE_REAL32:

return StringArrayToValueAux(lineNumber, array, type, (Real32*)0);

case CIMType::REAL64:

case CIMTYPE_REAL64:

return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);

default:

Line 1088

Line 1753

// <!ELEMENT VALUE.ARRAY (VALUE*)>

// Return: Boolean. Returns false if there is no VALUE.ARRAY start element

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

Boolean XmlReader::getValueArrayElement(

Line 1095

Line 1762

CIMType type,

CIMValue& value)

{

// Clears any values from the Array. Assumes this is array CIMValue

value.clear();

// Get VALUE.ARRAY open tag:

XmlEntry entry;

Array<const char*> stringArray;

// If no VALUE.ARRAY start tag, return false

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

return false;

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

if (entry.type != XmlEntry::EMPTY_TAG)

return true;

{

// For each VALUE element:

Array<const char*> stringArray;

while (testStartTagOrEmptyTag(parser, entry, "VALUE"))

{

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

Line 1128

Line 1795

}

expectEndTag(parser, "VALUE.ARRAY");

}

value = stringArrayToValue(parser.getLine(), stringArray, type);

return true;

Line 1145

Line 1813

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

Uint32 XmlReader::getFlavor(

CIMFlavor XmlReader::getFlavor(

XmlEntry& entry,

Uint32 lineNumber,

const char* tagName)

Line 1170

Line 1838

Boolean translatable = getCimBooleanAttribute(

lineNumber, entry, tagName, "TRANSLATABLE", false, false);

Uint32 flavor = 0;

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

// getCimBooleanAttribute() calls above.

CIMFlavor flavor = CIMFlavor (CIMFlavor::NONE);

if (overridable)

flavor |= CIMFlavor::OVERRIDABLE;

flavor.addFlavor (CIMFlavor::OVERRIDABLE);

else

flavor.addFlavor (CIMFlavor::DISABLEOVERRIDE);

if (toSubClass)

flavor |= CIMFlavor::TOSUBCLASS;

flavor.addFlavor (CIMFlavor::TOSUBCLASS);

else

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 1204

Line 1878

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

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 1217

Line 1892

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 1257

Line 1932

// getQualifierElement()

// <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>

// <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)?>

// <!ATTLIST QUALIFIER

// %CIMName;

// %CIMType; #REQUIRED

Line 1278

Line 1953

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

Line 1967

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

Line 1976

if (!getValueElement(parser, type, value) &&

!getValueArrayElement(parser, type, value))

{

throw XmlSemanticError(parser.getLine(),

value.setNullValue(type, false);

"Expected VALUE or VALUE.ARRAY element");

}

// Expect </QUALIFIER>:

Line 1331

Line 2006

{

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",

"duplicate $0", "qualifier");

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

}

Line 1362

Line 2045

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

Line 2059

// Get PROPERTY.TYPE attribute:

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

CIMType type;

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

// Create property:

// Create property: Sets type and !isarray

CIMValue value;

CIMValue value(type, false);

value.setNullValue(type, false);

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

property = CIMProperty(

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

if (!empty)

{

Line 1391

Line 2073

getQualifierElements(parser, property);

// Get value:

// Get value: Insert value if getValueElement exists (returns True)

if (getValueElement(parser, type, value))

property.setValue(value);

Line 1428

Line 2110

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 1466

Line 2159

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

Line 2174

// Get PROPERTY.CLASSORIGIN attribute:

String classOrigin

CIMName classOrigin

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

// Get PROPERTY.ARRAY.PROPAGATED

Line 1490

Line 2184

// Create property:

CIMValue nullValue;

CIMValue value(type, true, arraySize);

nullValue.setNullValue(type, true, arraySize);

property = CIMProperty(

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

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

if (!empty)

{

Line 1503

Line 2196

// Get value:

CIMValue value;

if (getValueArrayElement(parser, type, value))

{

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

{

throw XmlSemanticError(parser.getLine(),

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

// l10n

// throw XmlSemanticError(parser.getLine(),

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

MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT",

"$0 attribute and $1 size are different",

"ARRAYSIZE", "value-array");

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

}

property.setValue(value);

Line 1538

Line 2238

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 (!parser.next(entry) || entry.type != XmlEntry::CONTENT)

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

host = String(entry.text,STRING_FLAG_UTF8);

else

{

throw XmlValidationError(parser.getLine(),

parser.putBack(entry);

"expected content of HOST element");

host = "HOSTNAMEINSERTEDBYPEGASUSCLIENT";

}

host = entry.text;

#else

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

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected content of HOST element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT",

"expected content of $0 element", "HOST");

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

}

host = String(entry.text,STRING_FLAG_UTF8);

#endif

expectEndTag(parser, "HOST");

return true;

}

Line 1562

Line 2287

Boolean XmlReader::getNameSpaceElement(

XmlParser& parser,

String& nameSpaceComponent)

CIMName& nameSpaceComponent)

{

XmlEntry entry;

Line 1597

Line 2322

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 $0 elements within $1 element",

"NAMESPACE", "LOCALNAMESPACEPATH");

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

}

expectEndTag(parser, "LOCALNAMESPACEPATH");

Line 1639

Line 2375

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

return false;

if (!getHostElement(parser, host))

if (!getHostElement(parser, host)) {

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

// l10n

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

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "HOST");

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

}

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

throw XmlValidationError(parser.getLine(),

"expected LOCALNAMESPACEPATH element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "LOCALNAMESPACEPATH");

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

}

expectEndTag(parser, "NAMESPACEPATH");

Line 1664

Line 2417

Boolean XmlReader::getClassNameElement(

XmlParser& parser,

String& className,

CIMName& className,

Boolean required)

{

XmlEntry entry;

Line 1673

Line 2426

{

if (required)

{

throw XmlValidationError(parser.getLine(),

"expected CLASSNAME element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "CLASSNAME");

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

}

else

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 1699

Line 2459

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

KeyBinding::Type XmlReader::getValueTypeAttribute(

CIMKeyBinding::Type XmlReader::getValueTypeAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

Line 1707

Line 2467

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

sprintf(buffer,

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",

"Illegal value for %s.VALUETYPE attribute; "

"Illegal value for $0 attribute; $1 must be one of $2, $3, or $4",

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

buffer, "CIMValue", "\"string\"", "\"boolean\"", "\"numeric\"");

elementName);

throw XmlSemanticError(lineNumber, buffer);

throw XmlSemanticError(lineNumber, mlParms);

return KeyBinding::BOOLEAN;

return CIMKeyBinding::BOOLEAN;

}

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

Line 1735

Line 2506

// <!ATTLIST KEYVALUE

// VALUETYPE (string|boolean|numeric) 'string'>

// ATTN-B: VALUE.REFERENCE ignored above; can't understand why it is needed!

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

Boolean XmlReader::getKeyValueElement(

XmlParser& parser,

KeyBinding::Type& type,

CIMKeyBinding::Type& type,

String& value)

{

XmlEntry entry;

Line 1761

Line 2530

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 1779

Line 2548

// <!ATTLIST KEYBINDING

// %CIMName;>

// ATTN-B: VALUE.REFERENCE ignored above; can't understand why it is needed!

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

Boolean XmlReader::getKeyBindingElement(

XmlParser& parser,

String& name,

CIMName& name,

String& value,

KeyBinding::Type& type)

CIMKeyBinding::Type& type)

{

XmlEntry entry;

Line 1797

Line 2564

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

if (!getKeyValueElement(parser, type, value))

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

{

CIMObjectPath reference;

if (!getValueReferenceElement(parser, reference))

{

// l10n

// throw XmlValidationError(parser.getLine(),

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

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",

"Expected $0 or $1 element", "KEYVALUE", "VALUE.REFERENCE");

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

}

type = CIMKeyBinding::REFERENCE;

value = reference.toString();

}

expectEndTag(parser, "KEYBINDING");

return true;

Line 1811

Line 2597

// <!ATTLIST INSTANCENAME

// %ClassName;>

// ATTN-B: VALUE.REFERENCE sub-element not accepted yet.

// Note: An empty key name is used in the keyBinding when the INSTANCENAME is

// specified using a KEYVALUE or a VALUE.REFERENCE.

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

Boolean XmlReader::getInstanceNameElement(

XmlParser& parser,

String& className,

Array<KeyBinding>& keyBindings)

Array<CIMKeyBinding>& keyBindings)

{

className.clear();

keyBindings.clear();

Line 1832

Line 2619

className = getClassNameAttribute(parser.getLine(), entry, "INSTANCENAME");

if (!empty)

if (empty)

{

String name;

return true;

KeyBinding::Type type;

}

CIMName name;

CIMKeyBinding::Type type;

String value;

CIMObjectPath reference;

if (getKeyValueElement(parser, type, value))

{

// Use empty key name because none was specified

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

}

else if (getValueReferenceElement(parser, reference))

{

// Use empty key name because none was specified

type = CIMKeyBinding::REFERENCE;

value = reference.toString();

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

}

if (!empty)

expectEndTag(parser, "INSTANCENAME");

return true;

}

Boolean XmlReader::getInstanceNameElement(

XmlParser& parser,

CIMObjectPath& instanceName)

{

String className;

Array<CIMKeyBinding> keyBindings;

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

return false;

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

return true;

}

Line 1858

Line 2676

Boolean XmlReader::getInstancePathElement(

XmlParser& parser,

CIMReference& reference)

CIMObjectPath& reference)

{

XmlEntry entry;

Line 1870

Line 2688

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

{

throw XmlValidationError(parser.getLine(),

"expected NAMESPACEPATH element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected NAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "NAMESPACEPATH");

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

}

String className;

Array<KeyBinding> keyBindings;

Array<CIMKeyBinding> keyBindings;

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

{

throw XmlValidationError(parser.getLine(),

"expected INSTANCENAME element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "INSTANCENAME");

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

}

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

Line 1899

Line 2736

Boolean XmlReader::getLocalInstancePathElement(

XmlParser& parser,

CIMReference& reference)

CIMObjectPath& reference)

{

XmlEntry entry;

Line 1910

Line 2747

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

throw XmlValidationError(parser.getLine(),

"expected LOCALNAMESPACEPATH element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "LOCALNAMESPACEPATH");

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

}

String className;

Array<KeyBinding> keyBindings;

Array<CIMKeyBinding> keyBindings;

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

{

throw XmlValidationError(parser.getLine(),

"expected INSTANCENAME element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "INSTANCENAME");

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

}

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

Line 1939

Line 2794

Boolean XmlReader::getClassPathElement(

XmlParser& parser,

CIMReference& reference)

CIMObjectPath& reference)

{

XmlEntry entry;

Line 1951

Line 2806

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

{

throw XmlValidationError(parser.getLine(),

"expected NAMESPACEPATH element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected NAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "NAMESPACEPATH");

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

}

String className;

CIMName className;

if (!getClassNameElement(parser, className))

{

throw XmlValidationError(parser.getLine(),

"expected CLASSNAME element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "CLASSNAME");

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

}

reference.set(host, nameSpace, className);

Line 1979

Line 2852

Boolean XmlReader::getLocalClassPathElement(

XmlParser& parser,

CIMReference& reference)

CIMObjectPath& reference)

{

XmlEntry entry;

Line 1990

Line 2863

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

throw XmlValidationError(parser.getLine(),

"expected LOCALNAMESPACEPATH element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected LOCALNAMESPACEPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "LOCALNAMESPACEPATH");

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

}

String className;

CIMName className;

if (!getClassNameElement(parser, className))

{

throw XmlValidationError(parser.getLine(),

"expected CLASSNAME element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "CLASSNAME");

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

}

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

Line 2021

Line 2912

Boolean XmlReader::getValueReferenceElement(

XmlParser& parser,

CIMReference& reference)

CIMObjectPath& reference)

{

XmlEntry entry;

Line 2034

Line 2925

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: $0", "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME");

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

}

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

Line 2053

Line 2953

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 2071

Line 2971

{

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 2082

Line 2982

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

// getValueReferenceArrayElement()

// <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>

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

Boolean XmlReader::getValueReferenceArrayElement(

XmlParser& parser,

CIMValue& value)

{

XmlEntry entry;

Array<CIMObjectPath> referenceArray;

CIMObjectPath reference;

value.clear();

// Get VALUE.REFARRAY open tag:

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

return false;

if (entry.type != XmlEntry::EMPTY_TAG)

{

// For each VALUE.REFERENCE element:

while (getValueReferenceElement(parser, reference))

{

referenceArray.append(reference);

}

expectEndTag(parser, "VALUE.REFARRAY");

}

value.set(referenceArray);

return true;

}

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

// getPropertyReferenceElement()

// <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)>

Line 2106

Line 3045

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

Line 3065

// Create property:

CIMValue value;

CIMValue value = CIMValue(CIMTYPE_REFERENCE, false, 0);

value.set(CIMReference());

// value.set(CIMObjectPath());

property = CIMProperty(

name, value, 0, referenceClass, classOrigin, propagated);

Line 2135

Line 3074

{

getQualifierElements(parser, property);

CIMReference reference;

CIMObjectPath reference;

if (getValueReferenceElement(parser, reference))

property.setValue(reference);

Line 2165

Line 3104

{

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",

"duplicate $0", "property");

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

}

Line 2196

Line 3143

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

Line 3189

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

Line 3240

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

parameter = CIMParameter(name, CIMType::REFERENCE, false, 0, referenceClass);

parameter = CIMParameter(name, CIMTYPE_REFERENCE, false, 0, referenceClass);

if (!empty)

{

Line 2314

Line 3263

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

// getParameterReferenceArrayElement()

// <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>

// <!ATTLIST PARAMETER.REFARRAY

// %CIMName;

// %ReferenceClass;

// %ArraySize;>

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

Boolean XmlReader::getParameterReferenceArrayElement(

XmlParser& parser,

CIMParameter& parameter)

{

XmlEntry entry;

if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFARRAY"))

return false;

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

// Get PARAMETER.NAME attribute:

CIMName name = getCimNameAttribute(

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

// Get PARAMETER.REFERENCECLASS attribute:

CIMName referenceClass = getReferenceClassAttribute(

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

// Get PARAMETER.ARRAYSIZE attribute:

Uint32 arraySize = 0;

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

arraySize);

// Create parameter:

parameter = CIMParameter(name, CIMTYPE_REFERENCE, true, arraySize,

referenceClass);

if (!empty)

{

getQualifierElements(parser, parameter);

expectEndTag(parser, "PARAMETER.REFARRAY");

}

return true;

}

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

// GetParameterElements()

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

Line 2325

Line 3327

while (XmlReader::getParameterElement(parser, parameter) ||

XmlReader::getParameterArrayElement(parser, parameter) ||

XmlReader::getParameterReferenceElement(parser, parameter))

XmlReader::getParameterReferenceElement(parser, parameter) ||

XmlReader::getParameterReferenceArrayElement(parser, parameter))

{

try

{

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",

"duplicate $0", "parameter");

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

}

Line 2365

Line 3376

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

Boolean isArray = false;

Boolean isArray = getCimBooleanAttribute(

getIsArrayAttribute(

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

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

false, false);

// Get ARRAYSIZE attribute:

Line 2387

Line 3398

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

Line 3419

{

if (!isArray)

{

throw XmlSemanticError(parser.getLine(),

"VALUE.ARRAY element encountered without "

// l10n

"ISARRAY attribute");

// throw XmlSemanticError(parser.getLine(),

// "VALUE.ARRAY element encountered without "

// "ISARRAY attribute");

MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY",

"$0 element encountered without $1 attribute",

"VALUE.ARRAY", "ISARRAY");

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

}

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

{

throw XmlSemanticError(parser.getLine(),

"VALUE.ARRAY size is not the same as "

// l10n

"ARRAYSIZE attribute");

// throw XmlSemanticError(parser.getLine(),

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

// "ARRAYSIZE attribute");

MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME",

"$0 size is not the same as $1 attribute",

"VALUE.ARRAY", "ARRAYSIZE");

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

}

gotValue = true;

}

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

{

if (isArray)

{

throw XmlSemanticError(parser.getLine(),

"ISARRAY attribute used but VALUE element encountered");

// l10n

// throw XmlSemanticError(parser.getLine(),

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

MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",

"$0 attribute used but $1 element encountered",

"ISARRAY", "VALUE");

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

}

gotValue = true;

}

// Now get the closing tag:

Line 2432

Line 3476

expectEndTag(parser, "QUALIFIER.DECLARATION");

}

if (value.getType() == CIMType::NONE)

if (!gotValue)

{

if (isArray)

value.setNullValue(type, true, arraySize);

Line 2467

Line 3511

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 2481

Line 3526

if (!empty)

{

// ATTN-RK-P2-20020219: Decoding algorithm must not depend on the

// ordering of qualifiers and parameters.

getQualifierElements(parser, method);

GetParameterElements(parser, method);

Line 2507

Line 3554

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 2575

Line 3622

}

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

// getNamedInstanceElement()

// <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>

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

Boolean XmlReader::getNamedInstanceElement(

XmlParser& parser,

CIMInstance& namedInstance)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))

return false;

CIMObjectPath instanceName;

// Get INSTANCENAME elements:

if (!getInstanceNameElement(parser, instanceName))

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "INSTANCENAME");

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

}

// Get INSTANCE elements:

if (!getInstanceElement(parser, namedInstance))

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "INSTANCE");

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

}

// Get VALUE.NAMEDINSTANCE end tag:

expectEndTag(parser, "VALUE.NAMEDINSTANCE");

namedInstance.setPath (instanceName);

return true;

}

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

// getObject()

Line 2584

Line 3691

{

if (!getClassElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

"expected CLASS element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "CLASS");

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

}

Line 2599

Line 3714

{

if (!getInstanceElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

"expected INSTANCE element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "INSTANCE");

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

}

Line 2614

Line 3737

{

if (!getQualifierDeclElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

"expected QUALIFIER.DECLARATION element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected QUALIFIER.DECLARATION element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "QUALIFIER.DECLARATION");

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

}

Line 2628

Line 3759

Boolean XmlReader::getMessageStartTag(

XmlParser& parser,

String& id,

const char*& protocolVersion)

String& protocolVersion)

{

XmlEntry entry;

Line 2637

Line 3768

// 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_ATTRIBUTE",

"Invalid or missing $0 attribute", "MESSAGE.ID");

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_ATTRIBUTE",

"Invalid or missing $0 attribute", "MESSAGE.PROTOCOLVERSION");

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

}

return true;

}

Line 2667

Line 3817

// Get IMETHODCALL.NAME attribute:

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

throw XmlValidationError(parser.getLine(),

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

"Missing IMETHODCALL.NAME attribute");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing IMETHODCALL.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"Missing $0 attribute",

"IMETHODCALL.NAME");

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

}

return true;

}

Line 2691

Line 3853

// Get IMETHODRESPONSE.NAME attribute:

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

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

throw XmlValidationError(parser.getLine(),

"Missing IMETHODRESPONSE.NAME attribute");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing IMETHODRESPONSE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"Missing $0 attribute",

"IMETHODRESPONSE.NAME");

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

}

return true;

}

Line 2715

Line 3888

// Get IPARAMVALUE.NAME attribute:

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

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

throw XmlValidationError(parser.getLine(),

"Missing IPARAMVALUE.NAME attribute");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing IPARAMVALUE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"Missing $0 attribute",

"IPARAMVALUE.NAME");

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

}

return true;

}

Line 2741

Line 3924

{

if (required)

{

throw XmlValidationError(parser.getLine(),

"Expected VALUE element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected VALUE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"Expected $0 element", "VALUE");

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

}

return false;

}

expectContentOrCData(parser, entry);

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

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

result = true;

else if (strcmp(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\"");

expectEndTag(parser, "VALUE");

// l10n

return true;

// throw XmlSemanticError(parser.getLine(),

}

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",

"Invalid value for $0 element: must be $1 or $2",

"VALUE", "\"TRUE\"", "\"FALSE\"");

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

}

expectEndTag(parser, "VALUE");

return true;

}

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

Line 2775

Line 3976

Boolean XmlReader::getErrorElement(

XmlParser& parser,

CIMException::Code& code,

CIMException& cimException,

const char*& description,

Boolean required)

{

XmlEntry entry;

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

{

if (required)

if (required) {

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

// l10n

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

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"Expected $0 element", "ERROR");

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

}

return false;

}

Line 2794

Line 4004

Uint32 tmpCode;

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

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

throw XmlValidationError(

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

// l10n

// throw XmlValidationError(

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

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

"ERROR.CODE");

code = CIMException::Code(tmpCode);

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

}

// Get ERROR.DESCRIPTION:

description = "";

String tmpDescription;

entry.getAttributeValue("DESCRIPTION", description);

entry.getAttributeValue("DESCRIPTION", tmpDescription);

if (!empty)

expectEndTag(parser, "ERROR");

cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);

return true;

}

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

// getObjectWithPath()

// getValueObjectElement()

// <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>

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

Boolean XmlReader::getValueObjectElement(

XmlParser& parser,

CIMObject& object)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "VALUE.OBJECT"))

return false;

CIMInstance cimInstance;

CIMClass cimClass;

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

{

object = CIMObject(cimInstance);

}

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

{

object = CIMObject(cimClass);

}

else

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE or CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",

"Expected $0 or $1 element", "INSTANCE", "CLASS");

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

}

expectEndTag(parser, "VALUE.OBJECT");

return true;

}

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

// getValueObjectWithPathElement()

// <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>

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

Boolean XmlReader::getObjectWithPath(

Boolean XmlReader::getValueObjectWithPathElement(

XmlParser& parser,

CIMObjectWithPath& objectWithPath)

CIMObject& objectWithPath)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "VALUE.OBJECTWITHPATH"))

return false;

if (testStartTag(parser, entry, "INSTANCEPATH"))

CIMObjectPath reference;

{

Boolean isInstance = false;

CIMReference reference;

if (!XmlReader::getInstancePathElement(parser, reference))

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

isInstance = true;

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

{

throw XmlValidationError(parser.getLine(),

"Expected INSTANCEPATH element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCEPATH or CLASSPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",

"Expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH");

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

}

CIMInstance instance;

if (isInstance)

{

CIMInstance cimInstance;

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

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

{

throw XmlValidationError(parser.getLine(),

"Expected INSTANCE element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"Expected $0 element", "INSTANCE");

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

}

objectWithPath = CIMObject (cimInstance);

objectWithPath.setPath (reference);

}

if (testStartTag(parser, entry, "CLASSPATH"))

else

{

CIMReference reference;

CIMClass cimClass;

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

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

{

throw XmlValidationError(parser.getLine(),

"Expected CLASSPATH element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"Expected $0 element", "CLASS");

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

}

objectWithPath = CIMObject (cimClass);

objectWithPath.setPath (reference);

}

expectEndTag(parser, "VALUE.OBJECTWITHPATH");

return true;

}

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

// getValueObjectWithLocalPathElement()

// <!ELEMENT VALUE.OBJECTWITHLOCALPATH

// ((LOCALCLASSPATH,CLASS)|(LOCALINSTANCEPATH,INSTANCE))>

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

Boolean XmlReader::getValueObjectWithLocalPathElement(

XmlParser& parser,

CIMObject& objectWithPath)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "VALUE.OBJECTWITHLOCALPATH"))

return false;

CIMObjectPath reference;

Boolean isInstance = false;

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

isInstance = true;

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

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",

"Expected $0 or $1 element", "LOCALINSTANCEPATH", "LOCALCLASSPATH");

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

}

if (isInstance)

{

CIMInstance cimInstance;

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

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"Expected $0 element", "INSTANCE");

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

}

objectWithPath = CIMObject (cimInstance);

objectWithPath.setPath (reference);

}

else

{

CIMClass cimClass;

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

{

throw XmlValidationError(parser.getLine(),

"Expected CLASS element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"Expected $0 element", "CLASS");

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

}

objectWithPath = CIMObject (cimClass);

objectWithPath.setPath (reference);

}

expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");

return true;

}

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

// getObjectArray()

// <object>

// (VALUE.OBJECT|VALUE.OBJECTWITHLOCALPATH|VALUE.OBJECTWITHPATH)

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

void XmlReader::getObjectArray(

XmlParser& parser,

Array<CIMObject>& objectArray)

{

CIMObject object;

CIMObject objectWithPath;

objectArray.clear();

if (getValueObjectElement(parser, object))

{

objectArray.append(object);

while (getValueObjectElement(parser, object))

objectArray.append(object);

}

else if (getValueObjectWithPathElement(parser, objectWithPath))

{

objectArray.append(objectWithPath);

while (getValueObjectWithPathElement(parser, objectWithPath))

objectArray.append(objectWithPath);

}

else if (getValueObjectWithLocalPathElement(parser, objectWithPath))

{

objectArray.append(objectWithPath);

while (getValueObjectWithLocalPathElement(parser, objectWithPath))

objectArray.append(objectWithPath);

}

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

// <objectName>: (CLASSNAME|INSTANCENAME)

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

Boolean XmlReader::getObjectNameElement(

XmlParser& parser,

CIMObjectPath& objectName)

{

CIMName className;

if (getClassNameElement(parser, className, false))

{

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

return true;

}

else if (getInstanceNameElement(parser, objectName))

return true;

else

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected CLASSNAME or INSTANCENAME element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",

"Expected $0 or $1 element", "CLASSNAME", "INSTANCENAME");

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

}

return false;

}

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

// <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>

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

Boolean XmlReader::getObjectPathElement(

XmlParser& parser,

CIMObjectPath& objectPath)

{

XmlEntry entry;

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

return false;

if (getClassPathElement(parser, objectPath))

{

expectEndTag(parser, "OBJECTPATH");

return true;

}

else if (getInstancePathElement(parser, objectPath))

{

expectEndTag(parser, "OBJECTPATH");

return true;

}

else

{

throw XmlValidationError(parser.getLine(),

"Expected INSTANCEPATH or CLASSPATH element");

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected INSTANCEPATH or CLASSPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT",

"expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH");

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

}

expectEndTag(parser, "VALUE.OBJECTWITHPATH");

PEGASUS_UNREACHABLE ( return false; )

}

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

// getEMethodCallStartTag()

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

Boolean XmlReader::getEMethodCallStartTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

return false;

// Get EXPMETHODCALL.NAME attribute:

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

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing EXPMETHODCALL.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"Missing $0 attribute",

"EXPMETHODCALL.NAME");

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

}

return true;

}

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

// getEMethodResponseStartTag()

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

Boolean XmlReader::getEMethodResponseStartTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

return false;

// Get EXPMETHODRESPONSE.NAME attribute:

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

// l10n

// throw XmlValidationError(

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

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"Missing $0 attribute",

"EXPMETHODRESPONSE.NAME");

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

}

return true;

}

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

// getEParamValueTag()

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

Boolean XmlReader::getEParamValueTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

return false;

// Get EXPPARAMVALUE.NAME attribute:

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

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing EXPPARAMVALUE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"Missing $0 attribute",

"EXPPARAMVALUE.NAME");

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

}

return true;

}

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

// getMethodCallStartTag()

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

Boolean XmlReader::getMethodCallStartTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

return false;

// Get METHODCALL.NAME attribute:

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

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing METHODCALL.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"Missing $0 attribute",

"METHODCALL.NAME");

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

}

return true;

}

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

// getMethodResponseStartTag()

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

Boolean XmlReader::getMethodResponseStartTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

return false;

// Get METHODRESPONSE.NAME attribute:

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

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing METHODRESPONSE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"Missing $0 attribute",

"METHODRESPONSE.NAME");

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

}

return true;

}

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

// getParamValueElement()

// <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>

// <!ATTLIST PARAMVALUE

// %CIMName;

// %ParamType;>

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

Boolean XmlReader::getParamValueElement(

XmlParser& parser,

CIMParamValue& paramValue)

{

XmlEntry entry;

const char* name;

CIMType type;

CIMValue value;

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

return false;

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

// Get PARAMVALUE.NAME attribute:

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

// l10n

// throw XmlValidationError(parser.getLine(),

// "Missing PARAMVALUE.NAME attribute");

MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE",

"Missing $0 attribute",

"PARAMVALUE.NAME");

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

}

// Get PARAMVALUE.PARAMTYPE attribute:

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

"PARAMVALUE", "PARAMTYPE", false);

if (!empty)

{

// Parse VALUE.REFERENCE and VALUE.REFARRAY type

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

}

// Parse non-reference value

if ( type != CIMTYPE_REFERENCE )

{

CIMType effectiveType;

if (!gotType)

{

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

{

value.clear(); // Isn't necessary; should already be cleared

}

expectEndTag(parser, "PARAMVALUE");

}

paramValue = CIMParamValue(name, value, gotType);

return true;

}

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

// getReturnValueElement()

// <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>

// <!ATTLIST RETURNVALUE

// %ParamType;>

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

Boolean XmlReader::getReturnValueElement(

XmlParser& parser,

CIMValue& returnValue)

{

XmlEntry entry;

CIMType type;

CIMValue value;

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

return false;

// Get RETURNVALUE.PARAMTYPE attribute:

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

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

"RETURNVALUE", "PARAMTYPE", false);

// Parse VALUE.REFERENCE type

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)

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected VALUE.REFERENCE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "VALUE.REFERENCE");

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

}

// Parse non-reference return value

if ( type != CIMTYPE_REFERENCE )

{

if (!gotType)

{

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

type = CIMTYPE_STRING;

}

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

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected VALUE element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT",

"expected $0 element", "VALUE");

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

}

expectEndTag(parser, "RETURNVALUE");

return true;

}

Legend:

Removed from v.1.18
changed lines
	Added in v.1.84.6.1

No CVS admin address has been configured