libyajl2 0.1.4 → 0.1.5

data/ext/libyajl2/api/yajl_tree.h

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2010-2011  Florian Forster  <ff at octo.it>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * \file yajl_tree.h
+ *
+ * Parses JSON data and returns the data in tree form.
+ *
+ * \author Florian Forster
+ * \date August 2010
+ *
+ * This interface makes quick parsing and extraction of
+ * smallish JSON docs trivial:
+ *
+ * \include example/parse_config.c
+ */
+
+#ifndef YAJL_TREE_H
+#define YAJL_TREE_H 1
+
+#include <yajl/yajl_common.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** possible data types that a yajl_val_s can hold */
+typedef enum {
+    yajl_t_string = 1,
+    yajl_t_number = 2,
+    yajl_t_object = 3,
+    yajl_t_array = 4,
+    yajl_t_true = 5,
+    yajl_t_false = 6,
+    yajl_t_null = 7,
+    /** The any type isn't valid for yajl_val_s.type, but can be
+     *  used as an argument to routines like yajl_tree_get().
+     */
+    yajl_t_any = 8
+} yajl_type;
+
+#define YAJL_NUMBER_INT_VALID    0x01
+#define YAJL_NUMBER_DOUBLE_VALID 0x02
+
+/** A pointer to a node in the parse tree */
+typedef struct yajl_val_s * yajl_val;
+
+/**
+ * A JSON value representation capable of holding one of the seven
+ * types above. For "string", "number", "object", and "array"
+ * additional data is available in the union.  The "YAJL_IS_*"
+ * and "YAJL_GET_*" macros below allow type checking and convenient
+ * value extraction.
+ */
+struct yajl_val_s
+{
+    /** Type of the value contained. Use the "YAJL_IS_*" macros to check for a
+     * specific type. */
+    yajl_type type;
+    /** Type-specific data. You may use the "YAJL_GET_*" macros to access these
+     * members. */
+    union
+    {
+        char * string;
+        struct {
+            long long i; /*< integer value, if representable. */
+            double  d;   /*< double value, if representable. */
+            char   *r;   /*< unparsed number in string form. */
+            /** Signals whether the \em i and \em d members are
+             * valid. See \c YAJL_NUMBER_INT_VALID and
+             * \c YAJL_NUMBER_DOUBLE_VALID. */
+            unsigned int flags;
+        } number;
+        struct {
+            const char **keys; /*< Array of keys */
+            yajl_val *values; /*< Array of values. */
+            size_t len; /*< Number of key-value-pairs. */
+        } object;
+        struct {
+            yajl_val *values; /*< Array of elements. */
+            size_t len; /*< Number of elements. */
+        } array;
+    } u;
+};
+
+/**
+ * Parse a string.
+ *
+ * Parses an null-terminated string containing JSON data and returns a pointer
+ * to the top-level value (root of the parse tree).
+ *
+ * \param input              Pointer to a null-terminated utf8 string containing
+ *                           JSON data.
+ * \param error_buffer       Pointer to a buffer in which an error message will
+ *                           be stored if \em yajl_tree_parse fails, or
+ *                           \c NULL. The buffer will be initialized before
+ *                           parsing, so its content will be destroyed even if
+ *                           \em yajl_tree_parse succeeds.
+ * \param error_buffer_size  Size of the memory area pointed to by
+ *                           \em error_buffer_size. If \em error_buffer_size is
+ *                           \c NULL, this argument is ignored.
+ *
+ * \returns Pointer to the top-level value or \c NULL on error. The memory
+ * pointed to must be freed using \em yajl_tree_free. In case of an error, a
+ * null terminated message describing the error in more detail is stored in
+ * \em error_buffer if it is not \c NULL.
+ */
+YAJL_API yajl_val yajl_tree_parse (const char *input,
+                                   char *error_buffer, size_t error_buffer_size);
+
+
+/**
+ * Free a parse tree returned by "yajl_tree_parse".
+ *
+ * \param v Pointer to a JSON value returned by "yajl_tree_parse". Passing NULL
+ * is valid and results in a no-op.
+ */
+YAJL_API void yajl_tree_free (yajl_val v);
+
+/**
+ * Access a nested value inside a tree.
+ *
+ * \param parent the node under which you'd like to extract values.
+ * \param path A null terminated array of strings, each the name of an object key
+ * \param type the yajl_type of the object you seek, or yajl_t_any if any will do.
+ *
+ * \returns a pointer to the found value, or NULL if we came up empty.
+ *
+ * Future Ideas:  it'd be nice to move path to a string and implement support for
+ * a teeny tiny micro language here, so you can extract array elements, do things
+ * like .first and .last, even .length.  Inspiration from JSONPath and css selectors?
+ * No it wouldn't be fast, but that's not what this API is about.
+ */
+YAJL_API yajl_val yajl_tree_get(yajl_val parent, const char ** path, yajl_type type);
+
+/* Various convenience macros to check the type of a `yajl_val` */
+#define YAJL_IS_STRING(v) (((v) != NULL) && ((v)->type == yajl_t_string))
+#define YAJL_IS_NUMBER(v) (((v) != NULL) && ((v)->type == yajl_t_number))
+#define YAJL_IS_INTEGER(v) (YAJL_IS_NUMBER(v) && ((v)->u.number.flags & YAJL_NUMBER_INT_VALID))
+#define YAJL_IS_DOUBLE(v) (YAJL_IS_NUMBER(v) && ((v)->u.number.flags & YAJL_NUMBER_DOUBLE_VALID))
+#define YAJL_IS_OBJECT(v) (((v) != NULL) && ((v)->type == yajl_t_object))
+#define YAJL_IS_ARRAY(v)  (((v) != NULL) && ((v)->type == yajl_t_array ))
+#define YAJL_IS_TRUE(v)   (((v) != NULL) && ((v)->type == yajl_t_true  ))
+#define YAJL_IS_FALSE(v)  (((v) != NULL) && ((v)->type == yajl_t_false ))
+#define YAJL_IS_NULL(v)   (((v) != NULL) && ((v)->type == yajl_t_null  ))
+
+/** Given a yajl_val_string return a ptr to the bare string it contains,
+ *  or NULL if the value is not a string. */
+#define YAJL_GET_STRING(v) (YAJL_IS_STRING(v) ? (v)->u.string : NULL)
+
+/** Get the string representation of a number.  You should check type first,
+ *  perhaps using YAJL_IS_NUMBER */
+#define YAJL_GET_NUMBER(v) ((v)->u.number.r)
+
+/** Get the double representation of a number.  You should check type first,
+ *  perhaps using YAJL_IS_DOUBLE */
+#define YAJL_GET_DOUBLE(v) ((v)->u.number.d)
+
+/** Get the 64bit (long long) integer representation of a number.  You should
+ *  check type first, perhaps using YAJL_IS_INTEGER */
+#define YAJL_GET_INTEGER(v) ((v)->u.number.i)
+
+/** Get a pointer to a yajl_val_object or NULL if the value is not an object. */
+#define YAJL_GET_OBJECT(v) (YAJL_IS_OBJECT(v) ? &(v)->u.object : NULL)
+
+/** Get a pointer to a yajl_val_array or NULL if the value is not an object. */
+#define YAJL_GET_ARRAY(v)  (YAJL_IS_ARRAY(v)  ? &(v)->u.array  : NULL)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YAJL_TREE_H */

