Changeset 1768

Show
Ignore:
Timestamp:
01/16/06 18:52:47
Author:
miyagawa
Message:

merged audrey's patch to fix null <=> undef and segfaults

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • JSON-Syck/trunk/Changes

    r1764 r1768  
     10.05 2006-01-16T09:50:18Z 
     2        * Added more tests. Fixed undef <=> null roundtrip problem 
     3          (Reported by kazeburo) 
     4        * Fixed segmentation fault with [null,null] (Audrey Tang) 
     5 
    160.04 2006-01-16T04:57:40Z 
    27        * Merged from YAML::Syck 0.27 and added SingleQuote flag 
  • JSON-Syck/trunk/lib/JSON/Syck.pm

    r1764 r1768  
    55use DynaLoader; 
    66 
    7 our $VERSION = '0.04'; 
     7our $VERSION = '0.05'; 
    88our @EXPORT_OK  = qw( Dump Load ); 
    99our @ISA     = qw( Exporter DynaLoader ); 
  • JSON-Syck/trunk/perl_syck.h

    r1766 r1768  
    3232#  define MAP_NONE      map_inline 
    3333#  define COND_FOLD(x)  TRUE 
    34 #  define TYPE_IS_NULL(x) ((x == NULL) || (strcmp( x, "str" ) == 0)) 
     34#  define TYPE_IS_NULL(x) ((x == NULL) || (strncmp( x, "str", 3 ) == 0)) 
    3535#  define OBJOF(a)        (a) 
    3636#else 
     
    379379#endif 
    380380 
     381    ENTER; SAVETMPS; 
     382 
    381383    /* Don't even bother if the string is empty. */ 
    382384    if (*s == '\0') { return &PL_sv_undef; } 
     
    404406#endif 
    405407 
     408    FREETMPS; LEAVE; 
     409 
    406410    return obj; 
    407411} 
     
    419423    char* tag = bonus->tag; 
    420424    char* ref = NULL; 
     425    svtype ty = SvTYPE(sv); 
    421426 
    422427#define OBJECT_TAG     "tag:perl:" 
     
    456461            } 
    457462        } 
    458         *tag = '\0'; 
    459         return; 
    460     } 
    461  
    462     switch (SvTYPE(sv)) { 
    463         case SVt_NULL: { 
    464             syck_emit_scalar(e, "string", scalar_none, 0, 0, 0, NULL_LITERAL, NULL_LITERAL_LENGTH); 
    465             break; 
    466         } 
    467         case SVt_IV: 
    468         case SVt_NV: { 
    469             if (sv_len(sv) > 0) { 
    470                 syck_emit_scalar(e, OBJOF("string"), SCALAR_NUMBER, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
    471             } 
    472             else { 
    473                 syck_emit_scalar(e, OBJOF("string"), SCALAR_QUOTED, 0, 0, 0, "", 0); 
    474             } 
    475             break; 
    476         } 
    477         case SVt_PV: 
    478         case SVt_PVIV: 
    479         case SVt_PVNV: 
    480         case SVt_PVMG: 
    481         case SVt_PVBM: 
    482         case SVt_PVLV: { 
    483             if (sv_len(sv) > 0) { 
    484                 if (SvNIOK(sv)) { 
    485                     syck_emit_scalar(e, OBJOF("string"), SCALAR_NUMBER, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
    486                 } 
    487                 else if (COND_FOLD(sv)) { 
    488                     enum scalar_style old_s = e->style; 
    489                     e->style = SCALAR_UTF8; 
    490                     syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
    491                     e->style = old_s; 
     463    } 
     464    else if (ty == SVt_NULL) { 
     465        syck_emit_scalar(e, "string", scalar_none, 0, 0, 0, NULL_LITERAL, NULL_LITERAL_LENGTH); 
     466    } 
     467    else if (SvNIOK(sv)) { 
     468        syck_emit_scalar(e, OBJOF("string"), SCALAR_NUMBER, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
     469    } 
     470    else if (SvPOK(sv)) { 
     471        STRLEN len = sv_len(sv); 
     472        if (len == 0) { 
     473            syck_emit_scalar(e, OBJOF("string"), SCALAR_QUOTED, 0, 0, 0, "", 0); 
     474        } 
     475        else if (COND_FOLD(sv)) { 
     476            enum scalar_style old_s = e->style; 
     477            e->style = SCALAR_UTF8; 
     478            syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), len); 
     479            e->style = old_s; 
     480        } 
     481        else { 
     482            syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), len); 
     483        } 
     484    } 
     485    else { 
     486        switch (ty) { 
     487            case SVt_PVAV: { 
     488                syck_emit_seq(e, OBJOF("array"), SEQ_NONE); 
     489                *tag = '\0'; 
     490                len = av_len((AV*)sv) + 1; 
     491                for (i = 0; i < len; i++) { 
     492                    SV** sav = av_fetch((AV*)sv, i, 0); 
     493                    if (sav == NULL) { 
     494                        syck_emit_item( e, (st_data_t)(&PL_sv_undef) ); 
     495                    } 
     496                    else { 
     497                        syck_emit_item( e, (st_data_t)(*sav) ); 
     498                    } 
     499                } 
     500                syck_emit_end(e); 
     501                return; 
     502            } 
     503            case SVt_PVHV: { 
     504                HV *hv = (HV*)sv; 
     505                syck_emit_map(e, OBJOF("hash"), MAP_NONE); 
     506                *tag = '\0'; 
     507#ifdef HAS_RESTRICTED_HASHES 
     508                len = HvTOTALKEYS((HV*)sv); 
     509#else 
     510                len = HvKEYS((HV*)sv); 
     511#endif 
     512                hv_iterinit((HV*)sv); 
     513 
     514                if (e->sort_keys) { 
     515                    AV *av = newAV(); 
     516                    for (i = 0; i < len; i++) { 
     517#ifdef HAS_RESTRICTED_HASHES 
     518                        HE *he = hv_iternext_flags(hv, HV_ITERNEXT_WANTPLACEHOLDERS); 
     519#else 
     520                        HE *he = hv_iternext(hv); 
     521#endif 
     522                        SV *key = hv_iterkeysv(he); 
     523                        av_store(av, AvFILLp(av)+1, key);       /* av_push(), really */ 
     524                    } 
     525                    STORE_HASH_SORT; 
     526                    for (i = 0; i < len; i++) { 
     527#ifdef HAS_RESTRICTED_HASHES 
     528                        int placeholders = (int)HvPLACEHOLDERS_get(hv); 
     529#endif 
     530                        unsigned char flags = 0; 
     531                        char *keyval; 
     532                        STRLEN keylen_tmp; 
     533                        I32 keylen; 
     534                        SV *key = av_shift(av); 
     535                        HE *he  = hv_fetch_ent(hv, key, 0, 0); 
     536                        SV *val = HeVAL(he); 
     537                        if (val == NULL) { val = &PL_sv_undef; } 
     538                        syck_emit_item( e, (st_data_t)key ); 
     539                        syck_emit_item( e, (st_data_t)val ); 
     540                    } 
    492541                } 
    493542                else { 
    494                     syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
    495                 } 
    496             } 
    497             else { 
    498                 syck_emit_scalar(e, OBJOF("string"), SCALAR_QUOTED, 0, 0, 0, "", 0); 
    499             } 
    500             break; 
    501         } 
    502         case SVt_RV: { 
    503             perl_syck_emitter_handler(e, (st_data_t)SvRV(sv)); 
    504             break; 
    505         } 
    506         case SVt_PVAV: { 
    507             syck_emit_seq(e, OBJOF("array"), SEQ_NONE); 
    508             *tag = '\0'; 
    509             len = av_len((AV*)sv) + 1; 
    510             for (i = 0; i < len; i++) { 
    511                 SV** sav = av_fetch((AV*)sv, i, 0); 
    512                 syck_emit_item( e, (st_data_t)(*sav) ); 
    513             } 
    514             syck_emit_end(e); 
    515             return; 
    516         } 
    517         case SVt_PVHV: { 
    518             HV *hv = (HV*)sv; 
    519             syck_emit_map(e, OBJOF("hash"), MAP_NONE); 
    520             *tag = '\0'; 
    521 #ifdef HAS_RESTRICTED_HASHES 
    522             len = HvTOTALKEYS((HV*)sv); 
     543                    for (i = 0; i < len; i++) { 
     544#ifdef HV_ITERNEXT_WANTPLACEHOLDERS 
     545                        HE *he = hv_iternext_flags(hv, HV_ITERNEXT_WANTPLACEHOLDERS); 
    523546#else 
    524             len = HvKEYS((HV*)sv); 
    525 #endif 
    526             hv_iterinit((HV*)sv); 
    527  
    528             if (e->sort_keys) { 
    529                 AV *av = newAV(); 
    530                 for (i = 0; i < len; i++) { 
    531 #ifdef HAS_RESTRICTED_HASHES 
    532                     HE *he = hv_iternext_flags(hv, HV_ITERNEXT_WANTPLACEHOLDERS); 
    533 #else 
    534                     HE *he = hv_iternext(hv); 
    535 #endif 
    536                     SV *key = hv_iterkeysv(he); 
    537                     av_store(av, AvFILLp(av)+1, key);   /* av_push(), really */ 
    538                 } 
    539                 STORE_HASH_SORT; 
    540                 for (i = 0; i < len; i++) { 
    541 #ifdef HAS_RESTRICTED_HASHES 
    542                     int placeholders = (int)HvPLACEHOLDERS_get(hv); 
    543 #endif 
    544                     unsigned char flags = 0; 
    545                     char *keyval; 
    546                     STRLEN keylen_tmp; 
    547                     I32 keylen; 
    548                     SV *key = av_shift(av); 
    549                     HE *he  = hv_fetch_ent(hv, key, 0, 0); 
    550                     SV *val = HeVAL(he); 
    551                     if (val == NULL) { val = &PL_sv_undef; } 
    552                     syck_emit_item( e, (st_data_t)key ); 
    553                     syck_emit_item( e, (st_data_t)val ); 
    554                 } 
    555             } 
    556             else { 
    557                 for (i = 0; i < len; i++) { 
    558 #ifdef HV_ITERNEXT_WANTPLACEHOLDERS 
    559                     HE *he = hv_iternext_flags(hv, HV_ITERNEXT_WANTPLACEHOLDERS); 
    560 #else 
    561                     HE *he = hv_iternext(hv); 
    562 #endif 
    563                     I32 keylen; 
    564                     SV *key = hv_iterkeysv(he); 
    565                     SV *val = hv_iterval(hv, he); 
    566                     syck_emit_item( e, (st_data_t)key ); 
    567                     syck_emit_item( e, (st_data_t)val ); 
    568                 } 
    569             } 
    570             syck_emit_end(e); 
    571             return; 
    572         } 
    573         case SVt_PVCV: { 
    574             /* XXX TODO XXX */ 
    575             syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
    576             break; 
    577         } 
    578         case SVt_PVGV: 
    579         case SVt_PVFM: { 
    580             /* XXX TODO XXX */ 
    581             syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
    582             break; 
    583         } 
    584         case SVt_PVIO: { 
    585             syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
    586             break; 
     547                        HE *he = hv_iternext(hv); 
     548#endif 
     549                        I32 keylen; 
     550                        SV *key = hv_iterkeysv(he); 
     551                        SV *val = hv_iterval(hv, he); 
     552                        syck_emit_item( e, (st_data_t)key ); 
     553                        syck_emit_item( e, (st_data_t)val ); 
     554                    } 
     555                } 
     556                syck_emit_end(e); 
     557                return; 
     558            } 
     559            case SVt_PVCV: { 
     560                /* XXX TODO XXX */ 
     561                syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
     562                break; 
     563            } 
     564            case SVt_PVGV: 
     565            case SVt_PVFM: { 
     566                /* XXX TODO XXX */ 
     567                syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
     568                break; 
     569            } 
     570            case SVt_PVIO: { 
     571                syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
     572                break; 
     573            } 
     574            default: { 
     575                syck_emit_scalar(e, "string", scalar_none, 0, 0, 0, NULL_LITERAL, NULL_LITERAL_LENGTH); 
     576            } 
    587577        } 
    588578    } 
     
    604594#endif 
    605595 
     596    ENTER; SAVETMPS; 
     597 
    606598    emitter->headless = SvTRUE(headless); 
    607599    emitter->sort_keys = SvTRUE(sortkeys); 
     
    634626        SvUTF8_on(out); 
    635627    } 
     628 
     629    FREETMPS; LEAVE; 
     630 
    636631    return out; 
    637632} 
  • JSON-Syck/trunk/t/01_json.t

    r1767 r1768  
    5353        # try parsing the data with JSON.pm 
    5454        if ($HAS_JSON) { 
    55             utf8::encode($data) if !ref($data) && $unicode; 
     55            utf8::encode($data) if defined($data) && !ref($data) && $unicode; 
    5656            my $data_pp = eval { JSON::jsonToObj($json) }; 
    5757            is_deeply $data_pp, $data, "compatibility with JSON.pm $test";