configparser.y

最新osg包

/* -*-c++-*- Producer - Copyright (C) 2001-2004  Don Burns
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
 */


%{

#ifndef WIN32
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <fcntl.h>
#endif

#ifndef WIN32
#define SUPPORT_CPP 1
#endif

#include <stdio.h>
#include <fstream>
#include <string>

#include "FlexLexer.h"

#include <Producer/CameraConfig>


using namespace std;
using namespace Producer;

static void ConfigParser_error( const char * );
static CameraConfig *cfg = 0L;
static std::string fileName = "(stdin)";

static yyFlexLexer *flexer = 0L;

static int yylex()
{
    if( flexer == 0L )
        fprintf( stderr, "Internal error!\n" );
    return flexer->yylex();
}

%}

%token PRTOKEN_VISUAL
%token PRTOKEN_SET_SIMPLE
%token PRTOKEN_VISUAL_ID
%token PRTOKEN_BUFFER_SIZE
%token PRTOKEN_LEVEL      
%token PRTOKEN_RGBA               
%token PRTOKEN_DOUBLEBUFFER
%token PRTOKEN_STEREO      
%token PRTOKEN_AUX_BUFFERS 
%token PRTOKEN_RED_SIZE    
%token PRTOKEN_GREEN_SIZE  
%token PRTOKEN_BLUE_SIZE     
%token PRTOKEN_ALPHA_SIZE    
%token PRTOKEN_DEPTH_SIZE    
%token PRTOKEN_STENCIL_SIZE  
%token PRTOKEN_ACCUM_RED_SIZE      
%token PRTOKEN_ACCUM_GREEN_SIZE    
%token PRTOKEN_ACCUM_BLUE_SIZE     
%token PRTOKEN_ACCUM_ALPHA_SIZE    
%token PRTOKEN_ACCUM_ALPHA_SIZE    
%token PRTOKEN_SAMPLES
%token PRTOKEN_SAMPLE_BUFFERS    
%token PRTOKEN_RENDER_SURFACE
%token PRTOKEN_WINDOW_RECT
%token PRTOKEN_INPUT_RECT
%token PRTOKEN_HOSTNAME
%token PRTOKEN_DISPLAY
%token PRTOKEN_SCREEN
%token PRTOKEN_BORDER
%token PRTOKEN_DRAWABLE_TYPE
%token PRTOKEN_WINDOW_TYPE
%token PRTOKEN_PBUFFER_TYPE
%token PRTOKEN_CAMERA_GROUP
%token PRTOKEN_CAMERA
%token PRTOKEN_PROJECTION_RECT
%token PRTOKEN_LENS
%token PRTOKEN_FRUSTUM
%token PRTOKEN_PERSPECTIVE
%token PRTOKEN_ORTHO
%token PRTOKEN_OFFSET
%token PRTOKEN_ROTATE
%token PRTOKEN_TRANSLATE
%token PRTOKEN_SCALE
%token PRTOKEN_SHEAR
%token PRTOKEN_CLEAR_COLOR
%token PRTOKEN_INPUT_AREA
%token PRTOKEN_ERROR
%token PRTOKEN_INTEGER
%token PRTOKEN_HEX_INTEGER
%token PRTOKEN_FLOAT
%token PRTOKEN_TRUE
%token PRTOKEN_FALSE
%token PRTOKEN_QUOTED_STRING
%token PRTOKEN_STEREO_SYSTEM_COMMANDS
%token PRTOKEN_CUSTOM_FULL_SCREEN_RECTANGLE
%token PRTOKEN_METHOD
%token PRTOKEN_PREMULTIPLY
%token PRTOKEN_POSTMULTIPLY
%token PRTOKEN_OVERRIDE_REDIRECT
%token PRTOKEN_SHARELENS
%token PRTOKEN_SHAREVIEW
%token PRTOKEN_READ_DRAWABLE
%token PRTOKEN_SET_RTT_MODE
%token PRTOKEN_RTT_MODE_NONE
%token PRTOKEN_RTT_MODE_RGB
%token PRTOKEN_RTT_MODE_RGBA
%token PRTOKEN_THREAD_MODEL
%token PRTOKEN_SINGLE_THREADED
%token PRTOKEN_THREAD_PER_CAMERA
%token PRTOKEN_THREAD_PER_RENDER_SURFACE

