source: trunk/orbital/mesh.yy @ 1418 Tweet

/* $Id: parser.yy 48 2009-09-05 08:07:10Z tb $ -*- mode: c++ -*- */
/** \file parser.yy Contains the example Bison parser source */

%{ /*** C/C++ Declarations ***/
#if defined HAVE_CONFIG_H
#   include "config.h"
#endif

#include "core.h"
#include "loldebug.h"

using namespace lol;

#include "mesh.h"

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

%}

/*** yacc/bison Declarations ***/

/* Require bison 2.3 or later */
%require "2.3"

/* add debug output code to generated parser. disable this for release
 * versions. */
%debug

/* start symbol */
%start mesh_description

/* write out a header file containing the token defines */
%defines

/* use newer C++ skeleton file */
%skeleton "lalr1.cc"

/* namespace to enclose parser in */
%name-prefix="orbital"

/* set the parser's class identifier */
%define parser_class_name "MeshParser"

/* keep track of the current position within the input */
%locations
%initial-action
{
    // initialize the initial location object
    @$.begin.filename = @$.end.filename = &driver.streamname;
};

/* The driver is passed by reference to the parser and to the scanner. This
 * provides a simple but effective pure interface, not relying on global
 * variables. */
%parse-param { class Driver& driver }

/* verbose error messages */
%error-verbose

%union
{
    float fval;
    struct { float f0, f1, f2, f3, f4, f5, f6, f7; } args;
}

%token T_FLUSH T_INITRB T_FREERB

%token T_COLOR T_BGCOLOR

%token T_TRANSLATEX T_ROTATEX T_TAPERX T_SCALEX T_MIRRORX
%token T_TRANSLATEY T_ROTATEY T_TAPERY T_SCALEY T_MIRRORY
%token T_TRANSLATEZ T_ROTATEZ T_TAPERZ T_SCALEZ T_MIRRORZ
%token T_TRANSLATE T_SCALE

%token T_CYLINDER T_BOX T_SMOOTHCHAMFBOX T_FLATCHAMFBOX T_SPHERE T_STAR
%token T_EXPANDEDSTAR T_DISC T_TRIANGLE T_QUAD T_COG

%token T_END 0

%token <fval> NUMBER

%type <fval> number

%type <args> args1 args2 args3 args4 args5 args6 args7 args8

%{

#include "mesh-driver.h"
#include "mesh-scanner.h"

/* this "connects" the bison parser in the driver to the flex scanner class
 * object. it defines the yylex() function call to pull the next token from the
 * current lexer object of the driver context. */
#undef yylex
#define yylex driver.lexer->lex

%}

%% /*** Grammar Rules ***/

mesh_description:
    mesh_command_list T_END
    ;

mesh_command_list:
    mesh_command
  | mesh_command_list ',' mesh_command
    ;

mesh_command:
    rb_command
  | color_command
  | transform_command
  | primitive_command
    ;

rb_command:
    T_FLUSH    { driver.mesh.Flush(); }
  | T_INITRB   { driver.mesh.MeshConvert(); }
  | T_FREERB   { /* TODO */ }
    ;

color_command:
    T_COLOR args4   { driver.mesh.SetCurColor(vec4($2.f0, $2.f1, $2.f2, $2.f3)); }
  | T_BGCOLOR args4 { driver.mesh.SetCurColor2(vec4($2.f0, $2.f1, $2.f2, $2.f3)); }
    ;

