← Back to branch summary

~ubuntu-branches/ubuntu/warty/aqsis/warty

« back to all changes in this revision

Viewing changes to libslparse/scanner.lxx

  • Committer: Bazaar Package Importer
  • Author(s): LaMont Jones
  • Date: 2004-08-24 07:25:04 UTC
  • Revision ID: james.westby@ubuntu.com-20040824072504-zf993vnevvisdsvb
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
libslparse/scanner.lxx
 
1
/* -------------- declaration section -------------- */
 
2
 
 
3
 
 
4
%{
 
5
 
 
6
#include <iostream>
 
7
#include <fstream>
 
8
#include <string>
 
9
#include <vector>
 
10
 
 
11
#include "parsenode.h"
 
12
 
 
13
using namespace Aqsis;
 
14
 
 
15
#ifdef  WIN32
 
16
#include "parser.hpp"
 
17
#else
 
18
#ifdef AQSIS_SYSTEM_MACOSX
 
19
#include "parser.cpp.h"
 
20
#else
 
21
#include "parser.h"
 
22
#endif
 
23
#endif
 
24
 
 
25
#ifdef  WIN32
 
26
extern "C" TqInt isatty(TqInt);
 
27
#pragma warning(disable : 4786)
 
28
#endif
 
29
 
 
30
namespace Aqsis
 
31
{
 
32
 
 
33
extern std::istream* ParseInputStream;
 
34
extern CqString         ParseStreamName;        
 
35
extern TqInt ParseLineNumber;
 
36
 
 
37
extern TqBool   FindVariable(const char* name, SqVarRef& ref);
 
38
extern TqBool   FindFunction(const char* name, std::vector<SqFuncRef>& Ref);
 
39
extern CqString strNameSpace();
 
40
 
 
41
}
 
42
 
 
43
static TqInt scannerinput(char* Buffer, TqInt MaxSize);
 
44
#undef YY_INPUT
 
45
#define YY_INPUT(buffer, result, max_size) (result = scannerinput(buffer, max_size))
 
46
 
 
47
%}
 
48
 
 
49
D                       [0-9]
 
50
L                       [a-zA-Z_]
 
51
H                       [a-fA-F0-9]
 
52
E                       [Ee][+-]?{D}+
 
53
FS                      (f|F|l|L)
 
54
IS                      (u|U|l|L)*
 
55
LF                      (\r\n)|(\r)|(\n)|(\x0c)
 
56
WS                      [ \t\h]
 
57
hashline        #{WS}?(line|{D}+)
 
58
hash            #{WS}?((pragma)).*{LF}
 
59
string          \"(\\.|[^\\"])*\"
 
60
 
 
61
%{
 
62
#define YY_SKIP_YYWRAP
 
63
TqInt yywrap();
 
64
static TqInt check_type();
 
65
%}
 
66
 
 
67
%%
 
68
 
 
69
{LF}                    { ParseLineNumber+=+1; }
 
70
 
 
71
"break"                 { return(BREAK); }
 
72
"continue"              { return(CONTINUE); }
 
73
"else"                  { return(ELSE); }
 
74
"float"                 { return(TYPE_FLOAT); }
 
75
"point"                 { return(TYPE_POINT); }
 
76
"vector"                { return(TYPE_VECTOR); }
 
77
"normal"                { return(TYPE_NORMAL); }
 
78
"string"                { return(TYPE_STRING); }
 
79
"void"                  { return(TYPE_VOID); }
 
80
"matrix"                { return(TYPE_MATRIX); }
 
81
"color"                 { return(TYPE_COLOR); }
 
82
"for"                   { return(FOR); }
 
83
"if"                    { return(IF); }
 
84
"return"                { return(RETURN); }
 
85
"while"                 { return(WHILE); }
 
86
"uniform"               { return(TYPE_UNIFORM); }
 
87
"varying"               { return(TYPE_VARYING); }
 
88
"output"                { return(OUTPUT); }
 
89
"extern"                { return(EXTERN); }
 
