glib2 3.0.7-x64-mingw32 → 3.0.8-x64-mingw32

data/vendor/local/bin/pcre-config

@@ -0,0 +1,133 @@
+#!/bin/sh
+
+prefix=/home/vagrant/ruby-gnome2.win64/glib2/vendor/local
+exec_prefix=${prefix}
+exec_prefix_set=no
+
+cflags="[--cflags]"
+
+if test yes = yes ; then
+  libs="[--libs-cpp]"
+else
+  libs=
+fi
+
+if test no = yes ; then
+  libs="[--libs16] $libs"
+fi
+
+if test no = yes ; then
+  libs="[--libs32] $libs"
+fi
+
+if test yes = yes ; then
+  libs="[--libs] [--libs-posix] $libs"
+  cflags="$cflags [--cflags-posix]"
+fi
+
+usage="Usage: pcre-config [--prefix] [--exec-prefix] [--version] $libs $cflags"
+
+if test $# -eq 0; then
+      echo "${usage}" 1>&2
+      exit 1
+fi
+
+libR=
+case `uname -s` in
+  *SunOS*)
+  libR=" -R${exec_prefix}/lib"
+  ;;
+  *BSD*)
+  libR=" -Wl,-R${exec_prefix}/lib"
+  ;;
+esac
+
+libS=
+if test ${exec_prefix}/lib != /usr/lib ; then
+  libS=-L${exec_prefix}/lib
+fi
+
+while test $# -gt 0; do
+  case "$1" in
+  -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
+  *) optarg= ;;
+  esac
+
+  case $1 in
+    --prefix=*)
+      prefix=$optarg
+      if test $exec_prefix_set = no ; then
+        exec_prefix=$optarg
+      fi
+      ;;
+    --prefix)
+      echo $prefix
+      ;;
+    --exec-prefix=*)
+      exec_prefix=$optarg
+      exec_prefix_set=yes
+      ;;
+    --exec-prefix)
+      echo $exec_prefix
+      ;;
+    --version)
+      echo 8.38
+      ;;
+    --cflags)
+      if test ${prefix}/include != /usr/include ; then
+        includes=-I${prefix}/include
+      fi
+      echo $includes 
+      ;;
+    --cflags-posix)
+      if test yes = yes ; then
+        if test ${prefix}/include != /usr/include ; then
+          includes=-I${prefix}/include
+        fi
+        echo $includes 
+      else
+        echo "${usage}" 1>&2
+      fi
+      ;;
+    --libs-posix)
+      if test yes = yes ; then
+        echo $libS$libR -lpcreposix -lpcre
+      else
+        echo "${usage}" 1>&2
+      fi
+      ;;
+    --libs)
+      if test yes = yes ; then
+        echo $libS$libR -lpcre
+      else
+        echo "${usage}" 1>&2
+      fi
+      ;;
+    --libs16)
+      if test no = yes ; then
+        echo $libS$libR -lpcre16
+      else
+        echo "${usage}" 1>&2
+      fi
+      ;;
+    --libs32)
+      if test no = yes ; then
+        echo $libS$libR -lpcre32
+      else
+        echo "${usage}" 1>&2
+      fi
+      ;;
+    --libs-cpp)
+      if test yes = yes ; then
+        echo $libS$libR -lpcrecpp -lpcre
+      else
+        echo "${usage}" 1>&2
+      fi
+      ;;
+    *)
+      echo "${usage}" 1>&2
+      exit 1
+      ;;
+  esac
+  shift
+done

