X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fdata-io%2Fplacement-parser.c;h=4f1d062cb8d3b18734afacfc427f1bfd5b1b5408;hb=173d1687aea88e0e5e1b1d8615ed68ebefb15d08;hp=074c5693312b00e6a3d5406ed4a69d322247b8c0;hpb=3816248a008a4af75aac6319d0c9929cb7ff679e;p=pspp diff --git a/src/language/data-io/placement-parser.c b/src/language/data-io/placement-parser.c index 074c569331..4f1d062cb8 100644 --- a/src/language/data-io/placement-parser.c +++ b/src/language/data-io/placement-parser.c @@ -1,21 +1,18 @@ -/* PSPP - computes sample statistics. +/* PSPP - a program for statistical analysis. Copyright (C) 2006 Free Software Foundation, Inc. - Written by Ben Pfaff . - 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 @@ -29,6 +26,8 @@ #include #include +#include + #include "xalloc.h" #include "xsize.h" @@ -37,7 +36,7 @@ /* 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. */ @@ -66,18 +65,18 @@ static bool fixed_parse_fortran (struct lexer *l, struct pool *, bool for_input, interpreting *FORMATS, POOL may be destroyed. */ bool parse_var_placements (struct lexer *lexer, struct pool *pool, size_t var_cnt, bool for_input, - struct fmt_spec **formats, size_t *format_cnt) + struct fmt_spec **formats, size_t *format_cnt) { assert (var_cnt > 0); if (lex_is_number (lexer)) return fixed_parse_columns (lexer, pool, var_cnt, for_input, formats, format_cnt); - else if (lex_match (lexer, '(')) + else if (lex_match (lexer, '(')) { size_t assignment_cnt; size_t i; if (!fixed_parse_fortran (lexer, pool, for_input, formats, format_cnt)) - return false; + return false; assignment_cnt = 0; for (i = 0; i < *format_cnt; i++) @@ -85,9 +84,9 @@ parse_var_placements (struct lexer *lexer, struct pool *pool, size_t var_cnt, bo if (assignment_cnt != var_cnt) { - msg (SE, _("Number of variables specified (%d) " - "differs from number of variable formats (%d)."), - (int) var_cnt, (int) assignment_cnt); + msg (SE, _("Number of variables specified (%zu) " + "differs from number of variable formats (%zu)."), + var_cnt, assignment_cnt); return false; } @@ -110,15 +109,15 @@ fixed_parse_columns (struct lexer *lexer, struct pool *pool, size_t var_cnt, boo int fc, lc; size_t i; - if ( !parse_column_range (lexer, &fc, &lc, NULL) ) + if ( !parse_column_range (lexer, 1, &fc, &lc, NULL) ) return false; - /* Divide columns evenly. */ + /* Divide columns evenly. */ format.w = (lc - fc + 1) / var_cnt; if ((lc - fc + 1) % var_cnt) { msg (SE, _("The %d columns %d-%d " - "can't be evenly divided into %d fields."), + "can't be evenly divided into %zu fields."), lc - fc + 1, fc, lc, var_cnt); return false; } @@ -181,7 +180,7 @@ fixed_parse_fortran (struct lexer *lexer, struct pool *pool, bool for_input, size_t new_format_cnt; size_t count; size_t formats_needed; - + /* Parse count. */ if (lex_is_integer (lexer)) { @@ -208,29 +207,29 @@ fixed_parse_fortran (struct lexer *lexer, struct pool *pool, bool for_input, else { char type[FMT_TYPE_LEN_MAX + 1]; - + if (!parse_abstract_format_specifier (lexer, type, &f.w, &f.d)) return false; - if (!strcasecmp (type, "T")) + if (!strcasecmp (type, "T")) f.type = PRS_TYPE_T; - else if (!strcasecmp (type, "X")) + else if (!strcasecmp (type, "X")) { f.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); + msg (SE, _("Unknown format type `%s'."), type); return false; } if (!fmt_check (&f, for_input)) return false; } - } + } } /* Add COUNT copies of the NEW_FORMAT_CNT formats in @@ -241,13 +240,13 @@ fixed_parse_fortran (struct lexer *lexer, struct pool *pool, bool for_input, sizeof *formats))) xalloc_die (); formats_needed = count * new_format_cnt; - if (formats_used + formats_needed > formats_allocated) + 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); @@ -267,18 +266,18 @@ fixed_parse_fortran (struct lexer *lexer, 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 (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,42 +289,57 @@ execute_placement_format (const struct fmt_spec *format, } } +/* 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. */ +static bool +parse_column (struct lexer *lexer, int base, int *column) +{ + assert (base == 0 || base == 1); + if (!lex_force_int (lexer)) + return false; + *column = lex_integer (lexer) - base + 1; + if (*column < 1) + { + if (base == 1) + msg (SE, _("Column positions for fields must be positive.")); + else + msg (SE, _("Column positions for fields must not be negative.")); + return false; + } + lex_get (lexer); + return true; +} + /* 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 (struct lexer *lexer, 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) { /* First column. */ - if (!lex_force_int (lexer)) + if (!parse_column (lexer, base, first_column)) return false; - *first_column = lex_integer (lexer); - if (*first_column < 1) - { - msg (SE, _("Column positions for fields must be positive.")); - return false; - } - lex_get (lexer); /* Last column. */ lex_negative_to_dash (lexer); if (lex_match (lexer, '-')) { - if (!lex_force_int (lexer)) - return false; - *last_column = lex_integer (lexer); - 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, 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.")); @@ -334,9 +348,8 @@ parse_column_range (struct lexer *lexer, int *first_column, int *last_column, if (range_specified) *range_specified = true; - lex_get (lexer); } - else + else { *last_column = *first_column; if (range_specified) @@ -354,7 +367,7 @@ parse_column_range (struct lexer *lexer, int *first_column, int *last_column, Returns true if successful, false on syntax error. */ bool -parse_record_placement (struct lexer *lexer, int *record, int *column) +parse_record_placement (struct lexer *lexer, int *record, int *column) { while (lex_match (lexer, '/')) { @@ -377,6 +390,6 @@ parse_record_placement (struct lexer *lexer, int *record, int *column) *column = 1; } assert (*record >= 1); - + return true; }