tenebrae/tenebrae2
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Nv parse (used to parse register combiner state out of file)

Browse source
This commit is contained in:
cholleme 2003-02-03 14:18:50 +00:00
parent f867791fd3
commit 03727ab085
20 changed files with 6749 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2450
nvparse/_rc1.0_lexer.cpp Normal file
View file

File diff suppressed because it is too large Load diff

1872
nvparse/_rc1.0_parser.cpp Normal file
View file

File diff suppressed because it is too large Load diff

54
nvparse/_rc1.0_parser.h Normal file
View file

@ -0,0 +1,54 @@
typedef union {
int ival;
float fval;
RegisterEnum registerEnum;
BiasScaleEnum biasScaleEnum;
MappedRegisterStruct mappedRegisterStruct;
ConstColorStruct constColorStruct;
GeneralPortionStruct generalPortionStruct;
GeneralFunctionStruct generalFunctionStruct;
OpStruct opStruct;
GeneralCombinerStruct generalCombinerStruct;
GeneralCombinersStruct generalCombinersStruct;
FinalProductStruct finalProductStruct;
FinalRgbFunctionStruct finalRgbFunctionStruct;
FinalAlphaFunctionStruct finalAlphaFunctionStruct;
FinalCombinerStruct finalCombinerStruct;
CombinersStruct combinersStruct;
} YYSTYPE;
#define regVariable 257
#define constVariable 258
#define color_sum 259
#define final_product 260
#define expandString 261
#define halfBiasString 262
#define unsignedString 263
#define unsignedInvertString 264
#define muxString 265
#define sumString 266
#define rgb_portion 267
#define alpha_portion 268
#define openParen 269
#define closeParen 270
#define openBracket 271
#define closeBracket 272
#define semicolon 273
#define comma 274
#define dot 275
#define times 276
#define minus 277
#define equals 278
#define plus 279
#define bias_by_negative_one_half_scale_by_two 280
#define bias_by_negative_one_half 281
#define scale_by_one_half 282
#define scale_by_two 283
#define scale_by_four 284
#define clamp_color_sum 285
#define lerp 286
#define fragment_rgb 287
#define fragment_alpha 288
#define floatValue 289
extern YYSTYPE rc10_lval;

77
nvparse/nvparse.cpp Normal file
View file

@ -0,0 +1,77 @@
#ifdef _WIN32
# include <windows.h>
#else
#include <stdarg.h>
#define strnicmp strncasecmp
#endif
#include <stdio.h>
#include <GL/glu.h>
#include <string>
#include <vector>
#include "nvparse_errors.h"
#include "nvparse.h"
//void yyinit(char*);
//int yyparse(void);
// RC1.0 -- register combiners 1.0 configuration
bool rc10_init(char *);
int rc10_parse();
bool is_rc10(const char *);
nvparse_errors errors;
int line_number;
char * myin = 0;
void nvparse(const char * input_string, int argc /* = 0 */,...)
{
if (NULL == input_string)
{
errors.set("NULL string passed to nvparse");
return;
}
char * instring = strdup(input_string);
// register combiners (1 and 2)
if(is_rc10(instring))
{
if(rc10_init(instring))
{
rc10_parse();
}
}
else
{
errors.set("invalid string.\n \
first characters must be: !!VP1.0 or !!VSP1.0 or !!RC1.0 or !!TS1.0\n \
or it must be a valid DirectX 8.0 Vertex Shader");
}
free(instring);
}
char * const * const nvparse_get_errors()
{
return errors.get_errors();
}
char * const * const nvparse_print_errors(FILE * errfp)
{
for (char * const * ep = nvparse_get_errors(); *ep; ep++)
{
const char * errstr = *ep;
fprintf(errfp, "%s\n", errstr);
}
return nvparse_get_errors();
}
const int* nvparse_get_info(const char* input_string, int* pcount)
{
return 0;
}

22
nvparse/nvparse.h Normal file
View file

@ -0,0 +1,22 @@
#ifndef NVPARSE_H
#define NVPARSE_H
#define NVPARSE 1
#include <stdio.h>
#ifdef __cplusplus
extern "C" {
#endif
void nvparse(const char * input_string, int argc,...);
char * const * const nvparse_get_errors();
char * const * const nvparse_print_errors(FILE *fp);
const int* nvparse_get_info(const char* input_string, int* pcount);
#ifdef __cplusplus
}
#endif
#endif

BIN
nvparse/nvparse.lib Normal file
View file

Binary file not shown.

148
nvparse/nvparse/nvparse.dsp Normal file
View file

