20 #define PSYCH_TRANSCODE(_str, _yaml_enc, _internal_enc) \
22 rb_enc_associate_index((_str), (_yaml_enc)); \
24 (_str) = rb_str_export_to_enc((_str), (_internal_enc)); \
47 parser = (yaml_parser_t *)ptr;
48 yaml_parser_delete(parser);
56 parser =
xmalloc(
sizeof(yaml_parser_t));
57 yaml_parser_initialize(parser);
66 line = parser->context_mark.line + 1;
67 column = parser->context_mark.column + 1;
73 INT2NUM(parser->problem_offset),
78 #ifdef HAVE_RUBY_ENCODING_H
79 static VALUE transcode_string(
VALUE src,
int * parser_encoding)
86 if (source_encoding == utf8) {
87 *parser_encoding = YAML_UTF8_ENCODING;
91 if (source_encoding == utf16le) {
92 *parser_encoding = YAML_UTF16LE_ENCODING;
96 if (source_encoding == utf16be) {
97 *parser_encoding = YAML_UTF16BE_ENCODING;
104 *parser_encoding = YAML_UTF8_ENCODING;
108 static VALUE transcode_io(
VALUE src,
int * parser_encoding)
110 VALUE io_external_encoding;
111 int io_external_enc_index;
116 if (
NIL_P(io_external_encoding)) {
124 *parser_encoding = YAML_UTF8_ENCODING;
129 *parser_encoding = YAML_UTF8_ENCODING;
134 *parser_encoding = YAML_UTF16LE_ENCODING;
139 *parser_encoding = YAML_UTF16BE_ENCODING;
145 *parser_encoding = YAML_ANY_ENCODING;
151 *parser_encoding = YAML_ANY_ENCODING;
237 int parser_encoding = YAML_ANY_ENCODING;
238 #ifdef HAVE_RUBY_ENCODING_H
244 if (
rb_scan_args(argc, argv,
"11", &yaml, &path) == 1) {
253 yaml_parser_delete(parser);
254 yaml_parser_initialize(parser);
259 #ifdef HAVE_RUBY_ENCODING_H
260 yaml = transcode_io(yaml, &parser_encoding);
261 yaml_parser_set_encoding(parser, parser_encoding);
263 yaml_parser_set_input(parser,
io_reader, (
void *)yaml);
267 #ifdef HAVE_RUBY_ENCODING_H
268 yaml = transcode_string(yaml, &parser_encoding);
269 yaml_parser_set_encoding(parser, parser_encoding);
271 yaml_parser_set_input_string(
279 if(!yaml_parser_parse(parser, &event)) {
283 yaml_parser_delete(parser);
284 yaml_parser_initialize(parser);
290 case YAML_STREAM_START_EVENT:
295 args[1] =
INT2NUM((
long)event.data.stream_start.encoding);
299 case YAML_DOCUMENT_START_EVENT:
305 VALUE version =
event.data.document_start.version_directive ?
308 INT2NUM((
long)event.data.document_start.version_directive->major),
309 INT2NUM((
long)event.data.document_start.version_directive->minor)
312 if(event.data.document_start.tag_directives.start) {
313 yaml_tag_directive_t *
start =
314 event.data.document_start.tag_directives.start;
315 yaml_tag_directive_t *
end =
316 event.data.document_start.tag_directives.end;
317 for(; start !=
end; start++) {
323 #ifdef HAVE_RUBY_ENCODING_H
331 #ifdef HAVE_RUBY_ENCODING_H
341 args[2] = tag_directives;
342 args[3] =
event.data.document_start.implicit == 1 ?
Qtrue :
Qfalse;
346 case YAML_DOCUMENT_END_EVENT:
351 args[1] =
event.data.document_end.implicit == 1 ?
Qtrue :
Qfalse;
355 case YAML_ALIAS_EVENT:
359 if(event.data.alias.anchor) {
360 alias =
rb_str_new2((
const char *)event.data.alias.anchor);
362 #ifdef HAVE_RUBY_ENCODING_H
372 case YAML_SCALAR_EVENT:
377 VALUE plain_implicit, quoted_implicit, style;
379 (
const char *)event.data.scalar.value,
380 (
long)event.data.scalar.length
384 #ifdef HAVE_RUBY_ENCODING_H
388 if(event.data.scalar.anchor) {
389 anchor =
rb_str_new2((
const char *)event.data.scalar.anchor);
391 #ifdef HAVE_RUBY_ENCODING_H
396 if(event.data.scalar.tag) {
397 tag =
rb_str_new2((
const char *)event.data.scalar.tag);
399 #ifdef HAVE_RUBY_ENCODING_H
405 event.data.scalar.plain_implicit == 0 ?
Qfalse :
Qtrue;
408 event.data.scalar.quoted_implicit == 0 ?
Qfalse :
Qtrue;
410 style =
INT2NUM((
long)event.data.scalar.style);
416 args[4] = plain_implicit;
417 args[5] = quoted_implicit;
422 case YAML_SEQUENCE_START_EVENT:
427 VALUE implicit, style;
428 if(event.data.sequence_start.anchor) {
429 anchor =
rb_str_new2((
const char *)event.data.sequence_start.anchor);
431 #ifdef HAVE_RUBY_ENCODING_H
437 if(event.data.sequence_start.tag) {
438 tag =
rb_str_new2((
const char *)event.data.sequence_start.tag);
440 #ifdef HAVE_RUBY_ENCODING_H
446 event.data.sequence_start.implicit == 0 ?
Qfalse :
Qtrue;
448 style =
INT2NUM((
long)event.data.sequence_start.style);
459 case YAML_SEQUENCE_END_EVENT:
462 case YAML_MAPPING_START_EVENT:
467 VALUE implicit, style;
468 if(event.data.mapping_start.anchor) {
469 anchor =
rb_str_new2((
const char *)event.data.mapping_start.anchor);
471 #ifdef HAVE_RUBY_ENCODING_H
476 if(event.data.mapping_start.tag) {
477 tag =
rb_str_new2((
const char *)event.data.mapping_start.tag);
479 #ifdef HAVE_RUBY_ENCODING_H
485 event.data.mapping_start.implicit == 0 ?
Qfalse :
Qtrue;
487 style =
INT2NUM((
long)event.data.mapping_start.style);
498 case YAML_MAPPING_END_EVENT:
504 case YAML_STREAM_END_EVENT:
509 yaml_event_delete(&event);
531 args[0] =
INT2NUM(parser->mark.index);
532 args[1] =
INT2NUM(parser->mark.line);
533 args[2] =
INT2NUM(parser->mark.column);
static VALUE protected_empty(VALUE handler)
#define RSTRING_LEN(string)
int rb_enc_get_index(VALUE obj)
static VALUE protected_start_sequence(VALUE pointer)
static ID id_start_stream
static VALUE protected_start_stream(VALUE pointer)
#define Data_Get_Struct(obj, type, sval)
static VALUE protected_end_stream(VALUE handler)
static ID id_start_mapping
rb_encoding * rb_default_internal_encoding(void)
static ID id_end_document
VALUE rb_ary_push(VALUE ary, VALUE item)
int rb_usascii_encindex(void)
static VALUE INT2NUM(int v)
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *state)
#define RSTRING_PTR(string)
static VALUE parse(int argc, VALUE *argv, VALUE self)
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
VALUE rb_obj_is_kind_of(VALUE, VALUE)
VALUE rb_ary_new3(long n,...)
static VALUE mark(VALUE self)
rb_encoding * rb_utf8_encoding(void)
#define PSYCH_TRANSCODE(_str, _yaml_enc, _internal_enc)
static VALUE protected_alias(VALUE pointer)
static void dealloc(void *ptr)
void rb_exc_raise(VALUE mesg)
VALUE rb_require(const char *)
int rb_to_encoding_index(VALUE enc)
return Data_Wrap_Struct(CLASS_OF(interp), 0, ip_free, slave)
VALUE rb_class_new_instance(int, VALUE *, VALUE)
static int io_reader(void *data, unsigned char *buf, size_t size, size_t *read)
RUBY_EXTERN VALUE rb_cObject
static ID id_end_sequence
int rb_ascii8bit_encindex(void)
VALUE rb_iv_get(VALUE, const char *)
void rb_define_const(VALUE, const char *, VALUE)
unsigned char buf[MIME_BUF_SIZE]
static VALUE protected_scalar(VALUE pointer)
static VALUE protected_end_mapping(VALUE handler)
static VALUE protected_end_document(VALUE pointer)
static VALUE protected_end_sequence(VALUE handler)
#define RB_GC_GUARD(object)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
static VALUE make_exception(yaml_parser_t *parser, VALUE path)
int rb_utf8_encindex(void)
static ID id_start_sequence
void rb_jump_tag(int tag)
VALUE rb_funcall3(VALUE, ID, int, const VALUE *)
Calls a method.
int rb_respond_to(VALUE, ID)
VALUE rb_usascii_str_new2(const char *)
static ID id_start_document
VALUE rb_str_export_to_enc(VALUE, rb_encoding *)
static VALUE protected_start_mapping(VALUE pointer)
struct parser_params * parser
VALUE rb_const_get_at(VALUE, ID)
static VALUE protected_start_document(VALUE pointer)
return rb_funcall(q->proc, ID_call, 0)
#define StringValuePtr(v)
int rb_enc_find_index(const char *name)
static void version(void)
VALUE rb_define_module(const char *name)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
VALUE rb_str_new2(const char *)
static VALUE allocate(VALUE klass)
VALUE rb_str_new(const char *, long)