%union {
    char * string;
    int    integer;
    float  real;
    bool boolean;
};

%type <string> name string;
%type <integer> intparam offset_multiply_method;
%type <integer> hex_integer;
%type <integer> drawableType rtt_mode;
%type <integer> threadModelDirective;
%type <real>    floatparam;
%type <real>    real;
%type <boolean> bool;

%%

config  : entries
	;

entries : entry | entries entry
	;

entry : visual | render_surface | camera | input_area | camera_group | stereo_param | system_params
	;

system_params : system_param | system_params system_param
    ;

system_param : 
        PRTOKEN_THREAD_MODEL threadModelDirective ';' 
        {
            Producer::CameraGroup::ThreadModel tm = (Producer::CameraGroup::ThreadModel)$2;
            cfg->setThreadModelDirective( tm );
        }
        ;

threadModelDirective:  
          PRTOKEN_SINGLE_THREADED               { $$ = CameraGroup::SingleThreaded; }
        | PRTOKEN_THREAD_PER_CAMERA             { $$ = CameraGroup::ThreadPerCamera; }
        | PRTOKEN_THREAD_PER_RENDER_SURFACE     { $$ = CameraGroup::ThreadPerRenderSurface; }
        ;

stereo_param : PRTOKEN_STEREO_SYSTEM_COMMANDS intparam string string ';'
        {
           cfg->addStereoSystemCommand( $2, $3, $4 );
        };


camera_group: PRTOKEN_CAMERA_GROUP '{' camera_group_attributes '}'
    ;

camera_group_attributes: cameras 
    ;

cameras :  /* null */ | camera | cameras camera
    ;

camera : PRTOKEN_CAMERA name 
	 {
	    cfg->beginCamera( $2 );
	 }
	'{' camera_attributes '}'
	 {
	    cfg->endCamera();
	 };

camera_attributes : camera_attribute | camera_attributes camera_attribute
 	;

camera_attribute :
	/* EMPTY */
	| PRTOKEN_RENDER_SURFACE name ';'
	{
	    cfg->setCameraRenderSurface( $2 );
	}
	| render_surface 
	{
	    cfg->setCameraRenderSurface();
	}
	| PRTOKEN_PROJECTION_RECT real real real real ';'
	{
	    cfg->setCameraProjectionRectangle( $2, $3, $4, $5 );
	}
	| PRTOKEN_SHARELENS bool ';'
	{
	    cfg->setCameraShareLens( $2 );
	}
    | PRTOKEN_SHAREVIEW bool ';'
    {
        cfg->setCameraShareView( $2 );
    }
    | PRTOKEN_CLEAR_COLOR real real real real ';'
    {
        cfg->setCameraClearColor( $2, $3, $4, $5 );
    }
	| lens 
	| camera_offset 
	;

camera_offset : PRTOKEN_OFFSET '{' 
	{
	    cfg->beginCameraOffset();
	}
		camera_offset_attributes '}'
	{
	    cfg->endCameraOffset();
	}
	;

camera_offset_attributes : camera_offset_attribute | camera_offset_attributes camera_offset_attribute
	;

camera_offset_attribute  :
	  PRTOKEN_SHEAR real real ';'
	  {
	    cfg->shearCameraOffset( $2, $3 );
	  }
	| PRTOKEN_ROTATE real real real real ';'
	  {
	    cfg->rotateCameraOffset( $2, $3, $4, $5 );
	  }
	| PRTOKEN_TRANSLATE real real real ';'
	  {
	    cfg->translateCameraOffset( $2, $3, $4 );
	  }
	| PRTOKEN_SCALE real real real ';'
	  {
	    cfg->scaleCameraOffset( $2, $3, $4 );
	  }
	| PRTOKEN_METHOD offset_multiply_method ';'
	  {
	    cfg->setCameraOffsetMultiplyMethod( (Producer::Camera::Offset::MultiplyMethod)$2 );
	  }
	;

