fastcsv 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e5d991d026c76068b9e646ba62cefdad823f01e1
+  data.tar.gz: 8815f0bb3b00e01593f2a46320cf58c88926099c
+SHA512:
+  metadata.gz: 8762ce01e3e5af4cd0395bf541879db46f677f79201e2f44dc5f35dd30514c53fa2c2c5808ec61149898d64bff908a74fe2153c690a04e75c82ba7306794fa15
+  data.tar.gz: e6dd0a3f89f9d330428fbc8d6f1b469d9f3a8ca255561c6fa972d1ad2147422bd090f3c7a373d08d29b07748f781f9b8d70fae27a092a075d183de897094eea5

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+.yardoc
+Gemfile.lock
+doc/*
+pkg/*
+tmp/*
+lib/fastcsv/fastcsv.bundle

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in the gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Open North Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+# FastCSV
+
+[![Gem Version](https://badge.fury.io/rb/fastcsv.svg)](http://badge.fury.io/rb/fastcsv)
+[![Dependency Status](https://gemnasium.com/opennorth/fastcsv.png)](https://gemnasium.com/opennorth/fastcsv)
+
+A fast [Ragel](http://www.colm.net/open-source/ragel/)-based CSV parser.
+
+## Usage
+
+```ruby
+require 'fastcsv'
+
+# Read from file.
+File.open(filename) do |f|
+  FastCSV.raw_parse(f) do |row|
+    # do stuff
+  end
+end
+
+# Read from an IO object.
+FastCSV.raw_parse(StringIO.new("foo,bar\n")) do |row|
+  # do stuff
+end
+
+# Read from a string.
+FastCSV.raw_parse("foo,bar\n") do |row|
+  # do stuff
+end
+
+# Transcode like with the CSV module.
+FastCSV.raw_parse("\xF1\n", encoding: 'iso-8859-1:utf-8') do |row|
+  # ["ñ"]
+end
+```
+
+## Development
+
+    ragel -G2 ext/fastcsv/fastcsv.rl
+    ragel -Vp ext/fastcsv/fastcsv.rl | dot -Tpng -o machine.png
+    rake compile
+    gem uninstall fastcsv
+    rake install
+
+## Why?
+
+We evaluated [many CSV Ruby gems](https://github.com/jpmckinney/csv-benchmark#benchmark), and they were either too slow or had implementation errors. [rcsv](https://github.com/fiksu/rcsv) is fast and [libcsv](http://sourceforge.net/projects/libcsv/)-based, but it skips blank rows (Ruby's CSV module returns an empty array) and silently fails on input with an unclosed quote; nonetheless, it's an excellent alternative if you find errors in FastCSV! We looked for Ragel-based CSV parsers to copy, but they either had implementation errors or could not handle large inputs. [commas](https://github.com/aklt/commas/blob/master/csv.rl) looks good, but it performs a memory check on each character, which is overkill.
+
+## Bugs? Questions?
+
+This project's main repository is on GitHub: [http://github.com/opennorth/fastcsv](http://github.com/opennorth/fastcsv), where your contributions, forks, bug reports, feature requests, and feedback are greatly welcomed.
+
+## Acknowledgements
+
+Started as a Ruby 2.1 fork of MoonWolf <moonwolf@moonwolf.com>'s CSVScan, found in [this commit](https://github.com/nickstenning/csvscan/commit/11ec30f71a27cc673bca09738ee8a63942f416f0.patch). CSVScan uses Ragel code from [HPricot](https://github.com/hpricot/hpricot/blob/master/ext/hpricot_scan/hpricot_scan.rl) from [this commit](https://github.com/hpricot/hpricot/blob/908a4ae64bc8b935c4415c47ca6aea6492c6ce0a/ext/hpricot_scan/hpricot_scan.rl).
+
+Copyright (c) 2014 Open North Inc., released under the MIT license

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('fastcsv') do |ext|
+  ext.lib_dir = 'lib/fastcsv'
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yard, you must: gem install yard'
+  end
+end

data/USAGE

@@ -0,0 +1 @@
+See README.md for full usage details.

data/ext/fastcsv/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('fastcsv/fastcsv')

data/ext/fastcsv/fastcsv.c

@@ -0,0 +1,697 @@
+
+#line 1 "ext/fastcsv/fastcsv.rl"
+#include <ruby.h>
+#include <ruby/encoding.h>
+// CSV specifications.
+// http://tools.ietf.org/html/rfc4180
+// http://w3c.github.io/csvw/syntax/#ebnf
+
+// CSV implementation.
+// https://github.com/ruby/ruby/blob/master/lib/csv.rb
+
+// Ruby C extensions help.
+// https://github.com/ruby/ruby/blob/trunk/README.EXT
+// http://rxr.whitequark.org/mri/source
+
+// Ragel help.
+// https://www.mail-archive.com/ragel-users@complang.org/
+
+# define ASSOCIATE_INDEX \
+  if (internal_index >= 0) { \
+    rb_enc_associate_index(field, internal_index); \
+    field = rb_str_encode(field, rb_enc_from_encoding(external_encoding), 0, Qnil); \
+  } \
+  else { \
+    rb_enc_associate_index(field, rb_enc_to_index(external_encoding)); \
+  }
+
+static VALUE mModule, rb_eParseError;
+static ID s_read, s_to_str;
+
+
+#line 139 "ext/fastcsv/fastcsv.rl"
+
+
+
+#line 37 "ext/fastcsv/fastcsv.c"
+static const int fastcsv_start = 4;
+static const int fastcsv_first_final = 4;
+static const int fastcsv_error = 0;
+
+static const int fastcsv_en_main = 4;
+
+
+#line 142 "ext/fastcsv/fastcsv.rl"
+
+#define BUFSIZE 16384
+
+VALUE fastcsv(int argc, VALUE *argv, VALUE self) {
+  int cs, act, have = 0, curline = 1, io = 0;
+  char *ts = 0, *te = 0, *buf = 0, *eof = 0;
+
+  VALUE port, opts;
+  VALUE row = rb_ary_new(), field = Qnil, bufsize = Qnil;
+  int done = 0, unclosed_line = 0, buffer_size = 0, taint = 0;
+  int internal_index = 0, external_index = rb_enc_to_index(rb_default_external_encoding());
+  rb_encoding *external_encoding = rb_default_external_encoding();
+
+  VALUE option;
+  char quote_char = '"'; //, *col_sep = ",", *row_sep = "\r\n";
+
+  rb_scan_args(argc, argv, "11", &port, &opts);
+  taint = OBJ_TAINTED(port);
+  io = rb_respond_to(port, s_read);
+  if (!io) {
+    if (rb_respond_to(port, s_to_str)) {
+      port = rb_funcall(port, s_to_str, 0);
+      StringValue(port);
+    }
+    else {
+      rb_raise(rb_eArgError, "data has to respond to #read or #to_str");
+    }
+  }
+
+  if (NIL_P(opts)) {
+    opts = rb_hash_new();
+  }
+  else if (TYPE(opts) != T_HASH) {
+    rb_raise(rb_eArgError, "options has to be a Hash or nil");
+  }
+
+  // @note Add machines for common CSV dialects, or see if we can use "when"
+  // from Chapter 6 to compare the character to the host program's variable.
+  // option = rb_hash_aref(opts, ID2SYM(rb_intern("quote_char")));
+  // if (TYPE(option) == T_STRING && RSTRING_LEN(option) == 1) {
+  //   quote_char = *StringValueCStr(option);
+  // }
+  // else if (!NIL_P(option)) {
+  //   rb_raise(rb_eArgError, ":quote_char has to be a single character String");
+  // }
+
+  // option = rb_hash_aref(opts, ID2SYM(rb_intern("col_sep")));
+  // if (TYPE(option) == T_STRING) {
+  //   col_sep = StringValueCStr(option);
+  // }
+  // else if (!NIL_P(option)) {
+  //   rb_raise(rb_eArgError, ":col_sep has to be a String");
+  // }
+
+  // option = rb_hash_aref(opts, ID2SYM(rb_intern("row_sep")));
+  // if (TYPE(option) == T_STRING) {
+  //   row_sep = StringValueCStr(option);
+  // }
+  // else if (!NIL_P(option)) {
+  //   rb_raise(rb_eArgError, ":row_sep has to be a String");
+  // }
+
+  option = rb_hash_aref(opts, ID2SYM(rb_intern("encoding")));
+  if (TYPE(option) == T_STRING) {
+    // @see parse_mode_enc in Ruby's io.c
+    const char *string = StringValueCStr(option), *pointer;
+    char internal_encoding_name[ENCODING_MAXNAMELEN + 1];
+
+    pointer = strrchr(string, ':');
+    if (pointer) {
+      long len = (pointer++) - string;
+      if (len == 0 || len > ENCODING_MAXNAMELEN) {
+        internal_index = -1;
+      }
+      else {
+        memcpy(internal_encoding_name, string, len);
+        internal_encoding_name[len] = '\0';
+        string = internal_encoding_name;
+        internal_index = rb_enc_find_index(internal_encoding_name);
+      }
+    }
+    else {
+      internal_index = rb_enc_find_index(string);
+    }
+
+    if (internal_index < 0 && internal_index != -2) {
+      rb_warn("Unsupported encoding %s ignored", string);
+    }
+
+    if (pointer) {
+      external_index = rb_enc_find_index(pointer);
+      if (external_index >= 0) {
+        external_encoding = rb_enc_from_index(external_index);
+      }
+      else {
+        rb_warn("Unsupported encoding %s ignored", string);
+      }
+    }
+    else if (internal_index >= 0) {
+      external_encoding = rb_enc_from_index(internal_index);
+    }
+  }
+  else if (!NIL_P(option)) {
+    rb_raise(rb_eArgError, ":encoding has to be a String");
+  }
+
+  buffer_size = BUFSIZE;
+  if (rb_ivar_defined(self, rb_intern("@buffer_size")) == Qtrue) {
+    bufsize = rb_ivar_get(self, rb_intern("@buffer_size"));
+    if (!NIL_P(bufsize)) {
+      buffer_size = NUM2INT(bufsize);
+    }
+  }
+
+  if (io) {
+    buf = ALLOC_N(char, buffer_size);
+  }
+
+  
+#line 165 "ext/fastcsv/fastcsv.c"
+	{
+	cs = fastcsv_start;
+	ts = 0;
+	te = 0;
+	act = 0;
+	}
+
+#line 261 "ext/fastcsv/fastcsv.rl"
+
+  while (!done) {
+    VALUE str;
+    char *p, *pe;
+    int len, space = buffer_size - have, tokstart_diff, tokend_diff;
+
+    if (io) {
+      if (space == 0) {
+         tokstart_diff = ts - buf;
+         tokend_diff = te - buf;
+
+         buffer_size += BUFSIZE;
+         REALLOC_N(buf, char, buffer_size);
+
+         space = buffer_size - have;
+
+         ts = buf + tokstart_diff;
+         te = buf + tokend_diff;
+      }
+      p = buf + have;
+
+      str = rb_funcall(port, s_read, 1, INT2FIX(space));
+      if (NIL_P(str)) {
+        // StringIO#read returns nil for empty string.
+        len = 0;
+      }
+      else {
+        len = RSTRING_LEN(str);
+        memcpy(p, StringValuePtr(str), len);
+      }
+
+      if (len < space) {
+        // EOF actions don't work in scanners, so we add a sentinel value.
+        // @see http://www.complang.org/pipermail/ragel-users/2007-May/001516.html
+        // @see https://github.com/leeonix/lua-csv-ragel/blob/master/src/csv.rl
+        p[len++] = 0;
+        done = 1;
+      }
+    }
+    else {
+      p = RSTRING_PTR(port);
+      len = RSTRING_LEN(port);
+      p[len++] = 0;
+      done = 1;
+    }
+
+    pe = p + len;
+    // if (done) {
+    //   // This triggers the eof action in the non-scanner version.
+    //   eof = pe;
+    // }
+    
+#line 226 "ext/fastcsv/fastcsv.c"
+	{
+	if ( p == pe )
+		goto _test_eof;
+	switch ( cs )
+	{
+tr0:
+#line 1 "NONE"
+	{	switch( act ) {
+	case 0:
+	{{goto st0;}}
+	break;
+	default:
+	{{p = ((te))-1;}}
+	break;
+	}
+	}
+	goto st4;
+tr10:
+#line 105 "ext/fastcsv/fastcsv.rl"
+	{
+    if (!NIL_P(field) || RARRAY_LEN(row)) {
+      rb_ary_push(row, field);
+    }
+    if (RARRAY_LEN(row)) {
+      rb_yield(row);
+    }
+  }
+#line 129 "ext/fastcsv/fastcsv.rl"
+	{te = p+1;}
+	goto st4;
+tr16:
+#line 129 "ext/fastcsv/fastcsv.rl"
+	{te = p;p--;}
+	goto st4;
+tr17:
+#line 128 "ext/fastcsv/fastcsv.rl"
+	{te = p;p--;}
+	goto st4;
+tr18:
+#line 105 "ext/fastcsv/fastcsv.rl"
+	{
+    if (!NIL_P(field) || RARRAY_LEN(row)) {
+      rb_ary_push(row, field);
+    }
+    if (RARRAY_LEN(row)) {
+      rb_yield(row);
+    }
+  }
+#line 128 "ext/fastcsv/fastcsv.rl"
+	{te = p+1;}
+	goto st4;
+tr20:
+#line 127 "ext/fastcsv/fastcsv.rl"
+	{te = p;p--;}
+	goto st4;
+tr21:
+#line 105 "ext/fastcsv/fastcsv.rl"
+	{
+    if (!NIL_P(field) || RARRAY_LEN(row)) {
+      rb_ary_push(row, field);
+    }
+    if (RARRAY_LEN(row)) {
+      rb_yield(row);
+    }
+  }
+#line 127 "ext/fastcsv/fastcsv.rl"
+	{te = p+1;}
+	goto st4;
+st4:
+#line 1 "NONE"
+	{ts = 0;}
+#line 1 "NONE"
+	{act = 0;}
+	if ( ++p == pe )
+		goto _test_eof4;
+case 4:
+#line 1 "NONE"
+	{ts = p;}
+#line 305 "ext/fastcsv/fastcsv.c"
+	switch( (*p) ) {
+		case 0: goto tr14;
+		case 10: goto tr3;
+		case 13: goto tr4;
+		case 34: goto tr15;
+		case 44: goto tr5;
+	}
+	goto st1;
+st1:
+	if ( ++p == pe )
+		goto _test_eof1;
+case 1:
+	switch( (*p) ) {
+		case 0: goto tr2;
+		case 10: goto tr3;
+		case 13: goto tr4;
+		case 34: goto tr0;
+		case 44: goto tr5;
+	}
+	goto st1;
+tr2:
+#line 1 "NONE"
+	{te = p+1;}
+#line 44 "ext/fastcsv/fastcsv.rl"
+	{
+    if (p == ts) {
+      // Unquoted empty fields are nil, not "", in Ruby.
+      field = Qnil;
+    }
+    else if (p > ts) {
+      field = rb_str_new(ts, p - ts);
+      ASSOCIATE_INDEX;
+    }
+  }
+#line 105 "ext/fastcsv/fastcsv.rl"
+	{
+    if (!NIL_P(field) || RARRAY_LEN(row)) {
+      rb_ary_push(row, field);
+    }
+    if (RARRAY_LEN(row)) {
+      rb_yield(row);
+    }
+  }
+#line 129 "ext/fastcsv/fastcsv.rl"
+	{act = 3;}
+	goto st5;
+st5:
+	if ( ++p == pe )
+		goto _test_eof5;
+case 5:
+#line 356 "ext/fastcsv/fastcsv.c"
+	switch( (*p) ) {
+		case 0: goto tr2;
+		case 10: goto tr3;
+		case 13: goto tr4;
+		case 34: goto tr16;
+		case 44: goto tr5;
+	}
+	goto st1;
+tr3:
+#line 44 "ext/fastcsv/fastcsv.rl"
+	{
+    if (p == ts) {
+      // Unquoted empty fields are nil, not "", in Ruby.
+      field = Qnil;
+    }
+    else if (p > ts) {
+      field = rb_str_new(ts, p - ts);
+      ASSOCIATE_INDEX;
+    }
+  }
+#line 95 "ext/fastcsv/fastcsv.rl"
+	{
+    if (!NIL_P(field) || RARRAY_LEN(row)) { // same as new_field
+      rb_ary_push(row, field);
+      field = Qnil;
+    }
+
+    rb_yield(row);
+    row = rb_ary_new();
+  }
+#line 32 "ext/fastcsv/fastcsv.rl"
+	{
+    curline++;
+  }
+	goto st6;
+tr19:
+#line 32 "ext/fastcsv/fastcsv.rl"
+	{
+    curline++;
+  }
+	goto st6;
+tr11:
+#line 95 "ext/fastcsv/fastcsv.rl"
+	{
+    if (!NIL_P(field) || RARRAY_LEN(row)) { // same as new_field
+      rb_ary_push(row, field);
+      field = Qnil;
+    }
+
+    rb_yield(row);
+    row = rb_ary_new();
+  }
+#line 32 "ext/fastcsv/fastcsv.rl"
+	{
+    curline++;
+  }
+	goto st6;
+st6:
+	if ( ++p == pe )
+		goto _test_eof6;
+case 6:
+#line 418 "ext/fastcsv/fastcsv.c"
+	if ( (*p) == 0 )
+		goto tr18;
+	goto tr17;
+tr4:
+#line 44 "ext/fastcsv/fastcsv.rl"
+	{
+    if (p == ts) {
+      // Unquoted empty fields are nil, not "", in Ruby.
+      field = Qnil;
+    }
+    else if (p > ts) {
+      field = rb_str_new(ts, p - ts);
+      ASSOCIATE_INDEX;
+    }
+  }
+#line 95 "ext/fastcsv/fastcsv.rl"
+	{
+    if (!NIL_P(field) || RARRAY_LEN(row)) { // same as new_field
+      rb_ary_push(row, field);
+      field = Qnil;
+    }
+
+    rb_yield(row);
+    row = rb_ary_new();
+  }
+#line 32 "ext/fastcsv/fastcsv.rl"
+	{
+    curline++;
+  }
+	goto st7;
+tr12:
+#line 95 "ext/fastcsv/fastcsv.rl"
+	{
+    if (!NIL_P(field) || RARRAY_LEN(row)) { // same as new_field
+      rb_ary_push(row, field);
+      field = Qnil;
+    }
+
+    rb_yield(row);
+    row = rb_ary_new();
+  }
+#line 32 "ext/fastcsv/fastcsv.rl"
+	{
+    curline++;
+  }
+	goto st7;
+st7:
+	if ( ++p == pe )
+		goto _test_eof7;
+case 7:
+#line 469 "ext/fastcsv/fastcsv.c"
+	switch( (*p) ) {
+		case 0: goto tr18;
+		case 10: goto tr19;
+	}
+	goto tr17;
+tr5:
+#line 44 "ext/fastcsv/fastcsv.rl"
+	{
+    if (p == ts) {
+      // Unquoted empty fields are nil, not "", in Ruby.
+      field = Qnil;
+    }
+    else if (p > ts) {
+      field = rb_str_new(ts, p - ts);
+      ASSOCIATE_INDEX;
+    }
+  }
+#line 90 "ext/fastcsv/fastcsv.rl"
+	{
+    rb_ary_push(row, field);
+    field = Qnil;
+  }
+	goto st8;
+tr13:
+#line 90 "ext/fastcsv/fastcsv.rl"
+	{
+    rb_ary_push(row, field);
+    field = Qnil;
+  }
+	goto st8;
+st8:
+	if ( ++p == pe )
+		goto _test_eof8;
+case 8:
+#line 504 "ext/fastcsv/fastcsv.c"
+	if ( (*p) == 0 )
+		goto tr21;
+	goto tr20;
+tr14:
+#line 1 "NONE"
+	{te = p+1;}
+#line 105 "ext/fastcsv/fastcsv.rl"
+	{
+    if (!NIL_P(field) || RARRAY_LEN(row)) {
+      rb_ary_push(row, field);
+    }
+    if (RARRAY_LEN(row)) {
+      rb_yield(row);
+    }
+  }
+#line 44 "ext/fastcsv/fastcsv.rl"
+	{
+    if (p == ts) {
+      // Unquoted empty fields are nil, not "", in Ruby.
+      field = Qnil;
+    }
+    else if (p > ts) {
+      field = rb_str_new(ts, p - ts);
+      ASSOCIATE_INDEX;
+    }
+  }
+#line 129 "ext/fastcsv/fastcsv.rl"
+	{act = 3;}
+	goto st9;
+st9:
+	if ( ++p == pe )
+		goto _test_eof9;
+case 9:
+#line 538 "ext/fastcsv/fastcsv.c"
+	switch( (*p) ) {
+		case 10: goto tr16;
+		case 13: goto tr16;
+		case 34: goto tr16;
+		case 44: goto tr16;
+	}
+	goto st1;
+tr8:
+#line 32 "ext/fastcsv/fastcsv.rl"
+	{
+    curline++;
+  }
+	goto st2;
+tr15:
+#line 36 "ext/fastcsv/fastcsv.rl"
+	{
+    unclosed_line = curline;
+  }
+	goto st2;
+st2:
+	if ( ++p == pe )
+		goto _test_eof2;
+case 2:
+#line 562 "ext/fastcsv/fastcsv.c"
+	switch( (*p) ) {
+		case 0: goto st0;
+		case 10: goto tr8;
+		case 13: goto tr8;
+		case 34: goto tr9;
+	}
+	goto st2;
+st0:
+cs = 0;
+	goto _out;
+tr9:
+#line 55 "ext/fastcsv/fastcsv.rl"
+	{
+    if (p == ts) {
+      field = rb_str_new2("");
+      ASSOCIATE_INDEX;
+    }
+    // @note If we add an action on '""', we can skip some steps if no '""' is found.
+    else if (p > ts) {
+      // Operating on ts in-place produces odd behavior, FYI.
+      char *copy = ALLOC_N(char, p - ts);
+      memcpy(copy, ts, p - ts);
+
+      char *reader = ts, *writer = copy;
+      int escaped = 0;
+
+      while (p > reader) {
+        if (*reader == quote_char && !escaped) {
+          // Skip the escaping character.
+          escaped = 1;
+        }
+        else {
+          escaped = 0;
+          *writer++ = *reader;
+        }
+        reader++;
+      }
+
+      field = rb_str_new(copy, writer - copy);
+      ASSOCIATE_INDEX;
+
+      if (copy != NULL) {
+        free(copy);
+      }
+    }
+  }
+#line 40 "ext/fastcsv/fastcsv.rl"
+	{
+    unclosed_line = 0;
+  }
+	goto st3;
+st3:
+	if ( ++p == pe )
+		goto _test_eof3;
+case 3:
+#line 618 "ext/fastcsv/fastcsv.c"
+	switch( (*p) ) {
+		case 0: goto tr10;
+		case 10: goto tr11;
+		case 13: goto tr12;
+		case 34: goto st2;
+		case 44: goto tr13;
+	}
+	goto st0;
+	}
+	_test_eof4: cs = 4; goto _test_eof; 
+	_test_eof1: cs = 1; goto _test_eof; 
+	_test_eof5: cs = 5; goto _test_eof; 
+	_test_eof6: cs = 6; goto _test_eof; 
+	_test_eof7: cs = 7; goto _test_eof; 
+	_test_eof8: cs = 8; goto _test_eof; 
+	_test_eof9: cs = 9; goto _test_eof; 
+	_test_eof2: cs = 2; goto _test_eof; 
+	_test_eof3: cs = 3; goto _test_eof; 
+
+	_test_eof: {}
+	if ( p == eof )
+	{
+	switch ( cs ) {
+	case 1: goto tr0;
+	case 5: goto tr16;
+	case 6: goto tr17;
+	case 7: goto tr17;
+	case 8: goto tr20;
+	case 9: goto tr16;
+	}
+	}
+
+	_out: {}
+	}
+
+#line 313 "ext/fastcsv/fastcsv.rl"
+
+    if (done && cs < fastcsv_first_final) {
+      if (buf != NULL) {
+        free(buf);
+      }
+      if (unclosed_line) {
+        rb_raise(rb_eParseError, "Unclosed quoted field on line %d.", unclosed_line);
+      }
+      // Ruby raises different errors for illegal quoting, depending on whether
+      // a quoted string is followed by a string ("Unclosed quoted field on line
+      // %d.") or by a string ending in a quote ("Missing or stray quote in line
+      // %d"). These precisions are kind of bogus, but we can try using $!.
+      else {
+        rb_raise(rb_eParseError, "Illegal quoting in line %d.", curline);
+      }
+    }
+
+    if (ts == 0) {
+      have = 0;
+    }
+    else if (io) {
+      have = pe - ts;
+      memmove(buf, ts, have);
+      te = buf + (te - ts);
+      ts = buf;
+    }
+  }
+
+  if (buf != NULL) {
+    free(buf);
+  }
+
+  return Qnil;
+}
+
+void Init_fastcsv() {
+  s_read = rb_intern("read");
+  s_to_str = rb_intern("to_str");
+
+  mModule = rb_define_module("FastCSV");
+  rb_define_attr(rb_singleton_class(mModule), "buffer_size", 1, 1);
+  rb_define_singleton_method(mModule, "raw_parse", fastcsv, -1);
+  rb_eParseError = rb_define_class_under(mModule, "ParseError", rb_eStandardError);
+}