Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / mesa3d / 8cc059ea6474c13bbba4f520ea1a63fd97a32450 / . / src / mesa / shader / arbprogparse.c
blob: 6cbdd39d297668c7509224383970262cfe0323be [file] [log] [blame]
/*
* Mesa 3-D graphics library
* Version: 6.1
*
* Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#define DEBUG_PARSING 0
/**
* \file arbprogparse.c
* ARB_*_program parser core
* \author Karl Rasche
*/
#include "mtypes.h"
#include "glheader.h"
#include "context.h"
#include "hash.h"
#include "imports.h"
#include "macros.h"
#include "program.h"
#include "nvvertprog.h"
#include "nvfragprog.h"
#include "arbprogparse.h"
#include "grammar_mesa.h"
/* TODO:
* Fragment Program Stuff:
* -----------------------------------------------------
*
* - things from Michal's email
* + overflow on atoi
* + not-overflowing floats (don't use parse_integer..)
* + can remove range checking in arbparse.c
*
* - check all limits of number of various variables
* + parameters
*
* - test! test! test!
*
* Vertex Program Stuff:
* -----------------------------------------------------
* - Optimize param array usage and count limits correctly, see spec,
* section 2.14.3.7
* + Record if an array is reference absolutly or relatively (or both)
* + For absolute arrays, store a bitmap of accesses
* + For single parameters, store an access flag
* + After parsing, make a parameter cleanup and merging pass, where
* relative arrays are layed out first, followed by abs arrays, and
* finally single state.
* + Remap offsets for param src and dst registers
* + Now we can properly count parameter usage
*
* - Multiple state binding errors in param arrays (see spec, just before
* section 2.14.3.3)
* - grep for XXX
*
* Mesa Stuff
* -----------------------------------------------------
* - User clipping planes vs. PositionInvariant
* - Is it sufficient to just multiply by the mvp to transform in the
* PositionInvariant case? Or do we need something more involved?
*
* - vp_src swizzle is GLubyte, fp_src swizzle is GLuint
* - fetch state listed in program_parameters list
* + WTF should this go???
* + currently in nvvertexec.c and s_nvfragprog.c
*
* - allow for multiple address registers (and fetch address regs properly)
*
* Cosmetic Stuff
* -----------------------------------------------------
* - remove any leftover unused grammer.c stuff (dict_ ?)
* - fix grammer.c error handling so its not static
* - #ifdef around stuff pertaining to extentions
*
* Outstanding Questions:
* -----------------------------------------------------
* - ARB_matrix_palette / ARB_vertex_blend -- not supported
* what gets hacked off because of this:
* + VERTEX_ATTRIB_MATRIXINDEX
* + VERTEX_ATTRIB_WEIGHT
* + MATRIX_MODELVIEW
* + MATRIX_PALETTE
*
* - When can we fetch env/local params from their own register files, and
* when to we have to fetch them into the main state register file?
* (think arrays)
*
* Grammar Changes:
* -----------------------------------------------------
*/
/* Changes since moving the file to shader directory
2004-III-4 ------------------------------------------------------------
- added #include "grammar_mesa.h"
- removed grammar specific code part (it resides now in grammar.c)
- added GL_ARB_fragment_program_shadow tokens
- modified #include "arbparse_syn.h"
- major changes inside _mesa_parse_arb_program()
- check the program string for '\0' characters
- copy the program string to a one-byte-longer location to have
it null-terminated
- position invariance test (not writing to result.position) moved
to syntax part
*/
typedef GLubyte *production;
/**
* This is the text describing the rules to parse the grammar
*/
static char arb_grammar_text[] =
#include "arbprogram_syn.h"
;
/**
* These should match up with the values defined in arbprogram.syn
*/
/*
Changes:
- changed and merged V_* and F_* opcode values to OP_*.
- added GL_ARB_fragment_program_shadow specific tokens (michal)
*/
#define REVISION 0x07
/* program type */
#define FRAGMENT_PROGRAM 0x01
#define VERTEX_PROGRAM 0x02
/* program section */
#define OPTION 0x01
#define INSTRUCTION 0x02
#define DECLARATION 0x03
#define END 0x04
/* GL_ARB_fragment_program option flags */
#define ARB_PRECISION_HINT_FASTEST 0x01
#define ARB_PRECISION_HINT_NICEST 0x02
#define ARB_FOG_EXP 0x04
#define ARB_FOG_EXP2 0x08
#define ARB_FOG_LINEAR 0x10
/* GL_ARB_vertex_program option flags */
#define ARB_POSITION_INVARIANT 0x20
/* GL_ARB_fragment_program_shadow option flags */
#define ARB_FRAGMENT_PROGRAM_SHADOW 0x40
/* GL_ARB_fragment_program instruction class */
#define OP_ALU_INST 0x00
#define OP_TEX_INST 0x01
/* GL_ARB_vertex_program instruction class */
/* OP_ALU_INST */
/* GL_ARB_fragment_program instruction type */
#define OP_ALU_VECTOR 0x00
#define OP_ALU_SCALAR 0x01
#define OP_ALU_BINSC 0x02
#define OP_ALU_BIN 0x03
#define OP_ALU_TRI 0x04
#define OP_ALU_SWZ 0x05
#define OP_TEX_SAMPLE 0x06
#define OP_TEX_KIL 0x07
/* GL_ARB_vertex_program instruction type */
#define OP_ALU_ARL 0x08
/* OP_ALU_VECTOR */
/* OP_ALU_SCALAR */
/* OP_ALU_BINSC */
/* OP_ALU_BIN */
/* OP_ALU_TRI */
/* OP_ALU_SWZ */
/* GL_ARB_fragment_program instruction code */
#define OP_ABS 0x00
#define OP_ABS_SAT 0x1B
#define OP_FLR 0x09
#define OP_FLR_SAT 0x26
#define OP_FRC 0x0A
#define OP_FRC_SAT 0x27
#define OP_LIT 0x0C
#define OP_LIT_SAT 0x2A
#define OP_MOV 0x11
#define OP_MOV_SAT 0x30
#define OP_COS 0x1F
#define OP_COS_SAT 0x20
#define OP_EX2 0x07
#define OP_EX2_SAT 0x25
#define OP_LG2 0x0B
#define OP_LG2_SAT 0x29
#define OP_RCP 0x14
#define OP_RCP_SAT 0x33
#define OP_RSQ 0x15
#define OP_RSQ_SAT 0x34
#define OP_SIN 0x38
#define OP_SIN_SAT 0x39
#define OP_SCS 0x35
#define OP_SCS_SAT 0x36
#define OP_POW 0x13
#define OP_POW_SAT 0x32
#define OP_ADD 0x01
#define OP_ADD_SAT 0x1C
#define OP_DP3 0x03
#define OP_DP3_SAT 0x21
#define OP_DP4 0x04
#define OP_DP4_SAT 0x22
#define OP_DPH 0x05
#define OP_DPH_SAT 0x23
#define OP_DST 0x06
#define OP_DST_SAT 0x24
#define OP_MAX 0x0F
#define OP_MAX_SAT 0x2E
#define OP_MIN 0x10
#define OP_MIN_SAT 0x2F
#define OP_MUL 0x12
#define OP_MUL_SAT 0x31
#define OP_SGE 0x16
#define OP_SGE_SAT 0x37
#define OP_SLT 0x17
#define OP_SLT_SAT 0x3A
#define OP_SUB 0x18
#define OP_SUB_SAT 0x3B
#define OP_XPD 0x1A
#define OP_XPD_SAT 0x43
#define OP_CMP 0x1D
#define OP_CMP_SAT 0x1E
#define OP_LRP 0x2B
#define OP_LRP_SAT 0x2C
#define OP_MAD 0x0E
#define OP_MAD_SAT 0x2D
#define OP_SWZ 0x19
#define OP_SWZ_SAT 0x3C
#define OP_TEX 0x3D
#define OP_TEX_SAT 0x3E
#define OP_TXB 0x3F
#define OP_TXB_SAT 0x40
#define OP_TXP 0x41
#define OP_TXP_SAT 0x42
#define OP_KIL 0x28
/* GL_ARB_vertex_program instruction code */
#define OP_ARL 0x02
/* OP_ABS */
/* OP_FLR */
/* OP_FRC */
/* OP_LIT */
/* OP_MOV */
/* OP_EX2 */
#define OP_EXP 0x08
/* OP_LG2 */
#define OP_LOG 0x0D
/* OP_RCP */
/* OP_RSQ */
/* OP_POW */
/* OP_ADD */
/* OP_DP3 */
/* OP_DP4 */
/* OP_DPH */
/* OP_DST */
/* OP_MAX */
/* OP_MIN */
/* OP_MUL */
/* OP_SGE */
/* OP_SLT */
/* OP_SUB */
/* OP_XPD */
/* OP_MAD */
/* OP_SWZ */
/* fragment attribute binding */
#define FRAGMENT_ATTRIB_COLOR 0x01
#define FRAGMENT_ATTRIB_TEXCOORD 0x02
#define FRAGMENT_ATTRIB_FOGCOORD 0x03
#define FRAGMENT_ATTRIB_POSITION 0x04
/* vertex attribute binding */
#define VERTEX_ATTRIB_POSITION 0x01
#define VERTEX_ATTRIB_WEIGHT 0x02
#define VERTEX_ATTRIB_NORMAL 0x03
#define VERTEX_ATTRIB_COLOR 0x04
#define VERTEX_ATTRIB_FOGCOORD 0x05
#define VERTEX_ATTRIB_TEXCOORD 0x06
#define VERTEX_ATTRIB_MATRIXINDEX 0x07
#define VERTEX_ATTRIB_GENERIC 0x08
/* fragment result binding */
#define FRAGMENT_RESULT_COLOR 0x01
#define FRAGMENT_RESULT_DEPTH 0x02
/* vertex result binding */
#define VERTEX_RESULT_POSITION 0x01
#define VERTEX_RESULT_COLOR 0x02
#define VERTEX_RESULT_FOGCOORD 0x03
#define VERTEX_RESULT_POINTSIZE 0x04
#define VERTEX_RESULT_TEXCOORD 0x05
/* texture target */
#define TEXTARGET_1D 0x01
#define TEXTARGET_2D 0x02
#define TEXTARGET_3D 0x03
#define TEXTARGET_RECT 0x04
#define TEXTARGET_CUBE 0x05
/* GL_ARB_fragment_program_shadow */
#define TEXTARGET_SHADOW1D 0x06
#define TEXTARGET_SHADOW2D 0x07
#define TEXTARGET_SHADOWRECT 0x08
/* face type */
#define FACE_FRONT 0x00
#define FACE_BACK 0x01
/* color type */
#define COLOR_PRIMARY 0x00
#define COLOR_SECONDARY 0x01
/* component */
#define COMPONENT_X 0x00
#define COMPONENT_Y 0x01
#define COMPONENT_Z 0x02
#define COMPONENT_W 0x03
#define COMPONENT_0 0x04
#define COMPONENT_1 0x05
/* array index type */
#define ARRAY_INDEX_ABSOLUTE 0x00
#define ARRAY_INDEX_RELATIVE 0x01
/* matrix name */
#define MATRIX_MODELVIEW 0x01
#define MATRIX_PROJECTION 0x02
#define MATRIX_MVP 0x03
#define MATRIX_TEXTURE 0x04
#define MATRIX_PALETTE 0x05
#define MATRIX_PROGRAM 0x06
/* matrix modifier */
#define MATRIX_MODIFIER_IDENTITY 0x00
#define MATRIX_MODIFIER_INVERSE 0x01
#define MATRIX_MODIFIER_TRANSPOSE 0x02
#define MATRIX_MODIFIER_INVTRANS 0x03
/* constant type */
#define CONSTANT_SCALAR 0x01
#define CONSTANT_VECTOR 0x02
/* program param type */
#define PROGRAM_PARAM_ENV 0x01
#define PROGRAM_PARAM_LOCAL 0x02
/* register type */
#define REGISTER_ATTRIB 0x01
#define REGISTER_PARAM 0x02
#define REGISTER_RESULT 0x03
#define REGISTER_ESTABLISHED_NAME 0x04
/* param binding */
#define PARAM_NULL 0x00
#define PARAM_ARRAY_ELEMENT 0x01
#define PARAM_STATE_ELEMENT 0x02
#define PARAM_PROGRAM_ELEMENT 0x03
#define PARAM_PROGRAM_ELEMENTS 0x04
#define PARAM_CONSTANT 0x05
/* param state property */
#define STATE_MATERIAL_PARSER 0x01
#define STATE_LIGHT_PARSER 0x02
#define STATE_LIGHT_MODEL 0x03
#define STATE_LIGHT_PROD 0x04
#define STATE_FOG 0x05
#define STATE_MATRIX_ROWS 0x06
/* GL_ARB_fragment_program */
#define STATE_TEX_ENV 0x07
#define STATE_DEPTH 0x08
/* GL_ARB_vertex_program */
#define STATE_TEX_GEN 0x09
#define STATE_CLIP_PLANE 0x0A
#define STATE_POINT 0x0B
/* state material property */
#define MATERIAL_AMBIENT 0x01
#define MATERIAL_DIFFUSE 0x02
#define MATERIAL_SPECULAR 0x03
#define MATERIAL_EMISSION 0x04
#define MATERIAL_SHININESS 0x05
/* state light property */
#define LIGHT_AMBIENT 0x01
#define LIGHT_DIFFUSE 0x02
#define LIGHT_SPECULAR 0x03
#define LIGHT_POSITION 0x04
#define LIGHT_ATTENUATION 0x05
#define LIGHT_HALF 0x06
#define LIGHT_SPOT_DIRECTION 0x07
/* state light model property */
#define LIGHT_MODEL_AMBIENT 0x01
#define LIGHT_MODEL_SCENECOLOR 0x02
/* state light product property */
#define LIGHT_PROD_AMBIENT 0x01
#define LIGHT_PROD_DIFFUSE 0x02
#define LIGHT_PROD_SPECULAR 0x03
/* state texture environment property */
#define TEX_ENV_COLOR 0x01
/* state texture generation coord property */
#define TEX_GEN_EYE 0x01
#define TEX_GEN_OBJECT 0x02
/* state fog property */
#define FOG_COLOR 0x01
#define FOG_PARAMS 0x02
/* state depth property */
#define DEPTH_RANGE 0x01
/* state point parameters property */
#define POINT_SIZE 0x01
#define POINT_ATTENUATION 0x02
/* declaration */
#define ATTRIB 0x01
#define PARAM 0x02
#define TEMP 0x03
#define OUTPUT 0x04
#define ALIAS 0x05
/* GL_ARB_vertex_program */
#define ADDRESS 0x06
/*-----------------------------------------------------------------------
* From here on down is the semantic checking portion
*
*/
/**
* Variable Table Handling functions
*/
typedef enum
{
vt_none,
vt_address,
vt_attrib,
vt_param,
vt_temp,
vt_output,
vt_alias
} var_type;
/*
* Setting an explicit field for each of the binding properties is a bit wasteful
* of space, but it should be much more clear when reading later on..
*/
struct var_cache
{
GLubyte *name;
var_type type;
GLuint address_binding; /* The index of the address register we should
* be using */
GLuint attrib_binding; /* For type vt_attrib, see nvfragprog.h for values */
GLuint attrib_binding_idx; /* The index into the attrib register file corresponding
* to the state in attrib_binding */
GLuint attrib_is_generic; /* If the attrib was specified through a generic
* vertex attrib */
GLuint temp_binding; /* The index of the temp register we are to use */
GLuint output_binding; /* For type vt_output, see nvfragprog.h for values */
GLuint output_binding_idx; /* This is the index into the result register file
* corresponding to the bound result state */
struct var_cache *alias_binding; /* For type vt_alias, points to the var_cache entry
* that this is aliased to */
GLuint param_binding_type; /* {PROGRAM_STATE_VAR, PROGRAM_LOCAL_PARAM,
* PROGRAM_ENV_PARAM} */
GLuint param_binding_begin; /* This is the offset into the program_parameter_list where
* the tokens representing our bound state (or constants)
* start */
GLuint param_binding_length; /* This is how many entries in the the program_parameter_list
* we take up with our state tokens or constants. Note that
* this is _not_ the same as the number of param registers
* we eventually use */
struct var_cache *next;
};
static GLvoid
var_cache_create (struct var_cache **va)
{
*va = (struct var_cache *) _mesa_malloc (sizeof (struct var_cache));
if (*va) {
(**va).name = NULL;
(**va).type = vt_none;
(**va).attrib_binding = ~0;
(**va).attrib_is_generic = 0;
(**va).temp_binding = ~0;
(**va).output_binding = ~0;
(**va).output_binding_idx = ~0;
(**va).param_binding_type = ~0;
(**va).param_binding_begin = ~0;
(**va).param_binding_length = ~0;
(**va).alias_binding = NULL;
(**va).next = NULL;
}
}
static GLvoid
var_cache_destroy (struct var_cache **va)
{
if (*va) {
var_cache_destroy (&(**va).next);
_mesa_free (*va);
*va = NULL;
}
}
static GLvoid
var_cache_append (struct var_cache **va, struct var_cache *nv)
{
if (*va)
var_cache_append (&(**va).next, nv);
else
*va = nv;
}
static struct var_cache *
var_cache_find (struct var_cache *va, GLubyte * name)
{
struct var_cache *first = va;
while (va) {
if (!strcmp ( (const char*) name, (const char*) va->name)) {
if (va->type == vt_alias)
return var_cache_find (first, va->name);
return va;
}
va = va->next;
}
return NULL;
}
/**
* constructs an integer from 4 GLubytes in LE format
*/
static GLuint
parse_position (GLubyte ** inst)
{
GLuint value;
value = (GLuint) (*(*inst)++);
value += (GLuint) (*(*inst)++) * 0x100;
value += (GLuint) (*(*inst)++) * 0x10000;
value += (GLuint) (*(*inst)++) * 0x1000000;
return value;
}
/**
* This will, given a string, lookup the string as a variable name in the
* var cache. If the name is found, the var cache node corresponding to the
* var name is returned. If it is not found, a new entry is allocated
*
* \param I Points into the binary array where the string identifier begins
* \param found 1 if the string was found in the var_cache, 0 if it was allocated
* \return The location on the var_cache corresponding the the string starting at I
*/
static struct var_cache *
parse_string (GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program, GLuint * found)
{
GLubyte *i = *inst;
struct var_cache *va = NULL;
*inst += _mesa_strlen ((char *) i) + 1;
va = var_cache_find (*vc_head, i);
if (va) {
*found = 1;
return va;
}
*found = 0;
var_cache_create (&va);
va->name = i;
var_cache_append (vc_head, va);
return va;
}
static char *
parse_string_without_adding (GLubyte ** inst, struct arb_program *Program)
{
GLubyte *i = *inst;
*inst += _mesa_strlen ((char *) i) + 1;
return (char *) i;
}
/**
* \return 0 if sign is plus, 1 if sign is minus
*/
static GLuint
parse_sign (GLubyte ** inst)
{
/*return *(*inst)++ != '+'; */
if (**inst == '-') {
(*inst)++;
return 1;
}
else if (**inst == '+') {
(*inst)++;
return 0;
}
return 0;
}
/**
* parses and returns signed integer
*/
static GLint
parse_integer (GLubyte ** inst, struct arb_program *Program)
{
GLint sign;
GLint value;
/* check if *inst points to '+' or '-'
* if yes, grab the sign and increment *inst
*/
sign = parse_sign (inst);
/* now check if *inst points to 0
* if yes, increment the *inst and return the default value
*/
if (**inst == 0) {
(*inst)++;
return 0;
}
/* parse the integer as you normally would do it */
value = _mesa_atoi (parse_string_without_adding (inst, Program));
/* now, after terminating 0 there is a position
* to parse it - parse_position()
*/
Program->Position = parse_position (inst);
if (sign)
value *= -1;
return value;
}
/**
*/
static GLfloat
parse_float (GLubyte ** inst, struct arb_program *Program)
{
GLint tmp[5], denom;
GLuint leading_zeros =0;
GLfloat value = 0;
#if 0
tmp[0] = parse_sign (inst); /* This is the sign of the number + - >0, - -> 1 */
#endif
tmp[1] = parse_integer (inst, Program); /* This is the integer portion of the number */
/* Now we grab the fractional portion of the number (the digits after
* the .). We can have leading 0's here, which parse_integer will ignore,
* so we'll check for those first
*/
while ((**inst == '0') && ( *(*inst+1) != 0))
{
leading_zeros++;
(*inst)++;
}
tmp[2] = parse_integer (inst, Program); /* This is the fractional portion of the number */
tmp[3] = parse_sign (inst); /* This is the sign of the exponent */
tmp[4] = parse_integer (inst, Program); /* This is the exponent */
value = (GLfloat) tmp[1];
denom = 1;
while (denom < tmp[2])
denom *= 10;
denom *= (GLint) _mesa_pow( 10, leading_zeros );
value += (GLfloat) tmp[2] / (GLfloat) denom;
#if 0
if (tmp[0])
value *= -1;
#endif
value *= (GLfloat) _mesa_pow (10, (GLfloat) tmp[3] * (GLfloat) tmp[4]);
return value;
}
/**
*/
static GLfloat
parse_signed_float (GLubyte ** inst, struct arb_program *Program)
{
GLint negate;
GLfloat value;
negate = parse_sign (inst);
value = parse_float (inst, Program);
if (negate)
value *= -1;
return value;
}
/**
* This picks out a constant value from the parsed array. The constant vector is r
* returned in the *values array, which should be of length 4.
*
* \param values - The 4 component vector with the constant value in it
*/
static GLvoid
parse_constant (GLubyte ** inst, GLfloat *values, struct arb_program *Program,
GLboolean use)
{
GLuint components, i;
switch (*(*inst)++) {
case CONSTANT_SCALAR:
if (use == GL_TRUE) {
values[0] =
values[1] =
values[2] = values[3] = parse_float (inst, Program);
}
else {
values[0] =
values[1] =
values[2] = values[3] = parse_signed_float (inst, Program);
}
break;
case CONSTANT_VECTOR:
values[0] = values[1] = values[2] = 0;
values[3] = 1;
components = *(*inst)++;
for (i = 0; i < components; i++) {
values[i] = parse_signed_float (inst, Program);
}
break;
}
}
/**
* \param offset The offset from the address register that we should
* address
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_relative_offset (GLcontext *ctx, GLubyte **inst, struct arb_program *Program,
GLint *offset)
{
*offset = parse_integer(inst, Program);
if ((*offset > 63) || (*offset < -64)) {
_mesa_set_program_error (ctx, Program->Position,
"Relative offset out of range");
_mesa_error (ctx, GL_INVALID_OPERATION, "Relative offset %d out of range",
*offset);
return 1;
}
return 0;
}
/**
* \param color 0 if color type is primary, 1 if color type is secondary
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_color_type (GLcontext * ctx, GLubyte ** inst, struct arb_program *Program,
GLint * color)
{
*color = *(*inst)++ != COLOR_PRIMARY;
return 0;
}
/**
* Get an integer corresponding to a generic vertex attribute.
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_generic_attrib_num(GLcontext *ctx, GLubyte ** inst,
struct arb_program *Program, GLuint *attrib)
{
*attrib = parse_integer(inst, Program);
if ((*attrib < 0) || (*attrib > MAX_VERTEX_PROGRAM_ATTRIBS))
{
_mesa_set_program_error (ctx, Program->Position,
"Invalid generic vertex attribute index");
_mesa_error (ctx, GL_INVALID_OPERATION, "Invalid generic vertex attribute index");
return 1;
}
return 0;
}
/**
* \param coord The texture unit index
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_texcoord_num (GLcontext * ctx, GLubyte ** inst,
struct arb_program *Program, GLuint * coord)
{
*coord = parse_integer (inst, Program);
if ((*coord < 0) || (*coord >= ctx->Const.MaxTextureUnits)) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid texture unit index");
_mesa_error (ctx, GL_INVALID_OPERATION, "Invalid texture unit index");
return 1;
}
return 0;
}
/**
* \param coord The weight index
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_weight_num (GLcontext * ctx, GLubyte ** inst, struct arb_program *Program,
GLint * coord)
{
*coord = parse_integer (inst, Program);
if ((*coord < 0) || (*coord >= 1)) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid weight index");
_mesa_error (ctx, GL_INVALID_OPERATION, "Invalid weight index");
return 1;
}
return 0;
}
/**
* \param coord The clip plane index
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_clipplane_num (GLcontext * ctx, GLubyte ** inst,
struct arb_program *Program, GLint * coord)
{
*coord = parse_integer (inst, Program);
if ((*coord < 0) || (*coord >= (GLint) ctx->Const.MaxClipPlanes)) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid clip plane index");
_mesa_error (ctx, GL_INVALID_OPERATION, "Invalid clip plane index");
return 1;
}
return 0;
}
/**
* \return 0 on front face, 1 on back face
*/
static GLuint
parse_face_type (GLubyte ** inst)
{
switch (*(*inst)++) {
case FACE_FRONT:
return 0;
case FACE_BACK:
return 1;
}
return 0;
}
/**
* Given a matrix and a modifier token on the binary array, return tokens
* that _mesa_fetch_state() [program.c] can understand.
*
* \param matrix - the matrix we are talking about
* \param matrix_idx - the index of the matrix we have (for texture & program matricies)
* \param matrix_modifier - the matrix modifier (trans, inv, etc)
* \return 0 on sucess, 1 on failure
*/
static GLuint
parse_matrix (GLcontext * ctx, GLubyte ** inst, struct arb_program *Program,
GLint * matrix, GLint * matrix_idx, GLint * matrix_modifier)
{
GLubyte mat = *(*inst)++;
*matrix_idx = 0;
switch (mat) {
case MATRIX_MODELVIEW:
*matrix = STATE_MODELVIEW;
*matrix_idx = parse_integer (inst, Program);
if (*matrix_idx > 0) {
_mesa_set_program_error (ctx, Program->Position,
"ARB_vertex_blend not supported\n");
_mesa_error (ctx, GL_INVALID_OPERATION,
"ARB_vertex_blend not supported\n");
return 1;
}
break;
case MATRIX_PROJECTION:
*matrix = STATE_PROJECTION;
break;
case MATRIX_MVP:
*matrix = STATE_MVP;
break;
case MATRIX_TEXTURE:
*matrix = STATE_TEXTURE;
*matrix_idx = parse_integer (inst, Program);
if (*matrix_idx >= (GLint) ctx->Const.MaxTextureUnits) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid Texture Unit");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Invalid Texture Unit: %d", *matrix_idx);
return 1;
}
break;
/* This is not currently supported (ARB_matrix_palette) */
case MATRIX_PALETTE:
*matrix_idx = parse_integer (inst, Program);
_mesa_set_program_error (ctx, Program->Position,
"ARB_matrix_palette not supported\n");
_mesa_error (ctx, GL_INVALID_OPERATION,
"ARB_matrix_palette not supported\n");
return 1;
break;
case MATRIX_PROGRAM:
*matrix = STATE_PROGRAM;
*matrix_idx = parse_integer (inst, Program);
if (*matrix_idx >= (GLint) ctx->Const.MaxProgramMatrices) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid Program Matrix");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Invalid Program Matrix: %d", *matrix_idx);
return 1;
}
break;
}
switch (*(*inst)++) {
case MATRIX_MODIFIER_IDENTITY:
*matrix_modifier = 0;
break;
case MATRIX_MODIFIER_INVERSE:
*matrix_modifier = STATE_MATRIX_INVERSE;
break;
case MATRIX_MODIFIER_TRANSPOSE:
*matrix_modifier = STATE_MATRIX_TRANSPOSE;
break;
case MATRIX_MODIFIER_INVTRANS:
*matrix_modifier = STATE_MATRIX_INVTRANS;
break;
}
return 0;
}
/**
* This parses a state string (rather, the binary version of it) into
* a 6-token sequence as described in _mesa_fetch_state() [program.c]
*
* \param inst - the start in the binary arry to start working from
* \param state_tokens - the storage for the 6-token state description
* \return - 0 on sucess, 1 on error
*/
static GLuint
parse_state_single_item (GLcontext * ctx, GLubyte ** inst,
struct arb_program *Program, GLint * state_tokens)
{
switch (*(*inst)++) {
case STATE_MATERIAL_PARSER:
state_tokens[0] = STATE_MATERIAL;
state_tokens[1] = parse_face_type (inst);
switch (*(*inst)++) {
case MATERIAL_AMBIENT:
state_tokens[2] = STATE_AMBIENT;
break;
case MATERIAL_DIFFUSE:
state_tokens[2] = STATE_DIFFUSE;
break;
case MATERIAL_SPECULAR:
state_tokens[2] = STATE_SPECULAR;
break;
case MATERIAL_EMISSION:
state_tokens[2] = STATE_EMISSION;
break;
case MATERIAL_SHININESS:
state_tokens[2] = STATE_SHININESS;
break;
}
break;
case STATE_LIGHT_PARSER:
state_tokens[0] = STATE_LIGHT;
state_tokens[1] = parse_integer (inst, Program);
/* Check the value of state_tokens[1] against the # of lights */
if (state_tokens[1] >= (GLint) ctx->Const.MaxLights) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid Light Number");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Invalid Light Number: %d", state_tokens[1]);
return 1;
}
switch (*(*inst)++) {
case LIGHT_AMBIENT:
state_tokens[2] = STATE_AMBIENT;
break;
case LIGHT_DIFFUSE:
state_tokens[2] = STATE_DIFFUSE;
break;
case LIGHT_SPECULAR:
state_tokens[2] = STATE_SPECULAR;
break;
case LIGHT_POSITION:
state_tokens[2] = STATE_POSITION;
break;
case LIGHT_ATTENUATION:
state_tokens[2] = STATE_ATTENUATION;
break;
case LIGHT_HALF:
state_tokens[2] = STATE_HALF;
break;
case LIGHT_SPOT_DIRECTION:
state_tokens[2] = STATE_SPOT_DIRECTION;
break;
}
break;
case STATE_LIGHT_MODEL:
switch (*(*inst)++) {
case LIGHT_MODEL_AMBIENT:
state_tokens[0] = STATE_LIGHTMODEL_AMBIENT;
break;
case LIGHT_MODEL_SCENECOLOR:
state_tokens[0] = STATE_LIGHTMODEL_SCENECOLOR;
state_tokens[1] = parse_face_type (inst);
break;
}
break;
case STATE_LIGHT_PROD:
state_tokens[0] = STATE_LIGHTPROD;
state_tokens[1] = parse_integer (inst, Program);
/* Check the value of state_tokens[1] against the # of lights */
if (state_tokens[1] >= (GLint) ctx->Const.MaxLights) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid Light Number");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Invalid Light Number: %d", state_tokens[1]);
return 1;
}
state_tokens[2] = parse_face_type (inst);
switch (*(*inst)++) {
case LIGHT_PROD_AMBIENT:
state_tokens[3] = STATE_AMBIENT;
break;
case LIGHT_PROD_DIFFUSE:
state_tokens[3] = STATE_DIFFUSE;
break;
case LIGHT_PROD_SPECULAR:
state_tokens[3] = STATE_SPECULAR;
break;
}
break;
case STATE_FOG:
switch (*(*inst)++) {
case FOG_COLOR:
state_tokens[0] = STATE_FOG_COLOR;
break;
case FOG_PARAMS:
state_tokens[0] = STATE_FOG_PARAMS;
break;
}
break;
case STATE_TEX_ENV:
state_tokens[1] = parse_integer (inst, Program);
switch (*(*inst)++) {
case TEX_ENV_COLOR:
state_tokens[0] = STATE_TEXENV_COLOR;
break;
}
break;
case STATE_TEX_GEN:
{
GLuint type, coord;
state_tokens[0] = STATE_TEXGEN;
/*state_tokens[1] = parse_integer (inst, Program);*/ /* Texture Unit */
if (parse_texcoord_num (ctx, inst, Program, &coord))
return 1;
state_tokens[1] = coord;
/* EYE or OBJECT */
type = *(*inst++);
/* 0 - s, 1 - t, 2 - r, 3 - q */
coord = *(*inst++);
if (type == TEX_GEN_EYE) {
switch (coord) {
case COMPONENT_X:
state_tokens[2] = STATE_TEXGEN_EYE_S;
break;
case COMPONENT_Y:
state_tokens[2] = STATE_TEXGEN_EYE_T;
break;
case COMPONENT_Z:
state_tokens[2] = STATE_TEXGEN_EYE_R;
break;
case COMPONENT_W:
state_tokens[2] = STATE_TEXGEN_EYE_Q;
break;
}
}
else {
switch (coord) {
case COMPONENT_X:
state_tokens[2] = STATE_TEXGEN_OBJECT_S;
break;
case COMPONENT_Y:
state_tokens[2] = STATE_TEXGEN_OBJECT_T;
break;
case COMPONENT_Z:
state_tokens[2] = STATE_TEXGEN_OBJECT_R;
break;
case COMPONENT_W:
state_tokens[2] = STATE_TEXGEN_OBJECT_Q;
break;
}
}
}
break;
case STATE_DEPTH:
switch (*(*inst)++) {
case DEPTH_RANGE:
state_tokens[0] = STATE_DEPTH_RANGE;
break;
}
break;
case STATE_CLIP_PLANE:
state_tokens[0] = STATE_CLIPPLANE;
state_tokens[1] = parse_integer (inst, Program);
if (parse_clipplane_num (ctx, inst, Program, &state_tokens[1]))
return 1;
break;
case STATE_POINT:
switch (*(*inst++)) {
case POINT_SIZE:
state_tokens[0] = STATE_POINT_SIZE;
break;
case POINT_ATTENUATION:
state_tokens[0] = STATE_POINT_ATTENUATION;
break;
}
break;
/* XXX: I think this is the correct format for a matrix row */
case STATE_MATRIX_ROWS:
state_tokens[0] = STATE_MATRIX;
if (parse_matrix
(ctx, inst, Program, &state_tokens[1], &state_tokens[2],
&state_tokens[5]))
return 1;
state_tokens[3] = parse_integer (inst, Program); /* The first row to grab */
if ((**inst) != 0) { /* Either the last row, 0 */
state_tokens[4] = parse_integer (inst, Program);
if (state_tokens[4] < state_tokens[3]) {
_mesa_set_program_error (ctx, Program->Position,
"Second matrix index less than the first");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Second matrix index (%d) less than the first (%d)",
state_tokens[4], state_tokens[3]);
return 1;
}
}
else {
state_tokens[4] = state_tokens[3];
(*inst)++;
}
break;
}
return 0;
}
/**
* This parses a state string (rather, the binary version of it) into
* a 6-token similar for the state fetching code in program.c
*
* One might ask, why fetch these parameters into just like you fetch
* state when they are already stored in other places?
*
* Because of array offsets -> We can stick env/local parameters in the
* middle of a parameter array and then index someplace into the array
* when we execute.
*
* One optimization might be to only do this for the cases where the
* env/local parameters end up inside of an array, and leave the
* single parameters (or arrays of pure env/local pareameters) in their
* respective register files.
*
* For ENV parameters, the format is:
* state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM
* state_tokens[1] = STATE_ENV
* state_tokens[2] = the parameter index
*
* for LOCAL parameters, the format is:
* state_tokens[0] = STATE_FRAGMENT_PROGRAM / STATE_VERTEX_PROGRAM
* state_tokens[1] = STATE_LOCAL
* state_tokens[2] = the parameter index
*
* \param inst - the start in the binary arry to start working from
* \param state_tokens - the storage for the 6-token state description
* \return - 0 on sucess, 1 on failure
*/
static GLuint
parse_program_single_item (GLcontext * ctx, GLubyte ** inst,
struct arb_program *Program, GLint * state_tokens)
{
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB)
state_tokens[0] = STATE_FRAGMENT_PROGRAM;
else
state_tokens[0] = STATE_VERTEX_PROGRAM;
switch (*(*inst)++) {
case PROGRAM_PARAM_ENV:
state_tokens[1] = STATE_ENV;
state_tokens[2] = parse_integer (inst, Program);
/* Check state_tokens[2] against the number of ENV parameters available */
if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
(state_tokens[2] >= (GLint) ctx->Const.MaxFragmentProgramEnvParams))
||
((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
(state_tokens[2] >= (GLint) ctx->Const.MaxVertexProgramEnvParams))) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid Program Env Parameter");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Invalid Program Env Parameter: %d",
state_tokens[2]);
return 1;
}
break;
case PROGRAM_PARAM_LOCAL:
state_tokens[1] = STATE_LOCAL;
state_tokens[2] = parse_integer (inst, Program);
/* Check state_tokens[2] against the number of LOCAL parameters available */
if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
(state_tokens[2] >= (GLint) ctx->Const.MaxFragmentProgramLocalParams))
||
((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
(state_tokens[2] >= (GLint) ctx->Const.MaxVertexProgramLocalParams))) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid Program Local Parameter");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Invalid Program Local Parameter: %d",
state_tokens[2]);
return 1;
}
break;
}
return 0;
}
/**
* For ARB_vertex_program, programs are not allowed to use both an explicit
* vertex attribute and a generic vertex attribute corresponding to the same
* state. See section 2.14.3.1 of the GL_ARB_vertex_program spec.
*
* This will walk our var_cache and make sure that nobody does anything fishy.
*
* \return 0 on sucess, 1 on error
*/
static GLuint
generic_attrib_check(struct var_cache *vc_head)
{
int a;
struct var_cache *curr;
GLboolean explicitAttrib[MAX_VERTEX_PROGRAM_ATTRIBS],
genericAttrib[MAX_VERTEX_PROGRAM_ATTRIBS];
for (a=0; a<MAX_VERTEX_PROGRAM_ATTRIBS; a++) {
explicitAttrib[a] = GL_FALSE;
genericAttrib[a] = GL_FALSE;
}
curr = vc_head;
while (curr) {
if (curr->type == vt_attrib) {
if (curr->attrib_is_generic)
genericAttrib[ curr->attrib_binding_idx ] = GL_TRUE;
else
explicitAttrib[ curr->attrib_binding_idx ] = GL_TRUE;
}
curr = curr->next;
}
for (a=0; a<MAX_VERTEX_PROGRAM_ATTRIBS; a++) {
if ((explicitAttrib[a]) && (genericAttrib[a]))
return 1;
}
return 0;
}
/**
* This will handle the binding side of an ATTRIB var declaration
*
* \param binding - the fragment input register state, defined in nvfragprog.h
* \param binding_idx - the index in the attrib register file that binding is associated with
* \return returns 0 on sucess, 1 on error
*
* See nvfragparse.c for attrib register file layout
*/
static GLuint
parse_attrib_binding (GLcontext * ctx, GLubyte ** inst,
struct arb_program *Program, GLuint * binding,
GLuint * binding_idx, GLuint *is_generic)
{
GLuint texcoord;
GLint coord;
GLint err = 0;
*is_generic = 0;
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
switch (*(*inst)++) {
case FRAGMENT_ATTRIB_COLOR:
err = parse_color_type (ctx, inst, Program, &coord);
*binding = FRAG_ATTRIB_COL0 + coord;
*binding_idx = 1 + coord;
break;
case FRAGMENT_ATTRIB_TEXCOORD:
err = parse_texcoord_num (ctx, inst, Program, &texcoord);
*binding = FRAG_ATTRIB_TEX0 + texcoord;
*binding_idx = 4 + texcoord;
break;
case FRAGMENT_ATTRIB_FOGCOORD:
*binding = FRAG_ATTRIB_FOGC;
*binding_idx = 3;
break;
case FRAGMENT_ATTRIB_POSITION:
*binding = FRAG_ATTRIB_WPOS;
*binding_idx = 0;
break;
default:
err = 1;
break;
}
}
else {
switch (*(*inst)++) {
case VERTEX_ATTRIB_POSITION:
*binding = VERT_ATTRIB_POS;
*binding_idx = 0;
break;
case VERTEX_ATTRIB_WEIGHT:
{
GLint weight;
err = parse_weight_num (ctx, inst, Program, &weight);
*binding = VERT_ATTRIB_WEIGHT;
*binding_idx = 1;
}
_mesa_set_program_error (ctx, Program->Position,
"ARB_vertex_blend not supported\n");
_mesa_error (ctx, GL_INVALID_OPERATION,
"ARB_vertex_blend not supported\n");
return 1;
break;
case VERTEX_ATTRIB_NORMAL:
*binding = VERT_ATTRIB_NORMAL;
*binding_idx = 2;
break;
case VERTEX_ATTRIB_COLOR:
{
GLint color;
err = parse_color_type (ctx, inst, Program, &color);
if (color) {
*binding = VERT_ATTRIB_COLOR1;
*binding_idx = 4;
}
else {
*binding = VERT_ATTRIB_COLOR0;
*binding_idx = 3;
}
}
break;
case VERTEX_ATTRIB_FOGCOORD:
*binding = VERT_ATTRIB_FOG;
*binding_idx = 5;
break;
case VERTEX_ATTRIB_TEXCOORD:
{
GLuint unit;
err = parse_texcoord_num (ctx, inst, Program, &unit);
*binding = VERT_ATTRIB_TEX0 + unit;
*binding_idx = 8 + unit;
}
break;
/* It looks like we don't support this at all, atm */
case VERTEX_ATTRIB_MATRIXINDEX:
parse_integer (inst, Program);
_mesa_set_program_error (ctx, Program->Position,
"ARB_palette_matrix not supported");
_mesa_error (ctx, GL_INVALID_OPERATION,
"ARB_palette_matrix not supported");
return 1;
break;
case VERTEX_ATTRIB_GENERIC:
{
GLuint attrib;
if (!parse_generic_attrib_num(ctx, inst, Program, &attrib)) {
*is_generic = 1;
switch (attrib) {
case 0:
*binding = VERT_ATTRIB_POS;
break;
case 1:
*binding = VERT_ATTRIB_WEIGHT;
break;
case 2:
*binding = VERT_ATTRIB_NORMAL;
break;
case 3:
*binding = VERT_ATTRIB_COLOR0;
break;
case 4:
*binding = VERT_ATTRIB_COLOR1;
break;
case 5:
*binding = VERT_ATTRIB_FOG;
break;
case 6:
break;
case 7:
break;
default:
*binding = VERT_ATTRIB_TEX0 + (attrib-8);
break;
}
*binding_idx = attrib;
}
}
break;
default:
err = 1;
break;
}
}
/* Can this even happen? */
if (err) {
_mesa_set_program_error (ctx, Program->Position,
"Bad attribute binding");
_mesa_error (ctx, GL_INVALID_OPERATION, "Bad attribute binding");
}
Program->InputsRead |= (1 << *binding_idx);
return err;
}
/**
* This translates between a binary token for an output variable type
* and the mesa token for the same thing.
*
*
* XXX: What is the 'name' for vertex program state? -> do we need it?
* I don't think we do;
*
* See nvfragprog.h for definitions
*
* \param inst - The parsed tokens
* \param binding - The name of the state we are binding too
* \param binding_idx - The index into the result register file that this is bound too
*
* See nvfragparse.c for the register file layout for fragment programs
* See nvvertparse.c for the register file layout for vertex programs
*/
static GLuint
parse_result_binding (GLcontext * ctx, GLubyte ** inst, GLuint * binding,
GLuint * binding_idx, struct arb_program *Program)
{
GLuint b;
switch (*(*inst)++) {
case FRAGMENT_RESULT_COLOR:
/* for frag programs, this is FRAGMENT_RESULT_COLOR */
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
*binding = FRAG_OUTPUT_COLR;
*binding_idx = 0;
}
/* for vtx programs, this is VERTEX_RESULT_POSITION */
else {
*binding_idx = 0;
}
break;
case FRAGMENT_RESULT_DEPTH:
/* for frag programs, this is FRAGMENT_RESULT_DEPTH */
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
*binding = FRAG_OUTPUT_DEPR;
*binding_idx = 2;
}
/* for vtx programs, this is VERTEX_RESULT_COLOR */
else {
GLint color_type;
GLuint face_type = parse_face_type(inst);
GLint color_type_ret = parse_color_type(ctx, inst, Program, &color_type);
/* back face */
if (face_type) {
if (color_type_ret) return 1;
/* secondary color */
if (color_type) {
*binding_idx = 4;
}
/* primary color */
else {
*binding_idx = 3;
}
}
/* front face */
else {
/* secondary color */
if (color_type) {
*binding_idx = 2;
}
/* primary color */
else {
*binding_idx = 1;
}
}
}
break;
case VERTEX_RESULT_FOGCOORD:
*binding_idx = 5;
break;
case VERTEX_RESULT_POINTSIZE:
*binding_idx = 6;
break;
case VERTEX_RESULT_TEXCOORD:
if (parse_texcoord_num (ctx, inst, Program, &b))
return 1;
*binding_idx = 7 + b;
break;
}
Program->OutputsWritten |= (1 << *binding_idx);
return 0;
}
/**
* This handles the declaration of ATTRIB variables
*
* XXX: Still needs
* parse_vert_attrib_binding(), or something like that
*
* \return 0 on sucess, 1 on error
*/
static GLint
parse_attrib (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program)
{
GLuint found;
char *error_msg;
struct var_cache *attrib_var;
attrib_var = parse_string (inst, vc_head, Program, &found);
Program->Position = parse_position (inst);
if (found) {
error_msg = (char *)
_mesa_malloc (_mesa_strlen ((char *) attrib_var->name) + 40);
_mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s",
attrib_var->name);
_mesa_set_program_error (ctx, Program->Position, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, error_msg);
_mesa_free (error_msg);
return 1;
}
attrib_var->type = vt_attrib;
/* I think this is ok now - karl */
/* XXX: */
/*if (Program->type == GL_FRAGMENT_PROGRAM_ARB) */
{
if (parse_attrib_binding
(ctx, inst, Program, &attrib_var->attrib_binding,
&attrib_var->attrib_binding_idx, &attrib_var->attrib_is_generic))
return 1;
if (generic_attrib_check(*vc_head)) {
_mesa_set_program_error (ctx, Program->Position,
"Cannot use both a generic vertex attribute and a specific attribute of the same type");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Cannot use both a generic vertex attribute and a specific attribute of the same type");
return 1;
}
}
Program->Base.NumAttributes++;
return 0;
}
/**
* \param use -- TRUE if we're called when declaring implicit parameters,
* FALSE if we're declaraing variables. This has to do with
* if we get a signed or unsigned float for scalar constants
*/
static GLuint
parse_param_elements (GLcontext * ctx, GLubyte ** inst,
struct var_cache *param_var,
struct arb_program *Program, GLboolean use)
{
GLint idx;
GLuint err;
GLint state_tokens[6];
GLfloat const_values[4];
err = 0;
switch (*(*inst)++) {
case PARAM_STATE_ELEMENT:
if (parse_state_single_item (ctx, inst, Program, state_tokens))
return 1;
/* If we adding STATE_MATRIX that has multiple rows, we need to
* unroll it and call _mesa_add_state_reference() for each row
*/
if ((state_tokens[0] == STATE_MATRIX)
&& (state_tokens[3] != state_tokens[4])) {
GLint row;
GLint first_row = state_tokens[3];
GLint last_row = state_tokens[4];
for (row = first_row; row <= last_row; row++) {
state_tokens[3] = state_tokens[4] = row;
idx =
_mesa_add_state_reference (Program->Parameters,
state_tokens);
if (param_var->param_binding_begin == ~0U)
param_var->param_binding_begin = idx;
param_var->param_binding_length++;
Program->Base.NumParameters++;
}
}
else {
idx =
_mesa_add_state_reference (Program->Parameters, state_tokens);
if (param_var->param_binding_begin == ~0U)
param_var->param_binding_begin = idx;
param_var->param_binding_length++;
Program->Base.NumParameters++;
}
break;
case PARAM_PROGRAM_ELEMENT:
if (parse_program_single_item (ctx, inst, Program, state_tokens))
return 1;
idx = _mesa_add_state_reference (Program->Parameters, state_tokens);
if (param_var->param_binding_begin == ~0U)
param_var->param_binding_begin = idx;
param_var->param_binding_length++;
Program->Base.NumParameters++;
/* Check if there is more: 0 -> we're done, else its an integer */
if (**inst) {
GLuint out_of_range, new_idx;
GLuint start_idx = state_tokens[2] + 1;
GLuint end_idx = parse_integer (inst, Program);
out_of_range = 0;
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
if (((state_tokens[1] == STATE_ENV)
&& (end_idx >= ctx->Const.MaxFragmentProgramEnvParams))
|| ((state_tokens[1] == STATE_LOCAL)
&& (end_idx >=
ctx->Const.MaxFragmentProgramLocalParams)))
out_of_range = 1;
}
else {
if (((state_tokens[1] == STATE_ENV)
&& (end_idx >= ctx->Const.MaxVertexProgramEnvParams))
|| ((state_tokens[1] == STATE_LOCAL)
&& (end_idx >=
ctx->Const.MaxVertexProgramLocalParams)))
out_of_range = 1;
}
if (out_of_range) {
_mesa_set_program_error (ctx, Program->Position,
"Invalid Program Parameter");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Invalid Program Parameter: %d", end_idx);
return 1;
}
for (new_idx = start_idx; new_idx <= end_idx; new_idx++) {
state_tokens[2] = new_idx;
idx =
_mesa_add_state_reference (Program->Parameters,
state_tokens);
param_var->param_binding_length++;
Program->Base.NumParameters++;
}
}
else
{
(*inst)++;
}
break;
case PARAM_CONSTANT:
parse_constant (inst, const_values, Program, use);
idx =
_mesa_add_named_constant (Program->Parameters,
(char *) param_var->name, const_values);
if (param_var->param_binding_begin == ~0U)
param_var->param_binding_begin = idx;
param_var->param_binding_length++;
Program->Base.NumParameters++;
break;
default:
_mesa_set_program_error (ctx, Program->Position,
"Unexpected token in parse_param_elements()");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Unexpected token in parse_param_elements()");
return 1;
}
/* Make sure we haven't blown past our parameter limits */
if (((Program->Base.Target == GL_VERTEX_PROGRAM_ARB) &&
(Program->Base.NumParameters >=
ctx->Const.MaxVertexProgramLocalParams))
|| ((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB)
&& (Program->Base.NumParameters >=
ctx->Const.MaxFragmentProgramLocalParams))) {
_mesa_set_program_error (ctx, Program->Position,
"Too many parameter variables");
_mesa_error (ctx, GL_INVALID_OPERATION, "Too many parameter variables");
return 1;
}
return err;
}
/**
* This picks out PARAM program parameter bindings.
*
* XXX: This needs to be stressed & tested
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_param (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program)
{
GLuint found, specified_length, err;
char *error_msg;
struct var_cache *param_var;
err = 0;
param_var = parse_string (inst, vc_head, Program, &found);
Program->Position = parse_position (inst);
if (found) {
error_msg = (char *) _mesa_malloc (_mesa_strlen ((char *) param_var->name) + 40);
_mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s",
param_var->name);
_mesa_set_program_error (ctx, Program->Position, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, error_msg);
_mesa_free (error_msg);
return 1;
}
specified_length = parse_integer (inst, Program);
if (specified_length < 0) {
_mesa_set_program_error (ctx, Program->Position,
"Negative parameter array length");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Negative parameter array length: %d", specified_length);
return 1;
}
param_var->type = vt_param;
param_var->param_binding_length = 0;
/* Right now, everything is shoved into the main state register file.
*
* In the future, it would be nice to leave things ENV/LOCAL params
* in their respective register files, if possible
*/
param_var->param_binding_type = PROGRAM_STATE_VAR;
/* Remember to:
* * - add each guy to the parameter list
* * - increment the param_var->param_binding_len
* * - store the param_var->param_binding_begin for the first one
* * - compare the actual len to the specified len at the end
*/
while (**inst != PARAM_NULL) {
if (parse_param_elements (ctx, inst, param_var, Program, GL_FALSE))
return 1;
}
/* Test array length here! */
if (specified_length) {
if (specified_length != param_var->param_binding_length) {
_mesa_set_program_error (ctx, Program->Position,
"Declared parameter array lenght does not match parameter list");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Declared parameter array lenght does not match parameter list");
}
}
(*inst)++;
return 0;
}
/**
*
*/
static GLuint
parse_param_use (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program, struct var_cache **new_var)
{
struct var_cache *param_var;
/* First, insert a dummy entry into the var_cache */
var_cache_create (&param_var);
param_var->name = (GLubyte *) _mesa_strdup (" ");
param_var->type = vt_param;
param_var->param_binding_length = 0;
/* Don't fill in binding_begin; We use the default value of -1
* to tell if its already initialized, elsewhere.
*
* param_var->param_binding_begin = 0;
*/
param_var->param_binding_type = PROGRAM_STATE_VAR;
var_cache_append (vc_head, param_var);
/* Then fill it with juicy parameter goodness */
if (parse_param_elements (ctx, inst, param_var, Program, GL_TRUE))
return 1;
*new_var = param_var;
return 0;
}
/**
* This handles the declaration of TEMP variables
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_temp (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program)
{
GLuint found;
struct var_cache *temp_var;
char *error_msg;
while (**inst != 0) {
temp_var = parse_string (inst, vc_head, Program, &found);
Program->Position = parse_position (inst);
if (found) {
error_msg = (char *)
_mesa_malloc (_mesa_strlen ((char *) temp_var->name) + 40);
_mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s",
temp_var->name);
_mesa_set_program_error (ctx, Program->Position, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, error_msg);
_mesa_free (error_msg);
return 1;
}
temp_var->type = vt_temp;
if (((Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) &&
(Program->Base.NumTemporaries >=
ctx->Const.MaxFragmentProgramTemps))
|| ((Program->Base.Target == GL_VERTEX_PROGRAM_ARB)
&& (Program->Base.NumTemporaries >=
ctx->Const.MaxVertexProgramTemps))) {
_mesa_set_program_error (ctx, Program->Position,
"Too many TEMP variables declared");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Too many TEMP variables declared");
return 1;
}
temp_var->temp_binding = Program->Base.NumTemporaries;
Program->Base.NumTemporaries++;
}
(*inst)++;
return 0;
}
/**
* This handles variables of the OUTPUT variety
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_output (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program)
{
GLuint found;
struct var_cache *output_var;
output_var = parse_string (inst, vc_head, Program, &found);
Program->Position = parse_position (inst);
if (found) {
char *error_msg;
error_msg = (char *)
_mesa_malloc (_mesa_strlen ((char *) output_var->name) + 40);
_mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s",
output_var->name);
_mesa_set_program_error (ctx, Program->Position, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, error_msg);
_mesa_free (error_msg);
return 1;
}
output_var->type = vt_output;
return parse_result_binding (ctx, inst, &output_var->output_binding,
&output_var->output_binding_idx, Program);
}
/**
* This handles variables of the ALIAS kind
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_alias (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program)
{
GLuint found;
struct var_cache *temp_var;
char *error_msg;
temp_var = parse_string (inst, vc_head, Program, &found);
Program->Position = parse_position (inst);
if (found) {
error_msg = (char *)
_mesa_malloc (_mesa_strlen ((char *) temp_var->name) + 40);
_mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s",
temp_var->name);
_mesa_set_program_error (ctx, Program->Position, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, error_msg);
_mesa_free (error_msg);
return 1;
}
temp_var->type = vt_alias;
temp_var->alias_binding = parse_string (inst, vc_head, Program, &found);
Program->Position = parse_position (inst);
if (!found)
{
error_msg = (char *)
_mesa_malloc (_mesa_strlen ((char *) temp_var->name) + 40);
_mesa_sprintf (error_msg, "Alias value %s is not defined",
temp_var->alias_binding->name);
_mesa_set_program_error (ctx, Program->Position, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, error_msg);
_mesa_free (error_msg);
return 1;
}
return 0;
}
/**
* This handles variables of the ADDRESS kind
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_address (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program)
{
GLuint found;
struct var_cache *temp_var;
char *error_msg;
while (**inst != 0) {
temp_var = parse_string (inst, vc_head, Program, &found);
Program->Position = parse_position (inst);
if (found) {
error_msg = (char *)
_mesa_malloc (_mesa_strlen ((char *) temp_var->name) + 40);
_mesa_sprintf (error_msg, "Duplicate Varible Declaration: %s",
temp_var->name);
_mesa_set_program_error (ctx, Program->Position, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, error_msg);
_mesa_free (error_msg);
return 1;
}
temp_var->type = vt_address;
if (Program->Base.NumAddressRegs >=
ctx->Const.MaxVertexProgramAddressRegs) {
_mesa_set_program_error (ctx, Program->Position,
"Too many ADDRESS variables declared");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Too many ADDRESS variables declared");
return 1;
}
temp_var->address_binding = Program->Base.NumAddressRegs;
Program->Base.NumAddressRegs++;
}
(*inst)++;
return 0;
}
/**
* Parse a program declaration
*
* \return 0 on sucess, 1 on error
*/
static GLint
parse_declaration (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program)
{
GLint err = 0;
switch (*(*inst)++) {
case ADDRESS:
err = parse_address (ctx, inst, vc_head, Program);
break;
case ALIAS:
err = parse_alias (ctx, inst, vc_head, Program);
break;
case ATTRIB:
err = parse_attrib (ctx, inst, vc_head, Program);
break;
case OUTPUT:
err = parse_output (ctx, inst, vc_head, Program);
break;
case PARAM:
err = parse_param (ctx, inst, vc_head, Program);
break;
case TEMP:
err = parse_temp (ctx, inst, vc_head, Program);
break;
}
return err;
}
/**
* Handle the parsing out of a masked destination register
*
* If we are a vertex program, make sure we don't write to
* result.position of we have specified that the program is
* position invariant
*
* \param File - The register file we write to
* \param Index - The register index we write to
* \param WriteMask - The mask controlling which components we write (1->write)
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_masked_dst_reg (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head, struct arb_program *Program,
GLint * File, GLint * Index, GLboolean * WriteMask)
{
GLuint result;
GLubyte mask;
struct var_cache *dst;
/* We either have a result register specified, or a
* variable that may or may not be writable
*/
switch (*(*inst)++) {
case REGISTER_RESULT:
if (parse_result_binding
(ctx, inst, &result, (GLuint *) Index, Program))
return 1;
*File = PROGRAM_OUTPUT;
break;
case REGISTER_ESTABLISHED_NAME:
dst = parse_string (inst, vc_head, Program, &result);
Program->Position = parse_position (inst);
/* If the name has never been added to our symbol table, we're hosed */
if (!result) {
_mesa_set_program_error (ctx, Program->Position,
"0: Undefined variable");
_mesa_error (ctx, GL_INVALID_OPERATION, "0: Undefined variable: %s",
dst->name);
return 1;
}
switch (dst->type) {
case vt_output:
*File = PROGRAM_OUTPUT;
*Index = dst->output_binding_idx;
break;
case vt_temp:
*File = PROGRAM_TEMPORARY;
*Index = dst->temp_binding;
break;
/* If the var type is not vt_output or vt_temp, no go */
default:
_mesa_set_program_error (ctx, Program->Position,
"Destination register is read only");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Destination register is read only: %s",
dst->name);
return 1;
}
break;
default:
_mesa_set_program_error (ctx, Program->Position,
"Unexpected opcode in parse_masked_dst_reg()");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Unexpected opcode in parse_masked_dst_reg()");
return 1;
}
/* Position invariance test */
/* This test is done now in syntax portion - when position invariance OPTION
is specified, "result.position" rule is disabled so there is no way
to write the position
*/
/*if ((Program->HintPositionInvariant) && (*File == PROGRAM_OUTPUT) &&
(*Index == 0)) {
_mesa_set_program_error (ctx, Program->Position,
"Vertex program specified position invariance and wrote vertex position");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Vertex program specified position invariance and wrote vertex position");
}*/
/* And then the mask.
* w,a -> bit 0
* z,b -> bit 1
* y,g -> bit 2
* x,r -> bit 3
*/
mask = *(*inst)++;
WriteMask[0] = (GLboolean) (mask & (1 << 3)) >> 3;
WriteMask[1] = (GLboolean) (mask & (1 << 2)) >> 2;
WriteMask[2] = (GLboolean) (mask & (1 << 1)) >> 1;
WriteMask[3] = (GLboolean) (mask & (1));
return 0;
}
/**
* Handle the parsing of a address register
*
* \param Index - The register index we write to
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_address_reg (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head,
struct arb_program *Program, GLint * Index)
{
struct var_cache *dst;
GLuint result;
dst = parse_string (inst, vc_head, Program, &result);
Program->Position = parse_position (inst);
/* If the name has never been added to our symbol table, we're hosed */
if (!result) {
_mesa_set_program_error (ctx, Program->Position, "Undefined variable");
_mesa_error (ctx, GL_INVALID_OPERATION, "Undefined variable: %s",
dst->name);
return 1;
}
if (dst->type != vt_address) {
_mesa_set_program_error (ctx, Program->Position,
"Variable is not of type ADDRESS");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Variable: %s is not of type ADDRESS", dst->name);
return 1;
}
return 0;
}
/**
* Handle the parsing out of a masked address register
*
* \param Index - The register index we write to
* \param WriteMask - The mask controlling which components we write (1->write)
*
* \return 0 on sucess, 1 on error
*/
static GLuint
parse_masked_address_reg (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head,
struct arb_program *Program, GLint * Index,
GLboolean * WriteMask)
{
if (parse_address_reg (ctx, inst, vc_head, Program, Index))
return 1;
/* This should be 0x8 */
(*inst)++;
/* Writemask of .x is implied */
WriteMask[0] = 1;
WriteMask[1] = WriteMask[2] = WriteMask[3] = 0;
return 0;
}
/**
* Parse out a swizzle mask.
*
* The values in the input stream are:
* COMPONENT_X -> x/r
* COMPONENT_Y -> y/g
* COMPONENT_Z-> z/b
* COMPONENT_W-> w/a
*
* The values in the output mask are:
* 0 -> x/r
* 1 -> y/g
* 2 -> z/b
* 3 -> w/a
*
* The len parameter allows us to grab 4 components for a vector
* swizzle, or just 1 component for a scalar src register selection
*/
static GLuint
parse_swizzle_mask (GLubyte ** inst, GLubyte * mask, GLint len)
{
GLint a;
for (a = 0; a < 4; a++)
mask[a] = a;
for (a = 0; a < len; a++) {
switch (*(*inst)++) {
case COMPONENT_X:
mask[a] = 0;
break;
case COMPONENT_Y:
mask[a] = 1;
break;
case COMPONENT_Z:
mask[a] = 2;
break;
case COMPONENT_W:
mask[a] = 3;
break;
}
}
return 0;
}
/**
*/
static GLuint
parse_extended_swizzle_mask (GLubyte ** inst, GLubyte * mask, GLboolean * Negate)
{
GLint a;
GLubyte swz;
*Negate = GL_FALSE;
for (a = 0; a < 4; a++) {
if (parse_sign (inst))
*Negate = GL_TRUE;
swz = *(*inst)++;
switch (swz) {
case COMPONENT_0:
mask[a] = SWIZZLE_ZERO;
break;
case COMPONENT_1:
mask[a] = SWIZZLE_ONE;
break;
case COMPONENT_X:
mask[a] = SWIZZLE_X;
break;
case COMPONENT_Y:
mask[a] = SWIZZLE_Y;
break;
case COMPONENT_Z:
mask[a] = SWIZZLE_Z;
break;
case COMPONENT_W:
mask[a] = SWIZZLE_W;
break;
}
#if 0
if (swz == 0)
mask[a] = SWIZZLE_ZERO;
else if (swz == 1)
mask[a] = SWIZZLE_ONE;
else
mask[a] = swz - 2;
#endif
}
return 0;
}
static GLuint
parse_src_reg (GLcontext * ctx, GLubyte ** inst, struct var_cache **vc_head,
struct arb_program *Program, GLint * File, GLint * Index,
GLboolean *IsRelOffset )
{
struct var_cache *src;
GLuint binding_state, binding_idx, is_generic, found, offset;
/* And the binding for the src */
switch (*(*inst)++) {
case REGISTER_ATTRIB:
if (parse_attrib_binding
(ctx, inst, Program, &binding_state, &binding_idx, &is_generic))
return 1;
*File = PROGRAM_INPUT;
*Index = binding_idx;
/* We need to insert a dummy variable into the var_cache so we can
* catch generic vertex attrib aliasing errors
*/
var_cache_create(&src);
src->type = vt_attrib;
src->name = (GLubyte *)_mesa_strdup("Dummy Attrib Variable");
src->attrib_binding = binding_state;
src->attrib_binding_idx = binding_idx;
src->attrib_is_generic = is_generic;
var_cache_append(vc_head, src);
if (generic_attrib_check(*vc_head)) {
_mesa_set_program_error (ctx, Program->Position,
"Cannot use both a generic vertex attribute and a specific attribute of the same type");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Cannot use both a generic vertex attribute and a specific attribute of the same type");
return 1;
}
break;
case REGISTER_PARAM:
switch (**inst) {
case PARAM_ARRAY_ELEMENT:
(*inst)++;
src = parse_string (inst, vc_head, Program, &found);
Program->Position = parse_position (inst);
if (!found) {
_mesa_set_program_error (ctx, Program->Position,
"2: Undefined variable");
_mesa_error (ctx, GL_INVALID_OPERATION,
"2: Undefined variable: %s", src->name);
return 1;
}
*File = src->param_binding_type;
switch (*(*inst)++) {
case ARRAY_INDEX_ABSOLUTE:
offset = parse_integer (inst, Program);
if ((offset < 0)
|| (offset >= src->param_binding_length)) {
_mesa_set_program_error (ctx, Program->Position,
"Index out of range");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Index %d out of range for %s", offset,
src->name);
return 1;
}
*Index = src->param_binding_begin + offset;
break;
case ARRAY_INDEX_RELATIVE:
{
GLint addr_reg_idx, rel_off;
/* First, grab the address regiseter */
if (parse_address_reg (ctx, inst, vc_head, Program, &addr_reg_idx))
return 1;
/* And the .x */
((*inst)++);
((*inst)++);
((*inst)++);
((*inst)++);
/* Then the relative offset */
if (parse_relative_offset(ctx, inst, Program, &rel_off)) return 1;
/* And store it properly */
*Index = src->param_binding_begin + rel_off;
*IsRelOffset = 1;
}
break;
}
break;
default:
if (parse_param_use (ctx, inst, vc_head, Program, &src))
return 1;
*File = src->param_binding_type;
*Index = src->param_binding_begin;
break;
}
break;
case REGISTER_ESTABLISHED_NAME:
src = parse_string (inst, vc_head, Program, &found);
Program->Position = parse_position (inst);
/* If the name has never been added to our symbol table, we're hosed */
if (!found) {
_mesa_set_program_error (ctx, Program->Position,
"3: Undefined variable");
_mesa_error (ctx, GL_INVALID_OPERATION, "3: Undefined variable: %s",
src->name);
return 1;
}
switch (src->type) {
case vt_attrib:
*File = PROGRAM_INPUT;
*Index = src->attrib_binding_idx;
break;
/* XXX: We have to handle offsets someplace in here! -- or are those above? */
case vt_param:
*File = src->param_binding_type;
*Index = src->param_binding_begin;
break;
case vt_temp:
*File = PROGRAM_TEMPORARY;
*Index = src->temp_binding;
break;
/* If the var type is vt_output no go */
default:
_mesa_set_program_error (ctx, Program->Position,
"destination register is read only");
_mesa_error (ctx, GL_INVALID_OPERATION,
"destination register is read only: %s",
src->name);
return 1;
}
break;
default:
_mesa_set_program_error (ctx, Program->Position,
"Unknown token in parse_src_reg");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Unknown token in parse_src_reg");
return 1;
}
return 0;
}
/**
*/
static GLuint
parse_vector_src_reg (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head, struct arb_program *Program,
GLint * File, GLint * Index, GLboolean * Negate,
GLubyte * Swizzle, GLboolean *IsRelOffset)
{
/* Grab the sign */
*Negate = parse_sign (inst);
/* And the src reg */
if (parse_src_reg (ctx, inst, vc_head, Program, File, Index, IsRelOffset))
return 1;
/* finally, the swizzle */
parse_swizzle_mask (inst, Swizzle, 4);
return 0;
}
/**
*/
static GLuint
parse_scalar_src_reg (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head, struct arb_program *Program,
GLint * File, GLint * Index, GLboolean * Negate,
GLubyte * Swizzle, GLboolean *IsRelOffset)
{
/* Grab the sign */
*Negate = parse_sign (inst);
/* And the src reg */
if (parse_src_reg (ctx, inst, vc_head, Program, File, Index, IsRelOffset))
return 1;
/* Now, get the component and shove it into all the swizzle slots */
parse_swizzle_mask (inst, Swizzle, 1);
return 0;
}
/**
* This is a big mother that handles getting opcodes into the instruction
* and handling the src & dst registers for fragment program instructions
*/
static GLuint
parse_fp_instruction (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head, struct arb_program *Program,
struct fp_instruction *fp)
{
GLint a, b;
GLubyte swz[4]; /* FP's swizzle mask is a GLubyte, while VP's is GLuint */
GLuint texcoord;
GLubyte instClass, type, code;
GLboolean rel;
/* No condition codes in ARB_fp */
fp->UpdateCondRegister = 0;
/* Record the position in the program string for debugging */
fp->StringPos = Program->Position;
/* OP_ALU_INST or OP_TEX_INST */
instClass = *(*inst)++;
/* OP_ALU_{VECTOR, SCALAR, BINSC, BIN, TRI, SWZ},
* OP_TEX_{SAMPLE, KIL}
*/
type = *(*inst)++;
/* The actual opcode name */
code = *(*inst)++;
/* Increment the correct count */
switch (instClass) {
case OP_ALU_INST:
Program->NumAluInstructions++;
break;
case OP_TEX_INST:
Program->NumTexInstructions++;
break;
}
fp->Saturate = 0;
fp->Precision = FLOAT32;
fp->DstReg.CondMask = COND_TR;
switch (type) {
case OP_ALU_VECTOR:
switch (code) {
case OP_ABS_SAT:
fp->Saturate = 1;
case OP_ABS:
fp->Opcode = FP_OPCODE_ABS;
break;
case OP_FLR_SAT:
fp->Saturate = 1;
case OP_FLR:
fp->Opcode = FP_OPCODE_FLR;
break;
case OP_FRC_SAT:
fp->Saturate = 1;
case OP_FRC:
fp->Opcode = FP_OPCODE_FRC;
break;
case OP_LIT_SAT:
fp->Saturate = 1;
case OP_LIT:
fp->Opcode = FP_OPCODE_LIT;
break;
case OP_MOV_SAT:
fp->Saturate = 1;
case OP_MOV:
fp->Opcode = FP_OPCODE_MOV;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->DstReg.File,
&fp->DstReg.Index, fp->DstReg.WriteMask))
return 1;
fp->SrcReg[0].Abs = GL_FALSE;
fp->SrcReg[0].NegateAbs = GL_FALSE;
if (parse_vector_src_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->SrcReg[0].File,
&fp->SrcReg[0].Index, &fp->SrcReg[0].NegateBase,
swz, &rel))
return 1;
for (b=0; b<4; b++)
fp->SrcReg[0].Swizzle[b] = swz[b];
break;
case OP_ALU_SCALAR:
switch (code) {
case OP_COS_SAT:
fp->Saturate = 1;
case OP_COS:
fp->Opcode = FP_OPCODE_COS;
break;
case OP_EX2_SAT:
fp->Saturate = 1;
case OP_EX2:
fp->Opcode = FP_OPCODE_EX2;
break;
case OP_LG2_SAT:
fp->Saturate = 1;
case OP_LG2:
fp->Opcode = FP_OPCODE_LG2;
break;
case OP_RCP_SAT:
fp->Saturate = 1;
case OP_RCP:
fp->Opcode = FP_OPCODE_RCP;
break;
case OP_RSQ_SAT:
fp->Saturate = 1;
case OP_RSQ:
fp->Opcode = FP_OPCODE_RSQ;
break;
case OP_SIN_SAT:
fp->Saturate = 1;
case OP_SIN:
fp->Opcode = FP_OPCODE_SIN;
break;
case OP_SCS_SAT:
fp->Saturate = 1;
case OP_SCS:
fp->Opcode = FP_OPCODE_SCS;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->DstReg.File,
&fp->DstReg.Index, fp->DstReg.WriteMask))
return 1;
fp->SrcReg[0].Abs = GL_FALSE;
fp->SrcReg[0].NegateAbs = GL_FALSE;
if (parse_scalar_src_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->SrcReg[0].File,
&fp->SrcReg[0].Index, &fp->SrcReg[0].NegateBase,
swz, &rel))
return 1;
for (b=0; b<4; b++)
fp->SrcReg[0].Swizzle[b] = swz[b];
break;
case OP_ALU_BINSC:
switch (code) {
case OP_POW_SAT:
fp->Saturate = 1;
case OP_POW:
fp->Opcode = FP_OPCODE_POW;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->DstReg.File,
&fp->DstReg.Index, fp->DstReg.WriteMask))
return 1;
for (a = 0; a < 2; a++) {
fp->SrcReg[a].Abs = GL_FALSE;
fp->SrcReg[a].NegateAbs = GL_FALSE;
if (parse_scalar_src_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->SrcReg[a].File,
&fp->SrcReg[a].Index, &fp->SrcReg[a].NegateBase,
swz, &rel))
return 1;
for (b=0; b<4; b++)
fp->SrcReg[a].Swizzle[b] = swz[b];
}
break;
case OP_ALU_BIN:
switch (code) {
case OP_ADD_SAT:
fp->Saturate = 1;
case OP_ADD:
fp->Opcode = FP_OPCODE_ADD;
break;
case OP_DP3_SAT:
fp->Saturate = 1;
case OP_DP3:
fp->Opcode = FP_OPCODE_DP3;
break;
case OP_DP4_SAT:
fp->Saturate = 1;
case OP_DP4:
fp->Opcode = FP_OPCODE_DP4;
break;
case OP_DPH_SAT:
fp->Saturate = 1;
case OP_DPH:
fp->Opcode = FP_OPCODE_DPH;
break;
case OP_DST_SAT:
fp->Saturate = 1;
case OP_DST:
fp->Opcode = FP_OPCODE_DST;
break;
case OP_MAX_SAT:
fp->Saturate = 1;
case OP_MAX:
fp->Opcode = FP_OPCODE_MAX;
break;
case OP_MIN_SAT:
fp->Saturate = 1;
case OP_MIN:
fp->Opcode = FP_OPCODE_MIN;
break;
case OP_MUL_SAT:
fp->Saturate = 1;
case OP_MUL:
fp->Opcode = FP_OPCODE_MUL;
break;
case OP_SGE_SAT:
fp->Saturate = 1;
case OP_SGE:
fp->Opcode = FP_OPCODE_SGE;
break;
case OP_SLT_SAT:
fp->Saturate = 1;
case OP_SLT:
fp->Opcode = FP_OPCODE_SLT;
break;
case OP_SUB_SAT:
fp->Saturate = 1;
case OP_SUB:
fp->Opcode = FP_OPCODE_SUB;
break;
case OP_XPD_SAT:
fp->Saturate = 1;
case OP_XPD:
fp->Opcode = FP_OPCODE_XPD;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->DstReg.File,
&fp->DstReg.Index, fp->DstReg.WriteMask))
return 1;
for (a = 0; a < 2; a++) {
fp->SrcReg[a].Abs = GL_FALSE;
fp->SrcReg[a].NegateAbs = GL_FALSE;
if (parse_vector_src_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->SrcReg[a].File,
&fp->SrcReg[a].Index, &fp->SrcReg[a].NegateBase,
swz, &rel))
return 1;
for (b=0; b<4; b++)
fp->SrcReg[a].Swizzle[b] = swz[b];
}
break;
case OP_ALU_TRI:
switch (code) {
case OP_CMP_SAT:
fp->Saturate = 1;
case OP_CMP:
fp->Opcode = FP_OPCODE_CMP;
break;
case OP_LRP_SAT:
fp->Saturate = 1;
case OP_LRP:
fp->Opcode = FP_OPCODE_LRP;
break;
case OP_MAD_SAT:
fp->Saturate = 1;
case OP_MAD:
fp->Opcode = FP_OPCODE_MAD;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->DstReg.File,
&fp->DstReg.Index, fp->DstReg.WriteMask))
return 1;
for (a = 0; a < 3; a++) {
fp->SrcReg[a].Abs = GL_FALSE;
fp->SrcReg[a].NegateAbs = GL_FALSE;
if (parse_vector_src_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->SrcReg[a].File,
&fp->SrcReg[a].Index, &fp->SrcReg[a].NegateBase,
swz, &rel))
return 1;
for (b=0; b<4; b++)
fp->SrcReg[a].Swizzle[b] = swz[b];
}
break;
case OP_ALU_SWZ:
switch (code) {
case OP_SWZ_SAT:
fp->Saturate = 1;
case OP_SWZ:
fp->Opcode = FP_OPCODE_SWZ;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->DstReg.File,
&fp->DstReg.Index, fp->DstReg.WriteMask))
return 1;
if (parse_src_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->SrcReg[0].File,
&fp->SrcReg[0].Index, &rel))
return 1;
parse_extended_swizzle_mask (inst, swz,
&fp->SrcReg[0].NegateBase);
for (b=0; b<4; b++)
fp->SrcReg[0].Swizzle[b] = swz[b];
break;
case OP_TEX_SAMPLE:
switch (code) {
case OP_TEX_SAT:
fp->Saturate = 1;
case OP_TEX:
fp->Opcode = FP_OPCODE_TEX;
break;
case OP_TXP_SAT:
fp->Saturate = 1;
case OP_TXP:
fp->Opcode = FP_OPCODE_TXP;
break;
case OP_TXB_SAT:
fp->Saturate = 1;
case OP_TXB:
fp->Opcode = FP_OPCODE_TXB;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->DstReg.File,
&fp->DstReg.Index, fp->DstReg.WriteMask))
return 1;
fp->SrcReg[0].Abs = GL_FALSE;
fp->SrcReg[0].NegateAbs = GL_FALSE;
if (parse_vector_src_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->SrcReg[0].File,
&fp->SrcReg[0].Index, &fp->SrcReg[0].NegateBase,
swz, &rel))
return 1;
for (b=0; b<4; b++)
fp->SrcReg[0].Swizzle[b] = swz[b];
/* texImageUnit */
if (parse_texcoord_num (ctx, inst, Program, &texcoord))
return 1;
fp->TexSrcUnit = texcoord;
/* texTarget */
switch (*(*inst)++) {
case TEXTARGET_1D:
fp->TexSrcBit = TEXTURE_1D_BIT;
break;
case TEXTARGET_2D:
fp->TexSrcBit = TEXTURE_2D_BIT;
break;
case TEXTARGET_3D:
fp->TexSrcBit = TEXTURE_3D_BIT;
break;
case TEXTARGET_RECT:
fp->TexSrcBit = TEXTURE_RECT_BIT;
break;
case TEXTARGET_CUBE:
fp->TexSrcBit = TEXTURE_CUBE_BIT;
break;
case TEXTARGET_SHADOW1D:
case TEXTARGET_SHADOW2D:
case TEXTARGET_SHADOWRECT:
/* TODO ARB_fragment_program_shadow code */
break;
}
Program->TexturesUsed[texcoord] |= fp->TexSrcBit;
break;
case OP_TEX_KIL:
fp->Opcode = FP_OPCODE_KIL;
fp->SrcReg[0].Abs = GL_FALSE;
fp->SrcReg[0].NegateAbs = GL_FALSE;
if (parse_vector_src_reg
(ctx, inst, vc_head, Program, (GLint *) & fp->SrcReg[0].File,
&fp->SrcReg[0].Index, &fp->SrcReg[0].NegateBase,
swz, &rel))
return 1;
for (b=0; b<4; b++)
fp->SrcReg[0].Swizzle[b] = swz[b];
break;
}
return 0;
}
/**
* This is a big mother that handles getting opcodes into the instruction
* and handling the src & dst registers for vertex program instructions
*/
static GLuint
parse_vp_instruction (GLcontext * ctx, GLubyte ** inst,
struct var_cache **vc_head, struct arb_program *Program,
struct vp_instruction *vp)
{
GLint a;
GLubyte type, code;
/* OP_ALU_{ARL, VECTOR, SCALAR, BINSC, BIN, TRI, SWZ} */
type = *(*inst)++;
/* The actual opcode name */
code = *(*inst)++;
/* Record the position in the program string for debugging */
vp->StringPos = Program->Position;
vp->SrcReg[0].RelAddr = vp->SrcReg[1].RelAddr = vp->SrcReg[2].RelAddr = 0;
for (a = 0; a < 4; a++) {
vp->SrcReg[0].Swizzle[a] = a;
vp->SrcReg[1].Swizzle[a] = a;
vp->SrcReg[2].Swizzle[a] = a;
vp->DstReg.WriteMask[a] = 1;
}
switch (type) {
/* XXX: */
case OP_ALU_ARL:
vp->Opcode = VP_OPCODE_ARL;
/* Remember to set SrcReg.RelAddr; */
/* Get the masked address register [dst] */
if (parse_masked_address_reg
(ctx, inst, vc_head, Program, &vp->DstReg.Index,
vp->DstReg.WriteMask))
return 1;
vp->DstReg.File = PROGRAM_ADDRESS;
/* Get a scalar src register */
if (parse_scalar_src_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->SrcReg[0].File,
&vp->SrcReg[0].Index, &vp->SrcReg[0].Negate,
vp->SrcReg[0].Swizzle, &vp->SrcReg[0].RelAddr))
return 1;
break;
case OP_ALU_VECTOR:
switch (code) {
case OP_ABS:
vp->Opcode = VP_OPCODE_ABS;
break;
case OP_FLR:
vp->Opcode = VP_OPCODE_FLR;
break;
case OP_FRC:
vp->Opcode = VP_OPCODE_FRC;
break;
case OP_LIT:
vp->Opcode = VP_OPCODE_LIT;
break;
case OP_MOV:
vp->Opcode = VP_OPCODE_MOV;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->DstReg.File,
&vp->DstReg.Index, vp->DstReg.WriteMask))
return 1;
if (parse_vector_src_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->SrcReg[0].File,
&vp->SrcReg[0].Index, &vp->SrcReg[0].Negate,
vp->SrcReg[0].Swizzle, &vp->SrcReg[0].RelAddr))
return 1;
break;
case OP_ALU_SCALAR:
switch (code) {
case OP_EX2:
vp->Opcode = VP_OPCODE_EX2;
break;
case OP_EXP:
vp->Opcode = VP_OPCODE_EXP;
break;
case OP_LG2:
vp->Opcode = VP_OPCODE_LG2;
break;
case OP_LOG:
vp->Opcode = VP_OPCODE_LOG;
break;
case OP_RCP:
vp->Opcode = VP_OPCODE_RCP;
break;
case OP_RSQ:
vp->Opcode = VP_OPCODE_RSQ;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->DstReg.File,
&vp->DstReg.Index, vp->DstReg.WriteMask))
return 1;
if (parse_scalar_src_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->SrcReg[0].File,
&vp->SrcReg[0].Index, &vp->SrcReg[0].Negate,
vp->SrcReg[0].Swizzle, &vp->SrcReg[0].RelAddr))
return 1;
break;
case OP_ALU_BINSC:
switch (code) {
case OP_POW:
vp->Opcode = VP_OPCODE_POW;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->DstReg.File,
&vp->DstReg.Index, vp->DstReg.WriteMask))
return 1;
for (a = 0; a < 2; a++) {
if (parse_scalar_src_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->SrcReg[a].File,
&vp->SrcReg[a].Index, &vp->SrcReg[a].Negate,
vp->SrcReg[a].Swizzle, &vp->SrcReg[a].RelAddr))
return 1;
}
break;
case OP_ALU_BIN:
switch (code) {
case OP_ADD:
vp->Opcode = VP_OPCODE_ADD;
break;
case OP_DP3:
vp->Opcode = VP_OPCODE_DP3;
break;
case OP_DP4:
vp->Opcode = VP_OPCODE_DP4;
break;
case OP_DPH:
vp->Opcode = VP_OPCODE_DPH;
break;
case OP_DST:
vp->Opcode = VP_OPCODE_DST;
break;
case OP_MAX:
vp->Opcode = VP_OPCODE_MAX;
break;
case OP_MIN:
vp->Opcode = VP_OPCODE_MIN;
break;
case OP_MUL:
vp->Opcode = VP_OPCODE_MUL;
break;
case OP_SGE:
vp->Opcode = VP_OPCODE_SGE;
break;
case OP_SLT:
vp->Opcode = VP_OPCODE_SLT;
break;
case OP_SUB:
vp->Opcode = VP_OPCODE_SUB;
break;
case OP_XPD:
vp->Opcode = VP_OPCODE_XPD;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->DstReg.File,
&vp->DstReg.Index, vp->DstReg.WriteMask))
return 1;
for (a = 0; a < 2; a++) {
if (parse_vector_src_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->SrcReg[a].File,
&vp->SrcReg[a].Index, &vp->SrcReg[a].Negate,
vp->SrcReg[a].Swizzle, &vp->SrcReg[a].RelAddr))
return 1;
}
break;
case OP_ALU_TRI:
switch (code) {
case OP_MAD:
vp->Opcode = VP_OPCODE_MAD;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->DstReg.File,
&vp->DstReg.Index, vp->DstReg.WriteMask))
return 1;
for (a = 0; a < 3; a++) {
if (parse_vector_src_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->SrcReg[a].File,
&vp->SrcReg[a].Index, &vp->SrcReg[a].Negate,
vp->SrcReg[a].Swizzle, &vp->SrcReg[a].RelAddr))
return 1;
}
break;
case OP_ALU_SWZ:
switch (code) {
case OP_SWZ:
vp->Opcode = VP_OPCODE_SWZ;
break;
}
if (parse_masked_dst_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->DstReg.File,
&vp->DstReg.Index, vp->DstReg.WriteMask))
return 1;
if (parse_src_reg
(ctx, inst, vc_head, Program, (GLint *) & vp->SrcReg[0].File,
&vp->SrcReg[0].Index, &vp->SrcReg[0].RelAddr))
return 1;
parse_extended_swizzle_mask (inst, vp->SrcReg[0].Swizzle,
&vp->SrcReg[0].Negate);
break;
}
return 0;
}
#if DEBUG_PARSING
static GLvoid
print_state_token (GLint token)
{
switch (token) {
case STATE_MATERIAL:
fprintf (stderr, "STATE_MATERIAL ");
break;
case STATE_LIGHT:
fprintf (stderr, "STATE_LIGHT ");
break;
case STATE_LIGHTMODEL_AMBIENT:
fprintf (stderr, "STATE_AMBIENT ");
break;
case STATE_LIGHTMODEL_SCENECOLOR:
fprintf (stderr, "STATE_SCENECOLOR ");
break;
case STATE_LIGHTPROD:
fprintf (stderr, "STATE_LIGHTPROD ");
break;
case STATE_TEXGEN:
fprintf (stderr, "STATE_TEXGEN ");
break;
case STATE_FOG_COLOR:
fprintf (stderr, "STATE_FOG_COLOR ");
break;
case STATE_FOG_PARAMS:
fprintf (stderr, "STATE_FOG_PARAMS ");
break;
case STATE_CLIPPLANE:
fprintf (stderr, "STATE_CLIPPLANE ");
break;
case STATE_POINT_SIZE:
fprintf (stderr, "STATE_POINT_SIZE ");
break;
case STATE_POINT_ATTENUATION:
fprintf (stderr, "STATE_ATTENUATION ");
break;
case STATE_MATRIX:
fprintf (stderr, "STATE_MATRIX ");
break;
case STATE_MODELVIEW:
fprintf (stderr, "STATE_MODELVIEW ");
break;
case STATE_PROJECTION:
fprintf (stderr, "STATE_PROJECTION ");
break;
case STATE_MVP:
fprintf (stderr, "STATE_MVP ");
break;
case STATE_TEXTURE:
fprintf (stderr, "STATE_TEXTURE ");
break;
case STATE_PROGRAM:
fprintf (stderr, "STATE_PROGRAM ");
break;
case STATE_MATRIX_INVERSE:
fprintf (stderr, "STATE_INVERSE ");
break;
case STATE_MATRIX_TRANSPOSE:
fprintf (stderr, "STATE_TRANSPOSE ");
break;
case STATE_MATRIX_INVTRANS:
fprintf (stderr, "STATE_INVTRANS ");
break;
case STATE_AMBIENT:
fprintf (stderr, "STATE_AMBIENT ");
break;
case STATE_DIFFUSE:
fprintf (stderr, "STATE_DIFFUSE ");
break;
case STATE_SPECULAR:
fprintf (stderr, "STATE_SPECULAR ");
break;
case STATE_EMISSION:
fprintf (stderr, "STATE_EMISSION ");
break;
case STATE_SHININESS:
fprintf (stderr, "STATE_SHININESS ");
break;
case STATE_HALF:
fprintf (stderr, "STATE_HALF ");
break;
case STATE_POSITION:
fprintf (stderr, "STATE_POSITION ");
break;
case STATE_ATTENUATION:
fprintf (stderr, "STATE_ATTENUATION ");
break;
case STATE_SPOT_DIRECTION:
fprintf (stderr, "STATE_DIRECTION ");
break;
case STATE_TEXGEN_EYE_S:
fprintf (stderr, "STATE_TEXGEN_EYE_S ");
break;
case STATE_TEXGEN_EYE_T:
fprintf (stderr, "STATE_TEXGEN_EYE_T ");
break;
case STATE_TEXGEN_EYE_R:
fprintf (stderr, "STATE_TEXGEN_EYE_R ");
break;
case STATE_TEXGEN_EYE_Q:
fprintf (stderr, "STATE_TEXGEN_EYE_Q ");
break;
case STATE_TEXGEN_OBJECT_S:
fprintf (stderr, "STATE_TEXGEN_EYE_S ");
break;
case STATE_TEXGEN_OBJECT_T:
fprintf (stderr, "STATE_TEXGEN_OBJECT_T ");
break;
case STATE_TEXGEN_OBJECT_R:
fprintf (stderr, "STATE_TEXGEN_OBJECT_R ");
break;
case STATE_TEXGEN_OBJECT_Q:
fprintf (stderr, "STATE_TEXGEN_OBJECT_Q ");
break;
case STATE_TEXENV_COLOR:
fprintf (stderr, "STATE_TEXENV_COLOR ");
break;
case STATE_DEPTH_RANGE:
fprintf (stderr, "STATE_DEPTH_RANGE ");
break;
case STATE_VERTEX_PROGRAM:
fprintf (stderr, "STATE_VERTEX_PROGRAM ");
break;
case STATE_FRAGMENT_PROGRAM:
fprintf (stderr, "STATE_FRAGMENT_PROGRAM ");
break;
case STATE_ENV:
fprintf (stderr, "STATE_ENV ");
break;
case STATE_LOCAL:
fprintf (stderr, "STATE_LOCAL ");
break;
}
fprintf (stderr, "[%d] ", token);
}
static GLvoid
debug_variables (GLcontext * ctx, struct var_cache *vc_head,
struct arb_program *Program)
{
struct var_cache *vc;
GLint a, b;
fprintf (stderr, "debug_variables, vc_head: %x\n", vc_head);
/* First of all, print out the contents of the var_cache */
vc = vc_head;
while (vc) {
fprintf (stderr, "[%x]\n", vc);
switch (vc->type) {
case vt_none:
fprintf (stderr, "UNDEFINED %s\n", vc->name);
break;
case vt_attrib:
fprintf (stderr, "ATTRIB %s\n", vc->name);
fprintf (stderr, " binding: 0x%x\n", vc->attrib_binding);
break;
case vt_param:
fprintf (stderr, "PARAM %s begin: %d len: %d\n", vc->name,
vc->param_binding_begin, vc->param_binding_length);
b = vc->param_binding_begin;
for (a = 0; a < vc->param_binding_length; a++) {
fprintf (stderr, "%s\n",
Program->Parameters->Parameters[a + b].Name);
if (Program->Parameters->Parameters[a + b].Type == STATE) {
print_state_token (Program->Parameters->Parameters[a + b].
StateIndexes[0]);
print_state_token (Program->Parameters->Parameters[a + b].
StateIndexes[1]);
print_state_token (Program->Parameters->Parameters[a + b].
StateIndexes[2]);
print_state_token (Program->Parameters->Parameters[a + b].
StateIndexes[3]);
print_state_token (Program->Parameters->Parameters[a + b].
StateIndexes[4]);
print_state_token (Program->Parameters->Parameters[a + b].
StateIndexes[5]);
}
else
fprintf (stderr, "%f %f %f %f\n",
Program->Parameters->Parameters[a + b].Values[0],
Program->Parameters->Parameters[a + b].Values[1],
Program->Parameters->Parameters[a + b].Values[2],
Program->Parameters->Parameters[a + b].Values[3]);
}
break;
case vt_temp:
fprintf (stderr, "TEMP %s\n", vc->name);
fprintf (stderr, " binding: 0x%x\n", vc->temp_binding);
break;
case vt_output:
fprintf (stderr, "OUTPUT %s\n", vc->name);
fprintf (stderr, " binding: 0x%x\n", vc->output_binding);
break;
case vt_alias:
fprintf (stderr, "ALIAS %s\n", vc->name);
fprintf (stderr, " binding: 0x%x (%s)\n",
vc->alias_binding, vc->alias_binding->name);
break;
}
vc = vc->next;
}
}
#endif
/**
* The main loop for parsing a fragment or vertex program
*
* \return 0 on sucess, 1 on error
*/
static GLint
parse_arb_program (GLcontext * ctx, GLubyte * inst, struct var_cache **vc_head,
struct arb_program *Program)
{
GLint err = 0;
Program->MajorVersion = (GLuint) * inst++;
Program->MinorVersion = (GLuint) * inst++;
while (*inst != END) {
switch (*inst++) {
case OPTION:
switch (*inst++) {
case ARB_PRECISION_HINT_FASTEST:
Program->PrecisionOption = GL_FASTEST;
break;
case ARB_PRECISION_HINT_NICEST:
Program->PrecisionOption = GL_NICEST;
break;
case ARB_FOG_EXP:
Program->FogOption = GL_EXP;
break;
case ARB_FOG_EXP2:
Program->FogOption = GL_EXP2;
break;
case ARB_FOG_LINEAR:
Program->FogOption = GL_LINEAR;
break;
case ARB_POSITION_INVARIANT:
if (Program->Base.Target == GL_VERTEX_PROGRAM_ARB)
Program->HintPositionInvariant = 1;
break;
case ARB_FRAGMENT_PROGRAM_SHADOW:
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
/* TODO ARB_fragment_program_shadow code */
}
break;
}
break;
case INSTRUCTION:
Program->Position = parse_position (&inst);
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
/* Check the instruction count
* XXX: Does END count as an instruction?
*/
if (Program->Base.NumInstructions+1 == MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS) {
_mesa_set_program_error (ctx, Program->Position,
"Max instruction count exceeded!");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Max instruction count exceeded!");
}
/* Realloc Program->FPInstructions */
Program->FPInstructions =
(struct fp_instruction *) _mesa_realloc (Program->FPInstructions,
Program->Base.NumInstructions*sizeof(struct fp_instruction),
(Program->Base.NumInstructions+1)*sizeof (struct fp_instruction));
/* parse the current instruction */
err = parse_fp_instruction (ctx, &inst, vc_head, Program,
&Program->FPInstructions[Program->Base.NumInstructions]);
}
else {
/* Check the instruction count
* XXX: Does END count as an instruction?
*/
if (Program->Base.NumInstructions+1 == MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS) {
_mesa_set_program_error (ctx, Program->Position,
"Max instruction count exceeded!");
_mesa_error (ctx, GL_INVALID_OPERATION,
"Max instruction count exceeded!");
}
/* Realloc Program->VPInstructions */
Program->VPInstructions =
(struct vp_instruction *) _mesa_realloc (Program->VPInstructions,
Program->Base.NumInstructions*sizeof(struct vp_instruction),
(Program->Base.NumInstructions +1)*sizeof(struct vp_instruction));
/* parse the current instruction */
err = parse_vp_instruction (ctx, &inst, vc_head, Program,
&Program->VPInstructions[Program->Base.NumInstructions]);
}
/* increment Program->Base.NumInstructions */
Program->Base.NumInstructions++;
break;
case DECLARATION:
err = parse_declaration (ctx, &inst, vc_head, Program);
break;
default:
break;
}
if (err)
break;
}
/* Finally, tag on an OPCODE_END instruction */
if (Program->Base.Target == GL_FRAGMENT_PROGRAM_ARB) {
Program->FPInstructions =
(struct fp_instruction *) _mesa_realloc (Program->FPInstructions,
Program->Base.NumInstructions*sizeof(struct fp_instruction),
(Program->Base.NumInstructions+1)*sizeof(struct fp_instruction));
Program->FPInstructions[Program->Base.NumInstructions].Opcode = FP_OPCODE_END;
/* YYY Wrong Position in program, whatever, at least not random -> crash
Program->Position = parse_position (&inst);
*/
Program->FPInstructions[Program->Base.NumInstructions].StringPos = Program->Position;
}
else {
Program->VPInstructions =
(struct vp_instruction *) _mesa_realloc (Program->VPInstructions,
Program->Base.NumInstructions*sizeof(struct vp_instruction),
(Program->Base.NumInstructions+1)*sizeof(struct vp_instruction));
Program->VPInstructions[Program->Base.NumInstructions].Opcode = VP_OPCODE_END;
/* YYY Wrong Position in program, whatever, at least not random -> crash
Program->Position = parse_position (&inst);
*/
Program->VPInstructions[Program->Base.NumInstructions].StringPos = Program->Position;
}
/* increment Program->Base.NumInstructions */
Program->Base.NumInstructions++;
return err;
}
/* XXX temporary */
static char core_grammar_text[] =
#include "grammar_syn.h"
;
static int set_reg8 (GLcontext *ctx, grammar id, const byte *name, byte value)
{
char error_msg[300];
GLint error_pos;
if (grammar_set_reg8 (id, name, value))
return 0;
grammar_get_last_error ((byte *) error_msg, 300, &error_pos);
_mesa_set_program_error (ctx, error_pos, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, "Grammar Register Error");
return 1;
}
static int extension_is_supported (const GLubyte *ext)
{
const GLubyte *extensions = glGetString (GL_EXTENSIONS);
const GLubyte *end = extensions + _mesa_strlen ((const char *) extensions);
const GLint ext_len = _mesa_strlen ((const char *) ext);
while (extensions < end)
{
const GLubyte *name_end = (const GLubyte *) strchr ((const char *) extensions, ' ');
if (name_end == NULL)
name_end = end;
if (name_end - extensions == ext_len && _mesa_strncmp ((const char *) ext,
(const char *) extensions, ext_len) == 0)
return 1;
extensions = name_end + 1;
}
return 0;
}
static int enable_ext (GLcontext *ctx, grammar id, const byte *name, const byte *extname)
{
if (extension_is_supported (extname))
if (set_reg8 (ctx, id, name, 0x01))
return 1;
return 0;
}
/**
* This kicks everything off.
*
* \param ctx - The GL Context
* \param str - The program string
* \param len - The program string length
* \param Program - The arb_program struct to return all the parsed info in
* \return 0 on sucess, 1 on error
*/
GLuint
_mesa_parse_arb_program (GLcontext * ctx, const GLubyte * str, GLsizei len,
struct arb_program * program)
{
GLint a, err, error_pos;
char error_msg[300];
GLuint parsed_len;
struct var_cache *vc_head;
grammar arbprogram_syn_id;
GLubyte *parsed, *inst;
GLubyte *strz = NULL;
static int arbprogram_syn_is_ok = 0; /* XXX temporary */
#if DEBUG_PARSING
fprintf (stderr, "Loading grammar text!\n");
#endif
/* check if the arb_grammar_text (arbprogram.syn) is syntactically correct */
if (!arbprogram_syn_is_ok) {
grammar grammar_syn_id;
GLint err;
GLuint parsed_len;
byte *parsed;
grammar_syn_id = grammar_load_from_text ((byte *) core_grammar_text);
if (grammar_syn_id == 0) {
grammar_get_last_error ((byte *) error_msg, 300, &error_pos);
_mesa_set_program_error (ctx, error_pos, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION,
"Error loading grammar rule set");
return 1;
}
err = grammar_check (grammar_syn_id, (byte *) arb_grammar_text, &parsed, &parsed_len);
/* NOTE: we cant destroy grammar_syn_id right here because grammar_destroy() can
reset the last error
*/
if (err == 0) {
grammar_get_last_error ((byte *) error_msg, 300, &error_pos);
_mesa_set_program_error (ctx, error_pos, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, "Error loading grammar rule set");
grammar_destroy (grammar_syn_id);
return 1;
}
grammar_destroy (grammar_syn_id);
arbprogram_syn_is_ok = 1;
}
/* create the grammar object */
arbprogram_syn_id = grammar_load_from_text ((byte *) arb_grammar_text);
if (arbprogram_syn_id == 0) {
grammar_get_last_error ((GLubyte *) error_msg, 300, &error_pos);
_mesa_set_program_error (ctx, error_pos, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION,
"Error loading grammer rule set");
return 1;
}
/* Set program_target register value */
if (set_reg8 (ctx, arbprogram_syn_id, (byte *) "program_target",
program->Base.Target == GL_FRAGMENT_PROGRAM_ARB ? 0x10 : 0x20)) {
grammar_destroy (arbprogram_syn_id);
return 1;
}
/* Enable all active extensions */
if (enable_ext (ctx, arbprogram_syn_id,
(byte *) "vertex_blend", (byte *) "GL_ARB_vertex_blend") ||
enable_ext (ctx, arbprogram_syn_id,
(byte *) "vertex_blend", (byte *) "GL_EXT_vertex_weighting") ||
enable_ext (ctx, arbprogram_syn_id,
(byte *) "matrix_palette", (byte *) "GL_ARB_matrix_palette") ||
enable_ext (ctx, arbprogram_syn_id,
(byte *) "point_parameters", (byte *) "GL_ARB_point_parameters") ||
enable_ext (ctx, arbprogram_syn_id,
(byte *) "point_parameters", (byte *) "GL_EXT_point_parameters") ||
enable_ext (ctx, arbprogram_syn_id,
(byte *) "secondary_color", (byte *) "GL_EXT_secondary_color") ||
enable_ext (ctx, arbprogram_syn_id,
(byte *) "fog_coord", (byte *) "GL_EXT_fog_coord") ||
enable_ext (ctx, arbprogram_syn_id,
(byte *) "texture_rectangle", (byte *) "GL_EXT_texture_rectangle") ||
enable_ext (ctx, arbprogram_syn_id,
(byte *) "texture_rectangle", (byte *) "GL_NV_texture_rectangle") ||
enable_ext (ctx, arbprogram_syn_id,
(byte *) "fragment_program_shadow", (byte *) "GL_ARB_fragment_program_shadow")) {
grammar_destroy (arbprogram_syn_id);
return 1;
}
/* check for NULL character occurences */
{
int i;
for (i = 0; i < len; i++)
if (str[i] == '\0') {
_mesa_set_program_error (ctx, i, "invalid character");
_mesa_error (ctx, GL_INVALID_OPERATION, "Lexical Error");
grammar_destroy (arbprogram_syn_id);
return 1;
}
}
/* copy the program string to a null-terminated string */
/* XXX should I check for NULL from malloc()? */
strz = _mesa_malloc (len + 1);
_mesa_memcpy (strz, str, len);
strz[len] = '\0';
#if DEBUG_PARSING
printf ("Checking Grammar!\n");
#endif
err = grammar_check (arbprogram_syn_id, strz, &parsed, &parsed_len);
/* Syntax parse error */
if (err == 0) {
_mesa_free (strz);
grammar_get_last_error ((GLubyte *) error_msg, 300, &error_pos);
_mesa_set_program_error (ctx, error_pos, error_msg);
_mesa_error (ctx, GL_INVALID_OPERATION, "Parse Error");
grammar_destroy (arbprogram_syn_id);
return 1;
}
#if DEBUG_PARSING
printf ("Destroying grammer dict [parse retval: %d]\n", err);
#endif
grammar_destroy (arbprogram_syn_id);
/* Initialize the arb_program struct */
program->Base.String = strz;
program->Base.NumInstructions =
program->Base.NumTemporaries =
program->Base.NumParameters =
program->Base.NumAttributes = program->Base.NumAddressRegs = 0;
program->Parameters = _mesa_new_parameter_list ();
program->InputsRead = 0;
program->OutputsWritten = 0;
program->Position = 0;
program->MajorVersion = program->MinorVersion = 0;
program->PrecisionOption = GL_DONT_CARE;
program->FogOption = GL_NONE;
program->HintPositionInvariant = GL_FALSE;
for (a = 0; a < MAX_TEXTURE_IMAGE_UNITS; a++)
program->TexturesUsed[a] = 0;
program->NumAluInstructions =
program->NumTexInstructions =
program->NumTexIndirections = 0;
program->FPInstructions = NULL;
program->VPInstructions = NULL;
vc_head = NULL;
err = 0;
/* Start examining the tokens in the array */
inst = parsed;
/* Check the grammer rev */
if (*inst++ != REVISION) {
_mesa_set_program_error (ctx, 0, "Grammar version mismatch");
_mesa_error (ctx, GL_INVALID_OPERATION, "Grammar verison mismatch");
err = 1;
}
else {
switch (*inst++) {
case FRAGMENT_PROGRAM:
program->Base.Target = GL_FRAGMENT_PROGRAM_ARB;
break;
case VERTEX_PROGRAM:
program->Base.Target = GL_VERTEX_PROGRAM_ARB;
break;
}
err = parse_arb_program (ctx, inst, &vc_head, program);
#if DEBUG_PARSING
fprintf (stderr, "Symantic analysis returns %d [1 is bad!]\n", err);
#endif
}
/*debug_variables(ctx, vc_head, program); */
/* We're done with the parsed binary array */
var_cache_destroy (&vc_head);
_mesa_free (parsed);
#if DEBUG_PARSING
printf ("_mesa_parse_arb_program() done\n");
#endif
return err;
}