core/XmlReader.cc

   1 /******************************************************************************
   2  * Copyright (c) 2000-2016 Ericsson Telecom AB
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *   Balasko, Jeno
  10  *   Raduly, Csaba
  11  *
  12  ******************************************************************************/
  13 /*
  14  * XmlReader.cc
  15  *
  16  *  Created on: 19-Nov-2008
  17  *      Author: ecsardu
  18  */
  19
  20 #include <libxml/xmlreader.h>
  21 #include "XmlReader.hh"
  22 #include "static_check.h"
  23
  24 #include "Encdec.hh"
  25
  26 XmlReaderWrap::XmlReaderWrap(TTCN_Buffer& buf)
  27 : my_reader(0)
  28 {
  29   // compile-time safety checks
  30   ENSURE_EQUAL(     XML_PARSER_SEVERITY_VALIDITY_WARNING, \
  31     xmlreader_lite::XML_PARSER_SEVERITY_VALIDITY_WARNING);
  32   ENSURE_EQUAL(     XML_PARSER_SEVERITY_VALIDITY_ERROR  , \
  33     xmlreader_lite::XML_PARSER_SEVERITY_VALIDITY_ERROR);
  34   ENSURE_EQUAL(     XML_PARSER_SEVERITY_WARNING, \
  35     xmlreader_lite::XML_PARSER_SEVERITY_WARNING);
  36   ENSURE_EQUAL(     XML_PARSER_SEVERITY_ERROR  , \
  37     xmlreader_lite::XML_PARSER_SEVERITY_ERROR);
  38
  39   ENSURE_EQUAL(     XML_READER_TYPE_NONE, \
  40     xmlreader_lite::XML_READER_TYPE_NONE);
  41   ENSURE_EQUAL(     XML_READER_TYPE_ELEMENT, \
  42     xmlreader_lite::XML_READER_TYPE_ELEMENT);
  43   ENSURE_EQUAL(     XML_READER_TYPE_ATTRIBUTE, \
  44     xmlreader_lite::XML_READER_TYPE_ATTRIBUTE);
  45   ENSURE_EQUAL(     XML_READER_TYPE_TEXT, \
  46     xmlreader_lite::XML_READER_TYPE_TEXT);
  47   ENSURE_EQUAL(     XML_READER_TYPE_CDATA, \
  48     xmlreader_lite::XML_READER_TYPE_CDATA);
  49   ENSURE_EQUAL(     XML_READER_TYPE_ENTITY_REFERENCE, \
  50     xmlreader_lite::XML_READER_TYPE_ENTITY_REFERENCE);
  51   ENSURE_EQUAL(     XML_READER_TYPE_ENTITY, \
  52     xmlreader_lite::XML_READER_TYPE_ENTITY);
  53   ENSURE_EQUAL(     XML_READER_TYPE_PROCESSING_INSTRUCTION, \
  54     xmlreader_lite::XML_READER_TYPE_PROCESSING_INSTRUCTION);
  55   ENSURE_EQUAL(     XML_READER_TYPE_COMMENT, \
  56     xmlreader_lite::XML_READER_TYPE_COMMENT);
  57   ENSURE_EQUAL(     XML_READER_TYPE_DOCUMENT, \
  58     xmlreader_lite::XML_READER_TYPE_DOCUMENT);
  59   ENSURE_EQUAL(     XML_READER_TYPE_DOCUMENT_TYPE, \
  60     xmlreader_lite::XML_READER_TYPE_DOCUMENT_TYPE);
  61   ENSURE_EQUAL(     XML_READER_TYPE_DOCUMENT_FRAGMENT, \
  62     xmlreader_lite::XML_READER_TYPE_DOCUMENT_FRAGMENT);
  63   ENSURE_EQUAL(     XML_READER_TYPE_NOTATION, \
  64     xmlreader_lite::XML_READER_TYPE_NOTATION);
  65   ENSURE_EQUAL(     XML_READER_TYPE_WHITESPACE, \
  66     xmlreader_lite::XML_READER_TYPE_WHITESPACE);
  67   ENSURE_EQUAL(     XML_READER_TYPE_SIGNIFICANT_WHITESPACE, \
  68     xmlreader_lite::XML_READER_TYPE_SIGNIFICANT_WHITESPACE);
  69   ENSURE_EQUAL(     XML_READER_TYPE_END_ELEMENT, \
  70     xmlreader_lite::XML_READER_TYPE_END_ELEMENT);
  71   ENSURE_EQUAL(     XML_READER_TYPE_END_ENTITY, \
  72     xmlreader_lite::XML_READER_TYPE_END_ENTITY);
  73   ENSURE_EQUAL(     XML_READER_TYPE_XML_DECLARATION, \
  74     xmlreader_lite::XML_READER_TYPE_XML_DECLARATION);
  75
  76   LIBXML_TEST_VERSION;
  77   const char * encoding = 0;
  78   if (0 == buf.get_len()) {
  79     TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_INCOMPL_MSG,
  80       "Cannot decode empty XML");
  81   }
  82   else {
  83     my_reader = xmlReaderForMemory((const char*)buf.get_data(), buf.get_len(),
  84       "uri:geller", encoding, 0);
  85     if (0 == my_reader) {
  86       TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_INVAL_MSG,
  87         "Failed to create XML reader"); // no further information available
  88     }
  89     else xmlTextReaderSetErrorHandler(my_reader, errorhandler, this);
  90   }
  91 }
  92
  93 void
  94 XmlReaderWrap::errorhandler(void * arg, const char * msg,
  95   xmlParserSeverities severity, xmlTextReaderLocatorPtr locator)
  96 {
  97   //XmlReaderWrap *self = (XmlReaderWrap*)arg;
  98   (void)arg;
  99   (void)severity;
 100   TTCN_EncDec_ErrorContext::error(TTCN_EncDec::ET_UNDEF, // TODO create a new ET_
 101     "XML error: %s at line %d", msg, xmlTextReaderLocatorLineNumber(locator));
 102 }
 103
 104 XmlReaderWrap::~XmlReaderWrap()
 105 {
 106   xmlFreeTextReader(my_reader);
 107   my_reader = 0;
 108 }
 109
 110
 111 #undef Read
 112 int XmlReaderWrap::Read()
 113 {
 114   return last_status = xmlTextReaderRead(my_reader); // assign and return
 115 }
 116
 117 // Debug version of Read(). Both are present to support linking
 118 // non-debug clients to the debug library.
 119 int XmlReaderWrap::ReadDbg(const char *where)
 120 {
 121 #ifdef NDEBUG
 122   (void)where;
 123 #else
 124   static bool d = !!getenv("DEBUG_XMLREADER");
 125   if(d){
 126     last_status = xmlTextReaderRead(my_reader);
 127     if (last_status==1) {
 128       int type = NodeType();
 129       const char * name = (const char * )Name();
 130       const char * uri  = (const char * )NamespaceUri();
 131       int empty = IsEmptyElement();
 132       char closer = type == XML_READER_TYPE_DOCUMENT_TYPE ? '[' : (empty ? '/' : ' ');
 133       printf("X%dX type=%2d, @%2d <%c{%s}%s%c>",
 134         xmlTextReaderReadState(my_reader), type, xmlTextReaderDepth(my_reader),
 135         ((type!=XML_READER_TYPE_END_ELEMENT) ? ' ' : '/'),
 136         uri ? uri : "", name, closer);
 137     }
 138     else if (last_status==0) {
 139       fputs("XXX eof  ", stdout);
 140     }
 141     else {
 142       fputs("XXX error", stdout);
 143     }
 144     printf("\t%s\n", where);
 145     fflush(stdout);
 146     return last_status;
 147   } else
 148 #endif
 149   {
 150     return last_status = xmlTextReaderRead(my_reader); // assign and return
 151   }
 152 }
 153
 154 #if 0
 155 xmlChar * XmlReaderWrap::ReadInnerXml()
 156 { return xmlTextReaderReadInnerXml(my_reader); }
 157 #endif
 158
 159 xmlChar * XmlReaderWrap::ReadOuterXml() // used by Charstring.cc
 160 { return xmlTextReaderReadOuterXml(my_reader); }
 161
 162 xmlChar * XmlReaderWrap::ReadString() // used by Objid.cc
 163 { return xmlTextReaderReadString(my_reader); }
 164
 165 int XmlReaderWrap::Depth() // used everywhere
 166 { return xmlTextReaderDepth(my_reader); }
 167
 168 #if 0
 169 int XmlReaderWrap::ReadAttributeValue()
 170 { return xmlTextReaderReadAttributeValue(my_reader); }
 171
 172 int XmlReaderWrap::AttributeCount()
 173 { return xmlTextReaderAttributeCount(my_reader); }
 174
 175 int XmlReaderWrap::HasAttributes()
 176 { return xmlTextReaderHasAttributes(my_reader); }
 177
 178 int XmlReaderWrap::HasValue()
 179 { return xmlTextReaderHasValue(my_reader); }
 180
 181 int XmlReaderWrap::IsDefault()
 182 { return xmlTextReaderIsDefault(my_reader); }
 183 #endif
 184
 185 int XmlReaderWrap::IsEmptyElement() // used often
 186 { return xmlTextReaderIsEmptyElement(my_reader); }
 187
 188 int XmlReaderWrap::NodeType()
 189 { return xmlTextReaderNodeType(my_reader); }
 190
 191 #if 0
 192 int XmlReaderWrap::QuoteChar()
 193 { return xmlTextReaderQuoteChar(my_reader); }
 194
 195 int XmlReaderWrap::ReadState()
 196 { return xmlTextReaderReadState(my_reader); }
 197 #endif
 198
 199 int XmlReaderWrap::IsNamespaceDecl() // used while processing attributes
 200 { return xmlTextReaderIsNamespaceDecl(my_reader); }
 201
 202 #if 0
 203 const xmlChar * XmlReaderWrap::BaseUri()
 204 { return xmlTextReaderConstBaseUri(my_reader); }
 205 #endif
 206
 207 const xmlChar * XmlReaderWrap::LocalName()
 208 { return xmlTextReaderConstLocalName(my_reader); }
 209
 210 const xmlChar * XmlReaderWrap::Name()
 211 { return xmlTextReaderConstName(my_reader); }
 212
 213 const xmlChar * XmlReaderWrap::NamespaceUri()
 214 { return xmlTextReaderConstNamespaceUri(my_reader); }
 215
 216 const xmlChar * XmlReaderWrap::Prefix()
 217 { return xmlTextReaderConstPrefix(my_reader); }
 218
 219 #if 0
 220 const xmlChar * XmlReaderWrap::XmlLang()
 221 { return xmlTextReaderConstXmlLang(my_reader); }
 222 #endif
 223
 224 const xmlChar * XmlReaderWrap::Value()
 225 { return xmlTextReaderConstValue(my_reader); }
 226
 227 xmlChar * XmlReaderWrap::NewValue()
 228 { return xmlTextReaderValue(my_reader); }
 229
 230 xmlChar * XmlReaderWrap::LookupNamespace( const xmlChar *prefix)
 231 { return xmlTextReaderLookupNamespace(my_reader,prefix); }
 232
 233 #if 0
 234 int XmlReaderWrap::Close()
 235 { return xmlTextReaderClose(my_reader); }
 236
 237 xmlChar * XmlReaderWrap::GetAttributeNo( int no)
 238 { return xmlTextReaderGetAttributeNo(my_reader,no); }
 239
 240 xmlChar * XmlReaderWrap::GetAttribute( const xmlChar *name)
 241 { return xmlTextReaderGetAttribute(my_reader,name); }
 242
 243 xmlChar * XmlReaderWrap::GetAttributeNs( const xmlChar *localName, const xmlChar *namespaceURI)
 244 { return xmlTextReaderGetAttributeNs(my_reader,localName,namespaceURI); }
 245
 246 int XmlReaderWrap::MoveToAttributeNo( int no)
 247 { return xmlTextReaderMoveToAttributeNo(my_reader,no); }
 248 #endif
 249
 250 int XmlReaderWrap::MoveToAttribute( const xmlChar *name)
 251 { return xmlTextReaderMoveToAttribute(my_reader,name); }
 252
 253 //int XmlReaderWrap::MoveToAttributeNs( const xmlChar *localName, const xmlChar *namespaceURI)
 254 //{ return xmlTextReaderMoveToAttributeNs(my_reader,localName,namespaceURI); }
 255
 256 #undef AdvanceAttribute
 257 int XmlReaderWrap::AdvanceAttribute()
 258 {
 259   int rez;
 260   for (rez = MoveToNextAttribute(); rez==1; rez = MoveToNextAttribute()) {
 261     if (!xmlTextReaderIsNamespaceDecl(my_reader)) break;
 262   }
 263   if (rez != 0) // success(1) or failure (-1)
 264     return rez;
 265   // 0 means no more attributes. Back to the element.
 266   rez = xmlTextReaderMoveToElement(my_reader);
 267   return -(rez == -1); // if -1, return -1 else return 0
 268 }
 269
 270 int XmlReaderWrap::AdvanceAttributeDbg(const char *where)
 271 {
 272   int rez;
 273   for (rez = MoveToNextAttributeDbg(where); rez==1; rez = MoveToNextAttributeDbg(where)) {
 274     if (!xmlTextReaderIsNamespaceDecl(my_reader)) break;
 275   }
 276   if (rez != 0) // success(1) or failure (-1)
 277     return rez;
 278   // 0 means no more attributes. Back to the element.
 279   rez = xmlTextReaderMoveToElement(my_reader);
 280   return -(rez == -1); // if -1, return -1 else return 0
 281 }
 282
 283
 284 #undef MoveToFirstAttribute
 285 int XmlReaderWrap::MoveToFirstAttribute()
 286 { return xmlTextReaderMoveToFirstAttribute(my_reader); }
 287
 288 int XmlReaderWrap::MoveToFirstAttributeDbg(const char *where)
 289 {
 290   int ret = xmlTextReaderMoveToFirstAttribute(my_reader);
 291 #ifdef NDEBUG
 292   (void)where;
 293 #else
 294   static bool d = !!getenv("DEBUG_XMLREADER");
 295   if (d) {
 296     switch (ret) {
 297     case 1: {//OK
 298       const xmlChar * name = xmlTextReaderConstLocalName(my_reader);
 299       const xmlChar * val  = xmlTextReaderConstValue(my_reader);
 300       printf("#%dX %s='%s'", xmlTextReaderReadState(my_reader), name, val);
 301       break;}
 302     case 0: {// not found
 303       const xmlChar * name = xmlTextReaderConstLocalName(my_reader);
 304       printf("#%dX no attribute found in <%s>", xmlTextReaderReadState(my_reader), name);
 305       break;}
 306     default:
 307       break;
 308     }
 309
 310     printf("\t%s\n", where);
 311     fflush(stdout);
 312   }
 313   //return xmlTextReaderMoveToFirstAttribute(my_reader);
 314 #endif
 315   return ret;
 316 }
 317
 318 #undef MoveToNextAttribute
 319 int XmlReaderWrap::MoveToNextAttribute()
 320 { return xmlTextReaderMoveToNextAttribute(my_reader); }
 321
 322 int XmlReaderWrap::MoveToNextAttributeDbg(const char *where)
 323 {
 324   int ret = xmlTextReaderMoveToNextAttribute(my_reader);
 325 #ifdef NDEBUG
 326   (void)where;
 327 #else
 328   static bool d = !!getenv("DEBUG_XMLREADER");
 329   if (d) {
 330     switch (ret) {
 331     case 1: {//OK
 332       const xmlChar * name = xmlTextReaderConstLocalName(my_reader);
 333       const xmlChar * val  = xmlTextReaderConstValue(my_reader);
 334       printf("X%dX %s='%s'", xmlTextReaderReadState(my_reader), name, val);
 335       break;}
 336     case 0: {// not found
 337       const xmlChar * name = xmlTextReaderConstLocalName(my_reader);
 338       printf("X%dX no more attributes found after '%s'", xmlTextReaderReadState(my_reader), name);
 339       break;}
 340     default:
 341       break;
 342     }
 343
 344     printf("\t%s\n", where);
 345     fflush(stdout);
 346   }
 347   //return xmlTextReaderMoveToNextAttribute(my_reader);
 348 #endif
 349   return ret;
 350 }
 351
 352 #undef MoveToElement
 353 int XmlReaderWrap::MoveToElement()
 354 { return xmlTextReaderMoveToElement(my_reader); }
 355
 356 int XmlReaderWrap::MoveToElementDbg(const char *where)
 357 {
 358   int ret = xmlTextReaderMoveToElement(my_reader);
 359 #ifdef NDEBUG
 360   (void)where;
 361 #else
 362   static bool d = !!getenv("DEBUG_XMLREADER");
 363   if (d) {
 364     const xmlChar * name = xmlTextReaderConstLocalName(my_reader);
 365     const xmlChar * val  = xmlTextReaderConstValue(my_reader);
 366     printf("X%dX <%s='%s'>\n", xmlTextReaderReadState(my_reader), name, val);
 367   }
 368
 369   printf("\t%s\n", where);
 370   fflush(stdout);
 371 #endif
 372   return ret;
 373 }
 374
 375 //int XmlReaderWrap::GetParserLineNumber()
 376 //{ return xmlTextReaderGetParserLineNumber(my_reader); }
 377
 378 //int XmlReaderWrap::GetParserColumnNumber()
 379 //{ return xmlTextReaderGetParserColumnNumber(my_reader); }
 380
 381 #if 0
 382 int XmlReaderWrap::Next()
 383 { return xmlTextReaderNext(my_reader); }
 384
 385 int XmlReaderWrap::NextSibling()
 386 { return xmlTextReaderNextSibling(my_reader); }
 387
 388 int XmlReaderWrap::Normalization()
 389 { return xmlTextReaderNormalization(my_reader); }
 390
 391 int XmlReaderWrap::SetParserProp( int prop, int value)
 392 { return xmlTextReaderSetParserProp(my_reader,prop,value); }
 393
 394 int XmlReaderWrap::GetParserProp( int prop)
 395 { return xmlTextReaderGetParserProp(my_reader,prop); }
 396
 397 xmlParserInputBufferPtr XmlReaderWrap::GetRemainder()
 398 { return xmlTextReaderGetRemainder(my_reader); }
 399
 400 xmlNodePtr XmlReaderWrap::CurrentNode()
 401 { return xmlTextReaderCurrentNode(my_reader); }
 402
 403 xmlNodePtr XmlReaderWrap::Preserve()
 404 { return xmlTextReaderPreserve(my_reader); }
 405
 406 int XmlReaderWrap::PreservePattern( const xmlChar *pattern, const xmlChar **namespaces)
 407 { return xmlTextReaderPreservePattern(my_reader,pattern,namespaces); }
 408
 409 xmlDocPtr XmlReaderWrap::CurrentDoc()
 410 { return xmlTextReaderCurrentDoc(my_reader); }
 411
 412 xmlNodePtr XmlReaderWrap::Expand()
 413 { return xmlTextReaderExpand(my_reader); }
 414
 415 int XmlReaderWrap::IsValid()
 416 { return xmlTextReaderIsValid(my_reader); }
 417
 418 int XmlReaderWrap::RelaxNGValidate( const char *rng)
 419 { return xmlTextReaderRelaxNGValidate(my_reader,rng); }
 420
 421 int XmlReaderWrap::RelaxNGSetSchema( xmlRelaxNGPtr schema)
 422 { return xmlTextReaderRelaxNGSetSchema(my_reader,schema); }
 423
 424 int XmlReaderWrap::SchemaValidate( const char *xsd)
 425 { return xmlTextReaderSchemaValidate(my_reader,xsd); }
 426
 427 int XmlReaderWrap::SchemaValidateCtxt( xmlSchemaValidCtxtPtr ctxt, int options)
 428 { return xmlTextReaderSchemaValidateCtxt(my_reader,ctxt,options); }
 429
 430 int XmlReaderWrap::SetSchema( xmlSchemaPtr schema)
 431 { return xmlTextReaderSetSchema(my_reader,schema); }
 432
 433 int XmlReaderWrap::Standalone()
 434 { return xmlTextReaderStandalone(my_reader); }
 435 #endif
 436
 437 long XmlReaderWrap::ByteConsumed()
 438 { return xmlTextReaderByteConsumed(my_reader); }
 439
 440 //int XmlReaderWrap::LocatorLineNumber(xmlTextReaderLocatorPtr locator)
 441 //{ return xmlTextReaderLocatorLineNumber(locator); }
 442
 443 //xmlChar * XmlReaderWrap::LocatorBaseURI(xmlTextReaderLocatorPtr locator)
 444 //{ return xmlTextReaderLocatorBaseURI(locator); }
 445
 446 #if 0
 447 void XmlReaderWrap::SetErrorHandler( xmlTextReaderErrorFunc f, void *arg)
 448 { return xmlTextReaderSetErrorHandler(my_reader,f,arg); }
 449
 450 void XmlReaderWrap::SetStructuredErrorHandler( xmlStructuredErrorFunc f, void *arg)
 451 { return xmlTextReaderSetStructuredErrorHandler(my_reader,f,arg); }
 452
 453 void XmlReaderWrap::GetErrorHandler( xmlTextReaderErrorFunc *f, void **arg)
 454 { return xmlTextReaderGetErrorHandler(my_reader,f,arg); }
 455 #endif
 456
 457 #ifndef NDEBUG
 458 void XmlReaderWrap::Status()
 459 {
 460   //const xmlChar *string   = xmlTextReaderConstString    (my_reader);
 461   const xmlChar *baseuri  = xmlTextReaderConstBaseUri   (my_reader);
 462   const xmlChar *localname= xmlTextReaderConstLocalName (my_reader);
 463   const xmlChar *name     = xmlTextReaderConstName      (my_reader);
 464   const xmlChar *ns_uri   = xmlTextReaderConstNamespaceUri(my_reader);
 465   const xmlChar *prefix   = xmlTextReaderConstPrefix    (my_reader);
 466   const xmlChar *lang     = xmlTextReaderConstXmlLang   (my_reader);
 467   const xmlChar *value    = xmlTextReaderConstValue     (my_reader);
 468   const xmlChar *encoding = xmlTextReaderConstEncoding  (my_reader);
 469   const xmlChar *version  = xmlTextReaderConstXmlVersion(my_reader);
 470
 471   printf ("XML reader %d deep:\n"
 472     "\tbaseUri   = '%s'\n"
 473     "\tprefix    = '%s'\n"
 474     "\tlocalname = '%s'\n"
 475     "\tname      = '%s%s'\n"
 476     "\tns-Uri    = '%s'\n"
 477     "\txml lang  = '%s'\n"
 478     "\tvalue     = '%s'\n"
 479     "\tencoding  = '%s'\n"
 480     "\txml ver   = '%s'\n"
 481     , xmlTextReaderDepth(my_reader)
 482     , baseuri
 483     , prefix
 484     , localname
 485     , name, (xmlTextReaderIsEmptyElement(my_reader) ? "/" : "")
 486     , ns_uri
 487     , lang
 488     , value
 489     , encoding
 490     , version);
 491 }
 492 #endif
 493
 494
 495