X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fdata-io%2Flist.q;h=d10a49d172592e0580e5015872ac2624c67c44d5;hb=9aac12c2130257396c9ee4ee7860f618dcb202b0;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..d10a49d1 100644
--- a/src/language/data-io/list.q
+++ b/src/language/data-io/list.q
@@ -1,6 +1,5 @@
 /* PSPP - computes sample statistics.
-   Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
-   Written by Ben Pfaff <blp@gnu.org>.
+   Copyright (C) 1997-9, 2000, 2006 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
@@ -18,40 +17,46 @@
    02110-1301, USA. */
 
 #include <config.h>
-#include "message.h"
+
 #include <stdio.h>
 #include <stdlib.h>
-#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 "intprops.h"
 #include "size_max.h"
-#include "manager.h"
-#include "table.h"
-#include "variable.h"
-#include "procedure.h"
-#include "format.h"
+#include <data/case.h>
+#include <data/dictionary.h>
+#include <data/data-out.h>
+#include <data/format.h>
+#include <data/procedure.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/message.h>
+#include <libpspp/misc.h>
+#include <output/htmlP.h>
+#include <output/manager.h>
+#include <output/output.h>
+#include <output/table.h>
+
+#include "minmax.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,
+             weight:weight/!noweight.
 */
 /* (declarations) */
 /* (functions) */
@@ -72,19 +77,19 @@ static struct cmd_list cmd;
 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 bool list_cases (const struct ccase *, void *, 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 (void *);
+static void write_all_headers (const struct ccase *, void *, const struct dataset*);
 
 /* Returns the number of text lines that can fit on the remainder of
    the page. */
@@ -108,15 +113,17 @@ 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;
@@ -124,12 +131,12 @@ write_line (struct outp_driver *d, char *s)
     
 /* Parses and executes the LIST procedure. */
 int
-cmd_list (void)
+cmd_list (struct lexer *lexer, struct dataset *ds)
 {
-  struct variable casenum_var;
+  struct variable *casenum_var = NULL;
   bool ok;
 
-  if (!parse_list (&cmd))
+  if (!parse_list (lexer, ds, &cmd, NULL))
     return CMD_FAILURE;
   
   /* Fill in defaults. */
@@ -140,7 +147,7 @@ cmd_list (void)
   if (cmd.last == NOT_LONG)
     cmd.last = LONG_MAX;
   if (!cmd.sbc_variables)
-    dict_get_vars (default_dict, &cmd.v_variables, &cmd.n_variables,
+    dict_get_vars (dataset_dict (ds), &cmd.v_variables, &cmd.n_variables,
 		   (1u << DC_SYSTEM) | (1u << DC_SCRATCH));
   if (cmd.n_variables == 0)
     {
@@ -180,12 +187,12 @@ cmd_list (void)
   /* Weighting variable. */
   if (cmd.weight == LST_WEIGHT)
     {
-      if (dict_get_weight (default_dict) != NULL)
+      if (dict_get_weight (dataset_dict (ds)) != 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 (dataset_dict (ds)))
 	      break;
 	  if (i >= cmd.n_variables)
 	    {
@@ -194,7 +201,7 @@ cmd_list (void)
 	      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 (dataset_dict (ds));
 	    }
 	}
       else
@@ -205,12 +212,10 @@ cmd_list (void)
   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++;
@@ -218,27 +223,30 @@ cmd_list (void)
                                    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 ();
 
   case_idx = 0;
-  ok = procedure_with_splits (write_all_headers, list_cases, NULL, NULL);
-  free (line_buf);
+  ok = procedure_with_splits (ds, write_all_headers, list_cases, NULL, NULL);
+  ds_destroy(&line_buffer);
 
   clean_up ();
 
+  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 (void *aux UNUSED)
+write_all_headers (const struct ccase *c, void *aux UNUSED, const struct dataset *ds)
 {
   struct outp_driver *d;
 
+  output_split_file_values (ds, c);
   for (d = outp_drivers (NULL); d; d = outp_drivers (d))
     {
       if (!d->class->special)
@@ -250,28 +258,20 @@ write_all_headers (void *aux UNUSED)
 	{
 	  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 ("<TABLE BORDER=1>\n  <TR>\n", x->file.file);
+	  fputs ("<TABLE BORDER=1>\n  <TR>\n", x->file);
 	  
 	  {
 	    size_t i;
 
 	    for (i = 0; i < cmd.n_variables; i++)
-	      fprintf (x->file.file, "    <TH><I><B>%s</B></I></TH>\n",
-		       cmd.v_variables[i]->name);
+	      fprintf (x->file, "    <TH><EM>%s</EM></TH>\n",
+		       var_get_name (cmd.v_variables[i]));
 	  }
 
-	  fputs ("  <TR>\n", x->file.file);
+	  fputs ("  </TR>\n", x->file);
 	}
       else
-	assert (0);
+	NOT_REACHED ();
     }
 }
 
@@ -312,12 +312,15 @@ write_header (struct outp_driver *d)
       for (i = x = 0; i < prc->n_vertical; i++)
 	{
 	  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 (&prc->header[prc->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];
 	  x += 2;
 	}
 
@@ -325,13 +328,16 @@ write_header (struct outp_driver *d)
       for (; i < cmd.n_variables; i++)
 	{
 	  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 (&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;
+		  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);
+	  x += name_len + 1;
 	}
 
       /* Add null bytes. */
@@ -378,20 +384,18 @@ clean_up (void)
 	    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)
+	if (d->page_open)
 	  {
 	    struct html_driver_ext *x = d->ext;
 
-	    fputs ("</TABLE>\n", x->file.file);
+	    fputs ("</TABLE>\n", x->file);
 	  }
       }
     else
-      assert (0);
+      NOT_REACHED ();
   
   free (cmd.v_variables);
 }
@@ -403,12 +407,9 @@ static void
 write_varname (struct outp_driver *d, char *string, int indent)
 {
   struct outp_text text;
-
-  text.options = OUTP_T_JUST_LEFT;
-  ls_init (&text.s, string, strlen (string));
-  d->class->text_metrics (d, &text);
+  int width;
   
-  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 +417,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
@@ -434,24 +440,29 @@ write_fallback_headers (struct outp_driver *d)
   int line_number = 0;
 
   const char *Line = _("Line");
-  char *leader = local_alloc (strlen (Line) + INT_DIGITS + 1 + 1);
+  char *leader = local_alloc (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 +471,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;
@@ -472,9 +483,10 @@ write_fallback_headers (struct outp_driver *d)
 	  }
 	  
 	  {
-	    char varname[10];
-	    sprintf (varname, " %s", cmd.v_variables[index]->name);
-	    write_varname (d, varname, text.h);
+	    char varname[LONG_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);
@@ -525,11 +537,10 @@ determine_layout (void)
       
       assert (d->class->special == 0);
 
-      if (!d->page_open)
-	d->class->open_page (d);
+      outp_open_page (d);
       
       max_width = n_chars_width (d);
-      largest_page_width = max (largest_page_width, max_width);
+      largest_page_width = MAX (largest_page_width, max_width);
 
       prc = d->prc = xmalloc (sizeof *prc);
       prc->type = 0;
@@ -540,12 +551,13 @@ determine_layout (void)
       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));
+          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");
 	  continue;
 	}
 
@@ -555,9 +567,11 @@ determine_layout (void)
 	   column++) 
         {
           struct variable *v = cmd.v_variables[column];
-          width += v->print.w;
-          if (strlen (v->name) > height)
-            height = strlen (v->name);
+          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
@@ -570,9 +584,9 @@ determine_layout (void)
 	  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)));
-	      
+              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;
@@ -586,12 +600,13 @@ determine_layout (void)
 	  /* Finally determine the length of the headers. */
 	  for (prc->header_rows = 0, column = 0;
 	       column < prc->n_vertical;
-	       column++)
-	    prc->header_rows = max (prc->header_rows,
-				    strlen (cmd.v_variables[column]->name));
+	       column++) 
+            {
+              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); 
+            }
 	  prc->header_rows++;
-
-	  d->class->text_set_font_by_name (d, "FIXED");
 	  continue;
 	}
 
