Changeset 203


Ignore:
Timestamp:
07/07/06 15:34:25 (8 years ago)
Author:
xi
Message:

Complete the Parser (it requires refactoring though) and fix some bugs.

Location:
libyaml/trunk/src
Files:
3 edited

Legend:

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

    r202 r203  
    127127    parser->state = YAML_PARSE_STREAM_START_STATE; 
    128128 
     129    /* Allocate the stack of marks. */ 
     130 
     131    parser->marks = yaml_malloc(YAML_DEFAULT_SIZE*sizeof(yaml_mark_t)); 
     132    if (!parser->marks) goto error; 
     133    memset(parser->marks, 0, YAML_DEFAULT_SIZE*sizeof(yaml_mark_t)); 
     134 
     135    parser->marks_size = YAML_DEFAULT_SIZE; 
     136 
    129137    /* Allocate the list of TAG directives. */ 
    130138 
     
    146154 
    147155    yaml_free(parser->tag_directives); 
     156    yaml_free(parser->marks); 
    148157    yaml_free(parser->states); 
    149158    yaml_free(parser->simple_keys); 
     
    167176    assert(parser); /* Non-NULL parser object expected. */ 
    168177 
    169     yaml_free(parser->tag_directives); 
     178    /*yaml_free(parser->tag_directives);*/ 
     179    yaml_free(parser->marks); 
    170180    yaml_free(parser->states); 
    171181    yaml_free(parser->simple_keys); 
     
    697707    { 
    698708        case YAML_DOCUMENT_START_EVENT: 
    699             yaml_free(event->data.document_start.version_directive); 
     709            /*yaml_free(event->data.document_start.version_directive); 
    700710            if (event->data.document_start.tag_directives) { 
    701711                yaml_tag_directive_t **tag_directive; 
     
    707717                } 
    708718                yaml_free(event->data.document_start.tag_directives); 
    709             } 
     719            }*/ 
    710720            break; 
    711721 
  • libyaml/trunk/src/parser.c

    r202 r203  
    8080 
    8181static int 
     82yaml_parser_append_tag_directive(yaml_parser_t *parser, 
     83        yaml_tag_directive_t *tag_directive); 
     84 
     85static int 
    8286yaml_parser_append_state(yaml_parser_t *parser, yaml_parser_state_t state); 
    8387 
     
    217221 
    218222    return 0; 
     223} 
     224 
     225/* 
     226 * Double a list. 
     227 */ 
     228 
     229static int 
     230yaml_parser_resize_list(yaml_parser_t *parser, void **buffer, size_t *size, 
     231        size_t item_size) 
     232{ 
     233    void *new_buffer = yaml_realloc(*buffer, item_size*(*size)*2); 
     234 
     235    if (!new_buffer) { 
     236        parser->error = YAML_MEMORY_ERROR; 
     237        return 0; 
     238    } 
     239 
     240    memset(new_buffer+item_size*(*size), 0, item_size*(*size)); 
     241 
     242    *buffer = new_buffer; 
     243    *size *= 2; 
     244 
     245    return 1; 
     246} 
     247 
     248/* 
     249 * Push a tag directive to the directive list. 
     250 */ 
     251 
     252static int 
     253yaml_parser_append_tag_directive(yaml_parser_t *parser, 
     254        yaml_tag_directive_t *tag_directive) 
     255{ 
     256    if (parser->tag_directives_length == parser->tag_directives_size-1) { 
     257        if (!yaml_parser_resize_list(parser, (void **)&parser->tag_directives, 
     258                    &parser->tag_directives_size, sizeof(yaml_tag_directive_t))) 
     259            return 0; 
     260    } 
     261 
     262    parser->tag_directives[parser->tag_directives_length++] = tag_directive; 
     263    parser->tag_directives[parser->tag_directives_length] = NULL; 
     264    return 1; 
    219265} 
    220266 
     
    397443                parser->version_directive, parser->tag_directives, 1, 
    398444                token->start_mark, token->start_mark); 
    399         if (!event) return NULL; 
     445        if (!event) { 
     446            parser->error = YAML_MEMORY_ERROR; 
     447            return NULL; 
     448        } 
    400449        return event; 
    401450    } 
     
    424473                parser->version_directive, parser->tag_directives, 0, 
    425474                start_mark, end_mark); 
    426         if (!event) return NULL; 
     475        if (!event) { 
     476            parser->error = YAML_MEMORY_ERROR; 
     477            return NULL; 
     478        } 
    427479        return event; 
    428480    } 
     
    436488        event = yaml_stream_end_event_new(token->start_mark, token->end_mark); 
    437489        yaml_token_delete(token); 
     490        if (!event) { 
     491            parser->error = YAML_MEMORY_ERROR; 
     492            return NULL; 
     493        } 
    438494        return event; 
    439495    } 
     
    496552    } 
    497553 
     554    parser->version_directive = NULL; 
     555    parser->tag_directives = NULL; 
     556    parser->tag_directives = yaml_malloc(YAML_DEFAULT_SIZE*sizeof(yaml_tag_directive_t *)); 
     557    if (!parser->tag_directives) { 
     558        parser->error = YAML_MEMORY_ERROR; 
     559        return NULL; 
     560    } 
     561    memset(parser->tag_directives, 0, YAML_DEFAULT_SIZE*sizeof(yaml_tag_directive_t *)); 
     562    parser->tag_directives_size = YAML_DEFAULT_SIZE; 
     563    parser->tag_directives_length = 0; 
     564 
     565 
     566 
    498567    event = yaml_document_end_event_new(implicit, start_mark, end_mark); 
    499568    if (!event) { 
     
    501570        return NULL; 
    502571    } 
     572    parser->state = YAML_PARSE_DOCUMENT_START_STATE; 
     573 
    503574    return event; 
    504575} 
     
    551622    if (token->type == YAML_ALIAS_TOKEN) 
    552623    { 
     624        parser->state = parser->states[--parser->states_length]; 
    553625        token = yaml_parser_get_token(parser); 
    554626        event = yaml_alias_event_new(token->data.alias.value, 
     
    627699                            goto error; 
    628700                        } 
    629                         memcpy(tag, (*tag_directive)->handle, prefix_len); 
     701                        memcpy(tag, (*tag_directive)->prefix, prefix_len); 
    630702                        memcpy(tag+prefix_len, tag_suffix, suffix_len); 
    631703                        tag[prefix_len+suffix_len] = '\0'; 
     
    636708                    } 
    637709                } 
    638                 if (*tag_directive) { 
     710                if (!*tag_directive) { 
    639711                    yaml_parser_set_parser_error_context(parser, 
    640712                            "while parsing a node", start_mark, 
     
    652724                    YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark); 
    653725            if (!event) goto error; 
     726            return event; 
    654727        } 
    655728        else { 
     
    660733                end_mark = token->end_mark; 
    661734                if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag) 
    662                         || strcmp((char *)tag, "!") == 0) { 
     735                        || (tag && strcmp((char *)tag, "!") == 0)) { 
    663736                    plain_implicit = 1; 
    664737                } 
     
    725798                } 
    726799                value[0] = '\0'; 
     800                parser->state = parser->states[--parser->states_length]; 
    727801                event = yaml_scalar_event_new(anchor, tag, value, 0, 
    728802                        implicit, 0, YAML_PLAIN_SCALAR_STYLE, 
     
    800874    { 
    801875        parser->state = parser->states[--parser->states_length]; 
     876        parser->marks_length --; 
    802877        event = yaml_sequence_end_event_new(token->start_mark, token->end_mark); 
    803878        yaml_token_delete(token); 
     
    917992    { 
    918993        parser->state = parser->states[--parser->states_length]; 
    919         event = yaml_sequence_end_event_new(token->start_mark, token->end_mark); 
     994        parser->marks_length --; 
     995        event = yaml_mapping_end_event_new(token->start_mark, token->end_mark); 
    920996        yaml_token_delete(token); 
    921997        if (!event) { 
     
    9841060} 
    9851061 
    986 static yaml_event_t * 
    987 yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, int first); 
    988  
    989 static yaml_event_t * 
    990 yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser); 
    991  
    992 static yaml_event_t * 
    993 yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser); 
    994  
    995 static yaml_event_t * 
    996 yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser); 
    997  
    998 static yaml_event_t * 
    999 yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, int first); 
    1000  
    1001 static yaml_event_t * 
    1002 yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, int empty); 
    1003  
     1062/* 
     1063 * Parse the productions: 
     1064 * flow_sequence        ::= FLOW-SEQUENCE-START 
     1065 *                          ******************* 
     1066 *                          (flow_sequence_entry FLOW-ENTRY)* 
     1067 *                           *                   ********** 
     1068 *                          flow_sequence_entry? 
     1069 *                          * 
     1070 *                          FLOW-SEQUENCE-END 
     1071 *                          ***************** 
     1072 * flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)? 
     1073 *                          * 
     1074 */ 
     1075 
     1076static yaml_event_t * 
     1077yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser, int first) 
     1078{ 
     1079    yaml_token_t *token; 
     1080    yaml_event_t *event; 
     1081 
     1082    if (first) { 
     1083        token = yaml_parser_get_token(parser); 
     1084        if (!yaml_parser_append_mark(parser, token->start_mark)) { 
     1085            yaml_token_delete(token); 
     1086            return NULL; 
     1087        } 
     1088        yaml_token_delete(token); 
     1089    } 
     1090 
     1091    token = yaml_parser_peek_token(parser); 
     1092    if (!token) return NULL; 
     1093 
     1094    if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) 
     1095    { 
     1096        if (!first) { 
     1097            if (token->type == YAML_FLOW_ENTRY_TOKEN) { 
     1098                yaml_token_delete(yaml_parser_get_token(parser)); 
     1099                token = yaml_parser_peek_token(parser); 
     1100                if (!token) return NULL; 
     1101            } 
     1102            else { 
     1103                yaml_parser_set_parser_error_context(parser, 
     1104                        "while parsing a flow sequence", parser->marks[parser->marks_length-1], 
     1105                        "did not found expected ',' or ']'", token->start_mark); 
     1106                return NULL; 
     1107            } 
     1108        } 
     1109 
     1110        if (token->type == YAML_KEY_TOKEN) { 
     1111            token = yaml_parser_get_token(parser); 
     1112            parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE; 
     1113            event = yaml_mapping_start_event_new(NULL, NULL, 
     1114                    1, YAML_FLOW_MAPPING_STYLE, 
     1115                    token->start_mark, token->end_mark); 
     1116            yaml_token_delete(token); 
     1117            return event; 
     1118        } 
     1119 
     1120        else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { 
     1121            if (!yaml_parser_append_state(parser, 
     1122                        YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE)) 
     1123                return NULL; 
     1124            return yaml_parser_parse_node(parser, 0, 0); 
     1125        } 
     1126    } 
     1127 
     1128    parser->state = parser->states[--parser->states_length]; 
     1129    parser->marks_length --; 
     1130    token = yaml_parser_get_token(parser); 
     1131    event = yaml_sequence_end_event_new(token->start_mark, token->end_mark); 
     1132    yaml_token_delete(token); 
     1133    return event; 
     1134} 
     1135 
     1136/* 
     1137 * Parse the productions: 
     1138 * flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)? 
     1139 *                                      *** * 
     1140 */ 
     1141 
     1142static yaml_event_t * 
     1143yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser) 
     1144{ 
     1145    yaml_token_t *token; 
     1146    yaml_event_t *event; 
     1147 
     1148    token = yaml_parser_peek_token(parser); 
     1149    if (!token) return NULL; 
     1150 
     1151    if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN 
     1152            && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { 
     1153        if (!yaml_parser_append_state(parser, 
     1154                    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)) 
     1155            return NULL; 
     1156        return yaml_parser_parse_node(parser, 0, 0); 
     1157    } 
     1158    else { 
     1159        parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE; 
     1160        event = yaml_parser_process_empty_scalar(parser, token->end_mark); 
     1161        yaml_token_delete(token); 
     1162        return event; 
     1163    } 
     1164} 
     1165 
     1166/* 
     1167 * Parse the productions: 
     1168 * flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)? 
     1169 *                                                      ***** * 
     1170 */ 
     1171 
     1172static yaml_event_t * 
     1173yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser) 
     1174{ 
     1175    yaml_token_t *token; 
     1176 
     1177    token = yaml_parser_peek_token(parser); 
     1178    if (!token) return NULL; 
     1179 
     1180    if (token->type == YAML_VALUE_TOKEN) { 
     1181        yaml_token_delete(yaml_parser_get_token(parser)); 
     1182        token = yaml_parser_peek_token(parser); 
     1183        if (!token) return NULL; 
     1184        if (token->type != YAML_FLOW_ENTRY_TOKEN 
     1185                && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) { 
     1186            if (!yaml_parser_append_state(parser, 
     1187                        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)) 
     1188                return NULL; 
     1189            return yaml_parser_parse_node(parser, 0, 0); 
     1190        } 
     1191    } 
     1192    parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE; 
     1193    return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     1194} 
     1195 
     1196/* 
     1197 * Parse the productions: 
     1198 * flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)? 
     1199 *                                                                      * 
     1200 */ 
     1201 
     1202static yaml_event_t * 
     1203yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser) 
     1204{ 
     1205    yaml_token_t *token; 
     1206 
     1207    token = yaml_parser_peek_token(parser); 
     1208    if (!token) return NULL; 
     1209 
     1210    parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE; 
     1211 
     1212    return yaml_mapping_end_event_new(token->start_mark, token->start_mark); 
     1213} 
     1214 
     1215/* 
     1216 * Parse the productions: 
     1217 * flow_mapping         ::= FLOW-MAPPING-START 
     1218 *                          ****************** 
     1219 *                          (flow_mapping_entry FLOW-ENTRY)* 
     1220 *                           *                  ********** 
     1221 *                          flow_mapping_entry? 
     1222 *                          ****************** 
     1223 *                          FLOW-MAPPING-END 
     1224 *                          **************** 
     1225 * flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)? 
     1226 *                          *           *** * 
     1227 */ 
     1228 
     1229static yaml_event_t * 
     1230yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser, int first) 
     1231{ 
     1232    yaml_token_t *token; 
     1233    yaml_event_t *event; 
     1234 
     1235    if (first) { 
     1236        token = yaml_parser_get_token(parser); 
     1237        if (!yaml_parser_append_mark(parser, token->start_mark)) { 
     1238            yaml_token_delete(token); 
     1239            return NULL; 
     1240        } 
     1241        yaml_token_delete(token); 
     1242    } 
     1243 
     1244    token = yaml_parser_peek_token(parser); 
     1245    if (!token) return; 
     1246 
     1247    if (token->type != YAML_FLOW_MAPPING_END_TOKEN) 
     1248    { 
     1249        if (!first) { 
     1250            if (token->type == YAML_FLOW_ENTRY_TOKEN) { 
     1251                yaml_token_delete(yaml_parser_get_token(parser)); 
     1252                token = yaml_parser_peek_token(parser); 
     1253                if (!token) return; 
     1254            } 
     1255            else { 
     1256                yaml_parser_set_parser_error_context(parser, 
     1257                        "while parsing a flow mapping", parser->marks[parser->marks_length-1], 
     1258                        "did not found expected ',' or '}'", token->start_mark); 
     1259                return NULL; 
     1260            } 
     1261        } 
     1262 
     1263        if (token->type == YAML_KEY_TOKEN) { 
     1264            yaml_token_delete(yaml_parser_get_token(parser)); 
     1265            token = yaml_parser_peek_token(parser); 
     1266            if (!token) return NULL; 
     1267            if (token->type != YAML_VALUE_TOKEN 
     1268                    && token->type != YAML_FLOW_ENTRY_TOKEN 
     1269                    && token->type != YAML_FLOW_MAPPING_END_TOKEN) { 
     1270                if (!yaml_parser_append_state(parser, 
     1271                            YAML_PARSE_FLOW_MAPPING_VALUE_STATE)) 
     1272                    return NULL; 
     1273                return yaml_parser_parse_node(parser, 0, 0); 
     1274            } 
     1275            else { 
     1276                parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE; 
     1277                return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     1278            } 
     1279        } 
     1280        else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) { 
     1281            if (!yaml_parser_append_state(parser, 
     1282                        YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)) 
     1283                return NULL; 
     1284            return yaml_parser_parse_node(parser, 0, 0); 
     1285        } 
     1286    } 
     1287 
     1288    parser->state = parser->states[--parser->states_length]; 
     1289    parser->marks_length --; 
     1290    token = yaml_parser_get_token(parser); 
     1291    event = yaml_mapping_end_event_new(token->start_mark, token->end_mark); 
     1292    yaml_token_delete(token); 
     1293    return event; 
     1294} 
     1295 
     1296/* 
     1297 * Parse the productions: 
     1298 * flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)? 
     1299 *                                   *                  ***** * 
     1300 */ 
     1301 
     1302static yaml_event_t * 
     1303yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser, int empty) 
     1304{ 
     1305    yaml_token_t *token; 
     1306    yaml_event_t *event; 
     1307 
     1308    token = yaml_parser_peek_token(parser); 
     1309    if (!token) return; 
     1310 
     1311    if (empty) { 
     1312        parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; 
     1313        return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     1314    } 
     1315 
     1316    if (token->type == YAML_VALUE_TOKEN) { 
     1317        yaml_token_delete(yaml_parser_get_token(parser)); 
     1318        token = yaml_parser_peek_token(parser); 
     1319        if (!token) return NULL; 
     1320        if (token->type != YAML_FLOW_ENTRY_TOKEN 
     1321                && token->type != YAML_FLOW_MAPPING_END_TOKEN) { 
     1322            if (!yaml_parser_append_state(parser, 
     1323                        YAML_PARSE_FLOW_MAPPING_KEY_STATE)) 
     1324                return NULL; 
     1325            return yaml_parser_parse_node(parser, 0, 0); 
     1326        } 
     1327    } 
     1328 
     1329    parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE; 
     1330    return yaml_parser_process_empty_scalar(parser, token->start_mark); 
     1331} 
     1332 
     1333/* 
     1334 * Generate an empty scalar event. 
     1335 */ 
     1336 
     1337static yaml_event_t * 
     1338yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_mark_t mark) 
     1339{ 
     1340    yaml_event_t *event; 
     1341    yaml_char_t *value; 
     1342 
     1343    value = yaml_malloc(1); 
     1344    if (!value) { 
     1345        parser->error = YAML_MEMORY_ERROR; 
     1346        return NULL; 
     1347    } 
     1348    value[0] = '\0'; 
     1349 
     1350    event = yaml_scalar_event_new(NULL, NULL, value, 0, 
     1351            1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark); 
     1352    if (!event) { 
     1353        yaml_free(value); 
     1354        parser->error = YAML_MEMORY_ERROR; 
     1355        return NULL; 
     1356    } 
     1357 
     1358    return event; 
     1359} 
     1360 
     1361/* 
     1362 * Parse directives. 
     1363 */ 
     1364 
     1365static int 
     1366yaml_parser_process_directives(yaml_parser_t *parser) 
     1367{ 
     1368    yaml_tag_directive_t default_tag_directives[] = { 
     1369        {(yaml_char_t *)"!", (yaml_char_t *)"!"}, 
     1370        {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"}, 
     1371        {NULL, NULL} 
     1372    }; 
     1373    yaml_tag_directive_t *ref; 
     1374    yaml_tag_directive_t *default_tag_directive; 
     1375    yaml_tag_directive_t **tag_directive; 
     1376    yaml_token_t *token; 
     1377 
     1378    token = yaml_parser_peek_token(parser); 
     1379    if (!token) return 0; 
     1380 
     1381    while (token->type == YAML_VERSION_DIRECTIVE_TOKEN || 
     1382            token->type == YAML_TAG_DIRECTIVE_TOKEN) 
     1383    { 
     1384        if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) { 
     1385            if (parser->version_directive) { 
     1386                return yaml_parser_set_parser_error(parser, 
     1387                        "found duplicate %YAML directive", token->start_mark); 
     1388            } 
     1389            if (token->data.version_directive.major != 1 
     1390                    && token->data.version_directive.minor != 1) { 
     1391                return yaml_parser_set_parser_error(parser, 
     1392                        "found incompatible YAML document", token->start_mark); 
     1393            } 
     1394            parser->version_directive = yaml_malloc(sizeof(yaml_version_directive_t)); 
     1395            if (!parser->version_directive) { 
     1396                parser->error = YAML_MEMORY_ERROR; 
     1397                return 0; 
     1398            } 
     1399            parser->version_directive->major = token->data.version_directive.major; 
     1400            parser->version_directive->minor = token->data.version_directive.minor; 
     1401        } 
     1402 
     1403        else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) { 
     1404            yaml_tag_directive_t value = { 
     1405                token->data.tag_directive.handle, 
     1406                token->data.tag_directive.prefix 
     1407            }; 
     1408            for (tag_directive = parser->tag_directives; 
     1409                    *tag_directive; tag_directive++) { 
     1410                if (strcmp((char *)value.handle, 
     1411                            (char *)(*tag_directive)->handle) == 0) { 
     1412                    return yaml_parser_set_parser_error(parser, 
     1413                            "found duplicate %TAG directive", token->start_mark); 
     1414                } 
     1415            } 
     1416            ref = yaml_malloc(sizeof(yaml_tag_directive_t)); 
     1417            if (!ref) { 
     1418                parser->error = YAML_MEMORY_ERROR; 
     1419                return 0; 
     1420            } 
     1421            *ref = value; 
     1422            if (!yaml_parser_append_tag_directive(parser, ref)) { 
     1423                yaml_free(ref); 
     1424                return 0; 
     1425            } 
     1426        } 
     1427        yaml_free(yaml_parser_get_token(parser)); 
     1428        token = yaml_parser_peek_token(parser); 
     1429        if (!token) return 0; 
     1430    } 
     1431 
     1432    for (default_tag_directive = default_tag_directives; 
     1433            default_tag_directive->handle; default_tag_directive++) { 
     1434        int found = 0; 
     1435        for (tag_directive = parser->tag_directives; 
     1436                *tag_directive; tag_directive++) { 
     1437            if (strcmp((char *)default_tag_directive->handle, 
     1438                        (char *)(*tag_directive)->handle) == 0) { 
     1439                found = 1; 
     1440                break; 
     1441            } 
     1442        } 
     1443        if (!found) { 
     1444            ref = yaml_malloc(sizeof(yaml_tag_directive_t)); 
     1445            if (!ref) { 
     1446                parser->error = YAML_MEMORY_ERROR; 
     1447                return 0; 
     1448            } 
     1449            ref->handle = yaml_malloc(strlen((char *)default_tag_directive->handle)+1); 
     1450            if (!ref->handle) { 
     1451                yaml_free(ref); 
     1452                parser->error = YAML_MEMORY_ERROR; 
     1453                return 0; 
     1454            } 
     1455            ref->prefix = yaml_malloc(strlen((char *)default_tag_directive->prefix)+1); 
     1456            if (!ref->prefix) { 
     1457                yaml_free(ref->handle); 
     1458                yaml_free(ref); 
     1459                parser->error = YAML_MEMORY_ERROR; 
     1460                return 0; 
     1461            } 
     1462            memcpy(ref->handle, default_tag_directive->handle, 
     1463                    strlen((char *)default_tag_directive->handle)+1); 
     1464            memcpy(ref->prefix, default_tag_directive->prefix, 
     1465                    strlen((char *)default_tag_directive->prefix)+1); 
     1466            if (!yaml_parser_append_tag_directive(parser, ref)) { 
     1467                yaml_free(ref); 
     1468                return 0; 
     1469            } 
     1470        } 
     1471    } 
     1472    return 1; 
     1473} 
     1474 
  • libyaml/trunk/src/scanner.c

    r200 r203  
    27402740    if (!yaml_parser_scan_version_directive_number(parser, start_mark, minor)) 
    27412741        return 0; 
     2742 
     2743    return 1; 
    27422744} 
    27432745 
Note: See TracChangeset for help on using the changeset viewer.