@ -0,0 +1,148 @@
# Microsoft Developer Studio Project File - Name="nvparse" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Static Library" 0x0104
CFG=nvparse - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "nvparse.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "nvparse.mak" CFG="nvparse - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "nvparse - Win32 Release" (based on "Win32 (x86) Static Library")
!MESSAGE "nvparse - Win32 Debug" (based on "Win32 (x86) Static Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "nvparse - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD BASE RSC /l 0x813 /d "NDEBUG"
# ADD RSC /l 0x813 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo
!ELSEIF "$(CFG)" == "nvparse - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
# ADD BASE RSC /l 0x813 /d "_DEBUG"
# ADD RSC /l 0x813 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo
!ENDIF
# Begin Target
# Name "nvparse - Win32 Release"
# Name "nvparse - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=..\_rc1.0_lexer.cpp
# End Source File
# Begin Source File
SOURCE=..\_rc1.0_parser.cpp
# End Source File
# Begin Source File
SOURCE=..\nvparse.cpp
# End Source File
# Begin Source File
SOURCE=..\nvparse_errors.cpp
# End Source File
# Begin Source File
SOURCE=..\rc1.0_combiners.cpp
# End Source File
# Begin Source File
SOURCE=..\rc1.0_final.cpp
# End Source File
# Begin Source File
SOURCE=..\rc1.0_general.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=..\_rc1.0_parser.h
# End Source File
# Begin Source File
SOURCE=..\nvparse_errors.h
# End Source File
# Begin Source File
SOURCE=..\nvparse_externs.h
# End Source File
# Begin Source File
SOURCE=..\rc1.0_combiners.h
# End Source File
# Begin Source File
SOURCE=..\rc1.0_final.h
# End Source File
# Begin Source File
SOURCE=..\rc1.0_general.h
# End Source File
# Begin Source File
SOURCE=..\rc1.0_register.h
# End Source File
# End Group
# End Target
# End Project

16
nvparse/nvparse/nvparse.plg Normal file
View file

@ -0,0 +1,16 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: nvparse - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
nvparse.lib - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

47
nvparse/nvparse_errors.cpp Normal file
View file

@ -0,0 +1,47 @@
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include "nvparse_errors.h"
nvparse_errors::nvparse_errors()
{
num_errors = 0;
reset();
}
nvparse_errors::~nvparse_errors()
{
reset();
}
void nvparse_errors::reset()
{
for(int i=0; i < num_errors; i++)
free(elist[i]);//FIXME detail_nmap something is writing 0x2 to elist[1] blah!
for(int j=0; j <= NVPARSE_MAX_ERRORS; j++)
elist[j] = 0;
num_errors = 0;
}
void nvparse_errors::set(const char * e)
{
if(num_errors < NVPARSE_MAX_ERRORS)
elist[num_errors++] = strdup(e);
}
void nvparse_errors::set(const char * e, int line_number)
{
char buff[256];
sprintf(buff, "error on line %d: %s", line_number, e);
if(num_errors < NVPARSE_MAX_ERRORS)
elist[num_errors++] = strdup(buff);
}
char * const * const nvparse_errors::get_errors()
{
return elist;
}

25
nvparse/nvparse_errors.h Normal file
View file

@ -0,0 +1,25 @@
#ifndef _NVPARSE_ERRORS_H_
#define _NVPARSE_ERRORS_H_
#ifdef _WIN32
#pragma warning(disable:4786) // stupid symbol size limitation
#endif
#define NVPARSE_MAX_ERRORS 32
class nvparse_errors
{
public:
nvparse_errors();
~nvparse_errors();
void reset();
void set(const char * e);
void set(const char * e, int line_number);
char * const * const get_errors();
inline int get_num_errors() { return num_errors; }
private:
char* elist [NVPARSE_MAX_ERRORS+1];
int num_errors;
};
#endif

9
nvparse/nvparse_externs.h Normal file
View file

@ -0,0 +1,9 @@
#ifndef NVPARSE_EXTERNS_H
#define NVPARSE_EXTERNS_H
extern nvparse_errors errors;
extern int line_number;
extern char * myin;
#endif

91
nvparse/rc1.0_combiners.cpp Normal file
View file

@ -0,0 +1,91 @@
#include "../glNV.h"
#include "rc1.0_combiners.h"
#include "nvparse_errors.h"
#include "nvparse_externs.h"
void CombinersStruct::Validate()
{
if (2 == numConsts &&
cc[0].reg.bits.name == cc[1].reg.bits.name)
errors.set("global constant set twice");
generals.Validate(numConsts, &cc[0]);
final.Validate();
}
void CombinersStruct::Invoke()
{
for (int i = 0; i < numConsts; i++)
qglCombinerParameterfvNV(cc[i].reg.bits.name, &(cc[i].v[0]));
generals.Invoke();
final.Invoke();
}
bool is_rc10(const char * s)
{
return ! strncmp(s, "!!RC1.0", 7);
}
bool rc10_init_more()
{
bool rcinit = false;
if(rcinit == false)
{
//FIXME; check extension availabe
rcinit = true;
/*
if(! glh_init_extensions("GL_NV_register_combiners"))
{
errors.set("unable to initialize GL_NV_register_combiners\n");
return false;
}
else
{
rcinit = true;
}
*/
}
bool rc2init = false;
if(rc2init == false)
{
//glh_init_extensions("GL_NV_register_combiners2");
// Don't fail if this doesn't initialize.
// We will run even if it doesn't exist.
rc2init = true;
}
errors.reset();
line_number = 1;
return true;
}
/*
else if(!strncmp(instring, "!!RC1.0", 7))
{
if(glCombinerParameterfvNV == 0)
{
if(! glh_init_extensions("GL_NV_register_combiners"))
{
errors.set("unable to initialize GL_NV_register_combiners\n");
free(instring);
return;
}
}
if(glCombinerStageParameterfvNV == 0)
{
glh_init_extensions("GL_NV_register_combiners2");
// Don't fail if this doesn't initialize.
// We will run even if it doesn't exist.
}
errors.reset();
line_number = 1;
rc10_init(instring+7);
rc10_parse();
}
*/

24
nvparse/rc1.0_combiners.h Normal file
View file

@ -0,0 +1,24 @@
#ifndef _RC10_COMBINERS_H
#define _RC10_COMBINERS_H
#include "rc1.0_general.h"
#include "rc1.0_final.h"
class CombinersStruct {
public:
void Init(GeneralCombinersStruct _gcs, FinalCombinerStruct _fc, ConstColorStruct _cc0, ConstColorStruct _cc1)
{ generals = _gcs; final = _fc; cc[0] = _cc0; cc[1] = _cc1; numConsts = 2;}
void Init(GeneralCombinersStruct _gcs, FinalCombinerStruct _fc, ConstColorStruct _cc0)
{ generals = _gcs; final = _fc; cc[0] = _cc0; numConsts = 1;}
void Init(GeneralCombinersStruct _gcs, FinalCombinerStruct _fc)
{ generals = _gcs; final = _fc; numConsts = 0;}
void Validate();
void Invoke();
private:
GeneralCombinersStruct generals;
FinalCombinerStruct final;
ConstColorStruct cc[2];
int numConsts;
};
#endif

160
nvparse/rc1.0_final.cpp Normal file
View file

@ -0,0 +1,160 @@
//#include <glh_extensions.h>
#include "../glNV.h"
#include "rc1.0_final.h"
#include "nvparse_errors.h"
#include "nvparse_externs.h"
void FinalRgbFunctionStruct::ZeroOut()
{
RegisterEnum zero;
zero.word = RCP_ZERO;
a.Init(zero, GL_UNSIGNED_IDENTITY_NV);
b.Init(zero, GL_UNSIGNED_IDENTITY_NV);
c.Init(zero, GL_UNSIGNED_IDENTITY_NV);
d.Init(zero, GL_UNSIGNED_IDENTITY_NV);
}
void FinalAlphaFunctionStruct::ZeroOut()
{
RegisterEnum zero;
zero.word = RCP_ZERO;
g.Init(zero, GL_UNSIGNED_IDENTITY_NV);
}
void FinalProductStruct::ZeroOut()
{
RegisterEnum zero;
zero.word = RCP_ZERO;
e.Init(zero, GL_UNSIGNED_IDENTITY_NV);
f.Init(zero, GL_UNSIGNED_IDENTITY_NV);
}
void FinalCombinerStruct::Validate()
{
if (hasProduct &&
(GL_E_TIMES_F_NV == product.e.reg.bits.name ||
GL_SPARE0_PLUS_SECONDARY_COLOR_NV == product.e.reg.bits.name ||
GL_DISCARD_NV == product.e.reg.bits.name ||
GL_E_TIMES_F_NV == product.f.reg.bits.name ||
GL_SPARE0_PLUS_SECONDARY_COLOR_NV == product.f.reg.bits.name ||
GL_DISCARD_NV == product.f.reg.bits.name))
errors.set("invalid input register for final_product");
if (hasProduct &&
(RCP_BLUE == product.e.reg.bits.channel ||
RCP_BLUE == product.f.reg.bits.channel))
errors.set("blue register used in final_product");
if (GL_E_TIMES_F_NV == alpha.g.reg.bits.name ||
GL_SPARE0_PLUS_SECONDARY_COLOR_NV == alpha.g.reg.bits.name ||
GL_DISCARD_NV == alpha.g.reg.bits.name)
errors.set("invalid input register for final alpha");
if (RCP_RGB == alpha.g.reg.bits.channel)
errors.set("rgb register used in final alpha");
if (GL_SPARE0_PLUS_SECONDARY_COLOR_NV == rgb.a.reg.bits.name &&
GL_SPARE0_PLUS_SECONDARY_COLOR_NV != rgb.b.reg.bits.name &&
GL_ZERO == rgb.c.reg.bits.name && GL_UNSIGNED_IDENTITY_NV == rgb.c.map)
{
MappedRegisterStruct temp;
temp = rgb.a;
rgb.a = rgb.b;
rgb.b = temp;
}
if (GL_SPARE0_PLUS_SECONDARY_COLOR_NV == rgb.a.reg.bits.name &&
GL_ZERO == rgb.b.reg.bits.name && GL_UNSIGNED_INVERT_NV == rgb.b.map &&
GL_ZERO == rgb.c.reg.bits.name && GL_UNSIGNED_IDENTITY_NV == rgb.c.map &&
GL_SPARE0_PLUS_SECONDARY_COLOR_NV != rgb.d.reg.bits.name)
{
MappedRegisterStruct temp;
temp = rgb.a;
rgb.a = rgb.d;
rgb.d = temp;
}
if (GL_SPARE0_PLUS_SECONDARY_COLOR_NV == rgb.a.reg.bits.name ||
GL_DISCARD_NV == rgb.a.reg.bits.name ||
GL_DISCARD_NV == rgb.b.reg.bits.name ||
GL_DISCARD_NV == rgb.c.reg.bits.name ||
GL_DISCARD_NV == rgb.d.reg.bits.name)
errors.set("invalid input register for final rgb");
if (RCP_BLUE == rgb.a.reg.bits.channel ||
RCP_BLUE == rgb.b.reg.bits.channel ||
RCP_BLUE == rgb.c.reg.bits.channel ||
RCP_BLUE == rgb.d.reg.bits.channel)
errors.set("blue register used in final rgb");
if ((GL_E_TIMES_F_NV == rgb.a.reg.bits.name ||
GL_E_TIMES_F_NV == rgb.b.reg.bits.name ||
GL_E_TIMES_F_NV == rgb.c.reg.bits.name ||
GL_E_TIMES_F_NV == rgb.d.reg.bits.name) && !hasProduct)
errors.set("final_product used but not set");
if (RCP_NONE == rgb.a.reg.bits.channel)
rgb.a.reg.bits.channel = RCP_RGB;
if (RCP_NONE == rgb.b.reg.bits.channel)
rgb.b.reg.bits.channel = RCP_RGB;
if (RCP_NONE == rgb.c.reg.bits.channel)
rgb.c.reg.bits.channel = RCP_RGB;
if (RCP_NONE == rgb.d.reg.bits.channel)
rgb.d.reg.bits.channel = RCP_RGB;
if (RCP_NONE == product.e.reg.bits.channel)
product.e.reg.bits.channel = RCP_RGB;
if (RCP_NONE == product.f.reg.bits.channel)
product.f.reg.bits.channel = RCP_RGB;
if (RCP_NONE == alpha.g.reg.bits.channel)
alpha.g.reg.bits.channel = RCP_ALPHA;
}
void FinalCombinerStruct::Invoke()
{
if(clamp)
qglCombinerParameteriNV(GL_COLOR_SUM_CLAMP_NV, GL_TRUE);
else
qglCombinerParameteriNV(GL_COLOR_SUM_CLAMP_NV, GL_FALSE);
qglFinalCombinerInputNV(
GL_VARIABLE_A_NV,
rgb.a.reg.bits.name,
rgb.a.map,
MAP_CHANNEL(rgb.a.reg.bits.channel));
qglFinalCombinerInputNV(
GL_VARIABLE_B_NV,
rgb.b.reg.bits.name,
rgb.b.map,
MAP_CHANNEL(rgb.b.reg.bits.channel));
qglFinalCombinerInputNV(
GL_VARIABLE_C_NV,
rgb.c.reg.bits.name,
rgb.c.map,
MAP_CHANNEL(rgb.c.reg.bits.channel));
qglFinalCombinerInputNV(
GL_VARIABLE_D_NV,
rgb.d.reg.bits.name,
rgb.d.map,
MAP_CHANNEL(rgb.d.reg.bits.channel));
qglFinalCombinerInputNV(
GL_VARIABLE_E_NV,
product.e.reg.bits.name,
product.e.map,
MAP_CHANNEL(product.e.reg.bits.channel));
qglFinalCombinerInputNV(
GL_VARIABLE_F_NV,
product.f.reg.bits.name,
product.f.map,
MAP_CHANNEL(product.f.reg.bits.channel));
qglFinalCombinerInputNV(
GL_VARIABLE_G_NV,
alpha.g.reg.bits.name,
alpha.g.map,
MAP_CHANNEL(alpha.g.reg.bits.channel));
}

48
nvparse/rc1.0_final.h Normal file
View file

@ -0,0 +1,48 @@
#ifndef _RC10_FINAL_H
#define _RC10_FINAL_H
#include "rc1.0_register.h"
class FinalAlphaFunctionStruct {
public:
void Init(MappedRegisterStruct _g) { g = _g; }
void ZeroOut();
MappedRegisterStruct g;
};
class FinalRgbFunctionStruct {
public:
void Init(MappedRegisterStruct _a, MappedRegisterStruct _b, MappedRegisterStruct _c, MappedRegisterStruct _d)
{ a = _a; b = _b; c = _c; d = _d; }
void ZeroOut();
MappedRegisterStruct a;
MappedRegisterStruct b;
MappedRegisterStruct c;
MappedRegisterStruct d;
};
class FinalProductStruct {
public:
void Init(MappedRegisterStruct _e, MappedRegisterStruct _f) { e = _e; f = _f; }
void ZeroOut();
MappedRegisterStruct e;
MappedRegisterStruct f;
};
class FinalCombinerStruct {
public:
void Init(FinalRgbFunctionStruct _rgb, FinalAlphaFunctionStruct _alpha, int _clamp, FinalProductStruct _product)
{ rgb = _rgb; alpha = _alpha; clamp = _clamp; product = _product; hasProduct = true;}
void Init(FinalRgbFunctionStruct _rgb, FinalAlphaFunctionStruct _alpha, int _clamp)
{ rgb = _rgb; alpha = _alpha; clamp = _clamp; hasProduct = false; product.ZeroOut();}
int hasProduct;
FinalProductStruct product;
int clamp;
FinalRgbFunctionStruct rgb;
FinalAlphaFunctionStruct alpha;
void Validate();
void Invoke();
};
#endif

300
nvparse/rc1.0_general.cpp Normal file
View file

@ -0,0 +1,300 @@
#include "../glNV.h"
#include <cstdio>
#include "rc1.0_general.h"
#include "nvparse_errors.h"
#include "nvparse_externs.h"
void GeneralCombinersStruct::Validate(int numConsts, ConstColorStruct *pcc)
{
GLint maxGCs;
glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &maxGCs);
if (num > maxGCs) {
char buffer[256];
sprintf(buffer, "%d general combiners specified, only %d supported", num, maxGCs);
errors.set(buffer);
num = maxGCs;
}
if (0 == num) {
// Setup a "fake" general combiner 0
general[0].ZeroOut();
num = 1;
}
localConsts = 0;
int i;
for (i = 0; i < num; i++)
localConsts += general[i].numConsts;
if (localConsts > 0)
if (NULL == qglCombinerStageParameterfvNV)
errors.set("local constant(s) specified, but not supported -- ignored");
else
for (i = 0; i < num; i++)
general[i].SetUnusedLocalConsts(numConsts, pcc);
for (i = 0; i < num; i++)
general[i].Validate(i);
for (; i < maxGCs; i++)
general[i].ZeroOut();
}
void GeneralCombinersStruct::Invoke()
{
qglCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, num);
int i;
for (i = 0; i < num; i++)
general[i].Invoke(i);
if (NULL != qglCombinerStageParameterfvNV) {
if (localConsts > 0)
glEnable(GL_PER_STAGE_CONSTANTS_NV);
else
glDisable(GL_PER_STAGE_CONSTANTS_NV);
}
}
void GeneralCombinerStruct::ZeroOut()
{
numPortions = 2;
numConsts = 0;
portion[0].ZeroOut();
portion[0].designator = RCP_RGB;
portion[1].ZeroOut();
portion[1].designator = RCP_ALPHA;
}
void GeneralCombinerStruct::SetUnusedLocalConsts(int numGlobalConsts, ConstColorStruct *globalCCs)
{
int i;
for (i = 0; i < numGlobalConsts; i++) {
bool constUsed = false;
int j;
for (j = 0; j < numConsts; j++)
constUsed |= (cc[j].reg.bits.name == globalCCs[i].reg.bits.name);
if (!constUsed)
cc[numConsts++] = globalCCs[i];
}
}
void GeneralCombinerStruct::Validate(int stage)
{
if (2 == numConsts &&
cc[0].reg.bits.name == cc[1].reg.bits.name)
errors.set("local constant set twice");
switch (numPortions)
{
case 0:
portion[0].designator = RCP_RGB;
// Fallthru
case 1:
portion[1].designator = ((RCP_RGB == portion[0].designator) ? RCP_ALPHA : RCP_RGB);
// Fallthru
case 2:
if (portion[0].designator == portion[1].designator)
errors.set("portion declared twice");
break;
}
int i;
for (i = 0; i < numPortions; i++)
portion[i].Validate(stage);
for (; i < 2; i++)
portion[i].ZeroOut();
}
void GeneralCombinerStruct::Invoke(int stage)
{
int i;
if (NULL != qglCombinerStageParameterfvNV)
for (i = 0; i < numConsts; i++)
qglCombinerStageParameterfvNV(GL_COMBINER0_NV + stage, cc[i].reg.bits.name, &(cc[i].v[0]));
for (i = 0; i < 2; i++)
portion[i].Invoke(stage);
}
void GeneralPortionStruct::Validate(int stage)
{
gf.Validate(stage, designator);
}
void GeneralPortionStruct::Invoke(int stage)
{
gf.Invoke(stage, designator, bs);
}
void GeneralPortionStruct::ZeroOut()
{
gf.ZeroOut();
bs.word = RCP_SCALE_BY_ONE;
}
void GeneralFunctionStruct::ZeroOut()
{
// Create mapped registers for zero and discard
MappedRegisterStruct unsignedZero;
RegisterEnum zero;
zero.word = RCP_ZERO;
unsignedZero.Init(zero);
MappedRegisterStruct unsignedDiscard;
RegisterEnum discard;
discard.word = RCP_DISCARD;
unsignedDiscard.Init(discard);
numOps = 3;
op[0].op = RCP_MUL;
op[0].reg[0] = unsignedDiscard;
op[0].reg[1] = unsignedZero;
op[0].reg[2] = unsignedZero;
op[1].op = RCP_MUL;
op[1].reg[0] = unsignedDiscard;
op[1].reg[1] = unsignedZero;
op[1].reg[2] = unsignedZero;
op[2].op = RCP_SUM;
op[2].reg[0] = unsignedDiscard;
}
void GeneralFunctionStruct::Validate(int stage, int portion)
{
int i;
for (i = 0; i < numOps; i++)
op[i].Validate(stage, portion);
// Check if multiple ops are writing to same register (and it's not DISCARD)
if (numOps > 1 &&
op[0].reg[0].reg.bits.name == op[1].reg[0].reg.bits.name &&
GL_DISCARD_NV != op[0].reg[0].reg.bits.name)
errors.set("writing to same register twice");
if (numOps > 2 &&
(op[0].reg[0].reg.bits.name == op[2].reg[0].reg.bits.name ||
op[1].reg[0].reg.bits.name == op[2].reg[0].reg.bits.name) &&
GL_DISCARD_NV != op[2].reg[0].reg.bits.name)
errors.set("writing to same register twice");
// Set unused outputs to discard, unused inputs to zero/unsigned_identity
if (numOps < 2) {
// Set C input to zero
op[1].reg[1].reg.bits.name = GL_ZERO;
op[1].reg[1].map = GL_UNSIGNED_IDENTITY_NV;
op[1].reg[1].reg.bits.channel = portion;
// Set D input to zero
op[1].reg[2].reg.bits.name = GL_ZERO;
op[1].reg[2].map = GL_UNSIGNED_IDENTITY_NV;
op[1].reg[2].reg.bits.channel = portion;
// Discard CD output
op[1].op = false;
op[1].reg[0].reg.bits.name = GL_DISCARD_NV;
}
if (numOps < 3) {
// Discard muxSum output
op[2].reg[0].reg.bits.name = GL_DISCARD_NV;
op[2].op = RCP_SUM;
}
}
void GeneralFunctionStruct::Invoke(int stage, int portion, BiasScaleEnum bs)
{
GLenum portionEnum = (RCP_RGB == portion) ? GL_RGB : GL_ALPHA;
qglCombinerInputNV(GL_COMBINER0_NV + stage,
portionEnum,
GL_VARIABLE_A_NV,
op[0].reg[1].reg.bits.name,
op[0].reg[1].map,
MAP_CHANNEL(op[0].reg[1].reg.bits.channel));
qglCombinerInputNV(GL_COMBINER0_NV + stage,
portionEnum,
GL_VARIABLE_B_NV,
op[0].reg[2].reg.bits.name,
op[0].reg[2].map,
MAP_CHANNEL(op[0].reg[2].reg.bits.channel));
qglCombinerInputNV(GL_COMBINER0_NV + stage,
portionEnum,
GL_VARIABLE_C_NV,
op[1].reg[1].reg.bits.name,
op[1].reg[1].map,
MAP_CHANNEL(op[1].reg[1].reg.bits.channel));
qglCombinerInputNV(GL_COMBINER0_NV + stage,
portionEnum,
GL_VARIABLE_D_NV,
op[1].reg[2].reg.bits.name,
op[1].reg[2].map,
MAP_CHANNEL(op[1].reg[2].reg.bits.channel));
qglCombinerOutputNV(GL_COMBINER0_NV + stage,
portionEnum,
op[0].reg[0].reg.bits.name,
op[1].reg[0].reg.bits.name,
op[2].reg[0].reg.bits.name,
bs.bits.scale,
bs.bits.bias,
op[0].op,
op[1].op,
(op[2].op == RCP_MUX) ? true : false);
}
// This helper function assigns a channel to an undesignated input register
static void ConvertRegister(RegisterEnum& reg, int portion)
{
if (RCP_NONE == reg.bits.channel) {
reg.bits.channel = portion;
if (GL_FOG == reg.bits.name && RCP_ALPHA == portion)
// Special case where fog alpha is final only, but RGB is not
reg.bits.finalOnly = true;
}
}
void OpStruct::Validate(int stage, int portion)
{
int args = 1;
if (RCP_DOT == op || RCP_MUL == op)
args = 3;
else
args = 1;
if (reg[0].reg.bits.readOnly)
errors.set("writing to a read-only register");
if (RCP_ALPHA == portion &&
RCP_DOT == op)
errors.set("dot used in alpha portion");
int i;
for (i = 0; i < args; i++) {
ConvertRegister(reg[i].reg, portion);
if (reg[i].reg.bits.finalOnly)
errors.set("final register used in general combiner");
if (RCP_RGB == portion &&
RCP_BLUE == reg[i].reg.bits.channel)
errors.set("blue register used in rgb portion");
if (RCP_ALPHA == portion &&
RCP_RGB == reg[i].reg.bits.channel)
errors.set("rgb register used in alpha portion");
if (i > 0 &&
GL_DISCARD_NV == reg[i].reg.bits.name)
errors.set("reading from discard");
}
}

