brianmario-yajl-ruby 0.4.8 → 0.5.0

data/examples/http/twitter_search_api.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../../lib')
+
+require 'rubygems'
+require 'yajl/http_stream'
+require 'uri'
+
+unless keywords = ARGV[0]
+  puts "\nUsage: ruby examples/http/twitter_search_api.rb keyword\n\n"
+  exit(0)
+end
+captured = 0
+uri = URI.parse("http://search.twitter.com/search.json?q=#{keywords}")
+
+puts Yajl::HttpStream.get(uri).inspect

data/examples/http/twitter_stream_api.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../../lib')
+
+require 'rubygems'
+require 'yajl/http_stream'
+require 'uri'
+
+unless (username = ARGV[0]) && (password = ARGV[1])
+  puts "\nUsage: ruby examples/http/twitter_stream_api.rb username password\n\n"
+  exit(0)
+end
+captured = 0
+uri = URI.parse("http://#{username}:#{password}@stream.twitter.com/spritzer.json")
+
+trap('INT') {
+  puts "\n\nCaptured #{captured} objects from the stream"
+  puts "CTRL+C caught, later!"
+  exit(0)
+}
+
+Yajl::HttpStream.get(uri) do |hash|
+  puts hash.inspect
+  captured += 1
+end

data/examples/parsing/from_file.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'yajl'
+
+unless file = ARGV[0]
+  puts "\nUsage: ruby examples/from_file.rb benchmark/subjects/item.json\n\n"
+  exit(0)
+end
+
+json = File.new(file, 'r')
+
+hash = Yajl::Parser.new.parse(json)
+puts hash.inspect

data/examples/parsing/from_stdin.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'yajl'
+
+# Usage: cat benchmark/subjects/item.json | ruby examples/from_stdin.rb
+
+hash = Yajl::Parser.new.parse(STDIN)
+puts hash.inspect

data/examples/parsing/from_string.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'yajl'
+require 'stringio'
+
+unless string = ARGV[0]
+  puts "\nUsage: ruby examples/from_string.rb '{\"foo\": 1145}'\n\n"
+  exit(0)
+end
+
+json = StringIO.new(string)
+
+hash = Yajl::Parser.new.parse(json)
+puts hash.inspect

data/ext/api/yajl_parse.h

@@ -131,6 +131,9 @@ extern "C" {
                                     const yajl_parser_config * config,
                                     const yajl_alloc_funcs * allocFuncs,
                                     void * ctx);
+    
+    /** allow resetting of the lexer without the need to realloc a new parser */
+    void yajl_reset_parser(yajl_handle hand);
 
     /** free a parser handle */    
     void YAJL_API yajl_free(yajl_handle handle);

data/ext/extconf.rb

@@ -2,6 +2,7 @@
 require 'mkmf'
 require 'rbconfig'
 
-# $CFLAGS << ' -Wall'
+$CFLAGS << ' -Wall'
+# $CFLAGS << ' -O0 -ggdb'
 
 create_makefile("yajl_ext")

data/ext/yajl.c

@@ -104,6 +104,11 @@ yajl_alloc(const yajl_callbacks * callbacks,
     return hand;
 }
 
