[gtk+/wip/otte/shader: 10/33] gsk: Add GskSlPointerType
- From: Benjamin Otte <otte src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+/wip/otte/shader: 10/33] gsk: Add GskSlPointerType
- Date: Wed, 27 Sep 2017 01:44:51 +0000 (UTC)
commit c92043dad92b36d97c2ca518068b06e6ee455881
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 22a4ba4..0fda4fd 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
@@ -1973,13 +1974,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))
@@ -2047,6 +2048,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:
@@ -2094,21 +2105,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..d9e4aaa
--- /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 (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 61e37b4..b13a33f 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]