data/ext/libyajl2/api/yajl_version.h

@@ -0,0 +1,23 @@
+#ifndef YAJL_VERSION_H_
+#define YAJL_VERSION_H_
+
+#include <yajl/yajl_common.h>
+
+#define YAJL_MAJOR 2
+#define YAJL_MINOR 1
+#define YAJL_MICRO 1
+
+#define YAJL_VERSION ((YAJL_MAJOR * 10000) + (YAJL_MINOR * 100) + YAJL_MICRO)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int YAJL_API yajl_version(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YAJL_VERSION_H_ */
+

data/ext/libyajl2/extconf.rb

@@ -1,7 +1,8 @@
 exit(0) if ENV["USE_SYSTEM_LIBYAJL2"]
 
 require 'rbconfig'
-require 'pp'
+require 'fileutils'
+require 'mkmf'
 
 module Libyajl2Build
   class BuildError < StandardError; end
@@ -23,201 +24,47 @@ module Libyajl2Build
   end
 
   def self.setup_env
-    if config['CC'] =~ /gcc/ || config['CC'] =~ /clang/
-      config['CFLAGS'] << " -std=c99 -pedantic -Wpointer-arith -Wno-format-y2k -Wstrict-prototypes -Wmissing-declarations -Wnested-externs -Wextra  -Wundef -Wwrite-strings -Wold-style-definition -Wredundant-decls -Wno-unused-parameter -Wno-sign-compare -Wmissing-prototypes"
-    end
-  end
+    RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 
-  # for mkmf.rb compat
-  def self.config
-    @config ||= RbConfig::MAKEFILE_CONFIG.dup
-  end
+    # set some sane defaults
+    if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc|clang/
+      # magic flags copied from upstream yajl build system (-std=c99 is necessary for older gcc)
+      $CFLAGS << " -std=c99 -pedantic -Wpointer-arith -Wno-format-y2k -Wstrict-prototypes -Wmissing-declarations -Wnested-externs -Wextra  -Wundef -Wwrite-strings -Wold-style-definition -Wredundant-decls -Wno-unused-parameter -Wno-sign-compare -Wmissing-prototypes"
+      $CFLAGS << " -O2"  # match what the upstream uses for optimization
 
