fart/parser/parser.yy

%{
#include <stdio.h>
#include <iostream>
#include "main/Scene.h"
#include "main/Material.h"
#include "util/Vector.h"
#include "util/refptr.h"
#include "shapes/Shape.h"           /* includes all shape types */
using namespace std;

extern "C" {
    int yylex(void);
}

extern FILE * yyin;
extern char * yytext;

void yyerror(const char * str)
{
    fprintf(stderr, "error: %s\n", str);
}

int yywrap()
{
    return 1;
}

class Node
{
    public:
        Node();
        Node(int type, void * ptr);
        int type;
        void * ptr;
};

static Scene * g_scene;

#define YYSTYPE Node

%}

%token PLUS;
%token MINUS;
%token STAR;
%token DIVIDE;
%token MOD;

%token SEMICOLON;
%token COLON;
%token QUESTION;
%token DOLLAR;
%token DOT;
%token DQUOTE;
%token SQUOTE;
%token COMMA;

%token LCURLY;
%token RCURLY;
%token LBRACKET;
%token RBRACKET;
%token LPAREN;
%token RPAREN;
%token LESS;
%token GREATER;

%token DEC_NUMBER;
%token REAL_NUMBER;

%token BOX;
%token CAMERA;
%token COLOR;
%token HEIGHT;
%token INTERSECT;
%token LOOKAT;
%token MATERIAL;
%token MULTISAMPLE;
%token OPTIONS;
%token PLANE;
%token POSITION;
%token RADIUS;
%token REFLECTANCE;
%token SCENE;
%token SHININESS;
%token SIZE;
%token SPHERE;
%token SUBTRACT;
%token UNION;
%token UP;
%token VFOV;
%token WIDTH;

%%

scene: /* empty */
       | scene_spec { printf("Saw a scene\n"); }
       ;

boolean_items: shape shape boolean_items_more
             ;

boolean_items_more: /* empty */
                  | material boolean_items_more
                  ;

box: BOX LCURLY box_items RCURLY
   ;

box_items: shape_items
         | SIZE vector box_items
         ;

camera: CAMERA LCURLY camera_items RCURLY
      ;

camera_items: /* empty */
            | camera_item camera_items
            ;

camera_item: POSITION vector
           | LOOKAT vector
           | UP vector
           | VFOV vector
           ;

intersect: INTERSECT LCURLY boolean_items RCURLY
         ;

material: MATERIAL LCURLY material_items RCURLY
        ;

material_items: /* empty */
              | material_item material_items
              ;

material_item: COLOR vector
             | REFLECTANCE number
             | SHININESS number
             ;

number: DEC_NUMBER  {
            double * ptr = new double;
            *ptr = atoi(yytext);
            $$.ptr = ptr;
        }
      | REAL_NUMBER {
            double * ptr = new double;
            *ptr = atof(yytext);
            $$.ptr = ptr;
        }
      ;

plane: PLANE LCURLY plane_items RCURLY
     ;

plane_items: shape_items
           | POSITION vector COMMA number plane_items
           ;

scene_spec: SCENE LCURLY scene_items RCURLY
          ;

scene_items: /* empty */
           | scene_item scene_items
           ;

scene_item: camera
          | shape
          ;

shape: plane
     | sphere
     | box
     | union
     | intersect
     | subtract
     ;

shape_items: /* empty */
           | material
           ;

sphere: SPHERE LCURLY sphere_items RCURLY
      ;

sphere_items: shape_items
            | RADIUS number sphere_items
            ;

subtract: SUBTRACT LCURLY boolean_items RCURLY
        ;

union: UNION LCURLY boolean_items RCURLY
     ;

vector: LESS number COMMA number COMMA number GREATER {
            Vector * ptr = new Vector();
            (*ptr)[0] = * (double *) $2.ptr;
            (*ptr)[1] = * (double *) $4.ptr;
            (*ptr)[2] = * (double *) $6.ptr;
            $$.ptr = ptr;
            delete (double *) $2.ptr;
            delete (double *) $4.ptr;
            delete (double *) $6.ptr;
      }
      ;

%%

int parse(Scene * scene, const char * fileName)
{
    g_scene = scene;
    yyin = fopen(fileName, "r");
    if (yyin == NULL)
    {
        cerr << "Failed to open file '" << fileName << "'" << endl;
        return -1;
    }
    yyparse();
}

Node::Node()
{
    type = -1;
    ptr = NULL;
}

Node::Node(int type, void * ptr)
{
    this->type = type;
    this->ptr = ptr;
}