rngparser.c
1 /** 2 * rngparser.c: parser for the Relax-NG compact syntax. 3 * 4 * Based on: 5 * RELAX NG Compact Syntax 6 * Committee Specification 21 November 2002 7 * http://www.oasis-open.org/committees/relax-ng/compact-20021121.html 8 * 9 * See Copyright for the status of this software. 10 * 11 * Daniel Veillard <veillard@redhat.com> 12 */ 13 14 #include <string.h> 15 16 #include <libxml/parser.h> 17 #include <libxml/parserInternals.h> 18 #include <libxml/relaxng.h> 19 #include <libxml/dict.h> 20 21 #define TODO \ 22 xmlGenericError(xmlGenericErrorContext, \ 23 "Unimplemented block at %s:%d\n", \ 24 __FILE__, __LINE__); 25 26 #define MAX_TOKEN 10 27 28 typedef enum { 29 CRNG_NONE = 0, 30 CRNG_OP = 1, 31 CRNG_KEYWORD, 32 CRNG_IDENTIFIER, 33 CRNG_LITERAL_SEGMENT, 34 CRNG_CNAME, 35 CRNG_QNAME, 36 CRNG_NSNAME, 37 CRNG_DOCUMENTATION 38 } xmlCRNGTokType; 39 40 typedef enum { 41 CRNG_OKAY = 0, 42 CRNG_MEMORY_ERROR, 43 CRNG_INVALID_CHAR_ERROR, 44 CRNG_END_ERROR, 45 CRNG_ENCODING_ERROR 46 } xmlCRNGError; 47 48 typedef enum { 49 XML_CRNG_ERROR = -1, 50 XML_CRNG_OK = 0, 51 XML_CRNG_EOF = 1 52 } xmlCRelaxNGParserState; 53 54 typedef struct _token _token; 55 typedef _token *tokenPtr; 56 struct _token { 57 xmlCRNGTokType toktype; 58 int toklen; 59 const xmlChar *token; 60 const xmlChar *prefix; 61 }; 62 63 typedef struct _xmlCRelaxNGParserCtxt xmlCRelaxNGParserCtxt; 64 typedef xmlCRelaxNGParserCtxt *xmlCRelaxNGParserCtxtPtr; 65 struct _xmlCRelaxNGParserCtxt { 66 void *userData; /* user specific data block */ 67 xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */ 68 xmlRelaxNGValidityWarningFunc warning;/* the callback in case of warning */ 69 xmlRelaxNGValidErr err; 70 71 const xmlChar *compact; 72 const xmlChar *end; 73 const xmlChar *cur; 74 int isElem; 75 int lineno; 76 const xmlChar *linestart; 77 const char *filename; 78 79 int nbTokens; 80 int firstToken; 81 _token tokens[MAX_TOKEN]; 82 int totalToken; 83 84 xmlCRelaxNGParserState state; 85 86 int nbErrors; 87 88 xmlDocPtr res; /* the result */ 89 xmlNodePtr ins; /* the current insertion node */ 90 91 xmlNsPtr nsDef; 92 tokenPtr token; 93 94 xmlHashTablePtr namespaces; 95 xmlHashTablePtr datatypes; 96 97 /* 98 * dictionary and keywords 99 */ 100 xmlDictPtr dict; 101 const xmlChar *key_attribute; 102 const xmlChar *key_default; 103 const xmlChar *key_datatypes; 104 const xmlChar *key_div; 105 const xmlChar *key_element; 106 const xmlChar *key_empty; 107 const xmlChar *key_external; 108 const xmlChar *key_grammar; 109 const xmlChar *key_include; 110 const xmlChar *key_inherit; 111 const xmlChar *key_list; 112 const xmlChar *key_mixed; 113 const xmlChar *key_namespace; 114 const xmlChar *key_notAllowed; 115 const xmlChar *key_parent; 116 const xmlChar *key_start; 117 const xmlChar *key_string; 118 const xmlChar *key_text; 119 const xmlChar *key_token; 120 const xmlChar *key_equal; 121 const xmlChar *key_orequal; 122 const xmlChar *key_andequal; 123 const xmlChar *key_combine; 124 const xmlChar *key_or; 125 const xmlChar *key_comma; 126 const xmlChar *key_and; 127 const xmlChar *key_choice; 128 const xmlChar *key_group; 129 const xmlChar *key_interleave; 130 const xmlChar *key_ref; 131 const xmlChar *key_define; 132 133 /* results */ 134 xmlDocPtr doc; /* the resulting doc */ 135 xmlNodePtr insert; /* the insertion point */ 136 xmlAttrPtr attrs; /* pending attributes */ 137 }; 138 139 static const xmlChar *xmlCRelaxNGInherit = BAD_CAST "Inherit string"; 140 static const xmlChar *xmlCRelaxNGDefault = BAD_CAST "Default string"; 141 142 #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l) 143 /** 144 * IS_BLANK: 145 * @c: an UNICODE value (int) 146 * 147 * Macro to check the following production in the XML spec: 148 * 149 * [3] S ::= (#x20 | #x9 | #xD | #xA)+ 150 */ 151 #ifndef IS_BLANK 152 #define IS_BLANK(c) (((c) == 0x20) || ((c) == 0x09) || ((c) == 0xA) || \ 153 ((c) == 0x0D)) 154 #endif 155 #define IS_SEPARATOR(c) (((c) == 0x20) || ((c) == 0x09) || ((c) == 0xA) || \ 156 ((c) == 0x0D) || (c == '#')) 157 158 #define CRNG_ERROR0(X) \ 159 { xmlCRNGErr(ctxt, X, NULL); return(0); } 160 #define CRNG_ERROR(X) \ 161 { xmlCRNGErr(ctxt, X, NULL); } 162 163 #define CRNG_MEM_ERROR0() \ 164 { xmlCRNGErr(ctxt, CRNG_MEMORY_ERROR, NULL); return(0); } 165 #define CRNG_MEM_ERROR() \ 166 { xmlCRNGErr(ctxt, CRNG_MEMORY_ERROR, NULL); } 167 168 #define ERROR(str) xmlCRNGErr(ctxt, 0, str); 169 170 static void 171 xmlCRNGErr(xmlCRelaxNGParserCtxtPtr ctxt, int err_no, const char *err_msg) { 172 const xmlChar *cur; 173 xmlChar buffer[150]; 174 int i, l; 175 176 if (ctxt != NULL) { 177 if (ctxt->filename != NULL) 178 fprintf(stderr, "%s:%d ", ctxt->filename, ctxt->lineno); 179 } 180 if (err_msg != NULL) { 181 fprintf(stderr, "error: %s\n", err_msg); 182 } else if (err_no != 0) 183 fprintf(stderr, "error %d\n", err_no); 184 cur = ctxt->cur; 185 while ((*cur != '\n') && (*cur != '\r') && (ctxt->cur - cur < 80)) cur--; 186 l = ctxt->cur - cur; 187 cur++; 188 for (i = 0; i < 100;i++) { 189 if ((*cur == '\n') || (*cur == '\r')) break; 190 buffer[i] = *cur++; 191 } 192 buffer[i] = 0; 193 fprintf(stderr, "%s\n", buffer); 194 for (i = 0; i < l;i++) buffer[i] = ' '; 195 buffer[i++] = '^'; 196 buffer[i++] = 0; 197 fprintf(stderr, "%s\n", buffer); 198 } 199 200 /** 201 * IS_OP 202 * @c: an UNICODE value (int) 203 * 204 * Macro to check for operator value 205 */ 206 #ifndef IS_OP 207 #define IS_OP(c) (((c) == ',') || ((c) == '&') || ((c) == '|') || \ 208 ((c) == '?') || ((c) == '-') || ((c) == '*') || \ 209 ((c) == '{') || ((c) == '}') || ((c) == '(') || \ 210 ((c) == ')') || ((c) == '+') || ((c) == '=') || \ 211 ((c) == ':')) 212 #endif 213 214 static int 215 xmlCRNGIsKeyword(xmlCRelaxNGParserCtxtPtr ctxt, const xmlChar *str) { 216 if ((str == ctxt->key_attribute) || 217 (str == ctxt->key_default) || 218 (str == ctxt->key_datatypes) || 219 (str == ctxt->key_div) || 220 (str == ctxt->key_element) || 221 (str == ctxt->key_empty) || 222 (str == ctxt->key_external) || 223 (str == ctxt->key_grammar) || 224 (str == ctxt->key_include) || 225 (str == ctxt->key_inherit) || 226 (str == ctxt->key_list) || 227 (str == ctxt->key_mixed) || 228 (str == ctxt->key_namespace) || 229 (str == ctxt->key_notAllowed) || 230 (str == ctxt->key_parent) || 231 (str == ctxt->key_start) || 232 (str == ctxt->key_string) || 233 (str == ctxt->key_text) || 234 (str == ctxt->key_token)) 235 return(1); 236 return(0); 237 238 } 239 240 /* 241 * xmlCRNGNextToken: 242 * ctxt: a compact RNG parser context 243 * 244 * Scan the schema to get the next token 245 * 246 * Return 0 if success and -1 in case of error 247 */ 248 249 static int 250 xmlCRNGNextToken(xmlCRelaxNGParserCtxtPtr ctxt) { 251 const xmlChar *cur; 252 tokenPtr token; 253 254 if (ctxt == NULL) return(-1); 255 if (ctxt->nbTokens >= MAX_TOKEN) return(-1); 256 token = &(ctxt->tokens[(ctxt->firstToken + ctxt->nbTokens) % MAX_TOKEN]); 257 token->toktype = CRNG_NONE; 258 259 if (ctxt->cur == NULL) { 260 ctxt->cur = ctxt->compact; 261 } 262 retry: 263 if (ctxt->cur >= ctxt->end) { 264 ctxt->state = XML_CRNG_EOF; 265 return(-1); 266 } 267 while ((ctxt->cur < ctxt->end) && 268 (IS_BLANK(*ctxt->cur))) ctxt->cur++; 269 if (ctxt->cur >= ctxt->end) { 270 ctxt->state = XML_CRNG_EOF; 271 return(-1); 272 } 273 if (*ctxt->cur == '#') { 274 cur = ctxt->cur; 275 cur++; 276 while ((cur < ctxt->end) && (*cur != '\n') && (*cur != '\r')) 277 cur++; 278 ctxt->cur = cur; 279 goto retry; 280 } else if (*ctxt->cur == '"') { 281 /* string, check for '"""' */ 282 ctxt->cur++; 283 if (ctxt->cur >= ctxt->end) goto eof; 284 cur = ctxt->cur; 285 if ((ctxt->end - ctxt->end > 2) && 286 (*cur == '"') && (cur[1] == '"')) { 287 TODO 288 } else { 289 while ((cur < ctxt->end) && (*cur != '"')) cur++; 290 if (cur >= ctxt->end) goto eof; 291 token->toklen = cur - ctxt->cur; 292 token->token = xmlDictLookup(ctxt->dict, ctxt->cur, token->toklen); 293 token->toktype = CRNG_LITERAL_SEGMENT; 294 token->prefix = NULL; 295 cur++; 296 ctxt->cur = cur; 297 } 298 } else if (*ctxt->cur == '\'') { 299 /* string, check for "'''" */ 300 TODO 301 } else if ((IS_OP(*ctxt->cur)) || (*ctxt->cur == ':')) { 302 cur = ctxt->cur; 303 cur++; 304 if ((cur < ctxt->end) && 305 (((*cur == '=') && 306 ((*ctxt->cur == '|') || (*ctxt->cur == '&'))) || 307 ((*cur == '*') && (*ctxt->cur == ':')))) { 308 token->toklen = 2; 309 } else { 310 token->toklen = 1; 311 } 312 token->token = xmlDictLookup(ctxt->dict, ctxt->cur, token->toklen); 313 token->toktype = CRNG_OP; 314 token->prefix = NULL; 315 ctxt->cur += token->toklen; 316 } else { 317 int escape = 0; 318 319 cur = ctxt->cur; 320 if (*cur == '\\') { 321 escape = 1; 322 cur++; 323 ctxt->cur++; 324 } 325 while ((cur < ctxt->end) && 326 (!(IS_SEPARATOR(*cur))) && (!(IS_OP(*cur)))) cur++; 327 328 token->toklen = cur - ctxt->cur; 329 token->token = xmlDictLookup(ctxt->dict, ctxt->cur, token->toklen); 330 token->prefix = NULL; 331 ctxt->cur = cur; 332 if ((escape == 0) && (xmlCRNGIsKeyword(ctxt, token->token))) 333 token->toktype = CRNG_KEYWORD; 334 else { 335 token->toktype = CRNG_IDENTIFIER; 336 } 337 if (*ctxt->cur == ':') { 338 ctxt->cur++; 339 if (*ctxt->cur == '*') { 340 ctxt->cur++; 341 token->toktype = CRNG_NSNAME; 342 } else { 343 cur = ctxt->cur; 344 while ((cur < ctxt->end) && 345 (!(IS_SEPARATOR(*cur))) && (!(IS_OP(*cur)))) cur++; 346 token->prefix = token->token; 347 token->toklen = cur - ctxt->cur; 348 token->token = xmlDictLookup(ctxt->dict, ctxt->cur, 349 token->toklen); 350 ctxt->cur = cur; 351 if (xmlValidateNCName(token->token, 0) == 0) 352 token->toktype = CRNG_QNAME; 353 else { 354 TODO /* sounds like an error ! */ 355 token->toktype = CRNG_IDENTIFIER; 356 } 357 } 358 } 359 } 360 ctxt->nbTokens++; 361 return(0); 362 eof: 363 ctxt->state = XML_CRNG_EOF; 364 CRNG_ERROR(CRNG_END_ERROR); 365 return(-1); 366 } 367 368 /** 369 * xmlParseCRNGGetToken: 370 * @ctxt: a compact RNG parser context 371 * @no: the number of the token from 1 for the first one 372 * and 2, 3 ... for read-ahead 373 * 374 * Token reading interface 375 * 376 * returns a pointer to the new token, or NULL in case of error or EOF 377 */ 378 static tokenPtr 379 xmlParseCRNGGetToken(xmlCRelaxNGParserCtxtPtr ctxt, int no) { 380 tokenPtr ret; 381 int res; 382 383 if ((no <= 0) || (no >= MAX_TOKEN)) return(NULL); 384 no--; 385 while (ctxt->nbTokens <= no) { 386 res = xmlCRNGNextToken(ctxt); 387 if (res < 0) 388 return(NULL); 389 } 390 ret = &(ctxt->tokens[(ctxt->firstToken + no) % MAX_TOKEN]); 391 return(ret); 392 } 393 394 /** 395 * xmlParseCRNGDropTokens: 396 * @ctxt: a compact RNG parser context 397 * @nr: the number of token marked as read 398 * 399 * mark a number of token as read and consumed. 400 * 401 * Returns -1 in case of error and 0 otherwise 402 */ 403 static int 404 xmlParseCRNGDropTokens(xmlCRelaxNGParserCtxtPtr ctxt, int nr) { 405 if ((nr <= 0) || (nr >= MAX_TOKEN)) return(-1); 406 while ((ctxt->nbTokens >0) && (nr > 0)) { 407 ctxt->firstToken++; 408 nr--; 409 ctxt->nbTokens--; 410 ctxt->totalToken++; 411 if (ctxt->totalToken == 384) 412 fprintf(stderr, "found\n"); 413 } 414 ctxt->firstToken = ctxt->firstToken % MAX_TOKEN; 415 return(0); 416 } 417 418 static void 419 xmlParseCRNGTokenize(xmlCRelaxNGParserCtxtPtr ctxt) { 420 tokenPtr token; 421 422 token = xmlParseCRNGGetToken(ctxt, 1); 423 while (token != NULL) { 424 switch (token->toktype) { 425 case CRNG_NONE: printf("none"); break; 426 case CRNG_OP: printf("op"); break; 427 case CRNG_KEYWORD: printf("keyword"); break; 428 case CRNG_IDENTIFIER: printf("identifier"); break; 429 case CRNG_LITERAL_SEGMENT: printf("literal"); break; 430 case CRNG_CNAME: printf("cname"); break; 431 case CRNG_QNAME: printf("qname"); break; 432 case CRNG_NSNAME: printf("nsname"); break; 433 case CRNG_DOCUMENTATION: printf("doc"); break; 434 } 435 printf(":%s\n", token->token); 436 xmlParseCRNGDropTokens(ctxt, 1); 437 token = xmlParseCRNGGetToken(ctxt, 1); 438 } 439 } 440 441 /** 442 * xmlParseCRNG_attribute: 443 * @ctxt: a compact RNG parser context 444 * @name: the attribute name 445 * @ns: the attribute namespace 446 * @value: the attribute value 447 * 448 * implements attribute of the RELAX NG Compact Syntax Appendix A 449 * 450 * Returns 0 in case of success and -1 in case of error 451 */ 452 static int 453 xmlParseCRNG_attribute(xmlCRelaxNGParserCtxtPtr ctxt, 454 const xmlChar *name, 455 xmlNsPtr ns, 456 const xmlChar *value) 457 { 458 xmlAttrPtr attr; 459 460 attr = xmlNewNsPropEatName(NULL, ns, (xmlChar *) name, value); 461 if (attr == NULL) CRNG_MEM_ERROR0(); 462 attr->next = ctxt->attrs; 463 if (ctxt->attrs != NULL) 464 ctxt->attrs->prev = attr; 465 ctxt->attrs = attr; 466 return(0); 467 } 468 469 /** 470 * xmlParseCRNG_bindPrefix: 471 * @ctxt: a compact RNG parser context 472 * @prefix: the namespace prefix or NULL 473 * @namespace: the namespace name 474 * 475 * implements bindPrefix of the RELAX NG Compact Syntax Appendix A 476 * 477 * Returns 0 in case of success and -1 in case of error 478 */ 479 static int 480 xmlParseCRNG_bindPrefix(xmlCRelaxNGParserCtxtPtr ctxt, 481 const xmlChar *prefix, 482 const xmlChar *namespace) 483 { 484 int ret; 485 486 if ((prefix != NULL) && (xmlStrEqual(prefix, BAD_CAST "xml")) && 487 (!xmlStrEqual(namespace, XML_XML_NAMESPACE))) { 488 ERROR("The \"xml\" prefix must be bound to \"http://www.w3.org/XML/1998/namespace\""); 489 return(-1); 490 } else if ((xmlStrEqual(namespace, XML_XML_NAMESPACE)) && 491 (!xmlStrEqual(prefix, BAD_CAST "xml"))) { 492 ERROR("The \"http://www.w3.org/XML/1998/namespace\" name must be bound to \"xml\" prefix"); 493 return(-1); 494 } 495 if (ctxt->namespaces == NULL) 496 ctxt->namespaces = xmlHashCreate(10); 497 if (ctxt->namespaces == NULL) { 498 ERROR("Failed to create namespace hash table"); 499 return(-1); 500 } 501 if (prefix == NULL) 502 ret = xmlHashAddEntry(ctxt->namespaces, xmlCRelaxNGDefault, 503 (void *) namespace); 504 else 505 ret = xmlHashAddEntry(ctxt->namespaces, prefix, 506 (void *) namespace); 507 if (ret < 0) { 508 if (prefix == NULL) { 509 ERROR("Redefinition of default namespace"); 510 } else { 511 ERROR("Redefinition of namespace"); 512 } 513 return(-1); 514 } 515 516 return(0); 517 } 518 519 /** 520 * xmlParseCRNG_bindDatatypePrefix: 521 * @ctxt: a compact RNG parser context 522 * @prefix: the datatype prefix 523 * @namespace: the datatype identifier 524 * 525 * implements bindDatatypePrefix of the RELAX NG Compact Syntax Appendix A 526 * 527 * Returns 0 in case of success and -1 in case of error 528 */ 529 static int 530 xmlParseCRNG_bindDatatypePrefix(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED, 531 const xmlChar *prefix, 532 const xmlChar *namespace) 533 { 534 int ret; 535 536 if ((prefix != NULL) && (xmlStrEqual(prefix, BAD_CAST "xsd")) && 537 (!xmlStrEqual(namespace, 538 BAD_CAST "http://www.w3.org/2001/XMLSchema-datatypes"))) { 539 ERROR("The \"xsd\" prefix must be bound to \"http://www.w3.org/2001/XMLSchema-datatypes\""); 540 return(-1); 541 } 542 if (ctxt->datatypes == NULL) 543 ctxt->datatypes = xmlHashCreate(10); 544 if (ctxt->datatypes == NULL) { 545 ERROR("Failed to create namespace hash table"); 546 return(-1); 547 } 548 ret = xmlHashAddEntry(ctxt->datatypes, prefix, 549 (void *) namespace); 550 if (ret < 0) { 551 ERROR("Redefinition of datatype"); 552 return(-1); 553 } 554 return(0); 555 } 556 557 /** 558 * xmlParseCRNG_lookupPrefix: 559 * @ctxt: a compact RNG parser context 560 * @prefix: the namespace prefix or NULL 561 * 562 * implements lookupPrefix of the RELAX NG Compact Syntax Appendix A 563 * 564 * Returns the prefix in case of success or NULL in case of error 565 */ 566 static const xmlChar * 567 xmlParseCRNG_lookupPrefix(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED, 568 const xmlChar *prefix) 569 { 570 const xmlChar *ret; 571 572 if (prefix == NULL) 573 ret = xmlHashLookup(ctxt->namespaces, xmlCRelaxNGDefault); 574 else 575 ret = xmlHashLookup(ctxt->namespaces, prefix); 576 return(ret); 577 } 578 579 /** 580 * xmlParseCRNG_lookupDatatypePrefix: 581 * @ctxt: a compact RNG parser context 582 * @prefix: the namespace prefix or NULL 583 * 584 * implements lookupDatatypePrefix of the RELAX NG Compact Syntax Appendix A 585 * 586 * Returns the prefix in case of success or NULL in case of error 587 */ 588 static const xmlChar * 589 xmlParseCRNG_lookupDatatypePrefix(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED, 590 const xmlChar *prefix) 591 { 592 const xmlChar *ret; 593 ret = xmlHashLookup(ctxt->datatypes, prefix); 594 return(ret); 595 } 596 597 /** 598 * xmlParseCRNG_datatypeAttributes: 599 * @ctxt: a compact RNG parser context 600 * @prefix: the namespace prefix or NULL 601 * 602 * implements lookupPrefix of the RELAX NG Compact Syntax Appendix A 603 * 604 * Returns the prefix in case of success or NULL in case of error 605 */ 606 static xmlAttrPtr 607 xmlParseCRNG_datatypeAttributes(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED, 608 const xmlChar *library, const xmlChar *type) 609 { 610 xmlAttrPtr lib, typ; 611 612 lib = xmlNewNsProp(NULL, NULL, BAD_CAST "datatypeLibrary", library); 613 if (lib == NULL) { 614 CRNG_MEM_ERROR(); 615 return(NULL); 616 } 617 typ = xmlNewNsProp(NULL, NULL, BAD_CAST "type", type); 618 if (typ == NULL) { 619 CRNG_MEM_ERROR(); 620 return(lib); 621 } 622 lib->next = typ; 623 624 return(lib); 625 } 626 627 /** 628 * xmlParseCRNG_XXX: 629 * @ctxt: a compact RNG parser context 630 * 631 * Parse XXX of the RELAX NG Compact Syntax Appendix A 632 * 633 * Returns 0 in case of success and -1 in case of error 634 */ 635 static int 636 xmlParseCRNG_XXX(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED) 637 { 638 return(0); 639 } 640 641 static int xmlParseCRNG_pattern(xmlCRelaxNGParserCtxtPtr ctxt); 642 static int xmlParseCRNG_nameClass(xmlCRelaxNGParserCtxtPtr ctxt); 643 644 /** 645 * xmlParseCRNG_params: 646 * @ctxt: a compact RNG parser context 647 * 648 * Parse params of the RELAX NG Compact Syntax Appendix A 649 * 650 * Returns 0 in case of success and -1 in case of error 651 */ 652 static int 653 xmlParseCRNG_params(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED) 654 { 655 TODO 656 return(0); 657 } 658 659 /** 660 * xmlParseCRNG_exceptNameClass: 661 * @ctxt: a compact RNG parser context 662 * 663 * Parse exceptNameClass of the RELAX NG Compact Syntax Appendix A 664 * 665 * Returns 0 in case of success and -1 in case of error 666 */ 667 static int 668 xmlParseCRNG_exceptNameClass(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED) 669 { 670 tokenPtr token; 671 xmlNodePtr insert = ctxt->insert, cur; 672 673 token = xmlParseCRNGGetToken(ctxt, 1); 674 if ((token->toktype == CRNG_OP) && 675 (token->token[0] == '-') && (token->token[1] == 0)) { 676 xmlParseCRNGDropTokens(ctxt, 1); 677 cur = xmlNewNode(NULL, BAD_CAST "except"); 678 if (cur == NULL) CRNG_MEM_ERROR0(); 679 if (ctxt->insert != NULL) 680 xmlAddChild(ctxt->insert, cur); 681 ctxt->insert = cur; 682 xmlParseCRNG_nameClass(ctxt); 683 } 684 ctxt->insert = insert; 685 return(0); 686 } 687 688 /** 689 * xmlParseCRNG_innerNameClass: 690 * @ctxt: a compact RNG parser context 691 * 692 * Parse innerNameClass of the RELAX NG Compact Syntax Appendix A 693 * 694 * Returns 0 in case of success and -1 in case of error 695 */ 696 static int 697 xmlParseCRNG_innerNameClass(xmlCRelaxNGParserCtxtPtr ctxt) 698 { 699 tokenPtr token; 700 xmlNodePtr cur; 701 702 token = xmlParseCRNGGetToken(ctxt, 1); 703 if (token->toktype == CRNG_OP) { 704 if ((token->token[0] == '(') && (token->token[1] == 0)) { 705 xmlParseCRNGDropTokens(ctxt, 1); 706 xmlParseCRNG_nameClass(ctxt); 707 token = xmlParseCRNGGetToken(ctxt, 1); 708 if ((token->toktype != CRNG_OP) || 709 (token->token[0] != ')') || (token->token[1] != 0)) { 710 ERROR("Expecting \")\" here"); 711 } 712 xmlParseCRNGDropTokens(ctxt, 1); 713 } else if ((token->token[0] == '*') && (token->token[1] == 0)) { 714 xmlParseCRNGDropTokens(ctxt, 1); 715 cur = xmlNewNode(NULL, BAD_CAST "anyName"); 716 if (cur == NULL) CRNG_MEM_ERROR0(); 717 if (ctxt->insert != NULL) 718 xmlAddChild(ctxt->insert, cur); 719 ctxt->insert = cur; 720 xmlParseCRNG_exceptNameClass(ctxt); 721 } else { 722 TODO 723 } 724 } else if ((token->toktype == CRNG_IDENTIFIER) || 725 (token->toktype == CRNG_KEYWORD)) { 726 cur = xmlNewNode(NULL, BAD_CAST "name"); 727 if (cur == NULL) CRNG_MEM_ERROR0(); 728 if (ctxt->isElem) { 729 xmlSetProp(cur, BAD_CAST "ns", 730 xmlParseCRNG_lookupPrefix(ctxt, NULL)); 731 } else { 732 xmlSetProp(cur, BAD_CAST "ns", BAD_CAST ""); 733 } 734 xmlNodeAddContent(cur, token->token); 735 if (ctxt->insert != NULL) 736 xmlAddChild(ctxt->insert, cur); 737 ctxt->insert = cur; 738 xmlParseCRNGDropTokens(ctxt, 1); 739 } else if (token->toktype == CRNG_CNAME) { 740 TODO 741 } else if (token->toktype == CRNG_NSNAME) { 742 cur = xmlNewNode(NULL, BAD_CAST "nsName"); 743 if (cur == NULL) CRNG_MEM_ERROR0(); 744 xmlSetProp(cur, BAD_CAST "ns", 745 xmlParseCRNG_lookupPrefix(ctxt, token->token)); 746 if (ctxt->insert != NULL) 747 xmlAddChild(ctxt->insert, cur); 748 ctxt->insert = cur; 749 xmlParseCRNGDropTokens(ctxt, 1); 750 xmlParseCRNG_exceptNameClass(ctxt); 751 } else { 752 TODO /* probably an error */ 753 } 754 755 return(0); 756 } 757 758 /** 759 * xmlParseCRNG_nameClass: 760 * @ctxt: a compact RNG parser context 761 * 762 * Parse nameClass of the RELAX NG Compact Syntax Appendix A 763 * 764 * Returns 0 in case of success and -1 in case of error 765 */ 766 static int 767 xmlParseCRNG_nameClass(xmlCRelaxNGParserCtxtPtr ctxt) 768 { 769 tokenPtr token; 770 xmlNodePtr insert = ctxt->insert, last, choice; 771 772 ctxt->insert = NULL; 773 xmlParseCRNG_innerNameClass(ctxt); 774 last = ctxt->insert; 775 token = xmlParseCRNGGetToken(ctxt, 1); 776 while ((token->toktype == CRNG_OP) && 777 (token->token[0] == '|') && (token->token[1] == 0)) { 778 choice = xmlNewNodeEatName(NULL, (xmlChar *) ctxt->key_choice); 779 xmlParseCRNGDropTokens(ctxt, 1); 780 if (choice == NULL) CRNG_MEM_ERROR0(); 781 ctxt->insert = NULL; 782 xmlParseCRNG_innerNameClass(ctxt); 783 xmlAddChild(choice, last); 784 xmlAddChild(choice, ctxt->insert); 785 last = choice; 786 token = xmlParseCRNGGetToken(ctxt, 1); 787 } 788 xmlAddChild(insert, last); 789 790 ctxt->insert = insert; 791 return(0); 792 } 793 794 /** 795 * xmlParseCRNG_patternBlock: 796 * @ctxt: a compact RNG parser context 797 * 798 * Parse a pattern block of the RELAX NG Compact Syntax Appendix A 799 * 800 * Returns 0 in case of success and -1 in case of error 801 */ 802 static int 803 xmlParseCRNG_patternBlock(xmlCRelaxNGParserCtxtPtr ctxt) 804 { 805 tokenPtr token; 806 807 token = xmlParseCRNGGetToken(ctxt, 1); 808 if ((token->toktype != CRNG_OP) || 809 (token->token[0] != '{') || (token->token[1] != 0)) { 810 ERROR("Expecting \"{\" here"); 811 } 812 xmlParseCRNGDropTokens(ctxt, 1); 813 xmlParseCRNG_pattern(ctxt); 814 token = xmlParseCRNGGetToken(ctxt, 1); 815 if ((token->toktype != CRNG_OP) || 816 (token->token[0] != '}') || (token->token[1] != 0)) { 817 ERROR("Expecting \"}\" here"); 818 } 819 xmlParseCRNGDropTokens(ctxt, 1); 820 return(0); 821 } 822 823 /** 824 * xmlParseCRNG_datatype: 825 * @ctxt: a compact RNG parser context 826 * 827 * Parse datatype of the RELAX NG Compact Syntax Appendix A 828 * 829 * Returns 0 in case of success and -1 in case of error 830 */ 831 static int 832 xmlParseCRNG_datatype(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED) 833 { 834 tokenPtr token; 835 xmlAttrPtr attrs = NULL; 836 837 token = xmlParseCRNGGetToken(ctxt, 1); 838 if (token->toktype == CRNG_KEYWORD) { 839 if (token->token == ctxt->key_string) { 840 attrs = xmlParseCRNG_datatypeAttributes(ctxt, BAD_CAST "", 841 token->token); 842 xmlParseCRNGDropTokens(ctxt, 1); 843 } else if (token->token == ctxt->key_token) { 844 attrs = xmlParseCRNG_datatypeAttributes(ctxt, BAD_CAST "", 845 token->token); 846 xmlParseCRNGDropTokens(ctxt, 1); 847 } else { 848 TODO /* probably an error */ 849 } 850 } else if (token->toktype == CRNG_LITERAL_SEGMENT) { 851 ctxt->insert = xmlNewNode(NULL, BAD_CAST "value"); 852 xmlParseCRNGDropTokens(ctxt, 1); 853 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 854 xmlNodeAddContent(ctxt->insert, token->token); 855 } else if (token->toktype == CRNG_QNAME) { 856 attrs = xmlParseCRNG_datatypeAttributes(ctxt, 857 xmlParseCRNG_lookupDatatypePrefix(ctxt, token->prefix), 858 token->token); 859 } else { 860 TODO 861 } 862 if (attrs != NULL) { 863 token = xmlParseCRNGGetToken(ctxt, 1); 864 if (token->toktype == CRNG_LITERAL_SEGMENT) { 865 ctxt->insert = xmlNewNode(NULL, BAD_CAST "value"); 866 xmlParseCRNGDropTokens(ctxt, 1); 867 if (ctxt->insert == NULL) { 868 xmlFreePropList(attrs); 869 CRNG_MEM_ERROR0(); 870 } 871 ctxt->insert->properties = attrs; 872 xmlNodeAddContent(ctxt->insert, token->token); 873 } else if ((token->toktype == CRNG_OP) && 874 (token->token[0] == '{') && (token->token[0] == 0)) { 875 ctxt->insert = xmlNewNode(NULL, BAD_CAST "data"); 876 xmlParseCRNGDropTokens(ctxt, 1); 877 if (ctxt->insert == NULL) { 878 xmlFreePropList(attrs); 879 CRNG_MEM_ERROR0(); 880 } 881 ctxt->insert->properties = attrs; 882 xmlParseCRNG_params(ctxt); 883 } else { 884 ctxt->insert = xmlNewNode(NULL, BAD_CAST "data"); 885 xmlParseCRNGDropTokens(ctxt, 1); 886 if (ctxt->insert == NULL) { 887 xmlFreePropList(attrs); 888 CRNG_MEM_ERROR0(); 889 } 890 ctxt->insert->properties = attrs; 891 xmlNodeAddContent(ctxt->insert, token->token); 892 } 893 } 894 return(0); 895 } 896 897 /** 898 * xmlParseCRNG_primary: 899 * @ctxt: a compact RNG parser context 900 * 901 * Parse primary of the RELAX NG Compact Syntax Appendix A 902 * 903 * Returns 0 in case of success and -1 in case of error 904 */ 905 static int 906 xmlParseCRNG_primary(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED) 907 { 908 tokenPtr token; 909 910 token = xmlParseCRNGGetToken(ctxt, 1); 911 if (token == NULL) 912 return(0); 913 if (token->toktype == CRNG_KEYWORD) { 914 if (token->token == ctxt->key_element) { 915 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) token->token); 916 xmlParseCRNGDropTokens(ctxt, 1); 917 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 918 ctxt->isElem = 1; 919 xmlParseCRNG_nameClass(ctxt); 920 xmlParseCRNG_patternBlock(ctxt); 921 } else if (token->token == ctxt->key_attribute) { 922 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) token->token); 923 xmlParseCRNGDropTokens(ctxt, 1); 924 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 925 ctxt->isElem = 0; 926 xmlParseCRNG_nameClass(ctxt); 927 xmlParseCRNG_patternBlock(ctxt); 928 } else if (token->token == ctxt->key_mixed) { 929 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) token->token); 930 xmlParseCRNGDropTokens(ctxt, 1); 931 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 932 xmlParseCRNG_patternBlock(ctxt); 933 } else if (token->token == ctxt->key_list) { 934 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) token->token); 935 xmlParseCRNGDropTokens(ctxt, 1); 936 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 937 xmlParseCRNG_patternBlock(ctxt); 938 } else if (token->token == ctxt->key_empty) { 939 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) token->token); 940 xmlParseCRNGDropTokens(ctxt, 1); 941 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 942 } else if (token->token == ctxt->key_notAllowed) { 943 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) token->token); 944 xmlParseCRNGDropTokens(ctxt, 1); 945 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 946 } else if (token->token == ctxt->key_text) { 947 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) token->token); 948 xmlParseCRNGDropTokens(ctxt, 1); 949 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 950 } else if (token->token == ctxt->key_parent) { 951 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) token->token); 952 xmlParseCRNGDropTokens(ctxt, 1); 953 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 954 TODO 955 } else if (token->token == ctxt->key_grammar) { 956 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) token->token); 957 xmlParseCRNGDropTokens(ctxt, 1); 958 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 959 TODO 960 } else if (token->token == ctxt->key_external) { 961 ctxt->insert = xmlNewNode(NULL, BAD_CAST "externalRef"); 962 xmlParseCRNGDropTokens(ctxt, 1); 963 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 964 TODO 965 } else { 966 TODO 967 } 968 } else if (token->toktype == CRNG_IDENTIFIER) { 969 ctxt->insert = xmlNewNodeEatName(NULL, (xmlChar *) ctxt->key_ref); 970 if (ctxt->insert == NULL) CRNG_MEM_ERROR0(); 971 xmlSetProp(ctxt->insert, BAD_CAST "name", token->token); 972 xmlParseCRNGDropTokens(ctxt, 1); 973 } else if (token->toktype == CRNG_QNAME) { 974 xmlParseCRNG_datatype(ctxt); 975 } else if (token->toktype == CRNG_LITERAL_SEGMENT) { 976 xmlParseCRNG_datatype(ctxt); 977 } else if ((token->toktype == CRNG_OP) && 978 (token->token[0] == '(') && (token->token[1] == 0)) { 979 xmlParseCRNGDropTokens(ctxt, 1); 980 xmlParseCRNG_pattern(ctxt); 981 token = xmlParseCRNGGetToken(ctxt, 1); 982 if ((token->toktype != CRNG_OP) || 983 (token->token[0] != ')') || (token->token[1] != 0)) { 984 ERROR("Expecting \")\" here"); 985 } 986 xmlParseCRNGDropTokens(ctxt, 1); 987 } 988 return(0); 989 } 990 991 /** 992 * xmlParseCRNG_particle: 993 * @ctxt: a compact RNG parser context 994 * 995 * Parse particle of the RELAX NG Compact Syntax Appendix A 996 * 997 * Returns 0 in case of success and -1 in case of error 998 */ 999 static int 1000 xmlParseCRNG_particle(xmlCRelaxNGParserCtxtPtr ctxt) 1001 { 1002 tokenPtr token; 1003 xmlNodePtr insert = ctxt->insert, res, tmp = NULL; 1004 1005 ctxt->insert = NULL; 1006 xmlParseCRNG_primary(ctxt); 1007 res = ctxt->insert; 1008 token = xmlParseCRNGGetToken(ctxt, 1); 1009 if ((token != NULL) && (token->toktype == CRNG_OP)) { 1010 if ((token->token[0] == '*') && (token->token[1] == 0)) { 1011 tmp = xmlNewNode(NULL, BAD_CAST "zeroOrMore"); 1012 if (tmp == NULL) CRNG_MEM_ERROR0(); 1013 } else if ((token->token[0] == '+') && (token->token[1] == 0)) { 1014 tmp = xmlNewNode(NULL, BAD_CAST "oneOrMore"); 1015 if (tmp == NULL) CRNG_MEM_ERROR0(); 1016 } else if ((token->token[0] == '?') && (token->token[1] == 0)) { 1017 tmp = xmlNewNode(NULL, BAD_CAST "optional"); 1018 if (tmp == NULL) CRNG_MEM_ERROR0(); 1019 } 1020 if (tmp != NULL) { 1021 xmlAddChild(tmp, res); 1022 res = tmp; 1023 xmlParseCRNGDropTokens(ctxt, 1); 1024 } 1025 } 1026 if (insert != NULL) { 1027 xmlAddChild(insert, res); 1028 ctxt->insert = insert; 1029 } else 1030 ctxt->insert = res; 1031 return(0); 1032 } 1033 1034 /** 1035 * xmlParseCRNG_pattern: 1036 * @ctxt: a compact RNG parser context 1037 * 1038 * Parse pattern of the RELAX NG Compact Syntax Appendix A 1039 * 1040 * Returns 0 in case of success and -1 in case of error 1041 */ 1042 static int 1043 xmlParseCRNG_pattern(xmlCRelaxNGParserCtxtPtr ctxt) 1044 { 1045 tokenPtr token; 1046 xmlNodePtr insert = ctxt->insert, prev, grp; 1047 1048 ctxt->insert = NULL; 1049 xmlParseCRNG_particle(ctxt); 1050 prev = ctxt->insert; 1051 token = xmlParseCRNGGetToken(ctxt, 1); 1052 while ((prev != NULL) && (token != NULL) && (token->toktype == CRNG_OP)) { 1053 if (token->token == ctxt->key_or) { 1054 grp = xmlNewNodeEatName(NULL, (xmlChar *) ctxt->key_choice); 1055 if (grp == NULL) CRNG_MEM_ERROR0(); 1056 } else if (token->token == ctxt->key_and) { 1057 grp = xmlNewNodeEatName(NULL, (xmlChar *) ctxt->key_interleave); 1058 if (grp == NULL) CRNG_MEM_ERROR0(); 1059 } else if (token->token == ctxt->key_comma) { 1060 grp = xmlNewNodeEatName(NULL, (xmlChar *) ctxt->key_group); 1061 if (grp == NULL) CRNG_MEM_ERROR0(); 1062 } else 1063 break; 1064 xmlParseCRNGDropTokens(ctxt, 1); 1065 ctxt->insert = NULL; 1066 xmlParseCRNG_particle(ctxt); 1067 xmlAddChild(grp, prev); 1068 xmlAddChild(grp, ctxt->insert); 1069 prev = grp; 1070 token = xmlParseCRNGGetToken(ctxt, 1); 1071 } 1072 if (insert != NULL) { 1073 xmlAddChild(insert, prev); 1074 ctxt->insert = insert; 1075 } else { 1076 ctxt->insert = prev; 1077 } 1078 1079 return(0); 1080 } 1081 1082 /** 1083 * xmlParseCRNG_component: 1084 * @ctxt: a compact RNG parser context 1085 * 1086 * Parse component of the RELAX NG Compact Syntax Appendix A 1087 * 1088 * Returns 0 in case of success and -1 in case of error 1089 */ 1090 static int 1091 xmlParseCRNG_component(xmlCRelaxNGParserCtxtPtr ctxt) 1092 { 1093 tokenPtr token, tok2; 1094 xmlNodePtr insert = ctxt->insert; 1095 1096 token = xmlParseCRNGGetToken(ctxt, 1); 1097 if (token == NULL) 1098 return(0); 1099 if (token->toktype == CRNG_KEYWORD) { 1100 if (token->token == ctxt->key_start) { 1101 xmlNodePtr start; 1102 1103 start = xmlNewNodeEatName(NULL, (xmlChar *) ctxt->key_start); 1104 if (start == NULL) CRNG_MEM_ERROR0(); 1105 if (ctxt->insert != NULL) 1106 xmlAddChild(ctxt->insert, start); 1107 ctxt->insert = start; 1108 xmlParseCRNGDropTokens(ctxt, 1); 1109 token = xmlParseCRNGGetToken(ctxt, 1); 1110 1111 if ((token->toktype == CRNG_OP) && 1112 (token->token == ctxt->key_equal)) { 1113 } else if ((token->toktype == CRNG_OP) && 1114 (token->token == ctxt->key_orequal)) { 1115 xmlParseCRNG_attribute(ctxt, ctxt->key_combine, NULL, 1116 BAD_CAST "choice"); 1117 } else if ((token->toktype == CRNG_OP) && 1118 (token->token == ctxt->key_andequal)) { 1119 xmlParseCRNG_attribute(ctxt, ctxt->key_combine, NULL, 1120 BAD_CAST "interleave"); 1121 } else { 1122 ERROR("expecting \"=\" or \"&=\" or \"|=\" here") 1123 return(-1); 1124 } 1125 start->properties = ctxt->attrs; 1126 ctxt->attrs = NULL; 1127 xmlParseCRNGDropTokens(ctxt, 1); 1128 xmlParseCRNG_pattern(ctxt); 1129 1130 } else if (token->token == ctxt->key_include) { 1131 TODO 1132 } else if (token->token == ctxt->key_div) { 1133 TODO 1134 } else { 1135 return(-1); 1136 } 1137 } else if (token->toktype == CRNG_IDENTIFIER) { 1138 xmlNodePtr define; 1139 const xmlChar *identifier; 1140 1141 identifier = token->token; 1142 tok2 = xmlParseCRNGGetToken(ctxt, 2); 1143 if ((tok2->toktype == CRNG_OP) && 1144 (tok2->token == ctxt->key_equal)) { 1145 } else if ((tok2->toktype == CRNG_OP) && 1146 (tok2->token == ctxt->key_orequal)) { 1147 xmlParseCRNG_attribute(ctxt, ctxt->key_combine, NULL, 1148 BAD_CAST "choice"); 1149 } else if ((tok2->toktype == CRNG_OP) && 1150 (tok2->token == ctxt->key_andequal)) { 1151 xmlParseCRNG_attribute(ctxt, ctxt->key_combine, NULL, 1152 BAD_CAST "interleave"); 1153 } else { 1154 ERROR("expecting \"=\" or \"&=\" or \"|=\" here") 1155 return(-1); 1156 } 1157 xmlParseCRNGDropTokens(ctxt, 2); 1158 1159 define = xmlNewNodeEatName(NULL, (xmlChar *) ctxt->key_define); 1160 if (define == NULL) CRNG_MEM_ERROR0(); 1161 define->properties = ctxt->attrs; 1162 ctxt->attrs = NULL; 1163 xmlSetProp(define, BAD_CAST "name", identifier); 1164 if (ctxt->insert != NULL) 1165 xmlAddChild(ctxt->insert, define); 1166 ctxt->insert = define; 1167 xmlParseCRNG_pattern(ctxt); 1168 } else { 1169 return(-1); 1170 } 1171 ctxt->insert = insert; 1172 return(0); 1173 } 1174 1175 /** 1176 * xmlParseCRNG_grammar: 1177 * @ctxt: a compact RNG parser context 1178 * 1179 * Parse grammar of the RELAX NG Compact Syntax Appendix A 1180 * 1181 * Returns 0 in case of success and -1 in case of error 1182 */ 1183 static int 1184 xmlParseCRNG_grammar(xmlCRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED) 1185 { 1186 tokenPtr token; 1187 int ret; 1188 1189 token = xmlParseCRNGGetToken(ctxt, 1); 1190 while (token != NULL) { 1191 ret = xmlParseCRNG_component(ctxt); 1192 if (ret != 0) 1193 break; 1194 token = xmlParseCRNGGetToken(ctxt, 1); 1195 } 1196 return(0); 1197 } 1198 1199 /** 1200 * xmlParseCRNG_topLevelBody: 1201 * @ctxt: a compact RNG parser context 1202 * 1203 * Parse topLevelBody of the RELAX NG Compact Syntax Appendix A 1204 * 1205 * Returns 0 in case of success and -1 in case of error 1206 */ 1207 static int 1208 xmlParseCRNG_topLevelBody(xmlCRelaxNGParserCtxtPtr ctxt) 1209 { 1210 tokenPtr token, tok2; 1211 1212 token = xmlParseCRNGGetToken(ctxt, 1); 1213 if (token->toktype == CRNG_KEYWORD) { 1214 if ((token->token == ctxt->key_start) || 1215 (token->token == ctxt->key_include) || 1216 (token->token == ctxt->key_div)) { 1217 xmlNodePtr grammar; 1218 1219 grammar = xmlNewNodeEatName(NULL, (xmlChar *) ctxt->key_grammar); 1220 if (grammar == NULL) CRNG_MEM_ERROR0(); 1221 xmlDocSetRootElement(ctxt->doc, grammar); 1222 ctxt->insert = grammar; 1223 1224 xmlParseCRNG_grammar(ctxt); 1225 } else { 1226 xmlParseCRNG_pattern(ctxt); 1227 } 1228 } else { 1229 tok2 = xmlParseCRNGGetToken(ctxt, 2); 1230 if ((tok2->toktype == CRNG_OP) && 1231 ((tok2->token == ctxt->key_equal) || 1232 (tok2->token == ctxt->key_orequal) || 1233 (tok2->token == ctxt->key_andequal))) { 1234 xmlNodePtr grammar; 1235 1236 grammar = xmlNewNodeEatName(NULL, (xmlChar *) ctxt->key_grammar); 1237 if (grammar == NULL) CRNG_MEM_ERROR0(); 1238 xmlDocSetRootElement(ctxt->doc, grammar); 1239 ctxt->insert = grammar; 1240 1241 xmlParseCRNG_grammar(ctxt); 1242 } else { 1243 xmlParseCRNG_pattern(ctxt); 1244 } 1245 } 1246 return(0); 1247 } 1248 1249 /** 1250 * xmlParseCRNG_namespacePrefix: 1251 * @ctxt: a compact RNG parser context 1252 * 1253 * Parse namespacePrefix of the RELAX NG Compact Syntax Appendix A 1254 * 1255 * Returns the prefix or NULL in case of error 1256 */ 1257 static const xmlChar * 1258 xmlParseCRNG_namespacePrefix(xmlCRelaxNGParserCtxtPtr ctxt) 1259 { 1260 tokenPtr token; 1261 const xmlChar *prefix = NULL; 1262 1263 token = xmlParseCRNGGetToken(ctxt, 1); 1264 if (token->toktype == CRNG_IDENTIFIER) { 1265 prefix = token->token; 1266 } else if (token->toktype == CRNG_OP) { 1267 if ((token->token[0] == '=') && (token->token[1] == 0)) 1268 return(NULL); 1269 prefix = token->token; 1270 } else { 1271 ERROR("Expecting a namespace prefix"); 1272 return(NULL); 1273 } 1274 xmlParseCRNGDropTokens(ctxt, 1); 1275 1276 if (xmlStrEqual(prefix, BAD_CAST "xmlns")) { 1277 ERROR("Namespace prefix \"xmlns\" is forbidden"); 1278 } 1279 return(prefix); 1280 } 1281 1282 /** 1283 * xmlParseCRNG_decl: 1284 * @ctxt: a compact RNG parser context 1285 * 1286 * Parse decl of the RELAX NG Compact Syntax Appendix A 1287 * 1288 * Returns 0 in case of success and -1 in case of error 1289 */ 1290 static int 1291 xmlParseCRNG_decl(xmlCRelaxNGParserCtxtPtr ctxt) 1292 { 1293 const xmlChar *prefix = NULL; 1294 const xmlChar *namespace = NULL; 1295 tokenPtr token; 1296 1297 token = xmlParseCRNGGetToken(ctxt, 1); 1298 if (token->toktype != CRNG_KEYWORD) return(-1); 1299 if (token->token == ctxt->key_default) { 1300 xmlParseCRNGDropTokens(ctxt, 1); 1301 token = xmlParseCRNGGetToken(ctxt, 1); 1302 if ((token->toktype != CRNG_KEYWORD) || 1303 (token->token != ctxt->key_namespace)) { 1304 ERROR("Expecting keyword \"namespace\" after \"default\""); 1305 } 1306 xmlParseCRNGDropTokens(ctxt, 1); 1307 prefix = xmlParseCRNG_namespacePrefix(ctxt); 1308 token = xmlParseCRNGGetToken(ctxt, 1); 1309 if ((token->toktype != CRNG_OP) || 1310 (token->token[0] != '=') || (token->token[1] != 0)) { 1311 ERROR("Expecting keyword \"=\" here"); 1312 } 1313 xmlParseCRNGDropTokens(ctxt, 1); 1314 token = xmlParseCRNGGetToken(ctxt, 1); 1315 if ((token->toktype == CRNG_KEYWORD) && 1316 (token->token == ctxt->key_inherit)) { 1317 namespace = xmlCRelaxNGInherit; 1318 } else if (token->toktype == CRNG_LITERAL_SEGMENT) { 1319 namespace = token->token; 1320 } else { 1321 ERROR("Expecting an URI or \"inherit\" value"); 1322 } 1323 xmlParseCRNGDropTokens(ctxt, 1); 1324 if (namespace != NULL) { 1325 if (prefix != NULL) 1326 xmlParseCRNG_bindPrefix(ctxt, prefix, namespace); 1327 xmlParseCRNG_bindPrefix(ctxt, NULL, namespace); 1328 } 1329 } else if (token->token == ctxt->key_namespace) { 1330 xmlParseCRNGDropTokens(ctxt, 1); 1331 prefix = xmlParseCRNG_namespacePrefix(ctxt); 1332 token = xmlParseCRNGGetToken(ctxt, 1); 1333 if ((token->toktype != CRNG_OP) || 1334 (token->token[0] != '=') || (token->token[1] != 0)) { 1335 ERROR("Expecting keyword \"=\" here"); 1336 } 1337 xmlParseCRNGDropTokens(ctxt, 1); 1338 token = xmlParseCRNGGetToken(ctxt, 1); 1339 if ((token->toktype == CRNG_KEYWORD) && 1340 (token->token == ctxt->key_inherit)) { 1341 namespace = xmlCRelaxNGInherit; 1342 } else if (token->toktype == CRNG_LITERAL_SEGMENT) { 1343 namespace = token->token; 1344 } else { 1345 ERROR("Expecting an URI or \"inherit\" value"); 1346 } 1347 xmlParseCRNGDropTokens(ctxt, 1); 1348 if (namespace != NULL) 1349 xmlParseCRNG_bindPrefix(ctxt, prefix, namespace); 1350 } else if (token->token == ctxt->key_datatypes) { 1351 xmlParseCRNGDropTokens(ctxt, 1); 1352 1353 token = xmlParseCRNGGetToken(ctxt, 1); 1354 if ((token->toktype != CRNG_KEYWORD) && 1355 (token->toktype != CRNG_IDENTIFIER)) { 1356 ERROR("Expecting a datatype prefix identifier here"); 1357 } else 1358 prefix = token->token; 1359 xmlParseCRNGDropTokens(ctxt, 1); 1360 token = xmlParseCRNGGetToken(ctxt, 1); 1361 if ((token->toktype != CRNG_OP) || 1362 (token->token[0] != '=') || (token->token[1] != 0)) { 1363 ERROR("Expecting keyword \"=\" here"); 1364 } 1365 xmlParseCRNGDropTokens(ctxt, 1); 1366 token = xmlParseCRNGGetToken(ctxt, 1); 1367 if (token->toktype == CRNG_LITERAL_SEGMENT) { 1368 namespace = token->token; 1369 } else { 1370 ERROR("Expecting a literal value for the datatype identifier"); 1371 } 1372 xmlParseCRNGDropTokens(ctxt, 1); 1373 if ((namespace != NULL) && (prefix != NULL)) 1374 xmlParseCRNG_bindDatatypePrefix(ctxt, prefix, namespace); 1375 } 1376 1377 return(0); 1378 } 1379 1380 /** 1381 * xmlParseCRNG_preamble: 1382 * @ctxt: a compact RNG parser context 1383 * 1384 * Parse preamble of the RELAX NG Compact Syntax Appendix A 1385 * 1386 * Returns 0 in case of success and -1 in case of error 1387 */ 1388 static int 1389 xmlParseCRNG_preamble(xmlCRelaxNGParserCtxtPtr ctxt) 1390 { 1391 tokenPtr token; 1392 1393 token = xmlParseCRNGGetToken(ctxt, 1); 1394 while (token != NULL) { 1395 if (token == NULL) return(-1); 1396 if ((token->toktype == CRNG_KEYWORD) && 1397 ((token->token == ctxt->key_default) || 1398 (token->token == ctxt->key_namespace) || 1399 (token->token == ctxt->key_datatypes))) { 1400 xmlParseCRNG_decl(ctxt); 1401 } else 1402 break; 1403 token = xmlParseCRNGGetToken(ctxt, 1); 1404 } 1405 return(0); 1406 } 1407 1408 /** 1409 * xmlParseCRNG_topLevel: 1410 * @ctxt: a compact RNG parser context 1411 * 1412 * Parse topLevel of the RELAX NG Compact Syntax Appendix A 1413 * 1414 * Returns 0 in case of success and -1 in case of error 1415 */ 1416 static int 1417 xmlParseCRNG_topLevel(xmlCRelaxNGParserCtxtPtr ctxt) 1418 { 1419 xmlParseCRNG_preamble(ctxt); 1420 xmlParseCRNG_topLevelBody(ctxt); 1421 return(0); 1422 } 1423 1424 /** 1425 * xmlConvertCRNG: 1426 * @schemas: pointer to the text of the compact schemas 1427 * @len: length of the schemas in bytes (or 0) 1428 * @encoding: encoding indicated by the context or NULL 1429 * 1430 * Compiles the schemas into the equivalent Relax-NG XML structure 1431 * 1432 * Returns the xmlDocPtr resulting from the compilation or 1433 * NULL in case of error 1434 */ 1435 xmlDocPtr 1436 xmlConvertCRNG(const char *schemas, int len, const char *encoding) { 1437 struct _xmlCRelaxNGParserCtxt ctxt; 1438 xmlDocPtr ret = NULL; 1439 1440 if (schemas == NULL) return(NULL); 1441 if (len <= 5) len = xmlStrlen((const unsigned char *) schemas); 1442 if (len <= 0) return(NULL); 1443 1444 memset(&ctxt, 0, sizeof(ctxt)); 1445 ctxt.compact = (const unsigned char *) schemas; 1446 ctxt.cur = (const unsigned char *) schemas; 1447 ctxt.end = (const unsigned char *) &schemas[len]; 1448 ctxt.dict = xmlDictCreate(); 1449 if (ctxt.dict == NULL) 1450 return(NULL); 1451 ctxt.doc = xmlNewDoc(NULL); 1452 if (ctxt.doc == NULL) { 1453 xmlDictFree(ctxt.dict); 1454 return(NULL); 1455 } 1456 ctxt.doc->dict = ctxt.dict; 1457 xmlDictReference(ctxt.dict); 1458 1459 ctxt.nbTokens = 0; 1460 ctxt.firstToken = 0; 1461 ctxt.key_attribute = xmlDictLookup(ctxt.dict, BAD_CAST "attribute", -1); 1462 ctxt.key_default = xmlDictLookup(ctxt.dict, BAD_CAST "default", -1); 1463 ctxt.key_datatypes = xmlDictLookup(ctxt.dict, BAD_CAST "datatypes", -1); 1464 ctxt.key_div = xmlDictLookup(ctxt.dict, BAD_CAST "div", -1); 1465 ctxt.key_element = xmlDictLookup(ctxt.dict, BAD_CAST "element", -1); 1466 ctxt.key_empty = xmlDictLookup(ctxt.dict, BAD_CAST "empty", -1); 1467 ctxt.key_external = xmlDictLookup(ctxt.dict, BAD_CAST "external", -1); 1468 ctxt.key_grammar = xmlDictLookup(ctxt.dict, BAD_CAST "grammar", -1); 1469 ctxt.key_include = xmlDictLookup(ctxt.dict, BAD_CAST "include", -1); 1470 ctxt.key_inherit = xmlDictLookup(ctxt.dict, BAD_CAST "inherit", -1); 1471 ctxt.key_list = xmlDictLookup(ctxt.dict, BAD_CAST "list", -1); 1472 ctxt.key_mixed = xmlDictLookup(ctxt.dict, BAD_CAST "mixed", -1); 1473 ctxt.key_namespace = xmlDictLookup(ctxt.dict, BAD_CAST "namespace", -1); 1474 ctxt.key_notAllowed = xmlDictLookup(ctxt.dict, BAD_CAST "notAllowed", -1); 1475 ctxt.key_parent = xmlDictLookup(ctxt.dict, BAD_CAST "parent", -1); 1476 ctxt.key_start = xmlDictLookup(ctxt.dict, BAD_CAST "start", -1); 1477 ctxt.key_string = xmlDictLookup(ctxt.dict, BAD_CAST "string", -1); 1478 ctxt.key_text = xmlDictLookup(ctxt.dict, BAD_CAST "text", -1); 1479 ctxt.key_token = xmlDictLookup(ctxt.dict, BAD_CAST "token", -1); 1480 ctxt.key_equal = xmlDictLookup(ctxt.dict, BAD_CAST "=", 1); 1481 ctxt.key_orequal = xmlDictLookup(ctxt.dict, BAD_CAST "|=", 2); 1482 ctxt.key_andequal = xmlDictLookup(ctxt.dict, BAD_CAST "&=", 2); 1483 ctxt.key_combine = xmlDictLookup(ctxt.dict, BAD_CAST "&=", 2); 1484 ctxt.key_or = xmlDictLookup(ctxt.dict, BAD_CAST "|", 1); 1485 ctxt.key_comma = xmlDictLookup(ctxt.dict, BAD_CAST ",", 1); 1486 ctxt.key_and = xmlDictLookup(ctxt.dict, BAD_CAST "&", 1); 1487 ctxt.key_choice = xmlDictLookup(ctxt.dict, BAD_CAST "choice", -1); 1488 ctxt.key_group = xmlDictLookup(ctxt.dict, BAD_CAST "group", -1); 1489 ctxt.key_interleave = xmlDictLookup(ctxt.dict, BAD_CAST "interleave", -1); 1490 ctxt.key_ref = xmlDictLookup(ctxt.dict, BAD_CAST "ref", 3); 1491 ctxt.key_define = xmlDictLookup(ctxt.dict, BAD_CAST "define", 6); 1492 1493 /* xmlConvertCRNGTokenize(&ctxt); */ 1494 xmlConvertCRNG_topLevel(&ctxt); 1495 1496 xmlDictFree(ctxt.dict); 1497 1498 ret = ctxt.doc; 1499 return(ret); 1500 } 1501 1502 /** 1503 * xmlConvertCRNGFile: 1504 * @URL: URL or filename for the resource 1505 * @encoding: encoding indicated by the context or NULL 1506 * 1507 * Compiles the schemas into the equivalent Relax-NG XML structure 1508 * 1509 * Returns the xmlDocPtr resulting from the compilation or 1510 * NULL in case of error 1511 */ 1512 xmlDocPtr 1513 xmlConvertCRNGFile(const char *URL, const char *encoding) { 1514 } 1515 1516 #ifdef STANDALONE 1517 const xmlChar *schemas = 1518 "# RELAX NG XML syntax specified in compact syntax.\n\ 1519 \n\ 1520 default namespace rng = \"http://relaxng.org/ns/structure/1.0\"\n\ 1521 namespace local = \"\"\n\ 1522 datatypes xsd = \"http://www.w3.org/2001/XMLSchema-datatypes\"\n\ 1523 \n\ 1524 start = pattern\n\ 1525 \n\ 1526 pattern =\n\ 1527 element element { (nameQName | nameClass), (common & pattern+) }\n\ 1528 | element attribute { (nameQName | nameClass), (common & pattern?) }\n\ 1529 | element group|interleave|choice|optional\n\ 1530 |zeroOrMore|oneOrMore|list|mixed { common & pattern+ }\n\ 1531 | element ref|parentRef { nameNCName, common }\n\ 1532 | element empty|notAllowed|text { common }\n\ 1533 | element data { type, param*, (common & exceptPattern?) }\n\ 1534 | element value { commonAttributes, type?, xsd:string }\n\ 1535 | element externalRef { href, common }\n\ 1536 | element grammar { common & grammarContent* }\n\ 1537 \n\ 1538 param = element param { commonAttributes, nameNCName, xsd:string }\n\ 1539 \n\ 1540 exceptPattern = element except { common & pattern+ }\n\ 1541 \n\ 1542 grammarContent =\n\ 1543 definition\n\ 1544 | element div { common & grammarContent* }\n\ 1545 | element include { href, (common & includeContent*) }\n\ 1546 \n\ 1547 includeContent =\n\ 1548 definition\n\ 1549 | element div { common & includeContent* }\n\ 1550 \n\ 1551 definition =\n\ 1552 element start { combine?, (common & pattern+) }\n\ 1553 | element define { nameNCName, combine?, (common & pattern+) }\n\ 1554 \n\ 1555 combine = attribute combine { \"choice\" | \"interleave\" }\n\ 1556 \n\ 1557 nameClass =\n\ 1558 element name { commonAttributes, xsd:QName }\n\ 1559 | element anyName { common & exceptNameClass? }\n\ 1560 | element nsName { common & exceptNameClass? }\n\ 1561 | element choice { common & nameClass+ }\n\ 1562 \n\ 1563 exceptNameClass = element except { common & nameClass+ }\n\ 1564 \n\ 1565 nameQName = attribute name { xsd:QName }\n\ 1566 nameNCName = attribute name { xsd:NCName }\n\ 1567 href = attribute href { xsd:anyURI }\n\ 1568 type = attribute type { xsd:NCName }\n\ 1569 \n\ 1570 common = commonAttributes, foreignElement*\n\ 1571 \n\ 1572 commonAttributes =\n\ 1573 attribute ns { xsd:string }?,\n\ 1574 attribute datatypeLibrary { xsd:anyURI }?,\n\ 1575 foreignAttribute*\n\ 1576 \n\ 1577 foreignElement = element * - rng:* { (anyAttribute | text | anyElement)* }\n\ 1578 foreignAttribute = attribute * - (rng:*|local:*) { text }\n\ 1579 anyElement = element * { (anyAttribute | text | anyElement)* }\n\ 1580 anyAttribute = attribute * { text }\n\ 1581 "; 1582 1583 int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { 1584 xmlDocPtr res; 1585 1586 res = xmlConvertCRNG(schemas, -1); 1587 if (res != NULL) { 1588 xmlDocFormatDump(stdout, res, 1); 1589 xmlFreeDoc(res); 1590 } 1591 return(0); 1592 } 1593 #endif 1594 #define bottom_rngparser 1595 #include "elfgcchack.h"