Changeset 265

Show
Ignore:
Timestamp:
12/27/07 16:11:27 (9 months ago)
Author:
xi
Message:

Fixed bugs and updated tests.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • libyaml/trunk/include/yaml.h

    r264 r265  
    15421542 * @param[in,out]   emitter         An emitter object. 
    15431543 * @param[in]       buffer          An output buffer. 
     1544 * @param[in]       capacity        The buffer size. 
    15441545 * @param[in]       length          The pointer to save the number of written 
    15451546 *                                  bytes. 
    1546  * @param[in]       capacity        The buffer size. 
    15471547 */ 
    15481548 
    15491549YAML_DECLARE(void) 
    15501550yaml_emitter_set_string_writer(yaml_emitter_t *emitter, 
    1551         unsigned char *buffer, size_t *length, size_t capacity); 
     1551        unsigned char *buffer, size_t capacity, size_t *length); 
    15521552 
    15531553/** 

  • libyaml/trunk/src/api.c

    r264 r265  
    104104            if (error->data.reading.value == -1) { 
    105105                length = snprintf(buffer, capacity, 
    106                         "%s: %s at position %d", 
     106                        "%s: %s at byte %d", 
    107107                        prefixes[error->type], 
    108108                        error->data.reading.problem, 
    …… 
    111111            else { 
    112112                length = snprintf(buffer, capacity, 
    113                         "%s: %s (#%X) at position %d", 
     113                        "%s: %s (#%X) at byte %d", 
    114114                        prefixes[error->type], 
    115115                        error->data.reading.problem, 
    …… 
    145145        case YAML_WRITER_ERROR: 
    146146            length = snprintf(buffer, capacity, 
    147                     "%s: %s at position %d", 
     147                    "%s: %s at byte %d", 
    148148                    prefixes[error->type], 
    149149                    error->data.writing.problem, 
    …… 
    497497    STACK_DEL(emitter, emitter->states); 
    498498    while (!QUEUE_EMPTY(emitter, emitter->events)) { 
    499         yaml_event_delete(&DEQUEUE(emitter, emitter->events)); 
     499        yaml_event_destroy(&DEQUEUE(emitter, emitter->events)); 
    500500    } 
    501501    QUEUE_DEL(emitter, emitter->events); 
    …… 
    564564YAML_DECLARE(void) 
    565565yaml_emitter_set_string_writer(yaml_emitter_t *emitter, 
    566         unsigned char *buffer, size_t *length, size_t capacity) 
     566        unsigned char *buffer, size_t capacity, size_t *length) 
    567567{ 
    568568    assert(emitter);    /* Non-NULL emitter object expected. */ 
    …… 
    730730 
    731731    token->type = model->type; 
    732     token->start_mark = model->start_mark; 
    733     token->end_mark = model->end_mark; 
    734732 
    735733    switch (token->type) 
    …… 
    782780                    model->data.scalar.length+1); 
    783781            token->data.scalar.length = model->data.scalar.length; 
     782            token->data.scalar.style = model->data.scalar.style; 
    784783            break; 
    785784 
    …… 
    927926 
    928927    event->type = model->type; 
    929     event->start_mark = model->start_mark; 
    930     event->end_mark = model->end_mark; 
    931928 
    932929    switch (event->type) 
    …… 
    969966            event->data.document_end.is_implicit = 
    970967                model->data.document_end.is_implicit; 
     968            break; 
    971969 
    972970        case YAML_ALIAS_EVENT: 
    …… 
    981979                        yaml_strdup(model->data.scalar.anchor))) 
    982980                goto error; 
    983             if (event->data.scalar.tag && 
     981            if (model->data.scalar.tag && 
    984982                    !(event->data.scalar.tag = 
    985983                        yaml_strdup(model->data.scalar.tag))) 
    …… 
    10031001                        yaml_strdup(model->data.sequence_start.anchor))) 
    10041002                goto error; 
    1005             if (event->data.sequence_start.tag && 
     1003            if (model->data.sequence_start.tag && 
    10061004                    !(event->data.sequence_start.tag = 
    10071005                        yaml_strdup(model->data.sequence_start.tag))) 
    …… 
    10181016                        yaml_strdup(model->data.mapping_start.anchor))) 
    10191017                goto error; 
    1020             if (event->data.mapping_start.tag && 
     1018            if (model->data.mapping_start.tag && 
    10211019                    !(event->data.mapping_start.tag = 
    10221020                        yaml_strdup(model->data.mapping_start.tag))) 

  • libyaml/trunk/src/emitter.c

    r264 r265  
    266266{ 
    267267    if (!ENQUEUE(emitter, emitter->events, *event)) { 
    268         yaml_event_delete(event); 
     268        yaml_event_destroy(event); 
    269269        return 0; 
    270270    } 
    …… 
    277277                    emitter->events.list + emitter->events.head)) 
    278278            return 0; 
    279         yaml_event_delete(&DEQUEUE(emitter, emitter->events)); 
     279        yaml_event_destroy(&DEQUEUE(emitter, emitter->events)); 
    280280    } 
    281281 

  • libyaml/trunk/src/scanner.c

    r264 r265  
    13651365 
    13661366    if (!ENQUEUE(parser, parser->tokens, token)) { 
    1367         yaml_token_delete(&token); 
     1367        yaml_token_destroy(&token); 
    13681368        return 0; 
    13691369    } 
    …… 
    17611761 
    17621762    if (!ENQUEUE(parser, parser->tokens, token)) { 
    1763         yaml_token_delete(&token); 
     1763        yaml_token_destroy(&token); 
    17641764        return 0; 
    17651765    } 
    …… 
    17911791 
    17921792    if (!ENQUEUE(parser, parser->tokens, token)) { 
    1793         yaml_token_delete(&token); 
     1793        yaml_token_destroy(&token); 
    17941794        return 0; 
    17951795    } 
    …… 
    18221822 
    18231823    if (!ENQUEUE(parser, parser->tokens, token)) { 
    1824         yaml_token_delete(&token); 
     1824        yaml_token_destroy(&token); 
    18251825        return 0; 
    18261826    } 
    …… 
    18531853 
    18541854    if (!ENQUEUE(parser, parser->tokens, token)) { 
    1855         yaml_token_delete(&token); 
     1855        yaml_token_destroy(&token); 
    18561856        return 0; 
    18571857    } 
    …… 
    18841884 
    18851885    if (!ENQUEUE(parser, parser->tokens, token)) { 
    1886         yaml_token_delete(&token); 
     1886        yaml_token_destroy(&token); 
    18871887        return 0; 
    18881888    } 

  • libyaml/trunk/src/yaml_private.h

    r264 r265  
    893893 */ 
    894894 
    895 typedef union yaml_standard_reader_data_u { 
     895typedef struct yaml_standard_reader_data_t { 
    896896    /* String input data. */ 
    897897    yaml_istring_t string; 
    …… 
    10901090 */ 
    10911091 
    1092 typedef union yaml_standard_writer_data_u { 
     1092typedef struct yaml_standard_writer_data_t { 
    10931093    /* String output data. */ 
    10941094    yaml_ostring_t string; 

  • libyaml/trunk/tests/run-dumper.c

    r242 r265  
    1212#define BUFFER_SIZE 65536 
    1313#define MAX_DOCUMENTS  16 
     14 
     15#if 0 
    1416 
    1517int copy_document(yaml_document_t *document_to, yaml_document_t *document_from) 
    …… 
    185187} 
    186188 
     189#endif 
     190 
    187191int 
    188192main(int argc, char *argv[]) 
    189193{ 
     194#if 0 
    190195    int number; 
    191196    int canonical = 0; 
    …… 
    308313    } 
    309314 
     315#endif 
    310316    return 0; 
    311317} 

  • libyaml/trunk/tests/run-emitter.c

    r242 r265  
    1313#define MAX_EVENTS  1024 
    1414 
    15 int copy_event(yaml_event_t *event_to, yaml_event_t *event_from) 
     15int compare_events(const yaml_event_t *event, const yaml_event_t *model) 
    1616{ 
    17     switch (event_from->type) 
     17    yaml_char_t *event_anchor = NULL; 
     18    yaml_char_t *model_anchor = NULL; 
     19    yaml_char_t *event_tag = NULL; 
     20    yaml_char_t *model_tag = NULL; 
     21    yaml_char_t *event_value = NULL; 
     22    yaml_char_t *model_value = NULL; 
     23    size_t event_length = 0; 
     24    size_t model_length = 0; 
     25    int idx; 
     26 
     27    if (event->type != model->type) 
     28        return 0; 
     29 
     30    switch (event->type) 
    1831    { 
    19         case YAML_STREAM_START_EVENT: 
    20             return yaml_stream_start_event_initialize(event_to, 
    21                     event_from->data.stream_start.encoding); 
    22  
    23         case YAML_STREAM_END_EVENT: 
    24             return yaml_stream_end_event_initialize(event_to); 
    25  
    2632        case YAML_DOCUMENT_START_EVENT: 
    27             return yaml_document_start_event_initialize(event_to, 
    28                     event_from->data.document_start.version_directive, 
    29                     event_from->data.document_start.tag_directives.start, 
    30                     event_from->data.document_start.tag_directives.end, 
    31                     event_from->data.document_start.implicit); 
    32  
    33         case YAML_DOCUMENT_END_EVENT: 
    34             return yaml_document_end_event_initialize(event_to, 
    35                     event_from->data.document_end.implicit); 
     33            if (!event->data.document_start.version_directive != 
     34                    !model->data.document_start.version_directive) 
     35                return 0; 
     36            if (event->data.document_start.version_directive) { 
     37                yaml_version_directive_t *event_version_directive = 
     38                    event->data.document_start.version_directive; 
     39                yaml_version_directive_t *model_version_directive = 
     40                    model->data.document_start.version_directive; 
     41                if (event_version_directive->major != 
     42                        model_version_directive->major || 
     43                        event_version_directive->minor != 
     44                        model_version_directive->minor) 
     45                    return 0; 
     46            } 
     47            if (event->data.document_start.tag_directives.length != 
     48                    model->data.document_start.tag_directives.length) 
     49                return 0; 
     50            for (idx = 0; idx < event->data.document_start.tag_directives.length; idx++) { 
     51                yaml_tag_directive_t *event_tag_directive = 
     52                    event->data.document_start.tag_directives.list + idx; 
     53                yaml_tag_directive_t *model_tag_directive = 
     54                    model->data.document_start.tag_directives.list + idx; 
     55                if (strcmp(event_tag_directive->handle, model_tag_directive->handle)) 
     56                    return 0; 
     57                if (strcmp(event_tag_directive->prefix, model_tag_directive->prefix)) 
     58                    return 0; 
     59            } 
     60            break; 
    3661 
    3762        case YAML_ALIAS_EVENT: 
    38             return yaml_alias_event_initialize(event_to, 
    39                     event_from->data.alias.anchor); 
     63            event_anchor = event->data.alias.anchor; 
     64            model_anchor = model->data.alias.anchor; 
     65            break; 
    4066 
    4167        case YAML_SCALAR_EVENT: 
    42             return yaml_scalar_event_initialize(event_to, 
    43                     event_from->data.scalar.anchor, 
    44                     event_from->data.scalar.tag, 
    45                     event_from->data.scalar.value, 
    46                     event_from->data.scalar.length, 
    47                     event_from->data.scalar.plain_implicit, 
    48                     event_from->data.scalar.quoted_implicit, 
    49                     event_from->data.scalar.style); 
     68            event_anchor = event->data.scalar.anchor; 
     69            model_anchor = model->data.scalar.anchor; 
     70            event_tag = event->data.scalar.tag; 
     71            model_tag = model->data.scalar.tag; 
     72            event_value = event->data.scalar.value; 
     73            model_value = model->data.scalar.value; 
     74            event_length = event->data.scalar.length; 
     75            model_length = model->data.scalar.length; 
     76            if (event->data.scalar.is_plain_implicit != 
     77                    model->data.scalar.is_plain_implicit) 
     78                return 0; 
     79            if (event->data.scalar.is_quoted_implicit != 
     80                    model->data.scalar.is_quoted_implicit) 
     81                return 0; 
     82            break; 
    5083 
    5184        case YAML_SEQUENCE_START_EVENT: 
    52             return yaml_sequence_start_event_initialize(event_to, 
    53                     event_from->data.sequence_start.anchor, 
    54                     event_from->data.sequence_start.tag, 
    55                     event_from->data.sequence_start.implicit, 
    56                     event_from->data.sequence_start.style); 
    57  
    58         case YAML_SEQUENCE_END_EVENT: 
    59             return yaml_sequence_end_event_initialize(event_to); 
     85            event_anchor = event->data.sequence_start.anchor; 
     86            model_anchor = model->data.sequence_start.anchor; 
     87            event_tag = event->data.sequence_start.tag; 
     88            model_tag = model->data.sequence_start.tag; 
     89            if (event->data.sequence_start.is_implicit != 
     90                    model->data.sequence_start.is_implicit) 
     91                return 0; 
     92            break; 
    6093 
    6194        case YAML_MAPPING_START_EVENT: 
    62             return yaml_mapping_start_event_initialize(event_to, 
    63                     event_from->data.mapping_start.anchor, 
    64                     event_from->data.mapping_start.tag, 
    65                     event_from->data.mapping_start.implicit, 
    66                     event_from->data.mapping_start.style); 
    67  
    68         case YAML_MAPPING_END_EVENT: 
    69             return yaml_mapping_end_event_initialize(event_to); 
     95            event_anchor = event->data.mapping_start.anchor; 
     96            model_anchor = model->data.mapping_start.anchor; 
     97            event_tag = event->data.mapping_start.tag; 
     98            model_tag = model->data.mapping_start.tag; 
     99            if (event->data.mapping_start.is_implicit != 
     100                    model->data.mapping_start.is_implicit) 
     101                return 0; 
     102            break; 
    70103 
    71104        default: 
    72             assert(1); 
    73     } 
    74  
    75     return 0; 
    76 } 
    77  
    78 int compare_events(yaml_event_t *event1, yaml_event_t *event2) 
    79 { 
    80     int k; 
    81  
    82     if (event1->type != event2->type) 
    83         return 0; 
    84  
    85     switch (event1->type) 
    86     { 
    87         case YAML_STREAM_START_EVENT: 
    88             return 1; 
    89             /* return (event1->data.stream_start.encoding == 
    90                     event2->data.stream_start.encoding); */ 
    91  
    92         case YAML_DOCUMENT_START_EVENT: 
    93             if ((event1->data.document_start.version_directive && !event2->data.document_start.version_directive) 
    94                     || (!event1->data.document_start.version_directive && event2->data.document_start.version_directive) 
    95                     || (event1->data.document_start.version_directive && event2->data.document_start.version_directive 
    96                         && (event1->data.document_start.version_directive->major != event2->data.document_start.version_directive->major 
    97                             || event1->data.document_start.version_directive->minor != event2->data.document_start.version_directive->minor))) 
    98                 return 0; 
    99             if ((event1->data.document_start.tag_directives.end - event1->data.document_start.tag_directives.start) != 
    100                     (event2->data.document_start.tag_directives.end - event2->data.document_start.tag_directives.start)) 
    101                 return 0; 
    102             for (k = 0; k < (event1->data.document_start.tag_directives.end - event1->data.document_start.tag_directives.start); k ++) { 
    103                 if ((strcmp((char *)event1->data.document_start.tag_directives.start[k].handle, 
    104                                 (char *)event2->data.document_start.tag_directives.start[k].handle) != 0) 
    105                         || (strcmp((char *)event1->data.document_start.tag_directives.start[k].prefix, 
    106                             (char *)event2->data.document_start.tag_directives.start[k].prefix) != 0)) 
    107                     return 0; 
    108             } 
    109             /* if (event1->data.document_start.implicit != event2->data.document_start.implicit) 
    110                 return 0; */ 
    111             return 1; 
    112  
    113         case YAML_DOCUMENT_END_EVENT: 
    114             return 1; 
    115             /* return (event1->data.document_end.implicit == 
    116                     event2->data.document_end.implicit); */ 
    117  
    118         case YAML_ALIAS_EVENT: 
    119             return (strcmp((char *)event1->data.alias.anchor, 
    120                         (char *)event2->data.alias.anchor) == 0); 
    121  
    122         case YAML_SCALAR_EVENT: 
    123             if ((event1->data.scalar.anchor && !event2->data.scalar.anchor) 
    124                     || (!event1->data.scalar.anchor && event2->data.scalar.anchor) 
    125                     || (event1->data.scalar.anchor && event2->data.scalar.anchor 
    126                         && strcmp((char *)event1->data.scalar.anchor, 
    127                             (char *)event2->data.scalar.anchor) != 0)) 
    128                 return 0; 
    129             if ((event1->data.scalar.tag && !event2->data.scalar.tag 
    130                         && strcmp((char *)event1->data.scalar.tag, "!") != 0) 
    131                     || (!event1->data.scalar.tag && event2->data.scalar.tag 
    132                         && strcmp((char *)event2->data.scalar.tag, "!") != 0) 
    133                     || (event1->data.scalar.tag && event2->data.scalar.tag 
    134                         && strcmp((char *)event1->data.scalar.tag, 
    135                             (char *)event2->data.scalar.tag) != 0)) 
    136                 return 0; 
    137             if ((event1->data.scalar.length != event2->data.scalar.length) 
    138                     || memcmp(event1->data.scalar.value, event2->data.scalar.value, 
    139                         event1->data.scalar.length) != 0) 
    140                 return 0; 
    141             if ((event1->data.scalar.plain_implicit != event2->data.scalar.plain_implicit) 
    142                     || (event2->data.scalar.quoted_implicit != event2->data.scalar.quoted_implicit) 
    143                     /* || (event2->data.scalar.style != event2->data.scalar.style) */) 
    144                 return 0; 
    145             return 1; 
    146  
    147         case YAML_SEQUENCE_START_EVENT: 
    148             if ((event1->data.sequence_start.anchor && !event2->data.sequence_start.anchor) 
    149                     || (!event1->data.sequence_start.anchor && event2->data.sequence_start.anchor) 
    150                     || (event1->data.sequence_start.anchor && event2->data.sequence_start.anchor 
    151                         && strcmp((char *)event1->data.sequence_start.anchor, 
    152                             (char *)event2->data.sequence_start.anchor) != 0)) 
    153                 return 0; 
    154             if ((event1->data.sequence_start.tag && !event2->data.sequence_start.tag) 
    155                     || (!event1->data.sequence_start.tag && event2->data.sequence_start.tag) 
    156                     || (event1->data.sequence_start.tag && event2->data.sequence_start.tag 
    157                         && strcmp((char *)event1->data.sequence_start.tag, 
    158                             (char *)event2->data.sequence_start.tag) != 0)) 
    159                 return 0; 
    160             if ((event1->data.sequence_start.implicit != event2->data.sequence_start.implicit) 
    161                     /* || (event2->data.sequence_start.style != event2->data.sequence_start.style) */) 
    162                 return 0; 
    163             return 1; 
    164  
    165         case YAML_MAPPING_START_EVENT: 
    166             if ((event1->data.mapping_start.anchor && !event2->data.mapping_start.anchor) 
    167                     || (!event1->data.mapping_start.anchor && event2->data.mapping_start.anchor) 
    168                     || (event1->data.mapping_start.anchor && event2->data.mapping_start.anchor 
    169                         && strcmp((char *)event1->data.mapping_start.anchor, 
    170                             (char *)event2->data.mapping_start.anchor) != 0)) 
    171                 return 0; 
    172             if ((event1->data.mapping_start.tag && !event2->data.mapping_start.tag) 
    173                     || (!event1->data.mapping_start.tag && event2->data.mapping_start.tag) 
    174                     || (event1->data.mapping_start.tag && event2->data.mapping_start.tag 
    175                         && strcmp((char *)event1->data.mapping_start.tag, 
    176                             (char *)event2->data.mapping_start.tag) != 0)) 
    177                 return 0; 
    178             if ((event1->data.mapping_start.implicit != event2->data.mapping_start.implicit) 
    179                     /* || (event2->data.mapping_start.style != event2->data.mapping_start.style) */) 
    180                 return 0; 
    181             return 1; 
    182  
    183         default: 
    184             return 1; 
    185     } 
     105            break; 
     106    } 
     107 
     108    if (!event_anchor != !model_anchor) 
     109        return 0; 
     110    if (event_anchor && strcmp(event_anchor, model_anchor)) 
     111        return 0; 
     112 
     113    if (event_tag && !strcmp(event_tag, "!")) 
     114        event_tag = NULL; 
     115    if (model_tag && !strcmp(model_tag, "!")) 
     116        model_tag = NULL; 
     117    if (!event_tag != !model_tag) 
     118        return 0; 
     119    if (event_tag && strcmp(event_tag, model_tag)) 
     120        return 0; 
     121 
     122    if (event_length != model_length) 
     123        return 0; 
     124    if (event_length && memcmp(event_value, model_value, event_length)) 
     125        return 0; 
     126 
     127    return 1; 
    186128} 
    187129 
    …… 
    214156main(int argc, char *argv[]) 
    215157{ 
    216     int number; 
    217     int canonical = 0; 
    218     int unicode = 0; 
    219  
    220     number = 1; 
    221     while (number < argc) { 
    222         if (strcmp(argv[number], "-c") == 0) { 
    223             canonical = 1; 
    224         } 
    225         else if (strcmp(argv[number], "-u") == 0) { 
    226             unicode = 1; 
    227         } 
    228         else if (argv[number][0] == '-') { 
    229             printf("Unknown option: '%s'\n", argv[number]); 
     158    int idx; 
     159    int is_canonical = 0; 
     160    int is_unicode = 0; 
     161 
     162    idx = 1; 
     163    while (idx < argc) { 
     164        if (strcmp(argv[idx], "-c") == 0) { 
     165            is_canonical = 1; 
     166        } 
     167        else if (strcmp(argv[idx], "-u") == 0) { 
     168            is_unicode = 1; 
     169        } 
     170        else if (argv[idx][0] == '-') { 
     171            printf("Unknown option: '%s'\n", argv[idx]); 
    230172            return 0; 
    231173        } 
    232         if (argv[number][0] == '-') { 
    233             if (number < argc-1) { 
    234                 memmove(argv+number, argv+number+1, (argc-number-1)*sizeof(char *)); 
     174        if (argv[idx][0] == '-') { 
     175            if (idx < argc-1) { 
     176                memmove(argv+idx, argv+idx+1, (argc-idx-1)*sizeof(char *)); 
    235177            } 
    236178            argc --; 
    237179        } 
    238180        else { 
    239             number ++; 
     181            idx ++; 
    240182        } 
    241183    } 
    …… 
    246188    } 
    247189 
    248     for (number = 1; number < argc; number ++) 
     190    for (idx = 1; idx < argc; idx ++) 
    249191    { 
    250192        FILE *file; 
    251         yaml_parser_t parser; 
    252         yaml_emitter_t emitter; 
     193        yaml_parser_t *parser; 
     194        yaml_emitter_t *emitter; 
    253195        yaml_event_t event; 
    254196        unsigned char buffer[BUFFER_SIZE]; 
    …… 
    256198        yaml_event_t events[MAX_EVENTS]; 
    257199        size_t event_number = 0; 
    258         int done = 0; 
    259200        int count = 0; 
    260         int error = 0; 
    261         int k; 
     201        int failed = 0; 
     202 
    262203        memset(buffer, 0, BUFFER_SIZE); 
    263204        memset(events, 0, MAX_EVENTS*sizeof(yaml_event_t)); 
    264205 
    265         printf("[%d] Parsing, emitting, and parsing again '%s': ", number, argv[number]); 
     206        printf("[%d] Parsing, emitting, and parsing again '%s': ", idx, argv[idx]); 
    266207        fflush(stdout); 
    267208 
    268         file = fopen(argv[number], "rb"); 
     209        file = fopen(argv[idx], "rb"); 
    269210        assert(file); 
    270211 
    271         assert(yaml_parser_initialize(&parser)); 
    272         yaml_parser_set_input_file(&parser, file); 
    273         assert(yaml_emitter_initialize(&emitter)); 
    274         if (canonical) { 
    275             yaml_emitter_set_canonical(&emitter, 1); 
    276         } 
    277         if (unicode) { 
    278             yaml_emitter_set_unicode(&emitter, 1); 
    279         } 
    280         yaml_emitter_set_output_string(&emitter, buffer, BUFFER_SIZE, &written); 
    281  
    282         while (!done) 
     212        parser = yaml_parser_new(); 
     213        assert(parser); 
     214 
     215        yaml_parser_set_file_reader(parser, file); 
     216 
     217        emitter = yaml_emitter_new(); 
     218        assert(emitter); 
     219 
     220        if (is_canonical) { 
     221            yaml_emitter_set_canonical(emitter, 1); 
     222        } 
     223        if (is_unicode) { 
     224            yaml_emitter_set_unicode(emitter, 1); 
     225        } 
     226        yaml_emitter_set_string_writer(emitter, buffer, BUFFER_SIZE, &written); 
     227 
     228        while (1) 
    283229        { 
    284             if (!yaml_parser_parse(&parser, &event)) { 
    285                 error = 1; 
     230            if (!yaml_parser_parse_event(parser, &event)) 
     231                failed = 1; 
     232 
     233            if (!event.type) 
    286234                break; 
    287             } 
    288  
    289             done = (event.type == YAML_STREAM_END_EVENT); 
     235 
    290236            assert(event_number < MAX_EVENTS); 
    291             assert(copy_event(&(events[event_number++]), &event)); 
    292             assert(yaml_emitter_emit(&emitter, &event) ||  
    293                     (yaml_emitter_flush(&emitter) && print_output(argv[number], buffer, written, count))); 
     237            yaml_event_duplicate(&(events[event_number++]), &event); 
     238            assert(yaml_emitter_emit_event(emitter, &event) ||  
     239                    (yaml_emitter_flush(emitter) && 
     240                     print_output(argv[idx], buffer, written, count))); 
    294241            count ++; 
    295242        } 
    296243 
    297         yaml_parser_delete(&parser); 
    298         assert(!fclose(file)); 
    299         yaml_emitter_delete(&emitter); 
    300  
    301         if (!error) 
     244        yaml_parser_delete(parser); 
     245        fclose(file); 
     246        yaml_emitter_delete(emitter); 
     247 
     248        if (!failed) 
    302249        { 
    303             count = done = 0; 
    304             assert(yaml_parser_initialize(&parser)); 
    305             yaml_parser_set_input_string(&parser, buffer, written); 
    306  
    307             while (!done) 
     250            count = 0; 
     251            parser = yaml_parser_new(); 
     252            yaml_parser_set_string_reader(parser, buffer, written); 
     253 
     254            while (1) 
    308255            { 
    309                 assert(yaml_parser_parse(&parser, &event) || print_output(argv[number], buffer, written, count)); 
    310                 done = (event.type == YAML_STREAM_END_EVENT); 
    311                 assert(compare_events(events+count, &event) || print_output(argv[number], buffer, written, count)); 
    312                 yaml_event_delete(&event); 
     256                assert(yaml_parser_parse_event(parser, &event) || 
     257                        print_output(argv[idx], buffer, written, count)); 
     258                if (!event.type) 
     259                    break; 
     260                assert(compare_events(events+count, &event) || 
     261                        print_output(argv[idx], buffer, written, count)); 
     262                yaml_event_destroy(&event); 
    313263                count ++; 
    314264            } 
    315             yaml_parser_delete(&parser); 
    316         } 
    317  
    318         for (k = 0; k < event_number; k ++) { 
    319             yaml_event_delete(events+k); 
     265            yaml_parser_delete(parser); 
     266        } 
     267 
     268        while(event_number) { 
     269            yaml_event_destroy(events+(--event_number)); 
    320270        } 
    321271 
    322272        printf("PASSED (length: %d)\n", written); 
    323         print_output(argv[number], buffer, written, -1); 
     273        print_output(argv[idx], buffer, written, -1); 
    324274    } 
    325275 

  • libyaml/trunk/tests/run-loader.c

    r242 r265  
    1212main(int argc, char *argv[]) 
    1313{ 
     14#if 0 
    1415    int number; 
    1516 
    …… 
    5960    } 
    6061 
     62#endif 
    6163    return 0; 
    6264} 

  • libyaml/trunk/tests/run-parser.c

    r242 r265  
    1212main(int argc, char *argv[]) 
    1313{ 
    14     int number; 
     14    int idx; 
    1515 
    1616    if (argc < 2) { 
    …… 
    1919    } 
    2020 
    21     for (number = 1; number < argc; number ++) 
     21    for (idx = 1; idx < argc; idx ++) 
    2222    { 
    2323        FILE *file; 
    24         yaml_parser_t parser; 
     24        yaml_parser_t *parser; 
    2525        yaml_event_t event; 
    26         int done = 0; 
     26        int failed = 0; 
    2727        int count = 0; 
    28         int error = 0; 
    2928 
    30         printf("[%d] Parsing '%s': ", number, argv[number]); 
     29        printf("[%d] Parsing '%s': ", idx, argv[idx]); 
    3130        fflush(stdout); 
    3231 
    33         file = fopen(argv[number], "rb"); 
     32        file = fopen(argv[idx], "rb"); 
    3433        assert(file); 
    3534 
    36         assert(yaml_parser_initialize(&parser)); 
     35        parser = yaml_parser_new(); 
     36        assert(parser); 
    3737 
    38         yaml_parser_set_input_file(&parser, file); 
     38        yaml_parser_set_file_reader(parser, file); 
    3939 
    40         while (!done) 
     40        while (1) 
    4141        { 
    42             if (!yaml_parser_parse(&parser, &event)) { 
    43                 error = 1; 
     42            if (!yaml_parser_parse_event(parser, &event)) { 
     43                failed = 1; 
    4444                break; 
    4545            } 
    4646 
    47             done = (event.type == YAML_STREAM_END_EVENT); 
     47            if (event.type == YAML_NO_EVENT) 
     48                break; 
    4849 
    49             yaml_event_delete(&event); 
     50            yaml_event_destroy(&event); 
    5051 
    5152            count ++; 
    5253        } 
    5354 
    54         yaml_parser_delete(&parser); 
     55        if (!failed) { 
     56            printf("SUCCESS (%d tokens)\n", count); 
     57        } 
     58        else { 
     59            yaml_error_t error; 
     60            char message[256]; 
     61            yaml_parser_get_error(parser, &error); 
     62            yaml_error_message(&error, message, 256); 
     63            printf("FAILURE (%d events)\n -> %s\n", count, message); 
     64        } 
    5565 
    56         assert(!fclose(file)); 
     66        yaml_parser_delete(parser); 
    5767 
    58         printf("%s (%d events)\n", (error ? "FAILURE" : "SUCCESS"), count); 
     68        fclose(file); 
    5969    } 
    6070 

  • libyaml/trunk/tests/run-scanner.c

    r264 r265  
    1212main(int argc, char *argv[]) 
    1313{ 
    14     int number; 
     14    int idx; 
    1515 
    1616    if (argc < 2) { 
    …… 
    1919    } 
    2020 
    21     for (number = 1; number < argc; number ++) 
     21    for (idx = 1; idx < argc; idx ++) 
    2222    { 
    2323        FILE *file; 
    2424        yaml_parser_t *parser; 
    2525        yaml_token_t token; 
    26         yaml_error_t error; 
    27         char error_buffer[256]; 
    28         int done = 0; 
     26        int failed = 0; 
    2927        int count = 0; 
    30         int failed = 0; 
    3128 
    32         printf("[%d] Scanning '%s': ", number, argv[number]); 
     29        printf("[%d] Scanning '%s': ", idx, argv[idx]); 
    3330        fflush(stdout); 
    3431 
    35         file = fopen(argv[number], "rb"); 
     32        file = fopen(argv[idx], "rb"); 
    3633        assert(file); 
    3734 
    38         assert((parser = yaml_parser_new())); 
     35        parser = yaml_parser_new(); 
     36        assert(parser); 
    3937 
    4038        yaml_parser_set_file_reader(parser, file); 
    4139 
    42         while (!done) 
     40        while (1) 
    4341        { 
    4442            if (!yaml_parser_parse_token(parser, &token)) { 
    …… 
    4745            } 
    4846 
    49             done = (token.type == YAML_STREAM_END_TOKEN); 
     47            if (token.type == YAML_NO_TOKEN) 
     48                break; 
    5049 
    5150            yaml_token_destroy(&token); 
    …… 
    5453        } 
    5554 
    56         yaml_parser_get_error(parser, &error); 
     55        if (!failed) { 
     56            printf("SUCCESS (%d tokens)\n", count); 
     57        } 
     58        else { 
     59            yaml_error_t error; 
     60            char message[256]; 
     61            yaml_parser_get_error(parser, &error); 
     62            yaml_error_message(&error, message, 256); 
     63            printf("FAILURE (%d tokens)\n -> %s\n", count, message); 
     64        } 
    5765 
    5866        yaml_parser_delete(parser); 
    5967 
    60         assert(!fclose(file)); 
     68        fclose(file); 
    6169 
    62         yaml_error_message(&error, error_buffer, 256); 
    63  
    64         printf("%s (%d tokens) -> %s\n", 
    65                 (failed ? "FAILURE" : "SUCCESS"), 
    66                 count, error_buffer); 
    6770    } 
    6871