added automake.mk files in src/language
[pspp] / src / data / any-reader.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 2006 Free Software Foundation, Inc.
3    Written by Ben Pfaff <blp@gnu.org>.
4
5    This program is free software; you can redistribute it and/or
6    modify it under the terms of the GNU General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18    02110-1301, USA. */
19
20 #include <config.h>
21 #include "any-reader.h"
22 #include <assert.h>
23 #include <errno.h>
24 #include <stdbool.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include "message.h"
28 #include "file-handle-def.h"
29 #include "filename.h"
30 #include "por-file-reader.h"
31 #include "sys-file-reader.h"
32 #include "str.h"
33 #include "scratch-reader.h"
34 #include "xalloc.h"
35
36 #include "gettext.h"
37 #define _(msgid) gettext (msgid)
38
39 /* Type of file backing an any_reader. */
40 enum any_reader_type
41   {
42     SYSTEM_FILE,                /* System file. */
43     PORTABLE_FILE,              /* Portable file. */
44     SCRATCH_FILE                /* Scratch file. */
45   };
46
47 /* Reader for any type of case-structured file. */
48 struct any_reader 
49   {
50     enum any_reader_type type;  /* Type of file. */
51     void *private;              /* Private data. */
52   };
53
54 /* Result of type detection. */
55 enum detect_result 
56   {
57     YES,                        /* It is this type. */
58     NO,                         /* It is not this type. */
59     IO_ERROR                    /* File couldn't be opened. */
60   };
61
62 /* Tries to detect whether HANDLE represents a given type of
63    file, by opening the file and passing it to DETECT, and
64    returns a detect_result. */
65 static enum detect_result
66 try_detect (struct file_handle *handle, bool (*detect) (FILE *))
67 {
68   FILE *file;
69   bool is_type;
70
71   file = fn_open (fh_get_filename (handle), "rb");
72   if (file == NULL)
73     {
74       msg (ME, _("An error occurred while opening \"%s\": %s."),
75            fh_get_filename (handle), strerror (errno));
76       return IO_ERROR;
77     }
78     
79   is_type = detect (file);
80   
81   fn_close (fh_get_filename (handle), file);
82
83   return is_type ? YES : NO;
84 }
85
86 /* If PRIVATE is non-null, creates and returns a new any_reader,
87    initializing its fields to TYPE and PRIVATE.  If PRIVATE is a
88    null pointer, just returns a null pointer. */   
89 static struct any_reader *
90 make_any_reader (enum any_reader_type type, void *private) 
91 {
92   if (private != NULL) 
93     {
94       struct any_reader *reader = xmalloc (sizeof *reader);
95       reader->type = type;
96       reader->private = private;
97       return reader;
98     }
99   else
100     return NULL;
101 }
102
103 /* Creates an any_reader for HANDLE.  On success, returns the new
104    any_reader and stores the file's dictionary into *DICT.  On
105    failure, returns a null pointer. */
106 struct any_reader *
107 any_reader_open (struct file_handle *handle, struct dictionary **dict)
108 {
109   switch (fh_get_referent (handle)) 
110     {
111     case FH_REF_FILE:
112       {
113         enum detect_result result;
114
115         result = try_detect (handle, sfm_detect);
116         if (result == IO_ERROR)
117           return NULL;
118         else if (result == YES)
119           return make_any_reader (SYSTEM_FILE,
120                                   sfm_open_reader (handle, dict, NULL));
121
122         result = try_detect (handle, pfm_detect);
123         if (result == IO_ERROR)
124           return NULL;
125         else if (result == YES)
126           return make_any_reader (PORTABLE_FILE,
127                                   pfm_open_reader (handle, dict, NULL));
128
129         msg (SE, _("\"%s\" is not a system or portable file."),
130              fh_get_filename (handle));
131         return NULL;
132       }
133
134     case FH_REF_INLINE:
135       msg (SE, _("The inline file is not allowed here."));
136       return NULL;
137
138     case FH_REF_SCRATCH:
139       return make_any_reader (SCRATCH_FILE,
140                               scratch_reader_open (handle, dict));
141     }
142   abort ();
143 }
144
145 /* Reads a single case from READER into C.
146    Returns true if successful, false at end of file or on error. */
147 bool
148 any_reader_read (struct any_reader *reader, struct ccase *c) 
149 {
150   switch (reader->type) 
151     {
152     case SYSTEM_FILE:
153       return sfm_read_case (reader->private, c);
154
155     case PORTABLE_FILE:
156       return pfm_read_case (reader->private, c);
157
158     case SCRATCH_FILE:
159       return scratch_reader_read_case (reader->private, c);
160     }
161   abort ();
162 }
163
164 /* Returns true if an I/O error has occurred on READER, false
165    otherwise. */
166 bool
167 any_reader_error (struct any_reader *reader) 
168 {
169   switch (reader->type) 
170     {
171     case SYSTEM_FILE:
172       return sfm_read_error (reader->private);
173
174     case PORTABLE_FILE:
175       return pfm_read_error (reader->private);
176
177     case SCRATCH_FILE:
178       return scratch_reader_error (reader->private);
179     }
180   abort ();
181 }
182
183 /* Closes READER. */
184 void
185 any_reader_close (struct any_reader *reader) 
186 {
187   if (reader == NULL)
188     return;
189
190   switch (reader->type) 
191     {
192     case SYSTEM_FILE:
193       sfm_close_reader (reader->private);
194       break;
195
196     case PORTABLE_FILE:
197       pfm_close_reader (reader->private);
198       break;
199
200     case SCRATCH_FILE:
201       scratch_reader_close (reader->private);
202       break;
203
204     default:
205       abort ();
206     }
207 }