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

Return to XmlParser.cpp CVS log

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

Diff for /pegasus/src/Pegasus/Common/XmlParser.cpp between version 1.5 and 1.29

version 1.5, 2001/05/08 07:31:12

version 1.29, 2004/10/17 20:39:18

Line 1

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

//%2004////////////////////////////////////////////////////////////////////////

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

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

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// IBM Corp.; EMC Corporation, The Open Group.

// and/or sell copies of the Software, and to permit persons to whom the

// Software is furnished to do so, subject to the following conditions:

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

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

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

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

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

// deal in the Software without restriction, including without limitation the

// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// sell copies of the Software, and to permit persons to whom the Software is

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

// furnished to do so, subject to the following conditions:

// DEALINGS IN THE SOFTWARE.

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

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

//==============================================================================

Line 48

Line 54

// &quot - full quote

// &apos - apostrophe

// as well as character (numeric) references:

// 1 - decimal reference for character '1'

// 1 - hexadecimal reference for character '1'

// 4. Element names and attribute names take the following form:

// [A-Za-z_][A-Za-z_0-9-.:]

Line 67

Line 78

// TODO:

// ATTN: KS P1 4 Mar 2002. Review the following TODOs to see if there is work.

// Handle <!DOCTYPE...> sections which are complicated (containing

// rules rather than references to files).

// Handle reference of this form: "Α"

// Remove newlines from string literals:

// Example: <xyz x="hello

Line 79

Line 89

////////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/Config.h>

#include <cctype>

#include <cassert>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include "XmlParser.h"

#include "Logger.h"

#include "ExceptionRep.h"

PEGASUS_NAMESPACE_BEGIN

#define PEGASUS_ARRAY_T XmlEntry

# include "ArrayImpl.h"

#undef PEGASUS_ARRAY_T

////////////////////////////////////////////////////////////////////////////////

// Static helper functions

Line 99

Line 116

for (; *p; p++)

{

if (*p == '\n')

std::cout << "\\n";

PEGASUS_STD(cout) << "\\n";

else if (*p == '\r')

std::cout << "\\r";

PEGASUS_STD(cout) << "\\r";

else if (*p == '\t')

std::cout << "\\t";

PEGASUS_STD(cout) << "\\t";

else

std::cout << *p;

PEGASUS_STD(cout) << *p;

}

Line 116

Line 133

char replacement;

};

// ATTN: Add support for more entity references

static EntityReference _references[] =

{

{ "&", 5, '&' },

Line 125

Line 143

{ "'", 6, '\'' }

};

// Implements a check for a whitespace character, without calling

// isspace( ). The isspace( ) function is locale-sensitive,

// and incorrectly flags some chars above 0x7f as whitespace. This

// causes the XmlParser to incorrectly parse UTF-8 data.

// Section 2.3 of XML 1.0 Standard (http://www.w3.org/TR/REC-xml)

// defines white space as:

// S ::= (#x20 | #x9 | #xD | #xA)+

static int _isspace(char c)

{

if (c == ' ' || c == '\r' || c == '\t' || c == '\n')

return 1;

return 0;

}

static Uint32 _REFERENCES_SIZE = (sizeof(_references) / sizeof(_references[0]));

// Remove all redundant spaces from the given string:

Line 137

Line 172

// Remove leading spaces:

while (isspace(*p))

while (_isspace(*p))

p++;

if (p != text)

Line 151

Line 186

