1 #include <yaml.h> 2 3 #include <stdlib.h> 4 #include <stdio.h> 5 #include <string.h> 6 7 #ifdef NDEBUG 8 #undef NDEBUG 9 #endif 10 #include <assert.h> 11 12 #define BUFFER_SIZE 65536 13 #define MAX_DOCUMENTS 16 14 15 int copy_document(yaml_document_t *document_to, yaml_document_t *document_from) 16 { 17 yaml_node_t *node; 18 yaml_node_item_t *item; 19 yaml_node_pair_t *pair; 20 21 if (!yaml_document_initialize(document_to, document_from->version_directive, 22 document_from->tag_directives.start, 23 document_from->tag_directives.end, 24 document_from->start_implicit, document_from->end_implicit)) 25 return 0; 26 27 for (node = document_from->nodes.start; 28 node < document_from->nodes.top; node ++) { 29 switch (node->type) { 30 case YAML_SCALAR_NODE: 31 if (!yaml_document_add_scalar(document_to, node->tag, 32 node->data.scalar.value, node->data.scalar.length, 33 node->data.scalar.style)) goto error; 34 break; 35 case YAML_SEQUENCE_NODE: 36 if (!yaml_document_add_sequence(document_to, node->tag, 37 node->data.sequence.style)) goto error; 38 break; 39 case YAML_MAPPING_NODE: 40 if (!yaml_document_add_mapping(document_to, node->tag, 41 node->data.mapping.style)) goto error; 42 break; 43 default: 44 assert(0); 45 break; 46 } 47 } 48 49 for (node = document_from->nodes.start; 50 node < document_from->nodes.top; node ++) { 51 switch (node->type) { 52 case YAML_SEQUENCE_NODE: 53 for (item = node->data.sequence.items.start; 54 item < node->data.sequence.items.top; item ++) { 55 if (!yaml_document_append_sequence_item(document_to, 56 node - document_from->nodes.start + 1, 57 *item)) goto error; 58 } 59 break; 60 case YAML_MAPPING_NODE: 61 for (pair = node->data.mapping.pairs.start; 62 pair < node->data.mapping.pairs.top; pair ++) { 63 if (!yaml_document_append_mapping_pair(document_to, 64 node - document_from->nodes.start + 1, 65 pair->key, pair->value)) goto error; 66 } 67 break; 68 default: 69 break; 70 } 71 } 72 return 1; 73 74 error: 75 yaml_document_delete(document_to); 76 return 0; 77 } 78 79 int compare_nodes(yaml_document_t *document1, int index1, 80 yaml_document_t *document2, int index2, int level) 81 { 82 int k; 83 yaml_node_t *node1; 84 yaml_node_t *node2; 85 if (level++ > 1000) return 0; 86 node1 = yaml_document_get_node(document1, index1); 87 node2 = yaml_document_get_node(document2, index2); 88 89 assert(node1); 90 assert(node2); 91 92 if (node1->type != node2->type) 93 return 0; 94 95 if (strcmp((char *)node1->tag, (char *)node2->tag) != 0) return 0; 96 97 switch (node1->type) { 98 case YAML_SCALAR_NODE: 99 if (node1->data.scalar.length != node2->data.scalar.length) 100 return 0; 101 if (strncmp((char *)node1->data.scalar.value, (char *)node2->data.scalar.value, 102 node1->data.scalar.length) != 0) return 0; 103 break; 104 case YAML_SEQUENCE_NODE: 105 if ((node1->data.sequence.items.top - node1->data.sequence.items.start) != 106 (node2->data.sequence.items.top - node2->data.sequence.items.start)) 107 return 0; 108 for (k = 0; k < (node1->data.sequence.items.top - node1->data.sequence.items.start); k ++) { 109 if (!compare_nodes(document1, node1->data.sequence.items.start[k], 110 document2, node2->data.sequence.items.start[k], level)) return 0; 111 } 112 break; 113 case YAML_MAPPING_NODE: 114 if ((node1->data.mapping.pairs.top - node1->data.mapping.pairs.start) != 115 (node2->data.mapping.pairs.top - node2->data.mapping.pairs.start)) 116 return 0; 117 for (k = 0; k < (node1->data.mapping.pairs.top - node1->data.mapping.pairs.start); k ++) { 118 if (!compare_nodes(document1, node1->data.mapping.pairs.start[k].key, 119 document2, node2->data.mapping.pairs.start[k].key, level)) return 0; 120 if (!compare_nodes(document1, node1->data.mapping.pairs.start[k].value, 121 document2, node2->data.mapping.pairs.start[k].value, level)) return 0; 122 } 123 break; 124 default: 125 assert(0); 126 break; 127 } 128 return 1; 129 } 130 131 int compare_documents(yaml_document_t *document1, yaml_document_t *document2) 132 { 133 int k; 134 135 if ((document1->version_directive && !document2->version_directive) 136 || (!document1->version_directive && document2->version_directive) 137 || (document1->version_directive && document2->version_directive 138 && (document1->version_directive->major != document2->version_directive->major 139 || document1->version_directive->minor != document2->version_directive->minor))) 140 return 0; 141 142 if ((document1->tag_directives.end - document1->tag_directives.start) != 143 (document2->tag_directives.end - document2->tag_directives.start)) 144 return 0; 145 for (k = 0; k < (document1->tag_directives.end - document1->tag_directives.start); k ++) { 146 if ((strcmp((char *)document1->tag_directives.start[k].handle, 147 (char *)document2->tag_directives.start[k].handle) != 0) 148 || (strcmp((char *)document1->tag_directives.start[k].prefix, 149 (char *)document2->tag_directives.start[k].prefix) != 0)) 150 return 0; 151 } 152 153 if ((document1->nodes.top - document1->nodes.start) != 154 (document2->nodes.top - document2->nodes.start)) 155 return 0; 156 157 if (document1->nodes.top != document1->nodes.start) { 158 if (!compare_nodes(document1, 1, document2, 1, 0)) 159 return 0; 160 } 161 162 return 1; 163 } 164 165 int print_output(char *name, unsigned char *buffer, size_t size, int count) 166 { 167 FILE *file; 168 char data[BUFFER_SIZE]; 169 size_t data_size = 1; 170 size_t total_size = 0; 171 if (count >= 0) { 172 printf("FAILED (at the document #%d)\nSOURCE:\n", count+1); 173 } 174 file = fopen(name, "rb"); 175 assert(file); 176 while (data_size > 0) { 177 data_size = fread(data, 1, BUFFER_SIZE, file); 178 assert(!ferror(file)); 179 if (!data_size) break; 180 assert(fwrite(data, 1, data_size, stdout) == data_size); 181 total_size += data_size; 182 if (feof(file)) break; 183 } 184 fclose(file); 185 printf("#### (length: %ld)\n", (long)total_size); 186 printf("OUTPUT:\n%s#### (length: %ld)\n", buffer, (long)size); 187 return 0; 188 } 189 190 int 191 main(int argc, char *argv[]) 192 { 193 int number; 194 int canonical = 0; 195 int unicode = 0; 196 197 number = 1; 198 while (number < argc) { 199 if (strcmp(argv[number], "-c") == 0) { 200 canonical = 1; 201 } 202 else if (strcmp(argv[number], "-u") == 0) { 203 unicode = 1; 204 } 205 else if (argv[number][0] == '-') { 206 printf("Unknown option: '%s'\n", argv[number]); 207 return 0; 208 } 209 if (argv[number][0] == '-') { 210 if (number < argc-1) { 211 memmove(argv+number, argv+number+1, (argc-number-1)*sizeof(char *)); 212 } 213 argc --; 214 } 215 else { 216 number ++; 217 } 218 } 219 220 if (argc < 2) { 221 printf("Usage: %s [-c] [-u] file1.yaml ...\n", argv[0]); 222 return 0; 223 } 224 225 for (number = 1; number < argc; number ++) 226 { 227 FILE *file; 228 yaml_parser_t parser; 229 yaml_emitter_t emitter; 230 231 yaml_document_t document; 232 unsigned char buffer[BUFFER_SIZE+1]; 233 size_t written = 0; 234 yaml_document_t documents[MAX_DOCUMENTS]; 235 size_t document_number = 0; 236 int done = 0; 237 int count = 0; 238 int error = 0; 239 int k; 240 memset(buffer, 0, BUFFER_SIZE+1); 241 memset(documents, 0, MAX_DOCUMENTS*sizeof(yaml_document_t)); 242 243 printf("[%d] Loading, dumping, and loading again '%s': ", number, argv[number]); 244 fflush(stdout); 245 246 file = fopen(argv[number], "rb"); 247 assert(file); 248 249 assert(yaml_parser_initialize(&parser)); 250 yaml_parser_set_input_file(&parser, file); 251 assert(yaml_emitter_initialize(&emitter)); 252 if (canonical) { 253 yaml_emitter_set_canonical(&emitter, 1); 254 } 255 if (unicode) { 256 yaml_emitter_set_unicode(&emitter, 1); 257 } 258 yaml_emitter_set_output_string(&emitter, buffer, BUFFER_SIZE, &written); 259 yaml_emitter_open(&emitter); 260 261 while (!done) 262 { 263 if (!yaml_parser_load(&parser, &document)) { 264 error = 1; 265 break; 266 } 267 268 done = (!yaml_document_get_root_node(&document)); 269 if (!done) { 270 assert(document_number < MAX_DOCUMENTS); 271 assert(copy_document(&(documents[document_number++]), &document)); 272 assert(yaml_emitter_dump(&emitter, &document) || 273 (yaml_emitter_flush(&emitter) && print_output(argv[number], buffer, written, count))); 274 count ++; 275 } 276 else { 277 yaml_document_delete(&document); 278 } 279 } 280 281 yaml_parser_delete(&parser); 282 assert(!fclose(file)); 283 yaml_emitter_close(&emitter); 284 yaml_emitter_delete(&emitter); 285 286 if (!error) 287 { 288 count = done = 0; 289 assert(yaml_parser_initialize(&parser)); 290 yaml_parser_set_input_string(&parser, buffer, written); 291 292 while (!done) 293 { 294 assert(yaml_parser_load(&parser, &document) || print_output(argv[number], buffer, written, count)); 295 done = (!yaml_document_get_root_node(&document)); 296 if (!done) { 297 assert(compare_documents(documents+count, &document) || print_output(argv[number], buffer, written, count)); 298 count ++; 299 } 300 yaml_document_delete(&document); 301 } 302 yaml_parser_delete(&parser); 303 } 304 305 for (k = 0; k < document_number; k ++) { 306 yaml_document_delete(documents+k); 307 } 308 309 printf("PASSED (length: %ld)\n", (long)written); 310 print_output(argv[number], buffer, written, -1); 311 } 312 313 return 0; 314 } 315