-  def self.mkintpath(path)
-    case config['build_os']
-    when 'mingw32'
-      path = path.dup
-      path.tr!('\\', '/')
-      path.sub!(/\A([A-Za-z]):(?=\/)/, '/\1')
-      path
-    when 'cygwin'
-      if config['target_os'] != 'cygwin'
-        IO.popen(["cygpath", "-u", path], &:read).chomp
-      else
-        path
+      # create the implib on windows
+      if windows?
+        $LDFLAGS << " -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--out-implib=libyajl.dll.a"
       end
-    else
-      path
     end
-  end
 
-  def self.system(*args)
-    print("-> #{args.join(' ')}\n")
-    super(*args)
-  end
-
-  # since we're not using cmake we have to mangle up yajl_version.h ourselves
-  def self.generate_yajl_version
-    yajl_major = yajl_minor = yajl_micro = nil
-    File.open("#{libyajl2_vendor_dir}/CMakeLists.txt").each do |line|
-      if m = line.match(/YAJL_MAJOR (\d+)/)
-        yajl_major = m[1]
-      end
-      if m = line.match(/YAJL_MINOR (\d+)/)
-        yajl_minor = m[1]
-      end
-      if m = line.match(/YAJL_MICRO (\d+)/)
-        yajl_micro = m[1]
-      end
-    end
-    File.open("#{libyajl2_vendor_dir}/src/api/yajl_version.h", "w+") do |out|
-      File.open("#{libyajl2_vendor_dir}/src/api/yajl_version.h.cmake").each do |line|
-        line.gsub!(/\$\{YAJL_MAJOR\}/, yajl_major)
-        line.gsub!(/\$\{YAJL_MINOR\}/, yajl_minor)
-        line.gsub!(/\$\{YAJL_MICRO\}/, yajl_micro)
-        out.write(line)
-      end
-    end
-  end
+    $CFLAGS << " -DNDEBUG"
 