107
nvparse/rc1.0_general.h Normal file
View file

@ -0,0 +1,107 @@
#ifndef _RC10_GENERAL_H
#define _RC10_GENERAL_H
#include "rc1.0_register.h"
#include "nvparse_errors.h"
#include "nvparse_externs.h"
enum {
RCP_MUL = 0,
RCP_DOT,
RCP_MUX,
RCP_SUM
};
class ConstColorStruct {
public:
void Init(RegisterEnum _reg, float _v0, float _v1, float _v2, float _v3)
{ reg = _reg; v[0] = _v0; v[1] = _v1; v[2] = _v2; v[3] = _v3; }
RegisterEnum reg;
float v[4];
};
class OpStruct {
public:
void Init(int _op, RegisterEnum _reg0, MappedRegisterStruct _reg1, MappedRegisterStruct _reg2)
{ op = _op; reg[0].reg = _reg0; reg[1] = _reg1; reg[2] = _reg2; }
void Init(int _op, RegisterEnum _reg0)
{ op = _op; reg[0].reg = _reg0; }
int op;
MappedRegisterStruct reg[3];
void Validate(int stage, int portion);
};
class GeneralFunctionStruct {
public:
void Init(OpStruct _op0, OpStruct _op1, OpStruct _op2) { op[0] = _op0; op[1] = _op1; op[2] = _op2; numOps = 3; }
void Init(OpStruct _op0, OpStruct _op1) { op[0] = _op0; op[1] = _op1; numOps = 2; }
void Init(OpStruct _op0) { op[0] = _op0; numOps = 1; }
void Validate(int stage, int portion);
void Invoke(int stage, int portion, BiasScaleEnum bs);
void ZeroOut();
int numOps;
OpStruct op[3];
};
class GeneralPortionStruct {
public:
void Init(int _designator, GeneralFunctionStruct _gf, BiasScaleEnum _bs)
{ designator = _designator; gf = _gf; bs = _bs; }
void Validate(int stage);
void Invoke(int stage);
void ZeroOut();
int designator;
GeneralFunctionStruct gf;
BiasScaleEnum bs;
};
class GeneralCombinerStruct {
public:
void Init(GeneralPortionStruct _portion0, GeneralPortionStruct _portion1, ConstColorStruct _cc0, ConstColorStruct _cc1)
{ portion[0] = _portion0; portion[1] = _portion1; numPortions = 2; cc[0] = _cc0; cc[1] = _cc1; numConsts = 2; }
void Init(GeneralPortionStruct _portion0, GeneralPortionStruct _portion1, ConstColorStruct _cc0)
{ portion[0] = _portion0; portion[1] = _portion1; numPortions = 2; cc[0] = _cc0; numConsts = 1; }
void Init(GeneralPortionStruct _portion0, GeneralPortionStruct _portion1)
{ portion[0] = _portion0; portion[1] = _portion1; numPortions = 2; numConsts = 0; }
void Init(GeneralPortionStruct _portion0, ConstColorStruct _cc0, ConstColorStruct _cc1)
{ portion[0] = _portion0; numPortions = 1; cc[0] = _cc0; cc[1] = _cc1; numConsts = 2; }
void Init(GeneralPortionStruct _portion0, ConstColorStruct _cc0)
{ portion[0] = _portion0; numPortions = 1; cc[0] = _cc0; numConsts = 1; }
void Init(GeneralPortionStruct _portion0)
{ portion[0] = _portion0; numPortions = 1; numConsts = 0; }
void Validate(int stage);
void SetUnusedLocalConsts(int numGlobalConsts, ConstColorStruct *globalCCs);
void Invoke(int stage);
void ZeroOut();
GeneralPortionStruct portion[2];
int numPortions;
ConstColorStruct cc[2];
int numConsts;
};
class GeneralCombinersStruct {
public:
void Init() {num = 0;}
void Init(GeneralCombinerStruct _gc) { num = 1; general[0] = _gc; }
GeneralCombinersStruct& operator+=(GeneralCombinerStruct& _gc)
{
if (num < RCP_NUM_GENERAL_COMBINERS)
general[num++] = _gc;
else
errors.set("Too many general combiners.");
return *this;
}
void Validate(int numConsts, ConstColorStruct *cc);
void Invoke();
GeneralCombinerStruct general[RCP_NUM_GENERAL_COMBINERS];
int num;
private:
int localConsts;
};
#endif

