glsl: Fix handling of function calls inside nested loops.

[mesa.git] / src / glsl / glsl_symbol_table.h

diff --git a/src/glsl/glsl_symbol_table.h b/src/glsl/glsl_symbol_table.h
index ae2fd3f4f1fef7dc592d40f01bdf05bb722c87f5..0e62448e2e7ca6c4ff5df1a3ce44afa4ddc5b6e2 100644 (file)
--- a/src/glsl/glsl_symbol_table.h
+++ b/src/glsl/glsl_symbol_table.h
@@ -28,83 +28,65 @@
 
 #include <new>
 
-#include "symbol_table.h"
+extern "C" {
+#include "program/symbol_table.h"
+}
 #include "ir.h"
 #include "glsl_types.h"
 
+class symbol_table_entry;
+
 /**
  * Facade class for _mesa_symbol_table
  *
  * Wraps the existing \c _mesa_symbol_table data structure to enforce some
  * type safe and some symbol table invariants.
  */
-class glsl_symbol_table {
+struct glsl_symbol_table {
 private:
-   enum glsl_symbol_name_space {
-      glsl_variable_name_space = 0,
-      glsl_type_name_space = 1,
-      glsl_function_name_space = 2
-   };
-
-   static int
+   static void
    _glsl_symbol_table_destructor (glsl_symbol_table *table)
    {
       table->~glsl_symbol_table();
-
-      return 0;
    }
 
 public:
-   /* Callers of this talloc-based new need not call delete. It's
-    * easier to just talloc_free 'ctx' (or any of its ancestors). */
+   /* Callers of this ralloc-based new need not call delete. It's
+    * easier to just ralloc_free 'ctx' (or any of its ancestors). */
    static void* operator new(size_t size, void *ctx)
    {
       void *table;
 
-      table = talloc_size(ctx, size);
+      table = ralloc_size(ctx, size);
       assert(table != NULL);
 
-      talloc_set_destructor(table, (int (*)(void*)) _glsl_symbol_table_destructor);
+      ralloc_set_destructor(table, (void (*)(void*)) _glsl_symbol_table_destructor);
 
       return table;
    }
 
    /* If the user *does* call delete, that's OK, we will just
-    * talloc_free in that case. Here, C++ will have already called the
-    * destructor so tell talloc not to do that again. */
+    * ralloc_free in that case. Here, C++ will have already called the
+    * destructor so tell ralloc not to do that again. */
    static void operator delete(void *table)
    {
-      talloc_set_destructor(table, NULL);
-      talloc_free(table);
+      ralloc_set_destructor(table, NULL);
+      ralloc_free(table);
    }
    
-   glsl_symbol_table()
-   {
-      table = _mesa_symbol_table_ctor();
-   }
+   glsl_symbol_table();
+   ~glsl_symbol_table();
 
-   ~glsl_symbol_table()
-   {
-      _mesa_symbol_table_dtor(table);
-   }
+   /* In 1.10, functions and variables have separate namespaces. */
+   bool separate_function_namespace;
 
-   void push_scope()
-   {
-      _mesa_symbol_table_push_scope(table);
-   }
-
-   void pop_scope()
-   {
-      _mesa_symbol_table_pop_scope(table);
-   }
+   void push_scope();
+   void pop_scope();
 
    /**
     * Determine whether a name was declared at the current scope
     */
-   bool name_declared_this_scope(const char *name)
-   {
-      return _mesa_symbol_table_symbol_scope(table, -1, name) == 0;
-   }
+   bool name_declared_this_scope(const char *name);
 
    /**
     * \name Methods to add symbols to the table
@@ -114,50 +96,44 @@ public:
     * reduces the clarity of the intention of code that uses these methods.
     */
    /*@{*/
-   bool add_variable(const char *name, ir_variable *v)
-   {
-      return _mesa_symbol_table_add_symbol(table, glsl_variable_name_space,
-                                          name, v) == 0;
-   }
-
-   bool add_type(const char *name, const glsl_type *t)
-   {
-      return _mesa_symbol_table_add_symbol(table, glsl_type_name_space,
-                                          name, (void *) t) == 0;
-   }
-
-   bool add_function(const char *name, ir_function *f)
-   {
-      return _mesa_symbol_table_add_symbol(table, glsl_function_name_space,
-                                          name, f) == 0;
-   }
+   bool add_variable(ir_variable *v);
+   bool add_type(const char *name, const glsl_type *t);
+   bool add_type_ast(const char *name, const class ast_type_specifier *t);
+   bool add_function(ir_function *f);
+   bool add_interface(const char *name, const glsl_type *i,
+                      enum ir_variable_mode mode);
    /*@}*/
 
+   /**
+    * Add an function at global scope without checking for scoping conflicts.
+    */
+   void add_global_function(ir_function *f);
+
    /**
     * \name Methods to get symbols from the table
     */
    /*@{*/
-   ir_variable *get_variable(const char *name)
-   {
-      return (ir_variable *)
-        _mesa_symbol_table_find_symbol(table, glsl_variable_name_space, name);
-   }
-
-   glsl_type *get_type(const char *name)
-   {
-      return (glsl_type *)
-        _mesa_symbol_table_find_symbol(table, glsl_type_name_space, name);
-   }
-
-   ir_function *get_function(const char *name)
-   {
-      return (ir_function *)
-        _mesa_symbol_table_find_symbol(table, glsl_function_name_space, name);
-   }
+   ir_variable *get_variable(const char *name);
+   const glsl_type *get_type(const char *name);
+   const class ast_type_specifier *get_type_ast(const char *name);
+   ir_function *get_function(const char *name);
+   const glsl_type *get_interface(const char *name,
+                                  enum ir_variable_mode mode);
    /*@}*/
 
+   /**
+    * Disable a previously-added variable so that it no longer appears to be
+    * in the symbol table.  This is necessary when gl_PerVertex is redeclared,
+    * to ensure that previously-available built-in variables are no longer
+    * available.
+    */
+   void disable_variable(const char *name);
+
 private:
+   symbol_table_entry *get_entry(const char *name);
+
    struct _mesa_symbol_table *table;
+   void *mem_ctx;
 };
 
 #endif /* GLSL_SYMBOL_TABLE */