static GLboolean slang_uniform_bindings_add (slang_uniform_bindings *self, slang_export_data_quant *q, const char *name, GLuint index, GLuint address) { const GLuint n = self->count; GLuint i; for (i = 0; i < n; i++) if (slang_string_compare (self->table[i].name, name) == 0) { self->table[i].address[index] = address; return GL_TRUE; } self->table = (slang_uniform_binding *) slang_alloc_realloc (self->table, n * sizeof (slang_uniform_binding), (n + 1) * sizeof (slang_uniform_binding)); if (self->table == NULL) return GL_FALSE; self->table[n].quant = q; self->table[n].name = slang_string_duplicate (name); for (i = 0; i < SLANG_SHADER_MAX; i++) self->table[n].address[i] = ~0; self->table[n].address[index] = address; if (self->table[n].name == NULL) return GL_FALSE; self->count++; return GL_TRUE; }
static GLboolean call_asm_instruction (slang_assemble_ctx *A, slang_atom a_name) { const char *id; GLuint i; id = slang_atom_pool_id (A->atoms, a_name); for (i = 0; inst[i].name != NULL; i++) if (slang_string_compare (id, inst[i].name) == 0) break; if (inst[i].name == NULL) return GL_FALSE; if (!PLAB2 (A->file, inst[i].code1, 4, 0)) return GL_FALSE; if (inst[i].code2 != slang_asm_none) if (!PLAB2 (A->file, inst[i].code2, 4, 0)) return GL_FALSE; /* clean-up the stack from the remaining dst address */ if (!PLAB (A->file, slang_asm_local_free, 4)) return GL_FALSE; return GL_TRUE; }
slang_type_specifier_type slang_type_specifier_type_from_string (const char *name) { type_specifier_type_name *p = type_specifier_type_names; while (p->name != NULL) { if (slang_string_compare (p->name, name) == 0) break; p++; } return p->type; }
/* * Search the atom pool for an atom with a given name. * If atom is not found, create and add it to the pool. * Returns ATOM_NULL if the atom was not found and the function failed * to create a new atom. */ slang_atom slang_atom_pool_atom(slang_atom_pool * pool, const char * id) { GLuint hash; const char * p = id; slang_atom_entry ** entry; /* Hash a given string to a number in the range [0, ATOM_POOL_SIZE). */ hash = 0; while (*p != '\0') { GLuint g; hash = (hash << 4) + (GLuint) (*p++); g = hash & 0xf0000000; if (g != 0) hash ^= g >> 24; hash &= ~g; } hash %= SLANG_ATOM_POOL_SIZE; /* Now the hash points to a linked list of atoms with names that * have the same hash value. Search the linked list for a given * name. */ entry = &pool->entries[hash]; while (*entry != NULL) { /* If the same, return the associated atom. */ if (slang_string_compare((**entry).id, id) == 0) return (slang_atom) (**entry).id; /* Grab the next atom in the linked list. */ entry = &(**entry).next; } /* Okay, we have not found an atom. Create a new entry for it. * Note that the <entry> points to the last entry's <next> field. */ *entry = (slang_atom_entry *) _slang_alloc(sizeof(slang_atom_entry)); if (*entry == NULL) return SLANG_ATOM_NULL; /* Initialize a new entry. Because we'll need the actual name of * the atom, we use the pointer to this string as an actual atom's * value. */ (**entry).next = NULL; (**entry).id = _slang_strdup(id); if ((**entry).id == NULL) return SLANG_ATOM_NULL; return (slang_atom) (**entry).id; }
slang_atom slang_atom_pool_atom (slang_atom_pool *pool, const char *id) { GLuint hash; const char *p = id; slang_atom_entry **entry; hash = 0; while (*p != '\0') { GLuint g; hash = (hash << 4) + (GLuint) *p++; g = hash & 0xf0000000; if (g != 0) hash ^= g >> 24; hash &= ~g; } hash %= SLANG_ATOM_POOL_SIZE; entry = &pool->entries[hash]; while (*entry != NULL) { if (slang_string_compare ((**entry).id, id) == 0) return (slang_atom) (**entry).id; entry = &(**entry).next; } *entry = (slang_atom_entry *) slang_alloc_malloc (sizeof (slang_atom_entry)); if (*entry == NULL) return SLANG_ATOM_NULL; (**entry).next = NULL; (**entry).id = slang_string_duplicate (id); if ((**entry).id == NULL) return SLANG_ATOM_NULL; return (slang_atom) (**entry).id; }