src/qs_parse_string.c

   1 /*
   2  * Copyright (C) 2005-2008 Atsushi Konno All rights reserved.
   3  * Copyright (C) 2005 QSDN,Inc. All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 #include <stdio.h>
  18 #include <strings.h>
  19 #include <stdlib.h>
  20
  21 #include "chxj_apache.h"
  22 #include "qs_parse_string.h"
  23 #include "qs_parse_tag.h"
  24 #include "qs_log.h"
  25
  26 #include "mod_chxj.h"
  27 #include <iconv.h>
  28
  29
  30 #define NL_COUNT_MAX  (10)
  31
  32 typedef struct node_stack_element {
  33   Node *node;
  34   struct node_stack_element *next;
  35   struct node_stack_element **ref;
  36 } *NodeStackElement;
  37
  38 typedef struct node_stack {
  39   NodeStackElement head;
  40   NodeStackElement tail;
  41 } *NodeStack;
  42
  43 static int s_cut_tag (const char *s, int len);
  44 static int s_cut_text(const char *s, int len, int script);
  45 static void qs_dump_node(Doc *doc, Node *node, int indent);
  46 static void qs_push_node(Doc *doc, Node *node, NodeStack stack);
  47 static Node *qs_pop_node(Doc *doc, NodeStack stack);
  48 #ifdef DUMP_NODE_STACK
  49 static void qs_dump_node_stack(Doc *doc, NodeStack stack);
  50 #endif
  51 static void qs_free_node_stack(Doc *doc, NodeStack stack);
  52 static void s_error_check(Doc *doc, const char *name, int line, NodeStack node_stack, NodeStack err_stack);
  53 static Node *qs_new_nl_node(Doc *doc);
  54
  55
  56 Node *
  57 qs_parse_string(Doc *doc, const char *src, int srclen)
  58 {
  59   int     ii;
  60   int     nl_cnt = 0;
  61   char    encoding[256];
  62   char    *osrc;
  63   char    *ibuf;
  64   size_t  olen;
  65   size_t  ilen;
  66   int     script_flag = 0;
  67   iconv_t cd;
  68
  69   osrc = NULL;
  70   ibuf = NULL;
  71   NodeStack node_stack;
  72   NodeStack err_stack;
  73
  74   memset(encoding, 0, 256);
  75
  76   doc->now_parent_node = qs_init_root_node(doc);
  77   if (! src || srclen <= 0) {
  78     return doc->root_node;
  79   }
  80   if (doc->r != NULL) {
  81     node_stack = apr_palloc(doc->r->pool, sizeof(struct node_stack));
  82     memset(node_stack, 0, sizeof(struct node_stack));
  83     err_stack = apr_palloc(doc->r->pool, sizeof(struct node_stack));
  84     memset(err_stack, 0, sizeof(struct node_stack));
  85   }
  86   else {
  87     node_stack = calloc(sizeof(struct node_stack), 1);
  88     err_stack  = calloc(sizeof(struct node_stack), 1);
  89   }
  90
  91   /*
  92    * It is the pre reading.
  93    * Because I want to specify encoding.
  94    */
  95   for (ii=0; ii<srclen; ii++) {
  96     if (src[ii] == '\n')  nl_cnt++;
  97     if (nl_cnt >= NL_COUNT_MAX) break; /* not found <?xml ...> */
  98
  99     if (is_white_space(src[ii]))
 100       continue;
 101
 102     if ((unsigned char)'<' == src[ii]) {
 103       int endpoint = s_cut_tag(&src[ii], srclen - ii);
 104       Node *node   = qs_parse_tag(doc, &src[ii], endpoint);
 105       if (! node) {
 106         QX_LOGGER_FATAL("runtime exception: qs_parse_string(): Out of memory.");
 107         return doc->root_node;
 108       }
 109       ii += endpoint;
 110
 111       if (node->name[0] != '?') break;
 112
 113       if (strcasecmp(node->name, "?xml") == 0) {
 114         Attr *parse_attr;
 115         for(parse_attr = node->attr;
 116             parse_attr && *encoding == '\0';
 117             parse_attr = parse_attr->next) {
 118           if (STRCASEEQ('e','E',"encoding",parse_attr->name)) {
 119             switch (*parse_attr->value) {
 120             case 'X':
 121             case 'x':
 122               if (strcasecmp(parse_attr->value, "x-sjis"   ) == 0) {
 123                 strcpy((char *)encoding, (char *)"NONE");
 124               }
 125               break;
 126
 127             case 'S':
 128             case 's':
 129               if ((strcasecmp(parse_attr->value, "Shift_JIS") == 0)
 130               ||  (strcasecmp(parse_attr->value, "SJIS"     ) == 0)
 131               ||  (strcasecmp(parse_attr->value, "Shift-JIS") == 0)) {
 132                 strcpy((char *)encoding, (char *)"NONE");
 133               }
 134               break;
 135
 136             case 'e':
 137             case 'E':
 138               if ((strcasecmp(parse_attr->value, "EUC_JP") == 0)
 139               ||  (strcasecmp(parse_attr->value, "EUC-JP") == 0)
 140               ||  (strcasecmp(parse_attr->value, "EUCJP" ) == 0)) {
 141                 strcpy((char *)encoding, "EUC-JP");
 142               }
 143               break;
 144
 145             case 'u':
 146             case 'U':
 147               if ((strcasecmp(parse_attr->value, "UTF-8") == 0)
 148               ||  (strcasecmp(parse_attr->value, "UTF8") == 0)) {
 149                 strcpy((char *)encoding, "UTF-8");
 150               }
 151               break;
 152
 153             default:
 154               strcpy((char *)encoding, "NONE");
 155               break;
 156             }
 157           }
 158         }
 159         break;
 160       }
 161       break;
 162     }
 163   }
 164
 165   if (strcasecmp(encoding, "NONE") != 0 && strlen(encoding) != 0) {
 166     char *sv_osrc;
 167     olen = srclen * 4 + 1;
 168     sv_osrc = osrc =(char *)apr_palloc(doc->pool, olen);
 169     memset((char *)osrc, 0, olen);
 170     if ((cd = iconv_open("CP932", encoding)) != (iconv_t) -1) {
 171       ilen = srclen;
 172       ibuf = apr_palloc(doc->pool, ilen+1);
 173       memset(ibuf, 0, ilen+1);
 174       memcpy(ibuf, src, ilen);
 175       while (ilen > 0) {
 176         size_t result = iconv(cd, &ibuf, &ilen, &osrc, &olen);
 177         if (result == (size_t)(-1)) {
 178           break;
 179         }
 180       }
 181       srclen = olen;
 182       src = sv_osrc;
 183       iconv_close(cd);
 184     }
 185   }
 186
 187   /*
 188    * Now, true parsing is done here.
 189    */
 190   nl_cnt = 1;
 191   for (ii=0; ii<srclen; ii++) {
 192     if (src[ii] == '\n') {
 193       nl_cnt++;
 194       if (doc->now_parent_node != NULL) {
 195         Node *node = qs_new_nl_node(doc);
 196         qs_add_child_node(doc,node);
 197       }
 198     }
 199     if (doc->parse_mode != PARSE_MODE_NO_PARSE
 200         && is_white_space(src[ii])
 201         && (doc->now_parent_node == NULL || !STRCASEEQ('p','P',"pre",doc->now_parent_node->name))) {
 202       continue;
 203     }
 204     if ((unsigned char)'<' == src[ii] && strncasecmp("<![CDATA[",&src[ii], sizeof("<![CDATA[")-1) != 0) {
 205       int endpoint = s_cut_tag(&src[ii], srclen - ii);
 206       Node *node   = qs_parse_tag(doc, &src[ii], endpoint);
 207       if (! node) {
 208         QX_LOGGER_FATAL("runtime exception: qs_parse_string(): Out of memory.");
 209         return doc->root_node;
 210       }
 211       node->line = nl_cnt;
 212
 213       ii += endpoint;
 214       if (node->name[0] == '/' ) {
 215         if (doc->parse_mode == PARSE_MODE_CHTML) {
 216           if (has_child(&(node->name[1]))) {
 217             if (doc->now_parent_node->parent != NULL) {
 218               doc->now_parent_node = doc->now_parent_node->parent;
 219               doc->parse_mode = PARSE_MODE_CHTML;
 220             }
 221             if (STRCASEEQ('s','S',"script",&node->name[1])) {
 222               script_flag = 0;
 223             }
 224             s_error_check(doc, &node->name[1], node->line, node_stack, err_stack);
 225           }
 226           else {
 227             /* ignore */
 228             continue;
 229           }
 230         }
 231         else
 232         if (doc->parse_mode == PARSE_MODE_NO_PARSE) {
 233           if (STRCASEEQ('c','C',"chxj:if",&node->name[1]) || STRCASEEQ('p','P',"plaintext",&node->name[1])) {
 234             if (doc->now_parent_node->parent != NULL) {
 235               doc->now_parent_node = doc->now_parent_node->parent;
 236               doc->parse_mode = PARSE_MODE_CHTML;
 237               s_error_check(doc, &node->name[1], node->line, node_stack, err_stack);
 238             }
 239           }
 240         }
 241
 242         if (doc->parse_mode != PARSE_MODE_NO_PARSE) {
 243           continue;
 244         }
 245       }
 246       if (*node->name == '!' && strncmp(node->name, "!--", 3) == 0) {
 247         /* comment tag */
 248         continue;
 249       }
 250       qs_add_child_node(doc,node);
 251       if ((has_child(node->name) && doc->parse_mode != PARSE_MODE_NO_PARSE) || STRCASEEQ('p','P',"plaintext",node->name)) {
 252         qs_push_node(doc, node, node_stack);
 253       }
 254
 255       if (doc->parse_mode == PARSE_MODE_NO_PARSE) {
 256         if (node->name[0] == '/')
 257           continue;
 258       }
 259
 260       if (doc->parse_mode == PARSE_MODE_CHTML && STRCASEEQ('c','C',"chxj:if", node->name)) {
 261         Attr *parse_attr;
 262         doc->parse_mode = PARSE_MODE_NO_PARSE;
 263         doc->now_parent_node = node;
 264         for(parse_attr = node->attr;
 265             parse_attr;
 266             parse_attr = parse_attr->next) {
 267           if (STRCASEEQ('p','P',"parse",parse_attr->name)) {
 268             if (STRCASEEQ('t','T',"true",parse_attr->value)) {
 269               doc->parse_mode = PARSE_MODE_CHTML;
 270             }
 271           }
 272         }
 273       }
 274       else if (doc->parse_mode == PARSE_MODE_CHTML && STRCASEEQ('p','P',"plaintext",node->name)) {
 275         doc->parse_mode = PARSE_MODE_NO_PARSE;
 276         doc->now_parent_node = node;
 277       }
 278
 279       if (doc->parse_mode == PARSE_MODE_CHTML && has_child(node->name)) {
 280         doc->now_parent_node = node;
 281       }
 282       if (STRCASEEQ('s','S',"script", node->name)) {
 283         script_flag = 1;
 284       }
 285       if (doc->parse_mode == PARSE_MODE_CHTML && node->closed_by_itself) {
 286         if (has_child(node->name)) {
 287           if (doc->now_parent_node->parent != NULL) {
 288             doc->now_parent_node = doc->now_parent_node->parent;
 289             doc->parse_mode = PARSE_MODE_CHTML;
 290           }
 291           if (STRCASEEQ('s','S',"script",node->name)) {
 292             script_flag = 0;
 293           }
 294           s_error_check(doc, node->name, node->line, node_stack, err_stack);
 295         }
 296         else {
 297           /* ignore */
 298           continue;
 299         }
 300       }
 301     }
 302     else if (strncasecmp("<![CDATA[", &src[ii], sizeof("<![CDATA[") - 1) == 0) {
 303       /* TEXT */
 304       int endpoint = s_cut_tag(&src[ii], srclen - ii);
 305       Node *node = qs_new_tag(doc);
 306       if (! node) {
 307         QX_LOGGER_DEBUG("runtime exception: qs_parse_string(): Out of memory");
 308         return doc->root_node;
 309       }
 310       node->value = (char *)apr_palloc(doc->pool,endpoint+1);
 311       node->name  = (char *)apr_palloc(doc->pool,4+1);
 312       node->otext = (char *)apr_palloc(doc->pool,endpoint+1);
 313       node->size  = endpoint;
 314       node->line  = nl_cnt;
 315       memset(node->value, 0, endpoint+1);
 316       memset(node->otext, 0, endpoint+1);
 317       memset(node->name,  0, 4+1       );
 318       memcpy(node->value, &src[ii+sizeof("<![CDATA[")-1], endpoint - (sizeof("<![CDATA[")-1) - (sizeof("]]")-1));
 319       memcpy(node->name,  "text",   4);
 320       memcpy(node->otext,node->value, endpoint);
 321
 322       qs_add_child_node(doc,node);
 323       ii += (endpoint - 1);
 324     }
 325     else {
 326       /* TEXT */
 327       int endpoint = s_cut_text(&src[ii], srclen - ii, script_flag);
 328       Node *node = qs_new_tag(doc);
 329       if (! node) {
 330         QX_LOGGER_DEBUG("runtime exception: qs_parse_string(): Out of memory");
 331         return doc->root_node;
 332       }
 333       node->value = (char *)apr_palloc(doc->pool,endpoint+1);
 334       node->name  = (char *)apr_palloc(doc->pool,4+1);
 335       node->otext = (char *)apr_palloc(doc->pool,endpoint+1);
 336       node->size  = endpoint;
 337       node->line  = nl_cnt;
 338       memset(node->value, 0, endpoint+1);
 339       memset(node->otext, 0, endpoint+1);
 340       memset(node->name,  0, 4+1       );
 341       memcpy(node->value, &src[ii], endpoint);
 342       memcpy(node->name,  "text",   4);
 343       memcpy(node->otext,node->value, endpoint);
 344
 345       qs_add_child_node(doc,node);
 346       ii += (endpoint - 1);
 347     }
 348   }
 349 #ifdef DEBUG
 350   QX_LOGGER_DEBUG("parse_string end");
 351 #endif
 352 #ifdef DEBUG
 353   if (doc->r != NULL) {
 354     qs_dump_node(doc, doc->root_node, 0);
 355   }
 356 #endif
 357 #ifdef DUMP_NODE_STACK
 358   qs_dump_node_stack(doc, node_stack);
 359 #endif
 360   {
 361     Node *prevNode;
 362     for (prevNode = qs_pop_node(doc,node_stack);
 363          prevNode;
 364          prevNode = qs_pop_node(doc, node_stack)) {
 365       if (has_child(prevNode->name)) {
 366         if (doc->r)
 367           ERR(doc->r, "tag parse error (perhaps, not close). tag_name:[%s] line:[%d]", prevNode->name, prevNode->line);
 368         else
 369           fprintf(stderr, "error :tag parse error (perhaps, not close). tag_name:[%s] line:[%d]\n", prevNode->name, prevNode->line);
 370       }
 371     }
 372   }
 373   qs_free_node_stack(doc, node_stack); node_stack = NULL;
 374   qs_free_node_stack(doc, err_stack);  err_stack = NULL;
 375   return doc->root_node;
 376 }
 377
 378
 379 static void
 380 s_error_check(Doc *doc, const char *name, int line, NodeStack node_stack, NodeStack err_stack)
 381 {
 382   Node *prevNode;
 383   int err = 0;
 384   for (prevNode = qs_pop_node(doc,node_stack);
 385        prevNode;
 386        prevNode = qs_pop_node(doc, node_stack)) {
 387     if (prevNode && strcasecmp(prevNode->name, name) != 0) {
 388       qs_push_node(doc, prevNode, err_stack);
 389       err++;
 390       continue;
 391     }
 392     break;
 393   }
 394   if (err) {
 395     Node *tmpNode = qs_pop_node(doc,node_stack);
 396     if (tmpNode == NULL && err != 1) {
 397       if (doc->r)
 398         ERR(doc->r, "tag parse error (perhaps, miss spell). tag_name:[%s] line:[%d]", name, line);
 399       else
 400         fprintf(stderr, "error :tag parse error (perhaps, miss spell). tag_name:[%s] line:[%d]\n", name, line);
 401       for (prevNode = qs_pop_node(doc,err_stack);
 402            prevNode;
 403            prevNode = qs_pop_node(doc, err_stack)) {
 404         qs_push_node(doc, prevNode, node_stack);
 405       }
 406     }
 407     else {
 408       for (prevNode = qs_pop_node(doc,err_stack);
 409            prevNode;
 410            prevNode = qs_pop_node(doc, err_stack)) {
 411         if (doc->r)
 412           ERR(doc->r, "tag parse error (perhaps, not close). tag_name:[%s] line:[%d]", prevNode->name, prevNode->line);
 413         else
 414           fprintf(stderr, "error :tag parse error (perhaps, not close). tag_name:[%s] line:[%d]\n", prevNode->name, prevNode->line);
 415       }
 416       qs_push_node(doc, tmpNode, node_stack);
 417     }
 418     err = 0;
 419   }
 420 }
 421
 422
 423 static void
 424 qs_dump_node(Doc *doc, Node *node, int indent)
 425 {
 426   Node *p = (Node *)qs_get_child_node(doc,node);
 427
 428   for (;p;p = (Node *)qs_get_next_node(doc,p)) {
 429     Attr *attr;
 430     if ((char *)qs_get_node_value(doc,p) != NULL) {
 431       DBG(doc->r,"%*.*sNode:[%s][%s]\n", indent,indent," ",
 432                       (char *)qs_get_node_name(doc,p),
 433                       (char *)qs_get_node_value(doc,p));
 434     }
 435     else {
 436       DBG(doc->r,"%*.*sNode:[%s]\n", indent,indent," ", qs_get_node_name(doc,p));
 437     }
 438     for (attr = (Attr *)qs_get_attr(doc,p); attr; attr = (Attr *)qs_get_next_attr(doc,attr)) {
 439       DBG(doc->r,"%*.*s  ATTR:[%s]\n", indent,indent," ", (char *)qs_get_attr_name(doc,attr));
 440       DBG(doc->r,"%*.*s  VAL :[%s]\n", indent,indent," ", (char *)qs_get_attr_value(doc,attr));
 441     }
 442     qs_dump_node(doc,p, indent+4);
 443   }
 444 }
 445
 446
 447
 448 static int
 449 s_cut_tag(const char *s, int len)
 450 {
 451   int lv = 0;
 452   int ii;
 453   int comment = 0;
 454   int cdata = 0;
 455
 456   if (strncmp("<!--", s, 4) == 0) {
 457     comment = 1;
 458   }
 459   else if (strncasecmp("<![CDATA[", s, sizeof("<![CDATA[")-1) == 0) {
 460     cdata = 1;
 461   }
 462
 463   for (ii=0;ii<len; ii++) {
 464     if (is_sjis_kanji(s[ii])) {
 465       ii++;
 466       continue;
 467     }
 468     if (is_sjis_kana(s[ii]))
 469       continue;
 470
 471     if (is_white_space(s[ii]))
 472       continue;
 473
 474     if (s[ii] == '<') {
 475       lv++;
 476       continue;
 477     }
 478     if (comment && s[ii] == '-') {
 479       if (strncmp(&s[ii], "-->", 3) == 0) {
 480         ii += 2;
 481         break;
 482       }
 483     }
 484     if (cdata && s[ii] == ']') {
 485       if (strncmp(&s[ii], "]]>", 3) == 0) {
 486         ii += 2;
 487         break;
 488       }
 489     }
 490
 491     if (!cdata && !comment && s[ii] == '>') {
 492       lv--;
 493       if (lv == 0)
 494         break;
 495       continue;
 496     }
 497   }
 498   return ii;
 499 }
 500
 501 static int
 502 s_cut_text(const char *s, int len, int script)
 503 {
 504   register int ii;
 505   register int sq = 0;
 506   register int dq = 0;
 507
 508   for (ii=0;ii<len; ii++) {
 509     if (is_sjis_kanji(s[ii])) {
 510       ii++;
 511       continue;
 512     }
 513     if (is_sjis_kana(s[ii]))
 514       continue;
 515
 516     if (is_white_space(s[ii]))
 517       continue;
 518
 519     if (script) {
 520       if (s[ii] == '\\') {
 521         ii++;
 522         continue;
 523       }
 524       /* single quote */
 525       if (s[ii] == '\'' && !dq) {
 526         if (sq) sq--;
 527         else    sq++;
 528       }
 529       /* double quote */
 530       if (s[ii] == '"' && !sq) {
 531         if (dq) dq--;
 532         else    dq++;
 533       }
 534     }
 535
 536     if (!sq && !dq && s[ii] == '<')
 537       break;
 538
 539   }
 540
 541   return ii;
 542 }
 543
 544
 545 Node *
 546 qs_init_root_node(Doc *doc)
 547 {
 548   doc->root_node = (Node *)apr_palloc(doc->pool,sizeof(struct Node));
 549   if (doc->root_node == NULL) {
 550     QX_LOGGER_FATAL("Out Of Memory");
 551   }
 552
 553   doc->root_node->next   = NULL;
 554   doc->root_node->parent = NULL;
 555   doc->root_node->child  = NULL;
 556   doc->root_node->attr   = NULL;
 557
 558   doc->root_node->name   = (char *)apr_palloc(doc->pool, 5);
 559   if (doc->root_node->name == NULL) {
 560     QX_LOGGER_FATAL("Out Of Memory");
 561   }
 562   memset(doc->root_node->name, 0, 5);
 563   strcpy(doc->root_node->name, "ROOT");
 564
 565   return doc->root_node;
 566 }
 567
 568
 569
 570 void
 571 qs_add_child_node(Doc *doc,Node *node)
 572 {
 573   node->next       = NULL;
 574   node->child      = NULL;
 575   node->child_tail = NULL;
 576   node->parent = doc->now_parent_node;
 577   if (doc->now_parent_node->child == NULL) {
 578     doc->now_parent_node->child      = node;
 579     doc->now_parent_node->child_tail = node;
 580   }
 581   else {
 582 #ifdef DEBUG
 583     QX_LOGGER_DEBUG("search child free node");
 584 #endif
 585     doc->now_parent_node->child_tail->next = node;
 586     doc->now_parent_node->child_tail       = node;
 587   }
 588 }
 589
 590
 591
 592
 593 Node *
 594 qs_get_root(Doc *doc) {
 595   return doc->root_node;
 596 }
 597
 598
 599
 600
 601 char *
 602 qs_get_node_value(Doc *UNUSED(doc), Node *node) {
 603   return node->value;
 604 }
 605
 606
 607
 608
 609 char *
 610 qs_get_node_name(Doc *UNUSED(doc), Node *node) {
 611   return node->name;
 612 }
 613
 614
 615
 616 Node *
 617 qs_get_child_node(Doc *UNUSED(doc), Node *node) {
 618   return node->child;
 619 }
 620
 621
 622
 623
 624 Node *
 625 qs_get_next_node(Doc *UNUSED(doc), Node *node) {
 626   return node->next;
 627 }
 628
 629
 630
 631 Attr *
 632 qs_get_attr(Doc *UNUSED(doc), Node *node) {
 633   return node->attr;
 634 }
 635
 636
 637
 638
 639 Attr *
 640 qs_get_next_attr(Doc *UNUSED(doc), Attr *attr) {
 641   return attr->next;
 642 }
 643
 644
 645
 646 char *
 647 qs_get_attr_name(Doc *UNUSED(doc), Attr *attr) {
 648   return attr->name;
 649 }
 650
 651
 652
 653 char *
 654 qs_get_attr_value(Doc *UNUSED(doc), Attr *attr) {
 655   return attr->value;
 656 }
 657
 658 int
 659 qs_get_node_size(Doc *UNUSED(doc), Node *node) {
 660   return node->size;
 661 }
 662
 663
 664 #define list_insert(node, point) do {           \
 665     node->ref = point->ref;                     \
 666     *node->ref = node;                          \
 667     node->next = point;                         \
 668     point->ref = &node->next;                   \
 669 } while (0)
 670
 671 #define list_remove(node) do {                  \
 672     *node->ref = node->next;                    \
 673     node->next->ref = node->ref;                \
 674 } while (0)
 675
 676
 677 static void
 678 qs_push_node(Doc *doc, Node *node, NodeStack stack)
 679 {
 680   NodeStackElement elem;
 681   if (doc->r != NULL) {
 682     elem = apr_palloc(doc->r->pool, sizeof(struct node_stack_element));
 683     memset(elem, 0, sizeof(struct node_stack_element));
 684   }
 685   else {
 686     elem = malloc(sizeof(struct node_stack_element));
 687     memset(elem, 0, sizeof(struct node_stack_element));
 688   }
 689   elem->node = node;
 690   if (stack->head == NULL) {
 691     /* add dummy head */
 692     if (doc->r != NULL) {
 693       stack->head = apr_palloc(doc->r->pool, sizeof(struct node_stack_element));
 694       memset(stack->head, 0, sizeof(struct node_stack_element));
 695     }
 696     else {
 697       stack->head = malloc(sizeof(struct node_stack_element));
 698       memset(stack->head, 0, sizeof(struct node_stack_element));
 699     }
 700     stack->head->next = stack->head;
 701     stack->head->ref = &stack->head->next;
 702   }
 703   list_insert(elem, stack->head);
 704   stack->tail = elem;
 705 }
 706
 707 #include "apr_ring.h"
 708
 709 static Node *
 710 qs_pop_node(Doc *doc, NodeStack stack)
 711 {
 712   NodeStackElement tail = stack->tail;
 713   Node *result;
 714
 715   if (tail == NULL) return NULL;
 716   if (tail == stack->head) return NULL;
 717   result = tail->node;
 718
 719
 720   list_remove(tail);
 721   stack->tail = (NodeStackElement)((apr_size_t)stack->head->ref - (apr_size_t)APR_OFFSETOF(struct node_stack_element, next));
 722   if (doc->r == NULL)
 723     free(tail);
 724
 725   return result;
 726 }
 727
 728 #ifdef DUMP_NODE_STACK
 729 static void
 730 qs_dump_node_stack(Doc *doc, NodeStack stack)
 731 {
 732   NodeStackElement elm;
 733   for (elm = stack->head->next;elm != stack->head; elm = elm->next) {
 734     if (doc->r) DBG(doc->r, "name:[%s]", elm->node->name);
 735      else       fprintf(stderr, "[%x] name:[%s] next:[%x]\n", (apr_size_t)elm, elm->node->name, (apr_size_t)elm->next);
 736   }
 737 }
 738 #endif
 739
 740 static void
 741 qs_free_node_stack(Doc *doc, NodeStack stack)
 742 {
 743   if (doc->r == NULL && stack != NULL) {
 744     Node *elm;
 745     for (elm = qs_pop_node(doc, stack);elm; elm = qs_pop_node(doc,stack))
 746       ;
 747     if (stack->head)
 748       free(stack->head);
 749     free(stack);
 750   }
 751 }
 752
 753
 754 static Node *
 755 qs_new_nl_node(Doc *doc)
 756 {
 757   Node *node = (Node *)qs_new_tag(doc);
 758   if (! node) {
 759     QX_LOGGER_DEBUG("runtime exception: qs_parse_tag(): Out of memory.");
 760     return NULL;
 761   }
 762   node->name = apr_pstrdup(doc->pool, QS_PARSE_NL_MARK);
 763   node->otext = NULL;
 764   return node;
 765 }
 766 /*
 767  * vim:ts=2 et
 768  */