X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fdata-io%2Flist.q;h=871fa69ef4db6369fcda469e77eb81c1c9adae90;hb=c9a3c45e44c1c03d13d4eb186e3817bc836f75f8;hp=0834e2ad2b7ca4b0eea757eb5de9b9ce4f05ad16;hpb=dcf9b154cbcaa35c3d8459a201b77eec8bcb30bd;p=pspp-builds.git diff --git a/src/language/data-io/list.q b/src/language/data-io/list.q index 0834e2ad..871fa69e 100644 --- a/src/language/data-io/list.q +++ b/src/language/data-io/list.q @@ -1,64 +1,71 @@ -/* PSPP - computes sample statistics. - Copyright (C) 1997-9, 2000 Free Software Foundation, Inc. - Written by Ben Pfaff . +/* 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 . */ #include -#include "message.h" + +#include #include #include -#include "alloc.h" -#include "case.h" -#include "command.h" -#include "dictionary.h" -#include "lexer.h" -#include "message.h" -#include "magic.h" -#include "misc.h" -#include "htmlP.h" -#include "output.h" -#include "size_max.h" -#include "manager.h" -#include "table.h" -#include "variable.h" -#include "procedure.h" -#include "format.h" + +#include "intprops.h" +#include "xmalloca.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "minmax.h" +#include "xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) /* (headers) */ -#include "debug-print.h" - /* (specification) 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. */ /* (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. */ @@ -68,23 +75,22 @@ struct list_ext /* Parsed command. */ static struct cmd_list cmd; -/* Current case number. */ -static int case_idx; - /* Line buffer. */ -static char *line_buf; +static struct string line_buffer; /* TTY-style output functions. */ static unsigned n_lines_remaining (struct outp_driver *d); static unsigned n_chars_width (struct outp_driver *d); -static void write_line (struct outp_driver *d, char *s); +static void write_line (struct outp_driver *d, const char *s); /* Other functions. */ -static bool list_cases (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 (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. */ @@ -108,40 +114,47 @@ n_chars_width (struct outp_driver *d) /* Writes the line S at the current position and advances to the next line. */ static void -write_line (struct outp_driver *d, char *s) +write_line (struct outp_driver *d, const char *s) { struct outp_text text; - + assert (d->cp_y + d->font_height <= d->length); - text.options = OUTP_T_JUST_LEFT; - ls_init (&text.s, s, strlen (s)); + text.font = OUTP_FIXED; + text.justification = OUTP_LEFT; + text.string = ss_cstr (s); text.x = d->cp_x; text.y = d->cp_y; + text.h = text.v = INT_MAX; d->class->text_draw (d, &text); 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.")); @@ -177,57 +190,50 @@ cmd_list (void) cmd.step = 1; } - /* Weighting variable. */ - if (cmd.weight == LST_WEIGHT) - { - if (dict_get_weight (default_dict) != NULL) - { - size_t i; - - for (i = 0; i < cmd.n_variables; i++) - if (cmd.v_variables[i] == dict_get_weight (default_dict)) - break; - if (i >= cmd.n_variables) - { - /* Add the weight variable to the end of the variable list. */ - 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); - } - } - else - msg (SW, _("`/FORMAT WEIGHT' specified, but weighting is not on.")); - } - /* Case number. */ 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); - - /* Add the weight variable at the beginning of the variable list. */ + 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 case-number variable at the beginning of the variable list. */ cmd.n_variables++; cmd.v_variables = xnrealloc (cmd.v_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); - free (line_buf); + 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; } @@ -235,112 +241,119 @@ cmd_list (void) /* Writes headers to all devices. This is done at the beginning of each SPLIT FILE group. */ static void -write_all_headers (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; - 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; - - assert (d->driver_open); - if (x->sequence_no == 0 && !d->class->open_page (d)) - { - msg (ME, _("Cannot open first page on HTML device %s."), - d->name); - return; - } - fputs ("\n \n", x->file.file); - + fputs ("
\n \n", x->file); + { size_t i; for (i = 0; i < cmd.n_variables; i++) - fprintf (x->file.file, " \n", - cmd.v_variables[i]->name); + fprintf (x->file, " \n", + var_get_name (cmd.v_variables[i])); } - fputs (" \n", x->file.file); + fputs (" \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); @@ -348,50 +361,51 @@ write_header (struct outp_driver *d) } /* 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); - - d->class->text_set_font_by_name (d, "PROP"); - } - else if (d->class == &html_class) - { - if (d->driver_open && 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 ("
%s%s
\n", x->file.file); - } - } - else - assert (0); + fputs ("\n", x->file); + } + } + else + NOT_REACHED (); + + ll_remove (&target->ll); + free (target); + } free (cmd.v_variables); } @@ -403,12 +417,9 @@ static void write_varname (struct outp_driver *d, char *string, int indent) { struct outp_text text; + int width; - text.options = OUTP_T_JUST_LEFT; - ls_init (&text.s, string, strlen (string)); - d->class->text_metrics (d, &text); - - if (d->cp_x + text.h > d->width) + if (d->cp_x + outp_string_width (d, string, OUTP_FIXED) > d->width) { d->cp_y += d->font_height; if (d->cp_y + d->font_height > d->length) @@ -416,10 +427,15 @@ write_varname (struct outp_driver *d, char *string, int indent) d->cp_x = indent; } + text.font = OUTP_FIXED; + text.justification = OUTP_LEFT; + text.string = ss_cstr (string); text.x = d->cp_x; text.y = d->cp_y; + text.h = text.v = INT_MAX; d->class->text_draw (d, &text); - d->cp_x += text.h; + d->class->text_metrics (d, &text, &width, NULL); + d->cp_x += width; } /* When we can't fit all the values across the page, we write out all @@ -428,30 +444,35 @@ static void 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_DIGITS + 1 + 1); - + char *leader = xmalloca (strlen (Line) + + INT_STRLEN_BOUND (line_number) + 1 + 1); + while (index < cmd.n_variables) { struct outp_text text; + int leader_width; /* 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.options = OUTP_T_JUST_LEFT; - ls_init (&text.s, leader, strlen (leader)); + sprintf (leader, "%s %d:", Line, ++line_number); + text.font = OUTP_FIXED; + text.justification = OUTP_LEFT; + text.string = ss_cstr (leader); text.x = 0; text.y = d->cp_y; + text.h = text.v = INT_MAX; d->class->text_draw (d, &text); - d->cp_x = text.h; + d->class->text_metrics (d, &text, &leader_width, NULL); + d->cp_x = leader_width; goto entry; do @@ -460,7 +481,7 @@ write_fallback_headers (struct outp_driver *d) 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; @@ -470,11 +491,12 @@ write_fallback_headers (struct outp_driver *d) } width += var_width; } - + { - char varname[10]; - sprintf (varname, " %s", cmd.v_variables[index]->name); - write_varname (d, varname, text.h); + char varname[VAR_NAME_LEN + 2]; + snprintf (varname, sizeof varname, + " %s", var_get_name (cmd.v_variables[index])); + write_varname (d, varname, leader_width); } } while (++index < cmd.n_variables); @@ -482,8 +504,8 @@ write_fallback_headers (struct outp_driver *d) } d->cp_x = 0; d->cp_y += d->font_height; - - local_free (leader); + + freea (leader); } /* There are three possible layouts for the LIST procedure: @@ -503,14 +525,15 @@ write_fallback_headers (struct outp_driver *d) 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. */ @@ -518,207 +541,220 @@ determine_layout (void) 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); - if (!d->page_open) - d->class->open_page (d); - - max_width = n_chars_width (d); - largest_page_width = max (largest_page_width, max_width); + outp_open_page (d); - 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; - d->class->text_set_font_by_name (d, "FIXED"); + 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++; - - d->class->text_set_font_by_name (d, "FIXED"); + { + 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; - d->class->text_set_font_by_name (d, "FIXED"); } - line_buf = xmalloc (max (1022, largest_page_width) + 2); + ds_init_empty (&line_buffer); } /* Writes case C to output. */ -static bool -list_cases (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; + struct dictionary *dict = dataset_dict (ds); + const char *encoding = dict_get_encoding (dict); + struct list_target *target; - 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; - int x = 0; - - if (!prc->header_rows) - x = nsprintf (line_buf, "%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; - - if (width + x > max_width && x != 0) - { - if (!n_lines_remaining (d)) - { - outp_eject_page (d); - write_header (d); - } - - line_buf[x] = 0; - write_line (d, line_buf); - - x = 0; - if (!prc->header_rows) - x = nsprintf (line_buf, "%8s: ", v->name); - } - - if (width > v->print.w) - { - memset(&line_buf[x], ' ', width - v->print.w); - x += width - v->print.w; - } - - if ((formats[v->print.type].cat & FCAT_STRING) || v->fv != -1) - data_out (&line_buf[x], &v->print, case_data (c, v->fv)); - else - { - union value case_idx_value; - case_idx_value.f = case_idx; - data_out (&line_buf[x], &v->print, &case_idx_value); - } - x += v->print.w; - - line_buf[x++] = ' '; - } - - if (!n_lines_remaining (d)) - { - outp_eject_page (d); - write_header (d); - } - - line_buf[x] = 0; - write_line (d, line_buf); - } - else if (d->class == &html_class) - { - struct html_driver_ext *x = d->ext; - int column; - - fputs (" \n", x->file.file); - - for (column = 0; column < cmd.n_variables; column++) - { - struct variable *v = cmd.v_variables[column]; - char buf[41]; - - 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); - } - buf[v->print.w] = 0; - - fprintf (x->file.file, " %s\n", - &buf[strspn (buf, " ")]); - } - - fputs (" \n", x->file.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 (" \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 (" ", x->file); + html_put_cell_contents (d, TAB_FIX, ss_cstr (s)); + fputs ("\n", x->file); + + free (s); + } + + fputs (" \n", x->file); + } + else + NOT_REACHED (); + } } -/* + +/* Local Variables: mode: c End: