X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=perl-module%2FPSPP.xs;h=94ca9b01834b9fd968319a75e736c4ecd1ef71be;hb=69c134ad8584c6c0dbbd908ed8ed278e920445a9;hp=7a3103e15d0e47a3e27914f8a8d0e61464cd3681;hpb=66b1b93cf6ca53c86199e88e5972f3017c56314c;p=pspp-builds.git

diff --git a/perl-module/PSPP.xs b/perl-module/PSPP.xs
index 7a3103e1..94ca9b01 100644
--- a/perl-module/PSPP.xs
+++ b/perl-module/PSPP.xs
@@ -1,5 +1,5 @@
 /* PSPP - computes sample statistics.
-   Copyright (C) 2007 Free Software Foundation, Inc.
+   Copyright (C) 2007, 2008, 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
@@ -31,12 +31,18 @@
 #include <gl/xalloc.h>
 #include <data/dictionary.h>
 #include <data/case.h>
+#include <data/casereader.h>
 #include <data/variable.h>
+#include <data/attributes.h>
 #include <data/file-handle-def.h>
 #include <data/sys-file-writer.h>
+#include <data/sys-file-reader.h>
 #include <data/value.h>
+#include <data/vardict.h>
+#include <data/value-labels.h>
 #include <data/format.h>
 #include <data/data-in.h>
+#include <data/data-out.h>
 #include <string.h>
 
 typedef struct fmt_spec input_format ;
@@ -46,16 +52,33 @@ typedef struct fmt_spec output_format ;
 /*  A thin wrapper around sfm_writer */
 struct sysfile_info
 {
-  bool opened; 
+  bool opened;
 
   /* A pointer to the writer. The writer is owned by the struct */
   struct casewriter *writer;
 
   /* A pointer to the dictionary. Owned externally */
   const struct dictionary *dict;
+
+  /* The scalar containing the dictionary */
+  SV *dict_sv;
 };
 
 
+/*  A thin wrapper around sfm_reader */
+struct sysreader_info
+{
+  struct sfm_read_info opts;
+
+  /* A pointer to the reader. The reader is owned by the struct */
+  struct casereader *reader;
+
+  /* A pointer to the dictionary. */
+  struct dictionary *dict;
+};
+
+
+
 /*  A message handler which writes messages to PSPP::errstr */
 static void
 message_handler (const struct msg *m)
@@ -79,34 +102,114 @@ sysfile_close (struct sysfile_info *sfi)
 }
 
 static void
-scalar_to_value (union value *val, SV *scalar)
+scalar_to_value (union value *val, SV *scalar, const struct variable *var)
 {
-  if ( looks_like_number (scalar))
+  if ( var_is_numeric (var))
     {
-	val->f = SvNV (scalar);
+	if ( SvNOK (scalar) || SvIOK (scalar) )
+	   val->f = SvNV (scalar);
+	else
+	   val->f = SYSMIS;
     }
   else
     {
 	STRLEN len;
-	char *p = SvPV (scalar, len);
-	memset (val->s, ' ', MAX_SHORT_STRING);
-	memcpy (val->s, p, len);
+	const char *p = SvPV (scalar, len);
+	int width = var_get_width (var);
+	value_set_missing (val, width);
+	memcpy (value_str_rw (val, width), p, len);
+    }
+}
+
+
+static SV *
+value_to_scalar (const union value *val, const struct variable *var)
+{
+  if ( var_is_numeric (var))
+    {
+      if ( var_is_value_missing (var, val, MV_SYSTEM))
+	return newSVpvn ("", 0);
+
+      return newSVnv (val->f);
+    }
+  else
+    {
+      int width = var_get_width (var);
+      return newSVpvn (value_str (val, width), width);
     }
 }
 
 
+static void
+var_set_input_format (struct variable *v, input_format ip_fmt)
+{
+  struct fmt_spec *if_copy = malloc (sizeof (*if_copy));
+  memcpy (if_copy, &ip_fmt, sizeof (ip_fmt));
+  var_attach_aux (v, if_copy, var_dtor_free);
+}
+
+static void
+make_value_from_scalar (union value *uv, SV *val, const struct variable *var)
+{
+ value_init (uv, var_get_width (var));
+ scalar_to_value (uv, val, var);
+}
+
+
 MODULE = PSPP
 
-BOOT:
+MODULE = PSPP		PACKAGE = PSPP
+
+void
+onBoot (ver)
+ const char *ver
+CODE:
+ assert (0 == strcmp (ver, bare_version));
+ i18n_init ();
  msg_init (NULL, message_handler);
  settings_init (0, 0);
  fh_init ();
 
