-/* PSPP - computes sample statistics.
- Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
- Written by Ben Pfaff <blp@gnu.org>.
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 1997-9, 2000, 2006, 2009 Free Software Foundation, Inc.
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2 of the
- License, or (at your option) any later version.
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
+#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "intprops.h"
-#include "size_max.h"
-#include <data/case.h>
+#include "xmalloca.h"
+
+#include <data/casegrouper.h>
+#include <data/casereader.h>
#include <data/dictionary.h>
+#include <data/data-out.h>
#include <data/format.h>
#include <data/procedure.h>
+#include <data/short-names.h>
#include <data/variable.h>
#include <language/command.h>
#include <language/dictionary/split-file.h>
#include <language/lexer/lexer.h>
-#include <libpspp/alloc.h>
#include <libpspp/compiler.h>
-#include <libpspp/magic.h>
-#include <libpspp/message.h>
+#include <libpspp/ll.h>
#include <libpspp/message.h>
#include <libpspp/misc.h>
#include <output/htmlP.h>
#include <output/output.h>
#include <output/table.h>
+#include "minmax.h"
+#include "xalloc.h"
+
#include "gettext.h"
#define _(msgid) gettext (msgid)
list (lst_):
*variables=varlist("PV_NO_SCRATCH");
cases=:from n:first,"%s>0"/by n:step,"%s>0"/ *to n:last,"%s>0";
- format=numbering:numbered/!unnumbered,
- wrap:!wrap/single,
- weight:weight/!noweight.
+ +format=numbering:numbered/!unnumbered,
+ wrap:!wrap/single,
+ weight:weight/!noweight.
*/
/* (declarations) */
/* (functions) */
/* Layout for one output driver. */
-struct list_ext
+struct list_target
{
+ struct ll ll;
+ struct outp_driver *driver;
int type; /* 0=Values and labels fit across the page. */
size_t n_vertical; /* Number of labels to list vertically. */
size_t header_rows; /* Number of header rows. */
/* Parsed command. */
static struct cmd_list cmd;
-/* Current case number. */
-static int case_idx;
-
/* Line buffer. */
static struct string line_buffer;
static void write_line (struct outp_driver *d, const char *s);
/* Other functions. */
-static bool list_cases (const struct ccase *, void *);
-static void determine_layout (void);
-static void clean_up (void);
-static void write_header (struct outp_driver *);
-static void write_all_headers (const struct ccase *, void *);
+static void list_case (const struct ccase *, casenumber case_idx,
+ const struct dataset *, struct ll_list *targets);
+static void determine_layout (struct ll_list *targets);
+static void clean_up (struct ll_list *targets);
+static void write_header (struct list_target *);
+static void write_all_headers (struct casereader *, const struct dataset *,
+ struct ll_list *targets);
/* Returns the number of text lines that can fit on the remainder of
the page. */
write_line (struct outp_driver *d, const char *s)
{
struct outp_text text;
-
+
assert (d->cp_y + d->font_height <= d->length);
text.font = OUTP_FIXED;
text.justification = OUTP_LEFT;
- ls_init (&text.string, s, strlen (s));
+ text.string = ss_cstr (s);
text.x = d->cp_x;
text.y = d->cp_y;
text.h = text.v = INT_MAX;
d->cp_x = 0;
d->cp_y += d->font_height;
}
-
+
/* Parses and executes the LIST procedure. */
int
-cmd_list (void)
+cmd_list (struct lexer *lexer, struct dataset *ds)
{
- struct variable casenum_var;
+ struct dictionary *dict = dataset_dict (ds);
+ struct variable *casenum_var = NULL;
+ struct casegrouper *grouper;
+ struct casereader *group;
+ struct ll_list targets;
+ casenumber case_idx;
bool ok;
- if (!parse_list (&cmd))
+ if (!parse_list (lexer, ds, &cmd, NULL))
return CMD_FAILURE;
-
+
/* Fill in defaults. */
- if (cmd.step == NOT_LONG)
+ if (cmd.step == LONG_MIN)
cmd.step = 1;
- if (cmd.first == NOT_LONG)
+ if (cmd.first == LONG_MIN)
cmd.first = 1;
- if (cmd.last == NOT_LONG)
+ if (cmd.last == LONG_MIN)
cmd.last = LONG_MAX;
if (!cmd.sbc_variables)
- dict_get_vars (default_dict, &cmd.v_variables, &cmd.n_variables,
- (1u << DC_SYSTEM) | (1u << DC_SCRATCH));
+ dict_get_vars (dict, &cmd.v_variables, &cmd.n_variables,
+ DC_SYSTEM | DC_SCRATCH);
if (cmd.n_variables == 0)
{
msg (SE, _("No variables specified."));
/* Weighting variable. */
if (cmd.weight == LST_WEIGHT)
{
- if (dict_get_weight (default_dict) != NULL)
+ if (dict_get_weight (dict) != NULL)
{
size_t i;
for (i = 0; i < cmd.n_variables; i++)
- if (cmd.v_variables[i] == dict_get_weight (default_dict))
+ if (cmd.v_variables[i] == dict_get_weight (dict))
break;
if (i >= cmd.n_variables)
{
cmd.v_variables = xnrealloc (cmd.v_variables, cmd.n_variables,
sizeof *cmd.v_variables);
cmd.v_variables[cmd.n_variables - 1]
- = dict_get_weight (default_dict);
+ = dict_get_weight (dict);
}
}
else
if (cmd.numbering == LST_NUMBERED)
{
/* Initialize the case-number variable. */
- strcpy (casenum_var.name, "Case#");
- casenum_var.type = NUMERIC;
- casenum_var.fv = -1;
- casenum_var.print = make_output_format (FMT_F,
- (cmd.last == LONG_MAX
- ? 5 : intlog10 (cmd.last)), 0);
+ int width = cmd.last == LONG_MAX ? 5 : intlog10 (cmd.last);
+ struct fmt_spec format = fmt_for_output (FMT_F, width, 0);
+ casenum_var = var_create ("Case#", 0);
+ var_set_both_formats (casenum_var, &format);
/* Add the weight variable at the beginning of the variable list. */
cmd.n_variables++;
cmd.n_variables, sizeof *cmd.v_variables);
memmove (&cmd.v_variables[1], &cmd.v_variables[0],
(cmd.n_variables - 1) * sizeof *cmd.v_variables);
- cmd.v_variables[0] = &casenum_var;
+ cmd.v_variables[0] = casenum_var;
}
- determine_layout ();
+ determine_layout (&targets);
case_idx = 0;
- ok = procedure_with_splits (write_all_headers, list_cases, NULL, NULL);
+ for (grouper = casegrouper_create_splits (proc_open (ds), dict);
+ casegrouper_get_next_group (grouper, &group);
+ casereader_destroy (group))
+ {
+ struct ccase *c;
+
+ write_all_headers (group, ds, &targets);
+ for (; (c = casereader_read (group)) != NULL; case_unref (c))
+ {
+ case_idx++;
+ if (case_idx >= cmd.first && case_idx <= cmd.last
+ && (case_idx - cmd.first) % cmd.step == 0)
+ list_case (c, case_idx, ds, &targets);
+ }
+ }
+ ok = casegrouper_destroy (grouper);
+ ok = proc_commit (ds) && ok;
+
ds_destroy(&line_buffer);
- clean_up ();
+ clean_up (&targets);
+
+ var_destroy (casenum_var);
return ok ? CMD_SUCCESS : CMD_CASCADING_FAILURE;
}
/* Writes headers to all devices. This is done at the beginning of
each SPLIT FILE group. */
static void
-write_all_headers (const struct ccase *c, void *aux UNUSED)
+write_all_headers (struct casereader *input, const struct dataset *ds,
+ struct ll_list *targets)
{
- struct outp_driver *d;
+ struct list_target *target;
+ struct ccase *c;
- output_split_file_values (c);
- for (d = outp_drivers (NULL); d; d = outp_drivers (d))
+ c = casereader_peek (input, 0);
+ if (c == NULL)
+ return;
+ output_split_file_values (ds, c);
+ case_unref (c);
+
+ ll_for_each (target, struct list_target, ll, targets)
{
+ struct outp_driver *d = target->driver;
if (!d->class->special)
{
d->cp_y += d->font_height; /* Blank line. */
- write_header (d);
+ write_header (target);
}
else if (d->class == &html_class)
{
struct html_driver_ext *x = d->ext;
-
+
fputs ("<TABLE BORDER=1>\n <TR>\n", x->file);
-
+
{
size_t i;
for (i = 0; i < cmd.n_variables; i++)
fprintf (x->file, " <TH><EM>%s</EM></TH>\n",
- cmd.v_variables[i]->name);
+ var_get_name (cmd.v_variables[i]));
}
fputs (" </TR>\n", x->file);
}
else
- assert (0);
+ NOT_REACHED ();
}
}
/* Writes the headers. Some of them might be vertical; most are
probably horizontal. */
static void
-write_header (struct outp_driver *d)
+write_header (struct list_target *target)
{
- struct list_ext *prc = d->prc;
+ struct outp_driver *d = target->driver;
- if (!prc->header_rows)
+ if (d->class->special || !target->header_rows)
return;
-
- if (n_lines_remaining (d) < prc->header_rows + 1)
+
+ if (n_lines_remaining (d) < target->header_rows + 1)
{
outp_eject_page (d);
- assert (n_lines_remaining (d) >= prc->header_rows + 1);
+ assert (n_lines_remaining (d) >= target->header_rows + 1);
}
/* Design the header. */
- if (!prc->header)
+ if (!target->header)
{
size_t i;
size_t x;
-
+
/* Allocate, initialize header. */
- prc->header = xnmalloc (prc->header_rows, sizeof *prc->header);
+ target->header = xnmalloc (target->header_rows, sizeof *target->header);
{
int w = n_chars_width (d);
- for (i = 0; i < prc->header_rows; i++)
+ for (i = 0; i < target->header_rows; i++)
{
- prc->header[i] = xmalloc (w + 1);
- memset (prc->header[i], ' ', w);
+ target->header[i] = xmalloc (w + 1);
+ memset (target->header[i], ' ', w);
}
}
/* Put in vertical names. */
- for (i = x = 0; i < prc->n_vertical; i++)
+ for (i = x = 0; i < target->n_vertical; i++)
{
- struct variable *v = cmd.v_variables[i];
+ const struct variable *v = cmd.v_variables[i];
+ const char *name = var_get_name (v);
+ size_t name_len = strlen (name);
+ const struct fmt_spec *print = var_get_print_format (v);
size_t j;
- memset (&prc->header[prc->header_rows - 1][x], '-', v->print.w);
- x += v->print.w - 1;
- for (j = 0; j < strlen (v->name); j++)
- prc->header[strlen (v->name) - j - 1][x] = v->name[j];
+ memset (&target->header[target->header_rows - 1][x], '-', print->w);
+ x += print->w - 1;
+ for (j = 0; j < name_len; j++)
+ target->header[name_len - j - 1][x] = name[j];
x += 2;
}
/* Put in horizontal names. */
for (; i < cmd.n_variables; i++)
{
- struct variable *v = cmd.v_variables[i];
-
- memset (&prc->header[prc->header_rows - 1][x], '-',
- max (v->print.w, (int) strlen (v->name)));
- if ((int) strlen (v->name) < v->print.w)
- x += v->print.w - strlen (v->name);
- memcpy (&prc->header[0][x], v->name, strlen (v->name));
- x += strlen (v->name) + 1;
+ const struct variable *v = cmd.v_variables[i];
+ const char *name = var_get_name (v);
+ size_t name_len = strlen (name);
+ const struct fmt_spec *print = var_get_print_format (v);
+
+ memset (&target->header[target->header_rows - 1][x], '-',
+ MAX (print->w, (int) name_len));
+ if ((int) name_len < print->w)
+ x += print->w - name_len;
+ memcpy (&target->header[0][x], name, name_len);
+ x += name_len + 1;
}
/* Add null bytes. */
- for (i = 0; i < prc->header_rows; i++)
+ for (i = 0; i < target->header_rows; i++)
{
for (x = n_chars_width (d); x >= 1; x--)
- if (prc->header[i][x - 1] != ' ')
+ if (target->header[i][x - 1] != ' ')
{
- prc->header[i][x] = 0;
+ target->header[i][x] = 0;
break;
}
assert (x);
}
/* Write out the header, in back-to-front order except for the last line. */
- if (prc->header_rows >= 2)
+ if (target->header_rows >= 2)
{
size_t i;
-
- for (i = prc->header_rows - 1; i-- != 0; )
- write_line (d, prc->header[i]);
+
+ for (i = target->header_rows - 1; i-- != 0; )
+ write_line (d, target->header[i]);
}
- write_line (d, prc->header[prc->header_rows - 1]);
+ write_line (d, target->header[target->header_rows - 1]);
}
-
-
+
+
/* Frees up all the memory we've allocated. */
static void
-clean_up (void)
+clean_up (struct ll_list *targets)
{
- struct outp_driver *d;
-
- for (d = outp_drivers (NULL); d; d = outp_drivers (d))
- if (d->class->special == 0)
- {
- struct list_ext *prc = d->prc;
- size_t i;
+ struct list_target *target, *next;
- if (prc->header)
- {
- for (i = 0; i < prc->header_rows; i++)
- free (prc->header[i]);
- free (prc->header);
- }
- free (prc);
- }
- else if (d->class == &html_class)
- {
- if (d->page_open)
- {
- struct html_driver_ext *x = d->ext;
+ ll_for_each_safe (target, next, struct list_target, ll, targets)
+ {
+ struct outp_driver *d = target->driver;
+ if (d->class->special == 0)
+ {
+ if (target->header)
+ {
+ size_t i;
+ for (i = 0; i < target->header_rows; i++)
+ free (target->header[i]);
+ free (target->header);
+ }
+ }
+ else if (d->class == &html_class)
+ {
+ if (d->page_open)
+ {
+ struct html_driver_ext *x = d->ext;
- fputs ("</TABLE>\n", x->file);
- }
- }
- else
- assert (0);
+ fputs ("</TABLE>\n", x->file);
+ }
+ }
+ else
+ NOT_REACHED ();
+
+ ll_remove (&target->ll);
+ free (target);
+ }
free (cmd.v_variables);
}
{
struct outp_text text;
int width;
-
+
if (d->cp_x + outp_string_width (d, string, OUTP_FIXED) > d->width)
{
d->cp_y += d->font_height;
text.font = OUTP_FIXED;
text.justification = OUTP_LEFT;
- ls_init (&text.string, string, strlen (string));
+ text.string = ss_cstr (string);
text.x = d->cp_x;
text.y = d->cp_y;
text.h = text.v = INT_MAX;
write_fallback_headers (struct outp_driver *d)
{
const int max_width = n_chars_width(d) - 10;
-
+
int index = 0;
int width = 0;
int line_number = 0;
const char *Line = _("Line");
- char *leader = local_alloc (strlen (Line)
- + INT_STRLEN_BOUND (line_number) + 1 + 1);
-
+ char *leader = xmalloca (strlen (Line)
+ + INT_STRLEN_BOUND (line_number) + 1 + 1);
+
while (index < cmd.n_variables)
{
struct outp_text text;
/* Ensure that there is enough room for a line of text. */
if (d->cp_y + d->font_height > d->length)
outp_eject_page (d);
-
+
/* The leader is a string like `Line 1: '. Write the leader. */
sprintf (leader, "%s %d:", Line, ++line_number);
text.font = OUTP_FIXED;
text.justification = OUTP_LEFT;
- ls_init (&text.string, leader, strlen (leader));
+ text.string = ss_cstr (leader);
text.x = 0;
text.y = d->cp_y;
text.h = text.v = INT_MAX;
entry:
{
- int var_width = cmd.v_variables[index]->print.w;
+ int var_width = var_get_print_format (cmd.v_variables[index])->w;
if (width + var_width > max_width && width != 0)
{
width = 0;
}
width += var_width;
}
-
+
{
- char varname[LONG_NAME_LEN + 2];
+ char varname[VAR_NAME_LEN + 2];
snprintf (varname, sizeof varname,
- " %s", cmd.v_variables[index]->name);
+ " %s", var_get_name (cmd.v_variables[index]));
write_varname (d, varname, leader_width);
}
}
}
d->cp_x = 0;
d->cp_y += d->font_height;
-
- local_free (leader);
+
+ freea (leader);
}
/* There are three possible layouts for the LIST procedure:
This is complicated by the fact that we have to do all this for
every output driver, not just once. */
static void
-determine_layout (void)
+determine_layout (struct ll_list *targets)
{
struct outp_driver *d;
-
+
/* This is the largest page width of any driver, so we can tell what
size buffer to allocate. */
int largest_page_width = 0;
-
+
+ ll_init (targets);
for (d = outp_drivers (NULL); d; d = outp_drivers (d))
{
size_t column; /* Current column. */
int height; /* Height of vertical names. */
int max_width; /* Page width. */
- struct list_ext *prc;
+ struct list_target *target;
+
+ target = xmalloc (sizeof *target);
+ ll_push_tail (targets, &target->ll);
+ target->driver = d;
+ target->type = 0;
+ target->n_vertical = 0;
+ target->header = NULL;
if (d->class == &html_class)
continue;
-
assert (d->class->special == 0);
outp_open_page (d);
-
- max_width = n_chars_width (d);
- largest_page_width = max (largest_page_width, max_width);
- prc = d->prc = xmalloc (sizeof *prc);
- prc->type = 0;
- prc->n_vertical = 0;
- prc->header = NULL;
+ max_width = n_chars_width (d);
+ largest_page_width = MAX (largest_page_width, max_width);
/* Try layout #1. */
for (width = cmd.n_variables - 1, column = 0; column < cmd.n_variables; column++)
{
- struct variable *v = cmd.v_variables[column];
- width += max (v->print.w, (int) strlen (v->name));
+ const struct variable *v = cmd.v_variables[column];
+ int fmt_width = var_get_print_format (v)->w;
+ int name_len = strlen (var_get_name (v));
+ width += MAX (fmt_width, name_len);
}
if (width <= max_width)
{
- prc->header_rows = 2;
+ target->header_rows = 2;
continue;
}
/* Try layout #2. */
for (width = cmd.n_variables - 1, height = 0, column = 0;
column < cmd.n_variables && width <= max_width;
- column++)
+ column++)
{
- struct variable *v = cmd.v_variables[column];
- width += v->print.w;
- if (strlen (v->name) > height)
- height = strlen (v->name);
+ const struct variable *v = cmd.v_variables[column];
+ int fmt_width = var_get_print_format (v)->w;
+ size_t name_len = strlen (var_get_name (v));
+ width += fmt_width;
+ if (name_len > height)
+ height = name_len;
}
-
+
/* If it fit then we need to determine how many labels can be
written horizontally. */
if (width <= max_width && height <= SHORT_NAME_LEN)
{
#ifndef NDEBUG
- prc->n_vertical = SIZE_MAX;
+ target->n_vertical = SIZE_MAX;
#endif
for (column = cmd.n_variables; column-- != 0; )
{
- struct variable *v = cmd.v_variables[column];
- int trial_width = (width - v->print.w
- + max (v->print.w, (int) strlen (v->name)));
-
+ const struct variable *v = cmd.v_variables[column];
+ int name_len = strlen (var_get_name (v));
+ int fmt_width = var_get_print_format (v)->w;
+ int trial_width = width - fmt_width + MAX (fmt_width, name_len);
if (trial_width > max_width)
{
- prc->n_vertical = column + 1;
+ target->n_vertical = column + 1;
break;
}
width = trial_width;
}
- assert (prc->n_vertical != SIZE_MAX);
+ assert (target->n_vertical != SIZE_MAX);
- prc->n_vertical = cmd.n_variables;
+ target->n_vertical = cmd.n_variables;
/* Finally determine the length of the headers. */
- for (prc->header_rows = 0, column = 0;
- column < prc->n_vertical;
+ for (target->header_rows = 0, column = 0;
+ column < target->n_vertical;
column++)
- prc->header_rows = max (prc->header_rows,
- strlen (cmd.v_variables[column]->name));
- prc->header_rows++;
+ {
+ const struct variable *var = cmd.v_variables[column];
+ size_t name_len = strlen (var_get_name (var));
+ target->header_rows = MAX (target->header_rows, name_len);
+ }
+ target->header_rows++;
continue;
}
/* Otherwise use the ugly fallback listing format. */
- prc->type = 1;
- prc->header_rows = 0;
+ target->type = 1;
+ target->header_rows = 0;
d->cp_y += d->font_height;
write_fallback_headers (d);
d->cp_y += d->font_height;
}
- ds_init (&line_buffer);
+ ds_init_empty (&line_buffer);
}
/* Writes case C to output. */
-static bool
-list_cases (const struct ccase *c, void *aux UNUSED)
+static void
+list_case (const struct ccase *c, casenumber case_idx,
+ const struct dataset *ds, struct ll_list *targets)
{
- struct outp_driver *d;
-
- case_idx++;
- if (case_idx < cmd.first || case_idx > cmd.last
- || (cmd.step != 1 && (case_idx - cmd.first) % cmd.step))
- return true;
-
- for (d = outp_drivers (NULL); d; d = outp_drivers (d))
- if (d->class->special == 0)
- {
- const struct list_ext *prc = d->prc;
- const int max_width = n_chars_width (d);
- int column;
-
- if (!prc->header_rows)
- {
- ds_printf(&line_buffer, "%8s: ", cmd.v_variables[0]->name);
- }
-
-
- for (column = 0; column < cmd.n_variables; column++)
- {
- struct variable *v = cmd.v_variables[column];
- int width;
-
- if (prc->type == 0 && column >= prc->n_vertical)
- width = max ((int) strlen (v->name), v->print.w);
- else
- width = v->print.w;
+ struct dictionary *dict = dataset_dict (ds);
+ const char *encoding = dict_get_encoding (dict);
+ struct list_target *target;
- if (width + ds_length(&line_buffer) > max_width &&
- ds_length(&line_buffer) != 0)
- {
- if (!n_lines_remaining (d))
- {
- outp_eject_page (d);
- write_header (d);
- }
-
- write_line (d, ds_c_str(&line_buffer));
- ds_clear(&line_buffer);
-
- if (!prc->header_rows)
- {
- ds_printf (&line_buffer, "%8s: ", v->name);
- }
- }
-
- if (width > v->print.w)
- {
- ds_putc_multiple(&line_buffer, ' ', width - v->print.w);
- }
-
- if ((formats[v->print.type].cat & FCAT_STRING) || v->fv != -1)
- {
- data_out (ds_append_uninit(&line_buffer, v->print.w),
- &v->print, case_data (c, v->fv));
- }
- else
- {
- union value case_idx_value;
- case_idx_value.f = case_idx;
- data_out (ds_append_uninit(&line_buffer,v->print.w),
- &v->print, &case_idx_value);
- }
-
- ds_putc(&line_buffer, ' ');
- }
-
- if (!n_lines_remaining (d))
- {
- outp_eject_page (d);
- write_header (d);
- }
-
- write_line (d, ds_c_str(&line_buffer));
- ds_clear(&line_buffer);
- }
- else if (d->class == &html_class)
- {
- struct html_driver_ext *x = d->ext;
- int column;
-
- fputs (" <TR>\n", x->file);
-
- for (column = 0; column < cmd.n_variables; column++)
- {
- struct variable *v = cmd.v_variables[column];
- char buf[256];
- struct fixed_string s;
-
- if ((formats[v->print.type].cat & FCAT_STRING) || v->fv != -1)
- data_out (buf, &v->print, case_data (c, v->fv));
- else
- {
- union value case_idx_value;
- case_idx_value.f = case_idx;
- data_out (buf, &v->print, &case_idx_value);
- }
-
- ls_init (&s, buf, v->print.w);
- fputs (" <TD>", x->file);
- html_put_cell_contents (d, TAB_FIX, &s);
- fputs ("</TD>\n", x->file);
- }
-
- fputs (" </TR>\n", x->file);
- }
- else
- assert (0);
+ ll_for_each (target, struct list_target, ll, targets)
+ {
+ struct outp_driver *d = target->driver;
- return true;
+ if (d->class->special == 0)
+ {
+ const int max_width = n_chars_width (d);
+ int column;
+
+ if (!target->header_rows)
+ {
+ ds_put_format(&line_buffer, "%8s: ",
+ var_get_name (cmd.v_variables[0]));
+ }
+
+
+ for (column = 0; column < cmd.n_variables; column++)
+ {
+ const struct variable *v = cmd.v_variables[column];
+ const struct fmt_spec *print = var_get_print_format (v);
+ int width;
+ char *s;
+
+ if (target->type == 0 && column >= target->n_vertical)
+ {
+ int name_len = strlen (var_get_name (v));
+ width = MAX (name_len, print->w);
+ }
+ else
+ width = print->w;
+
+ if (width + ds_length(&line_buffer) > max_width &&
+ ds_length(&line_buffer) != 0)
+ {
+ if (!n_lines_remaining (d))
+ {
+ outp_eject_page (d);
+ write_header (target);
+ }
+
+ write_line (d, ds_cstr (&line_buffer));
+ ds_clear(&line_buffer);
+
+ if (!target->header_rows)
+ ds_put_format (&line_buffer, "%8s: ", var_get_name (v));
+ }
+
+ if (width > print->w)
+ ds_put_char_multiple(&line_buffer, ' ', width - print->w);
+
+ if (fmt_is_string (print->type) || dict_contains_var (dict, v))
+ s = data_out (case_data (c, v), encoding, print);
+ else
+ {
+ union value case_idx_value;
+ case_idx_value.f = case_idx;
+ s = data_out (&case_idx_value, encoding, print);
+ }
+
+ ds_put_cstr (&line_buffer, s);
+ free (s);
+ ds_put_char(&line_buffer, ' ');
+ }
+
+ if (!n_lines_remaining (d))
+ {
+ outp_eject_page (d);
+ write_header (target);
+ }
+
+ write_line (d, ds_cstr (&line_buffer));
+ ds_clear(&line_buffer);
+ }
+ else if (d->class == &html_class)
+ {
+ struct html_driver_ext *x = d->ext;
+ int column;
+
+ fputs (" <TR>\n", x->file);
+
+ for (column = 0; column < cmd.n_variables; column++)
+ {
+ const struct variable *v = cmd.v_variables[column];
+ const struct fmt_spec *print = var_get_print_format (v);
+ char *s;
+
+ if (fmt_is_string (print->type)
+ || dict_contains_var (dict, v))
+ s = data_out (case_data (c, v), encoding, print);
+ else
+ {
+ union value case_idx_value;
+ case_idx_value.f = case_idx;
+ s = data_out (&case_idx_value, encoding, print);
+ }
+
+ fputs (" <TD>", x->file);
+ html_put_cell_contents (d, TAB_FIX, ss_cstr (s));
+ fputs ("</TD>\n", x->file);
+
+ free (s);
+ }
+
+ fputs (" </TR>\n", x->file);
+ }
+ else
+ NOT_REACHED ();
+ }
}
-/*
+
+/*
Local Variables:
mode: c
End: