OpenSG: OSGScanParseSkel.cpp Source File

00001 /*---------------------------------------------------------------------------*\
00002  *                                OpenSG                                     *
00003  *                                                                           *
00004  *                                                                           *
00005  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
00006  *                                                                           *
00007  *                            www.opensg.org                                 *
00008  *                                                                           *
00009  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
00010  *                                                                           *
00011 \*---------------------------------------------------------------------------*/
00012 /*---------------------------------------------------------------------------*\
00013  *                                License                                    *
00014  *                                                                           *
00015  * This library is free software; you can redistribute it and/or modify it   *
00016  * under the terms of the GNU Library General Public License as published    *
00017  * by the Free Software Foundation, version 2.                               *
00018  *                                                                           *
00019  * This library is distributed in the hope that it will be useful, but       *
00020  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
00021  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
00022  * Library General Public License for more details.                          *
00023  *                                                                           *
00024  * You should have received a copy of the GNU Library General Public         *
00025  * License along with this library; if not, write to the Free Software       *
00026  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
00027  *                                                                           *
00028 \*---------------------------------------------------------------------------*/
00029 /*---------------------------------------------------------------------------*\
00030  *                                Changes                                    *
00031  *                                                                           *
00032  *                                                                           *
00033  *                                                                           *
00034  *                                                                           *
00035  *                                                                           *
00036  *                                                                           *
00037 \*---------------------------------------------------------------------------*/
00038 
00039 //---------------------------------------------------------------------------
00040 //  Includes
00041 //---------------------------------------------------------------------------
00042 
00043 #include <stdlib.h>
00044 #include <stdio.h>
00045 
00046 #include "OSGConfig.h"
00047 
00048 #include <iostream>
00049 #include <sstream>
00050 
00051 #ifdef OSG_FLEX_USE_IOSTREAM_INPUT
00052 #include <fstream>
00053 #endif
00054 
00055 #include "OSGScanParseLexer.h"
00056 #include "OSGScanParseSkel.h"
00057 #include "OSGBaseFunctions.h"
00058 #include "OSGLog.h"
00059 
00060 
00061 OSG_USING_NAMESPACE
00062 
00063 /*-------------------------------------------------------------------------*/
00064 /*                            Constructors                                 */
00065 
00066 ScanParseSkel::ScanParseSkel(void) :
00067     _bMapTypeIds      (false ),
00068     _szReferenceHeader(NULL  ),
00069     _pLexer           (new OSGScanParseLexer),
00070     _image            (NullFC),
00071     _imageDataPtr     (0     )
00072 {
00073 }
00074 
00075 /*-------------------------------------------------------------------------*/
00076 /*                             Destructor                                  */
00077 
00078 ScanParseSkel::~ScanParseSkel(void)
00079 {
00080     if (_image != NullFC)
00081         subRefCP(_image);
00082     if(_pLexer != NULL)
00083         delete _pLexer;
00084 }
00085 
00086 /*-------------------------------------------------------------------------*/
00087 /*                                Scan                                     */
00088 
00089 extern int OSGScanParseSkel_parse(void *);
00090 
00091 #ifdef OSG_FLEX_USE_IOSTREAM_INPUT
00092 void ScanParseSkel::scanStream(std::istream &is)
00093 {
00094     if(is.good())
00095     {
00096         _pLexer->switch_streams(&is, 0);
00097         OSGScanParseSkel_parse(this);
00098     }
00099 }
00100 #endif
00101 
00102 void ScanParseSkel::scanFile(const Char8 *szFilename)
00103 {
00104     if(szFilename == NULL)
00105         return;
00106 
00107 #ifdef OSG_FLEX_USE_IOSTREAM_INPUT
00108     std::ifstream is(szFilename);
00109 
00110     if(is.good())
00111     {
00112         PNOTICE << "Loading Stream: " << szFilename << std::endl;
00113 
00114         scanStream(is);
00115 
00116         is.close();
00117     }
00118 #else
00119     FILE *pInFile = fopen(szFilename, "r");
00120 
00121     if(pInFile != NULL)
00122     {
00123         PNOTICE << "Loading File : " << szFilename << std::endl;
00124 
00125         OSGScanParseSkel_in = pInFile;
00126 
00127         OSGScanParseSkel_parse(this);
00128 
00129         fclose(pInFile);
00130     }
00131 #endif
00132 }
00133 
00134 Int32 ScanParseSkel::lex(YYSTYPE *lvalp)
00135 {
00136     return _pLexer->yylex(lvalp);
00137 }
00138 
00139 const Char8 *ScanParseSkel::getText(void)
00140 {
00141     return _pLexer->YYText();
00142 }
00143 
00144 void ScanParseSkel::handleError(const Char8 *szErrorText)
00145 {
00146     FWARNING(("-----> %s in Line %d, read '%s'\n",
00147               szErrorText,
00148               _pLexer->lineno(),
00149               _pLexer->YYText()));
00150 }
00151 
00152 /*-------------------------------------------------------------------------*/
00153 /*                             Prototypes                                  */
00154 
00155 bool ScanParseSkel::verifyHeader(const Char8 *szHeader)
00156 {
00157     bool returnValue = true;
00158 
00159     if(szHeader == NULL)
00160     {
00161         SLOG << "Error Null Header String Read" << std::endl;
00162         return false;
00163     }
00164 
00165     if(_szReferenceHeader != NULL)
00166     {
00167         if(strncmp(szHeader,
00168                    _szReferenceHeader,
00169                    stringlen(_szReferenceHeader)) != 0)
00170         {
00171             SLOG << "Error : Header [" << szHeader << "] does not "
00172                     << "match reference [" << _szReferenceHeader << "]"
00173                     << std::endl;
00174 
00175             returnValue = false;
00176         }
00177     }
00178     else
00179     {
00180         SLOG << "Error Null Reference Header, Check disabled " << std::endl;
00181         return true;
00182     }
00183 
00184     return returnValue;
00185 }
00186 
00187 void ScanParseSkel::beginProto(const Char8 *)
00188 {
00189 }
00190 
00191 void ScanParseSkel::endProto(void)
00192 {
00193 }
00194 
00195 void ScanParseSkel::beginExternProto(const Char8 *)
00196 {
00197 }
00198 
00199 void ScanParseSkel::endExternProtoInterface(void)
00200 {
00201 }
00202 
00203 void ScanParseSkel::endExternProto(void)
00204 {
00205 }
00206 
00207 void ScanParseSkel::beginScript(const Char8 *)
00208 {
00209 }
00210 
00211 void ScanParseSkel::endScript(void)
00212 {
00213 }
00214 
00215 void ScanParseSkel::beginEventInDecl (const Char8  *,
00216                                       const UInt32  ,
00217                                       const Char8  *)
00218 {
00219 }
00220 
00221 void ScanParseSkel::beginEventOutDecl(const Char8  *,
00222                                       const UInt32  ,
00223                                       const Char8  *)
00224 {
00225 }
00226 
00227 void ScanParseSkel::endEventDecl(void)
00228 {
00229 }
00230 
00231 void ScanParseSkel::beginFieldDecl(const Char8  *,
00232                                    const UInt32  ,
00233                                    const Char8  *)
00234 {
00235 }
00236 
00237 void ScanParseSkel::endFieldDecl(void)
00238 {
00239 }
00240 
00241 void ScanParseSkel::beginExposedFieldDecl(const Char8  *,
00242                                           const UInt32  ,
00243                                           const Char8  *)
00244 {
00245 }
00246 
00247 void ScanParseSkel::endExposedFieldDecl(void)
00248 {
00249 }
00250 
00251 
00252 void ScanParseSkel::addExternEventInDecl (const Char8  *,
00253                                           const UInt32  ,
00254                                           const Char8  *)
00255 {
00256 }
00257 
00258 void ScanParseSkel::addExternEventOutDecl(const Char8  *,
00259                                           const UInt32  ,
00260                                           const Char8  *)
00261 {
00262 }
00263 
00264 void ScanParseSkel::addExternFieldDecl(const Char8  *,
00265                                        const UInt32  ,
00266                                        const Char8  *)
00267 {
00268 }
00269 
00270 void ScanParseSkel::addExternExposedFieldDecl(const Char8  *,
00271                                               const UInt32  ,
00272                                               const Char8  *)
00273 {
00274 }
00275 
00276 /*-------------------------------------------------------------------------*/
00277 /*                               Fields                                    */
00278 
00279 void ScanParseSkel::beginField(const Char8 *,
00280                                const UInt32)
00281 {
00282 }
00283 
00284 void ScanParseSkel::endField(void)
00285 {
00286 }
00287 
00288 /*-------------------------------------------------------------------------*/
00289 /*                               Nodes                                     */
00290 
00291 void ScanParseSkel::beginNode(const Char8 *szNodeTypename,
00292                               const Char8 *szNodename)
00293 {
00294     fprintf(stderr, "Calling default begin node %s %s\n",
00295             szNodeTypename,
00296             szNodename);
00297 }
00298 
00299 void ScanParseSkel::endNode(void)
00300 {
00301 }
00302 
00303 void ScanParseSkel::use(const Char8 *szName)
00304 {
00305     PINFO << "Use : " << szName << std::endl;
00306 }
00307 
00308 void ScanParseSkel::is(const Char8 *)
00309 {
00310 }
00311 
00312 void ScanParseSkel::profileElement(const Char8 *szProfileName)
00313 {
00314     fprintf(stderr, "PROFILE %s\n", szProfileName);
00315 }
00316 
00317 void ScanParseSkel::componentElement    (const Char8 *szComponentName)
00318 {
00319     fprintf(stderr, "COMPONENT %s\n", szComponentName);
00320 }
00321 
00322 void ScanParseSkel::metaElement  (const Char8 *szMetaKey,
00323                                   const Char8 *szMetaValue)
00324 {
00325     fprintf(stderr, "META %s %s\n", szMetaKey, szMetaValue);
00326 }
00327 
00328 void ScanParseSkel::importElement(const Char8 *szInlineName,
00329                                   const Char8 *szNodeName,
00330                                   const Char8 *szImportAs   )
00331 {
00332     fprintf(stderr, "IMPORT %s.%s AS %s\n", 
00333                     szInlineName, szNodeName, szImportAs);
00334 }
00335 
00336 void ScanParseSkel::exportElement(const Char8 *szNodeName,
00337                                   const Char8 *szExportAs )
00338 {
00339     fprintf(stderr, "EXPORT %s AS %s\n", szNodeName, szExportAs);
00340 }
00341 
00342 /*-------------------------------------------------------------------------*/
00343 /*                               Helper                                    */
00344 
00345 void ScanParseSkel::addFieldValue(const Char8 *)
00346 {
00347 }
00348 
00349 void ScanParseSkel::addBoolValue(bool b)
00350 {
00351     addFieldValue(_pLexer->YYText());
00352 }
00353 
00354 void ScanParseSkel::addColorValue(const Color3f &c)
00355 {
00356     addFieldValue(_tmpString1.c_str());
00357 }
00358 
00359 void ScanParseSkel::addColorRGBAValue(const Color4f &c)
00360 {
00361     addFieldValue(_tmpString1.c_str());
00362 }
00363 
00364 void ScanParseSkel::addDoubleValue(Real64 d)
00365 {
00366     addFieldValue(_pLexer->YYText());
00367 }
00368 
00369 void ScanParseSkel::addFloatValue(Real32 f)
00370 {
00371     addFieldValue(_pLexer->YYText());
00372 }
00373 
00374 void ScanParseSkel::addImageValue(ImagePtr &img)
00375 {
00376     UInt32 numComponents = img->getComponents();
00377     std::ostringstream os;
00378     os << img->getWidth() << ' ' << img->getHeight() << ' ' << numComponents;
00379     addFieldValue(os.str().c_str());
00380     UInt32 numPixels = img->getWidth() * img->getHeight();
00381     UInt32 pixel;
00382     UInt8 *data = img->getData();
00383     for (UInt32 i = 0; i < numPixels; ++i)
00384     {
00385         pixel = 0;
00386         for (UInt32 j = 0; j < numComponents; ++j)
00387             pixel = (pixel << 8) | *data++;
00388         os.str(std::string());
00389         os << pixel;
00390         addFieldValue(os.str().c_str());
00391     }
00392 }
00393 
00394 void ScanParseSkel::addInt32Value(Int32 i)
00395 {
00396     addFieldValue(_pLexer->YYText());
00397 }
00398 
00399 void ScanParseSkel::addMatrix3dValue(Real64 m00, Real64 m10, Real64 m20,
00400                                      Real64 m01, Real64 m11, Real64 m21,
00401                                      Real64 m02, Real64 m12, Real64 m22)
00402 {
00403     addFieldValue(_tmpString1.c_str());
00404 }
00405 
00406 void ScanParseSkel::addMatrix3fValue(Real32 m00, Real32 m10, Real32 m20,
00407                                      Real32 m01, Real32 m11, Real32 m21,
00408                                      Real32 m02, Real32 m12, Real32 m22)
00409 {
00410     addFieldValue(_tmpString1.c_str());
00411 }
00412 
00413 void ScanParseSkel::addMatrix4dValue(const Matrix4d &m)
00414 {
00415     addFieldValue(_tmpString1.c_str());
00416 }
00417 
00418 void ScanParseSkel::addMatrix4fValue(const Matrix4f &m)
00419 {
00420     addFieldValue(_tmpString1.c_str());
00421 }
00422 
00423 void ScanParseSkel::addRotationValue(const Vec3f &axis, Real32 angle)
00424 {
00425     addFieldValue(_tmpString1.c_str());
00426 }
00427 
00428 void ScanParseSkel::addStringValue(const std::string &s)
00429 {
00430     addFieldValue(s.c_str());
00431 }
00432 
00433 void ScanParseSkel::addTimeValue(Time t)
00434 {
00435     addFieldValue(_pLexer->YYText());
00436 }
00437 
00438 void ScanParseSkel::addVec2dValue(const Vec2d &v)
00439 {
00440     addFieldValue(_tmpString1.c_str());
00441 }
00442 
00443 void ScanParseSkel::addVec2fValue(const Vec2f &v)
00444 {
00445     addFieldValue(_tmpString1.c_str());
00446 }
00447 
00448 void ScanParseSkel::addVec3dValue(const Vec3d &v)
00449 {
00450     addFieldValue(_tmpString1.c_str());
00451 }
00452 
00453 void ScanParseSkel::addVec3fValue(const Vec3f &v)
00454 {
00455     addFieldValue(_tmpString1.c_str());
00456 }
00457 
00458 void ScanParseSkel::addVec4dValue(const Vec4d &v)
00459 {
00460     addFieldValue(_tmpString1.c_str());
00461 }
00462 
00463 void ScanParseSkel::addVec4fValue(const Vec4f &v)
00464 {
00465     addFieldValue(_tmpString1.c_str());
00466 }
00467 
00468 void ScanParseSkel::addColor4iValue(const Color4ub &c)
00469 {
00470     addFieldValue(_tmpString1.c_str());
00471 }
00472 
00473 void ScanParseSkel::addPnt2fValue(const Pnt2f &p)
00474 {
00475     addFieldValue(_tmpString1.c_str());
00476 }
00477 
00478 void ScanParseSkel::addPnt3fValue(const Pnt3f &p)
00479 {
00480     addFieldValue(_tmpString1.c_str());
00481 }
00482 
00483 void ScanParseSkel::addPnt4fValue(const Pnt4f &p)
00484 {
00485     addFieldValue(_tmpString1.c_str());
00486 }
00487 
00488 void ScanParseSkel::addPlaneValue(const Plane &p)
00489 {
00490     addFieldValue(_tmpString1.c_str());
00491 }
00492 
00493 void ScanParseSkel::addVolumeValue(const DynamicVolume &v)
00494 {
00495     addFieldValue(_tmpString1.c_str());
00496 }
00497 
00498 void ScanParseSkel::addRoute(const Char8 *,
00499                              const Char8 *,
00500                              const Char8 *,
00501                              const Char8 *)
00502 {
00503 }
00504 
00505 /*-------------------------------------------------------------------------*/
00506 /*                           Type Information                              */
00507 
00508 bool ScanParseSkel::getMapFieldTypes(void)
00509 {
00510     return _bMapTypeIds;
00511 }
00512 
00513 Int32 ScanParseSkel::mapExtIntFieldType(const Char8*, const Int32 iFieldType)
00514 {
00515     return iFieldType;
00516 }
00517 
00518 UInt32 ScanParseSkel::getFieldType(const Char8 *)
00519 {
00520     return 0;
00521 }
00522 
00523 OSGScanParseLexer *ScanParseSkel::getLexer(void)
00524 {
00525     return _pLexer;
00526 }
00527 
00528 /*-------------------------------------------------------------------------*/
00529 /*                               Set                                       */
00530 
00531 void ScanParseSkel::reset(void)
00532 {
00533 }
00534 
00535 void ScanParseSkel::setMapTypeIds(bool bVal)
00536 {
00537     _bMapTypeIds = bVal;
00538 }
00539 
00540 void ScanParseSkel::setReferenceHeader(const Char8 *szReferenceHeader)
00541 {
00542     stringDup(szReferenceHeader, _szReferenceHeader);
00543 }
00544 
00545 /*-------------------------------------------------------------------------*/
00546 
00547 void ScanParseSkel::beginValue()
00548 {
00549     _tmpString1.assign(_pLexer->YYText(), _pLexer->YYLeng());
00550 }
00551 
00552 void ScanParseSkel::appendValue()
00553 {
00554     _tmpString1.push_back(' ');
00555     _tmpString1.append(_pLexer->YYText(), _pLexer->YYLeng());
00556 }
00557 
00558 void ScanParseSkel::beginImage(Int32 width, Int32 height, Int32 components)
00559 {
00560     if (_image == NullFC)
00561     {
00562         _image = Image::create();
00563         addRefCP(_image);
00564     }
00565     UInt32 pixelFormat;
00566     switch (components)
00567     {
00568     case 1:  pixelFormat = Image::OSG_L_PF;       break;
00569     case 2:  pixelFormat = Image::OSG_LA_PF;      break;
00570     case 3:  pixelFormat = Image::OSG_RGB_PF;     break;
00571     case 4:  pixelFormat = Image::OSG_RGBA_PF;    break;
00572     default: pixelFormat = Image::OSG_INVALID_PF; break;
00573     }
00574     _image->set(pixelFormat, width, height);
00575     _imageDataPtr = _image->getData();
00576     _pLexer->expectImageInts(width * height);
00577 }
00578 
00579 void ScanParseSkel::addImagePixel(Int32 pixel)
00580 {
00581     switch (_image->getPixelFormat())
00582     {
00583     case Image::OSG_RGBA_PF:
00584         *_imageDataPtr++ = pixel >> 24;
00585         // Fall through
00586     case Image::OSG_RGB_PF:
00587         *_imageDataPtr++ = pixel >> 16;
00588         // Fall through
00589     case Image::OSG_LA_PF:
00590         *_imageDataPtr++ = pixel >> 8;
00591         // Fall through
00592     case Image::OSG_L_PF:
00593         *_imageDataPtr++ = pixel;
00594         // Fall through
00595     default:
00596         break;
00597     }
00598 }
00599 
00600 void ScanParseSkel::endImage()
00601 {
00602     _imageDataPtr = 0;
00603     addImageValue(_image);
00604     subRefCP(_image);
00605     _image = NullFC;
00606 }
00607 
00608 /*-------------------------------------------------------------------------*/
00609 /*                              cvs id's                                   */
00610 
00611 #ifdef __sgi
00612 #pragma set woff 1174
00613 #endif
00614 
00615 #ifdef OSG_LINUX_ICC
00616 #pragma warning( disable : 177 )
00617 #endif
00618 
00619 namespace
00620 {
00621     static Char8 cvsid_cpp[] = "@(#)$Id: $";
00622     static Char8 cvsid_hpp[] = OSGSCANPARSESKEL_HEADER_CVSID;
00623 }