version 1.129.12.3, 2009/03/17 13:59:13
|
version 1.142, 2009/07/03 14:14:28
|
|
|
//%2006//////////////////////////////////////////////////////////////////////// |
//%LICENSE//////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Licensed to The Open Group (TOG) under one or more contributor license |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
// this work for additional information regarding copyright ownership. |
// IBM Corp.; EMC Corporation, The Open Group. |
// Each contributor licenses this file to you under the OpenPegasus Open |
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
// Source License; you may not use this file except in compliance with the |
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
// License. |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
// |
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
// Permission is hereby granted, free of charge, to any person obtaining a |
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
// copy of this software and associated documentation files (the "Software"), |
// EMC Corporation; Symantec Corporation; The Open Group. |
// to deal in the Software without restriction, including without limitation |
// |
// the rights to use, copy, modify, merge, publish, distribute, sublicense, |
// Permission is hereby granted, free of charge, to any person obtaining a copy |
// and/or sell copies of the Software, and to permit persons to whom the |
// of this software and associated documentation files (the "Software"), to |
// Software is furnished to do so, subject to the following conditions: |
// deal in the Software without restriction, including without limitation the |
// |
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
// The above copyright notice and this permission notice shall be included |
// sell copies of the Software, and to permit persons to whom the Software is |
// in all copies or substantial portions of the Software. |
// furnished to do so, subject to the following conditions: |
// |
// |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN |
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED |
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT |
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
// | // |
//============================================================================== |
////////////////////////////////////////////////////////////////////////// |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
|
|
# include <errno.h> | # include <errno.h> |
#endif | #endif |
#include "CIMName.h" | #include "CIMName.h" |
|
#include "CIMNameCast.h" |
#include "XmlReader.h" | #include "XmlReader.h" |
#include "XmlWriter.h" | #include "XmlWriter.h" |
#include "CIMQualifier.h" | #include "CIMQualifier.h" |
|
|
#include <Pegasus/Common/MessageLoader.h> | #include <Pegasus/Common/MessageLoader.h> |
#include <Pegasus/Common/StringConversion.h> | #include <Pegasus/Common/StringConversion.h> |
#include <Pegasus/Common/AutoPtr.h> | #include <Pegasus/Common/AutoPtr.h> |
#include "CIMNameUnchecked.h" |
|
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
|
|
XmlEntry& entry, | XmlEntry& entry, |
const char* tagName) | const char* tagName) |
{ | { |
if (!parser.next(entry) || |
if (!parser.next(entry)) |
(entry.type != XmlEntry::START_TAG && |
{ |
|
return false; |
|
} |
|
if ((entry.type != XmlEntry::START_TAG && |
entry.type != XmlEntry::EMPTY_TAG) || | entry.type != XmlEntry::EMPTY_TAG) || |
strcmp(entry.text, tagName) != 0) | strcmp(entry.text, tagName) != 0) |
{ | { |
|
|
const char* elementName, | const char* elementName, |
Boolean acceptNull) | Boolean acceptNull) |
{ | { |
String name; |
const char* name; |
| |
if (!entry.getAttributeValue("NAME", name)) | if (!entry.getAttributeValue("NAME", name)) |
{ | { |
|
|
throw XmlValidationError(lineNumber, mlParms); | throw XmlValidationError(lineNumber, mlParms); |
} | } |
| |
if (acceptNull && name.size() == 0) |
if (acceptNull && *name == '\0') |
return CIMName (); | return CIMName (); |
| |
|
Uint32 size = CIMNameLegalASCII(name); |
|
|
|
if (size) |
|
{ |
|
String tmp(name, size); |
|
return CIMName(CIMNameCast(tmp)); |
|
} |
|
|
if (!CIMName::legal(name)) | if (!CIMName::legal(name)) |
{ | { |
#ifdef PEGASUS_SNIA_INTEROP_TEST | #ifdef PEGASUS_SNIA_INTEROP_TEST |
|
|
| |
#endif | #endif |
} | } |
return CIMNameUnchecked(name); |
|
|
return CIMNameCast(name); |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
// The CIMName was already checked with legal() + String() | // The CIMName was already checked with legal() + String() |
return CIMNameUnchecked(name); |
return CIMNameCast(name); |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
// The CIMName was already checked with legal() + String() | // The CIMName was already checked with legal() + String() |
return CIMNameUnchecked(name); |
return CIMNameCast(name); |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
throw XmlSemanticError(lineNumber, mlParms); | throw XmlSemanticError(lineNumber, mlParms); |
} | } |
// The CIMName was already checked with legal() + String() | // The CIMName was already checked with legal() + String() |
return CIMNameUnchecked(superClass); |
return CIMNameCast(superClass); |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
{ | { |
Uint32 i; | Uint32 i; |
| |
Array<Uint8> utf8Chars; |
Buffer utf8Chars; |
| |
for (i=0; i<uriString.size(); i++) | for (i=0; i<uriString.size(); i++) |
{ | { |
|
|
} | } |
| |
Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2); | Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2); |
utf8Chars.append((Uint8)decodedChar); |
utf8Chars.append((char)decodedChar); |
} | } |
else | else |
{ | { |
utf8Chars.append((Uint8)uriString[i]); |
utf8Chars.append((char)uriString[i]); |
} | } |
} | } |
| |
|
|
if (uriString.size() > 0) | if (uriString.size() > 0) |
{ | { |
// Convert UTF-8 to UTF-16 and return the String | // Convert UTF-8 to UTF-16 and return the String |
utf8Chars.append('\0'); |
return String(utf8Chars.getData(), utf8Chars.size()); |
return String((char *)utf8Chars.getData()); |
|
} | } |
else | else |
{ | { |
|
|
// just a Pegasus internal representation of an embedded object. However, | // just a Pegasus internal representation of an embedded object. However, |
// this case is used when decoding string representations of embedded objects. | // this case is used when decoding string representations of embedded objects. |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
case CIMTYPE_INSTANCE: | case CIMTYPE_INSTANCE: |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
{ | { |
CIMObject x; | CIMObject x; |
| |
|
|
| |
if (XmlReader::getInstanceElement(tmp_parser, cimInstance)) | if (XmlReader::getInstanceElement(tmp_parser, cimInstance)) |
{ | { |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
if (type == CIMTYPE_INSTANCE) | if (type == CIMTYPE_INSTANCE) |
return CIMValue(cimInstance); | return CIMValue(cimInstance); |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
x = CIMObject(cimInstance); | x = CIMObject(cimInstance); |
} | } |
else if (XmlReader::getClassElement(tmp_parser, cimClass)) | else if (XmlReader::getClassElement(tmp_parser, cimClass)) |
|
|
} | } |
else | else |
{ | { |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
if (type == CIMTYPE_OBJECT) | if (type == CIMTYPE_OBJECT) |
{ | { |
// change "element" to "embedded object" | // change "element" to "embedded object" |
|
|
"Expected INSTANCE element"); | "Expected INSTANCE element"); |
throw XmlValidationError(lineNumber, mlParms); | throw XmlValidationError(lineNumber, mlParms); |
} | } |
#else |
|
// change "element" to "embedded object" |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT", |
|
"Expected INSTANCE or CLASS element"); |
|
throw XmlValidationError(lineNumber, mlParms); |
|
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
} | } |
// Ok, now we can delete the storage for the temporary | // Ok, now we can delete the storage for the temporary |
// XmlParser. | // XmlParser. |
|
|
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
return StringArrayToValueAux( | return StringArrayToValueAux( |
lineNumber, array, type, (CIMObject*)0); | lineNumber, array, type, (CIMObject*)0); |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
case CIMTYPE_INSTANCE: | case CIMTYPE_INSTANCE: |
return StringArrayToValueAux( | return StringArrayToValueAux( |
lineNumber, array, type, (CIMInstance*)0); | lineNumber, array, type, (CIMInstance*)0); |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
|
|
default: | default: |
break; | break; |
} | } |
|
|
{ | { |
property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue); | property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue); |
} | } |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
String embeddedInstanceQualifierValue; | String embeddedInstanceQualifierValue; |
ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE); | ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE); |
if (ix != PEG_NOT_FOUND) | if (ix != PEG_NOT_FOUND) |
|
|
property.getQualifier(ix).getValue().get( | property.getQualifier(ix).getValue().get( |
embeddedInstanceQualifierValue); | embeddedInstanceQualifierValue); |
} | } |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
// If the EmbeddedObject attribute is present with value "object" | // If the EmbeddedObject attribute is present with value "object" |
// or the EmbeddedObject qualifier exists on this property with value "true" | // or the EmbeddedObject qualifier exists on this property with value "true" |
// then convert the EmbeddedObject-encoded string into a CIMObject | // then convert the EmbeddedObject-encoded string into a CIMObject |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) || | Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) || |
embeddedObjectQualifierValue; | embeddedObjectQualifierValue; |
Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) || | Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) || |
|
|
| |
// Copy the qualifiers from the String property to the CIMObject | // Copy the qualifiers from the String property to the CIMObject |
// property. | // property. |
for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix) |
for (Uint32 i = 0; i < property.getQualifierCount(); ++i) |
{ | { |
// All properties are copied, including the EmbeddedObject | // All properties are copied, including the EmbeddedObject |
// qualifier. This way we don't have to keep track to know | // qualifier. This way we don't have to keep track to know |
// that the EmbeddedObject qualifier needs to be added back | // that the EmbeddedObject qualifier needs to be added back |
// during the encode step. | // during the encode step. |
new_property.addQualifier(property.getQualifier(ix)); |
new_property.addQualifier(property.getQualifier(i)); |
} | } |
| |
value = new_value; | value = new_value; |
|
|
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
#else |
|
if ((embeddedObject == EMBEDDED_OBJECT_ATTR)|| embeddedObjectQualifierValue) |
|
{ |
|
// The EmbeddedObject attribute is only valid on Properties of type |
|
// string |
|
if (type == CIMTYPE_STRING) |
|
{ |
|
type = CIMTYPE_OBJECT; |
|
CIMValue new_value(type, false); |
|
CIMProperty new_property = CIMProperty( |
|
name, new_value, 0, CIMName(), classOrigin, propagated); |
|
|
|
// Copy the qualifiers from the String property to the CIMObject |
|
// property. |
|
for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix) |
|
{ |
|
// All properties are copied, including the EmbeddedObject |
|
// qualifier. This way we don't have to keep track to know |
|
// that the EmbeddedObject qualifier needs to be added back |
|
// during the encode step. |
|
new_property.addQualifier(property.getQualifier(ix)); |
|
} |
|
|
|
value = new_value; |
|
property = new_property; |
|
} |
|
else |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE", |
|
"The EmbeddedObject attribute is only valid on string types."); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
} |
|
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
// Continue on to get property value, if not empty. | // Continue on to get property value, if not empty. |
if (!empty) | if (!empty) |
{ | { |
|
|
{ | { |
property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue); | property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue); |
} | } |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
String embeddedInstanceQualifierValue; | String embeddedInstanceQualifierValue; |
ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE); | ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE); |
if (ix != PEG_NOT_FOUND) | if (ix != PEG_NOT_FOUND) |
|
|
property.getQualifier(ix).getValue().get( | property.getQualifier(ix).getValue().get( |
embeddedInstanceQualifierValue); | embeddedInstanceQualifierValue); |
} | } |
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
// If the EmbeddedObject attribute is present with value "object" | // If the EmbeddedObject attribute is present with value "object" |
// or the EmbeddedObject qualifier exists on this property with value "true" | // or the EmbeddedObject qualifier exists on this property with value "true" |
// then | // then |
// Convert the EmbeddedObject-encoded string into a CIMObject | // Convert the EmbeddedObject-encoded string into a CIMObject |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) || | Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) || |
embeddedObjectQualifierValue; | embeddedObjectQualifierValue; |
Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) || | Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) || |
|
|
| |
// Copy the qualifiers from the String property to the CIMObject | // Copy the qualifiers from the String property to the CIMObject |
// property. | // property. |
for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix) |
for (Uint32 i = 0; i < property.getQualifierCount(); ++i) |
{ | { |
// All properties are copied, including the EmbeddedObject | // All properties are copied, including the EmbeddedObject |
// qualifier. This way we don't have to keep track to know | // qualifier. This way we don't have to keep track to know |
// that the EmbeddedObject qualifier needs to be added back | // that the EmbeddedObject qualifier needs to be added back |
// during the encode step. | // during the encode step. |
new_property.addQualifier(property.getQualifier(ix)); |
new_property.addQualifier(property.getQualifier(i)); |
} | } |
| |
value = new_value; | value = new_value; |
|
|
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
#else |
|
if ((embeddedObject == EMBEDDED_OBJECT_ATTR)||embeddedObjectQualifierValue) |
|
{ |
|
// The EmbeddedObject attribute is only valid on Properties of type |
|
// string |
|
if (type == CIMTYPE_STRING) |
|
{ |
|
type = CIMTYPE_OBJECT; |
|
CIMValue new_value(type, true, arraySize); |
|
CIMProperty new_property = CIMProperty( |
|
name, new_value, arraySize, CIMName(), classOrigin, propagated); |
|
|
|
// Copy the qualifiers from the String property to the CIMObject |
|
// property. |
|
for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix) |
|
{ |
|
// All properties are copied, including the EmbeddedObject |
|
// qualifier. This way we don't have to keep track to know |
|
// that the EmbeddedObject qualifier needs to be added back |
|
// during the encode step. |
|
new_property.addQualifier(property.getQualifier(ix)); |
|
} |
|
|
|
value = new_value; |
|
property = new_property; |
|
} |
|
else |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE", |
|
"The EmbeddedObject attribute is only valid on string types."); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
} |
|
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
// Continue on to get property array value, if not empty. | // Continue on to get property array value, if not empty. |
// Else not an embedded object, if not empty, get the property array value. | // Else not an embedded object, if not empty, get the property array value. |
if (!empty) | if (!empty) |
|
|
// If the EmbeddedObject attribute is present with value "object" | // If the EmbeddedObject attribute is present with value "object" |
// then | // then |
// Convert the EmbeddedObject-encoded string into a CIMObject | // Convert the EmbeddedObject-encoded string into a CIMObject |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
if (embeddedObject != NO_EMBEDDED_OBJECT) | if (embeddedObject != NO_EMBEDDED_OBJECT) |
{ | { |
// The EmbeddedObject attribute is only valid on Parameters | // The EmbeddedObject attribute is only valid on Parameters |
|
|
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
#else |
|
if (embeddedObject == EMBEDDED_OBJECT_ATTR) |
|
{ |
|
// The EmbeddedObject attribute is only valid on Parameters |
|
// of type string |
|
// The type must have been specified. |
|
if (gotType && (type == CIMTYPE_STRING)) |
|
{ |
|
// Used below by getValueElement() or getValueArrayElement() |
|
effectiveType = CIMTYPE_OBJECT; |
|
} |
|
else |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE", |
|
"The EmbeddedObject attribute is only valid on " |
|
"string types."); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
} |
|
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
| |
if (!XmlReader::getValueArrayElement(parser, effectiveType, value) | if (!XmlReader::getValueArrayElement(parser, effectiveType, value) |
&& !XmlReader::getValueElement(parser, effectiveType, value)) | && !XmlReader::getValueElement(parser, effectiveType, value)) |
|
|
// If we don't know what type the value is, read it as a String | // If we don't know what type the value is, read it as a String |
type = CIMTYPE_STRING; | type = CIMTYPE_STRING; |
} | } |
#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
if (embeddedObject != NO_EMBEDDED_OBJECT) | if (embeddedObject != NO_EMBEDDED_OBJECT) |
{ | { |
if (gotType && (type == CIMTYPE_STRING)) | if (gotType && (type == CIMTYPE_STRING)) |
|
|
throw XmlValidationError(parser.getLine(), mlParms); | throw XmlValidationError(parser.getLine(), mlParms); |
} | } |
} | } |
#else |
|
if (embeddedObject == EMBEDDED_OBJECT_ATTR) |
|
{ |
|
if (gotType && (type == CIMTYPE_STRING)) |
|
{ |
|
type = CIMTYPE_OBJECT; // Used below by getValueElement() |
|
} |
|
else |
|
{ |
|
MessageLoaderParms mlParms( |
|
"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE", |
|
"The EmbeddedObject attribute is only valid on string " |
|
"types."); |
|
throw XmlValidationError(parser.getLine(), mlParms); |
|
} |
|
} |
|
#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT |
|
if ( !XmlReader::getValueElement(parser, type, returnValue) ) | if ( !XmlReader::getValueElement(parser, type, returnValue) ) |
{ | { |
MessageLoaderParms mlParms( | MessageLoaderParms mlParms( |