cpp/galago/contrib/indri/src/XMLReader.cpp

   1 /*==========================================================================
   2  * Copyright (c) 2004 University of Massachusetts.  All Rights Reserved.
   3  *
   4  * Use of the Lemur Toolkit for Language Modeling and Information Retrieval
   5  * is subject to the terms of the software license set forth in the LICENSE
   6  * file included with this software, and also available at
   7  * http://www.lemurproject.org/license.html
   8  *
   9  *==========================================================================
  10  */
  11
  12
  13 //
  14 // XMLReader
  15 //
  16 // 8 October 2003 - tds
  17 //
  18
  19 #include "indri/XMLReader.hpp"
  20 #include "lemur/Exception.hpp"
  21
  22 int indri::xml::XMLReader::_tryFindChar( char ch, const char* buffer, int start, int finish ) {
  23   int i;
  24
  25   for( i=start; i<finish; i++ ) {
  26     if( buffer[i] == ch )
  27       break;
  28   }
  29
  30   if( i==finish )
  31     return -1;
  32
  33   return i;
  34 }
  35
  36 int indri::xml::XMLReader::_findChar( char ch, const char* buffer, int start, int finish ) {
  37   int result = _tryFindChar( ch, buffer, start, finish );
  38
  39   if( result == -1 )
  40     LEMUR_THROW( LEMUR_PARSE_ERROR, "Was looking for '" + ch + "', but couldn't find it." );
  41
  42   return result;
  43 }
  44
  45 int indri::xml::XMLReader::_tryFindBeginTag( const char* buffer, int start, int finish ) {
  46   return _tryFindChar( '<', buffer, start, finish );
  47 }
  48
  49 int indri::xml::XMLReader::_findBeginTag( const char* buffer, int start, int finish ) {
  50   int result = _tryFindBeginTag( buffer, start, finish );
  51
  52   if( result == -1 )
  53     LEMUR_THROW( LEMUR_PARSE_ERROR, "Ran off the end of a buffer while looking for a begin tag" );
  54
  55   return result;
  56 }
  57
  58 int indri::xml::XMLReader::_findEndTag( const char* buffer, int start, int finish ) {
  59   return _findChar( '>', buffer, start, finish );
  60 }
  61
  62 int indri::xml::XMLReader::_tryFindText( const char* buffer, int start, int finish ) {
  63   int i;
  64
  65   for( i=start; i<finish; i++ ) {
  66     if( !isspace(buffer[i]) )
  67       break;
  68   }
  69
  70   return i;
  71 }
  72
  73 int indri::xml::XMLReader::_findText( const char* buffer, int start, int finish ) {
  74   int result = _tryFindText( buffer, start, finish );
  75   if( result==finish )
  76     LEMUR_THROW( LEMUR_GENERIC_ERROR, "Was looking for text, but couldn't find any" );
  77
  78   return result;
  79 }
  80
  81 int indri::xml::XMLReader::_findNotName( const char* buffer, int start, int finish ) {
  82   int i;
  83
  84   for( i=start; i<finish; i++ ) {
  85     // this isn't unicode-safe, but it should be good for now
  86     if( !isalpha(buffer[i]) &&
  87         !isdigit(buffer[i]) &&
  88         buffer[i] != '-' &&
  89         buffer[i] != '_' &&
  90         buffer[i] != ':' &&
  91         buffer[i] != '.' ) {
  92       break;
  93     }
  94   }
  95
  96   if( i==finish )
  97     LEMUR_THROW( LEMUR_PARSE_ERROR, "Was looking for the end of a tag name, but couldn't find it." );
  98
  99   return i;
 100 }
 101
 102 int _findSpace( char* buffer, int start, int finish ) {
 103   int i;
 104
 105   for( i=start; i<finish; i++ ) {
 106     if( isspace(buffer[i]) )
 107       break;
 108   }
 109
 110   if( i==finish )
 111     LEMUR_THROW( LEMUR_PARSE_ERROR, "Was looking for a space, but couldn't find it." );
 112
 113   return i;
 114 }
 115
 116 int indri::xml::XMLReader::_readTag( const char* buffer, int bufferStart, int bufferEnd, std::string* tagName, std::map<std::string, std::string>* attributes, int* tagType ) {
 117   // skip opening whitespace
 118   int startLocation = bufferStart;
 119   int endLocation = _findEndTag( buffer, startLocation, bufferEnd );
 120   int position = startLocation+1;
 121   int trueEndLocation = endLocation+1;
 122
 123   if( endLocation - position < 1 )
 124     LEMUR_THROW( LEMUR_GENERIC_ERROR, "Found a tag with no body" );
 125
 126   // is it a <!CDATA[ tag?
 127   // expand this test for completeness
 128   if ( buffer[position] == '!' && buffer[position + 1] == 'C' ) {
 129     if( tagType )
 130       *tagType = TAG_CDATA_TYPE;
 131     trueEndLocation = position + 7;
 132     return trueEndLocation;
 133   }
 134   // is it an opening tag?
 135   if( buffer[position] == '/' ) {
 136     if( tagType )
 137       *tagType = TAG_CLOSE_TYPE;
 138     position++;
 139
 140     if( position >= endLocation )
 141       LEMUR_THROW( LEMUR_GENERIC_ERROR, "Found a tag with no body" );
 142   } else {
 143     if( buffer[endLocation-1] == '/' ) {
 144       if( tagType )
 145         *tagType = TAG_OPEN_CLOSE_TYPE;
 146       endLocation--;
 147     } else if( tagType ) {
 148       *tagType = TAG_OPEN_TYPE;
 149     }
 150   }
 151
 152   if( tagName || attributes ) {
 153     int textBegin = _findText( buffer, position, endLocation );
 154     int textEnd = _findNotName( buffer, textBegin, endLocation+1 );
 155
 156     if( tagName )
 157       tagName->assign( &buffer[textBegin], &buffer[textEnd] );
 158
 159     position = textEnd;
 160
 161     if( attributes ) {
 162       attributes->clear();
 163
 164       textBegin = _findText( buffer, position, endLocation+1 );
 165       position = textBegin;
 166
 167       for( ; position != endLocation; position = _tryFindText( buffer, position, endLocation ) ) {
 168         textEnd = _findNotName( buffer, position, endLocation );
 169         int equalsPosition = _findChar( '=', buffer, textEnd, endLocation );
 170         int quotePosition = _findText( buffer, equalsPosition+1, endLocation );
 171         int endQuotePosition = _findChar( buffer[quotePosition], buffer, quotePosition+1, endLocation );
 172
 173         std::string attributeName;
 174         std::string valueText;
 175
 176         assert( position <= textEnd );
 177         assert( quotePosition+1 <= endQuotePosition );
 178         assert( textEnd < quotePosition+1 );
 179
 180         attributeName.assign( &buffer[position], &buffer[textEnd] );
 181         valueText.assign( &buffer[quotePosition+1], &buffer[endQuotePosition] );
 182
 183         attributes->insert( std::make_pair( attributeName, valueText ) );
 184         position = endQuotePosition+1;
 185       }
 186     }
 187   }
 188
 189   return trueEndLocation;
 190 }
 191
 192 int indri::xml::XMLReader::_findClosingTag( const char* buffer, int start, int finish, std::string& openingTagName, bool* tagsBetween ) {
 193   int openingTags = 0;
 194   int closingTags = 0;
 195   int position = start;
 196   bool done = false;
 197   bool match = false;
 198   int tagType;
 199
 200   if( tagsBetween )
 201     *tagsBetween = false;
 202   try {
 203     while( !done ) {
 204       std::string tagName;
 205       position = _findBeginTag( buffer, position, finish );
 206       int end = _readTag( buffer, position, finish, &tagName, NULL, &tagType );
 207
 208       if( tagType == TAG_CDATA_TYPE ) {
 209         std::string cdata = &buffer[end];
 210         std::string::size_type dataEnd = cdata.find("]]>");
 211         position = end + dataEnd + 1;
 212       } else if( tagType != TAG_CLOSE_TYPE ) {
 213         if( tagsBetween )
 214           *tagsBetween = true;
 215
 216         if( tagType == TAG_OPEN_TYPE )
 217           openingTags++;
 218         position = end;
 219
 220         while( openingTags > closingTags ) {
 221           // don't need to check for matching tags here, we just need to
 222           // count open and closed tags
 223           position = _findBeginTag( buffer, position, finish );
 224           end = _readTag( buffer, position, finish, NULL, NULL, &tagType );
 225           position = end;
 226
 227           if( tagType == TAG_CDATA_TYPE ) {
 228             std::string cdata = &buffer[end];
 229             std::string::size_type dataEnd = cdata.find("]]>");
 230             position = end + dataEnd + 1;
 231           } else if( tagType == TAG_OPEN_TYPE ) {
 232             openingTags++;
 233           } else if( tagType == TAG_CLOSE_TYPE ) {
 234             closingTags++;
 235           }
 236         }
 237       } else {
 238         match = (tagName == openingTagName);
 239         done = true;
 240       }
 241     }
 242   } catch( lemur::api::Exception& e ) {
 243     LEMUR_RETHROW( e, std::string() + "Caught an error while looking for an end tag for '" + openingTagName + "'" );
 244   }
 245
 246   if( match ) {
 247     return position;
 248   } else {
 249     return -1;
 250   }
 251 }
 252
 253 void indri::xml::XMLReader::_read( indri::xml::XMLNode** parent, const char* buffer, int start, int end ) {
 254   int tagType;
 255
 256   for( int current = _tryFindBeginTag( buffer, start, end );
 257        current >= 0;
 258        current = _tryFindBeginTag( buffer, current, end ) ) {
 259     indri::xml::XMLNode* node;
 260     std::string tagName;
 261     std::map<std::string, std::string> attributes;
 262     bool tagsBetween;
 263
 264     int endLevel;
 265     int endTag = _readTag( buffer, current, end, &tagName, &attributes, &tagType );
 266
 267     if( tagType == TAG_CLOSE_TYPE )
 268       LEMUR_THROW( LEMUR_GENERIC_ERROR, "Found a close tag for '" + tagName + "' while looking for an open tag." );
 269
 270     if( tagType == TAG_OPEN_TYPE ) {
 271       int closingTag = _findClosingTag( buffer, endTag, end, tagName, &tagsBetween );
 272       if( closingTag == -1 )
 273         LEMUR_THROW( LEMUR_GENERIC_ERROR, "Could not find a close tag for '" + tagName + "'");
 274
 275       if( tagsBetween ) {
 276         node = new indri::xml::XMLNode( tagName, attributes );
 277         _read( &node, buffer, endTag, closingTag );
 278       } else {
 279         std::string nodeValue;
 280         nodeValue.assign( &buffer[endTag], &buffer[closingTag] );
 281         std::string::size_type dataStart = nodeValue.find("<!CDATA[");
 282         while (dataStart != std::string::npos) {
 283           // munch any CDATA tags in the element's value.
 284           nodeValue.erase(dataStart, 8);
 285           std::string::size_type dataEnd = nodeValue.find("]]>");
 286           if (dataEnd != std::string::npos)
 287             nodeValue.erase(dataEnd, 3);
 288           // else bad things here, should throw.
 289           dataStart = nodeValue.find("<!CDATA[");
 290         }
 291         node = new indri::xml::XMLNode( tagName, attributes, nodeValue );
 292       }
 293
 294       endLevel = _findEndTag( buffer, closingTag, end )+1;
 295     } else {
 296       assert( tagType == TAG_OPEN_CLOSE_TYPE );
 297       node = new indri::xml::XMLNode( tagName, attributes );
 298       endLevel = endTag;
 299     }
 300
 301     if( *parent ) {
 302       (*parent)->addChild( node );
 303     } else {
 304       *parent = node;
 305       break;
 306     }
 307
 308     current = endLevel;
 309   }
 310 }
 311
 312 indri::xml::XMLNode* indri::xml::XMLReader::read( const char* buffer, size_t length ) {
 313   indri::xml::XMLNode* result = NULL;
 314   std::string s = buffer;
 315   std::string::size_type commentstart = s.find("<!--",0);
 316   while (commentstart != std::string::npos) {
 317       std::string::size_type commentend = s.find("-->",0);
 318       s.erase(commentstart, (commentend + 3) - commentstart);
 319       commentstart = s.find("<!--",0);
 320   }
 321   std::string::size_type xmlDeclStart = s.find("<?xml");
 322   while (xmlDeclStart != std::string::npos) {
 323       std::string::size_type end = s.find("?>");
 324       s.erase(xmlDeclStart, (end + 2) - xmlDeclStart);
 325       xmlDeclStart = s.find("<?xml");
 326   }
 327   _read( &result, s.c_str(), 0, int(s.length()) );
 328   return result;
 329 }
 330
 331 indri::xml::XMLNode* indri::xml::XMLReader::read( const std::string& str ) {
 332   return read( str.c_str(), str.length() );
 333 }
 334
 335