+SV *
+format_value (val, var)
+ SV *val
+ struct variable *var
+CODE:
+ SV *ret;
+ const struct fmt_spec *fmt = var_get_print_format (var);
+ const struct dictionary *dict = var_get_vardict (var)->dict;
+ union value uv;
+ char *s;
+ make_value_from_scalar (&uv, val, var);
+ s = data_out (&uv, dict_get_encoding (dict), fmt);
+ value_destroy (&uv, var_get_width (var));
+ ret = newSVpv (s, fmt->w);
+ free (s);
+ RETVAL = ret;
+ OUTPUT:
+RETVAL
+
+
+int
+value_is_missing (val, var)
+ SV *val
+ struct variable *var
+CODE:
+ union value uv;
+ int ret;
+ make_value_from_scalar (&uv, val, var);
+ ret = var_is_value_missing (var, &uv, MV_ANY);
+ value_destroy (&uv, var_get_width (var));
+ RETVAL = ret;
+ OUTPUT:
+RETVAL
+
+
 
 MODULE = PSPP		PACKAGE = PSPP::Dict
 
 struct dictionary *
-_dict_new()
+pxs_dict_new()
 CODE:
  RETVAL = dict_create ();
 OUTPUT:
@@ -120,6 +223,14 @@ CODE:
  dict_destroy (dict);
 
 
+int
+get_var_cnt (dict)
+ struct dictionary *dict
+CODE:
+ RETVAL = dict_get_var_cnt (dict);
+OUTPUT:
+RETVAL
+
 void
 set_label (dict, label)
  struct dictionary *dict
@@ -158,11 +269,45 @@ CODE:
  dict_set_weight (dict, var);
 
 
+struct variable *
+pxs_get_variable (dict, idx)
+ struct dictionary *dict
+ SV *idx
+INIT:
+ SV *errstr = get_sv("PSPP::errstr", TRUE);
+ sv_setpv (errstr, "");
+ if ( SvIV (idx) >= dict_get_var_cnt (dict))
+  {
+    sv_setpv (errstr, "The dictionary doesn't have that many variables.");
+    XSRETURN_UNDEF;
+  }
+CODE:
+ RETVAL = dict_get_var (dict, SvIV (idx));
+ OUTPUT:
+RETVAL
+
+
+struct variable *
+pxs_get_var_by_name (dict, name)
+ struct dictionary *dict
+ const char *name
+INIT:
+ SV *errstr = get_sv("PSPP::errstr", TRUE);
+ sv_setpv (errstr, "");
+CODE:
+ struct variable *var = dict_lookup_var (dict, name);
+ if ( ! var )
+      sv_setpv (errstr, "No such variable.");
+ RETVAL = var;
+ OUTPUT:
+RETVAL
+
 
 MODULE = PSPP		PACKAGE = PSPP::Var
 
+
 struct variable *
-_dict_create_var (dict, name, ip_fmt)
+pxs_dict_create_var (dict, name, ip_fmt)
  struct dictionary * dict
  char *name
  input_format ip_fmt
@@ -176,7 +321,7 @@ INIT:
   }
 CODE:
  struct fmt_spec op_fmt;
- struct fmt_spec *if_copy;
+
  struct variable *v;
  op_fmt = fmt_for_output_from_input (&ip_fmt);
  v = dict_create_var (dict, name,
@@ -187,9 +332,7 @@ CODE:
     XSRETURN_UNDEF;
   }
  var_set_both_formats (v, &op_fmt);
- if_copy = malloc (sizeof (*if_copy));
- memcpy (if_copy, &ip_fmt, sizeof (ip_fmt));
- var_attach_aux (v, if_copy, var_dtor_free);
+ var_set_input_format (v, ip_fmt);
  RETVAL = v;
 OUTPUT:
  RETVAL
@@ -207,7 +350,7 @@ INIT:
   croak ("No more than 3 missing values are permitted");
 
  for (i = 0; i < items - 1; ++i)
-   scalar_to_value (&val[i], ST(i+1));
+   scalar_to_value (&val[i], ST(i+1), var);
 CODE:
  struct missing_values mv;
  mv_init (&mv, var_get_width (var));
@@ -222,7 +365,7 @@ set_label (var, label)
  char *label
 CODE:
   var_set_label (var, label);
- 
+
 
 void
 clear_value_labels (var)
@@ -231,7 +374,7 @@ CODE:
  var_clear_value_labels (var);
 
 void
-_set_write_format (var, fmt)
+pxs_set_write_format (var, fmt)
  struct variable *var
  output_format fmt
 CODE:
@@ -239,14 +382,14 @@ CODE:
 
 
 void
-_set_print_format (var, fmt)
+pxs_set_print_format (var, fmt)
  struct variable *var
  output_format fmt
 CODE:
  var_set_print_format (var, &fmt);
 
 void
-_set_output_format (var, fmt)
+pxs_set_output_format (var, fmt)
  struct variable *var
  output_format fmt
 CODE:
@@ -263,26 +406,27 @@ INIT:
  sv_setpv (errstr, "");
 CODE:
  union value the_value;
+ int width = var_get_width (var);
+ int ok;
 
+ value_init (&the_value, width);
  if ( var_is_numeric (var))
  {
   if ( ! looks_like_number (key))
     {
       sv_setpv (errstr, "Cannot add label with string key to a numeric variable");
+      value_destroy (&the_value, width);
       XSRETURN_IV (0);
     }
   the_value.f = SvNV (key);
  }
  else
  {
-   if ( var_is_long_string (var) )
-     {
-      sv_setpv (errstr, "Cannot add label to a long string variable");
-      XSRETURN_IV (0);
-     }
-  strncpy (the_value.s, SvPV_nolen(key), MAX_SHORT_STRING);
+  value_copy_str_rpad (&the_value, width, SvPV_nolen(key), ' ');
  }