90
"atmosphere"    { return(SHADER_TYPE_ATMOSPHERE); }
 
91
"surface"               { return(SHADER_TYPE_SURFACE); }
 
92
"volume"                { return(SHADER_TYPE_VOLUME); }
 
93
"displacement"  { return(SHADER_TYPE_DISPLACEMENT); }
 
94
"imager"                { return(SHADER_TYPE_IMAGER); }
 
95
"attribute"             { return(ATTRIBUTE);}
 
96
"option"                { return(OPTION);}
 
97
"rendererinfo"  { return(RENDERERINFO);}
 
98
"incident"              { return(INCIDENT);}
 
99
"opposite"              { return(OPPOSITE);}
 
100
"transformation" { return(SHADER_TYPE_TRANSFORMATION); }
 
101
"light"                 { return(SHADER_TYPE_LIGHT); }
 
102
"lightsource"   { return(LIGHTSOURCE); }
 
103
"illuminate"    { return(ILLUMINATE);}
 
104
"illuminance"   { return(ILLUMINANCE);}
 
105
"solar"                 { return(SOLAR);}
 
106
"texture"               { return(TEXTUREMAP);}
 
107
"environment"   { return(ENVIRONMENT);}
 
108
"bump"                  { return(BUMP);}
 
109
"shadow"                { return(SHADOW);}
 
110
"occlusion"             { return(OCCLUSION);}
 
111
"textureinfo"   { return(TEXTUREINFO);}
 
112
 
 
113
{hashline}.*{LF}        {
 
114
                                        // Find the start of the line no.
 
115
                                        TqInt i=0, ln=0;
 
116
                                        i=strcspn((char*)yytext, "0123456789");
 
117
                                        char* endptr;
 
118
                                        ln=strtol((char*)yytext+i, &endptr, 10);
 
119
                                        ParseLineNumber=ln;
 
120
                                        // Now check if there is a new filename specified.
 
121
                                        char* fname;
 
122
                                        if((fname=strchr(endptr, '\"'))!=0)
 
123
                                        {
 
124
                                                fname++;
 
125
                                                if((i=strcspn(fname, "\""))>0)
 
126
                                                {
 
127
                                                        CqString strfName(fname);
 
128
                                                        ParseStreamName=strfName.substr(0,i).c_str();
 
129
                                                }
 
130
                                        }
 
131
                                }
 
132
{hash}                  { ParseLineNumber+=1; }
 
133
 
 
134
{L}({L}|{D})*   { yylval.m_Identifier=new CqString((char*)yytext); return(check_type()); }
 
135
 
 
136
0[xX]{H}+{IS}?  { yylval.m_FloatConst=(TqFloat)atof((char*)yytext); return(FLOAT_CONSTANT); }
 
137
0{D}+{IS}?              { yylval.m_FloatConst=(TqFloat)atof((char*)yytext); return(FLOAT_CONSTANT); }
 
138
{D}+{IS}?               { yylval.m_FloatConst=(TqFloat)atof((char*)yytext); return(FLOAT_CONSTANT); }
 
139
'(\\.|[^\\'])+' { yylval.m_FloatConst=(TqFloat)atof((char*)yytext); return(FLOAT_CONSTANT); }
 
140
 
 
141
{D}+{E}{FS}?    { yylval.m_FloatConst=(TqFloat)atof((char*)yytext); return(FLOAT_CONSTANT); }
 
142
{D}*"."{D}+({E})?{FS}?  { yylval.m_FloatConst=(TqFloat)atof((char*)yytext); return(FLOAT_CONSTANT); }
 
143
{D}+"."{D}*({E})?{FS}?  { yylval.m_FloatConst=(TqFloat)atof((char*)yytext); return(FLOAT_CONSTANT); }
 
144
 
 
145
{string}                { 
 
146
                                        CqString strText((char*)yytext);
 
147
                                        yylval.m_Identifier=new CqString(strText.substr(1,strText.size()-2)); 
 
148
                                        return(STRING_LITERAL); 
 
149
                                }
 
