fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-05 07:28:11 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

change all enum tokens to uppercase

Browse source
This commit is contained in:
Brian 2007-02-16 09:31:35 -07:00
parent d15059b128
commit 1c1a0a23d3
16 changed files with 819 additions and 817 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

318
src/mesa/shader/slang/slang_codegen.c
View file

@ -142,12 +142,12 @@ static GLboolean
is_sampler_type(const slang_fully_specified_type *t)
{
switch (t->specifier.type) {
case slang_spec_sampler1D:
case slang_spec_sampler2D:
case slang_spec_sampler3D:
case slang_spec_samplerCube:
case slang_spec_sampler1DShadow:
case slang_spec_sampler2DShadow:
case SLANG_SPEC_SAMPLER1D:
case SLANG_SPEC_SAMPLER2D:
case SLANG_SPEC_SAMPLER3D:
case SLANG_SPEC_SAMPLERCUBE:
case SLANG_SPEC_SAMPLER1DSHADOW:
case SLANG_SPEC_SAMPLER2DSHADOW:
return GL_TRUE;
default:
return GL_FALSE;
@ -167,49 +167,49 @@ GLuint
_slang_sizeof_type_specifier(const slang_type_specifier *spec)
{
switch (spec->type) {
case slang_spec_void:
case SLANG_SPEC_VOID:
abort();
return 0;
case slang_spec_bool:
case SLANG_SPEC_BOOL:
return 1;
case slang_spec_bvec2:
case SLANG_SPEC_BVEC2:
return 2;
case slang_spec_bvec3:
case SLANG_SPEC_BVEC3:
return 3;
case slang_spec_bvec4:
case SLANG_SPEC_BVEC4:
return 4;
case slang_spec_int:
case SLANG_SPEC_INT:
return 1;
case slang_spec_ivec2:
case SLANG_SPEC_IVEC2:
return 2;
case slang_spec_ivec3:
case SLANG_SPEC_IVEC3:
return 3;
case slang_spec_ivec4:
case SLANG_SPEC_IVEC4:
return 4;
case slang_spec_float:
case SLANG_SPEC_FLOAT:
return 1;
case slang_spec_vec2:
case SLANG_SPEC_VEC2:
return 2;
case slang_spec_vec3:
case SLANG_SPEC_VEC3:
return 3;
case slang_spec_vec4:
case SLANG_SPEC_VEC4:
return 4;
case slang_spec_mat2:
case SLANG_SPEC_MAT2:
return 2 * 2;
case slang_spec_mat3:
case SLANG_SPEC_MAT3:
return 3 * 3;
case slang_spec_mat4:
case SLANG_SPEC_MAT4:
return 4 * 4;
case slang_spec_sampler1D:
case slang_spec_sampler2D:
case slang_spec_sampler3D:
case slang_spec_samplerCube:
case slang_spec_sampler1DShadow:
case slang_spec_sampler2DShadow:
case SLANG_SPEC_SAMPLER1D:
case SLANG_SPEC_SAMPLER2D:
case SLANG_SPEC_SAMPLER3D:
case SLANG_SPEC_SAMPLERCUBE:
case SLANG_SPEC_SAMPLER1DSHADOW:
case SLANG_SPEC_SAMPLER2DSHADOW:
return 1; /* special case */
case slang_spec_struct:
case SLANG_SPEC_STRUCT:
return _slang_sizeof_struct(spec->_struct);
case slang_spec_array:
case SLANG_SPEC_ARRAY:
return 1; /* XXX */
default:
abort();
@ -295,17 +295,17 @@ static GLint
sampler_to_texture_index(const slang_type_specifier_type type)
{
switch (type) {
case slang_spec_sampler1D:
case SLANG_SPEC_SAMPLER1D:
return TEXTURE_1D_INDEX;
case slang_spec_sampler2D:
case SLANG_SPEC_SAMPLER2D:
return TEXTURE_2D_INDEX;
case slang_spec_sampler3D:
case SLANG_SPEC_SAMPLER3D:
return TEXTURE_3D_INDEX;
case slang_spec_samplerCube:
case SLANG_SPEC_SAMPLERCUBE:
return TEXTURE_CUBE_INDEX;
case slang_spec_sampler1DShadow:
case SLANG_SPEC_SAMPLER1DSHADOW:
return TEXTURE_1D_INDEX; /* XXX fix */
case slang_spec_sampler2DShadow:
case SLANG_SPEC_SAMPLER2DSHADOW:
return TEXTURE_2D_INDEX; /* XXX fix */
default:
return -1;
@ -708,9 +708,9 @@ new_var(slang_assemble_ctx *A, slang_operation *oper, slang_atom name)
static GLboolean
slang_is_asm_function(const slang_function *fun)
{
if (fun->body->type == slang_oper_block_no_new_scope &&
if (fun->body->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE &&
fun->body->num_children == 1 &&
fun->body->children[0].type == slang_oper_asm) {
fun->body->children[0].type == SLANG_OPER_ASM) {
return GL_TRUE;
}
return GL_FALSE;
@ -729,7 +729,7 @@ slang_inline_asm_function(slang_assemble_ctx *A,
GLuint i;
slang_operation *inlined = slang_operation_new(1);
/*assert(oper->type == slang_oper_call); or vec4_add, etc */
/*assert(oper->type == SLANG_OPER_CALL); or vec4_add, etc */
/*
printf("Inline asm %s\n", (char*) fun->header.a_name);
*/
@ -755,7 +755,7 @@ slang_inline_asm_function(slang_assemble_ctx *A,
static void
slang_resolve_variable(slang_operation *oper)
{
if (oper->type != slang_oper_identifier)
if (oper->type != SLANG_OPER_IDENTIFIER)
return;
if (!oper->var) {
oper->var = _slang_locate_variable(oper->locals,
@ -768,7 +768,7 @@ slang_resolve_variable(slang_operation *oper)
/**
* Replace particular variables (slang_oper_identifier) with new expressions.
* Replace particular variables (SLANG_OPER_IDENTIFIER) with new expressions.
*/
static void
slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
@ -776,7 +776,7 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
slang_operation **substNew, GLboolean isLHS)
{
switch (oper->type) {
case slang_oper_variable_decl:
case SLANG_OPER_VARIABLE_DECL:
{
slang_variable *v = _slang_locate_variable(oper->locals,
oper->a_id, GL_TRUE);
@ -793,7 +793,7 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
}
}
break;
case slang_oper_identifier:
case SLANG_OPER_IDENTIFIER:
assert(oper->num_children == 0);
if (1/**!isLHS XXX FIX */) {
slang_atom id = oper->a_id;
@ -811,9 +811,9 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
/* look for a substitution */
for (i = 0; i < substCount; i++) {
if (v == substOld[i]) {
/* OK, replace this slang_oper_identifier with a new expr */
/* OK, replace this SLANG_OPER_IDENTIFIER with a new expr */
#if 0 /* DEBUG only */
if (substNew[i]->type == slang_oper_identifier) {
if (substNew[i]->type == SLANG_OPER_IDENTIFIER) {
assert(substNew[i]->var);
assert(substNew[i]->var->a_name);
printf("Substitute %s with %s in id node %p\n",
@ -833,7 +833,7 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
}
break;
#if 1 /* XXX rely on default case below */
case slang_oper_return:
case SLANG_OPER_RETURN:
/* do return replacement here too */
assert(oper->num_children == 0 || oper->num_children == 1);
if (oper->num_children == 1) {
@ -846,23 +846,23 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
*/
slang_operation *blockOper, *assignOper, *returnOper;
blockOper = slang_operation_new(1);
blockOper->type = slang_oper_block_no_new_scope;
blockOper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
blockOper->num_children = 2;
blockOper->children = slang_operation_new(2);
assignOper = blockOper->children + 0;
returnOper = blockOper->children + 1;
assignOper->type = slang_oper_assign;
assignOper->type = SLANG_OPER_ASSIGN;
assignOper->num_children = 2;
assignOper->children = slang_operation_new(2);
assignOper->children[0].type = slang_oper_identifier;
assignOper->children[0].type = SLANG_OPER_IDENTIFIER;
assignOper->children[0].a_id = slang_atom_pool_atom(A->atoms, "__retVal");
assignOper->children[0].locals->outer_scope = oper->locals;
assignOper->locals = oper->locals;
slang_operation_copy(&assignOper->children[1],
&oper->children[0]);
returnOper->type = slang_oper_return;
returnOper->type = SLANG_OPER_RETURN;
assert(returnOper->num_children == 0);
/* do substitutions on the "__retVal = expr" sub-tree */
@ -875,8 +875,8 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
}
break;
#endif
case slang_oper_assign:
case slang_oper_subscript:
case SLANG_OPER_ASSIGN:
case SLANG_OPER_SUBSCRIPT:
/* special case:
* child[0] can't have substitutions but child[1] can.
*/
@ -885,7 +885,7 @@ slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
slang_substitute(A, &oper->children[1],
substCount, substOld, substNew, GL_FALSE);
break;
case slang_oper_field:
case SLANG_OPER_FIELD:
/* XXX NEW - test */
slang_substitute(A, &oper->children[0],
substCount, substOld, substNew, GL_TRUE);
@ -925,7 +925,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
slang_operation **substNew;
GLuint substCount, numCopyIn, i;
/*assert(oper->type == slang_oper_call); (or (matrix) multiply, etc) */
/*assert(oper->type == SLANG_OPER_CALL); (or (matrix) multiply, etc) */
assert(fun->param_count == totalArgs);
/* allocate temporary arrays */
@ -953,7 +953,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
slang_variable *resultVar;
commaSeq = slang_operation_new(1);
commaSeq->type = slang_oper_sequence;
commaSeq->type = SLANG_OPER_SEQUENCE;
assert(commaSeq->locals);
commaSeq->locals->outer_scope = oper->locals->outer_scope;
commaSeq->num_children = 3;
@ -971,7 +971,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
/* child[0] = __resultTmp declaration */
declOper = &commaSeq->children[0];
declOper->type = slang_oper_variable_decl;
declOper->type = SLANG_OPER_VARIABLE_DECL;
declOper->a_id = resultVar->a_name;
declOper->locals->outer_scope = commaSeq->locals; /*** ??? **/
@ -982,7 +982,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
/* child[2] = __resultTmp reference */
returnOper = &commaSeq->children[2];
returnOper->type = slang_oper_identifier;
returnOper->type = SLANG_OPER_IDENTIFIER;
returnOper->a_id = resultVar->a_name;
returnOper->locals->outer_scope = commaSeq->locals;
declOper->locals->outer_scope = commaSeq->locals;
@ -1013,8 +1013,8 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
slang_type_qual_string(p->type.qualifier),
(char *) p->a_name);
*/
if (p->type.qualifier == slang_qual_inout ||
p->type.qualifier == slang_qual_out) {
if (p->type.qualifier == SLANG_QUAL_INOUT ||
p->type.qualifier == SLANG_QUAL_OUT) {
/* an output param */
slang_operation *arg;
if (i < numArgs)
@ -1023,7 +1023,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
arg = returnOper;
paramMode[i] = SUBST;
if (arg->type == slang_oper_identifier)
if (arg->type == SLANG_OPER_IDENTIFIER)
slang_resolve_variable(arg);
/* replace parameter 'p' with argument 'arg' */
@ -1031,10 +1031,10 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
substNew[substCount] = arg; /* will get copied */
substCount++;
}
else if (p->type.qualifier == slang_qual_const) {
else if (p->type.qualifier == SLANG_QUAL_CONST) {
/* a constant input param */
if (args[i].type == slang_oper_identifier ||
args[i].type == slang_oper_literal_float) {
if (args[i].type == SLANG_OPER_IDENTIFIER ||
args[i].type == SLANG_OPER_LITERAL_FLOAT) {
/* replace all occurances of this parameter variable with the
* actual argument variable or a literal.
*/
@ -1058,8 +1058,8 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
slang_operation_copy(inlined, fun->body);
/*** XXX review this */
assert(inlined->type = slang_oper_block_no_new_scope);
inlined->type = slang_oper_block_new_scope;
assert(inlined->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE);
inlined->type = SLANG_OPER_BLOCK_NEW_SCOPE;
#if 0
printf("======================= orig body code ======================\n");
@ -1092,7 +1092,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
/*
printf("COPY_IN %s from expr\n", (char*)p->a_name);
*/
decl->type = slang_oper_variable_decl;
decl->type = SLANG_OPER_VARIABLE_DECL;
assert(decl->locals);
decl->locals = fun->parameters;
decl->a_id = p->a_name;
@ -1114,7 +1114,7 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
slang_operation *lab = slang_operation_insert(&inlined->num_children,
&inlined->children,
inlined->num_children);
lab->type = slang_oper_label;
lab->type = SLANG_OPER_LABEL;
lab->a_id = slang_atom_pool_atom(A->atoms,
(char *) A->CurFunction->end_label);
}
@ -1127,13 +1127,13 @@ slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
slang_operation *ass = slang_operation_insert(&inlined->num_children,
&inlined->children,
inlined->num_children);
ass->type = slang_oper_assign;
ass->type = SLANG_OPER_ASSIGN;
ass->num_children = 2;
ass->locals = _slang_variable_scope_new(inlined->locals);
assert(ass->locals);
ass->children = slang_operation_new(2);
ass->children[0] = args[i]; /*XXX copy */
ass->children[1].type = slang_oper_identifier;
ass->children[1].type = SLANG_OPER_IDENTIFIER;
ass->children[1].a_id = p->a_name;
ass->children[1].locals = _slang_variable_scope_new(ass->locals);
}
@ -1261,7 +1261,7 @@ _slang_gen_asm(slang_assemble_ctx *A, slang_operation *oper,
slang_ir_node *kids[3], *n;
GLuint j, firstOperand;
assert(oper->type == slang_oper_asm);
assert(oper->type == SLANG_OPER_ASM);
info = slang_find_asm_info((char *) oper->a_id);
if (!info) {
@ -1301,7 +1301,7 @@ _slang_gen_asm(slang_assemble_ctx *A, slang_operation *oper,
slang_ir_node *n0;
dest_oper = &oper->children[0];
while /*if*/ (dest_oper->type == slang_oper_field) {
while /*if*/ (dest_oper->type == SLANG_OPER_FIELD) {
/* writemask */
writemask &= /*=*/make_writemask((char*) dest_oper->a_id);
dest_oper = &dest_oper->children[0];
@ -1326,8 +1326,8 @@ static GLboolean
_slang_is_noop(const slang_operation *oper)
{
if (!oper ||
oper->type == slang_oper_void ||
(oper->num_children == 1 && oper->children[0].type == slang_oper_void))
oper->type == SLANG_OPER_VOID ||
(oper->num_children == 1 && oper->children[0].type == SLANG_OPER_VOID))
return GL_TRUE;
else
return GL_FALSE;
@ -1414,16 +1414,16 @@ _slang_gen_function_call_name(slang_assemble_ctx *A, const char *name,
static GLboolean
_slang_is_constant_cond(const slang_operation *oper, GLboolean *value)
{
if (oper->type == slang_oper_literal_float ||
oper->type == slang_oper_literal_int ||
oper->type == slang_oper_literal_bool) {
if (oper->type == SLANG_OPER_LITERAL_FLOAT ||
oper->type == SLANG_OPER_LITERAL_INT ||
oper->type == SLANG_OPER_LITERAL_BOOL) {
if (oper->literal[0])
*value = GL_TRUE;
else
*value = GL_FALSE;
return GL_TRUE;
}
else if (oper->type == slang_oper_expression &&
else if (oper->type == SLANG_OPER_EXPRESSION &&
oper->num_children == 1) {
return _slang_is_constant_cond(&oper->children[0], value);
}
@ -1620,8 +1620,8 @@ is_operation_type(const const slang_operation *oper, slang_operation_type type)
{
if (oper->type == type)
return GL_TRUE;
else if ((oper->type == slang_oper_block_new_scope ||
oper->type == slang_oper_block_no_new_scope) &&
else if ((oper->type == SLANG_OPER_BLOCK_NEW_SCOPE ||
oper->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE) &&
oper->num_children == 1)
return is_operation_type(&oper->children[0], type);
else
@ -1650,7 +1650,7 @@ _slang_gen_hl_if(slang_assemble_ctx * A, const slang_operation *oper)
cond = _slang_gen_operation(A, &oper->children[0]);
cond = new_cond(cond);
if (is_operation_type(&oper->children[1], slang_oper_break)) {
if (is_operation_type(&oper->children[1], SLANG_OPER_BREAK)) {
/* Special case: generate a conditional break */
ifBody = new_break_if(A->CurLoop, cond, GL_TRUE);
if (haveElseClause) {
@ -1659,7 +1659,7 @@ _slang_gen_hl_if(slang_assemble_ctx * A, const slang_operation *oper)
}
return ifBody;
}
else if (is_operation_type(&oper->children[1], slang_oper_continue)) {
else if (is_operation_type(&oper->children[1], SLANG_OPER_CONTINUE)) {
/* Special case: generate a conditional break */
ifBody = new_cont_if(A->CurLoop, cond, GL_TRUE);
if (haveElseClause) {
@ -1744,7 +1744,7 @@ _slang_gen_select(slang_assemble_ctx *A, slang_operation *oper)
slang_typeinfo type;
int size;
assert(oper->type == slang_oper_select);
assert(oper->type == SLANG_OPER_SELECT);
assert(oper->num_children == 3);
/* size of x or y's type */
@ -1811,13 +1811,13 @@ _slang_gen_logical_and(slang_assemble_ctx *A, slang_operation *oper)
slang_ir_node *n;
select = slang_operation_new(1);
select->type = slang_oper_select;
select->type = SLANG_OPER_SELECT;
select->num_children = 3;
select->children = slang_operation_new(3);
slang_operation_copy(&select->children[0], &oper->children[0]);
slang_operation_copy(&select->children[1], &oper->children[1]);
select->children[2].type = slang_oper_literal_bool;
select->children[2].type = SLANG_OPER_LITERAL_BOOL;
ASSIGN_4V(select->children[2].literal, 0, 0, 0, 0);
select->children[2].literal_size = 2;
@ -1842,12 +1842,12 @@ _slang_gen_logical_or(slang_assemble_ctx *A, slang_operation *oper)
slang_ir_node *n;
select = slang_operation_new(1);
select->type = slang_oper_select;
select->type = SLANG_OPER_SELECT;
select->num_children = 3;
select->children = slang_operation_new(3);
slang_operation_copy(&select->children[0], &oper->children[0]);
select->children[1].type = slang_oper_literal_bool;
select->children[1].type = SLANG_OPER_LITERAL_BOOL;
ASSIGN_4V(select->children[2].literal, 1, 1, 1, 1);
slang_operation_copy(&select->children[2], &oper->children[1]);
select->children[2].literal_size = 2;
@ -1871,7 +1871,7 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
{
if (oper->num_children == 0 ||
(oper->num_children == 1 &&
oper->children[0].type == slang_oper_void)) {
oper->children[0].type == SLANG_OPER_VOID)) {
/* Convert from:
* return;
* To:
@ -1880,7 +1880,7 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
slang_ir_node *n;
slang_operation gotoOp;
slang_operation_construct(&gotoOp);
gotoOp.type = slang_oper_goto;
gotoOp.type = SLANG_OPER_GOTO;
/* XXX don't call function? */
gotoOp.a_id = slang_atom_pool_atom(A->atoms,
(char *) A->CurFunction->end_label);
@ -1914,7 +1914,7 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
#endif
block = slang_operation_new(1);
block->type = slang_oper_block_no_new_scope;
block->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
block->num_children = 2;
block->children = slang_operation_new(2);
assert(block->locals);
@ -1922,12 +1922,12 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
/* child[0]: __retVal = expr; */
assign = &block->children[0];
assign->type = slang_oper_assign;
assign->type = SLANG_OPER_ASSIGN;
assign->locals->outer_scope = block->locals;
assign->num_children = 2;
assign->children = slang_operation_new(2);
/* lhs (__retVal) */
assign->children[0].type = slang_oper_identifier;
assign->children[0].type = SLANG_OPER_IDENTIFIER;
assign->children[0].a_id = a_retVal;
assign->children[0].locals->outer_scope = assign->locals;
/* rhs (expr) */
@ -1936,7 +1936,7 @@ _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
/* child[1]: goto __endOfFunction */
jump = &block->children[1];
jump->type = slang_oper_goto;
jump->type = SLANG_OPER_GOTO;
assert(A->CurFunction->end_label);
/* XXX don't call function? */
jump->a_id = slang_atom_pool_atom(A->atoms,
@ -2150,8 +2150,8 @@ _slang_gen_swizzle(slang_ir_node *child, GLuint swizzle)
static slang_ir_node *
_slang_gen_assignment(slang_assemble_ctx * A, slang_operation *oper)
{
if (oper->children[0].type == slang_oper_identifier &&
oper->children[1].type == slang_oper_call) {
if (oper->children[0].type == SLANG_OPER_IDENTIFIER &&
oper->children[1].type == SLANG_OPER_CALL) {
/* Special case of: x = f(a, b)
* Replace with f(a, b, x) (where x == hidden __retVal out param)
*
@ -2220,7 +2220,7 @@ _slang_gen_field(slang_assemble_ctx * A, slang_operation *oper)
n = _slang_gen_swizzle(n, swizzle);
return n;
}
else if (ti.spec.type == slang_spec_float) {
else if (ti.spec.type == SLANG_SPEC_FLOAT) {
const GLuint rows = 1;
slang_swizzle swz;
slang_ir_node *n;
@ -2267,7 +2267,7 @@ _slang_gen_subscript(slang_assemble_ctx * A, slang_operation *oper)
slang_ir_node *n;
index = (GLint) oper->children[1].literal[0];
if (oper->children[1].type != slang_oper_literal_int ||
if (oper->children[1].type != SLANG_OPER_LITERAL_INT ||
index >= max) {
RETURN_ERROR("Invalid array index for vector type", 0);
}
@ -2321,15 +2321,15 @@ static slang_ir_node *
_slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
{
switch (oper->type) {
case slang_oper_block_new_scope:
case SLANG_OPER_BLOCK_NEW_SCOPE:
{
slang_ir_node *n;
_slang_push_var_table(A->vartable);
oper->type = slang_oper_block_no_new_scope; /* temp change */
oper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE; /* temp change */
n = _slang_gen_operation(A, oper);
oper->type = slang_oper_block_new_scope; /* restore */
oper->type = SLANG_OPER_BLOCK_NEW_SCOPE; /* restore */
_slang_pop_var_table(A->vartable);
@ -2339,7 +2339,7 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
}
break;
case slang_oper_block_no_new_scope:
case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
/* list of operations */
if (oper->num_children > 0)
{
@ -2378,104 +2378,104 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
return tree;
}
break;
case slang_oper_expression:
case SLANG_OPER_EXPRESSION:
return _slang_gen_operation(A, &oper->children[0]);
case slang_oper_for:
case SLANG_OPER_FOR:
return _slang_gen_for(A, oper);
case slang_oper_do:
case SLANG_OPER_DO:
return _slang_gen_do(A, oper);
case slang_oper_while:
case SLANG_OPER_WHILE:
return _slang_gen_while(A, oper);
case slang_oper_break:
case SLANG_OPER_BREAK:
if (!A->CurLoop) {
RETURN_ERROR("'break' not in loop", 0);
}
return new_break(A->CurLoop);
case slang_oper_continue:
case SLANG_OPER_CONTINUE:
if (!A->CurLoop) {
RETURN_ERROR("'continue' not in loop", 0);
}
return new_cont(A->CurLoop);
case slang_oper_discard:
case SLANG_OPER_DISCARD:
return new_node0(IR_KILL);
case slang_oper_equal:
case SLANG_OPER_EQUAL:
return new_node2(IR_SEQUAL,
_slang_gen_operation(A, &oper->children[0]),
_slang_gen_operation(A, &oper->children[1]));
case slang_oper_notequal:
case SLANG_OPER_NOTEQUAL:
return new_node2(IR_SNEQUAL,
_slang_gen_operation(A, &oper->children[0]),
_slang_gen_operation(A, &oper->children[1]));
case slang_oper_greater:
case SLANG_OPER_GREATER:
return new_node2(IR_SGT,
_slang_gen_operation(A, &oper->children[0]),
_slang_gen_operation(A, &oper->children[1]));
case slang_oper_less:
case SLANG_OPER_LESS:
/* child[0] < child[1] ----> child[1] > child[0] */
return new_node2(IR_SGT,
_slang_gen_operation(A, &oper->children[1]),
_slang_gen_operation(A, &oper->children[0]));
case slang_oper_greaterequal:
case SLANG_OPER_GREATERequal:
return new_node2(IR_SGE,
_slang_gen_operation(A, &oper->children[0]),
_slang_gen_operation(A, &oper->children[1]));
case slang_oper_lessequal:
case SLANG_OPER_LESSequal:
/* child[0] <= child[1] ----> child[1] >= child[0] */
return new_node2(IR_SGE,
_slang_gen_operation(A, &oper->children[1]),
_slang_gen_operation(A, &oper->children[0]));
case slang_oper_add:
case SLANG_OPER_ADD:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_function_call_name(A, "+", oper, NULL);
return n;
}
case slang_oper_subtract:
case SLANG_OPER_SUBTRACT:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_function_call_name(A, "-", oper, NULL);
return n;
}
case slang_oper_multiply:
case SLANG_OPER_MULTIPLY:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_function_call_name(A, "*", oper, NULL);
return n;
}
case slang_oper_divide:
case SLANG_OPER_DIVIDE:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_function_call_name(A, "/", oper, NULL);
return n;
}
case slang_oper_minus:
case SLANG_OPER_MINUS:
{
slang_ir_node *n;
assert(oper->num_children == 1);
n = _slang_gen_function_call_name(A, "-", oper, NULL);
return n;
}
case slang_oper_plus:
case SLANG_OPER_PLUS:
/* +expr --> do nothing */
return _slang_gen_operation(A, &oper->children[0]);
case slang_oper_variable_decl:
case SLANG_OPER_VARIABLE_DECL:
return _slang_gen_declaration(A, oper);
case slang_oper_assign:
case SLANG_OPER_ASSIGN:
return _slang_gen_assignment(A, oper);
case slang_oper_addassign:
case SLANG_OPER_ADDASSIGN:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_function_call_name(A, "+=", oper, &oper->children[0]);
return n;
}
case slang_oper_subassign:
case SLANG_OPER_SUBASSIGN:
{
slang_ir_node *n;
assert(oper->num_children == 2);
@ -2483,42 +2483,42 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
return n;
}
break;
case slang_oper_mulassign:
case SLANG_OPER_MULASSIGN:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_function_call_name(A, "*=", oper, &oper->children[0]);
return n;
}
case slang_oper_divassign:
case SLANG_OPER_DIVASSIGN:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_function_call_name(A, "/=", oper, &oper->children[0]);
return n;
}
case slang_oper_logicaland:
case SLANG_OPER_LOGICALAND:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_logical_and(A, oper);
return n;
}
case slang_oper_logicalor:
case SLANG_OPER_LOGICALOR:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_logical_or(A, oper);
return n;
}
case slang_oper_logicalxor:
case SLANG_OPER_LOGICALXOR:
{
slang_ir_node *n;
assert(oper->num_children == 2);
n = _slang_gen_function_call_name(A, "__logicalXor", oper, NULL);
return n;
}
case slang_oper_not:
case SLANG_OPER_NOT:
{
slang_ir_node *n;
assert(oper->num_children == 1);
@ -2526,7 +2526,7 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
return n;
}
case slang_oper_select: /* b ? x : y */
case SLANG_OPER_SELECT: /* b ? x : y */
{
slang_ir_node *n;
assert(oper->num_children == 3);
@ -2534,20 +2534,20 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
return n;
}
case slang_oper_asm:
case SLANG_OPER_ASM:
return _slang_gen_asm(A, oper, NULL);
case slang_oper_call:
case SLANG_OPER_CALL:
return _slang_gen_function_call_name(A, (const char *) oper->a_id,
oper, NULL);
case slang_oper_return:
case SLANG_OPER_RETURN:
return _slang_gen_return(A, oper);
case slang_oper_goto:
case SLANG_OPER_GOTO:
return new_jump((char*) oper->a_id);
case slang_oper_label:
case SLANG_OPER_LABEL:
return new_label((char*) oper->a_id);
case slang_oper_identifier:
case SLANG_OPER_IDENTIFIER:
return _slang_gen_variable(A, oper);
case slang_oper_if:
case SLANG_OPER_IF:
if (A->program->Target == GL_FRAGMENT_PROGRAM_ARB) {
return _slang_gen_hl_if(A, oper);
}
@ -2555,39 +2555,39 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
/* XXX update tnl executor */
return _slang_gen_if(A, oper);
}
case slang_oper_field:
case SLANG_OPER_FIELD:
return _slang_gen_field(A, oper);
case slang_oper_subscript:
case SLANG_OPER_SUBSCRIPT:
return _slang_gen_subscript(A, oper);
case slang_oper_literal_float:
case SLANG_OPER_LITERAL_FLOAT:
/* fall-through */
case slang_oper_literal_int:
case SLANG_OPER_LITERAL_INT:
/* fall-through */
case slang_oper_literal_bool:
case SLANG_OPER_LITERAL_BOOL:
return new_float_literal(oper->literal);
case slang_oper_postincrement: /* var++ */
case SLANG_OPER_POSTINCREMENT: /* var++ */
{
slang_ir_node *n;
assert(oper->num_children == 1);
n = _slang_gen_function_call_name(A, "__postIncr", oper, NULL);
return n;
}
case slang_oper_postdecrement: /* var-- */
case SLANG_OPER_POSTDECREMENT: /* var-- */
{
slang_ir_node *n;
assert(oper->num_children == 1);
n = _slang_gen_function_call_name(A, "__postDecr", oper, NULL);
return n;
}
case slang_oper_preincrement: /* ++var */
case SLANG_OPER_PREINCREMENT: /* ++var */
{
slang_ir_node *n;
assert(oper->num_children == 1);
n = _slang_gen_function_call_name(A, "++", oper, NULL);
return n;
}
case slang_oper_predecrement: /* --var */
case SLANG_OPER_PREDECREMENT: /* --var */
{
slang_ir_node *n;
assert(oper->num_children == 1);
@ -2595,7 +2595,7 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
return n;
}
case slang_oper_sequence:
case SLANG_OPER_SEQUENCE:
{
slang_ir_node *tree = NULL;
GLuint i;
@ -2606,9 +2606,9 @@ _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
return tree;
}
case slang_oper_none:
case SLANG_OPER_NONE:
return NULL;
case slang_oper_void:
case SLANG_OPER_VOID:
return NULL;
default:
@ -2658,7 +2658,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
store = _slang_new_ir_storage(PROGRAM_SAMPLER, samplerUniform, texIndex);
if (dbg) printf("SAMPLER ");
}
else if (var->type.qualifier == slang_qual_uniform) {
else if (var->type.qualifier == SLANG_QUAL_UNIFORM) {
/* Uniform variable */
const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
if (prog) {
@ -2675,7 +2675,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
}
if (dbg) printf("UNIFORM ");
}
else if (var->type.qualifier == slang_qual_varying) {
else if (var->type.qualifier == SLANG_QUAL_VARYING) {
const GLint size = 4; /* XXX fix */
if (prog) {
/* user-defined varying */
@ -2684,7 +2684,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
}
else {
/* pre-defined varying, like gl_Color or gl_TexCoord */
if (type == slang_unit_fragment_builtin) {
if (type == SLANG_UNIT_FRAGMENT_BUILTIN) {
GLint index = _slang_input_index(varName, GL_FRAGMENT_PROGRAM_ARB);
assert(index >= 0);
store = _slang_new_ir_storage(PROGRAM_INPUT, index, size);
@ -2693,7 +2693,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
else {
GLint index = _slang_output_index(varName, GL_VERTEX_PROGRAM_ARB);
assert(index >= 0);
assert(type == slang_unit_vertex_builtin);
assert(type == SLANG_UNIT_VERTEX_BUILTIN);
store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
assert(index < VERT_RESULT_MAX);
}
@ -2701,7 +2701,7 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
}
if (dbg) printf("VARYING ");
}
else if (var->type.qualifier == slang_qual_attribute) {
else if (var->type.qualifier == SLANG_QUAL_ATTRIBUTE) {
if (prog) {
/* user-defined vertex attribute */
const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
@ -2721,27 +2721,27 @@ _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
}
if (dbg) printf("ATTRIB ");
}
else if (var->type.qualifier == slang_qual_fixedinput) {
else if (var->type.qualifier == SLANG_QUAL_FIXEDINPUT) {
GLint index = _slang_input_index(varName, GL_FRAGMENT_PROGRAM_ARB);
GLint size = 4; /* XXX? */
store = _slang_new_ir_storage(PROGRAM_INPUT, index, size);
if (dbg) printf("INPUT ");
}
else if (var->type.qualifier == slang_qual_fixedoutput) {
if (type == slang_unit_vertex_builtin) {
else if (var->type.qualifier == SLANG_QUAL_FIXEDOUTPUT) {
if (type == SLANG_UNIT_VERTEX_BUILTIN) {
GLint index = _slang_output_index(varName, GL_VERTEX_PROGRAM_ARB);
GLint size = 4; /* XXX? */
store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
}
else {
assert(type == slang_unit_fragment_builtin);
assert(type == SLANG_UNIT_FRAGMENT_BUILTIN);
GLint index = _slang_output_index(varName, GL_FRAGMENT_PROGRAM_ARB);
GLint size = 4; /* XXX? */
store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
}
if (dbg) printf("OUTPUT ");
}
else if (var->type.qualifier == slang_qual_const && !prog) {
else if (var->type.qualifier == SLANG_QUAL_CONST && !prog) {
/* pre-defined global constant, like gl_MaxLights */
const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
store = _slang_new_ir_storage(PROGRAM_CONSTANT, -1, size);

224
src/mesa/shader/slang/slang_compile.c
View file

@ -358,7 +358,7 @@ parse_array_len(slang_parse_ctx * C, slang_output_ctx * O, GLuint * len)
/* evaluate compile-time expression which is array size */
_slang_simplify(&array_size, &space, C->atoms);
result = (array_size.type == slang_oper_literal_int);
result = (array_size.type == SLANG_OPER_LITERAL_INT);
slang_operation_destruct(&array_size);
return result;
@ -388,7 +388,7 @@ convert_to_array(slang_parse_ctx * C, slang_variable * var,
{
/* sized array - mark it as array, copy the specifier to the array element and
* parse the expression */
var->type.specifier.type = slang_spec_array;
var->type.specifier.type = SLANG_SPEC_ARRAY;
var->type.specifier._array = (slang_type_specifier *)
slang_alloc_malloc(sizeof(slang_type_specifier));
if (var->type.specifier._array == NULL) {
@ -540,25 +540,25 @@ parse_type_qualifier(slang_parse_ctx * C, slang_type_qualifier * qual)
{
switch (*C->I++) {
case TYPE_QUALIFIER_NONE:
*qual = slang_qual_none;
*qual = SLANG_QUAL_NONE;
break;
case TYPE_QUALIFIER_CONST:
*qual = slang_qual_const;
*qual = SLANG_QUAL_CONST;
break;
case TYPE_QUALIFIER_ATTRIBUTE:
*qual = slang_qual_attribute;
*qual = SLANG_QUAL_ATTRIBUTE;
break;
case TYPE_QUALIFIER_VARYING:
*qual = slang_qual_varying;
*qual = SLANG_QUAL_VARYING;
break;
case TYPE_QUALIFIER_UNIFORM:
*qual = slang_qual_uniform;
*qual = SLANG_QUAL_UNIFORM;
break;
case TYPE_QUALIFIER_FIXEDOUTPUT:
*qual = slang_qual_fixedoutput;
*qual = SLANG_QUAL_FIXEDOUTPUT;
break;
case TYPE_QUALIFIER_FIXEDINPUT:
*qual = slang_qual_fixedinput;
*qual = SLANG_QUAL_FIXEDINPUT;
break;
default:
return 0;
@ -598,78 +598,78 @@ parse_type_specifier(slang_parse_ctx * C, slang_output_ctx * O,
{
switch (*C->I++) {
case TYPE_SPECIFIER_VOID:
spec->type = slang_spec_void;
spec->type = SLANG_SPEC_VOID;
break;
case TYPE_SPECIFIER_BOOL:
spec->type = slang_spec_bool;
spec->type = SLANG_SPEC_BOOL;
break;
case TYPE_SPECIFIER_BVEC2:
spec->type = slang_spec_bvec2;
spec->type = SLANG_SPEC_BVEC2;
break;
case TYPE_SPECIFIER_BVEC3:
spec->type = slang_spec_bvec3;
spec->type = SLANG_SPEC_BVEC3;
break;
case TYPE_SPECIFIER_BVEC4:
spec->type = slang_spec_bvec4;
spec->type = SLANG_SPEC_BVEC4;
break;
case TYPE_SPECIFIER_INT:
spec->type = slang_spec_int;
spec->type = SLANG_SPEC_INT;
break;
case TYPE_SPECIFIER_IVEC2:
spec->type = slang_spec_ivec2;
spec->type = SLANG_SPEC_IVEC2;
break;
case TYPE_SPECIFIER_IVEC3:
spec->type = slang_spec_ivec3;
spec->type = SLANG_SPEC_IVEC3;
break;
case TYPE_SPECIFIER_IVEC4:
spec->type = slang_spec_ivec4;
spec->type = SLANG_SPEC_IVEC4;
break;
case TYPE_SPECIFIER_FLOAT:
spec->type = slang_spec_float;
spec->type = SLANG_SPEC_FLOAT;
break;
case TYPE_SPECIFIER_VEC2:
spec->type = slang_spec_vec2;
spec->type = SLANG_SPEC_VEC2;
break;
case TYPE_SPECIFIER_VEC3:
spec->type = slang_spec_vec3;
spec->type = SLANG_SPEC_VEC3;
break;
case TYPE_SPECIFIER_VEC4:
spec->type = slang_spec_vec4;
spec->type = SLANG_SPEC_VEC4;
break;
case TYPE_SPECIFIER_MAT2:
spec->type = slang_spec_mat2;
spec->type = SLANG_SPEC_MAT2;
break;
case TYPE_SPECIFIER_MAT3:
spec->type = slang_spec_mat3;
spec->type = SLANG_SPEC_MAT3;
break;
case TYPE_SPECIFIER_MAT4:
spec->type = slang_spec_mat4;
spec->type = SLANG_SPEC_MAT4;
break;
case TYPE_SPECIFIER_SAMPLER1D:
spec->type = slang_spec_sampler1D;
spec->type = SLANG_SPEC_SAMPLER1D;
break;
case TYPE_SPECIFIER_SAMPLER2D:
spec->type = slang_spec_sampler2D;
spec->type = SLANG_SPEC_SAMPLER2D;
break;
case TYPE_SPECIFIER_SAMPLER3D:
spec->type = slang_spec_sampler3D;
spec->type = SLANG_SPEC_SAMPLER3D;
break;
case TYPE_SPECIFIER_SAMPLERCUBE:
spec->type = slang_spec_samplerCube;
spec->type = SLANG_SPEC_SAMPLERCUBE;
break;
case TYPE_SPECIFIER_SAMPLER1DSHADOW:
spec->type = slang_spec_sampler1DShadow;
spec->type = SLANG_SPEC_SAMPLER1DSHADOW;
break;
case TYPE_SPECIFIER_SAMPLER2DSHADOW:
spec->type = slang_spec_sampler2DShadow;
spec->type = SLANG_SPEC_SAMPLER2DSHADOW;
break;
case TYPE_SPECIFIER_STRUCT:
spec->type = slang_spec_struct;
spec->type = SLANG_SPEC_STRUCT;
if (!parse_struct(C, O, &spec->_struct))
return 0;
break;
case TYPE_SPECIFIER_TYPENAME:
spec->type = slang_spec_struct;
spec->type = SLANG_SPEC_STRUCT;
{
slang_atom a_name;
slang_struct *stru;
@ -817,7 +817,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
switch (*C->I++) {
case OP_BLOCK_BEGIN_NO_NEW_SCOPE:
/* parse child statements, do not create new variable scope */
oper->type = slang_oper_block_no_new_scope;
oper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
while (*C->I != OP_END)
if (!parse_child_operation(C, O, oper, 1))
return 0;
@ -828,7 +828,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
{
slang_output_ctx o = *O;
oper->type = slang_oper_block_new_scope;
oper->type = SLANG_OPER_BLOCK_NEW_SCOPE;
o.vars = oper->locals;
while (*C->I != OP_END)
if (!parse_child_operation(C, &o, oper, 1))
@ -840,7 +840,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
/* local variable declaration, individual declarators are stored as
* children identifiers
*/
oper->type = slang_oper_block_no_new_scope;
oper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
{
const unsigned int first_var = O->vars->num_variables;
@ -861,7 +861,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
}
for (i = first_var; i < O->vars->num_variables; i++) {
slang_operation *o = &oper->children[i - first_var];
o->type = slang_oper_variable_decl;
o->type = SLANG_OPER_VARIABLE_DECL;
o->locals->outer_scope = O->vars;
o->a_id = O->vars->variables[i]->a_name;
}
@ -872,7 +872,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
/* the __asm statement, parse the mnemonic and all its arguments
* as expressions
*/
oper->type = slang_oper_asm;
oper->type = SLANG_OPER_ASM;
oper->a_id = parse_identifier(C);
if (oper->a_id == SLANG_ATOM_NULL)
return 0;
@ -883,26 +883,26 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
C->I++;
break;
case OP_BREAK:
oper->type = slang_oper_break;
oper->type = SLANG_OPER_BREAK;
break;
case OP_CONTINUE:
oper->type = slang_oper_continue;
oper->type = SLANG_OPER_CONTINUE;
break;
case OP_DISCARD:
oper->type = slang_oper_discard;
oper->type = SLANG_OPER_DISCARD;
break;
case OP_RETURN:
oper->type = slang_oper_return;
oper->type = SLANG_OPER_RETURN;
if (!parse_child_operation(C, O, oper, 0))
return 0;
break;
case OP_EXPRESSION:
oper->type = slang_oper_expression;
oper->type = SLANG_OPER_EXPRESSION;
if (!parse_child_operation(C, O, oper, 0))
return 0;
break;
case OP_IF:
oper->type = slang_oper_if;
oper->type = SLANG_OPER_IF;
if (!parse_child_operation(C, O, oper, 0))
return 0;
if (!parse_child_operation(C, O, oper, 1))
@ -914,7 +914,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
{
slang_output_ctx o = *O;
oper->type = slang_oper_while;
oper->type = SLANG_OPER_WHILE;
o.vars = oper->locals;
if (!parse_child_operation(C, &o, oper, 1))
return 0;
@ -923,7 +923,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
}
break;
case OP_DO:
oper->type = slang_oper_do;
oper->type = SLANG_OPER_DO;
if (!parse_child_operation(C, O, oper, 1))
return 0;
if (!parse_child_operation(C, O, oper, 0))
@ -933,7 +933,7 @@ parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
{
slang_output_ctx o = *O;
oper->type = slang_oper_for;
oper->type = SLANG_OPER_FOR;
o.vars = oper->locals;
if (!parse_child_operation(C, &o, oper, 1))
return 0;
@ -986,7 +986,7 @@ static int
is_constructor_name(const char *name, slang_atom a_name,
slang_struct_scope * structs)
{
if (slang_type_specifier_type_from_string(name) != slang_spec_void)
if (slang_type_specifier_type_from_string(name) != SLANG_SPEC_VOID)
return 1;
return slang_struct_scope_find(structs, a_name, 1) != NULL;
}
@ -1022,10 +1022,10 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
switch (op_code) {
case OP_PUSH_VOID:
op->type = slang_oper_void;
op->type = SLANG_OPER_VOID;
break;
case OP_PUSH_BOOL:
op->type = slang_oper_literal_bool;
op->type = SLANG_OPER_LITERAL_BOOL;
if (!parse_number(C, &number))
return 0;
op->literal[0] =
@ -1035,7 +1035,7 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
op->literal_size = 1;
break;
case OP_PUSH_INT:
op->type = slang_oper_literal_int;
op->type = SLANG_OPER_LITERAL_INT;
if (!parse_number(C, &number))
return 0;
op->literal[0] =
@ -1045,7 +1045,7 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
op->literal_size = 1;
break;
case OP_PUSH_FLOAT:
op->type = slang_oper_literal_float;
op->type = SLANG_OPER_LITERAL_FLOAT;
if (!parse_float(C, &op->literal[0]))
return 0;
op->literal[1] =
@ -1054,38 +1054,38 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
op->literal_size = 1;
break;
case OP_PUSH_IDENTIFIER:
op->type = slang_oper_identifier;
op->type = SLANG_OPER_IDENTIFIER;
op->a_id = parse_identifier(C);
if (op->a_id == SLANG_ATOM_NULL)
return 0;
break;
case OP_SEQUENCE:
op->type = slang_oper_sequence;
op->type = SLANG_OPER_SEQUENCE;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_ASSIGN:
op->type = slang_oper_assign;
op->type = SLANG_OPER_ASSIGN;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_ADDASSIGN:
op->type = slang_oper_addassign;
op->type = SLANG_OPER_ADDASSIGN;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_SUBASSIGN:
op->type = slang_oper_subassign;
op->type = SLANG_OPER_SUBASSIGN;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_MULASSIGN:
op->type = slang_oper_mulassign;
op->type = SLANG_OPER_MULASSIGN;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_DIVASSIGN:
op->type = slang_oper_divassign;
op->type = SLANG_OPER_DIVASSIGN;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
@ -1096,22 +1096,22 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
/*case OP_XORASSIGN: */
/*case OP_ANDASSIGN: */
case OP_SELECT:
op->type = slang_oper_select;
op->type = SLANG_OPER_SELECT;
if (!handle_nary_expression(C, op, &ops, &num_ops, 3))
return 0;
break;
case OP_LOGICALOR:
op->type = slang_oper_logicalor;
op->type = SLANG_OPER_LOGICALOR;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_LOGICALXOR:
op->type = slang_oper_logicalxor;
op->type = SLANG_OPER_LOGICALXOR;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_LOGICALAND:
op->type = slang_oper_logicaland;
op->type = SLANG_OPER_LOGICALAND;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
@ -1119,91 +1119,91 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
/*case OP_BITXOR: */
/*case OP_BITAND: */
case OP_EQUAL:
op->type = slang_oper_equal;
op->type = SLANG_OPER_EQUAL;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_NOTEQUAL:
op->type = slang_oper_notequal;
op->type = SLANG_OPER_NOTEQUAL;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_LESS:
op->type = slang_oper_less;
op->type = SLANG_OPER_LESS;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_GREATER:
op->type = slang_oper_greater;
op->type = SLANG_OPER_GREATER;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_LESSEQUAL:
op->type = slang_oper_lessequal;
op->type = SLANG_OPER_LESSequal;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_GREATEREQUAL:
op->type = slang_oper_greaterequal;
op->type = SLANG_OPER_GREATERequal;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
/*case OP_LSHIFT: */
/*case OP_RSHIFT: */
case OP_ADD:
op->type = slang_oper_add;
op->type = SLANG_OPER_ADD;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_SUBTRACT:
op->type = slang_oper_subtract;
op->type = SLANG_OPER_SUBTRACT;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_MULTIPLY:
op->type = slang_oper_multiply;
op->type = SLANG_OPER_MULTIPLY;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_DIVIDE:
op->type = slang_oper_divide;
op->type = SLANG_OPER_DIVIDE;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
/*case OP_MODULUS: */
case OP_PREINCREMENT:
op->type = slang_oper_preincrement;
op->type = SLANG_OPER_PREINCREMENT;
if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
return 0;
break;
case OP_PREDECREMENT:
op->type = slang_oper_predecrement;
op->type = SLANG_OPER_PREDECREMENT;
if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
return 0;
break;
case OP_PLUS:
op->type = slang_oper_plus;
op->type = SLANG_OPER_PLUS;
if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
return 0;
break;
case OP_MINUS:
op->type = slang_oper_minus;
op->type = SLANG_OPER_MINUS;
if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
return 0;
break;
case OP_NOT:
op->type = slang_oper_not;
op->type = SLANG_OPER_NOT;
if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
return 0;
break;
/*case OP_COMPLEMENT: */
case OP_SUBSCRIPT:
op->type = slang_oper_subscript;
op->type = SLANG_OPER_SUBSCRIPT;
if (!handle_nary_expression(C, op, &ops, &num_ops, 2))
return 0;
break;
case OP_CALL:
op->type = slang_oper_call;
op->type = SLANG_OPER_CALL;
op->a_id = parse_identifier(C);
if (op->a_id == SLANG_ATOM_NULL)
return 0;
@ -1224,7 +1224,7 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
}
break;
case OP_FIELD:
op->type = slang_oper_field;
op->type = SLANG_OPER_FIELD;
op->a_id = parse_identifier(C);
if (op->a_id == SLANG_ATOM_NULL)
return 0;
@ -1232,12 +1232,12 @@ parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
return 0;
break;
case OP_POSTINCREMENT:
op->type = slang_oper_postincrement;
op->type = SLANG_OPER_POSTINCREMENT;
if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
return 0;
break;
case OP_POSTDECREMENT:
op->type = slang_oper_postdecrement;
op->type = SLANG_OPER_POSTDECREMENT;
if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
return 0;
break;
@ -1273,23 +1273,23 @@ parse_parameter_declaration(slang_parse_ctx * C, slang_output_ctx * O,
return 0;
switch (*C->I++) {
case PARAM_QUALIFIER_IN:
if (param->type.qualifier != slang_qual_const
&& param->type.qualifier != slang_qual_none) {
if (param->type.qualifier != SLANG_QUAL_CONST
&& param->type.qualifier != SLANG_QUAL_NONE) {
slang_info_log_error(C->L, "Invalid type qualifier.");
return 0;
}
break;
case PARAM_QUALIFIER_OUT:
if (param->type.qualifier == slang_qual_none)
param->type.qualifier = slang_qual_out;
if (param->type.qualifier == SLANG_QUAL_NONE)
param->type.qualifier = SLANG_QUAL_OUT;
else {
slang_info_log_error(C->L, "Invalid type qualifier.");
return 0;
}
break;
case PARAM_QUALIFIER_INOUT:
if (param->type.qualifier == slang_qual_none)
param->type.qualifier = slang_qual_inout;
if (param->type.qualifier == SLANG_QUAL_NONE)
param->type.qualifier = SLANG_QUAL_INOUT;
else {
slang_info_log_error(C->L, "Invalid type qualifier.");
return 0;
@ -1439,14 +1439,14 @@ parse_function_prototype(slang_parse_ctx * C, slang_output_ctx * O,
return 0;
switch (*C->I++) {
case FUNCTION_ORDINARY:
func->kind = slang_func_ordinary;
func->kind = SLANG_FUNC_ORDINARY;
func->header.a_name = parse_identifier(C);
if (func->header.a_name == SLANG_ATOM_NULL)
return 0;
break;
case FUNCTION_CONSTRUCTOR:
func->kind = slang_func_constructor;
if (func->header.type.specifier.type == slang_spec_struct)
func->kind = SLANG_FUNC_CONSTRUCTOR;
if (func->header.type.specifier.type == SLANG_SPEC_STRUCT)
return 0;
func->header.a_name =
slang_atom_pool_atom(C->atoms,
@ -1458,7 +1458,7 @@ parse_function_prototype(slang_parse_ctx * C, slang_output_ctx * O,
}
break;
case FUNCTION_OPERATOR:
func->kind = slang_func_operator;
func->kind = SLANG_FUNC_OPERATOR;
func->header.a_name = parse_operator_name(C);
if (func->header.a_name == SLANG_ATOM_NULL)
return 0;
@ -1487,7 +1487,7 @@ parse_function_prototype(slang_parse_ctx * C, slang_output_ctx * O,
assert(a_retVal);
p->a_name = a_retVal;
p->type = func->header.type;
p->type.qualifier = slang_qual_out;
p->type.qualifier = SLANG_QUAL_OUT;
}
/* function formal parameters and local variables share the same
@ -1546,7 +1546,7 @@ initialize_global(slang_assemble_ctx * A, slang_variable * var)
/* construct the left side of assignment */
if (!slang_operation_construct(&op_id))
return GL_FALSE;
op_id.type = slang_oper_identifier;
op_id.type = SLANG_OPER_IDENTIFIER;
op_id.a_id = var->a_name;
/* put the variable into operation's scope */
@ -1565,7 +1565,7 @@ initialize_global(slang_assemble_ctx * A, slang_variable * var)
slang_operation_destruct(&op_id);
return GL_FALSE;
}
op_assign.type = slang_oper_assign;
op_assign.type = SLANG_OPER_ASSIGN;
op_assign.children =
(slang_operation *) slang_alloc_malloc(2 * sizeof(slang_operation));
if (op_assign.children == NULL) {
@ -1689,7 +1689,7 @@ parse_init_declarator(slang_parse_ctx * C, slang_output_ctx * O,
/* allocate global address space for a variable with a known size */
if (C->global_scope
&& !(var->type.specifier.type == slang_spec_array
&& !(var->type.specifier.type == SLANG_SPEC_ARRAY
&& var->array_len == 0)) {
if (!calculate_var_size(C, O, var))
return GL_FALSE;
@ -1885,13 +1885,13 @@ parse_code_unit(slang_parse_ctx * C, slang_code_unit * unit,
GLboolean success;
GLuint maxRegs;
if (unit->type == slang_unit_fragment_builtin ||
unit->type == slang_unit_fragment_shader) {
if (unit->type == SLANG_UNIT_FRAGMENT_BUILTIN ||
unit->type == SLANG_UNIT_FRAGMENT_SHADER) {
maxRegs = ctx->Const.FragmentProgram.MaxTemps;
}
else {
assert(unit->type == slang_unit_vertex_builtin ||
unit->type == slang_unit_vertex_shader);
assert(unit->type == SLANG_UNIT_VERTEX_BUILTIN ||
unit->type == SLANG_UNIT_VERTEX_SHADER);
maxRegs = ctx->Const.VertexProgram.MaxTemps;
}
@ -2055,8 +2055,8 @@ compile_object(grammar * id, const char *source, slang_code_object * object,
}
/* set shader type - the syntax is slightly different for different shaders */
if (type == slang_unit_fragment_shader
|| type == slang_unit_fragment_builtin)
if (type == SLANG_UNIT_FRAGMENT_SHADER
|| type == SLANG_UNIT_FRAGMENT_BUILTIN)
grammar_set_reg8(*id, (const byte *) "shader_type", 1);
else
grammar_set_reg8(*id, (const byte *) "shader_type", 2);
@ -2065,33 +2065,33 @@ compile_object(grammar * id, const char *source, slang_code_object * object,
grammar_set_reg8(*id, (const byte *) "parsing_builtin", 1);
/* if parsing user-specified shader, load built-in library */
if (type == slang_unit_fragment_shader || type == slang_unit_vertex_shader) {
if (type == SLANG_UNIT_FRAGMENT_SHADER || type == SLANG_UNIT_VERTEX_SHADER) {
/* compile core functionality first */
if (!compile_binary(slang_core_gc,
&object->builtin[SLANG_BUILTIN_CORE],
slang_unit_fragment_builtin, infolog,
SLANG_UNIT_FRAGMENT_BUILTIN, infolog,
NULL, NULL, NULL))
return GL_FALSE;
/* compile common functions and variables, link to core */
if (!compile_binary(slang_common_builtin_gc,
&object->builtin[SLANG_BUILTIN_COMMON],
slang_unit_fragment_builtin, infolog, NULL,
SLANG_UNIT_FRAGMENT_BUILTIN, infolog, NULL,
&object->builtin[SLANG_BUILTIN_CORE], NULL))
return GL_FALSE;
/* compile target-specific functions and variables, link to common */
if (type == slang_unit_fragment_shader) {
if (type == SLANG_UNIT_FRAGMENT_SHADER) {
if (!compile_binary(slang_fragment_builtin_gc,
&object->builtin[SLANG_BUILTIN_TARGET],
slang_unit_fragment_builtin, infolog, NULL,
SLANG_UNIT_FRAGMENT_BUILTIN, infolog, NULL,
&object->builtin[SLANG_BUILTIN_COMMON], NULL))
return GL_FALSE;
}
else if (type == slang_unit_vertex_shader) {
else if (type == SLANG_UNIT_VERTEX_SHADER) {
if (!compile_binary(slang_vertex_builtin_gc,
&object->builtin[SLANG_BUILTIN_TARGET],
slang_unit_vertex_builtin, infolog, NULL,
SLANG_UNIT_VERTEX_BUILTIN, infolog, NULL,
&object->builtin[SLANG_BUILTIN_COMMON], NULL))
return GL_FALSE;
}
@ -2145,11 +2145,11 @@ _slang_compile(GLcontext *ctx, struct gl_shader *shader)
slang_unit_type type;
if (shader->Type == GL_VERTEX_SHADER) {
type = slang_unit_vertex_shader;
type = SLANG_UNIT_VERTEX_SHADER;
}
else {
assert(shader->Type == GL_FRAGMENT_SHADER);
type = slang_unit_fragment_shader;
type = SLANG_UNIT_FRAGMENT_SHADER;
}
/* XXX temporary hack */

13
src/mesa/shader/slang/slang_compile.h
View file

@ -39,17 +39,19 @@ extern "C" {
typedef enum slang_unit_type_
{
slang_unit_fragment_shader,
slang_unit_vertex_shader,
slang_unit_fragment_builtin,
slang_unit_vertex_builtin
SLANG_UNIT_FRAGMENT_SHADER,
SLANG_UNIT_VERTEX_SHADER,
SLANG_UNIT_FRAGMENT_BUILTIN,
SLANG_UNIT_VERTEX_BUILTIN
} slang_unit_type;
typedef struct slang_var_pool_
{
GLuint next_addr;
GLuint next_addr;
} slang_var_pool;
typedef struct slang_code_unit_
{
slang_variable_scope vars;
@ -59,6 +61,7 @@ typedef struct slang_code_unit_
struct slang_code_object_ *object;
} slang_code_unit;
extern GLvoid
_slang_code_unit_ctr (slang_code_unit *, struct slang_code_object_ *);

6
src/mesa/shader/slang/slang_compile_function.c
View file

@ -71,7 +71,7 @@ slang_fixup_save(slang_fixup_table *fixups, GLuint address)
int
slang_function_construct(slang_function * func)
{
func->kind = slang_func_ordinary;
func->kind = SLANG_FUNC_ORDINARY;
if (!slang_variable_construct(&func->header))
return 0;
@ -133,7 +133,7 @@ slang_function_scope_destruct(slang_function_scope * scope)
GLboolean
_slang_function_has_return_value(const slang_function *fun)
{
return fun->header.type.specifier.type != slang_spec_void;
return fun->header.type.specifier.type != SLANG_SPEC_VOID;
}
@ -179,7 +179,7 @@ slang_function_scope_find(slang_function_scope * funcs, slang_function * fun,
slang_function *f = &funcs->functions[i];
const GLuint haveRetValue = 0;
#if 0
= (f->header.type.specifier.type != slang_spec_void);
= (f->header.type.specifier.type != SLANG_SPEC_VOID);
#endif
unsigned int j;

6
src/mesa/shader/slang/slang_compile_function.h
View file

@ -36,9 +36,9 @@ struct slang_code_unit_;
*/
typedef enum slang_function_kind_
{
slang_func_ordinary,
slang_func_constructor,
slang_func_operator
SLANG_FUNC_ORDINARY,
SLANG_FUNC_CONSTRUCTOR,
SLANG_FUNC_OPERATOR
} slang_function_kind;

2
src/mesa/shader/slang/slang_compile_operation.c
View file

@ -38,7 +38,7 @@
GLboolean
slang_operation_construct(slang_operation * oper)
{
oper->type = slang_oper_none;
oper->type = SLANG_OPER_NONE;
oper->children = NULL;
oper->num_children = 0;
oper->literal[0] = 0.0;

130
src/mesa/shader/slang/slang_compile_operation.h
View file

@ -37,70 +37,70 @@ extern "C" {
*/
typedef enum slang_operation_type_
{
slang_oper_none,
slang_oper_block_no_new_scope, /* "{" sequence "}" */
slang_oper_block_new_scope, /* "{" sequence "}" */
slang_oper_variable_decl, /* [type] [var] or [var] = [expr] */
slang_oper_asm,
slang_oper_break, /* "break" statement */
slang_oper_continue, /* "continue" statement */
slang_oper_discard, /* "discard" (kill fragment) statement */
slang_oper_return, /* "return" [expr] */
slang_oper_goto, /* jump to label */
slang_oper_label, /* a jump target */
slang_oper_expression, /* [expr] */
slang_oper_if, /* "if" [0] then [1] else [2] */
slang_oper_while, /* "while" [cond] [body] */
slang_oper_do, /* "do" [body] "while" [cond] */
slang_oper_for, /* "for" [init] [while] [incr] [body] */
slang_oper_void, /* nop */
slang_oper_literal_bool, /* "true" or "false" */
slang_oper_literal_int, /* integer literal */
slang_oper_literal_float, /* float literal */
slang_oper_identifier, /* var name, func name, etc */
slang_oper_sequence, /* [expr] "," [expr] "," etc */
slang_oper_assign, /* [var] "=" [expr] */
slang_oper_addassign, /* [var] "+=" [expr] */
slang_oper_subassign, /* [var] "-=" [expr] */
slang_oper_mulassign, /* [var] "*=" [expr] */
slang_oper_divassign, /* [var] "/=" [expr] */
/*slang_oper_modassign, */
/*slang_oper_lshassign, */
/*slang_oper_rshassign, */
/*slang_oper_orassign, */
/*slang_oper_xorassign, */
/*slang_oper_andassign, */
slang_oper_select, /* [expr] "?" [expr] ":" [expr] */
slang_oper_logicalor, /* [expr] "||" [expr] */
slang_oper_logicalxor, /* [expr] "^^" [expr] */
slang_oper_logicaland, /* [expr] "&&" [expr] */
/*slang_oper_bitor, */
/*slang_oper_bitxor, */
/*slang_oper_bitand, */
slang_oper_equal, /* [expr] "==" [expr] */
slang_oper_notequal, /* [expr] "!=" [expr] */
slang_oper_less, /* [expr] "<" [expr] */
slang_oper_greater, /* [expr] ">" [expr] */
slang_oper_lessequal, /* [expr] "<=" [expr] */
slang_oper_greaterequal, /* [expr] ">=" [expr] */
/*slang_oper_lshift, */
/*slang_oper_rshift, */
slang_oper_add, /* [expr] "+" [expr] */
slang_oper_subtract, /* [expr] "-" [expr] */
slang_oper_multiply, /* [expr] "*" [expr] */
slang_oper_divide, /* [expr] "/" [expr] */
/*slang_oper_modulus, */
slang_oper_preincrement, /* "++" [var] */
slang_oper_predecrement, /* "--" [var] */
slang_oper_plus, /* "-" [expr] */
slang_oper_minus, /* "+" [expr] */
/*slang_oper_complement, */
slang_oper_not, /* "!" [expr] */
slang_oper_subscript, /* [expr] "[" [expr] "]" */
slang_oper_call, /* [func name] [param] [param] [...] */
slang_oper_field, /* i.e.: ".next" or ".xzy" or ".xxx" etc */
slang_oper_postincrement, /* [var] "++" */
slang_oper_postdecrement /* [var] "--" */
SLANG_OPER_NONE,
SLANG_OPER_BLOCK_NO_NEW_SCOPE, /* "{" sequence "}" */
SLANG_OPER_BLOCK_NEW_SCOPE, /* "{" sequence "}" */
SLANG_OPER_VARIABLE_DECL, /* [type] [var] or [var] = [expr] */
SLANG_OPER_ASM,
SLANG_OPER_BREAK, /* "break" statement */
SLANG_OPER_CONTINUE, /* "continue" statement */
SLANG_OPER_DISCARD, /* "discard" (kill fragment) statement */
SLANG_OPER_RETURN, /* "return" [expr] */
SLANG_OPER_GOTO, /* jump to label */
SLANG_OPER_LABEL, /* a jump target */
SLANG_OPER_EXPRESSION, /* [expr] */
SLANG_OPER_IF, /* "if" [0] then [1] else [2] */
SLANG_OPER_WHILE, /* "while" [cond] [body] */
SLANG_OPER_DO, /* "do" [body] "while" [cond] */
SLANG_OPER_FOR, /* "for" [init] [while] [incr] [body] */
SLANG_OPER_VOID, /* nop */
SLANG_OPER_LITERAL_BOOL, /* "true" or "false" */
SLANG_OPER_LITERAL_INT, /* integer literal */
SLANG_OPER_LITERAL_FLOAT, /* float literal */
SLANG_OPER_IDENTIFIER, /* var name, func name, etc */
SLANG_OPER_SEQUENCE, /* [expr] "," [expr] "," etc */
SLANG_OPER_ASSIGN, /* [var] "=" [expr] */
SLANG_OPER_ADDASSIGN, /* [var] "+=" [expr] */
SLANG_OPER_SUBASSIGN, /* [var] "-=" [expr] */
SLANG_OPER_MULASSIGN, /* [var] "*=" [expr] */
SLANG_OPER_DIVASSIGN, /* [var] "/=" [expr] */
/*SLANG_OPER_MODASSIGN, */
/*SLANG_OPER_LSHASSIGN, */
/*SLANG_OPER_RSHASSIGN, */
/*SLANG_OPER_ORASSIGN, */
/*SLANG_OPER_XORASSIGN, */
/*SLANG_OPER_ANDASSIGN, */
SLANG_OPER_SELECT, /* [expr] "?" [expr] ":" [expr] */
SLANG_OPER_LOGICALOR, /* [expr] "||" [expr] */
SLANG_OPER_LOGICALXOR, /* [expr] "^^" [expr] */
SLANG_OPER_LOGICALAND, /* [expr] "&&" [expr] */
/*SLANG_OPER_BITOR, */
/*SLANG_OPER_BITXOR, */
/*SLANG_OPER_BITAND, */
SLANG_OPER_EQUAL, /* [expr] "==" [expr] */
SLANG_OPER_NOTEQUAL, /* [expr] "!=" [expr] */
SLANG_OPER_LESS, /* [expr] "<" [expr] */
SLANG_OPER_GREATER, /* [expr] ">" [expr] */
SLANG_OPER_LESSequal, /* [expr] "<=" [expr] */
SLANG_OPER_GREATERequal, /* [expr] ">=" [expr] */
/*SLANG_OPER_LSHIFT, */
/*SLANG_OPER_RSHIFT, */
SLANG_OPER_ADD, /* [expr] "+" [expr] */
SLANG_OPER_SUBTRACT, /* [expr] "-" [expr] */
SLANG_OPER_MULTIPLY, /* [expr] "*" [expr] */
SLANG_OPER_DIVIDE, /* [expr] "/" [expr] */
/*SLANG_OPER_MODULUS, */
SLANG_OPER_PREINCREMENT, /* "++" [var] */
SLANG_OPER_PREDECREMENT, /* "--" [var] */
SLANG_OPER_PLUS, /* "-" [expr] */
SLANG_OPER_MINUS, /* "+" [expr] */
/*SLANG_OPER_COMPLEMENT, */
SLANG_OPER_NOT, /* "!" [expr] */
SLANG_OPER_SUBSCRIPT, /* [expr] "[" [expr] "]" */
SLANG_OPER_CALL, /* [func name] [param] [param] [...] */
SLANG_OPER_FIELD, /* i.e.: ".next" or ".xzy" or ".xxx" etc */
SLANG_OPER_POSTINCREMENT, /* [var] "++" */
SLANG_OPER_POSTDECREMENT /* [var] "--" */
} slang_operation_type;
@ -120,7 +120,7 @@ typedef struct slang_operation_
GLuint literal_size; /**< 1, 2, 3, or 4 */
slang_atom a_id; /**< type: asm, identifier, call, field */
slang_variable_scope *locals; /**< local vars for scope */
struct slang_function_ *fun; /**< If type == slang_oper_call */
struct slang_function_ *fun; /**< If type == SLANG_OPER_CALL */
struct slang_variable_ *var; /**< If type == slang_oper_identier */
} slang_operation;

2
src/mesa/shader/slang/slang_compile_struct.c
View file

@ -160,7 +160,7 @@ int slang_struct_equal (const slang_struct *x, const slang_struct *y)
return 0;
if (!slang_type_specifier_equal (&varx->type.specifier, &vary->type.specifier))
return 0;
if (varx->type.specifier.type == slang_spec_array)
if (varx->type.specifier.type == SLANG_SPEC_ARRAY)
if (varx->array_len != vary->array_len)
return GL_FALSE;
}

92
src/mesa/shader/slang/slang_compile_variable.c
View file

@ -40,29 +40,29 @@ typedef struct
} type_specifier_type_name;
static const type_specifier_type_name type_specifier_type_names[] = {
{"void", slang_spec_void},
{"bool", slang_spec_bool},
{"bvec2", slang_spec_bvec2},
{"bvec3", slang_spec_bvec3},
{"bvec4", slang_spec_bvec4},
{"int", slang_spec_int},
{"ivec2", slang_spec_ivec2},
{"ivec3", slang_spec_ivec3},
{"ivec4", slang_spec_ivec4},
{"float", slang_spec_float},
{"vec2", slang_spec_vec2},
{"vec3", slang_spec_vec3},
{"vec4", slang_spec_vec4},
{"mat2", slang_spec_mat2},
{"mat3", slang_spec_mat3},
{"mat4", slang_spec_mat4},
{"sampler1D", slang_spec_sampler1D},
{"sampler2D", slang_spec_sampler2D},
{"sampler3D", slang_spec_sampler3D},
{"samplerCube", slang_spec_samplerCube},
{"sampler1DShadow", slang_spec_sampler1DShadow},
{"sampler2DShadow", slang_spec_sampler2DShadow},
{NULL, slang_spec_void}
{"void", SLANG_SPEC_VOID},
{"bool", SLANG_SPEC_BOOL},
{"bvec2", SLANG_SPEC_BVEC2},
{"bvec3", SLANG_SPEC_BVEC3},
{"bvec4", SLANG_SPEC_BVEC4},
{"int", SLANG_SPEC_INT},
{"ivec2", SLANG_SPEC_IVEC2},
{"ivec3", SLANG_SPEC_IVEC3},
{"ivec4", SLANG_SPEC_IVEC4},
{"float", SLANG_SPEC_FLOAT},
{"vec2", SLANG_SPEC_VEC2},
{"vec3", SLANG_SPEC_VEC3},
{"vec4", SLANG_SPEC_VEC4},
{"mat2", SLANG_SPEC_MAT2},
{"mat3", SLANG_SPEC_MAT3},
{"mat4", SLANG_SPEC_MAT4},
{"sampler1D", SLANG_SPEC_SAMPLER1D},
{"sampler2D", SLANG_SPEC_SAMPLER2D},
{"sampler3D", SLANG_SPEC_SAMPLER3D},
{"samplerCube", SLANG_SPEC_SAMPLERCUBE},
{"sampler1DShadow", SLANG_SPEC_SAMPLER1DSHADOW},
{"sampler2DShadow", SLANG_SPEC_SAMPLER2DSHADOW},
{NULL, SLANG_SPEC_VOID}
};
slang_type_specifier_type
@ -94,7 +94,7 @@ slang_type_specifier_type_to_string(slang_type_specifier_type type)
int
slang_fully_specified_type_construct(slang_fully_specified_type * type)
{
type->qualifier = slang_qual_none;
type->qualifier = SLANG_QUAL_NONE;
slang_type_specifier_ctr(&type->specifier);
return 1;
}
@ -333,49 +333,49 @@ static GLenum
gl_type_from_specifier(const slang_type_specifier * type)
{
switch (type->type) {
case slang_spec_bool:
case SLANG_SPEC_BOOL:
return GL_BOOL_ARB;
case slang_spec_bvec2:
case SLANG_SPEC_BVEC2:
return GL_BOOL_VEC2_ARB;
case slang_spec_bvec3:
case SLANG_SPEC_BVEC3:
return GL_BOOL_VEC3_ARB;
case slang_spec_bvec4:
case SLANG_SPEC_BVEC4:
return GL_BOOL_VEC4_ARB;
case slang_spec_int:
case SLANG_SPEC_INT:
return GL_INT;
case slang_spec_ivec2:
case SLANG_SPEC_IVEC2:
return GL_INT_VEC2_ARB;
case slang_spec_ivec3:
case SLANG_SPEC_IVEC3:
return GL_INT_VEC3_ARB;
case slang_spec_ivec4:
case SLANG_SPEC_IVEC4:
return GL_INT_VEC4_ARB;
case slang_spec_float:
case SLANG_SPEC_FLOAT:
return GL_FLOAT;
case slang_spec_vec2:
case SLANG_SPEC_VEC2:
return GL_FLOAT_VEC2_ARB;
case slang_spec_vec3:
case SLANG_SPEC_VEC3:
return GL_FLOAT_VEC3_ARB;
case slang_spec_vec4:
case SLANG_SPEC_VEC4:
return GL_FLOAT_VEC4_ARB;
case slang_spec_mat2:
case SLANG_SPEC_MAT2:
return GL_FLOAT_MAT2_ARB;
case slang_spec_mat3:
case SLANG_SPEC_MAT3:
return GL_FLOAT_MAT3_ARB;
case slang_spec_mat4:
case SLANG_SPEC_MAT4:
return GL_FLOAT_MAT4_ARB;
case slang_spec_sampler1D:
case SLANG_SPEC_SAMPLER1D:
return GL_SAMPLER_1D_ARB;
case slang_spec_sampler2D:
case SLANG_SPEC_SAMPLER2D:
return GL_SAMPLER_2D_ARB;
case slang_spec_sampler3D:
case SLANG_SPEC_SAMPLER3D:
return GL_SAMPLER_3D_ARB;
case slang_spec_samplerCube:
case SLANG_SPEC_SAMPLERCUBE:
return GL_SAMPLER_CUBE_ARB;
case slang_spec_sampler1DShadow:
case SLANG_SPEC_SAMPLER1DShadow:
return GL_SAMPLER_1D_SHADOW_ARB;
case slang_spec_sampler2DShadow:
case SLANG_SPEC_SAMPLER2DShadow:
return GL_SAMPLER_2D_SHADOW_ARB;
case slang_spec_array:
case SLANG_SPEC_ARRAy:
return gl_type_from_specifier(type->_array);
default:
return GL_FLOAT;

20
src/mesa/shader/slang/slang_compile_variable.h
View file

@ -32,15 +32,15 @@ extern "C" {
typedef enum slang_type_qualifier_
{
slang_qual_none,
slang_qual_const,
slang_qual_attribute,
slang_qual_varying,
slang_qual_uniform,
slang_qual_out,
slang_qual_inout,
slang_qual_fixedoutput, /* internal */
slang_qual_fixedinput /* internal */
SLANG_QUAL_NONE,
SLANG_QUAL_CONST,
SLANG_QUAL_ATTRIBUTE,
SLANG_QUAL_VARYING,
SLANG_QUAL_UNIFORM,
SLANG_QUAL_OUT,
SLANG_QUAL_INOUT,
SLANG_QUAL_FIXEDOUTPUT, /* internal */
SLANG_QUAL_FIXEDINPUT /* internal */
} slang_type_qualifier;
extern slang_type_specifier_type
@ -75,7 +75,7 @@ typedef struct slang_variable_
{
slang_fully_specified_type type; /**< Variable's data type */
slang_atom a_name; /**< The variable's name (char *) */
GLuint array_len; /**< only if type == slang_spec_array */
GLuint array_len; /**< only if type == SLANG_SPEC_ARRAy */
struct slang_operation_ *initializer; /**< Optional initializer code */
GLuint address; /**< Storage location */
GLuint size; /**< Variable's size in bytes */

278
src/mesa/shader/slang/slang_print.c
View file

@ -21,31 +21,31 @@ static void
print_type(const slang_fully_specified_type *t)
{
switch (t->qualifier) {
case slang_qual_none:
case SLANG_QUAL_NONE:
/*printf("");*/
break;
case slang_qual_const:
case SLANG_QUAL_CONST:
printf("const ");
break;
case slang_qual_attribute:
case SLANG_QUAL_ATTRIBUTE:
printf("attrib ");
break;
case slang_qual_varying:
case SLANG_QUAL_VARYING:
printf("varying ");
break;
case slang_qual_uniform:
case SLANG_QUAL_UNIFORM:
printf("uniform ");
break;
case slang_qual_out:
case SLANG_QUAL_OUT:
printf("output ");
break;
case slang_qual_inout:
case SLANG_QUAL_INOUT:
printf("inout ");
break;
case slang_qual_fixedoutput:
case SLANG_QUAL_FIXEDOUTPUT:
printf("fixedoutput");
break;
case slang_qual_fixedinput:
case SLANG_QUAL_FIXEDINPUT:
printf("fixedinput");
break;
default:
@ -53,76 +53,76 @@ print_type(const slang_fully_specified_type *t)
}
switch (t->specifier.type) {
case slang_spec_void:
case SLANG_SPEC_VOID:
printf("void");
break;
case slang_spec_bool:
case SLANG_SPEC_BOOL:
printf("bool");
break;
case slang_spec_bvec2:
case SLANG_SPEC_BVEC2:
printf("bvec2");
break;
case slang_spec_bvec3:
case SLANG_SPEC_BVEC3:
printf("bvec3");
break;
case slang_spec_bvec4:
case SLANG_SPEC_BVEC4:
printf("bvec4");
break;
case slang_spec_int:
case SLANG_SPEC_INT:
printf("int");
break;
case slang_spec_ivec2:
case SLANG_SPEC_IVEC2:
printf("ivec2");
break;
case slang_spec_ivec3:
case SLANG_SPEC_IVEC3:
printf("ivec3");
break;
case slang_spec_ivec4:
case SLANG_SPEC_IVEC4:
printf("ivec4");
break;
case slang_spec_float:
case SLANG_SPEC_FLOAT:
printf("float");
break;
case slang_spec_vec2:
case SLANG_SPEC_VEC2:
printf("vec2");
break;
case slang_spec_vec3:
case SLANG_SPEC_VEC3:
printf("vec3");
break;
case slang_spec_vec4:
case SLANG_SPEC_VEC4:
printf("vec4");
break;
case slang_spec_mat2:
case SLANG_SPEC_MAT2:
printf("mat2");
break;
case slang_spec_mat3:
case SLANG_SPEC_MAT3:
printf("mat3");
break;
case slang_spec_mat4:
case SLANG_SPEC_MAT4:
printf("mat4");
break;
case slang_spec_sampler1D:
case SLANG_SPEC_SAMPLER1D:
printf("sampler1D");
break;
case slang_spec_sampler2D:
case SLANG_SPEC_SAMPLER2D:
printf("sampler2D");
break;
case slang_spec_sampler3D:
case SLANG_SPEC_SAMPLER3D:
printf("sampler3D");
break;
case slang_spec_samplerCube:
case SLANG_SPEC_SAMPLERCUBE:
printf("samplerCube");
break;
case slang_spec_sampler1DShadow:
case SLANG_SPEC_SAMPLER1DSHADOW:
printf("sampler1DShadow");
break;
case slang_spec_sampler2DShadow:
case SLANG_SPEC_SAMPLER2DSHADOW:
printf("sampler2DShadow");
break;
case slang_spec_struct:
case SLANG_SPEC_STRUCT:
printf("struct");
break;
case slang_spec_array:
case SLANG_SPEC_ARRAY:
printf("array");
break;
default:
@ -219,12 +219,12 @@ slang_print_tree(const slang_operation *op, int indent)
switch (op->type) {
case slang_oper_none:
case SLANG_OPER_NONE:
spaces(indent);
printf("slang_oper_none\n");
printf("SLANG_OPER_NONE\n");
break;
case slang_oper_block_no_new_scope:
case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
spaces(indent);
printf("{ locals %p outer %p\n", (void*)op->locals, (void*)op->locals->outer_scope);
print_generic(op, NULL, indent+3);
@ -232,7 +232,7 @@ slang_print_tree(const slang_operation *op, int indent)
printf("}\n");
break;
case slang_oper_block_new_scope:
case SLANG_OPER_BLOCK_NEW_SCOPE:
spaces(indent);
printf("{{ // new scope locals %p\n", (void*)op->locals);
print_generic(op, NULL, indent+3);
@ -240,7 +240,7 @@ slang_print_tree(const slang_operation *op, int indent)
printf("}}\n");
break;
case slang_oper_variable_decl:
case SLANG_OPER_VARIABLE_DECL:
assert(op->num_children == 0 || op->num_children == 1);
{
slang_variable *v;
@ -282,52 +282,52 @@ slang_print_tree(const slang_operation *op, int indent)
}
break;
case slang_oper_asm:
case SLANG_OPER_ASM:
spaces(indent);
printf("ASM: %s\n", (char*) op->a_id);
print_generic(op, NULL, indent+3);
break;
case slang_oper_break:
case SLANG_OPER_BREAK:
spaces(indent);
printf("BREAK\n");
break;
case slang_oper_continue:
case SLANG_OPER_CONTINUE:
spaces(indent);
printf("CONTINUE\n");
break;
case slang_oper_discard:
case SLANG_OPER_DISCARD:
spaces(indent);
printf("DISCARD\n");
break;
case slang_oper_return:
case SLANG_OPER_RETURN:
spaces(indent);
printf("RETURN\n");
if (op->num_children > 0)
slang_print_tree(&op->children[0], indent + 3);
break;
case slang_oper_goto:
case SLANG_OPER_GOTO:
spaces(indent);
printf("GOTO %s\n", (char *) op->a_id);
break;
case slang_oper_label:
case SLANG_OPER_LABEL:
spaces(indent);
printf("LABEL %s\n", (char *) op->a_id);
break;
case slang_oper_expression:
case SLANG_OPER_EXPRESSION:
spaces(indent);
printf("EXPR: locals %p\n", (void*) op->locals);
/*print_generic(op, "slang_oper_expression", indent);*/
/*print_generic(op, "SLANG_OPER_EXPRESSION", indent);*/
slang_print_tree(&op->children[0], indent + 3);
break;
case slang_oper_if:
case SLANG_OPER_IF:
spaces(indent);
printf("IF\n");
slang_print_tree(&op->children[0], indent + 3);
@ -341,7 +341,7 @@ slang_print_tree(const slang_operation *op, int indent)
printf("ENDIF\n");
break;
case slang_oper_while:
case SLANG_OPER_WHILE:
assert(op->num_children == 2);
spaces(indent);
printf("WHILE cond:\n");
@ -351,7 +351,7 @@ slang_print_tree(const slang_operation *op, int indent)
slang_print_tree(&op->children[1], indent + 3);
break;
case slang_oper_do:
case SLANG_OPER_DO:
spaces(indent);
printf("DO body:\n");
slang_print_tree(&op->children[0], indent + 3);
@ -360,7 +360,7 @@ slang_print_tree(const slang_operation *op, int indent)
slang_print_tree(&op->children[1], indent + 3);
break;
case slang_oper_for:
case SLANG_OPER_FOR:
spaces(indent);
printf("FOR init:\n");
slang_print_tree(&op->children[0], indent + 3);
@ -380,32 +380,32 @@ slang_print_tree(const slang_operation *op, int indent)
*/
break;
case slang_oper_void:
case SLANG_OPER_VOID:
spaces(indent);
printf("(oper-void)\n");
break;
case slang_oper_literal_bool:
case SLANG_OPER_LITERAL_BOOL:
spaces(indent);
/*printf("slang_oper_literal_bool\n");*/
/*printf("SLANG_OPER_LITERAL_BOOL\n");*/
printf("%s\n", op->literal[0] ? "TRUE" : "FALSE");
break;
case slang_oper_literal_int:
case SLANG_OPER_LITERAL_INT:
spaces(indent);
/*printf("slang_oper_literal_int\n");*/
/*printf("SLANG_OPER_LITERAL_INT\n");*/
printf("(%d %d %d %d)\n", (int) op->literal[0], (int) op->literal[1],
(int) op->literal[2], (int) op->literal[3]);
break;
case slang_oper_literal_float:
case SLANG_OPER_LITERAL_FLOAT:
spaces(indent);
/*printf("slang_oper_literal_float\n");*/
/*printf("SLANG_OPER_LITERAL_FLOAT\n");*/
printf("(%f %f %f %f)\n", op->literal[0], op->literal[1], op->literal[2],
op->literal[3]);
break;
case slang_oper_identifier:
case SLANG_OPER_IDENTIFIER:
spaces(indent);
if (op->var && op->var->a_name)
printf("VAR %s (in scope %p)\n", (char *) op->var->a_name,
@ -415,49 +415,49 @@ slang_print_tree(const slang_operation *op, int indent)
(void *) find_scope(op->locals, op->a_id));
break;
case slang_oper_sequence:
case SLANG_OPER_SEQUENCE:
print_generic(op, "COMMA-SEQ", indent+3);
break;
case slang_oper_assign:
case SLANG_OPER_ASSIGN:
spaces(indent);
printf("ASSIGNMENT locals %p\n", (void*)op->locals);
print_binary(op, ":=", indent);
break;
case slang_oper_addassign:
case SLANG_OPER_ADDASSIGN:
spaces(indent);
printf("ASSIGN\n");
print_binary(op, "+=", indent);
break;
case slang_oper_subassign:
case SLANG_OPER_SUBASSIGN:
spaces(indent);
printf("ASSIGN\n");
print_binary(op, "-=", indent);
break;
case slang_oper_mulassign:
case SLANG_OPER_MULASSIGN:
spaces(indent);
printf("ASSIGN\n");
print_binary(op, "*=", indent);
break;
case slang_oper_divassign:
case SLANG_OPER_DIVASSIGN:
spaces(indent);
printf("ASSIGN\n");
print_binary(op, "/=", indent);
break;
/*slang_oper_modassign,*/
/*slang_oper_lshassign,*/
/*slang_oper_rshassign,*/
/*slang_oper_orassign,*/
/*slang_oper_xorassign,*/
/*slang_oper_andassign,*/
case slang_oper_select:
/*SLANG_OPER_MODASSIGN,*/
/*SLANG_OPER_LSHASSIGN,*/
/*SLANG_OPER_RSHASSIGN,*/
/*SLANG_OPER_ORASSIGN,*/
/*SLANG_OPER_XORASSIGN,*/
/*SLANG_OPER_ANDASSIGN,*/
case SLANG_OPER_SELECT:
spaces(indent);
printf("slang_oper_select n=%d\n", op->num_children);
printf("SLANG_OPER_SELECT n=%d\n", op->num_children);
assert(op->num_children == 3);
slang_print_tree(&op->children[0], indent+3);
spaces(indent);
@ -468,100 +468,100 @@ slang_print_tree(const slang_operation *op, int indent)
slang_print_tree(&op->children[2], indent+3);
break;
case slang_oper_logicalor:
case SLANG_OPER_LOGICALOR:
print_binary(op, "||", indent);
break;
case slang_oper_logicalxor:
case SLANG_OPER_LOGICALXOR:
print_binary(op, "^^", indent);
break;
case slang_oper_logicaland:
case SLANG_OPER_LOGICALAND:
print_binary(op, "&&", indent);
break;
/*slang_oper_bitor*/
/*slang_oper_bitxor*/
/*slang_oper_bitand*/
case slang_oper_equal:
/*SLANG_OPER_BITOR*/
/*SLANG_OPER_BITXOR*/
/*SLANG_OPER_BITAND*/
case SLANG_OPER_EQUAL:
print_binary(op, "==", indent);
break;
case slang_oper_notequal:
case SLANG_OPER_NOTEQUAL:
print_binary(op, "!=", indent);
break;
case slang_oper_less:
case SLANG_OPER_LESS:
print_binary(op, "<", indent);
break;
case slang_oper_greater:
case SLANG_OPER_GREATER:
print_binary(op, ">", indent);
break;
case slang_oper_lessequal:
case SLANG_OPER_LESSequal:
print_binary(op, "<=", indent);
break;
case slang_oper_greaterequal:
case SLANG_OPER_GREATERequal:
print_binary(op, ">=", indent);
break;
/*slang_oper_lshift*/
/*slang_oper_rshift*/
case slang_oper_add:
/*SLANG_OPER_LSHIFT*/
/*SLANG_OPER_RSHIFT*/
case SLANG_OPER_ADD:
print_binary(op, "+", indent);
break;
case slang_oper_subtract:
case SLANG_OPER_SUBTRACT:
print_binary(op, "-", indent);
break;
case slang_oper_multiply:
case SLANG_OPER_MULTIPLY:
print_binary(op, "*", indent);
break;
case slang_oper_divide:
case SLANG_OPER_DIVIDE:
print_binary(op, "/", indent);
break;
/*slang_oper_modulus*/
case slang_oper_preincrement:
/*SLANG_OPER_MODULUS*/
case SLANG_OPER_PREINCREMENT:
spaces(indent);
printf("PRE++\n");
slang_print_tree(&op->children[0], indent+3);
break;
case slang_oper_predecrement:
case SLANG_OPER_PREDECREMENT:
spaces(indent);
printf("PRE--\n");
slang_print_tree(&op->children[0], indent+3);
break;
case slang_oper_plus:
case SLANG_OPER_PLUS:
spaces(indent);
printf("slang_oper_plus\n");
printf("SLANG_OPER_PLUS\n");
break;
case slang_oper_minus:
case SLANG_OPER_MINUS:
spaces(indent);
printf("slang_oper_minus\n");
printf("SLANG_OPER_MINUS\n");
break;
/*slang_oper_complement*/
case slang_oper_not:
/*SLANG_OPER_COMPLEMENT*/
case SLANG_OPER_NOT:
spaces(indent);
printf("NOT\n");
slang_print_tree(&op->children[0], indent+3);
break;
case slang_oper_subscript:
case SLANG_OPER_SUBSCRIPT:
spaces(indent);
printf("slang_oper_subscript\n");
printf("SLANG_OPER_SUBSCRIPT\n");
print_generic(op, NULL, indent+3);
break;
case slang_oper_call:
case SLANG_OPER_CALL:
#if 0
slang_function *fun
= _slang_locate_function(A->space.funcs, oper->a_id,
@ -581,19 +581,19 @@ slang_print_tree(const slang_operation *op, int indent)
printf(")\n");
break;
case slang_oper_field:
case SLANG_OPER_FIELD:
spaces(indent);
printf("FIELD %s of\n", (char*) op->a_id);
slang_print_tree(&op->children[0], indent+3);
break;
case slang_oper_postincrement:
case SLANG_OPER_POSTINCREMENT:
spaces(indent);
printf("POST++\n");
slang_print_tree(&op->children[0], indent+3);
break;
case slang_oper_postdecrement:
case SLANG_OPER_POSTDECREMENT:
spaces(indent);
printf("POST--\n");
slang_print_tree(&op->children[0], indent+3);
@ -637,23 +637,23 @@ const char *
slang_type_qual_string(slang_type_qualifier q)
{
switch (q) {
case slang_qual_none:
case SLANG_QUAL_NONE:
return "none";
case slang_qual_const:
case SLANG_QUAL_CONST:
return "const";
case slang_qual_attribute:
case SLANG_QUAL_ATTRIBUTE:
return "attribute";
case slang_qual_varying:
case SLANG_QUAL_VARYING:
return "varying";
case slang_qual_uniform:
case SLANG_QUAL_UNIFORM:
return "uniform";
case slang_qual_out:
case SLANG_QUAL_OUT:
return "out";
case slang_qual_inout:
case SLANG_QUAL_INOUT:
return "inout";
case slang_qual_fixedoutput:
case SLANG_QUAL_FIXEDOUTPUT:
return "fixedoutput";
case slang_qual_fixedinput:
case SLANG_QUAL_FIXEDINPUT:
return "fixedinputk";
default:
return "qual?";
@ -665,53 +665,53 @@ static const char *
slang_type_string(slang_type_specifier_type t)
{
switch (t) {
case slang_spec_void:
case SLANG_SPEC_VOID:
return "void";
case slang_spec_bool:
case SLANG_SPEC_BOOL:
return "bool";
case slang_spec_bvec2:
case SLANG_SPEC_BVEC2:
return "bvec2";
case slang_spec_bvec3:
case SLANG_SPEC_BVEC3:
return "bvec3";
case slang_spec_bvec4:
case SLANG_SPEC_BVEC4:
return "bvec4";
case slang_spec_int:
case SLANG_SPEC_INT:
return "int";
case slang_spec_ivec2:
case SLANG_SPEC_IVEC2:
return "ivec2";
case slang_spec_ivec3:
case SLANG_SPEC_IVEC3:
return "ivec3";
case slang_spec_ivec4:
case SLANG_SPEC_IVEC4:
return "ivec4";
case slang_spec_float:
case SLANG_SPEC_FLOAT:
return "float";
case slang_spec_vec2:
case SLANG_SPEC_VEC2:
return "vec2";
case slang_spec_vec3:
case SLANG_SPEC_VEC3:
return "vec3";
case slang_spec_vec4:
case SLANG_SPEC_VEC4:
return "vec4";
case slang_spec_mat2:
case SLANG_SPEC_MAT2:
return "mat2";
case slang_spec_mat3:
case SLANG_SPEC_MAT3:
return "mat3";
case slang_spec_mat4:
case SLANG_SPEC_MAT4:
return "mat4";
case slang_spec_sampler1D:
case SLANG_SPEC_SAMPLER1D:
return "sampler1D";
case slang_spec_sampler2D:
case SLANG_SPEC_SAMPLER2D:
return "sampler2D";
case slang_spec_sampler3D:
case SLANG_SPEC_SAMPLER3D:
return "sampler3D";
case slang_spec_samplerCube:
case SLANG_SPEC_SAMPLERCUBE:
return "samplerCube";
case slang_spec_sampler1DShadow:
case SLANG_SPEC_SAMPLER1DSHADOW:
return "sampler1DShadow";
case slang_spec_sampler2DShadow:
case SLANG_SPEC_SAMPLER2DSHADOW:
return "sampler2DShadow";
case slang_spec_struct:
case SLANG_SPEC_STRUCT:
return "struct";
case slang_spec_array:
case SLANG_SPEC_ARRAY:
return "array";
default:
return "type?";

66
src/mesa/shader/slang/slang_simplify.c
View file

@ -97,7 +97,7 @@ _slang_simplify(slang_operation *oper,
GLboolean isBool[4];
GLuint i, n;
if (oper->type == slang_oper_identifier) {
if (oper->type == SLANG_OPER_IDENTIFIER) {
/* see if it's a named constant */
GLint value = _slang_lookup_constant((char *) oper->a_id);
if (value >= 0) {
@ -105,7 +105,7 @@ _slang_simplify(slang_operation *oper,
oper->literal[1] =
oper->literal[2] =
oper->literal[3] = value;
oper->type = slang_oper_literal_int;
oper->type = SLANG_OPER_LITERAL_INT;
return;
}
}
@ -118,49 +118,49 @@ _slang_simplify(slang_operation *oper,
/* examine children */
n = MIN2(oper->num_children, 4);
for (i = 0; i < n; i++) {
isFloat[i] = (oper->children[i].type == slang_oper_literal_float ||
oper->children[i].type == slang_oper_literal_int);
isBool[i] = (oper->children[i].type == slang_oper_literal_bool);
isFloat[i] = (oper->children[i].type == SLANG_OPER_LITERAL_FLOAT ||
oper->children[i].type == SLANG_OPER_LITERAL_INT);
isBool[i] = (oper->children[i].type == SLANG_OPER_LITERAL_BOOL);
}
if (oper->num_children == 2 && isFloat[0] && isFloat[1]) {
/* probably simple arithmetic */
switch (oper->type) {
case slang_oper_add:
case SLANG_OPER_ADD:
for (i = 0; i < 4; i++) {
oper->literal[i]
= oper->children[0].literal[i] + oper->children[1].literal[i];
}
oper->literal_size = oper->children[0].literal_size;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_float;
oper->type = SLANG_OPER_LITERAL_FLOAT;
return;
case slang_oper_subtract:
case SLANG_OPER_SUBTRACT:
for (i = 0; i < 4; i++) {
oper->literal[i]
= oper->children[0].literal[i] - oper->children[1].literal[i];
}
oper->literal_size = oper->children[0].literal_size;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_float;
oper->type = SLANG_OPER_LITERAL_FLOAT;
return;
case slang_oper_multiply:
case SLANG_OPER_MULTIPLY:
for (i = 0; i < 4; i++) {
oper->literal[i]
= oper->children[0].literal[i] * oper->children[1].literal[i];
}
oper->literal_size = oper->children[0].literal_size;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_float;
oper->type = SLANG_OPER_LITERAL_FLOAT;
return;
case slang_oper_divide:
case SLANG_OPER_DIVIDE:
for (i = 0; i < 4; i++) {
oper->literal[i]
= oper->children[0].literal[i] / oper->children[1].literal[i];
}
oper->literal_size = oper->children[0].literal_size;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_float;
oper->type = SLANG_OPER_LITERAL_FLOAT;
return;
default:
; /* nothing */
@ -169,19 +169,19 @@ _slang_simplify(slang_operation *oper,
if (oper->num_children == 1 && isFloat[0]) {
switch (oper->type) {
case slang_oper_minus:
case SLANG_OPER_MINUS:
for (i = 0; i < 4; i++) {
oper->literal[i] = -oper->children[0].literal[i];
}
oper->literal_size = oper->children[0].literal_size;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_float;
oper->type = SLANG_OPER_LITERAL_FLOAT;
return;
case slang_oper_plus:
case SLANG_OPER_PLUS:
COPY_4V(oper->literal, oper->children[0].literal);
oper->literal_size = oper->children[0].literal_size;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_float;
oper->type = SLANG_OPER_LITERAL_FLOAT;
return;
default:
; /* nothing */
@ -191,7 +191,7 @@ _slang_simplify(slang_operation *oper,
if (oper->num_children == 2 && isBool[0] && isBool[1]) {
/* simple boolean expression */
switch (oper->type) {
case slang_oper_logicaland:
case SLANG_OPER_LOGICALAND:
for (i = 0; i < 4; i++) {
const GLint a = oper->children[0].literal[i] ? 1 : 0;
const GLint b = oper->children[1].literal[i] ? 1 : 0;
@ -199,9 +199,9 @@ _slang_simplify(slang_operation *oper,
}
oper->literal_size = oper->children[0].literal_size;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_bool;
oper->type = SLANG_OPER_LITERAL_BOOL;
return;
case slang_oper_logicalor:
case SLANG_OPER_LOGICALOR:
for (i = 0; i < 4; i++) {
const GLint a = oper->children[0].literal[i] ? 1 : 0;
const GLint b = oper->children[1].literal[i] ? 1 : 0;
@ -209,9 +209,9 @@ _slang_simplify(slang_operation *oper,
}
oper->literal_size = oper->children[0].literal_size;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_bool;
oper->type = SLANG_OPER_LITERAL_BOOL;
return;
case slang_oper_logicalxor:
case SLANG_OPER_LOGICALXOR:
for (i = 0; i < 4; i++) {
const GLint a = oper->children[0].literal[i] ? 1 : 0;
const GLint b = oper->children[1].literal[i] ? 1 : 0;
@ -219,7 +219,7 @@ _slang_simplify(slang_operation *oper,
}
oper->literal_size = oper->children[0].literal_size;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_bool;
oper->type = SLANG_OPER_LITERAL_BOOL;
return;
default:
; /* nothing */
@ -229,7 +229,7 @@ _slang_simplify(slang_operation *oper,
if (oper->num_children == 4
&& isFloat[0] && isFloat[1] && isFloat[2] && isFloat[3]) {
/* vec4(flt, flt, flt, flt) constructor */
if (oper->type == slang_oper_call) {
if (oper->type == SLANG_OPER_CALL) {
if (strcmp((char *) oper->a_id, "vec4") == 0) {
oper->literal[0] = oper->children[0].literal[0];
oper->literal[1] = oper->children[1].literal[0];
@ -237,7 +237,7 @@ _slang_simplify(slang_operation *oper,
oper->literal[3] = oper->children[3].literal[0];
oper->literal_size = 4;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_float;
oper->type = SLANG_OPER_LITERAL_FLOAT;
return;
}
}
@ -245,7 +245,7 @@ _slang_simplify(slang_operation *oper,
if (oper->num_children == 3 && isFloat[0] && isFloat[1] && isFloat[2]) {
/* vec3(flt, flt, flt) constructor */
if (oper->type == slang_oper_call) {
if (oper->type == SLANG_OPER_CALL) {
if (strcmp((char *) oper->a_id, "vec3") == 0) {
oper->literal[0] = oper->children[0].literal[0];
oper->literal[1] = oper->children[1].literal[0];
@ -253,7 +253,7 @@ _slang_simplify(slang_operation *oper,
oper->literal[3] = oper->literal[2];
oper->literal_size = 3;
slang_operation_destruct(oper);
oper->type = slang_oper_literal_float;
oper->type = SLANG_OPER_LITERAL_FLOAT;
return;
}
}
@ -261,7 +261,7 @@ _slang_simplify(slang_operation *oper,
if (oper->num_children == 2 && isFloat[0] && isFloat[1]) {
/* vec2(flt, flt) constructor */
if (oper->type == slang_oper_call) {
if (oper->type == SLANG_OPER_CALL) {
if (strcmp((char *) oper->a_id, "vec2") == 0) {
printf("SIMPLIFY vec2 constructor scope = %p\n",
(void*) oper->locals);
@ -271,7 +271,7 @@ _slang_simplify(slang_operation *oper,
oper->literal[3] = oper->literal[1];
oper->literal_size = 2;
slang_operation_destruct(oper); /* XXX oper->locals goes NULL! */
oper->type = slang_oper_literal_float;
oper->type = SLANG_OPER_LITERAL_FLOAT;
assert(oper->num_children == 0);
return;
}
@ -305,7 +305,7 @@ _slang_adapt_call(slang_operation *callOper, const slang_function *fun,
if (callOper->num_children != numParams) {
/* number of arguments doesn't match number of parameters */
if (fun->kind == slang_func_constructor) {
if (fun->kind == SLANG_FUNC_CONSTRUCTOR) {
/* For constructor calls, we can try to unroll vector/matrix args
* into individual floats/ints and try to match the function params.
*/
@ -345,13 +345,13 @@ _slang_adapt_call(slang_operation *callOper, const slang_function *fun,
/* replace arg[i+j] with subscript/index oper */
for (j = 0; j < argSz; j++) {
callOper->children[i + j].type = slang_oper_subscript;
callOper->children[i + j].type = SLANG_OPER_SUBSCRIPT;
callOper->children[i + j].num_children = 2;
callOper->children[i + j].children = slang_operation_new(2);
slang_operation_copy(&callOper->children[i + j].children[0],
&origArg);
callOper->children[i + j].children[1].type
= slang_oper_literal_int;
= SLANG_OPER_LITERAL_INT;
callOper->children[i + j].children[1].literal[0] = j;
}
@ -408,7 +408,7 @@ _slang_adapt_call(slang_operation *callOper, const slang_function *fun,
slang_operation_copy(child, &callOper->children[i]);
child->locals->outer_scope = callOper->locals;
callOper->children[i].type = slang_oper_call;
callOper->children[i].type = SLANG_OPER_CALL;
callOper->children[i].a_id = slang_atom_pool_atom(atoms, constructorName);
callOper->children[i].num_children = 1;
callOper->children[i].children = child;

96
src/mesa/shader/slang/slang_storage.c
View file

@ -36,7 +36,7 @@
GLboolean
slang_storage_array_construct(slang_storage_array * arr)
{
arr->type = slang_stor_aggregate;
arr->type = SLANG_STORE_AGGREGATE;
arr->aggregate = NULL;
arr->length = 0;
return GL_TRUE;
@ -110,7 +110,7 @@ aggregate_matrix(slang_storage_aggregate * agg, slang_storage_type basic_type,
slang_storage_array *arr = slang_storage_aggregate_push_new(agg);
if (arr == NULL)
return GL_FALSE;
arr->type = slang_stor_aggregate;
arr->type = SLANG_STORE_AGGREGATE;
arr->length = dimension;
arr->aggregate =
(slang_storage_aggregate *)
@ -155,54 +155,54 @@ _slang_aggregate_variable(slang_storage_aggregate * agg,
slang_atom_pool * atoms)
{
switch (spec->type) {
case slang_spec_bool:
return aggregate_vector(agg, slang_stor_bool, 1);
case slang_spec_bvec2:
return aggregate_vector(agg, slang_stor_bool, 2);
case slang_spec_bvec3:
return aggregate_vector(agg, slang_stor_bool, 3);
case slang_spec_bvec4:
return aggregate_vector(agg, slang_stor_bool, 4);
case slang_spec_int:
return aggregate_vector(agg, slang_stor_int, 1);
case slang_spec_ivec2:
return aggregate_vector(agg, slang_stor_int, 2);
case slang_spec_ivec3:
return aggregate_vector(agg, slang_stor_int, 3);
case slang_spec_ivec4:
return aggregate_vector(agg, slang_stor_int, 4);
case slang_spec_float:
return aggregate_vector(agg, slang_stor_float, 1);
case slang_spec_vec2:
return aggregate_vector(agg, slang_stor_float, 2);
case slang_spec_vec3:
return aggregate_vector(agg, slang_stor_float, 3);
case slang_spec_vec4:
return aggregate_vector(agg, slang_stor_float, 4);
case slang_spec_mat2:
return aggregate_matrix(agg, slang_stor_float, 2);
case slang_spec_mat3:
return aggregate_matrix(agg, slang_stor_float, 3);
case slang_spec_mat4:
return aggregate_matrix(agg, slang_stor_float, 4);
case slang_spec_sampler1D:
case slang_spec_sampler2D:
case slang_spec_sampler3D:
case slang_spec_samplerCube:
case slang_spec_sampler1DShadow:
case slang_spec_sampler2DShadow:
return aggregate_vector(agg, slang_stor_int, 1);
case slang_spec_struct:
case SLANG_SPEC_BOOL:
return aggregate_vector(agg, SLANG_STORE_BOOL, 1);
case SLANG_SPEC_BVEC2:
return aggregate_vector(agg, SLANG_STORE_BOOL, 2);
case SLANG_SPEC_BVEC3:
return aggregate_vector(agg, SLANG_STORE_BOOL, 3);
case SLANG_SPEC_BVEC4:
return aggregate_vector(agg, SLANG_STORE_BOOL, 4);
case SLANG_SPEC_INT:
return aggregate_vector(agg, SLANG_STORE_INT, 1);
case SLANG_SPEC_IVEC2:
return aggregate_vector(agg, SLANG_STORE_INT, 2);
case SLANG_SPEC_IVEC3:
return aggregate_vector(agg, SLANG_STORE_INT, 3);
case SLANG_SPEC_IVEC4:
return aggregate_vector(agg, SLANG_STORE_INT, 4);
case SLANG_SPEC_FLOAT:
return aggregate_vector(agg, SLANG_STORE_FLOAT, 1);
case SLANG_SPEC_VEC2:
return aggregate_vector(agg, SLANG_STORE_FLOAT, 2);
case SLANG_SPEC_VEC3:
return aggregate_vector(agg, SLANG_STORE_FLOAT, 3);
case SLANG_SPEC_VEC4:
return aggregate_vector(agg, SLANG_STORE_FLOAT, 4);
case SLANG_SPEC_MAT2:
return aggregate_matrix(agg, SLANG_STORE_FLOAT, 2);
case SLANG_SPEC_MAT3:
return aggregate_matrix(agg, SLANG_STORE_FLOAT, 3);
case SLANG_SPEC_MAT4:
return aggregate_matrix(agg, SLANG_STORE_FLOAT, 4);
case SLANG_SPEC_SAMPLER1D:
case SLANG_SPEC_SAMPLER2D:
case SLANG_SPEC_SAMPLER3D:
case SLANG_SPEC_SAMPLERCUBE:
case SLANG_SPEC_SAMPLER1DSHADOW:
case SLANG_SPEC_SAMPLER2DSHADOW:
return aggregate_vector(agg, SLANG_STORE_INT, 1);
case SLANG_SPEC_STRUCT:
return aggregate_variables(agg, spec->_struct->fields, funcs, structs,
vars, atoms);
case slang_spec_array:
case SLANG_SPEC_ARRAY:
{
slang_storage_array *arr;
arr = slang_storage_aggregate_push_new(agg);
if (arr == NULL)
return GL_FALSE;
arr->type = slang_stor_aggregate;
arr->type = SLANG_STORE_AGGREGATE;
arr->aggregate =
(slang_storage_aggregate *)
slang_alloc_malloc(sizeof(slang_storage_aggregate));
@ -229,9 +229,9 @@ _slang_aggregate_variable(slang_storage_aggregate * agg,
GLuint
_slang_sizeof_type(slang_storage_type type)
{
if (type == slang_stor_aggregate)
if (type == SLANG_STORE_AGGREGATE)
return 0;
if (type == slang_stor_vec4)
if (type == SLANG_STORE_VEC4)
return 4 * sizeof(GLfloat);
return sizeof(GLfloat);
}
@ -246,7 +246,7 @@ _slang_sizeof_aggregate(const slang_storage_aggregate * agg)
slang_storage_array *arr = &agg->arrays[i];
GLuint element_size;
if (arr->type == slang_stor_aggregate)
if (arr->type == SLANG_STORE_AGGREGATE)
element_size = _slang_sizeof_aggregate(arr->aggregate);
else
element_size = _slang_sizeof_type(arr->type);
@ -266,7 +266,7 @@ _slang_flatten_aggregate(slang_storage_aggregate * flat,
GLuint j;
for (j = 0; j < agg->arrays[i].length; j++) {
if (agg->arrays[i].type == slang_stor_aggregate) {
if (agg->arrays[i].type == SLANG_STORE_AGGREGATE) {
if (!_slang_flatten_aggregate(flat, agg->arrays[i].aggregate))
return GL_FALSE;
}
@ -274,9 +274,9 @@ _slang_flatten_aggregate(slang_storage_aggregate * flat,
GLuint k, count;
slang_storage_type type;
if (agg->arrays[i].type == slang_stor_vec4) {
if (agg->arrays[i].type == SLANG_STORE_VEC4) {
count = 4;
type = slang_stor_float;
type = SLANG_STORE_FLOAT;
}
else {
count = 1;

17
src/mesa/shader/slang/slang_storage.h
View file

@ -22,7 +22,7 @@
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#if !defined SLANG_STORAGE_H
#ifndef SLANG_STORAGE_H
#define SLANG_STORAGE_H
#include "slang_compile.h"
@ -47,12 +47,12 @@
typedef enum slang_storage_type_
{
/* core */
slang_stor_aggregate,
slang_stor_bool,
slang_stor_int,
slang_stor_float,
SLANG_STORE_AGGREGATE,
SLANG_STORE_BOOL,
SLANG_STORE_INT,
SLANG_STORE_FLOAT,
/* vec4 */
slang_stor_vec4
SLANG_STORE_VEC4
} slang_storage_type;
@ -110,7 +110,7 @@ _slang_aggregate_variable(slang_storage_aggregate *agg,
/*
* Returns the size (in machine units) of the given storage type.
* It is an error to pass-in slang_stor_aggregate.
* It is an error to pass-in SLANG_STORE_AGGREGATE.
* Returns 0 on error.
*/
extern GLuint
@ -135,5 +135,4 @@ _slang_flatten_aggregate (slang_storage_aggregate *,
const slang_storage_aggregate *);
#endif
#endif /* SLANG_STORAGE_H */

318
src/mesa/shader/slang/slang_typeinfo.c
View file

@ -170,7 +170,7 @@ _slang_multiply_swizzles(slang_swizzle * dst, const slang_swizzle * left,
GLvoid
slang_type_specifier_ctr(slang_type_specifier * self)
{
self->type = slang_spec_void;
self->type = SLANG_SPEC_VOID;
self->_struct = NULL;
self->_array = NULL;
}
@ -196,7 +196,7 @@ slang_type_specifier_copy(slang_type_specifier * x,
slang_type_specifier_ctr(&z);
z.type = y->type;
if (z.type == slang_spec_struct) {
if (z.type == SLANG_SPEC_STRUCT) {
z._struct = (slang_struct *) slang_alloc_malloc(sizeof(slang_struct));
if (z._struct == NULL) {
slang_type_specifier_dtr(&z);
@ -212,7 +212,7 @@ slang_type_specifier_copy(slang_type_specifier * x,
return GL_FALSE;
}
}
else if (z.type == slang_spec_array) {
else if (z.type == SLANG_SPEC_ARRAY) {
z._array =
(slang_type_specifier *)
slang_alloc_malloc(sizeof(slang_type_specifier));
@ -241,9 +241,9 @@ slang_type_specifier_equal(const slang_type_specifier * x,
{
if (x->type != y->type)
return GL_FALSE;
if (x->type == slang_spec_struct)
if (x->type == SLANG_SPEC_STRUCT)
return slang_struct_equal(x->_struct, y->_struct);
if (x->type == slang_spec_array)
if (x->type == SLANG_SPEC_ARRAY)
return slang_type_specifier_equal(x->_array, y->_array);
return GL_TRUE;
}
@ -257,16 +257,16 @@ slang_type_specifier_compatible(const slang_type_specifier * x,
const slang_type_specifier * y)
{
/* special case: float == int */
if (x->type == slang_spec_int && y->type == slang_spec_float) {
if (x->type == SLANG_SPEC_INT && y->type == SLANG_SPEC_FLOAT) {
return GL_TRUE;
}
/* XXX may need to add bool/int compatibility, etc */
if (x->type != y->type)
return GL_FALSE;
if (x->type == slang_spec_struct)
if (x->type == SLANG_SPEC_STRUCT)
return slang_struct_equal(x->_struct, y->_struct);
if (x->type == slang_spec_array)
if (x->type == SLANG_SPEC_ARRAY)
return slang_type_specifier_compatible(x->_array, y->_array);
return GL_TRUE;
}
@ -341,93 +341,93 @@ _slang_typeof_operation_(const slang_operation * op,
ti->is_swizzled = GL_FALSE;
switch (op->type) {
case slang_oper_block_no_new_scope:
case slang_oper_block_new_scope:
case slang_oper_variable_decl:
case slang_oper_asm:
case slang_oper_break:
case slang_oper_continue:
case slang_oper_discard:
case slang_oper_return:
case slang_oper_if:
case slang_oper_while:
case slang_oper_do:
case slang_oper_for:
case slang_oper_void:
ti->spec.type = slang_spec_void;
case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
case SLANG_OPER_BLOCK_NEW_SCOPE:
case SLANG_OPER_VARIABLE_DECL:
case SLANG_OPER_ASM:
case SLANG_OPER_BREAK:
case SLANG_OPER_CONTINUE:
case SLANG_OPER_DISCARD:
case SLANG_OPER_RETURN:
case SLANG_OPER_IF:
case SLANG_OPER_WHILE:
case SLANG_OPER_DO:
case SLANG_OPER_FOR:
case SLANG_OPER_VOID:
ti->spec.type = SLANG_SPEC_VOID;
break;
case slang_oper_expression:
case slang_oper_assign:
case slang_oper_addassign:
case slang_oper_subassign:
case slang_oper_mulassign:
case slang_oper_divassign:
case slang_oper_preincrement:
case slang_oper_predecrement:
case SLANG_OPER_EXPRESSION:
case SLANG_OPER_ASSIGN:
case SLANG_OPER_ADDASSIGN:
case SLANG_OPER_SUBASSIGN:
case SLANG_OPER_MULASSIGN:
case SLANG_OPER_DIVASSIGN:
case SLANG_OPER_PREINCREMENT:
case SLANG_OPER_PREDECREMENT:
if (!_slang_typeof_operation_(op->children, space, ti, atoms))
return GL_FALSE;
break;
case slang_oper_literal_bool:
case SLANG_OPER_LITERAL_BOOL:
if (op->literal_size == 1)
ti->spec.type = slang_spec_bool;
ti->spec.type = SLANG_SPEC_BOOL;
else if (op->literal_size == 2)
ti->spec.type = slang_spec_bvec2;
ti->spec.type = SLANG_SPEC_BVEC2;
else if (op->literal_size == 3)
ti->spec.type = slang_spec_bvec3;
ti->spec.type = SLANG_SPEC_BVEC3;
else if (op->literal_size == 4)
ti->spec.type = slang_spec_bvec4;
ti->spec.type = SLANG_SPEC_BVEC4;
else {
_mesa_problem(NULL,
"Unexpected bool literal_size %d in _slang_typeof_operation()",
op->literal_size);
ti->spec.type = slang_spec_bool;
ti->spec.type = SLANG_SPEC_BOOL;
}
break;
case slang_oper_logicalor:
case slang_oper_logicalxor:
case slang_oper_logicaland:
case slang_oper_equal:
case slang_oper_notequal:
case slang_oper_less:
case slang_oper_greater:
case slang_oper_lessequal:
case slang_oper_greaterequal:
case slang_oper_not:
ti->spec.type = slang_spec_bool;
case SLANG_OPER_LOGICALOR:
case SLANG_OPER_LOGICALXOR:
case SLANG_OPER_LOGICALAND:
case SLANG_OPER_EQUAL:
case SLANG_OPER_NOTEQUAL:
case SLANG_OPER_LESS:
case SLANG_OPER_GREATER:
case SLANG_OPER_LESSequal:
case SLANG_OPER_GREATERequal:
case SLANG_OPER_NOT:
ti->spec.type = SLANG_SPEC_BOOL;
break;
case slang_oper_literal_int:
case SLANG_OPER_LITERAL_INT:
if (op->literal_size == 1)
ti->spec.type = slang_spec_int;
ti->spec.type = SLANG_SPEC_INT;
else if (op->literal_size == 2)
ti->spec.type = slang_spec_ivec2;
ti->spec.type = SLANG_SPEC_IVEC2;
else if (op->literal_size == 3)
ti->spec.type = slang_spec_ivec3;
ti->spec.type = SLANG_SPEC_IVEC3;
else if (op->literal_size == 4)
ti->spec.type = slang_spec_ivec4;
ti->spec.type = SLANG_SPEC_IVEC4;
else {
_mesa_problem(NULL,
"Unexpected int literal_size %d in _slang_typeof_operation()",
op->literal_size);
ti->spec.type = slang_spec_int;
ti->spec.type = SLANG_SPEC_INT;
}
break;
case slang_oper_literal_float:
case SLANG_OPER_LITERAL_FLOAT:
if (op->literal_size == 1)
ti->spec.type = slang_spec_float;
ti->spec.type = SLANG_SPEC_FLOAT;
else if (op->literal_size == 2)
ti->spec.type = slang_spec_vec2;
ti->spec.type = SLANG_SPEC_VEC2;
else if (op->literal_size == 3)
ti->spec.type = slang_spec_vec3;
ti->spec.type = SLANG_SPEC_VEC3;
else if (op->literal_size == 4)
ti->spec.type = slang_spec_vec4;
ti->spec.type = SLANG_SPEC_VEC4;
else {
_mesa_problem(NULL,
"Unexpected float literal_size %d in _slang_typeof_operation()",
op->literal_size);
ti->spec.type = slang_spec_float;
ti->spec.type = SLANG_SPEC_FLOAT;
}
break;
case slang_oper_identifier:
case SLANG_OPER_IDENTIFIER:
{
slang_variable *var;
var = _slang_locate_variable(op->locals, op->a_id, GL_TRUE);
@ -439,65 +439,65 @@ _slang_typeof_operation_(const slang_operation * op,
ti->array_len = var->array_len;
}
break;
case slang_oper_sequence:
case SLANG_OPER_SEQUENCE:
/* TODO: check [0] and [1] if they match */
if (!_slang_typeof_operation_(&op->children[1], space, ti, atoms))
RETURN_NIL();
ti->can_be_referenced = GL_FALSE;
ti->is_swizzled = GL_FALSE;
break;
/*case slang_oper_modassign: */
/*case slang_oper_lshassign: */
/*case slang_oper_rshassign: */
/*case slang_oper_orassign: */
/*case slang_oper_xorassign: */
/*case slang_oper_andassign: */
case slang_oper_select:
/*case SLANG_OPER_MODASSIGN: */
/*case SLANG_OPER_LSHASSIGN: */
/*case SLANG_OPER_RSHASSIGN: */
/*case SLANG_OPER_ORASSIGN: */
/*case SLANG_OPER_XORASSIGN: */
/*case SLANG_OPER_ANDASSIGN: */
case SLANG_OPER_SELECT:
/* TODO: check [1] and [2] if they match */
if (!_slang_typeof_operation_(&op->children[1], space, ti, atoms))
RETURN_NIL();
ti->can_be_referenced = GL_FALSE;
ti->is_swizzled = GL_FALSE;
break;
/*case slang_oper_bitor: */
/*case slang_oper_bitxor: */
/*case slang_oper_bitand: */
/*case slang_oper_lshift: */
/*case slang_oper_rshift: */
case slang_oper_add:
/*case SLANG_OPER_BITOR: */
/*case SLANG_OPER_BITXOR: */
/*case SLANG_OPER_BITAND: */
/*case SLANG_OPER_LSHIFT: */
/*case SLANG_OPER_RSHIFT: */
case SLANG_OPER_ADD:
if (!typeof_existing_function("+", op->children, 2, space,
&ti->spec, atoms))
RETURN_NIL();
break;
case slang_oper_subtract:
case SLANG_OPER_SUBTRACT:
if (!typeof_existing_function("-", op->children, 2, space,
&ti->spec, atoms))
RETURN_NIL();
break;
case slang_oper_multiply:
case SLANG_OPER_MULTIPLY:
if (!typeof_existing_function("*", op->children, 2, space,
&ti->spec, atoms))
RETURN_NIL();
break;
case slang_oper_divide:
case SLANG_OPER_DIVIDE:
if (!typeof_existing_function("/", op->children, 2, space,
&ti->spec, atoms))
RETURN_NIL();
break;
/*case slang_oper_modulus: */
case slang_oper_plus:
/*case SLANG_OPER_MODULUS: */
case SLANG_OPER_PLUS:
if (!_slang_typeof_operation_(op->children, space, ti, atoms))
RETURN_NIL();
ti->can_be_referenced = GL_FALSE;
ti->is_swizzled = GL_FALSE;
break;
case slang_oper_minus:
case SLANG_OPER_MINUS:
if (!typeof_existing_function("-", op->children, 1, space,
&ti->spec, atoms))
RETURN_NIL();
break;
/*case slang_oper_complement: */
case slang_oper_subscript:
/*case SLANG_OPER_COMPLEMENT: */
case SLANG_OPER_SUBSCRIPT:
{
slang_typeinfo _ti;
@ -508,7 +508,7 @@ _slang_typeof_operation_(const slang_operation * op,
RETURN_NIL();
}
ti->can_be_referenced = _ti.can_be_referenced;
if (_ti.spec.type == slang_spec_array) {
if (_ti.spec.type == SLANG_SPEC_ARRAY) {
if (!slang_type_specifier_copy(&ti->spec, _ti.spec._array)) {
slang_typeinfo_destruct(&_ti);
RETURN_NIL();
@ -525,7 +525,7 @@ _slang_typeof_operation_(const slang_operation * op,
slang_typeinfo_destruct(&_ti);
}
break;
case slang_oper_call:
case SLANG_OPER_CALL:
{
GLboolean exists;
@ -536,7 +536,7 @@ _slang_typeof_operation_(const slang_operation * op,
slang_struct *s =
slang_struct_scope_find(space->structs, op->a_id, GL_TRUE);
if (s != NULL) {
ti->spec.type = slang_spec_struct;
ti->spec.type = SLANG_SPEC_STRUCT;
ti->spec._struct =
(slang_struct *) slang_alloc_malloc(sizeof(slang_struct));
if (ti->spec._struct == NULL)
@ -555,14 +555,14 @@ _slang_typeof_operation_(const slang_operation * op,
name = slang_atom_pool_id(atoms, op->a_id);
type = slang_type_specifier_type_from_string(name);
if (type == slang_spec_void)
if (type == SLANG_SPEC_VOID)
RETURN_ERROR2("function not found", name, 0);
ti->spec.type = type;
}
}
}
break;
case slang_oper_field:
case SLANG_OPER_FIELD:
{
slang_typeinfo _ti;
@ -572,7 +572,7 @@ _slang_typeof_operation_(const slang_operation * op,
slang_typeinfo_destruct(&_ti);
RETURN_NIL();
}
if (_ti.spec.type == slang_spec_struct) {
if (_ti.spec.type == SLANG_SPEC_STRUCT) {
slang_variable *field;
field = _slang_locate_variable(_ti.spec._struct->fields, op->a_id,
@ -622,14 +622,14 @@ _slang_typeof_operation_(const slang_operation * op,
break;
case 2:
switch (base) {
case slang_spec_float:
ti->spec.type = slang_spec_vec2;
case SLANG_SPEC_FLOAT:
ti->spec.type = SLANG_SPEC_VEC2;
break;
case slang_spec_int:
ti->spec.type = slang_spec_ivec2;
case SLANG_SPEC_INT:
ti->spec.type = SLANG_SPEC_IVEC2;
break;
case slang_spec_bool:
ti->spec.type = slang_spec_bvec2;
case SLANG_SPEC_BOOL:
ti->spec.type = SLANG_SPEC_BVEC2;
break;
default:
break;
@ -637,14 +637,14 @@ _slang_typeof_operation_(const slang_operation * op,
break;
case 3:
switch (base) {
case slang_spec_float:
ti->spec.type = slang_spec_vec3;
case SLANG_SPEC_FLOAT:
ti->spec.type = SLANG_SPEC_VEC3;
break;
case slang_spec_int:
ti->spec.type = slang_spec_ivec3;
case SLANG_SPEC_INT:
ti->spec.type = SLANG_SPEC_IVEC3;
break;
case slang_spec_bool:
ti->spec.type = slang_spec_bvec3;
case SLANG_SPEC_BOOL:
ti->spec.type = SLANG_SPEC_BVEC3;
break;
default:
break;
@ -652,14 +652,14 @@ _slang_typeof_operation_(const slang_operation * op,
break;
case 4:
switch (base) {
case slang_spec_float:
ti->spec.type = slang_spec_vec4;
case SLANG_SPEC_FLOAT:
ti->spec.type = SLANG_SPEC_VEC4;
break;
case slang_spec_int:
ti->spec.type = slang_spec_ivec4;
case SLANG_SPEC_INT:
ti->spec.type = SLANG_SPEC_IVEC4;
break;
case slang_spec_bool:
ti->spec.type = slang_spec_bvec4;
case SLANG_SPEC_BOOL:
ti->spec.type = SLANG_SPEC_BVEC4;
break;
default:
break;
@ -672,8 +672,8 @@ _slang_typeof_operation_(const slang_operation * op,
slang_typeinfo_destruct(&_ti);
}
break;
case slang_oper_postincrement:
case slang_oper_postdecrement:
case SLANG_OPER_POSTINCREMENT:
case SLANG_OPER_POSTDECREMENT:
if (!_slang_typeof_operation_(op->children, space, ti, atoms))
RETURN_NIL();
ti->can_be_referenced = GL_FALSE;
@ -728,8 +728,8 @@ _slang_locate_function(const slang_function_scope * funcs, slang_atom a_name,
* parameter to be l-value.
*/
if (!ti.can_be_referenced &&
(f->parameters->variables[j]->type.qualifier == slang_qual_out ||
f->parameters->variables[j]->type.qualifier == slang_qual_inout))
(f->parameters->variables[j]->type.qualifier == SLANG_QUAL_OUT ||
f->parameters->variables[j]->type.qualifier == SLANG_QUAL_INOUT))
break;
}
if (j == num_args)
@ -777,9 +777,9 @@ GLboolean
_slang_type_is_matrix(slang_type_specifier_type ty)
{
switch (ty) {
case slang_spec_mat2:
case slang_spec_mat3:
case slang_spec_mat4:
case SLANG_SPEC_MAT2:
case SLANG_SPEC_MAT3:
case SLANG_SPEC_MAT4:
return GL_TRUE;
default:
return GL_FALSE;
@ -795,15 +795,15 @@ GLboolean
_slang_type_is_vector(slang_type_specifier_type ty)
{
switch (ty) {
case slang_spec_vec2:
case slang_spec_vec3:
case slang_spec_vec4:
case slang_spec_ivec2:
case slang_spec_ivec3:
case slang_spec_ivec4:
case slang_spec_bvec2:
case slang_spec_bvec3:
case slang_spec_bvec4:
case SLANG_SPEC_VEC2:
case SLANG_SPEC_VEC3:
case SLANG_SPEC_VEC4:
case SLANG_SPEC_IVEC2:
case SLANG_SPEC_IVEC3:
case SLANG_SPEC_IVEC4:
case SLANG_SPEC_BVEC2:
case SLANG_SPEC_BVEC3:
case SLANG_SPEC_BVEC4:
return GL_TRUE;
default:
return GL_FALSE;
@ -818,29 +818,29 @@ slang_type_specifier_type
_slang_type_base(slang_type_specifier_type ty)
{
switch (ty) {
case slang_spec_float:
case slang_spec_vec2:
case slang_spec_vec3:
case slang_spec_vec4:
return slang_spec_float;
case slang_spec_int:
case slang_spec_ivec2:
case slang_spec_ivec3:
case slang_spec_ivec4:
return slang_spec_int;
case slang_spec_bool:
case slang_spec_bvec2:
case slang_spec_bvec3:
case slang_spec_bvec4:
return slang_spec_bool;
case slang_spec_mat2:
return slang_spec_vec2;
case slang_spec_mat3:
return slang_spec_vec3;
case slang_spec_mat4:
return slang_spec_vec4;
case SLANG_SPEC_FLOAT:
case SLANG_SPEC_VEC2:
case SLANG_SPEC_VEC3:
case SLANG_SPEC_VEC4:
return SLANG_SPEC_FLOAT;
case SLANG_SPEC_INT:
case SLANG_SPEC_IVEC2:
case SLANG_SPEC_IVEC3:
case SLANG_SPEC_IVEC4:
return SLANG_SPEC_INT;
case SLANG_SPEC_BOOL:
case SLANG_SPEC_BVEC2:
case SLANG_SPEC_BVEC3:
case SLANG_SPEC_BVEC4:
return SLANG_SPEC_BOOL;
case SLANG_SPEC_MAT2:
return SLANG_SPEC_VEC2;
case SLANG_SPEC_MAT3:
return SLANG_SPEC_VEC3;
case SLANG_SPEC_MAT4:
return SLANG_SPEC_VEC4;
default:
return slang_spec_void;
return SLANG_SPEC_VOID;
}
}
@ -852,24 +852,24 @@ GLuint
_slang_type_dim(slang_type_specifier_type ty)
{
switch (ty) {
case slang_spec_float:
case slang_spec_int:
case slang_spec_bool:
case SLANG_SPEC_FLOAT:
case SLANG_SPEC_INT:
case SLANG_SPEC_BOOL:
return 1;
case slang_spec_vec2:
case slang_spec_ivec2:
case slang_spec_bvec2:
case slang_spec_mat2:
case SLANG_SPEC_VEC2:
case SLANG_SPEC_IVEC2:
case SLANG_SPEC_BVEC2:
case SLANG_SPEC_MAT2:
return 2;
case slang_spec_vec3:
case slang_spec_ivec3:
case slang_spec_bvec3:
case slang_spec_mat3:
case SLANG_SPEC_VEC3:
case SLANG_SPEC_IVEC3:
case SLANG_SPEC_BVEC3:
case SLANG_SPEC_MAT3:
return 3;
case slang_spec_vec4:
case slang_spec_ivec4:
case slang_spec_bvec4:
case slang_spec_mat4:
case SLANG_SPEC_VEC4:
case SLANG_SPEC_IVEC4:
case SLANG_SPEC_BVEC4:
case SLANG_SPEC_MAT4:
return 4;
default:
return 0;

48
src/mesa/shader/slang/slang_typeinfo.h
View file

@ -89,30 +89,30 @@ _slang_multiply_swizzles(slang_swizzle *, const slang_swizzle *,
*/
typedef enum slang_type_specifier_type_
{
slang_spec_void,
slang_spec_bool,
slang_spec_bvec2,
slang_spec_bvec3,
slang_spec_bvec4,
slang_spec_int,
slang_spec_ivec2,
slang_spec_ivec3,
slang_spec_ivec4,
slang_spec_float,
slang_spec_vec2,
slang_spec_vec3,
slang_spec_vec4,
slang_spec_mat2,
slang_spec_mat3,
slang_spec_mat4,
slang_spec_sampler1D,
slang_spec_sampler2D,
slang_spec_sampler3D,
slang_spec_samplerCube,
slang_spec_sampler1DShadow,
slang_spec_sampler2DShadow,
slang_spec_struct,
slang_spec_array
SLANG_SPEC_VOID,
SLANG_SPEC_BOOL,
SLANG_SPEC_BVEC2,
SLANG_SPEC_BVEC3,
SLANG_SPEC_BVEC4,
SLANG_SPEC_INT,
SLANG_SPEC_IVEC2,
SLANG_SPEC_IVEC3,
SLANG_SPEC_IVEC4,
SLANG_SPEC_FLOAT,
SLANG_SPEC_VEC2,
SLANG_SPEC_VEC3,
SLANG_SPEC_VEC4,
SLANG_SPEC_MAT2,
SLANG_SPEC_MAT3,
SLANG_SPEC_MAT4,
SLANG_SPEC_SAMPLER1D,
SLANG_SPEC_SAMPLER2D,
SLANG_SPEC_SAMPLER3D,
SLANG_SPEC_SAMPLERCUBE,
SLANG_SPEC_SAMPLER1DSHADOW,
SLANG_SPEC_SAMPLER2DSHADOW,
SLANG_SPEC_STRUCT,
SLANG_SPEC_ARRAY
} slang_type_specifier_type;