version 1.84.6.1, 2003/08/13 19:39:51
|
version 1.94.4.4, 2004/07/02 14:40:08
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%2003//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM, |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
// The Open Group, Tivoli Systems |
// Company, L. P., IBM Corp., The Open Group, Tivoli Systems. |
|
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; |
|
// IBM Corp.; EMC Corporation, The Open Group. |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy | // Permission is hereby granted, free of charge, to any person obtaining a copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
// (carolann_graves@hp.com) | // (carolann_graves@hp.com) |
// Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) | // Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) |
// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) | // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) |
|
// Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
|
|
#include "CIMObject.h" | #include "CIMObject.h" |
#include "CIMParamValue.h" | #include "CIMParamValue.h" |
#include "System.h" | #include "System.h" |
|
#include "XmlConstants.h" |
#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM | #ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM |
#include "OS400ConvertChar.h" | #include "OS400ConvertChar.h" |
#endif | #endif |
|
|
// "Expected <?xml ... ?> style declaration"); | // "Expected <?xml ... ?> style declaration"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE", | MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_XML_STYLE", |
"Expected $0 style declaration", |
"Expected <?xml ... ?> style declaration"); |
"<?xml ... ?>"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError( | // throw XmlValidationError( |
// parser.getLine(), "missing xml.version attribute"); | // parser.getLine(), "missing xml.version attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_XML_ATTRIBUTE", |
"missing $0 attribute", |
"missing xml.version attribute"); |
"xml.version"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// "Expected content of CDATA"); | // "Expected content of CDATA"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA", | MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CDATA", |
"Expected content of $0", "CDATA"); |
"Expected content of CDATA"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
|
// testStartTagOrEmptyTag() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
Boolean XmlReader::testStartTagOrEmptyTag( |
|
XmlParser& parser, |
|
XmlEntry& entry) |
|
{ |
|
if (!parser.next(entry) || |
|
(entry.type != XmlEntry::START_TAG && |
|
entry.type != XmlEntry::EMPTY_TAG)) |
|
{ |
|
parser.putBack(entry); |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
// testContentOrCData() | // testContentOrCData() |
// | // |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
// throw XmlValidationError( | // throw XmlValidationError( |
// parser.getLine(), "missing CIM.CIMVERSION attribute"); | // parser.getLine(), "missing CIM.CIMVERSION attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE", |
"missing $0 attribute", |
"missing CIM.CIMVERSION attribute"); |
"CIM.CIMVERSION"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError( | // throw XmlValidationError( |
// parser.getLine(), "missing CIM.DTDVERSION attribute"); | // parser.getLine(), "missing CIM.DTDVERSION attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE", |
"missing $0 attribute", |
"missing CIM.DTDVERSION attribute"); |
"CIM.DTDVERSION"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
return true; | return true; |
} | } |
| |
inline Uint8 _hexCharToNumeric(const char c) |
inline Uint8 _xmlReader_hexCharToNumeric(const char c) |
{ | { |
Uint8 n; | Uint8 n; |
| |
|
|
} | } |
| |
// See http://www.ietf.org/rfc/rfc2396.txt section 2 | // See http://www.ietf.org/rfc/rfc2396.txt section 2 |
|
// |
|
// Also see the "CIM Operations over HTTP" spec, section 3.3.2 and |
|
// 3.3.3, for the treatment of non US-ASCII chars (UTF-8) |
String XmlReader::decodeURICharacters(String uriString) | String XmlReader::decodeURICharacters(String uriString) |
{ | { |
String decodedString; |
|
Uint32 i; | Uint32 i; |
| |
|
Array<Uint8> utf8Chars; |
|
|
for (i=0; i<uriString.size(); i++) | for (i=0; i<uriString.size(); i++) |
{ | { |
if (uriString[i] == '%') | if (uriString[i] == '%') |
|
|
| |
// throw ParseError("Invalid URI encoding"); | // throw ParseError("Invalid URI encoding"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING", |
"Invalid $0 encoding", "URI"); |
"Invalid URI encoding"); |
| |
throw ParseError(MessageLoader::getMessage(mlParms)); | throw ParseError(MessageLoader::getMessage(mlParms)); |
| |
} | } |
| |
Uint8 digit1 = _hexCharToNumeric(char(uriString[++i])); |
Uint8 digit1 = _xmlReader_hexCharToNumeric(char(uriString[++i])); |
Uint8 digit2 = _hexCharToNumeric(char(uriString[++i])); |
Uint8 digit2 = _xmlReader_hexCharToNumeric(char(uriString[++i])); |
if ( (digit1 > 15) || (digit2 > 15) ) | if ( (digit1 > 15) || (digit2 > 15) ) |
{ | { |
// l10n | // l10n |
| |
// throw ParseError("Invalid URI encoding"); | // throw ParseError("Invalid URI encoding"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_ENCODING", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_URI_ENCODING", |
"Invalid $0 encoding", "URI"); |
"Invalid URI encoding"); |
| |
throw ParseError(MessageLoader::getMessage(mlParms)); | throw ParseError(MessageLoader::getMessage(mlParms)); |
} | } |
| |
// ATTN: Handle non-UTF-8 character sets |
|
Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2); | Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2); |
decodedString.append(Char16(decodedChar)); |
utf8Chars.append((Uint8)decodedChar); |
} | } |
else | else |
{ | { |
decodedString.append(uriString[i]); |
utf8Chars.append((Uint8)uriString[i]); |
} | } |
} | } |
| |
return decodedString; |
// If there was a string to decode... |
|
if (uriString.size() > 0) |
|
{ |
|
// Convert UTF-8 to UTF-16 and return the String |
|
utf8Chars.append('\0'); |
|
return String((char *)utf8Chars.getData(),STRING_FLAG_UTF8); |
|
} |
|
else |
|
{ |
|
return String(); |
|
} |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
x = x << 4; | x = x << 4; |
| |
// Make sure we don't overflow when we add the next digit | // Make sure we don't overflow when we add the next digit |
Sint64 newDigit = Sint64(_hexCharToNumeric(*p++)); |
Sint64 newDigit = Sint64(_xmlReader_hexCharToNumeric(*p++)); |
if (PEGASUS_SINT64_MIN - x > -newDigit) | if (PEGASUS_SINT64_MIN - x > -newDigit) |
{ | { |
return false; | return false; |
|
|
x = x << 4; | x = x << 4; |
| |
// We can't overflow when we add the next digit | // We can't overflow when we add the next digit |
Uint64 newDigit = Uint64(_hexCharToNumeric(*p++)); |
Uint64 newDigit = Uint64(_xmlReader_hexCharToNumeric(*p++)); |
if (PEGASUS_UINT64_MAX - x < newDigit) | if (PEGASUS_UINT64_MAX - x < newDigit) |
{ | { |
return false; | return false; |
|
|
// throw XmlSemanticError( | // throw XmlSemanticError( |
// lineNumber, "Invalid boolean value"); | // lineNumber, "Invalid boolean value"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_BOOLEAN_VALUE", |
"Invalid $0 value", |
"Invalid boolean value"); |
"boolean"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
| |
|
|
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
{ | { |
|
|
|
// remove this test, utf-8 can be up to 6 bytes per char |
|
/* |
if (strlen(valueString) != 1) { | if (strlen(valueString) != 1) { |
|
// l10n |
|
|
|
// throw XmlSemanticError(lineNumber, "Invalid char16 value"); |
|
|
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE", |
|
"Invalid char16 value"); |
| |
|
throw XmlSemanticError(lineNumber, mlParms); |
|
} |
|
*/ |
|
// Converts UTF-8 to UTF-16 |
|
String tmp(valueString, STRING_FLAG_UTF8); |
|
if (tmp.size() != 1) |
|
{ |
// l10n | // l10n |
| |
// throw XmlSemanticError(lineNumber, "Invalid char16 value"); | // throw XmlSemanticError(lineNumber, "Invalid char16 value"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_CHAR16_VALUE", |
"Invalid $0 value", |
"Invalid char16 value"); |
"char16"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
| |
return CIMValue(Char16(valueString[0])); |
return CIMValue(tmp[0]); |
} | } |
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
|
|
// throw XmlSemanticError( | // throw XmlSemanticError( |
// lineNumber, "Invalid unsigned integer value"); | // lineNumber, "Invalid unsigned integer value"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_UI_VALUE", |
"Invalid $0 value", |
"Invalid unsigned integer value"); |
"unsigned integer"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
| |
|
|
// throw XmlSemanticError( | // throw XmlSemanticError( |
// lineNumber, "Uint8 value out of range"); | // lineNumber, "Uint8 value out of range"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
MessageLoaderParms mlParms("Common.XmlReader.U8_VALUE_OUT_OF_RANGE", |
"$0 value out of range", |
"Uint8 value out of range"); |
"Uint8"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
|
|
// throw XmlSemanticError( | // throw XmlSemanticError( |
// lineNumber, "Uint16 value out of range"); | // lineNumber, "Uint16 value out of range"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
MessageLoaderParms mlParms("Common.XmlReader.U16_VALUE_OUT_OF_RANGE", |
"$0 value out of range", |
"Uint16 value out of range"); |
"Uint16"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
| |
|
|
// throw XmlSemanticError( | // throw XmlSemanticError( |
// lineNumber, "Uint32 value out of range"); | // lineNumber, "Uint32 value out of range"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
MessageLoaderParms mlParms("Common.XmlReader.U32_VALUE_OUT_OF_RANGE", |
"$0 value out of range", |
"Uint32 value out of range"); |
"Uint32"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
|
|
// throw XmlSemanticError( | // throw XmlSemanticError( |
// lineNumber, "Invalid signed integer value"); | // lineNumber, "Invalid signed integer value"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_SI_VALUE", |
"Invalid $0 value", |
"Invalid signed integer value"); |
"signed integer"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
| |
|
|
// throw XmlSemanticError( | // throw XmlSemanticError( |
// lineNumber, "Sint8 value out of range"); | // lineNumber, "Sint8 value out of range"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
MessageLoaderParms mlParms("Common.XmlReader.S8_VALUE_OUT_OF_RANGE", |
"$0 value out of range", |
"Sint8 value out of range"); |
"Sint8"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
|
|
// throw XmlSemanticError( | // throw XmlSemanticError( |
// lineNumber, "Sint16 value out of range"); | // lineNumber, "Sint16 value out of range"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
MessageLoaderParms mlParms("Common.XmlReader.S16_VALUE_OUT_OF_RANGE", |
"$0 value out of range", |
"Sint16 value out of range"); |
"Sint16"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
|
|
// throw XmlSemanticError( | // throw XmlSemanticError( |
// lineNumber, "Sint32 value out of range"); | // lineNumber, "Sint32 value out of range"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.VALUE_OUT_OF_RANGE", |
MessageLoaderParms mlParms("Common.XmlReader.S32_VALUE_OUT_OF_RANGE", |
"$0 value out of range", |
"Sint32 value out of range"); |
"Sint32"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
|
|
| |
// throw XmlSemanticError(lineNumber, "Invalid datetime value"); | // throw XmlSemanticError(lineNumber, "Invalid datetime value"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_DATETIME_VALUE", |
"Invalid $0 value", |
"Invalid datetime value"); |
"datetime"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
|
|
| |
// throw XmlSemanticError(lineNumber, "Invalid real number value"); | // throw XmlSemanticError(lineNumber, "Invalid real number value"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE", |
"Invalid $0 value", |
"Invalid real number value"); |
"real number"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
|
|
| |
// throw XmlSemanticError(lineNumber, "Invalid real number value"); | // throw XmlSemanticError(lineNumber, "Invalid real number value"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_RN_VALUE", |
"Invalid $0 value", |
"Invalid real number value"); |
"real number"); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
|
|
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
|
// skipElement() |
|
// |
|
//------------------------------------------------------------------------------ |
|
void XmlReader::skipElement( |
|
XmlParser& parser, |
|
XmlEntry& entry) |
|
{ |
|
const char * tag_name = entry.text; |
|
|
|
if (entry.type == XmlEntry::EMPTY_TAG) |
|
{ |
|
return; |
|
} |
|
|
|
while (testStartTagOrEmptyTag(parser, entry)) |
|
{ |
|
skipElement(parser, entry); |
|
} |
|
|
|
if (testContentOrCData(parser, entry)) |
|
{ |
|
; // skip |
|
} |
|
|
|
expectEndTag(parser, tag_name); |
|
return; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
// getValueElement() | // getValueElement() |
// | // |
// <!ELEMENT VALUE (#PCDATA)> | // <!ELEMENT VALUE (#PCDATA)> |
|
|
| |
// throw XmlValidationError(parser.getLine(),"Expected VALUE element"); | // throw XmlValidationError(parser.getLine(),"Expected VALUE element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT", |
"Expected $0 element", "VALUE"); |
"Expected VALUE element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
| |
// throw XmlSemanticError(parser.getLine(), "duplicate qualifier"); | // throw XmlSemanticError(parser.getLine(), "duplicate qualifier"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE", |
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_QUALIFIER", |
"duplicate $0", "qualifier"); |
"duplicate qualifier"); |
| |
throw XmlSemanticError(parser.getLine(), mlParms); | throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
|
|
// "ARRAYSIZE attribute and value-array size are different"); | // "ARRAYSIZE attribute and value-array size are different"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT", | MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_DIFFERENT", |
"$0 attribute and $1 size are different", |
"ARRAYSIZE attribute and value-array size are different"); |
"ARRAYSIZE", "value-array"); |
|
| |
throw XmlSemanticError(parser.getLine(), mlParms); | throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
|
|
// "expected content of HOST element"); | // "expected content of HOST element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT", | MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CONTENT_ELEMENT", |
"expected content of $0 element", "HOST"); |
"expected content of HOST element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// "LOCALNAMESPACEPATH element"); | // "LOCALNAMESPACEPATH element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS", | MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS", |
"Expected one or more $0 elements within $1 element", |
"Expected one or more NAMESPACE elements within LOCALNAMESPACEPATH element"); |
"NAMESPACE", "LOCALNAMESPACEPATH"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
| |
// throw XmlValidationError(parser.getLine(), "expected HOST element"); | // throw XmlValidationError(parser.getLine(), "expected HOST element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_HOST_ELEMENT", |
"expected $0 element", "HOST"); |
"expected HOST element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected LOCALNAMESPACEPATH element"); | // "expected LOCALNAMESPACEPATH element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT", |
"expected $0 element", "LOCALNAMESPACEPATH"); |
"expected LOCALNAMESPACEPATH element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected CLASSNAME element"); | // "expected CLASSNAME element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT", |
"expected $0 element", "CLASSNAME"); |
"expected CLASSNAME element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
sprintf(buffer, "%s.VALUETYPE", elementName); | sprintf(buffer, "%s.VALUETYPE", elementName); |
| |
MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE", | MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE", |
"Illegal value for $0 attribute; $1 must be one of $2, $3, or $4", |
"Illegal value for $0 attribute; CIMValue must be one of \"string\", \"boolean\", or \"numeric\"", buffer); |
buffer, "CIMValue", "\"string\"", "\"boolean\"", "\"numeric\""); |
|
| |
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Expected KEYVALUE or VALUE.REFERENCE element"); | // "Expected KEYVALUE or VALUE.REFERENCE element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT", |
"Expected $0 or $1 element", "KEYVALUE", "VALUE.REFERENCE"); |
"Expected KEYVALUE or VALUE.REFERENCE element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected NAMESPACEPATH element"); | // "expected NAMESPACEPATH element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT", |
"expected $0 element", "NAMESPACEPATH"); |
"expected NAMESPACEPATH element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// "expected INSTANCENAME element"); | // "expected INSTANCENAME element"); |
| |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT", |
"expected $0 element", "INSTANCENAME"); |
"expected INSTANCENAME element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected LOCALNAMESPACEPATH element"); | // "expected LOCALNAMESPACEPATH element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT", |
"expected $0 element", "LOCALNAMESPACEPATH"); |
"expected LOCALNAMESPACEPATH element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected INSTANCENAME element"); | // "expected INSTANCENAME element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT", |
"expected $0 element", "INSTANCENAME"); |
"expected INSTANCENAME element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected NAMESPACEPATH element"); | // "expected NAMESPACEPATH element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT", |
"expected $0 element", "NAMESPACEPATH"); |
"expected NAMESPACEPATH element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected CLASSNAME element"); | // "expected CLASSNAME element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT", |
"expected $0 element", "CLASSNAME"); |
"expected CLASSNAME element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected LOCALNAMESPACEPATH element"); | // "expected LOCALNAMESPACEPATH element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT", |
"expected $0 element", "LOCALNAMESPACEPATH"); |
"expected LOCALNAMESPACEPATH element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected CLASSNAME element"); | // "expected CLASSNAME element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT", |
"expected $0 element", "CLASSNAME"); |
"expected CLASSNAME element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// "LOCALINSTANCEPATH, INSTANCENAME"); | // "LOCALINSTANCEPATH, INSTANCENAME"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS", | MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_START_TAGS", |
"Expected one of the following start tags: $0", "CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME"); |
"Expected one of the following start tags: CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, INSTANCENAME"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
| |
// throw XmlSemanticError(parser.getLine(), "duplicate property"); | // throw XmlSemanticError(parser.getLine(), "duplicate property"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE", |
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PROPERTY", |
"duplicate $0", "property"); |
"duplicate property"); |
| |
throw XmlSemanticError(parser.getLine(), mlParms); | throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
|
|
| |
// throw XmlSemanticError(parser.getLine(), "duplicate parameter"); | // throw XmlSemanticError(parser.getLine(), "duplicate parameter"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE", |
MessageLoaderParms mlParms("Common.XmlReader.DUPLICATE_PARAMETER", |
"duplicate $0", "parameter"); |
"duplicate parameter"); |
| |
throw XmlSemanticError(parser.getLine(), mlParms); | throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
|
|
// "ISARRAY attribute"); | // "ISARRAY attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY", | MessageLoaderParms mlParms("Common.XmlReader.ARRAY_WITHOUT_ISARRAY", |
"$0 element encountered without $1 attribute", |
"VALUE.ARRAY element encountered without ISARRAY attribute"); |
"VALUE.ARRAY", "ISARRAY"); |
|
| |
throw XmlSemanticError(parser.getLine(), mlParms); | throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
|
|
// "ARRAYSIZE attribute"); | // "ARRAYSIZE attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME", | MessageLoaderParms mlParms("Common.XmlReader.ARRAY_SIZE_NOT_SAME", |
"$0 size is not the same as $1 attribute", |
"VALUE.ARRAY size is not the same as ARRAYSIZE attribute"); |
"VALUE.ARRAY", "ARRAYSIZE"); |
|
| |
throw XmlSemanticError(parser.getLine(), mlParms); | throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
|
|
// "ISARRAY attribute used but VALUE element encountered"); | // "ISARRAY attribute used but VALUE element encountered"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT", | MessageLoaderParms mlParms("Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT", |
"$0 attribute used but $1 element encountered", |
"ISARRAY attribute used but VALUE element encountered"); |
"ISARRAY", "VALUE"); |
|
| |
throw XmlSemanticError(parser.getLine(), mlParms); | throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
|
|
{ | { |
XmlEntry entry; | XmlEntry entry; |
| |
if (!testStartTag(parser, entry, "CLASS")) |
if (!testStartTagOrEmptyTag(parser, entry, "CLASS")) |
return false; | return false; |
| |
CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS"); | CIMName name = getCimNameAttribute(parser.getLine(), entry, "CLASS"); |
|
|
| |
cimClass = CIMClass(name, superClass); | cimClass = CIMClass(name, superClass); |
| |
|
if(entry.type != XmlEntry::EMPTY_TAG) |
|
{ |
|
|
// Get QUALIFIER elements: | // Get QUALIFIER elements: |
| |
getQualifierElements(parser, cimClass); | getQualifierElements(parser, cimClass); |
|
|
// Get CLASS end tag: | // Get CLASS end tag: |
| |
expectEndTag(parser, "CLASS"); | expectEndTag(parser, "CLASS"); |
|
} |
| |
return true; | return true; |
} | } |
|
|
{ | { |
XmlEntry entry; | XmlEntry entry; |
| |
if (!testStartTag(parser, entry, "INSTANCE")) |
if (!testStartTagOrEmptyTag(parser, entry, "INSTANCE")) |
return false; | return false; |
| |
|
Boolean empty = entry.type == XmlEntry::EMPTY_TAG; |
|
|
String className = getClassNameAttribute( | String className = getClassNameAttribute( |
parser.getLine(), entry, "INSTANCE"); | parser.getLine(), entry, "INSTANCE"); |
| |
cimInstance = CIMInstance(className); | cimInstance = CIMInstance(className); |
| |
|
if (!empty) |
|
{ |
// Get QUALIFIER elements: | // Get QUALIFIER elements: |
|
|
getQualifierElements(parser, cimInstance); | getQualifierElements(parser, cimInstance); |
| |
// Get PROPERTY elements: | // Get PROPERTY elements: |
|
|
GetPropertyElements(parser, cimInstance); | GetPropertyElements(parser, cimInstance); |
| |
// Get INSTANCE end tag: | // Get INSTANCE end tag: |
|
|
expectEndTag(parser, "INSTANCE"); | expectEndTag(parser, "INSTANCE"); |
|
} |
| |
return true; | return true; |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected INSTANCENAME element"); | // "expected INSTANCENAME element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT", |
"expected $0 element", "INSTANCENAME"); |
"expected INSTANCENAME element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// "expected INSTANCE element"); | // "expected INSTANCE element"); |
| |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT", |
"expected $0 element", "INSTANCE"); |
"expected INSTANCE element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected CLASS element"); | // "expected CLASS element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT", |
"expected $0 element", "CLASS"); |
"expected CLASS element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected INSTANCE element"); | // "expected INSTANCE element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT", |
"expected $0 element", "INSTANCE"); |
"expected INSTANCE element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected QUALIFIER.DECLARATION element"); | // "expected QUALIFIER.DECLARATION element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT", |
"expected $0 element", "QUALIFIER.DECLARATION"); |
"expected QUALIFIER.DECLARATION element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Invalid or missing MESSAGE.ID attribute"); | // "Invalid or missing MESSAGE.ID attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE", |
"Invalid or missing $0 attribute", "MESSAGE.ID"); |
"Invalid or missing MESSAGE.ID attribute"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Invalid or missing MESSAGE.PROTOCOLVERSION attribute"); | // "Invalid or missing MESSAGE.PROTOCOLVERSION attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE", |
"Invalid or missing $0 attribute", "MESSAGE.PROTOCOLVERSION"); |
"Invalid or missing MESSAGE.PROTOCOLVERSION attribute"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Missing IMETHODCALL.NAME attribute"); | // "Missing IMETHODCALL.NAME attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE", |
"Missing $0 attribute", |
"Missing IMETHODCALL.NAME attribute"); |
"IMETHODCALL.NAME"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Missing IMETHODRESPONSE.NAME attribute"); | // "Missing IMETHODRESPONSE.NAME attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE", |
"Missing $0 attribute", |
"Missing IMETHODRESPONSE.NAME attribute"); |
"IMETHODRESPONSE.NAME"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
| |
Boolean XmlReader::getIParamValueTag( | Boolean XmlReader::getIParamValueTag( |
XmlParser& parser, | XmlParser& parser, |
const char*& name) |
const char*& name, |
|
Boolean& isEmptyTag) |
{ | { |
XmlEntry entry; | XmlEntry entry; |
| |
if (!testStartTag(parser, entry, "IPARAMVALUE")) |
if (!testStartTagOrEmptyTag(parser, entry, "IPARAMVALUE")) |
return false; | return false; |
| |
|
isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG); |
|
|
// Get IPARAMVALUE.NAME attribute: | // Get IPARAMVALUE.NAME attribute: |
| |
if (!entry.getAttributeValue("NAME", name)) { | if (!entry.getAttributeValue("NAME", name)) { |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Missing IPARAMVALUE.NAME attribute"); | // "Missing IPARAMVALUE.NAME attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE", |
"Missing $0 attribute", |
"Missing IPARAMVALUE.NAME attribute"); |
"IPARAMVALUE.NAME"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
|
// rejectNullIParamValue() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
void XmlReader::rejectNullIParamValue( |
|
XmlParser& parser, |
|
Boolean isEmptyTag, |
|
const char* paramName) |
|
{ |
|
if (isEmptyTag) |
|
{ |
|
MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE", |
|
"A null value is not valid for IPARAMVALUE \"$0\".", |
|
paramName); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
// getBooleanValueElement() | // getBooleanValueElement() |
// | // |
// Get an elements like: "<VALUE>FALSE</VALUE>" | // Get an elements like: "<VALUE>FALSE</VALUE>" |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Expected VALUE element"); | // "Expected VALUE element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT", |
"Expected $0 element", "VALUE"); |
"Expected VALUE element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\""); | // "Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\""); |
| |
MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT", | MessageLoaderParms mlParms("Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT", |
"Invalid value for $0 element: must be $1 or $2", |
"Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\""); |
"VALUE", "\"TRUE\"", "\"FALSE\""); |
|
| |
throw XmlSemanticError(parser.getLine(), mlParms); | throw XmlSemanticError(parser.getLine(), mlParms); |
} | } |
|
|
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
// Pending DMTF CR |
// | // |
// getErrorElement() |
// <!ELEMENT ERROR (INSTANCE*)> |
// |
|
// <!ELEMENT ERROR EMPTY> |
|
// <!ATTLIST ERROR | // <!ATTLIST ERROR |
// CODE CDATA #REQUIRED | // CODE CDATA #REQUIRED |
// DESCRIPTION CDATA #IMPLIED> | // DESCRIPTION CDATA #IMPLIED> |
|
|
| |
// throw XmlValidationError(parser.getLine(),"Expected ERROR element"); | // throw XmlValidationError(parser.getLine(),"Expected ERROR element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ERROR_ELEMENT", |
"Expected $0 element", "ERROR"); |
"Expected ERROR element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError( | // throw XmlValidationError( |
// parser.getLine(), "missing ERROR.CODE attribute"); | // parser.getLine(), "missing ERROR.CODE attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE", |
"missing $0 attribute", |
"missing ERROR.CODE attribute"); |
"ERROR.CODE"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
entry.getAttributeValue("DESCRIPTION", tmpDescription); | entry.getAttributeValue("DESCRIPTION", tmpDescription); |
| |
if (!empty) | if (!empty) |
|
{ |
|
while (testStartTagOrEmptyTag(parser, entry)) |
|
{ |
|
skipElement(parser, entry); |
|
} |
|
|
expectEndTag(parser, "ERROR"); | expectEndTag(parser, "ERROR"); |
|
} |
| |
cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription); | cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription); |
return true; | return true; |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Expected INSTANCE or CLASS element"); | // "Expected INSTANCE or CLASS element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT", |
"Expected $0 or $1 element", "INSTANCE", "CLASS"); |
"Expected INSTANCE or CLASS element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
else if (!XmlReader::getClassPathElement(parser, reference)) | else if (!XmlReader::getClassPathElement(parser, reference)) |
{ | { |
| |
// l10n |
// l10n 485 |
| |
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Expected INSTANCEPATH or CLASSPATH element"); | // "Expected INSTANCEPATH or CLASSPATH element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT", |
"Expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH"); |
"Expected INSTANCEPATH or CLASSPATH element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Expected INSTANCE element"); | // "Expected INSTANCE element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT", |
"Expected $0 element", "INSTANCE"); |
"Expected INSTANCE element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Expected CLASS element"); | // "Expected CLASS element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT", |
"Expected $0 element", "CLASS"); |
"Expected CLASS element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element"); | // "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
//l10n updated |
"Expected $0 or $1 element", "LOCALINSTANCEPATH", "LOCALCLASSPATH"); |
MessageLoaderParms mlParms("Common.XmlConstants.MISSING_ELEMENT_LOCALPATH", |
|
MISSING_ELEMENT_LOCALPATH); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Expected INSTANCE element"); | // "Expected INSTANCE element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT", |
"Expected $0 element", "INSTANCE"); |
"Expected INSTANCE element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Expected CLASS element"); | // "Expected CLASS element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASS_ELEMENT", |
"Expected $0 element", "CLASS"); |
"Expected CLASS element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected CLASSNAME or INSTANCENAME element"); | // "expected CLASSNAME or INSTANCENAME element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT", |
"Expected $0 or $1 element", "CLASSNAME", "INSTANCENAME"); |
"Expected CLASSNAME or INSTANCENAME element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
| |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected INSTANCEPATH or CLASSPATH element"); | // "expected INSTANCEPATH or CLASSPATH element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_OR_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT", |
"expected $0 or $1 element", "INSTANCEPATH", "CLASSPATH"); |
"expected INSTANCEPATH or CLASSPATH element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Missing EXPMETHODCALL.NAME attribute"); | // "Missing EXPMETHODCALL.NAME attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE", |
"Missing $0 attribute", |
"Missing EXPMETHODCALL.NAME attribute"); |
"EXPMETHODCALL.NAME"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError( | // throw XmlValidationError( |
// parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute"); | // parser.getLine(), "Missing EXPMETHODRESPONSE.NAME attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE", |
"Missing $0 attribute", |
"Missing EXPMETHODRESPONSE.NAME attribute"); |
"EXPMETHODRESPONSE.NAME"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Missing EXPPARAMVALUE.NAME attribute"); | // "Missing EXPPARAMVALUE.NAME attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE", |
"Missing $0 attribute", |
"Missing EXPPARAMVALUE.NAME attribute"); |
"EXPPARAMVALUE.NAME"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Missing METHODCALL.NAME attribute"); | // "Missing METHODCALL.NAME attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE", |
"Missing $0 attribute", |
"Missing METHODCALL.NAME attribute"); |
"METHODCALL.NAME"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Missing METHODRESPONSE.NAME attribute"); | // "Missing METHODRESPONSE.NAME attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE", |
"Missing $0 attribute", |
"Missing METHODRESPONSE.NAME attribute"); |
"METHODRESPONSE.NAME"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
{ | { |
XmlEntry entry; | XmlEntry entry; |
const char* name; | const char* name; |
CIMType type; |
CIMType type=CIMTYPE_BOOLEAN; |
CIMValue value; | CIMValue value; |
| |
if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE")) | if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE")) |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "Missing PARAMVALUE.NAME attribute"); | // "Missing PARAMVALUE.NAME attribute"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_ATTRIBUTE", |
MessageLoaderParms mlParms("Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE", |
"Missing $0 attribute", |
"Missing PARAMVALUE.NAME attribute"); |
"PARAMVALUE.NAME"); |
|
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected VALUE.REFERENCE element"); | // "expected VALUE.REFERENCE element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT", |
"expected $0 element", "VALUE.REFERENCE"); |
"expected VALUE.REFERENCE element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
// throw XmlValidationError(parser.getLine(), | // throw XmlValidationError(parser.getLine(), |
// "expected VALUE element"); | // "expected VALUE element"); |
| |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_ELEMENT", |
MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_VALUE_ELEMENT", |
"expected $0 element", "VALUE"); |
"expected VALUE element"); |
| |
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
|
|
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
|
|