src/mesa/shader/slang/slang_compile_variable.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5.3
   4  *
   5  * Copyright (C) 2005-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * \file slang_compile_variable.c
  27  * slang front-end compiler
  28  * \author Michal Krol
  29  */
  30
  31 #include "imports.h"
  32 #include "slang_compile.h"
  33
  34 /* slang_type_specifier_type */
  35
  36 typedef struct
  37 {
  38    const char *name;
  39    slang_type_specifier_type type;
  40 } type_specifier_type_name;
  41
  42 static const type_specifier_type_name type_specifier_type_names[] = {
  43    {"void", SLANG_SPEC_VOID},
  44    {"bool", SLANG_SPEC_BOOL},
  45    {"bvec2", SLANG_SPEC_BVEC2},
  46    {"bvec3", SLANG_SPEC_BVEC3},
  47    {"bvec4", SLANG_SPEC_BVEC4},
  48    {"int", SLANG_SPEC_INT},
  49    {"ivec2", SLANG_SPEC_IVEC2},
  50    {"ivec3", SLANG_SPEC_IVEC3},
  51    {"ivec4", SLANG_SPEC_IVEC4},
  52    {"float", SLANG_SPEC_FLOAT},
  53    {"vec2", SLANG_SPEC_VEC2},
  54    {"vec3", SLANG_SPEC_VEC3},
  55    {"vec4", SLANG_SPEC_VEC4},
  56    {"mat2", SLANG_SPEC_MAT2},
  57    {"mat3", SLANG_SPEC_MAT3},
  58    {"mat4", SLANG_SPEC_MAT4},
  59    {"mat2x3", SLANG_SPEC_MAT23},
  60    {"mat3x2", SLANG_SPEC_MAT32},
  61    {"mat2x4", SLANG_SPEC_MAT24},
  62    {"mat4x2", SLANG_SPEC_MAT42},
  63    {"mat3x4", SLANG_SPEC_MAT34},
  64    {"mat4x3", SLANG_SPEC_MAT43},
  65    {"sampler1D", SLANG_SPEC_SAMPLER1D},
  66    {"sampler2D", SLANG_SPEC_SAMPLER2D},
  67    {"sampler3D", SLANG_SPEC_SAMPLER3D},
  68    {"samplerCube", SLANG_SPEC_SAMPLERCUBE},
  69    {"sampler1DShadow", SLANG_SPEC_SAMPLER1DSHADOW},
  70    {"sampler2DShadow", SLANG_SPEC_SAMPLER2DSHADOW},
  71    {"sampler2DRect", SLANG_SPEC_SAMPLER2DRECT},
  72    {"sampler2DRectShadow", SLANG_SPEC_SAMPLER2DRECTSHADOW},
  73    {NULL, SLANG_SPEC_VOID}
  74 };
  75
  76 slang_type_specifier_type
  77 slang_type_specifier_type_from_string(const char *name)
  78 {
  79    const type_specifier_type_name *p = type_specifier_type_names;
  80    while (p->name != NULL) {
  81       if (slang_string_compare(p->name, name) == 0)
  82          break;
  83       p++;
  84    }
  85    return p->type;
  86 }
  87
  88 const char *
  89 slang_type_specifier_type_to_string(slang_type_specifier_type type)
  90 {
  91    const type_specifier_type_name *p = type_specifier_type_names;
  92    while (p->name != NULL) {
  93       if (p->type == type)
  94          break;
  95       p++;
  96    }
  97    return p->name;
  98 }
  99
 100 /* slang_fully_specified_type */
 101
 102 int
 103 slang_fully_specified_type_construct(slang_fully_specified_type * type)
 104 {
 105    type->qualifier = SLANG_QUAL_NONE;
 106    slang_type_specifier_ctr(&type->specifier);
 107    return 1;
 108 }
 109
 110 void
 111 slang_fully_specified_type_destruct(slang_fully_specified_type * type)
 112 {
 113    slang_type_specifier_dtr(&type->specifier);
 114 }
 115
 116 int
 117 slang_fully_specified_type_copy(slang_fully_specified_type * x,
 118                                 const slang_fully_specified_type * y)
 119 {
 120    slang_fully_specified_type z;
 121
 122    if (!slang_fully_specified_type_construct(&z))
 123       return 0;
 124    z.qualifier = y->qualifier;
 125    if (!slang_type_specifier_copy(&z.specifier, &y->specifier)) {
 126       slang_fully_specified_type_destruct(&z);
 127       return 0;
 128    }
 129    slang_fully_specified_type_destruct(x);
 130    *x = z;
 131    return 1;
 132 }
 133
 134
 135 static slang_variable *
 136 slang_variable_new(void)
 137 {
 138    slang_variable *v = (slang_variable *) malloc(sizeof(slang_variable));
 139    if (v) {
 140       if (!slang_variable_construct(v)) {
 141          free(v);
 142          v = NULL;
 143       }
 144    }
 145    return v;
 146 }
 147
 148
 149 static void
 150 slang_variable_delete(slang_variable * var)
 151 {
 152    slang_variable_destruct(var);
 153    free(var);
 154 }
 155
 156
 157 /*
 158  * slang_variable_scope
 159  */
 160
 161 slang_variable_scope *
 162 _slang_variable_scope_new(slang_variable_scope *parent)
 163 {
 164    slang_variable_scope *s;
 165    s = (slang_variable_scope *) _mesa_calloc(sizeof(slang_variable_scope));
 166    s->outer_scope = parent;
 167    return s;
 168 }
 169
 170
 171 GLvoid
 172 _slang_variable_scope_ctr(slang_variable_scope * self)
 173 {
 174    self->variables = NULL;
 175    self->num_variables = 0;
 176    self->outer_scope = NULL;
 177 }
 178
 179 void
 180 slang_variable_scope_destruct(slang_variable_scope * scope)
 181 {
 182    unsigned int i;
 183
 184    if (!scope)
 185       return;
 186    for (i = 0; i < scope->num_variables; i++) {
 187       if (scope->variables[i])
 188          slang_variable_delete(scope->variables[i]);
 189    }
 190    slang_alloc_free(scope->variables);
 191    /* do not free scope->outer_scope */
 192 }
 193
 194 int
 195 slang_variable_scope_copy(slang_variable_scope * x,
 196                           const slang_variable_scope * y)
 197 {
 198    slang_variable_scope z;
 199    unsigned int i;
 200
 201    _slang_variable_scope_ctr(&z);
 202    z.variables = (slang_variable **)
 203       _mesa_calloc(y->num_variables * sizeof(slang_variable *));
 204    if (z.variables == NULL) {
 205       slang_variable_scope_destruct(&z);
 206       return 0;
 207    }
 208    for (z.num_variables = 0; z.num_variables < y->num_variables;
 209         z.num_variables++) {
 210       z.variables[z.num_variables] = slang_variable_new();
 211       if (!z.variables[z.num_variables]) {
 212          slang_variable_scope_destruct(&z);
 213          return 0;
 214       }
 215    }
 216    for (i = 0; i < z.num_variables; i++) {
 217       if (!slang_variable_copy(z.variables[i], y->variables[i])) {
 218          slang_variable_scope_destruct(&z);
 219          return 0;
 220       }
 221    }
 222    z.outer_scope = y->outer_scope;
 223    slang_variable_scope_destruct(x);
 224    *x = z;
 225    return 1;
 226 }
 227
 228
 229 /**
 230  * Grow the variable list by one.
 231  * \return  pointer to space for the new variable (will be initialized)
 232  */
 233 slang_variable *
 234 slang_variable_scope_grow(slang_variable_scope *scope)
 235 {
 236    const int n = scope->num_variables;
 237    scope->variables = (slang_variable **)
 238          slang_alloc_realloc(scope->variables,
 239                              n * sizeof(slang_variable *),
 240                              (n + 1) * sizeof(slang_variable *));
 241    if (!scope->variables)
 242       return NULL;
 243
 244    scope->num_variables++;
 245
 246    scope->variables[n] = slang_variable_new();
 247    if (!scope->variables[n])
 248       return NULL;
 249
 250    return scope->variables[n];
 251 }
 252
 253
 254
 255 /* slang_variable */
 256
 257 int
 258 slang_variable_construct(slang_variable * var)
 259 {
 260    if (!slang_fully_specified_type_construct(&var->type))
 261       return 0;
 262    var->a_name = SLANG_ATOM_NULL;
 263    var->array_len = 0;
 264    var->initializer = NULL;
 265    var->address = ~0;
 266    var->size = 0;
 267    var->isTemp = GL_FALSE;
 268    var->aux = NULL;
 269    return 1;
 270 }
 271
 272
 273 void
 274 slang_variable_destruct(slang_variable * var)
 275 {
 276    slang_fully_specified_type_destruct(&var->type);
 277    if (var->initializer != NULL) {
 278       slang_operation_destruct(var->initializer);
 279       slang_alloc_free(var->initializer);
 280    }
 281 #if 0
 282    if (var->aux) {
 283       _mesa_free(var->aux);
 284    }
 285 #endif
 286 }
 287
 288
 289 int
 290 slang_variable_copy(slang_variable * x, const slang_variable * y)
 291 {
 292    slang_variable z;
 293
 294    if (!slang_variable_construct(&z))
 295       return 0;
 296    if (!slang_fully_specified_type_copy(&z.type, &y->type)) {
 297       slang_variable_destruct(&z);
 298       return 0;
 299    }
 300    z.a_name = y->a_name;
 301    z.array_len = y->array_len;
 302    if (y->initializer != NULL) {
 303       z.initializer
 304          = (slang_operation *) slang_alloc_malloc(sizeof(slang_operation));
 305       if (z.initializer == NULL) {
 306          slang_variable_destruct(&z);
 307          return 0;
 308       }
 309       if (!slang_operation_construct(z.initializer)) {
 310          slang_alloc_free(z.initializer);
 311          slang_variable_destruct(&z);
 312          return 0;
 313       }
 314       if (!slang_operation_copy(z.initializer, y->initializer)) {
 315          slang_variable_destruct(&z);
 316          return 0;
 317       }
 318    }
 319    z.address = y->address;
 320    z.size = y->size;
 321    slang_variable_destruct(x);
 322    *x = z;
 323    return 1;
 324 }
 325
 326
 327 slang_variable *
 328 _slang_locate_variable(const slang_variable_scope * scope,
 329                        const slang_atom a_name, GLboolean all)
 330 {
 331    GLuint i;
 332
 333    for (i = 0; i < scope->num_variables; i++)
 334       if (a_name == scope->variables[i]->a_name)
 335          return scope->variables[i];
 336    if (all && scope->outer_scope != NULL)
 337       return _slang_locate_variable(scope->outer_scope, a_name, 1);
 338    return NULL;
 339 }