← Back to branch summary

~ubuntu-branches/ubuntu/quantal/libyaml-libyaml-perl/quantal-security

« back to all changes in this revision

Viewing changes to LibYAML/perl_libyaml.c

  • Committer: Bazaar Package Importer
  • Author(s): Krzysztof Krzyżaniak (eloy)
  • Date: 2010-09-24 17:35:42 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100924173542-7ajsmy5mmt6swpgh
Tags: 0.34-1
* New upstream release
* Update Standards-Version to 3.9.1 (no changes)
* Added me to Uploaders (debian/control) and debian/copyright file

Show diffs side-by-side

added added

removed removed

Lines of Context:
LibYAML/perl_libyaml.c
121
121
    dXSARGS;
122
122
    perl_yaml_loader_t loader;
123
123
    SV *node;
124
 
    char *yaml_str;
 
124
    const unsigned char *yaml_str;
125
125
    STRLEN yaml_len;
126
 
    
127
 
    /* If UTF8, make copy and downgrade */
128
 
    if (SvPV_nolen(yaml_sv) && SvUTF8(yaml_sv)) {
 
126
 
 
127
    yaml_str = (const unsigned char *)SvPV_const(yaml_sv, yaml_len);
 
128
 
 
129
    if (DO_UTF8(yaml_sv)) {
129
130
        yaml_sv = sv_mortalcopy(yaml_sv);
 
131
        if (!sv_utf8_downgrade(yaml_sv, TRUE))
 
132
            croak("Wide character in YAML::XS::Load()");
 
133
        yaml_str = (const unsigned char *)SvPV_const(yaml_sv, yaml_len);
130
134
    }
131
 
    yaml_str = SvPVbyte(yaml_sv, yaml_len);
132
135
 
133
136
    sp = mark;
134
137
    if (0 && (items || ax)) {} /* XXX Quiet the -Wall warnings for now. */
137
140
    loader.document = 0;
138
141
    yaml_parser_set_input_string(
139
142
        &loader.parser,
140
 
        (unsigned char *)yaml_str,
 
143
        yaml_str,
141
144
        yaml_len
142
145
    );
143
146
 
151
154
         );
152
155
 
153
156
    loader.anchors = newHV();
154
 
    sv_2mortal(loader.anchors);
 
157
    sv_2mortal((SV *)loader.anchors);
155
158
 
156
159
    /* Keep calling load_node until end of stream */
157
160
    while (1) {
350
353
            return newSV(0);
351
354
        else if (strEQ(string, ""))
352
355
            return newSV(0);
 
356
        else if (strEQ(string, "null"))
 
357
            return newSV(0);
353
358
        else if (strEQ(string, "true"))
354
359
            return &PL_sv_yes;
355
360
        else if (strEQ(string, "false"))
363
368
        SvIV_please(scalar);
364
369
    }
365
370
 
366
 
    SvUTF8_on(scalar);
 
371
    (void)sv_utf8_decode(scalar);
367
372
    if (anchor)
368
373
        hv_store(loader->anchors, anchor, strlen(anchor), SvREFCNT_inc(scalar), 0);
369
374
    return scalar;
463
468
        ((gv = gv_fetchpv("YAML::XS::DumpCode", TRUE, SVt_PV)) &&
464
469
        SvTRUE(GvSV(gv)))
465
470
    );
 
471
 
 
472
    dumper->quote_number_strings = (
 
473
        ((gv = gv_fetchpv("YAML::XS::QuoteNumericStrings", TRUE, SVt_PV)) &&
 
474
        SvTRUE(GvSV(gv)))
 
475
    );
466
476
}
467
477
 
