version 1.76, 2002/10/02 20:35:06
|
version 1.84.6.1, 2003/08/13 19:39:51
|
|
|
#include "CIMObject.h" | #include "CIMObject.h" |
#include "CIMParamValue.h" | #include "CIMParamValue.h" |
#include "System.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_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000)) |
#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF) | #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF) |
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
|
|
entry.type != XmlEntry::XML_DECLARATION || | entry.type != XmlEntry::XML_DECLARATION || |
strcmp(entry.text, "xml") != 0) | strcmp(entry.text, "xml") != 0) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected <?xml ... ?> style declaration"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected <?xml ... ?> style declaration"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE", |
|
"Expected $0 style declaration", |
|
"<?xml ... ?>"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
if (!entry.getAttributeValue("version", xmlVersion)) |
if (!entry.getAttributeValue("version", xmlVersion)) { |
throw XmlValidationError( |
|
parser.getLine(), "missing xml.version attribute"); |
// l10n |
|
|
|
// throw XmlValidationError( |
|
// parser.getLine(), "missing xml.version attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
"xml.version"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
| |
if (!entry.getAttributeValue("encoding", xmlEncoding)) | if (!entry.getAttributeValue("encoding", xmlEncoding)) |
{ | { |
|
|
entry.type != XmlEntry::START_TAG || | entry.type != XmlEntry::START_TAG || |
strcmp(entry.text, tagName) != 0) | strcmp(entry.text, tagName) != 0) |
{ | { |
char message[MESSAGE_SIZE]; |
// l10n |
sprintf(message, "Expected open of %s element", tagName); |
|
throw XmlValidationError(parser.getLine(), message); |
// char message[MESSAGE_SIZE]; |
|
// sprintf(message, "Expected open of %s element", tagName); |
|
// throw XmlValidationError(parser.getLine(), message); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPEN", |
|
"Expected open of $0 element", |
|
tagName); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
entry.type != XmlEntry::END_TAG || | entry.type != XmlEntry::END_TAG || |
strcmp(entry.text, tagName) != 0) | strcmp(entry.text, tagName) != 0) |
{ | { |
char message[MESSAGE_SIZE]; |
|
sprintf(message, "Expected close of %s element, got %s instead", |
// l10n |
|
|
|
// char message[MESSAGE_SIZE]; |
|
// sprintf(message, "Expected close of %s element, got %s instead", |
|
// tagName,entry.text); |
|
// throw XmlValidationError(parser.getLine(), message); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLOSE", |
|
"Expected close of $0 element, got $1 instead", |
tagName,entry.text); | tagName,entry.text); |
throw XmlValidationError(parser.getLine(), message); |
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
entry.type != XmlEntry::EMPTY_TAG) || | entry.type != XmlEntry::EMPTY_TAG) || |
strcmp(entry.text, tagName) != 0) | strcmp(entry.text, tagName) != 0) |
{ | { |
char message[MESSAGE_SIZE]; |
// l10n |
sprintf(message, |
|
"Expected either open or open/close %s element", tagName); |
// char message[MESSAGE_SIZE]; |
throw XmlValidationError(parser.getLine(), message); |
// sprintf(message, |
|
// "Expected either open or open/close %s element", tagName); |
|
// throw XmlValidationError(parser.getLine(), message); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OPENCLOSE", |
|
"Expected either open or open/close $0 element", |
|
tagName); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
(entry.type != XmlEntry::CONTENT && | (entry.type != XmlEntry::CONTENT && |
entry.type != XmlEntry::CDATA)) | entry.type != XmlEntry::CDATA)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
// l10n |
"Expected content of CDATA"); |
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected content of CDATA"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA", |
|
"Expected content of $0", "CDATA"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
return true; | return true; |
|
|
XmlEntry entry; | XmlEntry entry; |
XmlReader::expectStartTag(parser, entry, "CIM"); | XmlReader::expectStartTag(parser, entry, "CIM"); |
| |
if (!entry.getAttributeValue("CIMVERSION", cimVersion)) |
if (!entry.getAttributeValue("CIMVERSION", cimVersion)) { |
throw XmlValidationError( |
|
parser.getLine(), "missing CIM.CIMVERSION attribute"); |
// l10n |
|
|
if (!entry.getAttributeValue("DTDVERSION", dtdVersion)) |
// throw XmlValidationError( |
throw XmlValidationError( |
// parser.getLine(), "missing CIM.CIMVERSION attribute"); |
parser.getLine(), "missing CIM.DTDVERSION attribute"); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
"CIM.CIMVERSION"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
if (!entry.getAttributeValue("DTDVERSION", dtdVersion)){ |
|
|
|
// l10n |
|
|
|
// throw XmlValidationError( |
|
// parser.getLine(), "missing CIM.DTDVERSION attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
"CIM.DTDVERSION"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
| |
if (!entry.getAttributeValue("NAME", name)) | if (!entry.getAttributeValue("NAME", name)) |
{ | { |
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, "missing %s.NAME attribute", elementName); |
|
// throw XmlValidationError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, "missing %s.NAME attribute", elementName); |
sprintf(buffer, "%s.NAME", elementName); |
throw XmlValidationError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
buffer); |
|
|
|
throw XmlValidationError(lineNumber, mlParms); |
} | } |
| |
if (acceptNull && name.size() == 0) | if (acceptNull && name.size() == 0) |
|
|
| |
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
|
#ifdef PEGASUS_SNIA_INTEROP_TEST |
|
// In testing, replace illegal CIMName with this value to avoid the |
|
// exception and let xml parsing continue. THIS IS TEMP. |
|
name = "BADNAMESUBSTITUTEDBYPEGASUSCLIENT"; |
|
#else |
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, "Illegal value for %s.NAME attribute", elementName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, "Illegal value for %s.NAME attribute", elementName); |
sprintf(buffer, "%s.NAME", elementName); |
throw XmlSemanticError(lineNumber, buffer); |
|
} |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
| |
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
|
#endif |
|
} |
return CIMName (name); | return CIMName (name); |
} | } |
| |
|
|
| |
if (!entry.getAttributeValue("CLASSNAME", name)) | if (!entry.getAttributeValue("CLASSNAME", name)) |
{ | { |
|
|
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, "missing %s.CLASSNAME attribute", elementName); |
|
// throw XmlValidationError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, "missing %s.CLASSNAME attribute", elementName); |
sprintf(buffer, "%s.CLASSNAME", elementName); |
throw XmlValidationError(lineNumber, buffer); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
buffer); |
|
|
|
throw XmlValidationError(lineNumber, mlParms); |
|
|
} | } |
| |
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, |
|
// "Illegal value for %s.CLASSNAME attribute", elementName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, |
sprintf(buffer, "%s.CLASSNAME", elementName); |
"Illegal value for %s.CLASSNAME attribute", elementName); |
|
throw XmlSemanticError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
} | } |
| |
return name; | return name; |
|
|
| |
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, |
|
// "Illegal value for %s.CLASSORIGIN attribute", tagName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, |
sprintf(buffer, "%s.CLASSORIGIN", tagName); |
"Illegal value for %s.CLASSORIGIN attribute", tagName); |
|
throw XmlSemanticError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
return name; | return name; |
|
|
| |
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
|
#ifdef PEGASUS_SNIA_INTEROP_TEST |
|
name = "PEGASUS_SUBSTITUED_THIS_FOR_BAD_NAME"; |
|
return name; |
|
#endif |
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf(buffer, |
|
// "Illegal value for %s.REFERENCECLASS attribute", elementName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf(buffer, |
sprintf(buffer, "%s.REFERENCECLASS", elementName); |
"Illegal value for %s.REFERENCECLASS attribute", elementName); |
|
throw XmlSemanticError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
return name; | return name; |
|
|
| |
if (!CIMName::legal(superClass)) | if (!CIMName::legal(superClass)) |
{ | { |
|
|
|
// l10n |
|
|
|
// char buffer[MESSAGE_SIZE]; |
|
// sprintf( |
|
// buffer, "Illegal value for %s.SUPERCLASS attribute", tagName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
sprintf( |
sprintf(buffer, "%s.SUPERCLASS", tagName); |
buffer, "Illegal value for %s.SUPERCLASS attribute", tagName); |
|
throw XmlSemanticError(lineNumber, buffer); |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
return superClass; | return superClass; |
|
|
{ | { |
if (required) | if (required) |
{ | { |
|
|
|
// l10n |
|
|
|
// char message[MESSAGE_SIZE]; |
|
// sprintf(message, "missing %s.%s attribute", tagName, attributeName); |
|
// throw XmlValidationError(lineNumber, message); |
|
|
char message[MESSAGE_SIZE]; | char message[MESSAGE_SIZE]; |
sprintf(message, "missing %s.%s attribute", tagName, attributeName); |
sprintf(message, "%s.%s", tagName, attributeName); |
throw XmlValidationError(lineNumber, message); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
message); |
|
|
|
throw XmlValidationError(lineNumber, mlParms); |
|
|
} | } |
else | else |
{ | { |
|
|
((type == CIMTYPE_REFERENCE) && | ((type == CIMTYPE_REFERENCE) && |
(strcmp(attributeName, "PARAMTYPE") != 0))) | (strcmp(attributeName, "PARAMTYPE") != 0))) |
{ | { |
char message[MESSAGE_SIZE]; |
// l10n |
sprintf(message, "Illegal value for %s.%s attribute", tagName, |
|
attributeName); |
// char message[MESSAGE_SIZE]; |
throw XmlSemanticError(lineNumber, message); |
// sprintf(message, "Illegal value for %s.%s attribute", tagName, |
|
// attributeName); |
|
// throw XmlSemanticError(lineNumber, message); |
|
|
|
char buffer[MESSAGE_SIZE]; |
|
sprintf(buffer, "%s.%s", tagName, attributeName); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE", |
|
"Illegal value for $0 attribute", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
cimType = type; | cimType = type; |
|
|
if (!required) | if (!required) |
return defaultValue; | return defaultValue; |
| |
|
// l10n |
|
|
|
// char buffer[62]; |
|
// sprintf(buffer, "missing required %s.%s attribute", |
|
// attributeName, tagName); |
|
|
|
// throw XmlValidationError(lineNumber, buffer); |
|
|
char buffer[62]; | char buffer[62]; |
sprintf(buffer, "missing required %s.%s attribute", |
sprintf(buffer, "%s.%s", attributeName, tagName); |
attributeName, tagName); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE", |
|
"missing required $0 attribute", |
|
buffer); |
| |
throw XmlValidationError(lineNumber, buffer); |
throw XmlValidationError(lineNumber, mlParms); |
} | } |
| |
if (strcmp(tmp, "true") == 0) | if (strcmp(tmp, "true") == 0) |
|
|
else if (strcmp(tmp, "false") == 0) | else if (strcmp(tmp, "false") == 0) |
return false; | return false; |
| |
|
// l10n |
|
|
|
// char buffer[62]; |
|
// sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName); |
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
char buffer[62]; | char buffer[62]; |
sprintf(buffer, "Invalid %s.%s attribute value", attributeName, tagName); |
sprintf(buffer, "%s.%s", attributeName, tagName); |
throw XmlSemanticError(lineNumber, buffer); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_ATTRIBUTE", |
|
"Invalid $0 attribute value", |
|
buffer); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
return false; | return false; |
} | } |
| |
|
|
return n; | return n; |
} | } |
| |
|
// See http://www.ietf.org/rfc/rfc2396.txt section 2 |
|
String XmlReader::decodeURICharacters(String uriString) |
|
{ |
|
String decodedString; |
|
Uint32 i; |
|
|
|
for (i=0; i<uriString.size(); i++) |
|
{ |
|
if (uriString[i] == '%') |
|
{ |
|
if (i+2 >= uriString.size()) |
|
{ |
|
// l10n |
|
|
|
// throw ParseError("Invalid URI encoding"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING", |
|
"Invalid $0 encoding", "URI"); |
|
|
|
throw ParseError(MessageLoader::getMessage(mlParms)); |
|
|
|
} |
|
|
|
Uint8 digit1 = _hexCharToNumeric(char(uriString[++i])); |
|
Uint8 digit2 = _hexCharToNumeric(char(uriString[++i])); |
|
if ( (digit1 > 15) || (digit2 > 15) ) |
|
{ |
|
// l10n |
|
|
|
// throw ParseError("Invalid URI encoding"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING", |
|
"Invalid $0 encoding", "URI"); |
|
|
|
throw ParseError(MessageLoader::getMessage(mlParms)); |
|
} |
|
|
|
// ATTN: Handle non-UTF-8 character sets |
|
Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2); |
|
decodedString.append(Char16(decodedChar)); |
|
} |
|
else |
|
{ |
|
decodedString.append(uriString[i]); |
|
} |
|
} |
|
|
|
return decodedString; |
|
} |
|
|
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
// stringToSignedInteger | // stringToSignedInteger |
|
|
return CIMValue(true); | return CIMValue(true); |
else if (System::strcasecmp(valueString, "FALSE") == 0) | else if (System::strcasecmp(valueString, "FALSE") == 0) |
return CIMValue(false); | return CIMValue(false); |
else |
else { |
throw XmlSemanticError( |
|
lineNumber, "Invalid boolean value"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Invalid boolean value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
|
"Invalid $0 value", |
|
"boolean"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
|
} |
} | } |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
{ | { |
return CIMValue(String(valueString)); |
return CIMValue(String(valueString, STRING_FLAG_UTF8)); |
} | } |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
{ | { |
if (strlen(valueString) != 1) |
if (strlen(valueString) != 1) { |
throw XmlSemanticError(lineNumber, "Invalid char16 value"); |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "Invalid char16 value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
|
"Invalid $0 value", |
|
"char16"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
} |
| |
return CIMValue(Char16(valueString[0])); | return CIMValue(Char16(valueString[0])); |
} | } |
|
|
| |
if (!stringToUnsignedInteger(valueString, x)) | if (!stringToUnsignedInteger(valueString, x)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Invalid unsigned integer value"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Invalid unsigned integer value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
|
"Invalid $0 value", |
|
"unsigned integer"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
} | } |
| |
switch (type) | switch (type) |
|
|
{ | { |
if (x >= (Uint64(1)<<8)) | if (x >= (Uint64(1)<<8)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Uint8 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Uint8 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
|
"$0 value out of range", |
|
"Uint8"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Uint8(x)); | return CIMValue(Uint8(x)); |
} | } |
|
|
{ | { |
if (x >= (Uint64(1)<<16)) | if (x >= (Uint64(1)<<16)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Uint16 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Uint16 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
|
"$0 value out of range", |
|
"Uint16"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
} | } |
return CIMValue(Uint16(x)); | return CIMValue(Uint16(x)); |
} | } |
|
|
{ | { |
if (x >= (Uint64(1)<<32)) | if (x >= (Uint64(1)<<32)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Uint32 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Uint32 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
|
"$0 value out of range", |
|
"Uint32"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Uint32(x)); | return CIMValue(Uint32(x)); |
} | } |
|
|
| |
if (!stringToSignedInteger(valueString, x)) | if (!stringToSignedInteger(valueString, x)) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Invalid signed integer value"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Invalid signed integer value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
|
"Invalid $0 value", |
|
"signed integer"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
} | } |
| |
switch (type) | switch (type) |
|
|
{ | { |
if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) ) | if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) ) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Sint8 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Sint8 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
|
"$0 value out of range", |
|
"Sint8"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Sint8(x)); | return CIMValue(Sint8(x)); |
} | } |
|
|
{ | { |
if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) ) | if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) ) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Sint16 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Sint16 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
|
"$0 value out of range", |
|
"Sint16"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Sint16(x)); | return CIMValue(Sint16(x)); |
} | } |
|
|
{ | { |
if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) ) | if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) ) |
{ | { |
throw XmlSemanticError( |
|
lineNumber, "Sint32 value out of range"); |
// l10n |
|
|
|
// throw XmlSemanticError( |
|
// lineNumber, "Sint32 value out of range"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
|
"$0 value out of range", |
|
"Sint32"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
return CIMValue(Sint32(x)); | return CIMValue(Sint32(x)); |
} | } |
|
|
// KS 20021002 - Exception if no datatime value. Test for | // KS 20021002 - Exception if no datatime value. Test for |
// zero length and leave the NULL value in the variable | // zero length and leave the NULL value in the variable |
// Bugzilla 137 Adds the following if line. | // Bugzilla 137 Adds the following if line. |
|
// Expect this to become permanent but test only for now |
#ifdef PEGASUS_SNIA_INTEROP_TEST | #ifdef PEGASUS_SNIA_INTEROP_TEST |
if (strlen(valueString) != 0) | if (strlen(valueString) != 0) |
#endif | #endif |
|
|
} | } |
catch (InvalidDateTimeFormatException&) | catch (InvalidDateTimeFormatException&) |
{ | { |
cout << "KSTESTSNIA Invalid date time" << strlen(valueString) << "xx" << valueString << endl; |
|
throw XmlSemanticError(lineNumber, "Invalid datetime value"); |
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "Invalid datetime value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
|
"Invalid $0 value", |
|
"datetime"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
return CIMValue(tmp); | return CIMValue(tmp); |
|
|
{ | { |
Real64 x; | Real64 x; |
| |
if (!stringToReal(valueString, x)) |
if (!stringToReal(valueString, x)) { |
throw XmlSemanticError(lineNumber, "Invalid real number value"); |
|
|
// l10n |
| |
|
// throw XmlSemanticError(lineNumber, "Invalid real number value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
|
"Invalid $0 value", |
|
"real number"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
} |
return CIMValue(Real32(x)); | return CIMValue(Real32(x)); |
} | } |
| |
|
|
{ | { |
Real64 x; | Real64 x; |
| |
if (!stringToReal(valueString, x)) |
if (!stringToReal(valueString, x)) { |
throw XmlSemanticError(lineNumber, "Invalid real number value"); |
|
|
// l10n |
| |
|
// throw XmlSemanticError(lineNumber, "Invalid real number value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
|
"Invalid $0 value", |
|
"real number"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
} |
return CIMValue(x); | return CIMValue(x); |
} | } |
| |
|
|
break; | break; |
} | } |
| |
throw XmlSemanticError(lineNumber, "malformed XML"); |
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "malformed XML"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MALFORMED_XML", |
|
"malformed XML"); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
|
|
return false; | return false; |
} | } |
| |
|
|
| |
expectEndTag(parser, "VALUE"); | expectEndTag(parser, "VALUE"); |
} | } |
|
#ifdef PEGASUS_SNIA_INTEROP_TEST |
|
// KS 20021004 - tries to put value in even if empty. |
|
// Think this is general problem with empty value |
|
// Need to check meaning of (#PCDATA) - Does it allow empty. |
|
// Bugzilla tbd |
|
if (!empty) |
|
#endif |
value = stringToValue(parser.getLine(), valueString,type); | value = stringToValue(parser.getLine(), valueString,type); |
| |
return true; | return true; |
|
|
| |
if (!testStartTagOrEmptyTag(parser, entry, "VALUE")) | if (!testStartTagOrEmptyTag(parser, entry, "VALUE")) |
{ | { |
if (required) |
if (required) { |
throw XmlValidationError(parser.getLine(),"Expected VALUE element"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(),"Expected VALUE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"Expected $0 element", "VALUE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
|
|
} |
return false; | return false; |
} | } |
| |
|
|
expectEndTag(parser, "VALUE"); | expectEndTag(parser, "VALUE"); |
} | } |
| |
str = valueString; |
str = String(valueString,STRING_FLAG_UTF8); |
return true; | return true; |
} | } |
| |
|
|
} | } |
catch (AlreadyExistsException&) | catch (AlreadyExistsException&) |
{ | { |
throw XmlSemanticError(parser.getLine(), "duplicate qualifier"); |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), "duplicate qualifier"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE", |
|
"duplicate $0", "qualifier"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
} | } |
} | } |
|
|
| |
if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0) | if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0) |
{ | { |
|
// l10n |
|
|
|
// char message[128]; |
|
// sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE"); |
|
// throw XmlSemanticError(lineNumber, message); |
|
|
char message[128]; | char message[128]; |
sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE"); |
sprintf(message, "%s.%s", tagName, "ARRAYSIZE"); |
throw XmlSemanticError(lineNumber, message); |
|
|
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE", |
|
"Illegal value for $0", |
|
message); |
|
|
|
throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
value = Uint32(arraySize); | value = Uint32(arraySize); |
|
|
{ | { |
if (arraySize && arraySize != value.getArraySize()) | if (arraySize && arraySize != value.getArraySize()) |
{ | { |
throw XmlSemanticError(parser.getLine(), |
|
"ARRAYSIZE attribute and value-array size are different"); |
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "ARRAYSIZE attribute and value-array size are different"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT", |
|
"$0 attribute and $1 size are different", |
|
"ARRAYSIZE", "value-array"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
| |
property.setValue(value); | property.setValue(value); |
|
|
| |
if (!testStartTag(parser, entry, "HOST")) | if (!testStartTag(parser, entry, "HOST")) |
return false; | return false; |
|
#ifdef PEGASUS_SNIA_INTEROP_TEST |
|
// Temp code to allow empty HOST field. |
|
// SNIA CIMOMs return empty field particularly on enumerateinstance. |
|
// Simply substitute a string for the empty. |
|
if (!parser.next(entry)) |
|
throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine()); |
| |
if (!parser.next(entry) || entry.type != XmlEntry::CONTENT) |
if (entry.type == XmlEntry::CONTENT) |
|
host = String(entry.text,STRING_FLAG_UTF8); |
|
else |
{ | { |
throw XmlValidationError(parser.getLine(), |
parser.putBack(entry); |
"expected content of HOST element"); |
host = "HOSTNAMEINSERTEDBYPEGASUSCLIENT"; |
} | } |
| |
host = entry.text; |
#else |
|
|
|
if (!parser.next(entry) || entry.type != XmlEntry::CONTENT) |
|
{ |
|
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected content of HOST element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT", |
|
"expected content of $0 element", "HOST"); |
| |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
} |
|
|
|
host = String(entry.text,STRING_FLAG_UTF8); |
|
#endif |
expectEndTag(parser, "HOST"); | expectEndTag(parser, "HOST"); |
return true; | return true; |
} | } |
|
|
| |
if (!nameSpace.size()) | if (!nameSpace.size()) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected one or more NAMESPACE elements within " |
// l10n |
"LOCALNAMESPACEPATH element"); |
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected one or more NAMESPACE elements within " |
|
// "LOCALNAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS", |
|
"Expected one or more $0 elements within $1 element", |
|
"NAMESPACE", "LOCALNAMESPACEPATH"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
|
} | } |
| |
expectEndTag(parser, "LOCALNAMESPACEPATH"); | expectEndTag(parser, "LOCALNAMESPACEPATH"); |
|
|
if (!testStartTag(parser, entry, "NAMESPACEPATH")) | if (!testStartTag(parser, entry, "NAMESPACEPATH")) |
return false; | return false; |
| |
if (!getHostElement(parser, host)) |
if (!getHostElement(parser, host)) { |
throw XmlValidationError(parser.getLine(), "expected HOST element"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), "expected HOST element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "HOST"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
| |
if (!getLocalNameSpacePathElement(parser, nameSpace)) | if (!getLocalNameSpacePathElement(parser, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected LOCALNAMESPACEPATH element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected LOCALNAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "LOCALNAMESPACEPATH"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
expectEndTag(parser, "NAMESPACEPATH"); | expectEndTag(parser, "NAMESPACEPATH"); |
|
|
{ | { |
if (required) | if (required) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected CLASSNAME element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASSNAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "CLASSNAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
else | else |
return false; | return false; |
} | } |
|
|
Boolean empty = entry.type == XmlEntry::EMPTY_TAG; | Boolean empty = entry.type == XmlEntry::EMPTY_TAG; |
| |
className = getCimNameAttribute( | className = getCimNameAttribute( |
parser.getLine(), entry, "CLASSNAME", true); |
parser.getLine(), entry, "CLASSNAME", false); |
| |
if (!empty) | if (!empty) |
expectEndTag(parser, "CLASSNAME"); | expectEndTag(parser, "CLASSNAME"); |
|
|
else if (String::equal(tmp, "numeric")) | else if (String::equal(tmp, "numeric")) |
return CIMKeyBinding::NUMERIC; | return CIMKeyBinding::NUMERIC; |
| |
|
// char buffer[MESSAGE_SIZE]; |
|
|
|
// sprintf(buffer, |
|
// "Illegal value for %s.VALUETYPE attribute; " |
|
// "CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", |
|
// elementName); |
|
|
|
// throw XmlSemanticError(lineNumber, buffer); |
|
|
|
|
char buffer[MESSAGE_SIZE]; | char buffer[MESSAGE_SIZE]; |
|
sprintf(buffer, "%s.VALUETYPE", elementName); |
| |
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, mlParms); |
| |
throw XmlSemanticError(lineNumber, buffer); |
|
return CIMKeyBinding::BOOLEAN; | return CIMKeyBinding::BOOLEAN; |
} | } |
| |
|
|
throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine()); | throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine()); |
| |
if (entry.type == XmlEntry::CONTENT) | if (entry.type == XmlEntry::CONTENT) |
value = entry.text; |
value = String(entry.text,STRING_FLAG_UTF8); |
else | else |
parser.putBack(entry); | parser.putBack(entry); |
| |
|
|
| |
if (!getValueReferenceElement(parser, reference)) | if (!getValueReferenceElement(parser, reference)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected KEYVALUE or VALUE.REFERENCE element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected KEYVALUE or VALUE.REFERENCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
|
"Expected $0 or $1 element", "KEYVALUE", "VALUE.REFERENCE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
type = CIMKeyBinding::REFERENCE; | type = CIMKeyBinding::REFERENCE; |
|
|
| |
if (!getNameSpacePathElement(parser, host, nameSpace)) | if (!getNameSpacePathElement(parser, host, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected NAMESPACEPATH element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected NAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "NAMESPACEPATH"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
String className; | String className; |
|
|
| |
if (!getInstanceNameElement(parser, className, keyBindings)) | if (!getInstanceNameElement(parser, className, keyBindings)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected INSTANCENAME element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCENAME element"); |
|
|
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "INSTANCENAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
reference.set(host, nameSpace, className, keyBindings); | reference.set(host, nameSpace, className, keyBindings); |
|
|
| |
if (!getLocalNameSpacePathElement(parser, nameSpace)) | if (!getLocalNameSpacePathElement(parser, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected LOCALNAMESPACEPATH element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected LOCALNAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "LOCALNAMESPACEPATH"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
String className; | String className; |
|
|
| |
if (!getInstanceNameElement(parser, className, keyBindings)) | if (!getInstanceNameElement(parser, className, keyBindings)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected INSTANCENAME element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCENAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "INSTANCENAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
reference.set(String(), nameSpace, className, keyBindings); | reference.set(String(), nameSpace, className, keyBindings); |
|
|
| |
if (!getNameSpacePathElement(parser, host, nameSpace)) | if (!getNameSpacePathElement(parser, host, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected NAMESPACEPATH element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected NAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "NAMESPACEPATH"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
CIMName className; | CIMName className; |
| |
if (!getClassNameElement(parser, className)) | if (!getClassNameElement(parser, className)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected CLASSNAME element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASSNAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "CLASSNAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
reference.set(host, nameSpace, className); | reference.set(host, nameSpace, className); |
|
|
| |
if (!getLocalNameSpacePathElement(parser, nameSpace)) | if (!getLocalNameSpacePathElement(parser, nameSpace)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected LOCALNAMESPACEPATH element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected LOCALNAMESPACEPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "LOCALNAMESPACEPATH"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
CIMName className; | CIMName className; |
| |
if (!getClassNameElement(parser, className)) | if (!getClassNameElement(parser, className)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected CLASSNAME element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASSNAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "CLASSNAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
reference.set(String(), nameSpace, className); | reference.set(String(), nameSpace, className); |
|
|
if (entry.type != XmlEntry::START_TAG && | if (entry.type != XmlEntry::START_TAG && |
entry.type != XmlEntry::EMPTY_TAG) | entry.type != XmlEntry::EMPTY_TAG) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected one of the following start tags: " |
// l10n |
"CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, " |
|
"LOCALINSTANCEPATH, INSTANCENAME"); |
// throw XmlValidationError(parser.getLine(), |
|
// "Expected one of the following start tags: " |
|
// "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, " |
|
// "LOCALINSTANCEPATH, INSTANCENAME"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS", |
|
"Expected one of the following start tags: $0", "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
if (strcmp(entry.text, "CLASSPATH") == 0) | if (strcmp(entry.text, "CLASSPATH") == 0) |
|
|
} | } |
catch (AlreadyExistsException&) | catch (AlreadyExistsException&) |
{ | { |
throw XmlSemanticError(parser.getLine(), "duplicate property"); |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), "duplicate property"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE", |
|
"duplicate $0", "property"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
} | } |
} | } |
|
|
} | } |
catch (AlreadyExistsException&) | catch (AlreadyExistsException&) |
{ | { |
throw XmlSemanticError(parser.getLine(), "duplicate parameter"); |
|
|
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), "duplicate parameter"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE", |
|
"duplicate $0", "parameter"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
} | } |
} | } |
|
|
{ | { |
if (!isArray) | if (!isArray) |
{ | { |
throw XmlSemanticError(parser.getLine(), |
|
"VALUE.ARRAY element encountered without " |
// l10n |
"ISARRAY attribute"); |
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "VALUE.ARRAY element encountered without " |
|
// "ISARRAY attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY", |
|
"$0 element encountered without $1 attribute", |
|
"VALUE.ARRAY", "ISARRAY"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
| |
if (arraySize && arraySize != value.getArraySize()) | if (arraySize && arraySize != value.getArraySize()) |
{ | { |
throw XmlSemanticError(parser.getLine(), |
|
"VALUE.ARRAY size is not the same as " |
// l10n |
"ARRAYSIZE attribute"); |
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "VALUE.ARRAY size is not the same as " |
|
// "ARRAYSIZE attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME", |
|
"$0 size is not the same as $1 attribute", |
|
"VALUE.ARRAY", "ARRAYSIZE"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
| |
gotValue = true; | gotValue = true; |
|
|
{ | { |
if (isArray) | if (isArray) |
{ | { |
throw XmlSemanticError(parser.getLine(), |
|
"ISARRAY attribute used but VALUE element encountered"); |
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "ISARRAY attribute used but VALUE element encountered"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT", |
|
"$0 attribute used but $1 element encountered", |
|
"ISARRAY", "VALUE"); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
| |
gotValue = true; | gotValue = true; |
|
|
| |
if (!getInstanceNameElement(parser, instanceName)) | if (!getInstanceNameElement(parser, instanceName)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected INSTANCENAME element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCENAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "INSTANCENAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
// Get INSTANCE elements: | // Get INSTANCE elements: |
| |
if (!getInstanceElement(parser, namedInstance)) | if (!getInstanceElement(parser, namedInstance)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected INSTANCE element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCE element"); |
|
|
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "INSTANCE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
// Get VALUE.NAMEDINSTANCE end tag: | // Get VALUE.NAMEDINSTANCE end tag: |
|
|
{ | { |
if (!getClassElement(parser, x)) | if (!getClassElement(parser, x)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected CLASS element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASS element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "CLASS"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
{ | { |
if (!getInstanceElement(parser, x)) | if (!getInstanceElement(parser, x)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected INSTANCE element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "INSTANCE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
{ | { |
if (!getQualifierDeclElement(parser, x)) | if (!getQualifierDeclElement(parser, x)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected QUALIFIER.DECLARATION element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected QUALIFIER.DECLARATION element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "QUALIFIER.DECLARATION"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
| |
// Get MESSAGE.ID: | // Get MESSAGE.ID: |
| |
if (!entry.getAttributeValue("ID", id)) |
if (!entry.getAttributeValue("ID", id)) { |
throw XmlValidationError(parser.getLine(), |
|
"Invalid or missing MESSAGE.ID attribute"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Invalid or missing MESSAGE.ID attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_ATTRIBUTE", |
|
"Invalid or missing $0 attribute", "MESSAGE.ID"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
| |
// Get MESSAGE.PROTOCOLVERSION: | // Get MESSAGE.PROTOCOLVERSION: |
| |
if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion)) |
if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion)) { |
throw XmlValidationError(parser.getLine(), |
|
"Invalid or missing MESSAGE.PROTOCOLVERSION attribute"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Invalid or missing MESSAGE.PROTOCOLVERSION attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_ATTRIBUTE", |
|
"Invalid or missing $0 attribute", "MESSAGE.PROTOCOLVERSION"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
| |
return true; | return true; |
} | } |
|
|
| |
// Get IMETHODCALL.NAME attribute: | // Get IMETHODCALL.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
"Missing IMETHODCALL.NAME attribute"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing IMETHODCALL.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"Missing $0 attribute", |
|
"IMETHODCALL.NAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
| |
return true; | return true; |
} | } |
|
|
| |
// Get IMETHODRESPONSE.NAME attribute: | // Get IMETHODRESPONSE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
if (!entry.getAttributeValue("NAME", name)) { |
throw XmlValidationError(parser.getLine(), |
|
"Missing IMETHODRESPONSE.NAME attribute"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing IMETHODRESPONSE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"Missing $0 attribute", |
|
"IMETHODRESPONSE.NAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
| |
return true; | return true; |
} | } |
|
|
| |
// Get IPARAMVALUE.NAME attribute: | // Get IPARAMVALUE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
if (!entry.getAttributeValue("NAME", name)) { |
throw XmlValidationError(parser.getLine(), |
|
"Missing IPARAMVALUE.NAME attribute"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing IPARAMVALUE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"Missing $0 attribute", |
|
"IPARAMVALUE.NAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
| |
return true; | return true; |
} | } |
|
|
{ | { |
if (required) | if (required) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected VALUE element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected VALUE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"Expected $0 element", "VALUE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
return false; | return false; |
} | } |
|
|
result = true; | result = true; |
else if (System::strcasecmp(entry.text, "FALSE") == 0) | else if (System::strcasecmp(entry.text, "FALSE") == 0) |
result = false; | result = false; |
else |
else { |
throw XmlSemanticError(parser.getLine(), |
|
"Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\""); |
// l10n |
|
|
|
// throw XmlSemanticError(parser.getLine(), |
|
// "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\""); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT", |
|
"Invalid value for $0 element: must be $1 or $2", |
|
"VALUE", "\"TRUE\"", "\"FALSE\""); |
|
|
|
throw XmlSemanticError(parser.getLine(), mlParms); |
|
} |
| |
expectEndTag(parser, "VALUE"); | expectEndTag(parser, "VALUE"); |
| |
|
|
| |
if (!testStartTagOrEmptyTag(parser, entry, "ERROR")) | if (!testStartTagOrEmptyTag(parser, entry, "ERROR")) |
{ | { |
if (required) |
if (required) { |
throw XmlValidationError(parser.getLine(),"Expected ERROR element"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(),"Expected ERROR element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"Expected $0 element", "ERROR"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
} |
return false; | return false; |
} | } |
| |
|
|
| |
Uint32 tmpCode; | Uint32 tmpCode; |
| |
if (!entry.getAttributeValue("CODE", tmpCode)) |
if (!entry.getAttributeValue("CODE", tmpCode)) { |
throw XmlValidationError( |
|
parser.getLine(), "missing ERROR.CODE attribute"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError( |
|
// parser.getLine(), "missing ERROR.CODE attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"missing $0 attribute", |
|
"ERROR.CODE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
} |
| |
// Get ERROR.DESCRIPTION: | // Get ERROR.DESCRIPTION: |
| |
|
|
} | } |
else | else |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected INSTANCE or CLASS element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected INSTANCE or CLASS element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
|
"Expected $0 or $1 element", "INSTANCE", "CLASS"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
expectEndTag(parser, "VALUE.OBJECT"); | expectEndTag(parser, "VALUE.OBJECT"); |
|
|
isInstance = true; | isInstance = true; |
else if (!XmlReader::getClassPathElement(parser, reference)) | else if (!XmlReader::getClassPathElement(parser, reference)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected INSTANCEPATH or CLASSPATH element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected INSTANCEPATH or CLASSPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
|
"Expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
if (isInstance) | if (isInstance) |
|
|
| |
if (!XmlReader::getInstanceElement(parser, cimInstance)) | if (!XmlReader::getInstanceElement(parser, cimInstance)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected INSTANCE element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected INSTANCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"Expected $0 element", "INSTANCE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
objectWithPath = CIMObject (cimInstance); | objectWithPath = CIMObject (cimInstance); |
objectWithPath.setPath (reference); | objectWithPath.setPath (reference); |
|
|
| |
if (!XmlReader::getClassElement(parser, cimClass)) | if (!XmlReader::getClassElement(parser, cimClass)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected CLASS element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected CLASS element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"Expected $0 element", "CLASS"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
objectWithPath = CIMObject (cimClass); | objectWithPath = CIMObject (cimClass); |
objectWithPath.setPath (reference); | objectWithPath.setPath (reference); |
|
|
isInstance = true; | isInstance = true; |
else if (!XmlReader::getLocalClassPathElement(parser, reference)) | else if (!XmlReader::getLocalClassPathElement(parser, reference)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected LOCALINSTANCEPATH or LOCALCLASSPATH element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
|
"Expected $0 or $1 element", "LOCALINSTANCEPATH", "LOCALCLASSPATH"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
if (isInstance) | if (isInstance) |
|
|
| |
if (!XmlReader::getInstanceElement(parser, cimInstance)) | if (!XmlReader::getInstanceElement(parser, cimInstance)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected INSTANCE element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected INSTANCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"Expected $0 element", "INSTANCE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
objectWithPath = CIMObject (cimInstance); | objectWithPath = CIMObject (cimInstance); |
objectWithPath.setPath (reference); | objectWithPath.setPath (reference); |
|
|
| |
if (!XmlReader::getClassElement(parser, cimClass)) | if (!XmlReader::getClassElement(parser, cimClass)) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"Expected CLASS element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Expected CLASS element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"Expected $0 element", "CLASS"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
|
|
} | } |
objectWithPath = CIMObject (cimClass); | objectWithPath = CIMObject (cimClass); |
objectWithPath.setPath (reference); | objectWithPath.setPath (reference); |
|
|
return true; | return true; |
else | else |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected CLASSNAME or INSTANCENAME element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected CLASSNAME or INSTANCENAME element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
|
"Expected $0 or $1 element", "CLASSNAME", "INSTANCENAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
|
} | } |
| |
return false; | return false; |
|
|
} | } |
else | else |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected INSTANCEPATH or CLASSPATH element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected INSTANCEPATH or CLASSPATH element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
|
"expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
| |
PEGASUS_UNREACHABLE ( return false; ) | PEGASUS_UNREACHABLE ( return false; ) |
|
|
| |
// Get EXPMETHODCALL.NAME attribute: | // Get EXPMETHODCALL.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
"Missing EXPMETHODCALL.NAME attribute"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing EXPMETHODCALL.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"Missing $0 attribute", |
|
"EXPMETHODCALL.NAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
| |
return true; | return true; |
} | } |
|
|
| |
// Get EXPMETHODRESPONSE.NAME attribute: | // Get EXPMETHODRESPONSE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
"Missing EXPMETHODRESPONSE.NAME attribute"); |
// l10n |
|
|
|
// throw XmlValidationError( |
|
// parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"Missing $0 attribute", |
|
"EXPMETHODRESPONSE.NAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// getEParamValueTag() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::getEParamValueTag( |
|
XmlParser& parser, |
|
const char*& name) |
|
{ |
|
XmlEntry entry; |
|
|
|
if (!testStartTag(parser, entry, "EXPPARAMVALUE")) |
|
return false; |
|
|
|
// Get EXPPARAMVALUE.NAME attribute: |
|
|
|
|
|
if (!entry.getAttributeValue("NAME", name)) { |
|
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing EXPPARAMVALUE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"Missing $0 attribute", |
|
"EXPPARAMVALUE.NAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
|
|
| |
return true; | return true; |
} | } |
|
|
| |
// Get METHODCALL.NAME attribute: | // Get METHODCALL.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
"Missing METHODCALL.NAME attribute"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing METHODCALL.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"Missing $0 attribute", |
|
"METHODCALL.NAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
| |
return true; | return true; |
} | } |
|
|
| |
// Get METHODRESPONSE.NAME attribute: | // Get METHODRESPONSE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
|
throw XmlValidationError(parser.getLine(), |
if (!entry.getAttributeValue("NAME", name)) { |
"Missing METHODRESPONSE.NAME attribute"); |
|
|
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing METHODRESPONSE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"Missing $0 attribute", |
|
"METHODRESPONSE.NAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
| |
return true; | return true; |
} | } |
|
|
| |
// Get PARAMVALUE.NAME attribute: | // Get PARAMVALUE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) |
if (!entry.getAttributeValue("NAME", name)) { |
throw XmlValidationError(parser.getLine(), |
|
"Missing PARAMVALUE.NAME attribute"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "Missing PARAMVALUE.NAME attribute"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
|
"Missing $0 attribute", |
|
"PARAMVALUE.NAME"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
|
| |
// Get PARAMVALUE.PARAMTYPE attribute: | // Get PARAMVALUE.PARAMTYPE attribute: |
| |
|
|
} | } |
else if (type == CIMTYPE_REFERENCE) | else if (type == CIMTYPE_REFERENCE) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected VALUE.REFERENCE element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected VALUE.REFERENCE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "VALUE.REFERENCE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |
|
|
| |
if ( !XmlReader::getValueElement(parser, type, returnValue) ) | if ( !XmlReader::getValueElement(parser, type, returnValue) ) |
{ | { |
throw XmlValidationError(parser.getLine(), |
|
"expected VALUE element"); |
// l10n |
|
|
|
// throw XmlValidationError(parser.getLine(), |
|
// "expected VALUE element"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
|
"expected $0 element", "VALUE"); |
|
|
|
throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
| |