ffi-yajl 0.0.1

data/ext/ffi_yajl/ext/encoder/extconf.rb

@@ -0,0 +1,29 @@
+require 'mkmf'
+
+# the customer is always right, ruby is always compiled to be stupid
+$CFLAGS = ENV['CFLAGS'] if ENV['CFLAGS']
+$LDFLAGS = ENV['LDFLAGS'] if ENV['LDFLAGS']
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+# search our gem root first to pick up libyajl2 that we vendored
+gem_root = File.expand_path(File.join(File.dirname(__FILE__), "../../../.."))
+$CFLAGS = "-I#{gem_root}/include -L#{gem_root}/lib #{$CFLAGS}"
+$LDFLAGS = "-L#{gem_root}/lib #{$CFLAGS}"
+
+puts gem_root
+puts $CFLAGS
+puts $LDFLAGS
+
+# except if you're doing an unoptimized gcc install we're going to help you out a bit
+if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc|clang/
+  $CFLAGS << " -O3" unless $CFLAGS[/-O\d/]
+  # how many people realize that -Wall is a compiler-specific flag???
+  # apparently not many based on reading lots of shitty extconf.rb's out there
+  $CFLAGS << " -Wall"
+end
+
+$LDFLAGS << " -lyajl"
+
+dir_config 'encoder'
+
+create_makefile 'ffi_yajl/ext/encoder'

data/ext/ffi_yajl/ext/parser/extconf.rb

@@ -0,0 +1,29 @@
+require 'mkmf'
+
+# the customer is always right, ruby is always compiled to be stupid
+$CFLAGS = ENV['CFLAGS'] if ENV['CFLAGS']
+$LDFLAGS = ENV['LDFLAGS'] if ENV['LDFLAGS']
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+# search our gem root first to pick up libyajl2 that we vendored
+gem_root = File.expand_path(File.join(File.dirname(__FILE__), "../../../.."))
+$CFLAGS = "-I#{gem_root}/include -L#{gem_root}/lib #{$CFLAGS}"
+$LDFLAGS = "-L#{gem_root}/lib #{$CFLAGS}"
+
+puts gem_root
+puts $CFLAGS
+puts $LDFLAGS
+
+# except if you're doing an unoptimized gcc install we're going to help you out a bit
+if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc|clang/
+  $CFLAGS << " -O3" unless $CFLAGS[/-O\d/]
+  # how many people realize that -Wall is a compiler-specific flag???
+  # apparently not many based on reading lots of shitty extconf.rb's out there
+  $CFLAGS << " -Wall"
+end
+
+$LDFLAGS << " -lyajl"
+
+dir_config 'parser'
+
+create_makefile 'ffi_yajl/ext/parser'

data/ext/ffi_yajl/ext/parser/parser.c

