Make the value labels dialog resizable
[pspp-builds.git] / src / ui / terminal / terminal-reader.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2007, 2009, 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 "ui/terminal/terminal-reader.h"
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <stdbool.h>
24 #include <stdint.h>
25 #include <stdlib.h>
26
27 #include "data/file-name.h"
28 #include "data/settings.h"
29 #include "language/command.h"
30 #include "language/lexer/lexer.h"
31 #include "libpspp/assertion.h"
32 #include "libpspp/cast.h"
33 #include "libpspp/message.h"
34 #include "libpspp/prompt.h"
35 #include "libpspp/str.h"
36 #include "libpspp/version.h"
37 #include "output/driver.h"
38 #include "output/journal.h"
39 #include "ui/terminal/terminal.h"
40
41 #include "gl/minmax.h"
42 #include "gl/xalloc.h"
43
44 #include "gettext.h"
45 #define _(msgid) gettext (msgid)
46
47 struct terminal_reader
48   {
49     struct lex_reader reader;
50     struct substring s;
51     size_t offset;
52     bool eof;
53   };
54
55 static int n_terminal_readers;
56
57 static void readline_init (void);
58 static void readline_done (void);
59 static struct substring readline_read (enum prompt_style);
60
61 /* Display a welcoming message. */
62 static void
63 welcome (void)
64 {
65   static bool welcomed = false;
66   if (welcomed)
67     return;
68   welcomed = true;
69   fputs ("PSPP is free software and you are welcome to distribute copies of "
70          "it\nunder certain conditions; type \"show copying.\" to see the "
71          "conditions.\nThere is ABSOLUTELY NO WARRANTY for PSPP; type \"show "
72          "warranty.\" for details.\n", stdout);
73   puts (stat_version);
74   journal_enable ();
75 }
76
77 static struct terminal_reader *
78 terminal_reader_cast (struct lex_reader *r)
79 {
80   return UP_CAST (r, struct terminal_reader, reader);
81 }
82
83 static size_t
84 terminal_reader_read (struct lex_reader *r_, char *buf, size_t n,
85                       enum prompt_style prompt_style)
86 {
87   struct terminal_reader *r = terminal_reader_cast (r_);
88   size_t chunk;
89
90   if (r->offset >= r->s.length && !r->eof)
91     {
92       welcome ();
93       msg_ui_reset_counts ();
94       output_flush ();
95
96       ss_dealloc (&r->s);
97       r->s = readline_read (prompt_style);
98       r->offset = 0;
99       r->eof = ss_is_empty (r->s);
100
101       /* Check whether the size of the window has changed, so that
102          the output drivers can adjust their settings as needed.  We
103          only do this for the first line of a command, as it's
104          possible that the output drivers are actually in use
105          afterward, and we don't want to confuse them in the middle
106          of output. */
107       if (prompt_style == PROMPT_FIRST)
108         terminal_check_size ();
109     }
110
111   chunk = MIN (n, r->s.length - r->offset);
112   memcpy (buf, r->s.string + r->offset, chunk);
113   r->offset += chunk;
114   return chunk;
115 }
116
117 static void
118 terminal_reader_close (struct lex_reader *r_)
119 {
120   struct terminal_reader *r = terminal_reader_cast (r_);
121
122   ss_dealloc (&r->s);
123   free (r->reader.file_name);
124   free (r);
125
126   if (!--n_terminal_readers)
127     readline_done ();
128 }
129
130 static struct lex_reader_class terminal_reader_class =
131   {
132     terminal_reader_read,
133     terminal_reader_close
134   };
135
136 /* Creates a source which uses readln to get its line */
137 struct lex_reader *
138 terminal_reader_create (void)
139 {
140   struct terminal_reader *r;
141
142   if (!n_terminal_readers++)
143     readline_init ();
144
145   r = xzalloc (sizeof *r);
146   r->reader.class = &terminal_reader_class;
147   r->reader.syntax = LEX_SYNTAX_INTERACTIVE;
148   r->reader.error = LEX_ERROR_INTERACTIVE;
149   r->reader.file_name = NULL;
150   r->s = ss_empty ();
151   r->offset = 0;
152   r->eof = false;
153   return &r->reader;
154 }
155 \f
156
157
158 static const char *
159 readline_prompt (enum prompt_style style)
160 {
161   switch (style)
162     {
163     case PROMPT_FIRST:
164       return "PSPP> ";
165
166     case PROMPT_LATER:
167       return "    > ";
168
169     case PROMPT_DATA:
170       return "data> ";
171
172     case PROMPT_COMMENT:
173       return "comment> ";
174
175     case PROMPT_DOCUMENT:
176       return "document> ";
177
178     case PROMPT_DO_REPEAT:
179       return "DO REPEAT> ";
180     }
181
182   NOT_REACHED ();
183 }
184
185
186 #if HAVE_READLINE
187 #include <readline/readline.h>
188 #include <readline/history.h>
189
190 static char *history_file;
191
192 static char **complete_command_name (const char *, int, int);
193 static char **dont_complete (const char *, int, int);
194 static char *command_generator (const char *text, int state);
195
196 static void
197 readline_init (void)
198 {
199   rl_basic_word_break_characters = "\n";
200   using_history ();
201   stifle_history (500);
202   if (history_file == NULL)
203     {
204       const char *home_dir = getenv ("HOME");
205       if (home_dir != NULL)
206         {
207           history_file = xasprintf ("%s/.pspp_history", home_dir);
208           read_history (history_file);
209         }
210     }
211 }
212
213 static void
214 readline_done (void)
215 {
216   if (history_file != NULL && false == settings_get_testing_mode () )
217     write_history (history_file);
218   clear_history ();
219   free (history_file);
220 }
221
222 static struct substring
223 readline_read (enum prompt_style style)
224 {
225   char *string;
226
227   rl_attempted_completion_function = (style == PROMPT_FIRST
228                                       ? complete_command_name
229                                       : dont_complete);
230   string = readline (readline_prompt (style));
231   if (string != NULL)
232     {
233       char *end;
234
235       if (string[0])
236         add_history (string);
237
238       end = strchr (string, '\0');
239       *end = '\n';
240       return ss_buffer (string, end - string + 1);
241     }
242   else
243     return ss_empty ();
244 }
245
246 /* Returns a set of command name completions for TEXT.
247    This is of the proper form for assigning to
248    rl_attempted_completion_function. */
249 static char **
250 complete_command_name (const char *text, int start, int end UNUSED)
251 {
252   if (start == 0)
253     {
254       /* Complete command name at start of line. */
255       return rl_completion_matches (text, command_generator);
256     }
257   else
258     {
259       /* Otherwise don't do any completion. */
260       rl_attempted_completion_over = 1;
261       return NULL;
262     }
263 }
264
265 /* Do not do any completion for TEXT. */
266 static char **
267 dont_complete (const char *text UNUSED, int start UNUSED, int end UNUSED)
268 {
269   rl_attempted_completion_over = 1;
270   return NULL;
271 }
272
273 /* If STATE is 0, returns the first command name matching TEXT.
274    Otherwise, returns the next command name matching TEXT.
275    Returns a null pointer when no matches are left. */
276 static char *
277 command_generator (const char *text, int state)
278 {
279   static const struct command *cmd;
280   const char *name;
281
282   if (state == 0)
283     cmd = NULL;
284   name = cmd_complete (text, &cmd);
285   return name ? xstrdup (name) : NULL;
286 }
287 #else  /* !HAVE_READLINE */
288 static void
289 readline_init (void)
290 {
291 }
292
293 static void
294 readline_done (void)
295 {
296 }
297
298 static struct substring
299 readline_read (enum prompt_style style)
300 {
301   const char *prompt = readline_prompt (style);
302   struct string line;
303
304   fputs (prompt, stdout);
305   fflush (stdout);
306   ds_init_empty (&line);
307   ds_read_line (&line, stdin, SIZE_MAX);
308
309   return line.ss;
310 }
311 #endif /* !HAVE_READLINE */