clutter 2.2.4-x64-mingw32

data/vendor/local/include/json-glib-1.0/json-glib/json-types.h

@@ -0,0 +1,445 @@
+/* json-types.h - JSON data types
+ * 
+ * This file is part of JSON-GLib
+ * Copyright (C) 2007  OpenedHand Ltd.
+ * Copyright (C) 2009  Intel Corp.
+ *
+ * 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.1 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/>.
+ *
+ * Author:
+ *   Emmanuele Bassi  <ebassi@linux.intel.com>
+ */
+
+#ifndef __JSON_TYPES_H__
+#define __JSON_TYPES_H__
+
+#if !defined(__JSON_GLIB_INSIDE__) && !defined(JSON_COMPILATION)
+#error "Only <json-glib/json-glib.h> can be included directly."
+#endif
+
+#include <glib-object.h>
+#include <json-glib/json-version-macros.h>
+
+G_BEGIN_DECLS
+
+/**
+ * JSON_NODE_TYPE:
+ * @node: a #JsonNode
+ *
+ * Evaluates to the #JsonNodeType contained by @node
+ */
+#define JSON_NODE_TYPE(node)    (json_node_get_node_type ((node)))
+
+/**
+ * JSON_NODE_HOLDS:
+ * @node: a #JsonNode
+ * @t: a #JsonNodeType
+ *
+ * Evaluates to %TRUE if the @node holds type @t
+ *
+ * Since: 0.10
+ */
+#define JSON_NODE_HOLDS(node,t)         (json_node_get_node_type ((node)) == (t))
+
+/**
+ * JSON_NODE_HOLDS_VALUE:
+ * @node: a #JsonNode
+ *
+ * Evaluates to %TRUE if @node holds a %JSON_NODE_VALUE
+ *
+ * Since: 0.10
+ */
+#define JSON_NODE_HOLDS_VALUE(node)     (JSON_NODE_HOLDS ((node), JSON_NODE_VALUE))
+
+/**
+ * JSON_NODE_HOLDS_OBJECT:
+ * @node: a #JsonNode
+ *
+ * Evaluates to %TRUE if @node holds a %JSON_NODE_OBJECT
+ *
+ * Since: 0.10
+ */
+#define JSON_NODE_HOLDS_OBJECT(node)    (JSON_NODE_HOLDS ((node), JSON_NODE_OBJECT))
+
+/**
+ * JSON_NODE_HOLDS_ARRAY:
+ * @node: a #JsonNode
+ *
+ * Evaluates to %TRUE if @node holds a %JSON_NODE_ARRAY
+ *
+ * Since: 0.10
+ */
+#define JSON_NODE_HOLDS_ARRAY(node)     (JSON_NODE_HOLDS ((node), JSON_NODE_ARRAY))
+
+/**
+ * JSON_NODE_HOLDS_NULL:
+ * @node: a #JsonNode
+ *
+ * Evaluates to %TRUE if @node holds a %JSON_NODE_NULL
+ *
+ * Since: 0.10
+ */
+#define JSON_NODE_HOLDS_NULL(node)      (JSON_NODE_HOLDS ((node), JSON_NODE_NULL))
+
+#define JSON_TYPE_NODE          (json_node_get_type ())
+#define JSON_TYPE_OBJECT        (json_object_get_type ())
+#define JSON_TYPE_ARRAY         (json_array_get_type ())
+
+/**
+ * JsonNode:
+ *
+ * A generic container of JSON data types. The contents of the #JsonNode
+ * structure are private and should only be accessed via the provided
+ * functions and never directly.
+ */
+typedef struct _JsonNode        JsonNode;
+
+/**
+ * JsonObject:
+ *
+ * A JSON object type. The contents of the #JsonObject structure are private
+ * and should only be accessed by the provided API
+ */
+typedef struct _JsonObject      JsonObject;
+
+/**
+ * JsonArray:
+ *
+ * A JSON array type. The contents of the #JsonArray structure are private
+ * and should only be accessed by the provided API
+ */
+typedef struct _JsonArray       JsonArray;
+
+/**
+ * JsonNodeType:
+ * @JSON_NODE_OBJECT: The node contains a #JsonObject
+ * @JSON_NODE_ARRAY: The node contains a #JsonArray
+ * @JSON_NODE_VALUE: The node contains a fundamental type
+ * @JSON_NODE_NULL: Special type, for nodes containing null
+ *
+ * Indicates the content of a #JsonNode.
+ */
+typedef enum {
+  JSON_NODE_OBJECT,
+  JSON_NODE_ARRAY,
+  JSON_NODE_VALUE,
+  JSON_NODE_NULL
+} JsonNodeType;
+
+/**
+ * JsonObjectForeach:
+ * @object: the iterated #JsonObject
+ * @member_name: the name of the member
+ * @member_node: a #JsonNode containing the @member_name value
+ * @user_data: data passed to the function
+ *
+ * The function to be passed to json_object_foreach_member(). You
+ * should not add or remove members to and from @object within
+ * this function. It is safe to change the value of @member_node.
+ *
+ * Since: 0.8
+ */
+typedef void (* JsonObjectForeach) (JsonObject  *object,
+                                    const gchar *member_name,
+                                    JsonNode    *member_node,
+                                    gpointer     user_data);
+
+/**
+ * JsonArrayForeach:
+ * @array: the iterated #JsonArray
+ * @index_: the index of the element
+ * @element_node: a #JsonNode containing the value at @index_
+ * @user_data: data passed to the function
+ *
+ * The function to be passed to json_array_foreach_element(). You
+ * should not add or remove elements to and from @array within
+ * this function. It is safe to change the value of @element_node.
+ *
+ * Since: 0.8
+ */
+typedef void (* JsonArrayForeach) (JsonArray  *array,
+                                   guint       index_,
+                                   JsonNode   *element_node,
+                                   gpointer    user_data);
+
+/*
+ * JsonNode
+ */
+
+JSON_AVAILABLE_IN_1_0
+GType                 json_node_get_type        (void) G_GNUC_CONST;
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_new             (JsonNodeType  type);
+
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_alloc           (void);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_init            (JsonNode     *node,
+                                                 JsonNodeType  type);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_init_object     (JsonNode     *node,
+                                                 JsonObject   *object);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_init_array      (JsonNode     *node,
+                                                 JsonArray    *array);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_init_int        (JsonNode     *node,
+                                                 gint64        value);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_init_double     (JsonNode     *node,
+                                                 gdouble       value);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_init_boolean    (JsonNode     *node,
+                                                 gboolean      value);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_init_string     (JsonNode     *node,
+                                                 const char   *value);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_init_null       (JsonNode     *node);
+
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_copy            (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_free            (JsonNode     *node);
+
+JSON_AVAILABLE_IN_1_0
+JsonNodeType          json_node_get_node_type   (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+GType                 json_node_get_value_type  (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_set_parent      (JsonNode     *node,
+                                                 JsonNode     *parent);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_node_get_parent      (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+const gchar *         json_node_type_name       (JsonNode     *node);
+
+JSON_AVAILABLE_IN_1_0
+void                  json_node_set_object      (JsonNode     *node,
+                                                 JsonObject   *object);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_take_object     (JsonNode     *node,
+                                                 JsonObject   *object);
+JSON_AVAILABLE_IN_1_0
+JsonObject *          json_node_get_object      (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+JsonObject *          json_node_dup_object      (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_set_array       (JsonNode     *node,
+                                                 JsonArray    *array);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_take_array      (JsonNode     *node,
+                                                 JsonArray    *array);
+JSON_AVAILABLE_IN_1_0
+JsonArray *           json_node_get_array       (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+JsonArray *           json_node_dup_array       (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_set_value       (JsonNode     *node,
+                                                 const GValue *value);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_get_value       (JsonNode     *node,
+                                                 GValue       *value);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_set_string      (JsonNode     *node,
+                                                 const gchar  *value);
+JSON_AVAILABLE_IN_1_0
+const gchar *         json_node_get_string      (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+gchar *               json_node_dup_string      (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_set_int         (JsonNode     *node,
+                                                 gint64        value);
+JSON_AVAILABLE_IN_1_0
+gint64                json_node_get_int         (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_set_double      (JsonNode     *node,
+                                                 gdouble       value);
+JSON_AVAILABLE_IN_1_0
+gdouble               json_node_get_double      (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+void                  json_node_set_boolean     (JsonNode     *node,
+                                                 gboolean      value);
+JSON_AVAILABLE_IN_1_0
+gboolean              json_node_get_boolean     (JsonNode     *node);
+JSON_AVAILABLE_IN_1_0
+gboolean              json_node_is_null         (JsonNode     *node);
+
+/*
+ * JsonObject
+ */
+JSON_AVAILABLE_IN_1_0
+GType                 json_object_get_type           (void) G_GNUC_CONST;
+JSON_AVAILABLE_IN_1_0
+JsonObject *          json_object_new                (void);
+JSON_AVAILABLE_IN_1_0
+JsonObject *          json_object_ref                (JsonObject  *object);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_unref              (JsonObject  *object);
+
+JSON_DEPRECATED_IN_1_0_FOR(json_object_set_member)
+void                  json_object_add_member         (JsonObject  *object,
+                                                      const gchar *member_name,
+                                                      JsonNode    *node);
+
+JSON_AVAILABLE_IN_1_0
+void                  json_object_set_member         (JsonObject  *object,
+                                                      const gchar *member_name,
+                                                      JsonNode    *node);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_set_int_member     (JsonObject  *object,
+                                                      const gchar *member_name,
+                                                      gint64       value);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_set_double_member  (JsonObject  *object,
+                                                      const gchar *member_name,
+                                                      gdouble      value);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_set_boolean_member (JsonObject  *object,
+                                                      const gchar *member_name,
+                                                      gboolean     value);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_set_string_member  (JsonObject  *object,
+                                                      const gchar *member_name,
+                                                      const gchar *value);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_set_null_member    (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_set_array_member   (JsonObject  *object,
+                                                      const gchar *member_name,
+                                                      JsonArray   *value);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_set_object_member  (JsonObject  *object,
+                                                      const gchar *member_name,
+                                                      JsonObject  *value);
+JSON_AVAILABLE_IN_1_0
+GList *               json_object_get_members        (JsonObject  *object);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_object_get_member         (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_object_dup_member         (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+gint64                json_object_get_int_member     (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+gdouble               json_object_get_double_member  (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+gboolean              json_object_get_boolean_member (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+const gchar *         json_object_get_string_member  (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+gboolean              json_object_get_null_member    (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+JsonArray *           json_object_get_array_member   (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+JsonObject *          json_object_get_object_member  (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+gboolean              json_object_has_member         (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_remove_member      (JsonObject  *object,
+                                                      const gchar *member_name);
+JSON_AVAILABLE_IN_1_0
+GList *               json_object_get_values         (JsonObject  *object);
+JSON_AVAILABLE_IN_1_0
+guint                 json_object_get_size           (JsonObject  *object);
+JSON_AVAILABLE_IN_1_0
+void                  json_object_foreach_member     (JsonObject  *object,
+                                                      JsonObjectForeach func,
+                                                      gpointer     data);
+
+JSON_AVAILABLE_IN_1_0
+GType                 json_array_get_type            (void) G_GNUC_CONST;
+JSON_AVAILABLE_IN_1_0
+JsonArray *           json_array_new                 (void);
+JSON_AVAILABLE_IN_1_0
+JsonArray *           json_array_sized_new           (guint        n_elements);
+JSON_AVAILABLE_IN_1_0
+JsonArray *           json_array_ref                 (JsonArray   *array);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_unref               (JsonArray   *array);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_add_element         (JsonArray   *array,
+                                                      JsonNode    *node);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_add_int_element     (JsonArray   *array,
+                                                      gint64       value);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_add_double_element  (JsonArray   *array,
+                                                      gdouble      value);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_add_boolean_element (JsonArray   *array,
+                                                      gboolean     value);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_add_string_element  (JsonArray   *array,
+                                                      const gchar *value);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_add_null_element    (JsonArray   *array);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_add_array_element   (JsonArray   *array,
+                                                      JsonArray   *value);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_add_object_element  (JsonArray   *array,
+                                                      JsonObject  *value);
+JSON_AVAILABLE_IN_1_0
+GList *               json_array_get_elements        (JsonArray   *array);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_array_get_element         (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+gint64                json_array_get_int_element     (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+gdouble               json_array_get_double_element  (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+gboolean              json_array_get_boolean_element (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+const gchar *         json_array_get_string_element  (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+gboolean              json_array_get_null_element    (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+JsonArray *           json_array_get_array_element   (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+JsonObject *          json_array_get_object_element  (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+JsonNode *            json_array_dup_element         (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_remove_element      (JsonArray   *array,
+                                                      guint        index_);
+JSON_AVAILABLE_IN_1_0
+guint                 json_array_get_length          (JsonArray   *array);
+JSON_AVAILABLE_IN_1_0
+void                  json_array_foreach_element     (JsonArray   *array,
+                                                      JsonArrayForeach func,
+                                                      gpointer     data);
+
+G_END_DECLS
+
+#endif /* __JSON_TYPES_H__ */

data/vendor/local/include/json-glib-1.0/json-glib/json-version-macros.h

@@ -0,0 +1,135 @@
+/* json-version-macros.h - JSON-GLib symbol versioning macros
+ * 
+ * This file is part of JSON-GLib
+ * Copyright © 2014  Emmanuele Bassi
+ *
+ * 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.1 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 __JSON_VERSION_MACROS_H__
+#define __JSON_VERSION_MACROS_H__
+
+#if !defined(__JSON_GLIB_INSIDE__) && !defined(JSON_COMPILATION)
+#error "Only <json-glib/json-glib.h> can be included directly."
+#endif
+
+#include "json-version.h"
+
+#ifndef _JSON_EXTERN
+#define _JSON_EXTERN extern
+#endif
+
+#ifdef JSON_DISABLE_DEPRECATION_WARNINGS
+#define JSON_DEPRECATED _JSON_EXTERN
+#define JSON_DEPRECATED_FOR(f) _JSON_EXTERN
+#define JSON_UNAVAILABLE(maj,min) _JSON_EXTERN
+#else
+#define JSON_DEPRECATED G_DEPRECATED _JSON_EXTERN
+#define JSON_DEPRECATED_FOR(f) G_DEPRECATED_FOR(f) _JSON_EXTERN
+#define JSON_UNAVAILABLE(maj,min) G_UNAVAILABLE(maj,min) _JSON_EXTERN
+#endif
+
+/* XXX: Each new cycle should add a new version symbol here */
+#define JSON_VERSION_1_0        (G_ENCODE_VERSION (1, 0))
+
+/* evaluates to the current stable version; for development cycles,
+ * this means the next stable target
+ */
+#if (JSON_MINOR_VERSION == 99)
+#define JSON_VERSION_CUR_STABLE         (G_ENCODE_VERSION (JSON_MAJOR_VERSION + 1, 0))
+#elif (JSON_MINOR_VERSION % 2)
+#define JSON_VERSION_CUR_STABLE         (G_ENCODE_VERSION (JSON_MAJOR_VERSION, JSON_MINOR_VERSION + 1))
+#else
+#define JSON_VERSION_CUR_STABLE         (G_ENCODE_VERSION (JSON_MAJOR_VERSION, JSON_MINOR_VERSION))
+#endif
+
+/* evaluates to the previous stable version */
+#if (JSON_MINOR_VERSION == 99)
+#define JSON_VERSION_PREV_STABLE        (G_ENCODE_VERSION (JSON_MAJOR_VERSION + 1, 0))
+#elif (JSON_MINOR_VERSION % 2)
+#define JSON_VERSION_PREV_STABLE        (G_ENCODE_VERSION (JSON_MAJOR_VERSION, JSON_MINOR_VERSION - 1))
+#else
+#define JSON_VERSION_PREV_STABLE        (G_ENCODE_VERSION (JSON_MAJOR_VERSION, JSON_MINOR_VERSION - 2))
+#endif
+
+/**
+ * JSON_VERSION_MIN_REQUIRED:
+ *
+ * A macro that should be defined by the user prior to including
+ * the gdk.h header.
+ * The definition should be one of the predefined JSON version
+ * macros: %JSON_VERSION_1_0, %JSON_VERSION_1_2,...
+ *
+ * This macro defines the lower bound for the JSON-GLib API to use.
+ *
+ * If a function has been deprecated in a newer version of JSON-GLib,
+ * it is possible to use this symbol to avoid the compiler warnings
+ * without disabling warning for every deprecated function.
+ *
+ * Since: 1.0
+ */
+#ifndef JSON_VERSION_MIN_REQUIRED
+# define JSON_VERSION_MIN_REQUIRED      (JSON_VERSION_CUR_STABLE)
+#endif
+
+/**
+ * JSON_VERSION_MAX_ALLOWED:
+ *
+ * A macro that should be defined by the user prior to including
+ * the json-glib.h header.
+
+ * The definition should be one of the predefined JSON-GLib version
+ * macros: %JSON_VERSION_1_0, %JSON_VERSION_1_2,...
+ *
+ * This macro defines the upper bound for the JSON API-GLib to use.
+ *
+ * If a function has been introduced in a newer version of JSON-GLib,
+ * it is possible to use this symbol to get compiler warnings when
+ * trying to use that function.
+ *
+ * Since: 1.0
+ */
+#ifndef JSON_VERSION_MAX_ALLOWED
+# if JSON_VERSION_MIN_REQUIRED > JSON_VERSION_PREV_STABLE
+#  define JSON_VERSION_MAX_ALLOWED      (JSON_VERSION_MIN_REQUIRED)
+# else
+#  define JSON_VERSION_MAX_ALLOWED      (JSON_VERSION_CUR_STABLE)
+# endif
+#endif
+
+/* sanity checks */
+#if JSON_VERSION_MAX_ALLOWED < JSON_VERSION_MIN_REQUIRED
+#error "JSON_VERSION_MAX_ALLOWED must be >= JSON_VERSION_MIN_REQUIRED"
+#endif
+#if JSON_VERSION_MIN_REQUIRED < JSON_VERSION_1_0
+#error "JSON_VERSION_MIN_REQUIRED must be >= JSON_VERSION_1_0"
+#endif
+
+/* XXX: Every new stable minor release should add a set of macros here */
+
+#if JSON_VERSION_MIN_REQUIRED >= JSON_VERSION_1_0
+# define JSON_DEPRECATED_IN_1_0                JSON_DEPRECATED
+# define JSON_DEPRECATED_IN_1_0_FOR(f)         JSON_DEPRECATED_FOR(f)
+#else
+# define JSON_DEPRECATED_IN_1_0                _JSON_EXTERN
+# define JSON_DEPRECATED_IN_1_0_FOR(f)         _JSON_EXTERN
+#endif
+
+#if JSON_VERSION_MAX_ALLOWED < JSON_VERSION_1_0
+# define JSON_AVAILABLE_IN_1_0                 JSON_UNAVAILABLE(1, 0)
+#else
+# define JSON_AVAILABLE_IN_1_0                 _JSON_EXTERN
+#endif
+
+#endif /* __JSON_VERSION_MACROS_H__ */