offset_multiply_method: 
      PRTOKEN_PREMULTIPLY  { $$ = Producer::Camera::Offset::PreMultiply; }
    | PRTOKEN_POSTMULTIPLY { $$ = Producer::Camera::Offset::PostMultiply; }
    ;

lens : PRTOKEN_LENS '{' lens_attributes '}'
	;

lens_attributes : lens_attribute | lens_attributes lens_attribute
	;

lens_attribute :
	/* Empty */
	| PRTOKEN_ORTHO real real real real real real ';'
	  {
	      cfg->setCameraOrtho( $2, $3, $4, $5, $6, $7 );
	  }
	| PRTOKEN_ORTHO real real real real real real real real ';'
	  {
	      cfg->setCameraOrtho( $2, $3, $4, $5, $6, $7, $8, $9 );
	  }
	| PRTOKEN_PERSPECTIVE real real real real ';'
	  {
	      cfg->setCameraPerspective( $2, $3, $4, $5 );
	  }
	| PRTOKEN_PERSPECTIVE real real real real real real ';'
	  {
	      cfg->setCameraPerspective( $2, $3, $4, $5, $6, $7 );
	  }
	| PRTOKEN_FRUSTUM real real real real real real ';'
	  {
	      cfg->setCameraFrustum( $2, $3, $4, $5, $6, $7 );
	  }
	| PRTOKEN_FRUSTUM real real real real real real real real ';'
	  {
	      cfg->setCameraFrustum( $2, $3, $4, $5, $6, $7, $8, $9 );
	  }
	| PRTOKEN_SHEAR real real ';'
	  {
	      cfg->setCameraLensShear( $2, $3 );
	  }
	;

render_surface : PRTOKEN_RENDER_SURFACE name 
	 {
	     cfg->beginRenderSurface( $2 );
	 }
	 '{' render_surface_attributes '}'
	 {
	     cfg->endRenderSurface();
	 }
	;

render_surface_attributes : 
          render_surface_attribute 
        | render_surface_attributes render_surface_attribute
	;

render_surface_attribute :
	/* Empty */
	| PRTOKEN_VISUAL name ';'
	{
	    cfg->setRenderSurfaceVisualChooser( $2 );
	}
	| visual 
	{
	    cfg->setRenderSurfaceVisualChooser();
	}
	| PRTOKEN_WINDOW_RECT intparam  intparam  intparam  intparam ';'
	{
	    cfg->setRenderSurfaceWindowRectangle( $2, $3, $4, $5 );
	}
    | PRTOKEN_INPUT_RECT floatparam floatparam floatparam floatparam ';'
    {
        cfg->setRenderSurfaceInputRectangle( $2, $3, $4, $5 );
    }
	| PRTOKEN_HOSTNAME name ';'
	{
	    cfg->setRenderSurfaceHostName( std::string($2) );
	}
	| PRTOKEN_DISPLAY intparam ';'
	{
	    cfg->setRenderSurfaceDisplayNum( $2 );
	}
	| PRTOKEN_SCREEN intparam ';'
	{
	    cfg->setRenderSurfaceScreen( $2 );
	}
	| PRTOKEN_BORDER bool ';'
	{    
	    cfg->setRenderSurfaceBorder( $2 );
	}
    | PRTOKEN_CUSTOM_FULL_SCREEN_RECTANGLE intparam  intparam  intparam  intparam ';'
    {
        cfg->setRenderSurfaceCustomFullScreenRectangle( $2, $3, $4, $5 );
    }
    | PRTOKEN_OVERRIDE_REDIRECT bool ';'
    {
        cfg->setRenderSurfaceOverrideRedirect( $2 );
    }
    | PRTOKEN_DRAWABLE_TYPE drawableType ';' 
    {
        Producer::RenderSurface::DrawableType drawableType = (RenderSurface::DrawableType)$2;
        cfg->setRenderSurfaceDrawableType( drawableType );
    }
    | PRTOKEN_READ_DRAWABLE name ';'
    {
        cfg->setRenderSurfaceReadDrawable( $2 );
    }
    | PRTOKEN_SET_RTT_MODE rtt_mode ';'
    {
        cfg->setRenderSurfaceRenderToTextureMode( (Producer::RenderSurface::RenderToTextureMode)$2 );
    }
	;