468
478
/*
574
584
    }
575
585
    else if (ref_type == SVt_PVHV) {
576
586
        HV *hash = (HV *)SvRV(node);
577
 
        len = HvKEYS(hash);
 
587
        HE *he;
578
588
        hv_iterinit(hash);
579
 
        for (i = 0; i < len; i++) {
580
 
            HE *he = hv_iternext(hash);
 
589
        while ((he = hv_iternext(hash))) {
581
590
            SV *val = HeVAL(he);
582
591
            if (val)
583
592
                dump_prewalk(dumper, val);
608
617
{
609
618
    yaml_char_t *anchor = NULL;
610
619
    yaml_char_t *tag = NULL;
611
 
    char *class = NULL;
 
620
    const char *class = NULL;
612
621
 
613
622
    if (SvTYPE(node) == SVt_PVGV) {
614
623
        SV **svr;
653
662
            dump_scalar(dumper, node, tag);
654
663
        }
655
664
#if PERL_REVISION > 5 || (PERL_REVISION == 5 && PERL_VERSION >= 11)
656
 
        else if (ref_type == SVt_REGEXP) {
657
 
            yaml_char_t *tag = (yaml_char_t *)form(TAG_PERL_PREFIX "regexp");
658
 
            class = sv_reftype(rnode, TRUE);
659
 
            if (!strEQ(class, "Regexp"))
660
 
                 tag = (yaml_char_t *)form("%s:%s", tag, class);
661
 
            dump_scalar(dumper, node, tag);
662
 
        }
 
665
        else if (ref_type == SVt_REGEXP) {
 
666
            yaml_char_t *tag = (yaml_char_t *)form(TAG_PERL_PREFIX "regexp");
 
667
            class = sv_reftype(rnode, TRUE);
 
668
                if (!strEQ(class, "Regexp"))
 
669
                     tag = (yaml_char_t *)form("%s:%s", tag, class);
 
670
            dump_scalar(dumper, node, tag);
 
671
        }
663
672
#endif
664
673
        else {
665
674
            printf(
701
710
get_yaml_tag(SV *node)
702
711
{
703
712
    yaml_char_t *tag;
704
 
    char *class;
705
 
    char *kind = "";
 
713
    const char *class;
 
714
    const char *kind = "";
706
715
    if (! (
707
716
        sv_isobject(node) ||
708
717
        (SvRV(node) && ( SvTYPE(SvRV(node)) == SVt_PVCV))
734
743
    int len;
735
744
    AV *av;
736
745
    HV *hash = (HV *)SvRV(node);
737
 
    len = HvKEYS(hash);
738
 
    hv_iterinit(hash);
 
746
    HE *he;
739
747
 
740
748
    if (!anchor)
741
749
        anchor = get_yaml_anchor(dumper, (SV *)hash);
750
758
    yaml_emitter_emit(&dumper->emitter, &event_mapping_start);
751
759
 
752
760
    av = newAV();
753
 
    for (i = 0; i < len; i++) {
754
 
        HE *he = hv_iternext(hash);
 
761
    len = 0;
 
762
    hv_iterinit(hash);
 
763
    while ((he = hv_iternext(hash))) {
755
764
        SV *key = hv_iterkeysv(he);
756
765
        av_store(av, AvFILLp(av)+1, key); /* av_push(), really */
 
766
        len++;
757
767
    }
758
768
    STORE_HASH_SORT;
759
769
    for (i = 0; i < len; i++) {
760
770
        SV *key = av_shift(av);
761
771
        HE *he  = hv_fetch_ent(hash, key, 0, 0);
762
 
        SV *val = HeVAL(he);
 
772
        SV *val = he ? HeVAL(he) : NULL;
763
773
        if (val == NULL) { val = &PL_sv_undef; }
764
774
        dump_node(dumper, key);
765
775
        dump_node(dumper, val);
818
828
        plain_implicit = quoted_implicit = 1;
819
829
    }
820
830
 
 
831
    SvGETMAGIC(node);
821
832
    if (!SvOK(node)) {
822
833
        string = "~";
823
834
        string_len = 1;
834
845
        style = YAML_PLAIN_SCALAR_STYLE;
835
846
    }
836
847
    else {
837
 
        string = SvPV(node, string_len);
 
848
        string = SvPV_nomg(node, string_len);
838
849
        if (
839
850
            (string_len == 0) ||
840
851
            strEQ(string, "~") ||
842
853
            strEQ(string, "false") ||
843
854
            strEQ(string, "null") ||
844
855
            (SvTYPE(node) >= SVt_PVGV) ||
845
 
            ( !SvNIOK(node) && looks_like_number(node) )
 
856
            ( dumper->quote_number_strings && !SvNIOK(node) && looks_like_number(node) )
846
857
        ) {
847
858
            style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
848
859
        }
958
969
}
959
970
 
960
971
int
961
 
append_output(void *yaml, unsigned char *buffer, unsigned int size)
 
972
append_output(void *yaml, unsigned char *buffer, size_t size)
962
973
{
963
974
    sv_catpvn((SV *)yaml, (const char *)buffer, (STRLEN)size);
964
975
    return 1;