data/vendor/local/include/glib-2.0/gio/gdatagrambased.h

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2015 Collabora Ltd.
+ *
+ * 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/>.
+ *
+ * Authors: Philip Withnall <philip.withnall@collabora.co.uk>
+ */
+
+#ifndef __G_DATAGRAM_BASED_H__
+#define __G_DATAGRAM_BASED_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_DATAGRAM_BASED             (g_datagram_based_get_type ())
+#define G_DATAGRAM_BASED(inst)            (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
+                                           G_TYPE_DATAGRAM_BASED, GDatagramBased))
+#define G_IS_DATAGRAM_BASED(inst)         (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
+                                           G_TYPE_DATAGRAM_BASED))
+#define G_DATAGRAM_BASED_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), \
+                                           G_TYPE_DATAGRAM_BASED, \
+                                           GDatagramBasedInterface))
+#define G_TYPE_IS_DATAGRAM_BASED(type)    (g_type_is_a ((type), \
+                                           G_TYPE_DATAGRAM_BASED))
+
+/**
+ * GDatagramBased:
+ *
+ * Interface for socket-like objects with datagram semantics.
+ *
+ * Since: 2.48
+ */
+typedef struct _GDatagramBasedInterface GDatagramBasedInterface;
+
+/**
+ * GDatagramBasedInterface:
+ * @g_iface: The parent interface.
+ * @receive_messages: Virtual method for g_datagram_based_receive_messages().
+ * @send_messages: Virtual method for g_datagram_based_send_messages().
+ * @create_source: Virtual method for g_datagram_based_create_source().
+ * @condition_check: Virtual method for g_datagram_based_condition_check().
+ * @condition_wait: Virtual method for
+ *   g_datagram_based_condition_wait().
+ *
+ * Provides an interface for socket-like objects which have datagram semantics,
+ * following the Berkeley sockets API. The interface methods are thin wrappers
+ * around the corresponding virtual methods, and no pre-processing of inputs is
+ * implemented — so implementations of this API must handle all functionality
+ * documented in the interface methods.
+ *
+ * Since: 2.48
+ */
+struct _GDatagramBasedInterface
+{
+  GTypeInterface g_iface;
+
+  /* Virtual table */
+  gint          (*receive_messages)     (GDatagramBased       *datagram_based,
+                                         GInputMessage        *messages,
+                                         guint                 num_messages,
+                                         gint                  flags,
+                                         gint64                timeout,
+                                         GCancellable         *cancellable,
+                                         GError              **error);
+  gint          (*send_messages)        (GDatagramBased       *datagram_based,
+                                         GOutputMessage       *messages,
+                                         guint                 num_messages,
+                                         gint                  flags,
+                                         gint64                timeout,
+                                         GCancellable         *cancellable,
+                                         GError              **error);
+
+  GSource      *(*create_source)        (GDatagramBased       *datagram_based,
+                                         GIOCondition          condition,
+                                         GCancellable         *cancellable);
+  GIOCondition  (*condition_check)      (GDatagramBased       *datagram_based,
+                                         GIOCondition          condition);
+  gboolean      (*condition_wait)       (GDatagramBased       *datagram_based,
+                                         GIOCondition          condition,
+                                         gint64                timeout,
+                                         GCancellable         *cancellable,
+                                         GError              **error);
+};
+
+GLIB_AVAILABLE_IN_2_48
+GType
+g_datagram_based_get_type             (void);
+
+GLIB_AVAILABLE_IN_2_48
+gint
+g_datagram_based_receive_messages     (GDatagramBased       *datagram_based,
+                                       GInputMessage        *messages,
+                                       guint                 num_messages,
+                                       gint                  flags,
+                                       gint64                timeout,
+                                       GCancellable         *cancellable,
+                                       GError              **error);
+
+GLIB_AVAILABLE_IN_2_48
+gint
+g_datagram_based_send_messages        (GDatagramBased       *datagram_based,
+                                       GOutputMessage       *messages,
+                                       guint                 num_messages,
+                                       gint                  flags,
+                                       gint64                timeout,
+                                       GCancellable         *cancellable,
+                                       GError              **error);
+
+GLIB_AVAILABLE_IN_2_48
+GSource *
+g_datagram_based_create_source        (GDatagramBased       *datagram_based,
+                                       GIOCondition          condition,
+                                       GCancellable         *cancellable);
+GLIB_AVAILABLE_IN_2_48
+GIOCondition
+g_datagram_based_condition_check      (GDatagramBased       *datagram_based,
+                                       GIOCondition          condition);
+GLIB_AVAILABLE_IN_2_48
+gboolean
+g_datagram_based_condition_wait       (GDatagramBased       *datagram_based,
+                                       GIOCondition          condition,
+                                       gint64                timeout,
+                                       GCancellable         *cancellable,
+                                       GError              **error);
+
+G_END_DECLS
+
+#endif /* __G_DATAGRAM_BASED_H__ */

data/vendor/local/include/glib-2.0/gio/gdbusconnection.h

@@ -401,6 +401,14 @@ guint            g_dbus_connection_register_object            (GDBusConnection
                                                                gpointer                    user_data,
                                                                GDestroyNotify              user_data_free_func,
                                                                GError                    **error);
