QUICK CLUSTER: Adjust comment style.
[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
18
19 #include <config.h>
20
21 #include "libpspp/message.h"
22 #include "libpspp/misc.h"
23
24 #include "gl/minmax.h"
25
26 #include "gettext.h"
27 #define _(msgid) gettext (msgid)
28 #define N_(msgid) (msgid)
29
30
31 #if !GNM_SUPPORT
32
33 struct casereader *
34 gnumeric_open_reader (struct gnumeric_read_info *gri, struct dictionary **dict)
35 {
36   msg (ME, _("Support for Gnumeric files was not compiled into this installation of PSPP"));
37
38   return NULL;
39 }
40
41 #else
42
43 #include "data/gnumeric-reader.h"
44
45 #include <assert.h>
46 #include <stdbool.h>
47 #include <errno.h>
48 #include <libxml/xmlreader.h>
49 #include <zlib.h>
50
51 #include "data/case.h"
52 #include "data/casereader-provider.h"
53 #include "data/dictionary.h"
54 #include "data/identifier.h"
55 #include "data/value.h"
56 #include "data/variable.h"
57 #include "libpspp/i18n.h"
58 #include "libpspp/str.h"
59
60 #include "gl/xalloc.h"
61
62 /* Default width of string variables. */
63 #define GNUMERIC_DEFAULT_WIDTH 8
64
65 static void gnm_file_casereader_destroy (struct casereader *, void *);
66
67 static struct ccase *gnm_file_casereader_read (struct casereader *, void *);
68
69 static const struct casereader_class gnm_file_casereader_class =
70   {
71     gnm_file_casereader_read,
72     gnm_file_casereader_destroy,
73     NULL,
74     NULL,
75   };
76
77 /* Convert a string, which is an integer encoded in base26
78    IE, A=0, B=1, ... Z=25 to the integer it represents.
79    ... except that in this scheme, digits with an exponent
80    greater than 1 are implicitly incremented by 1, so
81    AA  = 0 + 1*26, AB = 1 + 1*26,
82    ABC = 2 + 2*26 + 1*26^2 ....
83 */
84 static int
85 pseudo_base26 (const char *str)
86 {
87   int i;
88   int multiplier = 1;
89   int result = 0;
90   int len = strlen (str);
91
92   for ( i = len - 1 ; i >= 0; --i)
93     {
94       int mantissa = (str[i] - 'A');
95
96       if ( mantissa < 0 || mantissa > 25 )
97         return -1;
98
99       if ( i != len - 1)
100         mantissa++;
101
102       result += mantissa * multiplier;
103
104       multiplier *= 26;
105     }
106
107   return result;
108 }
109
110
111
112 /* Convert a cell reference in the form "A1:B2", to
113    integers.  A1 means column zero, row zero.
114    B1 means column 1 row 0. AA1 means column 26, row 0.
115 */
116 static bool
117 convert_cell_ref (const char *ref,
118                   int *col0, int *row0,
119                   int *coli, int *rowi)
120 {
121   char startcol[5];
122   char stopcol [5];
123
124   int startrow;
125   int stoprow;
126
127   int n = sscanf (ref, "%4[a-zA-Z]%d:%4[a-zA-Z]%d",
128               startcol, &startrow,
129               stopcol, &stoprow);
130   if ( n != 4)
131     return false;
132
133   str_uppercase (startcol);
134   *col0 = pseudo_base26 (startcol);
135   str_uppercase (stopcol);
136   *coli = pseudo_base26 (stopcol);
137   *row0 = startrow - 1;
138   *rowi = stoprow - 1 ;
139
140   return true;
141 }
142
143
144 enum reader_state
145   {
146     STATE_INIT = 0,        /* Initial state */
147     STATE_SHEET_START,     /* Found the start of a sheet */
148     STATE_SHEET_NAME,      /* Found the sheet name */
149     STATE_MAXROW,
150     STATE_SHEET_FOUND,     /* Found the sheet that we actually want */
151     STATE_CELLS_START,     /* Found the start of the cell array */
152     STATE_CELL             /* Found a cell */
153   };
154
155
156 struct gnumeric_reader
157 {
158   xmlTextReaderPtr xtr;
159
160   enum reader_state state;
161   int row;
162   int col;
163   int node_type;
164   int sheet_index;
165
166
167   const xmlChar *target_sheet;
168   int target_sheet_index;
169
170   int start_row;
171   int start_col;
172   int stop_row;
173   int stop_col;
174
175   struct caseproto *proto;
176   struct dictionary *dict;
177   struct ccase *first_case;
178   bool used_first_case;
179 };
180
181 static void process_node (struct gnumeric_reader *r);
182
183 #define _xml(X) (CHAR_CAST (const xmlChar *, X))
184
185 #define _xmlchar_to_int(X) (atoi(CHAR_CAST (const char *, X)))
186
187 static void
188 gnm_file_casereader_destroy (struct casereader *reader UNUSED, void *r_)
189 {
190   struct gnumeric_reader *r = r_;
191   if ( r == NULL)
192         return ;
193
194   if ( r->xtr)
195     xmlFreeTextReader (r->xtr);
196
197   if ( ! r->used_first_case )
198     case_unref (r->first_case);
199
200   caseproto_unref (r->proto);
201
202   free (r);
203 }
204
205 static void
206 process_node (struct gnumeric_reader *r)
207 {
208   xmlChar *name = xmlTextReaderName (r->xtr);
209   if (name == NULL)
210     name = xmlStrdup (_xml ("--"));
211
212
213   r->node_type = xmlTextReaderNodeType (r->xtr);
214
215   switch ( r->state)
216     {
217     case STATE_INIT:
218       if (0 == xmlStrcasecmp (name, _xml("gnm:Sheet")) &&
219           XML_READER_TYPE_ELEMENT  == r->node_type)
220         {
221           r->state = STATE_SHEET_START;
222         }
223       break;
224     case STATE_SHEET_START:
225       if (0 == xmlStrcasecmp (name, _xml("gnm:Name"))  &&
226           XML_READER_TYPE_ELEMENT  == r->node_type)
227         {
228           r->state = STATE_SHEET_NAME;
229         }
230       else if (0 == xmlStrcasecmp (name, _xml("gnm:Name"))  &&
231                XML_READER_TYPE_END_ELEMENT  == r->node_type)
232         {
233           r->state = STATE_INIT;
234         }
235       break;
236     case STATE_SHEET_NAME:
237       if (0 == xmlStrcasecmp (name, _xml("gnm:Name"))  &&
238           XML_READER_TYPE_END_ELEMENT  == r->node_type)
239         {
240           r->state = STATE_SHEET_START;
241         }
242       else if (XML_READER_TYPE_TEXT == r->node_type)
243         {
244           ++r->sheet_index;
245           if ( r->target_sheet != NULL)
246             {
247               xmlChar *value = xmlTextReaderValue (r->xtr);
248               if ( 0 == xmlStrcmp (value, r->target_sheet))
249                 r->state = STATE_SHEET_FOUND;
250               free (value);
251             }
252           else if (r->target_sheet_index == r->sheet_index)
253             {
254               r->state = STATE_SHEET_FOUND;
255             }
256         }
257       break;
258     case STATE_SHEET_FOUND:
259       if (0 == xmlStrcasecmp (name, _xml("gnm:Cells"))  &&
260           XML_READER_TYPE_ELEMENT  == r->node_type)
261         {
262           if (! xmlTextReaderIsEmptyElement (r->xtr))
263             r->state = STATE_CELLS_START;
264         }
265       else if (0 == xmlStrcasecmp (name, _xml("gnm:MaxRow"))  &&
266           XML_READER_TYPE_ELEMENT  == r->node_type)
267         {
268           r->state = STATE_MAXROW;
269         }
270       else if (0 == xmlStrcasecmp (name, _xml("gnm:Sheet"))  &&
271           XML_READER_TYPE_END_ELEMENT  == r->node_type)
272         {
273           r->state = STATE_INIT;
274         }
275       break;
276     case STATE_MAXROW:
277       if (0 == xmlStrcasecmp (name, _xml("gnm:MaxRow"))  &&
278           XML_READER_TYPE_END_ELEMENT  == r->node_type)
279         {
280           r->state = STATE_SHEET_FOUND;
281         }
282     case STATE_CELLS_START:
283       if (0 == xmlStrcasecmp (name, _xml ("gnm:Cell"))  &&
284           XML_READER_TYPE_ELEMENT  == r->node_type)
285         {
286           xmlChar *attr = NULL;
287           r->state = STATE_CELL;
288
289           attr = xmlTextReaderGetAttribute (r->xtr, _xml ("Col"));
290           r->col =  _xmlchar_to_int (attr);
291           free (attr);
292
293           attr = xmlTextReaderGetAttribute (r->xtr, _xml ("Row"));
294           r->row = _xmlchar_to_int (attr);
295           free (attr);
296         }
297       else if (0 == xmlStrcasecmp (name, _xml("gnm:Cells"))  &&
298                XML_READER_TYPE_END_ELEMENT  == r->node_type)
299         r->state = STATE_SHEET_NAME;
300
301       break;
302     case STATE_CELL:
303       if (0 == xmlStrcasecmp (name, _xml("gnm:Cell"))  &&
304                               XML_READER_TYPE_END_ELEMENT  == r->node_type)
305         r->state = STATE_CELLS_START;
306       break;
307     default:
308       break;
309     };
310
311   xmlFree (name);
312 }
313
314
315 /*
316    Sets the VAR of case C, to the value corresponding to the xml string XV
317  */
318 static void
319 convert_xml_string_to_value (struct ccase *c, const struct variable *var,
320                              const xmlChar *xv)
321 {
322   union value *v = case_data_rw (c, var);
323
324   if (xv == NULL)
325     value_set_missing (v, var_get_width (var));
326   else if ( var_is_alpha (var))
327     value_copy_str_rpad (v, var_get_width (var), xv, ' ');
328   else
329     {
330       const char *text = CHAR_CAST (const char *, xv);
331       char *endptr;
332
333       errno = 0;
334       v->f = strtod (text, &endptr);
335       if ( errno != 0 || endptr == text)
336         v->f = SYSMIS;
337     }
338 }
339
340 struct var_spec
341 {
342   char *name;
343   int width;
344   xmlChar *first_value;
345 };
346
347 struct casereader *
348 gnumeric_open_reader (struct gnumeric_read_info *gri, struct dictionary **dict)
349 {
350   unsigned long int vstart = 0;
351   int ret;
352   casenumber n_cases = CASENUMBER_MAX;
353   int i;
354   struct var_spec *var_spec = NULL;
355   int n_var_specs = 0;
356
357   struct gnumeric_reader *r = NULL;
358
359   gzFile gz = gzopen (gri->file_name, "r");
360
361   if ( NULL == gz)
362     {
363       msg (ME, _("Error opening `%s' for reading as a Gnumeric file: %s."),
364            gri->file_name, strerror (errno));
365
366       goto error;
367     }
368
369   r = xzalloc (sizeof *r);
370
371   r->xtr = xmlReaderForIO ((xmlInputReadCallback) gzread, gzclose, gz,
372                            NULL, NULL, 0);
373
374   if ( r->xtr == NULL)
375     goto error;
376
377   if ( gri->cell_range )
378     {
379       if ( ! convert_cell_ref (gri->cell_range,
380                                &r->start_col, &r->start_row,
381                                &r->stop_col, &r->stop_row))
382         {
383           msg (SE, _("Invalid cell range `%s'"),
384                gri->cell_range);
385           goto error;
386         }
387     }
388   else
389     {
390       r->start_col = 0;
391       r->start_row = 0;
392       r->stop_col = -1;
393       r->stop_row = -1;
394     }
395
396   r->state = STATE_INIT;
397   r->target_sheet = BAD_CAST gri->sheet_name;
398   r->target_sheet_index = gri->sheet_index;
399   r->row = r->col = -1;
400   r->sheet_index = 0;
401
402   /* Advance to the start of the cells for the target sheet */
403   while ( (r->state != STATE_CELL || r->row < r->start_row )
404           && 1 == (ret = xmlTextReaderRead (r->xtr)))
405     {
406       xmlChar *value ;
407       process_node (r);
408       value = xmlTextReaderValue (r->xtr);
409
410       if ( r->state == STATE_MAXROW  && r->node_type == XML_READER_TYPE_TEXT)
411         {
412           n_cases = 1 + _xmlchar_to_int (value) ;
413         }
414       free (value);
415     }
416
417
418   /* If a range has been given, then  use that to calculate the number
419      of cases */
420   if ( gri->cell_range)
421     {
422       n_cases = MIN (n_cases, r->stop_row - r->start_row + 1);
423     }
424
425   if ( gri->read_names )
426     {
427       r->start_row++;
428       n_cases --;
429     }
430
431   /* Read in the first row of cells,
432      including the headers if read_names was set */
433   while (
434          (( r->state == STATE_CELLS_START && r->row <= r->start_row) || r->state == STATE_CELL )
435          && (ret = xmlTextReaderRead (r->xtr))
436          )
437     {
438       int idx;
439       process_node (r);
440
441       if ( r->row > r->start_row ) break;
442
443       if ( r->col < r->start_col ||
444            (r->stop_col != -1 && r->col > r->stop_col))
445         continue;
446
447       idx = r->col - r->start_col;
448
449       if ( idx  >= n_var_specs )
450         {
451           n_var_specs =  idx + 1 ;
452           var_spec = xrealloc (var_spec, sizeof (*var_spec) * n_var_specs);
453           var_spec [idx].name = NULL;
454           var_spec [idx].width = -1;
455           var_spec [idx].first_value = NULL;
456         }
457
458       if ( r->node_type == XML_READER_TYPE_TEXT )
459         {
460           xmlChar *value = xmlTextReaderValue (r->xtr);
461           const char *text  = CHAR_CAST (const char *, value);
462
463           if ( r->row < r->start_row)
464             {
465               if ( gri->read_names )
466                 {
467                   var_spec [idx].name = xstrdup (text);
468                 }
469             }
470           else
471             {
472               var_spec [idx].first_value = xmlStrdup (value);
473
474               if (-1 ==  var_spec [idx].width )
475                 var_spec [idx].width = (gri->asw == -1) ?
476                   ROUND_UP (strlen(text), GNUMERIC_DEFAULT_WIDTH) : gri->asw;
477             }
478
479           free (value);
480         }
481       else if ( r->node_type == XML_READER_TYPE_ELEMENT
482                 && r->state == STATE_CELL)
483         {
484           if ( r->row == r->start_row )
485             {
486               xmlChar *attr =
487                 xmlTextReaderGetAttribute (r->xtr, _xml ("ValueType"));
488
489               if ( NULL == attr || 60 !=  _xmlchar_to_int (attr))
490                 var_spec [idx].width = 0;
491
492               free (attr);
493             }
494         }
495     }
496
497
498   /* Create the dictionary and populate it */
499   *dict = r->dict = dict_create (
500     CHAR_CAST (const char *, xmlTextReaderConstEncoding (r->xtr)));
501
502   for (i = 0 ; i < n_var_specs ; ++i )
503     {
504       char *name;
505
506       /* Probably no data exists for this variable, so allocate a
507          default width */
508       if ( var_spec[i].width == -1 )
509         var_spec[i].width = GNUMERIC_DEFAULT_WIDTH;
510
511       name = dict_make_unique_var_name (r->dict, var_spec[i].name, &vstart);
512       dict_create_var (r->dict, name, var_spec[i].width);
513       free (name);
514     }
515
516   /* Create the first case, and cache it */
517   r->used_first_case = false;
518
519   if ( n_var_specs ==  0 )
520     {
521       msg (MW, _("Selected sheet or range of spreadsheet `%s' is empty."),
522            gri->file_name);
523       goto error;
524     }
525
526   r->proto = caseproto_ref (dict_get_proto (r->dict));
527   r->first_case = case_create (r->proto);
528   case_set_missing (r->first_case);
529
530   for ( i = 0 ; i < n_var_specs ; ++i )
531     {
532       const struct variable *var = dict_get_var (r->dict, i);
533
534       convert_xml_string_to_value (r->first_case, var,
535                                    var_spec[i].first_value);
536     }
537
538   for ( i = 0 ; i < n_var_specs ; ++i )
539     {
540       free (var_spec[i].first_value);
541       free (var_spec[i].name);
542     }
543
544   free (var_spec);
545
546   return casereader_create_sequential
547     (NULL,
548      r->proto,
549      n_cases,
550      &gnm_file_casereader_class, r);
551
552
553  error:
554   for ( i = 0 ; i < n_var_specs ; ++i )
555     {
556       free (var_spec[i].first_value);
557       free (var_spec[i].name);
558     }
559
560   free (var_spec);
561   dict_destroy (*dict);
562
563   gnm_file_casereader_destroy (NULL, r);
564
565   return NULL;
566 };
567
568
569 /* Reads and returns one case from READER's file.  Returns a null
570    pointer on failure. */
571 static struct ccase *
572 gnm_file_casereader_read (struct casereader *reader UNUSED, void *r_)
573 {
574   struct ccase *c;
575   int ret = 0;
576
577   struct gnumeric_reader *r = r_;
578   int current_row = r->row;
579
580   if ( !r->used_first_case )
581     {
582       r->used_first_case = true;
583       return r->first_case;
584     }
585
586   c = case_create (r->proto);
587   case_set_missing (c);
588
589   while ((r->state == STATE_CELL || r->state == STATE_CELLS_START )
590          && r->row == current_row && (ret = xmlTextReaderRead (r->xtr)))
591     {
592       process_node (r);
593
594       if ( r->col < r->start_col || (r->stop_col != -1 &&
595                                      r->col > r->stop_col))
596         continue;
597
598       if ( r->col - r->start_col >= caseproto_get_n_widths (r->proto))
599         continue;
600
601       if ( r->stop_row != -1 && r->row > r->stop_row)
602         break;
603
604       if ( r->node_type == XML_READER_TYPE_TEXT )
605         {
606           xmlChar *value = xmlTextReaderValue (r->xtr);
607
608           const int idx = r->col - r->start_col;
609
610           const struct variable *var = dict_get_var (r->dict, idx);
611
612           convert_xml_string_to_value (c, var, value);
613
614           free (value);
615         }
616
617     }
618
619   if (ret == 1)
620     return c;
621   else
622     {
623       case_unref (c);
624       return NULL;
625     }
626 }
627
628
629 #endif /* GNM_SUPPORT */