CORRELATIONS: Fixed bug displaying non-sqaure correlation matrices
[pspp] / src / data / gnumeric-reader.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2007, 2009, 2010, 2011 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU 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, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "libpspp/message.h"
20 #include "libpspp/misc.h"
21
22 #include "gl/minmax.h"
23
24 #include "gettext.h"
25 #define _(msgid) gettext (msgid)
26 #define N_(msgid) (msgid)
27
28 #include "spreadsheet-reader.h"
29
30 #if !GNM_SUPPORT
31
32 struct casereader *
33 gnumeric_open_reader (struct spreadsheet_read_info *gri, struct dictionary **dict)
34 {
35   msg (ME, _("Support for %s files was not compiled into this installation of PSPP"), "Gnumeric");
36
37   return NULL;
38 }
39
40 #else
41
42 #include "data/gnumeric-reader.h"
43
44 #include <assert.h>
45 #include <stdbool.h>
46 #include <errno.h>
47 #include <libxml/xmlreader.h>
48 #include <zlib.h>
49
50 #include "data/case.h"
51 #include "data/casereader-provider.h"
52 #include "data/dictionary.h"
53 #include "data/identifier.h"
54 #include "data/value.h"
55 #include "data/variable.h"
56 #include "libpspp/i18n.h"
57 #include "libpspp/str.h"
58
59 #include "gl/xalloc.h"
60
61 static void gnm_file_casereader_destroy (struct casereader *, void *);
62
63 static struct ccase *gnm_file_casereader_read (struct casereader *, void *);
64
65 static const struct casereader_class gnm_file_casereader_class =
66   {
67     gnm_file_casereader_read,
68     gnm_file_casereader_destroy,
69     NULL,
70     NULL,
71   };
72
73 enum reader_state
74   {
75     STATE_INIT = 0,        /* Initial state */
76     STATE_SHEET_START,     /* Found the start of a sheet */
77     STATE_SHEET_NAME,      /* Found the sheet name */
78     STATE_MAXROW,
79     STATE_SHEET_FOUND,     /* Found the sheet that we actually want */
80     STATE_CELLS_START,     /* Found the start of the cell array */
81     STATE_CELL             /* Found a cell */
82   };
83
84
85 struct gnumeric_reader
86 {
87   xmlTextReaderPtr xtr;
88
89   enum reader_state state;
90   int row;
91   int col;
92   int node_type;
93   int sheet_index;
94
95
96   const xmlChar *target_sheet;
97   int target_sheet_index;
98
99   int start_row;
100   int start_col;
101   int stop_row;
102   int stop_col;
103
104   struct caseproto *proto;
105   struct dictionary *dict;
106   struct ccase *first_case;
107   bool used_first_case;
108 };
109
110 static void process_node (struct gnumeric_reader *r);
111
112
113 static void
114 gnm_file_casereader_destroy (struct casereader *reader UNUSED, void *r_)
115 {
116   struct gnumeric_reader *r = r_;
117   if ( r == NULL)
118         return ;
119
120   if ( r->xtr)
121     xmlFreeTextReader (r->xtr);
122
123   if ( ! r->used_first_case )
124     case_unref (r->first_case);
125
126   caseproto_unref (r->proto);
127
128   free (r);
129 }
130
131 static void
132 process_node (struct gnumeric_reader *r)
133 {
134   xmlChar *name = xmlTextReaderName (r->xtr);
135   if (name == NULL)
136     name = xmlStrdup (_xml ("--"));
137
138
139   r->node_type = xmlTextReaderNodeType (r->xtr);
140
141   switch ( r->state)
142     {
143     case STATE_INIT:
144       if (0 == xmlStrcasecmp (name, _xml("gnm:Sheet")) &&
145           XML_READER_TYPE_ELEMENT  == r->node_type)
146         {
147           r->state = STATE_SHEET_START;
148         }
149       break;
150     case STATE_SHEET_START:
151       if (0 == xmlStrcasecmp (name, _xml("gnm:Name"))  &&
152           XML_READER_TYPE_ELEMENT  == r->node_type)
153         {
154           r->state = STATE_SHEET_NAME;
155         }
156       else if (0 == xmlStrcasecmp (name, _xml("gnm:Name"))  &&
157                XML_READER_TYPE_END_ELEMENT  == r->node_type)
158         {
159           r->state = STATE_INIT;
160         }
161       break;
162     case STATE_SHEET_NAME:
163       if (0 == xmlStrcasecmp (name, _xml("gnm:Name"))  &&
164           XML_READER_TYPE_END_ELEMENT  == r->node_type)
165         {
166           r->state = STATE_SHEET_START;
167         }
168       else if (XML_READER_TYPE_TEXT == r->node_type)
169         {
170           ++r->sheet_index;
171           if ( r->target_sheet != NULL)
172             {
173               xmlChar *value = xmlTextReaderValue (r->xtr);
174               if ( 0 == xmlStrcmp (value, r->target_sheet))
175                 r->state = STATE_SHEET_FOUND;
176               free (value);
177             }
178           else if (r->target_sheet_index == r->sheet_index)
179             {
180               r->state = STATE_SHEET_FOUND;
181             }
182         }
183       break;
184     case STATE_SHEET_FOUND:
185       if (0 == xmlStrcasecmp (name, _xml("gnm:Cells"))  &&
186           XML_READER_TYPE_ELEMENT  == r->node_type)
187         {
188           if (! xmlTextReaderIsEmptyElement (r->xtr))
189             r->state = STATE_CELLS_START;
190         }
191       else if (0 == xmlStrcasecmp (name, _xml("gnm:MaxRow"))  &&
192           XML_READER_TYPE_ELEMENT  == r->node_type)
193         {
194           r->state = STATE_MAXROW;
195         }
196       else if (0 == xmlStrcasecmp (name, _xml("gnm:Sheet"))  &&
197           XML_READER_TYPE_END_ELEMENT  == r->node_type)
198         {
199           r->state = STATE_INIT;
200         }
201       break;
202     case STATE_MAXROW:
203       if (0 == xmlStrcasecmp (name, _xml("gnm:MaxRow"))  &&
204           XML_READER_TYPE_END_ELEMENT  == r->node_type)
205         {
206           r->state = STATE_SHEET_FOUND;
207         }
208     case STATE_CELLS_START:
209       if (0 == xmlStrcasecmp (name, _xml ("gnm:Cell"))  &&
210           XML_READER_TYPE_ELEMENT  == r->node_type)
211         {
212           xmlChar *attr = NULL;
213           r->state = STATE_CELL;
214
215           attr = xmlTextReaderGetAttribute (r->xtr, _xml ("Col"));
216           r->col =  _xmlchar_to_int (attr);
217           free (attr);
218
219           attr = xmlTextReaderGetAttribute (r->xtr, _xml ("Row"));
220           r->row = _xmlchar_to_int (attr);
221           free (attr);
222         }
223       else if (0 == xmlStrcasecmp (name, _xml("gnm:Cells"))  &&
224                XML_READER_TYPE_END_ELEMENT  == r->node_type)
225         r->state = STATE_SHEET_NAME;
226
227       break;
228     case STATE_CELL:
229       if (0 == xmlStrcasecmp (name, _xml("gnm:Cell"))  &&
230                               XML_READER_TYPE_END_ELEMENT  == r->node_type)
231         r->state = STATE_CELLS_START;
232       break;
233     default:
234       break;
235     };
236
237   xmlFree (name);
238 }
239
240
241 /*
242    Sets the VAR of case C, to the value corresponding to the xml string XV
243  */
244 static void
245 convert_xml_string_to_value (struct ccase *c, const struct variable *var,
246                              const xmlChar *xv)
247 {
248   union value *v = case_data_rw (c, var);
249
250   if (xv == NULL)
251     value_set_missing (v, var_get_width (var));
252   else if ( var_is_alpha (var))
253     value_copy_str_rpad (v, var_get_width (var), xv, ' ');
254   else
255     {
256       const char *text = CHAR_CAST (const char *, xv);
257       char *endptr;
258
259       errno = 0;
260       v->f = strtod (text, &endptr);
261       if ( errno != 0 || endptr == text)
262         v->f = SYSMIS;
263     }
264 }
265
266 struct var_spec
267 {
268   char *name;
269   int width;
270   xmlChar *first_value;
271 };
272
273 struct casereader *
274 gnumeric_open_reader (struct spreadsheet_read_info *gri, struct dictionary **dict)
275 {
276   unsigned long int vstart = 0;
277   int ret;
278   casenumber n_cases = CASENUMBER_MAX;
279   int i;
280   struct var_spec *var_spec = NULL;
281   int n_var_specs = 0;
282
283   struct gnumeric_reader *r = NULL;
284
285   gzFile gz = gzopen (gri->file_name, "r");
286
287   if ( NULL == gz)
288     {
289       msg (ME, _("Error opening `%s' for reading as a Gnumeric file: %s."),
290            gri->file_name, strerror (errno));
291
292       goto error;
293     }
294
295   r = xzalloc (sizeof *r);
296
297   r->xtr = xmlReaderForIO ((xmlInputReadCallback) gzread, gzclose, gz,
298                            NULL, NULL, 0);
299
300   if ( r->xtr == NULL)
301     goto error;
302
303   if ( gri->cell_range )
304     {
305       if ( ! convert_cell_ref (gri->cell_range,
306                                &r->start_col, &r->start_row,
307                                &r->stop_col, &r->stop_row))
308         {
309           msg (SE, _("Invalid cell range `%s'"),
310                gri->cell_range);
311           goto error;
312         }
313     }
314   else
315     {
316       r->start_col = 0;
317       r->start_row = 0;
318       r->stop_col = -1;
319       r->stop_row = -1;
320     }
321
322   r->state = STATE_INIT;
323   r->target_sheet = BAD_CAST gri->sheet_name;
324   r->target_sheet_index = gri->sheet_index;
325   r->row = r->col = -1;
326   r->sheet_index = 0;
327
328   /* Advance to the start of the cells for the target sheet */
329   while ( (r->state != STATE_CELL || r->row < r->start_row )
330           && 1 == (ret = xmlTextReaderRead (r->xtr)))
331     {
332       xmlChar *value ;
333       process_node (r);
334       value = xmlTextReaderValue (r->xtr);
335
336       if ( r->state == STATE_MAXROW  && r->node_type == XML_READER_TYPE_TEXT)
337         {
338           n_cases = 1 + _xmlchar_to_int (value) ;
339         }
340       free (value);
341     }
342
343
344   /* If a range has been given, then  use that to calculate the number
345      of cases */
346   if ( gri->cell_range)
347     {
348       n_cases = MIN (n_cases, r->stop_row - r->start_row + 1);
349     }
350
351   if ( gri->read_names )
352     {
353       r->start_row++;
354       n_cases --;
355     }
356
357   /* Read in the first row of cells,
358      including the headers if read_names was set */
359   while (
360          (( r->state == STATE_CELLS_START && r->row <= r->start_row) || r->state == STATE_CELL )
361          && (ret = xmlTextReaderRead (r->xtr))
362          )
363     {
364       int idx;
365       process_node (r);
366
367       if ( r->row > r->start_row ) break;
368
369       if ( r->col < r->start_col ||
370            (r->stop_col != -1 && r->col > r->stop_col))
371         continue;
372
373       idx = r->col - r->start_col;
374
375       if ( idx  >= n_var_specs )
376         {
377           n_var_specs =  idx + 1 ;
378           var_spec = xrealloc (var_spec, sizeof (*var_spec) * n_var_specs);
379           var_spec [idx].name = NULL;
380           var_spec [idx].width = -1;
381           var_spec [idx].first_value = NULL;
382         }
383
384       if ( r->node_type == XML_READER_TYPE_TEXT )
385         {
386           xmlChar *value = xmlTextReaderValue (r->xtr);
387           const char *text  = CHAR_CAST (const char *, value);
388
389           if ( r->row < r->start_row)
390             {
391               if ( gri->read_names )
392                 {
393                   var_spec [idx].name = xstrdup (text);
394                 }
395             }
396           else
397             {
398               var_spec [idx].first_value = xmlStrdup (value);
399
400               if (-1 ==  var_spec [idx].width )
401                 var_spec [idx].width = (gri->asw == -1) ?
402                   ROUND_UP (strlen(text), SPREADSHEET_DEFAULT_WIDTH) : gri->asw;
403             }
404
405           free (value);
406         }
407       else if ( r->node_type == XML_READER_TYPE_ELEMENT
408                 && r->state == STATE_CELL)
409         {
410           if ( r->row == r->start_row )
411             {
412               xmlChar *attr =
413                 xmlTextReaderGetAttribute (r->xtr, _xml ("ValueType"));
414
415               if ( NULL == attr || 60 !=  _xmlchar_to_int (attr))
416                 var_spec [idx].width = 0;
417
418               free (attr);
419             }
420         }
421     }
422
423
424   /* Create the dictionary and populate it */
425   *dict = r->dict = dict_create (
426     CHAR_CAST (const char *, xmlTextReaderConstEncoding (r->xtr)));
427
428   for (i = 0 ; i < n_var_specs ; ++i )
429     {
430       char *name;
431
432       /* Probably no data exists for this variable, so allocate a
433          default width */
434       if ( var_spec[i].width == -1 )
435         var_spec[i].width = SPREADSHEET_DEFAULT_WIDTH;
436
437       name = dict_make_unique_var_name (r->dict, var_spec[i].name, &vstart);
438       dict_create_var (r->dict, name, var_spec[i].width);
439       free (name);
440     }
441
442   /* Create the first case, and cache it */
443   r->used_first_case = false;
444
445   if ( n_var_specs ==  0 )
446     {
447       msg (MW, _("Selected sheet or range of spreadsheet `%s' is empty."),
448            gri->file_name);
449       goto error;
450     }
451
452   r->proto = caseproto_ref (dict_get_proto (r->dict));
453   r->first_case = case_create (r->proto);
454   case_set_missing (r->first_case);
455
456   for ( i = 0 ; i < n_var_specs ; ++i )
457     {
458       const struct variable *var = dict_get_var (r->dict, i);
459
460       convert_xml_string_to_value (r->first_case, var,
461                                    var_spec[i].first_value);
462     }
463
464   for ( i = 0 ; i < n_var_specs ; ++i )
465     {
466       free (var_spec[i].first_value);
467       free (var_spec[i].name);
468     }
469
470   free (var_spec);
471
472   return casereader_create_sequential
473     (NULL,
474      r->proto,
475      n_cases,
476      &gnm_file_casereader_class, r);
477
478
479  error:
480   for ( i = 0 ; i < n_var_specs ; ++i )
481     {
482       free (var_spec[i].first_value);
483       free (var_spec[i].name);
484     }
485
486   free (var_spec);
487   dict_destroy (*dict);
488
489   gnm_file_casereader_destroy (NULL, r);
490
491   return NULL;
492 };
493
494
495 /* Reads and returns one case from READER's file.  Returns a null
496    pointer on failure. */
497 static struct ccase *
498 gnm_file_casereader_read (struct casereader *reader UNUSED, void *r_)
499 {
500   struct ccase *c;
501   int ret = 0;
502
503   struct gnumeric_reader *r = r_;
504   int current_row = r->row;
505
506   if ( !r->used_first_case )
507     {
508       r->used_first_case = true;
509       return r->first_case;
510     }
511
512   c = case_create (r->proto);
513   case_set_missing (c);
514
515   while ((r->state == STATE_CELL || r->state == STATE_CELLS_START )
516          && r->row == current_row && (ret = xmlTextReaderRead (r->xtr)))
517     {
518       process_node (r);
519
520       if ( r->col < r->start_col || (r->stop_col != -1 &&
521                                      r->col > r->stop_col))
522         continue;
523
524       if ( r->col - r->start_col >= caseproto_get_n_widths (r->proto))
525         continue;
526
527       if ( r->stop_row != -1 && r->row > r->stop_row)
528         break;
529
530       if ( r->node_type == XML_READER_TYPE_TEXT )
531         {
532           xmlChar *value = xmlTextReaderValue (r->xtr);
533
534           const int idx = r->col - r->start_col;
535
536           const struct variable *var = dict_get_var (r->dict, idx);
537
538           convert_xml_string_to_value (c, var, value);
539
540           free (value);
541         }
542
543     }
544
545   if (ret == 1)
546     return c;
547   else
548     {
549       case_unref (c);
550       return NULL;
551     }
552 }
553
554
555 #endif /* GNM_SUPPORT */