src/chxj_xhtml_mobile_1_0.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 "mod_chxj.h"
  18 #include "chxj_encoding.h"
  19 #include "chxj_xhtml_mobile_1_0.h"
  20 #include "chxj_hdml.h"
  21 #include "chxj_dump.h"
  22 #include "chxj_img_conv.h"
  23 #include "chxj_qr_code.h"
  24 #include "chxj_buffered_write.h"
  25 #include "chxj_str_util.h"
  26 #include "chxj_header_inf.h"
  27
  28 #define GET_XHTML(X) ((xhtml_t*)(X))
  29 #undef W_L
  30 #undef W_V
  31 #define W_L(X)          do { xhtml->out = BUFFERED_WRITE_LITERAL(xhtml->out, &doc->buf, (X)); } while(0)
  32 #define W_V(X)          do { xhtml->out = (X) ? BUFFERED_WRITE_VALUE(xhtml->out, &doc->buf, (X))  \
  33                                                : BUFFERED_WRITE_LITERAL(xhtml->out, &doc->buf, ""); } while(0)
  34 #undef W_NLCODE
  35 #define W_NLCODE()     do { char *nlcode = TO_NLCODE(xhtml->conf); W_V(nlcode); } while (0)
  36
  37 static char *s_xhtml_1_0_start_html_tag   (void *pdoc, Node *node);
  38 static char *s_xhtml_1_0_end_html_tag     (void *pdoc, Node *node);
  39 static char *s_xhtml_1_0_start_p_tag      (void *pdoc, Node *node);
  40 static char *s_xhtml_1_0_end_p_tag        (void *pdoc, Node *node);
  41 static char *s_xhtml_1_0_start_pre_tag    (void *pdoc, Node *node);
  42 static char *s_xhtml_1_0_end_pre_tag      (void *pdoc, Node *node);
  43 static char *s_xhtml_1_0_start_ul_tag     (void *pdoc, Node *node);
  44 static char *s_xhtml_1_0_end_ul_tag       (void *pdoc, Node *node);
  45 static char *s_xhtml_1_0_start_h1_tag     (void *pdoc, Node *node);
  46 static char *s_xhtml_1_0_end_h1_tag       (void *pdoc, Node *node);
  47 static char *s_xhtml_1_0_start_h2_tag     (void *pdoc, Node *node);
  48 static char *s_xhtml_1_0_end_h2_tag       (void *pdoc, Node *node);
  49 static char *s_xhtml_1_0_start_h3_tag     (void *pdoc, Node *node);
  50 static char *s_xhtml_1_0_end_h3_tag       (void *pdoc, Node *node);
  51 static char *s_xhtml_1_0_start_h4_tag     (void *pdoc, Node *node);
  52 static char *s_xhtml_1_0_end_h4_tag       (void *pdoc, Node *node);
  53 static char *s_xhtml_1_0_start_h5_tag     (void *pdoc, Node *node);
  54 static char *s_xhtml_1_0_end_h5_tag       (void *pdoc, Node *node);
  55 static char *s_xhtml_1_0_start_h6_tag     (void *pdoc, Node *node);
  56 static char *s_xhtml_1_0_end_h6_tag       (void *pdoc, Node *node);
  57 static char *s_xhtml_1_0_start_ol_tag     (void *pdoc, Node *node);
  58 static char *s_xhtml_1_0_end_ol_tag       (void *pdoc, Node *node);
  59 static char *s_xhtml_1_0_start_li_tag     (void *pdoc, Node *node);
  60 static char *s_xhtml_1_0_end_li_tag       (void *pdoc, Node *node);
  61 static char *s_xhtml_1_0_start_meta_tag   (void *pdoc, Node *node);
  62 static char *s_xhtml_1_0_end_meta_tag     (void *pdoc, Node *node);
  63 static char *s_xhtml_1_0_start_head_tag   (void *pdoc, Node *node);
  64 static char *s_xhtml_1_0_end_head_tag     (void *pdoc, Node *node);
  65 static char *s_xhtml_1_0_start_title_tag  (void *pdoc, Node *node);
  66 static char *s_xhtml_1_0_end_title_tag    (void *pdoc, Node *node);
  67 static char *s_xhtml_1_0_start_base_tag   (void *pdoc, Node *node);
  68 static char *s_xhtml_1_0_end_base_tag     (void *pdoc, Node *node);
  69 static char *s_xhtml_1_0_start_body_tag   (void *pdoc, Node *node);
  70 static char *s_xhtml_1_0_end_body_tag     (void *pdoc, Node *node);
  71 static char *s_xhtml_1_0_start_a_tag      (void *pdoc, Node *node);
  72 static char *s_xhtml_1_0_end_a_tag        (void *pdoc, Node *node);
  73 static char *s_xhtml_1_0_start_br_tag     (void *pdoc, Node *node);
  74 static char *s_xhtml_1_0_end_br_tag       (void *pdoc, Node *node);
  75 static char *s_xhtml_1_0_start_tr_tag     (void *pdoc, Node *node);
  76 static char *s_xhtml_1_0_end_tr_tag       (void *pdoc, Node *node);
  77 static char *s_xhtml_1_0_start_font_tag   (void *pdoc, Node *node);
  78 static char *s_xhtml_1_0_end_font_tag     (void *pdoc, Node *node);
  79 static char *s_xhtml_1_0_start_form_tag   (void *pdoc, Node *node);
  80 static char *s_xhtml_1_0_end_form_tag     (void *pdoc, Node *node);
  81 static char *s_xhtml_1_0_start_input_tag  (void *pdoc, Node *node);
  82 static char *s_xhtml_1_0_end_input_tag    (void *pdoc, Node *node);
  83 static char *s_xhtml_1_0_start_center_tag (void *pdoc, Node *node);
  84 static char *s_xhtml_1_0_end_center_tag   (void *pdoc, Node *node);
  85 static char *s_xhtml_1_0_start_hr_tag     (void *pdoc, Node *node);
  86 static char *s_xhtml_1_0_end_hr_tag       (void *pdoc, Node *node);
  87 static char *s_xhtml_1_0_start_img_tag    (void *pdoc, Node *node);
  88 static char *s_xhtml_1_0_end_img_tag      (void *pdoc, Node *node);
  89 static char *s_xhtml_1_0_start_select_tag (void *pdoc, Node *node);
  90 static char *s_xhtml_1_0_end_select_tag   (void *pdoc, Node *node);
  91 static char *s_xhtml_1_0_start_option_tag (void *pdoc, Node *node);
  92 static char *s_xhtml_1_0_end_option_tag   (void *pdoc, Node *node);
  93 static char *s_xhtml_1_0_start_div_tag       (void *pdoc, Node *node);
  94 static char *s_xhtml_1_0_end_div_tag         (void *pdoc, Node *node);
  95 static char *s_xhtml_1_0_start_textarea_tag  (void *pdoc, Node *node);
  96 static char *s_xhtml_1_0_end_textarea_tag    (void *pdoc, Node *node);
  97 static char *s_xhtml_1_0_start_b_tag         (void *pdoc, Node *node);
  98 static char *s_xhtml_1_0_end_b_tag           (void *pdoc, Node *node);
  99 static char *s_xhtml_1_0_chxjif_tag          (void *pdoc, Node *node);
 100 static char *s_xhtml_1_0_start_blockquote_tag(void *pdoc, Node *node);
 101 static char *s_xhtml_1_0_end_blockquote_tag  (void *pdoc, Node *node);
 102 static char *s_xhtml_1_0_start_dir_tag       (void *pdoc, Node *node);
 103 static char *s_xhtml_1_0_end_dir_tag         (void *pdoc, Node *node);
 104 static char *s_xhtml_1_0_start_dl_tag        (void *pdoc, Node *node);
 105 static char *s_xhtml_1_0_end_dl_tag          (void *pdoc, Node *node);
 106 static char *s_xhtml_1_0_start_dt_tag        (void *pdoc, Node *node);
 107 static char *s_xhtml_1_0_end_dt_tag          (void *pdoc, Node *node);
 108 static char *s_xhtml_1_0_start_dd_tag        (void *pdoc, Node *node);
 109 static char *s_xhtml_1_0_end_dd_tag          (void *pdoc, Node *node);
 110 static char *s_xhtml_1_0_start_menu_tag      (void *pdoc, Node *node);
 111 static char *s_xhtml_1_0_end_menu_tag        (void *pdoc, Node *node);
 112 static char *s_xhtml_1_0_start_plaintext_tag       (void *pdoc, Node *node);
 113 static char *s_xhtml_1_0_start_plaintext_tag_inner (void *pdoc, Node *node);
 114 static char *s_xhtml_1_0_end_plaintext_tag         (void *pdoc, Node *node);
 115 static char *s_xhtml_1_0_start_blink_tag     (void *pdoc, Node *node);
 116 static char *s_xhtml_1_0_end_blink_tag       (void *pdoc, Node *node);
 117 static char *s_xhtml_1_0_start_marquee_tag   (void *pdoc, Node *node);
 118 static char *s_xhtml_1_0_end_marquee_tag     (void *pdoc, Node *node);
 119 static char *s_xhtml_1_0_newline_mark       (void *pdoc, Node *node);
 120
 121 static void  s_init_xhtml(xhtml_t *xhtml, Doc *doc, request_rec *r, device_table *spec);
 122 static int   s_xhtml_search_emoji(xhtml_t *xhtml, char *txt, char **rslt);
 123 static char *s_xhtml_1_0_text_tag(void *pdoc, Node *child);
 124
 125
 126 tag_handler xhtml_handler[] = {
 127   /* tagHTML */
 128   {
 129     s_xhtml_1_0_start_html_tag,
 130     s_xhtml_1_0_end_html_tag,
 131   },
 132   /* tagMETA */
 133   {
 134     s_xhtml_1_0_start_meta_tag,
 135     s_xhtml_1_0_end_meta_tag,
 136   },
 137   /* tagTEXTAREA */
 138   {
 139     s_xhtml_1_0_start_textarea_tag,
 140     s_xhtml_1_0_end_textarea_tag,
 141   },
 142   /* tagP */
 143   {
 144     s_xhtml_1_0_start_p_tag,
 145     s_xhtml_1_0_end_p_tag,
 146   },
 147   /* tagPRE */
 148   {
 149     s_xhtml_1_0_start_pre_tag,
 150     s_xhtml_1_0_end_pre_tag,
 151   },
 152   /* tagUL */
 153   {
 154     s_xhtml_1_0_start_ul_tag,
 155     s_xhtml_1_0_end_ul_tag,
 156   },
 157   /* tagLI */
 158   {
 159     s_xhtml_1_0_start_li_tag,
 160     s_xhtml_1_0_end_li_tag,
 161   },
 162   /* tagOL */
 163   {
 164     s_xhtml_1_0_start_ol_tag,
 165     s_xhtml_1_0_end_ol_tag,
 166   },
 167   /* tagH1 */
 168   {
 169     s_xhtml_1_0_start_h1_tag,
 170     s_xhtml_1_0_end_h1_tag,
 171   },
 172   /* tagH2 */
 173   {
 174     s_xhtml_1_0_start_h2_tag,
 175     s_xhtml_1_0_end_h2_tag,
 176   },
 177   /* tagH3 */
 178   {
 179     s_xhtml_1_0_start_h3_tag,
 180     s_xhtml_1_0_end_h3_tag,
 181   },
 182   /* tagH4 */
 183   {
 184     s_xhtml_1_0_start_h4_tag,
 185     s_xhtml_1_0_end_h4_tag,
 186   },
 187   /* tagH5 */
 188   {
 189     s_xhtml_1_0_start_h5_tag,
 190     s_xhtml_1_0_end_h5_tag,
 191   },
 192   /* tagH6 */
 193   {
 194     s_xhtml_1_0_start_h6_tag,
 195     s_xhtml_1_0_end_h6_tag,
 196   },
 197   /* tagHEAD */
 198   {
 199     s_xhtml_1_0_start_head_tag,
 200     s_xhtml_1_0_end_head_tag,
 201   },
 202   /* tagTITLE */
 203   {
 204     s_xhtml_1_0_start_title_tag,
 205     s_xhtml_1_0_end_title_tag,
 206   },
 207   /* tagBASE */
 208   {
 209     s_xhtml_1_0_start_base_tag,
 210     s_xhtml_1_0_end_base_tag,
 211   },
 212   /* tagBODY */
 213   {
 214     s_xhtml_1_0_start_body_tag,
 215     s_xhtml_1_0_end_body_tag,
 216   },
 217   /* tagA */
 218   {
 219     s_xhtml_1_0_start_a_tag,
 220     s_xhtml_1_0_end_a_tag,
 221   },
 222   /* tagBR */
 223   {
 224     s_xhtml_1_0_start_br_tag,
 225     s_xhtml_1_0_end_br_tag,
 226   },
 227   /* tagTABLE */
 228   {
 229     NULL,
 230     NULL,
 231   },
 232   /* tagTR */
 233   {
 234     s_xhtml_1_0_start_tr_tag,
 235     s_xhtml_1_0_end_tr_tag,
 236   },
 237   /* tagTD */
 238   {
 239     NULL,
 240     NULL,
 241   },
 242   /* tagTBODY */
 243   {
 244     NULL,
 245     NULL,
 246   },
 247   /* tagFONT */
 248   {
 249     s_xhtml_1_0_start_font_tag,
 250     s_xhtml_1_0_end_font_tag,
 251   },
 252   /* tagFORM */
 253   {
 254     s_xhtml_1_0_start_form_tag,
 255     s_xhtml_1_0_end_form_tag,
 256   },
 257   /* tagINPUT */
 258   {
 259     s_xhtml_1_0_start_input_tag,
 260     s_xhtml_1_0_end_input_tag,
 261   },
 262   /* tagCENTER */
 263   {
 264     s_xhtml_1_0_start_center_tag,
 265     s_xhtml_1_0_end_center_tag,
 266   },
 267   /* tagHR */
 268   {
 269     s_xhtml_1_0_start_hr_tag,
 270     s_xhtml_1_0_end_hr_tag,
 271   },
 272   /* tagIMG */
 273   {
 274     s_xhtml_1_0_start_img_tag,
 275     s_xhtml_1_0_end_img_tag,
 276   },
 277   /* tagSELECT */
 278   {
 279     s_xhtml_1_0_start_select_tag,
 280     s_xhtml_1_0_end_select_tag,
 281   },
 282   /* tagOPTION */
 283   {
 284     s_xhtml_1_0_start_option_tag,
 285     s_xhtml_1_0_end_option_tag,
 286   },
 287   /* tagDIV */
 288   {
 289     s_xhtml_1_0_start_div_tag,
 290     s_xhtml_1_0_end_div_tag,
 291   },
 292   /* tagCHXJIF */
 293   {
 294     s_xhtml_1_0_chxjif_tag,
 295     NULL,
 296   },
 297   /* tagNOBR */
 298   {
 299     NULL,
 300     NULL,
 301   },
 302   /* tagSMALL */
 303   {
 304     NULL,
 305     NULL,
 306   },
 307   /* tagSTYLE */
 308   {
 309     NULL,
 310     NULL,
 311   },
 312   /* tagSPAN */
 313   {
 314     NULL,
 315     NULL,
 316   },
 317   /* tagTEXT */
 318   {
 319     s_xhtml_1_0_text_tag,
 320     NULL,
 321   },
 322   /* tagTH */
 323   {
 324     NULL,
 325     NULL,
 326   },
 327   /* tagB */
 328   {
 329     s_xhtml_1_0_start_b_tag,
 330     s_xhtml_1_0_end_b_tag,
 331   },
 332   /* tagFIELDSET */
 333   {
 334     NULL,
 335     NULL,
 336   },
 337   /* tagDT */
 338   {
 339     s_xhtml_1_0_start_dt_tag,
 340     s_xhtml_1_0_end_dt_tag,
 341   },
 342   /* tagLEGEND */
 343   {
 344     NULL,
 345     NULL,
 346   },
 347   /* tagLABEL */
 348   {
 349     NULL,
 350     NULL,
 351   },
 352   /* tagBLOCKQUOTE */
 353   {
 354     s_xhtml_1_0_start_blockquote_tag,
 355     s_xhtml_1_0_end_blockquote_tag,
 356   },
 357   /* tagDIR */
 358   {
 359     s_xhtml_1_0_start_dir_tag,
 360     s_xhtml_1_0_end_dir_tag,
 361   },
 362   /* tagDL */
 363   {
 364     s_xhtml_1_0_start_dl_tag,
 365     s_xhtml_1_0_end_dl_tag,
 366   },
 367   /* tagDD */
 368   {
 369     s_xhtml_1_0_start_dd_tag,
 370     s_xhtml_1_0_end_dd_tag,
 371   },
 372   /* tagMENU */
 373   {
 374     s_xhtml_1_0_start_menu_tag,
 375     s_xhtml_1_0_end_menu_tag,
 376   },
 377   /* tagPLAINTEXT */
 378   {
 379     s_xhtml_1_0_start_plaintext_tag,
 380     s_xhtml_1_0_end_plaintext_tag,
 381   },
 382   /* tagBLINK */
 383   {
 384     s_xhtml_1_0_start_blink_tag,
 385     s_xhtml_1_0_end_blink_tag,
 386   },
 387   /* tagMARQUEE */
 388   {
 389     s_xhtml_1_0_start_marquee_tag,
 390     s_xhtml_1_0_end_marquee_tag,
 391   },
 392   /* tagNLMARK */
 393   {
 394     s_xhtml_1_0_newline_mark,
 395     NULL,
 396   },
 397 };
 398
 399 /**
 400  * converts from CHTML to XHTML.
 401  *
 402  * @param r     [i]   Requet_rec is appointed.
 403  * @param spec  [i]   The result of the device specification processing which
 404  *                    was done in advance is appointed.
 405  * @param src   [i]   The character string before the converting is appointed.
 406  * @return The character string after the converting is returned.
 407  */
 408 char *
 409 chxj_convert_xhtml_mobile_1_0(
 410   request_rec        *r,
 411   device_table       *spec,
 412   const char         *src,
 413   apr_size_t         srclen,
 414   apr_size_t         *dstlen,
 415   chxjconvrule_entry *entryp,
 416   cookie_t           *cookie
 417 )
 418 {
 419   char      *dst = NULL;
 420   char      *ss;
 421   xhtml_t   xhtml;
 422   Doc       doc;
 423
 424   DBG(r,"start chxj_convert_xhtml_mobile_1_0()");
 425   /*--------------------------------------------------------------------------*/
 426   /* If qrcode xml                                                            */
 427   /*--------------------------------------------------------------------------*/
 428   *dstlen = srclen;
 429   dst = chxj_qr_code_blob_handler(r, src, (size_t*)dstlen);
 430   if (dst != NULL) {
 431     DBG(r,"end chxj_convert_xhtml_mobile_1_0() (found qrcode.xml)");
 432     return dst;
 433   }
 434
 435   /*--------------------------------------------------------------------------*/
 436   /* The XHTML structure is initialized.                                      */
 437   /*--------------------------------------------------------------------------*/
 438   s_init_xhtml(&xhtml, &doc, r, spec);
 439
 440   xhtml.entryp = entryp;
 441   xhtml.cookie = cookie;
 442
 443   chxj_set_content_type(r, chxj_header_inf_set_content_type(r, "text/html; charset=Windows-31J"));
 444
 445   /*--------------------------------------------------------------------------*/
 446   /* The character string of the input is analyzed.                           */
 447   /*--------------------------------------------------------------------------*/
 448   qs_init_malloc(&doc);
 449   qs_init_root_node(&doc);
 450
 451   ss = apr_pcalloc(r->pool, srclen + 1);
 452   memset(ss,   0, srclen + 1);
 453   memcpy(ss, src, srclen);
 454
 455 #ifdef DUMP_LOG
 456   chxj_dump_out("[src] CHTML->XHTML", ss, srclen);
 457 #endif
 458   qs_parse_string(&doc,ss, strlen(ss));
 459
 460   chxj_buffered_write_init(r->pool, &doc.buf);
 461   /*--------------------------------------------------------------------------*/
 462   /* It converts it from CHTML to XHTML.                                      */
 463   /*--------------------------------------------------------------------------*/
 464   chxj_node_convert(spec,r,(void *)&xhtml, &doc, qs_get_root(&doc), 0);
 465   xhtml.out = chxj_buffered_write_flush(xhtml.out, &doc.buf);
 466   dst = apr_pstrdup(r->pool, xhtml.out);
 467   chxj_buffered_write_terminate(&doc.buf);
 468
 469   qs_all_free(&doc,QX_LOGMARK);
 470
 471   if (! dst) {
 472     return apr_pstrdup(r->pool,ss);
 473   }
 474
 475   if (! *dst) {
 476     dst = apr_psprintf(r->pool, "\n");
 477   }
 478   *dstlen = strlen(dst);
 479
 480 #ifdef DUMP_LOG
 481   chxj_dump_out("[dst] CHTML->XHTML", dst, *dstlen);
 482 #endif
 483
 484   DBG(r,"end chxj_convert_xhtml_mobile_1_0()");
 485   return dst;
 486 }
 487
 488
 489 /**
 490  * The XHTML structure is initialized.
 491  *
 492  * @param xhtml [i/o] The pointer to the HDML structure that wants to be
 493  *                   initialized is specified.
 494  * @param doc   [i]   The Doc structure that should be set to the initialized
 495  *                   HDML structure is specified.
 496  * @param r     [i]   To use POOL, the pointer to request_rec is specified.
 497  * @param spec  [i]   The pointer to the device_table
 498  */
 499 static void
 500 s_init_xhtml(xhtml_t *xhtml, Doc *doc, request_rec *r, device_table *spec)
 501 {
 502   memset(doc,   0, sizeof(Doc));
 503   memset(xhtml, 0, sizeof(xhtml_t));
 504
 505   doc->r      = r;
 506   xhtml->doc  = doc;
 507   xhtml->spec = spec;
 508   xhtml->out  = qs_alloc_zero_byte_string(r->pool);
 509   xhtml->conf = chxj_get_module_config(r->per_dir_config, &chxj_module);
 510   xhtml->doc->parse_mode = PARSE_MODE_CHTML;
 511 }
 512
 513
 514 /**
 515  * Corresponding EMOJI to a current character-code is retrieved.
 516  * The substitution character string is stored in the rslt pointer if agreeing.
 517  *
 518  * @param xhtml   [i]   The pointer to the XHTML structure is specified.
 519  * @param txt     [i]   The character string to want to examine whether it is
 520  *                      EMOJI is specified.
 521  * @param rslt    [o]   The pointer to the pointer that stores the result is
 522  *                      specified.
 523  * @return When corresponding EMOJI exists, it returns it excluding 0.
 524  */
 525 static int
 526 s_xhtml_search_emoji(xhtml_t *xhtml, char *txt, char **rslt)
 527 {
 528   emoji_t       *ee;
 529   request_rec   *r;
 530   device_table  *spec;
 531   int           len;
 532
 533   spec = xhtml->spec;
 534
 535   len = strlen(txt);
 536   r = xhtml->doc->r;
 537
 538   if (spec == NULL) {
 539     DBG(r,"spec is NULL");
 540   }
 541
 542   for (ee = xhtml->conf->emoji;
 543        ee;
 544        ee = ee->next) {
 545     unsigned char hex1byte;
 546     unsigned char hex2byte;
 547     if (!ee->imode) {
 548       DBG(r,"emoji->imode is NULL");
 549       continue;
 550     }
 551
 552     if (ee->imode->string != NULL
 553     &&  strlen(ee->imode->string) > 0
 554     &&  strncasecmp(ee->imode->string, txt, strlen(ee->imode->string)) == 0) {
 555       if (spec == NULL || spec->emoji_type == NULL) {
 556         *rslt = apr_psprintf(r->pool,
 557                         "<img localsrc=%s>",
 558                         ee->ezweb->typeA);
 559         return strlen(ee->imode->string);
 560       }
 561
 562       if (strcasecmp(xhtml->spec->emoji_type, "a") == 0) {
 563         *rslt = apr_psprintf(r->pool,
 564                         "<img localsrc=%s>",
 565                         ee->ezweb->typeA);
 566         return strlen(ee->imode->string);
 567       }
 568       else
 569       if (strcasecmp(xhtml->spec->emoji_type, "b") == 0) {
 570         *rslt = apr_psprintf(r->pool,
 571                         "<img localsrc=%s>",
 572                         ee->ezweb->typeB);
 573         return strlen(ee->imode->string);
 574       }
 575       else
 576       if (strcasecmp(xhtml->spec->emoji_type, "c") == 0) {
 577         *rslt = apr_psprintf(r->pool,
 578                         "<img localsrc=%s>",
 579                         ee->ezweb->typeC);
 580         return strlen(ee->imode->string);
 581       }
 582       else
 583       if (strcasecmp(xhtml->spec->emoji_type, "d") == 0) {
 584         *rslt = apr_psprintf(r->pool,
 585                         "<img localsrc=%s>",
 586                         ee->ezweb->typeD);
 587         return strlen(ee->imode->string);
 588       }
 589       else {
 590         *rslt = apr_psprintf(r->pool,
 591                         "<img localsrc=%s>",
 592                         ee->ezweb->typeA);
 593         return strlen(ee->imode->string);
 594       }
 595       return 0;
 596     }
 597     hex1byte = ee->imode->hex1byte & 0xff;
 598     hex2byte = ee->imode->hex2byte & 0xff;
 599     if (len >= 2
 600     && ((unsigned char)txt[0] & 0xff) == ((unsigned char)hex1byte)
 601     && ((unsigned char)txt[1] & 0xff) == ((unsigned char)hex2byte)) {
 602       if (spec == NULL || spec->emoji_type == NULL) {
 603         *rslt = apr_psprintf(r->pool,
 604                         "<img localsrc=\"%s\">",
 605                         ee->ezweb->typeA);
 606         return 2;
 607       }
 608
 609       if (strcasecmp(xhtml->spec->emoji_type, "a") == 0) {
 610         *rslt = apr_psprintf(r->pool,
 611                         "<img localsrc=\"%s\">",
 612                         ee->ezweb->typeA);
 613         return 2;
 614       }
 615       else
 616       if (strcasecmp(xhtml->spec->emoji_type, "b") == 0) {
 617         *rslt = apr_psprintf(r->pool,
 618                         "<img localsrc=\"%s\">",
 619                         ee->ezweb->typeB);
 620         return 2;
 621       }
 622       else
 623       if (strcasecmp(xhtml->spec->emoji_type, "c") == 0) {
 624         *rslt = apr_psprintf(r->pool,
 625                         "<img localsrc=\"%s\">",
 626                         ee->ezweb->typeC);
 627         return 2;
 628       }
 629       else
 630       if (strcasecmp(xhtml->spec->emoji_type, "d") == 0) {
 631         *rslt = apr_psprintf(r->pool,
 632                         "<img localsrc=\"%s\">",
 633                         ee->ezweb->typeD);
 634         return 2;
 635       }
 636       else {
 637         *rslt = apr_psprintf(r->pool,
 638                         "<img localsrc=\"%s\">",
 639                         ee->ezweb->typeD);
 640         return 2;
 641       }
 642       return 0;
 643     }
 644   }
 645   return 0;
 646 }
 647
 648
 649 /**
 650  * It is a handler who processes the HTML tag.
 651  *
 652  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 653  *                     destination is specified.
 654  * @param node   [i]   The HTML tag node is specified.
 655  * @return The conversion result is returned.
 656  */
 657 static char *
 658 s_xhtml_1_0_start_html_tag(void *pdoc, Node *node)
 659 {
 660   xhtml_t       *xhtml = GET_XHTML(pdoc);
 661   Attr          *attr;
 662   Doc           *doc   = xhtml->doc;
 663
 664   /*--------------------------------------------------------------------------*/
 665   /* Add XML Declare                                                          */
 666   /*--------------------------------------------------------------------------*/
 667   W_L("<?xml version=\"1.0\" encoding=\"Windows-31J\"?>");
 668   W_NLCODE();
 669   /*--------------------------------------------------------------------------*/
 670   /* Add DocType                                                              */
 671   /*--------------------------------------------------------------------------*/
 672   W_L("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML Basic 1.0//EN\"");
 673   W_NLCODE();
 674   W_L(" \"http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd\">");
 675   W_NLCODE();
 676   /*--------------------------------------------------------------------------*/
 677   /* start HTML tag                                                           */
 678   /*--------------------------------------------------------------------------*/
 679   W_L("<html xmlns=\"http://www.w3.org/1999/xhtml\"");
 680   /*--------------------------------------------------------------------------*/
 681   /* Get Attributes                                                           */
 682   /*--------------------------------------------------------------------------*/
 683   for (attr = qs_get_attr(doc,node);
 684        attr;
 685        attr = qs_get_next_attr(doc,attr)) {
 686     char* name  = qs_get_attr_name(doc,attr);
 687     char* value = qs_get_attr_value(doc,attr);
 688     if (STRCASEEQ('l','L',"lang", name)) {
 689       W_L(" xml:lang=\"");
 690       W_V(value);
 691       W_L("\"");
 692     }
 693     else if (STRCASEEQ('v','V',"version", name)) {
 694       W_L(" version=\"-//OPENWAVE//DTD XHTML Mobile 1.0//EN\"");
 695     }
 696   }
 697   W_L(">");
 698   return xhtml->out;
 699 }
 700
 701
 702 /**
 703  * It is a handler who processes the HTML tag.
 704  *
 705  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 706  *                     destination is specified.
 707  * @param node   [i]   The HTML tag node is specified.
 708  * @return The conversion result is returned.
 709  */
 710 static char *
 711 s_xhtml_1_0_end_html_tag(void *pdoc, Node *UNUSED(child))
 712 {
 713   xhtml_t       *xhtml = GET_XHTML(pdoc);
 714   Doc           *doc   = xhtml->doc;
 715   W_L("</html>");
 716   return xhtml->out;
 717 }
 718
 719
 720 /**
 721  * It is a handler who processes the META tag.
 722  *
 723  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 724  *                     destination is specified.
 725  * @param node   [i]   The META tag node is specified.
 726  * @return The conversion result is returned.
 727  */
 728 static char *
 729 s_xhtml_1_0_start_meta_tag(void *pdoc, Node *node)
 730 {
 731   xhtml_t       *xhtml = GET_XHTML(pdoc);
 732   Attr          *attr;
 733   Doc           *doc   = xhtml->doc;
 734   int           content_type_flag = 0;
 735   request_rec   *r = doc->r;
 736
 737   W_L("<meta");
 738   /*--------------------------------------------------------------------------*/
 739   /* Get Attributes                                                           */
 740   /*--------------------------------------------------------------------------*/
 741   for (attr = qs_get_attr(doc,node);
 742        attr;
 743        attr = qs_get_next_attr(doc,attr)) {
 744     char *name  = qs_get_attr_name(doc,attr);
 745     char *value = qs_get_attr_value(doc,attr);
 746     if (STRCASEEQ('n','N',"name", name) && value && *value) {
 747       W_L(" ");
 748       W_V(name);
 749       W_L("=\"");
 750       W_V(value);
 751       W_L("\"");
 752     }
 753     else if (STRCASEEQ('h','H',"http-equiv", name) && value && *value) {
 754       W_L(" ");
 755       W_V(name);
 756       W_L("=\"");
 757       W_V(value);
 758       W_L("\"");
 759       if (STRCASEEQ('c','C', "content-type", value)) {
 760         content_type_flag = 1;
 761       }
 762     }
 763     else if (STRCASEEQ('c','C',"content", name) && value && *value) {
 764       if (content_type_flag) {
 765         W_L(" ");
 766         W_V(name);
 767         W_L("=\"");
 768         W_V(chxj_header_inf_set_content_type(r, "text/html; charset=Windows-31J"));
 769         W_L("\"");
 770       }
 771       else {
 772         W_L(" ");
 773         W_V(name);
 774         W_L("=\"");
 775         W_V(value);
 776         W_L("\"");
 777       }
 778     }
 779   }
 780   W_L(" />");
 781   return xhtml->out;
 782 }
 783
 784
 785 /**
 786  * It is a handler who processes the META tag.
 787  *
 788  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 789  *                     destination is specified.
 790  * @param node   [i]   The META tag node is specified.
 791  * @return The conversion result is returned.
 792  */
 793 static char *
 794 s_xhtml_1_0_end_meta_tag(void *pdoc, Node *UNUSED(child))
 795 {
 796   xhtml_t *xhtml = GET_XHTML(pdoc);
 797
 798   return xhtml->out;
 799 }
 800
 801
 802 /**
 803  * It is a handler who processes the HEAD tag.
 804  *
 805  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 806  *                     destination is specified.
 807  * @param node   [i]   The HEAD tag node is specified.
 808  * @return The conversion result is returned.
 809  */
 810 static char *
 811 s_xhtml_1_0_start_head_tag(void *pdoc, Node *UNUSED(node))
 812 {
 813   xhtml_t       *xhtml = GET_XHTML(pdoc);
 814   Doc           *doc   = xhtml->doc;
 815
 816   W_L("<head>");
 817   return xhtml->out;
 818 }
 819
 820
 821 /**
 822  * It is a handler who processes the HEAD tag.
 823  *
 824  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 825  *                     destination is specified.
 826  * @param node   [i]   The HEAD tag node is specified.
 827  * @return The conversion result is returned.
 828  */
 829 static char *
 830 s_xhtml_1_0_end_head_tag(void *pdoc, Node *UNUSED(child))
 831 {
 832   xhtml_t       *xhtml = GET_XHTML(pdoc);
 833   Doc           *doc   = xhtml->doc;
 834
 835   W_L("</head>");
 836   return xhtml->out;
 837 }
 838
 839
 840 /**
 841  * It is a handler who processes the TITLE tag.
 842  *
 843  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 844  *                     destination is specified.
 845  * @param node   [i]   The TITLE tag node is specified.
 846  * @return The conversion result is returned.
 847  */
 848 static char *
 849 s_xhtml_1_0_start_title_tag(void *pdoc, Node *UNUSED(node))
 850 {
 851   xhtml_t      *xhtml = GET_XHTML(pdoc);
 852   Doc          *doc   = xhtml->doc;
 853
 854   W_L("<title>");
 855   return xhtml->out;
 856 }
 857
 858
 859 /**
 860  * It is a handler who processes the TITLE tag.
 861  *
 862  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 863  *                     destination is specified.
 864  * @param node   [i]   The TITLE tag node is specified.
 865  * @return The conversion result is returned.
 866  */
 867 static char *
 868 s_xhtml_1_0_end_title_tag(void *pdoc, Node *UNUSED(child))
 869 {
 870   xhtml_t       *xhtml = GET_XHTML(pdoc);
 871   Doc           *doc   = xhtml->doc;
 872
 873   W_L("</title>");
 874
 875   return xhtml->out;
 876 }
 877
 878
 879 /**
 880  * It is a handler who processes the BASE tag.
 881  *
 882  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 883  *                     destination is specified.
 884  * @param node   [i]   The BASE tag node is specified.
 885  * @return The conversion result is returned.
 886  */
 887 static char *
 888 s_xhtml_1_0_start_base_tag(void *pdoc, Node *node)
 889 {
 890   xhtml_t       *xhtml = GET_XHTML(pdoc);
 891   Attr          *attr;
 892   Doc           *doc   = xhtml->doc;
 893
 894   W_L("<base");
 895   /*--------------------------------------------------------------------------*/
 896   /* Get Attributes                                                           */
 897   /*--------------------------------------------------------------------------*/
 898   for (attr = qs_get_attr(doc,node);
 899        attr;
 900        attr = qs_get_next_attr(doc,attr)) {
 901     char *name = qs_get_attr_name(doc,attr);
 902     char *value = qs_get_attr_value(doc,attr);
 903     if (STRCASEEQ('h','H',"href",name)) {
 904       W_L(" href=\"");
 905       W_V(value);
 906       W_L("\"");
 907       break;
 908     }
 909   }
 910   W_L(" />");
 911
 912   return xhtml->out;
 913 }
 914
 915
 916 /**
 917  * It is a handler who processes the BASE tag.
 918  *
 919  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 920  *                     destination is specified.
 921  * @param node   [i]   The BASE tag node is specified.
 922  * @return The conversion result is returned.
 923  */
 924 static char *
 925 s_xhtml_1_0_end_base_tag(void *pdoc, Node *UNUSED(child))
 926 {
 927   xhtml_t *xhtml = GET_XHTML(pdoc);
 928
 929   return xhtml->out;
 930 }
 931
 932
 933 /**
 934  * It is a handler who processes the BODY tag.
 935  *
 936  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 937  *                     destination is specified.
 938  * @param node   [i]   The BODY tag node is specified.
 939  * @return The conversion result is returned.
 940  */
 941 static char *
 942 s_xhtml_1_0_start_body_tag(void *pdoc, Node *node)
 943 {
 944   xhtml_t      *xhtml = GET_XHTML(pdoc);
 945   Doc          *doc   = xhtml->doc;
 946   Attr         *attr;
 947
 948   W_L("<body");
 949   /*--------------------------------------------------------------------------*/
 950   /* Get Attributes                                                           */
 951   /*--------------------------------------------------------------------------*/
 952   for (attr = qs_get_attr(doc,node);
 953        attr;
 954        attr = qs_get_next_attr(doc,attr)) {
 955     char *name  = qs_get_attr_name(doc,attr);
 956     char *value = qs_get_attr_value(doc,attr);
 957     if (STRCASEEQ('b','B',"bgcolor", name) && value && *value) {
 958       W_L(" bgcolor=\"");
 959       W_V(value);
 960       W_L("\"");
 961     }
 962     else if (STRCASEEQ('t','T',"text",name) && value && *value) {
 963       W_L(" text=\"");
 964       W_V(value);
 965       W_L("\"");
 966     }
 967     else if (STRCASEEQ('l','L',"link", name) && value && *value) {
 968       W_L(" link=\"");
 969       W_V(value);
 970       W_L("\"");
 971     }
 972     else if (STRCASEEQ('a','A',"alink", name)) {
 973       /* ignore */
 974     }
 975     else if (STRCASEEQ('v','V',"vlink",name)) {
 976       /* ignore */
 977     }
 978   }
 979   W_L(">");
 980   return xhtml->out;
 981 }
 982
 983
 984 /**
 985  * It is a handler who processes the BODY tag.
 986  *
 987  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
 988  *                     destination is specified.
 989  * @param node   [i]   The BODY tag node is specified.
 990  * @return The conversion result is returned.
 991  */
 992 static char *
 993 s_xhtml_1_0_end_body_tag(void *pdoc, Node *UNUSED(child))
 994 {
 995   xhtml_t       *xhtml = GET_XHTML(pdoc);
 996   Doc           *doc   = xhtml->doc;
 997
 998   W_L("</body>");
 999   return xhtml->out;
1000 }
1001
1002
1003 /**
1004  * It is a handler who processes the A tag.
1005  *
1006  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1007  *                     destination is specified.
1008  * @param node   [i]   The A tag node is specified.
1009  * @return The conversion result is returned.
1010  */
1011 static char *
1012 s_xhtml_1_0_start_a_tag(void *pdoc, Node *node)
1013 {
1014   xhtml_t       *xhtml = GET_XHTML(pdoc);
1015   Doc           *doc   = xhtml->doc;
1016   request_rec   *r     = doc->r;
1017   Attr          *attr;
1018
1019   W_L("<a");
1020   /*--------------------------------------------------------------------------*/
1021   /* Get Attributes                                                           */
1022   /*--------------------------------------------------------------------------*/
1023   for (attr = qs_get_attr(doc,node);
1024        attr;
1025        attr = qs_get_next_attr(doc,attr)) {
1026     char* name  = qs_get_attr_name(doc,attr);
1027     char* value = qs_get_attr_value(doc,attr);
1028     if (STRCASEEQ('n','N',"name",name) && value && *value) {
1029       W_L(" id=\"");
1030       W_V(value);
1031       W_L("\"");
1032     }
1033     else if (STRCASEEQ('h','H',"href", name) && value && *value) {
1034       value = chxj_encoding_parameter(r, value);
1035       if (! chxj_starts_with(value, "mailto:") && ! chxj_starts_with(value, "telto:")) {
1036         value = chxj_add_cookie_parameter(r, value, xhtml->cookie);
1037       }
1038       W_L(" href=\"");
1039       W_V(value);
1040       W_L("\"");
1041     }
1042     else if (STRCASEEQ('a','A',"accesskey", name)) {
1043       W_L(" accesskey=\"");
1044       W_V(value);
1045       W_L("\"");
1046     }
1047     else if (STRCASEEQ('c','C',"cti",name)) {
1048       /* ignore */
1049     }
1050     else if (STRCASEEQ('i','I',"ijam", name)) {
1051       /* ignore */
1052     }
1053     else if (STRCASEEQ('u','U',"utn", name)) {
1054       /* ignore */
1055     }
1056     else if (STRCASEEQ('t','T',"telbook",name)) {
1057       /* ignore */
1058     }
1059     else if (STRCASEEQ('k','K',"kana",name)) {
1060       /* ignore */
1061     }
1062     else if (STRCASEEQ('e','E',"email",name)) {
1063       /* ignore */
1064     }
1065     else if (STRCASEEQ('i','I',"ista",name)) {
1066       /* ignore */
1067     }
1068     else if (STRCASEEQ('i','I',"ilet",name)) {
1069       /* ignore */
1070     }
1071     else if (STRCASEEQ('i','I',"iswf",name)) {
1072       /* ignore */
1073     }
1074     else if (STRCASEEQ('i','I',"irst",name)) {
1075       /* ignore */
1076     }
1077   }
1078   W_L(">");
1079   return xhtml->out;
1080 }
1081
1082
1083 /**
1084  * It is a handler who processes the A tag.
1085  *
1086  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1087  *                     destination is specified.
1088  * @param node   [i]   The A tag node is specified.
1089  * @return The conversion result is returned.
1090  */
1091 static char *
1092 s_xhtml_1_0_end_a_tag(void *pdoc, Node *UNUSED(child))
1093 {
1094   xhtml_t *xhtml = GET_XHTML(pdoc);
1095   Doc     *doc   = xhtml->doc;
1096
1097   W_L("</a>");
1098
1099   return xhtml->out;
1100 }
1101
1102
1103 /**
1104  * It is a handler who processes the BR tag.
1105  *
1106  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1107  *                     destination is specified.
1108  * @param node   [i]   The BR tag node is specified.
1109  * @return The conversion result is returned.
1110  */
1111 static char *
1112 s_xhtml_1_0_start_br_tag(void *pdoc, Node *node)
1113 {
1114   xhtml_t *xhtml = GET_XHTML(pdoc);
1115   Doc     *doc   = xhtml->doc;
1116   Attr    *attr;
1117
1118   W_L("<br");
1119   /*--------------------------------------------------------------------------*/
1120   /* Get Attributes                                                           */
1121   /*--------------------------------------------------------------------------*/
1122   for (attr = qs_get_attr(doc,node);
1123        attr;
1124        attr = qs_get_next_attr(doc,attr)) {
1125     char *name  = qs_get_attr_name(doc,attr);
1126     char *value = qs_get_attr_value(doc,attr);
1127     if (STRCASEEQ('c','C',"clear",name)) {
1128       if (value && (STRCASEEQ('l','L',"left",value) || STRCASEEQ('r','R',"right",value) || STRCASEEQ('a','A',"all",value))) {
1129         W_L(" clear=\"");
1130         W_V(value);
1131         W_L("\"");
1132       }
1133     }
1134   }
1135   W_L(" />");
1136
1137   return xhtml->out;
1138 }
1139
1140
1141 /**
1142  * It is a handler who processes the BR tag.
1143  *
1144  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1145  *                     destination is specified.
1146  * @param node   [i]   The BR tag node is specified.
1147  * @return The conversion result is returned.
1148  */
1149 static char *
1150 s_xhtml_1_0_end_br_tag(void *pdoc, Node *UNUSED(child))
1151 {
1152   xhtml_t *xhtml = GET_XHTML(pdoc);
1153
1154   return xhtml->out;
1155 }
1156
1157
1158 /**
1159  * It is a handler who processes the TR tag.
1160  *
1161  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1162  *                     destination is specified.
1163  * @param node   [i]   The TR tag node is specified.
1164  * @return The conversion result is returned.
1165  */
1166 static char *
1167 s_xhtml_1_0_start_tr_tag(void *pdoc, Node *UNUSED(node))
1168 {
1169   xhtml_t *xhtml = GET_XHTML(pdoc);
1170   Doc     *doc   = xhtml->doc;
1171
1172   W_L("<br />");
1173
1174   return xhtml->out;
1175 }
1176
1177
1178 /**
1179  * It is a handler who processes the TR tag.
1180  *
1181  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1182  *                     destination is specified.
1183  * @param node   [i]   The TR tag node is specified.
1184  * @return The conversion result is returned.
1185  */
1186 static char *
1187 s_xhtml_1_0_end_tr_tag(void *pdoc, Node *UNUSED(child))
1188 {
1189   xhtml_t *xhtml = GET_XHTML(pdoc);
1190
1191   return xhtml->out;
1192 }
1193
1194
1195 /**
1196  * It is a handler who processes the FONT tag.
1197  *
1198  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1199  *                     destination is specified.
1200  * @param node   [i]   The FONT tag node is specified.
1201  * @return The conversion result is returned.
1202  */
1203 static char *
1204 s_xhtml_1_0_start_font_tag(void *pdoc, Node *node)
1205 {
1206   xhtml_t *xhtml = GET_XHTML(pdoc);
1207   Doc     *doc   = xhtml->doc;
1208   Attr    *attr;
1209   char    *size = NULL;
1210   char    *color = NULL;
1211
1212   /*=========================================================================*/
1213   /* Get Attributes                                                          */
1214   /*=========================================================================*/
1215   for (attr = qs_get_attr(doc,node);
1216        attr;
1217        attr = qs_get_next_attr(doc,attr)) {
1218     char *name = qs_get_attr_name(doc,attr);
1219     char *value = qs_get_attr_value(doc,attr);
1220     if (STRCASEEQ('c','C',"color",name) && value && *value) {
1221       color = apr_pstrdup(doc->buf.pool, value);
1222     }
1223     else if (STRCASEEQ('s','S',"size",name) && value && *value) {
1224       size = apr_pstrdup(doc->buf.pool, value);
1225     }
1226   }
1227   if (color) {
1228     W_L("<font color=\"");
1229     W_V(color);
1230     W_L("\">");
1231     xhtml->font_color_flag++;
1232   }
1233   if (size) {
1234     xhtml->font_size_flag++;
1235     switch(*size) {
1236     case '1': W_L("<span style=\"font-size: xx-small\">"); break;
1237     case '2': W_L("<span style=\"font-size: x-small\">");  break;
1238     case '3': W_L("<span style=\"font-size: small\">");    break;
1239     case '4': W_L("<span style=\"font-size: medium\">");   break;
1240     case '5': W_L("<span style=\"font-size: large\">");    break;
1241     case '6': W_L("<span style=\"font-size: x-large\">");  break;
1242     case '7': W_L("<span style=\"font-size: xx-large\">"); break;
1243     case '-':
1244       if (*(size + 1) == '1') {
1245         W_L("<span style=\"font-size: small\">");
1246         break;
1247       }
1248       if (*(size + 1) == '2') {
1249         W_L("<span style=\"font-size: x-small\">");
1250         break;
1251       }
1252       if (*(size + 1) == '3') {
1253         W_L("<span style=\"font-size: xx-small\">");
1254         break;
1255       }
1256       xhtml->font_size_flag--;
1257       break;
1258
1259     case '+':
1260       if (*(size + 1) == '1') {
1261         W_L("<span style=\"font-size: large\">");
1262         break;
1263       }
1264       if (*(size + 1) == '2') {
1265         W_L("<span style=\"font-size: x-large\">");
1266         break;
1267       }
1268       if (*(size + 1) == '3') {
1269         W_L("<span style=\"font-size: xx-large\">");
1270         break;
1271       }
1272       xhtml->font_size_flag--;
1273       break;
1274
1275     default:
1276       WRN(doc->r, "invlalid font size. [%s] != (1|2|3|4|5|6|7|+1|+2|+3|-1|-2|-3)", size);
1277       xhtml->font_size_flag--;
1278     }
1279   }
1280   return xhtml->out;
1281 }
1282
1283
1284 /**
1285  * It is a handler who processes the FONT tag.
1286  *
1287  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1288  *                     destination is specified.
1289  * @param node   [i]   The FONT tag node is specified.
1290  * @return The conversion result is returned.
1291  */
1292 static char *
1293 s_xhtml_1_0_end_font_tag(void *pdoc, Node *UNUSED(child))
1294 {
1295   xhtml_t *xhtml = GET_XHTML(pdoc);
1296   Doc     *doc   = xhtml->doc;
1297
1298   if (xhtml->font_size_flag) {
1299     W_L("</span>");
1300     xhtml->font_size_flag--;
1301   }
1302   if (xhtml->font_color_flag) {
1303     W_L("</font>");
1304     xhtml->font_color_flag--;
1305   }
1306   return xhtml->out;
1307 }
1308
1309
1310 /**
1311  * It is a handler who processes the FORM tag.
1312  *
1313  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1314  *                     destination is specified.
1315  * @param node   [i]   The FORM tag node is specified.
1316  * @return The conversion result is returned.
1317  */
1318 static char *
1319 s_xhtml_1_0_start_form_tag(void *pdoc, Node *node)
1320 {
1321   xhtml_t     *xhtml = GET_XHTML(pdoc);
1322   Doc         *doc   = xhtml->doc;
1323   request_rec *r     = doc->r;
1324   Attr        *attr;
1325   char        *new_hidden_tag = NULL;
1326   char        *attr_action = NULL;
1327   char        *attr_method = NULL;
1328   char        *attr_name = NULL;
1329
1330   /*--------------------------------------------------------------------------*/
1331   /* Get Attributes                                                           */
1332   /*--------------------------------------------------------------------------*/
1333   for (attr = qs_get_attr(doc,node);
1334        attr;
1335        attr = qs_get_next_attr(doc,attr)) {
1336     char *name = qs_get_attr_name(doc,attr);
1337     char *value = qs_get_attr_value(doc,attr);
1338     if (STRCASEEQ('a','A',"action",name)) {
1339       attr_action = chxj_encoding_parameter(r, value);
1340       attr_action = chxj_add_cookie_parameter(r, attr_action, xhtml->cookie);
1341     }
1342     else if (STRCASEEQ('m','M',"method",name)) {
1343       attr_method = apr_pstrdup(doc->pool, value);
1344     }
1345     else if (STRCASEEQ('u','U',"utn",name)) {
1346       /* ignore */
1347     }
1348     else if (STRCASEEQ('n','N',"name",name)) {
1349       attr_name = apr_pstrdup(doc->pool, value);
1350     }
1351   }
1352
1353   int post_flag = (attr_method && strcasecmp(attr_method, "post") == 0) ? 1 : 0;
1354
1355   W_L("<form");
1356   if (attr_action) {
1357     char *q;
1358     q = strchr(attr_action, '?');
1359     if (q) {
1360       new_hidden_tag = chxj_form_action_to_hidden_tag(r, doc->pool, attr_action, 1, post_flag);
1361       if (new_hidden_tag) {
1362         *q = 0;
1363       }
1364     }
1365     W_L(" action=\"");
1366     W_V(attr_action);
1367     W_L("\"");
1368   }
1369   if (attr_method) {
1370     W_L(" method=\"");
1371     W_V(attr_method);
1372     W_L("\"");
1373   }
1374   if (attr_name) {
1375     W_L(" name=\"");
1376     W_V(attr_name);
1377     W_L("\"");
1378   }
1379   W_L(">");
1380   if (new_hidden_tag) {
1381     W_V(new_hidden_tag);
1382   }
1383   return xhtml->out;
1384 }
1385
1386
1387 /**
1388  * It is a handler who processes the FORM tag.
1389  *
1390  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1391  *                     destination is specified.
1392  * @param node   [i]   The FORM tag node is specified.
1393  * @return The conversion result is returned.
1394  */
1395 static char *
1396 s_xhtml_1_0_end_form_tag(void *pdoc, Node *UNUSED(child))
1397 {
1398   xhtml_t *xhtml = GET_XHTML(pdoc);
1399   Doc     *doc   = xhtml->doc;
1400
1401   W_L("</form>");
1402
1403   return xhtml->out;
1404 }
1405
1406
1407 /**
1408  * It is a handler who processes the INPUT tag.
1409  *
1410  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1411  *                     destination is specified.
1412  * @param node   [i]   The INPUT tag node is specified.
1413  * @return The conversion result is returned.
1414  */
1415 static char *
1416 s_xhtml_1_0_start_input_tag(void *pdoc, Node *node)
1417 {
1418   xhtml_t     *xhtml       = GET_XHTML(pdoc);
1419   Doc         *doc         = xhtml->doc;
1420   request_rec *r           = doc->r;
1421   char        *max_length  = NULL;
1422   char        *type        = NULL;
1423   char        *name        = NULL;
1424   char        *value       = NULL;
1425   char        *istyle      = NULL;
1426   char        *size        = NULL;
1427   char        *checked     = NULL;
1428   char        *accesskey   = NULL;
1429
1430   W_L("<input");
1431   /*--------------------------------------------------------------------------*/
1432   /* Get Attributes                                                           */
1433   /*--------------------------------------------------------------------------*/
1434   type       = qs_get_type_attr(doc, node, doc->buf.pool);
1435   name       = qs_get_name_attr(doc, node, doc->buf.pool);
1436   value      = qs_get_value_attr(doc,node, doc->buf.pool);
1437   istyle     = qs_get_istyle_attr(doc,node,doc->buf.pool);
1438   max_length = qs_get_maxlength_attr(doc,node,doc->buf.pool);
1439   checked    = qs_get_checked_attr(doc,node, doc->buf.pool);
1440   accesskey  = qs_get_accesskey_attr(doc, node, doc->buf.pool);
1441   size       = qs_get_size_attr(doc, node, doc->buf.pool);
1442
1443   if (type) {
1444     type = qs_trim_string(doc->buf.pool, type);
1445     if (type && (STRCASEEQ('t','T',"text",    type) ||
1446                  STRCASEEQ('p','P',"password",type) ||
1447                  STRCASEEQ('c','C',"checkbox",type) ||
1448                  STRCASEEQ('r','R',"radio",   type) ||
1449                  STRCASEEQ('h','H',"hidden",  type) ||
1450                  STRCASEEQ('s','S',"submit",  type) ||
1451                  STRCASEEQ('r','R',"reset",   type))) {
1452       W_L(" type=\"");
1453       W_V(type);
1454       W_L("\"");
1455     }
1456   }
1457   if (size && *size) {
1458     W_L(" size=\"");
1459     W_V(size);
1460     W_L("\"");
1461   }
1462   if (name && *name) {
1463     W_L(" name=\"");
1464     W_V(name);
1465     W_L("\"");
1466   }
1467   if (value && *value) {
1468     W_L(" value=\"");
1469     W_V(chxj_add_slash_to_doublequote(doc->pool, value));
1470     W_L("\"");
1471   }
1472   if (accesskey && *accesskey) {
1473     W_L(" accesskey=\"");
1474     W_V(accesskey);
1475     W_L("\"");
1476   }
1477   if (istyle && *istyle && (*istyle == '1' || *istyle == '2' || *istyle == '3' || *istyle == '4')) {
1478     char *fmt = qs_conv_istyle_to_format(r,istyle);
1479     if (max_length && *max_length) {
1480       int ii;
1481       for (ii=0; (unsigned int)ii<strlen(max_length); ii++) {
1482         if (max_length[ii] < '0' || max_length[ii] > '9') {
1483           max_length = apr_psprintf(r->pool, "0");
1484           break;
1485         }
1486       }
1487
1488       if (strcmp(max_length, "0")) {
1489         char *vv = apr_psprintf(r->pool, " FORMAT=\"%d%s\"", atoi(max_length), fmt);
1490         W_V(vv);
1491       }
1492     }
1493     else {
1494       W_L(" FORMAT=\"");
1495       W_L("*");
1496       W_V(fmt);
1497       W_L("\"");
1498     }
1499   }
1500   else {
1501     if (max_length && *max_length) {
1502       if (chxj_chk_numeric(max_length) != 0) {
1503         max_length = apr_psprintf(r->pool, "0");
1504       }
1505       if (strcmp(max_length, "0")) {
1506         char *vv = apr_psprintf(r->pool, " FORMAT=\"%dm\"", atoi(max_length));
1507         W_V(vv);
1508       }
1509     }
1510   }
1511   /*--------------------------------------------------------------------------*/
1512   /* The figure is default for the password.                                  */
1513   /*--------------------------------------------------------------------------*/
1514   if (type && (istyle == NULL || *istyle == 0) && STRCASEEQ('p','P',"password", type) && ! xhtml->entryp->pc_flag) {
1515     if (max_length) {
1516       W_L(" FORMAT=\"");
1517       W_V(max_length);
1518       W_L("N\"");
1519     }
1520     else {
1521       W_L(" FORMAT=\"*N\"");
1522     }
1523   }
1524   if (checked) {
1525     W_L(" checked=\"checked\"");
1526   }
1527   W_L(" />");
1528
1529   return xhtml->out;
1530 }
1531
1532
1533 /**
1534  * It is a handler who processes the INPUT tag.
1535  *
1536  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1537  *                     destination is specified.
1538  * @param node   [i]   The INPUT tag node is specified.
1539  * @return The conversion result is returned.
1540  */
1541 static char *
1542 s_xhtml_1_0_end_input_tag(void *pdoc, Node *UNUSED(child))
1543 {
1544   xhtml_t *xhtml = GET_XHTML(pdoc);
1545
1546   return xhtml->out;
1547 }
1548
1549
1550 /**
1551  * It is a handler who processes the CENTER tag.
1552  *
1553  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1554  *                     destination is specified.
1555  * @param node   [i]   The CENTER tag node is specified.
1556  * @return The conversion result is returned.
1557  */
1558 static char *
1559 s_xhtml_1_0_start_center_tag(void *pdoc, Node *UNUSED(node))
1560 {
1561   xhtml_t *xhtml = GET_XHTML(pdoc);
1562   Doc     *doc   = xhtml->doc;
1563
1564   W_L("<center>");
1565   return xhtml->out;
1566 }
1567
1568
1569 /**
1570  * It is a handler who processes the CENTER tag.
1571  *
1572  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1573  *                     destination is specified.
1574  * @param node   [i]   The CENTER tag node is specified.
1575  * @return The conversion result is returned.
1576  */
1577 static char *
1578 s_xhtml_1_0_end_center_tag(void *pdoc, Node *UNUSED(child))
1579 {
1580   xhtml_t *xhtml = GET_XHTML(pdoc);
1581   Doc     *doc   = xhtml->doc;
1582
1583   W_L("</center>");
1584   return xhtml->out;
1585 }
1586
1587
1588 /**
1589  * It is a handler who processes the HR tag.
1590  *
1591  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1592  *                     destination is specified.
1593  * @param node   [i]   The HR tag node is specified.
1594  * @return The conversion result is returned.
1595  */
1596 static char *
1597 s_xhtml_1_0_start_hr_tag(void *pdoc, Node *node)
1598 {
1599   xhtml_t *xhtml = GET_XHTML(pdoc);
1600   Doc     *doc   = xhtml->doc;
1601   Attr    *attr;
1602
1603   W_L("<hr");
1604
1605   for (attr = qs_get_attr(doc,node);
1606        attr;
1607        attr = qs_get_next_attr(doc,attr)) {
1608     char *name = qs_get_attr_name(doc,attr);
1609     char *value = qs_get_attr_value(doc,attr);
1610     if (STRCASEEQ('a','A',"align", name)) {
1611       /*----------------------------------------------------------------------*/
1612       /* CHTML 1.0                                                            */
1613       /*----------------------------------------------------------------------*/
1614       if (value && (STRCASEEQ('l','L',"left",value) || STRCASEEQ('r','R',"right",value) || STRCASEEQ('c','C',"center",value))) {
1615         W_L(" align=\"");
1616         W_V(value);
1617         W_L("\"");
1618       }
1619     }
1620     else if (STRCASEEQ('s','S',"size", name)) {
1621       /*----------------------------------------------------------------------*/
1622       /* CHTML 1.0                                                            */
1623       /*----------------------------------------------------------------------*/
1624       if (value && *value) {
1625         W_L(" size=\"");
1626         W_V(value);
1627         W_L("\"");
1628       }
1629     }
1630     else if (STRCASEEQ('w','W',"width", name)) {
1631       /*----------------------------------------------------------------------*/
1632       /* CHTML 1.0                                                            */
1633       /*----------------------------------------------------------------------*/
1634       if (value && *value) {
1635         W_L(" width=\"");
1636         W_V(value);
1637         W_L("\"");
1638       }
1639     }
1640     else if (STRCASEEQ('n','N',"noshade", name)) {
1641       /*----------------------------------------------------------------------*/
1642       /* CHTML 1.0                                                            */
1643       /*----------------------------------------------------------------------*/
1644       /* ignore */
1645     }
1646     else if (STRCASEEQ('c','C',"color", name) && value && *value) {
1647       /*----------------------------------------------------------------------*/
1648       /* CHTML 4.0                                                            */
1649       /*----------------------------------------------------------------------*/
1650       W_L(" color=\"");
1651       W_V(value);
1652       W_L("\"");
1653     }
1654   }
1655   W_L(" />");
1656   return xhtml->out;
1657 }
1658
1659
1660 /**
1661  * It is a handler who processes the HR tag.
1662  *
1663  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1664  *                     destination is specified.
1665  * @param node   [i]   The HR tag node is specified.
1666  * @return The conversion result is returned.
1667  */
1668 static char *
1669 s_xhtml_1_0_end_hr_tag(void *pdoc, Node *UNUSED(child))
1670 {
1671   xhtml_t *xhtml = GET_XHTML(pdoc);
1672
1673   return xhtml->out;
1674 }
1675
1676
1677 /**
1678  * It is a handler who processes the PRE tag.
1679  *
1680  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1681  *                     destination is specified.
1682  * @param node   [i]   The PRE tag node is specified.
1683  * @return The conversion result is returned.
1684  */
1685 static char *
1686 s_xhtml_1_0_start_pre_tag(void* pdoc, Node* UNUSED(node))
1687 {
1688   xhtml_t *xhtml = GET_XHTML(pdoc);
1689   Doc     *doc   = xhtml->doc;
1690
1691   xhtml->pre_flag++;
1692   W_L("<pre>");
1693   return xhtml->out;
1694 }
1695
1696
1697 /**
1698  * It is a handler who processes the PRE tag.
1699  *
1700  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1701  *                     destination is specified.
1702  * @param node   [i]   The PRE tag node is specified.
1703  * @return The conversion result is returned.
1704  */
1705 static char *
1706 s_xhtml_1_0_end_pre_tag(void *pdoc, Node *UNUSED(child))
1707 {
1708   xhtml_t *xhtml = GET_XHTML(pdoc);
1709   Doc     *doc   = xhtml->doc;
1710
1711   W_L("</pre>");
1712   xhtml->pre_flag--;
1713
1714   return xhtml->out;
1715 }
1716
1717
1718 /**
1719  * It is a handler who processes the P tag.
1720  *
1721  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1722  *                     destination is specified.
1723  * @param node   [i]   The P tag node is specified.
1724  * @return The conversion result is returned.
1725  */
1726 static char *
1727 s_xhtml_1_0_start_p_tag(void *pdoc, Node *node)
1728 {
1729   xhtml_t *xhtml = GET_XHTML(pdoc);
1730   Doc     *doc   = xhtml->doc;
1731   Attr    *attr;
1732   char    *align = NULL;
1733
1734   W_L("<p");
1735   for (attr = qs_get_attr(doc,node);
1736        attr;
1737        attr = qs_get_next_attr(doc,attr)) {
1738     char *nm  = qs_get_attr_name(doc,attr);
1739     char *val = qs_get_attr_value(doc,attr);
1740     if (STRCASEEQ('a','A',"align", nm)) {
1741       /*----------------------------------------------------------------------*/
1742       /* CHTML 1.0 (W3C version 3.2)                                          */
1743       /*----------------------------------------------------------------------*/
1744       if (val && (STRCASEEQ('l','L',"left",val) || STRCASEEQ('r','R',"right",val) || STRCASEEQ('c','C',"center",val))) {
1745         align = apr_pstrdup(doc->buf.pool, val);
1746         break;
1747       }
1748     }
1749   }
1750   if (align) {
1751     W_L(" align=\"");
1752     W_V(align);
1753     W_L("\"");
1754   }
1755   W_L(">");
1756   return xhtml->out;
1757 }
1758
1759
1760 /**
1761  * It is a handler who processes the P tag.
1762  *
1763  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1764  *                     destination is specified.
1765  * @param node   [i]   The P tag node is specified.
1766  * @return The conversion result is returned.
1767  */
1768 static char *
1769 s_xhtml_1_0_end_p_tag(void *pdoc, Node *UNUSED(child))
1770 {
1771   xhtml_t *xhtml = GET_XHTML(pdoc);
1772   Doc     *doc   = xhtml->doc;
1773
1774   W_L("</p>");
1775   return xhtml->out;
1776 }
1777
1778
1779 /**
1780  * It is a handler who processes the UL tag.
1781  *
1782  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1783  *                     destination is specified.
1784  * @param node   [i]   The UL tag node is specified.
1785  * @return The conversion result is returned.
1786  */
1787 static char *
1788 s_xhtml_1_0_start_ul_tag(void *pdoc, Node *node)
1789 {
1790   xhtml_t *xhtml = GET_XHTML(pdoc);
1791   Doc     *doc   = xhtml->doc;
1792   Attr    *attr;
1793   W_L("<ul");
1794   /*--------------------------------------------------------------------------*/
1795   /* Get Attributes                                                           */
1796   /*--------------------------------------------------------------------------*/
1797   for (attr = qs_get_attr(doc,node);
1798        attr;
1799        attr = qs_get_next_attr(doc,attr)) {
1800     char *name   = qs_get_attr_name(doc,attr);
1801     char *value  = qs_get_attr_value(doc,attr);
1802     if (STRCASEEQ('t','T',"type",name)) {
1803       if (value && (STRCASEEQ('d','D',"disc",value) || STRCASEEQ('c','C',"circle",value) || STRCASEEQ('s','S',"square",value))) {
1804         W_L(" type=\"");
1805         W_V(value);
1806         W_L("\"");
1807       }
1808     }
1809   }
1810   W_L(">");
1811   return xhtml->out;
1812 }
1813
1814
1815 /**
1816  * It is a handler who processes the UL tag.
1817  *
1818  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1819  *                     destination is specified.
1820  * @param node   [i]   The UL tag node is specified.
1821  * @return The conversion result is returned.
1822  */
1823 static char *
1824 s_xhtml_1_0_end_ul_tag(void *pdoc, Node *UNUSED(child))
1825 {
1826   xhtml_t *xhtml = GET_XHTML(pdoc);
1827   Doc     *doc   = xhtml->doc;
1828
1829   W_L("</ul>");
1830   return xhtml->out;
1831 }
1832
1833
1834 /**
1835  * It is a handler who processes the H1 tag.
1836  *
1837  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1838  *                     destination is specified.
1839  * @param node   [i]   The H1 tag node is specified.
1840  * @return The conversion result is returned.
1841  */
1842 static char *
1843 s_xhtml_1_0_start_h1_tag(void *pdoc, Node *node)
1844 {
1845   xhtml_t *xhtml = GET_XHTML(pdoc);
1846   Doc     *doc   = xhtml->doc;
1847   Attr    *attr;
1848
1849   W_L("<h1");
1850   for (attr = qs_get_attr(doc,node);
1851        attr;
1852        attr = qs_get_next_attr(doc,attr)) {
1853     char* name;
1854     char* value;
1855     name  = qs_get_attr_name(doc,attr);
1856     value = qs_get_attr_value(doc,attr);
1857     if (STRCASEEQ('a','A',"align", name)) {
1858       if (value) {
1859         if (STRCASEEQ('l','L',"left",value)) {
1860           W_L(" style=\"");
1861           W_L("text-align:left");
1862           W_L("\"");
1863         }
1864         else if (STRCASEEQ('r','R',"right",value)) {
1865           W_L(" style=\"");
1866           W_L("text-align:right");
1867           W_L("\"");
1868         }
1869         else if (STRCASEEQ('c','C',"center",value)) {
1870           W_L(" style=\"");
1871           W_L("text-align:center");
1872           W_L("\"");
1873         }
1874         break;
1875       }
1876     }
1877   }
1878   W_L(">");
1879   return xhtml->out;
1880 }
1881
1882
1883 /**
1884  * It is a handler who processes the H1 tag.
1885  *
1886  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1887  *                     destination is specified.
1888  * @param node   [i]   The H1 tag node is specified.
1889  * @return The conversion result is returned.
1890  */
1891 static char *
1892 s_xhtml_1_0_end_h1_tag(void *pdoc, Node *UNUSED(child))
1893 {
1894   xhtml_t *xhtml = GET_XHTML(pdoc);
1895   Doc     *doc   = xhtml->doc;
1896
1897   W_L("</h1>");
1898   return xhtml->out;
1899 }
1900
1901
1902 /**
1903  * It is a handler who processes the H2 tag.
1904  *
1905  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1906  *                     destination is specified.
1907  * @param node   [i]   The H2 tag node is specified.
1908  * @return The conversion result is returned.
1909  */
1910 static char *
1911 s_xhtml_1_0_start_h2_tag(void *pdoc, Node *node)
1912 {
1913   xhtml_t *xhtml = GET_XHTML(pdoc);
1914   Doc     *doc = xhtml->doc;
1915   Attr    *attr;
1916
1917   W_L("<h2");
1918   for (attr = qs_get_attr(doc,node);
1919        attr;
1920        attr = qs_get_next_attr(doc,attr)) {
1921     char* name;
1922     char* value;
1923     name  = qs_get_attr_name(doc,attr);
1924     value = qs_get_attr_value(doc,attr);
1925     if (STRCASEEQ('a','A',"align", name)) {
1926       if (value) {
1927         if (STRCASEEQ('l','L',"left",value)) {
1928           W_L(" style=\"");
1929           W_L("text-align:left");
1930           W_L("\"");
1931         }
1932         else if (STRCASEEQ('r','R',"right",value)) {
1933           W_L(" style=\"");
1934           W_L("text-align:right");
1935           W_L("\"");
1936         }
1937         else if (STRCASEEQ('c','C',"center",value)) {
1938           W_L(" style=\"");
1939           W_L("text-align:center");
1940           W_L("\"");
1941         }
1942         break;
1943       }
1944     }
1945   }
1946   W_L(">");
1947   return xhtml->out;
1948 }
1949
1950
1951 /**
1952  * It is a handler who processes the H2 tag.
1953  *
1954  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1955  *                     destination is specified.
1956  * @param node   [i]   The H2 tag node is specified.
1957  * @return The conversion result is returned.
1958  */
1959 static char *
1960 s_xhtml_1_0_end_h2_tag(void *pdoc, Node *UNUSED(child))
1961 {
1962   xhtml_t *xhtml = GET_XHTML(pdoc);
1963   Doc     *doc   = xhtml->doc;
1964
1965   W_L("</h2>");
1966   return xhtml->out;
1967 }
1968
1969
1970 /**
1971  * It is a handler who processes the H3 tag.
1972  *
1973  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1974  *                     destination is specified.
1975  * @param node   [i]   The H3 tag node is specified.
1976  * @return The conversion result is returned.
1977  */
1978 static char *
1979 s_xhtml_1_0_start_h3_tag(void *pdoc, Node *node)
1980 {
1981   xhtml_t *xhtml = GET_XHTML(pdoc);
1982   Doc     *doc   = xhtml->doc;
1983   Attr    *attr;
1984
1985   W_L("<h3");
1986   for (attr = qs_get_attr(doc,node);
1987        attr;
1988        attr = qs_get_next_attr(doc,attr)) {
1989     char* name;
1990     char* value;
1991     name  = qs_get_attr_name(doc,attr);
1992     value = qs_get_attr_value(doc,attr);
1993     if (STRCASEEQ('a','A',"align", name)) {
1994       if (value) {
1995         if (STRCASEEQ('l','L',"left",value)) {
1996           W_L(" style=\"");
1997           W_L("text-align:left");
1998           W_L("\"");
1999         }
2000         else if (STRCASEEQ('r','R',"right",value)) {
2001           W_L(" style=\"");
2002           W_L("text-align:right");
2003           W_L("\"");
2004         }
2005         else if (STRCASEEQ('c','C',"center",value)) {
2006           W_L(" style=\"");
2007           W_L("text-align:center");
2008           W_L("\"");
2009         }
2010         break;
2011       }
2012     }
2013   }
2014   W_L(">");
2015   return xhtml->out;
2016 }
2017
2018
2019 /**
2020  * It is a handler who processes the H3 tag.
2021  *
2022  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2023  *                     destination is specified.
2024  * @param node   [i]   The H3 tag node is specified.
2025  * @return The conversion result is returned.
2026  */
2027 static char *
2028 s_xhtml_1_0_end_h3_tag(void *pdoc, Node *UNUSED(child))
2029 {
2030   xhtml_t *xhtml = GET_XHTML(pdoc);
2031   Doc     *doc   = xhtml->doc;
2032
2033   W_L("</h3>");
2034   return xhtml->out;
2035 }
2036
2037
2038 /**
2039  * It is a handler who processes the H4 tag.
2040  *
2041  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2042  *                     destination is specified.
2043  * @param node   [i]   The H4 tag node is specified.
2044  * @return The conversion result is returned.
2045  */
2046 static char *
2047 s_xhtml_1_0_start_h4_tag(void *pdoc, Node *node)
2048 {
2049   xhtml_t *xhtml = GET_XHTML(pdoc);
2050   Doc     *doc   = xhtml->doc;
2051   Attr    *attr;
2052
2053   W_L("<h4");
2054   for (attr = qs_get_attr(doc,node);
2055        attr;
2056        attr = qs_get_next_attr(doc,attr)) {
2057     char* name;
2058     char* value;
2059     name  = qs_get_attr_name(doc,attr);
2060     value = qs_get_attr_value(doc,attr);
2061     if (STRCASEEQ('a','A',"align", name)) {
2062       if (value) {
2063         if (STRCASEEQ('l','L',"left",value)) {
2064           W_L(" style=\"");
2065           W_L("text-align:left");
2066           W_L("\"");
2067         }
2068         else if (STRCASEEQ('r','R',"right",value)) {
2069           W_L(" style=\"");
2070           W_L("text-align:right");
2071           W_L("\"");
2072         }
2073         else if (STRCASEEQ('c','C',"center",value)) {
2074           W_L(" style=\"");
2075           W_L("text-align:center");
2076           W_L("\"");
2077         }
2078         break;
2079       }
2080     }
2081   }
2082   W_L(">");
2083   return xhtml->out;
2084 }
2085
2086
2087 /**
2088  * It is a handler who processes the H4 tag.
2089  *
2090  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2091  *                     destination is specified.
2092  * @param node   [i]   The H4 tag node is specified.
2093  * @return The conversion result is returned.
2094  */
2095 static char *
2096 s_xhtml_1_0_end_h4_tag(void *pdoc, Node *UNUSED(child))
2097 {
2098   xhtml_t *xhtml = GET_XHTML(pdoc);
2099   Doc     *doc   = xhtml->doc;
2100
2101   W_L("</h4>");
2102   return xhtml->out;
2103 }
2104
2105
2106 /**
2107  * It is a handler who processes the H5 tag.
2108  *
2109  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2110  *                     destination is specified.
2111  * @param node   [i]   The H5 tag node is specified.
2112  * @return The conversion result is returned.
2113  */
2114 static char *
2115 s_xhtml_1_0_start_h5_tag(void *pdoc, Node *node)
2116 {
2117   xhtml_t *xhtml = GET_XHTML(pdoc);
2118   Doc     *doc   = xhtml->doc;
2119   Attr    *attr;
2120
2121   W_L("<h5");
2122   for (attr = qs_get_attr(doc,node);
2123        attr;
2124        attr = qs_get_next_attr(doc,attr)) {
2125     char* name;
2126     char* value;
2127     name  = qs_get_attr_name(doc,attr);
2128     value = qs_get_attr_value(doc,attr);
2129     if (STRCASEEQ('a','A',"align", name)) {
2130       if (value) {
2131         if (STRCASEEQ('l','L',"left",value)) {
2132           W_L(" style=\"");
2133           W_L("text-align:left");
2134           W_L("\"");
2135         }
2136         else if (STRCASEEQ('r','R',"right",value)) {
2137           W_L(" style=\"");
2138           W_L("text-align:right");
2139           W_L("\"");
2140         }
2141         else if (STRCASEEQ('c','C',"center",value)) {
2142           W_L(" style=\"");
2143           W_L("text-align:center");
2144           W_L("\"");
2145         }
2146         break;
2147       }
2148     }
2149   }
2150   W_L(">");
2151   return xhtml->out;
2152 }
2153
2154
2155 /**
2156  * It is a handler who processes the H5 tag.
2157  *
2158  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2159  *                     destination is specified.
2160  * @param node   [i]   The H5 tag node is specified.
2161  * @return The conversion result is returned.
2162  */
2163 static char *
2164 s_xhtml_1_0_end_h5_tag(void *pdoc, Node *UNUSED(child))
2165 {
2166   xhtml_t *xhtml = GET_XHTML(pdoc);
2167   Doc     *doc   = xhtml->doc;
2168
2169   W_L("</h5>");
2170   return xhtml->out;
2171 }
2172
2173
2174 /**
2175  * It is a handler who processes the H6 tag.
2176  *
2177  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2178  *                     destination is specified.
2179  * @param node   [i]   The H6 tag node is specified.
2180  * @return The conversion result is returned.
2181  */
2182 static char *
2183 s_xhtml_1_0_start_h6_tag(void *pdoc, Node *node)
2184 {
2185   xhtml_t *xhtml = GET_XHTML(pdoc);
2186   Doc     *doc   = xhtml->doc;
2187   Attr    *attr;
2188
2189   W_L("<h6");
2190   for (attr = qs_get_attr(doc,node);
2191        attr;
2192        attr = qs_get_next_attr(doc,attr)) {
2193     char* name;
2194     char* value;
2195     name  = qs_get_attr_name(doc,attr);
2196     value = qs_get_attr_value(doc,attr);
2197     if (STRCASEEQ('a','A',"align", name)) {
2198       if (value) {
2199         if (STRCASEEQ('l','L',"left",value)) {
2200           W_L(" style=\"");
2201           W_L("text-align:left");
2202           W_L("\"");
2203         }
2204         else if (STRCASEEQ('r','R',"right",value)) {
2205           W_L(" style=\"");
2206           W_L("text-align:right");
2207           W_L("\"");
2208         }
2209         else if (STRCASEEQ('c','C',"center",value)) {
2210           W_L(" style=\"");
2211           W_L("text-align:center");
2212           W_L("\"");
2213         }
2214         break;
2215       }
2216     }
2217   }
2218   W_L(">");
2219   return xhtml->out;
2220 }
2221
2222
2223 /**
2224  * It is a handler who processes the H6 tag.
2225  *
2226  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2227  *                     destination is specified.
2228  * @param node   [i]   The H6 tag node is specified.
2229  * @return The conversion result is returned.
2230  */
2231 static char *
2232 s_xhtml_1_0_end_h6_tag(void *pdoc, Node *UNUSED(child))
2233 {
2234   xhtml_t *xhtml = GET_XHTML(pdoc);
2235   Doc     *doc   = xhtml->doc;
2236
2237   W_L("</h6>");
2238   return xhtml->out;
2239 }
2240
2241
2242 /**
2243  * It is a handler who processes the OL tag.
2244  *
2245  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2246  *                     destination is specified.
2247  * @param node   [i]   The OL tag node is specified.
2248  * @return The conversion result is returned.
2249  */
2250 static char *
2251 s_xhtml_1_0_start_ol_tag(void *pdoc, Node *node)
2252 {
2253   xhtml_t *xhtml = GET_XHTML(pdoc);
2254   Doc     *doc   = xhtml->doc;
2255   Attr    *attr;
2256
2257   W_L("<ol");
2258   /*--------------------------------------------------------------------------*/
2259   /* Get Attributes                                                           */
2260   /*--------------------------------------------------------------------------*/
2261   for (attr = qs_get_attr(doc,node);
2262        attr;
2263        attr = qs_get_next_attr(doc,attr)) {
2264     char *name = qs_get_attr_name(doc,attr);
2265     char *value = qs_get_attr_value(doc,attr);
2266     if (STRCASEEQ('t','T',"type",name) && value && (*value == '1' || *value == 'a' || *value == 'A')) {
2267       W_L(" type=\"");
2268       W_V(value);
2269       W_L("\"");
2270     }
2271     else if (STRCASEEQ('s','S',"start",name) && value && *value) {
2272       W_L(" start=\"");
2273       W_V(value);
2274       W_L("\"");
2275     }
2276   }
2277   W_L(">");
2278   return xhtml->out;
2279 }
2280
2281
2282 /**
2283  * It is a handler who processes the OL tag.
2284  *
2285  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2286  *                     destination is specified.
2287  * @param node   [i]   The OL tag node is specified.
2288  * @return The conversion result is returned.
2289  */
2290 static char *
2291 s_xhtml_1_0_end_ol_tag(void *pdoc, Node *UNUSED(child))
2292 {
2293   xhtml_t *xhtml = GET_XHTML(pdoc);
2294   Doc     *doc   = xhtml->doc;
2295
2296   W_L("</ol>");
2297   return xhtml->out;
2298 }
2299
2300
2301 /**
2302  * It is a handler who processes the LI tag.
2303  *
2304  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2305  *                     destination is specified.
2306  * @param node   [i]   The LI tag node is specified.
2307  * @return The conversion result is returned.
2308  */
2309 static char *
2310 s_xhtml_1_0_start_li_tag(void *pdoc, Node *node)
2311 {
2312   xhtml_t *xhtml = GET_XHTML(pdoc);
2313   Doc     *doc   = xhtml->doc;
2314   Attr    *attr;
2315
2316   W_L("<li");
2317   /*--------------------------------------------------------------------------*/
2318   /* Get Attributes                                                           */
2319   /*--------------------------------------------------------------------------*/
2320   for (attr = qs_get_attr(doc,node);
2321        attr;
2322        attr = qs_get_next_attr(doc,attr)) {
2323     char *name  = qs_get_attr_name(doc,attr);
2324     char *value = qs_get_attr_value(doc,attr);
2325     if (STRCASEEQ('t','T',"type",name)) {
2326       if (value && (*value == '1' || *value == 'a' || *value == 'A' || STRCASEEQ('d','D',"disc",value) || STRCASEEQ('c','C',"circle",value) || STRCASEEQ('s','S',"square",value))) {
2327         W_L(" type=\"");
2328         W_V(value);
2329         W_L("\"");
2330       }
2331     }
2332     else if (STRCASEEQ('v','V',"value", name) && value && *value) {
2333       W_L(" value=\"");
2334       W_V(value);
2335       W_L("\"");
2336     }
2337   }
2338   W_L(">");
2339   return xhtml->out;
2340 }
2341
2342
2343 /**
2344  ** It is a handler who processes the LI tag.
2345  *
2346  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2347  *                     destination is specified.
2348  * @param node   [i]   The LI tag node is specified.
2349  * @return The conversion result is returned.
2350  */
2351 static char *
2352 s_xhtml_1_0_end_li_tag(void *pdoc, Node *UNUSED(child))
2353 {
2354   xhtml_t *xhtml = GET_XHTML(pdoc);
2355   Doc     *doc   = xhtml->doc;
2356
2357   W_L("</li>");
2358   return xhtml->out;
2359 }
2360
2361 /**
2362  * It is a handler who processes the IMG tag.
2363  *
2364  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2365  *                     destination is specified.
2366  * @param node   [i]   The IMG tag node is specified.
2367  * @return The conversion result is returned.
2368  */
2369 static char *
2370 s_xhtml_1_0_start_img_tag(void *pdoc, Node *node)
2371 {
2372   xhtml_t       *xhtml = GET_XHTML(pdoc);
2373   Doc           *doc   = xhtml->doc;
2374   request_rec   *r     = doc->r;
2375   Attr          *attr;
2376
2377 #ifndef IMG_NOT_CONVERT_FILENAME
2378   device_table  *spec = xhtml->spec;
2379 #endif
2380
2381   W_L("<img");
2382   /*--------------------------------------------------------------------------*/
2383   /* Get Attributes                                                           */
2384   /*--------------------------------------------------------------------------*/
2385   for (attr = qs_get_attr(doc,node);
2386        attr;
2387        attr = qs_get_next_attr(doc,attr)) {
2388     char *name  = qs_get_attr_name(doc,attr);
2389     char *value = qs_get_attr_value(doc,attr);
2390
2391     if (STRCASEEQ('s','S',"src",name)) {
2392       value = chxj_encoding_parameter(r, value);
2393       value = chxj_add_cookie_parameter(r, value, xhtml->cookie);
2394       if (value) {
2395         value = apr_psprintf(r->pool,
2396                              "%s%c%s=true",
2397                              value,
2398                              (strchr(value, '?')) ? '&' : '?',
2399                              CHXJ_COOKIE_NOUPDATE_PARAM);
2400       }
2401 #ifdef IMG_NOT_CONVERT_FILENAME
2402
2403       W_L(" src=\"");
2404       W_V(value);
2405       W_L("\"");
2406
2407 #else
2408
2409       W_L(" src=\"");
2410       {
2411         char *vv = chxj_img_conv(r,spec,value);
2412         W_V(vv);
2413       }
2414       W_L("\"");
2415
2416 #endif
2417     }
2418     else
2419     if (STRCASEEQ('a','A',"align",name)) {
2420       if (value) {
2421         if (STRCASEEQ('t','T',"top",   value) ||
2422             STRCASEEQ('m','M',"middle",value) ||
2423             STRCASEEQ('b','B',"bottom",value) ||
2424             STRCASEEQ('l','L',"left",  value) ||
2425             STRCASEEQ('r','R',"right", value)) {
2426           W_L(" align=\"");
2427           W_V(value);
2428           W_L("\"");
2429         }
2430         else if (STRCASEEQ('c','C',"center",  value)) {
2431           W_L(" align=\"");
2432           W_L("middle");
2433           W_L("\"");
2434         }
2435       }
2436     }
2437     else if (STRCASEEQ('a','A',"alt",name) && value && *value) {
2438       W_L(" alt=\"");
2439       W_V(value);
2440       W_L("\"");
2441     }
2442     else if (STRCASEEQ('w','W',"width",name) && value && *value) {
2443       W_L(" width=\"");
2444       W_V(value);
2445       W_L("\"");
2446     }
2447     else if (STRCASEEQ('h','H',"height",name) && value && *value) {
2448       W_L(" height=\"");
2449       W_V(value);
2450       W_L("\"");
2451     }
2452     else if (STRCASEEQ('h','H',"hspace",name) && value && *value) {
2453       W_L(" hspace=\"");
2454       W_V(value);
2455       W_L("\"");
2456     }
2457     else if (STRCASEEQ('v','V',"vspace",name) && value && *value) {
2458       W_L(" vspace=\"");
2459       W_V(value);
2460       W_L("\"");
2461     }
2462   }
2463   W_L(" />");
2464   return xhtml->out;
2465 }
2466
2467
2468 /**
2469  * It is a handler who processes the IMG tag.
2470  *
2471  * @param xhtml  [i/o] The pointer to the XHTML structure at the output
2472  *                     destination is specified.
2473  * @param node   [i]   The IMG tag node is specified.
2474  * @return The conversion result is returned.
2475  */
2476 static char *
2477 s_xhtml_1_0_end_img_tag(void *pdoc, Node *UNUSED(child))
2478 {
2479   xhtml_t *xhtml = GET_XHTML(pdoc);
2480
2481   return xhtml->out;
2482 }
2483
2484
2485 /**
2486  * It is a handler who processes the SELECT tag.
2487  *
2488  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2489  *                     destination is specified.
2490  * @param node   [i]   The SELECT tag node is specified.
2491  * @return The conversion result is returned.
2492  */
2493 static char *
2494 s_xhtml_1_0_start_select_tag(void *pdoc, Node *child)
2495 {
2496   xhtml_t *xhtml    = GET_XHTML(pdoc);
2497   Doc     *doc      = xhtml->doc;
2498   char    *size     = NULL;
2499   char    *name     = NULL;
2500   char    *multiple = NULL;
2501   Attr    *attr;
2502
2503
2504   W_L("<select");
2505   for (attr = qs_get_attr(doc,child);
2506        attr;
2507        attr = qs_get_next_attr(doc,attr)) {
2508     char *nm  = qs_get_attr_name(doc,attr);
2509     char *val = qs_get_attr_value(doc,attr);
2510     if (STRCASEEQ('s','S',"size",nm)) {
2511       /*----------------------------------------------------------------------*/
2512       /* CHTML 1.0 version 2.0                                                */
2513       /*----------------------------------------------------------------------*/
2514       size = apr_pstrdup(doc->buf.pool, val);
2515     }
2516     else if (STRCASEEQ('n','N',"name",nm)) {
2517       /*----------------------------------------------------------------------*/
2518       /* CHTML 1.0 version 2.0                                                */
2519       /*----------------------------------------------------------------------*/
2520       name = apr_pstrdup(doc->buf.pool, val);
2521     }
2522     else if (STRCASEEQ('m','M',"multiple",nm)) {
2523       /*----------------------------------------------------------------------*/
2524       /* CHTML 1.0 version 2.0                                                */
2525       /*----------------------------------------------------------------------*/
2526       multiple = apr_pstrdup(doc->buf.pool, val);
2527     }
2528   }
2529   if (size && *size) {
2530     W_L(" size=\"");
2531     W_V(size);
2532     W_L("\"");
2533   }
2534   if (name && *name) {
2535     W_L(" name=\"");
2536     W_V(name);
2537     W_L("\"");
2538   }
2539   if (multiple) {
2540     /* "true" is *NOT* W3C. it is specification of WAP2.0 for EZWEB */
2541     W_L(" multiple=\"true\"");
2542   }
2543   W_L(">");
2544   return xhtml->out;
2545 }
2546
2547
2548 /**
2549  * It is a handler who processes the SELECT tag.
2550  *
2551  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2552  *                     destination is specified.
2553  * @param node   [i]   The SELECT tag node is specified.
2554  * @return The conversion result is returned.
2555  */
2556 static char *
2557 s_xhtml_1_0_end_select_tag(void *pdoc, Node *UNUSED(child))
2558 {
2559   xhtml_t *xhtml = GET_XHTML(pdoc);
2560   Doc     *doc   = xhtml->doc;
2561
2562   W_L("</select>");
2563   return xhtml->out;
2564 }
2565
2566
2567 /**
2568  * It is a handler who processes the OPTION tag.
2569  *
2570  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2571  *                     destination is specified.
2572  * @param node   [i]   The OPTION tag node is specified.
2573  * @return The conversion result is returned.
2574  */
2575 static char *
2576 s_xhtml_1_0_start_option_tag(void *pdoc, Node *child)
2577 {
2578   xhtml_t *xhtml = GET_XHTML(pdoc);
2579   Doc     *doc   = xhtml->doc;
2580   Attr    *attr;
2581
2582   char *selected   = NULL;
2583   char *value      = NULL;
2584
2585   W_L("<option");
2586   for (attr = qs_get_attr(doc,child);
2587        attr;
2588        attr = qs_get_next_attr(doc,attr)) {
2589     char *nm  = qs_get_attr_name(doc,attr);
2590     char *val = qs_get_attr_value(doc,attr);
2591     if (STRCASEEQ('s','S',"selected",nm)) {
2592       /* CHTML version 2.0 */
2593       selected = apr_pstrdup(doc->buf.pool, val);
2594     }
2595     else if (STRCASEEQ('v','V',"value",nm)) {
2596       /* CHTML version 2.0 */
2597       value = apr_pstrdup(doc->buf.pool, val);
2598     }
2599   }
2600   if (value && *value) {
2601     W_L(" value=\"");
2602     W_V(value);
2603     W_L("\"");
2604   }
2605   if (selected) {
2606     W_L(" selected=\"selected\"");
2607   }
2608   W_L(">");
2609   return xhtml->out;
2610 }
2611
2612
2613 /**
2614  * It is a handler who processes the OPTION tag.
2615  *
2616  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2617  *                     destination is specified.
2618  * @param node   [i]   The OPTION tag node is specified.
2619  * @return The conversion result is returned.
2620  */
2621 static char *
2622 s_xhtml_1_0_end_option_tag(void *pdoc, Node *UNUSED(child))
2623 {
2624   xhtml_t *xhtml = GET_XHTML(pdoc);
2625   Doc     *doc   = xhtml->doc;
2626
2627   W_L("</option>");
2628   return xhtml->out;
2629 }
2630
2631
2632 /**
2633  * It is a handler who processes the DIV tag.
2634  *
2635  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2636  *                     destination is specified.
2637  * @param node   [i]   The DIV tag node is specified.
2638  * @return The conversion result is returned.
2639  */
2640 static char *
2641 s_xhtml_1_0_start_div_tag(void *pdoc, Node *child)
2642 {
2643   xhtml_t *xhtml = GET_XHTML(pdoc);
2644   Doc     *doc   = xhtml->doc;
2645   Attr    *attr;
2646   char    *align   = NULL;
2647
2648   W_L("<div");
2649   for (attr = qs_get_attr(doc,child);
2650        attr;
2651        attr = qs_get_next_attr(doc,attr)) {
2652     char *nm  = qs_get_attr_name(doc,attr);
2653     char *val = qs_get_attr_value(doc,attr);
2654     if (STRCASEEQ('a','A',"align",nm)) {
2655       /*=====================================================================*/
2656       /* CHTML version 3.2                                                   */
2657       /*=====================================================================*/
2658       if (val && (STRCASEEQ('l','L',"left",val) || STRCASEEQ('r','R',"right",val) || STRCASEEQ('c','C',"center",val))) {
2659         align = apr_pstrdup(doc->buf.pool, val);
2660       }
2661     }
2662   }
2663   if (align) {
2664     W_L(" align=\"");
2665     W_V(align);
2666     W_L("\"");
2667   }
2668   W_L(">");
2669   return xhtml->out;
2670 }
2671
2672
2673 /**
2674  * It is a handler who processes the DIV tag.
2675  *
2676  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2677  *                     destination is specified.
2678  * @param node   [i]   The DIV tag node is specified.
2679  * @return The conversion result is returned.
2680  */
2681 static char *
2682 s_xhtml_1_0_end_div_tag(void *pdoc, Node *UNUSED(child))
2683 {
2684   xhtml_t *xhtml = GET_XHTML(pdoc);
2685   Doc     *doc   = xhtml->doc;
2686   W_L("</div>");
2687   return xhtml->out;
2688 }
2689
2690
2691 /**
2692  * It is a handler who processes the B tag.
2693  *
2694  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2695  *                     destination is specified.
2696  * @param node   [i]   The B tag node is specified.
2697  * @return The conversion result is returned.
2698  */
2699 static char *
2700 s_xhtml_1_0_start_b_tag(void *pdoc, Node *UNUSED(child))
2701 {
2702   xhtml_t *xhtml = GET_XHTML(pdoc);
2703   Doc     *doc   = xhtml->doc;
2704
2705   W_L("<div style=\"font-weight:bold\">");
2706   return xhtml->out;
2707 }
2708
2709
2710 /**
2711  * It is a handler who processes the B tag.
2712  *
2713  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2714  *                     destination is specified.
2715  * @param node   [i]   The B tag node is specified.
2716  * @return The conversion result is returned.
2717  */
2718 static char *
2719 s_xhtml_1_0_end_b_tag(void *pdoc, Node *UNUSED(child))
2720 {
2721   xhtml_t *xhtml = GET_XHTML(pdoc);
2722   Doc     *doc   = xhtml->doc;
2723
2724   W_L("</div>");
2725   return xhtml->out;
2726 }
2727
2728
2729 /**
2730  * It is a handler who processes the CHXJ:IF tag.
2731  *
2732  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2733  *                     destination is specified.
2734  * @param node   [i]   The CHXJ:IF tag node is specified.
2735  */
2736 static char *
2737 s_xhtml_1_0_chxjif_tag(void *pdoc, Node *node)
2738 {
2739   xhtml_t      *xhtml = GET_XHTML(pdoc);
2740   Doc          *doc   = xhtml->doc;
2741   Node         *child;
2742
2743   for (child = qs_get_child_node(doc, node);
2744        child;
2745        child = qs_get_next_node(doc, child)) {
2746     W_V(child->otext);
2747     s_xhtml_1_0_chxjif_tag(xhtml, child);
2748   }
2749
2750   return NULL;
2751 }
2752
2753
2754 /**
2755  * It is a handler who processes the TEXTARE tag.
2756  *
2757  * @param pdoc  [i/o] The pointer to the CHTML structure at the output
2758  *                     destination is specified.
2759  * @param node   [i]   The TEXTAREA tag node is specified.
2760  * @return The conversion result is returned.
2761  */
2762 static char *
2763 s_xhtml_1_0_start_textarea_tag(void *pdoc, Node *node)
2764 {
2765   xhtml_t *xhtml = GET_XHTML(pdoc);
2766   Doc     *doc   = xhtml->doc;
2767   Attr    *attr;
2768
2769   xhtml->textarea_flag++;
2770   W_L("<textarea");
2771   for (attr = qs_get_attr(doc,node);
2772        attr;
2773        attr = qs_get_next_attr(doc,attr)) {
2774     char *name  = qs_get_attr_name(doc,attr);
2775     char *value = qs_get_attr_value(doc,attr);
2776     if (STRCASEEQ('n','N',"name",name) && value && *value) {
2777       W_L(" name=\"");
2778       W_V(value);
2779       W_L("\"");
2780     }
2781     else if (STRCASEEQ('r','R',"rows",name) && value && *value) {
2782       W_L(" rows=\"");
2783       W_V(value);
2784       W_L("\"");
2785     }
2786     else if (STRCASEEQ('c','C',"cols",name) && value && *value) {
2787       W_L(" cols=\"");
2788       W_V(value);
2789       W_L("\"");
2790     }
2791     else if (STRCASEEQ('i','I',"istyle", name) && value && (*value == '1' || *value == '2' || *value == '3' || *value == '4')) {
2792       char *fmt = qs_conv_istyle_to_format(doc->r,value);
2793       W_L(" FORMAT=\"*");
2794       W_V(fmt);
2795       W_L("\"");
2796     }
2797     else if (STRCASEEQ('a','A',"accesskey",name) && value && *value != 0) {
2798       W_L(" accesskey=\"");
2799       W_V(value);
2800       W_L("\"");
2801     }
2802   }
2803   W_L(">");
2804   return xhtml->out;
2805 }
2806
2807
2808 /**
2809  * It is a handler who processes the TEXTAREA tag.
2810  *
2811  * @param pdoc  [i/o] The pointer to the CHTML structure at the output
2812  *                     destination is specified.
2813  * @param node   [i]   The TEXTAREA tag node is specified.
2814  * @return The conversion result is returned.
2815  */
2816 static char *
2817 s_xhtml_1_0_end_textarea_tag(void *pdoc, Node *UNUSED(child))
2818 {
2819   xhtml_t *xhtml = GET_XHTML(pdoc);
2820   Doc     *doc   = xhtml->doc;
2821
2822   W_L("</textarea>");
2823   xhtml->textarea_flag--;
2824
2825   return xhtml->out;
2826 }
2827
2828 static char *
2829 s_xhtml_1_0_text_tag(void *pdoc, Node *child)
2830 {
2831   xhtml_t     *xhtml   = GET_XHTML(pdoc);
2832   Doc         *doc     = xhtml->doc;
2833   request_rec *r       = doc->r;
2834   char        *textval;
2835   char        *tmp;
2836   char        *tdst;
2837   char        one_byte[2];
2838   int         ii;
2839   int         tdst_len;
2840
2841   textval = qs_get_node_value(doc,child);
2842   if (strlen(textval) == 0) {
2843     return xhtml->out;
2844   }
2845
2846   tmp = apr_palloc(r->pool, qs_get_node_size(doc,child)+1);
2847   memset(tmp, 0, qs_get_node_size(doc,child)+1);
2848
2849   tdst     = qs_alloc_zero_byte_string(doc->buf.pool);
2850   memset(one_byte, 0, sizeof(one_byte));
2851   tdst_len = 0;
2852
2853   for (ii=0; ii<qs_get_node_size(doc,child); ii++) {
2854     char *out;
2855     int rtn = s_xhtml_search_emoji(xhtml, &textval[ii], &out);
2856     if (rtn != 0) {
2857       DBG(r,"[%s][%d]", out, rtn);
2858       tdst = qs_out_apr_pstrcat(r, tdst, out, &tdst_len);
2859       ii+=(rtn - 1);
2860       continue;
2861     }
2862     if (is_sjis_kanji(textval[ii])) {
2863       one_byte[0] = textval[ii+0];
2864       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2865       one_byte[0] = textval[ii+1];
2866       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2867       ii++;
2868     }
2869     else if (xhtml->pre_flag) {
2870       one_byte[0] = textval[ii+0];
2871       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2872     }
2873     else if (xhtml->textarea_flag) {
2874       one_byte[0] = textval[ii+0];
2875       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2876     }
2877     else if (textval[ii] != '\r' && textval[ii] != '\n') {
2878       one_byte[0] = textval[ii+0];
2879       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2880     }
2881   }
2882   W_V(tdst);
2883   return xhtml->out;
2884 }
2885
2886
2887 /**
2888  * It is a handler who processes the BLOCKQUOTE tag.
2889  *
2890  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2891  *                     destination is specified.
2892  * @param node   [i]   The BLOCKQUOTE tag node is specified.
2893  * @return The conversion result is returned.
2894  */
2895 static char *
2896 s_xhtml_1_0_start_blockquote_tag(void *pdoc, Node *UNUSED(child))
2897 {
2898   xhtml_t *xhtml = GET_XHTML(pdoc);
2899   Doc     *doc   = xhtml->doc;
2900   W_L("<blockquote>");
2901   return xhtml->out;
2902 }
2903
2904
2905 /**
2906  * It is a handler who processes the BLOCKQUOTE tag.
2907  *
2908  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2909  *                     destination is specified.
2910  * @param node   [i]   The BLOCKQUOTE tag node is specified.
2911  * @return The conversion result is returned.
2912  */
2913 static char *
2914 s_xhtml_1_0_end_blockquote_tag(void *pdoc, Node *UNUSED(child))
2915 {
2916   xhtml_t *xhtml = GET_XHTML(pdoc);
2917   Doc     *doc   = xhtml->doc;
2918   W_L("</blockquote>");
2919   return xhtml->out;
2920 }
2921
2922
2923 /**
2924  * It is a handler who processes the DIR tag.
2925  *
2926  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2927  *                     destination is specified.
2928  * @param node   [i]   The DIR tag node is specified.
2929  * @return The conversion result is returned.
2930  */
2931 static char *
2932 s_xhtml_1_0_start_dir_tag(void *pdoc, Node *node)
2933 {
2934   xhtml_t *xhtml = GET_XHTML(pdoc);
2935   Doc     *doc = xhtml->doc;
2936   Attr      *attr;
2937   W_L("<dir");
2938   for (attr = qs_get_attr(doc,node);
2939        attr;
2940        attr = qs_get_next_attr(doc,attr)) {
2941     char *name   = qs_get_attr_name(doc,attr);
2942     char *value  = qs_get_attr_value(doc,attr);
2943     if (STRCASEEQ('t','T',"type",name)) {
2944       if (value && (STRCASEEQ('d','D',"disc",value) || STRCASEEQ('c','C',"circle",value) || STRCASEEQ('s','S',"square",value))) {
2945         W_L(" type=\"");
2946         W_V(value);
2947         W_L("\"");
2948       }
2949     }
2950   }
2951   W_L(">");
2952   return xhtml->out;
2953 }
2954
2955
2956 /**
2957  * It is a handler who processes the DIR tag.
2958  *
2959  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2960  *                     destination is specified.
2961  * @param node   [i]   The DIR tag node is specified.
2962  * @return The conversion result is returned.
2963  */
2964 static char *
2965 s_xhtml_1_0_end_dir_tag(void *pdoc, Node *UNUSED(child))
2966 {
2967   xhtml_t *xhtml = GET_XHTML(pdoc);
2968   Doc     *doc = xhtml->doc;
2969   W_L("</dir>");
2970   return xhtml->out;
2971 }
2972
2973
2974 /**
2975  * It is a handler who processes the DL tag.
2976  *
2977  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2978  *                     destination is specified.
2979  * @param node   [i]   The DL tag node is specified.
2980  * @return The conversion result is returned.
2981  */
2982 static char *
2983 s_xhtml_1_0_start_dl_tag(void *pdoc, Node *UNUSED(child))
2984 {
2985   xhtml_t *xhtml = GET_XHTML(pdoc);
2986   Doc *doc = xhtml->doc;
2987   W_L("<dl>");
2988   return xhtml->out;
2989 }
2990
2991
2992 /**
2993  * It is a handler who processes the DL tag.
2994  *
2995  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2996  *                     destination is specified.
2997  * @param node   [i]   The DL tag node is specified.
2998  * @return The conversion result is returned.
2999  */
3000 static char *
3001 s_xhtml_1_0_end_dl_tag(void *pdoc, Node *UNUSED(child))
3002 {
3003   xhtml_t *xhtml = GET_XHTML(pdoc);
3004   Doc *doc = xhtml->doc;
3005   W_L("</dl>");
3006   return xhtml->out;
3007 }
3008
3009
3010 /**
3011  * It is a handter who processes the DT tag.
3012  *
3013  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3014  *                     destination is specified.
3015  * @param node   [i]   The DT tag node is specified.
3016  * @return The conversion result is returned.
3017  */
3018 static char *
3019 s_xhtml_1_0_start_dt_tag(void *pdoc, Node *UNUSED(child))
3020 {
3021   xhtml_t *xhtml = GET_XHTML(pdoc);
3022   Doc     *doc   = xhtml->doc;
3023   W_L("<dt>");
3024   return xhtml->out;
3025 }
3026
3027
3028 /**
3029  * It is a handter who processes the DT tag.
3030  *
3031  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3032  *                     destination is specified.
3033  * @param node   [i]   The DT tag node is specified.
3034  * @return The conversion result is returned.
3035  */
3036 static char *
3037 s_xhtml_1_0_end_dt_tag(void *pdoc, Node *UNUSED(child))
3038 {
3039   xhtml_t *xhtml = GET_XHTML(pdoc);
3040   Doc     *doc   = xhtml->doc;
3041   W_L("</dt>");
3042   return xhtml->out;
3043 }
3044
3045
3046 /**
3047  * It is a handder who processes the DD tag.
3048  *
3049  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3050  *                     destination is specified.
3051  * @param node   [i]   The DD tag node is specified.
3052  * @return The conversion result is returned.
3053  */
3054 static char *
3055 s_xhtml_1_0_start_dd_tag(void *pdoc, Node *UNUSED(child))
3056 {
3057   xhtml_t *xhtml = GET_XHTML(pdoc);
3058   Doc     *doc   = xhtml->doc;
3059   W_L("<dd>");
3060   return xhtml->out;
3061 }
3062
3063
3064 /**
3065  * It is a handder who processes the DD tag.
3066  *
3067  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3068  *                     destination is specified.
3069  * @param node   [i]   The DD tag node is specified.
3070  * @return The conversion result is returned.
3071  */
3072 static char *
3073 s_xhtml_1_0_end_dd_tag(void *pdoc, Node *UNUSED(child))
3074 {
3075   xhtml_t *xhtml = GET_XHTML(pdoc);
3076   Doc     *doc   = xhtml->doc;
3077   W_L("</dd>");
3078   return xhtml->out;
3079 }
3080
3081
3082 /**
3083  * It is a handler who processes the MENU tag.
3084  *
3085  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3086  *                     destination is specified.
3087  * @param node   [i]   The MENU tag node is specified.
3088  * @return The conversion result is returned.
3089  */
3090 static char *
3091 s_xhtml_1_0_start_menu_tag(void *pdoc, Node *node)
3092 {
3093   xhtml_t *xhtml = GET_XHTML(pdoc);
3094   Doc     *doc   = xhtml->doc;
3095   Attr    *attr;
3096   W_L("<menu");
3097   /*--------------------------------------------------------------------------*/
3098   /* Get Attributes                                                           */
3099   /*--------------------------------------------------------------------------*/
3100   for (attr = qs_get_attr(doc,node);
3101        attr;
3102        attr = qs_get_next_attr(doc,attr)) {
3103     char *name   = qs_get_attr_name(doc,attr);
3104     char *value  = qs_get_attr_value(doc,attr);
3105     if (STRCASEEQ('t','T',"type",name)) {
3106       if (value && (STRCASEEQ('d','D',"disc",value) || STRCASEEQ('c','C',"circle",value) || STRCASEEQ('s','S',"square",value))) {
3107         W_L(" type=\"");
3108         W_V(value);
3109         W_L("\"");
3110       }
3111     }
3112   }
3113   W_L(">");
3114   return xhtml->out;
3115 }
3116
3117
3118 /**
3119  * It is a hanmenuer who processes the MENU tag.
3120  *
3121  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3122  *                     destination is specified.
3123  * @param node   [i]   The MENU tag node is specified.
3124  * @return The conversion result is returned.
3125  */
3126 static char *
3127 s_xhtml_1_0_end_menu_tag(void *pdoc, Node *UNUSED(child))
3128 {
3129   xhtml_t *xhtml = GET_XHTML(pdoc);
3130   Doc *doc = xhtml->doc;
3131   W_L("</menu>");
3132   return xhtml->out;
3133 }
3134
3135
3136 /**
3137  * It is a handler who processes the PLAINTEXT tag.
3138  *
3139  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3140  *                     destination is specified.
3141  * @param node   [i]   The PLAINTEXT tag node is specified.
3142  * @return The conversion result is returned.
3143  */
3144 static char *
3145 s_xhtml_1_0_start_plaintext_tag(void *pdoc, Node *node)
3146 {
3147   xhtml_t *xhtml = GET_XHTML(pdoc);
3148   Doc     *doc     = xhtml->doc;
3149   W_L("<plaintext>");
3150   s_xhtml_1_0_start_plaintext_tag_inner(pdoc,node);
3151   return xhtml->out;
3152 }
3153
3154 static char *
3155 s_xhtml_1_0_start_plaintext_tag_inner(void *pdoc, Node *node)
3156 {
3157   xhtml_t *xhtml = GET_XHTML(pdoc);
3158   Doc     *doc     = xhtml->doc;
3159   Node    *child;
3160   for (child = qs_get_child_node(doc, node);
3161        child;
3162        child = qs_get_next_node(doc, child)) {
3163     W_V(child->otext);
3164     s_xhtml_1_0_start_plaintext_tag_inner(pdoc, child);
3165   }
3166   return xhtml->out;
3167 }
3168
3169
3170 /**
3171  * It is a handler who processes the PLAINTEXT tag.
3172  *
3173  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3174  *                     destination is specified.
3175  * @param node   [i]   The PLAINTEXT tag node is specified.
3176  * @return The conversion result is returned.
3177  */
3178 static char *
3179 s_xhtml_1_0_end_plaintext_tag(void *pdoc, Node *UNUSED(child))
3180 {
3181   xhtml_t *xhtml = GET_XHTML(pdoc);
3182   Doc     *doc     = xhtml->doc;
3183   W_L("</plaintext>");
3184   return xhtml->out;
3185 }
3186
3187
3188 /**
3189  * It is a hanblinker who processes the BLINK tag.
3190  *
3191  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3192  *                     destination is specified.
3193  * @param node   [i]   The BLINK tag node is specified.
3194  * @return The conversion result is returned.
3195  */
3196 static char *
3197 s_xhtml_1_0_start_blink_tag(void *pdoc, Node *UNUSED(child))
3198 {
3199   xhtml_t *xhtml = GET_XHTML(pdoc);
3200   Doc     *doc = xhtml->doc;
3201   W_L("<blink>");
3202   return xhtml->out;
3203 }
3204
3205
3206 /**
3207  * It is a hanblinker who processes the BLINK tag.
3208  *
3209  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3210  *                     destination is specified.
3211  * @param node   [i]   The BLINK tag node is specified.
3212  * @return The conversion result is returned.
3213  */
3214 static char *
3215 s_xhtml_1_0_end_blink_tag(void *pdoc, Node *UNUSED(child))
3216 {
3217   xhtml_t *xhtml = GET_XHTML(pdoc);
3218   Doc     *doc = xhtml->doc;
3219   W_L("</blink>");
3220   return xhtml->out;
3221 }
3222
3223
3224 /**
3225  * It is a handler who processes the MARQUEE tag.
3226  *
3227  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3228  *                     destination is specified.
3229  * @param node   [i]   The MARQUEE tag node is specified.
3230  * @return The conversion result is returned.
3231  */
3232 static char *
3233 s_xhtml_1_0_start_marquee_tag(void *pdoc, Node *node)
3234 {
3235   xhtml_t *xhtml = GET_XHTML(pdoc);
3236   Doc     *doc = xhtml->doc;
3237   Attr *attr;
3238   W_L("<marquee");
3239   /*--------------------------------------------------------------------------*/
3240   /* Get Attributes                                                           */
3241   /*--------------------------------------------------------------------------*/
3242   for (attr = qs_get_attr(doc,node);
3243        attr;
3244        attr = qs_get_next_attr(doc,attr)) {
3245     char *name   = qs_get_attr_name(doc,attr);
3246     char *value  = qs_get_attr_value(doc,attr);
3247     if (STRCASEEQ('d','D',"direction", name)) {
3248       if (value && (STRCASEEQ('l','L',"left",value) || STRCASEEQ('r','R',"right",value))) {
3249         W_L(" direction=\"");
3250         W_V(value);
3251         W_L("\"");
3252       }
3253     }
3254     else if (STRCASEEQ('b','B',"behavior",name)) {
3255       if (value && (STRCASEEQ('s','S',"scroll",value) || STRCASEEQ('s','S',"slide",value) || STRCASEEQ('a','A',"alternate",value))) {
3256         W_L(" behavior=\"");
3257         W_V(value);
3258         W_L("\"");
3259       }
3260     }
3261     else if (STRCASEEQ('l','L',"loop",name)) {
3262       if (value && *value) {
3263         W_L(" loop=\"");
3264         W_V(value);
3265         W_L("\"");
3266       }
3267     }
3268     else if (STRCASEEQ('b','B',"bgcolor",name)) {
3269       if (value && *value) {
3270         W_L(" bgcolor=\"");
3271         W_V(value);
3272         W_L("\"");
3273       }
3274     }
3275   }
3276   W_L(">");
3277   return xhtml->out;
3278 }
3279
3280
3281 /**
3282  * It is a handler who processes the MARQUEE tag.
3283  *
3284  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3285  *                     destination is specified.
3286  * @param node   [i]   The MARQUEE tag node is specified.
3287  * @return The conversion result is returned.
3288  */
3289 static char *
3290 s_xhtml_1_0_end_marquee_tag(void *pdoc, Node *UNUSED(child))
3291 {
3292   xhtml_t *xhtml = GET_XHTML(pdoc);
3293   Doc     *doc = xhtml->doc;
3294   W_L("</marquee>");
3295   return xhtml->out;
3296 }
3297
3298
3299 /**
3300  * It is handler who processes the New Line Code.
3301  */
3302 static char *
3303 s_xhtml_1_0_newline_mark(void *pdoc, Node *UNUSED(node))
3304 {
3305   xhtml_t *xhtml = GET_XHTML(pdoc);
3306   Doc *doc = xhtml->doc;
3307   W_NLCODE();
3308   return xhtml->out;
3309 }
3310 /*
3311  * vim:ts=2 et
3312  */