← Back to branch summary

~ubuntu-branches/ubuntu/quantal/aqsis/quantal

« back to all changes in this revision

Viewing changes to rib/rib2/scanner.ll

  • Committer: Bazaar Package Importer
  • Author(s): Fabrice Coutadeur
  • Date: 2009-08-06 04:53:26 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20090806045326-z6xeaaao62idxcc6
Tags: 1.6.0-0ubuntu1
* New upstream release
* debian/control:
  - changed name of lib package to libaqsis1 instead of aqsis-libsc2a
  - changed name of dev package to libaqsis-dev instead of aqsis-libs-dev
  - Added aqsis-data package
  - Revised summary text according to that specified by the RISpec (Pixar)
* Moved examples installation from aqsis.install to aqsis-data.install
* debian/rules: 
  - added content to binary-indep target
* debian/rules: added explicit name of mime file to force dh_installmime
  to generate postinst and prerm scripts

Show diffs side-by-side

added added

removed removed

Lines of Context:
rib/rib2/scanner.ll
1
 
/* -------------- declaration section -------------- */
2
 
 
3
 
%{
4
 
 
5
 
#ifdef  WIN32
6
 
extern "C" int isatty(int);
7
 
#pragma warning(disable : 4786)
8
 
#pragma warning(disable : 4102)
9
 
#endif
10
 
 
11
 
#include "aqsis.h"
12
 
 
13
 
#include <fstream>
14
 
#include <stack>
15
 
#include <string>
16
 
#include <vector>
17
 
#include <assert.h>
18
 
#include <stdio.h>
19
 
 
20
 
#include "libribtypes.h"
21
 
#include "parser.hpp"
22
 
 
23
 
#include "bdec.h"
24
 
 
25
 
namespace librib
26
 
{
27
 
 
28
 
extern FILE* ParseInputFile;
29
 
extern CqRibBinaryDecoder *BinaryDecoder;
30
 
extern unsigned int ParseLineNumber;
31
 
extern std::string ParseStreamName;
32
 
extern RtArchiveCallback pArchiveCallback;
33
 
 
34
 
bool fRequest;
35
 
bool fParams;
36
 
bool fSkipFrame;
37
 
 
38
 
}; // namespace librib
39
 
 
40
 
static std::stack<CqRibBinaryDecoder*> StreamStack;
41
 
static std::stack<YY_BUFFER_STATE> BufferStack;
42
 
static std::stack<std::string> StreamNameStack;
43
 
static std::stack<unsigned int> LineNumberStack;
44
 
 
45
 
#define YY_DECL int yylex( YYSTYPE *lvalp )
46
 
 
47
 
static int scannerinput(char* Buffer, int MaxSize);
48
 
#undef YY_INPUT
49
 
#define YY_INPUT(buffer, result, max_size) (result = scannerinput(buffer, max_size))
50
 
 
51
 
//#define YY_SKIP_YYWRAP
52
 
//static int yywrap();
53
 
 
54
 
%}
55
 
 
56
 
%option nounput
57
 
 
58
 
delim                           [ \t\\]
59
 
whitespace              {delim}+
60
 
letter                          [A-Za-z]
61
 
digit                                   [0-9]
62
 
float                           [+\-]?{digit}*(\.{digit}*)?([eE][+\-]?{digit}+)?
63
 
integer                 [+\-]?{digit}+
64
 
string                          \"[^"\n]*\"
65
 
eol                                     \r\n|\r|\n
66
 
comment                 #.*
67
 
array_start             \[
68
 
array_end               \]
69
 
 
70
 
%s params
71
 
%x incl skip_frame
72
 
 
73
 
/* %option lex-compat */
74
 
%option noreject
75
 
 
76
 
/* -------------- rules section -------------- */
77
 
 
78
 
%%
79
 
 
80
 
        if(fRequest)
81
 
        {
82
 
                BEGIN(INITIAL);
83
 
                fRequest=false;
84
 
        }
85
 
 
86
 
        if(fParams)
87
 
        {
88
 
                BEGIN(params);
89
 
                fParams=false;
90
 
        }
91
 
 
92
 
        if(fSkipFrame)
93
 
        {
94
 
                BEGIN(skip_frame);
95
 
                fSkipFrame=false;
96
 
        }
97
 
 
98
 
