nl-xml.c

   1 /* nl-xml.c - newLISP XML interface
   2
   3     Copyright (C) 2008 Lutz Mueller
   4
   5     This program is free software: you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation, either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 */
  19
  20 #include "newlisp.h"
  21 #include "protos.h"
  22
  23 #define XML_NONE 0
  24 #define XML_TEXT 1
  25 #define XML_CDATA 2
  26 #define XML_COMMENT 3
  27 #define XML_ELEMENT 4
  28
  29 int isWhiteSpaceStringN(char * source, int tagPos);
  30 CELL * makeTagSymbolCell(char * tagStart, int tagLen);
  31 void performXmlCallback(CELL * cell, char * start);
  32
  33 char * typeNames[] =
  34   {
  35   "none",
  36   "TEXT",
  37   "CDATA",
  38   "COMMENT",
  39   "ELEMENT"
  40   };
  41
  42 CELL typeCells[5] = {{0}, {0}, {0}, {0}, {0}};
  43
  44 static char * xmlError;
  45 static char xmlMsg[64];
  46 static char * sourceOrg;
  47 static char * source;
  48
  49 static SYMBOL * XMLcontext;
  50
  51 UINT optionsFlag;
  52 #define OPTION_NO_OPTION 0
  53 #define OPTION_NO_WHITESPACE 1
  54 #define OPTION_NO_EMPTY_ATTRIBUTES 2
  55 #define OPTION_NO_COMMENTS 4
  56 #define OPTION_TAGS_TO_SYMBOLS 8
  57 #define OPTION_SXML_ATTRIBUTES 16
  58
  59
  60 typedef struct
  61         {
  62         char * name;
  63         void * next;
  64         } TAG_STACK;
  65
  66 TAG_STACK * tagStack = NULL;
  67
  68 CELL * xmlCallback = NULL;
  69
  70 /* setup type tage default cells, if done already just relink */
  71 CELL * setupTypeTagCells(void)
  72 {
  73 int i;
  74
  75 /* if never done, initialize defaults */
  76 if(typeCells[0].contents == 0)
  77     for(i = 0; i < 5; i++)
  78     {
  79     typeCells[i].type = (i == 0) ? CELL_EXPRESSION : CELL_STRING;
  80     typeCells[i].next = nilCell;
  81     typeCells[i].aux = (i == 0) ? (UINT)nilCell : strlen(typeNames[i]) + 1;
  82     typeCells[i].contents = (UINT)typeNames[i];
  83     }
  84
  85 /* link cells in a list */
  86 typeCells[0].contents = (UINT)&typeCells[1];
  87 for(i = 1; i < 4; i++)
  88     typeCells[i].next = &typeCells[i+1];
  89
  90 return(&typeCells[0]);
  91 }
  92
  93 CELL * p_XMLparse(CELL * params)
  94 {
  95 CELL * result;
  96
  97 if(xmlCallback != NULL)
  98         errorProc(ERR_NOT_REENTRANT);
  99
 100 params = getString(params, &source);
 101 if(params != nilCell)
 102         {
 103     params = getInteger(params, &optionsFlag);
 104         if(params != nilCell)
 105                 {
 106                 XMLcontext = getCreateContext(params, TRUE);
 107                 if(XMLcontext == NULL)
 108                         return(errorProc(ERR_SYMBOL_OR_CONTEXT_EXPECTED));
 109                 if(params->next != nilCell)
 110                         xmlCallback = params->next;
 111                 else
 112                         xmlCallback = NULL;
 113                 }
 114         else
 115                 XMLcontext = currentContext;
 116         }
 117 else
 118         optionsFlag = OPTION_NO_OPTION;
 119
 120 setupTypeTagCells();
 121
 122 xmlError = NULL;
 123 sourceOrg = source;
 124 deleteTagStack();
 125
 126 result = parseDoc();
 127 deleteTagStack();
 128
 129 if(xmlError != NULL)
 130         return nilCell;
 131 else
 132         return result;
 133 }
 134
 135
 136 CELL * p_XMLtypeTags(CELL * params)
 137 {
 138 int i;
 139 CELL * cell;
 140
 141 if(params == nilCell)
 142     return(copyCell(setupTypeTagCells()));
 143
 144 setupTypeTagCells();
 145
 146 for(i = 1; i < 5; i++)
 147     {
 148     cell = evaluateExpression(params);
 149     memcpy(&typeCells[i], cell, sizeof(CELL));
 150     params = params->next;
 151     }
 152
 153 return(copyCell(setupTypeTagCells()));
 154 }
 155
 156
 157 CELL * p_XMLerror(CELL * params)
 158 {
 159 CELL * errorCell;
 160 CELL * cell;
 161
 162 if(xmlError == NULL)
 163         return(nilCell);
 164
 165 errorCell = getCell(CELL_EXPRESSION);
 166 cell = stuffString(xmlError);
 167 errorCell->contents = (UINT)cell;
 168 cell->next = stuffInteger((UINT)(source - sourceOrg));
 169
 170 return errorCell;
 171 }
 172
 173 void deleteTagStack(void)
 174 {
 175 TAG_STACK * oldTagStack;
 176
 177 while(tagStack != NULL)
 178         {
 179         oldTagStack = tagStack;
 180         freeMemory(tagStack->name);
 181         tagStack = tagStack->next;
 182         freeMemory(oldTagStack);
 183         }
 184 }
 185
 186
 187 CELL * parseDoc(void)
 188 {
 189 CELL * node;
 190 CELL * lastNode;
 191 int closingFlag = FALSE;
 192 int tagPos;
 193
 194 lastNode = node = getCell(CELL_EXPRESSION);
 195
 196 while(!xmlError && !closingFlag)
 197         {
 198         if((tagPos = find("<", source)) == -1) break;
 199         if(tagPos > 0)
 200                 {
 201                 if( (tagStack != NULL) || (node->contents != (UINT)nilCell))
 202                         {
 203                         if((optionsFlag & OPTION_NO_WHITESPACE) && isWhiteSpaceStringN(source, tagPos))
 204                                 {;}
 205                         else lastNode = appendNode(lastNode, makeTextNode(XML_TEXT, stuffStringN(source, tagPos)));
 206                         }
 207                 source = source + tagPos;
 208                 }
 209
 210         if(strncmp(source, "<!DOCTYPE", 9) == 0)
 211                 {
 212                 parseDTD();
 213                 continue;
 214                 }
 215
 216         if(*source == '<' && *(source + 1) == '?')
 217                 {
 218                 parseProcessingInstruction();
 219                 continue;
 220                 }
 221
 222         if(memcmp(source, "<!--", 4) == 0)
 223                 {
 224                 if(optionsFlag & OPTION_NO_COMMENTS)
 225                         parseTag("-->");
 226                 else
 227                         lastNode = appendNode(lastNode, parseTag("-->"));
 228                 continue;
 229                 }
 230         if(memcmp(source, "<![CDATA[", 9) == 0)
 231                 {
 232                 lastNode = appendNode(lastNode, parseTag("]]>"));
 233                 continue;
 234                 }
 235
 236         if(*source == '<' && *(source + 1) == '/')
 237                 {
 238                 closingFlag = TRUE;
 239                 parseClosing();
 240                 continue;
 241                 }
 242
 243         lastNode = appendNode(lastNode, parseTag(">"));
 244         }
 245
 246
 247 if(xmlError != NULL)
 248         {
 249         deleteList(node);
 250         return nilCell;
 251         }
 252
 253 return node;
 254 }
 255
 256
 257 void parseDTD(void)
 258 {
 259 int closeTag, squareTag;
 260 int closePos = 0;
 261 char * closeTagStr;
 262
 263 if((closeTag = find(">", source)) == -1)
 264         {
 265         xmlError = "error in DTD: expected '>'";
 266         return;
 267         }
 268
 269 squareTag = find("[", source);
 270 if(squareTag != -1 && squareTag < closeTag)
 271         closeTagStr = "]>";
 272 else
 273         closeTagStr = ">";
 274
 275 while(!xmlError)
 276         {
 277         if((closePos = find(closeTagStr, source)) == -1)
 278                 {
 279                 snprintf(xmlMsg, 63, "expected: %s", closeTagStr);
 280                 xmlError = xmlMsg;
 281                 return;
 282                 }
 283         if(*(source + closePos - 1) != ']')
 284                 break;
 285         source = source + closePos + strlen(closeTagStr);
 286         }
 287
 288 source = source + closePos + strlen(closeTagStr);
 289 return;
 290 }
 291
 292
 293 void parseProcessingInstruction(void)
 294 {
 295 int closeTag;
 296
 297 if((closeTag = find("?>", source)) == -1)
 298         {
 299         xmlError = "expecting closing tag sequence '?>'";
 300         return;
 301         }
 302
 303 source = source + closeTag + 2;
 304 }
 305
 306
 307 void parseClosing(void)
 308 {
 309 int closeTag;
 310 char * tagName;
 311 TAG_STACK * oldTagStack;
 312
 313 if((closeTag = find(">", source)) == -1)
 314         {
 315         xmlError = "missing closing >";
 316         return;
 317         }
 318
 319 if(tagStack == NULL)
 320         {
 321         xmlError = "closing tag has no opening";
 322         return;
 323         }
 324
 325 tagName = tagStack->name;
 326 if(strncmp(source + 2, tagName, strlen(tagName)) != 0)
 327         {
 328         xmlError = "closing tag doesn't match";
 329         return;
 330         }
 331
 332 /* pop tagStack */
 333 freeMemory(tagName);
 334 oldTagStack = tagStack;
 335 tagStack = tagStack->next;
 336
 337 freeMemory(oldTagStack);
 338
 339 source = source + closeTag + 1;
 340 }
 341
 342
 343 CELL * parseTag(char * closeTagStr)
 344 {
 345 char * newSrc;
 346 char * tagStart;
 347 int closeTag;
 348 CELL * cell;
 349
 350 tagStart = source;
 351
 352 cell = NULL;
 353 closeTag = find(closeTagStr, source);
 354 if(*(source + closeTag - 1) == '/')
 355         {
 356         if(memcmp(closeTagStr,"]]>",3) != 0)
 357                 {
 358                 --closeTag;
 359                 closeTagStr = "/>";
 360                 }
 361         }
 362
 363 if(closeTag == -1)
 364         {
 365         snprintf(xmlMsg, 63, "expected closing tag: %s", closeTagStr);
 366         xmlError = xmlMsg;
 367         return nilCell;
 368         }
 369
 370 if(memcmp(source, "<!--", 4) == 0)
 371         {
 372         if(optionsFlag & OPTION_NO_COMMENTS)
 373                 cell = nilCell;
 374         else
 375                 {
 376                 cell = stuffStringN(source + 4, closeTag - 4);
 377                 cell = makeTextNode(XML_COMMENT, cell);
 378                 }
 379         }
 380
 381 if(memcmp(source, "<![CDATA[", 9) == 0)
 382         {
 383         cell = stuffStringN(source + 9, closeTag - 9);
 384         cell = makeTextNode(XML_CDATA, cell);
 385         }
 386
 387 if(*source == '<' && *(source + 1) == '/')
 388         {
 389         xmlError = "closing node has no opening";
 390         return nilCell;
 391         }
 392
 393 newSrc = source + closeTag + strlen(closeTagStr);
 394
 395 if(cell == NULL)
 396         cell = parseNormalTag(source + closeTag, newSrc);
 397 else
 398         source = newSrc;
 399
 400 /* call back with closed tag expression found
 401    and opening start and end of source of this
 402    tag expression
 403 */
 404
 405 if(xmlCallback)
 406         performXmlCallback(cell, tagStart);
 407
 408 return(cell);
 409 }
 410
 411
 412 void performXmlCallback(CELL * result, char * tagStart)
 413 {
 414 CELL * list;
 415 CELL * cell;
 416 CELL * next;
 417 int errNo;
 418
 419 list = getCell(CELL_EXPRESSION);
 420 list->contents = (UINT)copyCell(xmlCallback);
 421 cell = getCell(CELL_QUOTE);
 422 cell->contents = (UINT)copyCell(result);
 423 cell->next = stuffInteger((UINT)(tagStart - sourceOrg));
 424 next = cell->next;
 425 next->next = stuffInteger((UINT)(source - tagStart));
 426 ((CELL*)list->contents)->next = cell;
 427 pushResult(list);
 428 if(!evaluateExpressionSafe(list, &errNo))
 429         {
 430         deleteTagStack();
 431         longjmp(errorJump, errNo);
 432         }
 433 }
 434
 435
 436 CELL * parseNormalTag(char * endSrc, char * newSrc)
 437 {
 438 char * tagStart;
 439 int tagLen;
 440 CELL * attributes;
 441 CELL * childs;
 442 CELL * tagCell;
 443 TAG_STACK * tag;
 444
 445 ++source; /* skip '/' */
 446
 447 while(*source <= ' ' && source < endSrc) ++source; /* skip whitespace */
 448
 449 tagStart = source;
 450 tagLen = 0;
 451 while(*source > ' ' && source < endSrc) ++source, ++tagLen; /* find tag end */
 452
 453 attributes = parseAttributes(endSrc);
 454 if(optionsFlag & OPTION_SXML_ATTRIBUTES)
 455         {
 456         childs = (CELL*)attributes->contents;
 457         if(! (childs == nilCell && (optionsFlag & OPTION_NO_EMPTY_ATTRIBUTES)))
 458                 {
 459                 attributes->contents = (UINT)stuffSymbol(atSymbol);
 460                 ((CELL*)(attributes->contents))->next = childs;
 461                 }
 462         }
 463
 464 if(xmlError)
 465         return nilCell;
 466
 467 if(*source == '/' && *(source + 1) == '>')
 468         {
 469         source = newSrc;
 470         if(optionsFlag & OPTION_TAGS_TO_SYMBOLS)
 471                 tagCell = makeTagSymbolCell(tagStart, tagLen);
 472         else
 473                 tagCell = stuffStringN(tagStart, tagLen);
 474         return makeElementNode(tagCell, attributes, getCell(CELL_EXPRESSION));
 475         }
 476
 477 /* push tag on tagstack */
 478 tag = (TAG_STACK*)allocMemory(sizeof(TAG_STACK));
 479 tag->name = (char *)callocMemory(tagLen + 1);
 480 memcpy(tag->name, tagStart, tagLen);
 481 tag->next = tagStack;
 482 tagStack = tag;
 483
 484 source = newSrc;
 485 childs = parseDoc();
 486
 487 if(optionsFlag & OPTION_TAGS_TO_SYMBOLS)
 488     tagCell = makeTagSymbolCell(tagStart, tagLen);
 489 else
 490     tagCell = stuffStringN(tagStart, tagLen);
 491
 492 return makeElementNode(tagCell, attributes, childs);
 493 }
 494
 495
 496 CELL * makeTagSymbolCell(char * tagStart, int tagLen)
 497 {
 498 char * name;
 499 CELL * cell;
 500
 501 name = (char *)callocMemory(tagLen + 1);
 502 memcpy(name, tagStart, tagLen);
 503 cell = stuffSymbol(translateCreateSymbol(name, CELL_NIL, XMLcontext, 0));
 504 freeMemory(name);
 505 return(cell);
 506 }
 507
 508
 509 CELL * parseAttributes(char * endSrc)
 510 {
 511 CELL * attributes;
 512 CELL * att;
 513 CELL * cell;
 514 CELL * lastAtt;
 515 char * namePos;
 516 char * valPos;
 517 char quoteChar;
 518 int  nameLen, valLen;
 519
 520 attributes = getCell(CELL_EXPRESSION);
 521 lastAtt = NULL;
 522
 523 while(!xmlError && source < endSrc)
 524         {
 525         while(*source <= ' ' && source < endSrc) source++; /* strip leading space */
 526         namePos = source;
 527         nameLen = 0;
 528         while(*source > ' ' && *source != '=' && source < endSrc) source++, nameLen++; /* get end */
 529         if(nameLen == 0) break;
 530         while(*source <= ' ' && source < endSrc) source++; /* strip leading space */
 531         if(*source != '=')
 532                 {
 533                 xmlError = "expected '=' in attributes";
 534                 deleteList(attributes);
 535                 return nilCell;
 536                 }
 537         else source++;
 538         while(*source <= ' ' && source < endSrc) source++; /* strip spaces */
 539         if(*source != '\"' && *source != '\'')
 540                 {
 541                 xmlError = "attribute values must be delimited by \" or \' ";
 542                 deleteList(attributes);
 543                 return nilCell;
 544                 }
 545         quoteChar = *source;
 546         source++;
 547         valPos = source;
 548         valLen = 0;
 549         while(*source != quoteChar && source < endSrc) source++, valLen++;
 550         if(*source != quoteChar) valLen = -1;
 551         else source++;
 552         if(nameLen == 0 || valLen == -1)
 553                 {
 554                 xmlError = "incorrect attribute";
 555                 deleteList(attributes);
 556                 return nilCell;
 557                 }
 558         att = getCell(CELL_EXPRESSION);
 559         if(optionsFlag & OPTION_TAGS_TO_SYMBOLS)
 560                 cell = makeTagSymbolCell(namePos, nameLen);
 561         else
 562                 cell = stuffStringN(namePos, nameLen);
 563         cell->next = stuffStringN(valPos, valLen);
 564         att->contents = (UINT)cell;
 565         if(lastAtt == NULL)
 566                 attributes->contents = (UINT)att;
 567         else
 568                 lastAtt->next = att;
 569         lastAtt = att;
 570         }
 571
 572 return attributes;
 573 }
 574
 575
 576 CELL * appendNode(CELL * node, CELL * newNode)
 577 {
 578 if(node->contents == (UINT)nilCell)
 579         node->contents = (UINT)newNode;
 580 else
 581         node->next = newNode;
 582
 583 return newNode;
 584 }
 585
 586
 587 CELL * makeTextNode(int type, CELL * contents)
 588 {
 589 CELL * newNode;
 590 CELL * cell;
 591
 592 /* unwrap text node if nil xml-type-tag */
 593 if(typeCells[type].type == CELL_NIL)
 594     return(contents);
 595
 596 newNode = getCell(CELL_EXPRESSION);
 597 cell = copyCell(&typeCells[type]);
 598 newNode->contents = (UINT)cell;
 599 cell->next = contents;
 600
 601 return newNode;
 602 }
 603
 604
 605 CELL * makeElementNode(CELL * tagNode, CELL * attributesNode, CELL * childrenNode)
 606 {
 607 CELL * newNode;
 608 CELL * cell;
 609
 610 /* unwrap children node, if nil in xml-type-tag */
 611 if(typeCells[XML_ELEMENT].type == CELL_NIL)
 612     {
 613     cell = childrenNode;
 614     childrenNode = (CELL *)childrenNode->contents;
 615     cell->contents = (UINT)nilCell;
 616     deleteList(cell);
 617     }
 618
 619 newNode = getCell(CELL_EXPRESSION);
 620 if(typeCells[XML_ELEMENT].type == CELL_NIL)
 621     newNode->contents = (UINT)tagNode;
 622 else
 623     {
 624     cell = copyCell(&typeCells[XML_ELEMENT]);
 625     newNode->contents = (UINT)cell;
 626     cell->next = tagNode;
 627     }
 628
 629 if( (attributesNode->contents == (UINT)nilCell) &&
 630     (optionsFlag & OPTION_NO_EMPTY_ATTRIBUTES))
 631     {
 632     tagNode->next = childrenNode;
 633     deleteList(attributesNode);
 634     }
 635 else
 636     {
 637     tagNode->next = attributesNode;
 638     attributesNode->next = childrenNode;
 639     }
 640
 641 return newNode;
 642 }
 643
 644
 645 int find(char * key, char * source)
 646 {
 647 char * ptr;
 648
 649 ptr = strstr(source, key);
 650 if(ptr == NULL) return -1;
 651
 652 return(ptr - source);
 653 }
 654
 655
 656 int isWhiteSpaceStringN(char * source, int tagPos)
 657 {
 658 while(tagPos--) if((unsigned char)*source++ > 32) return(FALSE);
 659 return(TRUE);
 660 }
 661
 662 /* eof */
 663
 664
 665
 666
 667