+void
+yajl_reset_parser(yajl_handle hand) {
+    hand->lexer = yajl_lex_realloc(hand->lexer);
+}
+
 void
 yajl_free(yajl_handle handle)
 {

data/ext/yajl_ext.c

@@ -1,55 +1,63 @@
 #include "yajl_ext.h"
 
-void check_and_fire_callback(void * ctx) {
-    yajl_status stat;
+// Helpers for building objects
+void yajl_check_and_fire_callback(void * ctx) {
+    struct yajl_parser_wrapper * wrapper;
+    GetParser((VALUE)ctx, wrapper);
     
-    if (RARRAY_LEN((VALUE)ctx) == 1 && parse_complete_callback != Qnil) {
-        // parse any remaining buffered data
-        stat = yajl_parse_complete(chunkedParser);
-        
-        rb_funcall(parse_complete_callback, intern_call, 1, rb_ary_pop((VALUE)ctx));
+    // No need to do any of this if the callback isn't even setup
+    if (wrapper->parse_complete_callback != Qnil) {
+        int len = RARRAY_LEN(wrapper->builderStack);
+        if (len == 1 && wrapper->nestedArrayLevel == 0 && wrapper->nestedHashLevel == 0) {
+            rb_funcall(wrapper->parse_complete_callback, intern_call, 1, rb_ary_pop(wrapper->builderStack));
+        }
     }
 }
 
-void set_static_value(void * ctx, VALUE val) {
-    VALUE len = RARRAY_LEN((VALUE)ctx);
+void yajl_set_static_value(void * ctx, VALUE val) {
+    struct yajl_parser_wrapper * wrapper;
+    VALUE lastEntry, hash;
+    int len;
     
+    GetParser((VALUE)ctx, wrapper);
+    
+    len = RARRAY_LEN(wrapper->builderStack);
     if (len > 0) {
-        VALUE lastEntry = rb_ary_entry((VALUE)ctx, len-1);
-        VALUE hash;
+        lastEntry = rb_ary_entry(wrapper->builderStack, len-1);
         switch (TYPE(lastEntry)) {
             case T_ARRAY:
                 rb_ary_push(lastEntry, val);
                 if (TYPE(val) == T_HASH || TYPE(val) == T_ARRAY) {
-                    rb_ary_push((VALUE)ctx, val);
+                    rb_ary_push(wrapper->builderStack, val);
                 }
                 break;
             case T_HASH:
                 rb_hash_aset(lastEntry, val, Qnil);
-                rb_ary_push((VALUE)ctx, val);
+                rb_ary_push(wrapper->builderStack, val);
                 break;
             case T_STRING:
-                hash = rb_ary_entry((VALUE)ctx, len-2);
+                hash = rb_ary_entry(wrapper->builderStack, len-2);
                 if (TYPE(hash) == T_HASH) {
                     rb_hash_aset(hash, lastEntry, val);
-                    rb_ary_pop((VALUE)ctx);
+                    rb_ary_pop(wrapper->builderStack);
                     if (TYPE(val) == T_HASH || TYPE(val) == T_ARRAY) {
-                        rb_ary_push((VALUE)ctx, val);
+                        rb_ary_push(wrapper->builderStack, val);
                     }
                 }
                 break;
         }
     } else {
-        rb_ary_push((VALUE)ctx, val);
+        rb_ary_push(wrapper->builderStack, val);
     }
 }
 
-void encode_part(yajl_gen hand, VALUE obj, VALUE io) {
+void yajl_encode_part(yajl_gen hand, VALUE obj, VALUE io) {
     VALUE str, outBuff, otherObj;
     int objLen;
     int idx = 0;
     const unsigned char * buffer;
     unsigned int len;
+    
     yajl_gen_get_buf(hand, &buffer, &len);
     outBuff = rb_str_new((const char *)buffer, len);
     rb_io_write(io, outBuff);
@@ -65,9 +73,9 @@ void encode_part(yajl_gen hand, VALUE obj, VALUE io) {
             for(idx=0; idx<RARRAY_LEN(keys); idx++) {
                 entry = rb_ary_entry(keys, idx);
                 // the key
-                encode_part(hand, entry, io);
+                yajl_encode_part(hand, entry, io);
                 // the value
-                encode_part(hand, rb_hash_aref(obj, entry), io);
+                yajl_encode_part(hand, rb_hash_aref(obj, entry), io);
             }
             
             yajl_gen_map_close(hand);
@@ -76,7 +84,7 @@ void encode_part(yajl_gen hand, VALUE obj, VALUE io) {
             yajl_gen_array_open(hand);
             for(idx=0; idx<RARRAY_LEN(obj); idx++) {
                 otherObj = rb_ary_entry(obj, idx);
-                encode_part(hand, otherObj, io);
+                yajl_encode_part(hand, otherObj, io);
             }
             yajl_gen_array_close(hand);
             break;
@@ -104,180 +112,285 @@ void encode_part(yajl_gen hand, VALUE obj, VALUE io) {
     }
 }
 
-static int found_null(void * ctx) {
-    set_static_value(ctx, Qnil);
-    check_and_fire_callback(ctx);
+void yajl_parser_wrapper_free(void * wrapper) {
+    struct yajl_parser_wrapper * w = wrapper;
+    yajl_free(w->parser);
+    free(w);
+}
+
+void yajl_parser_wrapper_mark(void * wrapper) {
+    struct yajl_parser_wrapper * w = wrapper;
+    rb_gc_mark(w->builderStack);
+    rb_gc_mark(w->parse_complete_callback);
+}
+
+// YAJL Callbacks
+static int yajl_found_null(void * ctx) {
+    yajl_set_static_value(ctx, Qnil);
+    yajl_check_and_fire_callback(ctx);
     return 1;
 }
 
-static int found_boolean(void * ctx, int boolean) {
-    set_static_value(ctx, boolean ? Qtrue : Qfalse);
-    check_and_fire_callback(ctx);
+static int yajl_found_boolean(void * ctx, int boolean) {
+    yajl_set_static_value(ctx, boolean ? Qtrue : Qfalse);
+    yajl_check_and_fire_callback(ctx);
     return 1;
 }
 
-static int found_number(void * ctx, const char * numberVal, unsigned int numberLen) {
+static int yajl_found_number(void * ctx, const char * numberVal, unsigned int numberLen) {
     VALUE subString = rb_str_new(numberVal, numberLen);
-    if (strstr(RSTRING_PTR(subString), ".") != NULL || strstr(RSTRING_PTR(subString), "e") != NULL || strstr(RSTRING_PTR(subString), "E") != NULL) {
-        set_static_value(ctx, rb_Float(subString));
+    char * cSubString = RSTRING_PTR(subString);
+    
+    if (strstr(cSubString, ".") != NULL ||
+        strstr(cSubString, "e") != NULL ||
+        strstr(cSubString, "E") != NULL) {
+            yajl_set_static_value(ctx, rb_Float(subString));
     } else {
-        set_static_value(ctx, rb_Integer(subString));
+        yajl_set_static_value(ctx, rb_Integer(subString));
     }
-    check_and_fire_callback(ctx);
+    yajl_check_and_fire_callback(ctx);
     return 1;
 }
 
-static int found_string(void * ctx, const unsigned char * stringVal, unsigned int stringLen) {
-    set_static_value(ctx, rb_str_new((const char *)stringVal, stringLen));
-    check_and_fire_callback(ctx);
+static int yajl_found_string(void * ctx, const unsigned char * stringVal, unsigned int stringLen) {
+    yajl_set_static_value(ctx, rb_str_new((const char *)stringVal, stringLen));
+    yajl_check_and_fire_callback(ctx);
     return 1;
 }
 
-static int found_hash_key(void * ctx, const unsigned char * stringVal, unsigned int stringLen) {
-    set_static_value(ctx, rb_str_new((const char *)stringVal, stringLen));
+static int yajl_found_hash_key(void * ctx, const unsigned char * stringVal, unsigned int stringLen) {
+    yajl_set_static_value(ctx, rb_str_new((const char *)stringVal, stringLen));
+    yajl_check_and_fire_callback(ctx);
     return 1;
 }
 
-static int found_start_hash(void * ctx) {
-    set_static_value(ctx, rb_hash_new());
+static int yajl_found_start_hash(void * ctx) {
+    struct yajl_parser_wrapper * wrapper;
+    GetParser((VALUE)ctx, wrapper);
+    wrapper->nestedHashLevel++;
+    yajl_set_static_value(ctx, rb_hash_new());
     return 1;
 }
 
-static int found_end_hash(void * ctx) {
-    if (RARRAY_LEN((VALUE)ctx) > 1) {
-        rb_ary_pop((VALUE)ctx);
+static int yajl_found_end_hash(void * ctx) {
+    struct yajl_parser_wrapper * wrapper;
+    GetParser((VALUE)ctx, wrapper);
+    wrapper->nestedHashLevel--;
+    if (RARRAY_LEN(wrapper->builderStack) > 1) {
+        rb_ary_pop(wrapper->builderStack);
     }
-    check_and_fire_callback(ctx);
+    yajl_check_and_fire_callback(ctx);
     return 1;
 }
 
-static int found_start_array(void * ctx) {
-    set_static_value(ctx, rb_ary_new());
+static int yajl_found_start_array(void * ctx) {
+    struct yajl_parser_wrapper * wrapper;
+    GetParser((VALUE)ctx, wrapper);
+    wrapper->nestedArrayLevel++;
+    yajl_set_static_value(ctx, rb_ary_new());
     return 1;
 }
 
-static int found_end_array(void * ctx) {
-    if (RARRAY_LEN((VALUE)ctx) > 1) {
-        rb_ary_pop((VALUE)ctx);
+static int yajl_found_end_array(void * ctx) {
+    struct yajl_parser_wrapper * wrapper;
+    GetParser((VALUE)ctx, wrapper);
+    wrapper->nestedArrayLevel--;
+    if (RARRAY_LEN(wrapper->builderStack) > 1) {
+        rb_ary_pop(wrapper->builderStack);
     }
-    check_and_fire_callback(ctx);
+    yajl_check_and_fire_callback(ctx);
     return 1;
 }
 
-static VALUE t_setParseComplete(VALUE self, VALUE callback) {
-    parse_complete_callback = callback;
-    return Qnil;
-}
 
-static VALUE t_parseSome(VALUE self, VALUE string) {
-    yajl_status stat;
-    
-    if (string == Qnil) {
-        rb_raise(cParseError, "%s", "Can't parse a nil string.");
-        return Qnil;
-    }
+/** Ruby Interface */
+
+// Yajl::Parser
+static VALUE rb_yajl_parser_new(int argc, VALUE * argv, VALUE klass) {
+    struct yajl_parser_wrapper * wrapper;
+    yajl_parser_config cfg;
+    VALUE opts, obj;
+    int allowComments = 1, checkUTF8 = 1;
     
-    if (parse_complete_callback != Qnil) {
-        if (context == Qnil) {
-            context = rb_ary_new();
-        }
-        if (chunkedParser == NULL) {
-            // allocate our parser
-            chunkedParser = yajl_alloc(&callbacks, &cfg, NULL, (void *)context);
-        }
+    // Scan off config vars
+    if (rb_scan_args(argc, argv, "01", &opts) == 1) {
+        Check_Type(opts, T_HASH);
         
-        stat = yajl_parse(chunkedParser, (const unsigned char *)RSTRING_PTR(string), RSTRING_LEN(string));
-        if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
-            unsigned char * str = yajl_get_error(chunkedParser, 1, (const unsigned char *)RSTRING_PTR(string), RSTRING_LEN(string));
-            rb_raise(cParseError, "%s", (const char *) str);
-            yajl_free_error(chunkedParser, str);
+        if (rb_hash_aref(opts, ID2SYM(sym_allow_comments)) == Qfalse) {
+            allowComments = 0;
+        }
+        if (rb_hash_aref(opts, ID2SYM(sym_check_utf8)) == Qfalse) {
+            checkUTF8 = 0;
         }
-    } else {
-        rb_raise(cParseError, "%s", "The on_parse_complete callback isn't setup, parsing useless.");
-    }
-    
-    if (RARRAY_LEN(context) == 0) {
-        yajl_free(chunkedParser);
     }
+    cfg = (yajl_parser_config){allowComments, checkUTF8};
     
-    return Qnil;
+    obj = Data_Make_Struct(klass, struct yajl_parser_wrapper, yajl_parser_wrapper_mark, yajl_parser_wrapper_free, wrapper);
+    wrapper->parser = yajl_alloc(&callbacks, &cfg, NULL, (void *)obj);
+    wrapper->nestedArrayLevel = 0;
+    wrapper->nestedHashLevel = 0;
+    wrapper->builderStack = rb_ary_new();
+    wrapper->parse_complete_callback = Qnil;
+    rb_obj_call_init(obj, 0, 0);
+    return obj;
 }
 
-static VALUE t_parse(VALUE self, VALUE io) {
+static VALUE rb_yajl_parser_init(int argc, VALUE * argv, VALUE self) {
+    return self;
+}
+
+static VALUE rb_yajl_parser_parse(int argc, VALUE * argv, VALUE self) {
+    struct yajl_parser_wrapper * wrapper;
     yajl_status stat;
-    context = rb_ary_new();
+    VALUE parsed, rbufsize, io;
     
-    // allocate our parser
-    streamParser = yajl_alloc(&callbacks, &cfg, NULL, (void *)context);
+    GetParser(self, wrapper);
+    parsed = rb_str_new2("");
     
-    VALUE parsed = rb_str_new2("");
-    VALUE rbufsize = INT2FIX(readBufferSize);
+    // setup our parameters
+    rb_scan_args(argc, argv, "11", &io, &rbufsize);
+    if (NIL_P(rbufsize)) {
+        rbufsize = INT2FIX(READ_BUFSIZE);
+    } else {
+        Check_Type(rbufsize, T_FIXNUM);
+    }
     
     // now parse from the IO
     while (rb_funcall(io, intern_eof, 0) != Qtrue) {
         rb_funcall(io, intern_io_read, 2, rbufsize, parsed);
         
-        stat = yajl_parse(streamParser, (const unsigned char *)RSTRING_PTR(parsed), RSTRING_LEN(parsed));
+        stat = yajl_parse(wrapper->parser, (const unsigned char *)RSTRING_PTR(parsed), RSTRING_LEN(parsed));
         
         if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
-            unsigned char * str = yajl_get_error(streamParser, 1, (const unsigned char *)RSTRING_PTR(parsed), RSTRING_LEN(parsed));
+            unsigned char * str = yajl_get_error(wrapper->parser, 1, (const unsigned char *)RSTRING_PTR(parsed), RSTRING_LEN(parsed));
             rb_raise(cParseError, "%s", (const char *) str);
-            yajl_free_error(streamParser, str);
+            yajl_free_error(wrapper->parser, str);
             break;
         }
     }
     
     // parse any remaining buffered data
-    stat = yajl_parse_complete(streamParser);
-    yajl_free(streamParser);
+    stat = yajl_parse_complete(wrapper->parser);
+    
+    if (wrapper->parse_complete_callback != Qnil) {
+        yajl_check_and_fire_callback((void *)self);
+        return Qnil;
+    }
+
+    return rb_ary_pop(wrapper->builderStack);
+}
+
+static VALUE rb_yajl_parser_parse_chunk(VALUE self, VALUE chunk) {
+    struct yajl_parser_wrapper * wrapper;
+    yajl_status stat;
     
-    if (parse_complete_callback != Qnil) {
-        check_and_fire_callback((void *)context);
+    GetParser(self, wrapper);
+    if (NIL_P(chunk)) {
+        rb_raise(cParseError, "Can't parse a nil string.");
         return Qnil;
     }
+    
+    if (wrapper->parse_complete_callback != Qnil) {
+        stat = yajl_parse(wrapper->parser, (const unsigned char *)RSTRING_PTR(chunk), RSTRING_LEN(chunk));
+        if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) {
+            unsigned char * str = yajl_get_error(wrapper->parser, 1, (const unsigned char *)RSTRING_PTR(chunk), RSTRING_LEN(chunk));
+            rb_raise(cParseError, "%s", (const char *) str);
+            yajl_free_error(wrapper->parser, str);
+        }
+    } else {
+        rb_raise(cParseError, "The on_parse_complete callback isn't setup, parsing useless.");
+    }
 
-    return rb_ary_pop(context);
+    return Qnil;
 }
 
-static VALUE t_encode(VALUE self, VALUE obj, VALUE io) {
-  yajl_gen_config conf = {0, " "};
-  yajl_gen hand;
-  const unsigned char * buffer;
-  unsigned int len;
-  VALUE outBuff;
-  
-  hand = yajl_gen_alloc(&conf, NULL);
-  encode_part(hand, obj, io);
-  
-  // just make sure we output the remaining buffer
-  yajl_gen_get_buf(hand, &buffer, &len);
-  outBuff = rb_str_new((const char *)buffer, len);
-  rb_io_write(io, outBuff);
-  
-  yajl_gen_clear(hand);
-  yajl_gen_free(hand);
-  return Qnil;
+static VALUE rb_yajl_set_complete_cb(VALUE self, VALUE callback) {
+    struct yajl_parser_wrapper * wrapper;
+    GetParser(self, wrapper);
+    wrapper->parse_complete_callback = callback;
+    return Qnil;
 }
 
-void Init_yajl_ext() {
-    mYajl = rb_define_module("Yajl");
+// Yajl::Encoder
+static VALUE rb_yajl_encoder_new(int argc, VALUE * argv, VALUE klass) {
+    yajl_gen_config cfg;
+    yajl_gen encoder;
+    VALUE opts, obj, indent;
+    const char * indentString = "  ";
+    int beautify = 0;
     
-    mStream = rb_define_module_under(mYajl, "Stream");
-    rb_define_module_function(mStream, "parse", t_parse, 1);
-    rb_define_module_function(mStream, "encode", t_encode, 2);
+    // Scan off config vars
+    if (rb_scan_args(argc, argv, "01", &opts) == 1) {
+        Check_Type(opts, T_HASH);
+        
+        if (rb_hash_aref(opts, ID2SYM(sym_pretty)) == Qtrue) {
+            beautify = 1;
+            indent = rb_hash_aref(opts, ID2SYM(sym_indent));
+            if (indent != Qnil) {
+                Check_Type(indent, T_STRING);
+                indentString = RSTRING_PTR(indent);
+            }
+        }
+    }
+    cfg = (yajl_gen_config){beautify, indentString};
     
-    mChunked = rb_define_module_under(mYajl, "Chunked");
-    rb_define_module_function(mChunked, "parse_some", t_parseSome, 1);
-    rb_define_module_function(mChunked, "<<", t_parseSome, 1);
-    rb_define_module_function(mChunked, "on_parse_complete=", t_setParseComplete, 1);
+    encoder = yajl_gen_alloc(&cfg, NULL);
+    obj = Data_Wrap_Struct(klass, 0, yajl_gen_free, encoder);
+    rb_obj_call_init(obj, 0, 0);
+    return obj;
+}
+
+static VALUE rb_yajl_encoder_init(int argc, VALUE * argv, VALUE self) {
+    return self;
+}
+
+static VALUE rb_yajl_encoder_encode(VALUE self, VALUE obj, VALUE io) {
+    yajl_gen encoder;
+    const unsigned char * buffer;
+    unsigned int len;
+    VALUE outBuff;
+    
+    GetEncoder(self, encoder);
+    
+    // begin encode process
+    yajl_encode_part(encoder, obj, io);
+
+    // just make sure we output the remaining buffer
+    yajl_gen_get_buf(encoder, &buffer, &len);
+    outBuff = rb_str_new((const char *)buffer, len);
+    rb_io_write(io, outBuff);
+    yajl_gen_clear(encoder);
+    
+    return Qnil;
+}
+
+// Ruby Extension initializer
+void Init_yajl_ext() {
+    mYajl = rb_define_module("Yajl");
     
     VALUE rb_cStandardError = rb_const_get(rb_cObject, rb_intern("StandardError"));
     cParseError = rb_define_class_under(mYajl, "ParseError", rb_cStandardError);
     
+    cParser = rb_define_class_under(mYajl, "Parser", rb_cObject);
+    rb_define_singleton_method(cParser, "new", rb_yajl_parser_new, -1);
+    rb_define_method(cParser, "initialize", rb_yajl_parser_init, -1);
+    rb_define_method(cParser, "parse", rb_yajl_parser_parse, -1);
+    rb_define_method(cParser, "parse_chunk", rb_yajl_parser_parse_chunk, -1);
+    rb_define_method(cParser, "<<", rb_yajl_parser_parse_chunk, 1);
+    rb_define_method(cParser, "on_parse_complete=", rb_yajl_set_complete_cb, 1);
+    
+    cEncoder = rb_define_class_under(mYajl, "Encoder", rb_cObject);
+    rb_define_singleton_method(cEncoder, "new", rb_yajl_encoder_new, -1);
+    rb_define_method(cEncoder, "initialize", rb_yajl_encoder_init, -1);
+    rb_define_method(cEncoder, "encode", rb_yajl_encoder_encode, 2);
+    
     intern_io_read = rb_intern("read");
     intern_eof = rb_intern("eof?");
-    intern_respond_to = rb_intern("respond_to?");
     intern_call = rb_intern("call");
     intern_keys = rb_intern("keys");
     intern_to_s = rb_intern("to_s");
+    sym_allow_comments = rb_intern("allow_comments");
+    sym_check_utf8 = rb_intern("check_utf8");
+    sym_pretty = rb_intern("pretty");
+    sym_indent = rb_intern("indent");
 }