Changeset 237 for trunk/ext

Show
Ignore:
Timestamp:
10/14/2006 01:58:02 (2 years ago)
Author:
why
Message:
  • ext/ruby/ext/syck/rubyext.c: merging in Ruby CVS, (mostly changes in function decls and support for 1.9 string and array macros.)
  • lib/: alterations to some function decls from Ruby CVS.
  • lib/Makefile.am: update to Automake 1.4.
Files:
1 modified

Legend:

Unmodified
Added
Removed

  • trunk/ext/ruby/ext/syck/rubyext.c

    r234 r237  
    5454#endif 
    5555 
     56#ifdef RARRAY_LEN 
     57#undef T_SYMBOL 
     58#define T_SYMBOL T_STRING 
     59static inline long  rb_str_len(VALUE s) {return RSTRING_LEN(s);}                                                                
     60static inline char *rb_str_ptr(VALUE s) {return RSTRING_PTR(s);}                                                                
     61static inline long  rb_ary_len(VALUE s) {return  RARRAY_LEN(s);}                                                                
     62static inline VALUE *rb_ary_ptr(VALUE s) {return  RARRAY_PTR(s);} 
     63#else                                                                                                                          
     64static inline long  rb_str_len(VALUE s) {return rb_str_len(s);}                                                               
     65static inline char *rb_str_ptr(VALUE s) {return rb_str_ptr(s);}                                                               
     66static inline long  rb_ary_len(VALUE s) {return  rb_ary_len(s);}                                                               
     67static inline VALUE *rb_ary_ptr(VALUE s) {return  rb_ary_ptr(s);}                                                               
     68#endif  
     69 
    5670/* 
    5771 * symbols and constants 
    … …  
    105119 */ 
    106120VALUE 
    107 rb_syck_compile(self, port) 
    108     VALUE self, port; 
     121rb_syck_compile(VALUE self, VALUE port) 
    109122{ 
    110123    SYMID oid; 
    … …  
    158171        { 
    159172            StringValue(str2); 
    160             len = RSTRING(str2)->len; 
    161             memcpy( buf + skip, RSTRING(str2)->ptr, len ); 
     173            len = rb_str_len(str2); 
     174            memcpy( buf + skip, rb_str_ptr(str2), len ); 
    162175        } 
    163176    } 
    … …  
    172185 */ 
    173186int 
    174 syck_parser_assign_io(parser, pport) 
    175     SyckParser *parser; 
    176     VALUE *pport; 
     187syck_parser_assign_io(SyckParser *parser, VALUE *pport) 
    177188{ 
    178189    int taint = Qtrue; 
    … …  
    181192        taint = OBJ_TAINTED(port); /* original taintedness */ 
    182193        port = tmp; 
    183         syck_parser_str( parser, RSTRING(port)->ptr, RSTRING(port)->len, NULL ); 
     194        syck_parser_str( parser, rb_str_ptr(port), rb_str_len(port), NULL ); 
    184195    } 
    185196    else if (rb_respond_to(port, s_read)) { 
    … …  
    200211 */ 
    201212VALUE 
    202 syck_get_hash_aref(hsh, key) 
    203     VALUE hsh, key; 
     213syck_get_hash_aref(VALUE hsh, VALUE key) 
    204214{ 
    205215   VALUE val = rb_hash_aref( hsh, key ); 
    … …  
    216226 */ 
    217227SYMID 
    218 rb_syck_mktime(str, len) 
    219     char *str; 
    220     long len; 
     228rb_syck_mktime(char *str, long len) 
    221229{ 
    222230    VALUE time; 
    … …  
    323331 */ 
    324332VALUE 
    325 syck_merge_i( entry, hsh ) 
    326     VALUE entry, hsh; 
     333syck_merge_i(VALUE entry, VALUE hsh) 
    327334{ 
    328335    VALUE tmp; 
    … …  
    339346 */ 
    340347int 
    341 yaml_org_handler( n, ref ) 
    342     SyckNode *n; 
    343     VALUE *ref; 
     348yaml_org_handler(SyckNode *n, VALUE *ref) 
    344349{ 
    345350    char *type_id = n->type_id; 
    … …  
    610615 */ 
    611616SYMID 
    612 rb_syck_load_handler(p, n) 
    613     SyckParser *p; 
    614     SyckNode *n; 
     617rb_syck_load_handler(SyckParser *p, SyckNode *n) 
    615618{ 
    616619    VALUE obj = Qnil; 
    … …  
    648651 */ 
    649652void 
    650 rb_syck_err_handler(p, msg) 
    651     SyckParser *p; 
    652     char *msg; 
     653rb_syck_err_handler(SyckParser *p, char *msg) 
    653654{ 
    654655    char *endl = p->cursor; 
    … …  
    669670 */ 
    670671SyckNode * 
    671 rb_syck_bad_anchor_handler(p, a) 
    672     SyckParser *p; 
    673     char *a; 
     672rb_syck_bad_anchor_handler(SyckParser *p, char *a) 
    674673{ 
    675674    VALUE anchor_name = rb_str_new2( a ); 
    … …  
    683682 */ 
    684683void 
    685 syck_set_model( p, input, model ) 
    686     VALUE p, input, model; 
     684syck_set_model(VALUE p, VALUE input, VALUE model) 
    687685{ 
    688686    SyckParser *parser; 
    … …  
    724722 */ 
    725723static void 
    726 syck_mark_parser(parser) 
    727     SyckParser *parser; 
     724syck_mark_parser(SyckParser *parser) 
    728725{ 
    729726    struct parser_xtra *bonus = (struct parser_xtra *)parser->bonus; 
    … …  
    748745 */ 
    749746void 
    750 rb_syck_free_parser(p) 
    751     SyckParser *p; 
     747rb_syck_free_parser(SyckParser *p) 
    752748{ 
    753749    S_FREE( p->bonus ); 
    … …  
    760756VALUE syck_parser_s_alloc _((VALUE)); 
    761757VALUE  
    762 syck_parser_s_alloc(class) 
    763     VALUE class; 
     758syck_parser_s_alloc(VALUE class) 
    764759{ 
    765760    VALUE pobj; 
    … …  
    780775 */ 
    781776static VALUE 
    782 syck_parser_initialize(argc, argv, self) 
    783     int argc; 
    784     VALUE *argv; 
    785     VALUE self; 
     777syck_parser_initialize(int argc, VALUE *argv, VALUE self) 
    786778{ 
    787779    VALUE options; 
    … …  
    804796 */ 
    805797static VALUE 
    806 syck_parser_bufsize_set( self, size ) 
    807     VALUE self, size; 
     798syck_parser_bufsize_set(VALUE self, VALUE size) 
    808799{ 
    809800    SyckParser *parser; 
    … …  
    821812 */ 
    822813static VALUE 
    823 syck_parser_bufsize_get( self ) 
    824     VALUE self; 
     814syck_parser_bufsize_get(VALUE self) 
    825815{ 
    826816    SyckParser *parser; 
    … …  
    834824 */ 
    835825VALUE 
    836 syck_parser_load(argc, argv, self) 
    837     int argc; 
    838     VALUE *argv; 
    839     VALUE self; 
     826syck_parser_load(int argc, VALUE *argv, VALUE self) 
    840827{ 
    841828    VALUE port, proc, model, input; 
    … …  
    864851 */ 
    865852VALUE 
    866 syck_parser_load_documents(argc, argv, self) 
    867     int argc; 
    868     VALUE *argv; 
    869     VALUE self; 
     853syck_parser_load_documents(int argc, VALUE *argv, VALUE self) 
    870854{ 
    871855    VALUE port, proc, v, input, model; 
    … …  
    908892 */ 
    909893VALUE 
    910 syck_parser_set_resolver( self, resolver ) 
    911     VALUE self, resolver; 
     894syck_parser_set_resolver(VALUE self, VALUE resolver) 
    912895{ 
    913896    rb_ivar_set( self, s_resolver, resolver ); 
    … …  
    919902 */ 
    920903static VALUE 
    921 syck_resolver_initialize( self ) 
    922     VALUE self; 
     904syck_resolver_initialize(VALUE self) 
    923905{ 
    924906    VALUE tags = rb_hash_new(); 
    … …  
    931913 */ 
    932914VALUE 
    933 syck_resolver_add_type( self, taguri, cls ) 
    934     VALUE self, taguri, cls; 
     915syck_resolver_add_type(VALUE self, VALUE taguri, VALUE cls) 
    935916{ 
    936917    VALUE tags = rb_attr_get(self, s_tags); 
    … …  
    943924 */ 
    944925VALUE 
    945 syck_resolver_use_types_at( self, hsh ) 
    946     VALUE self, hsh; 
     926syck_resolver_use_types_at(VALUE self, VALUE hsh) 
    947927{ 
    948928    rb_ivar_set( self, s_tags, hsh ); 
    … …  
    954934 */ 
    955935VALUE 
    956 syck_resolver_detect_implicit( self, val ) 
    957     VALUE self, val; 
     936syck_resolver_detect_implicit(VALUE self, VALUE val) 
    958937{ 
    959938    char *type_id; 
    … …  
    965944 */ 
    966945VALUE 
    967 syck_resolver_node_import( self, node ) 
    968     VALUE self, node; 
     946syck_resolver_node_import(VALUE self, VALUE node) 
    969947{ 
    970948    SyckNode *n; 
    … …  
    10461024 */ 
    10471025VALUE 
    1048 syck_set_ivars( vars, obj ) 
    1049         VALUE vars, obj; 
     1026syck_set_ivars(VALUE vars, VALUE obj) 
    10501027{ 
    10511028    VALUE ivname = rb_ary_entry( vars, 0 ); 
    10521029    char *ivn; 
    10531030    StringValue( ivname ); 
    1054     ivn = S_ALLOCA_N( char, RSTRING(ivname)->len + 2 ); 
     1031    ivn = S_ALLOCA_N( char, rb_str_len(ivname) + 2 ); 
    10551032    ivn[0] = '@'; 
    10561033    ivn[1] = '\0'; 
    1057     strncat( ivn, RSTRING(ivname)->ptr, RSTRING(ivname)->len ); 
     1034    strncat( ivn, rb_str_ptr(ivname), rb_str_len(ivname) ); 
    10581035    rb_iv_set( obj, ivn, rb_ary_entry( vars, 1 ) ); 
    10591036    return Qnil; 
    … …  
    10641041 */ 
    10651042VALUE 
    1066 syck_const_find( const_name ) 
    1067     VALUE const_name; 
     1043syck_const_find(VALUE const_name) 
    10681044{ 
    10691045    VALUE tclass = rb_cObject; 
    10701046    VALUE tparts = rb_str_split( const_name, "::" ); 
    10711047    int i = 0; 
    1072     for ( i = 0; i < RARRAY(tparts)->len; i++ ) { 
     1048    for ( i = 0; i < rb_ary_len(tparts); i++ ) { 
    10731049        VALUE tpart = rb_to_id( rb_ary_entry( tparts, i ) ); 
    10741050        if ( !rb_const_defined( tclass, tpart ) ) return Qnil; 
    … …  
    10821058 */ 
    10831059VALUE 
    1084 syck_resolver_transfer( self, type, val ) 
    1085     VALUE self, type, val; 
    1086 { 
    1087     if (NIL_P(type) || RSTRING(StringValue(type))->len == 0)  
     1060syck_resolver_transfer(VALUE self, VALUE type, VALUE val) 
     1061{ 
     1062    if (NIL_P(type) || rb_str_len(StringValue(type)) == 0)  
    10881063    { 
    10891064        type = rb_funcall( self, s_detect_implicit, 1, val ); 
    10901065    } 
    10911066 
    1092     if ( ! (NIL_P(type) || RSTRING(StringValue(type))->len == 0) ) 
     1067    if ( ! (NIL_P(type) || rb_str_len(StringValue(type)) == 0) ) 
    10931068    { 
    10941069        VALUE str_xprivate = rb_str_new2( "x-private" ); 
    … …  
    11071082            VALUE parts = rb_str_split( type, ":" ); 
    11081083 
    1109             while ( RARRAY(parts)->len > 1 ) 
     1084            while ( rb_ary_len(parts) > 1 ) 
    11101085            { 
    11111086                VALUE partial; 
    … …  
    11251100                { 
    11261101                    subclass = target_class; 
    1127                     if ( RARRAY(subclass_parts)->len > 0 && rb_respond_to( target_class, s_tag_subclasses ) && 
     1102                    if ( rb_ary_len(subclass_parts) > 0 && rb_respond_to( target_class, s_tag_subclasses ) && 
    11281103                         RTEST( rb_funcall( target_class, s_tag_subclasses, 0 ) ) ) 
    11291104                    { 
    … …  
    12141189 */ 
    12151190VALUE 
    1216 syck_resolver_tagurize( self, val ) 
    1217     VALUE self, val; 
     1191syck_resolver_tagurize(VALUE self, VALUE val) 
    12181192{ 
    12191193    VALUE tmp = rb_check_string_type(val); 
    … …  
    12211195    if ( !NIL_P(tmp) ) 
    12221196    { 
    1223         char *taguri = syck_type_id_to_uri( RSTRING(tmp)->ptr ); 
     1197        char *taguri = syck_type_id_to_uri( rb_str_ptr(tmp) ); 
    12241198        val = rb_str_new2( taguri ); 
    12251199        S_FREE( taguri ); 
    … …  
    12331207 */ 
    12341208VALUE 
    1235 syck_defaultresolver_detect_implicit( self, val ) 
    1236     VALUE self, val; 
     1209syck_defaultresolver_detect_implicit(VALUE self, VALUE val) 
    12371210{ 
    12381211    char *type_id; 
    … …  
    12421215    { 
    12431216        val = tmp; 
    1244         type_id = syck_match_implicit( RSTRING(val)->ptr, RSTRING(val)->len ); 
     1217        type_id = syck_match_implicit( rb_str_ptr(val), rb_str_len(val) ); 
    12451218        return rb_str_new2( type_id ); 
    12461219    } 
    … …  
    12531226 */ 
    12541227VALUE 
    1255 syck_defaultresolver_node_import( self, node ) 
    1256     VALUE self, node; 
     1228syck_defaultresolver_node_import(VALUE self, VALUE node) 
    12571229{ 
    12581230    SyckNode *n; 
    … …  
    12701242 */ 
    12711243VALUE 
    1272 syck_genericresolver_node_import( self, node ) 
    1273     VALUE self, node; 
     1244syck_genericresolver_node_import(VALUE self, VALUE node) 
    12741245{ 
    12751246    SyckNode *n; 
    … …  
    13481319 */ 
    13491320VALUE 
    1350 syck_badalias_initialize( self, val ) 
    1351     VALUE self, val; 
     1321syck_badalias_initialize(VALUE self, VALUE val) 
    13521322{ 
    13531323    rb_iv_set( self, "@name", val ); 
    … …  
    13591329 */ 
    13601330VALUE 
    1361 syck_badalias_cmp( alias1, alias2 ) 
    1362     VALUE alias1, alias2; 
     1331syck_badalias_cmp(VALUE alias1, VALUE alias2) 
    13631332{ 
    13641333    VALUE str1 = rb_ivar_get( alias1, s_name );  
    … …  
    13721341 */ 
    13731342VALUE 
    1374 syck_domaintype_initialize( self, domain, type_id, val ) 
    1375     VALUE self, domain, type_id, val; 
     1343syck_domaintype_initialize(VALUE self, VALUE domain, VALUE type_id, VALUE val) 
    13761344{ 
    13771345    rb_iv_set( self, "@domain", domain ); 
    … …  
    13851353 */ 
    13861354VALUE 
    1387 syck_yobject_initialize( self, klass, ivars ) 
    1388     VALUE self, klass, ivars; 
     1355syck_yobject_initialize(VALUE self, VALUE klass, VALUE ivars) 
    13891356{ 
    13901357    rb_iv_set( self, "@class", klass ); 
    … …  
    13971364 */ 
    13981365VALUE 
    1399 syck_privatetype_initialize( self, type_id, val ) 
    1400     VALUE self, type_id, val; 
     1366syck_privatetype_initialize(VALUE self, VALUE type_id, VALUE val) 
    14011367{ 
    14021368    rb_iv_set( self, "@type_id", type_id ); 
    … …  
    14091375 */ 
    14101376static void 
    1411 syck_node_mark( n ) 
    1412     SyckNode *n; 
     1377syck_node_mark(SyckNode *n) 
    14131378{ 
    14141379    int i; 
    … …  
    14401405 */ 
    14411406VALUE 
    1442 syck_scalar_alloc( class ) 
    1443     VALUE class; 
     1407syck_scalar_alloc(VALUE class) 
    14441408{ 
    14451409    SyckNode *node = syck_alloc_str(); 
    … …  
    14531417 */ 
    14541418VALUE 
    1455 syck_scalar_initialize( self, type_id, val, style ) 
    1456     VALUE self, type_id, val, style; 
     1419syck_scalar_initialize(VALUE self, VALUE type_id, VALUE val, VALUE style) 
    14571420{ 
    14581421    rb_iv_set( self, "@kind", sym_scalar ); 
    … …  
    14671430 */ 
    14681431VALUE 
    1469 syck_scalar_style_set( self, style ) 
    1470     VALUE self, style; 
     1432syck_scalar_style_set(VALUE self, VALUE style) 
    14711433{ 
    14721434    SyckNode *node; 
    … …  
    15061468 */ 
    15071469VALUE 
    1508 syck_scalar_value_set( self, val ) 
    1509     VALUE self, val; 
     1470syck_scalar_value_set(VALUE  self, VALUE val) 
    15101471{ 
    15111472    SyckNode *node; 
    … …  
    15131474 
    15141475    StringValue( val ); 
    1515     node->data.str->ptr = syck_strndup( RSTRING(val)->ptr, RSTRING(val)->len ); 
    1516     node->data.str->len = RSTRING(val)->len; 
     1476    node->data.str->ptr = syck_strndup( rb_str_ptr(val), rb_str_len(val) ); 
     1477    node->data.str->len = rb_str_len(val); 
    15171478    node->data.str->style = scalar_none; 
    15181479 
    … …  
    15251486 */ 
    15261487VALUE 
    1527 syck_seq_alloc( class ) 
    1528     VALUE class; 
     1488syck_seq_alloc(VALUE class) 
    15291489{ 
    15301490    SyckNode *node; 
    … …  
    15401500 */ 
    15411501VALUE 
    1542 syck_seq_initialize( self, type_id, val, style ) 
    1543     VALUE self, type_id, val, style; 
     1502syck_seq_initialize(VALUE self, VALUE type_id, VALUE val, VALUE style) 
    15441503{ 
    15451504    SyckNode *node; 
    … …  
    15571516 */ 
    15581517VALUE 
    1559 syck_seq_value_set( self, val ) 
    1560     VALUE self, val; 
     1518syck_seq_value_set(VALUE self, VALUE val) 
    15611519{ 
    15621520    SyckNode *node; 
    … …  
    15671525        int i; 
    15681526        syck_seq_empty( node ); 
    1569         for ( i = 0; i < RARRAY( val )->len; i++ ) 
     1527        for ( i = 0; i < rb_ary_len( val ); i++ ) 
    15701528        { 
    15711529            syck_seq_add( node, rb_ary_entry(val, i) ); 
    … …  
    15811539 */ 
    15821540VALUE 
    1583 syck_seq_add_m( self, val ) 
    1584     VALUE self, val; 
     1541syck_seq_add_m(VALUE self, VALUE val) 
    15851542{ 
    15861543    SyckNode *node; 
    … …  
    16011558 */ 
    16021559VALUE 
    1603 syck_seq_style_set( self, style ) 
    1604     VALUE self, style; 
     1560syck_seq_style_set(VALUE self, VALUE style) 
    16051561{ 
    16061562    SyckNode *node; 
    … …  
    16241580 */ 
    16251581VALUE 
    1626 syck_map_alloc( class ) 
    1627     VALUE class; 
     1582syck_map_alloc(VALUE class) 
    16281583{ 
    16291584    SyckNode *node; 
    … …  
    16391594 */ 
    16401595VALUE 
    1641 syck_map_initialize( self, type_id, val, style ) 
    1642     VALUE self, type_id, val, style; 
     1596syck_map_initialize(VALUE self, VALUE type_id, VALUE val, VALUE style) 
    16431597{ 
    16441598    SyckNode *node; 
    … …  
    16561610 
    16571611        keys = rb_funcall( hsh, s_keys, 0 ); 
    1658         for ( i = 0; i < RARRAY(keys)->len; i++ ) 
     1612        for ( i = 0; i < rb_ary_len(keys); i++ ) 
    16591613        { 
    16601614            VALUE key = rb_ary_entry(keys, i); 
    … …  
    16741628 */ 
    16751629VALUE 
    1676 syck_map_value_set( self, val ) 
    1677     VALUE self, val; 
     1630syck_map_value_set(VALUE self, VALUE val) 
    16781631{ 
    16791632    SyckNode *node; 
    … …  
    16921645        syck_map_empty( node ); 
    16931646        keys = rb_funcall( hsh, s_keys, 0 ); 
    1694         for ( i = 0; i < RARRAY(keys)->len; i++ ) 
     1647        for ( i = 0; i < rb_ary_len(keys); i++ ) 
    16951648        { 
    16961649            VALUE key = rb_ary_entry(keys, i); 
    … …  
    17071660 */ 
    17081661VALUE 
    1709 syck_map_add_m( self, key, val ) 
    1710     VALUE self, key, val; 
     1662syck_map_add_m(VALUE self, VALUE key, VALUE val) 
    17111663{ 
    17121664    SyckNode *node; 
    … …  
    17281680 */ 
    17291681VALUE 
    1730 syck_map_style_set( self, style ) 
    1731     VALUE self, style; 
     1682syck_map_style_set(VALUE self, VALUE style) 
    17321683{ 
    17331684    SyckNode *node; 
    … …  
    17511702 */ 
    17521703VALUE 
    1753 syck_node_init_copy( copy, orig ) 
    1754     VALUE copy, orig; 
     1704syck_node_init_copy(VALUE copy, VALUE orig) 
    17551705{ 
    17561706    SyckNode *copy_n; 
    … …  
    17751725 */ 
    17761726VALUE 
    1777 syck_node_type_id_set( self, type_id ) 
    1778     VALUE self, type_id; 
     1727syck_node_type_id_set(VALUE self, VALUE type_id) 
    17791728{ 
    17801729    SyckNode *node; 
    … …  
    17851734    if ( !NIL_P( type_id ) ) { 
    17861735        StringValue( type_id ); 
    1787         node->type_id = syck_strndup( RSTRING(type_id)->ptr, RSTRING(type_id)->len ); 
     1736        node->type_id = syck_strndup( rb_str_ptr(type_id), rb_str_len(type_id) ); 
    17881737    } 
    17891738 
    … …  
    17961745 */ 
    17971746VALUE 
    1798 syck_node_transform( self ) 
    1799     VALUE self; 
     1747syck_node_transform(VALUE self) 
    18001748{ 
    18011749    VALUE t; 
    … …  
    18531801 */ 
    18541802void 
    1855 rb_syck_emitter_handler(e, data) 
    1856     SyckEmitter *e; 
    1857     st_data_t data; 
     1803rb_syck_emitter_handler(SyckEmitter *e, st_data_t data) 
    18581804{ 
    18591805    SyckNode *n; 
    … …  
    18991845 */ 
    19001846void  
    1901 rb_syck_output_handler( emitter, str, len ) 
    1902     SyckEmitter *emitter; 
    1903     char *str; 
    1904     long len; 
     1847rb_syck_output_handler(SyckEmitter * emitter, char *str, long len) 
    19051848{ 
    19061849    struct emitter_xtra *bonus = (struct emitter_xtra *)emitter->bonus; 
    … …  
    19181861 */ 
    19191862void 
    1920 syck_out_mark( emitter, node ) 
    1921     VALUE emitter, node; 
     1863syck_out_mark(VALUE emitter, VALUE node) 
    19221864{ 
    19231865    SyckEmitter *emitterPtr; 
    … …  
    19361878