Ignore:
Timestamp:
12/27/07 07:05:17 (6 years ago)
Author:
xi
Message:

Completed the first phase of API refactoring.

File:
1 edited

Legend:

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

    r250 r263  
    4747 
    4848#define PEEK_TOKEN(parser)                                                      \ 
    49     ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ?       \ 
    50         parser->tokens.head : NULL) 
     49    ((parser->is_token_available || yaml_parser_fetch_more_tokens(parser)) ?    \ 
     50        parser->tokens.list + parser->tokens.head : NULL) 
    5151 
    5252/* 
     
    5555 
    5656#define SKIP_TOKEN(parser)                                                      \ 
    57     (parser->token_available = 0,                                               \ 
     57    (parser->is_token_available = 0,                                            \ 
    5858     parser->tokens_parsed ++,                                                  \ 
    59      parser->stream_end_produced =                                              \ 
    60         (parser->tokens.head->type == YAML_STREAM_END_TOKEN),                   \ 
     59     parser->is_stream_end_produced =                                           \ 
     60        (parser->tokens.list[parser->tokens.head].type == YAML_STREAM_END_TOKEN),   \ 
    6161     parser->tokens.head ++) 
    6262 
     
    6969 
    7070/* 
    71  * Error handling. 
    72  */ 
    73  
    74 static int 
    75 yaml_parser_set_parser_error(yaml_parser_t *parser, 
    76         const char *problem, yaml_mark_t problem_mark); 
    77  
    78 static int 
    79 yaml_parser_set_parser_error_context(yaml_parser_t *parser, 
    80         const char *context, yaml_mark_t context_mark, 
    81         const char *problem, yaml_mark_t problem_mark); 
    82  
    83 /* 
    8471 * State functions. 
    8572 */ 
     
    156143yaml_parser_process_directives(yaml_parser_t *parser, 
    157144        yaml_version_directive_t **version_directive_ref, 
    158         yaml_tag_directive_t **tag_directives_start_ref, 
    159         yaml_tag_directive_t **tag_directives_end_ref); 
     145        yaml_tag_directive_t **tag_directives_list_ref, 
     146        size_t *tag_directives_length_ref, 
     147        size_t *tag_directives_capacity_ref); 
    160148 
    161149static int 
     
    179167    /* No events after the end of the stream or error. */ 
    180168 
    181     if (parser->stream_end_produced || parser->error || 
    182             parser->state == YAML_PARSE_END_STATE) { 
     169    if (parser->is_stream_end_produced || parser->error.type 
     170            || parser->state == YAML_PARSE_END_STATE) { 
    183171        return 1; 
    184172    } 
     
    188176    return yaml_parser_state_machine(parser, event); 
    189177} 
    190  
    191 /* 
    192  * Set parser error. 
    193  */ 
    194  
    195 static int 
    196 yaml_parser_set_parser_error(yaml_parser_t *parser, 
    197         const char *problem, yaml_mark_t problem_mark) 
    198 { 
    199     parser->error = YAML_PARSER_ERROR; 
    200     parser->problem = problem; 
    201     parser->problem_mark = problem_mark; 
    202  
    203     return 0; 
    204 } 
    205  
    206 static int 
    207 yaml_parser_set_parser_error_context(yaml_parser_t *parser, 
    208         const char *context, yaml_mark_t context_mark, 
    209         const char *problem, yaml_mark_t problem_mark) 
    210 { 
    211     parser->error = YAML_PARSER_ERROR; 
    212     parser->context = context; 
    213     parser->context_mark = context_mark; 
    214     parser->problem = problem; 
    215     parser->problem_mark = problem_mark; 
    216  
    217     return 0; 
    218 } 
    219  
    220178 
    221179/* 
     
    319277 
    320278    if (token->type != YAML_STREAM_START_TOKEN) { 
    321         return yaml_parser_set_parser_error(parser, 
     279        return PARSER_ERROR_INIT(parser, 
    322280                "did not found expected <stream-start>", token->start_mark); 
    323281    } 
     
    346304    yaml_version_directive_t *version_directive = NULL; 
    347305    struct { 
    348         yaml_tag_directive_t *start; 
    349         yaml_tag_directive_t *end; 
    350     } tag_directives = { NULL, NULL }; 
     306        yaml_tag_directive_t *list; 
     307        size_t length; 
     308        size_t capacity; 
     309    } tag_directives = { NULL, 0, 0 }; 
    351310 
    352311    token = PEEK_TOKEN(parser); 
     
    371330            token->type != YAML_STREAM_END_TOKEN) 
    372331    { 
    373         if (!yaml_parser_process_directives(parser, NULL, NULL, NULL)) 
     332        if (!yaml_parser_process_directives(parser, NULL, NULL, NULL, NULL)) 
    374333            return 0; 
    375334        if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE)) 
    376335            return 0; 
    377336        parser->state = YAML_PARSE_BLOCK_NODE_STATE; 
    378         DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1, 
     337        DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, 0, 0, 1, 
    379338                token->start_mark, token->start_mark); 
    380339        return 1; 
     
    388347        start_mark = token->start_mark; 
    389348        if (!yaml_parser_process_directives(parser, &version_directive, 
    390                     &tag_directives.start, &tag_directives.end)) 
     349                    &tag_directives.list, &tag_directives.length, 
     350                    &tag_directives.capacity)) 
    391351            return 0; 
    392352        token = PEEK_TOKEN(parser); 
    393353        if (!token) goto error; 
    394354        if (token->type != YAML_DOCUMENT_START_TOKEN) { 
    395             yaml_parser_set_parser_error(parser, 
     355            PARSER_ERROR_INIT(parser, 
    396356                    "did not found expected <document start>", token->start_mark); 
    397357            goto error; 
     
    402362        end_mark = token->end_mark; 
    403363        DOCUMENT_START_EVENT_INIT(*event, version_directive, 
    404                 tag_directives.start, tag_directives.end, 0, 
     364                tag_directives.list, tag_directives.length, 
     365                tag_directives.capacity, 0, 
    405366                start_mark, end_mark); 
    406367        SKIP_TOKEN(parser); 
    407368        version_directive = NULL; 
    408         tag_directives.start = tag_directives.end = NULL; 
     369        tag_directives.list = NULL; 
     370        tag_directives.length = tag_directives.capacity = 0; 
    409371        return 1; 
    410372    } 
     
    422384error: 
    423385    yaml_free(version_directive); 
    424     while (tag_directives.start != tag_directives.end) { 
    425         yaml_free(tag_directives.end[-1].handle); 
    426         yaml_free(tag_directives.end[-1].prefix); 
    427         tag_directives.end --; 
    428     } 
    429     yaml_free(tag_directives.start); 
     386    while (!STACK_EMPTY(parser, tag_directives)) { 
     387        yaml_tag_directive_t tag_directive = POP(parser, tag_directives); 
     388        yaml_free(tag_directive.handle); 
     389        yaml_free(tag_directive.prefix); 
     390    } 
     391    STACK_DEL(parser, tag_directives); 
    430392    return 0; 
    431393} 
     
    599561            } 
    600562            else { 
    601                 yaml_tag_directive_t *tag_directive; 
    602                 for (tag_directive = parser->tag_directives.start; 
    603                         tag_directive != parser->tag_directives.top; 
    604                         tag_directive ++) { 
     563                int idx; 
     564                for (idx = 0; idx < parser->tag_directives.length; idx++) { 
     565                    yaml_tag_directive_t *tag_directive = parser->tag_directives.list + idx; 
    605566                    if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) { 
    606567                        size_t prefix_len = strlen((char *)tag_directive->prefix); 
     
    608569                        tag = yaml_malloc(prefix_len+suffix_len+1); 
    609570                        if (!tag) { 
    610                             parser->error = YAML_MEMORY_ERROR; 
     571                            MEMORY_ERROR_INIT(parser); 
    611572                            goto error; 
    612573                        } 
     
    621582                } 
    622583                if (!tag) { 
    623                     yaml_parser_set_parser_error_context(parser, 
     584                    PARSER_ERROR_WITH_CONTEXT_INIT(parser, 
    624585                            "while parsing a node", start_mark, 
    625586                            "found undefined tag handle", tag_mark); 
     
    688649                yaml_char_t *value = yaml_malloc(1); 
    689650                if (!value) { 
    690                     parser->error = YAML_MEMORY_ERROR; 
     651                    MEMORY_ERROR_INIT(parser); 
    691652                    goto error; 
    692653                } 
     
    699660            } 
    700661            else { 
    701                 yaml_parser_set_parser_error_context(parser, 
     662                PARSER_ERROR_WITH_CONTEXT_INIT(parser, 
    702663                        (block ? "while parsing a block node" 
    703664                         : "while parsing a flow node"), start_mark, 
     
    770731    else 
    771732    { 
    772         return yaml_parser_set_parser_error_context(parser, 
     733        return PARSER_ERROR_WITH_CONTEXT_INIT(parser, 
    773734                "while parsing a block collection", POP(parser, parser->marks), 
    774735                "did not found expected '-' indicator", token->start_mark); 
     
    880841    else 
    881842    { 
    882         return yaml_parser_set_parser_error_context(parser, 
     843        return PARSER_ERROR_WITH_CONTEXT_INIT(parser, 
    883844                "while parsing a block mapping", POP(parser, parser->marks), 
    884845                "did not found expected key", token->start_mark); 
     
    974935            } 
    975936            else { 
    976                 return yaml_parser_set_parser_error_context(parser, 
     937                return PARSER_ERROR_WITH_CONTEXT_INIT(parser, 
    977938                        "while parsing a flow sequence", POP(parser, parser->marks), 
    978939                        "did not found expected ',' or ']'", token->start_mark); 
     
    11261087            } 
    11271088            else { 
    1128                 return yaml_parser_set_parser_error_context(parser, 
     1089                return PARSER_ERROR_WITH_CONTEXT_INIT(parser, 
    11291090                        "while parsing a flow mapping", POP(parser, parser->marks), 
    11301091                        "did not found expected ',' or '}'", token->start_mark); 
     
    12151176    value = yaml_malloc(1); 
    12161177    if (!value) { 
    1217         parser->error = YAML_MEMORY_ERROR; 
    1218         return 0; 
     1178        return MEMORY_ERROR_INIT(parser); 
    12191179    } 
    12201180    value[0] = '\0'; 
     
    12331193yaml_parser_process_directives(yaml_parser_t *parser, 
    12341194        yaml_version_directive_t **version_directive_ref, 
    1235         yaml_tag_directive_t **tag_directives_start_ref, 
    1236         yaml_tag_directive_t **tag_directives_end_ref) 
     1195        yaml_tag_directive_t **tag_directives_list_ref, 
     1196        size_t *tag_directives_length_ref, 
     1197        size_t *tag_directives_capacity_ref) 
    12371198{ 
    12381199    yaml_tag_directive_t default_tag_directives[] = { 
     
    12441205    yaml_version_directive_t *version_directive = NULL; 
    12451206    struct { 
    1246         yaml_tag_directive_t *start; 
    1247         yaml_tag_directive_t *end; 
    1248         yaml_tag_directive_t *top; 
    1249     } tag_directives = { NULL, NULL, NULL }; 
    1250     yaml_token_t *token; 
    1251  
    1252     if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_SIZE)) 
     1207        yaml_tag_directive_t *list; 
     1208        size_t length; 
     1209        size_t capacity; 
     1210    } tag_directives = { NULL, 0, 0 }; 
     1211    yaml_token_t *token; 
     1212 
     1213    if (!STACK_INIT(parser, tag_directives, INITIAL_STACK_CAPACITY)) 
    12531214        goto error; 
    12541215 
     
    12611222        if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) { 
    12621223            if (version_directive) { 
    1263                 yaml_parser_set_parser_error(parser, 
     1224                PARSER_ERROR_INIT(parser, 
    12641225                        "found duplicate %YAML directive", token->start_mark); 
    12651226                goto error; 
     
    12671228            if (token->data.version_directive.major != 1 
    12681229                    || token->data.version_directive.minor != 1) { 
    1269                 yaml_parser_set_parser_error(parser, 
     1230                PARSER_ERROR_INIT(parser, 
    12701231                        "found incompatible YAML document", token->start_mark); 
    12711232                goto error; 
     
    12731234            version_directive = yaml_malloc(sizeof(yaml_version_directive_t)); 
    12741235            if (!version_directive) { 
    1275                 parser->error = YAML_MEMORY_ERROR; 
     1236                MEMORY_ERROR_INIT(parser); 
    12761237                goto error; 
    12771238            } 
     
    13071268        *version_directive_ref = version_directive; 
    13081269    } 
    1309     if (tag_directives_start_ref) { 
     1270    if (tag_directives_list_ref) { 
    13101271        if (STACK_EMPTY(parser, tag_directives)) { 
    1311             *tag_directives_start_ref = *tag_directives_end_ref = NULL; 
     1272            *tag_directives_list_ref = NULL; 
     1273            *tag_directives_length_ref = 0; 
     1274            *tag_directives_capacity_ref = 0; 
    13121275            STACK_DEL(parser, tag_directives); 
    13131276        } 
    13141277        else { 
    1315             *tag_directives_start_ref = tag_directives.start; 
    1316             *tag_directives_end_ref = tag_directives.top; 
     1278            *tag_directives_list_ref = tag_directives.list; 
     1279            *tag_directives_length_ref = tag_directives.length; 
     1280            *tag_directives_capacity_ref = tag_directives.capacity; 
    13171281        } 
    13181282    } 
     
    13441308    yaml_tag_directive_t *tag_directive; 
    13451309    yaml_tag_directive_t copy = { NULL, NULL }; 
    1346  
    1347     for (tag_directive = parser->tag_directives.start; 
    1348             tag_directive != parser->tag_directives.top; tag_directive ++) { 
     1310    int idx; 
     1311 
     1312    for (idx = 0; idx < parser->tag_directives.length; idx++) { 
     1313        yaml_tag_directive_t *tag_directive = parser->tag_directives.list + idx; 
    13491314        if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) { 
    13501315            if (allow_duplicates) 
    13511316                return 1; 
    1352             return yaml_parser_set_parser_error(parser, 
     1317            return PARSER_ERROR_INIT(parser, 
    13531318                    "found duplicate %TAG directive", mark); 
    13541319        } 
     
    13581323    copy.prefix = yaml_strdup(value.prefix); 
    13591324    if (!copy.handle || !copy.prefix) { 
    1360         parser->error = YAML_MEMORY_ERROR; 
     1325        MEMORY_ERROR_INIT(parser); 
    13611326        goto error; 
    13621327    } 
Note: See TracChangeset for help on using the changeset viewer.