02111-1307, USA. */
#include <config.h>
+#include "data-list.h"
#include <assert.h>
#include <ctype.h>
#include <float.h>
return CMD_FAILURE;
dls.end = dict_lookup_var (default_dict, tokid);
if (!dls.end)
- {
- dls.end = dict_create_var (default_dict, tokid, 0);
- assert (dls.end != NULL);
- }
+ dls.end = dict_create_var_assert (default_dict, tokid, 0);
lex_get ();
}
else if (token == T_ID)
{
convert_fmt_ItoO (&fx.spec.input, &v->print);
v->write = v->print;
+ if (vfm_source != &input_program_source
+ && vfm_source != &file_type_source)
+ v->init = 0;
}
else
{
- v = dict_lookup_var (default_dict, fx.name[i]);
- assert (v != NULL);
+ v = dict_lookup_var_assert (default_dict, fx.name[i]);
if (!vfm_source)
{
msg (SE, _("%s is a duplicate variable name."), fx.name[i]);
return 0;
}
+ if (vfm_source != &input_program_source
+ && vfm_source != &file_type_source)
+ v->init = 0;
+
fx.spec.input = f->f;
convert_fmt_ItoO (&fx.spec.input, &v->print);
v->write = v->print;
v->print = v->write = out;
+ if (vfm_source != &input_program_source
+ && vfm_source != &file_type_source)
+ v->init = 0;
+
strcpy (spec.name, name[i]);
spec.fv = v->fv;
spec.width = width;
static int read_from_data_list_fixed (void);
static int read_from_data_list_free (void);
static int read_from_data_list_list (void);
-static int do_reading (int flag);
/* FLAG==0: reads any number of cases into temp_case and calls
write_case() for each one, returns garbage. FLAG!=0: reads one
case into temp_case and returns -2 on eof, -1 otherwise.
Uses dlsp as the relevant parsing description. */
static int
-do_reading (int flag)
+do_reading (int flag, write_case_func *write_case, write_case_data wc_data)
{
int (*func) (void);
else
{
while (func () != -2)
- if (!write_case ())
+ if (!write_case (wc_data))
{
debug_printf ((_("abort in write_case()\n")));
break;
/* Note that since this is exclusively an input program, C is
guaranteed to be temp_case. */
static int
-read_one_case (struct trns_header *t, struct ccase *c unused)
+read_one_case (struct trns_header *t, struct ccase *c UNUSED)
{
dlsp = (struct data_list_pgm *) t;
- return do_reading (1);
+ return do_reading (1, NULL, NULL);
}
\f
/* Reads all the records from the data file and passes them to
write_case(). */
static void
-data_list_source_read (void)
+data_list_source_read (write_case_func *write_case, write_case_data wc_data)
{
dlsp = &dls;
- do_reading (0);
+ do_reading (0, write_case, wc_data);
}
/* Destroys the source's internal data. */
int id_beg, id_end; /* ID subcommand, beginning & end columns. */
struct variable *id_var; /* ID subcommand, DATA LIST variable. */
struct fmt_spec id_spec; /* ID subcommand, input format spec. */
+ write_case_func *write_case;
+ write_case_data wc_data;
};
/* Information about the transformation being parsed. */
static struct repeating_data_trns rpd;
-static int read_one_set_of_repetitions (struct trns_header *, struct ccase *);
+int repeating_data_trns_proc (struct trns_header *, struct ccase *);
static int parse_num_or_var (struct rpd_num_or_var *, const char *);
static int parse_repeating_data (void);
static void find_variable_input_spec (struct variable *v,
lex_match ('=');
if (seen & 1)
{
- msg (SE, _("STARTS subcommand given multiple times."));
+ msg (SE, _("%s subcommand given multiple times."),"STARTS");
return CMD_FAILURE;
}
seen |= 1;
lex_match ('=');
if (seen & 2)
{
- msg (SE, _("OCCURS subcommand given multiple times."));
+ msg (SE, _("%s subcommand given multiple times."),"OCCURS");
return CMD_FAILURE;
}
seen |= 2;
lex_match ('=');
if (seen & 4)
{
- msg (SE, _("LENGTH subcommand given multiple times."));
+ msg (SE, _("%s subcommand given multiple times."),"LENGTH");
return CMD_FAILURE;
}
seen |= 4;
lex_match ('=');
if (seen & 8)
{
- msg (SE, _("CONTINUED subcommand given multiple times."));
+ msg (SE, _("%s subcommand given multiple times."),"CONTINUED");
return CMD_FAILURE;
}
seen |= 8;
lex_match ('=');
if (seen & 16)
{
- msg (SE, _("ID subcommand given multiple times."));
+ msg (SE, _("%s subcommand given multiple times."),"ID");
return CMD_FAILURE;
}
seen |= 16;
{
struct repeating_data_trns *new_trns;
- rpd.h.proc = read_one_set_of_repetitions;
+ rpd.h.proc = repeating_data_trns_proc;
rpd.h.free = destroy_dls;
new_trns = xmalloc (sizeof *new_trns);
warned = 1;
tmsg (SW, RPD_ERR,
- _("Variable %s startging in column %d extends "
+ _("Variable %s starting in column %d extends "
"beyond physical record length of %d."),
var_spec->v->name, fc, len);
}
cur += ofs;
- if (!write_case ())
+ if (!t->write_case (t->wc_data))
return 0;
}
}
/* Analogous to read_one_case; reads one set of repetitions of the
elements in the REPEATING DATA structure. Returns -1 on success,
-2 on end of file or on failure. */
-static int
-read_one_set_of_repetitions (struct trns_header *trns, struct ccase *c)
+int
+repeating_data_trns_proc (struct trns_header *trns, struct ccase *c)
{
dfm_push (dlsp->handle);
transformations. */
return -3;
}
+
+/* This is a kluge. It is only here until I have more time
+ tocome up with something better. It lets
+ repeating_data_trns_proc() know how to write the cases that it
+ composes. */
+void
+repeating_data_set_write_case (struct trns_header *trns,
+ write_case_func *write_case,
+ write_case_data wc_data)
+{
+ struct repeating_data_trns *t = (struct repeating_data_trns *) trns;
+
+ assert (trns->proc == repeating_data_trns_proc);
+ t->write_case = write_case;
+ t->wc_data = wc_data;
+}
projects / pspp-builds.git / blobdiff