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 #include "slang_mem.h"
  34
  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 *) _slang_alloc(sizeof(slang_variable));
 139    if (v) {
 140       if (!slang_variable_construct(v)) {
 141          _slang_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    _slang_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 *) _slang_alloc(sizeof(slang_variable_scope));
 166    if (s)
 167       s->outer_scope = parent;
 168    return s;
 169 }
 170
 171
 172 GLvoid
 173 _slang_variable_scope_ctr(slang_variable_scope * self)
 174 {
 175    self->variables = NULL;
 176    self->num_variables = 0;
 177    self->outer_scope = NULL;
 178 }
 179
 180 void
 181 slang_variable_scope_destruct(slang_variable_scope * scope)
 182 {
 183    unsigned int i;
 184
 185    if (!scope)
 186       return;
 187    for (i = 0; i < scope->num_variables; i++) {
 188       if (scope->variables[i])
 189          slang_variable_delete(scope->variables[i]);
 190    }
 191    _slang_free(scope->variables);
 192    /* do not free scope->outer_scope */
 193 }
 194
 195 int
 196 slang_variable_scope_copy(slang_variable_scope * x,
 197                           const slang_variable_scope * y)
 198 {
 199    slang_variable_scope z;
 200    unsigned int i;
 201
 202    _slang_variable_scope_ctr(&z);
 203    z.variables = (slang_variable **)
 204       _slang_alloc(y->num_variables * sizeof(slang_variable *));
 205    if (z.variables == NULL) {
 206       slang_variable_scope_destruct(&z);
 207       return 0;
 208    }
 209    for (z.num_variables = 0; z.num_variables < y->num_variables;
 210         z.num_variables++) {
 211       z.variables[z.num_variables] = slang_variable_new();
 212       if (!z.variables[z.num_variables]) {
 213          slang_variable_scope_destruct(&z);
 214          return 0;
 215       }
 216    }
 217    for (i = 0; i < z.num_variables; i++) {
 218       if (!slang_variable_copy(z.variables[i], y->variables[i])) {
 219          slang_variable_scope_destruct(&z);
 220          return 0;
 221       }
 222    }
 223    z.outer_scope = y->outer_scope;
 224    slang_variable_scope_destruct(x);
 225    *x = z;
 226    return 1;
 227 }
 228
 229
 230 /**
 231  * Grow the variable list by one.
 232  * \return  pointer to space for the new variable (will be initialized)
 233  */
 234 slang_variable *
 235 slang_variable_scope_grow(slang_variable_scope *scope)
 236 {
 237    const int n = scope->num_variables;
 238    scope->variables = (slang_variable **)
 239          _slang_realloc(scope->variables,
 240                         n * sizeof(slang_variable *),
 241                         (n + 1) * sizeof(slang_variable *));
 242    if (!scope->variables)
 243       return NULL;
 244
 245    scope->num_variables++;
 246
 247    scope->variables[n] = slang_variable_new();
 248    if (!scope->variables[n])
 249       return NULL;
 250
 251    return scope->variables[n];
 252 }
 253
 254
 255
 256 /* slang_variable */
 257
 258 int
 259 slang_variable_construct(slang_variable * var)
 260 {
 261    if (!slang_fully_specified_type_construct(&var->type))
 262       return 0;
 263    var->a_name = SLANG_ATOM_NULL;
 264    var->array_len = 0;
 265    var->initializer = NULL;
 266    var->address = ~0;
 267    var->size = 0;
 268    var->isTemp = GL_FALSE;
 269    var->aux = NULL;
 270    return 1;
 271 }
 272
 273
 274 void
 275 slang_variable_destruct(slang_variable * var)
 276 {
 277    slang_fully_specified_type_destruct(&var->type);
 278    if (var->initializer != NULL) {
 279       slang_operation_destruct(var->initializer);
 280       _slang_free(var->initializer);
 281    }
 282 #if 0
 283    if (var->aux) {
 284       _mesa_free(var->aux);
 285    }
 286 #endif
 287 }
 288
 289
 290 int
 291 slang_variable_copy(slang_variable * x, const slang_variable * y)
 292 {
 293    slang_variable z;
 294
 295    if (!slang_variable_construct(&z))
 296       return 0;
 297    if (!slang_fully_specified_type_copy(&z.type, &y->type)) {
 298       slang_variable_destruct(&z);
 299       return 0;
 300    }
 301    z.a_name = y->a_name;
 302    z.array_len = y->array_len;
 303    if (y->initializer != NULL) {
 304       z.initializer
 305          = (slang_operation *) _slang_alloc(sizeof(slang_operation));
 306       if (z.initializer == NULL) {
 307          slang_variable_destruct(&z);
 308          return 0;
 309       }
 310       if (!slang_operation_construct(z.initializer)) {
 311          _slang_free(z.initializer);
 312          slang_variable_destruct(&z);
 313          return 0;
 314       }
 315       if (!slang_operation_copy(z.initializer, y->initializer)) {
 316          slang_variable_destruct(&z);
 317          return 0;
 318       }
 319    }
 320    z.address = y->address;
 321    z.size = y->size;
 322    slang_variable_destruct(x);
 323    *x = z;
 324    return 1;
 325 }
 326
 327
 328 slang_variable *
 329 _slang_locate_variable(const slang_variable_scope * scope,
 330                        const slang_atom a_name, GLboolean all)
 331 {
 332    GLuint i;
 333
 334    for (i = 0; i < scope->num_variables; i++)
 335       if (a_name == scope->variables[i]->a_name)
 336          return scope->variables[i];
 337    if (all && scope->outer_scope != NULL)
 338       return _slang_locate_variable(scope->outer_scope, a_name, 1);
 339    return NULL;
 340 }