/* PSPP - computes sample statistics.
- Copyright (C) 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2007, 2008, 2009, 2010 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
02110-1301, USA. */
+#include <config.h>
+
+/* The Gnulib "strftime" module defines my_strftime in <config.h> for use by
+ gl/strftime.c. Perl also defines my_strftime in embed.h for some other
+ purpose. The former definition doesn't matter in this file, so suppress it
+ to avoid a compiler warning. */
+#undef my_strftime
+
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
-#include <config.h>
-
#include "ppport.h"
#include "minmax.h"
#include <libpspp/message.h>
#include <libpspp/version.h>
+#include <libpspp/i18n.h>
#include <gl/xalloc.h>
#include <data/dictionary.h>
#include <data/case.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 ;
{
STRLEN len;
const char *p = SvPV (scalar, len);
- memset (val->s, ' ', var_get_width (var));
- memcpy (val->s, p, len);
+ int width = var_get_width (var);
+ value_set_missing (val, width);
+ memcpy (value_str_rw (val, width), p, len);
}
}
return newSVnv (val->f);
}
else
- return newSVpvn (val->s, var_get_width (var));
+ {
+ int width = var_get_width (var);
+ return newSVpvn (value_str (val, width), width);
+ }
}
var_attach_aux (v, if_copy, var_dtor_free);
}
-static union value *
-make_value_from_scalar (SV *val, const struct variable *var)
+static void
+make_value_from_scalar (union value *uv, SV *val, const struct variable *var)
{
- union value *uv = value_create (var_get_width (var));
+ value_init (uv, var_get_width (var));
scalar_to_value (uv, val, var);
- return uv;
}
MODULE = PSPP PACKAGE = PSPP
+PROTOTYPES: ENABLE
+
void
onBoot (ver)
const char *ver
CODE:
- assert (0 == strcmp (ver, bare_version));
+ /* Check that the version is correct up to the length of 'ver'.
+ This allows PSPP autobuilders to add a "-build#" suffix to the
+ PSPP version without causing failures here. */
+ assert (0 == strncmp (ver, bare_version, strlen (ver)));
+
+ i18n_init ();
msg_init (NULL, message_handler);
settings_init (0, 0);
fh_init ();
CODE:
SV *ret;
const struct fmt_spec *fmt = var_get_print_format (var);
- union value *uv = make_value_from_scalar (val, var);
+ union value uv;
char *s;
- s = malloc (fmt->w);
- memset (s, '\0', fmt->w);
- data_out (uv, fmt, s);
- free (uv);
+ make_value_from_scalar (&uv, val, var);
+ s = data_out (&uv, var_get_encoding (var), fmt);
+ value_destroy (&uv, var_get_width (var));
ret = newSVpv (s, fmt->w);
free (s);
RETVAL = ret;
SV *val
struct variable *var
CODE:
- union value *uv = make_value_from_scalar (val, var);
- int ret = var_is_value_missing (var, uv, MV_ANY);
- free (uv);
+ 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
CODE:
var_clear_value_labels (var);
+SV *
+get_write_format (var)
+ struct variable *var
+CODE:
+ HV *fmthash = (HV *) sv_2mortal ((SV *) newHV());
+ const struct fmt_spec *fmt = var_get_write_format (var);
+
+ hv_store (fmthash, "fmt", 3, newSVnv (fmt->type), 0);
+ hv_store (fmthash, "decimals", 8, newSVnv (fmt->d), 0);
+ hv_store (fmthash, "width", 5, newSVnv (fmt->w), 0);
+
+ RETVAL = newRV ((SV *) fmthash);
+ OUTPUT:
+RETVAL
+
+SV *
+get_print_format (var)
+ struct variable *var
+CODE:
+ HV *fmthash = (HV *) sv_2mortal ((SV *) newHV());
+ const struct fmt_spec *fmt = var_get_print_format (var);
+
+ hv_store (fmthash, "fmt", 3, newSVnv (fmt->type), 0);
+ hv_store (fmthash, "decimals", 8, newSVnv (fmt->d), 0);
+ hv_store (fmthash, "width", 5, newSVnv (fmt->w), 0);
+
+ RETVAL = newRV ((SV *) fmthash);
+ OUTPUT:
+RETVAL
+
+
void
pxs_set_write_format (var, fmt)
struct variable *var
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);
struct variable *var
CODE:
HV *labelhash = (HV *) sv_2mortal ((SV *) newHV());
- struct val_lab *vl;
+ 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, &viter);
+ for (vl = val_labs_first (labels);
vl;
- vl = val_labs_next (labels, &viter))
+ 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 (vl->label, 0), 0);
+ hv_store (labelhash, s, len, newSVpv (val_lab_get_label (vl), 0), 0);
}
}
struct file_handle *fh =
fh_create_file (NULL, name, fh_default_properties () );
struct sysfile_info *sfi = xmalloc (sizeof (*sfi));
+ dict_set_encoding (dict, UTF8);
sfi->writer = sfm_open_writer (fh, dict, opts);
sfi->dict = dict;
sfi->opened = true;
if ( av_len (av_case) >= dict_get_var_cnt (sfi->dict))
XSRETURN_UNDEF;
- c = case_create (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);
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)) )
+ char *error;
+ bool ok;
+
+ error = data_in (ss, SvUTF8(sv) ? UTF8: "iso-8859-1", ifmt->type,
+ case_data_rw (c, v), var_get_width (v),
+ dict_get_encoding (sfi->dict));
+ ok = error == NULL;
+ free (error);
+
+ if ( !ok )
{
RETVAL = 0;
goto finish;
{
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));
+ value_set_missing (val, var_get_width (v));
}
- RETVAL = casewriter_write (sfi->writer, c);
+ casewriter_write (sfi->writer, c);
+ RETVAL = 1;
finish:
free (vv);
OUTPUT:
RETVAL
-SV *
+void
get_next_case (sfr)
struct sysreader_info *sfr;
-CODE:
+PPCODE:
struct ccase *c;
- if (! (c = casereader_read (sfr->reader)))
- {
- RETVAL = 0;
- }
- else
+ if (c = casereader_read (sfr->reader))
{
int v;
- AV *av_case = (AV *) sv_2mortal ((SV *) newAV());
+ 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);
- av_push (av_case, value_to_scalar (val, var));
+ PUSHs (sv_2mortal (value_to_scalar (val, var)));
}
case_unref (c);
- RETVAL = newRV ((SV *) av_case);
}
-OUTPUT:
- RETVAL
-