-  def self.yajl_makefile
-    File.open("Makefile", "w+") do |f|
-      f.write <<EOF
-SHELL = /bin/sh
-
-# V=0 quiet, V=1 verbose.  other values don't work.
-V = 0
-Q1 = $(V:1=)
-Q = $(Q1:0=@)
-ECHO1 = $(V:1=@:)
-ECHO = $(ECHO1:0=@echo)
-
-#### Start of system configuration section. ####
-
-srcdir = .
-prefix = #{mkintpath(config['prefix'])}
-rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
-exec_prefix = $(prefix)
-sitearchdir = $(sitelibdir)/$(sitearch)
-sitelibdir = $(sitedir)/$(ruby_version)
-sitedir = $(rubylibprefix)/site_ruby
-libdir = $(exec_prefix)/lib
-
-CC = #{config['CC']}
-COUTFLAG = '-o'
-
-cflags   = #{config['cflags']}
-optflags = #{config['optflags']}
-debugflags = #{config['debugflags']}
-warnflags = #{config['warnflags']}
-CCDLFLAGS = #{config['CCDLFLAGS']}
-CFLAGS   = $(CCDLFLAGS) -I#{libyajl2_vendor_dir}/src/api -I. #{config['CFLAGS']} $(ARCH_FLAG)
-INCFLAGS = -I. -I$(srcdir)
-DEFS     = #{config['DEFS']}
-CPPFLAGS = #{config['CPPFLAGS']} $(cppflags)
-ldflags  = #{config['LDFLAGS']}
-#dldflags = -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress
-dldflags = #{config['DLDFLAGS']} #{config['EXTDLDFLAGS']}
-ARCH_FLAG = #{config['ARCH_FLAG']}
-DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
-LDSHARED = #{config['LDSHARED']}
-
-RUBY_INSTALL_NAME = #{config['RUBY_INSTALL_NAME']}
-RUBY_SO_NAME = #{config['RUBY_SO_NAME']}
-RUBYW_INSTALL_NAME = #{config['RUBYW_INSTALL_NAME']}
-RUBY_VERSION_NAME = #{config['RUBY_VERSION_NAME']}
-RUBYW_BASE_NAME = #{config['RUBYW_BASE_NAME']}
-RUBY_BASE_NAME = #{config['RUBY_BASE_NAME']}
-
-arch = #{config['arch']}
-sitearch = #{config['sitearch']}
-ruby_version = #{RbConfig::CONFIG['ruby_version']}
-ruby = #{File.join(RbConfig::CONFIG["bindir"], config["ruby_install_name"])}
-RUBY = $(ruby)
-
-RM = $(RUBY) -run -e rm -- -f
-MAKEDIRS = $(RUBY) -run -e mkdir -- -p
-INSTALL = $(RUBY) -run -e install -- -vp
-INSTALL_PROG = $(INSTALL) -m 0755
-TOUCH = exit >
-
-#### End of system configuration section. ####
-
-libpath = . $(libdir)
-LIBPATH = -L. -L$(libdir)
-
-CLEANFILES = mkmf.log
-
-target_prefix =
-LIBS =  #{config['LIBS']} #{config['DLDLIBS']}
-ORIG_SRCS = yajl.c yajl_alloc.c yajl_buf.c yajl_encode.c yajl_gen.c yajl_lex.c yajl_parser.c yajl_tree.c yajl_version.c
-SRCS = $(ORIG_SRCS)
-OBJS = yajl.o yajl_alloc.o yajl_buf.o yajl_encode.o yajl_gen.o yajl_lex.o yajl_parser.o yajl_tree.o yajl_version.o
-HDRS = yajl_alloc.h yajl_buf.h yajl_bytestack.h yajl_encode.h yajl_lex.h yajl_parser.h
-TARGET = libyajl
-DLLIB = $(TARGET).#{config['DLEXT']}
 
-TIMESTAMP_DIR = .
-RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
-
-CLEANLIBS     = $(TARGET).bundle
-CLEANOBJS     = *.o  *.bak
-
-all:    $(DLLIB)
-
-clean:
-\t-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
-
-install: install-so install-rb
-
-install-so: $(DLLIB) $(TIMESTAMP_DIR)/.RUBYARCHDIR.time
-\t$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
-
-install-rb:
-\t$(ECHO) installing default libyajl libraries
-$(TIMESTAMP_DIR)/.RUBYARCHDIR.time:
-\t$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
-\t$(Q) $(TOUCH) $@
-
-.SUFFIXES: .c .o
-
-.c.o:
-\t$(ECHO) compiling $(<)
-\t$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
-
-$(DLLIB): $(OBJS) Makefile
-\t$(ECHO) linking shared-object $(DLLIB)
-\t-$(Q)$(RM) $(@)
-\t$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LIBS)
-
-$(OBJS): $(HDRS)
-EOF
-    end
+    # ENV vars can override everything
+    $CFLAGS = ENV['CFLAGS'] if ENV['CFLAGS']
+    $LDFLAGS = ENV['LDFLAGS'] if ENV['LDFLAGS']
   end
 
   def self.makemakefiles
     setup_env
-    generate_yajl_version
-    Dir.chdir("#{libyajl2_vendor_dir}/src") do
-      # hack to make includes work
-      system("rm -f api/yajl")
-      system("ln -s . api/yajl")
-      yajl_makefile
-    end
+    dir_config("libyajl")
+    create_makefile("libyajl")
+    # we cheat and build it right away...
+    system("make V=1")
+    # ...so we can hack up what install does later and copy over the include files
+
     File.open("Makefile", "w+") do |f|
       f.write <<EOF
 TARGET = libyajl