transform_command:
    T_TRANSLATEX args1  { driver.mesh.Translate(vec3($2.f0, 0, 0)); }
  | T_TRANSLATEY args1  { driver.mesh.Translate(vec3(0, $2.f0, 0)); }
  | T_TRANSLATEZ args1  { driver.mesh.Translate(vec3(0, 0, $2.f0)); }
  | T_TRANSLATE args3   { driver.mesh.Translate(vec3($2.f0, $2.f1, $2.f2)); }
  | T_ROTATEX args1     { driver.mesh.RotateX($2.f0); }
  | T_ROTATEY args1     { driver.mesh.RotateY($2.f0); }
  | T_ROTATEZ args1     { driver.mesh.RotateZ($2.f0); }
  | T_TAPERX args3      { driver.mesh.TaperX($2.f0, $2.f1, $2.f2); }
  | T_TAPERY args3      { driver.mesh.TaperY($2.f0, $2.f1, $2.f2); }
  | T_TAPERZ args3      { driver.mesh.TaperZ($2.f0, $2.f1, $2.f2); }
  | T_SCALEX args1      { driver.mesh.Scale(vec3($2.f0, 0, 0)); }
  | T_SCALEY args1      { driver.mesh.Scale(vec3(0, $2.f0, 0)); }
  | T_SCALEZ args1      { driver.mesh.Scale(vec3(0, 0, $2.f0)); }
  | T_SCALE args3       { driver.mesh.Scale(vec3($2.f0, $2.f1, $2.f2)); }
  | T_MIRRORX           { driver.mesh.MirrorX(); }
  | T_MIRRORY           { driver.mesh.MirrorY(); }
  | T_MIRRORZ           { driver.mesh.MirrorZ(); }
    ;

primitive_command:
    T_CYLINDER args6       { driver.mesh.AppendCylinder((int)$2.f0, $2.f1,
                                                 $2.f2, $2.f3,
                                                 (int)$2.f4, (int)$2.f5); }
  | T_BOX args3            { driver.mesh.AppendBox(vec3($2.f0, $2.f1, $2.f2)); }
  | T_SMOOTHCHAMFBOX args4 { driver.mesh.AppendSmoothChamfBox(vec3($2.f0, $2.f1,
                                                            $2.f2), $2.f3); }
  | T_FLATCHAMFBOX args4   { driver.mesh.AppendFlatChamfBox(vec3($2.f0, $2.f1,
                                                          $2.f2), $2.f3); }
  | T_SPHERE args4         { driver.mesh.AppendSphere($2.f0,
                                               vec3($2.f1, $2.f2, $2.f3)); }
  | T_STAR args5           { driver.mesh.AppendStar((int)$2.f0, $2.f1, $2.f2,
                                             (int)$2.f3, (int)$2.f4); }
  | T_EXPANDEDSTAR args4   { driver.mesh.AppendExpandedStar((int)$2.f0, $2.f1,
                                                     $2.f2, $2.f3); }
  | T_DISC args3           { driver.mesh.AppendDisc((int)$2.f0, $2.f1, (int)$2.f2); }
  | T_TRIANGLE args2       { driver.mesh.AppendSimpleTriangle($2.f0, (int)$2.f1); }
  | T_QUAD args2           { driver.mesh.AppendSimpleQuad($2.f0, (int)$2.f1); }
  | T_COG args8            { driver.mesh.AppendCog((int)$2.f0, $2.f1, $2.f2, $2.f3,
                                            $2.f4, $2.f5, $2.f6, (int)$2.f7); }
    ;

args1: number { $$.f0 = $1; } ;
args2: args1 ',' number { $$ = $1; $$.f1 = $3; } ;
args3: args2 ',' number { $$ = $1; $$.f2 = $3; } ;
args4: args3 ',' number { $$ = $1; $$.f3 = $3; } ;
args5: args4 ',' number { $$ = $1; $$.f4 = $3; } ;
args6: args5 ',' number { $$ = $1; $$.f5 = $3; } ;
args7: args6 ',' number { $$ = $1; $$.f6 = $3; } ;
args8: args7 ',' number { $$ = $1; $$.f7 = $3; } ;

number:
    NUMBER       { $$ = $1; }
  | '-' number   { $$ = -$2; }
    ;

%% /*** Additional Code ***/

void orbital::MeshParser::error(const MeshParser::location_type& l,
                                const std::string& m)
{
    driver.error(l, m);
}