Implement DATASET commands.
[pspp-builds.git] / src / language / utilities / include.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2007, 2010, 2011 Free Software Foundation, Inc.
3
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.
8
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.
13
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/>. */
16
17 #include <config.h>
18
19 #include <ctype.h>
20 #include <errno.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24
25 #include "data/dataset.h"
26 #include "data/file-name.h"
27 #include "data/session.h"
28 #include "language/command.h"
29 #include "language/lexer/include-path.h"
30 #include "language/lexer/lexer.h"
31 #include "libpspp/i18n.h"
32 #include "libpspp/message.h"
33 #include "libpspp/str.h"
34
35 #include "gl/dirname.h"
36 #include "gl/xalloc.h"
37
38 #include "gettext.h"
39 #define _(msgid) gettext (msgid)
40
41 enum variant
42   {
43     INSERT,
44     INCLUDE
45   };
46
47 static int
48 do_insert (struct lexer *lexer, struct dataset *ds, enum variant variant)
49 {
50   enum lex_syntax_mode syntax_mode;
51   enum lex_error_mode error_mode;
52   char *relative_name;
53   char *filename;
54   char *encoding;
55   int status;
56   bool cd;
57
58   /* Skip optional FILE=. */
59   if (lex_match_id (lexer, "FILE"))
60     lex_match (lexer, T_EQUALS);
61
62   /* File name can be identifier or string. */
63   if (lex_token (lexer) != T_ID && !lex_is_string (lexer))
64     {
65       lex_error (lexer, _("expecting file name"));
66       return CMD_FAILURE;
67     }
68
69   relative_name = utf8_to_filename (lex_tokcstr (lexer)); 
70   filename = include_path_search (relative_name);
71   free (relative_name);
72
73   if ( ! filename)
74     {
75       msg (SE, _("Can't find `%s' in include file search path."),
76            lex_tokcstr (lexer));
77       return CMD_FAILURE;
78     }
79   lex_get (lexer);
80
81   syntax_mode = LEX_SYNTAX_INTERACTIVE;
82   error_mode = LEX_ERROR_CONTINUE;
83   cd = false;
84   status = CMD_FAILURE;
85   encoding = xstrdup (session_get_default_syntax_encoding (
86                         dataset_session (ds)));
87   while ( T_ENDCMD != lex_token (lexer))
88     {
89       if (lex_match_id (lexer, "ENCODING"))
90         {
91           lex_match (lexer, T_EQUALS);
92           if (!lex_force_string (lexer))
93             goto exit;
94
95           free (encoding);
96           encoding = xstrdup (lex_tokcstr (lexer));
97         }
98       else if (variant == INSERT && lex_match_id (lexer, "SYNTAX"))
99         {
100           lex_match (lexer, T_EQUALS);
101           if ( lex_match_id (lexer, "INTERACTIVE") )
102             syntax_mode = LEX_SYNTAX_INTERACTIVE;
103           else if ( lex_match_id (lexer, "BATCH"))
104             syntax_mode = LEX_SYNTAX_BATCH;
105           else if ( lex_match_id (lexer, "AUTO"))
106             syntax_mode = LEX_SYNTAX_AUTO;
107           else
108             {
109               lex_error (lexer, _("expecting %s, %s, or %s after %s"),
110                          "BATCH", "INTERACTIVE", "AUTO", "SYNTAX");
111               goto exit;
112             }
113         }
114       else if (variant == INSERT && lex_match_id (lexer, "CD"))
115         {
116           lex_match (lexer, T_EQUALS);
117           if ( lex_match_id (lexer, "YES") )
118             {
119               cd = true;
120             }
121           else if ( lex_match_id (lexer, "NO"))
122             {
123               cd = false;
124             }
125           else
126             {
127               lex_error (lexer, _("expecting %s or %s after %s"),
128                          "YES", "NO", "CD");
129               goto exit;
130             }
131         }
132       else if (variant == INSERT && lex_match_id (lexer, "ERROR"))
133         {
134           lex_match (lexer, T_EQUALS);
135           if ( lex_match_id (lexer, "CONTINUE") )
136             {
137               error_mode = LEX_ERROR_CONTINUE;
138             }
139           else if ( lex_match_id (lexer, "STOP"))
140             {
141               error_mode = LEX_ERROR_STOP;
142             }
143           else
144             {
145               lex_error (lexer, _("expecting %s or %s after %s"),
146                          "CONTINUE", "STOP", "ERROR");
147               goto exit;
148             }
149         }
150
151       else
152         {
153           lex_error (lexer, NULL);
154           goto exit;
155         }
156     }
157   status = lex_end_of_command (lexer);
158
159   if ( status == CMD_SUCCESS)
160     {
161       struct lex_reader *reader;
162
163       reader = lex_reader_for_file (filename, encoding,
164                                     syntax_mode, error_mode);
165       if (reader != NULL)
166         {
167           lex_discard_rest_of_command (lexer);
168           lex_include (lexer, reader);
169
170           if ( cd )
171             {
172               char *directory = dir_name (filename);
173               chdir (directory);
174               free (directory);
175             }
176         }
177     }
178
179 exit:
180   free (encoding);
181   free (filename);
182   return status;
183 }
184
185 int
186 cmd_include (struct lexer *lexer, struct dataset *ds)
187 {
188   return do_insert (lexer, ds, INCLUDE);
189 }
190
191 int
192 cmd_insert (struct lexer *lexer, struct dataset *ds)
193 {
194   return do_insert (lexer, ds, INSERT);
195 }
196