/*
* Print what's mapped to t in the context's internalization table.
* - if t is mapped to a Boolean, the corresponding DIMACS literal is printed
* - if t is mapped to a bitvector then the corresponding literal array is printed
* - otherwise we print "non boolean"
*/
void dimacs_print_internalized_term(FILE *f, context_t *ctx, term_t t) {
intern_tbl_t *intern;
type_table_t *types;
term_t r;
type_t tau;
int32_t code;
uint32_t polarity;
intern = &ctx->intern;
types = ctx->types;
r = intern_tbl_get_root(intern, t);
if (t != r) {
// substitution: t --> r (can't deal with this)
fputs("eliminated", f);
} else if (intern_tbl_root_is_mapped(intern, r)) {
// t = r is mapped to something
polarity = polarity_of(r);
r = unsigned_term(r);
tau = intern_tbl_type_of_root(intern, r);
if (is_boolean_type(tau)) {
// Boolean term
code = intern_tbl_map_of_root(intern, r);
assert(code_is_valid(code));
dimacs_print_bool_code(f, code, polarity);
} else if (is_bv_type(types, tau)) {
// Bitvector term
code = intern_tbl_map_of_root(intern, r);
assert(code_is_valid(code));
assert(polarity == 0);
dimacs_print_bv_code(f, ctx, code);
} else {
// Can't be converted to DIMACS
fputs("non boolean", f);
}
} else {
// r not mapped to anything
fputs("not internalized", f);
}
}
bool Grammar::is_object_type(const std::string& str) {
return is_boolean_type(str) || is_character_type(str) || is_integer_type(str) || is_float_type(str) ||
is_string_type(str);
}
/**
* Set the value of a program's uniform variable.
* \param program the program whose uniform to update
* \param index the index of the program parameter for the uniform
* \param offset additional parameter slot offset (for arrays)
* \param type the incoming datatype of 'values'
* \param count the number of uniforms to set
* \param elems number of elements per uniform (1, 2, 3 or 4)
* \param values the new values, of datatype 'type'
*/
static void
set_program_uniform(GLcontext *ctx, struct gl_program *program,
GLint index, GLint offset,
GLenum type, GLsizei count, GLint elems,
const void *values)
{
const struct gl_program_parameter *param =
&program->Parameters->Parameters[index];
assert(offset >= 0);
assert(elems >= 1);
assert(elems <= 4);
if (!compatible_types(type, param->DataType)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");
return;
}
if (index + offset > (GLint) program->Parameters->Size) {
/* out of bounds! */
return;
}
if (param->Type == PROGRAM_SAMPLER) {
/* This controls which texture unit which is used by a sampler */
GLboolean changed = GL_FALSE;
GLint i;
/* this should have been caught by the compatible_types() check */
ASSERT(type == GL_INT);
/* loop over number of samplers to change */
for (i = 0; i < count; i++) {
GLuint sampler =
(GLuint) program->Parameters->ParameterValues[index + offset + i][0];
GLuint texUnit = ((GLuint *) values)[i];
/* check that the sampler (tex unit index) is legal */
if (texUnit >= ctx->Const.MaxTextureImageUnits) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glUniform1(invalid sampler/tex unit index for '%s')",
param->Name);
return;
}
/* This maps a sampler to a texture unit: */
if (sampler < MAX_SAMPLERS) {
#if 0
printf("Set program %p sampler %d '%s' to unit %u\n",
program, sampler, param->Name, texUnit);
#endif
if (program->SamplerUnits[sampler] != texUnit) {
program->SamplerUnits[sampler] = texUnit;
changed = GL_TRUE;
}
}
}
if (changed) {
/* When a sampler's value changes it usually requires rewriting
* a GPU program's TEX instructions since there may not be a
* sampler->texture lookup table. We signal this with the
* ProgramStringNotify() callback.
*/
FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM);
_mesa_update_shader_textures_used(program);
/* Do we need to care about the return value here?
* This should not be the first time the driver was notified of
* this program.
*/
(void) ctx->Driver.ProgramStringNotify(ctx, program->Target, program);
}
}
else {
/* ordinary uniform variable */
const GLboolean isUniformBool = is_boolean_type(param->DataType);
const GLenum basicType = base_uniform_type(type);
const GLint slots = (param->Size + 3) / 4;
const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
GLsizei k, i;
if ((GLint) param->Size > typeSize) {
/* an array */
/* we'll ignore extra data below */
}
else {
/* non-array: count must be at most one; count == 0 is handled by the loop below */
if (count > 1) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glUniform(uniform '%s' is not an array)",
param->Name);
return;
}
}
/* loop over number of array elements */
for (k = 0; k < count; k++) {
GLfloat *uniformVal;
if (offset + k >= slots) {
/* Extra array data is ignored */
break;
}
/* uniformVal (the destination) is always float[4] */
uniformVal = program->Parameters->ParameterValues[index + offset + k];
if (basicType == GL_INT) {
/* convert user's ints to floats */
const GLint *iValues = ((const GLint *) values) + k * elems;
for (i = 0; i < elems; i++) {
uniformVal[i] = (GLfloat) iValues[i];
}
}
else if (basicType == GL_UNSIGNED_INT) {
/* convert user's uints to floats */
const GLuint *iValues = ((const GLuint *) values) + k * elems;
for (i = 0; i < elems; i++) {
uniformVal[i] = (GLfloat) iValues[i];
}
}
else {
const GLfloat *fValues = ((const GLfloat *) values) + k * elems;
assert(basicType == GL_FLOAT);
for (i = 0; i < elems; i++) {
uniformVal[i] = fValues[i];
}
}
/* if the uniform is bool-valued, convert to 1.0 or 0.0 */
if (isUniformBool) {
for (i = 0; i < elems; i++) {
uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;
}
}
}
}
}
// Returns true if `t` is the type of an object. The
// object types are `bool` and `int`.
inline bool
is_object_type(Type const* t)
{
return is_boolean_type(t) || is_integer_type(t);
}
// Returns true if `e` has type `bool`.
bool
has_bool_type(Expr const& e)
{
return is_boolean_type(e.type());
}