682
nvparse/rc1.0_grammar.y Normal file
View file

@ -0,0 +1,682 @@
%start WholeEnchilada
%{
void yyerror(char* s);
int yylex ( void );
#ifdef _WIN32
# include <windows.h>
#endif
#include <stdio.h>
#include <malloc.h>
#include "rc1.0_combiners.h"
#include "nvparse_errors.h"
#include "nvparse_externs.h"
%}
%union {
int ival;
float fval;
RegisterEnum registerEnum;
BiasScaleEnum biasScaleEnum;
MappedRegisterStruct mappedRegisterStruct;
ConstColorStruct constColorStruct;
GeneralPortionStruct generalPortionStruct;
GeneralFunctionStruct generalFunctionStruct;
OpStruct opStruct;
GeneralCombinerStruct generalCombinerStruct;
GeneralCombinersStruct generalCombinersStruct;
FinalProductStruct finalProductStruct;
FinalRgbFunctionStruct finalRgbFunctionStruct;
FinalAlphaFunctionStruct finalAlphaFunctionStruct;
FinalCombinerStruct finalCombinerStruct;
CombinersStruct combinersStruct;
}
%token <registerEnum> regVariable constVariable color_sum final_product
%token <ival> expandString halfBiasString unsignedString unsignedInvertString muxString sumString
%token <ival> rgb_portion alpha_portion
%token <ival> openParen closeParen openBracket closeBracket semicolon comma
%token <ival> dot times minus equals plus
%token <biasScaleEnum> bias_by_negative_one_half_scale_by_two bias_by_negative_one_half
%token <biasScaleEnum> scale_by_one_half scale_by_two scale_by_four
%token <ival> clamp_color_sum lerp
%token <ival> fragment_rgb fragment_alpha
%token <fval> floatValue
%type <combinersStruct> WholeEnchilada Combiners
%type <constColorStruct> ConstColor
%type <generalCombinerStruct> GeneralCombiner
%type <generalCombinersStruct> GeneralCombiners
%type <ival> PortionDesignator
%type <opStruct> Mux Sum Dot Mul
%type <generalPortionStruct> GeneralPortion
%type <generalFunctionStruct> GeneralFunction
%type <biasScaleEnum> BiasScale
%type <registerEnum> Register
%type <mappedRegisterStruct> GeneralMappedRegister FinalMappedRegister
%type <finalProductStruct> FinalProduct
%type <ival> ClampColorSum
%type <finalRgbFunctionStruct> FinalRgbFunction
%type <finalAlphaFunctionStruct> FinalAlphaFunction
%type <finalCombinerStruct> FinalCombiner
%%
WholeEnchilada : Combiners
{
$1.Validate();
$1.Invoke();
}
;
Combiners : ConstColor GeneralCombiners FinalCombiner
{
CombinersStruct combinersStruct;
combinersStruct.Init($2, $3, $1);
$$ = combinersStruct;
}
| ConstColor ConstColor GeneralCombiners FinalCombiner
{
CombinersStruct combinersStruct;
combinersStruct.Init($3, $4, $1, $2);
$$ = combinersStruct;
}
| GeneralCombiners FinalCombiner
{
CombinersStruct combinersStruct;
combinersStruct.Init($1, $2);
$$ = combinersStruct;
}
| ConstColor FinalCombiner
{
GeneralCombinersStruct generalCombinersStruct;
generalCombinersStruct.Init();
CombinersStruct combinersStruct;
combinersStruct.Init(generalCombinersStruct, $2, $1);
$$ = combinersStruct;
}
| ConstColor ConstColor FinalCombiner
{
GeneralCombinersStruct generalCombinersStruct;
generalCombinersStruct.Init();
CombinersStruct combinersStruct;
combinersStruct.Init(generalCombinersStruct, $3, $1, $2);
$$ = combinersStruct;
}
| FinalCombiner
{
GeneralCombinersStruct generalCombinersStruct;
generalCombinersStruct.Init();
CombinersStruct combinersStruct;
combinersStruct.Init(generalCombinersStruct, $1);
$$ = combinersStruct;
}
;
ConstColor : constVariable equals openParen floatValue comma floatValue comma floatValue comma floatValue closeParen semicolon
{
ConstColorStruct constColorStruct;
constColorStruct.Init($1, $4, $6, $8, $10);
$$ = constColorStruct;
}
;
GeneralCombiners : GeneralCombiners GeneralCombiner
{
$1 += $2;
$$ = $1;
}
| GeneralCombiner
{
GeneralCombinersStruct generalCombinersStruct;
generalCombinersStruct.Init($1);
$$ = generalCombinersStruct;
}
;
GeneralCombiner : openBracket GeneralPortion GeneralPortion closeBracket
{
GeneralCombinerStruct generalCombinerStruct;
generalCombinerStruct.Init($2, $3);
$$ = generalCombinerStruct;
}
| openBracket ConstColor GeneralPortion GeneralPortion closeBracket
{
GeneralCombinerStruct generalCombinerStruct;
generalCombinerStruct.Init($3, $4, $2);
$$ = generalCombinerStruct;
}
| openBracket ConstColor ConstColor GeneralPortion GeneralPortion closeBracket
{
GeneralCombinerStruct generalCombinerStruct;
generalCombinerStruct.Init($4, $5, $2, $3);
$$ = generalCombinerStruct;
}
| openBracket GeneralPortion closeBracket
{
GeneralCombinerStruct generalCombinerStruct;
generalCombinerStruct.Init($2);
$$ = generalCombinerStruct;
}
| openBracket ConstColor GeneralPortion closeBracket
{
GeneralCombinerStruct generalCombinerStruct;
generalCombinerStruct.Init($3, $2);
$$ = generalCombinerStruct;
}
| openBracket ConstColor ConstColor GeneralPortion closeBracket
{
GeneralCombinerStruct generalCombinerStruct;
generalCombinerStruct.Init($4, $2, $3);
$$ = generalCombinerStruct;
}
;
GeneralPortion : PortionDesignator openBracket GeneralFunction BiasScale closeBracket
{
GeneralPortionStruct generalPortionStruct;
generalPortionStruct.Init($1, $3, $4);
$$ = generalPortionStruct;
}
| PortionDesignator openBracket GeneralFunction closeBracket
{
BiasScaleEnum noScale;
noScale.word = RCP_SCALE_BY_ONE;
GeneralPortionStruct generalPortionStruct;
generalPortionStruct.Init($1, $3, noScale);
$$ = generalPortionStruct;
}
;
PortionDesignator : rgb_portion
{
$$ = $1;
}
| alpha_portion
{
$$ = $1;
}
;
GeneralMappedRegister : Register
{
MappedRegisterStruct reg;
reg.Init($1, GL_SIGNED_IDENTITY_NV);
$$ = reg;
}
| minus Register
{
MappedRegisterStruct reg;
reg.Init($2, GL_SIGNED_NEGATE_NV);
$$ = reg;
}
| expandString openParen Register closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_EXPAND_NORMAL_NV);
$$ = reg;
}
| minus expandString openParen Register closeParen
{
MappedRegisterStruct reg;
reg.Init($4, GL_EXPAND_NEGATE_NV);
$$ = reg;
}
| halfBiasString openParen Register closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_HALF_BIAS_NORMAL_NV);
$$ = reg;
}
| minus halfBiasString openParen Register closeParen
{
MappedRegisterStruct reg;
reg.Init($4, GL_HALF_BIAS_NEGATE_NV);
$$ = reg;
}
| unsignedString openParen Register closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_UNSIGNED_IDENTITY_NV);
$$ = reg;
}
| unsignedInvertString openParen Register closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_UNSIGNED_INVERT_NV);
$$ = reg;
}
;
GeneralFunction : Dot Dot
{
GeneralFunctionStruct generalFunction;
generalFunction.Init($1, $2);
$$ = generalFunction;
}
| Dot Mul
{
GeneralFunctionStruct generalFunction;
generalFunction.Init($1, $2);
$$ = generalFunction;
}
| Mul Dot
{
GeneralFunctionStruct generalFunction;
generalFunction.Init($1, $2);
$$ = generalFunction;
}
| Dot
{
GeneralFunctionStruct generalFunction;
generalFunction.Init($1);
$$ = generalFunction;
}
| Mul Mul
{
GeneralFunctionStruct generalFunction;
generalFunction.Init($1, $2);
$$ = generalFunction;
}
| Mul Mul Mux
{
GeneralFunctionStruct generalFunction;
generalFunction.Init($1, $2, $3);
$$ = generalFunction;
}
| Mul Mul Sum
{
GeneralFunctionStruct generalFunction;
generalFunction.Init($1, $2, $3);
$$ = generalFunction;
}
| Mul
{
GeneralFunctionStruct generalFunction;
generalFunction.Init($1);
$$ = generalFunction;
}
;
Dot : Register equals GeneralMappedRegister dot GeneralMappedRegister semicolon
{
OpStruct dotFunction;
dotFunction.Init(RCP_DOT, $1, $3, $5);
$$ = dotFunction;
}
;
Mul : Register equals GeneralMappedRegister times GeneralMappedRegister semicolon
{
OpStruct mulFunction;
mulFunction.Init(RCP_MUL, $1, $3, $5);
$$ = mulFunction;
}
| Register equals GeneralMappedRegister semicolon
{
RegisterEnum zero;
zero.word = RCP_ZERO;
MappedRegisterStruct one;
one.Init(zero, GL_UNSIGNED_INVERT_NV);
OpStruct mulFunction;
mulFunction.Init(RCP_MUL, $1, $3, one);
$$ = mulFunction;
}
;
Mux : Register equals muxString openParen closeParen semicolon
{
OpStruct muxFunction;
muxFunction.Init(RCP_MUX, $1);
$$ = muxFunction;
}
;
Sum : Register equals sumString openParen closeParen semicolon
{
OpStruct sumFunction;
sumFunction.Init(RCP_SUM, $1);
$$ = sumFunction;
}
;
BiasScale : bias_by_negative_one_half_scale_by_two openParen closeParen semicolon
{
$$ = $1;
}
| bias_by_negative_one_half openParen closeParen semicolon
{
$$ = $1;
}
| scale_by_one_half openParen closeParen semicolon
{
$$ = $1;
}
| scale_by_two openParen closeParen semicolon
{
$$ = $1;
}
| scale_by_four openParen closeParen semicolon
{
$$ = $1;
}
;
FinalMappedRegister : Register
{
MappedRegisterStruct reg;
reg.Init($1, GL_UNSIGNED_IDENTITY_NV);
$$ = reg;
}
| unsignedString openParen Register closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_UNSIGNED_IDENTITY_NV);
$$ = reg;
}
| unsignedInvertString openParen Register closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_UNSIGNED_INVERT_NV);
$$ = reg;
}
| color_sum
{
MappedRegisterStruct reg;
reg.Init($1);
$$ = reg;
}
| unsignedString openParen color_sum closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_UNSIGNED_IDENTITY_NV);
$$ = reg;
}
| unsignedInvertString openParen color_sum closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_UNSIGNED_INVERT_NV);
$$ = reg;
}
| final_product
{
MappedRegisterStruct reg;
reg.Init($1);
$$ = reg;
}
| unsignedString openParen final_product closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_UNSIGNED_IDENTITY_NV);
$$ = reg;
}
| unsignedInvertString openParen final_product closeParen
{
MappedRegisterStruct reg;
reg.Init($3, GL_UNSIGNED_INVERT_NV);
$$ = reg;
}
;
FinalCombiner : FinalAlphaFunction FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($2, $1, false);
$$ = finalCombinerStruct;
}
| ClampColorSum FinalAlphaFunction FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($3, $2, true);
$$ = finalCombinerStruct;
}
| FinalProduct FinalAlphaFunction FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($3, $2, false, $1);
$$ = finalCombinerStruct;
}
| ClampColorSum FinalProduct FinalAlphaFunction FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($4, $3, true, $2);
$$ = finalCombinerStruct;
}
| FinalProduct ClampColorSum FinalAlphaFunction FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($4, $3, true, $1);
$$ = finalCombinerStruct;
}
| FinalRgbFunction FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($1, $2, false);
$$ = finalCombinerStruct;
}
| ClampColorSum FinalRgbFunction FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($2, $3, true);
$$ = finalCombinerStruct;
}
| FinalProduct FinalRgbFunction FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($2, $3, false, $1);
$$ = finalCombinerStruct;
}
| ClampColorSum FinalProduct FinalRgbFunction FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($3, $4, true, $2);
$$ = finalCombinerStruct;
}
| FinalProduct ClampColorSum FinalRgbFunction FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
finalCombinerStruct.Init($3, $4, true, $1);
$$ = finalCombinerStruct;
}
| FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalAlphaFunctionStruct finalAlphaFunctionStruct;
finalAlphaFunctionStruct.ZeroOut();
finalCombinerStruct.Init($1, finalAlphaFunctionStruct, false);
$$ = finalCombinerStruct;
}
| ClampColorSum FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalAlphaFunctionStruct finalAlphaFunctionStruct;
finalAlphaFunctionStruct.ZeroOut();
finalCombinerStruct.Init($2, finalAlphaFunctionStruct, true);
$$ = finalCombinerStruct;
}
| FinalProduct FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalAlphaFunctionStruct finalAlphaFunctionStruct;
finalAlphaFunctionStruct.ZeroOut();
finalCombinerStruct.Init($2, finalAlphaFunctionStruct, false, $1);
$$ = finalCombinerStruct;
}
| ClampColorSum FinalProduct FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalAlphaFunctionStruct finalAlphaFunctionStruct;
finalAlphaFunctionStruct.ZeroOut();
finalCombinerStruct.Init($3, finalAlphaFunctionStruct, true, $2);
$$ = finalCombinerStruct;
}
| FinalProduct ClampColorSum FinalRgbFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalAlphaFunctionStruct finalAlphaFunctionStruct;
finalAlphaFunctionStruct.ZeroOut();
finalCombinerStruct.Init($3, finalAlphaFunctionStruct, true, $1);
$$ = finalCombinerStruct;
}
| FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.ZeroOut();
finalCombinerStruct.Init(finalRgbFunctionStruct, $1, false);
$$ = finalCombinerStruct;
}
| ClampColorSum FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.ZeroOut();
finalCombinerStruct.Init(finalRgbFunctionStruct, $2, true);
$$ = finalCombinerStruct;
}
| FinalProduct FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.ZeroOut();
finalCombinerStruct.Init(finalRgbFunctionStruct, $2, false, $1);
$$ = finalCombinerStruct;
}
| ClampColorSum FinalProduct FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.ZeroOut();
finalCombinerStruct.Init(finalRgbFunctionStruct, $3, true, $2);
$$ = finalCombinerStruct;
}
| FinalProduct ClampColorSum FinalAlphaFunction
{
FinalCombinerStruct finalCombinerStruct;
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.ZeroOut();
finalCombinerStruct.Init(finalRgbFunctionStruct, $3, true, $1);
$$ = finalCombinerStruct;
}
;
ClampColorSum : clamp_color_sum openParen closeParen semicolon
{
$$ = $1;
}
;
FinalProduct : final_product equals FinalMappedRegister times FinalMappedRegister semicolon
{
FinalProductStruct finalProductStruct;
finalProductStruct.Init($3, $5);
$$ = finalProductStruct;
}
;
FinalRgbFunction : fragment_rgb equals lerp openParen FinalMappedRegister comma FinalMappedRegister comma FinalMappedRegister closeParen plus FinalMappedRegister semicolon
{
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.Init($5, $7, $9, $12);
$$ = finalRgbFunctionStruct;
}
| fragment_rgb equals FinalMappedRegister plus lerp openParen FinalMappedRegister comma FinalMappedRegister comma FinalMappedRegister closeParen semicolon
{
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.Init($7, $9, $11, $3);
$$ = finalRgbFunctionStruct;
}
| fragment_rgb equals lerp openParen FinalMappedRegister comma FinalMappedRegister comma FinalMappedRegister closeParen semicolon
{
RegisterEnum zero;
zero.word = RCP_ZERO;
MappedRegisterStruct reg;
reg.Init(zero, GL_UNSIGNED_IDENTITY_NV);
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.Init($5, $7, $9, reg);
$$ = finalRgbFunctionStruct;
}
| fragment_rgb equals FinalMappedRegister times FinalMappedRegister semicolon
{
RegisterEnum zero;
zero.word = RCP_ZERO;
MappedRegisterStruct reg1;
reg1.Init(zero, GL_UNSIGNED_IDENTITY_NV);
MappedRegisterStruct reg2;
reg2.Init(zero, GL_UNSIGNED_IDENTITY_NV);
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.Init($3, $5, reg1, reg2);
$$ = finalRgbFunctionStruct;
}
| fragment_rgb equals FinalMappedRegister times FinalMappedRegister plus FinalMappedRegister semicolon
{
RegisterEnum zero;
zero.word = RCP_ZERO;
MappedRegisterStruct reg1;
reg1.Init(zero, GL_UNSIGNED_IDENTITY_NV);
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.Init($3, $5, reg1, $7);
$$ = finalRgbFunctionStruct;
}
| fragment_rgb equals FinalMappedRegister semicolon
{
RegisterEnum zero;
zero.word = RCP_ZERO;
MappedRegisterStruct reg1;
reg1.Init(zero, GL_UNSIGNED_IDENTITY_NV);
MappedRegisterStruct reg2;
reg2.Init(zero, GL_UNSIGNED_IDENTITY_NV);
MappedRegisterStruct reg3;
reg3.Init(zero, GL_UNSIGNED_IDENTITY_NV);
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.Init(reg1, reg2, reg3, $3);
$$ = finalRgbFunctionStruct;
}
| fragment_rgb equals FinalMappedRegister plus FinalMappedRegister semicolon
{
RegisterEnum zero;
zero.word = RCP_ZERO;
MappedRegisterStruct reg2;
reg2.Init(zero, GL_UNSIGNED_INVERT_NV);
MappedRegisterStruct reg3;
reg3.Init(zero, GL_UNSIGNED_IDENTITY_NV);
FinalRgbFunctionStruct finalRgbFunctionStruct;
finalRgbFunctionStruct.Init($3, reg2, reg3, $5);
$$ = finalRgbFunctionStruct;
}
;
FinalAlphaFunction : fragment_alpha equals FinalMappedRegister semicolon
{
FinalAlphaFunctionStruct finalAlphaFunctionStruct;
finalAlphaFunctionStruct.Init($3);
$$ = finalAlphaFunctionStruct;
}
;
Register : constVariable
{
$$ = $1;
}
| regVariable
{
$$ = $1;
}
;
%%
void yyerror(char* s)
{
errors.set("unrecognized token");
}

