ext/OGDF/src/fileformats/DinoXmlScanner.cpp

   1 /*
   2  * $Revision: 2565 $
   3  *
   4  * last checkin:
   5  *   $Author: gutwenger $
   6  *   $Date: 2012-07-07 17:14:54 +0200 (Sa, 07. Jul 2012) $
   7  ***************************************************************/
   8
   9 /** \file
  10  * \brief Implementation of the class DinoXmlScanner serving the
  11  *        class DinoXmlParser
  12  *
  13  * \author Dino Ahr
  14  *
  15  * \par License:
  16  * This file is part of the Open Graph Drawing Framework (OGDF).
  17  *
  18  * \par
  19  * Copyright (C)<br>
  20  * See README.txt in the root directory of the OGDF installation for details.
  21  *
  22  * \par
  23  * This program is free software; you can redistribute it and/or
  24  * modify it under the terms of the GNU General Public License
  25  * Version 2 or 3 as published by the Free Software Foundation;
  26  * see the file LICENSE.txt included in the packaging of this file
  27  * for details.
  28  *
  29  * \par
  30  * This program is distributed in the hope that it will be useful,
  31  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  32  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  33  * GNU General Public License for more details.
  34  *
  35  * \par
  36  * You should have received a copy of the GNU General Public
  37  * License along with this program; if not, write to the Free
  38  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  39  * Boston, MA 02110-1301, USA.
  40  *
  41  * \see  http://www.gnu.org/copyleft/gpl.html
  42  ***************************************************************/
  43
  44
  45 #include <ogdf/fileformats/DinoXmlScanner.h>
  46
  47 #include <ctype.h>
  48 #include <string.h>
  49
  50 extern ofstream os;
  51
  52 namespace ogdf {
  53
  54         //
  55         // C o n s t r u c t o r
  56         //
  57         DinoXmlScanner::DinoXmlScanner(const char *fileName)
  58         {
  59                 // Create line buffer
  60                 m_pLineBuffer = new DinoLineBuffer(fileName);
  61
  62                 // Create current token string
  63                 m_pCurrentTokenString = new char[DinoLineBuffer::c_maxStringLength];
  64                 if (m_pCurrentTokenString == 0)
  65                         OGDF_THROW(InsufficientMemoryException);
  66                 for (int i = 0; i < DinoLineBuffer::c_maxStringLength; i++){
  67                         m_pCurrentTokenString[i] = '0';
  68                 }
  69
  70         } // DinoXmlScanner::DinoXmlScanner
  71
  72         //
  73         // D e s t r u c t o r
  74         //
  75         DinoXmlScanner::~DinoXmlScanner()
  76         {
  77                 // Destroy current token string
  78                 delete [] m_pCurrentTokenString;
  79
  80                 // Destroy line buffer
  81                 delete m_pLineBuffer;
  82
  83         } // DinoXmlScanner::~DinoXmlScanner
  84
  85         //
  86         // g e t N e x t T o k e n
  87         //
  88         // Take a look at the state machine of getNextToken() to understand
  89         // what is going on here.
  90         //
  91         // TODO: It seems to be useful that this function throws an exception
  92         //       if something goes wrong.
  93         XmlToken DinoXmlScanner::getNextToken(){
  94
  95                 // First skip whitespaces
  96                 m_pLineBuffer->skipWhitespace();
  97
  98                 // Let's have a look at the current character
  99                 char currentCharacter = m_pLineBuffer->getCurrentCharacter();
 100
 101                 // End of file reached
 102                 if (currentCharacter == EOF){
 103                         return endOfFile;
 104                 }
 105
 106                 // First we handle single characters with a switch statement
 107                 switch (currentCharacter){
 108
 109                 // Opening Bracket
 110                 case '<':
 111                         {
 112                                 m_pLineBuffer->moveToNextCharacter();
 113                                 return openingBracket;
 114                         }
 115                         break;
 116
 117                 // Closing Bracket
 118                 case '>':
 119                         {
 120                                 m_pLineBuffer->moveToNextCharacter();
 121                                 return closingBracket;
 122                         }
 123                         break;
 124
 125                 // Question Mark
 126                 case '?':
 127                         {
 128                                 m_pLineBuffer->moveToNextCharacter();
 129                                 return questionMark;
 130                         }
 131                         break;
 132
 133                 // Exclamation Mark
 134                 case '!':
 135                         {
 136                                 m_pLineBuffer->moveToNextCharacter();
 137                                 return exclamationMark;
 138                         }
 139                         break;
 140
 141                 // Minus
 142                 case '-':
 143                         {
 144                                 m_pLineBuffer->moveToNextCharacter();
 145                                 return minus;
 146                         }
 147                         break;
 148
 149                 // Slash
 150                 case '/':
 151                         {
 152                                 m_pLineBuffer->moveToNextCharacter();
 153                                 return slash;
 154                         }
 155                         break;
 156
 157                 // Equal Sign
 158                 case '=':
 159                         {
 160                                 m_pLineBuffer->moveToNextCharacter();
 161                                 return equalSign;
 162                         }
 163                         break;
 164
 165                 } // end of switch
 166
 167                 // Now we handle more complex token
 168
 169                 // Identifier
 170                 if (isalpha(currentCharacter)){
 171
 172                         // Put a pointer to the beginning of the identifier
 173                         DinoLineBufferPosition startPosition = m_pLineBuffer->getCurrentPosition();
 174
 175                         currentCharacter = m_pLineBuffer->moveToNextCharacter();
 176
 177                         // Read valid identifier characters
 178                         while ((isalnum(currentCharacter)) ||  // a..z|A..Z|0..9
 179                                 (currentCharacter == '.') ||
 180                                 (currentCharacter == ':') ||
 181                                 (currentCharacter == '_'))
 182                         {
 183                                 currentCharacter = m_pLineBuffer->moveToNextCharacter();
 184                         }
 185
 186                         // Copy identifier to currentTokenString
 187                         m_pLineBuffer->extractString(startPosition,
 188                                                                                  m_pLineBuffer->getCurrentPosition(),
 189                                                                                  m_pCurrentTokenString);
 190
 191                         // Return identifier token
 192                         return identifier;
 193
 194                 } // end of identifier
 195
 196                 // Quoted characters " ... " or ' ... '
 197                 if ((currentCharacter == '\"') ||
 198                         (currentCharacter == '\''))
 199                 {
 200                         // Distinguish what kind of quote sign we have
 201                         bool doubleQuote;
 202                         if (currentCharacter == '\"')
 203                                 doubleQuote = true;
 204                         else
 205                                 doubleQuote = false;
 206
 207                         // Skip quote sign
 208                         currentCharacter = m_pLineBuffer->moveToNextCharacter();
 209
 210                         // Read until the closing quotation sign is found
 211                         // String is copied to m_pCurrentTokenString by readStringUntil()
 212                         if (doubleQuote){
 213                                 readStringUntil('\"', false);
 214                         }
 215                         else{
 216                                 readStringUntil('\'', false);
 217                         }
 218
 219                         // Skip over the end quote character
 220                         m_pLineBuffer->moveToNextCharacter();
 221
 222                         // Return token for quoted value
 223                         return quotedValue;
 224
 225                 } // end of quoted characters
 226
 227                 // An atributeValue, i.e. a sequence of characters, digits, minus - or dot .
 228                 if ((isalnum(currentCharacter)) ||
 229                         (currentCharacter == '-') ||
 230                         (currentCharacter == '.'))
 231                 {
 232                         // Put a pointer to the beginning of the quoted text
 233                         DinoLineBufferPosition startPosition = m_pLineBuffer->getCurrentPosition();;
 234
 235                         // Read until until an invalid character occurs
 236                         currentCharacter = m_pLineBuffer->moveToNextCharacter();
 237                         while ((isalnum(currentCharacter)) ||
 238                                 (currentCharacter == '-') ||
 239                                 (currentCharacter == '.'))
 240                         {
 241                                 currentCharacter = m_pLineBuffer->moveToNextCharacter();
 242                         }
 243
 244                         // Copy attributeValue to currentTokenString
 245                         m_pLineBuffer->extractString(startPosition,
 246                                                                                  m_pLineBuffer->getCurrentPosition(),
 247                                                                                  m_pCurrentTokenString);
 248
 249                         // Return token for attribute value
 250                         return attributeValue;
 251
 252                 } // end of an attributeValue
 253
 254                 // No valid token
 255                 m_pLineBuffer->moveToNextCharacter();
 256                 return invalidToken;
 257
 258         } // getNextToken
 259
 260         //
 261         // t e s t N e x t T o k e n
 262         //
 263         XmlToken DinoXmlScanner::testNextToken(){
 264
 265                 // Save pointer to the current position
 266                 DinoLineBufferPosition originalPosition = m_pLineBuffer->getCurrentPosition();
 267
 268                 // Call getNextToken()
 269                 XmlToken returnToken = getNextToken();
 270
 271                 // Set pointer back to the original position
 272                 m_pLineBuffer->setCurrentPosition(originalPosition);
 273
 274                 // Return token
 275                 return returnToken;
 276
 277         } // testNextToken
 278
 279         //
 280         // t e s t N e x t N e x t T o k e n
 281         //
 282         XmlToken DinoXmlScanner::testNextNextToken(){
 283
 284                 // Save pointer to the current position
 285                 DinoLineBufferPosition originalPosition = m_pLineBuffer->getCurrentPosition();
 286
 287                 // Call getNextToken()
 288                 getNextToken();
 289
 290                 // Again Call getNextToken()
 291                 XmlToken returnToken = getNextToken();
 292
 293                 // Set pointer back to the original position
 294                 m_pLineBuffer->setCurrentPosition(originalPosition);
 295
 296                 // Return token
 297                 return returnToken;
 298
 299         } // testNextNextToken
 300
 301         //
 302         // s k i p U n t i l
 303         //
 304         bool DinoXmlScanner::skipUntil(char searchCharacter, bool skipOverSearchCharacter){
 305
 306                 while (m_pLineBuffer->getCurrentCharacter() != EOF){
 307
 308                         // Search character has been found!
 309                         if (m_pLineBuffer->getCurrentCharacter() == searchCharacter){
 310
 311                                 // Move to the position behind the search character if desired
 312                                 if (skipOverSearchCharacter){
 313                                         m_pLineBuffer->moveToNextCharacter();
 314                                 }
 315
 316                                 return true;
 317
 318                         } // Search character has been found!
 319
 320                         // Move to next character and proceed
 321                         m_pLineBuffer->moveToNextCharacter();
 322
 323                 } // while (!EOF)
 324
 325                 return false;
 326
 327         } // skipUntil
 328
 329         //
 330         // s k i p U n t i l M a t c h i n g C l o s i n g B r a c k e t
 331         //
 332         bool DinoXmlScanner::skipUntilMatchingClosingBracket(){
 333
 334                 // We assume that the opening bracket has already been read
 335                 int bracketParity = 1;
 336
 337                 while ((m_pLineBuffer->getCurrentCharacter() != EOF) &&
 338                         (bracketParity != 0))
 339                 {
 340                         // Opening bracket has been found!
 341                         if (m_pLineBuffer->getCurrentCharacter() == '<'){
 342
 343                                 ++bracketParity;
 344                         }
 345
 346                         // Closing bracket has been found!
 347                         if (m_pLineBuffer->getCurrentCharacter() == '>'){
 348
 349                                 --bracketParity;
 350                         }
 351
 352                         // Move to next character and proceed
 353                         m_pLineBuffer->moveToNextCharacter();
 354
 355                 } // while
 356
 357                 if (bracketParity != 0 )
 358                         return false;
 359                 else
 360                         return true;
 361
 362         } // skipUntilMatchingClosingBracket
 363
 364         //
 365         // r e a d S t r i n g U n t i l
 366         //
 367         bool DinoXmlScanner::readStringUntil(char searchCharacter,
 368                                                                                  bool includeSearchCharacter){
 369
 370                 // Remember start position
 371                 DinoLineBufferPosition startPosition = m_pLineBuffer->getCurrentPosition();
 372
 373                 // Use skipUntil()
 374                 if (skipUntil(searchCharacter, includeSearchCharacter)){
 375
 376                         // Copy found string to m_pCurrentTokenString
 377                         m_pLineBuffer->extractString(startPosition,
 378                                                                                  m_pLineBuffer->getCurrentPosition(),
 379                                                                                  m_pCurrentTokenString);
 380
 381                         return true;
 382
 383                 }
 384                 // An error occurred
 385                 else{
 386                         return false;
 387                 }
 388
 389         } // getStringUntil
 390
 391         //
 392         //  t e s t
 393         //
 394         void DinoXmlScanner::test(){
 395
 396                 bool terminate = false;
 397                 XmlToken currentToken;
 398
 399                 while (!terminate){
 400
 401                         cout << "Line " << getInputFileLineCounter() << ": ";
 402                         currentToken = getNextToken();
 403
 404                         switch (currentToken){
 405                         case openingBracket:
 406                                 cout << "<" << endl;
 407                                 break;
 408                         case closingBracket:
 409                                 cout << ">" << endl;
 410                                 break;
 411                         case questionMark:
 412                                 cout << "?" << endl;
 413                                 break;
 414                         case exclamationMark:
 415                                 cout << "!" << endl;
 416                                 break;
 417                         case minus:
 418                                 cout << "-" << endl;
 419                                 break;
 420                         case slash:
 421                                 cout << "/" << endl;
 422                                 break;
 423                         case equalSign:
 424                                 cout << "<" << endl;
 425                                 break;
 426                         case identifier:
 427                                 cout << "Identifier: " << m_pCurrentTokenString << endl;
 428                                 break;
 429                         case attributeValue:
 430                                 cout << "Attribute value: " << m_pCurrentTokenString << endl;
 431                                 break;
 432                         case quotedValue:
 433                                 cout << "Quoted value: \"" << m_pCurrentTokenString << "\"" << endl;
 434                                 break;
 435                         case endOfFile:
 436                                 cout << "EOF" << endl;
 437                                 terminate = true;
 438                                 break;
 439                         default:
 440                                 cout << "Invalid token!" << endl;
 441
 442                         } // switch
 443
 444                 } // while
 445
 446         } // testScanner
 447
 448 } // namespace ogdf