From 800214f0b286ce6862cf767c17197ce8107b8ef6 Mon Sep 17 00:00:00 2001 From: Ben Pfaff Date: Wed, 1 Jul 2009 15:54:50 -0700 Subject: [PATCH] LIST: Don't use outp_driver 'prc' member any longer. The LIST procedure is the only one that uses the 'prc' member of struct outp_driver. This commit gets rid of that use, so that 'prc' can be removed, as part of a larger output subsystem cleanup. --- src/language/data-io/list.q | 375 +++++++++++++++++++----------------- 1 file changed, 195 insertions(+), 180 deletions(-) diff --git a/src/language/data-io/list.q b/src/language/data-io/list.q index 28820a85..5f1b3a99 100644 --- a/src/language/data-io/list.q +++ b/src/language/data-io/list.q @@ -35,7 +35,7 @@ #include #include #include -#include +#include #include #include #include @@ -63,8 +63,10 @@ /* (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. */ @@ -84,11 +86,12 @@ static void write_line (struct outp_driver *d, const char *s); /* Other functions. */ static void list_case (const struct ccase *, casenumber case_idx, - const struct dataset *); -static void determine_layout (void); -static void clean_up (void); -static void write_header (struct outp_driver *); -static void write_all_headers (struct casereader *, const struct dataset*); + 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. */ @@ -136,6 +139,7 @@ cmd_list (struct lexer *lexer, struct dataset *ds) struct variable *casenum_var = NULL; struct casegrouper *grouper; struct casereader *group; + struct ll_list targets; casenumber case_idx; bool ok; @@ -229,7 +233,7 @@ cmd_list (struct lexer *lexer, struct dataset *ds) cmd.v_variables[0] = casenum_var; } - determine_layout (); + determine_layout (&targets); case_idx = 0; for (grouper = casegrouper_create_splits (proc_open (ds), dict); @@ -238,13 +242,13 @@ cmd_list (struct lexer *lexer, struct dataset *ds) { struct ccase *c; - write_all_headers (group, ds); + 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); + list_case (c, case_idx, ds, &targets); } } ok = casegrouper_destroy (grouper); @@ -252,7 +256,7 @@ cmd_list (struct lexer *lexer, struct dataset *ds) ds_destroy(&line_buffer); - clean_up (); + clean_up (&targets); var_destroy (casenum_var); @@ -262,9 +266,10 @@ cmd_list (struct lexer *lexer, struct dataset *ds) /* Writes headers to all devices. This is done at the beginning of each SPLIT FILE group. */ static void -write_all_headers (struct casereader *input, const struct dataset *ds) +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; c = casereader_peek (input, 0); @@ -273,12 +278,13 @@ write_all_headers (struct casereader *input, const struct dataset *ds) output_split_file_values (ds, c); case_unref (c); - for (d = outp_drivers (NULL); d; d = outp_drivers (d)) + 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) { @@ -304,38 +310,38 @@ write_all_headers (struct casereader *input, const struct dataset *ds) /* 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++) { const struct variable *v = cmd.v_variables[i]; const char *name = var_get_name (v); @@ -343,10 +349,10 @@ write_header (struct outp_driver *d) const struct fmt_spec *print = var_get_print_format (v); size_t j; - memset (&prc->header[prc->header_rows - 1][x], '-', print->w); + memset (&target->header[target->header_rows - 1][x], '-', print->w); x += print->w - 1; for (j = 0; j < name_len; j++) - prc->header[name_len - j - 1][x] = name[j]; + target->header[name_len - j - 1][x] = name[j]; x += 2; } @@ -358,21 +364,21 @@ write_header (struct outp_driver *d) size_t name_len = strlen (name); const struct fmt_spec *print = var_get_print_format (v); - memset (&prc->header[prc->header_rows - 1][x], '-', + 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 (&prc->header[0][x], name, 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); @@ -380,49 +386,52 @@ 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; + struct list_target *target, *next; - for (d = outp_drivers (NULL); d; d = outp_drivers (d)) - if (d->class->special == 0) - { - struct list_ext *prc = d->prc; - size_t i; - - 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 ("\n", x->file); - } - } - else - NOT_REACHED (); + fputs ("\n", x->file); + } + } + else + NOT_REACHED (); + ll_remove (&target->ll); + free (target); + } + free (cmd.v_variables); } @@ -541,7 +550,7 @@ 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; @@ -549,6 +558,7 @@ determine_layout (void) 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. */ @@ -556,11 +566,17 @@ 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); outp_open_page (d); @@ -568,11 +584,6 @@ determine_layout (void) 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; - /* Try layout #1. */ for (width = cmd.n_variables - 1, column = 0; column < cmd.n_variables; column++) { @@ -583,7 +594,7 @@ determine_layout (void) } if (width <= max_width) { - prc->header_rows = 2; + target->header_rows = 2; continue; } @@ -605,7 +616,7 @@ determine_layout (void) 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; ) { @@ -615,30 +626,30 @@ determine_layout (void) 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++) { const struct variable *var = cmd.v_variables[column]; size_t name_len = strlen (var_get_name (var)); - prc->header_rows = MAX (prc->header_rows, name_len); + target->header_rows = MAX (target->header_rows, name_len); } - prc->header_rows++; + 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); @@ -651,118 +662,122 @@ determine_layout (void) /* Writes case C to output. */ static void list_case (const struct ccase *c, casenumber case_idx, - const struct dataset *ds) + const struct dataset *ds, struct ll_list *targets) { struct dictionary *dict = dataset_dict (ds); - struct outp_driver *d; + 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; - - if (!prc->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; - - if (prc->type == 0 && column >= prc->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 (d); - } + ll_for_each (target, struct list_target, ll, targets) + { + struct outp_driver *d = target->driver; - write_line (d, ds_cstr (&line_buffer)); - ds_clear(&line_buffer); + if (d->class->special == 0) + { + const int max_width = n_chars_width (d); + int column; - if (!prc->header_rows) - ds_put_format (&line_buffer, "%8s: ", var_get_name (v)); - } + if (!target->header_rows) + { + ds_put_format(&line_buffer, "%8s: ", + var_get_name (cmd.v_variables[0])); + } - if (width > print->w) - ds_put_char_multiple(&line_buffer, ' ', width - print->w); - if (fmt_is_string (print->type) - || dict_contains_var (dict, v)) - { - data_out (case_data (c, v), print, - ds_put_uninit (&line_buffer, print->w)); - } - else - { - union value case_idx_value; - case_idx_value.f = case_idx; - data_out (&case_idx_value, print, - ds_put_uninit (&line_buffer,print->w)); - } - - ds_put_char(&line_buffer, ' '); - } + 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; + + 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)) + { + data_out (case_data (c, v), print, + ds_put_uninit (&line_buffer, print->w)); + } + else + { + union value case_idx_value; + case_idx_value.f = case_idx; + data_out (&case_idx_value, print, + ds_put_uninit (&line_buffer,print->w)); + } + + ds_put_char(&line_buffer, ' '); + } - if (!n_lines_remaining (d)) - { - outp_eject_page (d); - write_header (d); - } + 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; + 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); + 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 buf[256]; - - if (fmt_is_string (print->type) - || dict_contains_var (dict, v)) - data_out (case_data (c, v), print, buf); - else - { - union value case_idx_value; - case_idx_value.f = case_idx; - data_out (&case_idx_value, print, buf); - } - - fputs (" ", x->file); - html_put_cell_contents (d, TAB_FIX, ss_buffer (buf, print->w)); - 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 buf[256]; + + if (fmt_is_string (print->type) + || dict_contains_var (dict, v)) + data_out (case_data (c, v), print, buf); + else + { + union value case_idx_value; + case_idx_value.f = case_idx; + data_out (&case_idx_value, print, buf); + } + + fputs (" ", x->file); + html_put_cell_contents (d, TAB_FIX, ss_buffer (buf, print->w)); + fputs ("\n", x->file); + } - fputs (" \n", x->file); - } - else - NOT_REACHED (); + fputs (" \n", x->file); + } + else + NOT_REACHED (); + } } + /* Local Variables: mode: c -- 2.30.2