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/emitter.c

    r263 r264  
    1414 */ 
    1515 
    16 #define PUT(emitter,value)                                                      \ 
     16#define PUT(emitter, value)                                                     \ 
    1717    (FLUSH(emitter)                                                             \ 
    18      && (JOIN_OCTET(emitter->output,(yaml_char_t)(value)),                      \ 
     18     && (JOIN_OCTET(emitter->output, (yaml_char_t)(value)),                     \ 
    1919         emitter->column ++,                                                    \ 
    2020         1)) 
     
    4141 */ 
    4242 
    43 #define WRITE(emitter,string)                                                   \ 
     43#define WRITE(emitter, string)                                                  \ 
    4444    (FLUSH(emitter)                                                             \ 
    45      && (COPY(emitter->output,string),                                          \ 
     45     && (COPY(emitter->output, string),                                         \ 
    4646         emitter->column ++,                                                    \ 
    4747         1)) 
     
    5151 */ 
    5252 
    53 #define WRITE_BREAK(emitter,string)                                             \ 
     53#define WRITE_BREAK(emitter, string)                                            \ 
    5454    (FLUSH(emitter)                                                             \ 
    55      && (CHECK(string,'\n') ?                                                   \ 
     55     && (CHECK(string, '\n') ?                                                  \ 
    5656         (PUT_BREAK(emitter),                                                   \ 
    5757          string.pointer ++,                                                    \ 
    5858          1) :                                                                  \ 
    59          (COPY(emitter->output,string),                                         \ 
     59         (COPY(emitter->output, string),                                        \ 
    6060          emitter->column = 0,                                                  \ 
    6161          emitter->line ++,                                                     \ 
     
    6767 
    6868YAML_DECLARE(int) 
    69 yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event); 
     69yaml_emitter_emit_event(yaml_emitter_t *emitter, yaml_event_t *event); 
    7070 
    7171/* 
     
    219219static int 
    220220yaml_emitter_write_indicator(yaml_emitter_t *emitter, 
    221         char *indicator, int need_whitespace, 
     221        const char *indicator, int need_whitespace, 
    222222        int is_whitespace, int is_indention); 
    223223 
    224224static int 
    225225yaml_emitter_write_anchor(yaml_emitter_t *emitter, 
    226         yaml_char_t *value, size_t length); 
     226        const yaml_char_t *value, size_t length); 
    227227 
    228228static int 
    229229yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, 
    230         yaml_char_t *value, size_t length); 
     230        const yaml_char_t *value, size_t length); 
    231231 
    232232static int 
    233233yaml_emitter_write_tag_content(yaml_emitter_t *emitter, 
    234         yaml_char_t *value, size_t length, int need_whitespace); 
     234        const yaml_char_t *value, size_t length, int need_whitespace); 
    235235 
    236236static int 
    237237yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, 
    238         yaml_char_t *value, size_t length, int allow_breaks); 
     238        const yaml_char_t *value, size_t length, int allow_breaks); 
    239239 
    240240static int 
    241241yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, 
    242         yaml_char_t *value, size_t length, int allow_breaks); 
     242        const yaml_char_t *value, size_t length, int allow_breaks); 
    243243 
    244244static int 
    245245yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, 
    246         yaml_char_t *value, size_t length, int allow_breaks); 
     246        const yaml_char_t *value, size_t length, int allow_breaks); 
    247247 
    248248static int 
    249249yaml_emitter_determine_chomping(yaml_emitter_t *emitter, 
    250         yaml_string_t string); 
     250        yaml_istring_t string); 
    251251 
    252252static int 
    253253yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, 
    254         yaml_char_t *value, size_t length); 
     254        const yaml_char_t *value, size_t length); 
    255255 
    256256static int 
    257257yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, 
    258         yaml_char_t *value, size_t length); 
     258        const yaml_char_t *value, size_t length); 
    259259 
    260260/* 
     
    263263 
    264264YAML_DECLARE(int) 
    265 yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event) 
     265yaml_emitter_emit_event(yaml_emitter_t *emitter, yaml_event_t *event) 
    266266{ 
    267267    if (!ENQUEUE(emitter, emitter->events, *event)) { 
     
    468468 
    469469        default: 
    470             assert(1);      /* Invalid state. */ 
     470            assert(0);      /* Invalid state. */ 
    471471    } 
    472472 
     
    12871287 
    12881288        default: 
    1289             assert(1);      /* Impossible. */ 
     1289            assert(0);      /* Impossible. */ 
    12901290    } 
    12911291 
     
    13161316        yaml_tag_directive_t tag_directive) 
    13171317{ 
    1318     yaml_string_t handle = STRING(tag_directive.handle, 
     1318    yaml_istring_t handle = ISTRING(tag_directive.handle, 
    13191319            strlen((char *)tag_directive.handle)); 
    1320     yaml_string_t prefix = STRING(tag_directive.prefix, 
     1320    yaml_istring_t prefix = ISTRING(tag_directive.prefix, 
    13211321            strlen((char *)tag_directive.prefix)); 
    13221322 
    1323     if (!handle.capacity) { 
     1323    if (!handle.length) { 
    13241324        return EMITTER_ERROR_INIT(emitter, "tag handle must not be empty"); 
    13251325    } 
     
    13291329    } 
    13301330 
    1331     if (handle.buffer[handle.capacity-1] != '!') { 
     1331    if (handle.buffer[handle.length-1] != '!') { 
    13321332        return EMITTER_ERROR_INIT(emitter, "tag handle must end with '!'"); 
    13331333    } 
     
    13351335    handle.pointer ++; 
    13361336 
    1337     while (handle.pointer < handle.capacity-1) { 
     1337    while (handle.pointer < handle.length-1) { 
    13381338        if (!IS_ALPHA(handle)) { 
    13391339            return EMITTER_ERROR_INIT(emitter, 
     
    13431343    } 
    13441344 
    1345     if (!prefix.capacity) { 
     1345    if (!prefix.length) { 
    13461346        return EMITTER_ERROR_INIT(emitter, "tag prefix must not be empty"); 
    13471347    } 
     
    13581358        yaml_char_t *anchor, int is_alias) 
    13591359{ 
    1360     yaml_string_t string = STRING(anchor, strlen((char *)anchor)); 
    1361  
    1362     if (!string.capacity) { 
     1360    yaml_istring_t string = ISTRING(anchor, strlen((char *)anchor)); 
     1361 
     1362    if (!string.length) { 
    13631363        return EMITTER_ERROR_INIT(emitter, is_alias ? 
    13641364                "alias value must not be empty" : 
     
    13661366    } 
    13671367 
    1368     while (string.pointer < string.capacity) { 
     1368    while (string.pointer < string.length) { 
    13691369        if (!IS_ALPHA(string)) { 
    13701370            return EMITTER_ERROR_INIT(emitter, is_alias ? 
     
    13761376 
    13771377    emitter->anchor_data.anchor = string.buffer; 
    1378     emitter->anchor_data.anchor_length = string.capacity; 
     1378    emitter->anchor_data.anchor_length = string.length; 
    13791379    emitter->anchor_data.is_alias = is_alias; 
    13801380 
     
    13901390        yaml_char_t *tag) 
    13911391{ 
    1392     yaml_string_t string = STRING(tag, strlen((char *)tag)); 
     1392    yaml_istring_t string = ISTRING(tag, strlen((char *)tag)); 
    13931393    size_t idx; 
    13941394 
    1395     if (!string.capacity) { 
     1395    if (!string.length) { 
    13961396        return EMITTER_ERROR_INIT(emitter, "tag value must not be empty"); 
    13971397    } 
    13981398 
    13991399    for (idx = 0; idx < emitter->tag_directives.length; idx ++) { 
    1400         yaml_tag_directive_t *tag_directive = emitter->tag_directives.list+idx; 
     1400        yaml_tag_directive_t *tag_directive = 
     1401            STACK_ITER(emitter, emitter->tag_directives, idx); 
    14011402        size_t prefix_length = strlen((char *)tag_directive->prefix); 
    1402         if (prefix_length < string.capacity 
     1403        if (prefix_length < string.length 
    14031404                && strncmp((char *)tag_directive->prefix, (char *)string.buffer, 
    14041405                    prefix_length) == 0) 
     
    14081409                strlen((char *)tag_directive->handle); 
    14091410            emitter->tag_data.suffix = string.buffer + prefix_length; 
    1410             emitter->tag_data.suffix_length = string.capacity - prefix_length; 
     1411            emitter->tag_data.suffix_length = string.length - prefix_length; 
    14111412            return 1; 
    14121413        } 
     
    14141415 
    14151416    emitter->tag_data.suffix = string.buffer; 
    1416     emitter->tag_data.suffix_length = string.capacity; 
     1417    emitter->tag_data.suffix_length = string.length; 
    14171418 
    14181419    return 1; 
     
    14271428        yaml_char_t *value, size_t length) 
    14281429{ 
    1429     yaml_string_t string = STRING(value, length); 
     1430    yaml_istring_t string = ISTRING(value, length); 
    14301431 
    14311432    int block_indicators = 0; 
     
    14531454    emitter->scalar_data.length = length; 
    14541455 
    1455     if (!string.capacity) 
     1456    if (!string.length) 
    14561457    { 
    14571458        emitter->scalar_data.is_multiline = 0; 
     
    14771478    followed_by_space = IS_BLANKZ_AT(string, WIDTH(string)); 
    14781479 
    1479     while (string.pointer < string.capacity) 
     1480    while (string.pointer < string.length) 
    14801481    { 
    14811482        if (!string.pointer) 
     
    15841585        } 
    15851586 
    1586         if ((spaces || breaks) && string.pointer == string.capacity-1) 
     1587        if ((spaces || breaks) && string.pointer == string.length-1) 
    15871588        { 
    15881589            if (spaces && breaks) { 
     
    16051606        preceeded_by_space = IS_BLANKZ(string); 
    16061607        MOVE(string); 
    1607         if (string.pointer < string.capacity) { 
     1608        if (string.pointer < string.length) { 
    16081609            followed_by_space = IS_BLANKZ_AT(string, WIDTH(string)); 
    16091610        } 
     
    17701771static int 
    17711772yaml_emitter_write_indicator(yaml_emitter_t *emitter, 
    1772         char *indicator, int need_whitespace, 
     1773        const char *indicator, int need_whitespace, 
    17731774        int is_whitespace, int is_indention) 
    17741775{ 
    1775     yaml_string_t string = STRING((yaml_char_t *)indicator, strlen(indicator)); 
     1776    yaml_istring_t string = ISTRING((yaml_char_t *)indicator, strlen(indicator)); 
    17761777 
    17771778    if (need_whitespace && !emitter->is_whitespace) { 
     
    17791780    } 
    17801781 
    1781     while (string.pointer < string.capacity) { 
     1782    while (string.pointer < string.length) { 
    17821783        if (!WRITE(emitter, string)) return 0; 
    17831784    } 
     
    17911792static int 
    17921793yaml_emitter_write_anchor(yaml_emitter_t *emitter, 
    1793         yaml_char_t *value, size_t length) 
    1794 { 
    1795     yaml_string_t string = STRING(value, length); 
    1796  
    1797     while (string.pointer < string.capacity) { 
     1794        const yaml_char_t *value, size_t length) 
     1795{ 
     1796    yaml_istring_t string = ISTRING(value, length); 
     1797 
     1798    while (string.pointer < string.length) { 
    17981799        if (!WRITE(emitter, string)) return 0; 
    17991800    } 
     
    18071808static int 
    18081809yaml_emitter_write_tag_handle(yaml_emitter_t *emitter, 
    1809         yaml_char_t *value, size_t length) 
    1810 { 
    1811     yaml_string_t string = STRING(value, length); 
     1810        const yaml_char_t *value, size_t length) 
     1811{ 
     1812    yaml_istring_t string = ISTRING(value, length); 
    18121813 
    18131814    if (!emitter->is_whitespace) { 
     
    18151816    } 
    18161817 
    1817     while (string.pointer < string.capacity) { 
     1818    while (string.pointer < string.length) { 
    18181819        if (!WRITE(emitter, string)) return 0; 
    18191820    } 
     
    18271828static int 
    18281829yaml_emitter_write_tag_content(yaml_emitter_t *emitter, 
    1829         yaml_char_t *value, size_t length, 
     1830        const yaml_char_t *value, size_t length, 
    18301831        int need_whitespace) 
    18311832{ 
    1832     yaml_string_t string = STRING(value, length); 
     1833    yaml_istring_t string = ISTRING(value, length); 
    18331834 
    18341835    if (need_whitespace && !emitter->is_whitespace) { 
     
    18361837    } 
    18371838 
    1838     while (string.pointer < string.capacity) { 
     1839    while (string.pointer < string.length) { 
    18391840        if (IS_ALPHA(string) 
    18401841                || CHECK(string, ';') || CHECK(string, '/') 
     
    18751876static int 
    18761877yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter, 
    1877         yaml_char_t *value, size_t length, int allow_breaks) 
    1878 { 
    1879     yaml_string_t string = STRING(value, length); 
     1878        const yaml_char_t *value, size_t length, int allow_breaks) 
     1879{ 
     1880    yaml_istring_t string = ISTRING(value, length); 
    18801881    int spaces = 0; 
    18811882    int breaks = 0; 
     
    18851886    } 
    18861887 
    1887     while (string.pointer < string.capacity) 
     1888    while (string.pointer < string.length) 
    18881889    { 
    18891890        if (IS_SPACE(string)) 
     
    19291930static int 
    19301931yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter, 
    1931         yaml_char_t *value, size_t length, int allow_breaks) 
    1932 { 
    1933     yaml_string_t string = STRING(value, length); 
     1932        const yaml_char_t *value, size_t length, int allow_breaks) 
     1933{ 
     1934    yaml_istring_t string = ISTRING(value, length); 
    19341935    int spaces = 0; 
    19351936    int breaks = 0; 
     
    19381939        return 0; 
    19391940 
    1940     while (string.pointer < string.capacity) 
     1941    while (string.pointer < string.length) 
    19411942    { 
    19421943        if (IS_SPACE(string)) 
     
    19441945            if (allow_breaks && !spaces 
    19451946                    && emitter->column > emitter->best_width 
    1946                     && string.pointer != 0 
    1947                     && string.pointer != string.capacity - 1 
     1947                    && string.pointer > 0 && string.pointer < string.length 
    19481948                    && !IS_SPACE_AT(string, 1)) { 
    19491949                if (!yaml_emitter_write_indent(emitter)) return 0; 
     
    19901990static int 
    19911991yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter, 
    1992         yaml_char_t *value, size_t length, int allow_breaks) 
    1993 { 
    1994     yaml_string_t string = STRING(value, length); 
     1992        const yaml_char_t *value, size_t length, int allow_breaks) 
     1993{ 
     1994    yaml_istring_t string = ISTRING(value, length); 
    19951995    int spaces = 0; 
    19961996 
     
    19981998        return 0; 
    19991999 
    2000     while (string.pointer < string.capacity) 
     2000    while (string.pointer < string.length) 
    20012001    { 
    20022002        if (!IS_PRINTABLE(string) || (!emitter->is_unicode && !IS_ASCII(string)) 
     
    21132113            if (allow_breaks && !spaces 
    21142114                    && emitter->column > emitter->best_width 
    2115                     && string.pointer != 0 
    2116                     && string.pointer != string.capacity - 1) { 
     2115                    && string.pointer > 0 
     2116                    && string.pointer < string.length) { 
    21172117                if (!yaml_emitter_write_indent(emitter)) return 0; 
    21182118                if (IS_SPACE_AT(string, 1)) { 
     
    21442144static int 
    21452145yaml_emitter_determine_chomping(yaml_emitter_t *emitter, 
    2146         yaml_string_t string) 
    2147 { 
    2148     string.pointer = string.capacity; 
     2146        yaml_istring_t string) 
     2147{ 
     2148    string.pointer = string.length; 
    21492149    if (!string.pointer) 
    21502150        return -1; 
     
    21672167static int 
    21682168yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter, 
    2169         yaml_char_t *value, size_t length) 
    2170 { 
    2171     yaml_string_t string = STRING(value, length); 
     2169        const yaml_char_t *value, size_t length) 
     2170{ 
     2171    yaml_istring_t string = ISTRING(value, length); 
    21722172    int chomp = yaml_emitter_determine_chomping(emitter, string); 
    21732173    int breaks = 0; 
     
    21792179        return 0; 
    21802180 
    2181     while (string.pointer < string.capacity) 
     2181    while (string.pointer < string.length) 
    21822182    { 
    21832183        if (IS_BREAK(string)) 
     
    22032203static int 
    22042204yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter, 
    2205         yaml_char_t *value, size_t length) 
    2206 { 
    2207     yaml_string_t string = STRING(value, length); 
     2205        const yaml_char_t *value, size_t length) 
     2206{ 
     2207    yaml_istring_t string = ISTRING(value, length); 
    22082208    int chomp = yaml_emitter_determine_chomping(emitter, string); 
    22092209    int breaks = 1; 
     
    22162216        return 0; 
    22172217 
    2218     while (string.pointer < string.capacity) 
     2218    while (string.pointer < string.length) 
    22192219    { 
    22202220        if (IS_BREAK(string)) 
Note: See TracChangeset for help on using the changeset viewer.