src/glsl/glsl_symbol_table.cpp

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright © 2010 Intel Corporation
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include "glsl_symbol_table.h"
  26
  27 class symbol_table_entry {
  28 public:
  29    /* Callers of this ralloc-based new need not call delete. It's
  30     * easier to just ralloc_free 'ctx' (or any of its ancestors). */
  31    static void* operator new(size_t size, void *ctx)
  32    {
  33       void *entry = ralloc_size(ctx, size);
  34       assert(entry != NULL);
  35       return entry;
  36    }
  37
  38    /* If the user *does* call delete, that's OK, we will just ralloc_free. */
  39    static void operator delete(void *entry)
  40    {
  41       ralloc_free(entry);
  42    }
  43
  44    symbol_table_entry(ir_variable *v)                     : v(v), f(0), t(0) {}
  45    symbol_table_entry(ir_function *f)                     : v(0), f(f), t(0) {}
  46    symbol_table_entry(const glsl_type *t)                 : v(0), f(0), t(t) {}
  47
  48    ir_variable *v;
  49    ir_function *f;
  50    const glsl_type *t;
  51 };
  52
  53 glsl_symbol_table::glsl_symbol_table()
  54 {
  55    this->language_version = 120;
  56    this->table = _mesa_symbol_table_ctor();
  57    this->mem_ctx = ralloc_context(NULL);
  58 }
  59
  60 glsl_symbol_table::~glsl_symbol_table()
  61 {
  62    _mesa_symbol_table_dtor(table);
  63    ralloc_free(mem_ctx);
  64 }
  65
  66 void glsl_symbol_table::push_scope()
  67 {
  68    _mesa_symbol_table_push_scope(table);
  69 }
  70
  71 void glsl_symbol_table::pop_scope()
  72 {
  73    _mesa_symbol_table_pop_scope(table);
  74 }
  75
  76 bool glsl_symbol_table::name_declared_this_scope(const char *name)
  77 {
  78    return _mesa_symbol_table_symbol_scope(table, -1, name) == 0;
  79 }
  80
  81 bool glsl_symbol_table::add_variable(ir_variable *v)
  82 {
  83    if (this->language_version == 110) {
  84       /* In 1.10, functions and variables have separate namespaces. */
  85       symbol_table_entry *existing = get_entry(v->name);
  86       if (name_declared_this_scope(v->name)) {
  87          /* If there's already an existing function (not a constructor!) in
  88           * the current scope, just update the existing entry to include 'v'.
  89           */
  90          if (existing->v == NULL && existing->t == NULL) {
  91             existing->v = v;
  92             return true;
  93          }
  94       } else {
  95          /* If not declared at this scope, add a new entry.  But if an existing
  96           * entry includes a function, propagate that to this block - otherwise
  97           * the new variable declaration would shadow the function.
  98           */
  99          symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(v);
 100          if (existing != NULL)
 101             entry->f = existing->f;
 102          int added = _mesa_symbol_table_add_symbol(table, -1, v->name, entry);
 103          assert(added == 0);
 104          (void)added;
 105          return true;
 106       }
 107       return false;
 108    }
 109
 110    /* 1.20+ rules: */
 111    symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(v);
 112    return _mesa_symbol_table_add_symbol(table, -1, v->name, entry) == 0;
 113 }
 114
 115 bool glsl_symbol_table::add_type(const char *name, const glsl_type *t)
 116 {
 117    symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(t);
 118    return _mesa_symbol_table_add_symbol(table, -1, name, entry) == 0;
 119 }
 120
 121 bool glsl_symbol_table::add_function(ir_function *f)
 122 {
 123    if (this->language_version == 110 && name_declared_this_scope(f->name)) {
 124       /* In 1.10, functions and variables have separate namespaces. */
 125       symbol_table_entry *existing = get_entry(f->name);
 126       if ((existing->f == NULL) && (existing->t == NULL)) {
 127          existing->f = f;
 128          return true;
 129       }
 130    }
 131    symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(f);
 132    return _mesa_symbol_table_add_symbol(table, -1, f->name, entry) == 0;
 133 }
 134
 135 void glsl_symbol_table::add_global_function(ir_function *f)
 136 {
 137    symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(f);
 138    int added = _mesa_symbol_table_add_global_symbol(table, -1, f->name, entry);
 139    assert(added == 0);
 140    (void)added;
 141 }
 142
 143 ir_variable *glsl_symbol_table::get_variable(const char *name)
 144 {
 145    symbol_table_entry *entry = get_entry(name);
 146    return entry != NULL ? entry->v : NULL;
 147 }
 148
 149 const glsl_type *glsl_symbol_table::get_type(const char *name)
 150 {
 151    symbol_table_entry *entry = get_entry(name);
 152    return entry != NULL ? entry->t : NULL;
 153 }
 154
 155 ir_function *glsl_symbol_table::get_function(const char *name)
 156 {
 157    symbol_table_entry *entry = get_entry(name);
 158    return entry != NULL ? entry->f : NULL;
 159 }
 160
 161 symbol_table_entry *glsl_symbol_table::get_entry(const char *name)
 162 {
 163    return (symbol_table_entry *)
 164       _mesa_symbol_table_find_symbol(table, -1, name);
 165 }