150
 
 
151
"+="                    { return(ADD_ASSIGN); }
 
152
"-="                    { return(SUB_ASSIGN); }
 
153
"*="                    { return(MUL_ASSIGN); }
 
154
"/="                    { return(DIV_ASSIGN); }
 
155
"&&"                    { return(AND_OP); }
 
156
"||"                    { return(OR_OP); }
 
157
"<="                    { return(LE_OP); }
 
158
">="                    { return(GE_OP); }
 
159
"=="                    { return(EQ_OP); }
 
160
"!="                    { return(NE_OP); }
 
161
";"                             { return(';'); }
 
162
"{"                             { return('{'); }
 
163
"}"                             { return('}'); }
 
164
","                             { return(','); }
 
165
":"                             { return(':'); }
 
166
"="                             { return('='); }
 
167
"("                             { return('('); }
 
168
")"                             { return(')'); }
 
169
"["                             { return('['); }
 
170
"]"                             { return(']'); }
 
171
"."                             { return('.'); }
 
172
"&"                             { return('&'); }
 
173
"!"                             { return('!'); }
 
174
"~"                             { return('~'); }
 
175
"-"                             { return('-'); }
 
176
"+"                             { return('+'); }
 
177
"*"                             { return('*'); }
 
178
"/"                             { return('/'); }
 
179
"%"                             { return('%'); }
 
180
"<"                             { return('<'); }
 
181
">"                             { return('>'); }
 
182
"^"                             { return('^'); }
 
183
"|"                             { return('|'); }
 
184
"?"                             { return('?'); }
 
185
 
 
186
[ \t]           { }
 
187
.                       { /* ignore bad characters */ }
 
188
 
 
189
%%
 
190
 
 
191
TqInt yywrap()
 
192
{
 
193
        return(1);
 
194
}
 
195
 
 
196
 
 
197
TqInt check_type()
 
198
{
 
199
        // Check the type against known variables.
 
200
        TqInt Ret=IDENTIFIER;
 
201
        SqVarRef var;
 
202
        CqString strName(strNameSpace());
 
203
        strName+=(char*)yytext;
 
204
        
 
205
        yylval.m_pSymbol.eType=0;
 
206
 
 
207
        if(FindVariable(strName.c_str(), var))
 
208
        {
 
209
                yylval.m_pSymbol.VarRef=var;
 
210
                yylval.m_pSymbol.eType=1;
 
211
                Ret=SYMBOL;
 
212
        }
 
213
 
 
214
        // Check the type against global variables.
 
215
        strName=(char*)yytext;
 
216
        if(FindVariable(strName.c_str(), var))
 
217
        {
 
218
                yylval.m_pSymbol.VarRef=var;
 
219
                yylval.m_pSymbol.eType=1;
 
220
                Ret=SYMBOL;
 
221
        }
 
222
 
 
223
        // Check the type against known functions.
 
224
        std::vector<SqFuncRef> func;
 
225
        if(FindFunction((char*)yytext, func))
 
226
        {
 
227
                yylval.m_pSymbol.FuncRef=func[0];
 
228
                yylval.m_pSymbol.eType|=2;
 
229
                Ret=SYMBOL;
 
230
        }
 
231
 
 
232
        return(Ret);
 
233
}
 
234
 
 
235
static TqInt scannerinput(char* Buffer, TqInt MaxSize)
 
236
{
 
237
        // Sanity checks ...
 
238
        assert(ParseInputStream);
 
239
        assert(Buffer);
 
240
        assert(MaxSize);
 
241
 
 
242
        TqInt count = 0;
 
243
 
 
244
        if(!ParseInputStream->eof())
 
245
        {
 
246
                ParseInputStream->read(Buffer,MaxSize);
 
247
                count=ParseInputStream->gcount();
 
248
                ParseInputStream->clear(ParseInputStream->rdstate()&(~std::ios::failbit));
 
249
                if(ParseInputStream->bad())
 
250
                        count= -1;
 
251
        }
 
252
 
 
253
        return count;
 
254
}
 
255