@@ -602,15 +617,14 @@ determine_layout (void)
       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)
+list_cases (const struct ccase *c, void *aux UNUSED, const struct dataset *ds)
 {
   struct outp_driver *d;
   
@@ -625,22 +639,30 @@ list_cases (struct ccase *c, void *aux UNUSED)
 	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);
+	  {
+	    ds_put_format(&line_buffer, "%8s: ",
+                          var_get_name (cmd.v_variables[0]));
+	  }
+	
       
 	for (column = 0; column < cmd.n_variables; column++)
 	  {
 	    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)
-	      width = max ((int) strlen (v->name), v->print.w);
+	    if (prc->type == 0 && column >= prc->n_vertical) 
+              {
+                int name_len = strlen (var_get_name (v));
+                width = MAX (name_len, print->w); 
+              }
 	    else
-	      width = v->print.w;
+	      width = print->w;
 
-	    if (width + x > max_width && x != 0)
+	    if (width + ds_length(&line_buffer) > max_width && 
+		ds_length(&line_buffer) != 0)
 	      {
 		if (!n_lines_remaining (d))
 		  {
@@ -648,31 +670,31 @@ list_cases (struct ccase *c, void *aux UNUSED)
 		    write_header (d);
 		  }
 	      
-		line_buf[x] = 0;
-		write_line (d, line_buf);
+		write_line (d, ds_cstr (&line_buffer));
+		ds_clear(&line_buffer);
 
-		x = 0;
 		if (!prc->header_rows)
-		  x = nsprintf (line_buf, "%8s: ", v->name);
+                  ds_put_format (&line_buffer, "%8s: ", var_get_name (v));
 	      }
 
-	    if (width > v->print.w)
+	    if (width > print->w)
+              ds_put_char_multiple(&line_buffer, ' ', width - print->w);
+
+            if (fmt_is_string (print->type)
+                || dict_contains_var (dataset_dict (ds), v))
 	      {
-		memset(&line_buf[x], ' ', width - v->print.w);
-		x += width - v->print.w;
+                data_out (case_data (c, v), print,
+                          ds_put_uninit (&line_buffer, 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); 
+                data_out (&case_idx_value, print,
+                          ds_put_uninit (&line_buffer,print->w)); 
               }
-	    x += v->print.w;
-	  
-	    line_buf[x++] = ' ';
+
+	    ds_put_char(&line_buffer, ' ');
 	  }
       
 	if (!n_lines_remaining (d))
@@ -681,39 +703,41 @@ list_cases (struct ccase *c, void *aux UNUSED)
 	    write_header (d);
 	  }
 	      
-	line_buf[x] = 0;
-	write_line (d, line_buf);
+	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.file);
+	fputs ("  <TR>\n", x->file);
 	
 	for (column = 0; column < cmd.n_variables; column++)
 	  {
 	    struct variable *v = cmd.v_variables[column];
-	    char buf[41];
+            const struct fmt_spec *print = var_get_print_format (v);
+	    char buf[256];
 	    
-            if ((formats[v->print.type].cat & FCAT_STRING) || v->fv != -1)
-	      data_out (buf, &v->print, case_data (c, v->fv));
+            if (fmt_is_string (print->type)
+                || dict_contains_var (dataset_dict (ds), v))
+	      data_out (case_data (c, v), print, buf);
             else 
               {
                 union value case_idx_value;
                 case_idx_value.f = case_idx;
-                data_out (buf, &v->print, &case_idx_value); 
+                data_out (&case_idx_value, print, buf);
               }
-	    buf[v->print.w] = 0;
 
-	    fprintf (x->file.file, "    <TD ALIGN=RIGHT>%s</TD>\n",
-		     &buf[strspn (buf, " ")]);
+            fputs ("    <TD>", x->file);
+            html_put_cell_contents (d, TAB_FIX, ss_buffer (buf, print->w));
+            fputs ("</TD>\n", x->file);
 	  }
 	  
-	fputs ("  </TR>\n", x->file.file);
+	fputs ("  </TR>\n", x->file);
       }
     else
-      assert (0);
+      NOT_REACHED ();
 
   return true;
 }