table-paste: Add error-checking assertion to table_paste().
[pspp] / perl-module / PSPP.xs
1 /* PSPP - computes sample statistics.
2    Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or
5    modify it under the terms of the GNU General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    License, or (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful, but
10    WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program; if not, write to the Free Software
16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17    02110-1301, USA. */
18
19
20 #include <config.h>
21
22 /* The Gnulib "strftime" module defines my_strftime in <config.h> for use by
23    gl/strftime.c.  Perl also defines my_strftime in embed.h for some other
24    purpose.  The former definition doesn't matter in this file, so suppress it
25    to avoid a compiler warning. */
26 #undef my_strftime
27
28 #include "EXTERN.h"
29 #include "perl.h"
30 #include "XSUB.h"
31
32 #include "ppport.h"
33
34 #include "minmax.h"
35 #include <libpspp/message.h>
36 #include <libpspp/version.h>
37 #include <libpspp/i18n.h>
38 #include <gl/xalloc.h>
39 #include <data/dictionary.h>
40 #include <data/case.h>
41 #include <data/casereader.h>
42 #include <data/casewriter.h>
43 #include <data/variable.h>
44 #include <data/attributes.h>
45 #include <data/file-handle-def.h>
46 #include <data/identifier.h>
47 #include <data/settings.h>
48 #include <data/sys-file-writer.h>
49 #include <data/sys-file-reader.h>
50 #include <data/value.h>
51 #include <data/vardict.h>
52 #include <data/value-labels.h>
53 #include <data/format.h>
54 #include <data/data-in.h>
55 #include <data/data-out.h>
56 #include <string.h>
57
58 typedef struct fmt_spec input_format ;
59 typedef struct fmt_spec output_format ;
60
61
62 /*  A thin wrapper around sfm_writer */
63 struct syswriter_info
64 {
65   bool opened;
66
67   /* A pointer to the writer. The writer is owned by the struct */
68   struct casewriter *writer;
69
70   /* A pointer to the dictionary. Owned externally */
71   const struct pspp_dict *dict;
72
73   /* The scalar containing the dictionary */
74   SV *dict_sv;
75 };
76
77
78 /*  A thin wrapper around sfm_reader */
79 struct sysreader_info
80 {
81   struct sfm_read_info opts;
82
83   /* A pointer to the reader. The reader is owned by the struct */
84   struct casereader *reader;
85
86   /* A pointer to the dictionary. */
87   struct pspp_dict *dict;
88 };
89
90
91 struct input_format {
92   struct hmap_node hmap_node;   /* In struct pspp_dict's input_formats map. */
93   const struct variable *var;
94   struct fmt_spec input_format;
95 };
96
97 /* A thin wrapper around struct dictionary.*/
98 struct pspp_dict {
99   struct dictionary *dict;
100   struct hmap input_formats;    /* Contains struct input_format. */
101 };
102
103
104 /*  A message handler which writes messages to PSPP::errstr */
105 static void
106 message_handler (const struct msg *m, void *aux)
107 {
108  SV *errstr = get_sv("PSPP::errstr", TRUE);
109  sv_setpv (errstr, m->text);
110 }
111
112 static int
113 sysfile_close (struct syswriter_info *swi)
114 {
115   int retval ;
116   if ( ! swi->opened )
117     return 0;
118
119   retval = casewriter_destroy (swi->writer);
120   if (retval > 0 )
121     swi->opened = false;
122
123   return retval;
124 }
125
126 static void
127 scalar_to_value (union value *val, SV *scalar, const struct variable *var)
128 {
129   if ( var_is_numeric (var))
130     {
131         if ( SvNOK (scalar) || SvIOK (scalar) )
132            val->f = SvNV (scalar);
133         else
134            val->f = SYSMIS;
135     }
136   else
137     {
138         STRLEN len;
139         const char *p = SvPV (scalar, len);
140         int width = var_get_width (var);
141         value_set_missing (val, width);
142         memcpy (value_str_rw (val, width), p, len);
143     }
144 }
145
146
147 static SV *
148 value_to_scalar (const union value *val, const struct variable *var)
149 {
150   if ( var_is_numeric (var))
151     {
152       if ( var_is_value_missing (var, val, MV_SYSTEM))
153         return newSVpvn ("", 0);
154
155       return newSVnv (val->f);
156     }
157   else
158     {
159       int width = var_get_width (var);
160       return newSVpvn (value_str (val, width), width);
161     }
162 }
163
164
165 static void
166 make_value_from_scalar (union value *uv, SV *val, const struct variable *var)
167 {
168  value_init (uv, var_get_width (var));
169  scalar_to_value (uv, val, var);
170 }
171
172 static struct pspp_dict *
173 create_pspp_dict (struct dictionary *dict)
174 {
175   struct pspp_dict *pspp_dict = xmalloc (sizeof *pspp_dict);
176   pspp_dict->dict = dict;
177   hmap_init (&pspp_dict->input_formats);
178   return pspp_dict;
179 }
180
181 static const struct fmt_spec *
182 find_input_format (const struct pspp_dict *dict, const struct variable *var)
183 {
184   struct input_format *input_format;
185
186   HMAP_FOR_EACH_IN_BUCKET (input_format, struct input_format, hmap_node,
187                            hash_pointer (var, 0), &dict->input_formats)
188     if (input_format->var == var)
189       return &input_format->input_format;
190
191   return NULL;
192 }
193
194
195 MODULE = PSPP
196
197 MODULE = PSPP           PACKAGE = PSPP
198
199 PROTOTYPES: ENABLE
200
201 void
202 onBoot (ver)
203  const char *ver
204 CODE:
205  /* Check that the version is correct up to the length of 'ver'.
206     This allows PSPP autobuilders to add a "-build#" suffix to the
207     PSPP version without causing failures here. */
208  assert (0 == strncmp (ver, bare_version, strlen (ver)));
209
210  i18n_init ();
211  msg_set_handler (message_handler, NULL);
212  settings_init ();
213  fh_init ();
214
215 SV *
216 format_value (val, var)
217  SV *val
218  struct variable *var
219 CODE:
220  SV *ret;
221  const struct fmt_spec *fmt = var_get_print_format (var);
222  union value uv;
223  char *s;
224  make_value_from_scalar (&uv, val, var);
225  s = data_out (&uv, var_get_encoding (var), fmt);
226  value_destroy (&uv, var_get_width (var));
227  ret = newSVpv (s, fmt->w);
228  free (s);
229  RETVAL = ret;
230  OUTPUT:
231 RETVAL
232
233
234 int
235 value_is_missing (val, var)
236  SV *val
237  struct variable *var
238 CODE:
239  union value uv;
240  int ret;
241  make_value_from_scalar (&uv, val, var);
242  ret = var_is_value_missing (var, &uv, MV_ANY);
243  value_destroy (&uv, var_get_width (var));
244  RETVAL = ret;
245  OUTPUT:
246 RETVAL
247
248
249
250 MODULE = PSPP           PACKAGE = PSPP::Dict
251
252 struct pspp_dict *
253 pxs_dict_new()
254 CODE:
255  RETVAL = create_pspp_dict (dict_create ("UTF-8"));
256 OUTPUT:
257  RETVAL
258
259
260 void
261 DESTROY (dict)
262  struct pspp_dict *dict
263 CODE:
264  if (dict != NULL)
265    {
266      struct input_format *input_format, *next_input_format;
267
268      HMAP_FOR_EACH_SAFE (input_format, next_input_format,
269                          struct input_format, hmap_node, &dict->input_formats)
270        {
271          hmap_delete (&dict->input_formats, &input_format->hmap_node);
272          free (input_format);
273        }
274      hmap_destroy (&dict->input_formats);
275      dict_destroy (dict->dict);
276      free (dict);
277    }
278
279 int
280 get_var_cnt (dict)
281  struct pspp_dict *dict
282 CODE:
283  RETVAL = dict_get_var_cnt (dict->dict);
284 OUTPUT:
285 RETVAL
286
287 void
288 set_label (dict, label)
289  struct pspp_dict *dict
290  char *label
291 CODE:
292  dict_set_label (dict->dict, label);
293
294 void
295 set_documents (dict, docs)
296  struct pspp_dict *dict
297  char *docs
298 CODE:
299  dict_set_documents_string (dict->dict, docs);
300
301
302 void
303 add_document (dict, doc)
304  struct pspp_dict *dict
305  char *doc
306 CODE:
307  dict_add_document_line (dict->dict, doc, false);
308
309
310 void
311 clear_documents (dict)
312  struct pspp_dict *dict
313 CODE:
314  dict_clear_documents (dict->dict);
315
316
317 void
318 set_weight (dict, var)
319  struct pspp_dict *dict
320  struct variable *var
321 CODE:
322  dict_set_weight (dict->dict, var);
323
324
325 struct variable *
326 pxs_get_variable (dict, idx)
327  struct pspp_dict *dict
328  SV *idx
329 INIT:
330  SV *errstr = get_sv("PSPP::errstr", TRUE);
331  sv_setpv (errstr, "");
332  if ( SvIV (idx) >= dict_get_var_cnt (dict->dict))
333   {
334     sv_setpv (errstr, "The dictionary doesn't have that many variables.");
335     XSRETURN_UNDEF;
336   }
337 CODE:
338  RETVAL = dict_get_var (dict->dict, SvIV (idx));
339  OUTPUT:
340 RETVAL
341
342
343 struct variable *
344 pxs_get_var_by_name (dict, name)
345  struct pspp_dict *dict
346  const char *name
347 INIT:
348  SV *errstr = get_sv("PSPP::errstr", TRUE);
349  sv_setpv (errstr, "");
350 CODE:
351  struct variable *var = dict_lookup_var (dict->dict, name);
352  if ( ! var )
353       sv_setpv (errstr, "No such variable.");
354  RETVAL = var;
355  OUTPUT:
356 RETVAL
357
358
359 MODULE = PSPP           PACKAGE = PSPP::Var
360
361
362 struct variable *
363 pxs_dict_create_var (dict, name, ip_fmt)
364  struct pspp_dict * dict
365  char *name
366  input_format ip_fmt
367 INIT:
368  SV *errstr = get_sv("PSPP::errstr", TRUE);
369  sv_setpv (errstr, "");
370  if ( ! id_is_plausible (name, false))
371   {
372     sv_setpv (errstr, "The variable name is not valid.");
373     XSRETURN_UNDEF;
374   }
375 CODE:
376  struct fmt_spec op_fmt;
377  struct input_format *input_format;
378
379  struct variable *v;
380  op_fmt = fmt_for_output_from_input (&ip_fmt);
381  v = dict_create_var (dict->dict, name,
382         fmt_is_string (op_fmt.type) ? op_fmt.w : 0);
383  if ( NULL == v )
384   {
385     sv_setpv (errstr, "The variable could not be created (probably already exists).");
386     XSRETURN_UNDEF;
387   }
388  var_set_both_formats (v, &op_fmt);
389
390  input_format = xmalloc (sizeof *input_format);
391  input_format->var = v;
392  input_format->input_format = ip_fmt;
393  hmap_insert (&dict->input_formats, &input_format->hmap_node,
394               hash_pointer (v, 0));
395
396  RETVAL = v;
397 OUTPUT:
398  RETVAL
399
400
401 int
402 set_missing_values (var, v1, ...)
403  struct variable *var;
404  SV *v1;
405 INIT:
406  int i;
407  union value val[3];
408
409  if ( items > 4 )
410   croak ("No more than 3 missing values are permitted");
411
412  for (i = 0; i < items - 1; ++i)
413    scalar_to_value (&val[i], ST(i+1), var);
414 CODE:
415  struct missing_values mv;
416  mv_init (&mv, var_get_width (var));
417  for (i = 0 ; i < items - 1; ++i )
418    mv_add_value (&mv, &val[i]);
419  var_set_missing_values (var, &mv);
420
421
422 void
423 set_label (var, label)
424  struct variable *var;
425  char *label
426 CODE:
427   var_set_label (var, label);
428
429
430 void
431 clear_value_labels (var)
432  struct variable *var;
433 CODE:
434  var_clear_value_labels (var);
435
436 SV *
437 get_write_format (var)
438  struct variable *var
439 CODE:
440  HV *fmthash = (HV *) sv_2mortal ((SV *) newHV());
441  const struct fmt_spec *fmt = var_get_write_format (var);
442
443  hv_store (fmthash, "fmt", 3, newSVnv (fmt->type), 0);
444  hv_store (fmthash, "decimals", 8, newSVnv (fmt->d), 0);
445  hv_store (fmthash, "width", 5, newSVnv (fmt->w), 0);
446
447  RETVAL = newRV ((SV *) fmthash);
448  OUTPUT:
449 RETVAL
450
451 SV *
452 get_print_format (var)
453  struct variable *var
454 CODE:
455  HV *fmthash = (HV *) sv_2mortal ((SV *) newHV());
456  const struct fmt_spec *fmt = var_get_print_format (var);
457
458  hv_store (fmthash, "fmt", 3, newSVnv (fmt->type), 0);
459  hv_store (fmthash, "decimals", 8, newSVnv (fmt->d), 0);
460  hv_store (fmthash, "width", 5, newSVnv (fmt->w), 0);
461
462  RETVAL = newRV ((SV *) fmthash);
463  OUTPUT:
464 RETVAL
465
466
467 void
468 pxs_set_write_format (var, fmt)
469  struct variable *var
470  output_format fmt
471 CODE:
472  var_set_write_format (var, &fmt);
473
474
475 void
476 pxs_set_print_format (var, fmt)
477  struct variable *var
478  output_format fmt
479 CODE:
480  var_set_print_format (var, &fmt);
481
482 void
483 pxs_set_output_format (var, fmt)
484  struct variable *var
485  output_format fmt
486 CODE:
487  var_set_both_formats (var, &fmt);
488
489
490 int
491 add_value_label (var, key, label)
492  struct variable *var
493  SV *key
494  char *label
495 INIT:
496  SV *errstr = get_sv("PSPP::errstr", TRUE);
497  sv_setpv (errstr, "");
498 CODE:
499  union value the_value;
500  int width = var_get_width (var);
501  int ok;
502
503  value_init (&the_value, width);
504  if ( var_is_numeric (var))
505  {
506   if ( ! looks_like_number (key))
507     {
508       sv_setpv (errstr, "Cannot add label with string key to a numeric variable");
509       value_destroy (&the_value, width);
510       XSRETURN_IV (0);
511     }
512   the_value.f = SvNV (key);
513  }
514  else
515  {
516   value_copy_str_rpad (&the_value, width, SvPV_nolen(key), ' ');
517  }
518  ok = var_add_value_label (var, &the_value, label);
519  value_destroy (&the_value, width);
520  if (!ok)
521  {
522    sv_setpv (errstr, "Something went wrong");
523    XSRETURN_IV (0);
524  }
525  XSRETURN_IV (1);
526
527
528 SV *
529 get_attributes (var)
530  struct variable *var
531 CODE:
532  HV *attrhash = (HV *) sv_2mortal ((SV *) newHV());
533
534  struct attrset *as = var_get_attributes (var);
535
536  if ( as )
537    {
538      struct attrset_iterator iter;
539      struct attribute *attr;
540
541      for (attr = attrset_first (as, &iter);
542           attr;
543           attr = attrset_next (as, &iter))
544        {
545          int i;
546          const char *name = attribute_get_name (attr);
547
548          AV *values = newAV ();
549
550          for (i = 0 ; i < attribute_get_n_values (attr); ++i )
551            {
552              const char *value = attribute_get_value (attr, i);
553              av_push (values, newSVpv (value, 0));
554            }
555
556          hv_store (attrhash, name, strlen (name),
557                    newRV_noinc ((SV*) values), 0);
558        }
559    }
560
561  RETVAL = newRV ((SV *) attrhash);
562  OUTPUT:
563 RETVAL
564
565
566 const char *
567 get_name (var)
568  struct variable * var
569 CODE:
570  RETVAL = var_get_name (var);
571  OUTPUT:
572 RETVAL
573
574
575 const char *
576 get_label (var)
577  struct variable * var
578 CODE:
579  RETVAL = var_get_label (var);
580  OUTPUT:
581 RETVAL
582
583
584 SV *
585 get_value_labels (var)
586  struct variable *var
587 CODE:
588  HV *labelhash = (HV *) sv_2mortal ((SV *) newHV());
589  const struct val_lab *vl;
590  struct val_labs_iterator *viter = NULL;
591  const struct val_labs *labels = var_get_value_labels (var);
592
593  if ( labels )
594    {
595      for (vl = val_labs_first (labels);
596           vl;
597           vl = val_labs_next (labels, vl))
598        {
599          SV *sv = value_to_scalar (&vl->value, var);
600          STRLEN len;
601          const char *s = SvPV (sv, len);
602          hv_store (labelhash, s, len, newSVpv (val_lab_get_label (vl), 0), 0);
603        }
604    }
605
606  RETVAL = newRV ((SV *) labelhash);
607  OUTPUT:
608 RETVAL
609
610
611
612 MODULE = PSPP           PACKAGE = PSPP::Sysfile
613
614
615 struct syswriter_info *
616 pxs_create_sysfile (name, dict, opts_hr)
617  char *name
618  struct pspp_dict *dict;
619  SV *opts_hr
620 INIT:
621  SV *dict_sv = ST(1);
622  struct sfm_write_options opts;
623  if (!SvROK (opts_hr))
624   {
625     opts = sfm_writer_default_options ();
626   }
627  else
628   {
629     HV *opt_h = (HV *) SvRV (opts_hr);
630     SV** readonly = hv_fetch(opt_h, "readonly", 8, 0);
631     SV** compress = hv_fetch(opt_h, "compress", 8, 0);
632     SV** version = hv_fetch(opt_h, "version", 7, 0);
633
634     opts.create_writeable = readonly ? ! SvIV (*readonly) : true;
635     opts.compression = (compress && SvIV (*compress)
636                         ? SFM_COMP_SIMPLE
637                         : SFM_COMP_NONE);
638     opts.version = version ? SvIV (*version) : 3 ;
639   }
640 CODE:
641  struct file_handle *fh =
642   fh_create_file (NULL, name, fh_default_properties () );
643  struct syswriter_info *swi = xmalloc (sizeof (*swi));
644  swi->writer = sfm_open_writer (fh, dict->dict, opts);
645  swi->dict = dict;
646  swi->opened = true;
647  swi->dict_sv = dict_sv;
648  SvREFCNT_inc (swi->dict_sv);
649  
650  RETVAL = swi;
651  OUTPUT:
652 RETVAL
653
654 int
655 close (swi)
656  struct syswriter_info *swi
657 CODE:
658  RETVAL = sysfile_close (swi);
659 OUTPUT:
660  RETVAL
661
662 void
663 DESTROY (swi)
664  struct syswriter_info *swi
665 CODE:
666  sysfile_close (swi);
667  SvREFCNT_dec (swi->dict_sv);
668  free (swi);
669
670 int
671 append_case (swi, ccase)
672  struct syswriter_info *swi
673  SV *ccase
674 INIT:
675  SV *errstr = get_sv("PSPP::errstr", TRUE);
676  sv_setpv (errstr, "");
677  if ( (!SvROK(ccase)))
678   {
679     XSRETURN_UNDEF;
680   }
681 CODE:
682  int i = 0;
683  AV *av_case = (AV*) SvRV (ccase);
684
685  const struct variable **vv;
686  size_t nv;
687  struct ccase *c;
688  SV *sv;
689
690  if ( av_len (av_case) >= dict_get_var_cnt (swi->dict->dict))
691    XSRETURN_UNDEF;
692
693  c =  case_create (dict_get_proto (swi->dict->dict));
694
695  dict_get_vars (swi->dict->dict, &vv, &nv,
696                 1u << DC_ORDINARY | 1u << DC_SYSTEM);
697
698  for (sv = av_shift (av_case); SvOK (sv);  sv = av_shift (av_case))
699  {
700     const struct variable *v = vv[i++];
701     const struct fmt_spec *ifmt = find_input_format (swi->dict, v);
702
703     /* If an input format has been set, then use it.
704        Otherwise just convert the raw value.
705     */
706     if ( ifmt )
707       {
708         struct substring ss = ss_cstr (SvPV_nolen (sv));
709         char *error;
710         bool ok;
711
712         error = data_in (ss, SvUTF8(sv) ? UTF8: "iso-8859-1", ifmt->type,
713                          case_data_rw (c, v), var_get_width (v),
714                          dict_get_encoding (swi->dict->dict));
715         ok = error == NULL;
716         free (error);
717
718         if ( !ok )
719           {
720             RETVAL = 0;
721             goto finish;
722           }
723       }
724     else
725       {
726         scalar_to_value (case_data_rw (c, v), sv, v);
727       }
728  }
729
730  /* The remaining variables must be sysmis or blank string */
731  while (i < dict_get_var_cnt (swi->dict->dict))
732  {
733    const struct variable *v = vv[i++];
734    union value *val = case_data_rw (c, v);
735    value_set_missing (val, var_get_width (v));
736  }
737  casewriter_write (swi->writer, c);
738  RETVAL = 1;
739  finish:
740  free (vv);
741 OUTPUT:
742  RETVAL
743
744
745 \f
746
747 MODULE = PSPP           PACKAGE = PSPP::Reader
748
749 struct sysreader_info *
750 pxs_open_sysfile (name)
751  char * name
752 CODE:
753  struct casereader *reader;
754  struct sysreader_info *sri = NULL;
755  struct file_handle *fh =
756          fh_create_file (NULL, name, fh_default_properties () );
757  struct dictionary *dict;
758  struct sfm_reader *r;
759
760  sri = xmalloc (sizeof (*sri));
761  r = sfm_open (fh);
762  if (r)
763    {
764      sri->reader = sfm_decode (r, NULL, &dict, &sri->opts);
765      if (sri->reader)
766        sri->dict = create_pspp_dict (dict);
767      else
768        {
769          free (sri);
770          sri = NULL;
771        }
772    }
773  else
774    {
775      free (sri);
776      sri = NULL;
777    } 
778
779  RETVAL = sri;
780  OUTPUT:
781 RETVAL
782
783
784 struct pspp_dict *
785 pxs_get_dict (reader)
786  struct sysreader_info *reader;
787 CODE:
788  RETVAL = reader->dict;
789  OUTPUT:
790 RETVAL
791
792 SV *
793 get_case_cnt (sfr)
794  struct sysreader_info *sfr;
795 CODE:
796  SV *ret;
797  casenumber n = casereader_get_case_cnt (sfr->reader);
798  if (n == CASENUMBER_MAX)
799   ret = &PL_sv_undef;
800  else 
801   ret = newSViv (n);
802  RETVAL = ret;
803  OUTPUT:
804 RETVAL
805
806
807
808 void
809 get_next_case (sfr)
810  struct sysreader_info *sfr;
811 PPCODE:
812  struct ccase *c;
813
814  if ((c = casereader_read (sfr->reader)) != NULL)
815  {
816   int v;
817
818   EXTEND (SP, dict_get_var_cnt (sfr->dict->dict));
819   for (v = 0; v < dict_get_var_cnt (sfr->dict->dict); ++v )
820     {
821       const struct variable *var = dict_get_var (sfr->dict->dict, v);
822       const union value *val = case_data (c, var);
823
824       PUSHs (sv_2mortal (value_to_scalar (val, var)));
825     }
826
827   case_unref (c);
828  }