Changeset 1741

Show
Ignore:
Timestamp:
01/12/06 00:50:31
Author:
miyagawa
Message:

merge audrey's changes and added Unicode test: still failing

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • JSON-Syck/trunk/emitter.c

    r1740 r1741  
    759759    for( i = 0; i < len; i++ ) 
    760760    { 
    761         if( (src[i] < 0x20) ) // || (0x7E < src[i]) ) 
     761        if( (e->style == scalar_fold) 
     762                ? ((src[i] < 0x20) && (0 < src[i])) 
     763                : ((src[i] < 0x20) || (0x7E < src[i])) ) 
    762764        { 
    763765            syck_emitter_write( e, "\\", 1 ); 
     
    12181220             */ 
    12191221            st_insert( e->anchors, (st_data_t)oid, (st_data_t)anchor_name ); 
     1222 
     1223            /* XXX - Added by Audrey Tang to handle self-recursive structures - XXX */ 
     1224            return 0; 
    12201225        } 
    12211226    } 
  • JSON-Syck/trunk/perl_syck.h

    r1740 r1741  
    2020#  define SCALAR_STRING scalar_2quote 
    2121#  define SCALAR_QUOTED scalar_2quote 
     22#  define SCALAR_UTF8   scalar_fold 
    2223#  define SEQ_NONE      seq_inline 
    2324#  define MAP_NONE      map_inline 
     
    3031#  define SCALAR_STRING scalar_none 
    3132#  define SCALAR_QUOTED scalar_1quote 
     33#  define SCALAR_UTF8   scalar_fold 
    3234#  define SEQ_NONE      seq_none 
    3335#  define MAP_NONE      map_none 
     
    5153    return obj; 
    5254} 
     55 
     56#define CHECK_UTF8 \ 
     57    if (p->bonus && is_utf8_string((U8*)n->data.str->ptr, n->data.str->len)) \ 
     58        SvUTF8_on(sv); 
    5359 
    5460SYMID perl_syck_parser_handler(SyckParser *p, SyckNode *n) { 
     
    5763    HV *map; 
    5864    long i; 
    59  
    6065    switch (n->kind) { 
    6166        case syck_str_kind: 
     
    6671                } else { 
    6772                    sv = newSVpvn(n->data.str->ptr, n->data.str->len); 
     73                    CHECK_UTF8; 
    6874                } 
    6975            } else if (strcmp( n->type_id, "str" ) == 0 ) { 
    7076                sv = newSVpvn(n->data.str->ptr, n->data.str->len); 
     77                CHECK_UTF8; 
    7178            } else if (strcmp( n->type_id, "null" ) == 0 ) { 
    7279                sv = &PL_sv_undef; 
     
    7784            } else if (strcmp( n->type_id, "default" ) == 0 ) { 
    7885                sv = newSVpvn(n->data.str->ptr, n->data.str->len); 
     86                CHECK_UTF8; 
    7987            } else if (strcmp( n->type_id, "float#base60" ) == 0 ) { 
    8088                char *ptr, *end; 
     
    154162                /* croak("unknown node type: %s", n->type_id); */ 
    155163                sv = newSVpvn(n->data.str->ptr, n->data.str->len); 
     164                CHECK_UTF8; 
    156165            } 
    157166        break; 
     
    163172            } 
    164173            sv = newRV_noinc((SV*)seq); 
     174#ifndef YAML_IS_JSON 
    165175            if (n->type_id) { 
    166176                sv_bless(sv, gv_stashpv(n->type_id + 6, TRUE)); 
    167177            } 
     178#endif 
    168179        break; 
    169180 
    170181        case syck_map_kind: 
    171             map = newHV(); 
    172             for (i = 0; i < n->data.pairs->idx; i++) { 
    173                 hv_store_ent( 
    174                     map, 
    175                     perl_syck_lookup_sym(p, syck_map_read(n, map_key, i) ), 
    176                     perl_syck_lookup_sym(p, syck_map_read(n, map_value, i) ), 
    177                     0 
    178                 ); 
    179             } 
    180             sv = newRV_noinc((SV*)map); 
    181             if (n->type_id) { 
    182                 sv_bless(sv, gv_stashpv(n->type_id + 5, TRUE)); 
     182#ifndef YAML_IS_JSON 
     183            if ( (n->type_id != NULL) && (strcmp( n->type_id, "perl/ref:" ) == 0) ) { 
     184                sv = newRV_noinc( perl_syck_lookup_sym(p, syck_map_read(n, map_value, 0) ) ); 
     185            } 
     186            else 
     187#endif 
     188            { 
     189                map = newHV(); 
     190                for (i = 0; i < n->data.pairs->idx; i++) { 
     191                    hv_store_ent( 
     192                        map, 
     193                        perl_syck_lookup_sym(p, syck_map_read(n, map_key, i) ), 
     194                        perl_syck_lookup_sym(p, syck_map_read(n, map_value, i) ), 
     195                        0 
     196                    ); 
     197                } 
     198                sv = newRV_noinc((SV*)map); 
     199#ifndef YAML_IS_JSON 
     200                if (n->type_id) { 
     201                    sv_bless(sv, gv_stashpv(n->type_id + 5, TRUE)); 
     202                } 
     203#endif 
    183204            } 
    184205        break; 
     
    187208} 
    188209 
    189 void perl_syck_mark_emitter(SyckEmitter *e) { 
    190     return; 
     210void perl_syck_mark_emitter(SyckEmitter *e, SV *sv) { 
     211    if (syck_emitter_mark_node(e, (st_data_t)sv) == 0) { 
     212        return; 
     213    } 
     214 
     215    if (SvROK(sv)) { 
     216        perl_syck_mark_emitter(e, SvRV(sv)); 
     217        return; 
     218    } 
     219 
     220    switch (SvTYPE(sv)) { 
     221        case SVt_PVAV: { 
     222            I32 len, i; 
     223            len = av_len((AV*)sv) + 1; 
     224            for (i = 0; i < len; i++) { 
     225                SV** sav = av_fetch((AV*)sv, i, 0); 
     226                perl_syck_mark_emitter( e, *sav ); 
     227            } 
     228            break; 
     229        } 
     230        case SVt_PVHV: { 
     231            I32 len, i; 
     232#ifdef HAS_RESTRICTED_HASHES 
     233            len = HvTOTALKEYS((HV*)sv); 
     234#else 
     235            len = HvKEYS((HV*)sv); 
     236#endif 
     237            hv_iterinit((HV*)sv); 
     238            for (i = 0; i < len; i++) { 
     239#ifdef HV_ITERNEXT_WANTPLACEHOLDERS 
     240                HE *he = hv_iternext_flags((HV*)sv, HV_ITERNEXT_WANTPLACEHOLDERS); 
     241#else 
     242                HE *he = hv_iternext((HV*)sv); 
     243#endif 
     244                I32 keylen; 
     245                SV *val = hv_iterval((HV*)sv, he); 
     246                perl_syck_mark_emitter( e, val ); 
     247            } 
     248            break; 
     249        } 
     250    } 
     251
     252 
     253SyckNode * perl_syck_bad_anchor_handler(SyckParser *p, char *a) { 
     254    croak(form( "%s parser (line %d, column %d): Unsupported self-recursive anchor *%s",  
     255        PACKAGE_NAME, 
     256        p->linect + 1, 
     257        p->cursor - p->lineptr, 
     258        a )); 
     259    /* 
     260    SyckNode *badanc = syck_new_map( 
     261        (SYMID)newSVpvn_share("name", 4, 0), 
     262        (SYMID)newSVpvn_share(a, strlen(a), 0) 
     263    ); 
     264    badanc->type_id = syck_strndup( "perl:YAML::Syck::BadAlias", 25 ); 
     265    return badanc; 
     266    */ 
    191267} 
    192268 
     
    255331        } 
    256332    } 
     333 
     334    /* Remove the trailing newline */ 
     335    if (final_len > 0) { 
     336        final_len--; pos--; 
     337    } 
    257338    *pos = '\0'; 
    258  
    259339    SvCUR_set(sv, final_len); 
    260340} 
     
    265345    SV *obj = &PL_sv_undef; 
    266346    SV *implicit = GvSV(gv_fetchpv(form("%s::ImplicitTyping", PACKAGE_NAME), TRUE, SVt_PV)); 
     347    SV *unicode = GvSV(gv_fetchpv(form("%s::ImplicitUnicode", PACKAGE_NAME), TRUE, SVt_PV)); 
    267348 
    268349    /* Don't even bother if the string is empty. */ 
     
    277358    syck_parser_handler(parser, perl_syck_parser_handler); 
    278359    syck_parser_error_handler(parser, perl_syck_error_handler); 
     360    syck_parser_bad_anchor_handler( parser, perl_syck_bad_anchor_handler ); 
    279361    syck_parser_implicit_typing(parser, SvTRUE(implicit)); 
    280362    syck_parser_taguri_expansion(parser, 0); 
     363 
     364    parser->bonus = (void*)SvTRUE(unicode); 
     365 
    281366    v = syck_parse(parser); 
    282367    syck_lookup_sym(parser, v, (char **)&obj); 
     
    329414 
    330415    if (SvROK(sv)) { 
    331         perl_syck_emitter_handler(e, (st_data_t)SvRV(sv)); 
     416        switch (SvTYPE(SvRV(sv))) { 
     417            case SVt_PVAV: 
     418            case SVt_PVHV: 
     419            case SVt_PVCV: { 
     420                perl_syck_emitter_handler(e, (st_data_t)SvRV(sv)); 
     421                break; 
     422            } 
     423            default: { 
     424                syck_emit_map(e, "tag:perl:ref:", MAP_NONE); 
     425                syck_emit_item( e, (st_data_t)newSVpvn_share("=", 1, 0) ); 
     426                syck_emit_item( e, (st_data_t)SvRV(sv) ); 
     427                syck_emit_end(e); 
     428            } 
     429        } 
    332430        *tag = '\0'; 
    333431        return; 
     
    361459        case SVt_PVLV: { 
    362460            if (sv_len(sv) > 0) { 
    363                 syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
     461                if (SvUTF8(sv)) { 
     462                    enum scalar_style old_s = e->style; 
     463                    e->style = SCALAR_UTF8; 
     464                    syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
     465                    e->style = old_s; 
     466                } 
     467                else { 
     468                    syck_emit_scalar(e, OBJOF("string"), SCALAR_STRING, 0, 0, 0, SvPV_nolen(sv), sv_len(sv)); 
     469                } 
    364470            } 
    365471            else { 
     
    432538    SyckEmitter *emitter = syck_new_emitter(); 
    433539    SV *headless = GvSV(gv_fetchpv(form("%s::Headless", PACKAGE_NAME), TRUE, SVt_PV)); 
     540    SV *unicode = GvSV(gv_fetchpv(form("%s::ImplicitUnicode", PACKAGE_NAME), TRUE, SVt_PV)); 
    434541 
    435542    emitter->headless = SvTRUE(headless); 
     543    emitter->anchor_format = "%d"; 
    436544 
    437545    bonus = emitter->bonus = S_ALLOC_N(struct emitter_xtra, 1); 
     
    442550    syck_output_handler( emitter, perl_syck_output_handler ); 
    443551 
    444     perl_syck_mark_emitter( emitter ); 
     552#ifndef YAML_IS_JSON 
     553    perl_syck_mark_emitter( emitter, sv ); 
     554#endif 
     555 
    445556    syck_emit( emitter, (st_data_t)sv ); 
    446557    syck_emitter_flush( emitter, 0 ); 
     
    451562#ifdef YAML_IS_JSON 
    452563    if (SvCUR(out) > 0) { 
    453         /* Trim the trailing newline */ 
    454         SvCUR_set(out, SvCUR(out)-1); 
    455     } 
    456 #endif 
    457  
    458 #ifdef YAML_IS_JSON 
    459     perl_json_postprocess(out); 
    460 #endif 
    461  
     564        perl_json_postprocess(out); 
     565    } 
     566#endif 
     567 
     568    if (SvTRUE(unicode)) { 
     569        SvUTF8_on(out); 
     570    } 
    462571    return out; 
    463572} 
  • JSON-Syck/trunk/t/01_json.t

    r1725 r1741  
    1010$Data::Dumper::Indent = 0; 
    1111$Data::Dumper::Terse  = 1; 
     12 
     13#$JSON::Syck::ImplicitUnicode = 1; 
    1214 
    1315my @tests = ( 
     
    2426    '{"foo":"bar"}', 
    2527    '[{"foo": 2}, {"foo": "bar"}]', 
     28    qq("\xe5\xaa\xbe"), 
    2629); 
    2730