1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 2007, 2009, 2010, 2011 Free Software Foundation, Inc.
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.
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.
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/>. */
21 #include <libpspp/message.h>
22 #include <libpspp/misc.h>
27 #define _(msgid) gettext (msgid)
28 #define N_(msgid) (msgid)
34 gnumeric_open_reader (struct gnumeric_read_info *gri, struct dictionary **dict)
36 msg (ME, _("Support for Gnumeric files was not compiled into this installation of PSPP"));
49 #include <libxml/xmlreader.h>
52 #include <data/case.h>
53 #include <data/casereader-provider.h>
54 #include <data/dictionary.h>
55 #include <data/identifier.h>
56 #include <data/variable.h>
57 #include <data/value.h>
59 #include <libpspp/i18n.h>
60 #include <libpspp/str.h>
62 #include "gnumeric-reader.h"
64 /* Default width of string variables. */
65 #define GNUMERIC_DEFAULT_WIDTH 8
67 static void gnm_file_casereader_destroy (struct casereader *, void *);
69 static struct ccase *gnm_file_casereader_read (struct casereader *, void *);
71 static const struct casereader_class gnm_file_casereader_class =
73 gnm_file_casereader_read,
74 gnm_file_casereader_destroy,
79 /* Convert a string, which is an integer encoded in base26
80 IE, A=0, B=1, ... Z=25 to the integer it represents.
81 ... except that in this scheme, digits with an exponent
82 greater than 1 are implicitly incremented by 1, so
83 AA = 0 + 1*26, AB = 1 + 1*26,
84 ABC = 2 + 2*26 + 1*26^2 ....
87 pseudo_base26 (const char *str)
92 int len = strlen (str);
94 for ( i = len - 1 ; i >= 0; --i)
96 int mantissa = (str[i] - 'A');
98 if ( mantissa < 0 || mantissa > 25 )
104 result += mantissa * multiplier;
114 /* Convert a cell reference in the form "A1:B2", to
115 integers. A1 means column zero, row zero.
116 B1 means column 1 row 0. AA1 means column 26, row 0.
119 convert_cell_ref (const char *ref,
120 int *col0, int *row0,
121 int *coli, int *rowi)
129 int n = sscanf (ref, "%4[a-zA-Z]%d:%4[a-zA-Z]%d",
135 str_uppercase (startcol);
136 *col0 = pseudo_base26 (startcol);
137 str_uppercase (stopcol);
138 *coli = pseudo_base26 (stopcol);
139 *row0 = startrow - 1;
140 *rowi = stoprow - 1 ;
148 STATE_INIT = 0, /* Initial state */
149 STATE_SHEET_START, /* Found the start of a sheet */
150 STATE_SHEET_NAME, /* Found the sheet name */
152 STATE_SHEET_FOUND, /* Found the sheet that we actually want */
153 STATE_CELLS_START, /* Found the start of the cell array */
154 STATE_CELL /* Found a cell */
158 struct gnumeric_reader
160 xmlTextReaderPtr xtr;
162 enum reader_state state;
169 const xmlChar *target_sheet;
170 int target_sheet_index;
177 struct caseproto *proto;
178 struct dictionary *dict;
179 struct ccase *first_case;
180 bool used_first_case;
183 static void process_node (struct gnumeric_reader *r);
185 #define _xml(X) (CHAR_CAST (const xmlChar *, X))
187 #define _xmlchar_to_int(X) (atoi(CHAR_CAST (const char *, X)))
190 gnm_file_casereader_destroy (struct casereader *reader UNUSED, void *r_)
192 struct gnumeric_reader *r = r_;
197 xmlFreeTextReader (r->xtr);
199 if ( ! r->used_first_case )
200 case_unref (r->first_case);
202 caseproto_unref (r->proto);
208 process_node (struct gnumeric_reader *r)
210 xmlChar *name = xmlTextReaderName (r->xtr);
212 name = xmlStrdup (_xml ("--"));
215 r->node_type = xmlTextReaderNodeType (r->xtr);
220 if (0 == xmlStrcasecmp (name, _xml("gnm:Sheet")) &&
221 XML_READER_TYPE_ELEMENT == r->node_type)
223 r->state = STATE_SHEET_START;
226 case STATE_SHEET_START:
227 if (0 == xmlStrcasecmp (name, _xml("gnm:Name")) &&
228 XML_READER_TYPE_ELEMENT == r->node_type)
230 r->state = STATE_SHEET_NAME;
232 else if (0 == xmlStrcasecmp (name, _xml("gnm:Name")) &&
233 XML_READER_TYPE_END_ELEMENT == r->node_type)
235 r->state = STATE_INIT;
238 case STATE_SHEET_NAME:
239 if (0 == xmlStrcasecmp (name, _xml("gnm:Name")) &&
240 XML_READER_TYPE_END_ELEMENT == r->node_type)
242 r->state = STATE_SHEET_START;
244 else if (XML_READER_TYPE_TEXT == r->node_type)
247 if ( r->target_sheet != NULL)
249 xmlChar *value = xmlTextReaderValue (r->xtr);
250 if ( 0 == xmlStrcmp (value, r->target_sheet))
251 r->state = STATE_SHEET_FOUND;
254 else if (r->target_sheet_index == r->sheet_index)
256 r->state = STATE_SHEET_FOUND;
260 case STATE_SHEET_FOUND:
261 if (0 == xmlStrcasecmp (name, _xml("gnm:Cells")) &&
262 XML_READER_TYPE_ELEMENT == r->node_type)
264 if (! xmlTextReaderIsEmptyElement (r->xtr))
265 r->state = STATE_CELLS_START;
267 else if (0 == xmlStrcasecmp (name, _xml("gnm:MaxRow")) &&
268 XML_READER_TYPE_ELEMENT == r->node_type)
270 r->state = STATE_MAXROW;
272 else if (0 == xmlStrcasecmp (name, _xml("gnm:Sheet")) &&
273 XML_READER_TYPE_END_ELEMENT == r->node_type)
275 r->state = STATE_INIT;
279 if (0 == xmlStrcasecmp (name, _xml("gnm:MaxRow")) &&
280 XML_READER_TYPE_END_ELEMENT == r->node_type)
282 r->state = STATE_SHEET_FOUND;
284 case STATE_CELLS_START:
285 if (0 == xmlStrcasecmp (name, _xml ("gnm:Cell")) &&
286 XML_READER_TYPE_ELEMENT == r->node_type)
288 xmlChar *attr = NULL;
289 r->state = STATE_CELL;
291 attr = xmlTextReaderGetAttribute (r->xtr, _xml ("Col"));
292 r->col = _xmlchar_to_int (attr);
295 attr = xmlTextReaderGetAttribute (r->xtr, _xml ("Row"));
296 r->row = _xmlchar_to_int (attr);
299 else if (0 == xmlStrcasecmp (name, _xml("gnm:Cells")) &&
300 XML_READER_TYPE_END_ELEMENT == r->node_type)
301 r->state = STATE_SHEET_NAME;
305 if (0 == xmlStrcasecmp (name, _xml("gnm:Cell")) &&
306 XML_READER_TYPE_END_ELEMENT == r->node_type)
307 r->state = STATE_CELLS_START;
318 Sets the VAR of case C, to the value corresponding to the xml string XV
321 convert_xml_string_to_value (struct ccase *c, const struct variable *var,
324 union value *v = case_data_rw (c, var);
327 value_set_missing (v, var_get_width (var));
328 else if ( var_is_alpha (var))
329 value_copy_str_rpad (v, var_get_width (var), xv, ' ');
332 const char *text = CHAR_CAST (const char *, xv);
336 v->f = strtod (text, &endptr);
337 if ( errno != 0 || endptr == text)
346 xmlChar *first_value;
350 gnumeric_open_reader (struct gnumeric_read_info *gri, struct dictionary **dict)
352 unsigned long int vstart = 0;
354 casenumber n_cases = CASENUMBER_MAX;
356 struct var_spec *var_spec = NULL;
359 struct gnumeric_reader *r = NULL;
361 gzFile gz = gzopen (gri->file_name, "r");
365 msg (ME, _("Error opening `%s' for reading as a Gnumeric file: %s."),
366 gri->file_name, strerror (errno));
371 r = xzalloc (sizeof *r);
373 r->xtr = xmlReaderForIO ((xmlInputReadCallback) gzread, gzclose, gz,
379 if ( gri->cell_range )
381 if ( ! convert_cell_ref (gri->cell_range,
382 &r->start_col, &r->start_row,
383 &r->stop_col, &r->stop_row))
385 msg (SE, _("Invalid cell range `%s'"),
398 r->state = STATE_INIT;
399 r->target_sheet = BAD_CAST gri->sheet_name;
400 r->target_sheet_index = gri->sheet_index;
401 r->row = r->col = -1;
404 /* Advance to the start of the cells for the target sheet */
405 while ( (r->state != STATE_CELL || r->row < r->start_row )
406 && 1 == (ret = xmlTextReaderRead (r->xtr)))
410 value = xmlTextReaderValue (r->xtr);
412 if ( r->state == STATE_MAXROW && r->node_type == XML_READER_TYPE_TEXT)
414 n_cases = 1 + _xmlchar_to_int (value) ;
420 /* If a range has been given, then use that to calculate the number
422 if ( gri->cell_range)
424 n_cases = MIN (n_cases, r->stop_row - r->start_row + 1);
427 if ( gri->read_names )
433 /* Read in the first row of cells,
434 including the headers if read_names was set */
436 (( r->state == STATE_CELLS_START && r->row <= r->start_row) || r->state == STATE_CELL )
437 && (ret = xmlTextReaderRead (r->xtr))
443 if ( r->row > r->start_row ) break;
445 if ( r->col < r->start_col ||
446 (r->stop_col != -1 && r->col > r->stop_col))
449 idx = r->col - r->start_col;
451 if ( idx >= n_var_specs )
453 n_var_specs = idx + 1 ;
454 var_spec = xrealloc (var_spec, sizeof (*var_spec) * n_var_specs);
455 var_spec [idx].name = NULL;
456 var_spec [idx].width = -1;
457 var_spec [idx].first_value = NULL;
460 if ( r->node_type == XML_READER_TYPE_TEXT )
462 xmlChar *value = xmlTextReaderValue (r->xtr);
463 const char *text = CHAR_CAST (const char *, value);
465 if ( r->row < r->start_row)
467 if ( gri->read_names )
469 var_spec [idx].name = xstrdup (text);
474 var_spec [idx].first_value = xmlStrdup (value);
476 if (-1 == var_spec [idx].width )
477 var_spec [idx].width = (gri->asw == -1) ?
478 ROUND_UP (strlen(text), GNUMERIC_DEFAULT_WIDTH) : gri->asw;
483 else if ( r->node_type == XML_READER_TYPE_ELEMENT
484 && r->state == STATE_CELL)
486 if ( r->row == r->start_row )
489 xmlTextReaderGetAttribute (r->xtr, _xml ("ValueType"));
491 if ( NULL == attr || 60 != _xmlchar_to_int (attr))
492 var_spec [idx].width = 0;
500 /* Create the dictionary and populate it */
501 *dict = r->dict = dict_create ();
503 dict_set_encoding (r->dict, CHAR_CAST (const char *, xmlTextReaderConstEncoding (r->xtr)));
505 for (i = 0 ; i < n_var_specs ; ++i )
509 /* Probably no data exists for this variable, so allocate a
511 if ( var_spec[i].width == -1 )
512 var_spec[i].width = GNUMERIC_DEFAULT_WIDTH;
514 name = dict_make_unique_var_name (r->dict, var_spec[i].name, &vstart);
515 dict_create_var (r->dict, name, var_spec[i].width);
519 /* Create the first case, and cache it */
520 r->used_first_case = false;
522 if ( n_var_specs == 0 )
524 msg (MW, _("Selected sheet or range of spreadsheet `%s' is empty."),
529 r->proto = caseproto_ref (dict_get_proto (r->dict));
530 r->first_case = case_create (r->proto);
531 case_set_missing (r->first_case);
533 for ( i = 0 ; i < n_var_specs ; ++i )
535 const struct variable *var = dict_get_var (r->dict, i);
537 convert_xml_string_to_value (r->first_case, var,
538 var_spec[i].first_value);
541 for ( i = 0 ; i < n_var_specs ; ++i )
543 free (var_spec[i].first_value);
544 free (var_spec[i].name);
549 return casereader_create_sequential
553 &gnm_file_casereader_class, r);
557 for ( i = 0 ; i < n_var_specs ; ++i )
559 free (var_spec[i].first_value);
560 free (var_spec[i].name);
564 dict_destroy (*dict);
566 gnm_file_casereader_destroy (NULL, r);
572 /* Reads and returns one case from READER's file. Returns a null
573 pointer on failure. */
574 static struct ccase *
575 gnm_file_casereader_read (struct casereader *reader UNUSED, void *r_)
580 struct gnumeric_reader *r = r_;
581 int current_row = r->row;
583 if ( !r->used_first_case )
585 r->used_first_case = true;
586 return r->first_case;
589 c = case_create (r->proto);
590 case_set_missing (c);
592 while ((r->state == STATE_CELL || r->state == STATE_CELLS_START )
593 && r->row == current_row && (ret = xmlTextReaderRead (r->xtr)))
597 if ( r->col < r->start_col || (r->stop_col != -1 &&
598 r->col > r->stop_col))
601 if ( r->col - r->start_col >= caseproto_get_n_widths (r->proto))
604 if ( r->stop_row != -1 && r->row > r->stop_row)
607 if ( r->node_type == XML_READER_TYPE_TEXT )
609 xmlChar *value = xmlTextReaderValue (r->xtr);
611 const int idx = r->col - r->start_col;
613 const struct variable *var = dict_get_var (r->dict, idx);
615 convert_xml_string_to_value (c, var, value);
632 #endif /* GNM_SUPPORT */