-DLLIB = $(TARGET).#{config['DLEXT']}
+DLLIB = $(TARGET).#{RbConfig::MAKEFILE_CONFIG['DLEXT']}
 all:
-\tcd #{libyajl2_vendor_dir}/src && make
-\tcp #{libyajl2_vendor_dir}/src/$(DLLIB) .
+
 install:
 \tmkdir -p #{prefix}/lib
 \tcp $(DLLIB) #{prefix}/lib
 \tmkdir -p #{prefix}/include/yajl
-\tcp #{libyajl2_vendor_dir}/src/api/*.h #{prefix}/include/yajl
-clean:
-\tcd #{libyajl2_vendor_dir}/src && make clean
+\tcp yajl/*.h #{prefix}/include/yajl
 EOF
     end
   end

data/ext/libyajl2/patches/000-mingw-gcc.patch

@@ -0,0 +1,26 @@
+diff --git a/src/yajl_gen.c b/src/yajl_gen.c
+index 0f5c68e..a86a6ed 100644
+--- a/src/yajl_gen.c
++++ b/src/yajl_gen.c
+@@ -217,7 +217,7 @@ yajl_gen_integer(yajl_gen g, long long int number)
+     return yajl_gen_status_ok;
+ }
+ 
+-#if defined(_WIN32) || defined(WIN32)
++#if ( defined(_WIN32) || defined(WIN32) ) && !defined(__GCC__)
+ #include <float.h>
+ #define isnan _isnan
+ #define isinf !_finite
+diff --git a/src/yajl_tree.c b/src/yajl_tree.c
+index 3d357a3..2b4c183 100644
+--- a/src/yajl_tree.c
++++ b/src/yajl_tree.c
+@@ -25,7 +25,7 @@
+ 
+ #include "yajl_parser.h"
+ 
+-#if defined(_WIN32) || defined(WIN32)
++#if ( defined(_WIN32) || defined(WIN32) ) && !defined(__GCC__)
+ #define snprintf sprintf_s
+ #endif
+ 

data/ext/libyajl2/yajl/yajl_common.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2007-2014, Lloyd Hilaiel <me@lloyd.io>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef __YAJL_COMMON_H__
+#define __YAJL_COMMON_H__
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define YAJL_MAX_DEPTH 128
+
+/* msft dll export gunk.  To build a DLL on windows, you
+ * must define WIN32, YAJL_SHARED, and YAJL_BUILD.  To use a shared
+ * DLL, you must define YAJL_SHARED and WIN32 */
+#if (defined(_WIN32) || defined(WIN32)) && defined(YAJL_SHARED)
+#  ifdef YAJL_BUILD
+#    define YAJL_API __declspec(dllexport)
+#  else
+#    define YAJL_API __declspec(dllimport)
+#  endif
+#else
+#  if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303
+#    define YAJL_API __attribute__ ((visibility("default")))
+#  else
+#    define YAJL_API
+#  endif
+#endif
+
+/** pointer to a malloc function, supporting client overriding memory
+ *  allocation routines */
+typedef void * (*yajl_malloc_func)(void *ctx, size_t sz);
+
+/** pointer to a free function, supporting client overriding memory
+ *  allocation routines */
+typedef void (*yajl_free_func)(void *ctx, void * ptr);
+
+/** pointer to a realloc function which can resize an allocation. */
+typedef void * (*yajl_realloc_func)(void *ctx, void * ptr, size_t sz);
+
+/** A structure which can be passed to yajl_*_alloc routines to allow the
+ *  client to specify memory allocation functions to be used. */
+typedef struct
+{
+    /** pointer to a function that can allocate uninitialized memory */
+    yajl_malloc_func malloc;
+    /** pointer to a function that can resize memory allocations */
+    yajl_realloc_func realloc;
+    /** pointer to a function that can free memory allocated using
+     *  reallocFunction or mallocFunction */
+    yajl_free_func free;
+    /** a context pointer that will be passed to above allocation routines */
+    void * ctx;
+} yajl_alloc_funcs;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif