X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fdata-io%2Fplacement-parser.c;h=983bec84929b62fbace8791592ce4ca36d011670;hb=f7b99e8ac627ba617827961d851ea70efc39ad76;hp=82f9cd6ce82b85f789bf8781c7df1debf5f882fd;hpb=3a61659a8fc11c51ad5af02b20f5613dcde50382;p=pspp diff --git a/src/language/data-io/placement-parser.c b/src/language/data-io/placement-parser.c index 82f9cd6ce8..983bec8492 100644 --- a/src/language/data-io/placement-parser.c +++ b/src/language/data-io/placement-parser.c @@ -1,52 +1,51 @@ -/* PSPP - computes sample statistics. - Copyright (C) 2006 Free Software Foundation, Inc. - Written by Ben Pfaff . +/* PSPP - a program for statistical analysis. + Copyright (C) 2006, 2010, 2011, 2012 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 - published by the Free Software Foundation; either version 2 of the - License, or (at your option) any later version. + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - 02110-1301, USA. */ + along with this program. If not, see . */ #include -#include +#include "language/data-io/placement-parser.h" #include -#include -#include -#include -#include -#include +#include "data/format.h" +#include "language/lexer/format-parser.h" +#include "language/lexer/lexer.h" +#include "libpspp/message.h" +#include "libpspp/pool.h" +#include "libpspp/str.h" -#include "xalloc.h" -#include "xsize.h" +#include "gl/c-strcase.h" +#include "gl/xalloc.h" +#include "gl/xsize.h" #include "gettext.h" #define _(msgid) gettext (msgid) /* Extensions to the format specifiers used only for placement. */ -enum +enum { PRS_TYPE_T = SCHAR_MAX - 3, /* Tab to absolute column. */ PRS_TYPE_X, /* Skip columns. */ PRS_TYPE_NEW_REC /* Next record. */ }; -static bool fixed_parse_columns (struct pool *, size_t var_cnt, bool for_input, - struct fmt_spec **, size_t *); -static bool fixed_parse_fortran (struct pool *, bool for_input, +static bool fixed_parse_columns (struct lexer *, struct pool *, size_t n_vars, + enum fmt_use, struct fmt_spec **, size_t *); +static bool fixed_parse_fortran (struct lexer *l, struct pool *, enum fmt_use, struct fmt_spec **, size_t *); /* Parses Fortran-like or column-based specifications for placing @@ -54,40 +53,49 @@ static bool fixed_parse_fortran (struct pool *, bool for_input, formats like those parsed by DATA LIST or PRINT. Returns true only if successful. - If successful, formats for VAR_CNT variables are stored in + The formats parsed are either input or output formats, according + to USE. + + If USE is FMT_FOR_INPUT, then T, X, and / "formats" are parsed, + in addition to regular formats. If USE is FMT_FOR_OUTPUT, then + T and X "formats" are parsed but not /. + + If successful, formats for N_VARS variables are stored in *FORMATS, and the number of formats required is stored in - *FORMAT_CNT. *FORMAT_CNT may be greater than VAR_CNT because + *FORMAT_CNT. *FORMAT_CNT may be greater than N_VARS because of T, X, and / "formats", but success guarantees that exactly - VAR_CNT variables will be placed by the output formats. The + N_VARS variables will be placed by the output formats. The caller should call execute_placement_format to process those "formats" in interpreting the output. Uses POOL for allocation. When the caller is finished interpreting *FORMATS, POOL may be destroyed. */ bool -parse_var_placements (struct pool *pool, size_t var_cnt, bool for_input, - struct fmt_spec **formats, size_t *format_cnt) +parse_var_placements (struct lexer *lexer, struct pool *pool, size_t n_vars, + enum fmt_use use, + struct fmt_spec **formats, size_t *n_formats) { - assert (var_cnt > 0); - if (lex_is_number ()) - return fixed_parse_columns (pool, var_cnt, for_input, formats, format_cnt); - else if (lex_match ('(')) + assert (n_vars > 0); + if (lex_is_number (lexer)) + return fixed_parse_columns (lexer, pool, n_vars, use, + formats, n_formats); + else if (lex_match (lexer, T_LPAREN)) { - size_t assignment_cnt; - size_t i; - - if (!fixed_parse_fortran (pool, for_input, formats, format_cnt)) - return false; + int start_ofs = lex_ofs (lexer); + if (!fixed_parse_fortran (lexer, pool, use, formats, n_formats)) + return false; + int end_ofs = lex_ofs (lexer) - 1; - assignment_cnt = 0; - for (i = 0; i < *format_cnt; i++) - assignment_cnt += (*formats)[i].type < FMT_NUMBER_OF_FORMATS; + size_t n_assignments = 0; + for (size_t i = 0; i < *n_formats; i++) + n_assignments += (*formats)[i].type < FMT_NUMBER_OF_FORMATS; - if (assignment_cnt != var_cnt) + if (n_assignments != n_vars) { - msg (SE, _("Number of variables specified (%d) " - "differs from number of variable formats (%d)."), - (int) var_cnt, (int) assignment_cnt); + lex_ofs_error (lexer, start_ofs, end_ofs, + _("Number of variables specified (%zu) " + "differs from number of variable formats (%zu)."), + n_vars, n_assignments); return false; } @@ -95,169 +103,186 @@ parse_var_placements (struct pool *pool, size_t var_cnt, bool for_input, } else { - msg (SE, _("SPSS-like or Fortran-like format " - "specification expected after variable names.")); + lex_error (lexer, _("SPSS-like or Fortran-like format " + "specification expected after variable names.")); return false; } } /* Implements parse_var_placements for column-based formats. */ static bool -fixed_parse_columns (struct pool *pool, size_t var_cnt, bool for_input, - struct fmt_spec **formats, size_t *format_cnt) +fixed_parse_columns (struct lexer *lexer, struct pool *pool, size_t n_vars, + enum fmt_use use, + struct fmt_spec **formats, size_t *n_formats) { - struct fmt_spec format; - int fc, lc; - size_t i; + int start_ofs = lex_ofs (lexer); - if (!parse_column_range (&fc, &lc, NULL)) + int fc, lc; + if (!parse_column_range (lexer, 1, &fc, &lc, NULL)) return false; - /* Divide columns evenly. */ - format.w = (lc - fc + 1) / var_cnt; - if ((lc - fc + 1) % var_cnt) + /* Divide columns evenly. */ + int w = (lc - fc + 1) / n_vars; + if ((lc - fc + 1) % n_vars) { - msg (SE, _("The %d columns %d-%d " - "can't be evenly divided into %d fields."), - lc - fc + 1, fc, lc, var_cnt); + lex_ofs_error (lexer, start_ofs, lex_ofs (lexer) - 1, + _("The %d columns %d-%d " + "can't be evenly divided into %zu fields."), + lc - fc + 1, fc, lc, n_vars); return false; } /* Format specifier. */ - if (lex_match ('(')) + enum fmt_type type; + int d; + if (lex_match (lexer, T_LPAREN)) { /* Get format type. */ - if (token == T_ID) + if (lex_token (lexer) == T_ID) { - if (!parse_format_specifier_name (&format.type)) + if (!parse_format_specifier_name (lexer, &type)) return false; - lex_match (','); + lex_match (lexer, T_COMMA); } else - format.type = FMT_F; + type = FMT_F; /* Get decimal places. */ - if (lex_is_integer ()) + if (lex_is_integer (lexer)) { - format.d = lex_integer (); - lex_get (); + d = lex_integer (lexer); + lex_get (lexer); } else - format.d = 0; + d = 0; - if (!lex_force_match (')')) + if (!lex_force_match (lexer, T_RPAREN)) return false; } else { - format.type = FMT_F; - format.d = 0; + type = FMT_F; + d = 0; } - if (!fmt_check (&format, for_input)) - return false; + int end_ofs = lex_ofs (lexer) - 1; - *formats = pool_nalloc (pool, var_cnt + 1, sizeof **formats); - *format_cnt = var_cnt + 1; - (*formats)[0].type = PRS_TYPE_T; + struct fmt_spec format = { .type = type, .w = w, .d = d }; + char *error = fmt_check__ (&format, use); + if (error) + { + lex_ofs_error (lexer, start_ofs, end_ofs, "%s", error); + free (error); + return false; + } + + *formats = pool_nalloc (pool, n_vars + 1, sizeof **formats); + *n_formats = n_vars + 1; + (*formats)[0].type = (enum fmt_type) PRS_TYPE_T; (*formats)[0].w = fc; - for (i = 1; i <= var_cnt; i++) + for (size_t i = 1; i <= n_vars; i++) (*formats)[i] = format; return true; } /* Implements parse_var_placements for Fortran-like formats. */ static bool -fixed_parse_fortran (struct pool *pool, bool for_input, - struct fmt_spec **formats, size_t *format_cnt) +fixed_parse_fortran (struct lexer *lexer, struct pool *pool, enum fmt_use use, + struct fmt_spec **formats, size_t *n_formats) { size_t formats_allocated = 0; size_t formats_used = 0; *formats = NULL; - while (!lex_match (')')) + while (!lex_match (lexer, T_RPAREN)) { struct fmt_spec f; struct fmt_spec *new_formats; - size_t new_format_cnt; + size_t n_new_formats; size_t count; size_t formats_needed; - + /* Parse count. */ - if (lex_is_integer ()) + if (lex_is_integer (lexer)) { - count = lex_integer (); - lex_get (); + count = lex_integer (lexer); + lex_get (lexer); } else count = 1; /* Parse format specifier. */ - if (lex_match ('(')) + if (lex_match (lexer, T_LPAREN)) { /* Call ourselves recursively to handle parentheses. */ - if (!fixed_parse_fortran (pool, for_input, - &new_formats, &new_format_cnt)) + if (!fixed_parse_fortran (lexer, pool, use, + &new_formats, &n_new_formats)) return false; } else { new_formats = &f; - new_format_cnt = 1; - if (lex_match ('/')) - f.type = PRS_TYPE_NEW_REC; + n_new_formats = 1; + if (use == FMT_FOR_INPUT && lex_match (lexer, T_SLASH)) + f.type = (enum fmt_type) PRS_TYPE_NEW_REC; else { + int ofs = lex_ofs (lexer); char type[FMT_TYPE_LEN_MAX + 1]; - - if (!parse_abstract_format_specifier (type, &f.w, &f.d)) + if (!parse_abstract_format_specifier (lexer, type, &f.w, &f.d)) return false; - if (!strcasecmp (type, "T")) - f.type = PRS_TYPE_T; - else if (!strcasecmp (type, "X")) + if (!c_strcasecmp (type, "T")) + f.type = (enum fmt_type) PRS_TYPE_T; + else if (!c_strcasecmp (type, "X")) { - f.type = PRS_TYPE_X; + f.type = (enum fmt_type) PRS_TYPE_X; f.w = count; count = 1; } - else + else { - if (!fmt_from_name (type, &f.type)) + if (!fmt_from_name (type, &f.type)) { - msg (SE, _("Unknown format type \"%s\"."), type); + lex_ofs_error (lexer, ofs, ofs, + _("Unknown format type `%s'."), type); + return false; + } + char *error = fmt_check__ (&f, use); + if (error) + { + lex_ofs_error (lexer, ofs, ofs, "%s", error); + free (error); return false; } - if (!fmt_check (&f, for_input)) - return false; } - } + } } /* Add COUNT copies of the NEW_FORMAT_CNT formats in NEW_FORMATS to FORMATS. */ - if (new_format_cnt != 0 + if (n_new_formats != 0 && size_overflow_p (xtimes (xsum (formats_used, - xtimes (count, new_format_cnt)), + xtimes (count, n_new_formats)), sizeof *formats))) xalloc_die (); - formats_needed = count * new_format_cnt; - if (formats_used + formats_needed > formats_allocated) + formats_needed = count * n_new_formats; + if (formats_used + formats_needed > formats_allocated) { formats_allocated = formats_used + formats_needed; *formats = pool_2nrealloc (pool, *formats, &formats_allocated, sizeof **formats); } - for (; count > 0; count--) + for (; count > 0; count--) { memcpy (&(*formats)[formats_used], new_formats, - sizeof **formats * new_format_cnt); - formats_used += new_format_cnt; + sizeof **formats * n_new_formats); + formats_used += n_new_formats; } - lex_match (','); + lex_match (lexer, T_COMMA); } - *format_cnt = formats_used; + *n_formats = formats_used; return true; } @@ -267,18 +292,18 @@ fixed_parse_fortran (struct pool *pool, bool for_input, without any side effects. */ bool execute_placement_format (const struct fmt_spec *format, - int *record, int *column) + int *record, int *column) { - switch (format->type) + switch ((int) format->type) { case PRS_TYPE_X: *column += format->w; return true; - + case PRS_TYPE_T: *column = format->w; return true; - + case PRS_TYPE_NEW_REC: (*record)++; *column = 1; @@ -290,53 +315,88 @@ execute_placement_format (const struct fmt_spec *format, } } +static bool +parse_column__ (struct lexer *lexer, bool negative, int base, int *column) +{ + assert (base == 0 || base == 1); + + if (!lex_force_int (lexer)) + return false; + long int value = lex_integer (lexer); + if (negative) + value = -value; + lex_get (lexer); + + *column = value - base + 1; + if (*column < 1) + { + if (base == 1) + lex_next_error (lexer, -1, -1, + _("Column positions for fields must be positive.")); + else + lex_next_error (lexer, -1, -1, + _("Column positions for fields must not be negative.")); + return false; + } + return true; +} + +/* Parses a BASE-based column using LEXER. Returns true and + stores a 1-based column number into *COLUMN if successful, + otherwise emits an error message and returns false. + + If BASE is 0, zero-based column numbers are parsed; if BASE is + 1, 1-based column numbers are parsed. Regardless of BASE, the + values stored in *FIRST_COLUMN and *LAST_COLUMN are + 1-based. */ +bool +parse_column (struct lexer *lexer, int base, int *column) +{ + return parse_column__ (lexer, false, base, column); +} + /* Parse a column or a range of columns, specified as a single - integer or two integer delimited by a dash. Stores the range + integer or two integers delimited by a dash. Stores the range in *FIRST_COLUMN and *LAST_COLUMN. (If only a single integer is given, it is stored in both.) If RANGE_SPECIFIED is non-null, then *RANGE_SPECIFIED is set to true if the syntax contained a dash, false otherwise. Returns true if successful, false if the syntax was invalid or the values - specified did not make sense. */ + specified did not make sense. + + If BASE is 0, zero-based column numbers are parsed; if BASE is + 1, 1-based column numbers are parsed. Regardless of BASE, the + values stored in *FIRST_COLUMN and *LAST_COLUMN are + 1-based. */ bool -parse_column_range (int *first_column, int *last_column, - bool *range_specified) +parse_column_range (struct lexer *lexer, int base, + int *first_column, int *last_column, + bool *range_specified) { + int start_ofs = lex_ofs (lexer); + /* First column. */ - if (!lex_force_int ()) + if (!parse_column__ (lexer, false, base, first_column)) return false; - *first_column = lex_integer (); - if (*first_column < 1) - { - msg (SE, _("Column positions for fields must be positive.")); - return false; - } - lex_get (); /* Last column. */ - lex_negative_to_dash (); - if (lex_match ('-')) + if (lex_is_integer (lexer) && lex_integer (lexer) < 0) { - if (!lex_force_int ()) - return false; - *last_column = lex_integer (); - if (*last_column < 1) - { - msg (SE, _("Column positions for fields must be positive.")); - return false; - } - else if (*last_column < *first_column) + if (!parse_column__ (lexer, true, base, last_column)) + return false; + + if (*last_column < *first_column) { - msg (SE, _("The ending column for a field must be " - "greater than the starting column.")); + lex_ofs_error (lexer, start_ofs, lex_ofs (lexer) - 1, + _("The ending column for a field must be " + "greater than the starting column.")); return false; } if (range_specified) *range_specified = true; - lex_get (); } - else + else { *last_column = *first_column; if (range_specified) @@ -354,29 +414,22 @@ parse_column_range (int *first_column, int *last_column, Returns true if successful, false on syntax error. */ bool -parse_record_placement (int *record, int *column) +parse_record_placement (struct lexer *lexer, int *record, int *column) { - while (lex_match ('/')) + while (lex_match (lexer, T_SLASH)) { - if (lex_is_integer ()) + if (lex_is_number (lexer)) { - if (lex_integer () <= *record) - { - msg (SE, _("The record number specified, %ld, is at or " - "before the previous record, %d. Data " - "fields must be listed in order of " - "increasing record number."), - lex_integer (), *record); - return false; - } - *record = lex_integer (); - lex_get (); + if (!lex_force_int_range (lexer, NULL, *record + 1, INT_MAX)) + return false; + *record = lex_integer (lexer); + lex_get (lexer); } else (*record)++; *column = 1; } assert (*record >= 1); - + return true; }