+GLIB_AVAILABLE_IN_2_46
+guint            g_dbus_connection_register_object_with_closures (GDBusConnection         *connection,
+                                                                  const gchar             *object_path,
+                                                                  GDBusInterfaceInfo      *interface_info,
+                                                                  GClosure                *method_call_closure,
+                                                                  GClosure                *get_property_closure,
+                                                                  GClosure                *set_property_closure,
+                                                                  GError                 **error);
 GLIB_AVAILABLE_IN_ALL
 gboolean         g_dbus_connection_unregister_object          (GDBusConnection            *connection,
                                                                guint                       registration_id);
@@ -479,7 +487,7 @@ typedef GDBusInterfaceInfo ** (*GDBusSubtreeIntrospectFunc) (GDBusConnection
  * @object_path: The object path that was registered with g_dbus_connection_register_subtree().
  * @interface_name: The D-Bus interface name that the method call or property access is for.
  * @node: A node that is a child of @object_path (relative to @object_path) or %NULL for the root of the subtree.
- * @out_user_data: Return location for user data to pass to functions in the returned #GDBusInterfaceVTable (never %NULL).
+ * @out_user_data: (nullable) (not optional): Return location for user data to pass to functions in the returned #GDBusInterfaceVTable (never %NULL).
  * @user_data: The @user_data #gpointer passed to g_dbus_connection_register_subtree().
  *
  * The type of the @dispatch function in #GDBusSubtreeVTable.

data/vendor/local/include/glib-2.0/gio/gdtlsclientconnection.h

@@ -0,0 +1,75 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright © 2010 Red Hat, Inc.
+ * Copyright © 2015 Collabora, Ltd.
+ *
+ * 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 __G_DTLS_CLIENT_CONNECTION_H__
+#define __G_DTLS_CLIENT_CONNECTION_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/gdtlsconnection.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_DTLS_CLIENT_CONNECTION                (g_dtls_client_connection_get_type ())
+#define G_DTLS_CLIENT_CONNECTION(inst)               (G_TYPE_CHECK_INSTANCE_CAST ((inst), G_TYPE_DTLS_CLIENT_CONNECTION, GDtlsClientConnection))
+#define G_IS_DTLS_CLIENT_CONNECTION(inst)            (G_TYPE_CHECK_INSTANCE_TYPE ((inst), G_TYPE_DTLS_CLIENT_CONNECTION))
+#define G_DTLS_CLIENT_CONNECTION_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), G_TYPE_DTLS_CLIENT_CONNECTION, GDtlsClientConnectionInterface))
+
+typedef struct _GDtlsClientConnectionInterface GDtlsClientConnectionInterface;
+
+/**
+ * GDtlsClientConnectionInterface:
+ * @g_iface: The parent interface.
+ *
+ * vtable for a #GDtlsClientConnection implementation.
+ *
+ * Since: 2.48
+ */
+struct _GDtlsClientConnectionInterface
+{
+  GTypeInterface g_iface;
+};
+
+GLIB_AVAILABLE_IN_2_48
+GType                g_dtls_client_connection_get_type             (void) G_GNUC_CONST;
+
+GLIB_AVAILABLE_IN_2_48
+GDatagramBased      *g_dtls_client_connection_new                  (GDatagramBased         *base_socket,
+                                                                    GSocketConnectable     *server_identity,
+                                                                    GError                **error);
+
+GLIB_AVAILABLE_IN_2_48
+GTlsCertificateFlags g_dtls_client_connection_get_validation_flags (GDtlsClientConnection  *conn);
+GLIB_AVAILABLE_IN_2_48
+void                 g_dtls_client_connection_set_validation_flags (GDtlsClientConnection  *conn,
+                                                                    GTlsCertificateFlags    flags);
+GLIB_AVAILABLE_IN_2_48
+GSocketConnectable  *g_dtls_client_connection_get_server_identity  (GDtlsClientConnection  *conn);
+GLIB_AVAILABLE_IN_2_48
+void                 g_dtls_client_connection_set_server_identity  (GDtlsClientConnection  *conn,
+                                                                    GSocketConnectable     *identity);
+GLIB_AVAILABLE_IN_2_48
+GList *              g_dtls_client_connection_get_accepted_cas     (GDtlsClientConnection  *conn);
+
+
+G_END_DECLS
+
+#endif /* __G_DTLS_CLIENT_CONNECTION_H__ */

data/vendor/local/include/glib-2.0/gio/gdtlsconnection.h

@@ -0,0 +1,191 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright © 2010 Red Hat, Inc.
+ * Copyright © 2015 Collabora, Ltd.
+ *
+ * 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 __G_DTLS_CONNECTION_H__
+#define __G_DTLS_CONNECTION_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/gdatagrambased.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_DTLS_CONNECTION                (g_dtls_connection_get_type ())
+#define G_DTLS_CONNECTION(inst)               (G_TYPE_CHECK_INSTANCE_CAST ((inst), G_TYPE_DTLS_CONNECTION, GDtlsConnection))
+#define G_IS_DTLS_CONNECTION(inst)            (G_TYPE_CHECK_INSTANCE_TYPE ((inst), G_TYPE_DTLS_CONNECTION))
+#define G_DTLS_CONNECTION_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), G_TYPE_DTLS_CONNECTION, GDtlsConnectionInterface))
+
+typedef struct _GDtlsConnectionInterface GDtlsConnectionInterface;
+
+/**
+ * GDtlsConnectionInterface:
+ * @g_iface: The parent interface.
+ * @accept_certificate: Check whether to accept a certificate.
+ * @handshake: Perform a handshake operation.
+ * @handshake_async: Start an asynchronous handshake operation.
+ * @handshake_finish: Finish an asynchronous handshake operation.
+ * @shutdown: Shut down one or both directions of the connection.
+ * @shutdown_async: Start an asynchronous shutdown operation.
+ * @shutdown_finish: Finish an asynchronous shutdown operation.
+ *
+ * Virtual method table for a #GDtlsConnection implementation.
+ *
+ * Since: 2.48
+ */
+struct _GDtlsConnectionInterface
+{
+  GTypeInterface g_iface;
+
+  /* signals */
+  gboolean (*accept_certificate) (GDtlsConnection       *connection,
+                                  GTlsCertificate       *peer_cert,
+                                  GTlsCertificateFlags   errors);
+
+  /* methods */
+  gboolean (*handshake)          (GDtlsConnection       *conn,
+                                  GCancellable          *cancellable,
+                                  GError               **error);
+
+  void     (*handshake_async)    (GDtlsConnection       *conn,
+                                  int                    io_priority,
+                                  GCancellable          *cancellable,
+                                  GAsyncReadyCallback    callback,
+                                  gpointer               user_data);
+  gboolean (*handshake_finish)   (GDtlsConnection       *conn,
+                                  GAsyncResult          *result,
+                                  GError               **error);
+
+  gboolean (*shutdown)           (GDtlsConnection       *conn,
+                                  gboolean               shutdown_read,
+                                  gboolean               shutdown_write,
+                                  GCancellable          *cancellable,
+                                  GError               **error);
+
+  void     (*shutdown_async)     (GDtlsConnection       *conn,
+                                  gboolean               shutdown_read,
+                                  gboolean               shutdown_write,
+                                  int                    io_priority,
+                                  GCancellable          *cancellable,
+                                  GAsyncReadyCallback    callback,
+                                  gpointer               user_data);
+  gboolean (*shutdown_finish)    (GDtlsConnection       *conn,
+                                  GAsyncResult          *result,
+                                  GError               **error);
+};
+
+GLIB_AVAILABLE_IN_2_48
+GType                 g_dtls_connection_get_type                    (void) G_GNUC_CONST;
+
+GLIB_AVAILABLE_IN_2_48
+void                  g_dtls_connection_set_database                (GDtlsConnection       *conn,
+                                                                     GTlsDatabase          *database);
+GLIB_AVAILABLE_IN_2_48
+GTlsDatabase         *g_dtls_connection_get_database                (GDtlsConnection       *conn);
+
+GLIB_AVAILABLE_IN_2_48
+void                  g_dtls_connection_set_certificate             (GDtlsConnection       *conn,
+                                                                     GTlsCertificate       *certificate);
+GLIB_AVAILABLE_IN_2_48
+GTlsCertificate      *g_dtls_connection_get_certificate             (GDtlsConnection       *conn);
+
+GLIB_AVAILABLE_IN_2_48
+void                  g_dtls_connection_set_interaction             (GDtlsConnection       *conn,
+                                                                     GTlsInteraction       *interaction);
+GLIB_AVAILABLE_IN_2_48
+GTlsInteraction      *g_dtls_connection_get_interaction             (GDtlsConnection       *conn);
+
+GLIB_AVAILABLE_IN_2_48
+GTlsCertificate      *g_dtls_connection_get_peer_certificate        (GDtlsConnection       *conn);
+GLIB_AVAILABLE_IN_2_48
+GTlsCertificateFlags  g_dtls_connection_get_peer_certificate_errors (GDtlsConnection       *conn);
+
+GLIB_AVAILABLE_IN_2_48
+void                  g_dtls_connection_set_require_close_notify    (GDtlsConnection       *conn,
+                                                                     gboolean               require_close_notify);
+GLIB_AVAILABLE_IN_2_48
+gboolean              g_dtls_connection_get_require_close_notify    (GDtlsConnection       *conn);
+
+GLIB_AVAILABLE_IN_2_48
+void                  g_dtls_connection_set_rehandshake_mode        (GDtlsConnection       *conn,
+                                                                     GTlsRehandshakeMode    mode);
+GLIB_AVAILABLE_IN_2_48
+GTlsRehandshakeMode   g_dtls_connection_get_rehandshake_mode        (GDtlsConnection       *conn);
+
+GLIB_AVAILABLE_IN_2_48
+gboolean              g_dtls_connection_handshake                   (GDtlsConnection       *conn,
+                                                                     GCancellable          *cancellable,
+                                                                     GError               **error);
+
+GLIB_AVAILABLE_IN_2_48
+void                  g_dtls_connection_handshake_async             (GDtlsConnection       *conn,
+                                                                     int                    io_priority,
+                                                                     GCancellable          *cancellable,
+                                                                     GAsyncReadyCallback    callback,
+                                                                     gpointer               user_data);
+GLIB_AVAILABLE_IN_2_48
+gboolean              g_dtls_connection_handshake_finish            (GDtlsConnection       *conn,
+                                                                     GAsyncResult          *result,
+                                                                     GError               **error);
+
+GLIB_AVAILABLE_IN_2_48
+gboolean              g_dtls_connection_shutdown                    (GDtlsConnection       *conn,
+                                                                     gboolean               shutdown_read,
+                                                                     gboolean               shutdown_write,
+                                                                     GCancellable          *cancellable,
+                                                                     GError               **error);
+
+GLIB_AVAILABLE_IN_2_48
+void                  g_dtls_connection_shutdown_async              (GDtlsConnection       *conn,
+                                                                     gboolean               shutdown_read,
+                                                                     gboolean               shutdown_write,
+                                                                     int                    io_priority,
+                                                                     GCancellable          *cancellable,
+                                                                     GAsyncReadyCallback    callback,
+                                                                     gpointer               user_data);
+GLIB_AVAILABLE_IN_2_48
+gboolean              g_dtls_connection_shutdown_finish             (GDtlsConnection       *conn,
+                                                                     GAsyncResult          *result,
+                                                                     GError               **error);
+
+GLIB_AVAILABLE_IN_2_48
+gboolean              g_dtls_connection_close                       (GDtlsConnection       *conn,
+                                                                     GCancellable          *cancellable,
+                                                                     GError               **error);
+
+GLIB_AVAILABLE_IN_2_48
+void                  g_dtls_connection_close_async                 (GDtlsConnection       *conn,
+                                                                     int                    io_priority,
+                                                                     GCancellable          *cancellable,
+                                                                     GAsyncReadyCallback    callback,
+                                                                     gpointer               user_data);
+GLIB_AVAILABLE_IN_2_48
+gboolean              g_dtls_connection_close_finish                (GDtlsConnection       *conn,
+                                                                     GAsyncResult          *result,
+                                                                     GError               **error);
+
+/*< protected >*/
+GLIB_AVAILABLE_IN_2_48
+gboolean              g_dtls_connection_emit_accept_certificate     (GDtlsConnection       *conn,
+                                                                     GTlsCertificate       *peer_cert,
+                                                                     GTlsCertificateFlags   errors);
+G_END_DECLS
+
+#endif /* __G_DTLS_CONNECTION_H__ */