@@ -0,0 +1,199 @@
+#include <ruby.h>
+#include <yajl/yajl_parse.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+static rb_encoding *utf8Encoding;
+#endif
+
+static VALUE mFFI_Yajl, mExt, mParser, cParseError;
+
+typedef struct {
+  VALUE finished;
+  VALUE stack;
+  VALUE key_stack;
+  VALUE key;
+} CTX;
+
+void set_value(CTX *ctx, VALUE val) {
+  long len = RARRAY_LEN(ctx->stack);
+  VALUE last = rb_ary_entry(ctx->stack, len-1);
+  switch (TYPE(last)) {
+    case T_ARRAY:
+      rb_ary_push(last, val);
+      break;
+    case T_HASH:
+      rb_hash_aset(last, ctx->key, val);
+      break;
+    default:
+      break;
+  }
+}
+
+void set_key(CTX *ctx, VALUE key) {
+  ctx->key = key;
+}
+
+void start_object(CTX *ctx, VALUE obj) {
+  rb_ary_push(ctx->key_stack, ctx->key);
+  rb_ary_push(ctx->stack, obj);
+}
+
+void end_object(CTX *ctx) {
+  ctx->key = rb_ary_pop(ctx->key_stack);
+  if ( RARRAY_LEN(ctx->stack) > 1 ) {
+    set_value(ctx, rb_ary_pop(ctx->stack));
+  } else {
+    ctx->finished = rb_ary_pop(ctx->stack);
+  }
+}
+
+int null_callback(void *ctx) {
+  set_value(ctx, Qnil);
+  return 1;
+}
+
+int boolean_callback(void *ctx, int boolean) {
+  set_value(ctx, boolean ? Qtrue : Qfalse);
+  return 1;
+}
+
+int integer_callback(void *ctx, long long intVal) {
+  set_value(ctx, LONG2NUM(intVal));
+  return 1;
+}
+
+int double_callback(void *ctx, double doubleVal) {
+  set_value(ctx, rb_float_new(doubleVal));
+  return 1;
+}
+
+int number_callback(void *ctx, const char *numberVal, size_t numberLen) {
+  char buf[numberLen+1];
+  buf[numberLen] = 0;
+  memcpy(buf, numberVal, numberLen);
+  if (memchr(buf, '.', numberLen) ||
+    memchr(buf, 'e', numberLen) ||
+    memchr(buf, 'E', numberLen)) {
+    set_value(ctx, rb_float_new(strtod(buf, NULL)));
+  } else {
+    set_value(ctx, rb_cstr2inum(buf, 10));
+  }
+  return 1;
+}
+
+int string_callback(void *ctx, const unsigned char *stringVal, size_t stringLen) {
+  char buf[stringLen+1];
+  VALUE str;
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc;
+#endif
+
+  buf[stringLen] = 0;
+  memcpy(buf, stringVal, stringLen);
+  str = rb_str_new2(buf);
+#ifdef HAVE_RUBY_ENCODING_H
+  default_internal_enc = rb_default_internal_encoding();
+  rb_enc_associate(str, utf8Encoding);
+  if (default_internal_enc) {
+    str = rb_str_export_to_enc(str, default_internal_enc);
+  }
+#endif
+  set_value(ctx,str);
+  return 1;
+}
+
+int start_map_callback(void *ctx) {
+  start_object(ctx,rb_hash_new());
+  return 1;
+}
+
+int map_key_callback(void *ctx, const unsigned char *stringVal, size_t stringLen) {
+  char buf[stringLen+1];
+  VALUE str;
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc;
+#endif
+
+  buf[stringLen] = 0;
+  memcpy(buf, stringVal, stringLen);
+  str = rb_str_new2(buf);
+#ifdef HAVE_RUBY_ENCODING_H
+  default_internal_enc = rb_default_internal_encoding();
+  rb_enc_associate(str, utf8Encoding);
+  if (default_internal_enc) {
+    str = rb_str_export_to_enc(str, default_internal_enc);
+  }
+#endif
+  set_key(ctx,str);
+  return 1;
+}
+
+int end_map_callback(void *ctx) {
+  end_object(ctx);
+  return 1;
+}
+
+int start_array_callback(void *ctx) {
+  start_object(ctx,rb_ary_new());
+  return 1;
+}
+
+int end_array_callback(void *ctx) {
+  end_object(ctx);
+  return 1;
+}
+
+static yajl_callbacks callbacks = {
+  null_callback,
+  boolean_callback,
+  integer_callback,
+  double_callback,
+  number_callback,
+  string_callback,
+  start_map_callback,
+  map_key_callback,
+  end_map_callback,
+  start_array_callback,
+  end_array_callback,
+};
+
+static VALUE mParser_do_yajl_parse(VALUE self, VALUE str, VALUE opts) {
+  yajl_handle hand;
+  yajl_status stat;
+  unsigned char *err;
+  CTX ctx;
+
+  ctx.stack = rb_ary_new();
+  ctx.key_stack = rb_ary_new();
+
+  hand = yajl_alloc(&callbacks, NULL, &ctx);
+  if ((stat = yajl_parse(hand, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str))) != yajl_status_ok) {
+    err = yajl_get_error(hand, 1, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str));
+    goto raise;
+  }
+  if ((stat = yajl_complete_parse(hand)) != yajl_status_ok) {
+    err = yajl_get_error(hand, 1, (unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str));
+    goto raise;
+  }
+  yajl_free(hand);
+  return ctx.finished;
+
+raise:
+  if (hand) {
+    yajl_free(hand);
+  }
+  rb_raise(cParseError, "%s", err);
+}
+
+void Init_parser() {
+  mFFI_Yajl = rb_define_module("FFI_Yajl");
+  cParseError = rb_define_class_under(mFFI_Yajl, "ParseError", rb_eStandardError);
+  mExt = rb_define_module_under(mFFI_Yajl, "Ext");
+  mParser = rb_define_module_under(mExt, "Parser");
+  rb_define_method(mParser, "do_yajl_parse", mParser_do_yajl_parse, 2);
+#ifdef HAVE_RUBY_ENCODING_H
+  utf8Encoding = rb_utf8_encoding();
+#endif
+}
+