{

// Advance to the next space:

while (*p && !isspace(*p))

while (*p && !_isspace(*p))

p++;

if (!*p)

Line 161

Line 196

char* q = p++;

while (isspace(*p))

while (_isspace(*p))

p++;

// Discard trailing spaces (if we are at the end):

Line 191

Line 226

////////////////////////////////////////////////////////////////////////////////

static char* _xmlMessages[] =

static const char* _xmlMessages[] =

{

"Bad opening element",

"Bad closing element",

Line 212

Line 247

"Semantic error"

};

static const char* _xmlKeys[] =

{

"Common.XmlParser.BAD_START_TAG",

"Common.XmlParser.BAD_END_TAG",

"Common.XmlParser.BAD_ATTRIBUTE_NAME",

"Common.XmlParser.EXPECTED_EQUAL_SIGN",

"Common.XmlParser.BAD_ATTRIBUTE_VALUE",

"Common.XmlParser.MINUS_MINUS_IN_COMMENT",

"Common.XmlParser.UNTERMINATED_COMMENT",

"Common.XmlParser.UNTERMINATED_CDATA",

"Common.XmlParser.UNTERMINATED_DOCTYPE",

"Common.XmlParser.TOO_MANY_ATTRIBUTES",

"Common.XmlParser.MALFORMED_REFERENCE",

"Common.XmlParser.EXPECTED_COMMENT_OR_CDATA",

"Common.XmlParser.START_END_MISMATCH",

"Common.XmlParser.UNCLOSED_TAGS",

"Common.XmlParser.MULTIPLE_ROOTS",

"Common.XmlParser.VALIDATION_ERROR",

"Common.XmlParser.SEMANTIC_ERROR"

};

// l10n replace _formMessage (comment out the old one)

static String _formMessage(Uint32 code, Uint32 line, const String& message)

{

String result = _xmlMessages[Uint32(code) - 1];

Line 229

Line 287

return result;

}

static MessageLoaderParms _formMessage(Uint32 code, Uint32 line, const String& message)

{

String dftMsg = _xmlMessages[Uint32(code) - 1];

String key = _xmlKeys[Uint32(code) - 1];

String msg = message;

dftMsg.append(": on line $0");

if (message.size())

{

msg = ": " + msg;

dftMsg.append("$1");

}

return MessageLoaderParms(key, dftMsg, line ,msg);

}

static MessageLoaderParms _formPartialMessage(Uint32 code, Uint32 line)

{

String dftMsg = _xmlMessages[Uint32(code) - 1];

String key = _xmlKeys[Uint32(code) - 1];

dftMsg.append(": on line $0");

return MessageLoaderParms(key, dftMsg, line);

}

XmlException::XmlException(

XmlException::Code code,

Line 239

Line 325

}

XmlException::XmlException(

XmlException::Code code,

Uint32 lineNumber,

MessageLoaderParms& msgParms)

: Exception(_formPartialMessage(code, lineNumber))

{

if (msgParms.default_msg.size())

{

msgParms.default_msg = ": " + msgParms.default_msg;

}

_rep->message.append(MessageLoader::getMessage(msgParms));

}

////////////////////////////////////////////////////////////////////////////////

// XmlValidationError

Line 253

Line 354

}

XmlValidationError::XmlValidationError(

Uint32 lineNumber,

MessageLoaderParms& msgParms)

: XmlException(XmlException::VALIDATION_ERROR, lineNumber, msgParms)

{

}

////////////////////////////////////////////////////////////////////////////////

// XmlSemanticError

Line 267

Line 378

}

XmlSemanticError::XmlSemanticError(

Uint32 lineNumber,

MessageLoaderParms& msgParms)

: XmlException(XmlException::SEMANTIC_ERROR, lineNumber, msgParms)

{

}

////////////////////////////////////////////////////////////////////////////////

// XmlParser

Line 377

Line 498

void XmlParser::_skipWhitespace(char*& p)