drawableType: 
      PRTOKEN_WINDOW_TYPE   { $$ =  RenderSurface::DrawableType_Window; }
    | PRTOKEN_PBUFFER_TYPE  { $$ =  RenderSurface::DrawableType_PBuffer; }
    ;

rtt_mode : 
          PRTOKEN_RTT_MODE_NONE  { $$ = RenderSurface::RenderToTextureMode_None; }
        | PRTOKEN_RTT_MODE_RGB   { $$ = RenderSurface::RenderToRGBTexture; }
        | PRTOKEN_RTT_MODE_RGBA  { $$ = RenderSurface::RenderToRGBATexture; }
        ;


visual : PRTOKEN_VISUAL name 
	 {
	     cfg->beginVisual( $2 );
	 }
	'{' visual_attributes '}'
	 {
	     cfg->endVisual();
	 }

	 | PRTOKEN_VISUAL
	 {
	     cfg->beginVisual();
	 }
	'{' visual_attributes '}'
	 {
	     cfg->endVisual();
	 }
	 ;


visual_attributes : visual_attribute | visual_attributes ',' visual_attribute
	;
visual_attribute :
	  PRTOKEN_SET_SIMPLE 
	  {
	      cfg->setVisualSimpleConfiguration();
	  }
	| PRTOKEN_VISUAL_ID hex_integer
	  {
	      cfg->setVisualByID( $2 );
	  }

	| PRTOKEN_BUFFER_SIZE intparam 
	  {
	      cfg->addVisualAttribute( VisualChooser::BufferSize, $2 );
	  }
	| PRTOKEN_LEVEL intparam 
	  {
	      cfg->addVisualAttribute( VisualChooser::Level, $2 );
	  }

	| PRTOKEN_RGBA 
	  {
	      cfg->addVisualAttribute( VisualChooser::RGBA );
	  }
	| PRTOKEN_DOUBLEBUFFER         
	  {
	      cfg->addVisualAttribute( VisualChooser::DoubleBuffer );
	  }
	| PRTOKEN_STEREO               
	  {
	      cfg->addVisualAttribute( VisualChooser::Stereo );
	  }
	| PRTOKEN_AUX_BUFFERS intparam 
	  {
	      cfg->addVisualAttribute( VisualChooser::AuxBuffers, $2 );
	  }
	| PRTOKEN_RED_SIZE intparam             
	  {
	      cfg->addVisualAttribute( VisualChooser::RedSize, $2 );
	  }

	| PRTOKEN_GREEN_SIZE   intparam 
	  {
	      cfg->addVisualAttribute( VisualChooser::GreenSize, $2 );
	  }

	| PRTOKEN_BLUE_SIZE intparam 
	  {
	      cfg->addVisualAttribute( VisualChooser::BlueSize, $2 );
	  }
	| PRTOKEN_ALPHA_SIZE  intparam          
	  {
	      cfg->addVisualAttribute( VisualChooser::AlphaSize, $2 );
	  }
	| PRTOKEN_DEPTH_SIZE  intparam          
	  {
	      cfg->addVisualAttribute( VisualChooser::DepthSize, $2 );
	  }
	| PRTOKEN_STENCIL_SIZE  intparam        
	  {
	      cfg->addVisualAttribute( VisualChooser::StencilSize, $2 );
	  }
	| PRTOKEN_ACCUM_RED_SIZE  intparam      
	  {
	      cfg->addVisualAttribute( VisualChooser::AccumRedSize, $2 );
	  }
	| PRTOKEN_ACCUM_GREEN_SIZE  intparam    
	  {
	      cfg->addVisualAttribute( VisualChooser::AccumGreenSize, $2 );
	  }
	| PRTOKEN_ACCUM_BLUE_SIZE  intparam     
	  {
	      cfg->addVisualAttribute( VisualChooser::AccumBlueSize, $2 );
	  }
	| PRTOKEN_ACCUM_ALPHA_SIZE  intparam    
	  {
	      cfg->addVisualAttribute( VisualChooser::AccumAlphaSize, $2 );
	  }
	| PRTOKEN_SAMPLES  intparam    
	  {
	      cfg->addVisualAttribute( VisualChooser::Samples, $2 );
      }
	| PRTOKEN_SAMPLE_BUFFERS
	  {
	      cfg->addVisualAttribute( VisualChooser::SampleBuffers );
	  }
	| intparam intparam
	  {
	      cfg->addVisualExtendedAttribute( $1, $2 );
	  }
	  ;

