13 #include <sys/types.h>
47 #define RUBY_DOMAIN "ruby.yaml.org,2002"
52 static ID s_new,
s_utc,
s_at,
s_to_f,
s_to_i,
s_read,
s_binmode,
s_call,
s_cmp,
s_transfer,
s_update,
s_dup,
s_haskey,
s_match,
s_keys,
s_unpack,
s_tr_bang,
s_default_set,
s_tag_read_class,
s_tag_subclasses,
s_resolver,
s_push,
s_emitter,
s_level,
s_detect_implicit,
s_node_import,
s_out,
s_input,
s_intern,
s_transform,
s_yaml_new,
s_yaml_initialize,
s_node_export,
s_to_yaml,
s_write,
s_set_resolver,
s_each;
53 static ID s_tags,
s_kind,
s_name,
s_options,
s_type_id,
s_type_id_set,
s_style,
s_style_set,
s_value,
s_value_set,
s_parse;
57 static VALUE cDate,
cNode,
cMap,
cSeq,
cScalar,
cOut,
cParser,
cResolver,
cPrivateType,
cDomainType,
cYObject,
cBadAlias,
cDefaultKey,
cMergeKey,
cEmitter,
cDateTime;
63 static double S_zero(
void) {
return 0.0; }
64 static double S_one(
void) {
return 1.0; }
123 strcat( ret,
"D\n" );
124 strcat( ret, sav->
buffer );
144 if ( max_size <= 0 ) max_size = 0;
173 VALUE tmp, port = *pport;
220 const char *
str = arg->
str;
232 if ( ptr[0] !=
'\0' && len > 0 ) {
238 if ( ptr[0] !=
'\0' && len > ptr - str ) {
239 while ( !
ISDIGIT( *ptr ) ) ptr++;
245 if ( ptr[0] !=
'\0' && len > ptr - str ) {
246 while ( !
ISDIGIT( *ptr ) ) ptr++;
252 if ( ptr[0] !=
'\0' && len > ptr - str ) {
253 while ( !
ISDIGIT( *ptr ) ) ptr++;
259 if ( ptr[0] !=
'\0' && len > ptr - str ) {
260 while ( !
ISDIGIT( *ptr ) ) ptr++;
266 if ( ptr[0] !=
'\0' && len > ptr - str ) {
267 while ( !
ISDIGIT( *ptr ) ) ptr++;
273 if ( len > ptr - str && *ptr ==
'.' )
275 char padded[] =
"000000";
276 const int padding = (
int)(
sizeof(padded) - 1);
277 const char *
end = ptr + 1;
278 const char *begin =
end;
280 while ( isdigit( *end ) ) end++;
281 if ((length = (end - begin)) > padding) length = padding;
282 MEMCPY(padded, begin,
char, length);
291 while ( len > ptr - str && *ptr !=
'Z' && *ptr !=
'+' && *ptr !=
'-' && *ptr !=
'\0' ) ptr++;
292 if ( len > ptr - str && ( *ptr ==
'-' || *ptr ==
'+' ) )
294 time_t tz_offset =
strtol(ptr,
NULL, 10) * 3600;
297 while ( *ptr !=
':' && *ptr !=
'\0' ) ptr++;
376 if ( type_id !=
NULL && strncmp( type_id,
"tag:yaml.org,2002:", 18 ) == 0 )
385 if ( type_id ==
NULL )
389 else if ( strcmp( type_id,
"null" ) == 0 )
393 else if ( strcmp( type_id,
"binary" ) == 0 )
401 else if ( strcmp( type_id,
"bool#yes" ) == 0 )
405 else if ( strcmp( type_id,
"bool#no" ) == 0 )
409 else if ( strcmp( type_id,
"int#hex" ) == 0 )
414 else if ( strcmp( type_id,
"int#oct" ) == 0 )
419 else if ( strcmp( type_id,
"int#base60" ) == 0 )
430 char *colon = end - 1;
431 while ( colon >= ptr && *colon !=
':' )
435 if ( colon >= ptr && *colon ==
':' ) *colon =
'\0';
438 total += bnum * sixty;
444 else if ( strncmp( type_id,
"int", 3 ) == 0 )
449 else if ( strcmp( type_id,
"float#base60" ) == 0 )
460 char *colon = end - 1;
461 while ( colon >= ptr && *colon !=
':' )
465 if ( colon >= ptr && *colon ==
':' ) *colon =
'\0';
468 total += bnum * sixty;
474 else if ( strcmp( type_id,
"float#nan" ) == 0 )
478 else if ( strcmp( type_id,
"float#inf" ) == 0 )
482 else if ( strcmp( type_id,
"float#neginf" ) == 0 )
486 else if ( strncmp( type_id,
"float", 5 ) == 0 )
493 else if ( strcmp( type_id,
"timestamp#iso8601" ) == 0 )
497 else if ( strcmp( type_id,
"timestamp#spaced" ) == 0 )
501 else if ( strcmp( type_id,
"timestamp#ymd" ) == 0 )
512 while ( !
ISDIGIT( *ptr ) ) ptr++;
517 while ( !
ISDIGIT( *ptr ) ) ptr++;
530 else if ( strncmp( type_id,
"timestamp", 9 ) == 0 )
534 else if ( strncmp( type_id,
"merge", 5 ) == 0 )
538 else if ( strncmp( type_id,
"default", 7 ) == 0 )
544 strncmp( n->
data.
str->ptr,
":", 1 ) == 0 )
550 else if ( strcmp( type_id,
"str" ) == 0 )
563 if ( type_id ==
NULL || strcmp( type_id,
"seq" ) == 0 )
568 for ( i = 0; i < n->
data.
list->idx; i++ )
575 if ( type_id ==
NULL || strcmp( type_id,
"map" ) == 0 )
580 for ( i = 0; i < n->
data.
pairs->idx; i++ )
679 while ( *endl !=
'\0' && *endl !=
'\n' )
698 badanc->
type_id =
syck_strndup(
"tag:ruby.yaml.org,2002:object:YAML::Syck::BadAlias", 53 );
719 if (
NIL_P( input ) )
899 if ( parser->
eof == 1 )
980 for ( i = 0; i < n->
data.
list->idx; i++ )
988 for ( i = 0; i < n->
data.
pairs->idx; i++ )
1092 VALUE subclass = target_class;
1098 if (
NIL_P( target_class ) )
1109 if (
NIL_P( target_class ) )
1118 if ( !
NIL_P( target_class ) )
1120 subclass = target_class;
1129 if ( subclass_v !=
Qnil )
1131 subclass = subclass_v;
1163 else if ( !
NIL_P( target_class ) )
1187 if (
rb_str_cmp( scheme, str_xprivate ) == 0 )
1230 const char *type_id;
1404 for ( i = 0; i < n->
data.
list->idx; i++ )
1411 for ( i = 0; i < n->
data.
pairs->idx; i++ )
1462 if (
NIL_P( style ) )
1549 if ( !
NIL_P( val ) ) {
1626 if ( !
NIL_P( val ) )
1660 if ( !
NIL_P( val ) )
1761 if ( !
NIL_P( type_id ) ) {
1782 switch (orig_n->
kind)
1788 for ( i = 0; i < orig_n->
data.
pairs->idx; i++ )
1800 for ( i = 0; i < orig_n->
data.
list->idx; i++ )
1841 for ( i = 0; i < n->
data.
pairs->idx; i++ )
1854 for ( i = 0; i < n->
data.
list->idx; i++ )
2072 VALUE type_id, style, map;
2073 if (
rb_scan_args(argc, argv,
"11", &type_id, &style) == 1) {
2088 VALUE type_id, style, seq;
2089 if (
rb_scan_args(argc, argv,
"11", &type_id, &style) == 1) {
2107 rb_scan_args(argc, argv,
"21", &type_id, &str, &style);
#define RSTRING_LEN(string)
void syck_parser_taguri_expansion(SyckParser *p, int flag)
VALUE rb_ary_unshift(VALUE ary, VALUE item)
void syck_map_empty(SyckNode *n)
VALUE rb_ary_pop(VALUE ary)
SYMID rb_syck_load_handler(SyckParser *p, SyckNode *n)
void rb_syck_output_handler(SyckEmitter *emitter, char *str, long len)
VALUE rb_ary_entry(VALUE ary, long offset)
VALUE syck_badalias_cmp(VALUE alias1, VALUE alias2)
VALUE mktime_do(VALUE varg)
SyckNode * syck_alloc_seq(void)
static ID s_tag_read_class
size_t strlen(const char *)
void syck_emitter_flush(SyckEmitter *e, long check_room)
VALUE syck_parser_load_documents(int argc, VALUE *argv, VALUE self)
VALUE syck_map_add_m(VALUE self, VALUE key, VALUE val)
VALUE syck_genericresolver_node_import(VALUE self, VALUE node)
VALUE syck_resolver_add_type(VALUE self, VALUE taguri, VALUE cls)
void syck_parser_error_handler(SyckParser *p, SyckErrorHandler hdlr)
#define Data_Get_Struct(obj, type, sval)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
void syck_map_add(SyckNode *map, SYMID key, SYMID value)
int yaml_org_handler(SyckNode *n, VALUE *ref)
VALUE rb_ary_reverse(VALUE)
struct _syck_node::@19::SyckSeq * list
if(len<=MAX_WORD_LENGTH &&len >=MIN_WORD_LENGTH)
SyckNode * syck_new_str2(const char *str, long len, enum scalar_style style)
static double S_zero(void)
VALUE rb_str_cat(VALUE, const char *, long)
VALUE syck_resolver_node_import(VALUE self, VALUE node)
SYMID syck_parse(SyckParser *p)
rb_hash_aset(CALLBACK_TABLE, id_num, cmd)
union _syck_node::@19 data
VALUE rb_ary_shift(VALUE ary)
#define rb_block_call(arg1, arg2, arg3, arg4, arg5, arg6)
SyckEmitter * syck_new_emitter(void)
VALUE syck_resolver_detect_implicit(VALUE self, VALUE val)
VALUE syck_scalar_alloc(VALUE class)
VALUE rb_ary_push(VALUE ary, VALUE item)
VALUE mktime_r(VALUE varg)
static ID s_detect_implicit
VALUE syck_out_seq(int argc, VALUE *argv, VALUE self)
char * syck_type_id_to_uri(const char *type_id)
#define RSTRING_PTR(string)
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_ivar_get(VALUE, ID)
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
SYMID syck_emitter_mark_node(SyckEmitter *e, st_data_t n)
VALUE syck_resolver_use_types_at(VALUE self, VALUE hsh)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
VALUE rb_obj_is_kind_of(VALUE, VALUE)
int rb_const_defined(VALUE, ID)
#define RARRAY_LEN(ARRAY)
void rb_include_module(VALUE klass, VALUE module)
void syck_free_parser(SyckParser *p)
VALUE rb_io_write(VALUE, VALUE)
int rb_str_cmp(VALUE, VALUE)
static VALUE syck_node_transform(VALUE)
rb_encoding * rb_utf8_encoding(void)
VALUE syck_emitter_set_resolver(VALUE self, VALUE resolver)
VALUE syck_scalar_initialize(VALUE self, VALUE type_id, VALUE val, VALUE style)
void syck_parser_implicit_typing(SyckParser *p, int flag)
static VALUE syck_resolver_initialize(VALUE self)
static ID s_yaml_initialize
VALUE syck_privatetype_initialize(VALUE self, VALUE type_id, VALUE val)
char * syck_strndup(const char *buf, long len)
void syck_emit_scalar(SyckEmitter *e, const char *tag, enum scalar_style force_style, int force_indent, int force_width, char keep_nl, const char *str, long len)
static VALUE oGenericResolver
const char * syck_match_implicit(const char *str, size_t len)
void syck_free_emitter(SyckEmitter *e)
VALUE syck_domaintype_initialize(VALUE self, VALUE domain, VALUE type_id, VALUE val)
void rb_global_variable(VALUE *var)
VALUE syck_resolver_transfer(VALUE self, VALUE type, VALUE val)
#define S_ALLOCA_N(type, n)
void syck_seq_add(SyckNode *arr, SYMID value)
static int syck_st_mark_nodes(char *key, SyckNode *n, char *arg)
return rb_str_append(rb_str_new2(cmd_id_head), id_num)
void syck_emit_seq(SyckEmitter *e, const char *tag, enum seq_style style)
void syck_parser_bad_anchor_handler(SyckParser *p, SyckBadAnchorHandler hdlr)
VALUE syck_emitter_reset(int argc, VALUE *argv, VALUE self)
void rb_syck_err_handler(SyckParser *p, const char *msg)
VALUE syck_emitter_s_alloc(VALUE class)
#define MEMZERO(p, type, n)
VALUE rb_require(const char *)
static void syck_mark_emitter(SyckEmitter *emitter)
return Data_Wrap_Struct(CLASS_OF(interp), 0, ip_free, slave)
SyckParser * syck_new_parser(void)
VALUE syck_emitter_emit(int argc, VALUE *argv, VALUE self)
int syck_lookup_sym(SyckParser *p, SYMID id, void **datap)
VALUE rb_syck_mktime(const char *str, long len)
void syck_set_model(VALUE p, VALUE input, VALUE model)
RUBY_EXTERN VALUE rb_cObject
void syck_emitter_handler(SyckEmitter *e, SyckEmitterHandler hdlr)
long syck_map_count(SyckNode *map)
VALUE syck_parser_s_alloc(VALUE class)
VALUE syck_resolver_tagurize(VALUE self, VALUE val)
VALUE syck_parser_load(int argc, VALUE *argv, VALUE self)
void rb_define_const(VALUE, const char *, VALUE)
void rb_ary_store(VALUE ary, long idx, VALUE val)
VALUE syck_map_value_set(VALUE self, VALUE val)
VALUE syck_out_scalar(int argc, VALUE *argv, VALUE self)
long rb_syck_io_str_read(char *buf, SyckIoStr *str, long max_size, long skip)
VALUE syck_map_alloc(VALUE class)
SYMID syck_seq_read(SyckNode *seq, long idx)
VALUE syck_seq_add_m(VALUE self, VALUE val)
SYMID syck_yaml2byte_handler(SyckParser *, SyckNode *)
#define MEMCPY(p1, p2, type, n)
unsigned char buf[MIME_BUF_SIZE]
void syck_parser_handler(SyckParser *p, SyckNodeHandler hdlr)
SyckNode * syck_alloc_map(void)
VALUE rb_obj_alloc(VALUE)
VALUE rb_str_split(VALUE, const char *)
struct RVALUE::@22::@23 free
VALUE syck_defaultresolver_detect_implicit(VALUE self, VALUE val)
VALUE rb_const_get(VALUE, ID)
void syck_out_mark(VALUE emitter, VALUE node)
static VALUE scalar(VALUE self, VALUE value, VALUE anchor, VALUE tag, VALUE plain, VALUE quoted, VALUE style)
void rb_define_module_function(VALUE module, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a module function for module.
void syck_parser_set_root_on_error(SyckParser *p, SYMID roer)
VALUE syck_parser_set_resolver(VALUE self, VALUE resolver)
void syck_free_node(SyckNode *n)
VALUE rb_funcall2(VALUE, ID, int, const VALUE *)
Calls a method.
void syck_emit_end(SyckEmitter *e)
void syck_seq_empty(SyckNode *n)
void syck_emit(SyckEmitter *e, st_data_t n)
VALUE rb_iv_set(VALUE, const char *, VALUE)
VALUE syck_map_initialize(VALUE self, VALUE type_id, VALUE val, VALUE style)
static double S_nan(void)
VALUE syck_seq_style_set(VALUE self, VALUE style)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
void syck_parser_str(SyckParser *p, char *ptr, long len, SyckIoStrRead read)
VALUE syck_get_hash_aref(VALUE hsh, VALUE key)
static double S_inf(void)
VALUE syck_set_ivars(VALUE vars, VALUE obj)
VALUE syck_badalias_initialize(VALUE self, VALUE val)
VALUE syck_seq_value_set(VALUE self, VALUE val)
long syck_seq_count(SyckNode *seq)
VALUE syck_map_style_set(VALUE self, VALUE style)
VALUE rb_rescue2(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*r_proc)(ANYARGS), VALUE data2,...)
register unsigned int len
void syck_emit_map(SyckEmitter *e, const char *tag, enum map_style style)
VALUE syck_out_map(int argc, VALUE *argv, VALUE self)
long strtol(const char *nptr, char **endptr, int base)
int rb_respond_to(VALUE, ID)
VALUE rb_define_module_under(VALUE outer, const char *name)
VALUE rb_float_new(double)
void syck_output_handler(SyckEmitter *e, SyckOutputHandler hdlr)
VALUE rb_obj_is_instance_of(VALUE, VALUE)
VALUE syck_seq_alloc(VALUE class)
VALUE rb_str2inum(VALUE str, int base)
void rb_syck_free_parser(SyckParser *p)
VALUE rb_check_convert_type(VALUE, int, const char *, const char *)
void rb_define_attr(VALUE klass, const char *name, int read, int write)
Defines (a) public accessor method(s) for an attribute.
static void syck_node_mark(SyckNode *n)
SyckNode * syck_new_map(SYMID key, SYMID value)
VALUE rb_check_array_type(VALUE ary)
VALUE rb_hash_aref(VALUE hash, VALUE key)
void syck_emit_item(SyckEmitter *e, st_data_t n)
VALUE rb_syck_compile(VALUE self, VALUE port)
VALUE syck_scalar_style_set(VALUE self, VALUE style)
static ID s_tag_subclasses
static VALUE syck_parser_initialize(int argc, VALUE *argv, VALUE self)
rb_ivar_set(einfo, ID_at_interp, interp)
VALUE rb_check_string_type(VALUE)
SyckNode * syck_alloc_str(void)
struct _syck_node::@19::SyckStr * str
void syck_parser_set_input_type(SyckParser *p, enum syck_parser_input input_type)
VALUE syck_emitter_node_export(VALUE self, VALUE node)
static VALUE id_hash_new(void)
VALUE syck_defaultresolver_node_import(VALUE self, VALUE node)
void syck_str_blow_away_commas(SyckNode *n)
SyckNode * rb_syck_bad_anchor_handler(SyckParser *p, char *a)
VALUE rb_ary_join(VALUE ary, VALUE sep)
VALUE rb_ary_new2(long capa)
struct parser_params * parser
static VALUE sym_bytecode
void rb_gc_mark_maybe(VALUE obj)
return rb_funcall(q->proc, ID_call, 0)
VALUE syck_yobject_initialize(VALUE self, VALUE klass, VALUE ivars)
VALUE syck_out_initialize(VALUE self, VALUE emitter)
static VALUE oDefaultResolver
VALUE syck_node_type_id_set(VALUE self, VALUE type_id)
int syck_parser_assign_io(SyckParser *parser, VALUE *pport)
VALUE syck_scalar_value_set(VALUE self, VALUE val)
void rb_syck_free_emitter(SyckEmitter *e)
void rb_syck_emitter_handler(SyckEmitter *e, st_data_t data)
static VALUE syck_parser_bufsize_get(VALUE self)
VALUE syck_const_find(VALUE const_name)
RUBY_EXTERN VALUE rb_cTime
SYMID syck_map_read(SyckNode *map, enum map_part p, long idx)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
VALUE rb_str_new2(const char *)
VALUE syck_merge_i(VALUE entry, VALUE hsh)
static double S_one(void)
VALUE rb_cstr2inum(const char *str, int base)
static VALUE cPrivateType
VALUE syck_seq_initialize(VALUE self, VALUE type_id, VALUE val, VALUE style)
struct _syck_node::@19::SyckMap * pairs
VALUE rb_attr_get(VALUE, ID)
static void syck_mark_parser(SyckParser *parser)
static VALUE syck_parser_bufsize_set(VALUE self, VALUE size)
#define S_MEMZERO(p, type, n)
VALUE rb_str_new(const char *, long)