src/chxj_hdml.c

   1 /*
   2  * Copyright (C) 2005 QSDN,Inc. All rights reserved.
   3  * Copyright (C) 2005 Atsushi Konno 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 "chxj_hdml.h"
  18 #include "chxj_tag_util.h"
  19 #include "chxj_str_util.h"
  20 #include <unistd.h>
  21 #include "chxj_img_conv.h"
  22 #include "chxj_dump.h"
  23 #include "chxj_qr_code.h"
  24
  25 #define CHECK_BOX_PREFIX     "_chxj_c_"
  26 #define RADIO_BUTTON_PREFIX  "_chxj_r_"
  27 #define SUBMIT_BUTTON_PREFIX "_chxj_s_"
  28
  29 #define GET_HDML(X) ((hdml_t*)(X))
  30
  31 static void  s_init_hdml            (hdml_t* hdml, Doc* doc, request_rec* r, device_table* spec);
  32
  33
  34 static char* s_hdml_start_html_tag    (void* pdoc,  Node* node);
  35 static char* s_hdml_end_html_tag      (void* pdoc,  Node* node);
  36 static char* s_hdml_start_meta_tag    (void* pdoc,  Node* node);
  37 static char* s_hdml_end_meta_tag      (void* pdoc,  Node* node);
  38 static char* s_hdml_start_li_tag      (void* pdoc,  Node* node);
  39 static char* s_hdml_end_li_tag        (void* pdoc,  Node* node);
  40 static char* s_hdml_start_head_tag    (void* pdoc,  Node* node);
  41 static char* s_hdml_end_head_tag      (void* pdoc,  Node* node);
  42 static char* s_hdml_start_title_tag   (void* pdoc,  Node* node);
  43 static char* s_hdml_end_title_tag     (void* pdoc,  Node* node);
  44 static char* s_hdml_start_base_tag    (void* pdoc,  Node* node);
  45 static char* s_hdml_end_base_tag      (void* pdoc,  Node* node);
  46 static char* s_hdml_start_body_tag    (void* pdoc,  Node* node);
  47 static char* s_hdml_end_body_tag      (void* pdoc,  Node* node);
  48 static char* s_hdml_start_a_tag       (void* pdoc,  Node* node);
  49 static char* s_hdml_end_a_tag         (void* pdoc,  Node* node);
  50 static char* s_hdml_start_br_tag      (void* pdoc,  Node* node);
  51 static char* s_hdml_end_br_tag        (void* pdoc,  Node* node);
  52 static char* s_hdml_start_tr_tag      (void* pdoc,  Node* node);
  53 static char* s_hdml_end_tr_tag        (void* pdoc,  Node* node);
  54 static char* s_hdml_start_font_tag    (void* pdoc,  Node* node);
  55 static char* s_hdml_end_font_tag      (void* pdoc,  Node* node);
  56 static char* s_hdml_start_form_tag    (void* pdoc,  Node* node);
  57 static char* s_hdml_end_form_tag      (void* pdoc,  Node* node);
  58 static char* s_hdml_start_input_tag   (void* pdoc,  Node* node);
  59 static char* s_hdml_end_input_tag     (void* pdoc,  Node* node);
  60 static char* s_hdml_start_select_tag  (void* pdoc,  Node* node);
  61 static char* s_hdml_end_select_tag    (void* pdoc,  Node* node);
  62 static char* s_hdml_start_option_tag  (void* pdoc,  Node* node);
  63 static char* s_hdml_end_option_tag    (void* pdoc,  Node* node);
  64 static char* s_hdml_start_center_tag  (void* pdoc,  Node* node);
  65 static char* s_hdml_end_center_tag    (void* pdoc,  Node* node);
  66 static char* s_hdml_start_hr_tag      (void* pdoc,  Node* node);
  67 static char* s_hdml_end_hr_tag        (void* pdoc,  Node* node);
  68 static char* s_hdml_start_img_tag     (void* pdoc,  Node* node);
  69 static char* s_hdml_end_img_tag       (void* pdoc,  Node* node);
  70 static char* s_hdml_start_div_tag     (void* pdoc,  Node* node);
  71 static char* s_hdml_end_div_tag       (void* pdoc,  Node* node);
  72
  73 static char* s_get_form_no          (request_rec* r, hdml_t* hdml);
  74
  75 static void  s_hdml_count_radio_tag (hdml_t* hdml, Node* node) ;
  76
  77 static void  s_hdml_do_input_text_tag    (hdml_t* hdml, Node* tag);
  78 static void  s_hdml_do_input_password_tag(hdml_t* hdml, Node* tag);
  79 static void  s_hdml_do_input_submit_tag  (hdml_t* hdml, Node* tag);
  80 static void  s_hdml_do_input_hidden_tag  (hdml_t* hdml, Node* tag);
  81 static void  s_hdml_do_input_radio_tag   (hdml_t* hdml, Node* tag);
  82 static void  s_hdml_do_input_checkbox_tag(hdml_t* hdml, Node* tag);
  83 static void  s_hdml_tag_output_upper_half(hdml_t* hdml, Node* node);
  84
  85 static hdml_t* s_output_to_hdml_out       (hdml_t* hdml, char* s);
  86 static hdml_t* s_output_to_hdml_card      (hdml_t* hdml, char* s);
  87 static void  s_output_to_postdata         (hdml_t* hdml, char* s);
  88 static void  s_output_to_init_vars        (hdml_t* hdml, char* s);
  89 static int   s_hdml_search_emoji          (hdml_t* hdml, char* txt, char** rslt);
  90
  91 static char* s_hdml_chxjif_tag            (void* pdoc, Node* node);
  92 static char* s_hdml_text_tag              (void* pdoc, Node* node);
  93
  94
  95 tag_handler hdml_handler[] = {
  96   /* tagHTML */
  97   {
  98     s_hdml_start_html_tag,
  99     s_hdml_end_html_tag,
 100   },
 101   /* tagMETA */
 102   {
 103     s_hdml_start_meta_tag,
 104     s_hdml_end_meta_tag,
 105   },
 106   /* tagTEXTAREA */
 107   {
 108     NULL,
 109     NULL,
 110   },
 111   /* tagP */
 112   {
 113     NULL,
 114     NULL,
 115   },
 116   /* tagPRE */
 117   {
 118     NULL,
 119     NULL,
 120   },
 121   /* tagUL */
 122   {
 123     NULL,
 124     NULL,
 125   },
 126   /* tagLI */
 127   {
 128     s_hdml_start_li_tag,
 129     s_hdml_end_li_tag,
 130   },
 131   /* tagOL */
 132   {
 133     NULL,
 134     NULL,
 135   },
 136   /* tagH1 */
 137   {
 138     NULL,
 139     NULL,
 140   },
 141   /* tagH2 */
 142   {
 143     NULL,
 144     NULL,
 145   },
 146   /* tagH3 */
 147   {
 148     NULL,
 149     NULL,
 150   },
 151   /* tagH4 */
 152   {
 153     NULL,
 154     NULL,
 155   },
 156   /* tagH5 */
 157   {
 158     NULL,
 159     NULL,
 160   },
 161   /* tagH6 */
 162   {
 163     NULL,
 164     NULL,
 165   },
 166   /* tagHEAD */
 167   {
 168     s_hdml_start_head_tag,
 169     s_hdml_end_head_tag,
 170   },
 171   /* tagTITLE */
 172   {
 173     s_hdml_start_title_tag,
 174     s_hdml_end_title_tag,
 175   },
 176   /* tagBASE */
 177   {
 178     s_hdml_start_base_tag,
 179     s_hdml_end_base_tag,
 180   },
 181   /* tagBODY */
 182   {
 183     s_hdml_start_body_tag,
 184     s_hdml_end_body_tag,
 185   },
 186   /* tagA */
 187   {
 188     s_hdml_start_a_tag,
 189     s_hdml_end_a_tag,
 190   },
 191   /* tagBR */
 192   {
 193     s_hdml_start_br_tag,
 194     s_hdml_end_br_tag,
 195   },
 196   /* tagTABLE */
 197   {
 198     NULL,
 199     NULL,
 200   },
 201   /* tagTR */
 202   {
 203     s_hdml_start_tr_tag,
 204     s_hdml_end_tr_tag,
 205   },
 206   /* tagTD */
 207   {
 208     NULL,
 209     NULL,
 210   },
 211   /* tagTBODY */
 212   {
 213     NULL,
 214     NULL,
 215   },
 216   /* tagFONT */
 217   {
 218     s_hdml_start_font_tag,
 219     s_hdml_end_font_tag,
 220   },
 221   /* tagFORM */
 222   {
 223     s_hdml_start_form_tag,
 224     s_hdml_end_form_tag,
 225   },
 226   /* tagINPUT */
 227   {
 228     s_hdml_start_input_tag,
 229     s_hdml_end_input_tag,
 230   },
 231   /* tagCENTER */
 232   {
 233     s_hdml_start_center_tag,
 234     s_hdml_end_center_tag,
 235   },
 236   /* tagHR */
 237   {
 238     s_hdml_start_hr_tag,
 239     s_hdml_end_hr_tag,
 240   },
 241   /* tagIMG */
 242   {
 243     s_hdml_start_img_tag,
 244     s_hdml_end_img_tag,
 245   },
 246   /* tagSELECT */
 247   {
 248     s_hdml_start_select_tag,
 249     s_hdml_end_select_tag,
 250   },
 251   /* tagOPTION */
 252   {
 253     s_hdml_start_option_tag,
 254     s_hdml_end_option_tag,
 255   },
 256   /* tagDIV */
 257   {
 258     s_hdml_start_div_tag,
 259     s_hdml_end_div_tag,
 260   },
 261   /* tagCHXJIF */
 262   {
 263     s_hdml_chxjif_tag,
 264     NULL,
 265   },
 266   /* tagNOBR */
 267   {
 268     NULL,
 269     NULL,
 270   },
 271   /* tagSMALL */
 272   {
 273     NULL,
 274     NULL,
 275   },
 276   /* tagSTYLE */
 277   {
 278     NULL,
 279     NULL,
 280   },
 281   /* tagSPAN */
 282   {
 283     NULL,
 284     NULL,
 285   },
 286   /* tagTEXT */
 287   {
 288     s_hdml_text_tag,
 289     NULL,
 290   },
 291   /* tagTH */
 292   {
 293     NULL,
 294     NULL,
 295   },
 296   /* tagB */
 297   {
 298     NULL,
 299     NULL,
 300   },
 301   /* tagFIELDSET */
 302   {
 303     NULL,
 304     NULL,
 305   },
 306 };
 307
 308 /**
 309  * converts from CHTML to hdml.
 310  *
 311  * @param r    [i] Requet_rec is appointed.
 312  * @param spec [i] The result of the device specification processing which
 313  *                 was done in advance is appointed.
 314  * @param src  [i] The character string before the converting is appointed.
 315  * @return         The character string after the converting is returned.
 316  */
 317 char*
 318 chxj_exchange_hdml(
 319   request_rec* r,
 320   device_table* spec,
 321   const char* src,
 322   apr_size_t srclen,
 323   apr_size_t* dstlen,
 324   chxjconvrule_entry* entryp,
 325   cookie_t* cookie
 326 )
 327 {
 328   char*     dst;
 329   char*     buf;
 330   Doc       doc;
 331   hdml_t    hdml;
 332
 333   dst = NULL;
 334   buf = NULL;
 335
 336   /*--------------------------------------------------------------------------*/
 337   /* If qrcode xml                                                            */
 338   /*--------------------------------------------------------------------------*/
 339   *dstlen = srclen;
 340   dst = chxj_qr_code_blob_handler(r, src, (size_t*)dstlen);
 341   if (dst) {
 342     DBG(r,"i found qrcode xml");
 343     return dst;
 344   }
 345   DBG(r,"not found qrcode xml");
 346
 347   /*--------------------------------------------------------------------------*/
 348   /* initialize hdml structure                                                */
 349   /*--------------------------------------------------------------------------*/
 350   s_init_hdml(&hdml,&doc,r, spec);
 351
 352   hdml.entryp = entryp;
 353
 354   ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
 355   /*--------------------------------------------------------------------------*/
 356   /* DEBUG                                                                    */
 357   /*--------------------------------------------------------------------------*/
 358 #ifdef DUMP_LOG
 359   chxj_dump_out("[src] CHTML->HDML", src, srclen);
 360 #endif
 361
 362
 363   /*--------------------------------------------------------------------------*/
 364   /* It is examined whether there is a location header. It ends without doing */
 365   /* anything when is.                                                        */
 366   /*--------------------------------------------------------------------------*/
 367   buf = (char*)apr_table_get(r->headers_out, (const char*)"Location");
 368   if (buf) {
 369     /*------------------------------------------------------------------------*/
 370     /* The Location header generates tag in an initial HDML machine for the   */
 371     /* uncorrespon dence.                                                     */
 372     /*------------------------------------------------------------------------*/
 373     DBG1(r, "Location is not null[Location:%s]", buf);
 374     s_output_to_hdml_out(&hdml,
 375         "<HDML VERSION=3.0 MARKABLE=TRUE PUBLIC=TRUE>\n"
 376         "<NODISPLAY MARKABLE=TRUE PUBLIC=TRUE TITLE=\" \">\n"
 377         "<ACTION TYPE=ACCEPT TASK=GO DEST=\""
 378         );
 379     s_output_to_hdml_out(&hdml, buf);
 380     s_output_to_hdml_out(&hdml,
 381         "\">\n"
 382         "</NODISPLAY>\n"
 383         "</HDML>\n"
 384         );
 385     dst = apr_pstrdup(r->pool, hdml.out);
 386   }
 387   else {
 388     /*------------------------------------------------------------------------*/
 389     /* Here, the parsing of the received character string is done             */
 390     /*------------------------------------------------------------------------*/
 391     char *ss = apr_pstrdup(r->pool, src);
 392
 393     DBG1(r, "input srclen=[%d]\n", srclen);
 394
 395     qs_init_malloc(&doc);
 396     qs_init_root_node(&doc);
 397     ss[srclen] = '\0';
 398     qs_parse_string(&doc, ss, srclen);
 399
 400     /*------------------------------------------------------------------------*/
 401     /* The number of radiobuttons is counted.                                 */
 402     /*------------------------------------------------------------------------*/
 403     s_hdml_count_radio_tag(&hdml, qs_get_root(&doc));
 404
 405     chxj_node_exchange(spec,r,(void*)&hdml, &doc, qs_get_root(&doc), 0);
 406     dst = hdml.out;
 407
 408     DBG1(r,"tmp=[%s]", dst);
 409     qs_all_free(&doc,QX_LOGMARK);
 410   }
 411
 412   /*--------------------------------------------------------------------------*/
 413   /* DEBUG                                                                    */
 414   /*--------------------------------------------------------------------------*/
 415 #ifdef DUMP_LOG
 416   chxj_dump_out("[dst] CHTML->HDML", hdml.out, hdml.out_len);
 417 #endif
 418
 419   /*--------------------------------------------------------------------------*/
 420   /* When there is no processing result, former character string is copied    */
 421   /* and it returns it.                                                       */
 422   /*--------------------------------------------------------------------------*/
 423   if (!dst) {
 424     *dstlen = srclen;
 425     return apr_pstrdup(r->pool,src);
 426   }
 427
 428   *dstlen = hdml.out_len;
 429
 430   /*--------------------------------------------------------------------------*/
 431   /* Null is set at the end of the character string to make sure.             */
 432   /*--------------------------------------------------------------------------*/
 433   dst[hdml.out_len] = 0;
 434
 435   return dst;
 436 }
 437
 438
 439 /**
 440  * The HDML structure is initialized.
 441  *
 442  * @param hdml [i/o] The pointer to the HDML structure that wants to be
 443  *                   initialized is specified.
 444  * @param doc  [i]   The Doc structure that should be set to the initialized
 445  *                   HDML structure is specified.
 446  * @param r    [i]   To use POOL, the pointer to request_rec is specified.
 447  * @param spec [i]   The pointer to the device_table
 448  */
 449 static void
 450 s_init_hdml(hdml_t* hdml, Doc* doc, request_rec* r, device_table* spec)
 451 {
 452   int     ii;
 453   int     jj;
 454
 455   /*--------------------------------------------------------------------------*/
 456   /* init hdml structure value                                                */
 457   /*--------------------------------------------------------------------------*/
 458   memset(hdml, 0, sizeof(hdml_t));
 459   hdml->doc      = doc;
 460   hdml->card     = qs_alloc_zero_byte_string(r);
 461   hdml->spec     = spec;
 462   hdml->conf     = ap_get_module_config(r->per_dir_config, &chxj_module);
 463   hdml->doc->parse_mode = PARSE_MODE_CHTML;
 464
 465   for (ii=0; ii<MAX_FORM_COUNT; ii++) {
 466     hdml->var_cnt[ii]     = 0;
 467     hdml->postdata[ii]    = qs_alloc_zero_byte_string(r);
 468   }
 469
 470   for (ii=0; ii<MAX_RADIO_COUNT; ii++) {
 471     for (jj=0; jj<MAX_RADIO_VALUE_COUNT; jj++)
 472       hdml->radio_value_list[ii][jj] = NULL;
 473
 474     hdml->radio_name_list[ii]     = NULL;
 475     hdml->radio_out_cnt[ii]       = 0;
 476     hdml->radio_checked_value[ii] = NULL;
 477   }
 478
 479   for (ii=0; ii<MAX_SUBMIT_BUTTON_COUNT; ii++)
 480     hdml->submit_button[ii] = NULL;
 481
 482   hdml->init_vars      = qs_alloc_zero_byte_string(r);
 483
 484   doc->r               = r;
 485
 486   hdml->form_cnt = apr_time_now();
 487   hdml->out = qs_alloc_zero_byte_string(r);
 488 }
 489
 490
 491 static int
 492 s_hdml_search_emoji(hdml_t* hdml, char* txt, char** rslt)
 493 {
 494   emoji_t*      ee;
 495   request_rec*  r;
 496   device_table* spec;
 497   int           len;
 498
 499   spec = hdml->spec;
 500
 501   len = strlen(txt);
 502   r = hdml->doc->r;
 503
 504   if (!spec)
 505     DBG(r,"spec is NULL");
 506
 507   for (ee = hdml->conf->emoji;
 508        ee;
 509        ee = ee->next) {
 510
 511     unsigned char hex1byte;
 512     unsigned char hex2byte;
 513
 514     if (! ee->imode) {
 515       DBG(r, "emoji->imode is NULL");
 516       continue;
 517     }
 518
 519     hex1byte = ee->imode->hex1byte & 0xff;
 520     hex2byte = ee->imode->hex2byte & 0xff;
 521
 522     if (ee->imode->string
 523     &&  strlen(ee->imode->string) > 0
 524     &&  strncasecmp(ee->imode->string, txt, strlen(ee->imode->string)) == 0) {
 525       if (spec == NULL || spec->emoji_type == NULL) {
 526         *rslt = apr_psprintf(r->pool,
 527                         "<IMG ICON=%s>",
 528                         ee->ezweb->typeA);
 529         return strlen(ee->imode->string);
 530       }
 531
 532       if (strcasecmp(hdml->spec->emoji_type, "a") == 0) {
 533         *rslt = apr_psprintf(r->pool,
 534                         "<IMG ICON=%s>",
 535                         ee->ezweb->typeA);
 536         return strlen(ee->imode->string);
 537       }
 538       else
 539       if (strcasecmp(hdml->spec->emoji_type, "b") == 0) {
 540         *rslt = apr_psprintf(r->pool,
 541                         "<IMG ICON=%s>",
 542                         ee->ezweb->typeB);
 543         return strlen(ee->imode->string);
 544       }
 545       else
 546       if (strcasecmp(hdml->spec->emoji_type, "c") == 0) {
 547         *rslt = apr_psprintf(r->pool,
 548                         "<IMG ICON=%s>",
 549                         ee->ezweb->typeC);
 550         return strlen(ee->imode->string);
 551       }
 552       else
 553       if (strcasecmp(hdml->spec->emoji_type, "d") == 0) {
 554         *rslt = apr_psprintf(r->pool,
 555                         "<IMG ICON=%s>",
 556                         ee->ezweb->typeD);
 557         return strlen(ee->imode->string);
 558       }
 559       else {
 560         *rslt = apr_psprintf(r->pool,
 561                         "<IMG ICON=%s>",
 562                         ee->ezweb->typeA);
 563         return strlen(ee->imode->string);
 564       }
 565       return 0;
 566     }
 567     if (len >= 2
 568     && ((unsigned char)txt[0] & 0xff) == ((unsigned char)hex1byte)
 569     && ((unsigned char)txt[1] & 0xff) == ((unsigned char)hex2byte)) {
 570       if (spec == NULL || spec->emoji_type == NULL) {
 571         *rslt = apr_psprintf(r->pool,
 572                         "<IMG ICON=%s>",
 573                         ee->ezweb->typeA);
 574         return 2;
 575       }
 576
 577       if (strcasecmp(hdml->spec->emoji_type, "a") == 0) {
 578         *rslt = apr_psprintf(r->pool,
 579                         "<IMG ICON=%s>",
 580                         ee->ezweb->typeA);
 581         return 2;
 582       }
 583       else
 584       if (strcasecmp(hdml->spec->emoji_type, "b") == 0) {
 585         *rslt = apr_psprintf(r->pool,
 586                         "<IMG ICON=%s>",
 587                         ee->ezweb->typeB);
 588         return 2;
 589       }
 590       else
 591       if (strcasecmp(hdml->spec->emoji_type, "c") == 0) {
 592         *rslt = apr_psprintf(r->pool,
 593                         "<IMG ICON=%s>",
 594                         ee->ezweb->typeC);
 595         return 2;
 596       }
 597       else
 598       if (strcasecmp(hdml->spec->emoji_type, "d") == 0) {
 599         *rslt = apr_psprintf(r->pool,
 600                         "<IMG ICON=%s>",
 601                         ee->ezweb->typeD);
 602         return 2;
 603       }
 604       else {
 605         *rslt = apr_psprintf(r->pool,
 606                         "<IMG ICON=%s>",
 607                         ee->ezweb->typeA);
 608         return 2;
 609       }
 610       return 0;
 611     }
 612   }
 613   return 0;
 614 }
 615
 616
 617 /**
 618  * It is a handler who processes the HTML tag.
 619  *
 620  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 621  *                     destination is specified.
 622  * @param node   [i]   The HTML tag node is specified.
 623  * @return The conversion result is returned.
 624  */
 625 static char*
 626 s_hdml_start_html_tag(void* pdoc, Node* node)
 627 {
 628   hdml_t* hdml;
 629
 630   hdml = GET_HDML(pdoc);
 631
 632   s_output_to_hdml_out(hdml,
 633     "<HDML VERSION=3.0 TTL=0 MARKABLE=TRUE>\n"
 634     "<NODISPLAY NAME=D0>\n"
 635     "<ACTION TYPE=ACCEPT TASK=GOSUB DEST=#D1 NEXT=#D2 CLEAR=TRUE>\n"
 636     "</NODISPLAY>\n"
 637     );
 638
 639   hdml->card_cnt = 2;
 640   hdml->hdml_br_flag = 0;
 641
 642   return hdml->out;
 643 }
 644
 645
 646 /**
 647  * It is a handler who processes the HTML tag.
 648  *
 649  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 650  *                     destination is specified.
 651  * @param node   [i]   The HTML tag node is specified.
 652  * @return The conversion result is returned.
 653  */
 654 static char*
 655 s_hdml_end_html_tag(void* pdoc, Node* child)
 656 {
 657   hdml_t* hdml;
 658
 659   hdml = GET_HDML(pdoc);
 660
 661   s_output_to_hdml_card(hdml,
 662                   "<NODISPLAY NAME=D1>\n"
 663                   "<ACTION TYPE=ACCEPT TASK=RETURN VARS=\""
 664                   );
 665
 666   if (strlen(hdml->init_vars))
 667     s_output_to_hdml_card(hdml, hdml->init_vars   );
 668   else
 669     s_output_to_hdml_card(hdml, "_chxj_dmy="            );
 670
 671   s_output_to_hdml_card(hdml,
 672                   "\" CLEAR=TRUE>\n"
 673                   "</NODISPLAY>\n"
 674                   );
 675
 676   s_output_to_hdml_out(hdml, hdml->card );
 677   s_output_to_hdml_out(hdml, "</HDML>\n");
 678
 679   hdml->hdml_end_flag = 1;
 680
 681   return hdml->out;
 682 }
 683
 684
 685 /**
 686  * It is a handler who processes the META tag.
 687  *
 688  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 689  *                     destination is specified.
 690  * @param node   [i]   The META tag node is specified.
 691  * @return The conversion result is returned.
 692  */
 693 static char*
 694 s_hdml_start_meta_tag(void* pdoc, Node* node)
 695 {
 696   hdml_t* hdml;
 697
 698   hdml = GET_HDML(pdoc);
 699
 700   hdml->hdml_br_flag = 0;
 701
 702   /* ignore */
 703
 704   return hdml->out;
 705 }
 706
 707
 708 /**
 709  * It is a handler who processes the META tag.
 710  *
 711  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 712  *                     destination is specified.
 713  * @param node   [i]   The META tag node is specified.
 714  * @return The conversion result is returned.
 715  */
 716 static char*
 717 s_hdml_end_meta_tag(void* pdoc, Node* child)
 718 {
 719   hdml_t* hdml;
 720
 721   hdml = GET_HDML(pdoc);
 722
 723   return hdml->out;
 724 }
 725
 726
 727 /**
 728  * It is a handler who processes the HEAD tag.
 729  *
 730  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 731  *                     destination is specified.
 732  * @param node   [i]   The HEAD tag node is specified.
 733  * @return The conversion result is returned.
 734  */
 735 static char*
 736 s_hdml_start_head_tag(void* pdoc, Node* node)
 737 {
 738   hdml_t* hdml;
 739
 740   hdml = GET_HDML(pdoc);
 741
 742   /* ignore */
 743
 744   hdml->hdml_br_flag = 0;
 745
 746   return hdml->out;
 747 }
 748
 749
 750 /**
 751  * It is a handler who processes the HEAD tag.
 752  *
 753  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 754  *                     destination is specified.
 755  * @param node   [i]   The HEAD tag node is specified.
 756  * @return The conversion result is returned.
 757  */
 758 static char*
 759 s_hdml_end_head_tag(void* pdoc, Node* child)
 760 {
 761   hdml_t* hdml;
 762
 763   hdml = GET_HDML(pdoc);
 764   /* ignore */
 765
 766   return hdml->out;
 767 }
 768
 769
 770 /**
 771  * It is a handler who processes the TITLE tag.
 772  *
 773  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 774  *                     destination is specified.
 775  * @param node   [i]   The TITLE tag node is specified.
 776  * @return The conversion result is returned.
 777  */
 778 static char*
 779 s_hdml_start_title_tag(void* pdoc, Node* node)
 780 {
 781   hdml_t* hdml;
 782
 783   hdml = GET_HDML(pdoc);
 784
 785   s_output_to_hdml_out(hdml, "<DISPLAY NAME=D2 TITLE=\"");
 786
 787   hdml->found_title = 1;
 788   hdml->hdml_br_flag = 0;
 789
 790   return hdml->out;
 791 }
 792
 793
 794 /**
 795  * It is a handler who processes the TITLE tag.
 796  *
 797  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 798  *                     destination is specified.
 799  * @param node   [i]   The TITLE tag node is specified.
 800  * @return The conversion result is returned.
 801  */
 802 static char*
 803 s_hdml_end_title_tag(void* pdoc, Node* child)
 804 {
 805   hdml_t* hdml;
 806
 807   hdml = GET_HDML(pdoc);
 808
 809   s_output_to_hdml_out(hdml, "\">\n");
 810
 811   return hdml->out;
 812 }
 813
 814
 815 /**
 816  * It is a handler who processes the BASE tag.
 817  *
 818  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 819  *                     destination is specified.
 820  * @param node   [i]   The BASE tag node is specified.
 821  * @return The conversion result is returned.
 822  */
 823 static char*
 824 s_hdml_start_base_tag(void* pdoc, Node* node)
 825 {
 826   hdml_t* hdml;
 827
 828   hdml = GET_HDML(pdoc);
 829
 830   hdml->hdml_br_flag = 0;
 831
 832   return hdml->out;
 833 }
 834
 835
 836 /**
 837  * It is a handler who processes the BASE tag.
 838  *
 839  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 840  *                     destination is specified.
 841  * @param node   [i]   The BASE tag node is specified.
 842  * @return The conversion result is returned.
 843  */
 844 static char*
 845 s_hdml_end_base_tag(void* pdoc, Node* child)
 846 {
 847   hdml_t* hdml;
 848
 849   hdml = GET_HDML(pdoc);
 850
 851   return hdml->out;
 852 }
 853
 854
 855 /**
 856  * It is a handler who processes the BODY tag.
 857  *
 858  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 859  *                     destination is specified.
 860  * @param node   [i]   The BODY tag node is specified.
 861  * @return The conversion result is returned.
 862  */
 863 static char*
 864 s_hdml_start_body_tag(void* pdoc, Node* node)
 865 {
 866   hdml_t*      hdml;
 867   Doc*         doc;
 868   Attr*        attr;
 869
 870   hdml = GET_HDML(pdoc);
 871
 872   doc  = hdml->doc;
 873
 874   if (hdml->found_title == 0)
 875     s_output_to_hdml_out(hdml, "<DISPLAY NAME=D2 TITLE=\"NO TITLE\">\n");
 876
 877   s_output_to_hdml_out(hdml, "<ACTION TYPE=ACCEPT TASK=NOOP LABEL=\" \"");
 878
 879   /*--------------------------------*/
 880   /* Get Attributes                 */
 881   /*--------------------------------*/
 882   for (attr = qs_get_attr(doc,node);
 883     attr;
 884     attr = qs_get_next_attr(doc,attr)) {
 885
 886     char* name;
 887
 888     name  = qs_get_attr_name(doc,attr);
 889
 890     if ((*name == 'b' || *name == 'B') && strcasecmp(name, "bgcolor")     == 0) {
 891       /* ignore */
 892     }
 893     else
 894     if ((*name == 't' || *name == 'T') && strcasecmp(name, "text")   == 0) {
 895       /* ignore */
 896     }
 897     else
 898     if ((*name == 'l' || *name == 'L') && strcasecmp(name, "link")   == 0) {
 899       /* ignore */
 900     }
 901     else
 902     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "alink")  == 0) {
 903       /* ignore */
 904     }
 905     else
 906     if ((*name == 'v' || *name == 'V') && strcasecmp(name, "vlink")  == 0) {
 907       /* ignore */
 908     }
 909   }
 910
 911   s_output_to_hdml_out(hdml, ">\n");
 912
 913   hdml->hdml_br_flag = 0;
 914
 915   return hdml->out;
 916 }
 917
 918
 919 /**
 920  * It is a handler who processes the BODY tag.
 921  *
 922  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 923  *                     destination is specified.
 924  * @param node   [i]   The BODY tag node is specified.
 925  * @return The conversion result is returned.
 926  */
 927 static char*
 928 s_hdml_end_body_tag(void* pdoc, Node* child)
 929 {
 930   hdml_t* hdml;
 931
 932   hdml = GET_HDML(pdoc);
 933
 934   s_output_to_hdml_out(hdml, "\n</DISPLAY>\n");
 935
 936   return hdml->out;
 937 }
 938
 939
 940 /**
 941  * It is a handler who processes the A tag.
 942  *
 943  * @param pdoc   [i/o] The pointer to the HDML structure at the output
 944  *                     destination is specified.
 945  * @param node   [i]   The A tag node is specified.
 946  * @return The conversion result is returned.
 947  */
 948 static char*
 949 s_hdml_start_a_tag(void* pdoc, Node* node)
 950 {
 951   hdml_t*      hdml;
 952   Doc*         doc;
 953   Attr*        attr;
 954
 955   hdml = GET_HDML(pdoc);
 956   doc  = hdml->doc;
 957
 958   s_hdml_tag_output_upper_half(hdml,node);
 959
 960   s_output_to_hdml_out(hdml, "<A");
 961
 962
 963   /*------------------------------------*/
 964   /* Get Attributes                     */
 965   /*------------------------------------*/
 966   for (attr = qs_get_attr(doc,node);
 967        attr;
 968        attr = qs_get_next_attr(doc,attr)) {
 969
 970     char* name;
 971     char* value;
 972
 973     name  = qs_get_attr_name(doc,attr);
 974     value = qs_get_attr_value(doc,attr);
 975
 976     if ((*name == 'n' || *name == 'N') && strcasecmp(name, "name") == 0) {
 977       /* IGNORE */
 978     }
 979     else
 980     if ((*name == 'h' || *name == 'H') && strcasecmp(name, "href") == 0) {
 981       if ((*value == 'm' || *value == 'M') && strncasecmp(value, "mailto:", 7) == 0) {
 982         s_output_to_hdml_out(hdml, " TASK=GO DEST=\""     );
 983         s_output_to_hdml_out(hdml, value                  );
 984         s_output_to_hdml_out(hdml, "\" "                  );
 985       }
 986       else
 987       if ((*value == 't' || *value == 'T') && strncasecmp(value, "tel:", 4) == 0) {
 988
 989         s_output_to_hdml_out(hdml,  " TASK=CALL NUMBER=\"");
 990         s_output_to_hdml_out(hdml, &value[4]              );
 991         s_output_to_hdml_out(hdml, "\" "                  );
 992       }
 993       else {
 994         s_output_to_hdml_out(hdml, " TASK=GO DEST=\""     );
 995         s_output_to_hdml_out(hdml, value                  );
 996         s_output_to_hdml_out(hdml, "\""                   );
 997       }
 998     }
 999     else
1000     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "accesskey") == 0) {
1001       if (strcasecmp(value, "0") != 0) {
1002         s_output_to_hdml_out(hdml, " ACCESSKEY="          );
1003         s_output_to_hdml_out(hdml, value                  );
1004         s_output_to_hdml_out(hdml, ""                     );
1005       }
1006     }
1007     else
1008     if ((*name == 'c' || *name == 'C') && strcasecmp(name, "cti") == 0) {
1009       /* ignore */
1010     }
1011     else
1012     if ((*name == 'i' || *name == 'I') && strcasecmp(name, "ijam") == 0) {
1013       /* ignore */
1014     }
1015     else
1016     if ((*name == 'u' || *name == 'U') && strcasecmp(name, "utn") == 0) {
1017       /* ignore */
1018     }
1019     else
1020     if ((*name == 't' || *name == 'T') && strcasecmp(name, "telbook") == 0) {
1021       /* ignore */
1022     }
1023     else
1024     if ((*name == 'k' || *name == 'K') && strcasecmp(name, "kana") == 0) {
1025       /* ignore */
1026     }
1027     else
1028     if ((*name == 'e' || *name == 'E') && strcasecmp(name, "email") == 0) {
1029       /* ignore */
1030     }
1031     else
1032     if ((*name == 'i' || *name == 'I') && strcasecmp(name, "ista") == 0) {
1033       /* ignore */
1034     }
1035     else
1036     if ((*name == 'i' || *name == 'I') && strcasecmp(name, "ilet") == 0) {
1037       /* ignore */
1038     }
1039     else
1040     if ((*name == 'i' || *name == 'I') && strcasecmp(name, "iswf") == 0) {
1041       /* ignore */
1042     }
1043     else
1044     if ((*name == 'i' || *name == 'I') && strcasecmp(name, "irst") == 0) {
1045       /* ignore */
1046     }
1047   }
1048   s_output_to_hdml_out(hdml, ">"  );
1049
1050   hdml->hdml_a_flag = 1;
1051
1052   hdml->hdml_br_flag = 0;
1053
1054   return hdml->out;
1055 }
1056
1057
1058 /**
1059  * It is a handler who processes the A tag.
1060  *
1061  * @param pdoc   [i/o] The pointer to the HDML structure at the output
1062  *                     destination is specified.
1063  * @param node   [i]   The A tag node is specified.
1064  * @return The conversion result is returned.
1065  */
1066 static char*
1067 s_hdml_end_a_tag(void* pdoc, Node* child)
1068 {
1069   hdml_t* hdml;
1070
1071   hdml = GET_HDML(pdoc);
1072
1073   s_output_to_hdml_out(hdml, "</A>\n");
1074
1075   hdml->hdml_a_flag = 0;
1076
1077   return hdml->out;
1078 }
1079
1080
1081 /**
1082  * It is a handler who processes the BR tag.
1083  *
1084  * @param pdoc   [i/o] The pointer to the HDML structure at the output
1085  *                     destination is specified.
1086  * @param node   [i]   The BR tag node is specified.
1087  * @return The conversion result is returned.
1088  */
1089 static char*
1090 s_hdml_start_br_tag(void* pdoc, Node* node)
1091 {
1092   hdml_t* hdml;
1093
1094   hdml = GET_HDML(pdoc);
1095
1096   if (hdml->in_center > 0)
1097     hdml->in_center = 0;
1098
1099   if (hdml->div_in_center > 0)
1100     hdml->div_in_center = 0;
1101
1102   s_output_to_hdml_out(hdml, "<BR>\n");
1103
1104   hdml->hdml_br_flag = 1;
1105
1106   return hdml->out;
1107 }
1108
1109
1110 /**
1111  * It is a handler who processes the BR tag.
1112  *
1113  * @param pdoc   [i/o] The pointer to the HDML structure at the output
1114  *                     destination is specified.
1115  * @param node   [i]   The BR tag node is specified.
1116  * @return The conversion result is returned.
1117  */
1118 static char*
1119 s_hdml_end_br_tag(void* pdoc, Node* child)
1120 {
1121   hdml_t* hdml;
1122
1123   hdml = GET_HDML(pdoc);
1124
1125   return hdml->out;
1126 }
1127
1128
1129 /**
1130  * It is a handler who processes the TR tag.
1131  *
1132  * @param pdoc   [i/o] The pointer to the HDML structure at the output
1133  *                     destination is specified.
1134  * @param node   [i]   The TR tag node is specified.
1135  * @return The conversion result is returned.
1136  */
1137 static char*
1138 s_hdml_start_tr_tag(void* pdoc, Node* node)
1139 {
1140   hdml_t* hdml;
1141
1142   hdml = GET_HDML(pdoc);
1143
1144   if (hdml->in_center > 0)
1145     hdml->in_center = 0;
1146
1147   if (hdml->div_in_center > 0)
1148     hdml->div_in_center = 0;
1149
1150   s_output_to_hdml_out(hdml, "<BR>\n");
1151
1152   hdml->hdml_br_flag = 1;
1153
1154   return hdml->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 HDML 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_hdml_end_tr_tag(void* pdoc, Node* child)
1168 {
1169   hdml_t* hdml;
1170
1171   hdml = GET_HDML(pdoc);
1172
1173   return hdml->out;
1174 }
1175
1176
1177 /**
1178  * It is a handler who processes the FONT tag.
1179  *
1180  * @param pdoc   [i/o] The pointer to the HDML structure at the output
1181  *                     destination is specified.
1182  * @param node   [i]   The FONT tag node is specified.
1183  * @return The conversion result is returned.
1184  */
1185 static char*
1186 s_hdml_start_font_tag(void* pdoc, Node* node)
1187 {
1188   hdml_t* hdml;
1189
1190   hdml = GET_HDML(pdoc);
1191
1192   return hdml->out;
1193 }
1194
1195
1196 /**
1197  * It is a handler who processes the FONT tag.
1198  *
1199  * @param pdoc   [i/o] The pointer to the HDML structure at the output
1200  *                     destination is specified.
1201  * @param node   [i]   The FONT tag node is specified.
1202  * @return The conversion result is returned.
1203  */
1204 static char*
1205 s_hdml_end_font_tag(void* pdoc, Node* child)
1206 {
1207   hdml_t* hdml;
1208
1209   hdml = GET_HDML(pdoc);
1210
1211   return hdml->out;
1212 }
1213
1214
1215 /**
1216  * It is a handler who processes the FORM tag.
1217  *
1218  * @param pdoc   [i/o] The pointer to the HDML structure at the output
1219  *                     destination is specified.
1220  * @param node   [i]   The FORM tag node is specified.
1221  * @return The conversion result is returned.
1222  */
1223 static char*
1224 s_hdml_start_form_tag(void* pdoc, Node* node)
1225 {
1226   hdml_t*      hdml;
1227   request_rec* r;
1228   Attr*        attr;
1229   Doc*         doc;
1230   char*        act;
1231
1232   hdml = GET_HDML(pdoc);
1233   doc  = hdml->doc;
1234   r    = hdml->doc->r;
1235   act  = NULL;
1236
1237   hdml->form_tmp = apr_psprintf(r->pool,
1238                   "<NODISPLAY NAME=F%d>\n",
1239                   hdml->pure_form_cnt);
1240   hdml->form_tmp = apr_pstrcat(r->pool,
1241                            hdml->form_tmp,
1242                            "<ACTION TYPE=ACCEPT TASK=GO METHOD=POST DEST=\"",NULL);
1243   /* Get Attributes */
1244   for (attr = qs_get_attr(doc,node);
1245        attr;
1246        attr = qs_get_next_attr(doc,attr)) {
1247
1248     char* name;
1249     char* value;
1250
1251     name  = qs_get_attr_name(doc,attr);
1252     value = qs_get_attr_value(doc,attr);
1253
1254     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "action") == 0) {
1255       act = apr_psprintf(r->pool, "%s", value);
1256       break;
1257     }
1258   }
1259
1260   if (act) {
1261     hdml->form_tmp = apr_pstrcat(r->pool,
1262                                  hdml->form_tmp,
1263                                  act,
1264                                  NULL);
1265   }
1266   hdml->form_tmp = apr_pstrcat(r->pool,
1267                                hdml->form_tmp,
1268                                "\" ",
1269                                NULL);
1270   hdml->form_tmp = apr_pstrcat(r->pool,
1271                                hdml->form_tmp,
1272                                "POSTDATA=\"",
1273                                NULL);
1274
1275   hdml->hdml_br_flag = 0;
1276
1277   return hdml->out;
1278 }
1279
1280
1281 /**
1282  * handler of the form end tag.
1283  *
1284  * @param pdoc [i/o] The pointer to the HDML structure at the output
1285  *                   destination is specified.
1286  * @param child [i]  unused.
1287  * @return The HDML output result after it edits it is returned.
1288  */
1289 static char*
1290 s_hdml_end_form_tag(void* pdoc, Node* child)
1291 {
1292   hdml_t*      hdml;
1293   request_rec* r;
1294
1295   hdml = GET_HDML(pdoc);
1296   r    = hdml->doc->r;
1297
1298   s_output_to_postdata(hdml, "_chxj_dmy=");
1299
1300   hdml->form_tmp = apr_pstrcat(r->pool,
1301                                hdml->form_tmp,
1302                                hdml->postdata[hdml->pure_form_cnt],
1303                                NULL);
1304
1305   hdml->form_tmp = apr_pstrcat(r->pool,
1306                                hdml->form_tmp,
1307                                "\" CLEAR=TRUE >\n",
1308                                NULL);
1309   hdml->form_tmp = apr_pstrcat(r->pool,
1310                                hdml->form_tmp,
1311                                "</NODISPLAY>\n",
1312                                NULL);
1313
1314   s_output_to_hdml_card(hdml, hdml->form_tmp);
1315
1316   hdml->form_tmp = NULL;
1317   hdml->pure_form_cnt++;
1318
1319   return hdml->out;
1320 }
1321
1322
1323 /**
1324  * It is a handler that takes charge of the processing of the input tag.
1325  *
1326  * @param pdoc [i/o] The pointer to the HDML structure at the output
1327  *                   destination is specified.
1328  * @param node [i]   The tag node to be processed is specified.
1329  */
1330 static char*
1331 s_hdml_start_input_tag(void* pdoc, Node* node)
1332 {
1333   hdml_t*    hdml;
1334   Doc*       doc;
1335   Attr*      attr;
1336
1337   hdml = GET_HDML(pdoc);
1338   doc  = hdml->doc;
1339
1340   /*--------------------------------------------------------------------------*/
1341   /* The attribute of the input tag is acquired.                              */
1342   /*--------------------------------------------------------------------------*/
1343   for (attr = qs_get_attr(doc,node);
1344        attr;
1345        attr = qs_get_next_attr(doc,attr)) {
1346
1347     char* name;
1348     char* value;
1349
1350     name  = qs_get_attr_name(doc,attr);
1351     value = qs_get_attr_value(doc,attr);
1352
1353     if ((*name == 't'|| *name == 'T') && strcasecmp(name, "type") == 0) {
1354       if ((*value == 't' || *value == 'T') && strcasecmp(value, "text") == 0) {
1355         /*--------------------------------------------------------------------*/
1356         /* "input type ='text'" tag is processed.                             */
1357         /*--------------------------------------------------------------------*/
1358         s_hdml_do_input_text_tag(hdml, node);
1359       }
1360       else
1361       if ((*value == 'p' || *value == 'P') && strcasecmp(value, "password") == 0) {
1362         /*--------------------------------------------------------------------*/
1363         /* "input type='password'" tag is processed.                          */
1364         /*--------------------------------------------------------------------*/
1365         s_hdml_do_input_password_tag(hdml, node);
1366       }
1367       else
1368       if ((*value == 's' || *value == 'S') && strcasecmp(value, "submit") == 0) {
1369         /*--------------------------------------------------------------------*/
1370         /* "input type='submit'" tag is processed.                            */
1371         /*--------------------------------------------------------------------*/
1372         s_hdml_do_input_submit_tag(hdml, node);
1373       }
1374       else
1375       if ((*value == 'h' || *value == 'H') && strcasecmp(value, "hidden") == 0) {
1376         /*--------------------------------------------------------------------*/
1377         /* "input type='hidden'" tag is processed.                            */
1378         /*--------------------------------------------------------------------*/
1379         s_hdml_do_input_hidden_tag(hdml, node);
1380       }
1381       else
1382       if ((*value == 'r' || *value == 'R') && strcasecmp(value, "radio") == 0) {
1383         /*--------------------------------------------------------------------*/
1384         /* "input type='radio'" tag is processed.                             */
1385         /*--------------------------------------------------------------------*/
1386         s_hdml_do_input_radio_tag(hdml, node);
1387       }
1388       else
1389       if ((*value == 'c' || *value == 'C') && strcasecmp(value, "checkbox") == 0) {
1390         /*--------------------------------------------------------------------*/
1391         /* "input type='checkbox'" tag is processed.                          */
1392         /*--------------------------------------------------------------------*/
1393         s_hdml_do_input_checkbox_tag(hdml, node);
1394       }
1395     }
1396     else
1397     if ((*name == 'n' || *name == 'N') && strcasecmp(name, "name")      == 0) {
1398       /* ignore */
1399     }
1400     else
1401     if ((*name == 'v' || *name == 'V') && strcasecmp(name, "value")     == 0) {
1402       /* ignore */
1403     }
1404     else
1405     if ((*name == 's' || *name == 'S') && strcasecmp(name, "size")      == 0) {
1406       /* ignore */
1407     }
1408     else
1409     if ((*name == 'm' || *name == 'M') && strcasecmp(name, "maxlength") == 0) {
1410       /* ignore */
1411     }
1412     else
1413     if ((*name == 'c' || *name == 'C') && strcasecmp(name, "checked")   == 0) {
1414       /* ignore */
1415     }
1416     else
1417     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "accesskey") == 0) {
1418       /* ignore */
1419     }
1420     else
1421     if ((*name == 'i' || *name == 'I') && strcasecmp(name, "istyle")    == 0) {
1422       /* ignore */
1423     }
1424   }
1425
1426   hdml->hdml_br_flag = 0;
1427
1428   return hdml->out;
1429 }
1430
1431
1432 /**
1433  * The substitution processing of tag "input type = text" is done.
1434  *
1435  * @param hdml [i/o] The pointer to the HDML structure at the output
1436  *                   destination is specified.
1437  * @param tag  [i]   The tag node of input type=text is specified.
1438  */
1439 static void
1440 s_hdml_do_input_text_tag(hdml_t* hdml, Node* tag)
1441 {
1442   Doc*          doc;
1443   request_rec*  r;
1444   char*         mlen;
1445   char*         val;
1446   char*         is;
1447   char*         nm;
1448   char*         fmt;
1449   int           ii;
1450
1451   doc   = hdml->doc;
1452   r     = doc->r;
1453
1454   s_hdml_tag_output_upper_half(hdml, tag);
1455
1456   hdml->card_cnt++;
1457   s_output_to_hdml_out(hdml,
1458                        apr_psprintf(r->pool,
1459                                     "<A TASK=GOSUB LABEL=\x93\xfc\x97\xcd DEST=#D%d "
1460                                     "VARS=\"V=$%s%02d\" RECEIVE=%s%02d>",
1461                                     hdml->card_cnt,
1462                                     s_get_form_no(r, hdml),
1463                                     hdml->var_cnt[hdml->pure_form_cnt],
1464                                     s_get_form_no(r, hdml),
1465                                     hdml->var_cnt[hdml->pure_form_cnt]
1466                       ));
1467
1468   s_output_to_hdml_out(hdml,
1469                        apr_psprintf(r->pool, "[$%s%02d]</A>\n"  ,
1470                                     s_get_form_no(r, hdml),
1471                           hdml->var_cnt[hdml->pure_form_cnt]));
1472
1473   /*--------------------------------------------------------------------------*/
1474   /* ENTRY CARD is output here.                                               */
1475   /*--------------------------------------------------------------------------*/
1476   s_output_to_hdml_card(hdml, "<ENTRY NAME="                               );
1477   s_output_to_hdml_card(hdml, apr_psprintf(r->pool, "D%d ", hdml->card_cnt));
1478   s_output_to_hdml_card(hdml, " KEY=V DEFAULT=$V "                         );
1479
1480   mlen = NULL;
1481   is   = NULL;
1482   val  = NULL;
1483   fmt  = NULL;
1484   nm = qs_get_name_attr(doc, tag, r);
1485   if (! nm) {
1486     nm = qs_alloc_zero_byte_string(r);
1487   }
1488
1489   s_output_to_postdata(hdml,
1490                   apr_psprintf(r->pool,
1491                           "%s=$%s%02d",
1492                           nm,
1493                           s_get_form_no(r, hdml),
1494                           hdml->var_cnt[hdml->pure_form_cnt]));
1495
1496   mlen = qs_get_maxlength_attr  (doc, tag, r);
1497   is   = qs_get_istyle_attr     (doc, tag, r);
1498   val  = qs_get_value_attr      (doc, tag, r);
1499
1500   fmt  = qs_conv_istyle_to_format(r, is);
1501   DBG(r,"qs_conv_istyle_to_format end");
1502
1503   if (fmt) {
1504     if (mlen) {
1505       for (ii=0; ii<strlen(mlen); ii++) {
1506         if (mlen[ii] < '0' || mlen[ii] > '9') {
1507           mlen = apr_psprintf(r->pool, "0");
1508           break;
1509         }
1510       }
1511       s_output_to_hdml_card(hdml, apr_psprintf(r->pool, " FORMAT=%d%s", atoi(mlen), fmt));
1512     }
1513     else
1514       s_output_to_hdml_card(hdml, apr_psprintf(r->pool, " FORMAT=*%s", fmt)       );
1515   }
1516
1517   s_output_to_hdml_card(hdml,
1518                   " MARKABLE=FALSE>\n"
1519                   "<ACTION TYPE=ACCEPT TASK=RETURN RETVALS=$V>\n"
1520                   "</ENTRY>\n");
1521
1522   if (val)
1523     s_output_to_init_vars(hdml,
1524                     apr_psprintf(r->pool, "%s%02d=%s",
1525                         s_get_form_no(r, hdml),
1526                         hdml->var_cnt[hdml->pure_form_cnt],
1527                         ap_escape_uri(r->pool,val)));
1528   else
1529     s_output_to_init_vars(hdml,
1530                     apr_psprintf(r->pool, "%s%02d=",
1531                         s_get_form_no(r, hdml),
1532                         hdml->var_cnt[hdml->pure_form_cnt]));
1533
1534   hdml->var_cnt[hdml->pure_form_cnt]++;
1535 }
1536
1537 /**
1538  * The substitution processing of tag "input type = password" is done.
1539  *
1540  * @param hdml [i/o] The pointer to the HDML structure at the output
1541  *                   destination is specified.
1542  * @param tag  [i]   The tag node of input type=password is specified.
1543  */
1544 static void
1545 s_hdml_do_input_password_tag(hdml_t* hdml, Node* tag)
1546 {
1547   Doc*            doc = hdml->doc;
1548   request_rec*    r   = doc->r;
1549   char*           mlen;
1550   char*           val;
1551   char*           is;
1552   char*           nm;
1553   char*           fmt;
1554
1555   s_hdml_tag_output_upper_half(hdml, tag);
1556
1557   hdml->card_cnt++;
1558   s_output_to_hdml_out(hdml, "<A TASK=GOSUB LABEL=\"\x93\xfc\x97\xcd\" DEST=");
1559   s_output_to_hdml_out(hdml, apr_psprintf(r->pool, "#D%d ", hdml->card_cnt));
1560   s_output_to_hdml_out(hdml,
1561                   apr_psprintf(r->pool, "VARS=\"V=$%s%02d\" ",
1562                           s_get_form_no(r, hdml),
1563                           hdml->var_cnt[hdml->pure_form_cnt]));
1564
1565   s_output_to_hdml_out(hdml,
1566                   apr_psprintf(r->pool, "RECEIVE=%s%02d>"  ,
1567                           s_get_form_no(r, hdml),
1568                           hdml->var_cnt[hdml->pure_form_cnt]));
1569   s_output_to_hdml_out(hdml,
1570                   apr_psprintf(r->pool, "[$%s%02d]</A>\n"  ,
1571                           s_get_form_no(r, hdml),
1572                           hdml->var_cnt[hdml->pure_form_cnt]));
1573
1574   s_output_to_hdml_card(hdml, "<ENTRY NAME="                               );
1575   s_output_to_hdml_card(hdml, apr_psprintf(r->pool, "D%d ", hdml->card_cnt));
1576   s_output_to_hdml_card(hdml, " KEY=V DEFAULT=$V "                         );
1577
1578   mlen = NULL;
1579   is   = NULL;
1580   val  = NULL;
1581   fmt  = NULL;
1582
1583   nm = qs_get_name_attr(doc, tag, r);
1584   if (! nm)
1585     nm = qs_alloc_zero_byte_string(r);
1586
1587   s_output_to_postdata(hdml,
1588                   apr_psprintf(r->pool,
1589                           "%s=$%s%02d",
1590                           nm,
1591                           s_get_form_no(r, hdml),
1592                           hdml->var_cnt[hdml->pure_form_cnt]));
1593
1594   mlen = qs_get_maxlength_attr  (doc, tag, r);
1595   val  = qs_get_value_attr      (doc, tag, r);
1596   /*--------------------------------------------------------------------------*/
1597   /* Default is a figure input.                                               */
1598   /*--------------------------------------------------------------------------*/
1599   fmt = apr_psprintf(r->pool, "N");
1600   if (mlen) {
1601     if (chxj_chk_numeric(mlen) != 0)
1602       mlen = apr_psprintf(r->pool, "0");
1603     s_output_to_hdml_card(hdml,
1604                     apr_psprintf(r->pool, " FORMAT=%d%s", chxj_atoi(mlen), fmt));
1605   }
1606   else
1607     s_output_to_hdml_card(hdml,
1608                     apr_psprintf(r->pool, " FORMAT=*%s", fmt)       );
1609
1610   s_output_to_hdml_card(hdml, apr_psprintf(r->pool, " NOECHO=TRUE "));
1611
1612   s_output_to_hdml_card(hdml,
1613                   " MARKABLE=FALSE>\n"
1614                   "<ACTION TYPE=ACCEPT TASK=RETURN RETVALS=$V>\n"
1615                   "</ENTRY>\n");
1616
1617   if (val)
1618     s_output_to_init_vars(hdml,
1619                     apr_psprintf(r->pool, "%s%02d=%s",
1620                         s_get_form_no(r, hdml),
1621                         hdml->var_cnt[hdml->pure_form_cnt],
1622                         ap_escape_uri(r->pool,val)));
1623   else
1624     s_output_to_init_vars(hdml,
1625                     apr_psprintf(r->pool, "%s%02d=",
1626                         s_get_form_no(r, hdml),
1627                         hdml->var_cnt[hdml->pure_form_cnt]));
1628
1629   hdml->var_cnt[hdml->pure_form_cnt]++;
1630 }
1631
1632 /**
1633  * The substitution processing of tag "input type = submit" is done.
1634  *
1635  * @param hdml [i/o] The pointer to the HDML structure at the output
1636  *                   destination is specified.
1637  * @param tag  [i]   The tag node of input type=submit is specified.
1638  */
1639 static void
1640 s_hdml_do_input_submit_tag(hdml_t* hdml, Node* tag)
1641 {
1642   Doc*          doc = hdml->doc;
1643   request_rec*  r   = doc->r;
1644   char*         nm  = NULL;
1645   char*         val = NULL;
1646
1647   s_hdml_tag_output_upper_half(hdml, tag);
1648
1649   s_output_to_hdml_out(hdml,
1650                   apr_psprintf(r->pool,
1651                           "<A TASK=GO LABEL=OK DEST=#F%d ",
1652                           hdml->pure_form_cnt));
1653
1654   /*--------------------------------------------------------------------------*/
1655   /* get name and value attribute                                             */
1656   /*--------------------------------------------------------------------------*/
1657   nm  = qs_get_name_attr  (doc, tag, r);
1658   val = qs_get_value_attr (doc, tag, r);
1659
1660   if (nm && val) {
1661     s_output_to_hdml_out(hdml,
1662                     apr_psprintf(r->pool, "VARS=\"%s=%s\" ",
1663                             nm,
1664                             ap_escape_uri(r->pool,val)));
1665     if (strstr(hdml->postdata[hdml->pure_form_cnt], nm) == NULL) {
1666       s_output_to_postdata(hdml,
1667                       apr_psprintf(r->pool,"%s%s=$%s",
1668                               SUBMIT_BUTTON_PREFIX, nm, nm));
1669     }
1670   }
1671   s_output_to_hdml_out(hdml, ">"         );
1672   s_output_to_hdml_out(hdml, val);
1673   s_output_to_hdml_out(hdml, "</A>\n"    );
1674 }
1675
1676 /**
1677  * The substitution processing of tag "input type = hidden" is done.
1678  *
1679  * @param hdml [i/o] The pointer to the HDML structure at the output
1680  *                   destination is specified.
1681  * @param tag  [i]   The tag node of input type=hidden is specified.
1682  */
1683 static void
1684 s_hdml_do_input_hidden_tag(hdml_t* hdml, Node* tag)
1685 {
1686   Doc*          doc = hdml->doc;
1687   request_rec*  r   = doc->r;
1688   char*         nm  = NULL;
1689   char*         val = NULL;
1690
1691   /*--------------------------------------------------------------------------*/
1692   /* get name and value attribute                                             */
1693   /*--------------------------------------------------------------------------*/
1694   nm  = qs_get_name_attr  (doc, tag, r);
1695   val = qs_get_value_attr (doc, tag, r);
1696
1697   if (nm && val) {
1698     s_output_to_postdata(hdml,
1699                     apr_psprintf(r->pool,
1700                             "%s=%s",
1701                             nm,
1702                             ap_escape_uri(r->pool, val)));
1703   }
1704 }
1705
1706 /**
1707  * The substitution processing of tag "input type = radio" is done.
1708  *
1709  * @param hdml [i/o] The pointer to the HDML structure at the output
1710  *                   destination is specified.
1711  * @param tag  [i]   The tag node of input type=radio is specified.
1712  */
1713 static void
1714 s_hdml_do_input_radio_tag(hdml_t* hdml, Node* tag)
1715 {
1716   Doc*          doc       = hdml->doc;
1717   request_rec*  r         = doc->r;
1718   char*         nm        = NULL;
1719   char*         val       = NULL;
1720   int           ii;
1721   int           jj;
1722   int           kk;
1723   int           r_cnt;
1724
1725   s_hdml_tag_output_upper_half(hdml, tag);
1726
1727   /*--------------------------------------------------------------------------*/
1728   /* get name and value attribute                                             */
1729   /*--------------------------------------------------------------------------*/
1730   nm  = qs_get_name_attr  (doc, tag, r);
1731   val = qs_get_value_attr (doc, tag, r);
1732
1733   /*--------------------------------------------------------------------------*/
1734   /* The same name is searched out from the list made beforehand.             */
1735   /*--------------------------------------------------------------------------*/
1736   for (ii=0; ii<MAX_RADIO_COUNT; ii++) {
1737     if (! hdml->radio_name_list[ii]) {
1738       /* @todo Oops..  */
1739       DBG1(r, "Oops... radio list is null[%d]", ii);
1740       /*----------------------------------------------------------------------*/
1741       /* Processing is ended because it doesn't happen off the fly.           */
1742       /*----------------------------------------------------------------------*/
1743       return;
1744     }
1745
1746     if (strcasecmp(hdml->radio_name_list[ii], nm) == 0)
1747       break;
1748   }
1749   if (ii == MAX_RADIO_COUNT) {
1750     /* @todo Oops.. */
1751     DBG(r,"Oops... The same name was not in the list. ");
1752     /*------------------------------------------------------------------------*/
1753     /* Processing is ended because it doesn't happen off the fly.             */
1754     /*------------------------------------------------------------------------*/
1755     return;
1756   }
1757
1758   s_output_to_hdml_out(hdml,
1759                   apr_psprintf(r->pool,
1760                           "<A TASK=GOSUB "
1761                           "LABEL=\"\x93\xfc\x97\xcd\" "
1762                           "DEST=#R%d VARS=\"VAL=%s\" "
1763                           "RECEIVE=\"%s;",
1764                           ii,
1765                           val,
1766                           nm));
1767
1768   if (hdml->radio_out_cnt[ii] == 0) {
1769     s_output_to_hdml_card(hdml,
1770                     apr_psprintf(r->pool,
1771                             "<NODISPLAY NAME=R%d>\n",
1772                             ii));
1773     s_output_to_hdml_card(hdml,
1774                     apr_psprintf(r->pool,
1775                             "<ACTION "
1776                             "TYPE=ACCEPT TASK=RETURN RETVALS=\"$VAL;"));
1777   }
1778
1779   kk = hdml->radio_out_cnt[ii];
1780   for (jj=0; jj<MAX_RADIO_VALUE_COUNT; jj++)
1781     if (! hdml->radio_value_list[ii][jj])
1782       break;
1783
1784   r_cnt = jj;
1785
1786   for (jj=0; jj<r_cnt; jj++) {
1787     if (! hdml->radio_value_list[ii][jj])
1788       break;
1789
1790     if (jj != 0) {
1791       s_output_to_hdml_out(hdml, apr_psprintf(r->pool, ";"));
1792       if (hdml->radio_out_cnt[ii] == 0)
1793         s_output_to_hdml_card(hdml, apr_psprintf(r->pool, ";"));
1794     }
1795
1796     s_output_to_hdml_out(hdml, apr_psprintf(r->pool, "%s_%02d", nm, kk));
1797     if (hdml->radio_out_cnt[ii] == 0)  {
1798       if (jj == 0)
1799         s_output_to_hdml_card(hdml, apr_psprintf(r->pool, "X"));
1800       else
1801         s_output_to_hdml_card(hdml, apr_psprintf(r->pool, "_"));
1802     }
1803
1804     kk++;
1805     if (kk >= r_cnt)
1806       kk=0;
1807   }
1808   s_output_to_hdml_out(hdml,
1809                   apr_psprintf(r->pool, "\" >$%s_%02d</A>",
1810                           nm,
1811                           hdml->radio_out_cnt[ii]));
1812   if (! hdml->radio_out_cnt[ii]) {
1813     s_output_to_hdml_card(hdml, "\">\n"         );
1814     s_output_to_hdml_card(hdml, "</NODISPLAY>\n");
1815
1816     s_output_to_postdata(hdml,  apr_psprintf(r->pool, "%s%s=$%s", RADIO_BUTTON_PREFIX, nm, nm));
1817
1818     for (jj=0; jj<r_cnt; jj++) {
1819       if (hdml->radio_value_list[ii][jj] &&  hdml->radio_checked_value[ii]) {
1820         if (strcasecmp(hdml->radio_value_list[ii][jj],
1821                        hdml->radio_checked_value[ii]) == 0) {
1822           s_output_to_init_vars(hdml,
1823                           apr_psprintf(r->pool,
1824                                   "%s_%02d=X",
1825                                   nm,
1826                                   jj));
1827         }
1828         else {
1829           s_output_to_init_vars(hdml,
1830                           apr_psprintf(r->pool,
1831                                   "%s_%02d=_",
1832                                   nm,
1833                                   jj));
1834         }
1835       }
1836       else {
1837         s_output_to_init_vars(hdml,
1838                         apr_psprintf(r->pool,
1839                                 "%s_%02d=_",
1840                                 nm,
1841                                 jj));
1842       }
1843     }
1844
1845     if (hdml->radio_checked_value[ii]) {
1846       DBG1(r,"radio button is checked. checked value is [%s]",
1847         hdml->radio_checked_value[ii]);
1848       s_output_to_init_vars(hdml,
1849                     apr_psprintf(r->pool,
1850                             "%s=%s",
1851                             nm,
1852                             hdml->radio_checked_value[ii]));
1853     }
1854     else {
1855       DBG(r,"radio button is not checked. checked value is []");
1856       s_output_to_init_vars(hdml,
1857                     apr_psprintf(r->pool,
1858                             "%s=",
1859                             nm));
1860     }
1861   }
1862   hdml->radio_out_cnt[ii]++;
1863 }
1864
1865 /**
1866  * The substitution processing of tag "input type = checkbox" is done.
1867  *
1868  * @param hdml [i/o] The pointer to the HDML structure at the output
1869  *                   destination is specified.
1870  * @param tag  [i]   The tag node of input type=checkbox is specified.
1871  */
1872 static void
1873 s_hdml_do_input_checkbox_tag(hdml_t* hdml, Node* tag)
1874 {
1875   Doc*          doc       = hdml->doc;
1876   request_rec*  r         = doc->r;
1877   char*         nm        = NULL;
1878   char*         val       = NULL;
1879   int           chk;
1880
1881   /*--------------------------------------------------------------------------*/
1882   /* It is posted to the one without the checked attribute.                   */
1883   /* However, they were able to be removed with INPUT FILTER.                 */
1884   /*--------------------------------------------------------------------------*/
1885   if (! hdml->has_checkbox) {
1886     hdml->has_checkbox++;
1887     s_output_to_hdml_card(hdml,
1888                     "<NODISPLAY NAME=\"_chk\">\n"
1889                     "<ACTION TYPE=\"ACCEPT\" TASK=\"RETURN\" "
1890                                              "RETVALS=\"_uchk;$V;X\" >\n"
1891                     "</NODISPLAY>\n"
1892                     "<NODISPLAY NAME=\"_uchk\">\n"
1893                     "<ACTION TYPE=\"ACCEPT\" TASK=\"RETURN\" "
1894                                              "RETVALS=\"_chk;;_\" >\n"
1895                     "</NODISPLAY>\n"
1896                     );
1897     DBG(r, "wrote checkbox hdml card.");
1898   }
1899
1900   /*--------------------------------------------------------------------------*/
1901   /* It is examined whether it is CHECKED.                                    */
1902   /*--------------------------------------------------------------------------*/
1903   chk = qs_is_checked_checkbox_attr(doc, tag, r);
1904
1905   /*--------------------------------------------------------------------------*/
1906   /* The value of the name attribute and the value attribute is acquired      */
1907   /* respectively.                                                            */
1908   /*--------------------------------------------------------------------------*/
1909   val = qs_get_value_attr(doc, tag, r);
1910   nm  = qs_get_name_attr(doc, tag, r);
1911
1912   if (! val)
1913     val    = qs_alloc_zero_byte_string(r);
1914
1915   if (! nm)
1916     nm   = qs_alloc_zero_byte_string(r);
1917
1918   s_output_to_hdml_out(hdml, apr_psprintf(r->pool,
1919                                 "<A TASK=GOSUB LABEL=\"a\xaf\xb8\" "
1920                                    "DEST=\"#$%s%02d\" "
1921                                    "VARS=\"V=%s\" "
1922                                    "RECEIVE=\"%s%02d;%s%02d;%s%02d\">"
1923                                    "$%s%02d</A>\n",
1924                                 s_get_form_no(r, hdml),
1925                                 hdml->var_cnt[hdml->pure_form_cnt] + 0,
1926                                 val,
1927                                 s_get_form_no(r, hdml),
1928                                 hdml->var_cnt[hdml->pure_form_cnt] + 0,
1929                                 s_get_form_no(r, hdml),
1930                                 hdml->var_cnt[hdml->pure_form_cnt] + 1,
1931                                 s_get_form_no(r, hdml),
1932                                 hdml->var_cnt[hdml->pure_form_cnt] + 2,
1933                                 s_get_form_no(r, hdml),
1934                                 hdml->var_cnt[hdml->pure_form_cnt] + 2));
1935   if (chk) {
1936     s_output_to_init_vars(hdml,
1937                     apr_psprintf(r->pool,
1938                             "%s%02d=_uchk&%s%02d=%s&%s%02d=X",
1939                             s_get_form_no(r, hdml),
1940                             hdml->var_cnt[hdml->pure_form_cnt] + 0,
1941                             s_get_form_no(r, hdml),
1942                             hdml->var_cnt[hdml->pure_form_cnt] + 1,
1943                             ap_escape_uri(r->pool,val),
1944                             s_get_form_no(r, hdml),
1945                             hdml->var_cnt[hdml->pure_form_cnt] + 2
1946                             ));
1947   }
1948   else {
1949     s_output_to_init_vars(hdml,
1950                     apr_psprintf(r->pool,
1951                             "%s%02d=_chk&%s%02d=&%s%02d=_",
1952                             s_get_form_no(r, hdml),
1953                             hdml->var_cnt[hdml->pure_form_cnt] + 0,
1954                             s_get_form_no(r, hdml),
1955                             hdml->var_cnt[hdml->pure_form_cnt] + 1,
1956                             s_get_form_no(r, hdml),
1957                             hdml->var_cnt[hdml->pure_form_cnt] + 2
1958                             ));
1959   }
1960
1961   s_output_to_postdata(hdml,
1962                   apr_psprintf(r->pool, "%s%s=$%s%02d",
1963                                   CHECK_BOX_PREFIX,
1964                                   nm,
1965                                   s_get_form_no(r, hdml),
1966                                   hdml->var_cnt[hdml->pure_form_cnt] + 1));
1967
1968   hdml->var_cnt[hdml->pure_form_cnt] += 3;
1969 }
1970
1971 /**
1972  * The ISTYLE attribute is converted into the HDML form.
1973  *
1974  * @param r    [i]   To use POOL, the pointer to request_rec is specified.
1975  * @param is   [i]   The value of the ISTYLE attribute is specified.
1976  * @return The ISTYLE attribute converted into the HDML form is returned.
1977  */
1978 char*
1979 qs_conv_istyle_to_format(request_rec* r, char* is)
1980 {
1981   char* fmt;
1982
1983   if (!is)
1984     return NULL;
1985
1986   switch(*is) {
1987   case '1':
1988     fmt = apr_psprintf(r->pool, "M");
1989     break;
1990   case '2':
1991     fmt = apr_psprintf(r->pool, "M");
1992     break;
1993   case '3':
1994     fmt = apr_psprintf(r->pool, "m");
1995     break;
1996   case '4':
1997     fmt = apr_psprintf(r->pool, "N");
1998     break;
1999   default:
2000     return NULL;
2001   }
2002
2003   return fmt;
2004 }
2005
2006
2007 /**
2008  * It is a handler who processes the INPUT tag.
2009  *
2010  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2011  *                     destination is specified.
2012  * @param node   [i]   The INPUT tag node is specified.
2013  * @return The conversion result is returned.
2014  */
2015 static char*
2016 s_hdml_end_input_tag(void* pdoc, Node* child)
2017 {
2018   hdml_t* hdml;
2019
2020   hdml = GET_HDML(pdoc);
2021
2022   return hdml->out;
2023 }
2024
2025
2026 /**
2027  * It is a handler who processes the CENTER tag.
2028  *
2029  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2030  *                     destination is specified.
2031  * @param node   [i]   The CENTER tag node is specified.
2032  * @return The conversion result is returned.
2033  */
2034 static char*
2035 s_hdml_start_center_tag(void* pdoc, Node* node)
2036 {
2037   hdml_t* hdml;
2038
2039   hdml = GET_HDML(pdoc);
2040
2041   hdml->center++;
2042   hdml->in_center++;
2043
2044   if (hdml->hdml_br_flag == 0)
2045     hdml = s_output_to_hdml_out(hdml, "<BR>\n");
2046
2047   hdml = s_output_to_hdml_out(hdml, "<CENTER>");
2048
2049   return hdml->out;
2050 }
2051
2052
2053 /**
2054  * It is a handler who processes the CENTER tag.
2055  *
2056  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2057  *                     destination is specified.
2058  * @param node   [i]   The CENTER tag node is specified.
2059  * @return The conversion result is returned.
2060  */
2061 static char*
2062 s_hdml_end_center_tag(void* pdoc, Node* child)
2063 {
2064   hdml_t* hdml;
2065
2066   hdml = GET_HDML(pdoc);
2067
2068   hdml->center = 0;
2069   hdml->in_center = 0;
2070
2071   hdml = s_output_to_hdml_out(hdml, "<BR>\n");
2072   hdml->hdml_br_flag = 1;
2073
2074   return hdml->out;
2075 }
2076
2077
2078 /**
2079  * It is a handler who processes the HR tag.
2080  *
2081  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2082  *                     destination is specified.
2083  * @param node   [i]   The HR tag node is specified.
2084  * @return The conversion result is returned.
2085  */
2086 static char*
2087 s_hdml_start_hr_tag(void* pdoc, Node* node)
2088 {
2089   hdml_t* hdml;
2090
2091   hdml = GET_HDML(pdoc);
2092
2093   if (hdml->hdml_br_flag == 0) {
2094     s_output_to_hdml_out(hdml, "<BR>\n");
2095     if (hdml->in_center)
2096       hdml->in_center--;
2097     else
2098     if (hdml->div_in_center)
2099       hdml->div_in_center--;
2100   }
2101
2102   s_output_to_hdml_out(hdml, "<CENTER>\x81\x7c\x81\x7c\x81\x7c\x81\x7c\x81\x7c\x81\x7c\x81\x7c\x81\x7c\x81\x7c<BR>\n");
2103
2104   hdml->hdml_br_flag = 1;
2105
2106   return hdml->out;
2107 }
2108
2109
2110 /**
2111  * It is a handler who processes the HR tag.
2112  *
2113  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2114  *                     destination is specified.
2115  * @param node   [i]   The HR tag node is specified.
2116  * @return The conversion result is returned.
2117  */
2118 static char*
2119 s_hdml_end_hr_tag(void* pdoc, Node* child)
2120 {
2121   hdml_t* hdml;
2122
2123   hdml = GET_HDML(pdoc);
2124
2125   return hdml->out;
2126 }
2127
2128
2129 /**
2130  * It is a handler who processes the LI tag.
2131  *
2132  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2133  *                     destination is specified.
2134  * @param node   [i]   The LI tag node is specified.
2135  * @return The conversion result is returned.
2136  */
2137 static char*
2138 s_hdml_start_li_tag(void* pdoc, Node* node)
2139 {
2140   hdml_t* hdml;
2141
2142   hdml = GET_HDML(pdoc);
2143
2144   if (hdml->hdml_br_flag == 0) {
2145     s_output_to_hdml_out(hdml, "<BR>\n");
2146     if (hdml->in_center)
2147       hdml->in_center--;
2148     else
2149     if (hdml->div_in_center)
2150       hdml->div_in_center--;
2151   }
2152
2153   hdml->hdml_br_flag = 1;
2154
2155   return hdml->out;
2156 }
2157
2158
2159 /**
2160  * It is a handler who processes the LI tag.
2161  *
2162  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2163  *                     destination is specified.
2164  * @param node   [i]   The LI tag node is specified.
2165  * @return The conversion result is returned.
2166  */
2167 static char*
2168 s_hdml_end_li_tag(void* pdoc, Node* child)
2169 {
2170   hdml_t* hdml;
2171
2172   hdml = GET_HDML(pdoc);
2173
2174   if (hdml->hdml_br_flag == 0) {
2175     s_output_to_hdml_out(hdml, "<BR>\n");
2176     if (hdml->in_center)
2177       hdml->in_center--;
2178     else
2179     if (hdml->div_in_center)
2180       hdml->div_in_center--;
2181   }
2182
2183   hdml->hdml_br_flag = 1;
2184
2185   return hdml->out;
2186 }
2187
2188
2189 /**
2190  * It is a handler who processes the IMG tag.
2191  *
2192  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2193  *                     destination is specified.
2194  * @param node   [i]   The IMG tag node is specified.
2195  * @return The conversion result is returned.
2196  */
2197 static char*
2198 s_hdml_start_img_tag(void* pdoc, Node* node)
2199 {
2200   hdml_t*       hdml;
2201   Doc*          doc;
2202 #ifndef IMG_NOT_CONVERT_FILENAME
2203   device_table_t* spec;
2204 #endif
2205   Attr*         attr;
2206
2207   hdml = GET_HDML(pdoc);
2208   doc  = hdml->doc;
2209 #ifndef IMG_NOT_CONVERT_FILENAME
2210   spec = hdml->spec;
2211 #endif
2212
2213   s_hdml_tag_output_upper_half(hdml, node);
2214
2215   s_output_to_hdml_out(hdml, "<img");
2216
2217   /* Get Attributes */
2218   for (attr = qs_get_attr(doc,node);
2219        attr;
2220        attr = qs_get_next_attr(doc,attr)) {
2221
2222     char* name  = qs_get_attr_name(doc,attr);
2223     char* value = qs_get_attr_value(doc,attr);
2224
2225     if ((*name == 's' || *name == 'S') && strcasecmp(name, "src") == 0) {
2226       s_output_to_hdml_out(hdml, " src=\"");
2227 #ifdef IMG_NOT_CONVERT_FILENAME
2228       s_output_to_hdml_out(hdml, value    );
2229 #else
2230       s_output_to_hdml_out(hdml, chxj_img_conv(doc->r, spec,value));
2231 #endif
2232       s_output_to_hdml_out(hdml, "\""     );
2233     }
2234     else
2235     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "align" ) == 0) {
2236       s_output_to_hdml_out(hdml, " align=\"" );
2237       s_output_to_hdml_out(hdml, value       );
2238       s_output_to_hdml_out(hdml, "\""        );
2239     }
2240     else
2241     if ((*name == 'w' || *name == 'W') && strcasecmp(name, "width" ) == 0) {
2242       s_output_to_hdml_out(hdml, " width=\"");
2243       s_output_to_hdml_out(hdml, value      );
2244       s_output_to_hdml_out(hdml, "\""       );
2245     }
2246     else
2247     if ((*name == 'h' || *name == 'H') && strcasecmp(name, "height") == 0) {
2248       s_output_to_hdml_out(hdml, " height=\"");
2249       s_output_to_hdml_out(hdml, value       );
2250       s_output_to_hdml_out(hdml, "\""        );
2251     }
2252     else
2253     if ((*name == 'h' || *name == 'H') && strcasecmp(name, "hspace") == 0) {
2254       s_output_to_hdml_out(hdml, " hspace=\"");
2255       s_output_to_hdml_out(hdml, value       );
2256       s_output_to_hdml_out(hdml, "\""        );
2257     }
2258     else
2259     if ((*name == 'v' || *name == 'V') && strcasecmp(name, "vspace") == 0) {
2260       s_output_to_hdml_out(hdml, " vspace=\"");
2261       s_output_to_hdml_out(hdml, value       );
2262       s_output_to_hdml_out(hdml, "\""        );
2263     }
2264     else
2265     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "alt"   ) == 0) {
2266       s_output_to_hdml_out(hdml, " alt=\""   );
2267       s_output_to_hdml_out(hdml, value       );
2268       s_output_to_hdml_out(hdml, "\""        );
2269     }
2270   }
2271   s_output_to_hdml_out(hdml, ">"             );
2272
2273   hdml->hdml_br_flag = 0;
2274
2275   return hdml->out;
2276 }
2277
2278
2279 /**
2280  * It is a handler who processes the IMG tag.
2281  *
2282  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2283  *                     destination is specified.
2284  * @param node   [i]   The IMG tag node is specified.
2285  * @return The conversion result is returned.
2286  */
2287 static char*
2288 s_hdml_end_img_tag(void* pdoc, Node* child)
2289 {
2290   hdml_t* hdml;
2291
2292   hdml = GET_HDML(pdoc);
2293
2294   return hdml->out;
2295 }
2296
2297
2298 /**
2299  * It is a handler who processes the SELECT tag.
2300  *
2301  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2302  *                     destination is specified.
2303  * @param node   [i]   The SELECT tag node is specified.
2304  * @return The conversion result is returned.
2305  */
2306 static char*
2307 s_hdml_start_select_tag(void* pdoc, Node* node)
2308 {
2309   Doc*         doc;
2310   request_rec* r;
2311   Attr*        attr;
2312   hdml_t*      hdml;
2313
2314   hdml = GET_HDML(pdoc);
2315   doc  = hdml->doc;
2316   r    = doc->r;
2317
2318   s_hdml_tag_output_upper_half(hdml, node);
2319
2320   hdml->card_cnt++;
2321
2322   s_output_to_hdml_out(hdml, apr_psprintf(r->pool,
2323                                    "<A TASK=GOSUB LABEL=\x91\x49\x91\xf0 "
2324                                    "VARS=\"V=$%s%02d\" DEST=#D%d "
2325                                    "RECEIVE=\"%s%02d;%s%02d\">"
2326                                    "$%s%02d</A>\n",
2327                                    s_get_form_no(r, hdml),
2328                                    hdml->var_cnt[hdml->pure_form_cnt]+0,
2329                                    hdml->card_cnt,
2330                                    s_get_form_no(r, hdml),
2331                                    hdml->var_cnt[hdml->pure_form_cnt]+0,
2332                                    s_get_form_no(r, hdml),
2333                                    hdml->var_cnt[hdml->pure_form_cnt]+1,
2334                                    s_get_form_no(r, hdml),
2335                                    hdml->var_cnt[hdml->pure_form_cnt]+1));
2336
2337   s_output_to_hdml_card(hdml,
2338                   apr_psprintf(r->pool,
2339                           "<CHOICE KEY=V NAME=D%d ", hdml->card_cnt));
2340   s_output_to_hdml_card(hdml,
2341                   apr_psprintf(r->pool,
2342                           "DEFAULT=$V METHOD=ALPHA MARKABLE=FALSE>\n"));
2343   /*--------------------------------------------------------------------------*/
2344   /* Get Attributes                                                           */
2345   /*--------------------------------------------------------------------------*/
2346   for (attr = qs_get_attr(doc,node);
2347        attr;
2348        attr=qs_get_next_attr(doc,attr)) {
2349
2350     char* name      = qs_get_attr_name(doc,attr);
2351     char* value     = qs_get_attr_value(doc,attr);
2352     char* selval    = NULL;
2353     char* selvaltxt = NULL;
2354
2355     if ((*name == 'n' || *name == 'N') && strcasecmp(name, "name") == 0) {
2356
2357       s_output_to_postdata(hdml,
2358                       apr_psprintf(r->pool, "%s=$%s%02d",
2359                               value,
2360                               s_get_form_no(r, hdml),
2361                               hdml->var_cnt[hdml->pure_form_cnt]));
2362       selval = qs_get_selected_value(doc, node, r);
2363       if (! selval) {
2364         DBG(r, "selected value not found");
2365         selval = qs_alloc_zero_byte_string(r);
2366       }
2367       else {
2368         DBG1(r, "selected value found[%s]" , selval);
2369       }
2370       selvaltxt = qs_get_selected_value_text(doc, node, r);
2371       if (!selvaltxt)
2372         selvaltxt = qs_alloc_zero_byte_string(r);
2373
2374       DBG1(r, "selvaltxt:[%s]" ,selvaltxt);
2375
2376       s_output_to_init_vars(hdml,
2377                       apr_psprintf(r->pool,
2378                               "%s%02d=%s&%s%02d=%s",
2379                               s_get_form_no(r, hdml),
2380                               hdml->var_cnt[hdml->pure_form_cnt] + 0,
2381                               selval,
2382                               s_get_form_no(r, hdml),
2383                               hdml->var_cnt[hdml->pure_form_cnt] + 1,
2384                               selvaltxt));
2385
2386       hdml->var_cnt[hdml->pure_form_cnt] += 2;
2387       break;
2388     }
2389   }
2390
2391   hdml->hdml_br_flag = 0;
2392
2393   return hdml->out;
2394 }
2395
2396 /**
2397  * It is a handler who processes the SELECT tag.
2398  *
2399  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2400  *                     destination is specified.
2401  * @param node   [i]   The SELECT tag node is specified.
2402  * @return The conversion result is returned.
2403  */
2404 static char*
2405 s_hdml_end_select_tag(void* pdoc,  Node* node)
2406 {
2407   hdml_t* hdml;
2408
2409   hdml = GET_HDML(pdoc);
2410
2411   s_output_to_hdml_card(hdml, "</CHOICE>\n");
2412
2413   return hdml->out;
2414 }
2415
2416
2417 /**
2418  * It is a handler who processes the OPTION tag.
2419  *
2420  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2421  *                     destination is specified.
2422  * @param node   [i]   The OPTION tag node is specified.
2423  * @return The conversion result is returned.
2424  */
2425 static char*
2426 s_hdml_start_option_tag(void* pdoc, Node* node)
2427 {
2428   request_rec* r;
2429   Doc*         doc;
2430   Node*        child;
2431   char*        val;
2432   char*        txtval;
2433   hdml_t*      hdml;
2434
2435   hdml  = GET_HDML(pdoc);
2436   r     = hdml->doc->r;
2437   doc   = hdml->doc;
2438
2439   hdml->card_cnt++;
2440
2441   hdml->option_flag = 1;
2442   val = qs_get_value_attr(doc, node, r);
2443
2444   /*--------------------------------------------------------------------------*/
2445   /* The child node of the object tag node acquires the value in assumption   */
2446   /* that is the TEXT node.                                                   */
2447   /*--------------------------------------------------------------------------*/
2448   child = qs_get_child_node(doc, node);
2449   if (!child) {
2450     txtval    = apr_palloc(r->pool, 1);
2451     txtval[0] = 0;
2452   }
2453   else
2454     txtval = qs_get_node_value(doc, child);
2455
2456   DBG1(r, "txtval:[%s]" , txtval);
2457
2458   if (val && txtval) {
2459     s_output_to_hdml_card(hdml,
2460                     apr_psprintf(r->pool,
2461                             "<CE TASK=RETURN VALUE=\"%s\" "
2462                             "RETVALS=\"$V;%s\">%s</CE>\n",
2463                             val,
2464                             qs_trim_string(r,txtval),
2465                             qs_trim_string(r,txtval)));
2466   }
2467
2468   hdml->hdml_br_flag = 0;
2469
2470   return hdml->out;
2471 }
2472
2473
2474 /**
2475  * It is a handler who processes the OPTION tag.
2476  *
2477  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2478  *                     destination is specified.
2479  * @param node   [i]   The OPTION tag node is specified.
2480  * @return The conversion result is returned.
2481  */
2482 static char*
2483 s_hdml_end_option_tag(void* pdoc,  Node* node)
2484 {
2485   hdml_t* hdml;
2486
2487   hdml = GET_HDML(pdoc);
2488
2489   hdml->option_flag = 0;
2490
2491   return hdml->out;
2492 }
2493
2494
2495 /**
2496  * It is a handler who processes the DIV tag.
2497  *
2498  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2499  *                     destination is specified.
2500  * @param node   [i]   The DIV tag node is specified.
2501  * @return The conversion result is returned.
2502  */
2503 static char*
2504 s_hdml_start_div_tag(void* pdoc, Node* node)
2505 {
2506   hdml_t* hdml;
2507   Doc*    doc;
2508   Attr*   attr;
2509
2510   hdml = GET_HDML(pdoc);
2511   doc  = hdml->doc;
2512
2513   /*--------------------------------------------------------------------------*/
2514   /* If the br tag is not output immediately before the div tag appears, the  */
2515   /* br tag is output.                                                        */
2516   /*--------------------------------------------------------------------------*/
2517   if (hdml->hdml_br_flag == 0) {
2518     hdml->hdml_br_flag = 1;
2519     s_output_to_hdml_out(hdml, "<BR>\n");
2520   }
2521
2522   /*--------------------------------------------------------------------------*/
2523   /* The object tag node is scanned.                                          */
2524   /*--------------------------------------------------------------------------*/
2525   for (attr = qs_get_attr(doc,node);
2526        attr != NULL;
2527        attr = qs_get_next_attr(doc,attr)) {
2528     char* name  = qs_get_attr_name(doc,attr);
2529     char* value = qs_get_attr_value(doc,attr);
2530
2531     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "align") == 0) {
2532       if ((*value == 'r' || *value == 'R') && strcasecmp(value, "right") == 0) {
2533         hdml->div_right_flag = 1;
2534         s_output_to_hdml_out(hdml, "<RIGHT>");
2535         hdml->hdml_br_flag = 0;
2536         break;
2537       }
2538       else
2539       if ((*value == 'c' || *value == 'C') && strcasecmp(value, "center") == 0) {
2540         hdml->div_center_flag = 1;
2541         s_output_to_hdml_out(hdml, "<CENTER>");
2542         hdml->hdml_br_flag = 0;
2543         break;
2544       }
2545     }
2546   }
2547   hdml->hdml_br_flag = 0;
2548
2549   return hdml->out;
2550 }
2551
2552
2553 /**
2554  * It is a handler who processes the DIV tag.
2555  *
2556  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2557  *                     destination is specified.
2558  * @param node   [i]   The DIV tag node is specified.
2559  * @return The conversion result is returned.
2560  */
2561 static char*
2562 s_hdml_end_div_tag(void* pdoc,  Node* node)
2563 {
2564   hdml_t*      hdml;
2565   request_rec* r;
2566
2567   hdml = GET_HDML(pdoc);
2568   r    = hdml->doc->r;
2569
2570   if (hdml->div_right_flag == 1) {
2571     s_output_to_hdml_out(hdml, apr_psprintf(r->pool, "<BR>\n"));
2572     hdml->div_right_flag = 0;
2573   }
2574   if (hdml->div_center_flag == 1) {
2575     s_output_to_hdml_out(hdml, apr_psprintf(r->pool, "<BR>\n"));
2576     hdml->div_center_flag = 0;
2577     hdml->div_in_center   = 0;
2578   }
2579
2580   return hdml->out;
2581 }
2582
2583
2584 /**
2585  * It is a wrapper of the apr_pstrcat function.
2586  *
2587  * @param r    [i]   To use POOL, the pointer to request_rec is specified.
2588  * @param o    [i]   The character string of connected origin is specified.
2589  * @param s    [i]   The character string connected with 'o' parameter is
2590  *                   specified.
2591  * @param len  [i/o] The pointer to the area where the character string
2592  *                   length is stored is specified.
2593  * @return The character string after it connects it is returned.
2594  */
2595 char*
2596 qs_out_apr_pstrcat(request_rec* r, char* o, char* s, int* len)
2597 {
2598   *len = (strlen(s) + *len);
2599   return apr_pstrcat(r->pool, o, s, NULL);
2600 }
2601
2602 /**
2603  * The prepositive character string used to generate the variable for HDML is
2604  * generated.
2605  *
2606  * @param r    [i]   To use POOL, the pointer to request_rec is specified.
2607  * @param hdml [i]   The pointer to the HDML structure that maintains the seed
2608  *                   to generate it is specified.
2609  * @return The character string after it generates it is returned.
2610  */
2611 static char*
2612 s_get_form_no(request_rec* r, hdml_t* hdml)
2613 {
2614   char *result;
2615   apr_time_exp_t tm;
2616   unsigned long fc = hdml->form_cnt;
2617
2618   apr_time_exp_tz(&tm, hdml->form_cnt, 0);
2619
2620   result = apr_psprintf(r->pool, "%c",(int)('A' + ((fc / 100) % 26)));
2621   result = apr_pstrcat(r->pool, result,
2622                   apr_psprintf(r->pool, "%02d%02d%02d",
2623                           tm.tm_hour,
2624                           tm.tm_min,
2625                           tm.tm_sec), NULL);
2626   return result;
2627 }
2628
2629 /**
2630  * The number of tag nodes .."Input type =' radio '".. is counted.
2631  *
2632  * @param hdml [i] The pointer to the HDML structure is specified.
2633  * @param node [i] The first parents node that counts the radio tag node is
2634  *                 specified.
2635  */
2636 static void
2637 s_hdml_count_radio_tag(hdml_t* hdml, Node* node)
2638 {
2639   Node*         child;
2640   Doc*          doc       = hdml->doc;
2641   request_rec*  r         = doc->r;
2642
2643   /*--------------------------------------------------------------------------*/
2644   /* All the child nodes of the specified node are scanned.                   */
2645   /*--------------------------------------------------------------------------*/
2646   for (child =  qs_get_child_node(doc,node);
2647        child;
2648        child =  qs_get_next_node(doc,child)) {
2649
2650     char*     type;
2651     char*     rname;
2652     char*     rvalue;
2653     char*     chkd;
2654     char*     name;
2655     int       ii;
2656     int       jj;
2657
2658
2659     name = qs_get_node_name(doc,child);
2660     if (strcasecmp(name, "input") != 0) {
2661       s_hdml_count_radio_tag(hdml, child);
2662       continue;
2663     }
2664
2665     DBG(r,"found input tag");
2666
2667     type = qs_get_type_attr(doc, child, r);
2668     if (!type) {
2669       ERR(r, "Oops! The input tag without the type attribute has been found.Please give a type.");
2670       continue;
2671     }
2672
2673     if (strcasecmp(type, "radio") != 0)
2674       continue;
2675
2676     DBG(r, "found type=radio");
2677
2678     rname  = qs_get_name_attr (doc, child, r);
2679     rvalue = qs_get_value_attr(doc, child, r);
2680
2681     if (!rname) {
2682       /*----------------------------------------------------------------------*/
2683       /* Oops!. The input tag without the name attribute has been found.      */
2684       /*----------------------------------------------------------------------*/
2685       DBG(r, "Oops!. The input tag without the name attribute has been found. Please give a name.");
2686       continue;
2687     }
2688
2689     DBG(r, "found name attribute");
2690
2691     /*------------------------------------------------------------------------*/
2692     /* It scans in radio_name_list. When the same value exists, the           */
2693     /* value is overwrited.                                                   */
2694     /* The value is written in a new area when not is.                        */
2695     /*------------------------------------------------------------------------*/
2696     for (ii=0; ii<MAX_RADIO_COUNT; ii++) {
2697       if (! hdml->radio_name_list[ii]) {
2698         DBG1(r, "new name:[%s]", rname);
2699         break;
2700       }
2701       if (strcasecmp(hdml->radio_name_list[ii], rname) == 0) {
2702         DBG1(r, "already registered name:[%s]", rname);
2703         break;
2704       }
2705     }
2706     if (ii == MAX_RADIO_COUNT) {
2707       DBG(r, apr_psprintf(r->pool,
2708                         "I do not understand the name of the radiobutton "
2709                         "of %d piece or more. Please decrease "
2710                         "the number of radiobuttons.",
2711                         MAX_RADIO_COUNT));
2712       continue;
2713     }
2714
2715     DBG1(r,"add radio name:[%s]" ,rname);
2716
2717     hdml->radio_name_list[ii] = apr_pstrdup(r->pool, rname);
2718
2719     /*------------------------------------------------------------------------*/
2720     /* It adds it to radio_value_list.                                        */
2721     /*------------------------------------------------------------------------*/
2722     for (jj=0; jj<MAX_RADIO_VALUE_COUNT; jj++) {
2723       if (!hdml->radio_value_list[ii][jj])
2724         break;
2725     }
2726     if (jj == MAX_RADIO_VALUE_COUNT) {
2727       DBG(r, apr_psprintf(r->pool,
2728                         "I do not understand the value of the radiobutton "
2729                         "of %d piece or more. Please decrease "
2730                         "the number of radiobuttons.",
2731                         MAX_RADIO_VALUE_COUNT));
2732       continue;
2733     }
2734     hdml->radio_value_list[ii][jj] = apr_pstrdup(r->pool, rvalue);
2735
2736     /*------------------------------------------------------------------------*/
2737     /* Now let's be the checked attribute or scan.                            */
2738     /*------------------------------------------------------------------------*/
2739     chkd = qs_get_checked_attr(hdml->doc, child, hdml->doc->r);
2740     if (chkd) {
2741       DBG(r,apr_psprintf(r->pool,
2742                               "The tag scanned now had the checked "
2743                               "attribute. The value is [%s].",
2744                               rvalue));
2745       hdml->radio_checked_value[ii] = apr_pstrdup(r->pool, rvalue);
2746     }
2747   }
2748 }
2749
2750
2751 /**
2752  * The character string is added, and output to the out member of the HDML
2753  * structure.
2754  *
2755  * @param hdml [i/o] The pointer to the HDML structure that maintains the out
2756  *                   member at the output destination is specified.
2757  * @param s    [i]   The character string that should be output is specified.
2758  * @return The pointer to the HDML structure after it processes it is returned.
2759  */
2760 static hdml_t*
2761 s_output_to_hdml_out(hdml_t* hdml, char* s)
2762 {
2763   hdml->out = qs_out_apr_pstrcat(hdml->doc->r, hdml->out, s, &hdml->out_len);
2764
2765   return hdml;
2766 }
2767
2768
2769 /**
2770  * The character string is added, and output to the card member of the HDML
2771  * structure.
2772  *
2773  * @param hdml [i/o] The pointer to the HDML structure that maintains the
2774  *                   card member at the output destination is specified.
2775  * @param s    [i]   The character string that should be output is specified.
2776  * @return The pointer to the HDML structure after it processes it is returned.
2777  */
2778 static hdml_t*
2779 s_output_to_hdml_card(hdml_t* hdml, char* s)
2780 {
2781   hdml->card = qs_out_apr_pstrcat(hdml->doc->r, hdml->card, s, &hdml->card_len);
2782
2783   return hdml;
2784 }
2785
2786
2787
2788 /**
2789  * The data for the post is added, and output.
2790  *
2791  * @param hdml [i/o] The pointer to the HDML structure at the output
2792  *                    destination is specified.
2793  * @param s    [i]   The character string that wants to output to postdata is
2794  *                   specified.
2795  */
2796 static void
2797 s_output_to_postdata(hdml_t* hdml, char* s)
2798 {
2799   request_rec*          r = hdml->doc->r;
2800
2801   if (strlen(hdml->postdata[hdml->pure_form_cnt]))
2802     hdml->postdata[hdml->pure_form_cnt] =
2803                   apr_pstrcat(r->pool,
2804                               hdml->postdata[hdml->pure_form_cnt],
2805                               "&",
2806                               NULL);
2807
2808   hdml->postdata[hdml->pure_form_cnt] =
2809           apr_pstrcat(r->pool,
2810                           hdml->postdata[hdml->pure_form_cnt],
2811                           qs_trim_string(r, s),
2812                           NULL);
2813
2814   DBG1(r, "POSTDATA:[%s]", hdml->postdata[hdml->pure_form_cnt] );
2815 }
2816
2817
2818
2819 /**
2820  * The tag output upper half.
2821  *
2822  * @param hdml   [i/o] The pointer to the HDML structure at the output
2823  *                     destination is specified.
2824  * @param node   [i]   The A tag node is specified.
2825  */
2826 static void
2827 s_hdml_tag_output_upper_half(hdml_t* hdml, Node* node)
2828 {
2829   if (hdml->hdml_br_flag   == 1
2830   &&  hdml->div_right_flag == 1) {
2831     s_output_to_hdml_out(hdml, "<RIGHT>");
2832     hdml->hdml_br_flag = 0;
2833   }
2834
2835   if (hdml->hdml_br_flag == 1
2836   &&  hdml->center > 0
2837   &&  hdml->in_center == 0) {
2838     s_output_to_hdml_out(hdml, "<CENTER>");
2839     hdml->in_center++;
2840     hdml->hdml_br_flag = 0;
2841   }
2842   else
2843   if (hdml->hdml_br_flag == 1
2844   &&  hdml->div_center_flag > 0
2845   &&  hdml->div_in_center == 0)  {
2846     s_output_to_hdml_out(hdml, "<CENTER>");
2847     hdml->div_in_center++;
2848     hdml->hdml_br_flag = 0;
2849   }
2850 }
2851
2852
2853
2854 /**
2855  * The data for the init_vars is added, and output.
2856  *
2857  * @param hdml [i/o] The pointer to the HDML structure at the output
2858  *                    destination is specified.
2859  * @param s    [i]   The character string that wants to output to postdata is
2860  *                   specified.
2861  */
2862 static void
2863 s_output_to_init_vars(hdml_t* hdml, char* s)
2864 {
2865   request_rec*    r = hdml->doc->r;
2866
2867   if (strlen(hdml->init_vars))
2868     hdml->init_vars = apr_pstrcat(r->pool, hdml->init_vars, "&", NULL);
2869
2870   hdml->init_vars = apr_pstrcat(r->pool, hdml->init_vars, qs_trim_string(r,s), NULL);
2871
2872   DBG1(r, "INIT_VARS:[%s]", hdml->init_vars);
2873 }
2874
2875
2876
2877 static char*
2878 s_hdml_chxjif_tag(void* pdoc, Node* node)
2879 {
2880   hdml_t*      hdml;
2881   Doc*         doc;
2882   Node*        child;
2883
2884   hdml = GET_HDML(pdoc);
2885   doc  = hdml->doc;
2886
2887   for (child = qs_get_child_node(doc, node);
2888        child;
2889        child = qs_get_next_node(doc, child)) {
2890     s_output_to_hdml_out(hdml, child->otext);
2891     s_hdml_chxjif_tag(hdml, child);
2892   }
2893   return NULL;
2894 }
2895
2896 static char*
2897 s_hdml_text_tag(void* pdoc, Node* child)
2898 {
2899   hdml_t* hdml;
2900   Doc*    doc;
2901   char*   textval;
2902   char*   tmp;
2903   char*   tdst;
2904   char    one_byte[2];
2905   int     ii;
2906   int     tdst_len = 0;
2907   request_rec* r;
2908
2909   hdml = GET_HDML(pdoc);
2910   doc  = hdml->doc;
2911   r    = doc->r;
2912
2913   textval = qs_get_node_value(doc,child);
2914   textval = qs_trim_string(r, textval);
2915   if (strlen(textval) == 0)
2916     return hdml->out;
2917
2918   if (hdml->option_flag == 1)
2919     return hdml->out;
2920
2921   tmp = apr_palloc(r->pool, qs_get_node_size(doc,child)+1);
2922   memset(tmp, 0, qs_get_node_size(doc,child)+1);
2923   tdst = apr_palloc(r->pool, 1);
2924   tdst[0] = '\0';
2925   one_byte[0] = '\0';
2926   one_byte[1] = '\0';
2927
2928   for (ii=0; ii<qs_get_node_size(doc,child); ii++) {
2929     char* out;
2930     int rtn = s_hdml_search_emoji(hdml, &textval[ii], &out);
2931     if (rtn) {
2932       tdst = qs_out_apr_pstrcat(r, tdst, out, &tdst_len);
2933       ii += (rtn-1);
2934       continue;
2935     }
2936     if (is_sjis_kanji(textval[ii])) {
2937       one_byte[0] = textval[ii+0];
2938       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2939       one_byte[0] = textval[ii+1];
2940       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2941       ii++;
2942     }
2943     else
2944     if (textval[ii] != '\r' && textval[ii] != '\n') {
2945       one_byte[0] = textval[ii+0];
2946       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2947     }
2948   }
2949   memcpy(tmp, textval, strlen(textval)-1);
2950
2951   s_hdml_tag_output_upper_half(hdml, child->parent);
2952   s_output_to_hdml_out(hdml, tdst);
2953   hdml->hdml_br_flag = 0;
2954
2955   return hdml->out;
2956 }
2957
2958 /*
2959  * vim:ts=2 et
2960  */