{

while (*p && isspace(*p))

while (*p && _isspace(*p))

{

if (*p == '\n')

_line++;

Line 388

Line 509

Boolean XmlParser::_getElementName(char*& p)

{

if (!isalpha(*p) && *p != '_')

if (!(((*p >= 'A') && (*p <= 'Z')) ||

((*p >= 'a') && (*p <= 'z')) ||

(*p == '_')))

throw XmlException(XmlException::BAD_START_TAG, _line);

p++;

while (*p &&

while ((*p) &&

(isalnum(*p) || *p == '_' || *p == '-' || *p == ':' || *p == '.'))

(((*p >= 'A') && (*p <= 'Z')) ||

((*p >= 'a') && (*p <= 'z')) ||

((*p >= '0') && (*p <= '9')) ||

*p == '_' || *p == '-' || *p == ':' || *p == '.'))

p++;

// The next character must be a space:

if (isspace(*p))

if (_isspace(*p))

{

*p++ = '\0';

_skipWhitespace(p);

Line 416

Line 543

{

openCloseElement = false;

if (!isalpha(*p) && *p != '_')

if (!(((*p >= 'A') && (*p <= 'Z')) ||

((*p >= 'a') && (*p <= 'z')) ||

(*p == '_')))

throw XmlException(XmlException::BAD_START_TAG, _line);

p++;

while (*p &&

while ((*p) &&

(isalnum(*p) || *p == '_' || *p == '-' || *p == ':' || *p == '.'))

(((*p >= 'A') && (*p <= 'Z')) ||

((*p >= 'a') && (*p <= 'z')) ||

((*p >= '0') && (*p <= '9')) ||

*p == '_' || *p == '-' || *p == ':' || *p == '.'))

p++;

// The next character must be a space:

if (isspace(*p))

if (_isspace(*p))

{

*p++ = '\0';

_skipWhitespace(p);

Line 450

Line 583

void XmlParser::_getAttributeNameAndEqual(char*& p)

{

if (!isalpha(*p) && *p != '_')

if (!(((*p >= 'A') && (*p <= 'Z')) ||

((*p >= 'a') && (*p <= 'z')) ||

(*p == '_')))

throw XmlException(XmlException::BAD_ATTRIBUTE_NAME, _line);

p++;

while (*p &&

while ((*p) &&

(isalnum(*p) || *p == '_' || *p == '-' || *p == ':' || *p == '.'))

(((*p >= 'A') && (*p <= 'Z')) ||

((*p >= 'a') && (*p <= 'z')) ||

((*p >= '0') && (*p <= '9')) ||

*p == '_' || *p == '-' || *p == ':' || *p == '.'))

p++;

char* term = p;

Line 572

Line 711

{

if (*p == '&')

{

// Look for predefined entity reference:

// Process character or entity reference

Boolean found = false;

Uint16 referenceChar = 0;

Uint32 referenceLength = 0;

XmlException::Code code = XmlException::MALFORMED_REFERENCE;

for (Uint32 i = 0; i < _REFERENCES_SIZE; i++)

if (*(p+1) == '#')

{

Uint32 length = _references[i].length;

// Found a character (numeric) reference

const char* match = _references[i].match;

// Determine whether it is decimal or hex

if (*(p+2) == 'x')

{

// Decode a hexadecimal character reference

char* q = p+3;

if (strncmp(p, _references[i].match, length) == 0)

// At most four digits are allowed, plus trailing ';'

Uint32 numDigits;

for (numDigits = 0; numDigits < 5; numDigits++, q++)

{

found = true;

if (isdigit(*q))

*p = _references[i].replacement;

{

char* q = p + length;

referenceChar = (referenceChar << 4);

rem = rem - length + 1;

referenceChar += (*q - '0');

memmove(p + 1, q, rem);

}

else if ((*q >= 'A') && (*q <= 'F'))

{

referenceChar = (referenceChar << 4);

referenceChar += (*q - 'A' + 10);

}

else if ((*q >= 'a') && (*q <= 'f'))

{

referenceChar = (referenceChar << 4);

referenceChar += (*q - 'a' + 10);

}

else if (*q == ';')

{

break;

}

else

{

throw XmlException(code, _line);

}

// If not found, then at least make sure it is well formed:

// Hex number must be 1 - 4 digits

if ((numDigits == 0) || (numDigits > 4))

{

throw XmlException(code, _line);

}

if (!found)

// ATTN: Currently do not support 16-bit characters

if (referenceChar > 0xff)

{

char* start = p;

// ATTN: Is there a good way to say "unsupported"?

p++;

throw XmlException(code, _line);

}

XmlException::Code code = XmlException::MALFORMED_REFERENCE;

referenceLength = numDigits + 4;

}

else

{

// Decode a decimal character reference

Uint32 newChar = 0;

char* q = p+2;

if (isalpha(*p) || *p == '_')

// At most five digits are allowed, plus trailing ';'

Uint32 numDigits;

for (numDigits = 0; numDigits < 6; numDigits++, q++)

{

if (isdigit(*q))

{

for (p++; *p && *p != ';'; p++)

newChar = (newChar * 10);

newChar += (*q - '0');

}

else if (*q == ';')

{

break;

}

else

{

if (!isalnum(*p) && *p != '_')

throw XmlException(code, _line);

}

else if (*p == '#')

// Decimal number must be 1 - 5 digits and fit in 16 bits

if ((numDigits == 0) || (numDigits > 5) ||

(newChar > 0xffff))

{

for (p++ ; *p && *p != ';'; p++)

throw XmlException(code, _line);

}

// ATTN: Currently do not support 16-bit characters

if (newChar > 0xff)

{

if (!isdigit(*p))

// ATTN: Is there a good way to say "unsupported"?

throw XmlException(code, _line);

}

referenceChar = Uint16(newChar);

referenceLength = numDigits + 3;

}

else

{

// Check for entity reference

// ATTN: Inefficient if many entity references are supported

Uint32 i;

for (i = 0; i < _REFERENCES_SIZE; i++)

{

Uint32 length = _references[i].length;

const char* match = _references[i].match;

if (*p != ';')

if (strncmp(p, _references[i].match, length) == 0)

throw XmlException(code, _line);

{

referenceChar = _references[i].replacement;

referenceLength = length;

break;

}

rem -= p - start;

if (i == _REFERENCES_SIZE)

{

// Didn't recognize the entity reference

// ATTN: Is there a good way to say "unsupported"?

throw XmlException(code, _line);

}

// Replace the reference with the correct character

*p = (char)referenceChar;

char* q = p + referenceLength;

rem = rem - referenceLength + 1;

memmove(p + 1, q, rem);

}

Line 687

Line 909

return;

}

else if (isalpha(*p) || *p == '_')

else if ((((*p >= 'A') && (*p <= 'Z')) ||

((*p >= 'a') && (*p <= 'z')) ||

(*p == '_')))

{

entry.type = XmlEntry::START_TAG;

entry.text = p;

Line 744

Line 968

{

// The next thing must a space or a "?>":

if (!(p[0] == '?' && p[1] == '>') && !isspace(*p))

if (!(p[0] == '?' && p[1] == '>') && !_isspace(*p))

{

throw XmlException(

XmlException::BAD_ATTRIBUTE_VALUE, _line);

}

else if (!(*p == '>' || (p[0] == '/' && p[1] == '>') || isspace(*p)))

else if (!(*p == '>' || (p[0] == '/' && p[1] == '>') || _isspace(*p)))

{

// The next thing must be a space or a '>':

Line 781

Line 1005

void XmlEntry::print() const

{

std::cout << "=== " << _typeStrings[type] << " ";

PEGASUS_STD(cout) << "=== " << _typeStrings[type] << " ";

Boolean needQuotes = type == XmlEntry::CDATA || type == XmlEntry::CONTENT;

if (needQuotes)

std::cout << "\"";

PEGASUS_STD(cout) << "\"";

_printValue(text);

if (needQuotes)

std::cout << "\"";

PEGASUS_STD(cout) << "\"";

std::cout << '\n';

PEGASUS_STD(cout) << '\n';

for (Uint32 i = 0; i < attributeCount; i++)

{

std::cout << " " << attributes[i].name << "=\"";

PEGASUS_STD(cout) << " " << attributes[i].name << "=\"";

_printValue(attributes[i].value);

std::cout << "\"" << std::endl;

PEGASUS_STD(cout) << "\"" << PEGASUS_STD(endl);

}

Line 830

Line 1054

{

first = str;

while (isspace(*first))

while (_isspace(*first))

first++;

if (!*first)

Line 841

Line 1065

last = first + strlen(first);

while (last != first && isspace(last[-1]))

while (last != first && _isspace(last[-1]))

last--;

}

Line 911

Line 1135

if (!getAttributeValue(name, tmp))

return false;

value = tmp;

value = String(tmp);

return true;

}

void XmlAppendCString(Array<Sint8>& out, const char* str)

{

out.append(str, strlen(str));

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.5
changed lines
	Added in v.1.29

No CVS admin address has been configured