chugalug 0.0.1

data/CHANGELOG

@@ -0,0 +1 @@
+v0.0.1. First version.

data/LICENSE

@@ -0,0 +1,184 @@
+Academic Free License (AFL) v. 3.0
+
+This Academic Free License (the "License") applies to any original work
+of authorship (the "Original Work") whose owner (the "Licensor") has
+placed the following licensing notice adjacent to the copyright notice
+for the Original Work:
+
+Licensed under the Academic Free License version 3.0
+
+1) Grant of Copyright License. Licensor grants You a worldwide,
+royalty-free, non-exclusive, sublicensable license, for the duration of
+the copyright, to do the following:
+
+a) to reproduce the Original Work in copies, either alone or as part of
+a collective work;
+
+b) to translate, adapt, alter, transform, modify, or arrange the
+Original Work, thereby creating derivative works ("Derivative Works")
+based upon the Original Work;
+
+c) to distribute or communicate copies of the Original Work and
+Derivative Works to the public, under any license of your choice that
+does not contradict the terms and conditions, including Licensor's
+reserved rights and remedies, in this Academic Free License;
+
+d) to perform the Original Work publicly; and
+
+e) to display the Original Work publicly.
+
+2) Grant of Patent License. Licensor grants You a worldwide,
+royalty-free, non-exclusive, sublicensable license, under patent claims
+owned or controlled by the Licensor that are embodied in the Original
+Work as furnished by the Licensor, for the duration of the patents, to
+make, use, sell, offer for sale, have made, and import the Original Work
+and Derivative Works.
+
+3) Grant of Source Code License. The term "Source Code" means the
+preferred form of the Original Work for making modifications to it and
+all available documentation describing how to modify the Original Work.
+Licensor agrees to provide a machine-readable copy of the Source Code of
+the Original Work along with each copy of the Original Work that
+Licensor distributes. Licensor reserves the right to satisfy this
+obligation by placing a machine-readable copy of the Source Code in an
+information repository reasonably calculated to permit inexpensive and
+convenient access by You for as long as Licensor continues to distribute
+the Original Work.
+
+4) Exclusions From License Grant. Neither the names of Licensor, nor the
+names of any contributors to the Original Work, nor any of their
+trademarks or service marks, may be used to endorse or promote products
+derived from this Original Work without express prior permission of the
+Licensor. Except as expressly stated herein, nothing in this License
+grants any license to Licensor's trademarks, copyrights, patents, trade
+secrets or any other intellectual property. No patent license is granted
+to make, use, sell, offer for sale, have made, or import embodiments of
+any patent claims other than the licensed claims defined in Section 2.
+No license is granted to the trademarks of Licensor even if such marks
+are included in the Original Work. Nothing in this License shall be
+interpreted to prohibit Licensor from licensing under terms different
+from this License any Original Work that Licensor otherwise would have a
+right to license.
+
+5) External Deployment. The term "External Deployment" means the use,
+distribution, or communication of the Original Work or Derivative Works
+in any way such that the Original Work or Derivative Works may be used
+by anyone other than You, whether those works are distributed or
+communicated to those persons or made available as an application
+intended for use over a network. As an express condition for the grants
+of license hereunder, You must treat any External Deployment by You of
+the Original Work or a Derivative Work as a distribution under section
+1(c).
+
+6) Attribution Rights. You must retain, in the Source Code of any
+Derivative Works that You create, all copyright, patent, or trademark
+notices from the Source Code of the Original Work, as well as any
+notices of licensing and any descriptive text identified therein as an
+"Attribution Notice." You must cause the Source Code for any Derivative
+Works that You create to carry a prominent Attribution Notice reasonably
+calculated to inform recipients that You have modified the Original
+Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants
+that the copyright in and to the Original Work and the patent rights
+granted herein by Licensor are owned by the Licensor or are sublicensed
+to You under the terms of this License with the permission of the
+contributor(s) of those copyrights and patent rights. Except as
+expressly stated in the immediately preceding sentence, the Original
+Work is provided under this License on an "AS IS" BASIS and WITHOUT
+WARRANTY, either express or implied, including, without limitation, the
+warranties of non-infringement, merchantability or fitness for a
+particular purpose. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL
+WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential
+part of this License. No license to the Original Work is granted by this
+License except under this disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal
+theory, whether in tort (including negligence), contract, or otherwise,
+shall the Licensor be liable to anyone for any indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or the use of the Original Work including,
+without limitation, damages for loss of goodwill, work stoppage,
+computer failure or malfunction, or any and all other commercial damages
+or losses. This limitation of liability shall not apply to the extent
+applicable law prohibits such limitation.
+
+9) Acceptance and Termination. If, at any time, You expressly assented
+to this License, that assent indicates your clear and irrevocable
+acceptance of this License and all of its terms and conditions. If You
+distribute or communicate copies of the Original Work or a Derivative
+Work, You must make a reasonable effort under the circumstances to
+obtain the express assent of recipients to the terms of this License.
+This License conditions your rights to undertake the activities listed
+in Section 1, including your right to create Derivative Works based upon
+the Original Work, and doing so without honoring these terms and
+conditions is prohibited by copyright law and international treaty.
+Nothing in this License is intended to affect copyright exceptions and
+limitations (including "fair use" or "fair dealing"). This License shall
+terminate immediately and You may no longer exercise any of the rights
+granted to You by this License upon your failure to honor the conditions
+in Section 1(c).
+
+10) Termination for Patent Action. This License shall terminate
+automatically and You may no longer exercise any of the rights granted
+to You by this License as of the date You commence an action, including
+a cross-claim or counterclaim, against Licensor or any licensee alleging
+that the Original Work infringes a patent. This termination provision
+shall not apply for an action alleging patent infringement by
+combinations of the Original Work with other software or hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating
+to this License may be brought only in the courts of a jurisdiction
+wherein the Licensor resides or in which Licensor conducts its primary
+business, and under the laws of that jurisdiction excluding its
+conflict-of-law provisions. The application of the United Nations
+Convention on Contracts for the International Sale of Goods is expressly
+excluded. Any use of the Original Work outside the scope of this License
+or after its termination shall be subject to the requirements and
+penalties of copyright or patent law in the appropriate jurisdiction.
+This section shall survive the termination of this License.
+
+12) Attorneys' Fees. In any action to enforce the terms of this License
+or seeking damages relating thereto, the prevailing party shall be
+entitled to recover its costs and expenses, including, without
+limitation, reasonable attorneys' fees and costs incurred in connection
+with such action, including any appeal of such action. This section
+shall survive the termination of this License.
+
+13) Miscellaneous. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable.
+
+14) Definition of "You" in This License. "You" throughout this License,
+whether in upper or lower case, means an individual or a legal entity
+exercising rights under, and complying with all of the terms of, this
+License. For legal entities, "You" includes any entity that controls, is
+controlled by, or is under common control with you. For purposes of this
+definition, "control" means (i) the power, direct or indirect, to cause
+the direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+15) Right to Use. You may use the Original Work in all ways not
+otherwise restricted or conditioned by this License or by law, and
+Licensor promises not to interfere with or be responsible for such uses
+by You.
+
+16) Modification of This License. This License is Copyright (c) 2005
+Lawrence Rosen. Permission is granted to copy, distribute, or
+communicate this License without modification. Nothing in this License
+permits You to modify this License as applied to the Original Work or to
+Derivative Works. However, You may modify the text of this License and
+copy, distribute or communicate your modified version (the "Modified
+License") and apply it to other original works of authorship subject to
+the following conditions: (i) You may not indicate in any way that your
+Modified License is the "Academic Free License" or "AFL" and you may not
+use those names in the name of your Modified License; (ii) You must
+replace the notice specified in the first paragraph above with the
+notice "Licensed under <insert your license name here>" or with a notice
+of your own that is not confusingly similar to the notice in this
+License; and (iii) You may not claim that your original works are open
+source software unless your Modified License has been approved by Open
+Source Initiative (OSI) and You comply with its license review and
+certification process.
+

data/Manifest

@@ -0,0 +1,15 @@
+CHANGELOG
+LICENSE
+Manifest
+README
+Rakefile
+ext/chugalug.c
+ext/csv.h
+ext/extconf.rb
+ext/libcsv.c
+test/data.csv
+test/data_small.csv
+test/easy.csv
+test/messages.csv
+test/quoted_values.csv
+test/unit/test_chugalug.rb

data/README

@@ -0,0 +1,12 @@
+
+Ccsv
+
+A pure-C CSV parser.
+
+== License
+
+Copyright 2010 Josh Ferguson, based off of Ccsv with the License Below:
+
+== Attribution
+
+Copyright 2007, 2008 Cloudburst, LLC. Licensed under the AFL 3. See the included LICENSE file. 

data/Rakefile

@@ -0,0 +1,9 @@
+require 'echoe'
+
+Echoe.new("chugalug") do |p|
+  p.author = "Josh Ferguson"
+  p.email = "josh@besquared.net"
+  p.project = "Besquared"
+  p.summary = "A wrapper around libcsv."
+  p.url = "http://www.github.com/besquared/chugalug/"
+end

data/chugalug.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{chugalug}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Josh Ferguson"]
+  s.date = %q{2010-05-15}
+  s.description = %q{A wrapper around libcsv.}
+  s.email = %q{josh@besquared.net}
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "README", "ext/chugalug.c", "ext/csv.h", "ext/extconf.rb", "ext/libcsv.c"]
+  s.files = ["CHANGELOG", "LICENSE", "Manifest", "README", "Rakefile", "ext/chugalug.c", "ext/csv.h", "ext/extconf.rb", "ext/libcsv.c", "test/data.csv", "test/data_small.csv", "test/easy.csv", "test/messages.csv", "test/quoted_values.csv", "test/unit/test_chugalug.rb", "chugalug.gemspec"]
+  s.homepage = %q{http://www.github.com/besquared/chugalug/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Chugalug", "--main", "README"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{Besquared}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A wrapper around libcsv.}
+  s.test_files = ["test/unit/test_chugalug.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/ext/chugalug.c

@@ -0,0 +1,79 @@
+#include <ruby.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "csv.h"
+
+struct rowdata {
+  VALUE ary;
+};
+
+void fieldcb(void* str, size_t len, void* data) {
+  VALUE ary = ((struct rowdata *)data)->ary;
+  rb_ary_store(ary, RARRAY_LEN(ary), rb_str_new(str, len));
+}
+
+void rowcb(int c, void* data) {
+  rb_yield(((struct rowdata *)data)->ary);
+  ((struct rowdata *)data)->ary = rb_ary_new();
+}
+
+static int is_space(unsigned char c) {
+  if (c == CSV_SPACE || c == CSV_TAB) return 1;
+  return 0;
+}
+
+static int is_term(unsigned char c) {
+  if (c == CSV_CR || c == CSV_LF) return 1;
+  return 0;
+}
+
+static VALUE foreach(VALUE self, VALUE filename) {
+  FILE *file = fopen(StringValueCStr(filename), "r");
+  
+  if (file == NULL) {
+    rb_raise(rb_eRuntimeError, "File not found");
+  }
+  
+  char buf[1024];
+  size_t bytes_read;
+  struct csv_parser p;
+  unsigned char options = 0;
+  
+  struct rowdata data;
+  data.ary = rb_ary_new();
+  
+  if(csv_init(&p, options) != 0) {
+    rb_raise(rb_eRuntimeError, "Failed to initialize csv parser");
+    exit(EXIT_FAILURE);
+  }
+  
+  csv_set_space_func(&p, is_space);
+  csv_set_term_func(&p, is_term);  
+  
+  while((bytes_read = fread(buf, 1, 1024, file)) > 0) {
+    if(csv_parse(&p, buf, bytes_read, fieldcb, rowcb, &data) != bytes_read) {
+      rb_raise(rb_eRuntimeError, "Error while parsing file"); //, csv_strerror(csv_error(&p)));
+    }
+  }
+  
+  csv_fini(&p, fieldcb, rowcb, &data);
+  csv_free(&p);
+  
+  if(ferror(file)) {
+    fclose(file);
+    rb_raise(rb_eRuntimeError, "Error while reading file");
+  } else {
+    fclose(file);
+  }
+  
+  return Qnil;
+}
+
+static VALUE rb_cC;
+void Init_chugalug() {
+  rb_cC = rb_define_class("Chugalug", rb_cObject);
+  rb_define_singleton_method(rb_cC, "foreach", foreach, 1);
+}

data/ext/csv.h

@@ -0,0 +1,86 @@
+#ifndef LIBCSV_H__
+#define LIBCSV_H__
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CSV_MAJOR 3
+#define CSV_MINOR 0
+#define CSV_RELEASE 0
+
+/* Error Codes */
+#define CSV_SUCCESS 0
+#define CSV_EPARSE 1   /* Parse error in strict mode */
+#define CSV_ENOMEM 2   /* Out of memory while increasing buffer size */
+#define CSV_ETOOBIG 3  /* Buffer larger than SIZE_MAX needed */
+#define CSV_EINVALID 4 /* Invalid code,should never be received from csv_error*/
+
+
+/* parser options */
+#define CSV_STRICT 1    /* enable strict mode */
+#define CSV_REPALL_NL 2 /* report all unquoted carriage returns and linefeeds */
+#define CSV_STRICT_FINI 4 /* causes csv_fini to return CSV_EPARSE if last
+                             field is quoted and doesn't containg ending 
+                             quote */
+#define CSV_APPEND_NULL 8 /* Ensure that all fields are null-ternimated */
+
+
+/* Character values */
+#define CSV_TAB    0x09
+#define CSV_SPACE  0x20
+#define CSV_CR     0x0d
+#define CSV_LF     0x0a
+#define CSV_COMMA  0x2c
+#define CSV_QUOTE  0x22
+
+struct csv_parser {
+  int pstate;         /* Parser state */
+  int quoted;         /* Is the current field a quoted field? */
+  size_t spaces;      /* Number of continious spaces after quote or in a non-quoted field */
+  unsigned char * entry_buf;   /* Entry buffer */
+  size_t entry_pos;   /* Current position in entry_buf (and current size of entry) */
+  size_t entry_size;  /* Size of entry buffer */
+  int status;         /* Operation status */
+  unsigned char options;
+  unsigned char quote_char;
+  unsigned char delim_char;
+  int (*is_space)(unsigned char);
+  int (*is_term)(unsigned char);
+  size_t blk_size;
+  void *(*malloc_func)(size_t);
+  void *(*realloc_func)(void *, size_t);
+  void (*free_func)(void *);
+};
+
+/* Function Prototypes */
+int csv_init(struct csv_parser *p, unsigned char options);
+int csv_fini(struct csv_parser *p, void (*cb1)(void *, size_t, void *), void (*cb2)(int, void *), void *data);
+void csv_free(struct csv_parser *p);
+int csv_error(struct csv_parser *p);
+char * csv_strerror(int error);
+size_t csv_parse(struct csv_parser *p, const void *s, size_t len, void (*cb1)(void *, size_t, void *), void (*cb2)(int, void *), void *data);
+size_t csv_write(void *dest, size_t dest_size, const void *src, size_t src_size);
+int csv_fwrite(FILE *fp, const void *src, size_t src_size);
+size_t csv_write2(void *dest, size_t dest_size, const void *src, size_t src_size, unsigned char quote);
+int csv_fwrite2(FILE *fp, const void *src, size_t src_size, unsigned char quote);
+int csv_get_opts(struct csv_parser *p);
+int csv_set_opts(struct csv_parser *p, unsigned char options);
+void csv_set_delim(struct csv_parser *p, unsigned char c);
+void csv_set_quote(struct csv_parser *p, unsigned char c);
+unsigned char csv_get_delim(struct csv_parser *p);
+unsigned char csv_get_quote(struct csv_parser *p);
+void csv_set_space_func(struct csv_parser *p, int (*f)(unsigned char));
+void csv_set_term_func(struct csv_parser *p, int (*f)(unsigned char));
+void csv_set_realloc_func(struct csv_parser *p, void *(*)(void *, size_t));
+void csv_set_free_func(struct csv_parser *p, void (*)(void *));
+void csv_set_blk_size(struct csv_parser *p, size_t);
+size_t csv_get_buffer_size(struct csv_parser *p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+dir_config('chugalug')
+create_makefile('chugalug')

data/ext/libcsv.c

@@ -0,0 +1,579 @@
+/*
+libcsv - parse and write csv data
+Copyright (C) 2008  Robert Gamble
+
+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, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#if ___STDC_VERSION__ >= 199901L
+#  include <stdint.h>
+#else
+#  define SIZE_MAX ((size_t)-1) /* C89 doesn't have stdint.h or SIZE_MAX */
+#endif
+
+#include "csv.h"
+
+#define VERSION "3.0.0"
+
+#define ROW_NOT_BEGUN           0
+#define FIELD_NOT_BEGUN         1
+#define FIELD_BEGUN             2
+#define FIELD_MIGHT_HAVE_ENDED  3
+
+/*
+  Explanation of states
+  ROW_NOT_BEGUN    There have not been any fields encountered for this row
+  FIELD_NOT_BEGUN  There have been fields but we are currently not in one
+  FIELD_BEGUN      We are in a field
+  FIELD_MIGHT_HAVE_ENDED
+                   We encountered a double quote inside a quoted field, the
+                   field is either ended or the quote is literal
+*/
+
+#define MEM_BLK_SIZE 128
+
+#define SUBMIT_FIELD(p) \
+  do { \
+   if (!quoted) \
+     entry_pos -= spaces; \
+   if (p->options & CSV_APPEND_NULL) \
+     ((p)->entry_buf[entry_pos+1]) = '\0'; \
+   if (cb1) \
+     cb1(p->entry_buf, entry_pos, data); \
+   pstate = FIELD_NOT_BEGUN; \
+   entry_pos = quoted = spaces = 0; \
+ } while (0)
+
+#define SUBMIT_ROW(p, c) \
+  do { \
+    if (cb2) \
+      cb2(c, data); \
+    pstate = ROW_NOT_BEGUN; \
+    entry_pos = quoted = spaces = 0; \
+  } while (0)
+
+#define SUBMIT_CHAR(p, c) ((p)->entry_buf[entry_pos++] = (c))
+
+static char *csv_errors[] = {"success",
+                             "error parsing data while strict checking enabled",
+                             "memory exhausted while increasing buffer size",
+                             "data size too large",
+                             "invalid status code"};
+
+int
+csv_error(struct csv_parser *p)
+{
+  /* Return the current status of the parser */
+  return p->status;
+}
+
+char *
+csv_strerror(int status)
+{
+  /* Return a textual description of status */
+  if (status >= CSV_EINVALID || status < 0)
+    return csv_errors[CSV_EINVALID];
+  else
+    return csv_errors[status];
+}
+
+int
+csv_get_opts(struct csv_parser *p)
+{
+  /* Return the currently set options of parser */
+  if (p == NULL)
+    return -1;
+
+  return p->options;
+}
+
+int
+csv_set_opts(struct csv_parser *p, unsigned char options)
+{
+  /* Set the options */
+  if (p == NULL)
+    return -1;
+
+  p->options = options;
+  return 0;
+}
+
+int
+csv_init(struct csv_parser *p, unsigned char options)
+{
+  /* Initialize a csv_parser object returns 0 on success, -1 on error */
+  if (p == NULL)
+    return -1;
+
+  p->entry_buf = NULL;
+  p->pstate = ROW_NOT_BEGUN;
+  p->quoted = 0;
+  p->spaces = 0;
+  p->entry_pos = 0;
+  p->entry_size = 0;
+  p->status = 0;
+  p->options = options;
+  p->quote_char = CSV_QUOTE;
+  p->delim_char = CSV_COMMA;
+  p->is_space = NULL;
+  p->is_term = NULL;
+  p->blk_size = MEM_BLK_SIZE;
+  p->malloc_func = NULL;
+  p->realloc_func = realloc;
+  p->free_func = free;
+
+  return 0;
+}
+
+void
+csv_free(struct csv_parser *p)
+{
+  /* Free the entry_buffer of csv_parser object */
+  if (p == NULL)
+    return;
+
+  if (p->entry_buf)
+    p->free_func(p->entry_buf);
+
+  p->entry_buf = NULL;
+  p->entry_size = 0;
+
+  return;
+}
+
+int
+csv_fini(struct csv_parser *p, void (*cb1)(void *, size_t, void *), void (*cb2)(int c, void *), void *data)
+{
+  /* Finalize parsing.  Needed, for example, when file does not end in a newline */
+  int quoted = p->quoted;
+  int pstate = p->pstate;
+  size_t spaces = p->spaces;
+  size_t entry_pos = p->entry_pos;
+
+  if (p == NULL)
+    return -1;
+
+
+  if (p->pstate == FIELD_BEGUN && p->quoted && p->options & CSV_STRICT && p->options & CSV_STRICT_FINI) {
+    /* Current field is quoted, no end-quote was seen, and CSV_STRICT_FINI is set */
+    p->status = CSV_EPARSE;
+    return -1;
+  }
+
+  switch (p->pstate) {
+    case FIELD_MIGHT_HAVE_ENDED:
+      p->entry_pos -= p->spaces + 1;  /* get rid of spaces and original quote */
+      /* Fall-through */
+    case FIELD_NOT_BEGUN:
+    case FIELD_BEGUN:
+      quoted = p->quoted, pstate = p->pstate;
+      spaces = p->spaces, entry_pos = p->entry_pos;
+      SUBMIT_FIELD(p);
+      SUBMIT_ROW(p, -1);
+    case ROW_NOT_BEGUN: /* Already ended properly */
+      ;
+  }
+
+  /* Reset parser */
+  p->spaces = p->quoted = p->entry_pos = p->status = 0;
+  p->pstate = ROW_NOT_BEGUN;
+
+  return 0;
+}
+
+void
+csv_set_delim(struct csv_parser *p, unsigned char c)
+{
+  /* Set the delimiter */
+  if (p) p->delim_char = c;
+}
+
+void
+csv_set_quote(struct csv_parser *p, unsigned char c)
+{
+  /* Set the quote character */
+  if (p) p->quote_char = c;
+}
+
+unsigned char
+csv_get_delim(struct csv_parser *p)
+{
+  /* Get the delimiter */
+  return p->delim_char;
+}
+
+unsigned char
+csv_get_quote(struct csv_parser *p)
+{
+  /* Get the quote character */
+  return p->quote_char;
+}
+
+void
+csv_set_space_func(struct csv_parser *p, int (*f)(unsigned char))
+{
+  /* Set the space function */
+  if (p) p->is_space = f;
+}
+ 
+void
+csv_set_term_func(struct csv_parser *p, int (*f)(unsigned char))
+{
+  /* Set the term function */
+  if (p) p->is_term = f;
+}
+
+void
+csv_set_realloc_func(struct csv_parser *p, void *(*f)(void *, size_t))
+{
+  /* Set the realloc function used to increase buffer size */
+  if (p && f) p->realloc_func = f;
+}
+ 
+void
+csv_set_free_func(struct csv_parser *p, void (*f)(void *))
+{
+  /* Set the free function used to free the buffer */
+  if (p && f) p->free_func = f;
+}
+
+void
+csv_set_blk_size(struct csv_parser *p, size_t size)
+{
+  /* Set the block size used to increment buffer size */
+  if (p) p->blk_size = size;
+}
+
+size_t
+csv_get_buffer_size(struct csv_parser *p)
+{
+  /* Get the size of the entry buffer */
+  if (p)
+    return p->entry_size;
+  return 0;
+}
+ 
+static int
+csv_increase_buffer(struct csv_parser *p)
+{
+  /* Increase the size of the entry buffer.  Attempt to increase size by 
+   * p->blk_size, if this is larger than SIZE_MAX try to increase current
+   * buffer size to SIZE_MAX.  If allocation fails, try to allocate halve 
+   * the size and try again until successful or increment size is zero.
+   */
+
+  size_t to_add = p->blk_size;
+  void *vp;
+
+  if ( p->entry_size >= SIZE_MAX - to_add )
+    to_add = SIZE_MAX - p->entry_size;
+
+  if (!to_add) {
+    p->status = CSV_ETOOBIG;
+    return -1;
+  }
+
+  while ((vp = p->realloc_func(p->entry_buf, p->entry_size + to_add)) == NULL) {
+    to_add /= 2;
+    if (!to_add) {
+      p->status = CSV_ENOMEM;
+      return -1;
+    }
+  }
+
+  /* Update entry buffer pointer and entry_size if successful */
+  p->entry_buf = vp;
+  p->entry_size += to_add;
+  return 0;
+}
+ 
+size_t
+csv_parse(struct csv_parser *p, const void *s, size_t len, void (*cb1)(void *, size_t, void *), void (*cb2)(int c, void *), void *data)
+{
+  unsigned const char *us = s;  /* Access input data as array of unsigned char */
+  unsigned char c;              /* The character we are currently processing */
+  size_t pos = 0;               /* The number of characters we have processed in this call */
+
+  /* Store key fields into local variables for performance */
+  unsigned char delim = p->delim_char;
+  unsigned char quote = p->quote_char;
+  int (*is_space)(unsigned char) = p->is_space;
+  int (*is_term)(unsigned char) = p->is_term;
+  int quoted = p->quoted;
+  int pstate = p->pstate;
+  size_t spaces = p->spaces;
+  size_t entry_pos = p->entry_pos;
+
+
+  if (!p->entry_buf && pos < len) {
+    /* Buffer hasn't been allocated yet and len > 0 */
+    if (csv_increase_buffer(p) != 0) { 
+      p->quoted = quoted, p->pstate = pstate, p->spaces = spaces, p->entry_pos = entry_pos;
+      return pos;
+    }
+  }
+
+  while (pos < len) {
+    /* Check memory usage, increase buffer if neccessary */
+    if (entry_pos == ((p->options & CSV_APPEND_NULL) ? p->entry_size - 1 : p->entry_size) ) {
+      if (csv_increase_buffer(p) != 0) {
+        p->quoted = quoted, p->pstate = pstate, p->spaces = spaces, p->entry_pos = entry_pos;
+        return pos;
+      }
+    }
+
+    c = us[pos++];
+
+    switch (pstate) {
+      case ROW_NOT_BEGUN:
+      case FIELD_NOT_BEGUN:
+        if (is_space ? is_space(c) : c == CSV_SPACE || c == CSV_TAB) { /* Space or Tab */
+          continue;
+        } else if (is_term ? is_term(c) : c == CSV_CR || c == CSV_LF) { /* Carriage Return or Line Feed */
+          if (pstate == FIELD_NOT_BEGUN) {
+            SUBMIT_FIELD(p);
+            SUBMIT_ROW(p, (unsigned char)c); 
+          } else {  /* ROW_NOT_BEGUN */
+            /* Don't submit empty rows by default */
+            if (p->options & CSV_REPALL_NL) {
+              SUBMIT_ROW(p, (unsigned char)c);
+            }
+          }
+          continue;
+        } else if (c == delim) { /* Comma */
+          SUBMIT_FIELD(p);
+          break;
+        } else if (c == quote) { /* Quote */
+          pstate = FIELD_BEGUN;
+          quoted = 1;
+        } else {               /* Anything else */
+          pstate = FIELD_BEGUN;
+          quoted = 0;
+          SUBMIT_CHAR(p, c);
+        }
+        break;
+      case FIELD_BEGUN:
+        if (c == quote) {         /* Quote */
+          if (quoted) {
+            SUBMIT_CHAR(p, c);
+            pstate = FIELD_MIGHT_HAVE_ENDED;
+          } else {
+            /* STRICT ERROR - double quote inside non-quoted field */
+            if (p->options & CSV_STRICT) {
+              p->status = CSV_EPARSE;
+              p->quoted = quoted, p->pstate = pstate, p->spaces = spaces, p->entry_pos = entry_pos;
+              return pos-1;
+            }
+            SUBMIT_CHAR(p, c);
+            spaces = 0;
+          }
+        } else if (c == delim) {  /* Comma */
+          if (quoted) {
+            SUBMIT_CHAR(p, c);
+          } else {
+            SUBMIT_FIELD(p);
+          }
+        } else if (is_term ? is_term(c) : c == CSV_CR || c == CSV_LF) {  /* Carriage Return or Line Feed */
+          if (!quoted) {
+            SUBMIT_FIELD(p);
+            SUBMIT_ROW(p, (unsigned char)c);
+          } else {
+            SUBMIT_CHAR(p, c);
+          }
+        } else if (!quoted && (is_space? is_space(c) : c == CSV_SPACE || c == CSV_TAB)) { /* Tab or space for non-quoted field */
+            SUBMIT_CHAR(p, c);
+            spaces++;
+        } else {  /* Anything else */
+          SUBMIT_CHAR(p, c);
+          spaces = 0;
+        }
+        break;
+      case FIELD_MIGHT_HAVE_ENDED:
+        /* This only happens when a quote character is encountered in a quoted field */
+        if (c == delim) {  /* Comma */
+          entry_pos -= spaces + 1;  /* get rid of spaces and original quote */
+          SUBMIT_FIELD(p);
+        } else if (is_term ? is_term(c) : c == CSV_CR || c == CSV_LF) {  /* Carriage Return or Line Feed */
+          entry_pos -= spaces + 1;  /* get rid of spaces and original quote */
+          SUBMIT_FIELD(p);
+          SUBMIT_ROW(p, (unsigned char)c);
+        } else if (is_space ? is_space(c) : c == CSV_SPACE || c == CSV_TAB) {  /* Space or Tab */
+          SUBMIT_CHAR(p, c);
+          spaces++;
+        } else if (c == quote) {  /* Quote */
+          if (spaces) {
+            /* STRICT ERROR - unescaped double quote */
+            if (p->options & CSV_STRICT) {
+              p->status = CSV_EPARSE;
+              p->quoted = quoted, p->pstate = pstate, p->spaces = spaces, p->entry_pos = entry_pos;
+              return pos-1;
+            }
+            spaces = 0;
+            SUBMIT_CHAR(p, c);
+          } else {
+            /* Two quotes in a row */
+            pstate = FIELD_BEGUN;
+          }
+        } else {  /* Anything else */
+          /* STRICT ERROR - unescaped double quote */
+          if (p->options & CSV_STRICT) {
+            p->status = CSV_EPARSE;
+            p->quoted = quoted, p->pstate = pstate, p->spaces = spaces, p->entry_pos = entry_pos;
+            return pos-1;
+          }
+          pstate = FIELD_BEGUN;
+          spaces = 0;
+          SUBMIT_CHAR(p, c);
+        }
+        break;
+     default:
+       break;
+    }
+  }
+  p->quoted = quoted, p->pstate = pstate, p->spaces = spaces, p->entry_pos = entry_pos;
+  return pos;
+}
+
+size_t
+csv_write (void *dest, size_t dest_size, const void *src, size_t src_size)
+{
+  unsigned char *cdest = dest;
+  const unsigned char *csrc = src;
+  size_t chars = 0;
+
+  if (src == NULL)
+    return 0;
+
+  if (cdest == NULL)
+    dest_size = 0;
+
+  if (dest_size > 0)
+    *cdest++ = '"';
+  chars++;
+
+  while (src_size) {
+    if (*csrc == '"') {
+      if (dest_size > chars)
+        *cdest++ = '"';
+      if (chars < SIZE_MAX) chars++;
+    }
+    if (dest_size > chars)
+      *cdest++ = *csrc;
+    if (chars < SIZE_MAX) chars++;
+    src_size--;
+    csrc++;
+  }
+
+  if (dest_size > chars)
+    *cdest = '"';
+  if (chars < SIZE_MAX) chars++;
+
+  return chars;
+}
+
+int
+csv_fwrite (FILE *fp, const void *src, size_t src_size)
+{
+  const unsigned char *csrc = src;
+
+  if (fp == NULL || src == NULL)
+    return 0;
+
+  if (fputc('"', fp) == EOF)
+    return EOF;
+
+  while (src_size) {
+    if (*csrc == '"') {
+      if (fputc('"', fp) == EOF)
+        return EOF;
+    }
+    if (fputc(*csrc, fp) == EOF)
+      return EOF;
+    src_size--;
+    csrc++;
+  }
+
+  if (fputc('"', fp) == EOF) {
+    return EOF;
+  }
+
+  return 0;
+}
+
+size_t
+csv_write2 (void *dest, size_t dest_size, const void *src, size_t src_size, unsigned char quote)
+{
+  unsigned char *cdest = dest;
+  const unsigned char *csrc = src;
+  size_t chars = 0;
+
+  if (src == NULL)
+    return 0;
+
+  if (dest == NULL)
+    dest_size = 0;
+
+  if (dest_size > 0)
+    *cdest++ = quote;
+  chars++;
+
+  while (src_size) {
+    if (*csrc == quote) {
+      if (dest_size > chars)
+        *cdest++ = quote;
+      if (chars < SIZE_MAX) chars++;
+    }
+    if (dest_size > chars)
+      *cdest++ = *csrc;
+    if (chars < SIZE_MAX) chars++;
+    src_size--;
+    csrc++;
+  }
+
+  if (dest_size > chars)
+    *cdest = quote;
+  if (chars < SIZE_MAX) chars++;
+
+  return chars;
+}
+
+int
+csv_fwrite2 (FILE *fp, const void *src, size_t src_size, unsigned char quote)
+{
+  const unsigned char *csrc = src;
+
+  if (fp == NULL || src == NULL)
+    return 0;
+
+  if (fputc(quote, fp) == EOF)
+    return EOF;
+
+  while (src_size) {
+    if (*csrc == quote) {
+      if (fputc(quote, fp) == EOF)
+        return EOF;
+    }
+    if (fputc(*csrc, fp) == EOF)
+      return EOF;
+    src_size--;
+    csrc++;
+  }
+
+  if (fputc(quote, fp) == EOF) {
+    return EOF;
+  }
+
+  return 0;
+}