data/ext/libyajl2/extconf.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'rbconfig'
+
+cflags = ENV['CFLAGS']
+ldflags = ENV['LDFLAGS']
+cc = ENV['CC']
+
+# use the CC that ruby was compiled with by default
+cc ||= RbConfig::MAKEFILE_CONFIG['CC']
+cflags ||= ""
+ldflags ||= ""
+
+# then ultimately default back to gcc
+cc ||= "gcc"
+
+# FIXME: add more compilers with default options
+if cc =~ /gcc|clang/
+  cflags << " -O3" unless cflags =~ /-O\d/
+  cflags << " -Wall"
+end
+
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
+  require 'mkmf'
+
+  # yajl_complete_parse is only in >= 2.0
+  libyajl2_ok = have_library("yajl", "yajl_complete_parse", [ "yajl/yajl_parse.h" ]) && have_func("yajl_complete_parse")
+else
+  # always install libyajl2 on Jruby
+  # FIXME: get the conditional mkmf stuff to work on Jruby
+  libyajl2_ok = false
+end
+
+prefix=File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+
+#dir_config 'libyajl2'
+
+if libyajl2_ok
+  File.open("Makefile", "w") do |mf|
+    mf.puts "# Dummy makefile when we don't build the library"
+    mf.puts "all install::\n"
+  end
+else
+  ENV['CFLAGS'] = cflags
+  ENV['LDFLAGS'] = ldflags
+  ENV['CC'] = cc
+  unless File.exists?("vendored")
+    system("pwd")
+    puts "FOOOOOOOO: #{__FILE__}"
+    system("ls -lad #{File.expand_path(File.join(File.dirname(__FILE__), "vendored"))}")
+  end
+  system("cp -rf #{File.expand_path(File.join(File.dirname(__FILE__), "vendored"))} .") unless File.exists?("vendored")
+
+  File.open("Makefile", "w") do |mf|
+    mf.puts "# Makefile for building vendored libyajl2"
+    mf.puts "CFLAGS = #{ENV['CFLAGS']}"
+    mf.puts "LDFLAGS = #{ENV['LDFLAGS']}"
+    mf.puts "CC = #{ENV['CC']}\n"
+    mf.puts "all install::"
+    mf.puts "\tcd vendored && ./configure --prefix=#{prefix}"
+    mf.puts "\tcd vendored && make install"
+    mf.puts "\tcp -f vendored/build/yajl-2.0.5/lib/libyajl.so .\n"
+  end
+end
+

data/ext/libyajl2/vendored/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+Makefile
+/build/

data/ext/libyajl2/vendored/BUILDING