input_area : PRTOKEN_INPUT_AREA 
			{ cfg->beginInputArea(); } 
			'{' input_area_entries '}'
			{ cfg->endInputArea(); } 
	;

input_area_entries : input_area_entry | input_area_entries input_area_entry
	;

input_area_entry : 
		PRTOKEN_RENDER_SURFACE name ';'
		{
			cfg->addInputAreaEntry( $2 );
		}
		;

real   : PRTOKEN_FLOAT
	{
	    $$ = atof(flexer->YYText());
	}
	| PRTOKEN_INTEGER
	{
	    $$ = atof(flexer->YYText());
	}
	;


floatparam : PRTOKEN_FLOAT
	{
	    $$ = atof(flexer->YYText());
	}
	;

intparam : PRTOKEN_INTEGER
	{
	    $$ = atoi( flexer->YYText() );
	}
	;

name : PRTOKEN_QUOTED_STRING
	{
	    $$ = strdup( flexer->YYText() );
	}
	;

string : PRTOKEN_QUOTED_STRING
	{
	    $$ = strdup( flexer->YYText() );
	}
	;


hex_integer : PRTOKEN_HEX_INTEGER
	{
	    int n;
	    sscanf( flexer->YYText(), "0x%x", &n );
	    $$ = n;
	}
	;

bool : PRTOKEN_TRUE { $$ = true;} | PRTOKEN_FALSE { $$ = false; }
	;

%%

static void yyerror( const char *errmsg )
{
    fprintf( stderr, 
    	"CameraConfig::parseFile(\"%s\") : %s - Line %d at or before \"%s\"\n",
		fileName.c_str(),
		errmsg, 
        flexer->lineno(),
        flexer->YYText() );
}

bool CameraConfig::parseFile( const std::string &file )
{
    fileName.clear();

    fileName = findFile(file);

    if( fileName.empty() )
    {
        fprintf( stderr, "CameraConfig::parseFile() - Can't find file \"%s\".\n", file.c_str() );
        return false;
    }

    bool retval = true;

#if defined (SUPPORT_CPP)

    char *cpp_path =
  #if defined(__APPLE__)
                "/usr/bin/cpp";
  #else
                "/lib/cpp";
  #endif

    if( access( cpp_path, X_OK ) == 0 )
    {

        int pd[2];
        pipe( pd );

        flexer = new yyFlexLexer;
        if( fork() == 0 )
        {
            // we don't want to read from the pipe in the child, so close it.
            close( pd[0] );
            close( 1 );
            dup( pd[1] );


            /* This was here to allow reading a config file from stdin.
             * This has never been directly supported, so commenting out.
            if( fileName.empty() )
                execlp( cpp_path, "cpp",  "-P", 0L );
            else
            */
            execlp( cpp_path, "cpp",  "-P", fileName.c_str(), 0L );

            // This should not execute unless an error happens
            perror( "execlp" );
        }
        else
        {
            close( pd[1]);
            close( 0 );
            dup( pd[0] );

            cfg = this;

            retval = ConfigParser_parse() == 0 ? true : false;

            // Wait on child process to finish
            int stat;
            wait( &stat );
        }
    }
    else
#endif
    {
        std::ifstream ifs(fileName.c_str());
        flexer = new yyFlexLexer(&ifs);
        cfg = this;
        retval = ConfigParser_parse() == 0 ? true : false;
        ifs.close();
        delete flexer;
    }
    return retval;
}