Ignore:
Timestamp:
12/27/07 12:14:01 (7 years ago)
Author:
xi
Message:

Another round of API update.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libyaml/trunk/src/scanner.c

    r263 r264  
    516516 */ 
    517517 
    518 #define READ(parser,string)                                                     \ 
    519      (STRING_EXTEND(parser,string) ?                                            \ 
    520          (COPY(string,parser->input),                                           \ 
     518#define READ(parser, string)                                                    \ 
     519     (OSTRING_EXTEND(parser, string) ?                                          \ 
     520         (COPY(string, parser->input),                                          \ 
    521521          parser->mark.index ++,                                                \ 
    522522          parser->mark.column ++,                                               \ 
     
    528528 */ 
    529529 
    530 #define READ_LINE(parser,string)                                                \ 
    531     (STRING_EXTEND(parser,string) ?                                             \ 
    532     (((CHECK_AT(parser->input,'\r',0)                                           \ 
    533        && CHECK_AT(parser->input,'\n',1)) ?         /* CR LF -> LF */           \ 
     530#define READ_LINE(parser, string)                                               \ 
     531    (OSTRING_EXTEND(parser, string) ?                                           \ 
     532    (((CHECK_AT(parser->input, '\r', 0)                                         \ 
     533       && CHECK_AT(parser->input, '\n', 1)) ?       /* CR LF -> LF */           \ 
    534534     (JOIN_OCTET(string, (yaml_char_t) '\n'),                                   \ 
    535535      parser->input.pointer += 2,                                               \ 
     
    538538      parser->mark.line ++,                                                     \ 
    539539      parser->unread -= 2) :                                                    \ 
    540      (CHECK_AT(parser->input,'\r',0)                                            \ 
    541       || CHECK_AT(parser->input,'\n',0)) ?          /* CR|LF -> LF */           \ 
    542      (JOIN_OCTET(string,(yaml_char_t) '\n'),                                    \ 
     540     (CHECK_AT(parser->input, '\r', 0)                                          \ 
     541      || CHECK_AT(parser->input, '\n', 0)) ?        /* CR|LF -> LF */           \ 
     542     (JOIN_OCTET(string, (yaml_char_t) '\n'),                                   \ 
    543543      parser->input.pointer ++,                                                 \ 
    544544      parser->mark.index ++,                                                    \ 
     
    546546      parser->mark.line ++,                                                     \ 
    547547      parser->unread --) :                                                      \ 
    548      (CHECK_AT(parser->input,'\xC2',0)                                          \ 
    549       && CHECK_AT(parser->input,'\x85',1)) ?        /* NEL -> LF */             \ 
    550      (JOIN_OCTET(string,(yaml_char_t) '\n'),                                    \ 
     548     (CHECK_AT(parser->input, '\xC2', 0)                                        \ 
     549      && CHECK_AT(parser->input, '\x85', 1)) ?      /* NEL -> LF */             \ 
     550     (JOIN_OCTET(string, (yaml_char_t) '\n'),                                   \ 
    551551      parser->input.pointer += 2,                                               \ 
    552552      parser->mark.index ++,                                                    \ 
     
    554554      parser->mark.line ++,                                                     \ 
    555555      parser->unread --) :                                                      \ 
    556      (CHECK_AT(parser->input,'\xE2',0) &&                                       \ 
    557       CHECK_AT(parser->input,'\x80',1) &&                                       \ 
    558       (CHECK_AT(parser->input,'\xA8',2) ||                                      \ 
    559        CHECK_AT(parser->input,'\xA9',2))) ?         /* LS|PS -> LS|PS */        \ 
    560      (COPY_OCTET(string,parser->input),                                         \ 
    561       COPY_OCTET(string,parser->input),                                         \ 
    562       COPY_OCTET(string,parser->input),                                         \ 
     556     (CHECK_AT(parser->input, '\xE2', 0) &&                                     \ 
     557      CHECK_AT(parser->input, '\x80', 1) &&                                     \ 
     558      (CHECK_AT(parser->input, '\xA8', 2) ||                                    \ 
     559       CHECK_AT(parser->input, '\xA9', 2))) ?       /* LS|PS -> LS|PS */        \ 
     560     (COPY_OCTET(string, parser->input),                                        \ 
     561      COPY_OCTET(string, parser->input),                                        \ 
     562      COPY_OCTET(string, parser->input),                                        \ 
    563563      parser->mark.index ++,                                                    \ 
    564564      parser->mark.column = 0,                                                  \ 
     
    572572 
    573573YAML_DECLARE(int) 
    574 yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token); 
     574yaml_parser_parse_token(yaml_parser_t *parser, yaml_token_t *token); 
    575575 
    576576/* 
     
    709709static int 
    710710yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive, 
    711         yaml_mark_t start_mark, yaml_string_t *string); 
     711        yaml_mark_t start_mark, yaml_ostring_t *string); 
    712712 
    713713static int 
     
    717717static int 
    718718yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser, 
    719         int *indent, yaml_string_t *breaks, 
     719        int *indent, yaml_ostring_t *breaks, 
    720720        yaml_mark_t start_mark, yaml_mark_t *end_mark); 
    721721 
     
    732732 
    733733YAML_DECLARE(int) 
    734 yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) 
     734yaml_parser_parse_token(yaml_parser_t *parser, yaml_token_t *token) 
    735735{ 
    736736    assert(parser); /* Non-NULL parser object is expected. */ 
     
    20932093        yaml_mark_t start_mark, yaml_char_t **name) 
    20942094{ 
    2095     yaml_string_t string = NULL_STRING; 
    2096  
    2097     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2095    yaml_ostring_t string = NULL_OSTRING; 
     2096 
     2097    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    20982098        goto error; 
    20992099 
     
    21312131 
    21322132error: 
    2133     STRING_DEL(parser, string); 
     2133    OSTRING_DEL(parser, string); 
    21342134    return 0; 
    21352135} 
     
    23122312    int length = 0; 
    23132313    yaml_mark_t start_mark, end_mark; 
    2314     yaml_string_t string = NULL_STRING; 
    2315  
    2316     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2314    yaml_ostring_t string = NULL_OSTRING; 
     2315 
     2316    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    23172317        goto error; 
    23182318 
     
    23672367 
    23682368error: 
    2369     STRING_DEL(parser, string); 
     2369    OSTRING_DEL(parser, string); 
    23702370    return 0; 
    23712371} 
     
    24962496        yaml_mark_t start_mark, yaml_char_t **handle) 
    24972497{ 
    2498     yaml_string_t string = NULL_STRING; 
    2499  
    2500     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2498    yaml_ostring_t string = NULL_OSTRING; 
     2499 
     2500    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    25012501        goto error; 
    25022502 
     
    25542554 
    25552555error: 
    2556     STRING_DEL(parser, string); 
     2556    OSTRING_DEL(parser, string); 
    25572557    return 0; 
    25582558} 
     
    25672567{ 
    25682568    size_t length = head ? strlen((char *)head) : 0; 
    2569     yaml_string_t string = NULL_STRING; 
    2570  
    2571     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2569    yaml_ostring_t string = NULL_OSTRING; 
     2570 
     2571    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    25722572        goto error; 
    25732573 
     
    25752575 
    25762576    while (string.capacity <= length) { 
    2577         if (!yaml_string_extend(&string.buffer, &string.capacity)) { 
     2577        if (!yaml_ostring_extend(&string.buffer, &string.capacity)) { 
    25782578            MEMORY_ERROR_INIT(parser); 
    25792579            goto error; 
     
    26332633 
    26342634    if (!length) { 
    2635         if (!STRING_EXTEND(parser, string)) 
     2635        if (!OSTRING_EXTEND(parser, string)) 
    26362636            goto error; 
    26372637 
     
    26472647 
    26482648error: 
    2649     STRING_DEL(parser, string); 
     2649    OSTRING_DEL(parser, string); 
    26502650    return 0; 
    26512651} 
     
    26572657static int 
    26582658yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive, 
    2659         yaml_mark_t start_mark, yaml_string_t *string) 
     2659        yaml_mark_t start_mark, yaml_ostring_t *string) 
    26602660{ 
    26612661    int width = 0; 
     
    27312731    yaml_mark_t start_mark; 
    27322732    yaml_mark_t end_mark; 
    2733     yaml_string_t string = NULL_STRING; 
    2734     yaml_string_t leading_break = NULL_STRING; 
    2735     yaml_string_t trailing_breaks = NULL_STRING; 
     2733    yaml_ostring_t string = NULL_OSTRING; 
     2734    yaml_ostring_t leading_break = NULL_OSTRING; 
     2735    yaml_ostring_t trailing_breaks = NULL_OSTRING; 
    27362736    int chomping = 0; 
    27372737    int increment = 0; 
     
    27402740    int trailing_blank = 0; 
    27412741 
    2742     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     2742    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    27432743        goto error; 
    2744     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
     2744    if (!OSTRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
    27452745        goto error; 
    2746     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
     2746    if (!OSTRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
    27472747        goto error; 
    27482748 
     
    28812881 
    28822882            if (*trailing_breaks.buffer == '\0') { 
    2883                 if (!STRING_EXTEND(parser, string)) goto error; 
     2883                if (!OSTRING_EXTEND(parser, string)) goto error; 
    28842884                JOIN_OCTET(string, ' '); 
    28852885            } 
     
    29352935            start_mark, end_mark); 
    29362936 
    2937     STRING_DEL(parser, leading_break); 
    2938     STRING_DEL(parser, trailing_breaks); 
     2937    OSTRING_DEL(parser, leading_break); 
     2938    OSTRING_DEL(parser, trailing_breaks); 
    29392939 
    29402940    return 1; 
    29412941 
    29422942error: 
    2943     STRING_DEL(parser, string); 
    2944     STRING_DEL(parser, leading_break); 
    2945     STRING_DEL(parser, trailing_breaks); 
     2943    OSTRING_DEL(parser, string); 
     2944    OSTRING_DEL(parser, leading_break); 
     2945    OSTRING_DEL(parser, trailing_breaks); 
    29462946 
    29472947    return 0; 
     
    29552955static int 
    29562956yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser, 
    2957         int *indent, yaml_string_t *breaks, 
     2957        int *indent, yaml_ostring_t *breaks, 
    29582958        yaml_mark_t start_mark, yaml_mark_t *end_mark) 
    29592959{ 
     
    30233023    yaml_mark_t start_mark; 
    30243024    yaml_mark_t end_mark; 
    3025     yaml_string_t string = NULL_STRING; 
    3026     yaml_string_t leading_break = NULL_STRING; 
    3027     yaml_string_t trailing_breaks = NULL_STRING; 
    3028     yaml_string_t whitespaces = NULL_STRING; 
     3025    yaml_ostring_t string = NULL_OSTRING; 
     3026    yaml_ostring_t leading_break = NULL_OSTRING; 
     3027    yaml_ostring_t trailing_breaks = NULL_OSTRING; 
     3028    yaml_ostring_t whitespaces = NULL_OSTRING; 
    30293029    int leading_blanks; 
    30303030 
    3031     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     3031    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    30323032        goto error; 
    3033     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
     3033    if (!OSTRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
    30343034        goto error; 
    3035     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
     3035    if (!OSTRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
    30363036        goto error; 
    3037     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
     3037    if (!OSTRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
    30383038        goto error; 
    30393039 
     
    30893089                    && CHECK_AT(parser->input, '\'', 1)) 
    30903090            { 
    3091                 if (!STRING_EXTEND(parser, string)) goto error; 
     3091                if (!OSTRING_EXTEND(parser, string)) goto error; 
    30923092                JOIN_OCTET(string, '\''); 
    30933093                SKIP(parser); 
     
    31203120                size_t code_length = 0; 
    31213121 
    3122                 if (!STRING_EXTEND(parser, string)) goto error; 
     3122                if (!OSTRING_EXTEND(parser, string)) goto error; 
    31233123 
    31243124                /* Check the escape character. */ 
     
    33423342            if (leading_break.buffer[0] == '\n') { 
    33433343                if (trailing_breaks.buffer[0] == '\0') { 
    3344                     if (!STRING_EXTEND(parser, string)) goto error; 
     3344                    if (!OSTRING_EXTEND(parser, string)) goto error; 
    33453345                    JOIN_OCTET(string, ' '); 
    33463346                } 
     
    33773377            start_mark, end_mark); 
    33783378 
    3379     STRING_DEL(parser, leading_break); 
    3380     STRING_DEL(parser, trailing_breaks); 
    3381     STRING_DEL(parser, whitespaces); 
     3379    OSTRING_DEL(parser, leading_break); 
     3380    OSTRING_DEL(parser, trailing_breaks); 
     3381    OSTRING_DEL(parser, whitespaces); 
    33823382 
    33833383    return 1; 
    33843384 
    33853385error: 
    3386     STRING_DEL(parser, string); 
    3387     STRING_DEL(parser, leading_break); 
    3388     STRING_DEL(parser, trailing_breaks); 
    3389     STRING_DEL(parser, whitespaces); 
     3386    OSTRING_DEL(parser, string); 
     3387    OSTRING_DEL(parser, leading_break); 
     3388    OSTRING_DEL(parser, trailing_breaks); 
     3389    OSTRING_DEL(parser, whitespaces); 
    33903390 
    33913391    return 0; 
     
    34013401    yaml_mark_t start_mark; 
    34023402    yaml_mark_t end_mark; 
    3403     yaml_string_t string = NULL_STRING; 
    3404     yaml_string_t leading_break = NULL_STRING; 
    3405     yaml_string_t trailing_breaks = NULL_STRING; 
    3406     yaml_string_t whitespaces = NULL_STRING; 
     3403    yaml_ostring_t string = NULL_OSTRING; 
     3404    yaml_ostring_t leading_break = NULL_OSTRING; 
     3405    yaml_ostring_t trailing_breaks = NULL_OSTRING; 
     3406    yaml_ostring_t whitespaces = NULL_OSTRING; 
    34073407    int leading_blanks = 0; 
    34083408    int indent = parser->indent+1; 
    34093409 
    3410     if (!STRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
     3410    if (!OSTRING_INIT(parser, string, INITIAL_STRING_CAPACITY)) 
    34113411        goto error; 
    3412     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
     3412    if (!OSTRING_INIT(parser, leading_break, INITIAL_STRING_CAPACITY)) 
    34133413        goto error; 
    3414     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
     3414    if (!OSTRING_INIT(parser, trailing_breaks, INITIAL_STRING_CAPACITY)) 
    34153415        goto error; 
    3416     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
     3416    if (!OSTRING_INIT(parser, whitespaces, INITIAL_STRING_CAPACITY)) 
    34173417        goto error; 
    34183418 
     
    34763476                    if (leading_break.buffer[0] == '\n') { 
    34773477                        if (trailing_breaks.buffer[0] == '\0') { 
    3478                             if (!STRING_EXTEND(parser, string)) goto error; 
     3478                            if (!OSTRING_EXTEND(parser, string)) goto error; 
    34793479                            JOIN_OCTET(string, ' '); 
    34803480                        } 
     
    35803580    } 
    35813581 
    3582     STRING_DEL(parser, leading_break); 
    3583     STRING_DEL(parser, trailing_breaks); 
    3584     STRING_DEL(parser, whitespaces); 
     3582    OSTRING_DEL(parser, leading_break); 
     3583    OSTRING_DEL(parser, trailing_breaks); 
     3584    OSTRING_DEL(parser, whitespaces); 
    35853585 
    35863586    return 1; 
    35873587 
    35883588error: 
    3589     STRING_DEL(parser, string); 
    3590     STRING_DEL(parser, leading_break); 
    3591     STRING_DEL(parser, trailing_breaks); 
    3592     STRING_DEL(parser, whitespaces); 
     3589    OSTRING_DEL(parser, string); 
     3590    OSTRING_DEL(parser, leading_break); 
     3591    OSTRING_DEL(parser, trailing_breaks); 
     3592    OSTRING_DEL(parser, whitespaces); 
    35933593 
    35943594    return 0; 
Note: See TracChangeset for help on using the changeset viewer.