207
nvparse/rc1.0_register.h Normal file
View file

@ -0,0 +1,207 @@
#ifndef _RC10_REGISTER_H
#define _RC10_REGISTER_H
#ifdef _WIN32
# include <windows.h>
# define BYTE_ORDER !BIG_ENDIAN
#endif
#include <GL/gl.h>
#include <stdlib.h>
#include "../glNV.h"
#define RCP_NUM_GENERAL_COMBINERS 8
#define RCP_RGB 0
#define RCP_ALPHA 1
#define RCP_BLUE 2
#define RCP_NONE 3
typedef union _RegisterEnum {
struct {
#if BYTE_ORDER != BIG_ENDIAN
unsigned int name :16; // OpenGL enum for register
unsigned int channel : 2; // RCP_RGB, RCP_ALPHA, etc
unsigned int readOnly : 1; // true or false
unsigned int finalOnly : 1; // true or false
unsigned int unused :12;
#else
unsigned int unused :12;
unsigned int finalOnly : 1; // true or false
unsigned int readOnly : 1; // true or false
unsigned int channel : 2; // RCP_RGB, RCP_ALPHA, RCP_BLUE, RCP_NONE
unsigned int name :16; // OpenGL enum for register
#endif
} bits;
unsigned int word;
} RegisterEnum;
// No need for writeOnly flag, since DISCARD is the only register in that category
// WARNING: Don't monkey with the above structure or this macro
// unless you're absolutely sure of what you're doing!
// This constant allocation makes validation *much* cleaner.
#define RCP_SET_REGISTER_ENUM(name, channel, readonly, finalonly) \
((finalonly << 19) | (readonly << 18) | (channel << 16) | name)
#define RCP_FOG_RGB RCP_SET_REGISTER_ENUM(GL_FOG, RCP_RGB, 1, 0)
#define RCP_FOG_ALPHA RCP_SET_REGISTER_ENUM(GL_FOG, RCP_ALPHA, 1, 1)
#define RCP_FOG_BLUE RCP_SET_REGISTER_ENUM(GL_FOG, RCP_BLUE, 1, 0)
#define RCP_FOG RCP_SET_REGISTER_ENUM(GL_FOG, RCP_NONE, 1, 0)
#define RCP_PRIMARY_COLOR_RGB RCP_SET_REGISTER_ENUM(GL_PRIMARY_COLOR_NV, RCP_RGB, 0, 0)
#define RCP_PRIMARY_COLOR_ALPHA RCP_SET_REGISTER_ENUM(GL_PRIMARY_COLOR_NV, RCP_ALPHA, 0, 0)
#define RCP_PRIMARY_COLOR_BLUE RCP_SET_REGISTER_ENUM(GL_PRIMARY_COLOR_NV, RCP_BLUE, 0, 0)
#define RCP_PRIMARY_COLOR RCP_SET_REGISTER_ENUM(GL_PRIMARY_COLOR_NV, RCP_NONE, 0, 0)
#define RCP_SECONDARY_COLOR_RGB RCP_SET_REGISTER_ENUM(GL_SECONDARY_COLOR_NV, RCP_RGB, 0, 0)
#define RCP_SECONDARY_COLOR_ALPHA RCP_SET_REGISTER_ENUM(GL_SECONDARY_COLOR_NV, RCP_ALPHA, 0, 0)
#define RCP_SECONDARY_COLOR_BLUE RCP_SET_REGISTER_ENUM(GL_SECONDARY_COLOR_NV, RCP_BLUE, 0, 0)
#define RCP_SECONDARY_COLOR RCP_SET_REGISTER_ENUM(GL_SECONDARY_COLOR_NV, RCP_NONE, 0, 0)
#define RCP_SPARE0_RGB RCP_SET_REGISTER_ENUM(GL_SPARE0_NV, RCP_RGB, 0, 0)
#define RCP_SPARE0_ALPHA RCP_SET_REGISTER_ENUM(GL_SPARE0_NV, RCP_ALPHA, 0, 0)
#define RCP_SPARE0_BLUE RCP_SET_REGISTER_ENUM(GL_SPARE0_NV, RCP_BLUE, 0, 0)
#define RCP_SPARE0 RCP_SET_REGISTER_ENUM(GL_SPARE0_NV, RCP_NONE, 0, 0)
#define RCP_SPARE1_RGB RCP_SET_REGISTER_ENUM(GL_SPARE1_NV, RCP_RGB, 0, 0)
#define RCP_SPARE1_ALPHA RCP_SET_REGISTER_ENUM(GL_SPARE1_NV, RCP_ALPHA, 0, 0)
#define RCP_SPARE1_BLUE RCP_SET_REGISTER_ENUM(GL_SPARE1_NV, RCP_BLUE, 0, 0)
#define RCP_SPARE1 RCP_SET_REGISTER_ENUM(GL_SPARE1_NV, RCP_NONE, 0, 0)
#define RCP_TEXTURE0_RGB RCP_SET_REGISTER_ENUM(GL_TEXTURE0_ARB, RCP_RGB, 0, 0)
#define RCP_TEXTURE0_ALPHA RCP_SET_REGISTER_ENUM(GL_TEXTURE0_ARB, RCP_ALPHA, 0, 0)
#define RCP_TEXTURE0_BLUE RCP_SET_REGISTER_ENUM(GL_TEXTURE0_ARB, RCP_BLUE, 0, 0)
#define RCP_TEXTURE0 RCP_SET_REGISTER_ENUM(GL_TEXTURE0_ARB, RCP_NONE, 0, 0)
#define RCP_TEXTURE1_RGB RCP_SET_REGISTER_ENUM(GL_TEXTURE1_ARB, RCP_RGB, 0, 0)
#define RCP_TEXTURE1_ALPHA RCP_SET_REGISTER_ENUM(GL_TEXTURE1_ARB, RCP_ALPHA, 0, 0)
#define RCP_TEXTURE1_BLUE RCP_SET_REGISTER_ENUM(GL_TEXTURE1_ARB, RCP_BLUE, 0, 0)
#define RCP_TEXTURE1 RCP_SET_REGISTER_ENUM(GL_TEXTURE1_ARB, RCP_NONE, 0, 0)
#define RCP_TEXTURE2_RGB RCP_SET_REGISTER_ENUM(GL_TEXTURE2_ARB, RCP_RGB, 0, 0)
#define RCP_TEXTURE2_ALPHA RCP_SET_REGISTER_ENUM(GL_TEXTURE2_ARB, RCP_ALPHA, 0, 0)
#define RCP_TEXTURE2_BLUE RCP_SET_REGISTER_ENUM(GL_TEXTURE2_ARB, RCP_BLUE, 0, 0)
#define RCP_TEXTURE2 RCP_SET_REGISTER_ENUM(GL_TEXTURE2_ARB, RCP_NONE, 0, 0)
#define RCP_TEXTURE3_RGB RCP_SET_REGISTER_ENUM(GL_TEXTURE3_ARB, RCP_RGB, 0, 0)
#define RCP_TEXTURE3_ALPHA RCP_SET_REGISTER_ENUM(GL_TEXTURE3_ARB, RCP_ALPHA, 0, 0)
#define RCP_TEXTURE3_BLUE RCP_SET_REGISTER_ENUM(GL_TEXTURE3_ARB, RCP_BLUE, 0, 0)
#define RCP_TEXTURE3 RCP_SET_REGISTER_ENUM(GL_TEXTURE3_ARB, RCP_NONE, 0, 0)
#define RCP_CONST_COLOR0_RGB RCP_SET_REGISTER_ENUM(GL_CONSTANT_COLOR0_NV, RCP_RGB, 1, 0)
#define RCP_CONST_COLOR0_ALPHA RCP_SET_REGISTER_ENUM(GL_CONSTANT_COLOR0_NV, RCP_ALPHA, 1, 0)
#define RCP_CONST_COLOR0_BLUE RCP_SET_REGISTER_ENUM(GL_CONSTANT_COLOR0_NV, RCP_BLUE, 1, 0)
#define RCP_CONST_COLOR0 RCP_SET_REGISTER_ENUM(GL_CONSTANT_COLOR0_NV, RCP_NONE, 1, 0)
#define RCP_CONST_COLOR1_RGB RCP_SET_REGISTER_ENUM(GL_CONSTANT_COLOR1_NV, RCP_RGB, 1, 0)
#define RCP_CONST_COLOR1_ALPHA RCP_SET_REGISTER_ENUM(GL_CONSTANT_COLOR1_NV, RCP_ALPHA, 1, 0)
#define RCP_CONST_COLOR1_BLUE RCP_SET_REGISTER_ENUM(GL_CONSTANT_COLOR1_NV, RCP_BLUE, 1, 0)
#define RCP_CONST_COLOR1 RCP_SET_REGISTER_ENUM(GL_CONSTANT_COLOR1_NV, RCP_NONE, 1, 0)
#define RCP_ZERO_RGB RCP_SET_REGISTER_ENUM(GL_ZERO, RCP_RGB, 1, 0)
#define RCP_ZERO_ALPHA RCP_SET_REGISTER_ENUM(GL_ZERO, RCP_ALPHA, 1, 0)
#define RCP_ZERO_BLUE RCP_SET_REGISTER_ENUM(GL_ZERO, RCP_BLUE, 1, 0)
#define RCP_ZERO RCP_SET_REGISTER_ENUM(GL_ZERO, RCP_NONE, 1, 0)
#define RCP_ONE_RGB RCP_SET_REGISTER_ENUM(GL_ONE, RCP_RGB, 1, 0)
#define RCP_ONE_ALPHA RCP_SET_REGISTER_ENUM(GL_ONE, RCP_ALPHA, 1, 0)
#define RCP_ONE_BLUE RCP_SET_REGISTER_ENUM(GL_ONE, RCP_BLUE, 1, 0)
#define RCP_ONE RCP_SET_REGISTER_ENUM(GL_ONE, RCP_NONE, 1, 0)
#define RCP_DISCARD RCP_SET_REGISTER_ENUM(GL_DISCARD_NV, RCP_NONE, 0, 0)
#define RCP_FINAL_PRODUCT RCP_SET_REGISTER_ENUM(GL_E_TIMES_F_NV, RCP_NONE, 1, 1)
#define RCP_COLOR_SUM RCP_SET_REGISTER_ENUM(GL_SPARE0_PLUS_SECONDARY_COLOR_NV, RCP_NONE, 1, 1)
#define MAP_CHANNEL(channel) ((RCP_RGB == (channel)) ? GL_RGB : (RCP_ALPHA == (channel) ? GL_ALPHA : GL_BLUE))
typedef union _BiasScaleEnum {
struct {
#if BYTE_ORDER != BIG_ENDIAN
unsigned int bias :16; // OpenGL enum for bias
unsigned int scale :16; // OpenGL enum for scale
#else
unsigned int scale :16; // OpenGL enum for scale
unsigned int bias :16; // OpenGL enum for bias
#endif
} bits;
unsigned int word;
} BiasScaleEnum;
// WARNING: Don't monkey with the above structure or this macro
// unless you're absolutely sure of what you're doing!
// This constant allocation makes validation *much* cleaner.
#define RCP_SET_BIAS_SCALE_ENUM(bias, scale) ((scale << 16) | bias)
#define RCP_BIAS_BY_NEGATIVE_ONE_HALF_SCALE_BY_TWO RCP_SET_BIAS_SCALE_ENUM(GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_SCALE_BY_TWO_NV)
#define RCP_BIAS_BY_NEGATIVE_ONE_HALF RCP_SET_BIAS_SCALE_ENUM(GL_BIAS_BY_NEGATIVE_ONE_HALF_NV, GL_NONE)
#define RCP_SCALE_BY_ONE_HALF RCP_SET_BIAS_SCALE_ENUM(GL_NONE, GL_SCALE_BY_ONE_HALF_NV)
#define RCP_SCALE_BY_ONE RCP_SET_BIAS_SCALE_ENUM(GL_NONE, GL_NONE)
#define RCP_SCALE_BY_TWO RCP_SET_BIAS_SCALE_ENUM(GL_NONE, GL_SCALE_BY_TWO_NV)
#define RCP_SCALE_BY_FOUR RCP_SET_BIAS_SCALE_ENUM(GL_NONE, GL_SCALE_BY_FOUR_NV)
class MappedRegisterStruct {
public:
void Init(RegisterEnum _reg, int _map = GL_UNSIGNED_IDENTITY_NV)
{
if (RCP_ONE == _reg.bits.name) {
_reg.bits.name = RCP_ZERO;
switch (_map) {
case GL_UNSIGNED_IDENTITY_NV:
_map = GL_UNSIGNED_INVERT_NV;
break;
case GL_UNSIGNED_INVERT_NV:
_map = GL_UNSIGNED_IDENTITY_NV;
break;
case GL_EXPAND_NORMAL_NV:
_map = GL_UNSIGNED_INVERT_NV;
break;
case GL_EXPAND_NEGATE_NV:
_map = GL_EXPAND_NORMAL_NV;
break;
case GL_HALF_BIAS_NORMAL_NV:
_map = GL_HALF_BIAS_NEGATE_NV;
break;
case GL_HALF_BIAS_NEGATE_NV:
_map = GL_HALF_BIAS_NORMAL_NV;
break;
case GL_SIGNED_IDENTITY_NV:
_map = GL_UNSIGNED_INVERT_NV;
break;
case GL_SIGNED_NEGATE_NV:
_map = GL_EXPAND_NORMAL_NV;
break;
}
}
map = _map;
reg = _reg;
}
int map;
RegisterEnum reg;
};
#ifdef TEST_BIT_FIELDS
class RegisterEnumTest {
public:
RegisterEnumTest()
{
RegisterEnum reg;
bool error = false;
if (sizeof(reg.bits) != sizeof(reg.word))
error = true;
reg.word = 0; reg.bits.name = 0xFFFF;
if (RCP_SET_REGISTER_ENUM(0xFFFF, 0, 0, 0) != reg.word)
error = true;
reg.word = 0; reg.bits.channel = 3;
if (RCP_SET_REGISTER_ENUM(0, 3, 0, 0) != reg.word)
error = true;
reg.word = 0; reg.bits.readOnly = true;
if (RCP_SET_REGISTER_ENUM(0, 0, 1, 0) != reg.word)
error = true;
reg.word = 0; reg.bits.finalOnly = true;
if (RCP_SET_REGISTER_ENUM(0, 0, 0, 1) != reg.word)
error = true;
if (error) {
fprintf(stderr, "ERROR: Bit Fields were not compiled correctly in " __FILE__ "!\n");
exit(1);
}
}
};
static RegisterEnumTest registerEnumTest;
#endif
#endif

