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     char *unused = NULL;
1359     q = strchr(attr_action, '?');
1360     if (q) {
1361       new_hidden_tag = chxj_form_action_to_hidden_tag(r, doc->pool, attr_action, 1, post_flag, &unused, CHXJ_FALSE, CHXJ_FALSE);
1362       if (new_hidden_tag) {
1363         *q = 0;
1364       }
1365     }
1366     W_L(" action=\"");
1367     W_V(attr_action);
1368     W_L("\"");
1369   }
1370   if (attr_method) {
1371     W_L(" method=\"");
1372     W_V(attr_method);
1373     W_L("\"");
1374   }
1375   if (attr_name) {
1376     W_L(" name=\"");
1377     W_V(attr_name);
1378     W_L("\"");
1379   }
1380   W_L(">");
1381   if (new_hidden_tag) {
1382     W_V(new_hidden_tag);
1383   }
1384   return xhtml->out;
1385 }
1386
1387
1388 /**
1389  * It is a handler who processes the FORM tag.
1390  *
1391  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1392  *                     destination is specified.
1393  * @param node   [i]   The FORM tag node is specified.
1394  * @return The conversion result is returned.
1395  */
1396 static char *
1397 s_xhtml_1_0_end_form_tag(void *pdoc, Node *UNUSED(child))
1398 {
1399   xhtml_t *xhtml = GET_XHTML(pdoc);
1400   Doc     *doc   = xhtml->doc;
1401
1402   W_L("</form>");
1403
1404   return xhtml->out;
1405 }
1406
1407
1408 /**
1409  * It is a handler who processes the INPUT tag.
1410  *
1411  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1412  *                     destination is specified.
1413  * @param node   [i]   The INPUT tag node is specified.
1414  * @return The conversion result is returned.
1415  */
1416 static char *
1417 s_xhtml_1_0_start_input_tag(void *pdoc, Node *node)
1418 {
1419   xhtml_t     *xhtml       = GET_XHTML(pdoc);
1420   Doc         *doc         = xhtml->doc;
1421   request_rec *r           = doc->r;
1422   char        *max_length  = NULL;
1423   char        *type        = NULL;
1424   char        *name        = NULL;
1425   char        *value       = NULL;
1426   char        *istyle      = NULL;
1427   char        *size        = NULL;
1428   char        *checked     = NULL;
1429   char        *accesskey   = NULL;
1430
1431   W_L("<input");
1432   /*--------------------------------------------------------------------------*/
1433   /* Get Attributes                                                           */
1434   /*--------------------------------------------------------------------------*/
1435   type       = qs_get_type_attr(doc, node, doc->buf.pool);
1436   name       = qs_get_name_attr(doc, node, doc->buf.pool);
1437   value      = qs_get_value_attr(doc,node, doc->buf.pool);
1438   istyle     = qs_get_istyle_attr(doc,node,doc->buf.pool);
1439   max_length = qs_get_maxlength_attr(doc,node,doc->buf.pool);
1440   checked    = qs_get_checked_attr(doc,node, doc->buf.pool);
1441   accesskey  = qs_get_accesskey_attr(doc, node, doc->buf.pool);
1442   size       = qs_get_size_attr(doc, node, doc->buf.pool);
1443
1444   if (type) {
1445     type = qs_trim_string(doc->buf.pool, type);
1446     if (type && (STRCASEEQ('t','T',"text",    type) ||
1447                  STRCASEEQ('p','P',"password",type) ||
1448                  STRCASEEQ('c','C',"checkbox",type) ||
1449                  STRCASEEQ('r','R',"radio",   type) ||
1450                  STRCASEEQ('h','H',"hidden",  type) ||
1451                  STRCASEEQ('s','S',"submit",  type) ||
1452                  STRCASEEQ('r','R',"reset",   type))) {
1453       W_L(" type=\"");
1454       W_V(type);
1455       W_L("\"");
1456     }
1457   }
1458   if (size && *size) {
1459     W_L(" size=\"");
1460     W_V(size);
1461     W_L("\"");
1462   }
1463   if (name && *name) {
1464     W_L(" name=\"");
1465     W_V(name);
1466     W_L("\"");
1467   }
1468   if (value && *value) {
1469     W_L(" value=\"");
1470     W_V(chxj_add_slash_to_doublequote(doc->pool, value));
1471     W_L("\"");
1472   }
1473   if (accesskey && *accesskey) {
1474     W_L(" accesskey=\"");
1475     W_V(accesskey);
1476     W_L("\"");
1477   }
1478   if (istyle && *istyle && (*istyle == '1' || *istyle == '2' || *istyle == '3' || *istyle == '4')) {
1479     char *fmt = qs_conv_istyle_to_format(r,istyle);
1480     if (max_length && *max_length) {
1481       int ii;
1482       for (ii=0; (unsigned int)ii<strlen(max_length); ii++) {
1483         if (max_length[ii] < '0' || max_length[ii] > '9') {
1484           max_length = apr_psprintf(r->pool, "0");
1485           break;
1486         }
1487       }
1488
1489       if (strcmp(max_length, "0")) {
1490         char *vv = apr_psprintf(r->pool, " FORMAT=\"%d%s\"", atoi(max_length), fmt);
1491         W_V(vv);
1492       }
1493     }
1494     else {
1495       W_L(" FORMAT=\"");
1496       W_L("*");
1497       W_V(fmt);
1498       W_L("\"");
1499     }
1500   }
1501   else {
1502     if (max_length && *max_length) {
1503       if (chxj_chk_numeric(max_length) != 0) {
1504         max_length = apr_psprintf(r->pool, "0");
1505       }
1506       if (strcmp(max_length, "0")) {
1507         char *vv = apr_psprintf(r->pool, " FORMAT=\"%dm\"", atoi(max_length));
1508         W_V(vv);
1509       }
1510     }
1511   }
1512   /*--------------------------------------------------------------------------*/
1513   /* The figure is default for the password.                                  */
1514   /*--------------------------------------------------------------------------*/
1515   if (type && (istyle == NULL || *istyle == 0) && STRCASEEQ('p','P',"password", type) && ! xhtml->entryp->pc_flag) {
1516     if (max_length) {
1517       W_L(" FORMAT=\"");
1518       W_V(max_length);
1519       W_L("N\"");
1520     }
1521     else {
1522       W_L(" FORMAT=\"*N\"");
1523     }
1524   }
1525   if (checked) {
1526     W_L(" checked=\"checked\"");
1527   }
1528   W_L(" />");
1529
1530   return xhtml->out;
1531 }
1532
1533
1534 /**
1535  * It is a handler who processes the INPUT tag.
1536  *
1537  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1538  *                     destination is specified.
1539  * @param node   [i]   The INPUT tag node is specified.
1540  * @return The conversion result is returned.
1541  */
1542 static char *
1543 s_xhtml_1_0_end_input_tag(void *pdoc, Node *UNUSED(child))
1544 {
1545   xhtml_t *xhtml = GET_XHTML(pdoc);
1546
1547   return xhtml->out;
1548 }
1549
1550
1551 /**
1552  * It is a handler who processes the CENTER tag.
1553  *
1554  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1555  *                     destination is specified.
1556  * @param node   [i]   The CENTER tag node is specified.
1557  * @return The conversion result is returned.
1558  */
1559 static char *
1560 s_xhtml_1_0_start_center_tag(void *pdoc, Node *UNUSED(node))
1561 {
1562   xhtml_t *xhtml = GET_XHTML(pdoc);
1563   Doc     *doc   = xhtml->doc;
1564
1565   W_L("<center>");
1566   return xhtml->out;
1567 }
1568
1569
1570 /**
1571  * It is a handler who processes the CENTER tag.
1572  *
1573  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1574  *                     destination is specified.
1575  * @param node   [i]   The CENTER tag node is specified.
1576  * @return The conversion result is returned.
1577  */
1578 static char *
1579 s_xhtml_1_0_end_center_tag(void *pdoc, Node *UNUSED(child))
1580 {
1581   xhtml_t *xhtml = GET_XHTML(pdoc);
1582   Doc     *doc   = xhtml->doc;
1583
1584   W_L("</center>");
1585   return xhtml->out;
1586 }
1587
1588
1589 /**
1590  * It is a handler who processes the HR tag.
1591  *
1592  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1593  *                     destination is specified.
1594  * @param node   [i]   The HR tag node is specified.
1595  * @return The conversion result is returned.
1596  */
1597 static char *
1598 s_xhtml_1_0_start_hr_tag(void *pdoc, Node *node)
1599 {
1600   xhtml_t *xhtml = GET_XHTML(pdoc);
1601   Doc     *doc   = xhtml->doc;
1602   Attr    *attr;
1603
1604   W_L("<hr");
1605
1606   for (attr = qs_get_attr(doc,node);
1607        attr;
1608        attr = qs_get_next_attr(doc,attr)) {
1609     char *name = qs_get_attr_name(doc,attr);
1610     char *value = qs_get_attr_value(doc,attr);
1611     if (STRCASEEQ('a','A',"align", name)) {
1612       /*----------------------------------------------------------------------*/
1613       /* CHTML 1.0                                                            */
1614       /*----------------------------------------------------------------------*/
1615       if (value && (STRCASEEQ('l','L',"left",value) || STRCASEEQ('r','R',"right",value) || STRCASEEQ('c','C',"center",value))) {
1616         W_L(" align=\"");
1617         W_V(value);
1618         W_L("\"");
1619       }
1620     }
1621     else if (STRCASEEQ('s','S',"size", name)) {
1622       /*----------------------------------------------------------------------*/
1623       /* CHTML 1.0                                                            */
1624       /*----------------------------------------------------------------------*/
1625       if (value && *value) {
1626         W_L(" size=\"");
1627         W_V(value);
1628         W_L("\"");
1629       }
1630     }
1631     else if (STRCASEEQ('w','W',"width", name)) {
1632       /*----------------------------------------------------------------------*/
1633       /* CHTML 1.0                                                            */
1634       /*----------------------------------------------------------------------*/
1635       if (value && *value) {
1636         W_L(" width=\"");
1637         W_V(value);
1638         W_L("\"");
1639       }
1640     }
1641     else if (STRCASEEQ('n','N',"noshade", name)) {
1642       /*----------------------------------------------------------------------*/
1643       /* CHTML 1.0                                                            */
1644       /*----------------------------------------------------------------------*/
1645       /* ignore */
1646     }
1647     else if (STRCASEEQ('c','C',"color", name) && value && *value) {
1648       /*----------------------------------------------------------------------*/
1649       /* CHTML 4.0                                                            */
1650       /*----------------------------------------------------------------------*/
1651       W_L(" color=\"");
1652       W_V(value);
1653       W_L("\"");
1654     }
1655   }
1656   W_L(" />");
1657   return xhtml->out;
1658 }
1659
1660
1661 /**
1662  * It is a handler who processes the HR tag.
1663  *
1664  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1665  *                     destination is specified.
1666  * @param node   [i]   The HR tag node is specified.
1667  * @return The conversion result is returned.
1668  */
1669 static char *
1670 s_xhtml_1_0_end_hr_tag(void *pdoc, Node *UNUSED(child))
1671 {
1672   xhtml_t *xhtml = GET_XHTML(pdoc);
1673
1674   return xhtml->out;
1675 }
1676
1677
1678 /**
1679  * It is a handler who processes the PRE tag.
1680  *
1681  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1682  *                     destination is specified.
1683  * @param node   [i]   The PRE tag node is specified.
1684  * @return The conversion result is returned.
1685  */
1686 static char *
1687 s_xhtml_1_0_start_pre_tag(void* pdoc, Node* UNUSED(node))
1688 {
1689   xhtml_t *xhtml = GET_XHTML(pdoc);
1690   Doc     *doc   = xhtml->doc;
1691
1692   xhtml->pre_flag++;
1693   W_L("<pre>");
1694   return xhtml->out;
1695 }
1696
1697
1698 /**
1699  * It is a handler who processes the PRE tag.
1700  *
1701  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1702  *                     destination is specified.
1703  * @param node   [i]   The PRE tag node is specified.
1704  * @return The conversion result is returned.
1705  */
1706 static char *
1707 s_xhtml_1_0_end_pre_tag(void *pdoc, Node *UNUSED(child))
1708 {
1709   xhtml_t *xhtml = GET_XHTML(pdoc);
1710   Doc     *doc   = xhtml->doc;
1711
1712   W_L("</pre>");
1713   xhtml->pre_flag--;
1714
1715   return xhtml->out;
1716 }
1717
1718
1719 /**
1720  * It is a handler who processes the P tag.
1721  *
1722  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1723  *                     destination is specified.
1724  * @param node   [i]   The P tag node is specified.
1725  * @return The conversion result is returned.
1726  */
1727 static char *
1728 s_xhtml_1_0_start_p_tag(void *pdoc, Node *node)
1729 {
1730   xhtml_t *xhtml = GET_XHTML(pdoc);
1731   Doc     *doc   = xhtml->doc;
1732   Attr    *attr;
1733   char    *align = NULL;
1734
1735   W_L("<p");
1736   for (attr = qs_get_attr(doc,node);
1737        attr;
1738        attr = qs_get_next_attr(doc,attr)) {
1739     char *nm  = qs_get_attr_name(doc,attr);
1740     char *val = qs_get_attr_value(doc,attr);
1741     if (STRCASEEQ('a','A',"align", nm)) {
1742       /*----------------------------------------------------------------------*/
1743       /* CHTML 1.0 (W3C version 3.2)                                          */
1744       /*----------------------------------------------------------------------*/
1745       if (val && (STRCASEEQ('l','L',"left",val) || STRCASEEQ('r','R',"right",val) || STRCASEEQ('c','C',"center",val))) {
1746         align = apr_pstrdup(doc->buf.pool, val);
1747         break;
1748       }
1749     }
1750   }
1751   if (align) {
1752     W_L(" align=\"");
1753     W_V(align);
1754     W_L("\"");
1755   }
1756   W_L(">");
1757   return xhtml->out;
1758 }
1759
1760
1761 /**
1762  * It is a handler who processes the P tag.
1763  *
1764  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1765  *                     destination is specified.
1766  * @param node   [i]   The P tag node is specified.
1767  * @return The conversion result is returned.
1768  */
1769 static char *
1770 s_xhtml_1_0_end_p_tag(void *pdoc, Node *UNUSED(child))
1771 {
1772   xhtml_t *xhtml = GET_XHTML(pdoc);
1773   Doc     *doc   = xhtml->doc;
1774
1775   W_L("</p>");
1776   return xhtml->out;
1777 }
1778
1779
1780 /**
1781  * It is a handler who processes the UL tag.
1782  *
1783  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1784  *                     destination is specified.
1785  * @param node   [i]   The UL tag node is specified.
1786  * @return The conversion result is returned.
1787  */
1788 static char *
1789 s_xhtml_1_0_start_ul_tag(void *pdoc, Node *node)
1790 {
1791   xhtml_t *xhtml = GET_XHTML(pdoc);
1792   Doc     *doc   = xhtml->doc;
1793   Attr    *attr;
1794   W_L("<ul");
1795   /*--------------------------------------------------------------------------*/
1796   /* Get Attributes                                                           */
1797   /*--------------------------------------------------------------------------*/
1798   for (attr = qs_get_attr(doc,node);
1799        attr;
1800        attr = qs_get_next_attr(doc,attr)) {
1801     char *name   = qs_get_attr_name(doc,attr);
1802     char *value  = qs_get_attr_value(doc,attr);
1803     if (STRCASEEQ('t','T',"type",name)) {
1804       if (value && (STRCASEEQ('d','D',"disc",value) || STRCASEEQ('c','C',"circle",value) || STRCASEEQ('s','S',"square",value))) {
1805         W_L(" type=\"");
1806         W_V(value);
1807         W_L("\"");
1808       }
1809     }
1810   }
1811   W_L(">");
1812   return xhtml->out;
1813 }
1814
1815
1816 /**
1817  * It is a handler who processes the UL tag.
1818  *
1819  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1820  *                     destination is specified.
1821  * @param node   [i]   The UL tag node is specified.
1822  * @return The conversion result is returned.
1823  */
1824 static char *
1825 s_xhtml_1_0_end_ul_tag(void *pdoc, Node *UNUSED(child))
1826 {
1827   xhtml_t *xhtml = GET_XHTML(pdoc);
1828   Doc     *doc   = xhtml->doc;
1829
1830   W_L("</ul>");
1831   return xhtml->out;
1832 }
1833
1834
1835 /**
1836  * It is a handler who processes the H1 tag.
1837  *
1838  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1839  *                     destination is specified.
1840  * @param node   [i]   The H1 tag node is specified.
1841  * @return The conversion result is returned.
1842  */
1843 static char *
1844 s_xhtml_1_0_start_h1_tag(void *pdoc, Node *node)
1845 {
1846   xhtml_t *xhtml = GET_XHTML(pdoc);
1847   Doc     *doc   = xhtml->doc;
1848   Attr    *attr;
1849
1850   W_L("<h1");
1851   for (attr = qs_get_attr(doc,node);
1852        attr;
1853        attr = qs_get_next_attr(doc,attr)) {
1854     char* name;
1855     char* value;
1856     name  = qs_get_attr_name(doc,attr);
1857     value = qs_get_attr_value(doc,attr);
1858     if (STRCASEEQ('a','A',"align", name)) {
1859       if (value) {
1860         if (STRCASEEQ('l','L',"left",value)) {
1861           W_L(" style=\"");
1862           W_L("text-align:left");
1863           W_L("\"");
1864         }
1865         else if (STRCASEEQ('r','R',"right",value)) {
1866           W_L(" style=\"");
1867           W_L("text-align:right");
1868           W_L("\"");
1869         }
1870         else if (STRCASEEQ('c','C',"center",value)) {
1871           W_L(" style=\"");
1872           W_L("text-align:center");
1873           W_L("\"");
1874         }
1875         break;
1876       }
1877     }
1878   }
1879   W_L(">");
1880   return xhtml->out;
1881 }
1882
1883
1884 /**
1885  * It is a handler who processes the H1 tag.
1886  *
1887  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1888  *                     destination is specified.
1889  * @param node   [i]   The H1 tag node is specified.
1890  * @return The conversion result is returned.
1891  */
1892 static char *
1893 s_xhtml_1_0_end_h1_tag(void *pdoc, Node *UNUSED(child))
1894 {
1895   xhtml_t *xhtml = GET_XHTML(pdoc);
1896   Doc     *doc   = xhtml->doc;
1897
1898   W_L("</h1>");
1899   return xhtml->out;
1900 }
1901
1902
1903 /**
1904  * It is a handler who processes the H2 tag.
1905  *
1906  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1907  *                     destination is specified.
1908  * @param node   [i]   The H2 tag node is specified.
1909  * @return The conversion result is returned.
1910  */
1911 static char *
1912 s_xhtml_1_0_start_h2_tag(void *pdoc, Node *node)
1913 {
1914   xhtml_t *xhtml = GET_XHTML(pdoc);
1915   Doc     *doc = xhtml->doc;
1916   Attr    *attr;
1917
1918   W_L("<h2");
1919   for (attr = qs_get_attr(doc,node);
1920        attr;
1921        attr = qs_get_next_attr(doc,attr)) {
1922     char* name;
1923     char* value;
1924     name  = qs_get_attr_name(doc,attr);
1925     value = qs_get_attr_value(doc,attr);
1926     if (STRCASEEQ('a','A',"align", name)) {
1927       if (value) {
1928         if (STRCASEEQ('l','L',"left",value)) {
1929           W_L(" style=\"");
1930           W_L("text-align:left");
1931           W_L("\"");
1932         }
1933         else if (STRCASEEQ('r','R',"right",value)) {
1934           W_L(" style=\"");
1935           W_L("text-align:right");
1936           W_L("\"");
1937         }
1938         else if (STRCASEEQ('c','C',"center",value)) {
1939           W_L(" style=\"");
1940           W_L("text-align:center");
1941           W_L("\"");
1942         }
1943         break;
1944       }
1945     }
1946   }
1947   W_L(">");
1948   return xhtml->out;
1949 }
1950
1951
1952 /**
1953  * It is a handler who processes the H2 tag.
1954  *
1955  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1956  *                     destination is specified.
1957  * @param node   [i]   The H2 tag node is specified.
1958  * @return The conversion result is returned.
1959  */
1960 static char *
1961 s_xhtml_1_0_end_h2_tag(void *pdoc, Node *UNUSED(child))
1962 {
1963   xhtml_t *xhtml = GET_XHTML(pdoc);
1964   Doc     *doc   = xhtml->doc;
1965
1966   W_L("</h2>");
1967   return xhtml->out;
1968 }
1969
1970
1971 /**
1972  * It is a handler who processes the H3 tag.
1973  *
1974  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
1975  *                     destination is specified.
1976  * @param node   [i]   The H3 tag node is specified.
1977  * @return The conversion result is returned.
1978  */
1979 static char *
1980 s_xhtml_1_0_start_h3_tag(void *pdoc, Node *node)
1981 {
1982   xhtml_t *xhtml = GET_XHTML(pdoc);
1983   Doc     *doc   = xhtml->doc;
1984   Attr    *attr;
1985
1986   W_L("<h3");
1987   for (attr = qs_get_attr(doc,node);
1988        attr;
1989        attr = qs_get_next_attr(doc,attr)) {
1990     char* name;
1991     char* value;
1992     name  = qs_get_attr_name(doc,attr);
1993     value = qs_get_attr_value(doc,attr);
1994     if (STRCASEEQ('a','A',"align", name)) {
1995       if (value) {
1996         if (STRCASEEQ('l','L',"left",value)) {
1997           W_L(" style=\"");
1998           W_L("text-align:left");
1999           W_L("\"");
2000         }
2001         else if (STRCASEEQ('r','R',"right",value)) {
2002           W_L(" style=\"");
2003           W_L("text-align:right");
2004           W_L("\"");
2005         }
2006         else if (STRCASEEQ('c','C',"center",value)) {
2007           W_L(" style=\"");
2008           W_L("text-align:center");
2009           W_L("\"");
2010         }
2011         break;
2012       }
2013     }
2014   }
2015   W_L(">");
2016   return xhtml->out;
2017 }
2018
2019
2020 /**
2021  * It is a handler who processes the H3 tag.
2022  *
2023  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2024  *                     destination is specified.
2025  * @param node   [i]   The H3 tag node is specified.
2026  * @return The conversion result is returned.
2027  */
2028 static char *
2029 s_xhtml_1_0_end_h3_tag(void *pdoc, Node *UNUSED(child))
2030 {
2031   xhtml_t *xhtml = GET_XHTML(pdoc);
2032   Doc     *doc   = xhtml->doc;
2033
2034   W_L("</h3>");
2035   return xhtml->out;
2036 }
2037
2038
2039 /**
2040  * It is a handler who processes the H4 tag.
2041  *
2042  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2043  *                     destination is specified.
2044  * @param node   [i]   The H4 tag node is specified.
2045  * @return The conversion result is returned.
2046  */
2047 static char *
2048 s_xhtml_1_0_start_h4_tag(void *pdoc, Node *node)
2049 {
2050   xhtml_t *xhtml = GET_XHTML(pdoc);
2051   Doc     *doc   = xhtml->doc;
2052   Attr    *attr;
2053
2054   W_L("<h4");
2055   for (attr = qs_get_attr(doc,node);
2056        attr;
2057        attr = qs_get_next_attr(doc,attr)) {
2058     char* name;
2059     char* value;
2060     name  = qs_get_attr_name(doc,attr);
2061     value = qs_get_attr_value(doc,attr);
2062     if (STRCASEEQ('a','A',"align", name)) {
2063       if (value) {
2064         if (STRCASEEQ('l','L',"left",value)) {
2065           W_L(" style=\"");
2066           W_L("text-align:left");
2067           W_L("\"");
2068         }
2069         else if (STRCASEEQ('r','R',"right",value)) {
2070           W_L(" style=\"");
2071           W_L("text-align:right");
2072           W_L("\"");
2073         }
2074         else if (STRCASEEQ('c','C',"center",value)) {
2075           W_L(" style=\"");
2076           W_L("text-align:center");
2077           W_L("\"");
2078         }
2079         break;
2080       }
2081     }
2082   }
2083   W_L(">");
2084   return xhtml->out;
2085 }
2086
2087
2088 /**
2089  * It is a handler who processes the H4 tag.
2090  *
2091  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2092  *                     destination is specified.
2093  * @param node   [i]   The H4 tag node is specified.
2094  * @return The conversion result is returned.
2095  */
2096 static char *
2097 s_xhtml_1_0_end_h4_tag(void *pdoc, Node *UNUSED(child))
2098 {
2099   xhtml_t *xhtml = GET_XHTML(pdoc);
2100   Doc     *doc   = xhtml->doc;
2101
2102   W_L("</h4>");
2103   return xhtml->out;
2104 }
2105
2106
2107 /**
2108  * It is a handler who processes the H5 tag.
2109  *
2110  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2111  *                     destination is specified.
2112  * @param node   [i]   The H5 tag node is specified.
2113  * @return The conversion result is returned.
2114  */
2115 static char *
2116 s_xhtml_1_0_start_h5_tag(void *pdoc, Node *node)
2117 {
2118   xhtml_t *xhtml = GET_XHTML(pdoc);
2119   Doc     *doc   = xhtml->doc;
2120   Attr    *attr;
2121
2122   W_L("<h5");
2123   for (attr = qs_get_attr(doc,node);
2124        attr;
2125        attr = qs_get_next_attr(doc,attr)) {
2126     char* name;
2127     char* value;
2128     name  = qs_get_attr_name(doc,attr);
2129     value = qs_get_attr_value(doc,attr);
2130     if (STRCASEEQ('a','A',"align", name)) {
2131       if (value) {
2132         if (STRCASEEQ('l','L',"left",value)) {
2133           W_L(" style=\"");
2134           W_L("text-align:left");
2135           W_L("\"");
2136         }
2137         else if (STRCASEEQ('r','R',"right",value)) {
2138           W_L(" style=\"");
2139           W_L("text-align:right");
2140           W_L("\"");
2141         }
2142         else if (STRCASEEQ('c','C',"center",value)) {
2143           W_L(" style=\"");
2144           W_L("text-align:center");
2145           W_L("\"");
2146         }
2147         break;
2148       }
2149     }
2150   }
2151   W_L(">");
2152   return xhtml->out;
2153 }
2154
2155
2156 /**
2157  * It is a handler who processes the H5 tag.
2158  *
2159  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2160  *                     destination is specified.
2161  * @param node   [i]   The H5 tag node is specified.
2162  * @return The conversion result is returned.
2163  */
2164 static char *
2165 s_xhtml_1_0_end_h5_tag(void *pdoc, Node *UNUSED(child))
2166 {
2167   xhtml_t *xhtml = GET_XHTML(pdoc);
2168   Doc     *doc   = xhtml->doc;
2169
2170   W_L("</h5>");
2171   return xhtml->out;
2172 }
2173
2174
2175 /**
2176  * It is a handler who processes the H6 tag.
2177  *
2178  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2179  *                     destination is specified.
2180  * @param node   [i]   The H6 tag node is specified.
2181  * @return The conversion result is returned.
2182  */
2183 static char *
2184 s_xhtml_1_0_start_h6_tag(void *pdoc, Node *node)
2185 {
2186   xhtml_t *xhtml = GET_XHTML(pdoc);
2187   Doc     *doc   = xhtml->doc;
2188   Attr    *attr;
2189
2190   W_L("<h6");
2191   for (attr = qs_get_attr(doc,node);
2192        attr;
2193        attr = qs_get_next_attr(doc,attr)) {
2194     char* name;
2195     char* value;
2196     name  = qs_get_attr_name(doc,attr);
2197     value = qs_get_attr_value(doc,attr);
2198     if (STRCASEEQ('a','A',"align", name)) {
2199       if (value) {
2200         if (STRCASEEQ('l','L',"left",value)) {
2201           W_L(" style=\"");
2202           W_L("text-align:left");
2203           W_L("\"");
2204         }
2205         else if (STRCASEEQ('r','R',"right",value)) {
2206           W_L(" style=\"");
2207           W_L("text-align:right");
2208           W_L("\"");
2209         }
2210         else if (STRCASEEQ('c','C',"center",value)) {
2211           W_L(" style=\"");
2212           W_L("text-align:center");
2213           W_L("\"");
2214         }
2215         break;
2216       }
2217     }
2218   }
2219   W_L(">");
2220   return xhtml->out;
2221 }
2222
2223
2224 /**
2225  * It is a handler who processes the H6 tag.
2226  *
2227  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2228  *                     destination is specified.
2229  * @param node   [i]   The H6 tag node is specified.
2230  * @return The conversion result is returned.
2231  */
2232 static char *
2233 s_xhtml_1_0_end_h6_tag(void *pdoc, Node *UNUSED(child))
2234 {
2235   xhtml_t *xhtml = GET_XHTML(pdoc);
2236   Doc     *doc   = xhtml->doc;
2237
2238   W_L("</h6>");
2239   return xhtml->out;
2240 }
2241
2242
2243 /**
2244  * It is a handler who processes the OL tag.
2245  *
2246  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2247  *                     destination is specified.
2248  * @param node   [i]   The OL tag node is specified.
2249  * @return The conversion result is returned.
2250  */
2251 static char *
2252 s_xhtml_1_0_start_ol_tag(void *pdoc, Node *node)
2253 {
2254   xhtml_t *xhtml = GET_XHTML(pdoc);
2255   Doc     *doc   = xhtml->doc;
2256   Attr    *attr;
2257
2258   W_L("<ol");
2259   /*--------------------------------------------------------------------------*/
2260   /* Get Attributes                                                           */
2261   /*--------------------------------------------------------------------------*/
2262   for (attr = qs_get_attr(doc,node);
2263        attr;
2264        attr = qs_get_next_attr(doc,attr)) {
2265     char *name = qs_get_attr_name(doc,attr);
2266     char *value = qs_get_attr_value(doc,attr);
2267     if (STRCASEEQ('t','T',"type",name) && value && (*value == '1' || *value == 'a' || *value == 'A')) {
2268       W_L(" type=\"");
2269       W_V(value);
2270       W_L("\"");
2271     }
2272     else if (STRCASEEQ('s','S',"start",name) && value && *value) {
2273       W_L(" start=\"");
2274       W_V(value);
2275       W_L("\"");
2276     }
2277   }
2278   W_L(">");
2279   return xhtml->out;
2280 }
2281
2282
2283 /**
2284  * It is a handler who processes the OL tag.
2285  *
2286  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2287  *                     destination is specified.
2288  * @param node   [i]   The OL tag node is specified.
2289  * @return The conversion result is returned.
2290  */
2291 static char *
2292 s_xhtml_1_0_end_ol_tag(void *pdoc, Node *UNUSED(child))
2293 {
2294   xhtml_t *xhtml = GET_XHTML(pdoc);
2295   Doc     *doc   = xhtml->doc;
2296
2297   W_L("</ol>");
2298   return xhtml->out;
2299 }
2300
2301
2302 /**
2303  * It is a handler who processes the LI tag.
2304  *
2305  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2306  *                     destination is specified.
2307  * @param node   [i]   The LI tag node is specified.
2308  * @return The conversion result is returned.
2309  */
2310 static char *
2311 s_xhtml_1_0_start_li_tag(void *pdoc, Node *node)
2312 {
2313   xhtml_t *xhtml = GET_XHTML(pdoc);
2314   Doc     *doc   = xhtml->doc;
2315   Attr    *attr;
2316
2317   W_L("<li");
2318   /*--------------------------------------------------------------------------*/
2319   /* Get Attributes                                                           */
2320   /*--------------------------------------------------------------------------*/
2321   for (attr = qs_get_attr(doc,node);
2322        attr;
2323        attr = qs_get_next_attr(doc,attr)) {
2324     char *name  = qs_get_attr_name(doc,attr);
2325     char *value = qs_get_attr_value(doc,attr);
2326     if (STRCASEEQ('t','T',"type",name)) {
2327       if (value && (*value == '1' || *value == 'a' || *value == 'A' || STRCASEEQ('d','D',"disc",value) || STRCASEEQ('c','C',"circle",value) || STRCASEEQ('s','S',"square",value))) {
2328         W_L(" type=\"");
2329         W_V(value);
2330         W_L("\"");
2331       }
2332     }
2333     else if (STRCASEEQ('v','V',"value", name) && value && *value) {
2334       W_L(" value=\"");
2335       W_V(value);
2336       W_L("\"");
2337     }
2338   }
2339   W_L(">");
2340   return xhtml->out;
2341 }
2342
2343
2344 /**
2345  ** It is a handler who processes the LI tag.
2346  *
2347  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2348  *                     destination is specified.
2349  * @param node   [i]   The LI tag node is specified.
2350  * @return The conversion result is returned.
2351  */
2352 static char *
2353 s_xhtml_1_0_end_li_tag(void *pdoc, Node *UNUSED(child))
2354 {
2355   xhtml_t *xhtml = GET_XHTML(pdoc);
2356   Doc     *doc   = xhtml->doc;
2357
2358   W_L("</li>");
2359   return xhtml->out;
2360 }
2361
2362 /**
2363  * It is a handler who processes the IMG tag.
2364  *
2365  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2366  *                     destination is specified.
2367  * @param node   [i]   The IMG tag node is specified.
2368  * @return The conversion result is returned.
2369  */
2370 static char *
2371 s_xhtml_1_0_start_img_tag(void *pdoc, Node *node)
2372 {
2373   xhtml_t       *xhtml = GET_XHTML(pdoc);
2374   Doc           *doc   = xhtml->doc;
2375   request_rec   *r     = doc->r;
2376   Attr          *attr;
2377
2378 #ifndef IMG_NOT_CONVERT_FILENAME
2379   device_table  *spec = xhtml->spec;
2380 #endif
2381
2382   W_L("<img");
2383   /*--------------------------------------------------------------------------*/
2384   /* Get Attributes                                                           */
2385   /*--------------------------------------------------------------------------*/
2386   for (attr = qs_get_attr(doc,node);
2387        attr;
2388        attr = qs_get_next_attr(doc,attr)) {
2389     char *name  = qs_get_attr_name(doc,attr);
2390     char *value = qs_get_attr_value(doc,attr);
2391
2392     if (STRCASEEQ('s','S',"src",name)) {
2393       value = chxj_encoding_parameter(r, value);
2394       value = chxj_add_cookie_parameter(r, value, xhtml->cookie);
2395       value = chxj_add_cookie_no_update_parameter(r, value);
2396 #ifdef IMG_NOT_CONVERT_FILENAME
2397
2398       W_L(" src=\"");
2399       W_V(value);
2400       W_L("\"");
2401
2402 #else
2403
2404       W_L(" src=\"");
2405       {
2406         char *vv = chxj_img_conv(r,spec,value);
2407         W_V(vv);
2408       }
2409       W_L("\"");
2410
2411 #endif
2412     }
2413     else
2414     if (STRCASEEQ('a','A',"align",name)) {
2415       if (value) {
2416         if (STRCASEEQ('t','T',"top",   value) ||
2417             STRCASEEQ('m','M',"middle",value) ||
2418             STRCASEEQ('b','B',"bottom",value) ||
2419             STRCASEEQ('l','L',"left",  value) ||
2420             STRCASEEQ('r','R',"right", value)) {
2421           W_L(" align=\"");
2422           W_V(value);
2423           W_L("\"");
2424         }
2425         else if (STRCASEEQ('c','C',"center",  value)) {
2426           W_L(" align=\"");
2427           W_L("middle");
2428           W_L("\"");
2429         }
2430       }
2431     }
2432     else if (STRCASEEQ('a','A',"alt",name) && value && *value) {
2433       W_L(" alt=\"");
2434       W_V(value);
2435       W_L("\"");
2436     }
2437     else if (STRCASEEQ('w','W',"width",name) && value && *value) {
2438       W_L(" width=\"");
2439       W_V(value);
2440       W_L("\"");
2441     }
2442     else if (STRCASEEQ('h','H',"height",name) && value && *value) {
2443       W_L(" height=\"");
2444       W_V(value);
2445       W_L("\"");
2446     }
2447     else if (STRCASEEQ('h','H',"hspace",name) && value && *value) {
2448       W_L(" hspace=\"");
2449       W_V(value);
2450       W_L("\"");
2451     }
2452     else if (STRCASEEQ('v','V',"vspace",name) && value && *value) {
2453       W_L(" vspace=\"");
2454       W_V(value);
2455       W_L("\"");
2456     }
2457   }
2458   W_L(" />");
2459   return xhtml->out;
2460 }
2461
2462
2463 /**
2464  * It is a handler who processes the IMG tag.
2465  *
2466  * @param xhtml  [i/o] The pointer to the XHTML structure at the output
2467  *                     destination is specified.
2468  * @param node   [i]   The IMG tag node is specified.
2469  * @return The conversion result is returned.
2470  */
2471 static char *
2472 s_xhtml_1_0_end_img_tag(void *pdoc, Node *UNUSED(child))
2473 {
2474   xhtml_t *xhtml = GET_XHTML(pdoc);
2475
2476   return xhtml->out;
2477 }
2478
2479
2480 /**
2481  * It is a handler who processes the SELECT tag.
2482  *
2483  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2484  *                     destination is specified.
2485  * @param node   [i]   The SELECT tag node is specified.
2486  * @return The conversion result is returned.
2487  */
2488 static char *
2489 s_xhtml_1_0_start_select_tag(void *pdoc, Node *child)
2490 {
2491   xhtml_t *xhtml    = GET_XHTML(pdoc);
2492   Doc     *doc      = xhtml->doc;
2493   char    *size     = NULL;
2494   char    *name     = NULL;
2495   char    *multiple = NULL;
2496   Attr    *attr;
2497
2498
2499   W_L("<select");
2500   for (attr = qs_get_attr(doc,child);
2501        attr;
2502        attr = qs_get_next_attr(doc,attr)) {
2503     char *nm  = qs_get_attr_name(doc,attr);
2504     char *val = qs_get_attr_value(doc,attr);
2505     if (STRCASEEQ('s','S',"size",nm)) {
2506       /*----------------------------------------------------------------------*/
2507       /* CHTML 1.0 version 2.0                                                */
2508       /*----------------------------------------------------------------------*/
2509       size = apr_pstrdup(doc->buf.pool, val);
2510     }
2511     else if (STRCASEEQ('n','N',"name",nm)) {
2512       /*----------------------------------------------------------------------*/
2513       /* CHTML 1.0 version 2.0                                                */
2514       /*----------------------------------------------------------------------*/
2515       name = apr_pstrdup(doc->buf.pool, val);
2516     }
2517     else if (STRCASEEQ('m','M',"multiple",nm)) {
2518       /*----------------------------------------------------------------------*/
2519       /* CHTML 1.0 version 2.0                                                */
2520       /*----------------------------------------------------------------------*/
2521       multiple = apr_pstrdup(doc->buf.pool, val);
2522     }
2523   }
2524   if (size && *size) {
2525     W_L(" size=\"");
2526     W_V(size);
2527     W_L("\"");
2528   }
2529   if (name && *name) {
2530     W_L(" name=\"");
2531     W_V(name);
2532     W_L("\"");
2533   }
2534   if (multiple) {
2535     /* "true" is *NOT* W3C. it is specification of WAP2.0 for EZWEB */
2536     W_L(" multiple=\"true\"");
2537   }
2538   W_L(">");
2539   return xhtml->out;
2540 }
2541
2542
2543 /**
2544  * It is a handler who processes the SELECT tag.
2545  *
2546  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2547  *                     destination is specified.
2548  * @param node   [i]   The SELECT tag node is specified.
2549  * @return The conversion result is returned.
2550  */
2551 static char *
2552 s_xhtml_1_0_end_select_tag(void *pdoc, Node *UNUSED(child))
2553 {
2554   xhtml_t *xhtml = GET_XHTML(pdoc);
2555   Doc     *doc   = xhtml->doc;
2556
2557   W_L("</select>");
2558   return xhtml->out;
2559 }
2560
2561
2562 /**
2563  * It is a handler who processes the OPTION tag.
2564  *
2565  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2566  *                     destination is specified.
2567  * @param node   [i]   The OPTION tag node is specified.
2568  * @return The conversion result is returned.
2569  */
2570 static char *
2571 s_xhtml_1_0_start_option_tag(void *pdoc, Node *child)
2572 {
2573   xhtml_t *xhtml = GET_XHTML(pdoc);
2574   Doc     *doc   = xhtml->doc;
2575   Attr    *attr;
2576
2577   char *selected   = NULL;
2578   char *value      = NULL;
2579
2580   W_L("<option");
2581   for (attr = qs_get_attr(doc,child);
2582        attr;
2583        attr = qs_get_next_attr(doc,attr)) {
2584     char *nm  = qs_get_attr_name(doc,attr);
2585     char *val = qs_get_attr_value(doc,attr);
2586     if (STRCASEEQ('s','S',"selected",nm)) {
2587       /* CHTML version 2.0 */
2588       selected = apr_pstrdup(doc->buf.pool, val);
2589     }
2590     else if (STRCASEEQ('v','V',"value",nm)) {
2591       /* CHTML version 2.0 */
2592       value = apr_pstrdup(doc->buf.pool, val);
2593     }
2594   }
2595   if (value) {
2596     W_L(" value=\"");
2597     W_V(value);
2598     W_L("\"");
2599   }
2600   if (selected) {
2601     W_L(" selected=\"selected\"");
2602   }
2603   W_L(">");
2604   return xhtml->out;
2605 }
2606
2607
2608 /**
2609  * It is a handler who processes the OPTION tag.
2610  *
2611  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2612  *                     destination is specified.
2613  * @param node   [i]   The OPTION tag node is specified.
2614  * @return The conversion result is returned.
2615  */
2616 static char *
2617 s_xhtml_1_0_end_option_tag(void *pdoc, Node *UNUSED(child))
2618 {
2619   xhtml_t *xhtml = GET_XHTML(pdoc);
2620   Doc     *doc   = xhtml->doc;
2621
2622   W_L("</option>");
2623   return xhtml->out;
2624 }
2625
2626
2627 /**
2628  * It is a handler who processes the DIV tag.
2629  *
2630  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2631  *                     destination is specified.
2632  * @param node   [i]   The DIV tag node is specified.
2633  * @return The conversion result is returned.
2634  */
2635 static char *
2636 s_xhtml_1_0_start_div_tag(void *pdoc, Node *child)
2637 {
2638   xhtml_t *xhtml = GET_XHTML(pdoc);
2639   Doc     *doc   = xhtml->doc;
2640   Attr    *attr;
2641   char    *align   = NULL;
2642
2643   W_L("<div");
2644   for (attr = qs_get_attr(doc,child);
2645        attr;
2646        attr = qs_get_next_attr(doc,attr)) {
2647     char *nm  = qs_get_attr_name(doc,attr);
2648     char *val = qs_get_attr_value(doc,attr);
2649     if (STRCASEEQ('a','A',"align",nm)) {
2650       /*=====================================================================*/
2651       /* CHTML version 3.2                                                   */
2652       /*=====================================================================*/
2653       if (val && (STRCASEEQ('l','L',"left",val) || STRCASEEQ('r','R',"right",val) || STRCASEEQ('c','C',"center",val))) {
2654         align = apr_pstrdup(doc->buf.pool, val);
2655       }
2656     }
2657   }
2658   if (align) {
2659     W_L(" align=\"");
2660     W_V(align);
2661     W_L("\"");
2662   }
2663   W_L(">");
2664   return xhtml->out;
2665 }
2666
2667
2668 /**
2669  * It is a handler who processes the DIV tag.
2670  *
2671  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2672  *                     destination is specified.
2673  * @param node   [i]   The DIV tag node is specified.
2674  * @return The conversion result is returned.
2675  */
2676 static char *
2677 s_xhtml_1_0_end_div_tag(void *pdoc, Node *UNUSED(child))
2678 {
2679   xhtml_t *xhtml = GET_XHTML(pdoc);
2680   Doc     *doc   = xhtml->doc;
2681   W_L("</div>");
2682   return xhtml->out;
2683 }
2684
2685
2686 /**
2687  * It is a handler who processes the B tag.
2688  *
2689  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2690  *                     destination is specified.
2691  * @param node   [i]   The B tag node is specified.
2692  * @return The conversion result is returned.
2693  */
2694 static char *
2695 s_xhtml_1_0_start_b_tag(void *pdoc, Node *UNUSED(child))
2696 {
2697   xhtml_t *xhtml = GET_XHTML(pdoc);
2698   Doc     *doc   = xhtml->doc;
2699
2700   W_L("<div style=\"font-weight:bold\">");
2701   return xhtml->out;
2702 }
2703
2704
2705 /**
2706  * It is a handler who processes the B tag.
2707  *
2708  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2709  *                     destination is specified.
2710  * @param node   [i]   The B tag node is specified.
2711  * @return The conversion result is returned.
2712  */
2713 static char *
2714 s_xhtml_1_0_end_b_tag(void *pdoc, Node *UNUSED(child))
2715 {
2716   xhtml_t *xhtml = GET_XHTML(pdoc);
2717   Doc     *doc   = xhtml->doc;
2718
2719   W_L("</div>");
2720   return xhtml->out;
2721 }
2722
2723
2724 /**
2725  * It is a handler who processes the CHXJ:IF tag.
2726  *
2727  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2728  *                     destination is specified.
2729  * @param node   [i]   The CHXJ:IF tag node is specified.
2730  */
2731 static char *
2732 s_xhtml_1_0_chxjif_tag(void *pdoc, Node *node)
2733 {
2734   xhtml_t      *xhtml = GET_XHTML(pdoc);
2735   Doc          *doc   = xhtml->doc;
2736   Node         *child;
2737
2738   for (child = qs_get_child_node(doc, node);
2739        child;
2740        child = qs_get_next_node(doc, child)) {
2741     W_V(child->otext);
2742     s_xhtml_1_0_chxjif_tag(xhtml, child);
2743   }
2744
2745   return NULL;
2746 }
2747
2748
2749 /**
2750  * It is a handler who processes the TEXTARE tag.
2751  *
2752  * @param pdoc  [i/o] The pointer to the CHTML structure at the output
2753  *                     destination is specified.
2754  * @param node   [i]   The TEXTAREA tag node is specified.
2755  * @return The conversion result is returned.
2756  */
2757 static char *
2758 s_xhtml_1_0_start_textarea_tag(void *pdoc, Node *node)
2759 {
2760   xhtml_t *xhtml = GET_XHTML(pdoc);
2761   Doc     *doc   = xhtml->doc;
2762   Attr    *attr;
2763
2764   xhtml->textarea_flag++;
2765   W_L("<textarea");
2766   for (attr = qs_get_attr(doc,node);
2767        attr;
2768        attr = qs_get_next_attr(doc,attr)) {
2769     char *name  = qs_get_attr_name(doc,attr);
2770     char *value = qs_get_attr_value(doc,attr);
2771     if (STRCASEEQ('n','N',"name",name) && value && *value) {
2772       W_L(" name=\"");
2773       W_V(value);
2774       W_L("\"");
2775     }
2776     else if (STRCASEEQ('r','R',"rows",name) && value && *value) {
2777       W_L(" rows=\"");
2778       W_V(value);
2779       W_L("\"");
2780     }
2781     else if (STRCASEEQ('c','C',"cols",name) && value && *value) {
2782       W_L(" cols=\"");
2783       W_V(value);
2784       W_L("\"");
2785     }
2786     else if (STRCASEEQ('i','I',"istyle", name) && value && (*value == '1' || *value == '2' || *value == '3' || *value == '4')) {
2787       char *fmt = qs_conv_istyle_to_format(doc->r,value);
2788       W_L(" FORMAT=\"*");
2789       W_V(fmt);
2790       W_L("\"");
2791     }
2792     else if (STRCASEEQ('a','A',"accesskey",name) && value && *value != 0) {
2793       W_L(" accesskey=\"");
2794       W_V(value);
2795       W_L("\"");
2796     }
2797   }
2798   W_L(">");
2799   return xhtml->out;
2800 }
2801
2802
2803 /**
2804  * It is a handler who processes the TEXTAREA tag.
2805  *
2806  * @param pdoc  [i/o] The pointer to the CHTML structure at the output
2807  *                     destination is specified.
2808  * @param node   [i]   The TEXTAREA tag node is specified.
2809  * @return The conversion result is returned.
2810  */
2811 static char *
2812 s_xhtml_1_0_end_textarea_tag(void *pdoc, Node *UNUSED(child))
2813 {
2814   xhtml_t *xhtml = GET_XHTML(pdoc);
2815   Doc     *doc   = xhtml->doc;
2816
2817   W_L("</textarea>");
2818   xhtml->textarea_flag--;
2819
2820   return xhtml->out;
2821 }
2822
2823 static char *
2824 s_xhtml_1_0_text_tag(void *pdoc, Node *child)
2825 {
2826   xhtml_t     *xhtml   = GET_XHTML(pdoc);
2827   Doc         *doc     = xhtml->doc;
2828   request_rec *r       = doc->r;
2829   char        *textval;
2830   char        *tmp;
2831   char        *tdst;
2832   char        one_byte[2];
2833   int         ii;
2834   int         tdst_len;
2835
2836   textval = qs_get_node_value(doc,child);
2837   if (strlen(textval) == 0) {
2838     return xhtml->out;
2839   }
2840
2841   tmp = apr_palloc(r->pool, qs_get_node_size(doc,child)+1);
2842   memset(tmp, 0, qs_get_node_size(doc,child)+1);
2843
2844   tdst     = qs_alloc_zero_byte_string(doc->buf.pool);
2845   memset(one_byte, 0, sizeof(one_byte));
2846   tdst_len = 0;
2847
2848   for (ii=0; ii<qs_get_node_size(doc,child); ii++) {
2849     char *out;
2850     int rtn = s_xhtml_search_emoji(xhtml, &textval[ii], &out);
2851     if (rtn != 0) {
2852       DBG(r,"[%s][%d]", out, rtn);
2853       tdst = qs_out_apr_pstrcat(r, tdst, out, &tdst_len);
2854       ii+=(rtn - 1);
2855       continue;
2856     }
2857     if (is_sjis_kanji(textval[ii])) {
2858       one_byte[0] = textval[ii+0];
2859       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2860       one_byte[0] = textval[ii+1];
2861       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2862       ii++;
2863     }
2864     else if (xhtml->pre_flag) {
2865       one_byte[0] = textval[ii+0];
2866       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2867     }
2868     else if (xhtml->textarea_flag) {
2869       one_byte[0] = textval[ii+0];
2870       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2871     }
2872     else if (textval[ii] != '\r' && textval[ii] != '\n') {
2873       one_byte[0] = textval[ii+0];
2874       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2875     }
2876   }
2877   W_V(tdst);
2878   return xhtml->out;
2879 }
2880
2881
2882 /**
2883  * It is a handler who processes the BLOCKQUOTE tag.
2884  *
2885  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2886  *                     destination is specified.
2887  * @param node   [i]   The BLOCKQUOTE tag node is specified.
2888  * @return The conversion result is returned.
2889  */
2890 static char *
2891 s_xhtml_1_0_start_blockquote_tag(void *pdoc, Node *UNUSED(child))
2892 {
2893   xhtml_t *xhtml = GET_XHTML(pdoc);
2894   Doc     *doc   = xhtml->doc;
2895   W_L("<blockquote>");
2896   return xhtml->out;
2897 }
2898
2899
2900 /**
2901  * It is a handler who processes the BLOCKQUOTE tag.
2902  *
2903  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2904  *                     destination is specified.
2905  * @param node   [i]   The BLOCKQUOTE tag node is specified.
2906  * @return The conversion result is returned.
2907  */
2908 static char *
2909 s_xhtml_1_0_end_blockquote_tag(void *pdoc, Node *UNUSED(child))
2910 {
2911   xhtml_t *xhtml = GET_XHTML(pdoc);
2912   Doc     *doc   = xhtml->doc;
2913   W_L("</blockquote>");
2914   return xhtml->out;
2915 }
2916
2917
2918 /**
2919  * It is a handler who processes the DIR tag.
2920  *
2921  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2922  *                     destination is specified.
2923  * @param node   [i]   The DIR tag node is specified.
2924  * @return The conversion result is returned.
2925  */
2926 static char *
2927 s_xhtml_1_0_start_dir_tag(void *pdoc, Node *node)
2928 {
2929   xhtml_t *xhtml = GET_XHTML(pdoc);
2930   Doc     *doc = xhtml->doc;
2931   Attr      *attr;
2932   W_L("<dir");
2933   for (attr = qs_get_attr(doc,node);
2934        attr;
2935        attr = qs_get_next_attr(doc,attr)) {
2936     char *name   = qs_get_attr_name(doc,attr);
2937     char *value  = qs_get_attr_value(doc,attr);
2938     if (STRCASEEQ('t','T',"type",name)) {
2939       if (value && (STRCASEEQ('d','D',"disc",value) || STRCASEEQ('c','C',"circle",value) || STRCASEEQ('s','S',"square",value))) {
2940         W_L(" type=\"");
2941         W_V(value);
2942         W_L("\"");
2943       }
2944     }
2945   }
2946   W_L(">");
2947   return xhtml->out;
2948 }
2949
2950
2951 /**
2952  * It is a handler who processes the DIR tag.
2953  *
2954  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2955  *                     destination is specified.
2956  * @param node   [i]   The DIR tag node is specified.
2957  * @return The conversion result is returned.
2958  */
2959 static char *
2960 s_xhtml_1_0_end_dir_tag(void *pdoc, Node *UNUSED(child))
2961 {
2962   xhtml_t *xhtml = GET_XHTML(pdoc);
2963   Doc     *doc = xhtml->doc;
2964   W_L("</dir>");
2965   return xhtml->out;
2966 }
2967
2968
2969 /**
2970  * It is a handler who processes the DL tag.
2971  *
2972  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2973  *                     destination is specified.
2974  * @param node   [i]   The DL tag node is specified.
2975  * @return The conversion result is returned.
2976  */
2977 static char *
2978 s_xhtml_1_0_start_dl_tag(void *pdoc, Node *UNUSED(child))
2979 {
2980   xhtml_t *xhtml = GET_XHTML(pdoc);
2981   Doc *doc = xhtml->doc;
2982   W_L("<dl>");
2983   return xhtml->out;
2984 }
2985
2986
2987 /**
2988  * It is a handler who processes the DL tag.
2989  *
2990  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
2991  *                     destination is specified.
2992  * @param node   [i]   The DL tag node is specified.
2993  * @return The conversion result is returned.
2994  */
2995 static char *
2996 s_xhtml_1_0_end_dl_tag(void *pdoc, Node *UNUSED(child))
2997 {
2998   xhtml_t *xhtml = GET_XHTML(pdoc);
2999   Doc *doc = xhtml->doc;
3000   W_L("</dl>");
3001   return xhtml->out;
3002 }
3003
3004
3005 /**
3006  * It is a handter who processes the DT tag.
3007  *
3008  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3009  *                     destination is specified.
3010  * @param node   [i]   The DT tag node is specified.
3011  * @return The conversion result is returned.
3012  */
3013 static char *
3014 s_xhtml_1_0_start_dt_tag(void *pdoc, Node *UNUSED(child))
3015 {
3016   xhtml_t *xhtml = GET_XHTML(pdoc);
3017   Doc     *doc   = xhtml->doc;
3018   W_L("<dt>");
3019   return xhtml->out;
3020 }
3021
3022
3023 /**
3024  * It is a handter who processes the DT tag.
3025  *
3026  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3027  *                     destination is specified.
3028  * @param node   [i]   The DT tag node is specified.
3029  * @return The conversion result is returned.
3030  */
3031 static char *
3032 s_xhtml_1_0_end_dt_tag(void *pdoc, Node *UNUSED(child))
3033 {
3034   xhtml_t *xhtml = GET_XHTML(pdoc);
3035   Doc     *doc   = xhtml->doc;
3036   W_L("</dt>");
3037   return xhtml->out;
3038 }
3039
3040
3041 /**
3042  * It is a handder who processes the DD tag.
3043  *
3044  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3045  *                     destination is specified.
3046  * @param node   [i]   The DD tag node is specified.
3047  * @return The conversion result is returned.
3048  */
3049 static char *
3050 s_xhtml_1_0_start_dd_tag(void *pdoc, Node *UNUSED(child))
3051 {
3052   xhtml_t *xhtml = GET_XHTML(pdoc);
3053   Doc     *doc   = xhtml->doc;
3054   W_L("<dd>");
3055   return xhtml->out;
3056 }
3057
3058
3059 /**
3060  * It is a handder who processes the DD tag.
3061  *
3062  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3063  *                     destination is specified.
3064  * @param node   [i]   The DD tag node is specified.
3065  * @return The conversion result is returned.
3066  */
3067 static char *
3068 s_xhtml_1_0_end_dd_tag(void *pdoc, Node *UNUSED(child))
3069 {
3070   xhtml_t *xhtml = GET_XHTML(pdoc);
3071   Doc     *doc   = xhtml->doc;
3072   W_L("</dd>");
3073   return xhtml->out;
3074 }
3075
3076
3077 /**
3078  * It is a handler who processes the MENU tag.
3079  *
3080  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3081  *                     destination is specified.
3082  * @param node   [i]   The MENU tag node is specified.
3083  * @return The conversion result is returned.
3084  */
3085 static char *
3086 s_xhtml_1_0_start_menu_tag(void *pdoc, Node *node)
3087 {
3088   xhtml_t *xhtml = GET_XHTML(pdoc);
3089   Doc     *doc   = xhtml->doc;
3090   Attr    *attr;
3091   W_L("<menu");
3092   /*--------------------------------------------------------------------------*/
3093   /* Get Attributes                                                           */
3094   /*--------------------------------------------------------------------------*/
3095   for (attr = qs_get_attr(doc,node);
3096        attr;
3097        attr = qs_get_next_attr(doc,attr)) {
3098     char *name   = qs_get_attr_name(doc,attr);
3099     char *value  = qs_get_attr_value(doc,attr);
3100     if (STRCASEEQ('t','T',"type",name)) {
3101       if (value && (STRCASEEQ('d','D',"disc",value) || STRCASEEQ('c','C',"circle",value) || STRCASEEQ('s','S',"square",value))) {
3102         W_L(" type=\"");
3103         W_V(value);
3104         W_L("\"");
3105       }
3106     }
3107   }
3108   W_L(">");
3109   return xhtml->out;
3110 }
3111
3112
3113 /**
3114  * It is a hanmenuer who processes the MENU tag.
3115  *
3116  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3117  *                     destination is specified.
3118  * @param node   [i]   The MENU tag node is specified.
3119  * @return The conversion result is returned.
3120  */
3121 static char *
3122 s_xhtml_1_0_end_menu_tag(void *pdoc, Node *UNUSED(child))
3123 {
3124   xhtml_t *xhtml = GET_XHTML(pdoc);
3125   Doc *doc = xhtml->doc;
3126   W_L("</menu>");
3127   return xhtml->out;
3128 }
3129
3130
3131 /**
3132  * It is a handler who processes the PLAINTEXT tag.
3133  *
3134  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3135  *                     destination is specified.
3136  * @param node   [i]   The PLAINTEXT tag node is specified.
3137  * @return The conversion result is returned.
3138  */
3139 static char *
3140 s_xhtml_1_0_start_plaintext_tag(void *pdoc, Node *node)
3141 {
3142   xhtml_t *xhtml = GET_XHTML(pdoc);
3143   Doc     *doc     = xhtml->doc;
3144   W_L("<plaintext>");
3145   s_xhtml_1_0_start_plaintext_tag_inner(pdoc,node);
3146   return xhtml->out;
3147 }
3148
3149 static char *
3150 s_xhtml_1_0_start_plaintext_tag_inner(void *pdoc, Node *node)
3151 {
3152   xhtml_t *xhtml = GET_XHTML(pdoc);
3153   Doc     *doc     = xhtml->doc;
3154   Node    *child;
3155   for (child = qs_get_child_node(doc, node);
3156        child;
3157        child = qs_get_next_node(doc, child)) {
3158     W_V(child->otext);
3159     s_xhtml_1_0_start_plaintext_tag_inner(pdoc, child);
3160   }
3161   return xhtml->out;
3162 }
3163
3164
3165 /**
3166  * It is a handler who processes the PLAINTEXT tag.
3167  *
3168  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3169  *                     destination is specified.
3170  * @param node   [i]   The PLAINTEXT tag node is specified.
3171  * @return The conversion result is returned.
3172  */
3173 static char *
3174 s_xhtml_1_0_end_plaintext_tag(void *pdoc, Node *UNUSED(child))
3175 {
3176   xhtml_t *xhtml = GET_XHTML(pdoc);
3177   Doc     *doc     = xhtml->doc;
3178   W_L("</plaintext>");
3179   return xhtml->out;
3180 }
3181
3182
3183 /**
3184  * It is a hanblinker who processes the BLINK tag.
3185  *
3186  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3187  *                     destination is specified.
3188  * @param node   [i]   The BLINK tag node is specified.
3189  * @return The conversion result is returned.
3190  */
3191 static char *
3192 s_xhtml_1_0_start_blink_tag(void *pdoc, Node *UNUSED(child))
3193 {
3194   xhtml_t *xhtml = GET_XHTML(pdoc);
3195   Doc     *doc = xhtml->doc;
3196   W_L("<blink>");
3197   return xhtml->out;
3198 }
3199
3200
3201 /**
3202  * It is a hanblinker who processes the BLINK tag.
3203  *
3204  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3205  *                     destination is specified.
3206  * @param node   [i]   The BLINK tag node is specified.
3207  * @return The conversion result is returned.
3208  */
3209 static char *
3210 s_xhtml_1_0_end_blink_tag(void *pdoc, Node *UNUSED(child))
3211 {
3212   xhtml_t *xhtml = GET_XHTML(pdoc);
3213   Doc     *doc = xhtml->doc;
3214   W_L("</blink>");
3215   return xhtml->out;
3216 }
3217
3218
3219 /**
3220  * It is a handler who processes the MARQUEE tag.
3221  *
3222  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3223  *                     destination is specified.
3224  * @param node   [i]   The MARQUEE tag node is specified.
3225  * @return The conversion result is returned.
3226  */
3227 static char *
3228 s_xhtml_1_0_start_marquee_tag(void *pdoc, Node *node)
3229 {
3230   xhtml_t *xhtml = GET_XHTML(pdoc);
3231   Doc     *doc = xhtml->doc;
3232   Attr *attr;
3233   W_L("<marquee");
3234   /*--------------------------------------------------------------------------*/
3235   /* Get Attributes                                                           */
3236   /*--------------------------------------------------------------------------*/
3237   for (attr = qs_get_attr(doc,node);
3238        attr;
3239        attr = qs_get_next_attr(doc,attr)) {
3240     char *name   = qs_get_attr_name(doc,attr);
3241     char *value  = qs_get_attr_value(doc,attr);
3242     if (STRCASEEQ('d','D',"direction", name)) {
3243       if (value && (STRCASEEQ('l','L',"left",value) || STRCASEEQ('r','R',"right",value))) {
3244         W_L(" direction=\"");
3245         W_V(value);
3246         W_L("\"");
3247       }
3248     }
3249     else if (STRCASEEQ('b','B',"behavior",name)) {
3250       if (value && (STRCASEEQ('s','S',"scroll",value) || STRCASEEQ('s','S',"slide",value) || STRCASEEQ('a','A',"alternate",value))) {
3251         W_L(" behavior=\"");
3252         W_V(value);
3253         W_L("\"");
3254       }
3255     }
3256     else if (STRCASEEQ('l','L',"loop",name)) {
3257       if (value && *value) {
3258         W_L(" loop=\"");
3259         W_V(value);
3260         W_L("\"");
3261       }
3262     }
3263     else if (STRCASEEQ('b','B',"bgcolor",name)) {
3264       if (value && *value) {
3265         W_L(" bgcolor=\"");
3266         W_V(value);
3267         W_L("\"");
3268       }
3269     }
3270   }
3271   W_L(">");
3272   return xhtml->out;
3273 }
3274
3275
3276 /**
3277  * It is a handler who processes the MARQUEE tag.
3278  *
3279  * @param pdoc  [i/o] The pointer to the XHTML structure at the output
3280  *                     destination is specified.
3281  * @param node   [i]   The MARQUEE tag node is specified.
3282  * @return The conversion result is returned.
3283  */
3284 static char *
3285 s_xhtml_1_0_end_marquee_tag(void *pdoc, Node *UNUSED(child))
3286 {
3287   xhtml_t *xhtml = GET_XHTML(pdoc);
3288   Doc     *doc = xhtml->doc;
3289   W_L("</marquee>");
3290   return xhtml->out;
3291 }
3292
3293
3294 /**
3295  * It is handler who processes the New Line Code.
3296  */
3297 static char *
3298 s_xhtml_1_0_newline_mark(void *pdoc, Node *UNUSED(node))
3299 {
3300   xhtml_t *xhtml = GET_XHTML(pdoc);
3301   Doc *doc = xhtml->doc;
3302   W_NLCODE();
3303   return xhtml->out;
3304 }
3305 /*
3306  * vim:ts=2 et
3307  */