rubex 0.0.1 → 0.1

data/Rakefile

@@ -13,6 +13,9 @@ task :parser => :lexer do
   `racc lib/rubex/parser.racc -o lib/rubex/parser.racc.rb`
 end
 
+# -v -> verbose
+# -t -> with debugging output
+
 RSpec::Core::RakeTask.new(:spec)
 
-task :spec => :parser
+task :spec => :parser

data/TUTORIAL.md

@@ -0,0 +1,234 @@
+# Rubex tutorial
+
+Here's a quick tutorial of Rubex to get you up and started. Once you're through, take a moment to convert one of your C extensions to Rubex and see the difference in speed of development and simplicity.
+
+<!-- MarkdownTOC autolink="true" bracket="round" -->
+
+- [Basics of Rubex](#basics-of-rubex)
+  - [Rubex Hello World](#rubex-hello-world)
+  - [String#blank?](#stringblank)
+- [Calling C Functions](#calling-c-functions)
+- [C Functions](#c-functions)
+- ['Attach' Classes](#attach-classes)
+- [Error Handling](#error-handling)
+- [Using Rubex Inside A Gem](#using-rubex-inside-a-gem)
+- [Examples](#examples)
+  - [Interfacing C structs](#interfacing-c-structs)
+  - [Fully Functional Ruby Gem](#fully-functional-ruby-gem)
+
+<!-- /MarkdownTOC -->
+
+# Basics of Rubex
+
+The Rubex syntax is very close to that of Ruby. In most use cases you can simply add a static types to variables and you're good to go. Rubex files have an extension `.rubex`.
+
+Before starting, make sure you've installed Rubex with `gem install rubex`.
+
+## Rubex Hello World
+
+In a Rubex file titled `hello_word.rubex` paste the following code:
+``` ruby
+def hello_world
+  print "Hello world!"
+end
+```
+
+Now the use the `rubex` binary to compile the above program:
+```
+rubex hello_world.rubex
+```
+
+This will generate a folder called `hello_world` that will contain the files `extconf.rb` and `hello_world.c`. Now run the following:
+```
+cd hello_world
+ruby extconf.rb
+make
+```
+
+This will generate a shared object file called `hello_world.so` that can be used in any normal Ruby script like so:
+``` ruby
+require_relative 'hello_world.so'
+
+hello_world
+```
+
+## String#blank?
+
+Sam Saffron's famous [`fast_blank`](https://github.com/SamSaffron/fast_blank) gem is something that most Rubyists probably use a lot of times in their daily life. It is also a classic example of porting a Ruby gem to a C extension for reasons of speed.
+
+Here's the Rubex version of fast_blank:
+``` ruby
+class String
+  def blank?(string)
+    char *s = string
+    int i = 0
+
+    while i < string.size do
+      return false if s[i] != ' '
+    end
+
+    return true
+  end
+end
+```
+
+As you can see above, Rubex can implicitly convert between Ruby objects and C data types (like a Ruby `String` into a `char*` C array).
+
+# Calling C Functions
+
+One of the primary uses of Rubex is making it easy for interfacing with C libraries. This can be done by using the `lib` keyword at the top of a Rubex file.
+
+So say for example, you want to interface some functions from the `math.h` C header file. In order to do this, you first list out the prototypes of the functions that you want to interface inside `lib`, and then you can use these functions in your program.
+``` ruby
+lib "<math.h>"
+  double cos(double)
+  double sin(double)
+end
+
+class CMath
+  def f_sin(num)
+    return sin(num)
+  end
+
+  def f_cos(num)
+    return cos(num)
+  end
+end
+```
+
+These functions can be used in a similar manner to our hello_world program above. Keep in mind that you cannot (yet) have function names in your Rubex program that have the same name as that of the external C functions. This will cause name clashes and malfunction.
+
+Read what you can do more with `lib` in the [REFERENCE](REFERENCE.md).
+
+# C Functions
+
+Apart from Ruby class methods and instance methods, Rubex allows you to define 'C functions' that are only accessible inside classes from within Rubex. These functions _cannot_ be accessed from an external Ruby script.
+
+C functions are defined used the `cfunc` keyword. You also need to specify the return type of the function along with its definition. For example:
+``` ruby
+class CFunctionTest
+  def foo(int n)
+    return bar(n)
+  end
+
+  # bar is a C function.
+  cfunc int bar(int n)
+    return n + 5
+  end
+end
+```
+
+# 'Attach' Classes
+
+Rubex introduces a special syntax that allows you to directly interface Ruby with C structs using some special language constructs, called 'attach' classes. These are normal Ruby classes and can be instantiated and used just like any other Ruby class, but with one caveat - they are permanently attached to a C struct and implicitly interface this struct with the Ruby VM.
+
+Let me demonstrate with an example:
+``` ruby
+# file: structs.rubex
+lib "rubex/ruby"; end
+
+struct mp3info
+  int id
+  char* title
+end
+
+class Music attach mp3info
+  def initialize(id, title)
+    mp3info* mp3 = data$.mp3info
+
+    mp3.id = id
+    mp3.title = title
+  end
+
+  def id
+    return data$.mp3info.id
+  end
+
+  def title
+    return data$.mp3info.title
+  end
+
+  cfunc void deallocate
+    xfree(data$.mp3info)
+  end
+end
+```
+This program can be used in a Ruby script like this:
+``` ruby
+require 'structs.so'
+
+id = 1
+title = "CAFO"
+m = Music.new id, title
+puts m.id, m.title
+```
+
+The above example has some notable Rubex constructs:
+
+### The attach keyword
+
+The 'attach' keyword is a special keyword that is used for associating a particular struct with a Ruby class. Once this keyword is used, the Rubex compiler will take care of allocation, deallocation and fetching of the struct (more about this in the [REFERENCE](REFERENCE.md)). The user only needs to concern themselves with using and allocating the data inside the struct.
+
+In the above case, `attach` creates tells the class `Music` that it will be associated with a C struct of type `mp3info`.
+
+### The data$ variable
+
+The `data$` variable is a special variable keyword that is available _only_ inside attach classes. The `data$` variable allows access to the `mp3info` struct. In order to do this, it makes available a **pointer** to the struct that is of the same name as the struct (i.e. `mp3info` for `struct mp3info` or `foo` for `struct foo`). This pointer to the struct can then be used for reading or writing elements in the struct.
+
+### The deallocate C function
+
+Once you are done using an instance of your newly created attach class, Ruby's GC will want to clean up the memory used by it so that it can be used by other objects. In order to not have any memory leaks later, it is important to tell the GC that the memory that was used up by the `mp3info` struct needs to be freed. This freeing up of memory should be done inside the `deallocate` function.
+
+The `xfree` function, which is the standard memory freeing function provided by the Ruby interpreter is used for this purpose.
+
+# Error Handling
+
+Rubex greatly simplifies error handling for C extensions. It now gives you the full power of a Ruby `begin-rescue-else-ensure` block. You can also define variables inside these blocks!
+
+Here's an example:
+``` ruby
+def error_example(int n)
+  begin
+    raise ArgumentError if n == 1
+    raise SyntaxError if n == 2
+  rescue ArgumentError
+    n += 10
+  rescue SyntaxError
+    n += 20
+  ensure
+    n += 5
+  end
+
+  return n
+end
+```
+
+# Using Rubex Inside A Gem
+
+Rubex ships with pre-built rake tasks that can be for compiling a Rubex file. In order to use these, simply drop in the following code into your `Rakefile`:
+``` ruby
+require 'rubex/rake_task'
+
+Rubex::RakeTask.new('hello_world')
+```
+
+Above rake task assumes that you use the standard Ruby gem structure:
+```
+|-- ext
+|   `-- hello_world
+|       `-- hello_world.rubex
+|-- lib
+`-- Rakefile
+```
+
+Calling `rake compile` will generate `hello_world.c` and `extconf.rb` in your `ext` folder and place `hello_world.so` in your `lib/` folder which you directly use with a simple `require`.
+
+# Examples
+
+## Interfacing C structs
+
+[This example](https://github.com/v0dro/rubex/tree/master/examples/c_struct_interface) is a program that interfaces with a C struct and creates reader and writer methods for C struct elements through a Ruby interface.
+
+## Fully Functional Ruby Gem
+
+See the [rcsv example](https://github.com/v0dro/rubex/tree/master/examples/rcsv%20wrapper/rcsv) for a fully functional rubygem that wraps around the [libcsv](https://sourceforge.net/projects/libcsv/) C library for parsing CSV files.

data/bin/rubex

@@ -7,4 +7,4 @@ if File.exists? file_name
   file_name = Dir.pwd + "/#{file_name}"
 end
 
-Rubex.compile file_name
+Rubex::Compiler.compile file_name

data/docs/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-dinky

data/docs/index.html

@@ -0,0 +1 @@
+<h1>Docs go here!</h1>

data/examples/c_struct_interface/c_struct_interface.rb

@@ -0,0 +1,6 @@
+require_relative 'c_struct_interface/c_struct_interface.so'
+
+m = Music.new("Periphery", "Marigold", 1)
+
+puts m.artist
+puts m.title

data/examples/c_struct_interface/c_struct_interface.rubex

@@ -0,0 +1,47 @@
+lib "rubex/ruby"; end
+
+struct mp3info
+  char *artist, *title
+  int id
+end
+
+# The class that will be 'attached' to the struct and will make it possible to
+#   initialize instances of the struct. There will be a variable called `data`
+#   which will be made available to the user which will be of type
+#   'struct __rubex_data_Music'. This variable will be available throughout the class.
+#
+# The allocate function will be defined implicitly, and calls to `TypeData_*`
+#   macros will also be implicit.
+#
+# The data variable is analogous to the 'params' variable in Sinatra routes.
+class Music attach mp3info
+  def initialize(artist, title, id)
+    mp3info* mp3 = data$.mp3info
+    int a_size = artist.size
+    int t_size = title.size
+
+    mp3.artist = artist # implicit conversion of Ruby String to char*
+    mp3.title = title # implicit conversion of Ruby String to char*
+    mp3.id = id # implicit typecast to int
+  end
+
+  # The deallocate function will be used by TypeData_* macros as a function
+  #   for freeing memory once this class has been GC'd. It will be a compulsory
+  #   method for such 'attach' classes and will not be callable through Ruby
+  #   scripts.
+  cfunc void deallocate
+    xfree(data$.mp3info)
+  end
+
+  def artist
+    return data$.mp3info.artist # typecast to ruby string
+  end
+
+  def title
+    return data$.mp3info.title # typecast to ruby string
+  end
+
+  def id
+    return data$.mp3info.id
+  end
+end

data/examples/linked_list/linked_list.rubex

@@ -0,0 +1,39 @@
+struct node
+  int data
+  object next
+end
+
+class LLNode attach node
+  def initialize(int d)
+    node n = data.node
+
+    n.data = d
+    n.next = nil
+  endturn
+
+  def add_node d
+    node n = data.node
+
+    new_node = LLNode.new(d)
+    n.next = new_node
+  end
+
+  def print_list
+    node n = data.node
+
+    temp = self
+    print "The linked list is: \n"
+    while next_node do
+      print temp.get_data
+      temp = n.next_node
+    end
+  end
+
+  def get_data
+    return data.node.data
+  end
+
+  def next_node
+    return data.node.next
+  end
+end

data/examples/linked_list/rb_linked_list.rb

@@ -0,0 +1,8 @@
+require 'linked_list.so'
+
+list = LLNode.new(0)
+10.times do |a|
+  list.add_node(a)
+end
+
+list.print_list

data/examples/rcsv wrapper/rcsv/README.md

@@ -0,0 +1 @@
+Rubex wrapper over libcsv.

data/examples/rcsv wrapper/rcsv/Rakefile

@@ -0,0 +1,7 @@
+require 'rubex/rake_task'
+require 'rspec/core/rake_task'
+
+Rubex::RakeTask.new('rcsv')
+RSpec::Core::RakeTask.new(:spec)
+
+task :spec => :compile

data/examples/rcsv wrapper/rcsv/ext/rcsv/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$libs += " -lcsv"
+create_makefile('ext/rcsv/rcsv')

data/examples/rcsv wrapper/rcsv/ext/rcsv/rcsv.c

@@ -0,0 +1,302 @@
+/* C extension for rcsv.
+This file in generated by Rubex::Compiler. Do not change!
+File generation time: 2017-08-28 23:47:06 +0530.*/
+
+#include <ruby.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <stdlib.h>
+#include "csv.h"
+
+#define __rubex_INT2BOOL(arg) (arg ? Qtrue : Qfalse)
+
+
+
+typedef struct rcsv_metadata
+{
+  int __rubex_v_skip_current_row;
+  size_t __rubex_v_current_col;
+  size_t __rubex_v_current_row;
+  VALUE __rubex_v_last_entry;
+  VALUE __rubex_v_result;
+} __rubex_t_Object_rcsv_metadata;
+
+
+
+VALUE rb_cObject;
+VALUE rb_eStandardError;
+VALUE __rubex_rb_cls_RcsvParseError;
+VALUE __rubex_rb_cls_Rcsv;
+static VALUE global_begin_block_Rcsv_parse_1__rubex_arg_dummy;
+static VALUE global_begin_block_Rcsv_parse_1__rubex_v_csvstr;
+static VALUE global_begin_block_Rcsv_parse_1__rubex_v_csvio;
+static char* global_begin_block_Rcsv_parse_1__rubex_ptr_csv_string;
+static int global_begin_block_Rcsv_parse_1__rubex_v_csv_string_len;
+static struct csv_parser global_begin_block_Rcsv_parse_1__rubex_v_cp;
+static __rubex_t_Object_rcsv_metadata global_begin_block_Rcsv_parse_1__rubex_v_meta;
+static int global_begin_block_Rcsv_parse_1__rubex_v_error;
+static VALUE __rubex_rb_f_Rcsv_parse (int argc,VALUE* argv,VALUE __rubex_arg_self);
+static void __rubex_c_f_Rcsv_end_of_field_callback (void* __rubex_arg_field,size_t __rubex_arg_field_size,void* __rubex_arg_data,VALUE __rubex_arg_self);
+static void __rubex_c_f_Rcsv_end_of_line_callback (int __rubex_arg_last_char,void* __rubex_arg_data,VALUE __rubex_arg_self);
+static VALUE __rubex_c_f_Rcsv_ENCODED_STR_NEW (char* __rubex_arg_string,int __rubex_arg_length,VALUE __rubex_arg_self);
+static void __rubex_c_f_Rcsv_setup_rcsv_metadata_defaults (__rubex_t_Object_rcsv_metadata* __rubex_arg_p_meta,VALUE __rubex_arg_self);
+static VALUE __rubex_c_f_begin_block_Rcsv_parse_1 (VALUE global_begin_block_Rcsv_parse_1__rubex_arg_dummy);
+
+VALUE __rubex_char2rubystr(char ch);
+VALUE __rubex_char2rubystr(char ch)
+{
+  char s[2];
+  s[0] = ch;
+  s[1] = '\0';
+  return rb_str_new2(s);
+}
+
+
+static VALUE __rubex_c_f_begin_block_Rcsv_parse_1 (VALUE global_begin_block_Rcsv_parse_1__rubex_arg_dummy)
+{
+  VALUE __rubex_v_ensure_container;
+  VALUE __rubex_temp_1;
+  while (Qtrue)
+  {
+
+    /* Rubex file location: ext/rcsv/rcsv.rubex:93 */
+    global_begin_block_Rcsv_parse_1__rubex_v_csvstr = rb_funcall(global_begin_block_Rcsv_parse_1__rubex_v_csvio, rb_intern("read"), 0, NULL);
+    if (RTEST(( __rubex_INT2BOOL(RTEST(rb_funcall(global_begin_block_Rcsv_parse_1__rubex_v_csvstr, rb_intern("nil?"), 0, NULL)) || RTEST(( rb_funcall(rb_funcall(global_begin_block_Rcsv_parse_1__rubex_v_csvstr, rb_intern("size"), 0, NULL), rb_intern("==") , 1, INT2NUM(0)) ))) ))) 
+    {
+
+      /* Rubex file location: ext/rcsv/rcsv.rubex:95 */
+      break;
+
+    }
+
+    global_begin_block_Rcsv_parse_1__rubex_ptr_csv_string = StringValueCStr(global_begin_block_Rcsv_parse_1__rubex_v_csvstr);
+
+    /* Rubex file location: ext/rcsv/rcsv.rubex:98 */
+    global_begin_block_Rcsv_parse_1__rubex_v_csv_string_len = NUM2INT(rb_funcall(global_begin_block_Rcsv_parse_1__rubex_v_csvstr, rb_intern("size"), 0, NULL));
+    if (( global_begin_block_Rcsv_parse_1__rubex_v_csv_string_len != csv_parse(&global_begin_block_Rcsv_parse_1__rubex_v_cp,global_begin_block_Rcsv_parse_1__rubex_ptr_csv_string,global_begin_block_Rcsv_parse_1__rubex_v_csv_string_len,&__rubex_c_f_Rcsv_end_of_field_callback,&__rubex_c_f_Rcsv_end_of_line_callback,&global_begin_block_Rcsv_parse_1__rubex_v_meta) )) 
+    {
+      global_begin_block_Rcsv_parse_1__rubex_v_error = csv_error(&global_begin_block_Rcsv_parse_1__rubex_v_cp);
+
+      if (( global_begin_block_Rcsv_parse_1__rubex_v_error == CSV_EPARSE )) 
+      {
+        __rubex_temp_1 = rb_str_new2("Error when parsing malformed data.");
+        rb_raise(__rubex_rb_cls_RcsvParseError,"%s" ,RSTRING_PTR(rb_funcall(__rubex_temp_1, rb_intern("inspect"), 0, NULL)));
+        __rubex_temp_1 = 0;
+
+      }
+
+      else if (( global_begin_block_Rcsv_parse_1__rubex_v_error == CSV_ENOMEM )) 
+      {
+        __rubex_temp_1 = rb_str_new2("No memory.");
+        rb_raise(__rubex_rb_cls_RcsvParseError,"%s" ,RSTRING_PTR(rb_funcall(__rubex_temp_1, rb_intern("inspect"), 0, NULL)));
+        __rubex_temp_1 = 0;
+
+      }
+
+      else if (( global_begin_block_Rcsv_parse_1__rubex_v_error == CSV_ETOOBIG )) 
+      {
+        __rubex_temp_1 = rb_str_new2("Field data data is too large.");
+        rb_raise(__rubex_rb_cls_RcsvParseError,"%s" ,RSTRING_PTR(rb_funcall(__rubex_temp_1, rb_intern("inspect"), 0, NULL)));
+        __rubex_temp_1 = 0;
+
+      }
+
+      else if (( global_begin_block_Rcsv_parse_1__rubex_v_error == CSV_EINVALID )) 
+      {
+        rb_raise(__rubex_rb_cls_RcsvParseError,"");
+
+      }
+
+      else
+      {
+        __rubex_temp_1 = rb_str_new2("Something went wrong.");
+        rb_raise(__rubex_rb_cls_RcsvParseError,"%s" ,RSTRING_PTR(rb_funcall(__rubex_temp_1, rb_intern("inspect"), 0, NULL)));
+        __rubex_temp_1 = 0;
+
+      }
+
+
+    }
+
+  }
+
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:117 */
+  csv_fini(&global_begin_block_Rcsv_parse_1__rubex_v_cp,&__rubex_c_f_Rcsv_end_of_field_callback,&__rubex_c_f_Rcsv_end_of_line_callback,&global_begin_block_Rcsv_parse_1__rubex_v_meta);
+}
+
+static void __rubex_c_f_Rcsv_end_of_field_callback (void* __rubex_arg_field,size_t __rubex_arg_field_size,void* __rubex_arg_data,VALUE __rubex_arg_self)
+{
+  char* __rubex_ptr_field_str;
+  __rubex_t_Object_rcsv_metadata* __rubex_ptr_meta_p;
+  __rubex_t_Object_rcsv_metadata __rubex_v_meta;
+  char __rubex_v_row_conversion;
+  VALUE __rubex_v_parsed_field;
+  __rubex_ptr_field_str = (char*)__rubex_arg_field;
+  __rubex_ptr_meta_p = (__rubex_t_Object_rcsv_metadata*)__rubex_arg_data;
+  __rubex_v_meta = __rubex_ptr_meta_p[0];
+  __rubex_v_row_conversion = 0;
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:48 */
+  __rubex_v_parsed_field = __rubex_c_f_Rcsv_ENCODED_STR_NEW(__rubex_ptr_field_str,__rubex_arg_field_size,__rubex_arg_self);
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:50 */
+  rb_funcall(__rubex_ptr_meta_p[0].__rubex_v_last_entry, rb_intern("push"), 1 ,__rubex_v_parsed_field);
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:51 */
+  __rubex_ptr_meta_p[0].__rubex_v_current_col = ( __rubex_ptr_meta_p[0].__rubex_v_current_col + 1 );
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:52 */
+  return ;
+}
+
+static void __rubex_c_f_Rcsv_end_of_line_callback (int __rubex_arg_last_char,void* __rubex_arg_data,VALUE __rubex_arg_self)
+{
+  __rubex_t_Object_rcsv_metadata* __rubex_ptr_meta;
+  VALUE __rubex_temp_1;
+  __rubex_ptr_meta = (__rubex_t_Object_rcsv_metadata*)__rubex_arg_data;
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:58 */
+  rb_funcall(__rubex_ptr_meta->__rubex_v_result, rb_intern("push"), 1 ,__rubex_ptr_meta->__rubex_v_last_entry);
+  if (( __rubex_arg_last_char != -1 )) 
+  {
+
+    /* Rubex file location: ext/rcsv/rcsv.rubex:59 */
+    __rubex_temp_1 = rb_ary_new2(0);
+    __rubex_ptr_meta->__rubex_v_last_entry = __rubex_temp_1;
+    __rubex_temp_1 = 0;
+
+  }
+
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:60 */
+  __rubex_ptr_meta->__rubex_v_current_col = 0;
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:61 */
+  __rubex_ptr_meta->__rubex_v_current_row = ( __rubex_ptr_meta->__rubex_v_current_row + 1 );
+}
+
+static VALUE __rubex_c_f_Rcsv_ENCODED_STR_NEW (char* __rubex_arg_string,int __rubex_arg_length,VALUE __rubex_arg_self)
+{
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:65 */
+  return rb_str_new(__rubex_arg_string,__rubex_arg_length);
+}
+
+static void __rubex_c_f_Rcsv_setup_rcsv_metadata_defaults (__rubex_t_Object_rcsv_metadata* __rubex_arg_p_meta,VALUE __rubex_arg_self)
+{
+  VALUE __rubex_temp_1;
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:69 */
+  __rubex_arg_p_meta->__rubex_v_skip_current_row = 0;
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:70 */
+  __rubex_arg_p_meta->__rubex_v_current_col = 0;
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:71 */
+  __rubex_arg_p_meta->__rubex_v_current_row = 0;
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:72 */
+  __rubex_temp_1 = rb_ary_new2(0);
+  __rubex_arg_p_meta->__rubex_v_result = __rubex_temp_1;
+  __rubex_temp_1 = 0;
+}
+
+static VALUE __rubex_rb_f_Rcsv_parse (int argc,VALUE* argv,VALUE __rubex_arg_self)
+{
+  VALUE __rubex_arg_file_name;
+  VALUE __rubex_arg_opts;
+  VALUE __rubex_v_options;
+  VALUE __rubex_v_option;
+  unsigned char __rubex_v_csv_options;
+  int __rubex_v_begin_block_1_state;
+  VALUE __rubex_v_begin_block_1_exec;
+  int __rubex_v_begin_block_1_unhandled_error;
+  VALUE __rubex_v_ensure_container;
+  VALUE __rubex_temp_1;
+  if (argc < 2)
+  {
+    rb_raise(rb_eArgError, "Need 2 args, not %d", argc);
+  }
+
+  __rubex_arg_file_name=argv[0];
+  __rubex_arg_opts=argv[1];
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:79 */
+  __rubex_temp_1 = rb_ary_new2(0);
+  __rubex_v_ensure_container = __rubex_temp_1;
+  __rubex_temp_1 = 0;
+  __rubex_temp_1 = 0;
+  __rubex_v_csv_options = ( CSV_STRICT_FINI | CSV_APPEND_NULL );
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:83 */
+  __rubex_c_f_Rcsv_setup_rcsv_metadata_defaults(&global_begin_block_Rcsv_parse_1__rubex_v_meta,__rubex_arg_self);
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:84 */
+  global_begin_block_Rcsv_parse_1__rubex_v_csvio = rb_funcall(rb_const_get(CLASS_OF(__rubex_arg_self), rb_intern("StringIO")), rb_intern("new"), 1 ,__rubex_arg_file_name);
+  if (( csv_init(&global_begin_block_Rcsv_parse_1__rubex_v_cp,__rubex_v_csv_options) == -1 )) 
+  {
+    __rubex_temp_1 = rb_str_new2("Failed to initialize libcsv.");
+    rb_raise(__rubex_rb_cls_RcsvParseError,"%s" ,RSTRING_PTR(rb_funcall(__rubex_temp_1, rb_intern("inspect"), 0, NULL)));
+    __rubex_temp_1 = 0;
+
+  }
+
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:89 */
+  __rubex_temp_1 = rb_ary_new2(0);
+  global_begin_block_Rcsv_parse_1__rubex_v_meta.__rubex_v_last_entry = __rubex_temp_1;
+  __rubex_temp_1 = 0;
+
+  /* begin-rescue-else-ensure-end block begins: */
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:120 */
+  __rubex_v_begin_block_1_state = 0;
+  rb_protect(__rubex_c_f_begin_block_Rcsv_parse_1, Qnil, &__rubex_v_begin_block_1_state);
+  __rubex_v_begin_block_1_exec = rb_errinfo();
+  __rubex_v_begin_block_1_unhandled_error = 0;
+  if (0) {}
+  else
+  {
+    /* If exception not among those captured in raise */
+    if (__rubex_v_begin_block_1_state)
+    {
+      __rubex_v_begin_block_1_unhandled_error = 1;
+    }
+
+  }
+
+  if (&global_begin_block_Rcsv_parse_1__rubex_v_cp) 
+  {
+
+    /* Rubex file location: ext/rcsv/rcsv.rubex:119 */
+    csv_free(&global_begin_block_Rcsv_parse_1__rubex_v_cp);
+
+  }
+
+  if (__rubex_v_begin_block_1_unhandled_error)
+  {
+    rb_jump_tag(__rubex_v_begin_block_1_state);
+  }
+
+  rb_set_errinfo(Qnil);
+
+  /* Rubex file location: ext/rcsv/rcsv.rubex:122 */
+  return global_begin_block_Rcsv_parse_1__rubex_v_meta.__rubex_v_result;
+}
+
+
+void Init_rcsv ();
+void Init_rcsv ()
+{
+  VALUE __rubex_rb_cls_RcsvParseError;
+  VALUE __rubex_rb_cls_Rcsv;
+
+  __rubex_rb_cls_RcsvParseError = rb_define_class("RcsvParseError", rb_eStandardError);
+  __rubex_rb_cls_Rcsv = rb_define_class("Rcsv", rb_cObject);
+
+  rb_define_singleton_method(__rubex_rb_cls_Rcsv ,"parse", __rubex_rb_f_Rcsv_parse, -1);
+}
+