connectivity/source/drivers/mork/MorkParser.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * Software License Agreement (BSD License)
   4  *
   5  * Copyright (c) 2006, ScalingWeb.com
   6  * All rights reserved.
   7  *
   8  * Redistribution and use of this software in source and binary forms, with or without modification, are
   9  * permitted provided that the following conditions are met:
  10  *
  11  * * Redistributions of source code must retain the above
  12  *   copyright notice, this list of conditions and the
  13  *   following disclaimer.
  14  *
  15  * * Redistributions in binary form must reproduce the above
  16  *   copyright notice, this list of conditions and the
  17  *   following disclaimer in the documentation and/or other
  18  *   materials provided with the distribution.
  19  *
  20  * * Neither the name of ScalingWeb.com nor the names of its
  21  *   contributors may be used to endorse or promote products
  22  *   derived from this software without specific prior
  23  *   written permission of ScalingWeb.com.
  24
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
  26  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  27  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  28  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  29  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  31  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  32  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #include "MorkParser.hxx"
  36 #include <boost/io/ios_state.hpp>
  37 #include <stdlib.h>
  38 #include <sstream>
  39 #include <string>
  40 #include <string.h>
  41 #include <stdexcept>
  42 #include <fstream>
  43 #include <iostream>
  44 #include <algorithm>
  45
  46 std::string g_Empty = "";
  47
  48 // Mork header of supported format version
  49 const char *MorkMagicHeader = "// <!-- <mdb:mork:z v=\"1.4\"/> -->";
  50
  51 const char *MorkDictColumnMeta = "<(a=c)>";
  52
  53
  54 MorkParser::MorkParser( int DefaultScope ) :
  55     columns_(),
  56     values_(),
  57     mork_(),
  58     currentCells_(0),
  59     error_(NoError),
  60     morkData_(),
  61     morkPos_(0),
  62     nextAddValueId_(0x7fffffff),
  63     defaultScope_(DefaultScope),
  64     defaultListScope_(0x81),
  65     defaultTableId_(1),
  66     nowParsing_(NPValues)
  67 {
  68 }
  69
  70 bool MorkParser::open( const std::string &path )
  71 {
  72     initVars();
  73     std::string line;
  74     std::ifstream infile(path.c_str(), std::ios_base::in);
  75     if(!infile.is_open())
  76     {
  77         error_ = FailedToOpen;
  78         return false;
  79     }
  80
  81     while (getline(infile, line, '\n'))
  82     {
  83         morkData_.append(line);
  84         morkData_.append("\n");
  85     }
  86
  87     // Parse mork
  88     return parse();
  89 }
  90
  91 inline MorkErrors MorkParser::error()
  92 {
  93     return error_;
  94 }
  95
  96 void MorkParser::initVars()
  97 {
  98     error_ = NoError;
  99     morkPos_ = 0;
 100     nowParsing_ = NPValues;
 101     currentCells_ = 0;
 102     nextAddValueId_ = 0x7fffffff;
 103 }
 104
 105 bool MorkParser::parse()
 106 {
 107     bool Result = true;
 108
 109     // Run over mork chars and parse each term
 110     char cur = nextChar();
 111
 112     int i = 0;
 113
 114     while ( Result && cur )
 115     {
 116         if ( !isWhiteSpace( cur ) )
 117         {
 118             i++;
 119             // Figure out what a term
 120             switch ( cur )
 121             {
 122             case '<':
 123                 // Dict
 124                 Result = parseDict();
 125                 break;
 126             case '/':
 127                 // Comment
 128                 Result = parseComment();
 129                 break;
 130             case '{':
 131                 Result = parseTable();
 132                 // Table
 133                 break;
 134             case '[':
 135                 Result = parseRow( 0, 0 );
 136                 // Row
 137                 break;
 138             case '@':
 139                 Result = parseGroup();
 140                 // Group
 141                 break;
 142             default:
 143                 error_ = DefectedFormat;
 144                 Result = false;
 145                 break;
 146             }
 147         }
 148
 149         // Get next char
 150         cur = nextChar();
 151     }
 152
 153     return Result;
 154 }
 155
 156 bool MorkParser::isWhiteSpace( char c )
 157 {
 158     switch ( c )
 159     {
 160     case ' ':
 161     case '\t':
 162     case '\r':
 163     case '\n':
 164     case '\f':
 165         return true;
 166     default:
 167         return false;
 168     }
 169 }
 170
 171 inline char MorkParser::nextChar()
 172 {
 173     char cur = 0;
 174
 175
 176     if ( morkPos_ < morkData_.length() )
 177     {
 178         cur = morkData_[ morkPos_ ];
 179         morkPos_++;
 180     }
 181
 182     if ( !cur )
 183     {
 184         cur = 0;
 185     }
 186
 187     return cur;
 188 }
 189
 190 bool MorkParser::parseDict()
 191 {
 192     char cur = nextChar();
 193     bool Result = true;
 194     nowParsing_ = NPValues;
 195
 196     while ( Result && cur != '>' && cur )
 197     {
 198         if ( !isWhiteSpace( cur ) )
 199         {
 200             switch ( cur )
 201             {
 202             case '<':
 203             {
 204
 205                 if ( morkData_.substr( morkPos_ - 1, strlen( MorkDictColumnMeta ) ) == MorkDictColumnMeta )
 206                 {
 207                     nowParsing_ = NPColumns;
 208                     morkPos_ += strlen( MorkDictColumnMeta ) - 1;
 209                 }
 210
 211
 212                 break;
 213             }
 214             case '(':
 215                 Result = parseCell();
 216                 break;
 217             case '/':
 218                 Result = parseComment();
 219                 break;
 220
 221             }
 222         }
 223
 224         cur = nextChar();
 225     }
 226
 227     return Result;
 228 }
 229
 230 inline bool MorkParser::parseComment()
 231 {
 232     char cur = nextChar();
 233     if ( '/' != cur ) return false;
 234
 235     while ( cur != '\r' && cur != '\n' && cur )
 236     {
 237         cur = nextChar();
 238     }
 239
 240     return true;
 241 }
 242
 243 bool MorkParser::parseCell()
 244 {
 245     bool Result = true;
 246     bool bValueOid = false;
 247     bool bColumn = true;
 248     int Corners = 0;
 249
 250     // Column = Value
 251     std::string Column;
 252     std::string Text;
 253     Column.reserve( 4 );
 254     Text.reserve( 32 );
 255
 256     char cur = nextChar();
 257
 258     // Process cell start with column (bColumn == true)
 259     while ( Result && cur != ')' && cur )
 260     {
 261         switch ( cur )
 262         {
 263         case '^':
 264             // Oids
 265             Corners++;
 266             if ( 1 == Corners )
 267             {
 268             }
 269             else if ( 2 == Corners )
 270             {
 271                 bColumn = false;
 272                 bValueOid = true;
 273             }
 274             else
 275             {
 276                 Text += cur;
 277             }
 278
 279             break;
 280         case '=':
 281             // From column to value
 282             if ( bColumn )
 283             {
 284                 bColumn = false;
 285             }
 286             else
 287             {
 288                 Text += cur;
 289             }
 290             break;
 291         case '\\':
 292         {
 293             // Get next two chars
 294             char NextChar= nextChar();
 295             if ( '\r' != NextChar && '\n' != NextChar )
 296             {
 297                 Text += NextChar;
 298             }
 299             else nextChar();
 300         }
 301         break;
 302         case '$':
 303         {
 304             // Get next two chars
 305             std::string HexChar;
 306             HexChar += nextChar();
 307             HexChar += nextChar();
 308             Text += (char)strtoul(HexChar.c_str(), 0, 16);
 309         }
 310         break;
 311         default:
 312             // Just a char
 313             if ( bColumn )
 314             {
 315                 Column += cur;
 316             }
 317             else
 318             {
 319                 Text += cur;
 320             }
 321             break;
 322         }
 323
 324         cur = nextChar();
 325     }
 326
 327     // Apply column and text
 328     int ColumnId = strtoul(Column.c_str(), 0, 16);
 329
 330     if ( NPRows != nowParsing_ )
 331     {
 332         // Dicts
 333         if ( "" != Text )
 334         {
 335             if ( nowParsing_ == NPColumns )
 336             {
 337                 columns_[ ColumnId ] = Text;
 338             }
 339             else
 340             {
 341                 values_[ ColumnId ] = Text;
 342             }
 343         }
 344     }
 345     else
 346     {
 347         if ( "" != Text )
 348         {
 349             // Rows
 350             //int ValueId = string( Text.c_str() ).toInt( 0, 16 );
 351             int ValueId = strtoul(Text.c_str(), 0, 16);
 352
 353             if ( bValueOid  )
 354             {
 355                 ( *currentCells_ )[ ColumnId ] = ValueId;
 356             }
 357             else
 358             {
 359                 nextAddValueId_--;
 360                 values_[ nextAddValueId_ ] = Text;
 361                 ( *currentCells_ )[ ColumnId ] = nextAddValueId_;
 362             }
 363         }
 364     }
 365
 366     return Result;
 367 }
 368
 369 bool MorkParser::parseTable()
 370 {
 371     bool Result = true;
 372     std::string TextId;
 373     int Id = 0, Scope = 0;
 374
 375     char cur = nextChar();
 376
 377     // Get id
 378     while ( cur != '{' && cur != '[' && cur != '}' && cur )
 379     {
 380         if ( !isWhiteSpace( cur ) )
 381         {
 382             TextId += cur;
 383         }
 384
 385         cur = nextChar();
 386     }
 387
 388     parseScopeId( TextId, &Id, &Scope );
 389
 390     // Parse the table
 391     while ( Result && cur != '}' && cur )
 392     {
 393         if ( !isWhiteSpace( cur ) )
 394         {
 395             switch ( cur )
 396             {
 397             case '{':
 398                 Result = parseMeta( '}' );
 399                 break;
 400             case '[':
 401                 Result = parseRow( Id, Scope );
 402                 break;
 403             case '-':
 404             case '+':
 405                 break;
 406             default:
 407             {
 408                 std::string JustId;
 409                 while ( !isWhiteSpace( cur ) && cur )
 410                 {
 411                     JustId += cur;
 412                     cur = nextChar();
 413
 414                     if ( cur == '}' )
 415                     {
 416                         return Result;
 417                     }
 418                 }
 419
 420                 int JustIdNum = 0, JustScopeNum = 0;
 421                 parseScopeId( JustId, &JustIdNum, &JustScopeNum );
 422
 423                 setCurrentRow( Scope, Id, JustScopeNum, JustIdNum );
 424             }
 425             break;
 426             }
 427         }
 428
 429         cur = nextChar();
 430     }
 431
 432     return Result;
 433 }
 434
 435 void MorkParser::parseScopeId( const std::string &TextId, int *Id, int *Scope )
 436 {
 437     int Pos = 0;
 438
 439     if ( ( Pos = TextId.find( ':' ) ) >= 0 )
 440     {
 441         std::string tId = TextId.substr( 0, Pos );
 442         std::string tSc = TextId.substr( Pos + 1, TextId.length() - Pos );
 443
 444         if ( tSc.length() > 1 && '^' == tSc[ 0 ] )
 445         {
 446             // Delete '^'
 447             tSc.erase( 0, 1 );
 448         }
 449
 450         *Id = strtoul(tId.c_str(), 0, 16);
 451
 452         *Scope = strtoul(tSc.c_str(), 0, 16);
 453     }
 454     else
 455     {
 456         *Id = strtoul(TextId.c_str(), 0, 16);
 457     }
 458 }
 459
 460 inline void MorkParser::setCurrentRow( int TableScope, int TableId, int RowScope, int RowId )
 461 {
 462     if ( !RowScope )
 463     {
 464         RowScope = defaultScope_;
 465     }
 466
 467     if ( !TableScope )
 468     {
 469         TableScope = defaultScope_;
 470     }
 471
 472     // 01.08.2012 davido
 473     // TableId 0 is wrong here.
 474     // Straying rows (rows that defined outside the table) belong to the default scope and table is the last was seen: 1:^80
 475     // (at least i read so the specification)
 476     if (TableId)
 477     {
 478         defaultTableId_ = TableId;
 479     }
 480
 481     if (!TableId)
 482     {
 483         TableId = defaultTableId_;
 484     }
 485
 486     currentCells_ = &( mork_[ abs( TableScope ) ][ abs( TableId ) ][ abs( RowScope ) ][ abs( RowId ) ] );
 487 }
 488
 489 bool MorkParser::parseRow( int TableId, int TableScope )
 490 {
 491     bool Result = true;
 492     std::string TextId;
 493     int Id = 0, Scope = 0;
 494     nowParsing_ = NPRows;
 495
 496     char cur = nextChar();
 497
 498     // Get id
 499     while ( cur != '(' && cur != ']' && cur != '[' && cur )
 500     {
 501         if ( !isWhiteSpace( cur ) )
 502         {
 503             TextId += cur;
 504         }
 505
 506         cur = nextChar();
 507     }
 508
 509     parseScopeId( TextId, &Id, &Scope );
 510     setCurrentRow( TableScope, TableId, Scope, Id );
 511
 512     // Parse the row
 513     while ( Result && cur != ']' && cur )
 514     {
 515         if ( !isWhiteSpace( cur ) )
 516         {
 517             switch ( cur )
 518             {
 519             case '(':
 520                 Result = parseCell();
 521                 break;
 522             case '[':
 523                 Result = parseMeta( ']' );
 524                 break;
 525             default:
 526                 Result = false;
 527                 break;
 528             }
 529         }
 530
 531         cur = nextChar();
 532     }
 533
 534     return Result;
 535 }
 536
 537 bool MorkParser::parseGroup()
 538 {
 539     return parseMeta( '@' );
 540 }
 541
 542 bool MorkParser::parseMeta( char c )
 543 {
 544     char cur = nextChar();
 545
 546     while ( cur != c && cur )
 547     {
 548         cur = nextChar();
 549     }
 550
 551     return true;
 552 }
 553
 554 MorkTableMap *MorkParser::getTables( int TableScope )
 555 {
 556     TableScopeMap::iterator iter;
 557     iter = mork_.find( TableScope );
 558
 559     if ( iter == mork_.end() )
 560     {
 561         return 0;
 562     }
 563
 564     return &iter->second;
 565 }
 566
 567 MorkRowMap *MorkParser::getRows( int RowScope, RowScopeMap *table )
 568 {
 569     RowScopeMap::iterator iter;
 570     iter = table->find( RowScope );
 571
 572     if ( iter == table->end() )
 573     {
 574         return 0;
 575     }
 576
 577     return &iter->second;
 578 }
 579
 580 std::string &MorkParser::getValue( int oid )
 581 {
 582     MorkDict::iterator foundIter = values_.find( oid );
 583
 584     if ( values_.end() == foundIter )
 585     {
 586         return g_Empty;
 587     }
 588
 589     return foundIter->second;
 590 }
 591
 592 std::string &MorkParser::getColumn( int oid )
 593 {
 594     MorkDict::iterator foundIter = columns_.find( oid );
 595
 596     if ( columns_.end() == foundIter )
 597     {
 598         return g_Empty;
 599     }
 600
 601     return foundIter->second;
 602 }
 603
 604 void MorkParser::retrieveLists(std::set<std::string>& lists)
 605 {
 606 #ifdef VERBOSE
 607     boost::io::ios_all_saver ias(std::cout);
 608     std::cout << std::hex << std::uppercase;
 609 #endif
 610
 611     MorkTableMap* tables = getTables(defaultScope_);
 612     if (!tables) return;
 613     for (MorkTableMap::iterator TableIter = tables->begin();
 614          TableIter != tables->end(); ++TableIter )
 615     {
 616 #ifdef VERBOSE
 617         std::cout    << "\t Table:"
 618         << ( ( int ) TableIter->first < 0 ? "-" : " " )
 619         << TableIter->first << std::endl;
 620 #endif
 621         MorkRowMap* rows = getRows( defaultListScope_, &TableIter->second );
 622         if (!rows) return;
 623         for ( MorkRowMap::iterator RowIter = rows->begin();
 624              RowIter != rows->end(); ++RowIter )
 625         {
 626 #ifdef VERBOSE
 627             std::cout    << "\t\t\t Row Id:"
 628                 << ( ( int ) RowIter->first < 0 ? "-" : " ")
 629                 << RowIter->first << std::endl;
 630                 std::cout << "\t\t\t\t Cells:\r\n";
 631 #endif
 632             // Get cells
 633             for ( MorkCells::iterator cellsIter = RowIter->second.begin();
 634                  cellsIter != RowIter->second.end(); ++cellsIter )
 635             {
 636                 if (cellsIter->first == 0xC1)
 637                 {
 638                     lists.insert(getValue( cellsIter->second ));
 639                     break;
 640                 }
 641             }
 642         }
 643     }
 644 }
 645
 646 void MorkParser::getRecordKeysForListTable(std::string& listName, std::set<int>& records)
 647 {
 648 #ifdef VERBOSE
 649     boost::io::ios_all_saver ias(std::cout);
 650     std::cout << std::hex << std::uppercase;
 651 #endif
 652
 653     MorkTableMap* tables = getTables(defaultScope_);
 654     if (!tables) return;
 655     for (MorkTableMap::iterator TableIter = tables->begin();
 656          TableIter != tables->end(); ++TableIter )
 657     {
 658 #ifdef VERBOSE
 659         std::cout    << "\t Table:"
 660         << ( ( int ) TableIter->first < 0 ? "-" : " " )
 661         << TableIter->first << std::endl;
 662 #endif
 663         MorkRowMap* rows = getRows( 0x81, &TableIter->second );
 664         if (!rows) return;
 665         for ( MorkRowMap::iterator RowIter = rows->begin();
 666              RowIter != rows->end(); ++RowIter )
 667         {
 668 #ifdef VERBOSE
 669             std::cout    << "\t\t\t Row Id:"
 670             << ( ( int ) RowIter->first < 0 ? "-" : " ")
 671             << RowIter->first << std::endl;
 672             std::cout << "\t\t\t\t Cells:\r\n";
 673 #endif
 674             // Get cells
 675             bool listFound = false;
 676             for ( MorkCells::iterator cellsIter = RowIter->second.begin();
 677                  cellsIter != RowIter->second.end(); ++cellsIter )
 678             {
 679                 if (listFound)
 680                 {
 681                     if (cellsIter->first >= 0xC7)
 682                     {
 683                         std::string value = getValue(cellsIter->second);
 684                         int id = strtoul(value.c_str(), 0, 16);
 685                         records.insert(id);
 686                     }
 687                 }
 688                 else if ((cellsIter->first == 0xC1) &&
 689                          listName == getValue( cellsIter->second ))
 690                 {
 691                     listFound = true;
 692                 }
 693             }
 694
 695         }
 696     }
 697 }
 698
 699 void MorkParser::dump()
 700 {
 701     boost::io::ios_all_saver ias(std::cout);
 702     std::cout << std::hex << std::uppercase;
 703
 704     std::cout << "Column Dict:\r\n";
 705     std::cout << "=============================================\r\n\r\n";
 706
 707     //// columns dict
 708     for ( MorkDict::iterator iter = columns_.begin();
 709           iter != columns_.end(); ++iter )
 710     {
 711         std::cout  << iter->first
 712                    << " : "
 713                    << iter->second
 714                    << std::endl;
 715     }
 716
 717     //// values dict
 718     std::cout << "\r\nValues Dict:\r\n";
 719     std::cout << "=============================================\r\n\r\n";
 720
 721     for ( MorkDict::iterator iter = values_.begin();
 722           iter != values_.end(); ++iter )
 723     {
 724         if (iter->first >= nextAddValueId_) {
 725             continue;
 726         }
 727
 728         std::cout << iter->first
 729                   << " : "
 730                   << iter->second
 731                   << "\r\n";
 732     }
 733
 734     std::cout << std::endl << "Data:" << std::endl;
 735     std::cout << "============================================="
 736               << std::endl << std::endl;
 737
 738     //// Mork data
 739     for ( TableScopeMap::iterator iter = mork_.begin();
 740           iter != mork_.end(); ++iter )
 741     {
 742         std::cout << "\r\n Scope:" << iter->first << std::endl;
 743
 744         for ( MorkTableMap::iterator TableIter = iter->second.begin();
 745               TableIter != iter->second.end(); ++TableIter )
 746         {
 747             std::cout << "\t Table:"
 748                       << ( ( int ) TableIter->first < 0 ? "-" : " " )
 749                       << TableIter->first << std::endl;
 750
 751             for (RowScopeMap::iterator RowScopeIter = TableIter->second.begin();
 752                  RowScopeIter != TableIter->second.end(); ++RowScopeIter )
 753             {
 754                 std::cout << "\t\t RowScope:"
 755                           << RowScopeIter->first << std::endl;
 756
 757                 for (MorkRowMap::iterator RowIter = RowScopeIter->second.begin();
 758                      RowIter != RowScopeIter->second.end(); ++RowIter )
 759                 {
 760                     std::cout << "\t\t\t Row Id:"
 761                               << ((int) RowIter->first < 0 ? "-" : " ")
 762                               << RowIter->first << std::endl;
 763                     std::cout << "\t\t\t\t Cells:" << std::endl;
 764
 765                     for (MorkCells::iterator CellsIter = RowIter->second.begin();
 766                          CellsIter != RowIter->second.end(); ++CellsIter )
 767                     {
 768                         // Write ids
 769                         std::cout << "\t\t\t\t\t"
 770                                   << CellsIter->first
 771                                   << " : "
 772                                   << CellsIter->second
 773                                   << "  =>  ";
 774
 775                         MorkDict::iterator FoundIter = values_.find( CellsIter->second );
 776                         if ( FoundIter != values_.end() )
 777                         {
 778                             // Write string values
 779                             std::cout << columns_[ CellsIter->first ].c_str()
 780                                       << " : "
 781                                       << FoundIter->second.c_str()
 782                                       << std::endl;
 783                         }
 784                     }
 785                 }
 786             }
 787         }
 788     }
 789 }
 790
 791 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */