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,
1470                                     "[$%s%02d]</A>\n"  ,
1471                                     s_get_form_no(r, hdml),
1472                           hdml->var_cnt[hdml->pure_form_cnt]));
1473
1474   /*--------------------------------------------------------------------------*/
1475   /* ENTRY CARD is output here.                                               */
1476   /*--------------------------------------------------------------------------*/
1477   s_output_to_hdml_card(hdml, "<ENTRY NAME="                               );
1478   s_output_to_hdml_card(hdml, apr_psprintf(r->pool, "D%d ", hdml->card_cnt));
1479   s_output_to_hdml_card(hdml, " KEY=V DEFAULT=$V "                         );
1480
1481   mlen = NULL;
1482   is   = NULL;
1483   val  = NULL;
1484   fmt  = NULL;
1485   nm = qs_get_name_attr(doc, tag, r);
1486   if (! nm) {
1487     nm = qs_alloc_zero_byte_string(r);
1488   }
1489
1490   s_output_to_postdata(hdml,
1491                        apr_psprintf(r->pool,
1492                                     "%s=$%s%02d",
1493                                     nm,
1494                                     s_get_form_no(r, hdml),
1495                                     hdml->var_cnt[hdml->pure_form_cnt]));
1496
1497   mlen = qs_get_maxlength_attr  (doc, tag, r);
1498   is   = qs_get_istyle_attr     (doc, tag, r);
1499   val  = qs_get_value_attr      (doc, tag, r);
1500
1501   fmt  = qs_conv_istyle_to_format(r, is);
1502   DBG(r,"qs_conv_istyle_to_format end");
1503
1504   if (fmt) {
1505     if (mlen) {
1506       for (ii=0; ii<strlen(mlen); ii++) {
1507         if (mlen[ii] < '0' || mlen[ii] > '9') {
1508           mlen = apr_psprintf(r->pool, "0");
1509           break;
1510         }
1511       }
1512       s_output_to_hdml_card(hdml, apr_psprintf(r->pool, " FORMAT=%d%s", atoi(mlen), fmt));
1513     }
1514     else
1515       s_output_to_hdml_card(hdml, apr_psprintf(r->pool, " FORMAT=*%s", fmt)       );
1516   }
1517
1518   s_output_to_hdml_card(hdml,
1519                         " MARKABLE=FALSE>\n"
1520                         "<ACTION TYPE=ACCEPT TASK=RETURN RETVALS=$V>\n"
1521                         "</ENTRY>\n");
1522
1523   if (val)
1524     s_output_to_init_vars(hdml,
1525                           apr_psprintf(r->pool,
1526                                        "%s%02d=%s",
1527                                        s_get_form_no(r, hdml),
1528                                        hdml->var_cnt[hdml->pure_form_cnt],
1529                                        ap_escape_uri(r->pool,val)));
1530   else
1531     s_output_to_init_vars(hdml,
1532                     apr_psprintf(r->pool, "%s%02d=",
1533                         s_get_form_no(r, hdml),
1534                         hdml->var_cnt[hdml->pure_form_cnt]));
1535
1536   hdml->var_cnt[hdml->pure_form_cnt]++;
1537 }
1538
1539 /**
1540  * The substitution processing of tag "input type = password" is done.
1541  *
1542  * @param hdml [i/o] The pointer to the HDML structure at the output
1543  *                   destination is specified.
1544  * @param tag  [i]   The tag node of input type=password is specified.
1545  */
1546 static void
1547 s_hdml_do_input_password_tag(hdml_t* hdml, Node* tag)
1548 {
1549   Doc*            doc = hdml->doc;
1550   request_rec*    r   = doc->r;
1551   char*           mlen;
1552   char*           val;
1553   char*           is;
1554   char*           nm;
1555   char*           fmt;
1556
1557   s_hdml_tag_output_upper_half(hdml, tag);
1558
1559   hdml->card_cnt++;
1560   s_output_to_hdml_out(hdml, "<A TASK=GOSUB LABEL=\"\x93\xfc\x97\xcd\" DEST=");
1561   s_output_to_hdml_out(hdml, apr_psprintf(r->pool, "#D%d ", hdml->card_cnt));
1562   s_output_to_hdml_out(hdml,
1563                   apr_psprintf(r->pool, "VARS=\"V=$%s%02d\" ",
1564                           s_get_form_no(r, hdml),
1565                           hdml->var_cnt[hdml->pure_form_cnt]));
1566
1567   s_output_to_hdml_out(hdml,
1568                   apr_psprintf(r->pool, "RECEIVE=%s%02d>"  ,
1569                           s_get_form_no(r, hdml),
1570                           hdml->var_cnt[hdml->pure_form_cnt]));
1571   s_output_to_hdml_out(hdml,
1572                   apr_psprintf(r->pool, "[$%s%02d]</A>\n"  ,
1573                           s_get_form_no(r, hdml),
1574                           hdml->var_cnt[hdml->pure_form_cnt]));
1575
1576   s_output_to_hdml_card(hdml, "<ENTRY NAME="                               );
1577   s_output_to_hdml_card(hdml, apr_psprintf(r->pool, "D%d ", hdml->card_cnt));
1578   s_output_to_hdml_card(hdml, " KEY=V DEFAULT=$V "                         );
1579
1580   mlen = NULL;
1581   is   = NULL;
1582   val  = NULL;
1583   fmt  = NULL;
1584
1585   nm = qs_get_name_attr(doc, tag, r);
1586   if (! nm)
1587     nm = qs_alloc_zero_byte_string(r);
1588
1589   s_output_to_postdata(hdml,
1590                   apr_psprintf(r->pool,
1591                           "%s=$%s%02d",
1592                           nm,
1593                           s_get_form_no(r, hdml),
1594                           hdml->var_cnt[hdml->pure_form_cnt]));
1595
1596   mlen = qs_get_maxlength_attr  (doc, tag, r);
1597   val  = qs_get_value_attr      (doc, tag, r);
1598   /*--------------------------------------------------------------------------*/
1599   /* Default is a figure input.                                               */
1600   /*--------------------------------------------------------------------------*/
1601   fmt = apr_psprintf(r->pool, "N");
1602   if (mlen) {
1603     if (chxj_chk_numeric(mlen) != 0)
1604       mlen = apr_psprintf(r->pool, "0");
1605     s_output_to_hdml_card(hdml,
1606                     apr_psprintf(r->pool, " FORMAT=%d%s", chxj_atoi(mlen), fmt));
1607   }
1608   else
1609     s_output_to_hdml_card(hdml,
1610                     apr_psprintf(r->pool, " FORMAT=*%s", fmt)       );
1611
1612   s_output_to_hdml_card(hdml, apr_psprintf(r->pool, " NOECHO=TRUE "));
1613
1614   s_output_to_hdml_card(hdml,
1615                   " MARKABLE=FALSE>\n"
1616                   "<ACTION TYPE=ACCEPT TASK=RETURN RETVALS=$V>\n"
1617                   "</ENTRY>\n");
1618
1619   if (val)
1620     s_output_to_init_vars(hdml,
1621                     apr_psprintf(r->pool, "%s%02d=%s",
1622                         s_get_form_no(r, hdml),
1623                         hdml->var_cnt[hdml->pure_form_cnt],
1624                         ap_escape_uri(r->pool,val)));
1625   else
1626     s_output_to_init_vars(hdml,
1627                     apr_psprintf(r->pool, "%s%02d=",
1628                         s_get_form_no(r, hdml),
1629                         hdml->var_cnt[hdml->pure_form_cnt]));
1630
1631   hdml->var_cnt[hdml->pure_form_cnt]++;
1632 }
1633
1634 /**
1635  * The substitution processing of tag "input type = submit" is done.
1636  *
1637  * @param hdml [i/o] The pointer to the HDML structure at the output
1638  *                   destination is specified.
1639  * @param tag  [i]   The tag node of input type=submit is specified.
1640  */
1641 static void
1642 s_hdml_do_input_submit_tag(hdml_t* hdml, Node* tag)
1643 {
1644   Doc*          doc = hdml->doc;
1645   request_rec*  r   = doc->r;
1646   char*         nm  = NULL;
1647   char*         val = NULL;
1648
1649   s_hdml_tag_output_upper_half(hdml, tag);
1650
1651   s_output_to_hdml_out(hdml,
1652                   apr_psprintf(r->pool,
1653                           "<A TASK=GO LABEL=OK DEST=#F%d ",
1654                           hdml->pure_form_cnt));
1655
1656   /*--------------------------------------------------------------------------*/
1657   /* get name and value attribute                                             */
1658   /*--------------------------------------------------------------------------*/
1659   nm  = qs_get_name_attr  (doc, tag, r);
1660   val = qs_get_value_attr (doc, tag, r);
1661
1662   if (nm && val) {
1663     s_output_to_hdml_out(hdml,
1664                     apr_psprintf(r->pool, "VARS=\"%s=%s\" ",
1665                             nm,
1666                             ap_escape_uri(r->pool,val)));
1667     if (strstr(hdml->postdata[hdml->pure_form_cnt], nm) == NULL) {
1668       s_output_to_postdata(hdml,
1669                       apr_psprintf(r->pool,"%s%s=$%s",
1670                               SUBMIT_BUTTON_PREFIX, nm, nm));
1671     }
1672   }
1673   s_output_to_hdml_out(hdml, ">"         );
1674   s_output_to_hdml_out(hdml, val);
1675   s_output_to_hdml_out(hdml, "</A>\n"    );
1676 }
1677
1678 /**
1679  * The substitution processing of tag "input type = hidden" is done.
1680  *
1681  * @param hdml [i/o] The pointer to the HDML structure at the output
1682  *                   destination is specified.
1683  * @param tag  [i]   The tag node of input type=hidden is specified.
1684  */
1685 static void
1686 s_hdml_do_input_hidden_tag(hdml_t* hdml, Node* tag)
1687 {
1688   Doc*          doc = hdml->doc;
1689   request_rec*  r   = doc->r;
1690   char*         nm  = NULL;
1691   char*         val = NULL;
1692
1693   /*--------------------------------------------------------------------------*/
1694   /* get name and value attribute                                             */
1695   /*--------------------------------------------------------------------------*/
1696   nm  = qs_get_name_attr  (doc, tag, r);
1697   val = qs_get_value_attr (doc, tag, r);
1698
1699   if (nm && val) {
1700     s_output_to_postdata(hdml,
1701                     apr_psprintf(r->pool,
1702                             "%s=%s",
1703                             nm,
1704                             ap_escape_uri(r->pool, val)));
1705   }
1706 }
1707
1708 /**
1709  * The substitution processing of tag "input type = radio" is done.
1710  *
1711  * @param hdml [i/o] The pointer to the HDML structure at the output
1712  *                   destination is specified.
1713  * @param tag  [i]   The tag node of input type=radio is specified.
1714  */
1715 static void
1716 s_hdml_do_input_radio_tag(hdml_t* hdml, Node* tag)
1717 {
1718   Doc*          doc       = hdml->doc;
1719   request_rec*  r         = doc->r;
1720   char*         nm        = NULL;
1721   char*         val       = NULL;
1722   int           ii;
1723   int           jj;
1724   int           kk;
1725   int           r_cnt;
1726
1727   s_hdml_tag_output_upper_half(hdml, tag);
1728
1729   /*--------------------------------------------------------------------------*/
1730   /* get name and value attribute                                             */
1731   /*--------------------------------------------------------------------------*/
1732   nm  = qs_get_name_attr  (doc, tag, r);
1733   val = qs_get_value_attr (doc, tag, r);
1734
1735   /*--------------------------------------------------------------------------*/
1736   /* The same name is searched out from the list made beforehand.             */
1737   /*--------------------------------------------------------------------------*/
1738   for (ii=0; ii<MAX_RADIO_COUNT; ii++) {
1739     if (! hdml->radio_name_list[ii]) {
1740       /* @todo Oops..  */
1741       DBG1(r, "Oops... radio list is null[%d]", ii);
1742       /*----------------------------------------------------------------------*/
1743       /* Processing is ended because it doesn't happen off the fly.           */
1744       /*----------------------------------------------------------------------*/
1745       return;
1746     }
1747
1748     if (strcasecmp(hdml->radio_name_list[ii], nm) == 0)
1749       break;
1750   }
1751   if (ii == MAX_RADIO_COUNT) {
1752     /* @todo Oops.. */
1753     DBG(r,"Oops... The same name was not in the list. ");
1754     /*------------------------------------------------------------------------*/
1755     /* Processing is ended because it doesn't happen off the fly.             */
1756     /*------------------------------------------------------------------------*/
1757     return;
1758   }
1759
1760   s_output_to_hdml_out(hdml,
1761                   apr_psprintf(r->pool,
1762                           "<A TASK=GOSUB "
1763                           "LABEL=\"\x93\xfc\x97\xcd\" "
1764                           "DEST=#R%d VARS=\"VAL=%s\" "
1765                           "RECEIVE=\"%s;",
1766                           ii,
1767                           val,
1768                           nm));
1769
1770   if (hdml->radio_out_cnt[ii] == 0) {
1771     s_output_to_hdml_card(hdml,
1772                     apr_psprintf(r->pool,
1773                             "<NODISPLAY NAME=R%d>\n",
1774                             ii));
1775     s_output_to_hdml_card(hdml,
1776                     apr_psprintf(r->pool,
1777                             "<ACTION "
1778                             "TYPE=ACCEPT TASK=RETURN RETVALS=\"$VAL;"));
1779   }
1780
1781   kk = hdml->radio_out_cnt[ii];
1782   for (jj=0; jj<MAX_RADIO_VALUE_COUNT; jj++)
1783     if (! hdml->radio_value_list[ii][jj])
1784       break;
1785
1786   r_cnt = jj;
1787
1788   for (jj=0; jj<r_cnt; jj++) {
1789     if (! hdml->radio_value_list[ii][jj])
1790       break;
1791
1792     if (jj != 0) {
1793       s_output_to_hdml_out(hdml, apr_psprintf(r->pool, ";"));
1794       if (hdml->radio_out_cnt[ii] == 0)
1795         s_output_to_hdml_card(hdml, apr_psprintf(r->pool, ";"));
1796     }
1797
1798     s_output_to_hdml_out(hdml, apr_psprintf(r->pool, "%s_%02d", nm, kk));
1799     if (hdml->radio_out_cnt[ii] == 0)  {
1800       if (jj == 0)
1801         s_output_to_hdml_card(hdml, apr_psprintf(r->pool, "X"));
1802       else
1803         s_output_to_hdml_card(hdml, apr_psprintf(r->pool, "_"));
1804     }
1805
1806     kk++;
1807     if (kk >= r_cnt)
1808       kk=0;
1809   }
1810   s_output_to_hdml_out(hdml,
1811                   apr_psprintf(r->pool, "\" >$%s_%02d</A>",
1812                           nm,
1813                           hdml->radio_out_cnt[ii]));
1814   if (! hdml->radio_out_cnt[ii]) {
1815     s_output_to_hdml_card(hdml, "\">\n"         );
1816     s_output_to_hdml_card(hdml, "</NODISPLAY>\n");
1817
1818     s_output_to_postdata(hdml,  apr_psprintf(r->pool, "%s%s=$%s", RADIO_BUTTON_PREFIX, nm, nm));
1819
1820     for (jj=0; jj<r_cnt; jj++) {
1821       if (hdml->radio_value_list[ii][jj] &&  hdml->radio_checked_value[ii]) {
1822         if (strcasecmp(hdml->radio_value_list[ii][jj],
1823                        hdml->radio_checked_value[ii]) == 0) {
1824           s_output_to_init_vars(hdml,
1825                           apr_psprintf(r->pool,
1826                                   "%s_%02d=X",
1827                                   nm,
1828                                   jj));
1829         }
1830         else {
1831           s_output_to_init_vars(hdml,
1832                           apr_psprintf(r->pool,
1833                                   "%s_%02d=_",
1834                                   nm,
1835                                   jj));
1836         }
1837       }
1838       else {
1839         s_output_to_init_vars(hdml,
1840                         apr_psprintf(r->pool,
1841                                 "%s_%02d=_",
1842                                 nm,
1843                                 jj));
1844       }
1845     }
1846
1847     if (hdml->radio_checked_value[ii]) {
1848       DBG1(r,"radio button is checked. checked value is [%s]",
1849         hdml->radio_checked_value[ii]);
1850       s_output_to_init_vars(hdml,
1851                     apr_psprintf(r->pool,
1852                             "%s=%s",
1853                             nm,
1854                             hdml->radio_checked_value[ii]));
1855     }
1856     else {
1857       DBG(r,"radio button is not checked. checked value is []");
1858       s_output_to_init_vars(hdml,
1859                     apr_psprintf(r->pool,
1860                             "%s=",
1861                             nm));
1862     }
1863   }
1864   hdml->radio_out_cnt[ii]++;
1865 }
1866
1867 /**
1868  * The substitution processing of tag "input type = checkbox" is done.
1869  *
1870  * @param hdml [i/o] The pointer to the HDML structure at the output
1871  *                   destination is specified.
1872  * @param tag  [i]   The tag node of input type=checkbox is specified.
1873  */
1874 static void
1875 s_hdml_do_input_checkbox_tag(hdml_t* hdml, Node* tag)
1876 {
1877   Doc*          doc       = hdml->doc;
1878   request_rec*  r         = doc->r;
1879   char*         nm        = NULL;
1880   char*         val       = NULL;
1881   int           chk;
1882
1883   /*--------------------------------------------------------------------------*/
1884   /* It is posted to the one without the checked attribute.                   */
1885   /* However, they were able to be removed with INPUT FILTER.                 */
1886   /*--------------------------------------------------------------------------*/
1887   if (! hdml->has_checkbox) {
1888     hdml->has_checkbox++;
1889     s_output_to_hdml_card(hdml,
1890                     "<NODISPLAY NAME=\"_chk\">\n"
1891                     "<ACTION TYPE=\"ACCEPT\" TASK=\"RETURN\" "
1892                                              "RETVALS=\"_uchk;$V;X\" >\n"
1893                     "</NODISPLAY>\n"
1894                     "<NODISPLAY NAME=\"_uchk\">\n"
1895                     "<ACTION TYPE=\"ACCEPT\" TASK=\"RETURN\" "
1896                                              "RETVALS=\"_chk;;_\" >\n"
1897                     "</NODISPLAY>\n"
1898                     );
1899     DBG(r, "wrote checkbox hdml card.");
1900   }
1901
1902   /*--------------------------------------------------------------------------*/
1903   /* It is examined whether it is CHECKED.                                    */
1904   /*--------------------------------------------------------------------------*/
1905   chk = qs_is_checked_checkbox_attr(doc, tag, r);
1906
1907   /*--------------------------------------------------------------------------*/
1908   /* The value of the name attribute and the value attribute is acquired      */
1909   /* respectively.                                                            */
1910   /*--------------------------------------------------------------------------*/
1911   val = qs_get_value_attr(doc, tag, r);
1912   nm  = qs_get_name_attr(doc, tag, r);
1913
1914   if (! val)
1915     val    = qs_alloc_zero_byte_string(r);
1916
1917   if (! nm)
1918     nm   = qs_alloc_zero_byte_string(r);
1919
1920   s_output_to_hdml_out(hdml, apr_psprintf(r->pool,
1921                                 "<A TASK=GOSUB LABEL=\"a\xaf\xb8\" "
1922                                    "DEST=\"#$%s%02d\" "
1923                                    "VARS=\"V=%s\" "
1924                                    "RECEIVE=\"%s%02d;%s%02d;%s%02d\">"
1925                                    "$%s%02d</A>\n",
1926                                 s_get_form_no(r, hdml),
1927                                 hdml->var_cnt[hdml->pure_form_cnt] + 0,
1928                                 val,
1929                                 s_get_form_no(r, hdml),
1930                                 hdml->var_cnt[hdml->pure_form_cnt] + 0,
1931                                 s_get_form_no(r, hdml),
1932                                 hdml->var_cnt[hdml->pure_form_cnt] + 1,
1933                                 s_get_form_no(r, hdml),
1934                                 hdml->var_cnt[hdml->pure_form_cnt] + 2,
1935                                 s_get_form_no(r, hdml),
1936                                 hdml->var_cnt[hdml->pure_form_cnt] + 2));
1937   if (chk) {
1938     s_output_to_init_vars(hdml,
1939                     apr_psprintf(r->pool,
1940                             "%s%02d=_uchk&%s%02d=%s&%s%02d=X",
1941                             s_get_form_no(r, hdml),
1942                             hdml->var_cnt[hdml->pure_form_cnt] + 0,
1943                             s_get_form_no(r, hdml),
1944                             hdml->var_cnt[hdml->pure_form_cnt] + 1,
1945                             ap_escape_uri(r->pool,val),
1946                             s_get_form_no(r, hdml),
1947                             hdml->var_cnt[hdml->pure_form_cnt] + 2
1948                             ));
1949   }
1950   else {
1951     s_output_to_init_vars(hdml,
1952                     apr_psprintf(r->pool,
1953                             "%s%02d=_chk&%s%02d=&%s%02d=_",
1954                             s_get_form_no(r, hdml),
1955                             hdml->var_cnt[hdml->pure_form_cnt] + 0,
1956                             s_get_form_no(r, hdml),
1957                             hdml->var_cnt[hdml->pure_form_cnt] + 1,
1958                             s_get_form_no(r, hdml),
1959                             hdml->var_cnt[hdml->pure_form_cnt] + 2
1960                             ));
1961   }
1962
1963   s_output_to_postdata(hdml,
1964                   apr_psprintf(r->pool, "%s%s=$%s%02d",
1965                                   CHECK_BOX_PREFIX,
1966                                   nm,
1967                                   s_get_form_no(r, hdml),
1968                                   hdml->var_cnt[hdml->pure_form_cnt] + 1));
1969
1970   hdml->var_cnt[hdml->pure_form_cnt] += 3;
1971 }
1972
1973 /**
1974  * The ISTYLE attribute is converted into the HDML form.
1975  *
1976  * @param r    [i]   To use POOL, the pointer to request_rec is specified.
1977  * @param is   [i]   The value of the ISTYLE attribute is specified.
1978  * @return The ISTYLE attribute converted into the HDML form is returned.
1979  */
1980 char*
1981 qs_conv_istyle_to_format(request_rec* r, char* is)
1982 {
1983   char* fmt;
1984
1985   if (!is)
1986     return NULL;
1987
1988   switch(*is) {
1989   case '1':
1990     fmt = apr_psprintf(r->pool, "M");
1991     break;
1992   case '2':
1993     fmt = apr_psprintf(r->pool, "M");
1994     break;
1995   case '3':
1996     fmt = apr_psprintf(r->pool, "m");
1997     break;
1998   case '4':
1999     fmt = apr_psprintf(r->pool, "N");
2000     break;
2001   default:
2002     return NULL;
2003   }
2004
2005   return fmt;
2006 }
2007
2008
2009 /**
2010  * It is a handler who processes the INPUT tag.
2011  *
2012  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2013  *                     destination is specified.
2014  * @param node   [i]   The INPUT tag node is specified.
2015  * @return The conversion result is returned.
2016  */
2017 static char*
2018 s_hdml_end_input_tag(void* pdoc, Node* child)
2019 {
2020   hdml_t* hdml;
2021
2022   hdml = GET_HDML(pdoc);
2023
2024   return hdml->out;
2025 }
2026
2027
2028 /**
2029  * It is a handler who processes the CENTER tag.
2030  *
2031  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2032  *                     destination is specified.
2033  * @param node   [i]   The CENTER tag node is specified.
2034  * @return The conversion result is returned.
2035  */
2036 static char*
2037 s_hdml_start_center_tag(void* pdoc, Node* node)
2038 {
2039   hdml_t* hdml;
2040
2041   hdml = GET_HDML(pdoc);
2042
2043   hdml->center++;
2044   hdml->in_center++;
2045
2046   if (hdml->hdml_br_flag == 0)
2047     hdml = s_output_to_hdml_out(hdml, "<BR>\n");
2048
2049   hdml = s_output_to_hdml_out(hdml, "<CENTER>");
2050
2051   return hdml->out;
2052 }
2053
2054
2055 /**
2056  * It is a handler who processes the CENTER tag.
2057  *
2058  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2059  *                     destination is specified.
2060  * @param node   [i]   The CENTER tag node is specified.
2061  * @return The conversion result is returned.
2062  */
2063 static char*
2064 s_hdml_end_center_tag(void* pdoc, Node* child)
2065 {
2066   hdml_t* hdml;
2067
2068   hdml = GET_HDML(pdoc);
2069
2070   hdml->center = 0;
2071   hdml->in_center = 0;
2072
2073   hdml = s_output_to_hdml_out(hdml, "<BR>\n");
2074   hdml->hdml_br_flag = 1;
2075
2076   return hdml->out;
2077 }
2078
2079
2080 /**
2081  * It is a handler who processes the HR tag.
2082  *
2083  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2084  *                     destination is specified.
2085  * @param node   [i]   The HR tag node is specified.
2086  * @return The conversion result is returned.
2087  */
2088 static char*
2089 s_hdml_start_hr_tag(void* pdoc, Node* node)
2090 {
2091   hdml_t* hdml;
2092
2093   hdml = GET_HDML(pdoc);
2094
2095   if (hdml->hdml_br_flag == 0) {
2096     s_output_to_hdml_out(hdml, "<BR>\n");
2097     if (hdml->in_center)
2098       hdml->in_center--;
2099     else
2100     if (hdml->div_in_center)
2101       hdml->div_in_center--;
2102   }
2103
2104   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");
2105
2106   hdml->hdml_br_flag = 1;
2107
2108   return hdml->out;
2109 }
2110
2111
2112 /**
2113  * It is a handler who processes the HR tag.
2114  *
2115  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2116  *                     destination is specified.
2117  * @param node   [i]   The HR tag node is specified.
2118  * @return The conversion result is returned.
2119  */
2120 static char*
2121 s_hdml_end_hr_tag(void* pdoc, Node* child)
2122 {
2123   hdml_t* hdml;
2124
2125   hdml = GET_HDML(pdoc);
2126
2127   return hdml->out;
2128 }
2129
2130
2131 /**
2132  * It is a handler who processes the LI tag.
2133  *
2134  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2135  *                     destination is specified.
2136  * @param node   [i]   The LI tag node is specified.
2137  * @return The conversion result is returned.
2138  */
2139 static char*
2140 s_hdml_start_li_tag(void* pdoc, Node* node)
2141 {
2142   hdml_t* hdml;
2143
2144   hdml = GET_HDML(pdoc);
2145
2146   if (hdml->hdml_br_flag == 0) {
2147     s_output_to_hdml_out(hdml, "<BR>\n");
2148     if (hdml->in_center)
2149       hdml->in_center--;
2150     else
2151     if (hdml->div_in_center)
2152       hdml->div_in_center--;
2153   }
2154
2155   hdml->hdml_br_flag = 1;
2156
2157   return hdml->out;
2158 }
2159
2160
2161 /**
2162  * It is a handler who processes the LI tag.
2163  *
2164  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2165  *                     destination is specified.
2166  * @param node   [i]   The LI tag node is specified.
2167  * @return The conversion result is returned.
2168  */
2169 static char*
2170 s_hdml_end_li_tag(void* pdoc, Node* child)
2171 {
2172   hdml_t* hdml;
2173
2174   hdml = GET_HDML(pdoc);
2175
2176   if (hdml->hdml_br_flag == 0) {
2177     s_output_to_hdml_out(hdml, "<BR>\n");
2178     if (hdml->in_center)
2179       hdml->in_center--;
2180     else
2181     if (hdml->div_in_center)
2182       hdml->div_in_center--;
2183   }
2184
2185   hdml->hdml_br_flag = 1;
2186
2187   return hdml->out;
2188 }
2189
2190
2191 /**
2192  * It is a handler who processes the IMG tag.
2193  *
2194  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2195  *                     destination is specified.
2196  * @param node   [i]   The IMG tag node is specified.
2197  * @return The conversion result is returned.
2198  */
2199 static char*
2200 s_hdml_start_img_tag(void* pdoc, Node* node)
2201 {
2202   hdml_t*       hdml;
2203   Doc*          doc;
2204 #ifndef IMG_NOT_CONVERT_FILENAME
2205   device_table_t* spec;
2206 #endif
2207   Attr*         attr;
2208
2209   hdml = GET_HDML(pdoc);
2210   doc  = hdml->doc;
2211 #ifndef IMG_NOT_CONVERT_FILENAME
2212   spec = hdml->spec;
2213 #endif
2214
2215   s_hdml_tag_output_upper_half(hdml, node);
2216
2217   s_output_to_hdml_out(hdml, "<img");
2218
2219   /* Get Attributes */
2220   for (attr = qs_get_attr(doc,node);
2221        attr;
2222        attr = qs_get_next_attr(doc,attr)) {
2223
2224     char* name  = qs_get_attr_name(doc,attr);
2225     char* value = qs_get_attr_value(doc,attr);
2226
2227     if ((*name == 's' || *name == 'S') && strcasecmp(name, "src") == 0) {
2228       s_output_to_hdml_out(hdml, " src=\"");
2229 #ifdef IMG_NOT_CONVERT_FILENAME
2230       s_output_to_hdml_out(hdml, value    );
2231 #else
2232       s_output_to_hdml_out(hdml, chxj_img_conv(doc->r, spec,value));
2233 #endif
2234       s_output_to_hdml_out(hdml, "\""     );
2235     }
2236     else
2237     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "align" ) == 0) {
2238       s_output_to_hdml_out(hdml, " align=\"" );
2239       s_output_to_hdml_out(hdml, value       );
2240       s_output_to_hdml_out(hdml, "\""        );
2241     }
2242     else
2243     if ((*name == 'w' || *name == 'W') && strcasecmp(name, "width" ) == 0) {
2244       s_output_to_hdml_out(hdml, " width=\"");
2245       s_output_to_hdml_out(hdml, value      );
2246       s_output_to_hdml_out(hdml, "\""       );
2247     }
2248     else
2249     if ((*name == 'h' || *name == 'H') && strcasecmp(name, "height") == 0) {
2250       s_output_to_hdml_out(hdml, " height=\"");
2251       s_output_to_hdml_out(hdml, value       );
2252       s_output_to_hdml_out(hdml, "\""        );
2253     }
2254     else
2255     if ((*name == 'h' || *name == 'H') && strcasecmp(name, "hspace") == 0) {
2256       s_output_to_hdml_out(hdml, " hspace=\"");
2257       s_output_to_hdml_out(hdml, value       );
2258       s_output_to_hdml_out(hdml, "\""        );
2259     }
2260     else
2261     if ((*name == 'v' || *name == 'V') && strcasecmp(name, "vspace") == 0) {
2262       s_output_to_hdml_out(hdml, " vspace=\"");
2263       s_output_to_hdml_out(hdml, value       );
2264       s_output_to_hdml_out(hdml, "\""        );
2265     }
2266     else
2267     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "alt"   ) == 0) {
2268       s_output_to_hdml_out(hdml, " alt=\""   );
2269       s_output_to_hdml_out(hdml, value       );
2270       s_output_to_hdml_out(hdml, "\""        );
2271     }
2272   }
2273   s_output_to_hdml_out(hdml, ">"             );
2274
2275   hdml->hdml_br_flag = 0;
2276
2277   return hdml->out;
2278 }
2279
2280
2281 /**
2282  * It is a handler who processes the IMG tag.
2283  *
2284  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2285  *                     destination is specified.
2286  * @param node   [i]   The IMG tag node is specified.
2287  * @return The conversion result is returned.
2288  */
2289 static char*
2290 s_hdml_end_img_tag(void* pdoc, Node* child)
2291 {
2292   hdml_t* hdml;
2293
2294   hdml = GET_HDML(pdoc);
2295
2296   return hdml->out;
2297 }
2298
2299
2300 /**
2301  * It is a handler who processes the SELECT tag.
2302  *
2303  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2304  *                     destination is specified.
2305  * @param node   [i]   The SELECT tag node is specified.
2306  * @return The conversion result is returned.
2307  */
2308 static char*
2309 s_hdml_start_select_tag(void* pdoc, Node* node)
2310 {
2311   Doc*         doc;
2312   request_rec* r;
2313   Attr*        attr;
2314   hdml_t*      hdml;
2315
2316   hdml = GET_HDML(pdoc);
2317   doc  = hdml->doc;
2318   r    = doc->r;
2319
2320   s_hdml_tag_output_upper_half(hdml, node);
2321
2322   hdml->card_cnt++;
2323
2324   s_output_to_hdml_out(hdml, apr_psprintf(r->pool,
2325                                    "<A TASK=GOSUB LABEL=\x91\x49\x91\xf0 "
2326                                    "VARS=\"V=$%s%02d\" DEST=#D%d "
2327                                    "RECEIVE=\"%s%02d;%s%02d\">"
2328                                    "$%s%02d</A>\n",
2329                                    s_get_form_no(r, hdml),
2330                                    hdml->var_cnt[hdml->pure_form_cnt]+0,
2331                                    hdml->card_cnt,
2332                                    s_get_form_no(r, hdml),
2333                                    hdml->var_cnt[hdml->pure_form_cnt]+0,
2334                                    s_get_form_no(r, hdml),
2335                                    hdml->var_cnt[hdml->pure_form_cnt]+1,
2336                                    s_get_form_no(r, hdml),
2337                                    hdml->var_cnt[hdml->pure_form_cnt]+1));
2338
2339   s_output_to_hdml_card(hdml,
2340                   apr_psprintf(r->pool,
2341                           "<CHOICE KEY=V NAME=D%d ", hdml->card_cnt));
2342   s_output_to_hdml_card(hdml,
2343                   apr_psprintf(r->pool,
2344                           "DEFAULT=$V METHOD=ALPHA MARKABLE=FALSE>\n"));
2345   /*--------------------------------------------------------------------------*/
2346   /* Get Attributes                                                           */
2347   /*--------------------------------------------------------------------------*/
2348   for (attr = qs_get_attr(doc,node);
2349        attr;
2350        attr=qs_get_next_attr(doc,attr)) {
2351
2352     char* name      = qs_get_attr_name(doc,attr);
2353     char* value     = qs_get_attr_value(doc,attr);
2354     char* selval    = NULL;
2355     char* selvaltxt = NULL;
2356
2357     if ((*name == 'n' || *name == 'N') && strcasecmp(name, "name") == 0) {
2358
2359       s_output_to_postdata(hdml,
2360                       apr_psprintf(r->pool, "%s=$%s%02d",
2361                               value,
2362                               s_get_form_no(r, hdml),
2363                               hdml->var_cnt[hdml->pure_form_cnt]));
2364       selval = qs_get_selected_value(doc, node, r);
2365       if (! selval) {
2366         DBG(r, "selected value not found");
2367         selval = qs_alloc_zero_byte_string(r);
2368       }
2369       else {
2370         DBG1(r, "selected value found[%s]" , selval);
2371       }
2372       selvaltxt = qs_get_selected_value_text(doc, node, r);
2373       if (!selvaltxt)
2374         selvaltxt = qs_alloc_zero_byte_string(r);
2375
2376       DBG1(r, "selvaltxt:[%s]" ,selvaltxt);
2377
2378       s_output_to_init_vars(hdml,
2379                       apr_psprintf(r->pool,
2380                               "%s%02d=%s&%s%02d=%s",
2381                               s_get_form_no(r, hdml),
2382                               hdml->var_cnt[hdml->pure_form_cnt] + 0,
2383                               selval,
2384                               s_get_form_no(r, hdml),
2385                               hdml->var_cnt[hdml->pure_form_cnt] + 1,
2386                               selvaltxt));
2387
2388       hdml->var_cnt[hdml->pure_form_cnt] += 2;
2389       break;
2390     }
2391   }
2392
2393   hdml->hdml_br_flag = 0;
2394
2395   return hdml->out;
2396 }
2397
2398 /**
2399  * It is a handler who processes the SELECT tag.
2400  *
2401  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2402  *                     destination is specified.
2403  * @param node   [i]   The SELECT tag node is specified.
2404  * @return The conversion result is returned.
2405  */
2406 static char*
2407 s_hdml_end_select_tag(void* pdoc,  Node* node)
2408 {
2409   hdml_t* hdml;
2410
2411   hdml = GET_HDML(pdoc);
2412
2413   s_output_to_hdml_card(hdml, "</CHOICE>\n");
2414
2415   return hdml->out;
2416 }
2417
2418
2419 /**
2420  * It is a handler who processes the OPTION tag.
2421  *
2422  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2423  *                     destination is specified.
2424  * @param node   [i]   The OPTION tag node is specified.
2425  * @return The conversion result is returned.
2426  */
2427 static char*
2428 s_hdml_start_option_tag(void* pdoc, Node* node)
2429 {
2430   request_rec* r;
2431   Doc*         doc;
2432   Node*        child;
2433   char*        val;
2434   char*        txtval;
2435   hdml_t*      hdml;
2436
2437   hdml  = GET_HDML(pdoc);
2438   r     = hdml->doc->r;
2439   doc   = hdml->doc;
2440
2441   hdml->card_cnt++;
2442
2443   hdml->option_flag = 1;
2444   val = qs_get_value_attr(doc, node, r);
2445
2446   /*--------------------------------------------------------------------------*/
2447   /* The child node of the object tag node acquires the value in assumption   */
2448   /* that is the TEXT node.                                                   */
2449   /*--------------------------------------------------------------------------*/
2450   child = qs_get_child_node(doc, node);
2451   if (!child) {
2452     txtval    = apr_palloc(r->pool, 1);
2453     txtval[0] = 0;
2454   }
2455   else
2456     txtval = qs_get_node_value(doc, child);
2457
2458   DBG1(r, "txtval:[%s]" , txtval);
2459
2460   if (val && txtval) {
2461     s_output_to_hdml_card(hdml,
2462                     apr_psprintf(r->pool,
2463                             "<CE TASK=RETURN VALUE=\"%s\" "
2464                             "RETVALS=\"$V;%s\">%s</CE>\n",
2465                             val,
2466                             qs_trim_string(r,txtval),
2467                             qs_trim_string(r,txtval)));
2468   }
2469
2470   hdml->hdml_br_flag = 0;
2471
2472   return hdml->out;
2473 }
2474
2475
2476 /**
2477  * It is a handler who processes the OPTION tag.
2478  *
2479  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2480  *                     destination is specified.
2481  * @param node   [i]   The OPTION tag node is specified.
2482  * @return The conversion result is returned.
2483  */
2484 static char*
2485 s_hdml_end_option_tag(void* pdoc,  Node* node)
2486 {
2487   hdml_t* hdml;
2488
2489   hdml = GET_HDML(pdoc);
2490
2491   hdml->option_flag = 0;
2492
2493   return hdml->out;
2494 }
2495
2496
2497 /**
2498  * It is a handler who processes the DIV tag.
2499  *
2500  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2501  *                     destination is specified.
2502  * @param node   [i]   The DIV tag node is specified.
2503  * @return The conversion result is returned.
2504  */
2505 static char*
2506 s_hdml_start_div_tag(void* pdoc, Node* node)
2507 {
2508   hdml_t* hdml;
2509   Doc*    doc;
2510   Attr*   attr;
2511
2512   hdml = GET_HDML(pdoc);
2513   doc  = hdml->doc;
2514
2515   /*--------------------------------------------------------------------------*/
2516   /* If the br tag is not output immediately before the div tag appears, the  */
2517   /* br tag is output.                                                        */
2518   /*--------------------------------------------------------------------------*/
2519   if (hdml->hdml_br_flag == 0) {
2520     hdml->hdml_br_flag = 1;
2521     s_output_to_hdml_out(hdml, "<BR>\n");
2522   }
2523
2524   /*--------------------------------------------------------------------------*/
2525   /* The object tag node is scanned.                                          */
2526   /*--------------------------------------------------------------------------*/
2527   for (attr = qs_get_attr(doc,node);
2528        attr != NULL;
2529        attr = qs_get_next_attr(doc,attr)) {
2530     char* name  = qs_get_attr_name(doc,attr);
2531     char* value = qs_get_attr_value(doc,attr);
2532
2533     if ((*name == 'a' || *name == 'A') && strcasecmp(name, "align") == 0) {
2534       if ((*value == 'r' || *value == 'R') && strcasecmp(value, "right") == 0) {
2535         hdml->div_right_flag = 1;
2536         s_output_to_hdml_out(hdml, "<RIGHT>");
2537         hdml->hdml_br_flag = 0;
2538         break;
2539       }
2540       else
2541       if ((*value == 'c' || *value == 'C') && strcasecmp(value, "center") == 0) {
2542         hdml->div_center_flag = 1;
2543         s_output_to_hdml_out(hdml, "<CENTER>");
2544         hdml->hdml_br_flag = 0;
2545         break;
2546       }
2547     }
2548   }
2549   hdml->hdml_br_flag = 0;
2550
2551   return hdml->out;
2552 }
2553
2554
2555 /**
2556  * It is a handler who processes the DIV tag.
2557  *
2558  * @param pdoc   [i/o] The pointer to the HDML structure at the output
2559  *                     destination is specified.
2560  * @param node   [i]   The DIV tag node is specified.
2561  * @return The conversion result is returned.
2562  */
2563 static char*
2564 s_hdml_end_div_tag(void* pdoc,  Node* node)
2565 {
2566   hdml_t*      hdml;
2567   request_rec* r;
2568
2569   hdml = GET_HDML(pdoc);
2570   r    = hdml->doc->r;
2571
2572   if (hdml->div_right_flag == 1) {
2573     s_output_to_hdml_out(hdml, apr_psprintf(r->pool, "<BR>\n"));
2574     hdml->div_right_flag = 0;
2575   }
2576   if (hdml->div_center_flag == 1) {
2577     s_output_to_hdml_out(hdml, apr_psprintf(r->pool, "<BR>\n"));
2578     hdml->div_center_flag = 0;
2579     hdml->div_in_center   = 0;
2580   }
2581
2582   return hdml->out;
2583 }
2584
2585
2586 /**
2587  * It is a wrapper of the apr_pstrcat function.
2588  *
2589  * @param r    [i]   To use POOL, the pointer to request_rec is specified.
2590  * @param o    [i]   The character string of connected origin is specified.
2591  * @param s    [i]   The character string connected with 'o' parameter is
2592  *                   specified.
2593  * @param len  [i/o] The pointer to the area where the character string
2594  *                   length is stored is specified.
2595  * @return The character string after it connects it is returned.
2596  */
2597 char*
2598 qs_out_apr_pstrcat(request_rec* r, char* o, char* s, int* len)
2599 {
2600   *len = (strlen(s) + *len);
2601   return apr_pstrcat(r->pool, o, s, NULL);
2602 }
2603
2604 /**
2605  * The prepositive character string used to generate the variable for HDML is
2606  * generated.
2607  *
2608  * @param r    [i]   To use POOL, the pointer to request_rec is specified.
2609  * @param hdml [i]   The pointer to the HDML structure that maintains the seed
2610  *                   to generate it is specified.
2611  * @return The character string after it generates it is returned.
2612  */
2613 static char*
2614 s_get_form_no(request_rec* r, hdml_t* hdml)
2615 {
2616   char *result;
2617   apr_time_exp_t tm;
2618   unsigned long fc = hdml->form_cnt;
2619
2620   apr_time_exp_tz(&tm, hdml->form_cnt, 0);
2621
2622   result = apr_psprintf(r->pool, "%c",(int)('A' + ((fc / 100) % 26)));
2623   result = apr_pstrcat(r->pool, result,
2624                   apr_psprintf(r->pool, "%02d%02d%02d",
2625                           tm.tm_hour,
2626                           tm.tm_min,
2627                           tm.tm_sec), NULL);
2628   return result;
2629 }
2630
2631 /**
2632  * The number of tag nodes .."Input type =' radio '".. is counted.
2633  *
2634  * @param hdml [i] The pointer to the HDML structure is specified.
2635  * @param node [i] The first parents node that counts the radio tag node is
2636  *                 specified.
2637  */
2638 static void
2639 s_hdml_count_radio_tag(hdml_t* hdml, Node* node)
2640 {
2641   Node*         child;
2642   Doc*          doc       = hdml->doc;
2643   request_rec*  r         = doc->r;
2644
2645   /*--------------------------------------------------------------------------*/
2646   /* All the child nodes of the specified node are scanned.                   */
2647   /*--------------------------------------------------------------------------*/
2648   for (child =  qs_get_child_node(doc,node);
2649        child;
2650        child =  qs_get_next_node(doc,child)) {
2651
2652     char*     type;
2653     char*     rname;
2654     char*     rvalue;
2655     char*     chkd;
2656     char*     name;
2657     int       ii;
2658     int       jj;
2659
2660
2661     name = qs_get_node_name(doc,child);
2662     if (strcasecmp(name, "input") != 0) {
2663       s_hdml_count_radio_tag(hdml, child);
2664       continue;
2665     }
2666
2667     DBG(r,"found input tag");
2668
2669     type = qs_get_type_attr(doc, child, r);
2670     if (!type) {
2671       ERR(r, "Oops! The input tag without the type attribute has been found.Please give a type.");
2672       continue;
2673     }
2674
2675     if (strcasecmp(type, "radio") != 0)
2676       continue;
2677
2678     DBG(r, "found type=radio");
2679
2680     rname  = qs_get_name_attr (doc, child, r);
2681     rvalue = qs_get_value_attr(doc, child, r);
2682
2683     if (!rname) {
2684       /*----------------------------------------------------------------------*/
2685       /* Oops!. The input tag without the name attribute has been found.      */
2686       /*----------------------------------------------------------------------*/
2687       DBG(r, "Oops!. The input tag without the name attribute has been found. Please give a name.");
2688       continue;
2689     }
2690
2691     DBG(r, "found name attribute");
2692
2693     /*------------------------------------------------------------------------*/
2694     /* It scans in radio_name_list. When the same value exists, the           */
2695     /* value is overwrited.                                                   */
2696     /* The value is written in a new area when not is.                        */
2697     /*------------------------------------------------------------------------*/
2698     for (ii=0; ii<MAX_RADIO_COUNT; ii++) {
2699       if (! hdml->radio_name_list[ii]) {
2700         DBG1(r, "new name:[%s]", rname);
2701         break;
2702       }
2703       if (strcasecmp(hdml->radio_name_list[ii], rname) == 0) {
2704         DBG1(r, "already registered name:[%s]", rname);
2705         break;
2706       }
2707     }
2708     if (ii == MAX_RADIO_COUNT) {
2709       DBG(r, apr_psprintf(r->pool,
2710                         "I do not understand the name of the radiobutton "
2711                         "of %d piece or more. Please decrease "
2712                         "the number of radiobuttons.",
2713                         MAX_RADIO_COUNT));
2714       continue;
2715     }
2716
2717     DBG1(r,"add radio name:[%s]" ,rname);
2718
2719     hdml->radio_name_list[ii] = apr_pstrdup(r->pool, rname);
2720
2721     /*------------------------------------------------------------------------*/
2722     /* It adds it to radio_value_list.                                        */
2723     /*------------------------------------------------------------------------*/
2724     for (jj=0; jj<MAX_RADIO_VALUE_COUNT; jj++) {
2725       if (!hdml->radio_value_list[ii][jj])
2726         break;
2727     }
2728     if (jj == MAX_RADIO_VALUE_COUNT) {
2729       DBG(r, apr_psprintf(r->pool,
2730                         "I do not understand the value of the radiobutton "
2731                         "of %d piece or more. Please decrease "
2732                         "the number of radiobuttons.",
2733                         MAX_RADIO_VALUE_COUNT));
2734       continue;
2735     }
2736     hdml->radio_value_list[ii][jj] = apr_pstrdup(r->pool, rvalue);
2737
2738     /*------------------------------------------------------------------------*/
2739     /* Now let's be the checked attribute or scan.                            */
2740     /*------------------------------------------------------------------------*/
2741     chkd = qs_get_checked_attr(hdml->doc, child, hdml->doc->r);
2742     if (chkd) {
2743       DBG(r,apr_psprintf(r->pool,
2744                               "The tag scanned now had the checked "
2745                               "attribute. The value is [%s].",
2746                               rvalue));
2747       hdml->radio_checked_value[ii] = apr_pstrdup(r->pool, rvalue);
2748     }
2749   }
2750 }
2751
2752
2753 /**
2754  * The character string is added, and output to the out member of the HDML
2755  * structure.
2756  *
2757  * @param hdml [i/o] The pointer to the HDML structure that maintains the out
2758  *                   member at the output destination is specified.
2759  * @param s    [i]   The character string that should be output is specified.
2760  * @return The pointer to the HDML structure after it processes it is returned.
2761  */
2762 static hdml_t*
2763 s_output_to_hdml_out(hdml_t* hdml, char* s)
2764 {
2765   hdml->out = qs_out_apr_pstrcat(hdml->doc->r, hdml->out, s, &hdml->out_len);
2766
2767   return hdml;
2768 }
2769
2770
2771 /**
2772  * The character string is added, and output to the card member of the HDML
2773  * structure.
2774  *
2775  * @param hdml [i/o] The pointer to the HDML structure that maintains the
2776  *                   card member at the output destination is specified.
2777  * @param s    [i]   The character string that should be output is specified.
2778  * @return The pointer to the HDML structure after it processes it is returned.
2779  */
2780 static hdml_t*
2781 s_output_to_hdml_card(hdml_t* hdml, char* s)
2782 {
2783   hdml->card = qs_out_apr_pstrcat(hdml->doc->r, hdml->card, s, &hdml->card_len);
2784
2785   return hdml;
2786 }
2787
2788
2789
2790 /**
2791  * The data for the post is added, and output.
2792  *
2793  * @param hdml [i/o] The pointer to the HDML structure at the output
2794  *                    destination is specified.
2795  * @param s    [i]   The character string that wants to output to postdata is
2796  *                   specified.
2797  */
2798 static void
2799 s_output_to_postdata(hdml_t* hdml, char* s)
2800 {
2801   request_rec*          r = hdml->doc->r;
2802
2803   if (strlen(hdml->postdata[hdml->pure_form_cnt]))
2804     hdml->postdata[hdml->pure_form_cnt] =
2805                   apr_pstrcat(r->pool,
2806                               hdml->postdata[hdml->pure_form_cnt],
2807                               "&",
2808                               NULL);
2809
2810   hdml->postdata[hdml->pure_form_cnt] =
2811           apr_pstrcat(r->pool,
2812                           hdml->postdata[hdml->pure_form_cnt],
2813                           qs_trim_string(r, s),
2814                           NULL);
2815
2816   DBG1(r, "POSTDATA:[%s]", hdml->postdata[hdml->pure_form_cnt] );
2817 }
2818
2819
2820
2821 /**
2822  * The tag output upper half.
2823  *
2824  * @param hdml   [i/o] The pointer to the HDML structure at the output
2825  *                     destination is specified.
2826  * @param node   [i]   The A tag node is specified.
2827  */
2828 static void
2829 s_hdml_tag_output_upper_half(hdml_t* hdml, Node* node)
2830 {
2831   if (hdml->hdml_br_flag   == 1
2832   &&  hdml->div_right_flag == 1) {
2833     s_output_to_hdml_out(hdml, "<RIGHT>");
2834     hdml->hdml_br_flag = 0;
2835   }
2836
2837   if (hdml->hdml_br_flag == 1
2838   &&  hdml->center > 0
2839   &&  hdml->in_center == 0) {
2840     s_output_to_hdml_out(hdml, "<CENTER>");
2841     hdml->in_center++;
2842     hdml->hdml_br_flag = 0;
2843   }
2844   else
2845   if (hdml->hdml_br_flag == 1
2846   &&  hdml->div_center_flag > 0
2847   &&  hdml->div_in_center == 0)  {
2848     s_output_to_hdml_out(hdml, "<CENTER>");
2849     hdml->div_in_center++;
2850     hdml->hdml_br_flag = 0;
2851   }
2852 }
2853
2854
2855
2856 /**
2857  * The data for the init_vars is added, and output.
2858  *
2859  * @param hdml [i/o] The pointer to the HDML structure at the output
2860  *                    destination is specified.
2861  * @param s    [i]   The character string that wants to output to postdata is
2862  *                   specified.
2863  */
2864 static void
2865 s_output_to_init_vars(hdml_t* hdml, char* s)
2866 {
2867   request_rec*    r = hdml->doc->r;
2868
2869   if (strlen(hdml->init_vars))
2870     hdml->init_vars = apr_pstrcat(r->pool, hdml->init_vars, "&", NULL);
2871
2872   hdml->init_vars = apr_pstrcat(r->pool, hdml->init_vars, qs_trim_string(r,s), NULL);
2873
2874   DBG1(r, "INIT_VARS:[%s]", hdml->init_vars);
2875 }
2876
2877
2878
2879 static char*
2880 s_hdml_chxjif_tag(void* pdoc, Node* node)
2881 {
2882   hdml_t*      hdml;
2883   Doc*         doc;
2884   Node*        child;
2885
2886   hdml = GET_HDML(pdoc);
2887   doc  = hdml->doc;
2888
2889   for (child = qs_get_child_node(doc, node);
2890        child;
2891        child = qs_get_next_node(doc, child)) {
2892     s_output_to_hdml_out(hdml, child->otext);
2893     s_hdml_chxjif_tag(hdml, child);
2894   }
2895   return NULL;
2896 }
2897
2898 static char*
2899 s_hdml_text_tag(void* pdoc, Node* child)
2900 {
2901   hdml_t* hdml;
2902   Doc*    doc;
2903   char*   textval;
2904   char*   tmp;
2905   char*   tdst;
2906   char    one_byte[2];
2907   int     ii;
2908   int     tdst_len = 0;
2909   request_rec* r;
2910
2911   hdml = GET_HDML(pdoc);
2912   doc  = hdml->doc;
2913   r    = doc->r;
2914
2915   textval = qs_get_node_value(doc,child);
2916   textval = qs_trim_string(r, textval);
2917   if (strlen(textval) == 0)
2918     return hdml->out;
2919
2920   if (hdml->option_flag == 1)
2921     return hdml->out;
2922
2923   tmp = apr_palloc(r->pool, qs_get_node_size(doc,child)+1);
2924   memset(tmp, 0, qs_get_node_size(doc,child)+1);
2925   tdst = apr_palloc(r->pool, 1);
2926   tdst[0] = '\0';
2927   one_byte[0] = '\0';
2928   one_byte[1] = '\0';
2929
2930   for (ii=0; ii<qs_get_node_size(doc,child); ii++) {
2931     char* out;
2932     int rtn = s_hdml_search_emoji(hdml, &textval[ii], &out);
2933     if (rtn) {
2934       tdst = qs_out_apr_pstrcat(r, tdst, out, &tdst_len);
2935       ii += (rtn-1);
2936       continue;
2937     }
2938     if (is_sjis_kanji(textval[ii])) {
2939       one_byte[0] = textval[ii+0];
2940       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2941       one_byte[0] = textval[ii+1];
2942       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2943       ii++;
2944     }
2945     else
2946     if (textval[ii] != '\r' && textval[ii] != '\n') {
2947       one_byte[0] = textval[ii+0];
2948       tdst = qs_out_apr_pstrcat(r, tdst, one_byte, &tdst_len);
2949     }
2950   }
2951   memcpy(tmp, textval, strlen(textval)-1);
2952
2953   s_hdml_tag_output_upper_half(hdml, child->parent);
2954   s_output_to_hdml_out(hdml, tdst);
2955   hdml->hdml_br_flag = 0;
2956
2957   return hdml->out;
2958 }
2959
2960 /*
2961  * vim:ts=2 et
2962  */