Ignore:
Timestamp:
06/19/06 16:27:22 (9 years ago)
Author:
xi
Message:

Fix numerous bugs in the Scanner.

File:
1 edited

Legend:

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

    r190 r194  
    10121012 
    10131013    parser->tokens[parser->tokens_head++] = NULL; 
    1014     if (parser->tokens_head == parser->tokens_size) 
    1015         parser->tokens_head = 0; 
    10161014 
    10171015    parser->tokens_parsed++; 
     1016 
     1017    if (token->type == YAML_STREAM_END_TOKEN) { 
     1018        parser->stream_end_produced = 1; 
     1019    } 
    10181020 
    10191021    return token; 
     
    10811083    memset(new_buffer+string->size, 0, string->size); 
    10821084 
    1083     string->pointer = new_buffer + (string->buffer-string->pointer); 
     1085    string->pointer = new_buffer + (string->pointer-string->buffer); 
    10841086    string->buffer = new_buffer; 
    10851087    string->size *= 2; 
     
    11041106 
    11051107    memcpy(string1->pointer, string2->buffer, string2->pointer-string2->buffer); 
     1108    string1->pointer += string2->pointer-string2->buffer; 
    11061109 
    11071110    return 1; 
     
    11391142    } 
    11401143 
    1141     memset(new_buffer+(*size), 0, item_size*(*size)); 
     1144    memset(new_buffer+item_size*(*size), 0, item_size*(*size)); 
    11421145 
    11431146    *buffer = new_buffer; 
     
    11601163    parser->problem = problem; 
    11611164    parser->problem_mark = yaml_parser_get_mark(parser); 
     1165 
     1166    return 0; 
    11621167} 
    11631168 
     
    12051210        { 
    12061211            /* Check if any potential simple key may occupy the head position. */ 
     1212 
     1213            if (!yaml_parser_stale_simple_keys(parser)) 
     1214                return 0; 
    12071215 
    12081216            for (k = 0; k <= parser->flow_level; k++) { 
     
    12521260        return 0; 
    12531261 
     1262    /* Remove obsolete potential simple keys. */ 
     1263 
     1264    if (!yaml_parser_stale_simple_keys(parser)) 
     1265        return 0; 
     1266 
    12541267    /* Check the indentation level against the current column. */ 
    12551268 
     
    13311344    /* Is it the key indicator? */ 
    13321345 
    1333     if (CHECK(parser, '?') && (!parser->flow_level || IS_BLANKZ_AT(parser, 1))) 
     1346    if (CHECK(parser, '?') && (parser->flow_level || IS_BLANKZ_AT(parser, 1))) 
    13341347        return yaml_parser_fetch_key(parser); 
    13351348 
    13361349    /* Is it the value indicator? */ 
    13371350 
    1338     if (CHECK(parser, ':') && (!parser->flow_level || IS_BLANKZ_AT(parser, 1))) 
     1351    if (CHECK(parser, ':') && (parser->flow_level || IS_BLANKZ_AT(parser, 1))) 
    13391352        return yaml_parser_fetch_value(parser); 
    13401353 
     
    13831396     *      '%', '@', '`'. 
    13841397     * 
    1385      * In the block context, it may also start with the characters 
     1398     * In the block context (and, for the '-' indicator, in the flow context 
     1399     * too), it may also start with the characters 
    13861400     * 
    13871401     *      '-', '?', ':' 
     
    13991413                || CHECK(parser, '\'') || CHECK(parser, '"') || CHECK(parser, '%') 
    14001414                || CHECK(parser, '@') || CHECK(parser, '`')) || 
     1415            (CHECK(parser, '-') && !IS_BLANK_AT(parser, 1)) || 
    14011416            (!parser->flow_level && 
    1402              (CHECK(parser, '-') || CHECK(parser, '?') || CHECK(parser, ':')) && 
    1403              IS_BLANKZ_AT(parser, 1))) 
     1417             (CHECK(parser, '?') || CHECK(parser, ':')) && !IS_BLANKZ_AT(parser, 1))) 
    14041418        return yaml_parser_fetch_plain_scalar(parser); 
    14051419 
     
    14361450 
    14371451        if (simple_key && (simple_key->line < parser->line || 
    1438                     simple_key->index < parser->index+1024)) { 
     1452                    simple_key->index+1024 < parser->index)) { 
    14391453 
    14401454            /* Check if the potential simple key to be removed is required. */ 
     
    17901804        return 0; 
    17911805 
    1792     /* We have finished. */ 
    1793  
    1794     parser->stream_end_produced = 1; 
     1806    /* Reset simple keys. */ 
     1807 
     1808    if (!yaml_parser_remove_simple_key(parser)) 
     1809        return 0; 
     1810 
     1811    parser->simple_key_allowed = 0; 
    17951812 
    17961813    /* Create the STREAM-END token. */ 
     
    22052222        /* In the block context, we may need to add the BLOCK-MAPPING-START token. */ 
    22062223 
    2207         if (!yaml_parser_roll_indent(parser, parser->column, 
     2224        if (!yaml_parser_roll_indent(parser, simple_key->column, 
    22082225                    simple_key->token_number, 
    22092226                    YAML_BLOCK_MAPPING_START_TOKEN, simple_key->mark)) 
     
    29903007            handle[0] = '!'; 
    29913008            handle[1] = '\0'; 
     3009 
     3010            /* 
     3011             * A special case: the '!' tag. 
     3012             */ 
     3013 
     3014            if (suffix[0] == '\0') { 
     3015                yaml_char_t *tmp = handle; 
     3016                handle = suffix; 
     3017                suffix = tmp; 
     3018            } 
    29923019        } 
    29933020    } 
     
    30693096    { 
    30703097        /* 
    3071          * It's not really a tag handle.  If it's a %TAG directive, it's an 
    3072          * error.  If it's a tag token, it must be a part of URI. 
     3098         * It's either the '!' tag or not really a tag handle.  If it's a %TAG 
     3099         * directive, it's an error.  If it's a tag token, it must be a part of 
     3100         * URI. 
    30733101         */ 
    30743102 
    3075         if (directive) { 
    3076             yaml_parser_set_scanner_error(parser, "while parsing a directive", 
     3103        if (directive && !(string.buffer[0] == '!' && string.buffer[1] == '\0')) { 
     3104            yaml_parser_set_scanner_error(parser, "while parsing a tag directive", 
    30773105                    start_mark, "did not find expected '!'"); 
    30783106            goto error; 
     
    31083136    } 
    31093137 
    3110     /* Copy the head if needed. */ 
    3111  
    3112     if (length) { 
    3113         memcpy(string.buffer, head, length); 
    3114         string.pointer += length; 
     3138    /* 
     3139     * Copy the head if needed. 
     3140     * 
     3141     * Note that we don't copy the leading '!' character. 
     3142     */ 
     3143 
     3144    if (length > 1) { 
     3145        memcpy(string.buffer, head+1, length-1); 
     3146        string.pointer += length-1; 
    31153147    } 
    31163148 
     
    36733705                        break; 
    36743706 
     3707                    case '\\': 
     3708                        *(string.pointer++) = '\\'; 
     3709                        break; 
     3710 
    36753711                    case 'N':   /* NEL (#x85) */ 
    36763712                        *(string.pointer++) = '\xC2'; 
     
    36923728                        *(string.pointer++) = '\xE2'; 
    36933729                        *(string.pointer++) = '\x80'; 
    3694                         *(string.pointer++) = '\xA8'; 
     3730                        *(string.pointer++) = '\xA9'; 
    36953731                        break; 
    36963732 
     
    38013837                    COPY(parser, whitespaces); 
    38023838                } 
     3839                else { 
     3840                    FORWARD(parser); 
     3841                } 
    38033842            } 
    38043843            else 
     
    39323971        while (!IS_BLANKZ(parser)) 
    39333972        { 
    3934             /* Check for 'x:x' in the flow context. */ 
     3973            /* Check for 'x:x' in the flow context. TODO: Fix the test "spec-08-13". */ 
    39353974 
    39363975            if (parser->flow_level && CHECK(parser, ':') && !IS_BLANKZ_AT(parser, 1)) { 
     
    40114050                    yaml_parser_set_scanner_error(parser, "while scanning a plain scalar", 
    40124051                            start_mark, "found a tab character that violate intendation"); 
    4013                     break; 
     4052                    goto error; 
    40144053                } 
    40154054 
     
    40194058                    if (!RESIZE(parser, whitespaces)) goto error; 
    40204059                    COPY(parser, whitespaces); 
     4060                } 
     4061                else { 
     4062                    FORWARD(parser); 
    40214063                } 
    40224064            } 
     
    40444086        /* Check intendation level. */ 
    40454087 
    4046         if (parser->column < indent) 
     4088        if (!parser->flow_level && parser->column < indent) 
    40474089            break; 
    40484090    } 
Note: See TracChangeset for help on using the changeset viewer.