src/output/html.c

   1 /* PSPP - computes sample statistics.
   2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU General Public License as
   6    published by the Free Software Foundation; either version 2 of the
   7    License, or (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17    02110-1301, USA. */
  18
  19 #include <config.h>
  20 #include "chart.h"
  21 #include "htmlP.h"
  22 #include <errno.h>
  23 #include <stdlib.h>
  24 #include <ctype.h>
  25 #include <time.h>
  26 #include <unistd.h>
  27
  28 #include <libpspp/alloc.h>
  29 #include <libpspp/assertion.h>
  30 #include <libpspp/compiler.h>
  31 #include <data/file-name.h>
  32 #include "error.h"
  33 #include "getline.h"
  34 #include "getlogin_r.h"
  35 #include "output.h"
  36 #include "manager.h"
  37 #include "table.h"
  38 #include <libpspp/version.h>
  39
  40 #include "size_max.h"
  41
  42 #include "gettext.h"
  43 #define _(msgid) gettext (msgid)
  44
  45 static void escape_string (FILE *file,
  46                            const char *text, size_t length,
  47                            const char *space);
  48 static bool handle_option (struct outp_driver *this,
  49                            const char *key, const struct string *val);
  50 static void print_title_tag (FILE *file, const char *name,
  51                              const char *content);
  52
  53 static bool
  54 html_open_driver (struct outp_driver *this, struct substring options)
  55 {
  56   struct html_driver_ext *x;
  57
  58   this->ext = x = xmalloc (sizeof *x);
  59   x->file_name = xstrdup ("pspp.html");
  60   x->chart_file_name = xstrdup ("pspp-#.png");
  61   x->file = NULL;
  62   x->chart_cnt = 0;
  63
  64   outp_parse_options (options, handle_option, this);
  65
  66   x->file = fn_open (x->file_name, "w");
  67   if (x->file == NULL)
  68     {
  69       error (0, errno, _("opening HTML output file: %s"), x->file_name);
  70       goto error;
  71     }
  72
  73   fputs ("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"\n"
  74          "   \"http://www.w3.org/TR/html4/loose.dtd\">\n", x->file);
  75   fputs ("<HTML>\n", x->file);
  76   fputs ("<HEAD>\n", x->file);
  77   /* The <TITLE> tag is required, so we use a default if the user
  78      didn't provide one. */
  79   print_title_tag (x->file,
  80                    "TITLE", outp_title ? outp_title : _("PSPP Output"));
  81   fprintf (x->file, "<META NAME=\"generator\" CONTENT=\"%s\">\n", version);
  82   fputs ("<META HTTP-EQUIV=\"Content-Type\" "
  83          "CONTENT=\"text/html; charset=ISO-8859-1\">\n", x->file);
  84   fputs ("</HEAD>\n", x->file);
  85   fputs ("<BODY BGCOLOR=\"#ffffff\" TEXT=\"#000000\"\n", x->file);
  86   fputs (" LINK=\"#1f00ff\" ALINK=\"#ff0000\" VLINK=\"#9900dd\">\n", x->file);
  87   print_title_tag (x->file, "H1", outp_title);
  88   print_title_tag (x->file, "H2", outp_subtitle);
  89   free (x->chart_file_name);
  90
  91   return true;
  92
  93  error:
  94   free (x->chart_file_name);
  95   this->class->close_driver (this);
  96   return false;
  97 }
  98
  99 /* Emits <NAME>CONTENT</NAME> to the output, escaping CONTENT as
 100    necessary for HTML. */
 101 static void
 102 print_title_tag (FILE *file, const char *name, const char *content)
 103 {
 104   if (content != NULL)
 105     {
 106       fprintf (file, "<%s>", name);
 107       escape_string (file, content, strlen (content), " ");
 108       fprintf (file, "</%s>\n", name);
 109     }
 110 }
 111
 112 static bool
 113 html_close_driver (struct outp_driver *this)
 114 {
 115   struct html_driver_ext *x = this->ext;
 116   bool ok;
 117
 118   if (x->file != NULL)
 119     {
 120       fprintf (x->file,
 121                "</BODY>\n"
 122                "</HTML>\n"
 123                "<!-- end of file -->\n");
 124       ok = fn_close (x->file_name, x->file) == 0;
 125       x->file = NULL;
 126     }
 127   else
 128     ok = true;
 129   free (x->file_name);
 130   free (x);
 131
 132   return ok;
 133 }
 134
 135 /* Link the image contained in FILE_NAME to the
 136    HTML stream in FILE. */
 137 static void
 138 link_image (FILE *file, char *file_name)
 139 {
 140   fprintf (file, "<IMG SRC=\"%s\"/>", file_name);
 141  }
 142
 143 /* Generic option types. */
 144 enum
 145   {
 146     string_arg,
 147     nonneg_int_arg
 148   };
 149
 150 /* All the options that the HTML driver supports. */
 151 static const struct outp_option option_tab[] =
 152   {
 153     {"output-file",             string_arg,     0},
 154     {"chart-files",            string_arg,     1},
 155     {NULL, 0, 0},
 156   };
 157
 158 static bool
 159 handle_option (struct outp_driver *this,
 160                const char *key, const struct string *val)
 161 {
 162   struct html_driver_ext *x = this->ext;
 163   int subcat;
 164
 165   switch (outp_match_keyword (key, option_tab, &subcat))
 166     {
 167     case -1:
 168       error (0, 0,
 169              _("unknown configuration parameter `%s' for HTML device driver"),
 170              key);
 171       break;
 172     case string_arg:
 173       switch (subcat)
 174         {
 175         case 0:
 176           free (x->file_name);
 177           x->file_name = ds_xstrdup (val);
 178           break;
 179         case 1:
 180           if (ds_find_char (val, '#') != SIZE_MAX)
 181             {
 182               free (x->chart_file_name);
 183               x->chart_file_name = ds_xstrdup (val);
 184             }
 185           error (0, 0, _("`chart-files' value must contain `#'"));
 186           break;
 187         default:
 188           NOT_REACHED ();
 189         }
 190       break;
 191     default:
 192       NOT_REACHED ();
 193     }
 194
 195   return true;
 196 }
 197
 198 static void output_tab_table (struct outp_driver *, struct tab_table *);
 199
 200 static void
 201 html_submit (struct outp_driver *this, struct som_entity *s)
 202 {
 203   extern struct som_table_class tab_table_class;
 204   struct html_driver_ext *x = this->ext;
 205
 206   assert (s->class == &tab_table_class ) ;
 207
 208   switch (s->type)
 209     {
 210     case SOM_TABLE:
 211       output_tab_table ( this, (struct tab_table *) s->ext);
 212       break;
 213     case SOM_CHART:
 214       link_image (x->file, ((struct chart *)s->ext)->file_name);
 215       break;
 216     default:
 217       NOT_REACHED ();
 218     }
 219 }
 220
 221 /* Write LENGTH characters in TEXT to file F, escaping characters
 222    as necessary for HTML.  Spaces are replaced by SPACE, which
 223    should be " " or "&nbsp;". */
 224 static void
 225 escape_string (FILE *file,
 226                const char *text, size_t length,
 227                const char *space)
 228 {
 229   while (length-- > 0)
 230     {
 231       char c = *text++;
 232       switch (c)
 233         {
 234         case '&':
 235           fputs ("&amp;", file);
 236           break;
 237         case '<':
 238           fputs ("&lt;", file);
 239           break;
 240         case '>':
 241           fputs ("&gt;", file);
 242           break;
 243         case ' ':
 244           fputs (space, file);
 245           break;
 246         default:
 247           putc (c, file);
 248           break;
 249         }
 250     }
 251 }
 252
 253 /* Outputs content for a cell with options OPTS and contents
 254    TEXT. */
 255 void
 256 html_put_cell_contents (struct outp_driver *this,
 257                         unsigned int opts, const struct substring text)
 258 {
 259   struct html_driver_ext *x = this->ext;
 260
 261   if (!(opts & TAB_EMPTY))
 262     {
 263       if (opts & TAB_EMPH)
 264         fputs ("<EM>", x->file);
 265       if (opts & TAB_FIX)
 266         {
 267           fputs ("<TT>", x->file);
 268           escape_string (x->file, ss_data (text), ss_length (text), "&nbsp;");
 269           fputs ("</TT>", x->file);
 270         }
 271       else
 272         {
 273           size_t initial_spaces = ss_span (text, ss_cstr (CC_SPACES));
 274           escape_string (x->file,
 275                          ss_data (text) + initial_spaces,
 276                          ss_length (text) - initial_spaces,
 277                          " ");
 278         }
 279       if (opts & TAB_EMPH)
 280         fputs ("</EM>", x->file);
 281     }
 282 }
 283
 284 /* Write table T to THIS output driver. */
 285 static void
 286 output_tab_table (struct outp_driver *this, struct tab_table *t)
 287 {
 288   struct html_driver_ext *x = this->ext;
 289
 290   if (t->nr == 1 && t->nc == 1)
 291     {
 292       fputs ("<P>", x->file);
 293       html_put_cell_contents (this, t->ct[0], *t->cc);
 294       fputs ("</P>\n", x->file);
 295
 296       return;
 297     }
 298
 299   fputs ("<TABLE BORDER=1>\n", x->file);
 300
 301   if (t->title != NULL)
 302     {
 303       fprintf (x->file, "  <CAPTION>");
 304       escape_string (x->file, t->title, strlen (t->title), " ");
 305       fputs ("</CAPTION>\n", x->file);
 306     }
 307
 308   {
 309     int r;
 310     unsigned char *ct = t->ct;
 311
 312     for (r = 0; r < t->nr; r++)
 313       {
 314         int c;
 315
 316         fputs ("  <TR>\n", x->file);
 317         for (c = 0; c < t->nc; c++, ct++)
 318           {
 319             struct substring *cc;
 320             const char *tag;
 321             struct tab_joined_cell *j = NULL;
 322
 323             cc = t->cc + c + r * t->nc;
 324             if (*ct & TAB_JOIN)
 325               {
 326                 j = (struct tab_joined_cell *) ss_data (*cc);
 327                 cc = &j->contents;
 328                 if (j->x1 != c || j->y1 != r)
 329                   continue;
 330               }
 331
 332             /* Output <TD> or <TH> tag. */
 333             tag = (r < t->t || r >= t->nr - t->b
 334                    || c < t->l || c >= t->nc - t->r) ? "TH" : "TD";
 335             fprintf (x->file, "    <%s ALIGN=%s",
 336                      tag,
 337                      (*ct & TAB_ALIGN_MASK) == TAB_LEFT ? "LEFT"
 338                      : (*ct & TAB_ALIGN_MASK) == TAB_RIGHT ? "RIGHT"
 339                      : "CENTER");
 340             if (*ct & TAB_JOIN)
 341               {
 342                 if (j->x2 - j->x1 > 1)
 343                   fprintf (x->file, " COLSPAN=%d", j->x2 - j->x1);
 344                 if (j->y2 - j->y1 > 1)
 345                   fprintf (x->file, " ROWSPAN=%d", j->y2 - j->y1);
 346               }
 347             putc ('>', x->file);
 348
 349             /* Output cell contents. */
 350             html_put_cell_contents (this, *ct, *cc);
 351
 352             /* Output </TH> or </TD>. */
 353             fprintf (x->file, "</%s>\n", tag);
 354           }
 355         fputs ("  </TR>\n", x->file);
 356       }
 357   }
 358
 359   fputs ("</TABLE>\n\n", x->file);
 360 }
 361
 362 static void
 363 html_initialise_chart (struct outp_driver *this, struct chart *ch)
 364 {
 365 #ifdef NO_CHARTS
 366   ch->lp = NULL;
 367 #else
 368   struct html_driver_ext *x = this->ext;
 369
 370   FILE *fp;
 371   int number_pos;
 372
 373   x->chart_cnt++;
 374
 375   number_pos = strchr (x->chart_file_name, '#') - x->chart_file_name;
 376   ch->file_name = xasprintf ("%.*s%d%s",
 377                              number_pos, x->chart_file_name,
 378                              x->chart_cnt,
 379                              x->chart_file_name + number_pos + 1);
 380   fp = fopen (ch->file_name, "wb");
 381   if (fp == NULL)
 382     {
 383       error (0, errno, _("creating \"%s\""), ch->file_name);
 384       free (ch->file_name);
 385       ch->file_name = NULL;
 386       return;
 387     }
 388
 389   ch->pl_params = pl_newplparams ();
 390   ch->lp = pl_newpl_r ("png", 0, fp, stderr, ch->pl_params);
 391 #endif
 392 }
 393
 394 static void
 395 html_finalise_chart(struct outp_driver *d UNUSED, struct chart *ch)
 396 {
 397   free(ch->file_name);
 398 }
 399
 400
 401
 402 /* HTML driver class. */
 403 const struct outp_class html_class =
 404   {
 405     "html",
 406     1,
 407
 408     html_open_driver,
 409     html_close_driver,
 410
 411     NULL,
 412     NULL,
 413
 414     html_submit,
 415
 416     NULL,
 417     NULL,
 418     NULL,
 419     html_initialise_chart,
 420     html_finalise_chart
 421   };