- if (! var_add_value_label (var, &the_value, label) )
+ ok = var_add_value_label (var, &the_value, label);
+ value_destroy (&the_value, width);
+ if (!ok)
  {
    sv_setpv (errstr, "Something went wrong");
    XSRETURN_IV (0);
@@ -290,16 +434,101 @@ CODE:
  XSRETURN_IV (1);
 
 
+SV *
+get_attributes (var)
+ struct variable *var
+CODE:
+ HV *attrhash = (HV *) sv_2mortal ((SV *) newHV());
+
+ struct attrset *as = var_get_attributes (var);
+
+ if ( as )
+   {
+     struct attrset_iterator iter;
+     struct attribute *attr;
+
+     for (attr = attrset_first (as, &iter);
+	  attr;
+	  attr = attrset_next (as, &iter))
+       {
+	 int i;
+	 const char *name = attribute_get_name (attr);
+
+	 AV *values = newAV ();
+
+	 for (i = 0 ; i < attribute_get_n_values (attr); ++i )
+	   {
+	     const char *value = attribute_get_value (attr, i);
+	     av_push (values, newSVpv (value, 0));
+	   }
+
+	 hv_store (attrhash, name, strlen (name),
+		   newRV_noinc ((SV*) values), 0);
+       }
+   }
+
+ RETVAL = newRV ((SV *) attrhash);
+ OUTPUT:
+RETVAL
+
+
+const char *
+get_name (var)
+ struct variable * var
+CODE:
+ RETVAL = var_get_name (var);
+ OUTPUT:
+RETVAL
+
+
+const char *
+get_label (var)
+ struct variable * var
+CODE:
+ RETVAL = var_get_label (var);
+ OUTPUT:
+RETVAL
+
+
+SV *
+get_value_labels (var)
+ struct variable *var
+CODE:
+ HV *labelhash = (HV *) sv_2mortal ((SV *) newHV());
+ const struct val_lab *vl;
+ struct val_labs_iterator *viter = NULL;
+ const struct val_labs *labels = var_get_value_labels (var);
+
+ if ( labels )
+   {
+     for (vl = val_labs_first (labels);
+	  vl;
+	  vl = val_labs_next (labels, vl))
+       {
+	 SV *sv = value_to_scalar (&vl->value, var);
+	 STRLEN len;
+	 const char *s = SvPV (sv, len);
+	 hv_store (labelhash, s, len, newSVpv (val_lab_get_label (vl), 0), 0);
+       }
+   }
+
+ RETVAL = newRV ((SV *) labelhash);
+ OUTPUT:
+RETVAL
+
+
 
 MODULE = PSPP		PACKAGE = PSPP::Sysfile
 
 
 struct sysfile_info *
-_create_sysfile (name, dict, opts_hr)
- char * name
- struct dictionary * dict
+pxs_create_sysfile (name, dict_ref, opts_hr)
+ char *name
+ SV *dict_ref
  SV *opts_hr
 INIT:
+ SV *dict_sv = SvRV (dict_ref);
+ struct dictionary *dict = (void *) SvIV (dict_sv);
  struct sfm_write_options opts;
  if (!SvROK (opts_hr))
   {
@@ -323,6 +552,9 @@ CODE:
  sfi->writer = sfm_open_writer (fh, dict, opts);
  sfi->dict = dict;
  sfi->opened = true;
+ sfi->dict_sv = dict_sv;
+ SvREFCNT_inc (sfi->dict_sv);
+ 
  RETVAL = sfi;
  OUTPUT:
 RETVAL
@@ -340,6 +572,7 @@ DESTROY (sfi)
  struct sysfile_info *sfi
 CODE:
  sysfile_close (sfi);
+ SvREFCNT_dec (sfi->dict_sv);
  free (sfi);
 
 int
@@ -359,42 +592,109 @@ CODE:
 
  const struct variable **vv;
  size_t nv;
- struct ccase c;
+ struct ccase *c;
+ SV *sv;
 
  if ( av_len (av_case) >= dict_get_var_cnt (sfi->dict))
    XSRETURN_UNDEF;
 
- case_create (&c, dict_get_next_value_idx (sfi->dict));
+ c =  case_create (dict_get_proto (sfi->dict));
 
  dict_get_vars (sfi->dict, &vv, &nv, 1u << DC_ORDINARY | 1u << DC_SYSTEM);
 
- SV *sv ;
  for (sv = av_shift (av_case); SvOK (sv);  sv = av_shift (av_case))
  {
     const struct variable *v = vv[i++];
-    struct substring ss = ss_cstr (SvPV_nolen (sv));
-    struct fmt_spec *ifmt = var_get_aux (v);
-
-    if ( ! data_in (ss, LEGACY_NATIVE, ifmt->type, 0, 0, 0, case_data_rw (&c, v),
-	var_get_width (v)) )
-     {
-	RETVAL = 0;
-	goto finish;
-     }
+    const struct fmt_spec *ifmt = var_get_aux (v);
+
+    /* If an input format has been set, then use it.
+       Otherwise just convert the raw value.
+    */
+    if ( ifmt )
+      {
+	struct substring ss = ss_cstr (SvPV_nolen (sv));
+	if ( ! data_in (ss, LEGACY_NATIVE, ifmt->type, 0, 0, 0,
+			case_data_rw (c, v),
+			var_get_width (v)) )
+	  {
+	    RETVAL = 0;
+	    goto finish;
+	  }
+      }
+    else
+      {
+	scalar_to_value (case_data_rw (c, v), sv, v);
+      }
  }
+
  /* The remaining variables must be sysmis or blank string */
  while (i < dict_get_var_cnt (sfi->dict))
  {
    const struct variable *v = vv[i++];
-   union value *val = case_data_rw (&c, v);
-   if ( var_is_numeric (v))
-	val->f = SYSMIS;
-   else
-	memset (val->s, ' ', var_get_width (v));
+   union value *val = case_data_rw (c, v);
+   value_set_missing (val, var_get_width (v));
  }
- RETVAL = casewriter_write (sfi->writer, &c);
+ RETVAL = casewriter_write (sfi->writer, c);
  finish:
- case_destroy (&c);
  free (vv);
 OUTPUT:
  RETVAL
+
+
+
+
+MODULE = PSPP		PACKAGE = PSPP::Reader
+
+struct sysreader_info *
+pxs_open_sysfile (name)
+ char * name
+CODE:
+ struct casereader *reader;
+ struct sysreader_info *sri = NULL;
+ struct file_handle *fh =
+ 	 fh_create_file (NULL, name, fh_default_properties () );
+
+ sri = xmalloc (sizeof (*sri));
+ sri->reader = sfm_open_reader (fh, &sri->dict, &sri->opts);
+
+ if ( NULL == sri->reader)
+ {
+   free (sri);
+   sri = NULL;
+ }
+
+ RETVAL = sri;
+ OUTPUT:
+RETVAL
+
+
+struct dictionary *
+pxs_get_dict (reader)
+ struct sysreader_info *reader;
+CODE:
+ RETVAL = reader->dict;
+ OUTPUT:
+RETVAL
+
+
+void
+get_next_case (sfr)
+ struct sysreader_info *sfr;
+PPCODE:
+ struct ccase *c;
+
+ if (c = casereader_read (sfr->reader))
+ {
+  int v;
+
+  EXTEND (SP, dict_get_var_cnt (sfr->dict));
+  for (v = 0; v < dict_get_var_cnt (sfr->dict); ++v )
+    {
+      const struct variable *var = dict_get_var (sfr->dict, v);
+      const union value *val = case_data (c, var);
+
+      PUSHs (sv_2mortal (value_to_scalar (val, var)));
+    }
+
+  case_unref (c);
+ }