{comment}                       { 
99
 
                                                lvalp->stype = new char[strlen(yytext)+1]; strcpy(lvalp->stype, yytext); return COMMENT; 
100
 
                                        }
101
 
<*>{eol}                        { ParseLineNumber++; }
102
 
<*>{whitespace}         {  }
103
 
 
104
 
<skip_frame>FrameEnd    {BEGIN(INITIAL);}
105
 
<skip_frame>.
106
 
 
107
 
<params>{integer}               { lvalp->itype = atoi(yytext); return INTEGER_TOKEN; }
108
 
<params>{float}                 { lvalp->ftype = atof(yytext); return FLOAT_TOKEN; }
109
 
<params>{string}                { std::string temp(yytext); lvalp->stype = new char[temp.size()-1]; strcpy(lvalp->stype, temp.substr(1, temp.size()-2).c_str()); return STRING_TOKEN; }
110
 
<INITIAL>{integer}              { return INVALID_VALUE; }
111
 
<INITIAL>{float}                { return INVALID_VALUE; }
112
 
<INITIAL>{string}               { return INVALID_VALUE; }
113
 
<INITIAL>{array_start}  { return INVALID_VALUE; }
114
 
<INITIAL>{array_end}    { return INVALID_VALUE; }
115
 
 
116
 
AreaLightSource                 { return REQUEST_TOKEN_AREALIGHTSOURCE; }
117
 
Atmosphere                      { return REQUEST_TOKEN_ATMOSPHERE; }
118
 
Attribute                       { return REQUEST_TOKEN_ATTRIBUTE; }
119
 
AttributeBegin                  { return REQUEST_TOKEN_ATTRIBUTEBEGIN; }
120
 
AttributeEnd                    { return REQUEST_TOKEN_ATTRIBUTEEND; }
121
 
Basis                           { return REQUEST_TOKEN_BASIS; }
122
 
BesselFilter                    { return REQUEST_TOKEN_BESSELFILTER; }
123
 
Blobby                          { return REQUEST_TOKEN_BLOBBY; }
124
 
Bound                           { return REQUEST_TOKEN_BOUND; }
125
 
MitchellFilter                  { return REQUEST_TOKEN_MITCHELLFILTER; }
126
 
BoxFilter                       { return REQUEST_TOKEN_BOXFILTER; }
127
 
CatmullRomFilter                { return REQUEST_TOKEN_CATMULLROMFILTER; }
128
 
Clipping                        { return REQUEST_TOKEN_CLIPPING; }
129
 
Color                           { return REQUEST_TOKEN_COLOR; }
130
 
ColorSamples                    { return REQUEST_TOKEN_COLORSAMPLES; }
131
 
ConcatTransform                 { return REQUEST_TOKEN_CONCATTRANSFORM; }
132
 
Cone                            { return REQUEST_TOKEN_CONE; }
133
 
CoordSysTransform               { return REQUEST_TOKEN_COORDSYSTRANSFORM; }
134
 
CoordinateSystem                { return REQUEST_TOKEN_COORDINATESYSTEM; }
135
 
CropWindow                      { return REQUEST_TOKEN_CROPWINDOW; }
136
 
Curves                          { return REQUEST_TOKEN_CURVES; }
137
 
Cylinder                        { return REQUEST_TOKEN_CYLINDER; }
138
 
Declare                         { return REQUEST_TOKEN_DECLARE; }
139
 
Deformation                     { return REQUEST_TOKEN_DEFORMATION; }
140
 
DepthOfField                    { return REQUEST_TOKEN_DEPTHOFFIELD; }
141
 
Detail                          { return REQUEST_TOKEN_DETAIL; }
142
 
DetailRange                     { return REQUEST_TOKEN_DETAILRANGE; }
143
 
Disk                            { return REQUEST_TOKEN_DISK; }
144
 
DiskFilter                      { return REQUEST_TOKEN_DISKFILTER; }
145
 
Displacement                    { return REQUEST_TOKEN_DISPLACEMENT; }
146
 
Display                         { return REQUEST_TOKEN_DISPLAY; }
147
 
Else                            { return REQUEST_TOKEN_ELSE; }
148
 
ElseIf                          { return REQUEST_TOKEN_ELSEIF; }
149
 
ErrorHandler                    { return REQUEST_TOKEN_ERRORHANDLER; }
150
 
