parse

static VALUE parse(VALUE self, VALUE yaml)
{
    yaml_parser_t * parser;
    yaml_event_t event;
    int done = 0;
    int tainted = 0;
#ifdef HAVE_RUBY_ENCODING_H
    int encoding = rb_utf8_encindex();
    rb_encoding * internal_enc = rb_default_internal_encoding();
#endif
    VALUE handler = rb_iv_get(self, "@handler");

    Data_Get_Struct(self, yaml_parser_t, parser);

    if (OBJ_TAINTED(yaml)) tainted = 1;

    if(rb_respond_to(yaml, id_read)) {
        yaml_parser_set_input(parser, io_reader, (void *)yaml);
        if (RTEST(rb_obj_is_kind_of(yaml, rb_cIO))) tainted = 1;
    } else {
        StringValue(yaml);
        yaml_parser_set_input_string(
                parser,
                (const unsigned char *)RSTRING_PTR(yaml),
                (size_t)RSTRING_LEN(yaml)
                );
    }

    while(!done) {
        if(!yaml_parser_parse(parser, &event)) {
            VALUE path;
            size_t line   = parser->mark.line;
            size_t column = parser->mark.column;

            if(rb_respond_to(yaml, id_path))
                path = rb_funcall(yaml, id_path, 0);
            else
                path = rb_str_new2("<unknown>");

            yaml_parser_delete(parser);
            yaml_parser_initialize(parser);

            rb_raise(ePsychSyntaxError, "(%s): couldn't parse YAML at line %d column %d",
                    StringValuePtr(path),
                    (int)line, (int)column);
        }

        switch(event.type) {
          case YAML_STREAM_START_EVENT:

            rb_funcall(handler, id_start_stream, 1,
                       INT2NUM((long)event.data.stream_start.encoding)
                );
            break;
          case YAML_DOCUMENT_START_EVENT:
            {
                /* Get a list of tag directives (if any) */
                VALUE tag_directives = rb_ary_new();
                /* Grab the document version */
                VALUE version = event.data.document_start.version_directive ?
                    rb_ary_new3(
                        (long)2,
                        INT2NUM((long)event.data.document_start.version_directive->major),
                        INT2NUM((long)event.data.document_start.version_directive->minor)
                        ) : rb_ary_new();

                if(event.data.document_start.tag_directives.start) {
                    yaml_tag_directive_t *start =
                        event.data.document_start.tag_directives.start;
                    yaml_tag_directive_t *end =
                        event.data.document_start.tag_directives.end;
                    for(; start != end; start++) {
                        VALUE handle = Qnil;
                        VALUE prefix = Qnil;
                        if(start->handle) {
                            handle = rb_str_new2((const char *)start->handle);
                            if (tainted) OBJ_TAINT(handle);
#ifdef HAVE_RUBY_ENCODING_H
                            PSYCH_TRANSCODE(handle, encoding, internal_enc);
#endif
                        }

                        if(start->prefix) {
                            prefix = rb_str_new2((const char *)start->prefix);
                            if (tainted) OBJ_TAINT(prefix);
#ifdef HAVE_RUBY_ENCODING_H
                            PSYCH_TRANSCODE(prefix, encoding, internal_enc);
#endif
                        }

                        rb_ary_push(tag_directives, rb_ary_new3((long)2, handle, prefix));
                    }
                }
                rb_funcall(handler, id_start_document, 3,
                           version, tag_directives,
                           event.data.document_start.implicit == 1 ? Qtrue : Qfalse
                    );
            }
            break;
          case YAML_DOCUMENT_END_EVENT:
            rb_funcall(handler, id_end_document, 1,
                       event.data.document_end.implicit == 1 ? Qtrue : Qfalse
                );
            break;
          case YAML_ALIAS_EVENT:
            {
                VALUE alias = Qnil;
                if(event.data.alias.anchor) {
                    alias = rb_str_new2((const char *)event.data.alias.anchor);
                    if (tainted) OBJ_TAINT(alias);
#ifdef HAVE_RUBY_ENCODING_H
                    PSYCH_TRANSCODE(alias, encoding, internal_enc);
#endif
                }

                rb_funcall(handler, id_alias, 1, alias);
            }
            break;
          case YAML_SCALAR_EVENT:
            {
                VALUE anchor = Qnil;
                VALUE tag = Qnil;
                VALUE plain_implicit, quoted_implicit, style;
                VALUE val = rb_str_new(
                    (const char *)event.data.scalar.value,
                    (long)event.data.scalar.length
                    );
                if (tainted) OBJ_TAINT(val);

#ifdef HAVE_RUBY_ENCODING_H
                PSYCH_TRANSCODE(val, encoding, internal_enc);
#endif

                if(event.data.scalar.anchor) {
                    anchor = rb_str_new2((const char *)event.data.scalar.anchor);
                    if (tainted) OBJ_TAINT(anchor);
#ifdef HAVE_RUBY_ENCODING_H
                    PSYCH_TRANSCODE(anchor, encoding, internal_enc);
#endif
                }

                if(event.data.scalar.tag) {
                    tag = rb_str_new2((const char *)event.data.scalar.tag);
                    if (tainted) OBJ_TAINT(tag);
#ifdef HAVE_RUBY_ENCODING_H
                    PSYCH_TRANSCODE(tag, encoding, internal_enc);
#endif
                }

                plain_implicit =
                    event.data.scalar.plain_implicit == 0 ? Qfalse : Qtrue;

                quoted_implicit =
                    event.data.scalar.quoted_implicit == 0 ? Qfalse : Qtrue;

                style = INT2NUM((long)event.data.scalar.style);

                rb_funcall(handler, id_scalar, 6,
                           val, anchor, tag, plain_implicit, quoted_implicit, style);
            }
            break;
          case YAML_SEQUENCE_START_EVENT:
            {
                VALUE anchor = Qnil;
                VALUE tag = Qnil;
                VALUE implicit, style;
                if(event.data.sequence_start.anchor) {
                    anchor = rb_str_new2((const char *)event.data.sequence_start.anchor);
                    if (tainted) OBJ_TAINT(anchor);
#ifdef HAVE_RUBY_ENCODING_H
                    PSYCH_TRANSCODE(anchor, encoding, internal_enc);
#endif
                }

                tag = Qnil;
                if(event.data.sequence_start.tag) {
                    tag = rb_str_new2((const char *)event.data.sequence_start.tag);
                    if (tainted) OBJ_TAINT(tag);
#ifdef HAVE_RUBY_ENCODING_H
                    PSYCH_TRANSCODE(tag, encoding, internal_enc);
#endif
                }

                implicit =
                    event.data.sequence_start.implicit == 0 ? Qfalse : Qtrue;

                style = INT2NUM((long)event.data.sequence_start.style);

                rb_funcall(handler, id_start_sequence, 4,
                           anchor, tag, implicit, style);
            }
            break;
          case YAML_SEQUENCE_END_EVENT:
            rb_funcall(handler, id_end_sequence, 0);
            break;
          case YAML_MAPPING_START_EVENT:
            {
                VALUE anchor = Qnil;
                VALUE tag = Qnil;
                VALUE implicit, style;
                if(event.data.mapping_start.anchor) {
                    anchor = rb_str_new2((const char *)event.data.mapping_start.anchor);
                    if (tainted) OBJ_TAINT(anchor);
#ifdef HAVE_RUBY_ENCODING_H
                    PSYCH_TRANSCODE(anchor, encoding, internal_enc);
#endif
                }

                if(event.data.mapping_start.tag) {
                    tag = rb_str_new2((const char *)event.data.mapping_start.tag);
                    if (tainted) OBJ_TAINT(tag);
#ifdef HAVE_RUBY_ENCODING_H
                    PSYCH_TRANSCODE(tag, encoding, internal_enc);
#endif
                }

                implicit =
                    event.data.mapping_start.implicit == 0 ? Qfalse : Qtrue;

                style = INT2NUM((long)event.data.mapping_start.style);

                rb_funcall(handler, id_start_mapping, 4,
                           anchor, tag, implicit, style);
            }
            break;
          case YAML_MAPPING_END_EVENT:
            rb_funcall(handler, id_end_mapping, 0);
            break;
          case YAML_NO_EVENT:
            rb_funcall(handler, id_empty, 0);
            break;
          case YAML_STREAM_END_EVENT:
            rb_funcall(handler, id_end_stream, 0);
            done = 1;
            break;
        }
        yaml_event_delete(&event);
    }

    return self;
}