Source/System/FileIO/ScanParseSkel/OSGScanParseSkel.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include <iostream>
  49 #include <sstream>
  50
  51 #ifdef OSG_FLEX_USE_IOSTREAM_INPUT
  52 #include <fstream>
  53 #endif
  54
  55 #include "OSGScanParseLexer.h"
  56 #include "OSGScanParseSkel.h"
  57 #include "OSGBaseFunctions.h"
  58 #include "OSGLog.h"
  59
  60
  61 OSG_USING_NAMESPACE
  62
  63 /*-------------------------------------------------------------------------*/
  64 /*                            Constructors                                 */
  65
  66 ScanParseSkel::ScanParseSkel(void) :
  67     _bMapTypeIds      (false                           ),
  68     _szReferenceHeader(NULL                            ),
  69     _pLexer           (new OSGScanParseLexer           ),
  70
  71     _tmpString1       (                                ),
  72     _tmpString2       (                                ),
  73     _tmpString3       (                                ),
  74     _tmpFloat1        (0.f                             ),
  75     _tmpFloat2        (0.f                             ),
  76     _tmpFloat3        (0.f                             ),
  77     _tmpFloat4        (0.f                             ),
  78     _tmpBitVector1    (TypeTraits<BitVector>::BitsClear),
  79
  80     _image            (NULL                            ),
  81     _imageDataPtr     (0                               ),
  82     _options          (0                               )
  83 {
  84 }
  85
  86 /*-------------------------------------------------------------------------*/
  87 /*                             Destructor                                  */
  88
  89 ScanParseSkel::~ScanParseSkel(void)
  90 {
  91     _image = NULL;
  92
  93     delete _pLexer;
  94
  95     delete [] _szReferenceHeader;
  96 }
  97
  98 /*-------------------------------------------------------------------------*/
  99 /*                                Scan                                     */
 100
 101 extern int OSGScanParseSkel_parse(void *);
 102
 103 #ifdef OSG_FLEX_USE_IOSTREAM_INPUT
 104 void ScanParseSkel::scanStream(std::istream &iStream)
 105 {
 106     if(iStream.good())
 107     {
 108         _pLexer->switch_streams(&iStream, 0);
 109         OSGScanParseSkel_parse(this);
 110     }
 111 }
 112 #endif
 113
 114 void ScanParseSkel::scanFile(const Char8 *szFilename)
 115 {
 116     if(szFilename == NULL)
 117         return;
 118
 119 #ifdef OSG_FLEX_USE_IOSTREAM_INPUT
 120     std::ifstream iStream(szFilename);
 121
 122     if(iStream.good())
 123     {
 124         PNOTICE << "Loading Stream: " << szFilename << std::endl;
 125
 126         scanStream(iStream);
 127
 128         iStream.close();
 129     }
 130 #else
 131     FILE *pInFile = fopen(szFilename, "r");
 132
 133     if(pInFile != NULL)
 134     {
 135         PNOTICE << "Loading File : " << szFilename << std::endl;
 136
 137         OSGScanParseSkel_in = pInFile;
 138
 139         OSGScanParseSkel_parse(this);
 140
 141         fclose(pInFile);
 142     }
 143 #endif
 144 }
 145
 146 Int32 ScanParseSkel::lex(YYSTYPE *lvalp)
 147 {
 148     return _pLexer->yylex(lvalp);
 149 }
 150
 151 const Char8 *ScanParseSkel::getText(void)
 152 {
 153     return _pLexer->YYText();
 154 }
 155
 156 void ScanParseSkel::handleError(void *pSelf, const Char8 *szErrorText)
 157 {
 158     FWARNING(("-----> %s in Line %d, read '%s'\n",
 159               szErrorText,
 160               _pLexer->lineno(),
 161               _pLexer->YYText()));
 162 }
 163
 164 /*-------------------------------------------------------------------------*/
 165 /*                             Prototypes                                  */
 166
 167 bool ScanParseSkel::verifyHeader(const Char8 *szHeader)
 168 {
 169     bool returnValue = true;
 170
 171     if(szHeader == NULL)
 172     {
 173         SLOG << "Error Null Header String Read" << std::endl;
 174         return false;
 175     }
 176
 177     if(_szReferenceHeader != NULL)
 178     {
 179         if(strncmp(szHeader,
 180                    _szReferenceHeader,
 181                    osgStringLen(_szReferenceHeader)) != 0)
 182         {
 183             SLOG << "Error : Header [" << szHeader << "] does not "
 184                     << "match reference [" << _szReferenceHeader << "]"
 185                     << std::endl;
 186
 187             returnValue = false;
 188         }
 189     }
 190     else
 191     {
 192         SLOG << "Error Null Reference Header, Check disabled " << std::endl;
 193         return true;
 194     }
 195
 196     return returnValue;
 197 }
 198
 199 bool ScanParseSkel::checkHeader(void)
 200 {
 201     return false;
 202 }
 203
 204 void ScanParseSkel::beginProto(const Char8 *)
 205 {
 206 }
 207
 208 void ScanParseSkel::endProto(void)
 209 {
 210 }
 211
 212 void ScanParseSkel::endProtoInterface(void)
 213 {
 214 }
 215
 216 void ScanParseSkel::beginExternProto(const Char8 *)
 217 {
 218 }
 219
 220 void ScanParseSkel::endExternProtoInterface(void)
 221 {
 222 }
 223
 224 void ScanParseSkel::endExternProto(void)
 225 {
 226 }
 227
 228 void ScanParseSkel::beginScript(const Char8 *)
 229 {
 230 }
 231
 232 void ScanParseSkel::endScript(void)
 233 {
 234 }
 235
 236 void ScanParseSkel::beginEventInDecl (const Char8  *,
 237                                       const UInt32  ,
 238                                       const Char8  *)
 239 {
 240 }
 241
 242 void ScanParseSkel::beginEventOutDecl(const Char8  *,
 243                                       const UInt32  ,
 244                                       const Char8  *)
 245 {
 246 }
 247
 248 void ScanParseSkel::endEventDecl(void)
 249 {
 250 }
 251
 252 void ScanParseSkel::beginFieldDecl(const Char8  *,
 253                                    const UInt32  ,
 254                                    const Char8  *)
 255 {
 256 }
 257
 258 void ScanParseSkel::endFieldDecl(void)
 259 {
 260 }
 261
 262 void ScanParseSkel::beginExposedFieldDecl(const Char8  *,
 263                                           const UInt32  ,
 264                                           const Char8  *)
 265 {
 266 }
 267
 268 void ScanParseSkel::endExposedFieldDecl(void)
 269 {
 270 }
 271
 272
 273 void ScanParseSkel::addExternEventInDecl (const Char8  *,
 274                                           const UInt32  ,
 275                                           const Char8  *)
 276 {
 277 }
 278
 279 void ScanParseSkel::addExternEventOutDecl(const Char8  *,
 280                                           const UInt32  ,
 281                                           const Char8  *)
 282 {
 283 }
 284
 285 void ScanParseSkel::addExternFieldDecl(const Char8  *,
 286                                        const UInt32  ,
 287                                        const Char8  *)
 288 {
 289 }
 290
 291 void ScanParseSkel::addExternExposedFieldDecl(const Char8  *,
 292                                               const UInt32  ,
 293                                               const Char8  *)
 294 {
 295 }
 296
 297 /*-------------------------------------------------------------------------*/
 298 /*                               Fields                                    */
 299
 300 void ScanParseSkel::beginField(const Char8 *,
 301                                const UInt32)
 302 {
 303 }
 304
 305 void ScanParseSkel::endField(void)
 306 {
 307 }
 308
 309 /*-------------------------------------------------------------------------*/
 310 /*                               Nodes                                     */
 311
 312 void ScanParseSkel::beginNode(const Char8     *szNodeTypename,
 313                               const Char8     *szNodename,
 314                               const BitVector  bvLocalFlags)
 315 {
 316     fprintf(stderr, "Calling default begin node %s %s\n",
 317             szNodeTypename,
 318             szNodename);
 319 }
 320
 321 void ScanParseSkel::endNode(void)
 322 {
 323 }
 324
 325 void ScanParseSkel::nullNode(void)
 326 {
 327 }
 328
 329 void ScanParseSkel::use(const Char8 *szName)
 330 {
 331     PINFO << "Use : " << szName << std::endl;
 332 }
 333
 334 void ScanParseSkel::is(const Char8 *)
 335 {
 336 }
 337
 338 void ScanParseSkel::profileElement(const Char8 *szProfileName)
 339 {
 340     fprintf(stderr, "PROFILE %s\n", szProfileName);
 341 }
 342
 343 void ScanParseSkel::componentElement    (const Char8 *szComponentName)
 344 {
 345     fprintf(stderr, "COMPONENT %s\n", szComponentName);
 346 }
 347
 348 void ScanParseSkel::metaElement  (const Char8 *szMetaKey,
 349                                   const Char8 *szMetaValue)
 350 {
 351     fprintf(stderr, "META %s %s\n", szMetaKey, szMetaValue);
 352 }
 353
 354 void ScanParseSkel::importElement(const Char8 *szInlineName,
 355                                   const Char8 *szNodeName,
 356                                   const Char8 *szImportAs   )
 357 {
 358     fprintf(stderr, "IMPORT %s.%s AS %s\n",
 359                     szInlineName, szNodeName, szImportAs);
 360 }
 361
 362 void ScanParseSkel::exportElement(const Char8 *szNodeName,
 363                                   const Char8 *szExportAs )
 364 {
 365     fprintf(stderr, "EXPORT %s AS %s\n", szNodeName, szExportAs);
 366 }
 367
 368 /*-------------------------------------------------------------------------*/
 369 /*                               Helper                                    */
 370
 371 void ScanParseSkel::addBufferAsStringValue(void)
 372 {
 373     addStringValue(_pLexer->YYText());
 374 }
 375
 376 void ScanParseSkel::addFieldValue(const Char8 *)
 377 {
 378 }
 379
 380 void ScanParseSkel::addBoolValue(bool b)
 381 {
 382     addFieldValue(_pLexer->YYText());
 383 }
 384
 385 void ScanParseSkel::addColorValue(const Color3f &c)
 386 {
 387     addFieldValue(_tmpString1.c_str());
 388 }
 389
 390 void ScanParseSkel::addColorRGBAValue(const Color4f &c)
 391 {
 392     addFieldValue(_tmpString1.c_str());
 393 }
 394
 395 void ScanParseSkel::addDoubleValue(Real64 d)
 396 {
 397     addFieldValue(_pLexer->YYText());
 398 }
 399
 400 void ScanParseSkel::addFloatValue(Real32 f)
 401 {
 402     addFieldValue(_pLexer->YYText());
 403 }
 404
 405 void ScanParseSkel::addImageValue(Image *img)
 406 {
 407     UInt32 numComponents = img->getComponents();
 408     std::ostringstream os;
 409     os << img->getWidth() << ' ' << img->getHeight() << ' ' << numComponents;
 410     addFieldValue(os.str().c_str());
 411     UInt32 numPixels = img->getWidth() * img->getHeight();
 412     UInt32 pixel;
 413     UInt8 *data = img->editData();
 414     for (UInt32 i = 0; i < numPixels; ++i)
 415     {
 416         pixel = 0;
 417         for (UInt32 j = 0; j < numComponents; ++j)
 418             pixel = (pixel << 8) | *data++;
 419         os.str(std::string());
 420         os << pixel;
 421         addFieldValue(os.str().c_str());
 422     }
 423 }
 424
 425 void ScanParseSkel::addInt32Value(Int32 i)
 426 {
 427     addFieldValue(_pLexer->YYText());
 428 }
 429
 430 void ScanParseSkel::addMatrix3dValue(Real64 m00, Real64 m10, Real64 m20,
 431                                      Real64 m01, Real64 m11, Real64 m21,
 432                                      Real64 m02, Real64 m12, Real64 m22)
 433 {
 434     addFieldValue(_tmpString1.c_str());
 435 }
 436
 437 void ScanParseSkel::addMatrix3fValue(Real32 m00, Real32 m10, Real32 m20,
 438                                      Real32 m01, Real32 m11, Real32 m21,
 439                                      Real32 m02, Real32 m12, Real32 m22)
 440 {
 441     addFieldValue(_tmpString1.c_str());
 442 }
 443
 444 void ScanParseSkel::addMatrix4dValue(const Matrix4d &m)
 445 {
 446     addFieldValue(_tmpString1.c_str());
 447 }
 448
 449 void ScanParseSkel::addMatrix4fValue(const Matrix4f &m)
 450 {
 451     addFieldValue(_tmpString1.c_str());
 452 }
 453
 454 void ScanParseSkel::addRotationValue(const Vec3f &axis, Real32 angle)
 455 {
 456     addFieldValue(_tmpString1.c_str());
 457 }
 458
 459 void ScanParseSkel::addStringValue(const std::string &s)
 460 {
 461     addFieldValue(s.c_str());
 462 }
 463
 464 void ScanParseSkel::addTimeValue(Time t)
 465 {
 466     addFieldValue(_pLexer->YYText());
 467 }
 468
 469 void ScanParseSkel::addVec2dValue(const Vec2d &v)
 470 {
 471     addFieldValue(_tmpString1.c_str());
 472 }
 473
 474 void ScanParseSkel::addVec3iValue(const Vec3i &v)
 475 {
 476     addFieldValue(_tmpString1.c_str());
 477 }
 478
 479 void ScanParseSkel::addVec2fValue(const Vec2f &v)
 480 {
 481     addFieldValue(_tmpString1.c_str());
 482 }
 483
 484 void ScanParseSkel::addVec3dValue(const Vec3d &v)
 485 {
 486     addFieldValue(_tmpString1.c_str());
 487 }
 488
 489 void ScanParseSkel::addVec3fValue(const Vec3f &v)
 490 {
 491     addFieldValue(_tmpString1.c_str());
 492 }
 493
 494 void ScanParseSkel::addVec4dValue(const Vec4d &v)
 495 {
 496     addFieldValue(_tmpString1.c_str());
 497 }
 498
 499 void ScanParseSkel::addVec4fValue(const Vec4f &v)
 500 {
 501     addFieldValue(_tmpString1.c_str());
 502 }
 503
 504 void ScanParseSkel::addColor4iValue(const Color4ub &c)
 505 {
 506     addFieldValue(_tmpString1.c_str());
 507 }
 508
 509 void ScanParseSkel::addPnt2fValue(const Pnt2f &p)
 510 {
 511     addFieldValue(_tmpString1.c_str());
 512 }
 513
 514 void ScanParseSkel::addPnt3fValue(const Pnt3f &p)
 515 {
 516     addFieldValue(_tmpString1.c_str());
 517 }
 518
 519 void ScanParseSkel::addPnt4fValue(const Pnt4f &p)
 520 {
 521     addFieldValue(_tmpString1.c_str());
 522 }
 523
 524 void ScanParseSkel::addVec2iValue(const Vec2i &)
 525 {
 526     addFieldValue(_tmpString1.c_str());
 527 }
 528
 529 void ScanParseSkel::addPlaneValue(const Plane &p)
 530 {
 531     addFieldValue(_tmpString1.c_str());
 532 }
 533
 534 void ScanParseSkel::addVolumeValue(const BoxVolume &v)
 535 {
 536     addFieldValue(_tmpString1.c_str());
 537 }
 538
 539 void ScanParseSkel::addRoute(const Char8 *,
 540                              const Char8 *,
 541                              const Char8 *,
 542                              const Char8 *)
 543 {
 544 }
 545
 546 /*-------------------------------------------------------------------------*/
 547 /*                           Type Information                              */
 548
 549 bool ScanParseSkel::getMapFieldTypes(void)
 550 {
 551     return _bMapTypeIds;
 552 }
 553
 554 Int32 ScanParseSkel::mapExtIntFieldType(const Char8*, const Int32 iFieldType)
 555 {
 556     return iFieldType;
 557 }
 558
 559 UInt32 ScanParseSkel::getFieldType(const Char8 *)
 560 {
 561     return 0;
 562 }
 563
 564 OSGScanParseLexer *ScanParseSkel::getLexer(void)
 565 {
 566     return _pLexer;
 567 }
 568
 569
 570 /*-------------------------------------------------------------------------*/
 571 /*                              Options                                    */
 572
 573 void ScanParseSkel::addOptions(UInt32 options)
 574 {
 575     _options |= options;
 576 }
 577
 578 void ScanParseSkel::subOptions(UInt32 options)
 579 {
 580     _options &= ~options;
 581 }
 582
 583 UInt32 ScanParseSkel::getOptions(void) const
 584 {
 585     return _options;
 586 }
 587
 588 /*-------------------------------------------------------------------------*/
 589 /*                               Set                                       */
 590
 591 void ScanParseSkel::reset(void)
 592 {
 593 }
 594
 595 void ScanParseSkel::setMapTypeIds(bool bVal)
 596 {
 597     _bMapTypeIds = bVal;
 598 }
 599
 600 void ScanParseSkel::setReferenceHeader(const Char8 *szReferenceHeader)
 601 {
 602     osgStringDup(szReferenceHeader, _szReferenceHeader);
 603 }
 604
 605 /*-------------------------------------------------------------------------*/
 606
 607 void ScanParseSkel::beginValue()
 608 {
 609     _tmpString1.assign(_pLexer->YYText(), _pLexer->YYLeng());
 610 }
 611
 612 void ScanParseSkel::appendValue()
 613 {
 614     _tmpString1.push_back(' ');
 615     _tmpString1.append(_pLexer->YYText(), _pLexer->YYLeng());
 616 }
 617
 618 void ScanParseSkel::beginImage(Int32 width, Int32 height, Int32 components)
 619 {
 620     if (_image == NULL)
 621     {
 622         _image = Image::create();
 623     }
 624     UInt32 pixelFormat;
 625     switch (components)
 626     {
 627     case 1:  pixelFormat = Image::OSG_L_PF;       break;
 628     case 2:  pixelFormat = Image::OSG_LA_PF;      break;
 629     case 3:  pixelFormat = Image::OSG_RGB_PF;     break;
 630     case 4:  pixelFormat = Image::OSG_RGBA_PF;    break;
 631     default: pixelFormat = Image::OSG_INVALID_PF; break;
 632     }
 633     _image->set(pixelFormat, width, height);
 634     _imageDataPtr = _image->editData();
 635     _pLexer->expectImageInts(width * height);
 636 }
 637
 638 void ScanParseSkel::addImagePixel(Int32 pixel)
 639 {
 640     switch (_image->getPixelFormat())
 641     {
 642     case Image::OSG_RGBA_PF:
 643         *_imageDataPtr++ = pixel >> 24;
 644         // Fall through
 645     case Image::OSG_RGB_PF:
 646         *_imageDataPtr++ = pixel >> 16;
 647         // Fall through
 648     case Image::OSG_LA_PF:
 649         *_imageDataPtr++ = pixel >> 8;
 650         // Fall through
 651     case Image::OSG_L_PF:
 652         *_imageDataPtr++ = pixel;
 653         // Fall through
 654     default:
 655         break;
 656     }
 657 }
 658
 659 void ScanParseSkel::endImage()
 660 {
 661     _imageDataPtr = 0;
 662
 663     addImageValue(_image);
 664
 665     _image = NULL;
 666 }