From d1b40400d64a8ab7f4dc64410e165e7c49d30a28 Mon Sep 17 00:00:00 2001 From: Michal Krol Date: Tue, 16 May 2006 09:53:42 +0000 Subject: Cleanup code. --- src/mesa/shader/slang/slang_compile.c | 438 ++++++++++++++-------------------- src/mesa/shader/slang/slang_compile.h | 56 +++-- 2 files changed, 210 insertions(+), 284 deletions(-) (limited to 'src/mesa/shader') diff --git a/src/mesa/shader/slang/slang_compile.c b/src/mesa/shader/slang/slang_compile.c index d25f75dab9..28c4120111 100644 --- a/src/mesa/shader/slang/slang_compile.c +++ b/src/mesa/shader/slang/slang_compile.c @@ -52,120 +52,65 @@ static GLuint slang_var_pool_alloc (slang_var_pool *pool, unsigned int size) return addr; } -/* slang_translation_unit */ +/* + * slang_code_unit + */ -int slang_translation_unit_construct (slang_translation_unit *unit) +GLvoid +_slang_code_unit_ctr (slang_code_unit *self, struct slang_code_object_ *object) { - unit->assembly = (slang_assembly_file *) slang_alloc_malloc (sizeof (slang_assembly_file)); - if (unit->assembly == NULL) - return 0; - if (!slang_assembly_file_construct (unit->assembly)) - { - slang_alloc_free (unit->assembly); - return 0; - } - unit->global_pool = (slang_var_pool *) slang_alloc_malloc (sizeof (slang_var_pool)); - if (unit->global_pool == NULL) - { - slang_assembly_file_destruct (unit->assembly); - slang_alloc_free (unit->assembly); - return 0; - } - unit->global_pool->next_addr = 0; - unit->machine = (slang_machine *) slang_alloc_malloc (sizeof (slang_machine)); - if (unit->machine == NULL) - { - slang_alloc_free (unit->global_pool); - slang_assembly_file_destruct (unit->assembly); - slang_alloc_free (unit->assembly); - return 0; - } - slang_machine_ctr (unit->machine); - unit->atom_pool = (slang_atom_pool *) slang_alloc_malloc (sizeof (slang_atom_pool)); - if (unit->atom_pool == NULL) - { - slang_alloc_free (unit->machine); - slang_alloc_free (unit->global_pool); - slang_assembly_file_destruct (unit->assembly); - slang_alloc_free (unit->assembly); - return 0; - } - slang_atom_pool_construct (unit->atom_pool); - if (!slang_translation_unit_construct2 (unit, unit->assembly, unit->global_pool, unit->machine, - unit->atom_pool)) - { - slang_alloc_free (unit->atom_pool); - slang_alloc_free (unit->machine); - slang_alloc_free (unit->global_pool); - slang_assembly_file_destruct (unit->assembly); - slang_alloc_free (unit->assembly); - return 0; - } - unit->free_assembly = 1; - unit->free_global_pool = 1; - unit->free_machine = 1; - unit->free_atom_pool = 1; - return 1; + _slang_variable_scope_ctr (&self->vars); + _slang_function_scope_ctr (&self->funs); + _slang_struct_scope_ctr (&self->structs); + self->object = object; } -int slang_translation_unit_construct2 (slang_translation_unit *unit, slang_assembly_file *file, - slang_var_pool *pool, struct slang_machine_ *mach, slang_atom_pool *atoms) +GLvoid +_slang_code_unit_dtr (slang_code_unit *self) { - if (!slang_variable_scope_construct (&unit->globals)) - return 0; - if (!slang_function_scope_construct (&unit->functions)) - { - slang_variable_scope_destruct (&unit->globals); - return 0; - } - if (!slang_struct_scope_construct (&unit->structs)) - { - slang_variable_scope_destruct (&unit->globals); - slang_function_scope_destruct (&unit->functions); - return 0; - } - unit->assembly = file; - unit->free_assembly = 0; - unit->global_pool = pool; - unit->free_global_pool = 0; - unit->machine = mach; - unit->free_machine = 0; - unit->atom_pool = atoms; - unit->free_atom_pool = 0; - slang_export_data_table_ctr (&unit->exp_data); - slang_export_code_table_ctr (&unit->exp_code); - return 1; + slang_variable_scope_destruct (&self->vars); + slang_function_scope_destruct (&self->funs); + slang_struct_scope_destruct (&self->structs); } -void slang_translation_unit_destruct (slang_translation_unit *unit) +/* + * slang_code_object + */ + +GLvoid +_slang_code_object_ctr (slang_code_object *self) { - slang_variable_scope_destruct (&unit->globals); - slang_function_scope_destruct (&unit->functions); - slang_struct_scope_destruct (&unit->structs); - if (unit->free_assembly) - { - slang_assembly_file_destruct (unit->assembly); - slang_alloc_free (unit->assembly); - } - if (unit->free_global_pool) - slang_alloc_free (unit->global_pool); - if (unit->free_machine) - { - slang_machine_dtr (unit->machine); - slang_alloc_free (unit->machine); - } - if (unit->free_atom_pool) - { - slang_atom_pool_destruct (unit->atom_pool); - slang_alloc_free (unit->atom_pool); - } - slang_export_data_table_dtr (&unit->exp_data); - slang_export_code_table_ctr (&unit->exp_code); + _slang_code_unit_ctr (&self->builtin[0], self); + _slang_code_unit_ctr (&self->builtin[1], self); + _slang_code_unit_ctr (&self->builtin[2], self); + _slang_code_unit_ctr (&self->unit, self); + _slang_assembly_file_ctr (&self->assembly); + 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 +_slang_code_object_dtr (slang_code_object *self) +{ + _slang_code_unit_dtr (&self->builtin[0]); + _slang_code_unit_dtr (&self->builtin[1]); + _slang_code_unit_dtr (&self->builtin[2]); + _slang_code_unit_dtr (&self->unit); + slang_assembly_file_destruct (&self->assembly); + 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"; +static char *out_of_memory = "Error: Out of memory.\n"; void slang_info_log_construct (slang_info_log *log) { @@ -181,32 +126,44 @@ void slang_info_log_destruct (slang_info_log *log) static int slang_info_log_message (slang_info_log *log, const char *prefix, const char *msg) { - unsigned int new_size; + GLuint size; if (log->dont_free_text) return 0; - new_size = slang_string_length (prefix) + 3 + slang_string_length (msg); - if (log->text != NULL) - { - unsigned int text_len = slang_string_length (log->text); - - log->text = (char *) slang_alloc_realloc (log->text, text_len + 1, new_size + text_len + 1); - } - else - { - log->text = (char *) slang_alloc_malloc (new_size + 1); - if (log->text != NULL) - log->text[0] = '\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; - slang_string_concat (log->text, prefix); - slang_string_concat (log->text, ": "); + 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; @@ -214,10 +171,10 @@ int slang_info_log_error (slang_info_log *log, const char *msg, ...) va_start (va, msg); _mesa_vsprintf (buf, msg, va); - if (slang_info_log_message (log, "error", buf)) + va_end (va); + if (slang_info_log_message (log, "Error", buf)) return 1; slang_info_log_memory (log); - va_end (va); return 0; } @@ -228,16 +185,16 @@ int slang_info_log_warning (slang_info_log *log, const char *msg, ...) va_start (va, msg); _mesa_vsprintf (buf, msg, va); - if (slang_info_log_message (log, "warning", buf)) + va_end (va); + if (slang_info_log_message (log, "Warning", buf)) return 1; slang_info_log_memory (log); - va_end (va); return 0; } void slang_info_log_memory (slang_info_log *log) { - if (!slang_info_log_message (log, "error", "out of memory")) + if (!slang_info_log_message (log, "Error", "Out of memory.")) { log->dont_free_text = 1; log->text = out_of_memory; @@ -302,7 +259,7 @@ static int parse_number (slang_parse_ctx *C, int *number) } C->I++; if (*number > 65535) - slang_info_log_warning (C->L, "%d: literal integer overflow", *number); + slang_info_log_warning (C->L, "%d: literal integer overflow.", *number); return 1; } @@ -344,7 +301,7 @@ static int check_revision (slang_parse_ctx *C) { if (*C->I != REVISION) { - slang_info_log_error (C->L, "internal compiler error"); + slang_info_log_error (C->L, "Internal compiler error."); return 0; } C->I++; @@ -486,7 +443,7 @@ static int parse_struct (slang_parse_ctx *C, slang_output_ctx *O, slang_struct * 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); + slang_info_log_error (C->L, "%s: duplicate type name.", name); return 0; } @@ -700,7 +657,7 @@ static int parse_type_specifier (slang_parse_ctx *C, slang_output_ctx *O, slang_ stru = slang_struct_scope_find (O->structs, a_name, 1); if (stru == NULL) { - slang_info_log_error (C->L, "%s: undeclared type name", + slang_info_log_error (C->L, "%s: undeclared type name.", slang_atom_pool_id (C->atoms, a_name)); return 0; } @@ -1220,7 +1177,7 @@ static int parse_expression (slang_parse_ctx *C, slang_output_ctx *O, slang_oper 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); + slang_info_log_error (C->L, "%s: undeclared function name.", id); return 0; } } @@ -1275,7 +1232,7 @@ static int parse_parameter_declaration (slang_parse_ctx *C, slang_output_ctx *O, case PARAM_QUALIFIER_IN: if (param->type.qualifier != slang_qual_const && param->type.qualifier != slang_qual_none) { - slang_info_log_error (C->L, "invalid type qualifier"); + slang_info_log_error (C->L, "Invalid type qualifier."); return 0; } break; @@ -1284,7 +1241,7 @@ static int parse_parameter_declaration (slang_parse_ctx *C, slang_output_ctx *O, param->type.qualifier = slang_qual_out; else { - slang_info_log_error (C->L, "invalid type qualifier"); + slang_info_log_error (C->L, "Invalid type qualifier."); return 0; } break; @@ -1293,7 +1250,7 @@ static int parse_parameter_declaration (slang_parse_ctx *C, slang_output_ctx *O, param->type.qualifier = slang_qual_inout; else { - slang_info_log_error (C->L, "invalid type qualifier"); + slang_info_log_error (C->L, "Invalid type qualifier."); return 0; } break; @@ -1815,7 +1772,7 @@ static int parse_function (slang_parse_ctx *C, slang_output_ctx *O, int definiti { if (found_func->body != NULL) { - slang_info_log_error (C->L, "%s: function already has a body", + slang_info_log_error (C->L, "%s: function already has a body.", slang_atom_pool_id (C->atoms, parsed_func.header.a_name)); slang_function_destruct (&parsed_func); return 0; @@ -1885,17 +1842,18 @@ static int parse_declaration (slang_parse_ctx *C, slang_output_ctx *O) #define EXTERNAL_FUNCTION_DEFINITION 1 #define EXTERNAL_DECLARATION 2 -static int parse_translation_unit (slang_parse_ctx *C, slang_translation_unit *unit) +static GLboolean +parse_code_unit (slang_parse_ctx *C, slang_code_unit *unit) { slang_output_ctx o; - /* setup output context */ - o.funs = &unit->functions; - o.structs = &unit->structs; - o.vars = &unit->globals; - o.assembly = unit->assembly; - o.global_pool = unit->global_pool; - o.machine = unit->machine; + /* setup output context */ + 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; /* parse individual functions and declarations */ while (*C->I != EXTERNAL_NULL) @@ -1927,60 +1885,44 @@ static int parse_translation_unit (slang_parse_ctx *C, slang_translation_unit *u #define BUILTIN_TARGET 2 #define BUILTIN_TOTAL 3 -static int compile_binary (const byte *prod, slang_translation_unit *unit, slang_unit_type type, - slang_info_log *log, slang_translation_unit *builtins, slang_assembly_file *file, - slang_var_pool *pool, slang_machine *mach, slang_translation_unit *downlink, - slang_atom_pool *atoms) +static GLboolean +compile_binary (const byte *prod, slang_code_unit *unit, slang_unit_type type, + slang_info_log *infolog, slang_code_unit *builtin, slang_code_unit *downlink) { - slang_parse_ctx C; + slang_parse_ctx C; - /* create translation unit object */ - if (file != NULL) - { - if (!slang_translation_unit_construct2 (unit, file, pool, mach, atoms)) - return 0; - unit->type = type; - } + unit->type = type; - /* set-up parse context */ - C.I = prod; - C.L = log; - C.parsing_builtin = builtins == NULL; - C.global_scope = 1; - C.atoms = unit->atom_pool; - - if (!check_revision (&C)) - { - slang_translation_unit_destruct (unit); - return 0; - } + /* setup parse context */ + C.I = prod; + C.L = infolog; + C.parsing_builtin = (builtin == NULL); + C.global_scope = GL_TRUE; + C.atoms = &unit->object->atompool; - if (downlink != NULL) - { - unit->functions.outer_scope = &downlink->functions; - unit->globals.outer_scope = &downlink->globals; - unit->structs.outer_scope = &downlink->structs; - } + if (!check_revision (&C)) + return GL_FALSE; - /* parse translation unit */ - if (!parse_translation_unit (&C, unit)) - { - slang_translation_unit_destruct (unit); - return 0; - } + if (downlink != NULL) { + unit->vars.outer_scope = &downlink->vars; + unit->funs.outer_scope = &downlink->funs; + unit->structs.outer_scope = &downlink->structs; + } - return 1; + /* parse translation unit */ + return parse_code_unit (&C, unit); } -static int compile_with_grammar (grammar id, const char *source, slang_translation_unit *unit, - slang_unit_type type, slang_info_log *log, slang_translation_unit *builtins) +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) { byte *prod; - unsigned int size, start, version; + GLuint size, start, version; /* retrieve version */ - if (!_slang_preprocess_version (source, &version, &start, log)) - return 0; + if (!_slang_preprocess_version (source, &version, &start, infolog)) + return GL_FALSE; /* check the syntax and generate its binary representation */ if (!grammar_fast_check (id, (const byte *) source + start, &prod, &size, 65536)) @@ -1988,20 +1930,18 @@ static int compile_with_grammar (grammar id, const char *source, slang_translati char buf[1024]; unsigned int pos; grammar_get_last_error ( (unsigned char*) buf, 1024, (int*) &pos); - slang_info_log_error (log, buf); - return 0; + slang_info_log_error (infolog, buf); + return GL_FALSE; } /* syntax is okay - translate it to internal representation */ - if (!compile_binary (prod, unit, type, log, builtins, NULL, NULL, NULL, - &builtins[BUILTIN_TARGET], NULL)) - { - grammar_alloc_free (prod); - return 0; - } + if (!compile_binary (prod, unit, type, infolog, builtin, &builtin[BUILTIN_TARGET])) { + grammar_alloc_free (prod); + return GL_FALSE; + } - grammar_alloc_free (prod); - return 1; + grammar_alloc_free (prod); + return GL_TRUE; } static const char *slang_shader_syn = @@ -2024,12 +1964,13 @@ static const byte slang_vertex_builtin_gc[] = { #include "library/slang_vertex_builtin_gc.h" }; -static int compile (grammar *id, slang_translation_unit *builtin_units, int *compiled, - const char *source, slang_translation_unit *unit, slang_unit_type type, slang_info_log *log) +static GLboolean +compile_object (grammar *id, const char *source, slang_code_object *object, slang_unit_type type, + slang_info_log *infolog) { - slang_translation_unit *builtins = NULL; + slang_code_unit *builtins = NULL; - /* load slang grammar */ + /* load GLSL grammar */ *id = grammar_load_from_text ((const byte *) (slang_shader_syn)); if (*id == 0) { @@ -2037,8 +1978,8 @@ static int compile (grammar *id, slang_translation_unit *builtin_units, int *com int pos; grammar_get_last_error (buf, 1024, &pos); - slang_info_log_error (log, (const char *) (buf)); - return 0; + slang_info_log_error (infolog, (const char *) (buf)); + return GL_FALSE; } /* set shader type - the syntax is slightly different for different shaders */ @@ -2054,95 +1995,68 @@ static int compile (grammar *id, slang_translation_unit *builtin_units, int *com if (type == slang_unit_fragment_shader || type == slang_unit_vertex_shader) { /* compile core functionality first */ - if (!compile_binary (slang_core_gc, &builtin_units[BUILTIN_CORE], - slang_unit_fragment_builtin, log, NULL, unit->assembly, unit->global_pool, - unit->machine, NULL, unit->atom_pool)) - return 0; - compiled[BUILTIN_CORE] = 1; + if (!compile_binary (slang_core_gc, &object->builtin[BUILTIN_CORE], + slang_unit_fragment_builtin, infolog, NULL, NULL)) + return GL_FALSE; /* compile common functions and variables, link to core */ - if (!compile_binary (slang_common_builtin_gc, &builtin_units[BUILTIN_COMMON], - slang_unit_fragment_builtin, log, NULL, unit->assembly, unit->global_pool, - unit->machine, &builtin_units[BUILTIN_CORE], unit->atom_pool)) - return 0; - compiled[BUILTIN_COMMON] = 1; + if (!compile_binary (slang_common_builtin_gc, &object->builtin[BUILTIN_COMMON], + slang_unit_fragment_builtin, infolog, NULL, + &object->builtin[BUILTIN_CORE])) + return GL_FALSE; /* compile target-specific functions and variables, link to common */ if (type == slang_unit_fragment_shader) { - if (!compile_binary (slang_fragment_builtin_gc, &builtin_units[BUILTIN_TARGET], - slang_unit_fragment_builtin, log, NULL, unit->assembly, unit->global_pool, - unit->machine, &builtin_units[BUILTIN_COMMON], unit->atom_pool)) - return 0; + if (!compile_binary (slang_fragment_builtin_gc, &object->builtin[BUILTIN_TARGET], + slang_unit_fragment_builtin, infolog, NULL, + &object->builtin[BUILTIN_COMMON])) + return GL_FALSE; } else if (type == slang_unit_vertex_shader) { - if (!compile_binary (slang_vertex_builtin_gc, &builtin_units[BUILTIN_TARGET], - slang_unit_vertex_builtin, log, NULL, unit->assembly, unit->global_pool, - unit->machine, &builtin_units[BUILTIN_COMMON], unit->atom_pool)) - return 0; + if (!compile_binary (slang_vertex_builtin_gc, &object->builtin[BUILTIN_TARGET], + slang_unit_vertex_builtin, infolog, NULL, + &object->builtin[BUILTIN_COMMON])) + return GL_FALSE; } - compiled[BUILTIN_TARGET] = 1; /* disable language extensions */ grammar_set_reg8 (*id, (const byte *) "parsing_builtin", 0); - builtins = builtin_units; + builtins = object->builtin; } /* compile the actual shader - pass-in built-in library for external shader */ - if (!compile_with_grammar (*id, source, unit, type, log, builtins)) - return 0; - - return 1; + return compile_with_grammar (*id, source, &object->unit, type, infolog, builtins); } -int _slang_compile (const char *source, slang_translation_unit *unit, slang_unit_type type, - slang_info_log *log) +GLboolean +_slang_compile (const char *source, slang_code_object *object, slang_unit_type type, + slang_info_log *infolog) { - int success; - grammar id = 0; -/* slang_translation_unit builtin_units[BUILTIN_TOTAL];*/ - slang_translation_unit *builtin_units; - int compiled[BUILTIN_TOTAL] = { 0 }; - - /* create the main unit first */ - if (!slang_translation_unit_construct (unit)) - return 0; - unit->type = type; - - builtin_units = (slang_translation_unit *) slang_alloc_malloc (BUILTIN_TOTAL * sizeof (slang_translation_unit)); - success = compile (&id, builtin_units, compiled, source, unit, type, log); - - /* destroy built-in library */ - /* XXX: free with the unit */ - /*if (type == slang_unit_fragment_shader || type == slang_unit_vertex_shader) - { - int i; - - for (i = 0; i < BUILTIN_TOTAL; i++) - if (compiled[i] != 0) - slang_translation_unit_destruct (&builtin_units[i]); - }*/ - if (id != 0) - grammar_destroy (id); + GLboolean success; + grammar id = 0; - if (!success) - return 0; + _slang_code_object_dtr (object); + _slang_code_object_ctr (object); - unit->exp_data.atoms = unit->atom_pool; - if (!_slang_build_export_data_table (&unit->exp_data, &unit->globals)) - return 0; + success = compile_object (&id, source, object, type, infolog); + if (id != 0) + grammar_destroy (id); + if (!success) + return GL_FALSE; - unit->exp_code.atoms = unit->atom_pool; - if (!_slang_build_export_code_table (&unit->exp_code, &unit->functions, unit)) - return 0; + 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 defined(USE_X86_ASM) || defined(SLANG_X86) - /* XXX: lookup the @main label */ - if (!_slang_x86_codegen (unit->machine, unit->assembly, unit->exp_code.entries[0].address)) - return 0; + /* XXX: lookup the @main label */ + if (!_slang_x86_codegen (&object->machine, &object->assembly, object->expcode.entries[0].address)) + return GL_FALSE; #endif - return 1; + return GL_TRUE; } diff --git a/src/mesa/shader/slang/slang_compile.h b/src/mesa/shader/slang/slang_compile.h index a1957bc3cf..89c3dcfdba 100644 --- a/src/mesa/shader/slang/slang_compile.h +++ b/src/mesa/shader/slang/slang_compile.h @@ -49,28 +49,38 @@ typedef struct slang_var_pool_ GLuint next_addr; } slang_var_pool; -typedef struct slang_translation_unit_ +typedef struct slang_code_unit_ { - slang_variable_scope globals; - slang_function_scope functions; - slang_struct_scope structs; - slang_unit_type type; - slang_assembly_file *assembly; - int free_assembly; - slang_var_pool *global_pool; - int free_global_pool; - slang_machine *machine; - int free_machine; - slang_atom_pool *atom_pool; - int free_atom_pool; - slang_export_data_table exp_data; - slang_export_code_table exp_code; -} slang_translation_unit; - -int slang_translation_unit_construct (slang_translation_unit *); -int slang_translation_unit_construct2 (slang_translation_unit *, slang_assembly_file *, - slang_var_pool *, slang_machine *, slang_atom_pool *); -void slang_translation_unit_destruct (slang_translation_unit *); + slang_variable_scope vars; + slang_function_scope funs; + slang_struct_scope structs; + slang_unit_type type; + struct slang_code_object_ *object; +} slang_code_unit; + +extern GLvoid +_slang_code_unit_ctr (slang_code_unit *, struct slang_code_object_ *); + +extern GLvoid +_slang_code_unit_dtr (slang_code_unit *); + +typedef struct slang_code_object_ +{ + slang_code_unit builtin[3]; + slang_code_unit unit; + slang_assembly_file assembly; + slang_machine machine; + slang_var_pool varpool; + slang_atom_pool atompool; + slang_export_data_table expdata; + slang_export_code_table expcode; +} slang_code_object; + +extern GLvoid +_slang_code_object_ctr (slang_code_object *); + +extern GLvoid +_slang_code_object_dtr (slang_code_object *); typedef struct slang_info_log_ { @@ -80,11 +90,13 @@ typedef struct 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 *); -int _slang_compile (const char *, slang_translation_unit *, slang_unit_type type, slang_info_log *); +extern GLboolean +_slang_compile (const char *, slang_code_object *, slang_unit_type, slang_info_log *); #ifdef __cplusplus } -- cgit v1.2.3