Exposure                        { return REQUEST_TOKEN_EXPOSURE; }
151
 
Exterior                        { return REQUEST_TOKEN_EXTERIOR; }
152
 
Format                          { return REQUEST_TOKEN_FORMAT; }
153
 
FrameAspectRatio                { return REQUEST_TOKEN_FRAMEASPECTRATIO; }
154
 
FrameBegin                      { return REQUEST_TOKEN_FRAMEBEGIN; }
155
 
FrameEnd                        { return REQUEST_TOKEN_FRAMEEND; }
156
 
GaussianFilter                  { return REQUEST_TOKEN_GAUSSIANFILTER; }
157
 
GeneralPolygon                  { return REQUEST_TOKEN_GENERALPOLYGON; }
158
 
GeometricApproximation          { return REQUEST_TOKEN_GEOMETRICAPPROXIMATION; }
159
 
Geometry                        { return REQUEST_TOKEN_GEOMETRY; }
160
 
Hider                           { return REQUEST_TOKEN_HIDER; }
161
 
Hyperboloid                     { return REQUEST_TOKEN_HYPERBOLOID; }
162
 
Identity                        { return REQUEST_TOKEN_IDENTITY; }
163
 
Illuminate                      { return REQUEST_TOKEN_ILLUMINATE; }
164
 
Imager                          { return REQUEST_TOKEN_IMAGER; }
165
 
Interior                        { return REQUEST_TOKEN_INTERIOR; }
166
 
IfBegin                         { return REQUEST_TOKEN_IFBEGIN; }
167
 
IfEnd                           { return REQUEST_TOKEN_IFEND; }
168
 
LightSource                     { return REQUEST_TOKEN_LIGHTSOURCE; }
169
 
MakeBump                        { return REQUEST_TOKEN_MAKEBUMP; }
170
 
MakeCubeFaceEnvironment         { return REQUEST_TOKEN_MAKECUBEFACEENVIRONMENT; }
171
 
MakeLatLongEnvironment          { return REQUEST_TOKEN_MAKELATLONGENVIRONMENT; }
172
 
MakeOcclusion                   { return REQUEST_TOKEN_MAKEOCCLUSION; }
173
 
MakeShadow                      { return REQUEST_TOKEN_MAKESHADOW; }
174
 
MakeTexture                     { return REQUEST_TOKEN_MAKETEXTURE; }
175
 
Matte                           { return REQUEST_TOKEN_MATTE; }
176
 
MotionBegin                     { return REQUEST_TOKEN_MOTIONBEGIN; }
177
 
MotionEnd                       { return REQUEST_TOKEN_MOTIONEND; }
178
 
NuPatch                         { return REQUEST_TOKEN_NUPATCH; }
179
 
ObjectBegin                     { return REQUEST_TOKEN_OBJECTBEGIN; }
180
 
ObjectEnd                       { return REQUEST_TOKEN_OBJECTEND; }
181
 
ObjectInstance                  { return REQUEST_TOKEN_OBJECTINSTANCE; }
182
 
Opacity                         { return REQUEST_TOKEN_OPACITY; }
183
 
Option                          { return REQUEST_TOKEN_OPTION; }
184
 
Orientation                     { return REQUEST_TOKEN_ORIENTATION; }
185
 
Paraboloid                      { return REQUEST_TOKEN_PARABOLOID; }
186
 
Patch                           { return REQUEST_TOKEN_PATCH; }
187
 
PatchMesh                       { return REQUEST_TOKEN_PATCHMESH; }
188
 
Perspective                     { return REQUEST_TOKEN_PERSPECTIVE; }
189
 
PixelFilter                     { return REQUEST_TOKEN_PIXELFILTER; }
190
 
PixelSamples                    { return REQUEST_TOKEN_PIXELSAMPLES; }
191
 
PixelVariance                   { return REQUEST_TOKEN_PIXELVARIANCE; }
192
 
Points                          { return REQUEST_TOKEN_POINTS; }
193
 
PointsGeneralPolygons           { return REQUEST_TOKEN_POINTSGENERALPOLYGONS; }
194
 
PointsPolygons                  { return REQUEST_TOKEN_POINTSPOLYGONS; }
195
 
Polygon                         { return REQUEST_TOKEN_POLYGON; }
196
 
