* \author Michal Krol
*/
-#include "imports.h"
-#include "context.h"
-#include "program.h"
-#include "prog_parameter.h"
-#include "grammar_mesa.h"
+#include "main/imports.h"
+#include "main/context.h"
+#include "shader/program.h"
+#include "shader/programopt.h"
+#include "shader/prog_print.h"
+#include "shader/prog_parameter.h"
+#include "shader/grammar/grammar_mesa.h"
#include "slang_codegen.h"
#include "slang_compile.h"
#include "slang_preprocess.h"
#include "slang_storage.h"
-#include "slang_error.h"
#include "slang_emit.h"
+#include "slang_log.h"
+#include "slang_mem.h"
#include "slang_vartable.h"
#include "slang_simplify.h"
*/
+/** re-defined below, should be the same though */
+#define TYPE_SPECIFIER_COUNT 32
+
+
+/**
+ * Check if the given identifier is legal.
+ */
+static GLboolean
+legal_identifier(slang_atom name)
+{
+ /* "gl_" is a reserved prefix */
+ if (_mesa_strncmp((char *) name, "gl_", 3) == 0) {
+ return GL_FALSE;
+ }
+ return GL_TRUE;
+}
+
/**
* Allocate storage for a variable of 'size' bytes from given pool.
for (i = 0; i < SLANG_BUILTIN_TOTAL; i++)
_slang_code_unit_ctr(&self->builtin[i], self);
_slang_code_unit_ctr(&self->unit, self);
-#if 01
- _slang_assembly_file_ctr(&self->assembly);
-#endif
- slang_machine_ctr(&self->machine);
self->varpool.next_addr = 0;
slang_atom_pool_construct(&self->atompool);
- slang_export_data_table_ctr(&self->expdata);
- self->expdata.atoms = &self->atompool;
- slang_export_code_table_ctr(&self->expcode);
- self->expcode.atoms = &self->atompool;
}
GLvoid
for (i = 0; i < SLANG_BUILTIN_TOTAL; i++)
_slang_code_unit_dtr(&self->builtin[i]);
_slang_code_unit_dtr(&self->unit);
-#if 01
- slang_assembly_file_destruct(&self->assembly);
-#endif
- slang_machine_dtr(&self->machine);
slang_atom_pool_destruct(&self->atompool);
- slang_export_data_table_dtr(&self->expdata);
- slang_export_code_table_ctr(&self->expcode);
}
-/* slang_info_log */
-
-static char *out_of_memory = "Error: Out of memory.\n";
-
-void
-slang_info_log_construct(slang_info_log * log)
-{
- log->text = NULL;
- log->dont_free_text = 0;
-}
-
-void
-slang_info_log_destruct(slang_info_log * log)
-{
- if (!log->dont_free_text)
- slang_alloc_free(log->text);
-}
-
-static int
-slang_info_log_message(slang_info_log * log, const char *prefix,
- const char *msg)
-{
- GLuint size;
-
- if (log->dont_free_text)
- return 0;
- size = slang_string_length(msg) + 2;
- if (prefix != NULL)
- size += slang_string_length(prefix) + 2;
- if (log->text != NULL) {
- GLuint old_len = slang_string_length(log->text);
- log->text = (char *)
- slang_alloc_realloc(log->text, old_len + 1, old_len + size);
- }
- else {
- log->text = (char *) (slang_alloc_malloc(size));
- if (log->text != NULL)
- log->text[0] = '\0';
- }
- if (log->text == NULL)
- return 0;
- if (prefix != NULL) {
- slang_string_concat(log->text, prefix);
- slang_string_concat(log->text, ": ");
- }
- slang_string_concat(log->text, msg);
- slang_string_concat(log->text, "\n");
- return 1;
-}
-
-int
-slang_info_log_print(slang_info_log * log, const char *msg, ...)
-{
- va_list va;
- char buf[1024];
-
- va_start(va, msg);
- _mesa_vsprintf(buf, msg, va);
- va_end(va);
- return slang_info_log_message(log, NULL, buf);
-}
-
-int
-slang_info_log_error(slang_info_log * log, const char *msg, ...)
-{
- va_list va;
- char buf[1024];
-
- va_start(va, msg);
- _mesa_vsprintf(buf, msg, va);
- va_end(va);
- if (slang_info_log_message(log, "Error", buf))
- return 1;
- slang_info_log_memory(log);
- return 0;
-}
-
-int
-slang_info_log_warning(slang_info_log * log, const char *msg, ...)
-{
- va_list va;
- char buf[1024];
-
- va_start(va, msg);
- _mesa_vsprintf(buf, msg, va);
- va_end(va);
- if (slang_info_log_message(log, "Warning", buf))
- return 1;
- slang_info_log_memory(log);
- return 0;
-}
-
-void
-slang_info_log_memory(slang_info_log * log)
-{
- if (!slang_info_log_message(log, "Error", "Out of memory.")) {
- log->dont_free_text = 1;
- log->text = out_of_memory;
- }
- abort();
-}
/* slang_parse_ctx */
GLboolean global_scope; /**< Is object being declared a global? */
slang_atom_pool *atoms;
slang_unit_type type; /**< Vertex vs. Fragment */
+ GLuint version; /**< user-specified (or default) #version */
} slang_parse_ctx;
/* slang_output_ctx */
slang_variable_scope *vars;
slang_function_scope *funs;
slang_struct_scope *structs;
- slang_assembly_file *assembly;
slang_var_pool *global_pool;
- slang_machine *machine;
struct gl_program *program;
slang_var_table *vartable;
+ GLuint default_precision[TYPE_SPECIFIER_COUNT];
+ GLboolean allow_precision;
+ GLboolean allow_invariant;
+ GLboolean allow_centroid;
+ GLboolean allow_array_types; /* float[] syntax */
} slang_output_ctx;
/* _slang_compile() */
+
+/* Debugging aid, print file/line where parsing error is detected */
+#define RETURN0 \
+ do { \
+ if (0) \
+ printf("slang error at %s:%d\n", __FILE__, __LINE__); \
+ return 0; \
+ } while (0)
+
+
static void
parse_identifier_str(slang_parse_ctx * C, char **id)
{
parse_identifier_str(C, &fractional);
parse_identifier_str(C, &exponent);
- whole = (char *) (slang_alloc_malloc((_mesa_strlen(integral) +
- _mesa_strlen(fractional) +
- _mesa_strlen(exponent) + 3) * sizeof(char)));
+ whole = (char *) _slang_alloc((_mesa_strlen(integral) +
+ _mesa_strlen(fractional) +
+ _mesa_strlen(exponent) + 3) * sizeof(char));
if (whole == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
slang_string_copy(whole, integral);
*number = (float) (_mesa_strtod(whole, (char **) NULL));
- slang_alloc_free(whole);
+ _slang_free(whole);
+
return 1;
}
/* revision number - increment after each change affecting emitted output */
-#define REVISION 3
+#define REVISION 4
static int
check_revision(slang_parse_ctx * C)
{
if (*C->I != REVISION) {
slang_info_log_error(C->L, "Internal compiler error.");
- return 0;
+ RETURN0;
}
C->I++;
return 1;
slang_operation *);
static int parse_type_specifier(slang_parse_ctx *, slang_output_ctx *,
slang_type_specifier *);
+static int
+parse_type_array_size(slang_parse_ctx *C,
+ slang_output_ctx *O,
+ GLint *array_len);
static GLboolean
parse_array_len(slang_parse_ctx * C, slang_output_ctx * O, GLuint * len)
{
slang_operation array_size;
- slang_assembly_name_space space;
+ slang_name_space space;
GLboolean result;
if (!slang_operation_construct(&array_size))
/* evaluate compile-time expression which is array size */
_slang_simplify(&array_size, &space, C->atoms);
- result = (array_size.type == slang_oper_literal_int);
+
+ if (array_size.type == SLANG_OPER_LITERAL_INT) {
+ result = GL_TRUE;
+ *len = (GLint) array_size.literal[0];
+ } else if (array_size.type == SLANG_OPER_IDENTIFIER) {
+ slang_variable *var = _slang_locate_variable(array_size.locals, array_size.a_id, GL_TRUE);
+ if (!var) {
+ slang_info_log_error(C->L, "undefined variable '%s'",
+ (char *) array_size.a_id);
+ result = GL_FALSE;
+ } else if (var->type.qualifier == SLANG_QUAL_CONST &&
+ var->type.specifier.type == SLANG_SPEC_INT) {
+ if (var->initializer &&
+ var->initializer->type == SLANG_OPER_LITERAL_INT) {
+ *len = (GLint) var->initializer->literal[0];
+ result = GL_TRUE;
+ } else {
+ slang_info_log_error(C->L, "unable to parse array size declaration");
+ result = GL_FALSE;
+ }
+ } else {
+ slang_info_log_error(C->L, "unable to parse array size declaration");
+ result = GL_FALSE;
+ }
+ } else {
+ result = GL_FALSE;
+ }
slang_operation_destruct(&array_size);
return result;
if (!slang_storage_aggregate_construct(&agg))
return GL_FALSE;
if (!_slang_aggregate_variable(&agg, &var->type.specifier, var->array_len,
- O->funs, O->structs, O->vars, O->machine,
- O->assembly, C->atoms)) {
+ O->funs, O->structs, O->vars, C->atoms)) {
slang_storage_aggregate_destruct(&agg);
return GL_FALSE;
}
convert_to_array(slang_parse_ctx * C, slang_variable * var,
const slang_type_specifier * sp)
{
- /* sized array - mark it as array, copy the specifier to the array element and
- * parse the expression */
- var->type.specifier.type = slang_spec_array;
+ /* 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._array = (slang_type_specifier *)
- slang_alloc_malloc(sizeof(slang_type_specifier));
+ _slang_alloc(sizeof(slang_type_specifier));
if (var->type.specifier._array == NULL) {
slang_info_log_memory(C->L);
return GL_FALSE;
static GLboolean
parse_struct_field_var(slang_parse_ctx * C, slang_output_ctx * O,
- slang_variable * var, const slang_type_specifier * sp)
+ slang_variable * var, slang_atom a_name,
+ const slang_type_specifier * sp,
+ GLuint array_len)
{
- var->a_name = parse_identifier(C);
+ var->a_name = a_name;
if (var->a_name == SLANG_ATOM_NULL)
return GL_FALSE;
switch (*C->I++) {
case FIELD_NONE:
- if (!slang_type_specifier_copy(&var->type.specifier, sp))
- return GL_FALSE;
+ if (array_len != -1) {
+ if (!convert_to_array(C, var, sp))
+ return GL_FALSE;
+ var->array_len = array_len;
+ }
+ else {
+ if (!slang_type_specifier_copy(&var->type.specifier, sp))
+ return GL_FALSE;
+ }
break;
case FIELD_ARRAY:
+ if (array_len != -1)
+ return GL_FALSE;
if (!convert_to_array(C, var, sp))
return GL_FALSE;
if (!parse_array_len(C, O, &var->array_len))
slang_struct * st, slang_type_specifier * sp)
{
slang_output_ctx o = *O;
+ GLint array_len;
o.structs = st->structs;
if (!parse_type_specifier(C, &o, sp))
- return 0;
+ RETURN0;
+ if (!parse_type_array_size(C, &o, &array_len))
+ RETURN0;
do {
+ slang_atom a_name;
slang_variable *var = slang_variable_scope_grow(st->fields);
if (!var) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
- if (!parse_struct_field_var(C, &o, var, sp))
- return 0;
+ a_name = parse_identifier(C);
+ if (_slang_locate_variable(st->fields, a_name, GL_FALSE)) {
+ slang_info_log_error(C->L, "duplicate field '%s'", (char *) a_name);
+ RETURN0;
+ }
+
+ if (!parse_struct_field_var(C, &o, var, a_name, sp, array_len))
+ RETURN0;
}
while (*C->I++ != FIELD_NONE);
/* parse struct name (if any) and make sure it is unique in current scope */
a_name = parse_identifier(C);
if (a_name == SLANG_ATOM_NULL)
- return 0;
+ RETURN0;
name = slang_atom_pool_id(C->atoms, a_name);
if (name[0] != '\0'
&& slang_struct_scope_find(O->structs, a_name, 0) != NULL) {
slang_info_log_error(C->L, "%s: duplicate type name.", name);
- return 0;
+ RETURN0;
}
/* set-up a new struct */
- *st = (slang_struct *) slang_alloc_malloc(sizeof(slang_struct));
+ *st = (slang_struct *) _slang_alloc(sizeof(slang_struct));
if (*st == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
if (!slang_struct_construct(*st)) {
- slang_alloc_free(*st);
+ _slang_free(*st);
*st = NULL;
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
(**st).a_name = a_name;
(**st).structs->outer_scope = O->structs;
slang_type_specifier_ctr(&sp);
if (!parse_struct_field(C, O, *st, &sp)) {
slang_type_specifier_dtr(&sp);
- return 0;
+ RETURN0;
}
slang_type_specifier_dtr(&sp);
}
slang_struct *s;
O->structs->structs =
- (slang_struct *) slang_alloc_realloc(O->structs->structs,
- O->structs->num_structs *
- sizeof(slang_struct),
- (O->structs->num_structs +
- 1) * sizeof(slang_struct));
+ (slang_struct *) _slang_realloc(O->structs->structs,
+ O->structs->num_structs
+ * sizeof(slang_struct),
+ (O->structs->num_structs + 1)
+ * sizeof(slang_struct));
if (O->structs->structs == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
s = &O->structs->structs[O->structs->num_structs];
if (!slang_struct_construct(s))
- return 0;
+ RETURN0;
O->structs->num_structs++;
if (!slang_struct_copy(s, *st))
- return 0;
+ RETURN0;
}
return 1;
}
+/* invariant qualifer */
+#define TYPE_VARIANT 90
+#define TYPE_INVARIANT 91
+
+static int
+parse_type_variant(slang_parse_ctx * C, slang_type_variant *variant)
+{
+ GLuint invariant = *C->I++;
+ switch (invariant) {
+ case TYPE_VARIANT:
+ *variant = SLANG_VARIANT;
+ return 1;
+ case TYPE_INVARIANT:
+ *variant = SLANG_INVARIANT;
+ return 1;
+ default:
+ RETURN0;
+ }
+}
+
+
+/* centroid qualifer */
+#define TYPE_CENTER 95
+#define TYPE_CENTROID 96
+
+static int
+parse_type_centroid(slang_parse_ctx * C, slang_type_centroid *centroid)
+{
+ GLuint c = *C->I++;
+ switch (c) {
+ case TYPE_CENTER:
+ *centroid = SLANG_CENTER;
+ return 1;
+ case TYPE_CENTROID:
+ *centroid = SLANG_CENTROID;
+ return 1;
+ default:
+ RETURN0;
+ }
+}
+
+
/* type qualifier */
#define TYPE_QUALIFIER_NONE 0
#define TYPE_QUALIFIER_CONST 1
static int
parse_type_qualifier(slang_parse_ctx * C, slang_type_qualifier * qual)
{
- switch (*C->I++) {
+ GLuint qualifier = *C->I++;
+ switch (qualifier) {
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;
+ RETURN0;
}
return 1;
}
#define TYPE_SPECIFIER_SAMPLERCUBE 19
#define TYPE_SPECIFIER_SAMPLER1DSHADOW 20
#define TYPE_SPECIFIER_SAMPLER2DSHADOW 21
-#define TYPE_SPECIFIER_STRUCT 22
-#define TYPE_SPECIFIER_TYPENAME 23
+#define TYPE_SPECIFIER_SAMPLER2DRECT 22
+#define TYPE_SPECIFIER_SAMPLER2DRECTSHADOW 23
+#define TYPE_SPECIFIER_STRUCT 24
+#define TYPE_SPECIFIER_TYPENAME 25
+#define TYPE_SPECIFIER_MAT23 26
+#define TYPE_SPECIFIER_MAT32 27
+#define TYPE_SPECIFIER_MAT24 28
+#define TYPE_SPECIFIER_MAT42 29
+#define TYPE_SPECIFIER_MAT34 30
+#define TYPE_SPECIFIER_MAT43 31
+#define TYPE_SPECIFIER_COUNT 32
static int
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_MAT23:
+ spec->type = SLANG_SPEC_MAT23;
+ break;
+ case TYPE_SPECIFIER_MAT32:
+ spec->type = SLANG_SPEC_MAT32;
+ break;
+ case TYPE_SPECIFIER_MAT24:
+ spec->type = SLANG_SPEC_MAT24;
+ break;
+ case TYPE_SPECIFIER_MAT42:
+ spec->type = SLANG_SPEC_MAT42;
+ break;
+ case TYPE_SPECIFIER_MAT34:
+ spec->type = SLANG_SPEC_MAT34;
+ break;
+ case TYPE_SPECIFIER_MAT43:
+ spec->type = SLANG_SPEC_MAT43;
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_SAMPLER2DRECT:
+ spec->type = SLANG_SPEC_SAMPLER2DRECT;
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_SAMPLER2DRECTSHADOW:
+ spec->type = SLANG_SPEC_SAMPLER2DRECTSHADOW;
break;
case TYPE_SPECIFIER_STRUCT:
- spec->type = slang_spec_struct;
+ spec->type = SLANG_SPEC_STRUCT;
if (!parse_struct(C, O, &spec->_struct))
- return 0;
+ RETURN0;
break;
case TYPE_SPECIFIER_TYPENAME:
- spec->type = slang_spec_struct;
+ spec->type = SLANG_SPEC_STRUCT;
{
slang_atom a_name;
slang_struct *stru;
a_name = parse_identifier(C);
if (a_name == NULL)
- return 0;
+ RETURN0;
stru = slang_struct_scope_find(O->structs, a_name, 1);
if (stru == NULL) {
slang_info_log_error(C->L, "undeclared type name '%s'",
slang_atom_pool_id(C->atoms, a_name));
- return 0;
+ RETURN0;
}
- spec->_struct =
- (slang_struct *) slang_alloc_malloc(sizeof(slang_struct));
+ spec->_struct = (slang_struct *) _slang_alloc(sizeof(slang_struct));
if (spec->_struct == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
if (!slang_struct_construct(spec->_struct)) {
- slang_alloc_free(spec->_struct);
+ _slang_free(spec->_struct);
spec->_struct = NULL;
- return 0;
+ RETURN0;
}
if (!slang_struct_copy(spec->_struct, stru))
- return 0;
+ RETURN0;
}
break;
default:
- return 0;
+ RETURN0;
}
return 1;
}
+#define TYPE_SPECIFIER_NONARRAY 0
+#define TYPE_SPECIFIER_ARRAY 1
+
+static int
+parse_type_array_size(slang_parse_ctx *C,
+ slang_output_ctx *O,
+ GLint *array_len)
+{
+ GLuint size;
+
+ switch (*C->I++) {
+ case TYPE_SPECIFIER_NONARRAY:
+ *array_len = -1; /* -1 = not an array */
+ break;
+ case TYPE_SPECIFIER_ARRAY:
+ if (!parse_array_len(C, O, &size))
+ RETURN0;
+ *array_len = (GLint) size;
+ break;
+ default:
+ assert(0);
+ RETURN0;
+ }
+ return 1;
+}
+
+#define PRECISION_DEFAULT 0
+#define PRECISION_LOW 1
+#define PRECISION_MEDIUM 2
+#define PRECISION_HIGH 3
+
+static int
+parse_type_precision(slang_parse_ctx *C,
+ slang_type_precision *precision)
+{
+ GLint prec = *C->I++;
+ switch (prec) {
+ case PRECISION_DEFAULT:
+ *precision = SLANG_PREC_DEFAULT;
+ return 1;
+ case PRECISION_LOW:
+ *precision = SLANG_PREC_LOW;
+ return 1;
+ case PRECISION_MEDIUM:
+ *precision = SLANG_PREC_MEDIUM;
+ return 1;
+ case PRECISION_HIGH:
+ *precision = SLANG_PREC_HIGH;
+ return 1;
+ default:
+ RETURN0;
+ }
+}
+
static int
parse_fully_specified_type(slang_parse_ctx * C, slang_output_ctx * O,
slang_fully_specified_type * type)
{
+ if (!parse_type_variant(C, &type->variant))
+ RETURN0;
+
+ if (!parse_type_centroid(C, &type->centroid))
+ RETURN0;
+
if (!parse_type_qualifier(C, &type->qualifier))
- return 0;
+ RETURN0;
+
+ if (!parse_type_precision(C, &type->precision))
+ RETURN0;
+
if (!parse_type_specifier(C, O, &type->specifier))
- return 0;
+ RETURN0;
+
+ if (!parse_type_array_size(C, O, &type->array_len))
+ RETURN0;
+
+ if (!O->allow_invariant && type->variant == SLANG_INVARIANT) {
+ slang_info_log_error(C->L,
+ "'invariant' keyword not allowed (perhaps set #version 120)");
+ RETURN0;
+ }
+
+ if (!O->allow_centroid && type->centroid == SLANG_CENTROID) {
+ slang_info_log_error(C->L,
+ "'centroid' keyword not allowed (perhaps set #version 120)");
+ RETURN0;
+ }
+ else if (type->centroid == SLANG_CENTROID &&
+ type->qualifier != SLANG_QUAL_VARYING) {
+ slang_info_log_error(C->L,
+ "'centroid' keyword only allowed for varying vars");
+ RETURN0;
+ }
+
+
+ /* need this?
+ if (type->qualifier != SLANG_QUAL_VARYING &&
+ type->variant == SLANG_INVARIANT) {
+ slang_info_log_error(C->L,
+ "invariant qualifer only allowed for varying vars");
+ RETURN0;
+ }
+ */
+
+ if (O->allow_precision) {
+ if (type->precision == SLANG_PREC_DEFAULT) {
+ assert(type->specifier.type < TYPE_SPECIFIER_COUNT);
+ /* use the default precision for this datatype */
+ type->precision = O->default_precision[type->specifier.type];
+ }
+ }
+ else {
+ /* only default is allowed */
+ if (type->precision != SLANG_PREC_DEFAULT) {
+ slang_info_log_error(C->L, "precision qualifiers not allowed");
+ RETURN0;
+ }
+ }
+
+ if (!O->allow_array_types && type->array_len >= 0) {
+ slang_info_log_error(C->L, "first-class array types not allowed");
+ RETURN0;
+ }
+
return 1;
}
#define OP_FIELD 59
#define OP_POSTINCREMENT 60
#define OP_POSTDECREMENT 61
+#define OP_PRECISION 62
+#define OP_METHOD 63
/**
* When parsing a compound production, this function is used to parse the
* children.
- * For example, a a while-loop compound will have two children, the
+ * For example, a while-loop compound will have two children, the
* while condition expression and the loop body. So, this function will
* be called twice to parse those two sub-expressions.
* \param C the parsing context
parse_statement(slang_parse_ctx * C, slang_output_ctx * O,
slang_operation * oper)
{
+ int op;
+
oper->locals->outer_scope = O->vars;
- switch (*C->I++) {
+
+ op = *C->I++;
+ switch (op) {
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;
+ RETURN0;
C->I++;
break;
case OP_BLOCK_BEGIN_NEW_SCOPE:
{
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))
- return 0;
+ RETURN0;
C->I++;
}
break;
/* 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;
* than one declarators
*/
if (!parse_declaration(C, O))
- return 0;
+ RETURN0;
if (first_var < O->vars->num_variables) {
const unsigned int num_vars = O->vars->num_variables - first_var;
unsigned int i;
-
+ assert(oper->num_children == 0);
oper->num_children = num_vars;
oper->children = slang_operation_new(num_vars);
if (oper->children == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
for (i = first_var; i < O->vars->num_variables; i++) {
slang_operation *o = &oper->children[i - first_var];
- o->type = slang_oper_variable_decl;
+ slang_variable *var = O->vars->variables[i];
+ o->type = SLANG_OPER_VARIABLE_DECL;
o->locals->outer_scope = O->vars;
- o->a_id = O->vars->variables[i]->a_name;
+ o->a_id = var->a_name;
+
+ /* new/someday...
+ calculate_var_size(C, O, var);
+ */
+
+ if (!legal_identifier(o->a_id)) {
+ slang_info_log_error(C->L, "illegal variable name '%s'",
+ (char *) o->a_id);
+ RETURN0;
+ }
}
}
}
/* 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;
+ RETURN0;
while (*C->I != OP_END) {
if (!parse_child_operation(C, O, oper, 0))
- return 0;
+ RETURN0;
}
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;
+ RETURN0;
break;
case OP_EXPRESSION:
- oper->type = slang_oper_expression;
+ oper->type = SLANG_OPER_EXPRESSION;
if (!parse_child_operation(C, O, oper, 0))
- return 0;
+ RETURN0;
break;
case OP_IF:
- oper->type = slang_oper_if;
+ oper->type = SLANG_OPER_IF;
if (!parse_child_operation(C, O, oper, 0))
- return 0;
+ RETURN0;
if (!parse_child_operation(C, O, oper, 1))
- return 0;
+ RETURN0;
if (!parse_child_operation(C, O, oper, 1))
- return 0;
+ RETURN0;
break;
case OP_WHILE:
{
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;
+ RETURN0;
if (!parse_child_operation(C, &o, oper, 1))
- return 0;
+ RETURN0;
}
break;
case OP_DO:
- oper->type = slang_oper_do;
+ oper->type = SLANG_OPER_DO;
if (!parse_child_operation(C, O, oper, 1))
- return 0;
+ RETURN0;
if (!parse_child_operation(C, O, oper, 0))
- return 0;
+ RETURN0;
break;
case OP_FOR:
{
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;
+ RETURN0;
if (!parse_child_operation(C, &o, oper, 1))
- return 0;
+ RETURN0;
if (!parse_child_operation(C, &o, oper, 0))
- return 0;
+ RETURN0;
if (!parse_child_operation(C, &o, oper, 1))
- return 0;
+ RETURN0;
+ }
+ break;
+ case OP_PRECISION:
+ {
+ /* set default precision for a type in this scope */
+ /* ignored at this time */
+ int prec_qual = *C->I++;
+ int datatype = *C->I++;
+ (void) prec_qual;
+ (void) datatype;
}
break;
default:
- return 0;
+ printf("Unexpected operation %d\n", op);
+ RETURN0;
}
return 1;
}
{
unsigned int i;
- op->children =
- (slang_operation *) slang_alloc_malloc(n * sizeof(slang_operation));
+ op->children = slang_operation_new(n);
if (op->children == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
op->num_children = n;
- for (i = 0; i < n; i++)
+ for (i = 0; i < n; i++) {
+ slang_operation_destruct(&op->children[i]);
op->children[i] = (*ops)[*total_ops - (n + 1 - i)];
+ }
+
(*ops)[*total_ops - (n + 1)] = (*ops)[*total_ops - 1];
*total_ops -= n;
*ops = (slang_operation *)
- slang_alloc_realloc(*ops,
- (*total_ops + n) * sizeof(slang_operation),
- *total_ops * sizeof(slang_operation));
+ _slang_realloc(*ops,
+ (*total_ops + n) * sizeof(slang_operation),
+ *total_ops * sizeof(slang_operation));
if (*ops == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
return 1;
}
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;
}
+#define FUNCTION_CALL_NONARRAY 0
+#define FUNCTION_CALL_ARRAY 1
+
static int
parse_expression(slang_parse_ctx * C, slang_output_ctx * O,
slang_operation * oper)
/* allocate default operation, becomes a no-op if not used */
ops = (slang_operation *)
- slang_alloc_realloc(ops,
- num_ops * sizeof(slang_operation),
- (num_ops + 1) * sizeof(slang_operation));
+ _slang_realloc(ops,
+ num_ops * sizeof(slang_operation),
+ (num_ops + 1) * sizeof(slang_operation));
if (ops == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
op = &ops[num_ops];
if (!slang_operation_construct(op)) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
num_ops++;
op->locals->outer_scope = O->vars;
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;
+ RETURN0;
op->literal[0] =
op->literal[1] =
op->literal[2] =
op->literal[3] = (GLfloat) number;
+ 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;
+ RETURN0;
op->literal[0] =
op->literal[1] =
op->literal[2] =
op->literal[3] = (GLfloat) number;
+ 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;
+ RETURN0;
op->literal[1] =
op->literal[2] =
op->literal[3] = op->literal[0];
+ 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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
break;
/*case OP_MODASSIGN: */
/*case OP_LSHASSIGN: */
/*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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
break;
/*case OP_BITOR: */
/*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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
break;
- case OP_CALL:
- op->type = slang_oper_call;
+ case OP_METHOD:
+ op->type = SLANG_OPER_METHOD;
+ op->a_obj = parse_identifier(C);
+ if (op->a_obj == SLANG_ATOM_NULL)
+ RETURN0;
+
op->a_id = parse_identifier(C);
if (op->a_id == SLANG_ATOM_NULL)
- return 0;
+ RETURN0;
+
while (*C->I != OP_END)
if (!parse_child_operation(C, O, op, 0))
- return 0;
+ RETURN0;
C->I++;
-
+#if 0
+ /* don't lookup the method (not yet anyway) */
if (!C->parsing_builtin
&& !slang_function_scope_find_by_name(O->funs, op->a_id, 1)) {
const char *id;
id = slang_atom_pool_id(C->atoms, op->a_id);
if (!is_constructor_name(id, op->a_id, O->structs)) {
slang_info_log_error(C->L, "%s: undeclared function name.", id);
- return 0;
+ RETURN0;
+ }
+ }
+#endif
+ break;
+ case OP_CALL:
+ {
+ GLboolean array_constructor = GL_FALSE;
+ GLint array_constructor_size;
+
+ op->type = SLANG_OPER_CALL;
+ op->a_id = parse_identifier(C);
+ if (op->a_id == SLANG_ATOM_NULL)
+ RETURN0;
+ switch (*C->I++) {
+ case FUNCTION_CALL_NONARRAY:
+ /* Nothing to do. */
+ break;
+ case FUNCTION_CALL_ARRAY:
+ /* Calling an array constructor. For example:
+ * float[3](1.1, 2.2, 3.3);
+ */
+ if (!O->allow_array_types) {
+ slang_info_log_error(C->L,
+ "array constructors not allowed "
+ "in this GLSL version");
+ RETURN0;
+ }
+ else {
+ array_constructor = GL_TRUE;
+ /* parse the array constructor size */
+ slang_operation array_size;
+ slang_operation_construct(&array_size);
+ if (!parse_expression(C, O, &array_size)) {
+ slang_operation_destruct(&array_size);
+ return GL_FALSE;
+ }
+ if (array_size.type != SLANG_OPER_LITERAL_INT) {
+ slang_info_log_error(C->L,
+ "constructor array size is not an integer");
+ slang_operation_destruct(&array_size);
+ RETURN0;
+ }
+ array_constructor_size = (int) array_size.literal[0];
+ slang_operation_destruct(&array_size);
+ }
+ break;
+ default:
+ assert(0);
+ RETURN0;
+ }
+ while (*C->I != OP_END)
+ if (!parse_child_operation(C, O, op, 0))
+ RETURN0;
+ C->I++;
+
+ if (array_constructor &&
+ array_constructor_size != op->num_children) {
+ slang_info_log_error(C->L, "number of parameters to array"
+ " constructor does not match array size");
+ RETURN0;
+ }
+
+ if (!C->parsing_builtin
+ && !slang_function_scope_find_by_name(O->funs, op->a_id, 1)) {
+ const char *id;
+
+ id = slang_atom_pool_id(C->atoms, op->a_id);
+ if (!is_constructor_name(id, op->a_id, O->structs)) {
+ slang_info_log_error(C->L, "%s: undeclared function name.", id);
+ RETURN0;
+ }
}
}
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;
+ RETURN0;
if (!handle_nary_expression(C, op, &ops, &num_ops, 1))
- return 0;
+ RETURN0;
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;
+ RETURN0;
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;
+ RETURN0;
break;
default:
- return 0;
+ RETURN0;
}
}
C->I++;
- *oper = *ops;
- slang_alloc_free(ops);
+ slang_operation_destruct(oper);
+ *oper = *ops; /* struct copy */
+ _slang_free(ops);
return 1;
}
parse_parameter_declaration(slang_parse_ctx * C, slang_output_ctx * O,
slang_variable * param)
{
+ int param_qual, precision_qual;
+
/* parse and validate the parameter's type qualifiers (there can be
* two at most) because not all combinations are valid
*/
if (!parse_type_qualifier(C, ¶m->type.qualifier))
- return 0;
- switch (*C->I++) {
+ RETURN0;
+
+ param_qual = *C->I++;
+ switch (param_qual) {
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;
+ RETURN0;
}
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;
+ RETURN0;
}
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;
+ RETURN0;
}
break;
default:
- return 0;
+ RETURN0;
}
+ /* parse precision qualifier (lowp, mediump, highp */
+ precision_qual = *C->I++;
+ /* ignored at this time */
+ (void) precision_qual;
+
/* parse parameter's type specifier and name */
if (!parse_type_specifier(C, O, ¶m->type.specifier))
- return 0;
+ RETURN0;
+ if (!parse_type_array_size(C, O, ¶m->type.array_len))
+ RETURN0;
param->a_name = parse_identifier(C);
if (param->a_name == SLANG_ATOM_NULL)
- return 0;
+ RETURN0;
+
+ /* first-class array
+ */
+ if (param->type.array_len >= 0) {
+ slang_type_specifier p;
+
+ slang_type_specifier_ctr(&p);
+ if (!slang_type_specifier_copy(&p, ¶m->type.specifier)) {
+ slang_type_specifier_dtr(&p);
+ RETURN0;
+ }
+ if (!convert_to_array(C, param, &p)) {
+ slang_type_specifier_dtr(&p);
+ RETURN0;
+ }
+ slang_type_specifier_dtr(&p);
+ param->array_len = param->type.array_len;
+ }
/* if the parameter is an array, parse its size (the size must be
* explicitly defined
if (*C->I++ == PARAMETER_ARRAY_PRESENT) {
slang_type_specifier p;
+ if (param->type.array_len >= 0) {
+ slang_info_log_error(C->L, "multi-dimensional arrays not allowed");
+ RETURN0;
+ }
slang_type_specifier_ctr(&p);
if (!slang_type_specifier_copy(&p, ¶m->type.specifier)) {
slang_type_specifier_dtr(&p);
- return GL_FALSE;
+ RETURN0;
}
if (!convert_to_array(C, param, &p)) {
slang_type_specifier_dtr(&p);
- return GL_FALSE;
+ RETURN0;
}
slang_type_specifier_dtr(&p);
if (!parse_array_len(C, O, ¶m->array_len))
- return GL_FALSE;
+ RETURN0;
}
+#if 0
/* calculate the parameter size */
if (!calculate_var_size(C, O, param))
- return GL_FALSE;
-
+ RETURN0;
+#endif
/* TODO: allocate the local address here? */
return 1;
}
slang_atom_pool_atom(C->atoms, operator_names[i].o_name);
if (atom == SLANG_ATOM_NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
C->I++;
return atom;
}
}
- return 0;
+ RETURN0;
}
+
static int
parse_function_prototype(slang_parse_ctx * C, slang_output_ctx * O,
slang_function * func)
{
+ GLuint functype;
/* parse function type and name */
if (!parse_fully_specified_type(C, O, &func->header.type))
- return 0;
- switch (*C->I++) {
+ RETURN0;
+
+ functype = *C->I++;
+ switch (functype) {
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;
+ RETURN0;
break;
case FUNCTION_CONSTRUCTOR:
- func->kind = slang_func_constructor;
- if (func->header.type.specifier.type == slang_spec_struct)
- return 0;
+ func->kind = SLANG_FUNC_CONSTRUCTOR;
+ if (func->header.type.specifier.type == SLANG_SPEC_STRUCT)
+ RETURN0;
func->header.a_name =
slang_atom_pool_atom(C->atoms,
slang_type_specifier_type_to_string
(func->header.type.specifier.type));
if (func->header.a_name == SLANG_ATOM_NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
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;
+ RETURN0;
break;
default:
- return 0;
+ RETURN0;
+ }
+
+ if (!legal_identifier(func->header.a_name)) {
+ slang_info_log_error(C->L, "illegal function name '%s'",
+ (char *) func->header.a_name);
+ RETURN0;
}
/* parse function parameters */
slang_variable *p = slang_variable_scope_grow(func->parameters);
if (!p) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
if (!parse_parameter_declaration(C, O, p))
- return 0;
+ RETURN0;
}
-#if 111
/* if the function returns a value, append a hidden __retVal 'out'
* parameter that corresponds to the return value.
*/
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;
}
-#endif
/* function formal parameters and local variables share the same
* scope, so save the information about param count in a seperate
slang_output_ctx o = *O;
if (!parse_function_prototype(C, O, func))
- return 0;
+ RETURN0;
/* create function's body operation */
- func->body =
- (slang_operation *) slang_alloc_malloc(sizeof(slang_operation));
+ func->body = (slang_operation *) _slang_alloc(sizeof(slang_operation));
if (func->body == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
if (!slang_operation_construct(func->body)) {
- slang_alloc_free(func->body);
+ _slang_free(func->body);
func->body = NULL;
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
/* to parse the body the parse context is modified in order to
C->global_scope = GL_FALSE;
o.vars = func->parameters;
if (!parse_statement(C, &o, func->body))
- return 0;
+ RETURN0;
C->global_scope = GL_TRUE;
return 1;
static GLboolean
initialize_global(slang_assemble_ctx * A, slang_variable * var)
{
-#if 01
- slang_assembly_file_restore_point point;
-#endif
- slang_machine mach;
- slang_assembly_local_info save_local = A->local;
slang_operation op_id, op_assign;
GLboolean result;
-#if 01
- /* save the current assembly */
- if (!slang_assembly_file_restore_point_save(A->file, &point))
- return GL_FALSE;
-#endif
-
- /* setup the machine */
- mach = *A->mach;
- mach.ip = A->file->count;
-
- /* allocate local storage for expression */
- A->local.ret_size = 0;
- A->local.addr_tmp = 0;
- A->local.swizzle_tmp = 4;
- if (!slang_assembly_file_push_label(A->file, slang_asm_local_alloc, 20))
- return GL_FALSE;
- if (!slang_assembly_file_push_label(A->file, slang_asm_enter, 20))
- return GL_FALSE;
-
/* 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 */
op_id.locals->variables =
- (slang_variable **) slang_alloc_malloc(sizeof(slang_variable *));
+ (slang_variable **) _slang_alloc(sizeof(slang_variable *));
if (op_id.locals->variables == NULL) {
slang_operation_destruct(&op_id);
return GL_FALSE;
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));
+ (slang_operation *) _slang_alloc(2 * sizeof(slang_operation));
if (op_assign.children == NULL) {
slang_operation_destruct(&op_assign);
op_id.locals->num_variables = 0;
op_assign.children[0] = op_id;
op_assign.children[1] = *var->initializer;
-#if 0 /* this should go away */
- /* insert the actual expression */
- result = _slang_assemble_operation(A, &op_assign, slang_ref_forbid);
-#else
result = 1;
-#endif
/* carefully destroy the operations */
op_assign.num_children = 0;
- slang_alloc_free(op_assign.children);
+ _slang_free(op_assign.children);
op_assign.children = NULL;
slang_operation_destruct(&op_assign);
op_id.locals->num_variables = 0;
if (!result)
return GL_FALSE;
- if (!slang_assembly_file_push(A->file, slang_asm_exit))
- return GL_FALSE;
-
- /* execute the expression */
-#if 0
- if (!_slang_execute2(A->file, &mach))
- return GL_FALSE;
-#endif
-
-#if 01
- /* restore the old assembly */
- if (!slang_assembly_file_restore_point_load(A->file, &point))
- return GL_FALSE;
-#endif
- A->local = save_local;
-
- /* now we copy the contents of the initialized variable back to the original machine */
- _mesa_memcpy((GLubyte *) A->mach->mem + var->address,
- (GLubyte *) mach.mem + var->address, var->size);
return GL_TRUE;
}
const slang_fully_specified_type * type)
{
slang_variable *var;
+ slang_atom a_name;
/* empty init declatator (without name, e.g. "float ;") */
if (*C->I++ == VARIABLE_NONE)
return 1;
+ a_name = parse_identifier(C);
+
+ /* check if name is already in this scope */
+ if (_slang_locate_variable(O->vars, a_name, GL_FALSE)) {
+ slang_info_log_error(C->L,
+ "declaration of '%s' conflicts with previous declaration",
+ (char *) a_name);
+ RETURN0;
+ }
+
/* make room for the new variable and initialize it */
var = slang_variable_scope_grow(O->vars);
if (!var) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
- /* copy the declarator qualifier type, parse the identifier */
- var->global = C->global_scope;
+ /* copy the declarator type qualifier/etc info, parse the identifier */
var->type.qualifier = type->qualifier;
- var->a_name = parse_identifier(C);
+ var->type.centroid = type->centroid;
+ var->type.precision = type->precision;
+ var->type.variant = type->variant;
+ var->a_name = a_name;
if (var->a_name == SLANG_ATOM_NULL)
- return 0;
+ RETURN0;
switch (*C->I++) {
case VARIABLE_NONE:
/* simple variable declarator - just copy the specifier */
- if (!slang_type_specifier_copy(&var->type.specifier, &type->specifier))
- return 0;
+ if (type->array_len >= 0) {
+ /* The type was something like "float[4]" */
+ convert_to_array(C, var, &type->specifier);
+ var->array_len = type->array_len;
+ }
+ else {
+ if (!slang_type_specifier_copy(&var->type.specifier, &type->specifier))
+ RETURN0;
+ }
break;
case VARIABLE_INITIALIZER:
/* initialized variable - copy the specifier and parse the expression */
- if (!slang_type_specifier_copy(&var->type.specifier, &type->specifier))
- return 0;
+ if (type->array_len >= 0) {
+ /* The type was something like "float[4]" */
+ convert_to_array(C, var, &type->specifier);
+ var->array_len = type->array_len;
+ }
+ else {
+ if (!slang_type_specifier_copy(&var->type.specifier, &type->specifier))
+ RETURN0;
+ }
var->initializer =
- (slang_operation *) slang_alloc_malloc(sizeof(slang_operation));
+ (slang_operation *) _slang_alloc(sizeof(slang_operation));
if (var->initializer == NULL) {
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
if (!slang_operation_construct(var->initializer)) {
- slang_alloc_free(var->initializer);
+ _slang_free(var->initializer);
var->initializer = NULL;
slang_info_log_memory(C->L);
- return 0;
+ RETURN0;
}
if (!parse_expression(C, O, var->initializer))
- return 0;
+ RETURN0;
break;
-#if 0
case VARIABLE_ARRAY_UNKNOWN:
/* unsized array - mark it as array and copy the specifier to
- the array element
- */
+ * the array element
+ */
+ if (type->array_len >= 0) {
+ slang_info_log_error(C->L, "multi-dimensional arrays not allowed");
+ RETURN0;
+ }
if (!convert_to_array(C, var, &type->specifier))
return GL_FALSE;
break;
-#endif
case VARIABLE_ARRAY_EXPLICIT:
+ if (type->array_len >= 0) {
+ slang_info_log_error(C->L, "multi-dimensional arrays not allowed");
+ RETURN0;
+ }
if (!convert_to_array(C, var, &type->specifier))
return GL_FALSE;
if (!parse_array_len(C, O, &var->array_len))
return GL_FALSE;
break;
default:
- return 0;
+ RETURN0;
}
-#if 1
+ /* allocate global address space for a variable with a known size */
+ if (C->global_scope
+ && !(var->type.specifier.type == SLANG_SPEC_ARRAY
+ && var->array_len == 0)) {
+ if (!calculate_var_size(C, O, var))
+ return GL_FALSE;
+ var->address = slang_var_pool_alloc(O->global_pool, var->size);
+ }
+
+ /* emit code for global var decl */
if (C->global_scope) {
slang_assemble_ctx A;
-
- A.file = O->assembly;
- A.mach = O->machine;
A.atoms = C->atoms;
A.space.funcs = O->funs;
A.space.structs = O->structs;
A.space.vars = O->vars;
A.program = O->program;
-#if 0
- A.codegen = O->codegen;
-#endif
A.vartable = O->vartable;
-
- _slang_codegen_global_variable(&A, var, C->type);
- }
-#endif
-
- /* allocate global address space for a variable with a known size */
- if (C->global_scope
- && !(var->type.specifier.type == slang_spec_array
- && var->array_len == 0)) {
- if (!calculate_var_size(C, O, var))
- return GL_FALSE;
- var->address = slang_var_pool_alloc(O->global_pool, var->size);
+ A.log = C->L;
+ A.curFuncEndLabel = NULL;
+ if (!_slang_codegen_global_variable(&A, var, C->type))
+ RETURN0;
}
/* initialize global variable */
if (var->initializer != NULL) {
slang_assemble_ctx A;
- A.file = O->assembly;
- A.mach = O->machine;
A.atoms = C->atoms;
A.space.funcs = O->funs;
A.space.structs = O->structs;
A.space.vars = O->vars;
if (!initialize_global(&A, var))
- return 0;
- }
- else {
- _mesa_memset((GLubyte *) (O->machine->mem) + var->address, 0,
- var->size);
+ RETURN0;
}
}
return 1;
/* parse the fully specified type, common to all declarators */
if (!slang_fully_specified_type_construct(&type))
- return 0;
+ RETURN0;
if (!parse_fully_specified_type(C, O, &type)) {
slang_fully_specified_type_destruct(&type);
- return 0;
+ RETURN0;
}
/* parse declarators, pass-in the parsed type */
do {
if (!parse_init_declarator(C, O, &type)) {
slang_fully_specified_type_destruct(&type);
- return 0;
+ RETURN0;
}
}
while (*C->I++ == DECLARATOR_NEXT);
if (found_func == NULL) {
/* New function, add it to the function list */
O->funs->functions =
- (slang_function *) slang_alloc_realloc(O->funs->functions,
- O->funs->num_functions *
- sizeof(slang_function),
- (O->funs->num_functions +
- 1) * sizeof(slang_function));
+ (slang_function *) _slang_realloc(O->funs->functions,
+ O->funs->num_functions
+ * sizeof(slang_function),
+ (O->funs->num_functions + 1)
+ * sizeof(slang_function));
if (O->funs->functions == NULL) {
slang_info_log_memory(C->L);
slang_function_destruct(&parsed_func);
*parsed_func_ret = found_func;
}
- /* assemble the parsed function */
- {
- slang_assemble_ctx A;
-
- A.file = O->assembly;
- A.mach = O->machine;
- A.atoms = C->atoms;
- A.space.funcs = O->funs;
- A.space.structs = O->structs;
- A.space.vars = O->vars;
- A.program = O->program;
-#if 0
- A.codegen = O->codegen;
-#endif
- A.vartable = O->vartable;
-
- _slang_reset_error();
-
-#if 0
- printf("*************** Assemble function %s ****\n", (char *) (*parsed_func_ret)->header.a_name);
- slang_print_var_scope((*parsed_func_ret)->parameters,
- (*parsed_func_ret)->param_count);
-#endif
-
-#if 0
- if (!_slang_assemble_function(&A, *parsed_func_ret)) {
- /* propogate the error message back through the info log */
- C->L->text = _mesa_strdup(_slang_error_text());
- C->L->dont_free_text = GL_FALSE;
- return GL_FALSE;
- }
-#endif
-
-#if 0
- printf("**************************************\n");
-#endif
-#if 1
- _slang_codegen_function(&A, *parsed_func_ret);
-#endif
- }
return GL_TRUE;
}
switch (*C->I++) {
case DECLARATION_INIT_DECLARATOR_LIST:
if (!parse_init_declarator_list(C, O))
- return 0;
+ RETURN0;
break;
case DECLARATION_FUNCTION_PROTOTYPE:
{
slang_function *dummy_func;
if (!parse_function(C, O, 0, &dummy_func))
- return 0;
+ RETURN0;
}
break;
default:
- return 0;
+ RETURN0;
+ }
+ return 1;
+}
+
+static int
+parse_default_precision(slang_parse_ctx * C, slang_output_ctx * O)
+{
+ int precision, type;
+
+ if (!O->allow_precision) {
+ slang_info_log_error(C->L, "syntax error at \"precision\"");
+ RETURN0;
+ }
+
+ precision = *C->I++;
+ switch (precision) {
+ case PRECISION_LOW:
+ case PRECISION_MEDIUM:
+ case PRECISION_HIGH:
+ /* OK */
+ break;
+ default:
+ _mesa_problem(NULL, "unexpected precision %d at %s:%d\n",
+ precision, __FILE__, __LINE__);
+ RETURN0;
+ }
+
+ type = *C->I++;
+ switch (type) {
+ case TYPE_SPECIFIER_FLOAT:
+ case TYPE_SPECIFIER_INT:
+ case TYPE_SPECIFIER_SAMPLER1D:
+ case TYPE_SPECIFIER_SAMPLER2D:
+ case TYPE_SPECIFIER_SAMPLER3D:
+ case TYPE_SPECIFIER_SAMPLERCUBE:
+ case TYPE_SPECIFIER_SAMPLER1DSHADOW:
+ case TYPE_SPECIFIER_SAMPLER2DSHADOW:
+ case TYPE_SPECIFIER_SAMPLER2DRECT:
+ case TYPE_SPECIFIER_SAMPLER2DRECTSHADOW:
+ /* OK */
+ break;
+ default:
+ _mesa_problem(NULL, "unexpected type %d at %s:%d\n",
+ type, __FILE__, __LINE__);
+ RETURN0;
}
+
+ assert(type < TYPE_SPECIFIER_COUNT);
+ O->default_precision[type] = precision;
+
return 1;
}
-/* external declaration */
+
+/**
+ * Initialize the default precision for all types.
+ * XXX this info isn't used yet.
+ */
+static void
+init_default_precision(slang_output_ctx *O, slang_unit_type type)
+{
+ GLuint i;
+ for (i = 0; i < TYPE_SPECIFIER_COUNT; i++) {
+#if FEATURE_es2_glsl
+ O->default_precision[i] = PRECISION_LOW;
+#else
+ O->default_precision[i] = PRECISION_HIGH;
+#endif
+ }
+
+ if (type == SLANG_UNIT_VERTEX_SHADER) {
+ O->default_precision[TYPE_SPECIFIER_FLOAT] = PRECISION_HIGH;
+ O->default_precision[TYPE_SPECIFIER_INT] = PRECISION_HIGH;
+ }
+ else {
+ O->default_precision[TYPE_SPECIFIER_INT] = PRECISION_MEDIUM;
+ }
+}
+
+
+static int
+parse_invariant(slang_parse_ctx * C, slang_output_ctx * O)
+{
+ if (O->allow_invariant) {
+ slang_atom *a = parse_identifier(C);
+ /* XXX not doing anything with this var yet */
+ /*printf("ID: %s\n", (char*) a);*/
+ return a ? 1 : 0;
+ }
+ else {
+ slang_info_log_error(C->L, "syntax error at \"invariant\"");
+ RETURN0;
+ }
+}
+
+
+/* external declaration or default precision specifier */
#define EXTERNAL_NULL 0
#define EXTERNAL_FUNCTION_DEFINITION 1
#define EXTERNAL_DECLARATION 2
+#define DEFAULT_PRECISION 3
+#define INVARIANT_STMT 4
+
static GLboolean
parse_code_unit(slang_parse_ctx * C, slang_code_unit * unit,
- struct gl_program *program)
+ struct gl_shader *shader)
{
GET_CURRENT_CONTEXT(ctx);
slang_output_ctx o;
GLboolean success;
GLuint maxRegs;
+ slang_function *mainFunc = NULL;
- 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;
}
o.funs = &unit->funs;
o.structs = &unit->structs;
o.vars = &unit->vars;
- o.assembly = &unit->object->assembly;
o.global_pool = &unit->object->varpool;
- o.machine = &unit->object->machine;
- o.program = program;
+ o.program = shader ? shader->Program : NULL;
o.vartable = _slang_new_var_table(maxRegs);
_slang_push_var_table(o.vartable);
+ /* allow 'invariant' keyword? */
+#if FEATURE_es2_glsl
+ o.allow_invariant = GL_TRUE;
+#else
+ o.allow_invariant = (C->version >= 120) ? GL_TRUE : GL_FALSE;
+#endif
+
+ /* allow 'centroid' keyword? */
+ o.allow_centroid = (C->version >= 120) ? GL_TRUE : GL_FALSE;
+
+ /* allow 'lowp/mediump/highp' keywords? */
+#if FEATURE_es2_glsl
+ o.allow_precision = GL_TRUE;
+#else
+ o.allow_precision = (C->version >= 120) ? GL_TRUE : GL_FALSE;
+#endif
+ init_default_precision(&o, unit->type);
+
+ /* allow 'float[]' keyword? */
+ o.allow_array_types = (C->version >= 120) ? GL_TRUE : GL_FALSE;
+
/* parse individual functions and declarations */
while (*C->I != EXTERNAL_NULL) {
switch (*C->I++) {
{
slang_function *func;
success = parse_function(C, &o, 1, &func);
+ if (success &&
+ _mesa_strcmp((char *) func->header.a_name, "main") == 0) {
+ /* found main() */
+ mainFunc = func;
+ }
}
break;
case EXTERNAL_DECLARATION:
success = parse_declaration(C, &o);
break;
+ case DEFAULT_PRECISION:
+ success = parse_default_precision(C, &o);
+ break;
+ case INVARIANT_STMT:
+ success = parse_invariant(C, &o);
+ break;
default:
success = GL_FALSE;
}
}
C->I++;
+ if (mainFunc) {
+ /* assemble (generate code) for main() */
+ slang_assemble_ctx A;
+
+ A.atoms = C->atoms;
+ A.space.funcs = o.funs;
+ A.space.structs = o.structs;
+ A.space.vars = o.vars;
+ A.program = o.program;
+ A.vartable = o.vartable;
+ A.log = C->L;
+
+ /* main() takes no parameters */
+ if (mainFunc->param_count > 0) {
+ slang_info_log_error(A.log, "main() takes no arguments");
+ return GL_FALSE;
+ }
+
+ _slang_codegen_function(&A, mainFunc);
+
+ shader->Main = GL_TRUE; /* this shader defines main() */
+ }
+
_slang_pop_var_table(o.vartable);
+ _slang_delete_var_table(o.vartable);
+
return GL_TRUE;
}
static GLboolean
compile_binary(const byte * prod, slang_code_unit * unit,
+ GLuint version,
slang_unit_type type, slang_info_log * infolog,
slang_code_unit * builtin, slang_code_unit * downlink,
- struct gl_program *program)
+ struct gl_shader *shader)
{
slang_parse_ctx C;
C.global_scope = GL_TRUE;
C.atoms = &unit->object->atompool;
C.type = type;
+ C.version = version;
if (!check_revision(&C))
return GL_FALSE;
}
/* parse translation unit */
- return parse_code_unit(&C, unit, program);
+ return parse_code_unit(&C, unit, shader);
}
static GLboolean
compile_with_grammar(grammar id, const char *source, slang_code_unit * unit,
slang_unit_type type, slang_info_log * infolog,
slang_code_unit * builtin,
- struct gl_program *program)
+ struct gl_shader *shader)
{
byte *prod;
GLuint size, start, version;
slang_string preprocessed;
+ GLuint maxVersion;
+
+#if FEATURE_ARB_shading_language_120
+ maxVersion = 120;
+#elif FEATURE_es2_glsl
+ maxVersion = 100;
+#else
+ maxVersion = 110;
+#endif
/* First retrieve the version number. */
if (!_slang_preprocess_version(source, &version, &start, infolog))
return GL_FALSE;
- if (version > 110) {
+ if (version > maxVersion) {
slang_info_log_error(infolog,
- "language version specified is not supported.");
+ "language version %.2f is not supported.",
+ version * 0.01);
return GL_FALSE;
}
/* Finally check the syntax and generate its binary representation. */
if (!grammar_fast_check(id,
(const byte *) (slang_string_cstr(&preprocessed)),
- &prod, &size,
- 65536)) {
+ &prod, &size, 65536)) {
char buf[1024];
GLint pos;
slang_string_free(&preprocessed);
grammar_get_last_error((byte *) (buf), sizeof(buf), &pos);
slang_info_log_error(infolog, buf);
- RETURN_ERROR("syntax error (possibly in library code)", 0);
+ /* syntax error (possibly in library code) */
+#if 0
+ {
+ int line, col;
+ char *s;
+ s = (char *) _mesa_find_line_column((const GLubyte *) source,
+ (const GLubyte *) source + pos,
+ &line, &col);
+ printf("Error on line %d, col %d: %s\n", line, col, s);
+ }
+#endif
+ return GL_FALSE;
}
slang_string_free(&preprocessed);
/* Syntax is okay - translate it to internal representation. */
- if (!compile_binary(prod, unit, type, infolog, builtin,
+ if (!compile_binary(prod, unit, version, type, infolog, builtin,
&builtin[SLANG_BUILTIN_TOTAL - 1],
- program)) {
+ shader)) {
grammar_alloc_free(prod);
return GL_FALSE;
}
#include "library/slang_core_gc.h"
};
+static const byte slang_120_core_gc[] = {
+#include "library/slang_120_core_gc.h"
+};
+
+static const byte slang_120_fragment_gc[] = {
+#include "library/slang_builtin_120_fragment_gc.h"
+};
+
static const byte slang_common_builtin_gc[] = {
#include "library/slang_common_builtin_gc.h"
};
#include "library/slang_vertex_builtin_gc.h"
};
-#if 0 /*defined(USE_X86_ASM) || defined(SLANG_X86)*/
-static const byte slang_builtin_vec4_gc[] = {
-#include "library/slang_builtin_vec4_gc.h"
-};
-#endif
-
static GLboolean
compile_object(grammar * id, const char *source, slang_code_object * object,
slang_unit_type type, slang_info_log * infolog,
- struct gl_program *program)
+ struct gl_shader *shader)
{
slang_code_unit *builtins = NULL;
+ GLuint base_version = 110;
/* load GLSL grammar */
*id = grammar_load_from_text((const byte *) (slang_shader_syn));
}
/* 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);
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,
+ base_version,
+ SLANG_UNIT_FRAGMENT_BUILTIN, infolog,
NULL, NULL, NULL))
return GL_FALSE;
+#if FEATURE_ARB_shading_language_120
+ if (!compile_binary(slang_120_core_gc,
+ &object->builtin[SLANG_BUILTIN_120_CORE],
+ 120,
+ SLANG_UNIT_FRAGMENT_BUILTIN, infolog,
+ NULL, &object->builtin[SLANG_BUILTIN_CORE], NULL))
+ return GL_FALSE;
+#endif
+
/* 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,
- &object->builtin[SLANG_BUILTIN_CORE], NULL))
+#if FEATURE_ARB_shading_language_120
+ 120,
+#else
+ base_version,
+#endif
+ SLANG_UNIT_FRAGMENT_BUILTIN, infolog, NULL,
+#if FEATURE_ARB_shading_language_120
+ &object->builtin[SLANG_BUILTIN_120_CORE],
+#else
+ &object->builtin[SLANG_BUILTIN_CORE],
+#endif
+ 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,
+ base_version,
+ SLANG_UNIT_FRAGMENT_BUILTIN, infolog, NULL,
&object->builtin[SLANG_BUILTIN_COMMON], NULL))
return GL_FALSE;
+#if FEATURE_ARB_shading_language_120
+ if (!compile_binary(slang_120_fragment_gc,
+ &object->builtin[SLANG_BUILTIN_TARGET],
+ 120,
+ SLANG_UNIT_FRAGMENT_BUILTIN, infolog, NULL,
+ &object->builtin[SLANG_BUILTIN_COMMON], NULL))
+ return GL_FALSE;
+#endif
}
- 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,
+ base_version,
+ SLANG_UNIT_VERTEX_BUILTIN, infolog, NULL,
&object->builtin[SLANG_BUILTIN_COMMON], NULL))
return GL_FALSE;
}
-#if 0/*defined(USE_X86_ASM) || defined(SLANG_X86)*/
- /* compile x86 4-component vector overrides, link to target */
- if (!compile_binary(slang_builtin_vec4_gc,
- &object->builtin[SLANG_BUILTIN_VEC4],
- slang_unit_fragment_builtin, infolog, NULL,
- &object->builtin[SLANG_BUILTIN_TARGET]))
- return GL_FALSE;
-#endif
-
/* disable language extensions */
#if NEW_SLANG /* allow-built-ins */
grammar_set_reg8(*id, (const byte *) "parsing_builtin", 1);
/* compile the actual shader - pass-in built-in library for external shader */
return compile_with_grammar(*id, source, &object->unit, type, infolog,
- builtins, program);
+ builtins, shader);
}
-#if 0
-static void
-slang_create_uniforms(const slang_export_data_table *exports,
- struct gl_program *program)
-{
- /* XXX only add uniforms that are actually going to get used */
- GLuint i;
- for (i = 0; i < exports->count; i++) {
- if (exports->entries[i].access == slang_exp_uniform) {
- const char *name = (char *) exports->entries[i].quant.name;
- GLint j = _mesa_add_uniform(program->Parameters, name, 4);
- assert(j >= 0);
- }
- }
-}
-#endif
-
-
static GLboolean
compile_shader(GLcontext *ctx, slang_code_object * object,
slang_unit_type type, slang_info_log * infolog,
struct gl_shader *shader)
{
- struct gl_program *program = shader->Programs[0];
GLboolean success;
grammar id = 0;
- assert(program);
+#if 0 /* for debug */
+ _mesa_printf("********* COMPILE SHADER ***********\n");
+ _mesa_printf("%s\n", shader->Source);
+ _mesa_printf("************************************\n");
+#endif
+
+ assert(shader->Program);
_slang_code_object_dtr(object);
_slang_code_object_ctr(object);
- success = compile_object(&id, shader->Source, object, type, infolog, program);
+ success = compile_object(&id, shader->Source, object, type, infolog, shader);
if (id != 0)
grammar_destroy(id);
if (!success)
return GL_FALSE;
- if (!_slang_build_export_data_table(&object->expdata, &object->unit.vars))
- return GL_FALSE;
- if (!_slang_build_export_code_table(&object->expcode, &object->unit.funs,
- &object->unit))
- return GL_FALSE;
-
-#if NEW_SLANG
- {
- slang_create_uniforms(&object->expdata, shader);
- _mesa_print_program(program);
- _mesa_print_program_parameters(ctx, program);
- }
-#endif
-
return GL_TRUE;
}
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 */
- if (!shader->Programs) {
+ if (!shader->Source)
+ return GL_FALSE;
+
+ ctx->Shader.MemPool = _slang_new_mempool(1024*1024);
+
+ shader->Main = GL_FALSE;
+
+ if (!shader->Program) {
GLenum progTarget;
if (shader->Type == GL_VERTEX_SHADER)
progTarget = GL_VERTEX_PROGRAM_ARB;
else
progTarget = GL_FRAGMENT_PROGRAM_ARB;
- shader->Programs
- = (struct gl_program **) malloc(sizeof(struct gl_program*));
- shader->Programs[0] = _mesa_new_program(ctx, progTarget, 1);
- shader->NumPrograms = 1;
-
- shader->Programs[0]->Parameters = _mesa_new_parameter_list();
- shader->Programs[0]->Varying = _mesa_new_parameter_list();
- shader->Programs[0]->Attributes = _mesa_new_parameter_list();
+ shader->Program = ctx->Driver.NewProgram(ctx, progTarget, 1);
+ shader->Program->Parameters = _mesa_new_parameter_list();
+ shader->Program->Varying = _mesa_new_parameter_list();
+ shader->Program->Attributes = _mesa_new_parameter_list();
}
slang_info_log_construct(&info_log);
success = compile_shader(ctx, &obj, type, &info_log, shader);
- if (success) {
-#if 0
- slang_create_uniforms(&object->expdata, shader);
- _mesa_print_program(program);
- _mesa_print_program_parameters(ctx, program);
-#endif
+ /* free shader's prev info log */
+ if (shader->InfoLog) {
+ _mesa_free(shader->InfoLog);
+ shader->InfoLog = NULL;
}
- else {
- /* XXX more work on info log needed here */
- if (info_log.text) {
- if (shader->InfoLog) {
- free(shader->InfoLog);
- shader->InfoLog = NULL;
- }
- shader->InfoLog = strdup(info_log.text);
- }
+
+ if (info_log.text) {
+ /* copy info-log string to shader object */
+ shader->InfoLog = _mesa_strdup(info_log.text);
+ }
+
+ if (info_log.error_flag) {
+ success = GL_FALSE;
}
slang_info_log_destruct(&info_log);
_slang_code_object_dtr(&obj);
+ _slang_delete_mempool((slang_mempool *) ctx->Shader.MemPool);
+ ctx->Shader.MemPool = NULL;
+
+ /* remove any reads of output registers */
+#if 0
+ printf("Pre-remove output reads:\n");
+ _mesa_print_program(shader->Program);
+#endif
+ _mesa_remove_output_reads(shader->Program, PROGRAM_OUTPUT);
+ if (shader->Type == GL_VERTEX_SHADER) {
+ /* and remove writes to varying vars in vertex programs */
+ _mesa_remove_output_reads(shader->Program, PROGRAM_VARYING);
+ }
+#if 0
+ printf("Post-remove output reads:\n");
+ _mesa_print_program(shader->Program);
+#endif
+
return success;
}