[gtk+/wip/otte/shader: 8/151] gsk: Add GskSlPointerType



commit 7d1585e2960e77d590f1ac22de252194c16ebb44
Author: Benjamin Otte <otte redhat com>
Date:   Fri Sep 22 14:39:26 2017 +0200

    gsk: Add GskSlPointerType
    
    This describes a type with qualifiers like const, volatile and so on.

 gsk/gskslnode.c               |   50 +++++-
 gsk/gskslpointertype.c        |  386 +++++++++++++++++++++++++++++++++++++++++
 gsk/gskslpointertypeprivate.h |   76 ++++++++
 gsk/gsksltypesprivate.h       |    1 +
 gsk/meson.build               |    1 +
 5 files changed, 504 insertions(+), 10 deletions(-)
---
diff --git a/gsk/gskslnode.c b/gsk/gskslnode.c
index 9b27ed1..9e04c9c 100644
--- a/gsk/gskslnode.c
+++ b/gsk/gskslnode.c
@@ -22,6 +22,7 @@
 
 #include "gskslpreprocessorprivate.h"
 #include "gskslfunctionprivate.h"
+#include "gskslpointertypeprivate.h"
 #include "gskslscopeprivate.h"
 #include "gsksltokenizerprivate.h"
 #include "gsksltypeprivate.h"
@@ -724,7 +725,7 @@ struct _GskSlNodeDeclaration {
   GskSlNode parent;
 
   char *name;
-  GskSlType *type;
+  GskSlPointerType *type;
   GskSlNode *initial;
   guint constant :1;
 };
@@ -735,7 +736,7 @@ gsk_sl_node_declaration_free (GskSlNode *node)
   GskSlNodeDeclaration *declaration = (GskSlNodeDeclaration *) node;
 
   g_free (declaration->name);
-  gsk_sl_type_unref (declaration->type);
+  gsk_sl_pointer_type_unref (declaration->type);
   if (declaration->initial)
     gsk_sl_node_unref (declaration->initial);
 