Procedural                      { return REQUEST_TOKEN_PROCEDURAL; }
197
 
Projection                      { return REQUEST_TOKEN_PROJECTION; }
198
 
Quantize                        { return REQUEST_TOKEN_QUANTIZE; }
199
 
ReadArchive                     { return REQUEST_TOKEN_READARCHIVE; }
200
 
RelativeDetail                  { return REQUEST_TOKEN_RELATIVEDETAIL; }
201
 
ReverseOrientation              { return REQUEST_TOKEN_REVERSEORIENTATION; }
202
 
Rotate                          { return REQUEST_TOKEN_ROTATE; }
203
 
Scale                           { return REQUEST_TOKEN_SCALE; }
204
 
ScreenWindow                    { return REQUEST_TOKEN_SCREENWINDOW; }
205
 
ShadingInterpolation            { return REQUEST_TOKEN_SHADINGINTERPOLATION; }
206
 
ShadingRate                     { return REQUEST_TOKEN_SHADINGRATE; }
207
 
Shutter                         { return REQUEST_TOKEN_SHUTTER; }
208
 
Sides                           { return REQUEST_TOKEN_SIDES; }
209
 
SincFilter                      { return REQUEST_TOKEN_SINCFILTER; }
210
 
Skew                            { return REQUEST_TOKEN_SKEW; }
211
 
SolidBegin                      { return REQUEST_TOKEN_SOLIDBEGIN; }
212
 
SolidEnd                        { return REQUEST_TOKEN_SOLIDEND; }
213
 
Sphere                          { return REQUEST_TOKEN_SPHERE; }
214
 
SubdivisionMesh                 { return REQUEST_TOKEN_SUBDIVISIONMESH; }
215
 
Surface                         { return REQUEST_TOKEN_SURFACE; }
216
 
TextureCoordinates              { return REQUEST_TOKEN_TEXTURECOORDINATES; }
217
 
Torus                           { return REQUEST_TOKEN_TORUS; }
218
 
Transform                       { return REQUEST_TOKEN_TRANSFORM; }
219
 
TransformBegin                  { return REQUEST_TOKEN_TRANSFORMBEGIN; }
220
 
TransformEnd                    { return REQUEST_TOKEN_TRANSFORMEND; }
221
 
TransformPoints                 { return REQUEST_TOKEN_TRANSFORMPOINTS; }
222
 
Translate                       { return REQUEST_TOKEN_TRANSLATE; }
223
 
TriangleFilter                  { return REQUEST_TOKEN_TRIANGLEFILTER; }
224
 
TrimCurve                       { return REQUEST_TOKEN_TRIMCURVE; }
225
 
WorldBegin                      { return REQUEST_TOKEN_WORLDBEGIN; }
226
 
WorldEnd                        { return REQUEST_TOKEN_WORLDEND; }
227
 
ShaderLayer                     { return REQUEST_TOKEN_SHADERLAYER; }
228
 
ConnectShaderLayers { return REQUEST_TOKEN_CONNECTSHADERLAYERS; }
229
 
version                         { return REQUEST_TOKEN_VERSION; }
230
 
 
231
 
{letter}({letter}|{digit})*     { lvalp->stype = new char[strlen(yytext)+1]; strcpy(lvalp->stype, yytext); return UNKNOWN_TOKEN; }
232
 
.                               { return(yytext[0]); }
233
 
 
234
 
<<EOF>>                 {
235
 
                                yyterminate();
236
 
                                return EOF_TOKEN;
237
 
                        }
238
 
 
239
 
 
240
 
%%
241
 
 
242
 
/* -------------- code section -------------- */
243
 
 
244
 
int yywrap()
245
 
{
246
 
        return 1;
247
 
}
248
 
 
249
 
static int scannerinput(char* Buffer, int MaxSize)
250
 
{
251
 
        // Sanity checks ...
252
 
        assert(BinaryDecoder);
253
 
        assert(Buffer);
254
 
        assert(MaxSize);
255
 
 
256
 
        int count = 0;
257
 
        if(!BinaryDecoder->eof())
258
 
                count=BinaryDecoder->read(Buffer,MaxSize);
259
 
 
260
 
        return count;
261
 
}
262
 
 
263
 
struct yy_buffer_state* current_flex_buffer(void)
264
 
{
265
 
        return YY_CURRENT_BUFFER;
266
 
}