@@ -0,0 +1,23 @@
+Short story (If you already have ruby and cmake):
+
+./configure && make install
+
+When things go wrong:
+
+attain CMake (http://www.cmake.org) and ruby (http://ruby-lang.org) and
+try again.
+
+OR, attain CMake and build by hand:
+
+1. mkdir build
+2. cd build
+3. cmake ..
+4. make 
+5. build output left in yajl-X.Y.Z
+
+NOTE: for 64-bit systems where lib64 is used you can pass the cmake
+      variable LIB_SUFFIX to cause installation into the system's 'lib64'
+      directory.
+
+best,
+lloyd

data/ext/libyajl2/vendored/BUILDING.win32

@@ -0,0 +1,27 @@
+YAJL has been successfully built using Visual Studio 8.  CMake, a
+build file generator, is used to build the software.  CMake supports
+several different build environments, so you may either build YAJL
+using the IDE via the following steps:
+
+1. acquire cmake (http://www.cmake.org)
+2. mkdir build
+3. cd build
+4. cmake ..
+5. devenv YetAnotherJSONParser.sln /project ALL_BUILD /build Release
+6. build output is left in build/yajl-X.Y.Z
+
+Or you can build from the command line using nmake:
+
+1. Click Start > Programs > Microsoft Visual Studio > Visual Studio
+Tools > Visual Studio Command Prompt -- for your version of Visual
+Studio, which will open a command prompt.  You may verify that the
+compiler is in your path by typing "cl /?" at the prompt.
+2. cd C:\path\to\yajl\source\
+3. mkdir build
+4. cd build
+5. cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=Release ..
+6. nmake
+7. nmake install
+
+Earlier versions of visual studio and other build generators haven't
+been thoroughly tested, but should work without any major issues.

data/ext/libyajl2/vendored/CMakeLists.txt

@@ -0,0 +1,79 @@
+# Copyright (c) 2007-2011, Lloyd Hilaiel <lloyd@hilaiel.com>
+#
+# 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.
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+
+PROJECT(YetAnotherJSONParser C)
+
+SET (YAJL_MAJOR 2)
+SET (YAJL_MINOR 0)
+SET (YAJL_MICRO 5)
+
+SET (YAJL_DIST_NAME "yajl-${YAJL_MAJOR}.${YAJL_MINOR}.${YAJL_MICRO}")
+
+IF (NOT CMAKE_BUILD_TYPE)
+  SET(CMAKE_BUILD_TYPE "Release")
+ENDIF (NOT CMAKE_BUILD_TYPE)
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+
+IF (WIN32)
+  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
+  ADD_DEFINITIONS(-DWIN32)
+  SET(linkFlags "/PDB:NONE /INCREMENTAL:NO /OPT:NOREF /OPT:NOICF")
+  SET(CMAKE_EXE_LINKER_FLAGS    "${linkFlags}"
+      CACHE STRING "YAJL linker flags" FORCE)
+  SET(CMAKE_EXE_LINKER_FLAGS_DEBUG ""
+      CACHE STRING "YAJL debug linker flags" FORCE)
+  SET(CMAKE_EXE_LINKER_FLAGS_RELEASE
+      CACHE STRING "YAJL release linker flags" FORCE)
+  SET(CMAKE_SHARED_LINKER_FLAGS "${linkFlags}"
+      CACHE STRING "YAJL shared linker flags" FORCE)
+  SET(CMAKE_MODULE_LINKER_FLAGS "${linkFlags}"
+      CACHE STRING "YAJL module linker flags" FORCE)
+
+  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4996 /wd4255 /wd4130 /wd4100 /wd4711")
+  SET(CMAKE_C_FLAGS_DEBUG "/D DEBUG /Od /Z7")
+  SET(CMAKE_C_FLAGS_RELEASE "/D NDEBUG /O2")
+ELSE (WIN32)
+  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
+  IF(CMAKE_COMPILER_IS_GNUCC)
+    INCLUDE(CheckCCompilerFlag)
+    CHECK_C_COMPILER_FLAG(-fvisibility=hidden HAVE_GCC_VISIBILITY)
+    IF(HAVE_GCC_VISIBILITY)
+      SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
+    ENDIF(HAVE_GCC_VISIBILITY)
+  ENDIF(CMAKE_COMPILER_IS_GNUCC)
+  SET(CMAKE_C_FLAGS
+      "${CMAKE_C_FLAGS} -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")
+
+  SET(CMAKE_C_FLAGS_DEBUG "-DDEBUG -g")
+  SET(CMAKE_C_FLAGS_RELEASE "-DNDEBUG -O2 -Wuninitialized")
+ENDIF (WIN32)
+
+
+ADD_SUBDIRECTORY(src)
+ADD_SUBDIRECTORY(test)
+ADD_SUBDIRECTORY(reformatter)
+ADD_SUBDIRECTORY(verify)
+ADD_SUBDIRECTORY(example)
+ADD_SUBDIRECTORY(perf)
+
+INCLUDE(YAJLDoc.cmake)
+
+# a test target
+ADD_CUSTOM_TARGET(test
+                  ./run_tests.sh ${CMAKE_CURRENT_BINARY_DIR}/test/yajl_test
+                  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
+