410
nvparse/rc1.0_tokens.l Normal file
View file

@ -0,0 +1,410 @@
/* definitions */
digit [0-9]
char [a-zA-Z_.]
alphanum [0-9a-zA-Z_]
%{ /* code to be included */
#include <stdlib.h>
#include <malloc.h>
#include "rc1.0_combiners.h"
#include "_rc1.0_parser.h"
#ifdef _WIN32
# include <windows.h>
#endif
#include <GL/gl.h>
#include <GL/glext.h>
#include "nvparse_errors.h"
#include "nvparse_externs.h"
#define YY_INPUT(buf,result,max_size) \
{ \
result = 0; \
while (*myin && result < max_size) \
buf[result++] = *myin++; \
}
#define YY_ALWAYS_INTERACTIVE 1
%}
/* end of definitions */
%%
\/\* {
A:
switch (yyinput()) {
case '*': goto B;
case 0: errors.set("end-of-file in comment", line_number); break;
case '\n': line_number++;
default: goto A;
}
B:
switch (yyinput()) {
case '*': goto B;
case '/': break;
case 0: errors.set("end-of-file in comment", line_number); break;
case '\n': line_number++;
default: goto A;
}
}
\/\/ {
char ch;
while ((ch = yyinput()) != '\n');
if (ch == '\n') line_number++;
}
\# {
char ch;
while ((ch = yyinput()) != '\n');
if (ch == '\n') line_number++;
}
!!RC1\.0 { /* eat header */ }
fog\.rgb {
rc10_lval.registerEnum.word = RCP_FOG_RGB;
return(regVariable);
}
fog\.a {
rc10_lval.registerEnum.word = RCP_FOG_ALPHA;
return(regVariable);
}
fog\.b {
rc10_lval.registerEnum.word = RCP_FOG_BLUE;
return(regVariable);
}
fog {
rc10_lval.registerEnum.word = RCP_FOG;
return(regVariable);
}
col0\.rgb {
rc10_lval.registerEnum.word = RCP_PRIMARY_COLOR_RGB;
return(regVariable);
}
col0\.a {
rc10_lval.registerEnum.word = RCP_PRIMARY_COLOR_ALPHA;
return(regVariable);
}
col0\.b {
rc10_lval.registerEnum.word = RCP_PRIMARY_COLOR_BLUE;
return(regVariable);
}
col0 {
rc10_lval.registerEnum.word = RCP_PRIMARY_COLOR;
return(regVariable);
}
col1\.rgb {
rc10_lval.registerEnum.word = RCP_SECONDARY_COLOR_RGB;
return(regVariable);
}
col1\.a {
rc10_lval.registerEnum.word = RCP_SECONDARY_COLOR_ALPHA;
return(regVariable);
}
col1\.b {
rc10_lval.registerEnum.word = RCP_SECONDARY_COLOR_BLUE;
return(regVariable);
}
col1 {
rc10_lval.registerEnum.word = RCP_SECONDARY_COLOR;
return(regVariable);
}
spare0\.rgb {
rc10_lval.registerEnum.word = RCP_SPARE0_RGB;
return(regVariable);
}
spare0\.a {
rc10_lval.registerEnum.word = RCP_SPARE0_ALPHA;
return(regVariable);
}
spare0\.b {
rc10_lval.registerEnum.word = RCP_SPARE0_BLUE;
return(regVariable);
}
spare0 {
rc10_lval.registerEnum.word = RCP_SPARE0;
return(regVariable);
}
spare1\.rgb {
rc10_lval.registerEnum.word = RCP_SPARE1_RGB;
return(regVariable);
}
spare1\.a {
rc10_lval.registerEnum.word = RCP_SPARE1_ALPHA;
return(regVariable);
}
spare1\.b {
rc10_lval.registerEnum.word = RCP_SPARE1_BLUE;
return(regVariable);
}
spare1 {
rc10_lval.registerEnum.word = RCP_SPARE1;
return(regVariable);
}
tex0\.rgb {
rc10_lval.registerEnum.word = RCP_TEXTURE0_RGB;
return(regVariable);
}
tex0\.a {
rc10_lval.registerEnum.word = RCP_TEXTURE0_ALPHA;
return(regVariable);
}
tex0\.b {
rc10_lval.registerEnum.word = RCP_TEXTURE0_BLUE;
return(regVariable);
}
tex0 {
rc10_lval.registerEnum.word = RCP_TEXTURE0;
return(regVariable);
}
tex1\.rgb {
rc10_lval.registerEnum.word = RCP_TEXTURE1_RGB;
return(regVariable);
}
tex1\.a {
rc10_lval.registerEnum.word = RCP_TEXTURE1_ALPHA;
return(regVariable);
}
tex1\.b {
rc10_lval.registerEnum.word = RCP_TEXTURE1_BLUE;
return(regVariable);
}
tex1 {
rc10_lval.registerEnum.word = RCP_TEXTURE1;
return(regVariable);
}
tex2\.rgb {
rc10_lval.registerEnum.word = RCP_TEXTURE2_RGB;
return(regVariable);
}
tex2\.a {
rc10_lval.registerEnum.word = RCP_TEXTURE2_ALPHA;
return(regVariable);
}
tex2\.b {
rc10_lval.registerEnum.word = RCP_TEXTURE2_BLUE;
return(regVariable);
}
tex2 {
rc10_lval.registerEnum.word = RCP_TEXTURE2;
return(regVariable);
}
tex3\.rgb {
rc10_lval.registerEnum.word = RCP_TEXTURE3_RGB;
return(regVariable);
}
tex3\.a {
rc10_lval.registerEnum.word = RCP_TEXTURE3_ALPHA;
return(regVariable);
}
tex3\.b {
rc10_lval.registerEnum.word = RCP_TEXTURE3_BLUE;
return(regVariable);
}
tex3 {
rc10_lval.registerEnum.word = RCP_TEXTURE3;
return(regVariable);
}
const0\.rgb {
rc10_lval.registerEnum.word = RCP_CONST_COLOR0_RGB;
return(regVariable);
}
const0\.a {
rc10_lval.registerEnum.word = RCP_CONST_COLOR0_ALPHA;
return(regVariable);
}
const0\.b {
rc10_lval.registerEnum.word = RCP_CONST_COLOR0_BLUE;
return(regVariable);
}
const0 {
rc10_lval.registerEnum.word = RCP_CONST_COLOR0;
return(constVariable);
}
const1\.rgb {
rc10_lval.registerEnum.word = RCP_CONST_COLOR1_RGB;
return(regVariable);
}
const1\.a {
rc10_lval.registerEnum.word = RCP_CONST_COLOR1_ALPHA;
return(regVariable);
}
const1\.b {
rc10_lval.registerEnum.word = RCP_CONST_COLOR1_BLUE;
return(regVariable);
}
const1 {
rc10_lval.registerEnum.word = RCP_CONST_COLOR1;
return(constVariable);
}
zero\.rgb {
rc10_lval.registerEnum.word = RCP_ZERO_RGB;
return(regVariable);
}
zero\.a {
rc10_lval.registerEnum.word = RCP_ZERO_ALPHA;
return(regVariable);
}
zero\.b {
rc10_lval.registerEnum.word = RCP_ZERO_BLUE;
return(regVariable);
}
zero {
rc10_lval.registerEnum.word = RCP_ZERO;
return(regVariable);
}
one\.rgb {
rc10_lval.registerEnum.word = RCP_ONE_RGB;
return(regVariable);
}
one\.a {
rc10_lval.registerEnum.word = RCP_ONE_ALPHA;
return(regVariable);
}
one\.b {
rc10_lval.registerEnum.word = RCP_ONE_BLUE;
return(regVariable);
}
one {
rc10_lval.registerEnum.word = RCP_ONE;
return(regVariable);
}
discard {
rc10_lval.registerEnum.word = RCP_DISCARD;
return(regVariable);
}
out\.rgb return(fragment_rgb);
out\.a return(fragment_alpha);
final_product {
rc10_lval.registerEnum.word = RCP_FINAL_PRODUCT;
return(final_product);
}
color_sum {
rc10_lval.registerEnum.word = RCP_COLOR_SUM;
return(color_sum);
}
expand return(expandString);
half_bias return(halfBiasString);
unsigned return(unsignedString);
unsigned_invert return(unsignedInvertString);
mux {
rc10_lval.ival = GL_TRUE;
return(muxString);
}
sum {
rc10_lval.ival = GL_FALSE;
return(sumString);
}
rgb {
rc10_lval.ival = RCP_RGB;
return(rgb_portion);
}
alpha {
rc10_lval.ival = RCP_ALPHA;
return(alpha_portion);
}
clamp_color_sum {
rc10_lval.ival = true;
return(clamp_color_sum);
}
lerp return(lerp);
bias_by_negative_one_half_scale_by_two {
rc10_lval.biasScaleEnum.word = RCP_BIAS_BY_NEGATIVE_ONE_HALF_SCALE_BY_TWO;
return(bias_by_negative_one_half_scale_by_two);
}
bias_by_negative_one_half {
rc10_lval.biasScaleEnum.word = RCP_BIAS_BY_NEGATIVE_ONE_HALF;
return(bias_by_negative_one_half);
}
scale_by_one_half {
rc10_lval.biasScaleEnum.word = RCP_SCALE_BY_ONE_HALF;
return(scale_by_one_half);
}
scale_by_two {
rc10_lval.biasScaleEnum.word = RCP_SCALE_BY_TWO;
return(scale_by_two);
}
scale_by_four {
rc10_lval.biasScaleEnum.word = RCP_SCALE_BY_FOUR;
return(scale_by_four);
}
[+-]?[0-9]+\.[0-9]* {
rc10_lval.fval = (float)atof(yytext);
return(floatValue);
}
[+-]?[0-9]*\.[0-9]+ {
rc10_lval.fval = (float)atof(yytext);
return(floatValue);
}
[+-]?[0-9]+ {
rc10_lval.fval = (float)atof(yytext);
return(floatValue);
}
\{ return(openBracket);
\} return(closeBracket);
\( return(openParen);
\) return(closeParen);
; return(semicolon);
, return(comma);
\. return(dot);
\* return(times);
- return(minus);
\+ return(plus);
= return(equals);
\r*\n {
line_number++;
}
[ \t]+ {}
{alphanum}+ {
errors.set("unrecognized token", line_number);
}
%%
bool rc10_init_more();
bool rc10_init(char* inputString)
{
myin = inputString;
return rc10_init_more();
}
#ifndef rc10_wrap
int rc10_wrap(void)
{
return(1);
}
#endif