# gamma are missing because they have not been converted to use the new
# interface.
DRI_DIRS = i810 i915tex i915 i965 mach64 mga r128 r200 r300 radeon s3v \
- savage sis tdfx trident unichrome ffb
+ savage sis tdfx trident unichrome ffb nouveau
#include "slang_typeinfo.h"
#include "slang_codegen.h"
#include "slang_compile.h"
-#include "slang_error.h"
#include "slang_label.h"
#include "slang_simplify.h"
#include "slang_emit.h"
*/
static slang_ir_node *
_slang_gen_asm(slang_assemble_ctx *A, slang_operation *oper,
- slang_operation *dest)
+ slang_operation *dest)
{
const slang_asm_info *info;
slang_ir_node *kids[3], *n;
* Use 'name' to find the function to call
*/
fun = _slang_locate_function(A->space.funcs, atom, params, param_count,
- &A->space, A->atoms);
+ &A->space, A->atoms, A->log);
if (!fun) {
/* A function with exactly the right parameters/types was not found.
* Try adapting the parameters.
*/
fun = _slang_first_function(A->space.funcs, name);
- if (!_slang_adapt_call(oper, fun, &A->space, A->atoms)) {
- RETURN_ERROR2("Undefined function (or no matching parameters)",
- name, 0);
+ if (!_slang_adapt_call(oper, fun, &A->space, A->atoms, A->log)) {
+ slang_info_log_error(A->log, "Undefined function '%s'", name);
+ return NULL;
}
assert(fun);
}
if (loop->BranchNode == 0 && isConst && constTrue) {
/* infinite loop detected */
A->CurLoop = prevLoop; /* clean-up */
- RETURN_ERROR("Infinite loop detected!", 0);
+ slang_info_log_error(A->log, "Infinite loop detected!");
+ return NULL;
}
/* pop loop, restore prev */
assert(oper->num_children == 1);
var = new_var(A, oper, oper->a_id);
if (!var) {
- RETURN_ERROR2("Undefined variable:", varName, 0);
+ slang_info_log_error(A->log, "undefined variable '%s'", varName);
+ return NULL;
}
/* XXX make copy of this initializer? */
rhs = _slang_gen_operation(A, &oper->children[0]);
slang_ir_node *var, *init, *rhs;
var = new_var(A, oper, oper->a_id);
if (!var) {
- RETURN_ERROR2("Undefined variable:", varName, 0);
+ slang_info_log_error(A->log, "undefined variable '%s'", varName);
+ return NULL;
}
#if 0
/* XXX make copy of this initializer? */
slang_atom aVar = oper->var ? oper->var->a_name : oper->a_id;
slang_ir_node *n = new_var(A, oper, aVar);
if (!n) {
- RETURN_ERROR2("Undefined variable:", (char *) aVar, 0);
+ slang_info_log_error(A->log, "undefined variable '%s'", (char *) aVar);
+ return NULL;
}
return n;
}
slang_ir_node *n;
GLuint swizzle;
if (!_slang_is_swizzle((char *) oper->a_id, rows, &swz)) {
- RETURN_ERROR("Bad swizzle", 0);
+ slang_info_log_error(A->log, "Bad swizzle");
}
swizzle = MAKE_SWIZZLE4(swz.swizzle[0],
swz.swizzle[1],
slang_ir_node *n;
GLuint swizzle;
if (!_slang_is_swizzle((char *) oper->a_id, rows, &swz)) {
- RETURN_ERROR("Bad swizzle", 0);
+ slang_info_log_error(A->log, "Bad swizzle");
}
swizzle = MAKE_SWIZZLE4(swz.swizzle[0],
swz.swizzle[1],
index = (GLint) oper->children[1].literal[0];
if (oper->children[1].type != SLANG_OPER_LITERAL_INT ||
index >= max) {
- RETURN_ERROR("Invalid array index for vector type", 0);
+ slang_info_log_error(A->log, "Invalid array index for vector type");
}
n = _slang_gen_operation(A, &oper->children[0]);
return _slang_gen_while(A, oper);
case SLANG_OPER_BREAK:
if (!A->CurLoop) {
- RETURN_ERROR("'break' not in loop", 0);
+ slang_info_log_error(A->log, "'break' not in loop");
}
return new_break(A->CurLoop);
case SLANG_OPER_CONTINUE:
if (!A->CurLoop) {
- RETURN_ERROR("'continue' not in loop", 0);
+ slang_info_log_error(A->log, "'continue' not in loop");
}
return new_cont(A->CurLoop);
case SLANG_OPER_DISCARD:
n = new_seq(n, init);
}
- success = _slang_emit_code(n, A->vartable, A->program, GL_FALSE);
+ success = _slang_emit_code(n, A->vartable, A->program, GL_FALSE, A->log);
_slang_free_ir_tree(n);
}
#endif
/* Emit program instructions */
- success = _slang_emit_code(n, A->vartable, A->program, GL_TRUE);
+ success = _slang_emit_code(n, A->vartable, A->program, GL_TRUE, A->log);
_slang_free_ir_tree(n);
/* free codegen context */
#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_vartable.h"
#include "slang_simplify.h"
slang_atom_pool_destruct(&self->atompool);
}
-/* 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");
-#if 1
- abort(); /* XXX temporary */
-#endif
- 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(); /* XXX temporary */
-}
/* slang_parse_ctx */
A.space.vars = O->vars;
A.program = O->program;
A.vartable = O->vartable;
-
- _slang_reset_error();
+ A.log = C->L;
_slang_codegen_function(&A, *parsed_func_ret);
}
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) */
}
slang_string_free(&preprocessed);
success = compile_shader(ctx, &obj, type, &info_log, shader);
- if (success) {
+ if (success && !info_log.text) {
#if 0
slang_create_uniforms(&object->expdata, shader);
_mesa_print_program(program);
#endif
}
else {
+ success = GL_FALSE;
/* XXX more work on info log needed here */
if (info_log.text) {
if (shader->InfoLog) {
extern GLvoid
_slang_code_object_dtr (slang_code_object *);
-typedef struct slang_info_log_
-{
- char *text;
- int dont_free_text;
-} slang_info_log;
-
-void slang_info_log_construct (slang_info_log *);
-void slang_info_log_destruct (slang_info_log *);
-int slang_info_log_print (slang_info_log *, const char *, ...);
-int slang_info_log_error (slang_info_log *, const char *, ...);
-int slang_info_log_warning (slang_info_log *, const char *, ...);
-void slang_info_log_memory (slang_info_log *);
-
extern GLboolean
_slang_compile (GLcontext *ctx, struct gl_shader *shader);
#include "prog_print.h"
#include "slang_builtin.h"
#include "slang_emit.h"
-#include "slang_error.h"
#define PEEPHOLE_OPTIMIZATIONS 1
assert(n->Store->Index < 0);
if (!n->Var || n->Var->isTemp) {
/* a nameless/temporary variable, will be freed after first use */
- if (!_slang_alloc_temp(emitInfo->vt, n->Store))
- RETURN_ERROR("Ran out of registers, too many temporaries", 0);
+ if (!_slang_alloc_temp(emitInfo->vt, n->Store)) {
+ slang_info_log_error(emitInfo->log,
+ "Ran out of registers, too many temporaries");
+ return NULL;
+ }
}
else {
/* a regular variable */
_slang_add_variable(emitInfo->vt, n->Var);
- if (!_slang_alloc_var(emitInfo->vt, n->Store))
- RETURN_ERROR("Ran out of registers, too many variables", 0);
+ if (!_slang_alloc_var(emitInfo->vt, n->Store)) {
+ slang_info_log_error(emitInfo->log,
+ "Ran out of registers, too many variables");
+ return NULL;
+ }
/*
printf("IR_VAR_DECL %s %d store %p\n",
(char*) n->Var->a_name, n->Store->Index, (void*) n->Store);
n->Store->Size,
&n->Store->Swizzle);
if (n->Store->Index < 0) {
- RETURN_ERROR("Ran out of space for constants.", 0);
+ slang_info_log_error(emitInfo->log, "Ran out of space for constants");
+ return NULL;
}
return NULL;
extern GLboolean
_slang_emit_code(slang_ir_node *n, slang_var_table *vartable,
- struct gl_program *prog, GLboolean withEnd);
+ struct gl_program *prog, GLboolean withEnd,
+ slang_info_log *log);
#endif /* SLANG_EMIT_H */
/*
* Mesa 3-D graphics library
- * Version: 6.6
+ * Version: 6.5.3
*
- * Copyright (C) 2005-2006 Brian Paul All Rights Reserved.
+ * Copyright (C) 2005-2007 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-#if !defined SLANG_PREPROCESS_H
+#ifndef SLANG_PREPROCESS_H
#define SLANG_PREPROCESS_H
#include "slang_compile.h"
+#include "slang_log.h"
-#if defined __cplusplus
-extern "C" {
-#endif
-GLboolean
+extern GLboolean
_slang_preprocess_version (const char *, GLuint *, GLuint *, slang_info_log *);
-GLboolean
-_slang_preprocess_directives (slang_string *output, const char *input, slang_info_log *);
+extern GLboolean
+_slang_preprocess_directives (slang_string *output, const char *input,
+ slang_info_log *);
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+#endif /* SLANG_PREPROCESS_H */
GLboolean
_slang_adapt_call(slang_operation *callOper, const slang_function *fun,
const slang_name_space * space,
- slang_atom_pool * atoms)
+ slang_atom_pool * atoms, slang_info_log *log)
{
const GLboolean haveRetValue = _slang_function_has_return_value(fun);
const int numParams = fun->param_count - haveRetValue;
if (!slang_typeinfo_construct(&argType))
return GL_FALSE;
if (!_slang_typeof_operation_(&callOper->children[i], space,
- &argType, atoms)) {
+ &argType, atoms, log)) {
slang_typeinfo_destruct(&argType);
return GL_FALSE;
}
if (!slang_typeinfo_construct(&argType))
return GL_FALSE;
if (!_slang_typeof_operation_(&callOper->children[i], space,
- &argType, atoms)) {
+ &argType, atoms, log)) {
slang_typeinfo_destruct(&argType);
return GL_FALSE;
}
extern GLboolean
_slang_adapt_call(slang_operation *callOper, const slang_function *fun,
const slang_name_space * space,
- slang_atom_pool * atoms);
-
+ slang_atom_pool * atoms, slang_info_log *log);
#endif /* SLANG_SIMPLIFY_H */
#include "imports.h"
#include "slang_typeinfo.h"
#include "slang_compile.h"
-#include "slang_error.h"
+#include "slang_log.h"
#include "prog_instruction.h"
GLuint num_params,
const slang_name_space * space,
slang_type_specifier * spec,
- slang_atom_pool * atoms)
+ slang_atom_pool * atoms,
+ slang_info_log *log)
{
slang_atom atom;
GLboolean exists;
atom = slang_atom_pool_atom(atoms, name);
if (!_slang_typeof_function(atom, params, num_params, space, spec,
- &exists, atoms))
+ &exists, atoms, log))
return GL_FALSE;
return exists;
}
const slang_operation * op,
slang_typeinfo * ti)
{
- return _slang_typeof_operation_(op, &A->space, ti, A->atoms);
+ return _slang_typeof_operation_(op, &A->space, ti, A->atoms, A->log);
}
_slang_typeof_operation_(const slang_operation * op,
const slang_name_space * space,
slang_typeinfo * ti,
- slang_atom_pool * atoms)
+ slang_atom_pool * atoms,
+ slang_info_log *log)
{
ti->can_be_referenced = GL_FALSE;
ti->is_swizzled = GL_FALSE;
case SLANG_OPER_DIVASSIGN:
case SLANG_OPER_PREINCREMENT:
case SLANG_OPER_PREDECREMENT:
- if (!_slang_typeof_operation_(op->children, space, ti, atoms))
+ if (!_slang_typeof_operation_(op->children, space, ti, atoms, log))
return GL_FALSE;
break;
case SLANG_OPER_LITERAL_BOOL:
{
slang_variable *var;
var = _slang_locate_variable(op->locals, op->a_id, GL_TRUE);
- if (var == NULL)
- RETURN_ERROR2("undefined variable", (char *) op->a_id, 0);
- if (!slang_type_specifier_copy(&ti->spec, &var->type.specifier))
- RETURN_OUT_OF_MEMORY();
+ if (!var) {
+ slang_info_log_error(log, "undefined variable '%s'",
+ (char *) op->a_id);
+ return GL_FALSE;
+ }
+ if (!slang_type_specifier_copy(&ti->spec, &var->type.specifier)) {
+ slang_info_log_memory(log);
+ return GL_FALSE;
+ }
ti->can_be_referenced = GL_TRUE;
ti->array_len = var->array_len;
}
break;
case SLANG_OPER_SEQUENCE:
/* TODO: check [0] and [1] if they match */
- if (!_slang_typeof_operation_(&op->children[1], space, ti, atoms))
- RETURN_NIL();
+ if (!_slang_typeof_operation_(&op->children[1], space, ti, atoms, log)) {
+ return GL_FALSE;
+ }
ti->can_be_referenced = GL_FALSE;
ti->is_swizzled = GL_FALSE;
break;
/*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();
+ if (!_slang_typeof_operation_(&op->children[1], space, ti, atoms, log)) {
+ return GL_FALSE;
+ }
ti->can_be_referenced = GL_FALSE;
ti->is_swizzled = GL_FALSE;
break;
/*case SLANG_OPER_RSHIFT: */
case SLANG_OPER_ADD:
if (!typeof_existing_function("+", op->children, 2, space,
- &ti->spec, atoms))
- RETURN_NIL();
+ &ti->spec, atoms, log))
+ return GL_FALSE;
break;
case SLANG_OPER_SUBTRACT:
if (!typeof_existing_function("-", op->children, 2, space,
- &ti->spec, atoms))
- RETURN_NIL();
+ &ti->spec, atoms, log))
+ return GL_FALSE;
break;
case SLANG_OPER_MULTIPLY:
if (!typeof_existing_function("*", op->children, 2, space,
- &ti->spec, atoms))
- RETURN_NIL();
+ &ti->spec, atoms, log))
+ return GL_FALSE;
break;
case SLANG_OPER_DIVIDE:
if (!typeof_existing_function("/", op->children, 2, space,
- &ti->spec, atoms))
- RETURN_NIL();
+ &ti->spec, atoms, log))
+ return GL_FALSE;
break;
/*case SLANG_OPER_MODULUS: */
case SLANG_OPER_PLUS:
- if (!_slang_typeof_operation_(op->children, space, ti, atoms))
- RETURN_NIL();
+ if (!_slang_typeof_operation_(op->children, space, ti, atoms, log))
+ return GL_FALSE;
ti->can_be_referenced = GL_FALSE;
ti->is_swizzled = GL_FALSE;
break;
case SLANG_OPER_MINUS:
if (!typeof_existing_function("-", op->children, 1, space,
- &ti->spec, atoms))
- RETURN_NIL();
+ &ti->spec, atoms, log))
+ return GL_FALSE;
break;
/*case SLANG_OPER_COMPLEMENT: */
case SLANG_OPER_SUBSCRIPT:
slang_typeinfo _ti;
if (!slang_typeinfo_construct(&_ti))
- RETURN_NIL();
- if (!_slang_typeof_operation_(op->children, space, &_ti, atoms)) {
+ return GL_FALSE;
+ if (!_slang_typeof_operation_(op->children, space, &_ti, atoms, log)) {
slang_typeinfo_destruct(&_ti);
- RETURN_NIL();
+ return GL_FALSE;
}
ti->can_be_referenced = _ti.can_be_referenced;
if (_ti.spec.type == SLANG_SPEC_ARRAY) {
if (!slang_type_specifier_copy(&ti->spec, _ti.spec._array)) {
slang_typeinfo_destruct(&_ti);
- RETURN_NIL();
+ return GL_FALSE;
}
}
else {
if (!_slang_type_is_vector(_ti.spec.type)
&& !_slang_type_is_matrix(_ti.spec.type)) {
slang_typeinfo_destruct(&_ti);
- RETURN_ERROR("cannot index a non-array type", 0);
+ slang_info_log_error(log, "cannot index a non-array type");
+ return GL_FALSE;
}
ti->spec.type = _slang_type_base(_ti.spec.type);
}
GLboolean exists;
if (!_slang_typeof_function(op->a_id, op->children, op->num_children,
- space, &ti->spec, &exists, atoms))
- RETURN_NIL();
+ space, &ti->spec, &exists, atoms, log))
+ return GL_FALSE;
if (!exists) {
slang_struct *s =
slang_struct_scope_find(space->structs, op->a_id, GL_TRUE);
ti->spec._struct =
(slang_struct *) slang_alloc_malloc(sizeof(slang_struct));
if (ti->spec._struct == NULL)
- RETURN_NIL();
+ return GL_FALSE;
if (!slang_struct_construct(ti->spec._struct)) {
slang_alloc_free(ti->spec._struct);
ti->spec._struct = NULL;
- RETURN_NIL();
+ return GL_FALSE;
}
if (!slang_struct_copy(ti->spec._struct, s))
- RETURN_NIL();
+ return GL_FALSE;
}
else {
const char *name;
name = slang_atom_pool_id(atoms, op->a_id);
type = slang_type_specifier_type_from_string(name);
- if (type == SLANG_SPEC_VOID)
- RETURN_ERROR2("function not found", name, 0);
+ if (type == SLANG_SPEC_VOID) {
+ slang_info_log_error(log, "undefined function '%s'", name);
+ return GL_FALSE;
+ }
ti->spec.type = type;
}
}
slang_typeinfo _ti;
if (!slang_typeinfo_construct(&_ti))
- RETURN_NIL();
- if (!_slang_typeof_operation_(op->children, space, &_ti, atoms)) {
+ return GL_FALSE;
+ if (!_slang_typeof_operation_(op->children, space, &_ti, atoms, log)) {
slang_typeinfo_destruct(&_ti);
- RETURN_NIL();
+ return GL_FALSE;
}
if (_ti.spec.type == SLANG_SPEC_STRUCT) {
slang_variable *field;
GL_FALSE);
if (field == NULL) {
slang_typeinfo_destruct(&_ti);
- RETURN_NIL();
+ return GL_FALSE;
}
if (!slang_type_specifier_copy(&ti->spec, &field->type.specifier)) {
slang_typeinfo_destruct(&_ti);
- RETURN_NIL();
+ return GL_FALSE;
}
ti->can_be_referenced = _ti.can_be_referenced;
}
slang_type_specifier_type base;
/* determine the swizzle of the field expression */
-#if 000
+#if 000 /*XXX re-enable? */
if (!_slang_type_is_vector(_ti.spec.type)) {
slang_typeinfo_destruct(&_ti);
- RETURN_ERROR("Can't swizzle scalar expression", 0);
+ slang_info_log_error(log, "Can't swizzle scalar expression");
+ return GL_FALSE;
}
#endif
rows = _slang_type_dim(_ti.spec.type);
swizzle = slang_atom_pool_id(atoms, op->a_id);
if (!_slang_is_swizzle(swizzle, rows, &ti->swz)) {
slang_typeinfo_destruct(&_ti);
- RETURN_ERROR("Bad swizzle", 0);
+ slang_info_log_error(log, "bad swizzle '%s'", swizzle);
+ return GL_FALSE;
}
ti->is_swizzled = GL_TRUE;
ti->can_be_referenced = _ti.can_be_referenced
break;
case SLANG_OPER_POSTINCREMENT:
case SLANG_OPER_POSTDECREMENT:
- if (!_slang_typeof_operation_(op->children, space, ti, atoms))
- RETURN_NIL();
+ if (!_slang_typeof_operation_(op->children, space, ti, atoms, log))
+ return GL_FALSE;
ti->can_be_referenced = GL_FALSE;
ti->is_swizzled = GL_FALSE;
break;
default:
- RETURN_NIL();
+ return GL_FALSE;
}
return GL_TRUE;
slang_function *
_slang_locate_function(const slang_function_scope * funcs, slang_atom a_name,
const slang_operation * args, GLuint num_args,
- const slang_name_space * space, slang_atom_pool * atoms)
+ const slang_name_space * space, slang_atom_pool * atoms,
+ slang_info_log *log)
{
GLuint i;
if (!slang_typeinfo_construct(&ti))
return NULL;
- if (!_slang_typeof_operation_(&args[j], space, &ti, atoms)) {
+ if (!_slang_typeof_operation_(&args[j], space, &ti, atoms, log)) {
slang_typeinfo_destruct(&ti);
return NULL;
}
}
if (funcs->outer_scope != NULL)
return _slang_locate_function(funcs->outer_scope, a_name, args,
- num_args, space, atoms);
+ num_args, space, atoms, log);
return NULL;
}
GLuint num_params,
const slang_name_space * space,
slang_type_specifier * spec, GLboolean * exists,
- slang_atom_pool * atoms)
+ slang_atom_pool *atoms, slang_info_log *log)
{
slang_function *fun = _slang_locate_function(space->funcs, a_name, params,
- num_params, space, atoms);
+ num_params, space, atoms, log);
*exists = fun != NULL;
if (!fun)
return GL_TRUE; /* yes, not false */
#include "imports.h"
#include "mtypes.h"
+#include "slang_log.h"
#include "slang_utility.h"
#include "slang_vartable.h"
slang_name_space space;
struct gl_program *program;
slang_var_table *vartable;
+ slang_info_log *log;
struct slang_function_ *CurFunction;
struct slang_ir_node_ *CurLoop;
} slang_assemble_ctx;
slang_atom name, const struct slang_operation_ *params,
GLuint num_params,
const slang_name_space *space,
- slang_atom_pool *);
+ slang_atom_pool *atoms, slang_info_log *log);
extern GLboolean
extern GLboolean
_slang_typeof_operation_(const struct slang_operation_ *,
const slang_name_space *,
- slang_typeinfo *, slang_atom_pool *);
+ slang_typeinfo *, slang_atom_pool *,
+ slang_info_log *log);
/**
* Retrieves type of a function prototype, if one exists.
const struct slang_operation_ *params,
GLuint num_params, const slang_name_space *,
slang_type_specifier *spec, GLboolean *exists,
- slang_atom_pool *);
+ slang_atom_pool *, slang_info_log *log);
extern GLboolean
_slang_type_is_matrix(slang_type_specifier_type);
shader/slang/slang_compile_struct.c \
shader/slang/slang_compile_variable.c \
shader/slang/slang_emit.c \
- shader/slang/slang_error.c \
shader/slang/slang_label.c \
shader/slang/slang_library_noise.c \
shader/slang/slang_link.c \
+ shader/slang/slang_log.c \
shader/slang/slang_preprocess.c \
shader/slang/slang_print.c \
shader/slang/slang_simplify.c \
projects / profile / ivi / mesa.git / commitdiff