@@ -748,7 +749,7 @@ gsk_sl_node_declaration_print (GskSlNode *node,
 {
   GskSlNodeDeclaration *declaration = (GskSlNodeDeclaration *) node;
 
-  g_string_append (string, gsk_sl_type_get_name (declaration->type));
+  gsk_sl_pointer_type_print (declaration->type, string);
   if (declaration->name)
     {
       g_string_append (string, " ");
@@ -766,7 +767,7 @@ gsk_sl_node_declaration_get_return_type (GskSlNode *node)
 {
   GskSlNodeDeclaration *declaration = (GskSlNodeDeclaration *) node;
 
-  return declaration->type;
+  return gsk_sl_pointer_type_get_type (declaration->type);
 }
 
 static gboolean
@@ -1974,13 +1975,13 @@ static GskSlNode *
 gsk_sl_node_parse_declaration (GskSlNodeProgram  *program,
                                GskSlScope        *scope,
                                GskSlPreprocessor *stream,
-                               GskSlType         *type)
+                               GskSlPointerType  *type)
 {
   GskSlNodeDeclaration *declaration;
   const GskSlToken *token;
 
   declaration = gsk_sl_node_new (GskSlNodeDeclaration, &GSK_SL_NODE_DECLARATION);
-  declaration->type = gsk_sl_type_ref (type);
+  declaration->type = gsk_sl_pointer_type_ref (type);
   
   token = gsk_sl_preprocessor_get (stream);
   if (!gsk_sl_token_is (token, GSK_SL_TOKEN_IDENTIFIER))
@@ -2048,6 +2049,16 @@ gsk_sl_node_parse_function_definition (GskSlNodeProgram  *program,
       case GSK_SL_TOKEN_RIGHT_BRACE:
         goto out;
 
+      case GSK_SL_TOKEN_CONST:
+      case GSK_SL_TOKEN_IN:
+      case GSK_SL_TOKEN_OUT:
+      case GSK_SL_TOKEN_INOUT:
+      case GSK_SL_TOKEN_INVARIANT:
+      case GSK_SL_TOKEN_COHERENT:
+      case GSK_SL_TOKEN_VOLATILE:
+      case GSK_SL_TOKEN_RESTRICT:
+      case GSK_SL_TOKEN_READONLY:
+      case GSK_SL_TOKEN_WRITEONLY:
       case GSK_SL_TOKEN_VOID:
       case GSK_SL_TOKEN_FLOAT:
       case GSK_SL_TOKEN_DOUBLE:
@@ -2095,21 +2106,40 @@ gsk_sl_node_parse_function_definition (GskSlNodeProgram  *program,
       case GSK_SL_TOKEN_DMAT4X4:
         {
           GskSlType *type;
+          GskSlPointerTypeFlags flags;
+          gboolean success;
+
+          success = gsk_sl_type_qualifier_parse (stream,
+                                                 GSK_SL_POINTER_TYPE_PARAMETER_QUALIFIER 
+                                                 | GSK_SL_POINTER_TYPE_MEMORY_QUALIFIER,
+                                                 &flags);
 
           type = gsk_sl_type_new_parse (stream);
           if (type == NULL)
-            return FALSE;
+            break;
 
           token = gsk_sl_preprocessor_get (stream);
 
           if (token->type == GSK_SL_TOKEN_LEFT_BRACE)
-            node = gsk_sl_node_parse_constructor_call (program, function->scope, stream, type);
+            {
+              node = gsk_sl_node_parse_constructor_call (program, function->scope, stream, type);
+            }
           else
-            node = gsk_sl_node_parse_declaration (program, function->scope, stream, type);
+            {
+              GskSlPointerType *pointer_type;
+          
+              pointer_type = gsk_sl_pointer_type_new (type, flags | GSK_SL_POINTER_TYPE_LOCAL);
+              node = gsk_sl_node_parse_declaration (program, function->scope, stream, pointer_type);
+              gsk_sl_pointer_type_unref (pointer_type);
+            }
 
           gsk_sl_type_unref (type);
 
-          if (node)
+          if (!success)
+            {
+              gsk_sl_node_unref (node);
+            }
+          else if (node)
             {
               function->statements = g_slist_append (function->statements, node);
             }
diff --git a/gsk/gskslpointertype.c b/gsk/gskslpointertype.c
new file mode 100644
index 0000000..07b09f2
--- /dev/null
+++ b/gsk/gskslpointertype.c
@@ -0,0 +1,386 @@
+/* GTK - The GIMP Toolkit
+ *   
+ * Copyright © 2017 Benjamin Otte <otte gnome org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gskslpointertypeprivate.h"
+
+#include "gskslpreprocessorprivate.h"
+#include "gsksltokenizerprivate.h"
+#include "gsksltypeprivate.h"
+
+struct _GskSlPointerType {
+  int ref_count;
+
+  GskSlType *type;
+
+  GskSlPointerTypeFlags flags;
+};
+
+GskSlPointerType *
+gsk_sl_pointer_type_new (GskSlType             *type,
+                         GskSlPointerTypeFlags  flags)
+{
+  GskSlPointerType *result;
+
+  result = g_slice_new0 (GskSlPointerType);
+
+  result->ref_count = 1;
+  result->type = gsk_sl_type_ref (type);
+  result->flags = flags;
+
+  return result;
+}
+
+gboolean
+gsk_sl_type_qualifier_parse (GskSlPreprocessor     *stream,
+                             GskSlPointerTypeFlags  allowed_flags,
+                             GskSlPointerTypeFlags *parsed_flags)
+{
+  const GskSlToken *token;
+  guint flags = 0;
+  gboolean success = TRUE;
+
+  while (TRUE)
+    {
+      token = gsk_sl_preprocessor_get (stream);
+      switch ((guint) token->type)
+      {
+        case GSK_SL_TOKEN_CONST:
+          if (!(allowed_flags & GSK_SL_POINTER_TYPE_CONST))
+            {
+              gsk_sl_preprocessor_error (stream, "\"const\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_CONST)
+            {
+              gsk_sl_preprocessor_error (stream, "\"const\" qualifier specified twice.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |=  GSK_SL_POINTER_TYPE_CONST;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+        case GSK_SL_TOKEN_IN:
+          if (!(allowed_flags & GSK_SL_POINTER_TYPE_IN))
+            {
+              gsk_sl_preprocessor_error (stream, "\"in\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_IN)
+            {
+              gsk_sl_preprocessor_error (stream, "\"in\" qualifier specified twice.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |= GSK_SL_POINTER_TYPE_IN;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+        case GSK_SL_TOKEN_OUT:
+          if (!(allowed_flags & GSK_SL_POINTER_TYPE_OUT))
+            {
+              gsk_sl_preprocessor_error (stream, "\"out\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_OUT)
+            {
+              gsk_sl_preprocessor_error (stream, "\"out\" qualifier specified twice.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |= GSK_SL_POINTER_TYPE_OUT;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+        case GSK_SL_TOKEN_INOUT:
+          if ((allowed_flags & (GSK_SL_POINTER_TYPE_IN | GSK_SL_POINTER_TYPE_OUT)) != 
(GSK_SL_POINTER_TYPE_IN | GSK_SL_POINTER_TYPE_OUT))
+            {
+              gsk_sl_preprocessor_error (stream, "\"inout\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_IN)
+            {
+              gsk_sl_preprocessor_error (stream, "\"in\" qualifier already used.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_OUT)
+            {
+              gsk_sl_preprocessor_error (stream, "\"out\" qualifier already used.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |= GSK_SL_POINTER_TYPE_IN | GSK_SL_POINTER_TYPE_OUT;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+        case GSK_SL_TOKEN_INVARIANT:
+          if (!(allowed_flags & GSK_SL_POINTER_TYPE_INVARIANT))
+            {
+              gsk_sl_preprocessor_error (stream, "\"invariant\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_INVARIANT)
+            {
+              gsk_sl_preprocessor_error (stream, "\"invariant\" qualifier specified twice.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |= GSK_SL_POINTER_TYPE_INVARIANT;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+        case GSK_SL_TOKEN_COHERENT:
+          if (!(allowed_flags & GSK_SL_POINTER_TYPE_COHERENT))
+            {
+              gsk_sl_preprocessor_error (stream, "\"coherent\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_COHERENT)
+            {
+              gsk_sl_preprocessor_error (stream, "\"coherent\" qualifier specified twice.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |= GSK_SL_POINTER_TYPE_COHERENT;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+        case GSK_SL_TOKEN_VOLATILE:
+          if (!(allowed_flags & GSK_SL_POINTER_TYPE_VOLATILE))
+            {
+              gsk_sl_preprocessor_error (stream, "\"volatile\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_VOLATILE)
+            {
+              gsk_sl_preprocessor_error (stream, "\"volatile\" qualifier specified twice.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |= GSK_SL_POINTER_TYPE_VOLATILE;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+        case GSK_SL_TOKEN_RESTRICT:
+          if (!(allowed_flags & GSK_SL_POINTER_TYPE_RESTRICT))
+            {
+              gsk_sl_preprocessor_error (stream, "\"restrict\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_RESTRICT)
+            {
+              gsk_sl_preprocessor_error (stream, "\"restrict\" qualifier specified twice.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |= GSK_SL_POINTER_TYPE_RESTRICT;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+
+        case GSK_SL_TOKEN_READONLY:
+          if (!(allowed_flags & GSK_SL_POINTER_TYPE_READONLY))
+            {
+              gsk_sl_preprocessor_error (stream, "\"readonly\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_READONLY)
+            {
+              gsk_sl_preprocessor_error (stream, "\"readonly\" qualifier specified twice.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_WRITEONLY)
+            {
+              gsk_sl_preprocessor_error (stream, "\"writeonly\" qualifier already used.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |= GSK_SL_POINTER_TYPE_READONLY;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+        case GSK_SL_TOKEN_WRITEONLY:
+          if (!(allowed_flags & GSK_SL_POINTER_TYPE_WRITEONLY))
+            {
+              gsk_sl_preprocessor_error (stream, "\"writeonly\" qualifier not allowed here.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_READONLY)
+            {
+              gsk_sl_preprocessor_error (stream, "\"readonly\" qualifier already used.");
+              success = FALSE;
+            }
+          else if (flags & GSK_SL_POINTER_TYPE_WRITEONLY)
+            {
+              gsk_sl_preprocessor_error (stream, "\"writeonly\" qualifier specified twice.");
+              success = FALSE;
+            }
+          else
+            {
+              flags |= GSK_SL_POINTER_TYPE_WRITEONLY;
+            }
+          gsk_sl_preprocessor_consume (stream, NULL);
+          break;
+
+        default:
+          {
+            *parsed_flags = flags;
+
+            return success;
+          }
+      }
+    }
+}
+
+GskSlPointerType *
+gsk_sl_pointer_type_ref (GskSlPointerType *type)
+{
+  g_return_val_if_fail (type != NULL, NULL);
+
+  type->ref_count += 1;
+
+  return type;
+}
+
+void
+gsk_sl_pointer_type_unref (GskSlPointerType *type)
+{
+  if (type == NULL)
+    return;
+
+  type->ref_count -= 1;
+  if (type->ref_count > 0)
+    return;
+
+  gsk_sl_type_unref (type->type);
+
+  g_slice_free (GskSlPointerType, type);
+}
+
+void
+gsk_sl_pointer_type_print (const GskSlPointerType *type,
+                           GString                *string)
+{
+  if (type->flags & GSK_SL_POINTER_TYPE_CONST)
+    g_string_append (string, "const ");
+  if (type->flags & GSK_SL_POINTER_TYPE_OUT)
+    {
+      if (type->flags & GSK_SL_POINTER_TYPE_IN)
+        g_string_append (string, "inout ");
+      else
+        g_string_append (string, "out ");
+    }
+  else if (type->flags & GSK_SL_POINTER_TYPE_IN)
+    {
+      g_string_append (string, "out ");
+    }
+  if (type->flags & GSK_SL_POINTER_TYPE_INVARIANT)
+    g_string_append (string, "invariant ");
+  if (type->flags & GSK_SL_POINTER_TYPE_COHERENT)
+    g_string_append (string, "coherent ");
+  if (type->flags & GSK_SL_POINTER_TYPE_VOLATILE)
+    g_string_append (string, "volatile ");
+  if (type->flags & GSK_SL_POINTER_TYPE_RESTRICT)
+    g_string_append (string, "restrict ");
+  if (type->flags & GSK_SL_POINTER_TYPE_READONLY)
+    g_string_append (string, "readonly ");
+  if (type->flags & GSK_SL_POINTER_TYPE_WRITEONLY)
+    g_string_append (string, "writeonly ");
+
+  g_string_append (string, gsk_sl_type_get_name (type->type));
+}
+
+GskSlType *
+gsk_sl_pointer_type_get_type (const GskSlPointerType *type)
+{
+  return type->type;
+}
+
+gboolean
+gsk_sl_pointer_type_is_const (const GskSlPointerType *type)
+{
+  return type->flags & GSK_SL_POINTER_TYPE_CONST ? TRUE : FALSE;
+}
+
+gboolean
+gsk_sl_pointer_type_is_in (const GskSlPointerType *type)
+{
+  return type->flags & GSK_SL_POINTER_TYPE_IN ? TRUE : FALSE;
+}
+
+gboolean
+gsk_sl_pointer_type_is_out (const GskSlPointerType *type)
+{
+  return type->flags & GSK_SL_POINTER_TYPE_OUT ? TRUE : FALSE;
+}
+
+gboolean
+gsk_sl_pointer_type_is_invariant (const GskSlPointerType *type)
+{
+  return type->flags & GSK_SL_POINTER_TYPE_INVARIANT ? TRUE : FALSE;
+}
+
+gboolean
+gsk_sl_pointer_type_is_coherent (const GskSlPointerType *type)
+{
+  return type->flags & GSK_SL_POINTER_TYPE_COHERENT ? TRUE : FALSE;
+}
+
+gboolean
+gsk_sl_pointer_type_is_volatile (const GskSlPointerType *type)
+{
+  return type->flags & GSK_SL_POINTER_TYPE_VOLATILE ? TRUE : FALSE;
+}
+
+gboolean
+gsk_sl_pointer_type_is_restrict (const GskSlPointerType *type)
+{
+  return type->flags & GSK_SL_POINTER_TYPE_RESTRICT ? TRUE : FALSE;
+}
+
+gboolean
+gsk_sl_pointer_type_is_readonly (const GskSlPointerType *type)
+{
+  return type->flags & GSK_SL_POINTER_TYPE_READONLY ? TRUE : FALSE;
+}
+
+gboolean
+gsk_sl_pointer_type_is_writeonly (const GskSlPointerType *type)
+{
+  return type->flags & GSK_SL_POINTER_TYPE_WRITEONLY ? TRUE : FALSE;
+}
diff --git a/gsk/gskslpointertypeprivate.h b/gsk/gskslpointertypeprivate.h
new file mode 100644
index 0000000..f0b5614
--- /dev/null
+++ b/gsk/gskslpointertypeprivate.h
@@ -0,0 +1,76 @@
+/* GTK - The GIMP Toolkit
+ *
+ * Copyright © 2017 Benjamin Otte <otte gnome org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GSK_SL_POINTER_TYPE_PRIVATE_H__
+#define __GSK_SL_POINTER_TYPE_PRIVATE_H__
+
+#include <glib.h>
+
+#include "gsksltypesprivate.h"
+
+G_BEGIN_DECLS
+
+typedef enum {
+  GSK_SL_POINTER_TYPE_LOCAL = (1 << 0),
+  GSK_SL_POINTER_TYPE_CONST = (1 << 1),
+  GSK_SL_POINTER_TYPE_IN = (1 << 2),
+  GSK_SL_POINTER_TYPE_OUT = (1 << 3),
+  GSK_SL_POINTER_TYPE_INVARIANT = (1 << 4),
+  GSK_SL_POINTER_TYPE_COHERENT = (1 << 5),
+  GSK_SL_POINTER_TYPE_VOLATILE = (1 << 6),
+  GSK_SL_POINTER_TYPE_RESTRICT = (1 << 7),
+  GSK_SL_POINTER_TYPE_READONLY = (1 << 8),
+  GSK_SL_POINTER_TYPE_WRITEONLY = (1 << 9)
+} GskSlPointerTypeFlags;
+
+#define GSK_SL_POINTER_TYPE_PARAMETER_QUALIFIER (GSK_SL_POINTER_TYPE_CONST \
+                                               | GSK_SL_POINTER_TYPE_IN \
+                                               | GSK_SL_POINTER_TYPE_OUT)
+#define GSK_SL_POINTER_TYPE_MEMORY_QUALIFIER (GSK_SL_POINTER_TYPE_COHERENT \
+                                            | GSK_SL_POINTER_TYPE_VOLATILE \
+                                            | GSK_SL_POINTER_TYPE_RESTRICT \
+                                            | GSK_SL_POINTER_TYPE_READONLY \
+                                            | GSK_SL_POINTER_TYPE_WRITEONLY)
+
+gboolean                gsk_sl_type_qualifier_parse                     (GskSlPreprocessor          *stream,
+                                                                         GskSlPointerTypeFlags       
allowed_flags,
+                                                                         GskSlPointerTypeFlags      
*parsed_flags);
+
+GskSlPointerType *      gsk_sl_pointer_type_new                         (GskSlType                  *type,
+                                                                         GskSlPointerTypeFlags       flags);
+
+GskSlPointerType *      gsk_sl_pointer_type_ref                         (GskSlPointerType           *type);
+void                    gsk_sl_pointer_type_unref                       (GskSlPointerType           *type);
+
+void                    gsk_sl_pointer_type_print                       (const GskSlPointerType     *type,
+                                                                         GString                    *string);
+
+GskSlType *             gsk_sl_pointer_type_get_type                    (const GskSlPointerType     *type);
+gboolean                gsk_sl_pointer_type_is_const                    (const GskSlPointerType     *type);
+gboolean                gsk_sl_pointer_type_is_in                       (const GskSlPointerType     *type);
+gboolean                gsk_sl_pointer_type_is_out                      (const GskSlPointerType     *type);
+gboolean                gsk_sl_pointer_type_is_invariant                (const GskSlPointerType     *type);
+gboolean                gsk_sl_pointer_type_is_coherent                 (const GskSlPointerType     *type);
+gboolean                gsk_sl_pointer_type_is_volatile                 (const GskSlPointerType     *type);
+gboolean                gsk_sl_pointer_type_is_restrict                 (const GskSlPointerType     *type);
+gboolean                gsk_sl_pointer_type_is_readonly                 (const GskSlPointerType     *type);
+gboolean                gsk_sl_pointer_type_is_writeonly                (const GskSlPointerType     *type);
+
+G_END_DECLS
+
+#endif /* __GSK_SL_POINTER_TYPE_PRIVATE_H__ */
diff --git a/gsk/gsksltypesprivate.h b/gsk/gsksltypesprivate.h
index cfe3f5c..d160d62 100644
--- a/gsk/gsksltypesprivate.h
+++ b/gsk/gsksltypesprivate.h
@@ -24,6 +24,7 @@
 typedef struct _GskSlFunction           GskSlFunction;
 typedef struct _GskSlNode               GskSlNode;
 typedef struct _GskSlPreprocessor       GskSlPreprocessor;
+typedef struct _GskSlPointerType        GskSlPointerType;
 typedef struct _GskSlScope              GskSlScope;
 typedef struct _GskSlToken              GskSlToken;
 typedef struct _GskSlType               GskSlType;
diff --git a/gsk/meson.build b/gsk/meson.build
index 2feca68..5b4f2ae 100644
--- a/gsk/meson.build
+++ b/gsk/meson.build
@@ -35,6 +35,7 @@ gsk_private_sources = files([
   'gskslfunction.c',
   'gskslnode.c',
   'gskslpreprocessor.c',
+  'gskslpointertype.c',
   'gskslscope.c',
   'gsksltokenizer.c',
   'gsksltype.c'


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]