]> git.ipfire.org Git - thirdparty/bash.git/blob - y.tab.c
projects / thirdparty / bash.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Imported from ../bash-2.03.tar.gz.
[thirdparty/bash.git] / y.tab.c
1
2 /* A Bison parser, made from /usr/homes/chet/src/bash/src/parse.y
3 by GNU Bison version 1.25
4 */
5
6 #define YYBISON 1 /* Identify Bison output. */
7
8 #define IF 258
9 #define THEN 259
10 #define ELSE 260
11 #define ELIF 261
12 #define FI 262
13 #define CASE 263
14 #define ESAC 264
15 #define FOR 265
16 #define SELECT 266
17 #define WHILE 267
18 #define UNTIL 268
19 #define DO 269
20 #define DONE 270
21 #define FUNCTION 271
22 #define COND_START 272
23 #define COND_END 273
24 #define COND_ERROR 274
25 #define IN 275
26 #define BANG 276
27 #define TIME 277
28 #define TIMEOPT 278
29 #define WORD 279
30 #define ASSIGNMENT_WORD 280
31 #define NUMBER 281
32 #define ARITH_CMD 282
33 #define COND_CMD 283
34 #define AND_AND 284
35 #define OR_OR 285
36 #define GREATER_GREATER 286
37 #define LESS_LESS 287
38 #define LESS_AND 288
39 #define GREATER_AND 289
40 #define SEMI_SEMI 290
41 #define LESS_LESS_MINUS 291
42 #define AND_GREATER 292
43 #define LESS_GREATER 293
44 #define GREATER_BAR 294
45 #define yacc_EOF 295
46
47 #line 21 "/usr/homes/chet/src/bash/src/parse.y"
48
49 #include "config.h"
50
51 #include "bashtypes.h"
52 #include "bashansi.h"
53
54 #if defined (HAVE_UNISTD_H)
55 # include <unistd.h>
56 #endif
57
58 #if defined (HAVE_LOCALE_H)
59 # include <locale.h>
60 #endif
61
62 #include <stdio.h>
63 #include <signal.h>
64
65 #include "memalloc.h"
66
67 #include "shell.h"
68 #include "trap.h"
69 #include "flags.h"
70 #include "parser.h"
71 #include "mailcheck.h"
72 #include "builtins/common.h"
73 #include "builtins/builtext.h"
74
75 #if defined (READLINE)
76 # include "bashline.h"
77 # include <readline/readline.h>
78 #endif /* READLINE */
79
80 #if defined (HISTORY)
81 # include "bashhist.h"
82 # include <readline/history.h>
83 #endif /* HISTORY */
84
85 #if defined (JOB_CONTROL)
86 # include "jobs.h"
87 #endif /* JOB_CONTROL */
88
89 #if defined (ALIAS)
90 # include "alias.h"
91 #endif /* ALIAS */
92
93 #if defined (PROMPT_STRING_DECODE)
94 # ifndef _MINIX
95 # include <sys/param.h>
96 # endif
97 # include <time.h>
98 # include "maxpath.h"
99 #endif /* PROMPT_STRING_DECODE */
100
101 #define RE_READ_TOKEN -99
102 #define NO_EXPANSION -100
103
104 #define YYDEBUG 0
105
106 #if defined (EXTENDED_GLOB)
107 #define PATTERN_CHAR(c) \
108 ((c) == '@' || (c) == '*' || (c) == '+' || (c) == '?' || (c) == '!')
109
110 extern int extended_glob;
111 #endif
112
113 extern int eof_encountered;
114 extern int no_line_editing, running_under_emacs;
115 extern int current_command_number;
116 extern int interactive, interactive_shell, login_shell;
117 extern int sourcelevel;
118 extern int posixly_correct;
119 extern int last_command_exit_value;
120 extern int interrupt_immediately;
121 extern char *shell_name, *current_host_name;
122 extern char *dist_version;
123 extern int patch_level;
124 extern int dump_translatable_strings, dump_po_strings;
125 extern Function *last_shell_builtin, *this_shell_builtin;
126 #if defined (BUFFERED_INPUT)
127 extern int bash_input_fd_changed;
128 #endif
129
130 /* **************************************************************** */
131 /* */
132 /* "Forward" declarations */
133 /* */
134 /* **************************************************************** */
135
136 static char *ansiexpand ();
137 static char *localeexpand ();
138 static int reserved_word_acceptable ();
139 static int read_token ();
140 static int yylex ();
141 static int parse_arith_cmd ();
142 #if defined (COND_COMMAND)
143 static COMMAND *parse_cond_command ();
144 #endif
145 static int read_token_word ();
146 static void discard_parser_constructs ();
147
148 static void report_syntax_error ();
149 static void handle_eof_input_unit ();
150 static void prompt_again ();
151 #if 0
152 static void reset_readline_prompt ();
153 #endif
154 static void print_prompt ();
155
156 extern int yyerror ();
157
158 /* Default prompt strings */
159 char *primary_prompt = PPROMPT;
160 char *secondary_prompt = SPROMPT;
161
162 /* PROMPT_STRING_POINTER points to one of these, never to an actual string. */
163 char *ps1_prompt, *ps2_prompt;
164
165 /* Handle on the current prompt string. Indirectly points through
166 ps1_ or ps2_prompt. */
167 char **prompt_string_pointer = (char **)NULL;
168 char *current_prompt_string;
169
170 /* Non-zero means we expand aliases in commands. */
171 int expand_aliases = 0;
172
173 /* If non-zero, the decoded prompt string undergoes parameter and
174 variable substitution, command substitution, arithmetic substitution,
175 string expansion, process substitution, and quote removal in
176 decode_prompt_string. */
177 int promptvars = 1;
178
179 /* The decoded prompt string. Used if READLINE is not defined or if
180 editing is turned off. Analogous to current_readline_prompt. */
181 static char *current_decoded_prompt;
182
183 /* The number of lines read from input while creating the current command. */
184 int current_command_line_count;
185
186 /* Variables to manage the task of reading here documents, because we need to
187 defer the reading until after a complete command has been collected. */
188 static REDIRECT *redir_stack[10];
189 int need_here_doc;
190
191 /* Where shell input comes from. History expansion is performed on each
192 line when the shell is interactive. */
193 static char *shell_input_line = (char *)NULL;
194 static int shell_input_line_index;
195 static int shell_input_line_size; /* Amount allocated for shell_input_line. */
196 static int shell_input_line_len; /* strlen (shell_input_line) */
197
198 /* Either zero or EOF. */
199 static int shell_input_line_terminator;
200
201 /* The line number in a script on which a function definition starts. */
202 static int function_dstart;
203
204 /* The line number in a script on which a function body starts. */
205 static int function_bstart;
206
207 static REDIRECTEE redir;
208
209 #line 183 "/usr/homes/chet/src/bash/src/parse.y"
210 typedef union {
211 WORD_DESC *word; /* the word that we read. */
212 int number; /* the number that we read. */
213 WORD_LIST *word_list;
214 COMMAND *command;
215 REDIRECT *redirect;
216 ELEMENT element;
217 PATTERN_LIST *pattern;
218 } YYSTYPE;
219 #include <stdio.h>
220
221 #ifndef __cplusplus
222 #ifndef __STDC__
223 #define const
224 #endif
225 #endif
226
227
228
229 #define YYFINAL 269
230 #define YYFLAG -32768
231 #define YYNTBASE 52
232
233 #define YYTRANSLATE(x) ((unsigned)(x) <= 295 ? yytranslate[x] : 85)
234
235 static const char yytranslate[] = { 0,
236 2, 2, 2, 2, 2, 2, 2, 2, 2, 42,
237 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
238 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
239 2, 2, 2, 2, 2, 2, 2, 40, 2, 50,
240 51, 2, 2, 2, 47, 2, 2, 2, 2, 2,
241 2, 2, 2, 2, 2, 2, 2, 2, 41, 46,
242 2, 45, 2, 2, 2, 2, 2, 2, 2, 2,
243 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
244 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
245 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
246 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
247 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
248 2, 2, 48, 44, 49, 2, 2, 2, 2, 2,
249 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
250 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
251 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
252 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
253 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
254 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
255 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
256 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
257 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
258 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
259 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
260 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
261 2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
262 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
263 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
264 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
265 36, 37, 38, 39, 43
266 };
267
268 #if YYDEBUG != 0
269 static const short yyprhs[] = { 0,
270 0, 3, 5, 8, 10, 12, 15, 18, 21, 25,
271 29, 32, 36, 39, 43, 46, 50, 53, 57, 60,
272 64, 67, 71, 74, 78, 81, 85, 88, 92, 95,
273 99, 102, 105, 109, 111, 113, 115, 117, 120, 122,
274 125, 127, 129, 132, 134, 136, 142, 148, 150, 152,
275 154, 156, 158, 160, 162, 169, 176, 184, 192, 203,
276 214, 221, 228, 236, 244, 255, 266, 273, 281, 288,
277 294, 301, 306, 310, 316, 324, 331, 335, 337, 341,
278 346, 353, 359, 361, 364, 369, 374, 380, 386, 389,
279 393, 395, 399, 402, 404, 407, 411, 415, 419, 424,
280 429, 434, 439, 444, 446, 448, 450, 452, 453, 456,
281 458, 461, 464, 469, 474, 478, 482, 484, 486, 489,
282 492, 496, 500, 505, 507, 509
283 };
284
285 static const short yyrhs[] = { 80,
286 42, 0, 42, 0, 1, 42, 0, 43, 0, 24,
287 0, 53, 24, 0, 45, 24, 0, 46, 24, 0,
288 26, 45, 24, 0, 26, 46, 24, 0, 31, 24,
289 0, 26, 31, 24, 0, 32, 24, 0, 26, 32,
290 24, 0, 33, 26, 0, 26, 33, 26, 0, 34,
291 26, 0, 26, 34, 26, 0, 33, 24, 0, 26,
292 33, 24, 0, 34, 24, 0, 26, 34, 24, 0,
293 36, 24, 0, 26, 36, 24, 0, 34, 47, 0,
294 26, 34, 47, 0, 33, 47, 0, 26, 33, 47,
295 0, 37, 24, 0, 26, 38, 24, 0, 38, 24,
296 0, 39, 24, 0, 26, 39, 24, 0, 24, 0,
297 25, 0, 54, 0, 54, 0, 56, 54, 0, 55,
298 0, 57, 55, 0, 57, 0, 59, 0, 59, 56,
299 0, 60, 0, 62, 0, 12, 75, 14, 75, 15,
300 0, 13, 75, 14, 75, 15, 0, 61, 0, 65,
301 0, 64, 0, 66, 0, 67, 0, 68, 0, 63,
302 0, 10, 24, 79, 14, 75, 15, 0, 10, 24,
303 79, 48, 75, 49, 0, 10, 24, 41, 79, 14,
304 75, 15, 0, 10, 24, 41, 79, 48, 75, 49,
305 0, 10, 24, 79, 20, 53, 78, 79, 14, 75,
306 15, 0, 10, 24, 79, 20, 53, 78, 79, 48,
307 75, 49, 0, 11, 24, 79, 14, 74, 15, 0,
308 11, 24, 79, 48, 74, 49, 0, 11, 24, 41,
309 79, 14, 74, 15, 0, 11, 24, 41, 79, 48,
310 74, 49, 0, 11, 24, 79, 20, 53, 78, 79,
311 14, 74, 15, 0, 11, 24, 79, 20, 53, 78,
312 79, 48, 74, 49, 0, 8, 24, 79, 20, 79,
313 9, 0, 8, 24, 79, 20, 72, 79, 9, 0,
314 8, 24, 79, 20, 70, 9, 0, 24, 50, 51,
315 79, 66, 0, 16, 24, 50, 51, 79, 66, 0,
316 16, 24, 79, 66, 0, 50, 75, 51, 0, 3,
317 75, 4, 75, 7, 0, 3, 75, 4, 75, 5,
318 75, 7, 0, 3, 75, 4, 75, 69, 7, 0,
319 48, 74, 49, 0, 27, 0, 17, 28, 18, 0,
320 6, 75, 4, 75, 0, 6, 75, 4, 75, 5,
321 75, 0, 6, 75, 4, 75, 69, 0, 71, 0,
322 72, 71, 0, 79, 73, 51, 75, 0, 79, 73,
323 51, 79, 0, 79, 50, 73, 51, 75, 0, 79,
324 50, 73, 51, 79, 0, 71, 35, 0, 72, 71,
325 35, 0, 24, 0, 73, 44, 24, 0, 79, 76,
326 0, 74, 0, 79, 77, 0, 77, 42, 79, 0,
327 77, 40, 79, 0, 77, 41, 79, 0, 77, 29,
328 79, 77, 0, 77, 30, 79, 77, 0, 77, 40,
329 79, 77, 0, 77, 41, 79, 77, 0, 77, 42,
330 79, 77, 0, 82, 0, 42, 0, 41, 0, 43,
331 0, 0, 79, 42, 0, 81, 0, 81, 40, 0,
332 81, 41, 0, 81, 29, 79, 81, 0, 81, 30,
333 79, 81, 0, 81, 40, 81, 0, 81, 41, 81,
334 0, 82, 0, 83, 0, 21, 83, 0, 84, 83,
335 0, 84, 21, 83, 0, 21, 84, 83, 0, 83,
336 44, 79, 83, 0, 58, 0, 22, 0, 22, 23,
337 0
338 };
339
340 #endif
341
342 #if YYDEBUG != 0
343 static const short yyrline[] = { 0,
344 232, 241, 248, 263, 273, 275, 279, 284, 289, 294,
345 299, 304, 309, 315, 321, 326, 331, 336, 341, 346,
346 351, 356, 361, 368, 375, 380, 385, 390, 395, 400,
347 405, 410, 415, 422, 424, 426, 430, 434, 445, 447,
348 451, 453, 455, 484, 486, 488, 490, 492, 494, 496,
349 498, 500, 502, 504, 508, 510, 512, 514, 516, 518,
350 522, 526, 530, 534, 538, 542, 548, 550, 552, 556,
351 560, 563, 567, 571, 573, 575, 580, 584, 588, 592,
352 594, 596, 600, 601, 605, 607, 609, 611, 615, 616,
353 620, 622, 631, 639, 640, 646, 647, 654, 658, 660,
354 662, 669, 671, 673, 677, 678, 679, 682, 683, 692,
355 698, 707, 715, 717, 719, 726, 729, 733, 735, 740,
356 745, 750, 757, 760, 764, 766
357 };
358 #endif
359
360
361 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
362
363 static const char * const yytname[] = { "$","error","$undefined.","IF","THEN",
364 "ELSE","ELIF","FI","CASE","ESAC","FOR","SELECT","WHILE","UNTIL","DO","DONE",
365 "FUNCTION","COND_START","COND_END","COND_ERROR","IN","BANG","TIME","TIMEOPT",
366 "WORD","ASSIGNMENT_WORD","NUMBER","ARITH_CMD","COND_CMD","AND_AND","OR_OR","GREATER_GREATER",
367 "LESS_LESS","LESS_AND","GREATER_AND","SEMI_SEMI","LESS_LESS_MINUS","AND_GREATER",
368 "LESS_GREATER","GREATER_BAR","'&'","';'","'\\n'","yacc_EOF","'|'","'>'","'<'",
369 "'-'","'{'","'}'","'('","')'","inputunit","word_list","redirection","simple_command_element",
370 "redirection_list","simple_command","command","shell_command","for_command",
371 "select_command","case_command","function_def","subshell","if_command","group_command",
372 "arith_command","cond_command","elif_clause","case_clause","pattern_list","case_clause_sequence",
373 "pattern","list","compound_list","list0","list1","list_terminator","newline_list",
374 "simple_list","simple_list1","pipeline_command","pipeline","timespec", NULL
375 };
376 #endif
377
378 static const short yyr1[] = { 0,
379 52, 52, 52, 52, 53, 53, 54, 54, 54, 54,
380 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
381 54, 54, 54, 54, 54, 54, 54, 54, 54, 54,
382 54, 54, 54, 55, 55, 55, 56, 56, 57, 57,
383 58, 58, 58, 59, 59, 59, 59, 59, 59, 59,
384 59, 59, 59, 59, 60, 60, 60, 60, 60, 60,
385 61, 61, 61, 61, 61, 61, 62, 62, 62, 63,
386 63, 63, 64, 65, 65, 65, 66, 67, 68, 69,
387 69, 69, 70, 70, 71, 71, 71, 71, 72, 72,
388 73, 73, 74, 75, 75, 76, 76, 76, 77, 77,
389 77, 77, 77, 77, 78, 78, 78, 79, 79, 80,
390 80, 80, 81, 81, 81, 81, 81, 82, 82, 82,
391 82, 82, 83, 83, 84, 84
392 };
393
394 static const short yyr2[] = { 0,
395 2, 1, 2, 1, 1, 2, 2, 2, 3, 3,
396 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
397 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
398 2, 2, 3, 1, 1, 1, 1, 2, 1, 2,
399 1, 1, 2, 1, 1, 5, 5, 1, 1, 1,
400 1, 1, 1, 1, 6, 6, 7, 7, 10, 10,
401 6, 6, 7, 7, 10, 10, 6, 7, 6, 5,
402 6, 4, 3, 5, 7, 6, 3, 1, 3, 4,
403 6, 5, 1, 2, 4, 4, 5, 5, 2, 3,
404 1, 3, 2, 1, 2, 3, 3, 3, 4, 4,
405 4, 4, 4, 1, 1, 1, 1, 0, 2, 1,
406 2, 2, 4, 4, 3, 3, 1, 1, 2, 2,
407 3, 3, 4, 1, 1, 2
408 };
409
410 static const short yydefact[] = { 0,
411 0, 108, 0, 0, 0, 108, 108, 0, 0, 0,
412 125, 34, 35, 0, 78, 0, 0, 0, 0, 0,
413 0, 0, 0, 2, 4, 0, 0, 108, 108, 36,
414 39, 41, 124, 42, 44, 48, 45, 54, 50, 49,
415 51, 52, 53, 0, 110, 117, 118, 0, 3, 94,
416 0, 0, 108, 108, 108, 0, 0, 108, 0, 119,
417 0, 126, 0, 0, 0, 0, 0, 0, 0, 0,
418 0, 0, 11, 13, 19, 15, 27, 21, 17, 25,
419 23, 29, 31, 32, 7, 8, 0, 0, 0, 34,
420 40, 37, 43, 1, 108, 108, 111, 112, 108, 0,
421 120, 108, 109, 93, 95, 104, 0, 108, 0, 108,
422 0, 108, 108, 0, 0, 79, 122, 108, 12, 14,
423 20, 16, 28, 22, 18, 26, 24, 30, 33, 9,
424 10, 77, 0, 73, 38, 0, 0, 115, 116, 0,
425 121, 0, 108, 108, 108, 108, 108, 108, 0, 108,
426 0, 108, 0, 108, 0, 108, 0, 0, 108, 72,
427 0, 113, 114, 0, 0, 123, 108, 108, 74, 0,
428 0, 0, 97, 98, 96, 0, 83, 108, 0, 108,
429 108, 0, 5, 0, 0, 108, 108, 0, 0, 0,
430 46, 47, 0, 70, 0, 0, 76, 99, 100, 101,
431 102, 103, 69, 89, 84, 0, 67, 91, 0, 0,
432 0, 0, 55, 6, 106, 105, 107, 108, 56, 0,
433 0, 61, 108, 62, 71, 75, 108, 108, 108, 108,
434 90, 68, 0, 0, 108, 57, 58, 0, 63, 64,
435 0, 80, 0, 0, 0, 108, 92, 85, 86, 108,
436 108, 108, 108, 108, 82, 87, 88, 0, 0, 0,
437 0, 81, 59, 60, 65, 66, 0, 0, 0
438 };
439
440 static const short yydefgoto[] = { 267,
441 184, 30, 31, 93, 32, 33, 34, 35, 36, 37,
442 38, 39, 40, 41, 42, 43, 170, 176, 177, 178,
443 210, 50, 51, 104, 105, 218, 52, 44, 138, 106,
444 47, 48
445 };
446
447 static const short yypact[] = { 246,
448 -34,-32768, 11, 20, 24,-32768,-32768, 33, -10, 369,
449 29, 19,-32768, 529,-32768, 42, 47, 30, 36, 64,
450 66, 78, 81,-32768,-32768, 84, 92,-32768,-32768,-32768,
451 -32768, 155,-32768, 513,-32768,-32768,-32768,-32768,-32768,-32768,
452 -32768,-32768,-32768, 89, -15,-32768, 77, 410,-32768,-32768,
453 130, 287,-32768, 95, 99, 127, 131, 97, 132, 77,
454 492,-32768, 100, 128, 129, 44, 56, 134, 135, 136,
455 139, 140,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
456 -32768,-32768,-32768,-32768,-32768,-32768, 105, 287, 104,-32768,
457 -32768,-32768, 513,-32768,-32768,-32768, 328, 328,-32768, 492,
458 77,-32768,-32768,-32768, 88,-32768, 1,-32768, -1,-32768,
459 16,-32768,-32768, 116, -32,-32768, 77,-32768,-32768,-32768,
460 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
461 -32768,-32768, 88,-32768,-32768, 287, 287, 69, 69, 451,
462 77, 79,-32768,-32768,-32768,-32768,-32768,-32768, 3,-32768,
463 144,-32768, 13,-32768, 144,-32768, 141, 157,-32768,-32768,
464 -32,-32768,-32768, 328, 328, 77,-32768,-32768,-32768, 166,
465 287, 287, 287, 287, 287, 169, 147,-32768, -4,-32768,
466 -32768, 175,-32768, 52, 146,-32768,-32768, 181, 52, 149,
467 -32768,-32768, -32,-32768, 192, 199,-32768,-32768,-32768, 71,
468 71, 71,-32768,-32768, 170, 0,-32768,-32768, 180, -22,
469 191, 161,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 196,
470 163,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
471 -32768,-32768, 28, 189,-32768,-32768,-32768, 17,-32768,-32768,
472 25, 114, 287, 287, 287,-32768,-32768,-32768, 287,-32768,
473 -32768,-32768,-32768,-32768,-32768,-32768, 287, 200, 167, 202,
474 171,-32768,-32768,-32768,-32768,-32768, 218, 219,-32768
475 };
476
477 static const short yypgoto[] = {-32768,
478 67, -30, 194,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
479 -32768,-32768,-32768, -112,-32768,-32768, -19,-32768, 46,-32768,
480 18, -17, -6,-32768, -60, 39, -21,-32768, 6, 12,
481 -8, 220
482 };
483
484
485 #define YYLAST 575
486
487
488 static const short yytable[] = { 56,
489 57, 60, 160, 92, 207, 45, 88, 49, 232, 103,
490 87, 46, 150, 95, 96, 28, 180, 59, 151, 208,
491 148, 234, 89, 208, 97, 98, 186, 133, 235, 154,
492 250, 107, 109, 111, 53, 155, 115, 103, 252, 101,
493 103, 103, 103, 54, 103, 209, 152, 55, 194, 209,
494 181, 62, 117, 75, 103, 76, 58, 103, 103, 78,
495 187, 79, 135, 156, 251, 73, 103, 121, 63, 122,
496 74, 234, 253, 136, 137, 214, 77, 140, 246, 124,
497 225, 125, 80, 167, 168, 169, 149, 81, 153, 82,
498 123, 141, 215, 216, 217, 142, 161, 95, 96, 143,
499 144, 83, 126, 139, 84, 157, 158, 85, 46, 46,
500 198, 199, 200, 201, 202, 86, 143, 144, 254, 168,
501 99, 171, 172, 173, 174, 175, 179, 145, 146, 147,
502 94, 166, 88, 102, 88, 108, 188, 193, 190, 110,
503 112, 162, 163, 182, 113, 185, 114, 46, 46, 116,
504 118, 119, 120, 132, 134, 191, 206, 127, 128, 129,
505 195, 196, 130, 131, 88, 88, 159, 183, 220, 221,
506 139, 192, 197, 211, 212, 46, 46, 203, 90, 13,
507 14, 204, 200, 201, 202, 16, 17, 18, 19, 213,
508 20, 21, 22, 23, 219, 222, 238, 224, 226, 26,
509 27, 241, 227, 208, 231, 236, 243, 244, 245, 237,
510 239, 240, 247, 249, 263, 264, 265, 268, 269, 266,
511 242, 189, 255, 205, 257, 91, 233, 223, 248, 61,
512 88, 88, 0, 0, 260, 261, 0, 0, 0, 256,
513 0, 0, 0, 258, 259, 0, 1, 262, 2, 0,
514 0, 0, 0, 3, 0, 4, 5, 6, 7, 0,
515 0, 8, 9, 0, 0, 0, 10, 11, 0, 12,
516 13, 14, 15, 0, 0, 0, 16, 17, 18, 19,
517 0, 20, 21, 22, 23, 0, 0, 24, 25, 2,
518 26, 27, 0, 28, 3, 29, 4, 5, 6, 7,
519 0, 0, 8, 9, 0, 0, 0, 10, 11, 0,
520 12, 13, 14, 15, 0, 0, 0, 16, 17, 18,
521 19, 0, 20, 21, 22, 23, 0, 0, 103, 0,
522 2, 26, 27, 0, 28, 3, 29, 4, 5, 6,
523 7, 0, 0, 8, 9, 0, 0, 0, 10, 11,
524 0, 12, 13, 14, 15, 0, 0, 0, 16, 17,
525 18, 19, 0, 20, 21, 22, 23, 0, 0, 0,
526 0, 2, 26, 27, 0, 28, 3, 29, 4, 5,
527 6, 7, 0, 0, 8, 9, 0, 0, 0, 0,
528 11, 0, 12, 13, 14, 15, 0, 0, 0, 16,
529 17, 18, 19, 0, 20, 21, 22, 23, 0, 0,
530 0, 0, 2, 26, 27, 0, 28, 3, 29, 4,
531 5, 6, 7, 0, 0, 8, 9, 0, 0, 0,
532 100, 0, 0, 12, 13, 14, 15, 0, 0, 0,
533 16, 17, 18, 19, 0, 20, 21, 22, 23, 0,
534 0, 0, 0, 2, 26, 27, 0, 28, 3, 29,
535 4, 5, 6, 7, 0, 0, 8, 9, 0, 0,
536 0, 0, 0, 0, 12, 13, 14, 15, 0, 0,
537 0, 16, 17, 18, 19, 0, 20, 21, 22, 23,
538 0, 0, 103, 0, 2, 26, 27, 0, 28, 3,
539 29, 4, 5, 6, 7, 0, 0, 8, 9, 0,
540 0, 0, 0, 0, 0, 12, 13, 14, 15, 0,
541 0, 0, 16, 17, 18, 19, 0, 20, 21, 22,
542 23, 0, 0, 0, 0, 0, 26, 27, 14, 28,
543 0, 29, 0, 16, 17, 18, 19, 0, 20, 21,
544 22, 23, 0, 0, 0, 0, 0, 26, 27, 64,
545 65, 66, 67, 0, 68, 0, 69, 70, 0, 0,
546 0, 0, 0, 71, 72
547 };
548
549 static const short yycheck[] = { 6,
550 7, 10, 115, 34, 9, 0, 28, 42, 9, 42,
551 28, 0, 14, 29, 30, 48, 14, 28, 20, 24,
552 20, 44, 29, 24, 40, 41, 14, 88, 51, 14,
553 14, 53, 54, 55, 24, 20, 58, 42, 14, 48,
554 42, 42, 42, 24, 42, 50, 48, 24, 161, 50,
555 48, 23, 61, 24, 42, 26, 24, 42, 42, 24,
556 48, 26, 93, 48, 48, 24, 42, 24, 50, 26,
557 24, 44, 48, 95, 96, 24, 47, 99, 51, 24,
558 193, 26, 47, 5, 6, 7, 108, 24, 110, 24,
559 47, 100, 41, 42, 43, 102, 118, 29, 30, 29,
560 30, 24, 47, 98, 24, 112, 113, 24, 97, 98,
561 171, 172, 173, 174, 175, 24, 29, 30, 5, 6,
562 44, 143, 144, 145, 146, 147, 148, 40, 41, 42,
563 42, 140, 154, 4, 156, 41, 154, 159, 156, 41,
564 14, 136, 137, 150, 14, 152, 50, 136, 137, 18,
565 51, 24, 24, 49, 51, 15, 178, 24, 24, 24,
566 167, 168, 24, 24, 186, 187, 51, 24, 186, 187,
567 165, 15, 7, 180, 181, 164, 165, 9, 24, 25,
568 26, 35, 243, 244, 245, 31, 32, 33, 34, 15,
569 36, 37, 38, 39, 49, 15, 218, 49, 7, 45,
570 46, 223, 4, 24, 35, 15, 228, 229, 230, 49,
571 15, 49, 24, 235, 15, 49, 15, 0, 0, 49,
572 227, 155, 242, 178, 246, 32, 209, 189, 235, 10,
573 252, 253, -1, -1, 252, 253, -1, -1, -1, 246,
574 -1, -1, -1, 250, 251, -1, 1, 254, 3, -1,
575 -1, -1, -1, 8, -1, 10, 11, 12, 13, -1,
576 -1, 16, 17, -1, -1, -1, 21, 22, -1, 24,
577 25, 26, 27, -1, -1, -1, 31, 32, 33, 34,
578 -1, 36, 37, 38, 39, -1, -1, 42, 43, 3,
579 45, 46, -1, 48, 8, 50, 10, 11, 12, 13,
580 -1, -1, 16, 17, -1, -1, -1, 21, 22, -1,
581 24, 25, 26, 27, -1, -1, -1, 31, 32, 33,
582 34, -1, 36, 37, 38, 39, -1, -1, 42, -1,
583 3, 45, 46, -1, 48, 8, 50, 10, 11, 12,
584 13, -1, -1, 16, 17, -1, -1, -1, 21, 22,
585 -1, 24, 25, 26, 27, -1, -1, -1, 31, 32,
586 33, 34, -1, 36, 37, 38, 39, -1, -1, -1,
587 -1, 3, 45, 46, -1, 48, 8, 50, 10, 11,
588 12, 13, -1, -1, 16, 17, -1, -1, -1, -1,
589 22, -1, 24, 25, 26, 27, -1, -1, -1, 31,
590 32, 33, 34, -1, 36, 37, 38, 39, -1, -1,
591 -1, -1, 3, 45, 46, -1, 48, 8, 50, 10,
592 11, 12, 13, -1, -1, 16, 17, -1, -1, -1,
593 21, -1, -1, 24, 25, 26, 27, -1, -1, -1,
594 31, 32, 33, 34, -1, 36, 37, 38, 39, -1,
595 -1, -1, -1, 3, 45, 46, -1, 48, 8, 50,
596 10, 11, 12, 13, -1, -1, 16, 17, -1, -1,
597 -1, -1, -1, -1, 24, 25, 26, 27, -1, -1,
598 -1, 31, 32, 33, 34, -1, 36, 37, 38, 39,
599 -1, -1, 42, -1, 3, 45, 46, -1, 48, 8,
600 50, 10, 11, 12, 13, -1, -1, 16, 17, -1,
601 -1, -1, -1, -1, -1, 24, 25, 26, 27, -1,
602 -1, -1, 31, 32, 33, 34, -1, 36, 37, 38,
603 39, -1, -1, -1, -1, -1, 45, 46, 26, 48,
604 -1, 50, -1, 31, 32, 33, 34, -1, 36, 37,
605 38, 39, -1, -1, -1, -1, -1, 45, 46, 31,
606 32, 33, 34, -1, 36, -1, 38, 39, -1, -1,
607 -1, -1, -1, 45, 46
608 };
609 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
610 #line 3 "/usr/share/misc/bison.simple"
611
612 /* Skeleton output parser for bison,
613 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
614
615 This program is free software; you can redistribute it and/or modify
616 it under the terms of the GNU General Public License as published by
617 the Free Software Foundation; either version 2, or (at your option)
618 any later version.
619
620 This program is distributed in the hope that it will be useful,
621 but WITHOUT ANY WARRANTY; without even the implied warranty of
622 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
623 GNU General Public License for more details.
624
625 You should have received a copy of the GNU General Public License
626 along with this program; if not, write to the Free Software
627 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
628
629 /* As a special exception, when this file is copied by Bison into a
630 Bison output file, you may use that output file without restriction.
631 This special exception was added by the Free Software Foundation
632 in version 1.24 of Bison. */
633
634 #ifndef alloca
635 #ifdef __GNUC__
636 #define alloca __builtin_alloca
637 #else /* not GNU C. */
638 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
639 #include <alloca.h>
640 #else /* not sparc */
641 #if defined (MSDOS) && !defined (__TURBOC__)
642 #include <malloc.h>
643 #else /* not MSDOS, or __TURBOC__ */
644 #if defined(_AIX)
645 #include <malloc.h>
646 #pragma alloca
647 #else /* not MSDOS, __TURBOC__, or _AIX */
648 #ifdef __hpux
649 #ifdef __cplusplus
650 extern "C" {
651 void *alloca (unsigned int);
652 };
653 #else /* not __cplusplus */
654 void *alloca ();
655 #endif /* not __cplusplus */
656 #endif /* __hpux */
657 #endif /* not _AIX */
658 #endif /* not MSDOS, or __TURBOC__ */
659 #endif /* not sparc. */
660 #endif /* not GNU C. */
661 #endif /* alloca not defined. */
662
663 /* This is the parser code that is written into each bison parser
664 when the %semantic_parser declaration is not specified in the grammar.
665 It was written by Richard Stallman by simplifying the hairy parser
666 used when %semantic_parser is specified. */
667
668 /* Note: there must be only one dollar sign in this file.
669 It is replaced by the list of actions, each action
670 as one case of the switch. */
671
672 #define yyerrok (yyerrstatus = 0)
673 #define yyclearin (yychar = YYEMPTY)
674 #define YYEMPTY -2
675 #define YYEOF 0
676 #define YYACCEPT return(0)
677 #define YYABORT return(1)
678 #define YYERROR goto yyerrlab1
679 /* Like YYERROR except do call yyerror.
680 This remains here temporarily to ease the
681 transition to the new meaning of YYERROR, for GCC.
682 Once GCC version 2 has supplanted version 1, this can go. */
683 #define YYFAIL goto yyerrlab
684 #define YYRECOVERING() (!!yyerrstatus)
685 #define YYBACKUP(token, value) \
686 do \
687 if (yychar == YYEMPTY && yylen == 1) \
688 { yychar = (token), yylval = (value); \
689 yychar1 = YYTRANSLATE (yychar); \
690 YYPOPSTACK; \
691 goto yybackup; \
692 } \
693 else \
694 { yyerror ("syntax error: cannot back up"); YYERROR; } \
695 while (0)
696
697 #define YYTERROR 1
698 #define YYERRCODE 256
699
700 #ifndef YYPURE
701 #define YYLEX yylex()
702 #endif
703
704 #ifdef YYPURE
705 #ifdef YYLSP_NEEDED
706 #ifdef YYLEX_PARAM
707 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
708 #else
709 #define YYLEX yylex(&yylval, &yylloc)
710 #endif
711 #else /* not YYLSP_NEEDED */
712 #ifdef YYLEX_PARAM
713 #define YYLEX yylex(&yylval, YYLEX_PARAM)
714 #else
715 #define YYLEX yylex(&yylval)
716 #endif
717 #endif /* not YYLSP_NEEDED */
718 #endif
719
720 /* If nonreentrant, generate the variables here */
721
722 #ifndef YYPURE
723
724 int yychar; /* the lookahead symbol */
725 YYSTYPE yylval; /* the semantic value of the */
726 /* lookahead symbol */
727
728 #ifdef YYLSP_NEEDED
729 YYLTYPE yylloc; /* location data for the lookahead */
730 /* symbol */
731 #endif
732
733 int yynerrs; /* number of parse errors so far */
734 #endif /* not YYPURE */
735
736 #if YYDEBUG != 0
737 int yydebug; /* nonzero means print parse trace */
738 /* Since this is uninitialized, it does not stop multiple parsers
739 from coexisting. */
740 #endif
741
742 /* YYINITDEPTH indicates the initial size of the parser's stacks */
743
744 #ifndef YYINITDEPTH
745 #define YYINITDEPTH 200
746 #endif
747
748 /* YYMAXDEPTH is the maximum size the stacks can grow to
749 (effective only if the built-in stack extension method is used). */
750
751 #if YYMAXDEPTH == 0
752 #undef YYMAXDEPTH
753 #endif
754
755 #ifndef YYMAXDEPTH
756 #define YYMAXDEPTH 10000
757 #endif
758
759 /* Prevent warning if -Wstrict-prototypes. */
760 #ifdef __GNUC__
761 int yyparse (void);
762 #endif
763 \f
764 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
765 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
766 #else /* not GNU C or C++ */
767 #ifndef __cplusplus
768
769 /* This is the most reliable way to avoid incompatibilities
770 in available built-in functions on various systems. */
771 static void
772 __yy_memcpy (to, from, count)
773 char *to;
774 char *from;
775 int count;
776 {
777 register char *f = from;
778 register char *t = to;
779 register int i = count;
780
781 while (i-- > 0)
782 *t++ = *f++;
783 }
784
785 #else /* __cplusplus */
786
787 /* This is the most reliable way to avoid incompatibilities
788 in available built-in functions on various systems. */
789 static void
790 __yy_memcpy (char *to, char *from, int count)
791 {
792 register char *f = from;
793 register char *t = to;
794 register int i = count;
795
796 while (i-- > 0)
797 *t++ = *f++;
798 }
799
800 #endif
801 #endif
802 \f
803 #line 196 "/usr/share/misc/bison.simple"
804
805 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
806 into yyparse. The argument should have type void *.
807 It should actually point to an object.
808 Grammar actions can access the variable by casting it
809 to the proper pointer type. */
810
811 #ifdef YYPARSE_PARAM
812 #ifdef __cplusplus
813 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
814 #define YYPARSE_PARAM_DECL
815 #else /* not __cplusplus */
816 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
817 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
818 #endif /* not __cplusplus */
819 #else /* not YYPARSE_PARAM */
820 #define YYPARSE_PARAM_ARG
821 #define YYPARSE_PARAM_DECL
822 #endif /* not YYPARSE_PARAM */
823
824 int
825 yyparse(YYPARSE_PARAM_ARG)
826 YYPARSE_PARAM_DECL
827 {
828 register int yystate;
829 register int yyn;
830 register short *yyssp;
831 register YYSTYPE *yyvsp;
832 int yyerrstatus; /* number of tokens to shift before error messages enabled */
833 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
834
835 short yyssa[YYINITDEPTH]; /* the state stack */
836 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
837
838 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
839 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
840
841 #ifdef YYLSP_NEEDED
842 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
843 YYLTYPE *yyls = yylsa;
844 YYLTYPE *yylsp;
845
846 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
847 #else
848 #define YYPOPSTACK (yyvsp--, yyssp--)
849 #endif
850
851 int yystacksize = YYINITDEPTH;
852
853 #ifdef YYPURE
854 int yychar;
855 YYSTYPE yylval;
856 int yynerrs;
857 #ifdef YYLSP_NEEDED
858 YYLTYPE yylloc;
859 #endif
860 #endif
861
862 YYSTYPE yyval; /* the variable used to return */
863 /* semantic values from the action */
864 /* routines */
865
866 int yylen;
867
868 #if YYDEBUG != 0
869 if (yydebug)
870 fprintf(stderr, "Starting parse\n");
871 #endif
872
873 yystate = 0;
874 yyerrstatus = 0;
875 yynerrs = 0;
876 yychar = YYEMPTY; /* Cause a token to be read. */
877
878 /* Initialize stack pointers.
879 Waste one element of value and location stack
880 so that they stay on the same level as the state stack.
881 The wasted elements are never initialized. */
882
883 yyssp = yyss - 1;
884 yyvsp = yyvs;
885 #ifdef YYLSP_NEEDED
886 yylsp = yyls;
887 #endif
888
889 /* Push a new state, which is found in yystate . */
890 /* In all cases, when you get here, the value and location stacks
891 have just been pushed. so pushing a state here evens the stacks. */
892 yynewstate:
893
894 *++yyssp = yystate;
895
896 if (yyssp >= yyss + yystacksize - 1)
897 {
898 /* Give user a chance to reallocate the stack */
899 /* Use copies of these so that the &'s don't force the real ones into memory. */
900 YYSTYPE *yyvs1 = yyvs;
901 short *yyss1 = yyss;
902 #ifdef YYLSP_NEEDED
903 YYLTYPE *yyls1 = yyls;
904 #endif
905
906 /* Get the current used size of the three stacks, in elements. */
907 int size = yyssp - yyss + 1;
908
909 #ifdef yyoverflow
910 /* Each stack pointer address is followed by the size of
911 the data in use in that stack, in bytes. */
912 #ifdef YYLSP_NEEDED
913 /* This used to be a conditional around just the two extra args,
914 but that might be undefined if yyoverflow is a macro. */
915 yyoverflow("parser stack overflow",
916 &yyss1, size * sizeof (*yyssp),
917 &yyvs1, size * sizeof (*yyvsp),
918 &yyls1, size * sizeof (*yylsp),
919 &yystacksize);
920 #else
921 yyoverflow("parser stack overflow",
922 &yyss1, size * sizeof (*yyssp),
923 &yyvs1, size * sizeof (*yyvsp),
924 &yystacksize);
925 #endif
926
927 yyss = yyss1; yyvs = yyvs1;
928 #ifdef YYLSP_NEEDED
929 yyls = yyls1;
930 #endif
931 #else /* no yyoverflow */
932 /* Extend the stack our own way. */
933 if (yystacksize >= YYMAXDEPTH)
934 {
935 yyerror("parser stack overflow");
936 return 2;
937 }
938 yystacksize *= 2;
939 if (yystacksize > YYMAXDEPTH)
940 yystacksize = YYMAXDEPTH;
941 yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
942 __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
943 yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
944 __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
945 #ifdef YYLSP_NEEDED
946 yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
947 __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
948 #endif
949 #endif /* no yyoverflow */
950
951 yyssp = yyss + size - 1;
952 yyvsp = yyvs + size - 1;
953 #ifdef YYLSP_NEEDED
954 yylsp = yyls + size - 1;
955 #endif
956
957 #if YYDEBUG != 0
958 if (yydebug)
959 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
960 #endif
961
962 if (yyssp >= yyss + yystacksize - 1)
963 YYABORT;
964 }
965
966 #if YYDEBUG != 0
967 if (yydebug)
968 fprintf(stderr, "Entering state %d\n", yystate);
969 #endif
970
971 goto yybackup;
972 yybackup:
973
974 /* Do appropriate processing given the current state. */
975 /* Read a lookahead token if we need one and don't already have one. */
976 /* yyresume: */
977
978 /* First try to decide what to do without reference to lookahead token. */
979
980 yyn = yypact[yystate];
981 if (yyn == YYFLAG)
982 goto yydefault;
983
984 /* Not known => get a lookahead token if don't already have one. */
985
986 /* yychar is either YYEMPTY or YYEOF
987 or a valid token in external form. */
988
989 if (yychar == YYEMPTY)
990 {
991 #if YYDEBUG != 0
992 if (yydebug)
993 fprintf(stderr, "Reading a token: ");
994 #endif
995 yychar = YYLEX;
996 }
997
998 /* Convert token to internal form (in yychar1) for indexing tables with */
999
1000 if (yychar <= 0) /* This means end of input. */
1001 {
1002 yychar1 = 0;
1003 yychar = YYEOF; /* Don't call YYLEX any more */
1004
1005 #if YYDEBUG != 0
1006 if (yydebug)
1007 fprintf(stderr, "Now at end of input.\n");
1008 #endif
1009 }
1010 else
1011 {
1012 yychar1 = YYTRANSLATE(yychar);
1013
1014 #if YYDEBUG != 0
1015 if (yydebug)
1016 {
1017 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
1018 /* Give the individual parser a way to print the precise meaning
1019 of a token, for further debugging info. */
1020 #ifdef YYPRINT
1021 YYPRINT (stderr, yychar, yylval);
1022 #endif
1023 fprintf (stderr, ")\n");
1024 }
1025 #endif
1026 }
1027
1028 yyn += yychar1;
1029 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
1030 goto yydefault;
1031
1032 yyn = yytable[yyn];
1033
1034 /* yyn is what to do for this token type in this state.
1035 Negative => reduce, -yyn is rule number.
1036 Positive => shift, yyn is new state.
1037 New state is final state => don't bother to shift,
1038 just return success.
1039 0, or most negative number => error. */
1040
1041 if (yyn < 0)
1042 {
1043 if (yyn == YYFLAG)
1044 goto yyerrlab;
1045 yyn = -yyn;
1046 goto yyreduce;
1047 }
1048 else if (yyn == 0)
1049 goto yyerrlab;
1050
1051 if (yyn == YYFINAL)
1052 YYACCEPT;
1053
1054 /* Shift the lookahead token. */
1055
1056 #if YYDEBUG != 0
1057 if (yydebug)
1058 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
1059 #endif
1060
1061 /* Discard the token being shifted unless it is eof. */
1062 if (yychar != YYEOF)
1063 yychar = YYEMPTY;
1064
1065 *++yyvsp = yylval;
1066 #ifdef YYLSP_NEEDED
1067 *++yylsp = yylloc;
1068 #endif
1069
1070 /* count tokens shifted since error; after three, turn off error status. */
1071 if (yyerrstatus) yyerrstatus--;
1072
1073 yystate = yyn;
1074 goto yynewstate;
1075
1076 /* Do the default action for the current state. */
1077 yydefault:
1078
1079 yyn = yydefact[yystate];
1080 if (yyn == 0)
1081 goto yyerrlab;
1082
1083 /* Do a reduction. yyn is the number of a rule to reduce with. */
1084 yyreduce:
1085 yylen = yyr2[yyn];
1086 if (yylen > 0)
1087 yyval = yyvsp[1-yylen]; /* implement default value of the action */
1088
1089 #if YYDEBUG != 0
1090 if (yydebug)
1091 {
1092 int i;
1093
1094 fprintf (stderr, "Reducing via rule %d (line %d), ",
1095 yyn, yyrline[yyn]);
1096
1097 /* Print the symbols being reduced, and their result. */
1098 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
1099 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
1100 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1101 }
1102 #endif
1103
1104
1105 switch (yyn) {
1106
1107 case 1:
1108 #line 233 "/usr/homes/chet/src/bash/src/parse.y"
1109 {
1110 /* Case of regular command. Discard the error
1111 safety net,and return the command just parsed. */
1112 global_command = yyvsp[-1].command;
1113 eof_encountered = 0;
1114 discard_parser_constructs (0);
1115 YYACCEPT;
1116 ;
1117 break;}
1118 case 2:
1119 #line 242 "/usr/homes/chet/src/bash/src/parse.y"
1120 {
1121 /* Case of regular command, but not a very
1122 interesting one. Return a NULL command. */
1123 global_command = (COMMAND *)NULL;
1124 YYACCEPT;
1125 ;
1126 break;}
1127 case 3:
1128 #line 249 "/usr/homes/chet/src/bash/src/parse.y"
1129 {
1130 /* Error during parsing. Return NULL command. */
1131 global_command = (COMMAND *)NULL;
1132 eof_encountered = 0;
1133 discard_parser_constructs (1);
1134 if (interactive)
1135 {
1136 YYACCEPT;
1137 }
1138 else
1139 {
1140 YYABORT;
1141 }
1142 ;
1143 break;}
1144 case 4:
1145 #line 264 "/usr/homes/chet/src/bash/src/parse.y"
1146 {
1147 /* Case of EOF seen by itself. Do ignoreeof or
1148 not. */
1149 global_command = (COMMAND *)NULL;
1150 handle_eof_input_unit ();
1151 YYACCEPT;
1152 ;
1153 break;}
1154 case 5:
1155 #line 274 "/usr/homes/chet/src/bash/src/parse.y"
1156 { yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); ;
1157 break;}
1158 case 6:
1159 #line 276 "/usr/homes/chet/src/bash/src/parse.y"
1160 { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-1].word_list); ;
1161 break;}
1162 case 7:
1163 #line 280 "/usr/homes/chet/src/bash/src/parse.y"
1164 {
1165 redir.filename = yyvsp[0].word;
1166 yyval.redirect = make_redirection (1, r_output_direction, redir);
1167 ;
1168 break;}
1169 case 8:
1170 #line 285 "/usr/homes/chet/src/bash/src/parse.y"
1171 {
1172 redir.filename = yyvsp[0].word;
1173 yyval.redirect = make_redirection (0, r_input_direction, redir);
1174 ;
1175 break;}
1176 case 9:
1177 #line 290 "/usr/homes/chet/src/bash/src/parse.y"
1178 {
1179 redir.filename = yyvsp[0].word;
1180 yyval.redirect = make_redirection (yyvsp[-2].number, r_output_direction, redir);
1181 ;
1182 break;}
1183 case 10:
1184 #line 295 "/usr/homes/chet/src/bash/src/parse.y"
1185 {
1186 redir.filename = yyvsp[0].word;
1187 yyval.redirect = make_redirection (yyvsp[-2].number, r_input_direction, redir);
1188 ;
1189 break;}
1190 case 11:
1191 #line 300 "/usr/homes/chet/src/bash/src/parse.y"
1192 {
1193 redir.filename = yyvsp[0].word;
1194 yyval.redirect = make_redirection (1, r_appending_to, redir);
1195 ;
1196 break;}
1197 case 12:
1198 #line 305 "/usr/homes/chet/src/bash/src/parse.y"
1199 {
1200 redir.filename = yyvsp[0].word;
1201 yyval.redirect = make_redirection (yyvsp[-2].number, r_appending_to, redir);
1202 ;
1203 break;}
1204 case 13:
1205 #line 310 "/usr/homes/chet/src/bash/src/parse.y"
1206 {
1207 redir.filename = yyvsp[0].word;
1208 yyval.redirect = make_redirection (0, r_reading_until, redir);
1209 redir_stack[need_here_doc++] = yyval.redirect;
1210 ;
1211 break;}
1212 case 14:
1213 #line 316 "/usr/homes/chet/src/bash/src/parse.y"
1214 {
1215 redir.filename = yyvsp[0].word;
1216 yyval.redirect = make_redirection (yyvsp[-2].number, r_reading_until, redir);
1217 redir_stack[need_here_doc++] = yyval.redirect;
1218 ;
1219 break;}
1220 case 15:
1221 #line 322 "/usr/homes/chet/src/bash/src/parse.y"
1222 {
1223 redir.dest = yyvsp[0].number;
1224 yyval.redirect = make_redirection (0, r_duplicating_input, redir);
1225 ;
1226 break;}
1227 case 16:
1228 #line 327 "/usr/homes/chet/src/bash/src/parse.y"
1229 {
1230 redir.dest = yyvsp[0].number;
1231 yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_input, redir);
1232 ;
1233 break;}
1234 case 17:
1235 #line 332 "/usr/homes/chet/src/bash/src/parse.y"
1236 {
1237 redir.dest = yyvsp[0].number;
1238 yyval.redirect = make_redirection (1, r_duplicating_output, redir);
1239 ;
1240 break;}
1241 case 18:
1242 #line 337 "/usr/homes/chet/src/bash/src/parse.y"
1243 {
1244 redir.dest = yyvsp[0].number;
1245 yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_output, redir);
1246 ;
1247 break;}
1248 case 19:
1249 #line 342 "/usr/homes/chet/src/bash/src/parse.y"
1250 {
1251 redir.filename = yyvsp[0].word;
1252 yyval.redirect = make_redirection (0, r_duplicating_input_word, redir);
1253 ;
1254 break;}
1255 case 20:
1256 #line 347 "/usr/homes/chet/src/bash/src/parse.y"
1257 {
1258 redir.filename = yyvsp[0].word;
1259 yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_input_word, redir);
1260 ;
1261 break;}
1262 case 21:
1263 #line 352 "/usr/homes/chet/src/bash/src/parse.y"
1264 {
1265 redir.filename = yyvsp[0].word;
1266 yyval.redirect = make_redirection (1, r_duplicating_output_word, redir);
1267 ;
1268 break;}
1269 case 22:
1270 #line 357 "/usr/homes/chet/src/bash/src/parse.y"
1271 {
1272 redir.filename = yyvsp[0].word;
1273 yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_output_word, redir);
1274 ;
1275 break;}
1276 case 23:
1277 #line 362 "/usr/homes/chet/src/bash/src/parse.y"
1278 {
1279 redir.filename = yyvsp[0].word;
1280 yyval.redirect = make_redirection
1281 (0, r_deblank_reading_until, redir);
1282 redir_stack[need_here_doc++] = yyval.redirect;
1283 ;
1284 break;}
1285 case 24:
1286 #line 369 "/usr/homes/chet/src/bash/src/parse.y"
1287 {
1288 redir.filename = yyvsp[0].word;
1289 yyval.redirect = make_redirection
1290 (yyvsp[-2].number, r_deblank_reading_until, redir);
1291 redir_stack[need_here_doc++] = yyval.redirect;
1292 ;
1293 break;}
1294 case 25:
1295 #line 376 "/usr/homes/chet/src/bash/src/parse.y"
1296 {
1297 redir.dest = 0L;
1298 yyval.redirect = make_redirection (1, r_close_this, redir);
1299 ;
1300 break;}
1301 case 26:
1302 #line 381 "/usr/homes/chet/src/bash/src/parse.y"
1303 {
1304 redir.dest = 0L;
1305 yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, redir);
1306 ;
1307 break;}
1308 case 27:
1309 #line 386 "/usr/homes/chet/src/bash/src/parse.y"
1310 {
1311 redir.dest = 0L;
1312 yyval.redirect = make_redirection (0, r_close_this, redir);
1313 ;
1314 break;}
1315 case 28:
1316 #line 391 "/usr/homes/chet/src/bash/src/parse.y"
1317 {
1318 redir.dest = 0L;
1319 yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, redir);
1320 ;
1321 break;}
1322 case 29:
1323 #line 396 "/usr/homes/chet/src/bash/src/parse.y"
1324 {
1325 redir.filename = yyvsp[0].word;
1326 yyval.redirect = make_redirection (1, r_err_and_out, redir);
1327 ;
1328 break;}
1329 case 30:
1330 #line 401 "/usr/homes/chet/src/bash/src/parse.y"
1331 {
1332 redir.filename = yyvsp[0].word;
1333 yyval.redirect = make_redirection (yyvsp[-2].number, r_input_output, redir);
1334 ;
1335 break;}
1336 case 31:
1337 #line 406 "/usr/homes/chet/src/bash/src/parse.y"
1338 {
1339 redir.filename = yyvsp[0].word;
1340 yyval.redirect = make_redirection (0, r_input_output, redir);
1341 ;
1342 break;}
1343 case 32:
1344 #line 411 "/usr/homes/chet/src/bash/src/parse.y"
1345 {
1346 redir.filename = yyvsp[0].word;
1347 yyval.redirect = make_redirection (1, r_output_force, redir);
1348 ;
1349 break;}
1350 case 33:
1351 #line 416 "/usr/homes/chet/src/bash/src/parse.y"
1352 {
1353 redir.filename = yyvsp[0].word;
1354 yyval.redirect = make_redirection (yyvsp[-2].number, r_output_force, redir);
1355 ;
1356 break;}
1357 case 34:
1358 #line 423 "/usr/homes/chet/src/bash/src/parse.y"
1359 { yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; ;
1360 break;}
1361 case 35:
1362 #line 425 "/usr/homes/chet/src/bash/src/parse.y"
1363 { yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; ;
1364 break;}
1365 case 36:
1366 #line 427 "/usr/homes/chet/src/bash/src/parse.y"
1367 { yyval.element.redirect = yyvsp[0].redirect; yyval.element.word = 0; ;
1368 break;}
1369 case 37:
1370 #line 431 "/usr/homes/chet/src/bash/src/parse.y"
1371 {
1372 yyval.redirect = yyvsp[0].redirect;
1373 ;
1374 break;}
1375 case 38:
1376 #line 435 "/usr/homes/chet/src/bash/src/parse.y"
1377 {
1378 register REDIRECT *t;
1379
1380 for (t = yyvsp[-1].redirect; t->next; t = t->next)
1381 ;
1382 t->next = yyvsp[0].redirect;
1383 yyval.redirect = yyvsp[-1].redirect;
1384 ;
1385 break;}
1386 case 39:
1387 #line 446 "/usr/homes/chet/src/bash/src/parse.y"
1388 { yyval.command = make_simple_command (yyvsp[0].element, (COMMAND *)NULL); ;
1389 break;}
1390 case 40:
1391 #line 448 "/usr/homes/chet/src/bash/src/parse.y"
1392 { yyval.command = make_simple_command (yyvsp[0].element, yyvsp[-1].command); ;
1393 break;}
1394 case 41:
1395 #line 452 "/usr/homes/chet/src/bash/src/parse.y"
1396 { yyval.command = clean_simple_command (yyvsp[0].command); ;
1397 break;}
1398 case 42:
1399 #line 454 "/usr/homes/chet/src/bash/src/parse.y"
1400 { yyval.command = yyvsp[0].command; ;
1401 break;}
1402 case 43:
1403 #line 456 "/usr/homes/chet/src/bash/src/parse.y"
1404 {
1405 COMMAND *tc;
1406
1407 tc = yyvsp[-1].command;
1408 /* According to Posix.2 3.9.5, redirections
1409 specified after the body of a function should
1410 be attached to the function and performed when
1411 the function is executed, not as part of the
1412 function definition command. */
1413 if (tc->type == cm_function_def)
1414 {
1415 tc = tc->value.Function_def->command;
1416 if (tc->type == cm_group)
1417 tc = tc->value.Group->command;
1418 }
1419 if (tc->redirects)
1420 {
1421 register REDIRECT *t;
1422 for (t = tc->redirects; t->next; t = t->next)
1423 ;
1424 t->next = yyvsp[0].redirect;
1425 }
1426 else
1427 tc->redirects = yyvsp[0].redirect;
1428 yyval.command = yyvsp[-1].command;
1429 ;
1430 break;}
1431 case 44:
1432 #line 485 "/usr/homes/chet/src/bash/src/parse.y"
1433 { yyval.command = yyvsp[0].command; ;
1434 break;}
1435 case 45:
1436 #line 487 "/usr/homes/chet/src/bash/src/parse.y"
1437 { yyval.command = yyvsp[0].command; ;
1438 break;}
1439 case 46:
1440 #line 489 "/usr/homes/chet/src/bash/src/parse.y"
1441 { yyval.command = make_while_command (yyvsp[-3].command, yyvsp[-1].command); ;
1442 break;}
1443 case 47:
1444 #line 491 "/usr/homes/chet/src/bash/src/parse.y"
1445 { yyval.command = make_until_command (yyvsp[-3].command, yyvsp[-1].command); ;
1446 break;}
1447 case 48:
1448 #line 493 "/usr/homes/chet/src/bash/src/parse.y"
1449 { yyval.command = yyvsp[0].command; ;
1450 break;}
1451 case 49:
1452 #line 495 "/usr/homes/chet/src/bash/src/parse.y"
1453 { yyval.command = yyvsp[0].command; ;
1454 break;}
1455 case 50:
1456 #line 497 "/usr/homes/chet/src/bash/src/parse.y"
1457 { yyval.command = yyvsp[0].command; ;
1458 break;}
1459 case 51:
1460 #line 499 "/usr/homes/chet/src/bash/src/parse.y"
1461 { yyval.command = yyvsp[0].command; ;
1462 break;}
1463 case 52:
1464 #line 501 "/usr/homes/chet/src/bash/src/parse.y"
1465 { yyval.command = yyvsp[0].command; ;
1466 break;}
1467 case 53:
1468 #line 503 "/usr/homes/chet/src/bash/src/parse.y"
1469 { yyval.command = yyvsp[0].command; ;
1470 break;}
1471 case 54:
1472 #line 505 "/usr/homes/chet/src/bash/src/parse.y"
1473 { yyval.command = yyvsp[0].command; ;
1474 break;}
1475 case 55:
1476 #line 509 "/usr/homes/chet/src/bash/src/parse.y"
1477 { yyval.command = make_for_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
1478 break;}
1479 case 56:
1480 #line 511 "/usr/homes/chet/src/bash/src/parse.y"
1481 { yyval.command = make_for_command (yyvsp[-4].word, add_string_to_list ("$@", (WORD_LIST *)NULL), yyvsp[-1].command); ;
1482 break;}
1483 case 57:
1484 #line 513 "/usr/homes/chet/src/bash/src/parse.y"
1485 { yyval.command = make_for_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
1486 break;}
1487 case 58:
1488 #line 515 "/usr/homes/chet/src/bash/src/parse.y"
1489 { yyval.command = make_for_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
1490 break;}
1491 case 59:
1492 #line 517 "/usr/homes/chet/src/bash/src/parse.y"
1493 { yyval.command = make_for_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command); ;
1494 break;}
1495 case 60:
1496 #line 519 "/usr/homes/chet/src/bash/src/parse.y"
1497 { yyval.command = make_for_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command); ;
1498 break;}
1499 case 61:
1500 #line 523 "/usr/homes/chet/src/bash/src/parse.y"
1501 {
1502 yyval.command = make_select_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command);
1503 ;
1504 break;}
1505 case 62:
1506 #line 527 "/usr/homes/chet/src/bash/src/parse.y"
1507 {
1508 yyval.command = make_select_command (yyvsp[-4].word, add_string_to_list ("$@", (WORD_LIST *)NULL), yyvsp[-1].command);
1509 ;
1510 break;}
1511 case 63:
1512 #line 531 "/usr/homes/chet/src/bash/src/parse.y"
1513 {
1514 yyval.command = make_select_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command);
1515 ;
1516 break;}
1517 case 64:
1518 #line 535 "/usr/homes/chet/src/bash/src/parse.y"
1519 {
1520 yyval.command = make_select_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command);
1521 ;
1522 break;}
1523 case 65:
1524 #line 539 "/usr/homes/chet/src/bash/src/parse.y"
1525 {
1526 yyval.command = make_select_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command);
1527 ;
1528 break;}
1529 case 66:
1530 #line 543 "/usr/homes/chet/src/bash/src/parse.y"
1531 {
1532 yyval.command = make_select_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command);
1533 ;
1534 break;}
1535 case 67:
1536 #line 549 "/usr/homes/chet/src/bash/src/parse.y"
1537 { yyval.command = make_case_command (yyvsp[-4].word, (PATTERN_LIST *)NULL); ;
1538 break;}
1539 case 68:
1540 #line 551 "/usr/homes/chet/src/bash/src/parse.y"
1541 { yyval.command = make_case_command (yyvsp[-5].word, yyvsp[-2].pattern); ;
1542 break;}
1543 case 69:
1544 #line 553 "/usr/homes/chet/src/bash/src/parse.y"
1545 { yyval.command = make_case_command (yyvsp[-4].word, yyvsp[-1].pattern); ;
1546 break;}
1547 case 70:
1548 #line 557 "/usr/homes/chet/src/bash/src/parse.y"
1549 { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command, function_dstart, function_bstart); ;
1550 break;}
1551 case 71:
1552 #line 561 "/usr/homes/chet/src/bash/src/parse.y"
1553 { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command, function_dstart, function_bstart); ;
1554 break;}
1555 case 72:
1556 #line 564 "/usr/homes/chet/src/bash/src/parse.y"
1557 { yyval.command = make_function_def (yyvsp[-2].word, yyvsp[0].command, function_dstart, function_bstart); ;
1558 break;}
1559 case 73:
1560 #line 568 "/usr/homes/chet/src/bash/src/parse.y"
1561 { yyvsp[-1].command->flags |= CMD_WANT_SUBSHELL; yyval.command = yyvsp[-1].command; ;
1562 break;}
1563 case 74:
1564 #line 572 "/usr/homes/chet/src/bash/src/parse.y"
1565 { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, (COMMAND *)NULL); ;
1566 break;}
1567 case 75:
1568 #line 574 "/usr/homes/chet/src/bash/src/parse.y"
1569 { yyval.command = make_if_command (yyvsp[-5].command, yyvsp[-3].command, yyvsp[-1].command); ;
1570 break;}
1571 case 76:
1572 #line 576 "/usr/homes/chet/src/bash/src/parse.y"
1573 { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[-1].command); ;
1574 break;}
1575 case 77:
1576 #line 581 "/usr/homes/chet/src/bash/src/parse.y"
1577 { yyval.command = make_group_command (yyvsp[-1].command); ;
1578 break;}
1579 case 78:
1580 #line 585 "/usr/homes/chet/src/bash/src/parse.y"
1581 { yyval.command = make_arith_command (yyvsp[0].word_list); ;
1582 break;}
1583 case 79:
1584 #line 589 "/usr/homes/chet/src/bash/src/parse.y"
1585 { yyval.command = yyvsp[-1].command; ;
1586 break;}
1587 case 80:
1588 #line 593 "/usr/homes/chet/src/bash/src/parse.y"
1589 { yyval.command = make_if_command (yyvsp[-2].command, yyvsp[0].command, (COMMAND *)NULL); ;
1590 break;}
1591 case 81:
1592 #line 595 "/usr/homes/chet/src/bash/src/parse.y"
1593 { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[0].command); ;
1594 break;}
1595 case 82:
1596 #line 597 "/usr/homes/chet/src/bash/src/parse.y"
1597 { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, yyvsp[0].command); ;
1598 break;}
1599 case 84:
1600 #line 602 "/usr/homes/chet/src/bash/src/parse.y"
1601 { yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; ;
1602 break;}
1603 case 85:
1604 #line 606 "/usr/homes/chet/src/bash/src/parse.y"
1605 { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ;
1606 break;}
1607 case 86:
1608 #line 608 "/usr/homes/chet/src/bash/src/parse.y"
1609 { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ;
1610 break;}
1611 case 87:
1612 #line 610 "/usr/homes/chet/src/bash/src/parse.y"
1613 { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ;
1614 break;}
1615 case 88:
1616 #line 612 "/usr/homes/chet/src/bash/src/parse.y"
1617 { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ;
1618 break;}
1619 case 90:
1620 #line 617 "/usr/homes/chet/src/bash/src/parse.y"
1621 { yyvsp[-1].pattern->next = yyvsp[-2].pattern; yyval.pattern = yyvsp[-1].pattern; ;
1622 break;}
1623 case 91:
1624 #line 621 "/usr/homes/chet/src/bash/src/parse.y"
1625 { yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); ;
1626 break;}
1627 case 92:
1628 #line 623 "/usr/homes/chet/src/bash/src/parse.y"
1629 { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-2].word_list); ;
1630 break;}
1631 case 93:
1632 #line 632 "/usr/homes/chet/src/bash/src/parse.y"
1633 {
1634 yyval.command = yyvsp[0].command;
1635 if (need_here_doc)
1636 gather_here_documents ();
1637 ;
1638 break;}
1639 case 95:
1640 #line 641 "/usr/homes/chet/src/bash/src/parse.y"
1641 {
1642 yyval.command = yyvsp[0].command;
1643 ;
1644 break;}
1645 case 97:
1646 #line 648 "/usr/homes/chet/src/bash/src/parse.y"
1647 {
1648 if (yyvsp[-2].command->type == cm_connection)
1649 yyval.command = connect_async_list (yyvsp[-2].command, (COMMAND *)NULL, '&');
1650 else
1651 yyval.command = command_connect (yyvsp[-2].command, (COMMAND *)NULL, '&');
1652 ;
1653 break;}
1654 case 99:
1655 #line 659 "/usr/homes/chet/src/bash/src/parse.y"
1656 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
1657 break;}
1658 case 100:
1659 #line 661 "/usr/homes/chet/src/bash/src/parse.y"
1660 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
1661 break;}
1662 case 101:
1663 #line 663 "/usr/homes/chet/src/bash/src/parse.y"
1664 {
1665 if (yyvsp[-3].command->type == cm_connection)
1666 yyval.command = connect_async_list (yyvsp[-3].command, yyvsp[0].command, '&');
1667 else
1668 yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '&');
1669 ;
1670 break;}
1671 case 102:
1672 #line 670 "/usr/homes/chet/src/bash/src/parse.y"
1673 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
1674 break;}
1675 case 103:
1676 #line 672 "/usr/homes/chet/src/bash/src/parse.y"
1677 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
1678 break;}
1679 case 104:
1680 #line 674 "/usr/homes/chet/src/bash/src/parse.y"
1681 { yyval.command = yyvsp[0].command; ;
1682 break;}
1683 case 110:
1684 #line 693 "/usr/homes/chet/src/bash/src/parse.y"
1685 {
1686 yyval.command = yyvsp[0].command;
1687 if (need_here_doc)
1688 gather_here_documents ();
1689 ;
1690 break;}
1691 case 111:
1692 #line 699 "/usr/homes/chet/src/bash/src/parse.y"
1693 {
1694 if (yyvsp[-1].command->type == cm_connection)
1695 yyval.command = connect_async_list (yyvsp[-1].command, (COMMAND *)NULL, '&');
1696 else
1697 yyval.command = command_connect (yyvsp[-1].command, (COMMAND *)NULL, '&');
1698 if (need_here_doc)
1699 gather_here_documents ();
1700 ;
1701 break;}
1702 case 112:
1703 #line 708 "/usr/homes/chet/src/bash/src/parse.y"
1704 {
1705 yyval.command = yyvsp[-1].command;
1706 if (need_here_doc)
1707 gather_here_documents ();
1708 ;
1709 break;}
1710 case 113:
1711 #line 716 "/usr/homes/chet/src/bash/src/parse.y"
1712 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
1713 break;}
1714 case 114:
1715 #line 718 "/usr/homes/chet/src/bash/src/parse.y"
1716 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
1717 break;}
1718 case 115:
1719 #line 720 "/usr/homes/chet/src/bash/src/parse.y"
1720 {
1721 if (yyvsp[-2].command->type == cm_connection)
1722 yyval.command = connect_async_list (yyvsp[-2].command, yyvsp[0].command, '&');
1723 else
1724 yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, '&');
1725 ;
1726 break;}
1727 case 116:
1728 #line 727 "/usr/homes/chet/src/bash/src/parse.y"
1729 { yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, ';'); ;
1730 break;}
1731 case 117:
1732 #line 730 "/usr/homes/chet/src/bash/src/parse.y"
1733 { yyval.command = yyvsp[0].command; ;
1734 break;}
1735 case 118:
1736 #line 734 "/usr/homes/chet/src/bash/src/parse.y"
1737 { yyval.command = yyvsp[0].command; ;
1738 break;}
1739 case 119:
1740 #line 736 "/usr/homes/chet/src/bash/src/parse.y"
1741 {
1742 yyvsp[0].command->flags |= CMD_INVERT_RETURN;
1743 yyval.command = yyvsp[0].command;
1744 ;
1745 break;}
1746 case 120:
1747 #line 741 "/usr/homes/chet/src/bash/src/parse.y"
1748 {
1749 yyvsp[0].command->flags |= yyvsp[-1].number;
1750 yyval.command = yyvsp[0].command;
1751 ;
1752 break;}
1753 case 121:
1754 #line 746 "/usr/homes/chet/src/bash/src/parse.y"
1755 {
1756 yyvsp[0].command->flags |= yyvsp[-2].number;
1757 yyval.command = yyvsp[0].command;
1758 ;
1759 break;}
1760 case 122:
1761 #line 751 "/usr/homes/chet/src/bash/src/parse.y"
1762 {
1763 yyvsp[0].command->flags |= yyvsp[-1].number|CMD_INVERT_RETURN;
1764 yyval.command = yyvsp[0].command;
1765 ;
1766 break;}
1767 case 123:
1768 #line 759 "/usr/homes/chet/src/bash/src/parse.y"
1769 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '|'); ;
1770 break;}
1771 case 124:
1772 #line 761 "/usr/homes/chet/src/bash/src/parse.y"
1773 { yyval.command = yyvsp[0].command; ;
1774 break;}
1775 case 125:
1776 #line 765 "/usr/homes/chet/src/bash/src/parse.y"
1777 { yyval.number = CMD_TIME_PIPELINE; ;
1778 break;}
1779 case 126:
1780 #line 767 "/usr/homes/chet/src/bash/src/parse.y"
1781 { yyval.number = CMD_TIME_PIPELINE|CMD_TIME_POSIX; ;
1782 break;}
1783 }
1784 /* the action file gets copied in in place of this dollarsign */
1785 #line 498 "/usr/share/misc/bison.simple"
1786 \f
1787 yyvsp -= yylen;
1788 yyssp -= yylen;
1789 #ifdef YYLSP_NEEDED
1790 yylsp -= yylen;
1791 #endif
1792
1793 #if YYDEBUG != 0
1794 if (yydebug)
1795 {
1796 short *ssp1 = yyss - 1;
1797 fprintf (stderr, "state stack now");
1798 while (ssp1 != yyssp)
1799 fprintf (stderr, " %d", *++ssp1);
1800 fprintf (stderr, "\n");
1801 }
1802 #endif
1803
1804 *++yyvsp = yyval;
1805
1806 #ifdef YYLSP_NEEDED
1807 yylsp++;
1808 if (yylen == 0)
1809 {
1810 yylsp->first_line = yylloc.first_line;
1811 yylsp->first_column = yylloc.first_column;
1812 yylsp->last_line = (yylsp-1)->last_line;
1813 yylsp->last_column = (yylsp-1)->last_column;
1814 yylsp->text = 0;
1815 }
1816 else
1817 {
1818 yylsp->last_line = (yylsp+yylen-1)->last_line;
1819 yylsp->last_column = (yylsp+yylen-1)->last_column;
1820 }
1821 #endif
1822
1823 /* Now "shift" the result of the reduction.
1824 Determine what state that goes to,
1825 based on the state we popped back to
1826 and the rule number reduced by. */
1827
1828 yyn = yyr1[yyn];
1829
1830 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1831 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1832 yystate = yytable[yystate];
1833 else
1834 yystate = yydefgoto[yyn - YYNTBASE];
1835
1836 goto yynewstate;
1837
1838 yyerrlab: /* here on detecting error */
1839
1840 if (! yyerrstatus)
1841 /* If not already recovering from an error, report this error. */
1842 {
1843 ++yynerrs;
1844
1845 #ifdef YYERROR_VERBOSE
1846 yyn = yypact[yystate];
1847
1848 if (yyn > YYFLAG && yyn < YYLAST)
1849 {
1850 int size = 0;
1851 char *msg;
1852 int x, count;
1853
1854 count = 0;
1855 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
1856 for (x = (yyn < 0 ? -yyn : 0);
1857 x < (sizeof(yytname) / sizeof(char *)); x++)
1858 if (yycheck[x + yyn] == x)
1859 size += strlen(yytname[x]) + 15, count++;
1860 msg = (char *) malloc(size + 15);
1861 if (msg != 0)
1862 {
1863 strcpy(msg, "parse error");
1864
1865 if (count < 5)
1866 {
1867 count = 0;
1868 for (x = (yyn < 0 ? -yyn : 0);
1869 x < (sizeof(yytname) / sizeof(char *)); x++)
1870 if (yycheck[x + yyn] == x)
1871 {
1872 strcat(msg, count == 0 ? ", expecting `" : " or `");
1873 strcat(msg, yytname[x]);
1874 strcat(msg, "'");
1875 count++;
1876 }
1877 }
1878 yyerror(msg);
1879 free(msg);
1880 }
1881 else
1882 yyerror ("parse error; also virtual memory exceeded");
1883 }
1884 else
1885 #endif /* YYERROR_VERBOSE */
1886 yyerror("parse error");
1887 }
1888
1889 goto yyerrlab1;
1890 yyerrlab1: /* here on error raised explicitly by an action */
1891
1892 if (yyerrstatus == 3)
1893 {
1894 /* if just tried and failed to reuse lookahead token after an error, discard it. */
1895
1896 /* return failure if at end of input */
1897 if (yychar == YYEOF)
1898 YYABORT;
1899
1900 #if YYDEBUG != 0
1901 if (yydebug)
1902 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1903 #endif
1904
1905 yychar = YYEMPTY;
1906 }
1907
1908 /* Else will try to reuse lookahead token
1909 after shifting the error token. */
1910
1911 yyerrstatus = 3; /* Each real token shifted decrements this */
1912
1913 goto yyerrhandle;
1914
1915 yyerrdefault: /* current state does not do anything special for the error token. */
1916
1917 #if 0
1918 /* This is wrong; only states that explicitly want error tokens
1919 should shift them. */
1920 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
1921 if (yyn) goto yydefault;
1922 #endif
1923
1924 yyerrpop: /* pop the current state because it cannot handle the error token */
1925
1926 if (yyssp == yyss) YYABORT;
1927 yyvsp--;
1928 yystate = *--yyssp;
1929 #ifdef YYLSP_NEEDED
1930 yylsp--;
1931 #endif
1932
1933 #if YYDEBUG != 0
1934 if (yydebug)
1935 {
1936 short *ssp1 = yyss - 1;
1937 fprintf (stderr, "Error: state stack now");
1938 while (ssp1 != yyssp)
1939 fprintf (stderr, " %d", *++ssp1);
1940 fprintf (stderr, "\n");
1941 }
1942 #endif
1943
1944 yyerrhandle:
1945
1946 yyn = yypact[yystate];
1947 if (yyn == YYFLAG)
1948 goto yyerrdefault;
1949
1950 yyn += YYTERROR;
1951 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1952 goto yyerrdefault;
1953
1954 yyn = yytable[yyn];
1955 if (yyn < 0)
1956 {
1957 if (yyn == YYFLAG)
1958 goto yyerrpop;
1959 yyn = -yyn;
1960 goto yyreduce;
1961 }
1962 else if (yyn == 0)
1963 goto yyerrpop;
1964
1965 if (yyn == YYFINAL)
1966 YYACCEPT;
1967
1968 #if YYDEBUG != 0
1969 if (yydebug)
1970 fprintf(stderr, "Shifting error token, ");
1971 #endif
1972
1973 *++yyvsp = yylval;
1974 #ifdef YYLSP_NEEDED
1975 *++yylsp = yylloc;
1976 #endif
1977
1978 yystate = yyn;
1979 goto yynewstate;
1980 }
1981 #line 769 "/usr/homes/chet/src/bash/src/parse.y"
1982
1983
1984 /* Possible states for the parser that require it to do special things. */
1985 #define PST_CASEPAT 0x001 /* in a case pattern list */
1986 #define PST_ALEXPNEXT 0x002 /* expand next word for aliases */
1987 #define PST_ALLOWOPNBRC 0x004 /* allow open brace for function def */
1988 #define PST_NEEDCLOSBRC 0x008 /* need close brace */
1989 #define PST_DBLPAREN 0x010 /* double-paren parsing */
1990 #define PST_SUBSHELL 0x020 /* ( ... ) subshell */
1991 #define PST_CMDSUBST 0x040 /* $( ... ) command substitution */
1992 #define PST_CASESTMT 0x080 /* parsing a case statement */
1993 #define PST_CONDCMD 0x100 /* parsing a [[...]] command */
1994 #define PST_CONDEXPR 0x200 /* parsing the guts of [[...]] */
1995
1996 /* Initial size to allocate for tokens, and the
1997 amount to grow them by. */
1998 #define TOKEN_DEFAULT_INITIAL_SIZE 496
1999 #define TOKEN_DEFAULT_GROW_SIZE 512
2000
2001 /* Shell meta-characters that, when unquoted, separate words. */
2002 #define shellmeta(c) (strchr (shell_meta_chars, (c)) != 0)
2003 #define shellbreak(c) (strchr (shell_break_chars, (c)) != 0)
2004 #define shellquote(c) ((c) == '"' || (c) == '`' || (c) == '\'')
2005 #define shellexp(c) ((c) == '$' || (c) == '<' || (c) == '>')
2006
2007 char *shell_meta_chars = "()<>;&|";
2008 char *shell_break_chars = "()<>;&| \t\n";
2009
2010 /* The token currently being read. */
2011 static int current_token;
2012
2013 /* The last read token, or NULL. read_token () uses this for context
2014 checking. */
2015 static int last_read_token;
2016
2017 /* The token read prior to last_read_token. */
2018 static int token_before_that;
2019
2020 /* The token read prior to token_before_that. */
2021 static int two_tokens_ago;
2022
2023 /* If non-zero, it is the token that we want read_token to return
2024 regardless of what text is (or isn't) present to be read. This
2025 is reset by read_token. If token_to_read == WORD or
2026 ASSIGNMENT_WORD, yylval.word should be set to word_desc_to_read. */
2027 static int token_to_read;
2028 static WORD_DESC *word_desc_to_read;
2029
2030 /* The current parser state. */
2031 static int parser_state;
2032
2033 /* Global var is non-zero when end of file has been reached. */
2034 int EOF_Reached = 0;
2035
2036 void
2037 debug_parser (i)
2038 int i;
2039 {
2040 #if YYDEBUG != 0
2041 yydebug = i;
2042 #endif
2043 }
2044
2045 /* yy_getc () returns the next available character from input or EOF.
2046 yy_ungetc (c) makes `c' the next character to read.
2047 init_yy_io (get, unget, type, location) makes the function GET the
2048 installed function for getting the next character, makes UNGET the
2049 installed function for un-getting a character, sets the type of stream
2050 (either string or file) from TYPE, and makes LOCATION point to where
2051 the input is coming from. */
2052
2053 /* Unconditionally returns end-of-file. */
2054 int
2055 return_EOF ()
2056 {
2057 return (EOF);
2058 }
2059
2060 /* Variable containing the current get and unget functions.
2061 See ./input.h for a clearer description. */
2062 BASH_INPUT bash_input;
2063
2064 /* Set all of the fields in BASH_INPUT to NULL. Free bash_input.name if it
2065 is non-null, avoiding a memory leak. */
2066 void
2067 initialize_bash_input ()
2068 {
2069 bash_input.type = st_none;
2070 FREE (bash_input.name);
2071 bash_input.name = (char *)NULL;
2072 bash_input.location.file = (FILE *)NULL;
2073 bash_input.location.string = (char *)NULL;
2074 bash_input.getter = (Function *)NULL;
2075 bash_input.ungetter = (Function *)NULL;
2076 }
2077
2078 /* Set the contents of the current bash input stream from
2079 GET, UNGET, TYPE, NAME, and LOCATION. */
2080 void
2081 init_yy_io (get, unget, type, name, location)
2082 Function *get, *unget;
2083 enum stream_type type;
2084 char *name;
2085 INPUT_STREAM location;
2086 {
2087 bash_input.type = type;
2088 FREE (bash_input.name);
2089 bash_input.name = name ? savestring (name) : (char *)NULL;
2090
2091 /* XXX */
2092 #if defined (CRAY)
2093 memcpy((char *)&bash_input.location.string, (char *)&location.string, sizeof(location));
2094 #else
2095 bash_input.location = location;
2096 #endif
2097 bash_input.getter = get;
2098 bash_input.ungetter = unget;
2099 }
2100
2101 /* Call this to get the next character of input. */
2102 int
2103 yy_getc ()
2104 {
2105 return (*(bash_input.getter)) ();
2106 }
2107
2108 /* Call this to unget C. That is, to make C the next character
2109 to be read. */
2110 int
2111 yy_ungetc (c)
2112 int c;
2113 {
2114 return (*(bash_input.ungetter)) (c);
2115 }
2116
2117 #if defined (BUFFERED_INPUT)
2118 int
2119 input_file_descriptor ()
2120 {
2121 switch (bash_input.type)
2122 {
2123 case st_stream:
2124 return (fileno (bash_input.location.file));
2125 case st_bstream:
2126 return (bash_input.location.buffered_fd);
2127 case st_stdin:
2128 default:
2129 return (fileno (stdin));
2130 }
2131 }
2132 #endif /* BUFFERED_INPUT */
2133
2134 /* **************************************************************** */
2135 /* */
2136 /* Let input be read from readline (). */
2137 /* */
2138 /* **************************************************************** */
2139
2140 #if defined (READLINE)
2141 char *current_readline_prompt = (char *)NULL;
2142 char *current_readline_line = (char *)NULL;
2143 int current_readline_line_index = 0;
2144
2145 static int
2146 yy_readline_get ()
2147 {
2148 SigHandler *old_sigint;
2149 int line_len, c;
2150
2151 if (!current_readline_line)
2152 {
2153 if (!bash_readline_initialized)
2154 initialize_readline ();
2155
2156 #if defined (JOB_CONTROL)
2157 if (job_control)
2158 give_terminal_to (shell_pgrp);
2159 #endif /* JOB_CONTROL */
2160
2161 if (signal_is_ignored (SIGINT) == 0)
2162 {
2163 old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
2164 interrupt_immediately++;
2165 }
2166
2167 current_readline_line = readline (current_readline_prompt ?
2168 current_readline_prompt : "");
2169
2170 if (signal_is_ignored (SIGINT) == 0)
2171 {
2172 interrupt_immediately--;
2173 set_signal_handler (SIGINT, old_sigint);
2174 }
2175
2176 #if 0
2177 /* Reset the prompt to the decoded value of prompt_string_pointer. */
2178 reset_readline_prompt ();
2179 #endif
2180
2181 if (current_readline_line == 0)
2182 return (EOF);
2183
2184 current_readline_line_index = 0;
2185 line_len = strlen (current_readline_line);
2186
2187 current_readline_line = xrealloc (current_readline_line, 2 + line_len);
2188 current_readline_line[line_len++] = '\n';
2189 current_readline_line[line_len] = '\0';
2190 }
2191
2192 if (current_readline_line[current_readline_line_index] == 0)
2193 {
2194 free (current_readline_line);
2195 current_readline_line = (char *)NULL;
2196 return (yy_readline_get ());
2197 }
2198 else
2199 {
2200 c = (unsigned char)current_readline_line[current_readline_line_index++];
2201 return (c);
2202 }
2203 }
2204
2205 static int
2206 yy_readline_unget (c)
2207 int c;
2208 {
2209 if (current_readline_line_index && current_readline_line)
2210 current_readline_line[--current_readline_line_index] = c;
2211 return (c);
2212 }
2213
2214 void
2215 with_input_from_stdin ()
2216 {
2217 INPUT_STREAM location;
2218
2219 if (bash_input.type != st_stdin && stream_on_stack (st_stdin) == 0)
2220 {
2221 location.string = current_readline_line;
2222 init_yy_io (yy_readline_get, yy_readline_unget,
2223 st_stdin, "readline stdin", location);
2224 }
2225 }
2226
2227 #else /* !READLINE */
2228
2229 void
2230 with_input_from_stdin ()
2231 {
2232 with_input_from_stream (stdin, "stdin");
2233 }
2234 #endif /* !READLINE */
2235
2236 /* **************************************************************** */
2237 /* */
2238 /* Let input come from STRING. STRING is zero terminated. */
2239 /* */
2240 /* **************************************************************** */
2241
2242 static int
2243 yy_string_get ()
2244 {
2245 register char *string;
2246 register int c;
2247
2248 string = bash_input.location.string;
2249 c = EOF;
2250
2251 /* If the string doesn't exist, or is empty, EOF found. */
2252 if (string && *string)
2253 {
2254 c = *(unsigned char *)string++;
2255 bash_input.location.string = string;
2256 }
2257 return (c);
2258 }
2259
2260 static int
2261 yy_string_unget (c)
2262 int c;
2263 {
2264 *(--bash_input.location.string) = c;
2265 return (c);
2266 }
2267
2268 void
2269 with_input_from_string (string, name)
2270 char *string, *name;
2271 {
2272 INPUT_STREAM location;
2273
2274 location.string = string;
2275 init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
2276 }
2277
2278 /* **************************************************************** */
2279 /* */
2280 /* Let input come from STREAM. */
2281 /* */
2282 /* **************************************************************** */
2283
2284 static int
2285 yy_stream_get ()
2286 {
2287 int result = EOF;
2288
2289 if (bash_input.location.file)
2290 {
2291 #if !defined (HAVE_RESTARTABLE_SYSCALLS)
2292 result = getc_with_restart (bash_input.location.file);
2293 #else /* HAVE_RESTARTABLE_SYSCALLS */
2294 result = getc (bash_input.location.file);
2295 result = (feof (bash_input.location.file)) ? EOF : (unsigned char)result;
2296 #endif /* HAVE_RESTARTABLE_SYSCALLS */
2297 }
2298 return (result);
2299 }
2300
2301 static int
2302 yy_stream_unget (c)
2303 int c;
2304 {
2305 #if !defined (HAVE_RESTARTABLE_SYSCALLS)
2306 return (ungetc_with_restart (c, bash_input.location.file));
2307 #else /* HAVE_RESTARTABLE_SYSCALLS */
2308 return (ungetc (c, bash_input.location.file));
2309 #endif /* HAVE_RESTARTABLE_SYSCALLS */
2310 }
2311
2312 void
2313 with_input_from_stream (stream, name)
2314 FILE *stream;
2315 char *name;
2316 {
2317 INPUT_STREAM location;
2318
2319 location.file = stream;
2320 init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
2321 }
2322
2323 typedef struct stream_saver {
2324 struct stream_saver *next;
2325 BASH_INPUT bash_input;
2326 int line;
2327 #if defined (BUFFERED_INPUT)
2328 BUFFERED_STREAM *bstream;
2329 #endif /* BUFFERED_INPUT */
2330 } STREAM_SAVER;
2331
2332 /* The globally known line number. */
2333 int line_number = 0;
2334
2335 #if defined (COND_COMMAND)
2336 static int cond_lineno;
2337 static int cond_token;
2338 #endif
2339
2340 STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
2341
2342 void
2343 push_stream (reset_lineno)
2344 int reset_lineno;
2345 {
2346 STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
2347
2348 xbcopy ((char *)&bash_input, (char *)&(saver->bash_input), sizeof (BASH_INPUT));
2349
2350 #if defined (BUFFERED_INPUT)
2351 saver->bstream = (BUFFERED_STREAM *)NULL;
2352 /* If we have a buffered stream, clear out buffers[fd]. */
2353 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
2354 saver->bstream = set_buffered_stream (bash_input.location.buffered_fd,
2355 (BUFFERED_STREAM *)NULL);
2356 #endif /* BUFFERED_INPUT */
2357
2358 saver->line = line_number;
2359 bash_input.name = (char *)NULL;
2360 saver->next = stream_list;
2361 stream_list = saver;
2362 EOF_Reached = 0;
2363 if (reset_lineno)
2364 line_number = 0;
2365 }
2366
2367 void
2368 pop_stream ()
2369 {
2370 if (!stream_list)
2371 EOF_Reached = 1;
2372 else
2373 {
2374 STREAM_SAVER *saver = stream_list;
2375
2376 EOF_Reached = 0;
2377 stream_list = stream_list->next;
2378
2379 init_yy_io (saver->bash_input.getter,
2380 saver->bash_input.ungetter,
2381 saver->bash_input.type,
2382 saver->bash_input.name,
2383 saver->bash_input.location);
2384
2385 #if defined (BUFFERED_INPUT)
2386 /* If we have a buffered stream, restore buffers[fd]. */
2387 /* If the input file descriptor was changed while this was on the
2388 save stack, update the buffered fd to the new file descriptor and
2389 re-establish the buffer <-> bash_input fd correspondence. */
2390 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
2391 {
2392 if (bash_input_fd_changed)
2393 {
2394 bash_input_fd_changed = 0;
2395 if (default_buffered_input >= 0)
2396 {
2397 bash_input.location.buffered_fd = default_buffered_input;
2398 saver->bstream->b_fd = default_buffered_input;
2399 }
2400 }
2401 set_buffered_stream (bash_input.location.buffered_fd, saver->bstream);
2402 }
2403 #endif /* BUFFERED_INPUT */
2404
2405 line_number = saver->line;
2406
2407 FREE (saver->bash_input.name);
2408 free (saver);
2409 }
2410 }
2411
2412 /* Return 1 if a stream of type TYPE is saved on the stack. */
2413 int
2414 stream_on_stack (type)
2415 enum stream_type type;
2416 {
2417 register STREAM_SAVER *s;
2418
2419 for (s = stream_list; s; s = s->next)
2420 if (s->bash_input.type == type)
2421 return 1;
2422 return 0;
2423 }
2424
2425 /*
2426 * This is used to inhibit alias expansion and reserved word recognition
2427 * inside case statement pattern lists. A `case statement pattern list' is:
2428 *
2429 * everything between the `in' in a `case word in' and the next ')'
2430 * or `esac'
2431 * everything between a `;;' and the next `)' or `esac'
2432 */
2433
2434 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2435
2436 #if !defined (ALIAS)
2437 typedef void *alias_t;
2438 #endif
2439
2440 #define END_OF_ALIAS 0
2441
2442 /*
2443 * Pseudo-global variables used in implementing token-wise alias expansion.
2444 */
2445
2446 /*
2447 * Pushing and popping strings. This works together with shell_getc to
2448 * implement alias expansion on a per-token basis.
2449 */
2450
2451 typedef struct string_saver {
2452 struct string_saver *next;
2453 int expand_alias; /* Value to set expand_alias to when string is popped. */
2454 char *saved_line;
2455 #if defined (ALIAS)
2456 alias_t *expander; /* alias that caused this line to be pushed. */
2457 #endif
2458 int saved_line_size, saved_line_index, saved_line_terminator;
2459 } STRING_SAVER;
2460
2461 STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
2462
2463 /*
2464 * Push the current shell_input_line onto a stack of such lines and make S
2465 * the current input. Used when expanding aliases. EXPAND is used to set
2466 * the value of expand_next_token when the string is popped, so that the
2467 * word after the alias in the original line is handled correctly when the
2468 * alias expands to multiple words. TOKEN is the token that was expanded
2469 * into S; it is saved and used to prevent infinite recursive expansion.
2470 */
2471 static void
2472 push_string (s, expand, ap)
2473 char *s;
2474 int expand;
2475 alias_t *ap;
2476 {
2477 STRING_SAVER *temp = (STRING_SAVER *) xmalloc (sizeof (STRING_SAVER));
2478
2479 temp->expand_alias = expand;
2480 temp->saved_line = shell_input_line;
2481 temp->saved_line_size = shell_input_line_size;
2482 temp->saved_line_index = shell_input_line_index;
2483 temp->saved_line_terminator = shell_input_line_terminator;
2484 #if defined (ALIAS)
2485 temp->expander = ap;
2486 #endif
2487 temp->next = pushed_string_list;
2488 pushed_string_list = temp;
2489
2490 #if defined (ALIAS)
2491 if (ap)
2492 ap->flags |= AL_BEINGEXPANDED;
2493 #endif
2494
2495 shell_input_line = s;
2496 shell_input_line_size = strlen (s);
2497 shell_input_line_index = 0;
2498 shell_input_line_terminator = '\0';
2499 parser_state &= ~PST_ALEXPNEXT;
2500 }
2501
2502 /*
2503 * Make the top of the pushed_string stack be the current shell input.
2504 * Only called when there is something on the stack. Called from shell_getc
2505 * when it thinks it has consumed the string generated by an alias expansion
2506 * and needs to return to the original input line.
2507 */
2508 static void
2509 pop_string ()
2510 {
2511 STRING_SAVER *t;
2512
2513 FREE (shell_input_line);
2514 shell_input_line = pushed_string_list->saved_line;
2515 shell_input_line_index = pushed_string_list->saved_line_index;
2516 shell_input_line_size = pushed_string_list->saved_line_size;
2517 shell_input_line_terminator = pushed_string_list->saved_line_terminator;
2518
2519 if (pushed_string_list->expand_alias)
2520 parser_state |= PST_ALEXPNEXT;
2521 else
2522 parser_state &= ~PST_ALEXPNEXT;
2523
2524 t = pushed_string_list;
2525 pushed_string_list = pushed_string_list->next;
2526
2527 #if defined (ALIAS)
2528 if (t->expander)
2529 t->expander->flags &= ~AL_BEINGEXPANDED;
2530 #endif
2531
2532 free ((char *)t);
2533 }
2534
2535 static void
2536 free_string_list ()
2537 {
2538 register STRING_SAVER *t, *t1;
2539
2540 for (t = pushed_string_list; t; )
2541 {
2542 t1 = t->next;
2543 FREE (t->saved_line);
2544 #if defined (ALIAS)
2545 if (t->expander)
2546 t->expander->flags &= ~AL_BEINGEXPANDED;
2547 #endif
2548 free ((char *)t);
2549 t = t1;
2550 }
2551 pushed_string_list = (STRING_SAVER *)NULL;
2552 }
2553
2554 #endif /* ALIAS || DPAREN_ARITHMETIC */
2555
2556 /* Return a line of text, taken from wherever yylex () reads input.
2557 If there is no more input, then we return NULL. If REMOVE_QUOTED_NEWLINE
2558 is non-zero, we remove unquoted \<newline> pairs. This is used by
2559 read_secondary_line to read here documents. */
2560 static char *
2561 read_a_line (remove_quoted_newline)
2562 int remove_quoted_newline;
2563 {
2564 static char *line_buffer = (char *)NULL;
2565 static int buffer_size = 0;
2566 int indx = 0, c, peekc, pass_next;
2567
2568 #if defined (READLINE)
2569 if (interactive && bash_input.type != st_string && no_line_editing)
2570 #else
2571 if (interactive && bash_input.type != st_string)
2572 #endif
2573 print_prompt ();
2574
2575 pass_next = 0;
2576 while (1)
2577 {
2578 c = yy_getc ();
2579
2580 /* Allow immediate exit if interrupted during input. */
2581 QUIT;
2582
2583 if (c == 0)
2584 continue;
2585
2586 /* If there is no more input, then we return NULL. */
2587 if (c == EOF)
2588 {
2589 if (interactive && bash_input.type == st_stream)
2590 clearerr (stdin);
2591 if (indx == 0)
2592 return ((char *)NULL);
2593 c = '\n';
2594 }
2595
2596 /* `+2' in case the final character in the buffer is a newline. */
2597 RESIZE_MALLOCED_BUFFER (line_buffer, indx, 2, buffer_size, 128);
2598
2599 /* IF REMOVE_QUOTED_NEWLINES is non-zero, we are reading a
2600 here document with an unquoted delimiter. In this case,
2601 the line will be expanded as if it were in double quotes.
2602 We allow a backslash to escape the next character, but we
2603 need to treat the backslash specially only if a backslash
2604 quoting a backslash-newline pair appears in the line. */
2605 if (pass_next)
2606 {
2607 line_buffer[indx++] = c;
2608 pass_next = 0;
2609 }
2610 else if (c == '\\' && remove_quoted_newline)
2611 {
2612 peekc = yy_getc ();
2613 if (peekc == '\n')
2614 continue; /* Make the unquoted \<newline> pair disappear. */
2615 else
2616 {
2617 yy_ungetc (peekc);
2618 pass_next = 1;
2619 line_buffer[indx++] = c; /* Preserve the backslash. */
2620 }
2621 }
2622 else
2623 line_buffer[indx++] = c;
2624
2625 if (c == '\n')
2626 {
2627 line_buffer[indx] = '\0';
2628 return (line_buffer);
2629 }
2630 }
2631 }
2632
2633 /* Return a line as in read_a_line (), but insure that the prompt is
2634 the secondary prompt. This is used to read the lines of a here
2635 document. REMOVE_QUOTED_NEWLINE is non-zero if we should remove
2636 newlines quoted with backslashes while reading the line. It is
2637 non-zero unless the delimiter of the here document was quoted. */
2638 char *
2639 read_secondary_line (remove_quoted_newline)
2640 int remove_quoted_newline;
2641 {
2642 prompt_string_pointer = &ps2_prompt;
2643 prompt_again ();
2644 return (read_a_line (remove_quoted_newline));
2645 }
2646
2647 /* **************************************************************** */
2648 /* */
2649 /* YYLEX () */
2650 /* */
2651 /* **************************************************************** */
2652
2653 /* Reserved words. These are only recognized as the first word of a
2654 command. */
2655 STRING_INT_ALIST word_token_alist[] = {
2656 { "if", IF },
2657 { "then", THEN },
2658 { "else", ELSE },
2659 { "elif", ELIF },
2660 { "fi", FI },
2661 { "case", CASE },
2662 { "esac", ESAC },
2663 { "for", FOR },
2664 #if defined (SELECT_COMMAND)
2665 { "select", SELECT },
2666 #endif
2667 { "while", WHILE },
2668 { "until", UNTIL },
2669 { "do", DO },
2670 { "done", DONE },
2671 { "in", IN },
2672 { "function", FUNCTION },
2673 #if defined (COMMAND_TIMING)
2674 { "time", TIME },
2675 #endif
2676 { "{", '{' },
2677 { "}", '}' },
2678 { "!", BANG },
2679 #if defined (COND_COMMAND)
2680 { "[[", COND_START },
2681 { "]]", COND_END },
2682 #endif
2683 { (char *)NULL, 0}
2684 };
2685
2686 /* XXX - we should also have an alist with strings for other tokens, so we
2687 can give more descriptive error messages. Look at y.tab.h for the
2688 other tokens. */
2689
2690 /* These are used by read_token_word, but appear up here so that shell_getc
2691 can use them to decide when to add otherwise blank lines to the history. */
2692
2693 /* The primary delimiter stack. */
2694 struct dstack dstack = { (char *)NULL, 0, 0 };
2695
2696 /* A temporary delimiter stack to be used when decoding prompt strings.
2697 This is needed because command substitutions in prompt strings (e.g., PS2)
2698 can screw up the parser's quoting state. */
2699 static struct dstack temp_dstack = { (char *)NULL, 0, 0 };
2700
2701 /* Macro for accessing the top delimiter on the stack. Returns the
2702 delimiter or zero if none. */
2703 #define current_delimiter(ds) \
2704 (ds.delimiter_depth ? ds.delimiters[ds.delimiter_depth - 1] : 0)
2705
2706 #define push_delimiter(ds, character) \
2707 do \
2708 { \
2709 if (ds.delimiter_depth + 2 > ds.delimiter_space) \
2710 ds.delimiters = xrealloc \
2711 (ds.delimiters, (ds.delimiter_space += 10) * sizeof (char)); \
2712 ds.delimiters[ds.delimiter_depth] = character; \
2713 ds.delimiter_depth++; \
2714 } \
2715 while (0)
2716
2717 #define pop_delimiter(ds) ds.delimiter_depth--
2718
2719 /* Return the next shell input character. This always reads characters
2720 from shell_input_line; when that line is exhausted, it is time to
2721 read the next line. This is called by read_token when the shell is
2722 processing normal command input. */
2723
2724 static int
2725 shell_getc (remove_quoted_newline)
2726 int remove_quoted_newline;
2727 {
2728 register int i;
2729 int c;
2730 static int mustpop = 0;
2731
2732 QUIT;
2733
2734 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2735 /* If shell_input_line[shell_input_line_index] == 0, but there is
2736 something on the pushed list of strings, then we don't want to go
2737 off and get another line. We let the code down below handle it. */
2738
2739 if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
2740 (pushed_string_list == (STRING_SAVER *)NULL)))
2741 #else /* !ALIAS && !DPAREN_ARITHMETIC */
2742 if (!shell_input_line || !shell_input_line[shell_input_line_index])
2743 #endif /* !ALIAS && !DPAREN_ARITHMETIC */
2744 {
2745 line_number++;
2746
2747 restart_read:
2748
2749 /* Allow immediate exit if interrupted during input. */
2750 QUIT;
2751
2752 i = 0;
2753 shell_input_line_terminator = 0;
2754
2755 #if defined (JOB_CONTROL)
2756 /* This can cause a problem when reading a command as the result
2757 of a trap, when the trap is called from flush_child. This call
2758 had better not cause jobs to disappear from the job table in
2759 that case, or we will have big trouble. */
2760 notify_and_cleanup ();
2761 #else /* !JOB_CONTROL */
2762 cleanup_dead_jobs ();
2763 #endif /* !JOB_CONTROL */
2764
2765 #if defined (READLINE)
2766 if (interactive && bash_input.type != st_string && no_line_editing)
2767 #else
2768 if (interactive && bash_input.type != st_string)
2769 #endif
2770 print_prompt ();
2771
2772 if (bash_input.type == st_stream)
2773 clearerr (stdin);
2774
2775 while (c = yy_getc ())
2776 {
2777 /* Allow immediate exit if interrupted during input. */
2778 QUIT;
2779
2780 RESIZE_MALLOCED_BUFFER (shell_input_line, i, 2, shell_input_line_size, 256);
2781
2782 if (c == EOF)
2783 {
2784 if (bash_input.type == st_stream)
2785 clearerr (stdin);
2786
2787 if (i == 0)
2788 shell_input_line_terminator = EOF;
2789
2790 shell_input_line[i] = '\0';
2791 break;
2792 }
2793
2794 shell_input_line[i++] = c;
2795
2796 if (c == '\n')
2797 {
2798 shell_input_line[--i] = '\0';
2799 current_command_line_count++;
2800 break;
2801 }
2802 }
2803 shell_input_line_index = 0;
2804 shell_input_line_len = i; /* == strlen (shell_input_line) */
2805
2806 #if defined (HISTORY)
2807 if (remember_on_history && shell_input_line && shell_input_line[0])
2808 {
2809 char *expansions;
2810 # if defined (BANG_HISTORY)
2811 int old_hist;
2812
2813 /* If the current delimiter is a single quote, we should not be
2814 performing history expansion, even if we're on a different
2815 line from the original single quote. */
2816 old_hist = history_expansion_inhibited;
2817 if (current_delimiter (dstack) == '\'')
2818 history_expansion_inhibited = 1;
2819 # endif
2820 expansions = pre_process_line (shell_input_line, 1, 1);
2821 # if defined (BANG_HISTORY)
2822 history_expansion_inhibited = old_hist;
2823 # endif
2824 if (expansions != shell_input_line)
2825 {
2826 free (shell_input_line);
2827 shell_input_line = expansions;
2828 shell_input_line_len = shell_input_line ?
2829 strlen (shell_input_line) : 0;
2830 if (!shell_input_line_len)
2831 current_command_line_count--;
2832
2833 /* We have to force the xrealloc below because we don't know
2834 the true allocated size of shell_input_line anymore. */
2835 shell_input_line_size = shell_input_line_len;
2836 }
2837 }
2838 /* XXX - this is grotesque */
2839 else if (remember_on_history && shell_input_line &&
2840 shell_input_line[0] == '\0' &&
2841 current_command_line_count > 1 && current_delimiter (dstack))
2842 {
2843 /* We know shell_input_line[0] == 0 and we're reading some sort of
2844 quoted string. This means we've got a line consisting of only
2845 a newline in a quoted string. We want to make sure this line
2846 gets added to the history. */
2847 maybe_add_history (shell_input_line);
2848 }
2849
2850 #endif /* HISTORY */
2851
2852 if (shell_input_line)
2853 {
2854 /* Lines that signify the end of the shell's input should not be
2855 echoed. */
2856 if (echo_input_at_read && (shell_input_line[0] ||
2857 shell_input_line_terminator != EOF))
2858 fprintf (stderr, "%s\n", shell_input_line);
2859 }
2860 else
2861 {
2862 shell_input_line_size = 0;
2863 prompt_string_pointer = &current_prompt_string;
2864 prompt_again ();
2865 goto restart_read;
2866 }
2867
2868 /* Add the newline to the end of this string, iff the string does
2869 not already end in an EOF character. */
2870 if (shell_input_line_terminator != EOF)
2871 {
2872 if (shell_input_line_len + 3 > shell_input_line_size)
2873 shell_input_line = xrealloc (shell_input_line,
2874 1 + (shell_input_line_size += 2));
2875
2876 shell_input_line[shell_input_line_len] = '\n';
2877 shell_input_line[shell_input_line_len + 1] = '\0';
2878 }
2879 }
2880
2881 c = shell_input_line[shell_input_line_index];
2882
2883 if (c)
2884 shell_input_line_index++;
2885
2886 if (c == '\\' && remove_quoted_newline &&
2887 shell_input_line[shell_input_line_index] == '\n')
2888 {
2889 prompt_again ();
2890 line_number++;
2891 goto restart_read;
2892 }
2893
2894 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2895 /* If C is NULL, we have reached the end of the current input string. If
2896 pushed_string_list is non-empty, it's time to pop to the previous string
2897 because we have fully consumed the result of the last alias expansion.
2898 Do it transparently; just return the next character of the string popped
2899 to. */
2900 if (!c && (pushed_string_list != (STRING_SAVER *)NULL))
2901 {
2902 if (mustpop)
2903 {
2904 pop_string ();
2905 c = shell_input_line[shell_input_line_index];
2906 if (c)
2907 shell_input_line_index++;
2908 mustpop--;
2909 }
2910 else
2911 {
2912 mustpop++;
2913 c = ' ';
2914 }
2915 }
2916 #endif /* ALIAS || DPAREN_ARITHMETIC */
2917
2918 if (!c && shell_input_line_terminator == EOF)
2919 return ((shell_input_line_index != 0) ? '\n' : EOF);
2920
2921 return ((unsigned char)c);
2922 }
2923
2924 /* Put C back into the input for the shell. */
2925 static void
2926 shell_ungetc (c)
2927 int c;
2928 {
2929 if (shell_input_line && shell_input_line_index)
2930 shell_input_line[--shell_input_line_index] = c;
2931 }
2932
2933 static void
2934 shell_ungetchar ()
2935 {
2936 if (shell_input_line && shell_input_line_index)
2937 shell_input_line_index--;
2938 }
2939
2940 /* Discard input until CHARACTER is seen, then push that character back
2941 onto the input stream. */
2942 static void
2943 discard_until (character)
2944 int character;
2945 {
2946 int c;
2947
2948 while ((c = shell_getc (0)) != EOF && c != character)
2949 ;
2950
2951 if (c != EOF)
2952 shell_ungetc (c);
2953 }
2954
2955 void
2956 execute_prompt_command (command)
2957 char *command;
2958 {
2959 Function *temp_last, *temp_this;
2960 char *last_lastarg;
2961 int temp_exit_value, temp_eof_encountered;
2962
2963 temp_last = last_shell_builtin;
2964 temp_this = this_shell_builtin;
2965 temp_exit_value = last_command_exit_value;
2966 temp_eof_encountered = eof_encountered;
2967 last_lastarg = get_string_value ("_");
2968 if (last_lastarg)
2969 last_lastarg = savestring (last_lastarg);
2970
2971 parse_and_execute (savestring (command), "PROMPT_COMMAND", SEVAL_NONINT|SEVAL_NOHIST);
2972
2973 last_shell_builtin = temp_last;
2974 this_shell_builtin = temp_this;
2975 last_command_exit_value = temp_exit_value;
2976 eof_encountered = temp_eof_encountered;
2977
2978 bind_variable ("_", last_lastarg);
2979 FREE (last_lastarg);
2980
2981 if (token_to_read == '\n') /* reset_parser was called */
2982 token_to_read = 0;
2983 }
2984
2985 /* Place to remember the token. We try to keep the buffer
2986 at a reasonable size, but it can grow. */
2987 static char *token = (char *)NULL;
2988
2989 /* Current size of the token buffer. */
2990 static int token_buffer_size;
2991
2992 /* Command to read_token () explaining what we want it to do. */
2993 #define READ 0
2994 #define RESET 1
2995 #define prompt_is_ps1 \
2996 (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
2997
2998 /* Function for yyparse to call. yylex keeps track of
2999 the last two tokens read, and calls read_token. */
3000 static int
3001 yylex ()
3002 {
3003 if (interactive && (current_token == 0 || current_token == '\n'))
3004 {
3005 /* Before we print a prompt, we might have to check mailboxes.
3006 We do this only if it is time to do so. Notice that only here
3007 is the mail alarm reset; nothing takes place in check_mail ()
3008 except the checking of mail. Please don't change this. */
3009 if (prompt_is_ps1 && time_to_check_mail ())
3010 {
3011 check_mail ();
3012 reset_mail_timer ();
3013 }
3014
3015 /* Avoid printing a prompt if we're not going to read anything, e.g.
3016 after resetting the parser with read_token (RESET). */
3017 if (token_to_read == 0 && interactive)
3018 prompt_again ();
3019 }
3020
3021 two_tokens_ago = token_before_that;
3022 token_before_that = last_read_token;
3023 last_read_token = current_token;
3024 current_token = read_token (READ);
3025 return (current_token);
3026 }
3027
3028 /* When non-zero, we have read the required tokens
3029 which allow ESAC to be the next one read. */
3030 static int esacs_needed_count;
3031
3032 void
3033 gather_here_documents ()
3034 {
3035 int r = 0;
3036 while (need_here_doc)
3037 {
3038 make_here_document (redir_stack[r++]);
3039 need_here_doc--;
3040 }
3041 }
3042
3043 /* When non-zero, an open-brace used to create a group is awaiting a close
3044 brace partner. */
3045 static int open_brace_count;
3046
3047 #define command_token_position(token) \
3048 (((token) == ASSIGNMENT_WORD) || \
3049 ((token) != SEMI_SEMI && reserved_word_acceptable(token)))
3050
3051 #define assignment_acceptable(token) command_token_position(token) && \
3052 ((parser_state & PST_CASEPAT) == 0)
3053
3054 /* Check to see if TOKEN is a reserved word and return the token
3055 value if it is. */
3056 #define CHECK_FOR_RESERVED_WORD(tok) \
3057 do { \
3058 if (!dollar_present && !quoted && \
3059 reserved_word_acceptable (last_read_token)) \
3060 { \
3061 int i; \
3062 for (i = 0; word_token_alist[i].word != (char *)NULL; i++) \
3063 if (STREQ (tok, word_token_alist[i].word)) \
3064 { \
3065 if ((parser_state & PST_CASEPAT) && (word_token_alist[i].token != ESAC)) \
3066 break; \
3067 if (word_token_alist[i].token == TIME) \
3068 break; \
3069 if (word_token_alist[i].token == ESAC) \
3070 parser_state &= ~(PST_CASEPAT|PST_CASESTMT); \
3071 else if (word_token_alist[i].token == CASE) \
3072 parser_state |= PST_CASESTMT; \
3073 else if (word_token_alist[i].token == COND_END) \
3074 parser_state &= ~(PST_CONDCMD|PST_CONDEXPR); \
3075 else if (word_token_alist[i].token == COND_START) \
3076 parser_state |= PST_CONDCMD; \
3077 else if (word_token_alist[i].token == '{') \
3078 open_brace_count++; \
3079 else if (word_token_alist[i].token == '}' && open_brace_count) \
3080 open_brace_count--; \
3081 return (word_token_alist[i].token); \
3082 } \
3083 } \
3084 } while (0)
3085
3086 #if defined (ALIAS)
3087
3088 /* OK, we have a token. Let's try to alias expand it, if (and only if)
3089 it's eligible.
3090
3091 It is eligible for expansion if the shell is in interactive mode, and
3092 the token is unquoted and the last token read was a command
3093 separator (or expand_next_token is set), and we are currently
3094 processing an alias (pushed_string_list is non-empty) and this
3095 token is not the same as the current or any previously
3096 processed alias.
3097
3098 Special cases that disqualify:
3099 In a pattern list in a case statement (parser_state & PST_CASEPAT). */
3100 static int
3101 alias_expand_token (token)
3102 char *token;
3103 {
3104 char *expanded;
3105 alias_t *ap;
3106
3107 if (((parser_state & PST_ALEXPNEXT) || command_token_position (last_read_token)) &&
3108 (parser_state & PST_CASEPAT) == 0)
3109 {
3110 ap = find_alias (token);
3111
3112 /* Currently expanding this token. */
3113 if (ap && (ap->flags & AL_BEINGEXPANDED))
3114 return (NO_EXPANSION);
3115
3116 expanded = ap ? savestring (ap->value) : (char *)NULL;
3117 if (expanded)
3118 {
3119 push_string (expanded, ap->flags & AL_EXPANDNEXT, ap);
3120 return (RE_READ_TOKEN);
3121 }
3122 else
3123 /* This is an eligible token that does not have an expansion. */
3124 return (NO_EXPANSION);
3125 }
3126 return (NO_EXPANSION);
3127 }
3128 #endif /* ALIAS */
3129
3130 static int
3131 time_command_acceptable ()
3132 {
3133 #if defined (COMMAND_TIMING)
3134 switch (last_read_token)
3135 {
3136 case 0:
3137 case ';':
3138 case '\n':
3139 case AND_AND:
3140 case OR_OR:
3141 case '&':
3142 case DO:
3143 case THEN:
3144 case ELSE:
3145 case '{':
3146 case '(':
3147 return 1;
3148 default:
3149 return 0;
3150 }
3151 #else
3152 return 0;
3153 #endif /* COMMAND_TIMING */
3154 }
3155
3156 /* Handle special cases of token recognition:
3157 IN is recognized if the last token was WORD and the token
3158 before that was FOR or CASE or SELECT.
3159
3160 DO is recognized if the last token was WORD and the token
3161 before that was FOR or SELECT.
3162
3163 ESAC is recognized if the last token caused `esacs_needed_count'
3164 to be set
3165
3166 `{' is recognized if the last token as WORD and the token
3167 before that was FUNCTION.
3168
3169 `}' is recognized if there is an unclosed `{' prsent.
3170
3171 `-p' is returned as TIMEOPT if the last read token was TIME.
3172
3173 ']]' is returned as COND_END if the parser is currently parsing
3174 a conditional expression ((parser_state & PST_CONDEXPR) != 0)
3175
3176 `time' is returned as TIME if and only if it is immediately
3177 preceded by one of `;', `\n', `||', `&&', or `&'.
3178 */
3179
3180 static int
3181 special_case_tokens (token)
3182 char *token;
3183 {
3184 if ((last_read_token == WORD) &&
3185 #if defined (SELECT_COMMAND)
3186 ((token_before_that == FOR) || (token_before_that == CASE) || (token_before_that == SELECT)) &&
3187 #else
3188 ((token_before_that == FOR) || (token_before_that == CASE)) &&
3189 #endif
3190 (token[0] == 'i' && token[1] == 'n' && token[2] == 0))
3191 {
3192 if (token_before_that == CASE)
3193 {
3194 parser_state |= PST_CASEPAT;
3195 esacs_needed_count++;
3196 }
3197 return (IN);
3198 }
3199
3200 if (last_read_token == WORD &&
3201 #if defined (SELECT_COMMAND)
3202 (token_before_that == FOR || token_before_that == SELECT) &&
3203 #else
3204 (token_before_that == FOR) &&
3205 #endif
3206 (token[0] == 'd' && token[1] == 'o' && token[2] == '\0'))
3207 return (DO);
3208
3209 /* Ditto for ESAC in the CASE case.
3210 Specifically, this handles "case word in esac", which is a legal
3211 construct, certainly because someone will pass an empty arg to the
3212 case construct, and we don't want it to barf. Of course, we should
3213 insist that the case construct has at least one pattern in it, but
3214 the designers disagree. */
3215 if (esacs_needed_count)
3216 {
3217 esacs_needed_count--;
3218 if (STREQ (token, "esac"))
3219 {
3220 parser_state &= ~PST_CASEPAT;
3221 return (ESAC);
3222 }
3223 }
3224
3225 /* The start of a shell function definition. */
3226 if (parser_state & PST_ALLOWOPNBRC)
3227 {
3228 parser_state &= ~PST_ALLOWOPNBRC;
3229 if (token[0] == '{' && token[1] == '\0') /* } */
3230 {
3231 open_brace_count++;
3232 function_bstart = line_number;
3233 return ('{'); /* } */
3234 }
3235 }
3236
3237 if (open_brace_count && reserved_word_acceptable (last_read_token) && token[0] == '}' && !token[1])
3238 {
3239 open_brace_count--; /* { */
3240 return ('}');
3241 }
3242
3243 #if defined (COMMAND_TIMING)
3244 /* Handle -p after `time'. */
3245 if (last_read_token == TIME && token[0] == '-' && token[1] == 'p' && !token[2])
3246 return (TIMEOPT);
3247 #endif
3248
3249 #if defined (COMMAND_TIMING)
3250 if (STREQ (token, "time") && ((parser_state & PST_CASEPAT) == 0) && time_command_acceptable ())
3251 return (TIME);
3252 #endif /* COMMAND_TIMING */
3253
3254 #if defined (COND_COMMAND) /* [[ */
3255 if ((parser_state & PST_CONDEXPR) && token[0] == ']' && token[1] == ']' && token[2] == '\0')
3256 return (COND_END);
3257 #endif
3258
3259 return (-1);
3260 }
3261
3262 /* Called from shell.c when Control-C is typed at top level. Or
3263 by the error rule at top level. */
3264 void
3265 reset_parser ()
3266 {
3267 dstack.delimiter_depth = 0; /* No delimiters found so far. */
3268 open_brace_count = 0;
3269
3270 parser_state = 0;
3271
3272 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
3273 if (pushed_string_list)
3274 free_string_list ();
3275 #endif /* ALIAS || DPAREN_ARITHMETIC */
3276
3277 if (shell_input_line)
3278 {
3279 free (shell_input_line);
3280 shell_input_line = (char *)NULL;
3281 shell_input_line_size = shell_input_line_index = 0;
3282 }
3283
3284 FREE (word_desc_to_read);
3285 word_desc_to_read = (WORD_DESC *)NULL;
3286
3287 last_read_token = '\n';
3288 token_to_read = '\n';
3289 }
3290
3291 /* Read the next token. Command can be READ (normal operation) or
3292 RESET (to normalize state). */
3293 static int
3294 read_token (command)
3295 int command;
3296 {
3297 int character; /* Current character. */
3298 int peek_char; /* Temporary look-ahead character. */
3299 int result; /* The thing to return. */
3300
3301 if (command == RESET)
3302 {
3303 reset_parser ();
3304 return ('\n');
3305 }
3306
3307 if (token_to_read)
3308 {
3309 result = token_to_read;
3310 if (token_to_read == WORD || token_to_read == ASSIGNMENT_WORD)
3311 {
3312 yylval.word = word_desc_to_read;
3313 word_desc_to_read = (WORD_DESC *)NULL;
3314 }
3315 token_to_read = 0;
3316 return (result);
3317 }
3318
3319 #if defined (COND_COMMAND)
3320 if ((parser_state & (PST_CONDCMD|PST_CONDEXPR)) == PST_CONDCMD)
3321 {
3322 cond_lineno = line_number;
3323 parser_state |= PST_CONDEXPR;
3324 yylval.command = parse_cond_command ();
3325 if (cond_token != COND_END)
3326 {
3327 if (EOF_Reached && cond_token != COND_ERROR) /* [[ */
3328 parser_error (cond_lineno, "unexpected EOF while looking for `]]'");
3329 else if (cond_token != COND_ERROR)
3330 parser_error (cond_lineno, "syntax error in conditional expression");
3331 return (-1);
3332 }
3333 token_to_read = COND_END;
3334 parser_state &= ~(PST_CONDEXPR|PST_CONDCMD);
3335 return (COND_CMD);
3336 }
3337 #endif
3338
3339 #if defined (ALIAS)
3340 /* This is a place to jump back to once we have successfully expanded a
3341 token with an alias and pushed the string with push_string () */
3342 re_read_token:
3343 #endif /* ALIAS */
3344
3345 /* Read a single word from input. Start by skipping blanks. */
3346 while ((character = shell_getc (1)) != EOF && whitespace (character))
3347 ;
3348
3349 if (character == EOF)
3350 {
3351 EOF_Reached = 1;
3352 return (yacc_EOF);
3353 }
3354
3355 if (character == '#' && (!interactive || interactive_comments))
3356 {
3357 /* A comment. Discard until EOL or EOF, and then return a newline. */
3358 discard_until ('\n');
3359 shell_getc (0);
3360 character = '\n'; /* this will take the next if statement and return. */
3361 }
3362
3363 if (character == '\n')
3364 {
3365 /* If we're about to return an unquoted newline, we can go and collect
3366 the text of any pending here document. */
3367 if (need_here_doc)
3368 gather_here_documents ();
3369
3370 #if defined (ALIAS)
3371 parser_state &= ~PST_ALEXPNEXT;
3372 #endif /* ALIAS */
3373
3374 return (character);
3375 }
3376
3377 /* Shell meta-characters. */
3378 if (shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
3379 {
3380 #if defined (ALIAS)
3381 /* Turn off alias tokenization iff this character sequence would
3382 not leave us ready to read a command. */
3383 if (character == '<' || character == '>')
3384 parser_state &= ~PST_ALEXPNEXT;
3385 #endif /* ALIAS */
3386
3387 peek_char = shell_getc (1);
3388 if (character == peek_char)
3389 {
3390 switch (character)
3391 {
3392 case '<':
3393 /* If '<' then we could be at "<<" or at "<<-". We have to
3394 look ahead one more character. */
3395 peek_char = shell_getc (1);
3396 if (peek_char == '-')
3397 return (LESS_LESS_MINUS);
3398 else
3399 {
3400 shell_ungetc (peek_char);
3401 return (LESS_LESS);
3402 }
3403
3404 case '>':
3405 return (GREATER_GREATER);
3406
3407 case ';':
3408 parser_state |= PST_CASEPAT;
3409 #if defined (ALIAS)
3410 parser_state &= ~PST_ALEXPNEXT;
3411 #endif /* ALIAS */
3412 return (SEMI_SEMI);
3413
3414 case '&':
3415 return (AND_AND);
3416
3417 case '|':
3418 return (OR_OR);
3419
3420 #if defined (DPAREN_ARITHMETIC)
3421 case '(': /* ) */
3422 if (reserved_word_acceptable (last_read_token))
3423 {
3424 int cmdtyp, sline;
3425 char *wval;
3426 WORD_DESC *wd;
3427
3428 sline = line_number;
3429 cmdtyp = parse_arith_cmd (&wval);
3430 if (cmdtyp == 1) /* arithmetic command */
3431 {
3432 wd = make_word (wval);
3433 wd->flags = W_QUOTED;
3434 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
3435 free (wval); /* make_word copies it */
3436 return (ARITH_CMD);
3437 }
3438 else if (cmdtyp == 0) /* nested subshell */
3439 {
3440 push_string (wval, 0, (alias_t *)NULL);
3441 if ((parser_state & PST_CASEPAT) == 0)
3442 parser_state |= PST_SUBSHELL;
3443 return (character);
3444 }
3445 else /* ERROR */
3446 return -1;
3447 }
3448 break;
3449 #endif
3450 }
3451 }
3452 else if (character == '<' && peek_char == '&')
3453 return (LESS_AND);
3454 else if (character == '>' && peek_char == '&')
3455 return (GREATER_AND);
3456 else if (character == '<' && peek_char == '>')
3457 return (LESS_GREATER);
3458 else if (character == '>' && peek_char == '|')
3459 return (GREATER_BAR);
3460 else if (peek_char == '>' && character == '&')
3461 return (AND_GREATER);
3462
3463 shell_ungetc (peek_char);
3464
3465 /* If we look like we are reading the start of a function
3466 definition, then let the reader know about it so that
3467 we will do the right thing with `{'. */
3468 if (character == ')' && last_read_token == '(' && token_before_that == WORD)
3469 {
3470 parser_state |= PST_ALLOWOPNBRC;
3471 #if defined (ALIAS)
3472 parser_state &= ~PST_ALEXPNEXT;
3473 #endif /* ALIAS */
3474 function_dstart = line_number;
3475 }
3476
3477 /* case pattern lists may be preceded by an optional left paren. If
3478 we're not trying to parse a case pattern list, the left paren
3479 indicates a subshell. */
3480 if (character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
3481 parser_state |= PST_SUBSHELL;
3482 /*(*/
3483 else if ((parser_state & PST_CASEPAT) && character == ')')
3484 parser_state &= ~PST_CASEPAT;
3485 /*(*/
3486 else if ((parser_state & PST_SUBSHELL) && character == ')')
3487 parser_state &= ~PST_SUBSHELL;
3488
3489 #if defined (PROCESS_SUBSTITUTION)
3490 /* Check for the constructs which introduce process substitution.
3491 Shells running in `posix mode' don't do process substitution. */
3492 if (posixly_correct ||
3493 ((character != '>' && character != '<') || peek_char != '('))
3494 #endif /* PROCESS_SUBSTITUTION */
3495 return (character);
3496 }
3497
3498 /* Hack <&- (close stdin) case. */
3499 if (character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
3500 return (character);
3501
3502 /* Okay, if we got this far, we have to read a word. Read one,
3503 and then check it against the known ones. */
3504 result = read_token_word (character);
3505 #if defined (ALIAS)
3506 if (result == RE_READ_TOKEN)
3507 goto re_read_token;
3508 #endif
3509 return result;
3510 }
3511
3512 /* Match a $(...) or other grouping construct. This has to handle embedded
3513 quoted strings ('', ``, "") and nested constructs. It also must handle
3514 reprompting the user, if necessary, after reading a newline, and returning
3515 correct error values if it reads EOF. */
3516
3517 #define P_FIRSTCLOSE 0x01
3518
3519 static char matched_pair_error;
3520 static char *
3521 parse_matched_pair (qc, open, close, lenp, flags)
3522 int qc; /* `"' if this construct is within double quotes */
3523 int open, close;
3524 int *lenp, flags;
3525 {
3526 int count, ch, was_dollar;
3527 int pass_next_character, nestlen, start_lineno;
3528 char *ret, *nestret;
3529 int retind, retsize;
3530
3531 count = 1;
3532 pass_next_character = was_dollar = 0;
3533
3534 ret = xmalloc (retsize = 64);
3535 retind = 0;
3536
3537 start_lineno = line_number;
3538 while (count)
3539 {
3540 ch = shell_getc (qc != '\'' && pass_next_character == 0);
3541 if (ch == EOF)
3542 {
3543 free (ret);
3544 parser_error (start_lineno, "unexpected EOF while looking for matching `%c'", close);
3545 EOF_Reached = 1; /* XXX */
3546 return (&matched_pair_error);
3547 }
3548
3549 /* Possible reprompting. */
3550 if (ch == '\n' && interactive &&
3551 (bash_input.type == st_stdin || bash_input.type == st_stream))
3552 prompt_again ();
3553
3554 if (pass_next_character) /* last char was backslash */
3555 {
3556 pass_next_character = 0;
3557 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
3558 {
3559 if (retind > 0) retind--; /* swallow previously-added backslash */
3560 continue;
3561 }
3562
3563 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3564 if (ch == CTLESC || ch == CTLNUL)
3565 ret[retind++] = CTLESC;
3566 ret[retind++] = ch;
3567 continue;
3568 }
3569 else if (ch == CTLESC || ch == CTLNUL) /* special shell escapes */
3570 {
3571 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3572 ret[retind++] = CTLESC;
3573 ret[retind++] = ch;
3574 continue;
3575 }
3576 else if (ch == close) /* ending delimiter */
3577 count--;
3578 else if (((flags & P_FIRSTCLOSE) == 0) && ch == open) /* nested begin */
3579 count++;
3580
3581 /* Add this character. */
3582 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3583 ret[retind++] = ch;
3584
3585 if (open == '\'') /* '' inside grouping construct */
3586 continue;
3587
3588 if (ch == '\\') /* backslashes */
3589 pass_next_character++;
3590
3591 if (open != close) /* a grouping construct */
3592 {
3593 if (shellquote (ch))
3594 {
3595 /* '', ``, or "" inside $(...) or other grouping construct. */
3596 push_delimiter (dstack, ch);
3597 nestret = parse_matched_pair (ch, ch, ch, &nestlen, 0);
3598 pop_delimiter (dstack);
3599 if (nestret == &matched_pair_error)
3600 {
3601 free (ret);
3602 return &matched_pair_error;
3603 }
3604 if (nestlen)
3605 {
3606 RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64);
3607 strcpy (ret + retind, nestret);
3608 retind += nestlen;
3609 }
3610 FREE (nestret);
3611 }
3612 }
3613 /* Parse an old-style command substitution within double quotes as a
3614 single word. */
3615 /* XXX - sh and ksh93 don't do this - XXX */
3616 else if (open == '"' && ch == '`')
3617 {
3618 nestret = parse_matched_pair (0, '`', '`', &nestlen, 0);
3619 if (nestret == &matched_pair_error)
3620 {
3621 free (ret);
3622 return &matched_pair_error;
3623 }
3624 if (nestlen)
3625 {
3626 RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64);
3627 strcpy (ret + retind, nestret);
3628 retind += nestlen;
3629 }
3630 FREE (nestret);
3631 }
3632 else if (was_dollar && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3633 /* check for $(), $[], or ${} inside quoted string. */
3634 {
3635 if (open == ch) /* undo previous increment */
3636 count--;
3637 if (ch == '(') /* ) */
3638 nestret = parse_matched_pair (0, '(', ')', &nestlen, 0);
3639 else if (ch == '{') /* } */
3640 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE);
3641 else if (ch == '[') /* ] */
3642 nestret = parse_matched_pair (0, '[', ']', &nestlen, 0);
3643 if (nestret == &matched_pair_error)
3644 {
3645 free (ret);
3646 return &matched_pair_error;
3647 }
3648 if (nestlen)
3649 {
3650 RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64);
3651 strcpy (ret + retind, nestret);
3652 retind += nestlen;
3653 }
3654 FREE (nestret);
3655 }
3656 was_dollar = (ch == '$');
3657 }
3658
3659 ret[retind] = '\0';
3660 if (lenp)
3661 *lenp = retind;
3662 return ret;
3663 }
3664
3665 #if defined (DPAREN_ARITHMETIC)
3666 /* We've seen a `(('. Look for the matching `))'. If we get it, return 1.
3667 If not, assume it's a nested subshell for backwards compatibility and
3668 return 0. In any case, put the characters we've consumed into a locally-
3669 allocated buffer and make *ep point to that buffer. Return -1 on an
3670 error, for example EOF. */
3671 static int
3672 parse_arith_cmd (ep)
3673 char **ep;
3674 {
3675 int exp_lineno, rval, c;
3676 char *ttok, *token;
3677 int ttoklen;
3678
3679 exp_lineno = line_number;
3680 ttok = parse_matched_pair (0, '(', ')', &ttoklen, 0);
3681 rval = 1;
3682 if (ttok == &matched_pair_error)
3683 return -1;
3684 /* Check that the next character is the closing right paren. If
3685 not, this is a syntax error. ( */
3686 if ((c = shell_getc (0)) != ')')
3687 rval = 0;
3688
3689 token = xmalloc(ttoklen + 4);
3690
3691 /* (( ... )) -> "..." */
3692 token[0] = (rval == 1) ? '"' : '(';
3693 strncpy (token + 1, ttok, ttoklen - 1); /* don't copy the final `)' */
3694 if (rval == 1)
3695 {
3696 token[ttoklen] = '"';
3697 token[ttoklen+1] = '\0';
3698 }
3699 else
3700 {
3701 token[ttoklen] = ')';
3702 token[ttoklen+1] = c;
3703 token[ttoklen+2] = '\0';
3704 }
3705 *ep = token;
3706 FREE (ttok);
3707 return rval;
3708 }
3709 #endif /* DPAREN_ARITHMETIC */
3710
3711 #if defined (COND_COMMAND)
3712 static COND_COM *cond_term ();
3713 static COND_COM *cond_and ();
3714 static COND_COM *cond_or ();
3715 static COND_COM *cond_expr ();
3716
3717 static COND_COM *
3718 cond_expr ()
3719 {
3720 return (cond_or ());
3721 }
3722
3723 static COND_COM *
3724 cond_or ()
3725 {
3726 COND_COM *l, *r;
3727
3728 l = cond_and ();
3729 if (cond_token == OR_OR)
3730 {
3731 r = cond_or ();
3732 l = make_cond_node (COND_OR, (WORD_DESC *)NULL, l, r);
3733 }
3734 return l;
3735 }
3736
3737 static COND_COM *
3738 cond_and ()
3739 {
3740 COND_COM *l, *r;
3741
3742 l = cond_term ();
3743 if (cond_token == AND_AND)
3744 {
3745 r = cond_and ();
3746 l = make_cond_node (COND_AND, (WORD_DESC *)NULL, l, r);
3747 }
3748 return l;
3749 }
3750
3751 static int
3752 cond_skip_newlines ()
3753 {
3754 while ((cond_token = read_token (READ)) == '\n')
3755 {
3756 if (interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
3757 prompt_again ();
3758 }
3759 return (cond_token);
3760 }
3761
3762 #define COND_RETURN_ERROR() \
3763 do { cond_token = COND_ERROR; return ((COND_COM *)NULL); } while (0)
3764
3765 static COND_COM *
3766 cond_term ()
3767 {
3768 WORD_DESC *op;
3769 COND_COM *term, *tleft, *tright;
3770 int tok, lineno;
3771
3772 /* Read a token. It can be a left paren, a `!', a unary operator, or a
3773 word that should be the first argument of a binary operator. Start by
3774 skipping newlines, since this is a compound command. */
3775 tok = cond_skip_newlines ();
3776 lineno = line_number;
3777 if (tok == COND_END)
3778 {
3779 COND_RETURN_ERROR ();
3780 }
3781 else if (tok == '(')
3782 {
3783 term = cond_expr ();
3784 if (cond_token != ')')
3785 {
3786 if (term)
3787 dispose_cond_node (term); /* ( */
3788 parser_error (lineno, "expected `)'");
3789 COND_RETURN_ERROR ();
3790 }
3791 term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
3792 (void)cond_skip_newlines ();
3793 }
3794 else if (tok == BANG || (tok == WORD && (yylval.word->word[0] == '!' && yylval.word->word[1] == '\0')))
3795 {
3796 if (tok == WORD)
3797 dispose_word (yylval.word); /* not needed */
3798 term = cond_term ();
3799 if (term)
3800 term->flags |= CMD_INVERT_RETURN;
3801 }
3802 else if (tok == WORD && test_unop (yylval.word->word))
3803 {
3804 op = yylval.word;
3805 tok = read_token (READ);
3806 if (tok == WORD)
3807 {
3808 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
3809 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
3810 }
3811 else
3812 {
3813 dispose_word (op);
3814 parser_error (line_number, "unexpected argument to conditional unary operator");
3815 COND_RETURN_ERROR ();
3816 }
3817
3818 (void)cond_skip_newlines ();
3819 }
3820 else /* left argument to binary operator */
3821 {
3822 /* lhs */
3823 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
3824
3825 /* binop */
3826 tok = read_token (READ);
3827 if (tok == WORD && test_binop (yylval.word->word))
3828 op = yylval.word;
3829 else if (tok == '<' || tok == '>')
3830 op = make_word_from_token (tok);
3831 else if (tok == COND_END || tok == AND_AND || tok == OR_OR)
3832 {
3833 /* Special case. [[ x ]] is equivalent to [[ -n x ]], just like
3834 the test command. Similarly for [[ x && expr ]] or
3835 [[ x || expr ]] */
3836 op = make_word ("-n");
3837 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
3838 cond_token = tok;
3839 return (term);
3840 }
3841 else
3842 {
3843 parser_error (line_number, "conditional binary operator expected");
3844 dispose_cond_node (tleft);
3845 COND_RETURN_ERROR ();
3846 }
3847
3848 /* rhs */
3849 tok = read_token (READ);
3850 if (tok == WORD)
3851 {
3852 tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
3853 term = make_cond_node (COND_BINARY, op, tleft, tright);
3854 }
3855 else
3856 {
3857 parser_error (line_number, "unexpected argument to conditional binary operator");
3858 dispose_cond_node (tleft);
3859 dispose_word (op);
3860 COND_RETURN_ERROR ();
3861 }
3862
3863 (void)cond_skip_newlines ();
3864 }
3865 return (term);
3866 }
3867
3868 /* This is kind of bogus -- we slip a mini recursive-descent parser in
3869 here to handle the conditional statement syntax. */
3870 static COMMAND *
3871 parse_cond_command ()
3872 {
3873 COND_COM *cexp;
3874
3875 cexp = cond_expr ();
3876 return (make_cond_command (cexp));
3877 }
3878 #endif
3879
3880 static int
3881 read_token_word (character)
3882 int character;
3883 {
3884 /* The value for YYLVAL when a WORD is read. */
3885 WORD_DESC *the_word;
3886
3887 /* Index into the token that we are building. */
3888 int token_index;
3889
3890 /* ALL_DIGITS becomes zero when we see a non-digit. */
3891 int all_digits;
3892
3893 /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
3894 int dollar_present;
3895
3896 /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
3897 int quoted;
3898
3899 /* Non-zero means to ignore the value of the next character, and just
3900 to add it no matter what. */
3901 int pass_next_character;
3902
3903 /* The current delimiting character. */
3904 int cd;
3905 int result, peek_char;
3906 char *ttok, *ttrans;
3907 int ttoklen, ttranslen;
3908
3909 if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
3910 token = xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
3911
3912 token_index = 0;
3913 all_digits = digit (character);
3914 dollar_present = quoted = pass_next_character = 0;
3915
3916 for (;;)
3917 {
3918 if (character == EOF)
3919 goto got_token;
3920
3921 if (pass_next_character)
3922 {
3923 pass_next_character = 0;
3924 goto got_character;
3925 }
3926
3927 cd = current_delimiter (dstack);
3928
3929 /* Handle backslashes. Quote lots of things when not inside of
3930 double-quotes, quote some things inside of double-quotes. */
3931 if (character == '\\')
3932 {
3933 peek_char = shell_getc (0);
3934
3935 /* Backslash-newline is ignored in all cases except
3936 when quoted with single quotes. */
3937 if (peek_char == '\n')
3938 {
3939 character = '\n';
3940 goto next_character;
3941 }
3942 else
3943 {
3944 shell_ungetc (peek_char);
3945
3946 /* If the next character is to be quoted, note it now. */
3947 if (cd == 0 || cd == '`' ||
3948 (cd == '"' && member (peek_char, slashify_in_quotes)))
3949 pass_next_character++;
3950
3951 quoted = 1;
3952 goto got_character;
3953 }
3954 }
3955
3956 /* Parse a matched pair of quote characters. */
3957 if (shellquote (character))
3958 {
3959 push_delimiter (dstack, character);
3960 ttok = parse_matched_pair (character, character, character, &ttoklen, 0);
3961 pop_delimiter (dstack);
3962 if (ttok == &matched_pair_error)
3963 return -1; /* Bail immediately. */
3964 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
3965 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
3966 token[token_index++] = character;
3967 strcpy (token + token_index, ttok);
3968 token_index += ttoklen;
3969 all_digits = 0;
3970 quoted = 1;
3971 dollar_present |= (character == '"' && strchr (ttok, '$') != 0);
3972 FREE (ttok);
3973 goto next_character;
3974 }
3975
3976 #ifdef EXTENDED_GLOB
3977 /* Parse a ksh-style extended pattern matching specification. */
3978 if (extended_glob && PATTERN_CHAR(character))
3979 {
3980 peek_char = shell_getc (1);
3981 if (peek_char == '(') /* ) */
3982 {
3983 push_delimiter (dstack, peek_char);
3984 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
3985 pop_delimiter (dstack);
3986 if (ttok == &matched_pair_error)
3987 return -1; /* Bail immediately. */
3988 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
3989 token_buffer_size,
3990 TOKEN_DEFAULT_GROW_SIZE);
3991 token[token_index++] = character;
3992 token[token_index++] = peek_char;
3993 strcpy (token + token_index, ttok);
3994 token_index += ttoklen;
3995 FREE (ttok);
3996 dollar_present = all_digits = 0;
3997 goto next_character;
3998 }
3999 else
4000 shell_ungetc (peek_char);
4001 }
4002 #endif /* EXTENDED_GLOB */
4003
4004 /* If the delimiter character is not single quote, parse some of
4005 the shell expansions that must be read as a single word. */
4006 #if defined (PROCESS_SUBSTITUTION)
4007 if (character == '$' || character == '<' || character == '>')
4008 #else
4009 if (character == '$')
4010 #endif /* !PROCESS_SUBSTITUTION */
4011 {
4012 peek_char = shell_getc (1);
4013 /* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
4014 if (peek_char == '(' ||
4015 ((peek_char == '{' || peek_char == '[') && character == '$')) /* ) ] } */
4016 {
4017 if (peek_char == '{') /* } */
4018 ttok = parse_matched_pair (cd, '{', '}', &ttoklen, P_FIRSTCLOSE);
4019 else if (peek_char == '(') /* ) */
4020 {
4021 /* XXX - push and pop the `(' as a delimiter for use by
4022 the command-oriented-history code. This way newlines
4023 appearing in the $(...) string get added to the
4024 history literally rather than causing a possibly-
4025 incorrect `;' to be added. */
4026 push_delimiter (dstack, peek_char);
4027 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4028 pop_delimiter (dstack);
4029 }
4030 else
4031 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
4032 if (ttok == &matched_pair_error)
4033 return -1; /* Bail immediately. */
4034 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4035 token_buffer_size,
4036 TOKEN_DEFAULT_GROW_SIZE);
4037 token[token_index++] = character;
4038 token[token_index++] = peek_char;
4039 strcpy (token + token_index, ttok);
4040 token_index += ttoklen;
4041 FREE (ttok);
4042 dollar_present = 1;
4043 all_digits = 0;
4044 goto next_character;
4045 }
4046 /* This handles $'...' and $"..." new-style quoted strings. */
4047 else if (character == '$' && (peek_char == '\'' || peek_char == '"'))
4048 {
4049 int first_line;
4050
4051 first_line = line_number;
4052 ttok = parse_matched_pair (peek_char, peek_char, peek_char, &ttoklen, 0);
4053 if (ttok == &matched_pair_error)
4054 return -1;
4055 if (peek_char == '\'')
4056 ttrans = ansiexpand (ttok, 0, ttoklen - 1, &ttranslen);
4057 else
4058 ttrans = localeexpand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
4059 free (ttok);
4060 RESIZE_MALLOCED_BUFFER (token, token_index, ttranslen + 2,
4061 token_buffer_size,
4062 TOKEN_DEFAULT_GROW_SIZE);
4063 token[token_index++] = peek_char;
4064 strcpy (token + token_index, ttrans);
4065 token_index += ttranslen;
4066 token[token_index++] = peek_char;
4067 FREE (ttrans);
4068 quoted = 1;
4069 all_digits = 0;
4070 goto next_character;
4071 }
4072 /* This could eventually be extended to recognize all of the
4073 shell's single-character parameter expansions, and set flags.*/
4074 else if (character == '$' && peek_char == '$')
4075 {
4076 ttok = xmalloc (3);
4077 ttok[0] = ttok[1] = '$';
4078 ttok[2] = '\0';
4079 RESIZE_MALLOCED_BUFFER (token, token_index, 3,
4080 token_buffer_size,
4081 TOKEN_DEFAULT_GROW_SIZE);
4082 strcpy (token + token_index, ttok);
4083 token_index += 2;
4084 dollar_present = 1;
4085 all_digits = 0;
4086 FREE (ttok);
4087 goto next_character;
4088 }
4089 else
4090 shell_ungetc (peek_char);
4091 }
4092
4093 #if defined (ARRAY_VARS)
4094 /* Identify possible compound array variable assignment. */
4095 else if (character == '=' && token_index > 0)
4096 {
4097 peek_char = shell_getc (1);
4098 if (peek_char == '(') /* ) */
4099 {
4100 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4101 if (ttok == &matched_pair_error)
4102 return -1; /* Bail immediately. */
4103 if (ttok[0] == '(') /* ) */
4104 {
4105 FREE (ttok);
4106 return -1;
4107 }
4108 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4109 token_buffer_size,
4110 TOKEN_DEFAULT_GROW_SIZE);
4111 token[token_index++] = character;
4112 token[token_index++] = peek_char;
4113 strcpy (token + token_index, ttok);
4114 token_index += ttoklen;
4115 FREE (ttok);
4116 all_digits = 0;
4117 goto next_character;
4118 }
4119 else
4120 shell_ungetc (peek_char);
4121 }
4122 #endif
4123
4124 /* When not parsing a multi-character word construct, shell meta-
4125 characters break words. */
4126 if (shellbreak (character))
4127 {
4128 shell_ungetc (character);
4129 goto got_token;
4130 }
4131
4132 got_character:
4133
4134 all_digits &= digit (character);
4135 dollar_present |= character == '$';
4136
4137 if (character == CTLESC || character == CTLNUL)
4138 token[token_index++] = CTLESC;
4139
4140 token[token_index++] = character;
4141
4142 RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
4143 TOKEN_DEFAULT_GROW_SIZE);
4144
4145 next_character:
4146 if (character == '\n' && interactive &&
4147 (bash_input.type == st_stdin || bash_input.type == st_stream))
4148 prompt_again ();
4149
4150 /* We want to remove quoted newlines (that is, a \<newline> pair)
4151 unless we are within single quotes or pass_next_character is
4152 set (the shell equivalent of literal-next). */
4153 cd = current_delimiter (dstack);
4154 character = shell_getc (cd != '\'' && pass_next_character == 0);
4155 } /* end for (;;) */
4156
4157 got_token:
4158
4159 token[token_index] = '\0';
4160
4161 /* Check to see what thing we should return. If the last_read_token
4162 is a `<', or a `&', or the character which ended this token is
4163 a '>' or '<', then, and ONLY then, is this input token a NUMBER.
4164 Otherwise, it is just a word, and should be returned as such. */
4165 if (all_digits && (character == '<' || character == '>' ||
4166 last_read_token == LESS_AND ||
4167 last_read_token == GREATER_AND))
4168 {
4169 yylval.number = atoi (token);
4170 return (NUMBER);
4171 }
4172
4173 /* Check for special case tokens. */
4174 result = special_case_tokens (token);
4175 if (result >= 0)
4176 return result;
4177
4178 #if defined (ALIAS)
4179 /* Posix.2 does not allow reserved words to be aliased, so check for all
4180 of them, including special cases, before expanding the current token
4181 as an alias. */
4182 if (posixly_correct)
4183 CHECK_FOR_RESERVED_WORD (token);
4184
4185 /* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
4186 inhibits alias expansion. */
4187 if (expand_aliases && quoted == 0)
4188 {
4189 result = alias_expand_token (token);
4190 if (result == RE_READ_TOKEN)
4191 return (RE_READ_TOKEN);
4192 else if (result == NO_EXPANSION)
4193 parser_state &= ~PST_ALEXPNEXT;
4194 }
4195
4196 /* If not in Posix.2 mode, check for reserved words after alias
4197 expansion. */
4198 if (posixly_correct == 0)
4199 #endif
4200 CHECK_FOR_RESERVED_WORD (token);
4201
4202 the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
4203 the_word->word = xmalloc (1 + token_index);
4204 the_word->flags = 0;
4205 strcpy (the_word->word, token);
4206 if (dollar_present)
4207 the_word->flags |= W_HASDOLLAR;
4208 if (quoted)
4209 the_word->flags |= W_QUOTED;
4210 /* A word is an assignment if it appears at the beginning of a
4211 simple command, or after another assignment word. This is
4212 context-dependent, so it cannot be handled in the grammar. */
4213 if (assignment (token))
4214 {
4215 the_word->flags |= W_ASSIGNMENT;
4216 /* Don't perform word splitting on assignment statements. */
4217 if (assignment_acceptable (last_read_token))
4218 the_word->flags |= W_NOSPLIT;
4219 }
4220
4221 yylval.word = the_word;
4222
4223 result = ((the_word->flags & (W_ASSIGNMENT|W_NOSPLIT)) == (W_ASSIGNMENT|W_NOSPLIT))
4224 ? ASSIGNMENT_WORD : WORD;
4225
4226 if (last_read_token == FUNCTION)
4227 {
4228 parser_state |= PST_ALLOWOPNBRC;
4229 function_dstart = line_number;
4230 }
4231
4232 return (result);
4233 }
4234
4235 /* $'...' ANSI-C expand the portion of STRING between START and END and
4236 return the result. The result cannot be longer than the input string. */
4237 static char *
4238 ansiexpand (string, start, end, lenp)
4239 char *string;
4240 int start, end, *lenp;
4241 {
4242 char *temp, *t;
4243 int len, tlen;
4244
4245 temp = xmalloc (end - start + 1);
4246 for (tlen = 0, len = start; len < end; )
4247 temp[tlen++] = string[len++];
4248 temp[tlen] = '\0';
4249
4250 if (*temp)
4251 {
4252 t = ansicstr (temp, tlen, (int *)NULL, lenp);
4253 free (temp);
4254 return (t);
4255 }
4256 else
4257 {
4258 if (lenp)
4259 *lenp = 0;
4260 return (temp);
4261 }
4262 }
4263
4264 /* $"..." -- Translate the portion of STRING between START and END
4265 according to current locale using gettext (if available) and return
4266 the result. The caller will take care of leaving the quotes intact.
4267 The string will be left without the leading `$' by the caller.
4268 If translation is performed, the translated string will be double-quoted
4269 by the caller. The length of the translated string is returned in LENP,
4270 if non-null. */
4271 static char *
4272 localeexpand (string, start, end, lineno, lenp)
4273 char *string;
4274 int start, end, lineno, *lenp;
4275 {
4276 int len, tlen;
4277 char *temp, *t;
4278
4279 temp = xmalloc (end - start + 1);
4280 for (tlen = 0, len = start; len < end; )
4281 temp[tlen++] = string[len++];
4282 temp[tlen] = '\0';
4283
4284 /* If we're just dumping translatable strings, don't do anything. */
4285 if (dump_translatable_strings)
4286 {
4287 if (dump_po_strings)
4288 printf ("#: %s:%d\nmsgid \"%s\"\nmsgstr \"\"\n",
4289 (bash_input.name ? bash_input.name : "stdin"), lineno, temp);
4290 else
4291 printf ("\"%s\"\n", temp);
4292 if (lenp)
4293 *lenp = tlen;
4294 return (temp);
4295 }
4296 else if (*temp)
4297 {
4298 t = localetrans (temp, tlen, &len);
4299 free (temp);
4300 if (lenp)
4301 *lenp = len;
4302 return (t);
4303 }
4304 else
4305 {
4306 if (lenp)
4307 *lenp = 0;
4308 return (temp);
4309 }
4310 }
4311
4312 /* Return 1 if TOKEN is a token that after being read would allow
4313 a reserved word to be seen, else 0. */
4314 static int
4315 reserved_word_acceptable (token)
4316 int token;
4317 {
4318 if (token == '\n' || token == ';' || token == '(' || token == ')' ||
4319 token == '|' || token == '&' || token == '{' ||
4320 token == '}' || /* XXX */
4321 token == AND_AND ||
4322 token == BANG ||
4323 token == TIME || token == TIMEOPT ||
4324 token == DO ||
4325 token == ELIF ||
4326 token == ELSE ||
4327 token == FI ||
4328 token == IF ||
4329 token == OR_OR ||
4330 token == SEMI_SEMI ||
4331 token == THEN ||
4332 token == UNTIL ||
4333 token == WHILE ||
4334 token == DONE || /* XXX these two are experimental */
4335 token == ESAC ||
4336 token == 0)
4337 return (1);
4338 else
4339 return (0);
4340 }
4341
4342 /* Return the index of TOKEN in the alist of reserved words, or -1 if
4343 TOKEN is not a shell reserved word. */
4344 int
4345 find_reserved_word (token)
4346 char *token;
4347 {
4348 int i;
4349 for (i = 0; word_token_alist[i].word; i++)
4350 if (STREQ (token, word_token_alist[i].word))
4351 return i;
4352 return -1;
4353 }
4354
4355 #if 0
4356 #if defined (READLINE)
4357 /* Called after each time readline is called. This insures that whatever
4358 the new prompt string is gets propagated to readline's local prompt
4359 variable. */
4360 static void
4361 reset_readline_prompt ()
4362 {
4363 char *temp_prompt;
4364
4365 if (prompt_string_pointer)
4366 {
4367 temp_prompt = (*prompt_string_pointer)
4368 ? decode_prompt_string (*prompt_string_pointer)
4369 : (char *)NULL;
4370
4371 if (temp_prompt == 0)
4372 {
4373 temp_prompt = xmalloc (1);
4374 temp_prompt[0] = '\0';
4375 }
4376
4377 FREE (current_readline_prompt);
4378 current_readline_prompt = temp_prompt;
4379 }
4380 }
4381 #endif /* READLINE */
4382 #endif /* 0 */
4383
4384 #if defined (HISTORY)
4385 /* A list of tokens which can be followed by newlines, but not by
4386 semi-colons. When concatenating multiple lines of history, the
4387 newline separator for such tokens is replaced with a space. */
4388 static int no_semi_successors[] = {
4389 '\n', '{', '(', ')', ';', '&', '|',
4390 CASE, DO, ELSE, IF, SEMI_SEMI, THEN, UNTIL, WHILE, AND_AND, OR_OR, IN,
4391 0
4392 };
4393
4394 /* If we are not within a delimited expression, try to be smart
4395 about which separators can be semi-colons and which must be
4396 newlines. Returns the string that should be added into the
4397 history entry. */
4398 char *
4399 history_delimiting_chars ()
4400 {
4401 register int i;
4402
4403 if (dstack.delimiter_depth != 0)
4404 return ("\n");
4405
4406 /* First, handle some special cases. */
4407 /*(*/
4408 /* If we just read `()', assume it's a function definition, and don't
4409 add a semicolon. If the token before the `)' was not `(', and we're
4410 not in the midst of parsing a case statement, assume it's a
4411 parenthesized command and add the semicolon. */
4412 /*)(*/
4413 if (token_before_that == ')')
4414 {
4415 if (two_tokens_ago == '(') /*)*/ /* function def */
4416 return " ";
4417 /* This does not work for subshells inside case statement
4418 command lists. It's a suboptimal solution. */
4419 else if (parser_state & PST_CASESTMT) /* case statement pattern */
4420 return " ";
4421 else
4422 return "; "; /* (...) subshell */
4423 }
4424 else if (token_before_that == WORD && two_tokens_ago == FUNCTION)
4425 return " "; /* function def using `function name' without `()' */
4426
4427 for (i = 0; no_semi_successors[i]; i++)
4428 {
4429 if (token_before_that == no_semi_successors[i])
4430 return (" ");
4431 }
4432
4433 return ("; ");
4434 }
4435 #endif /* HISTORY */
4436
4437 /* Issue a prompt, or prepare to issue a prompt when the next character
4438 is read. */
4439 static void
4440 prompt_again ()
4441 {
4442 char *temp_prompt;
4443
4444 if (!interactive) /* XXX */
4445 return;
4446
4447 ps1_prompt = get_string_value ("PS1");
4448 ps2_prompt = get_string_value ("PS2");
4449
4450 if (!prompt_string_pointer)
4451 prompt_string_pointer = &ps1_prompt;
4452
4453 temp_prompt = *prompt_string_pointer
4454 ? decode_prompt_string (*prompt_string_pointer)
4455 : (char *)NULL;
4456
4457 if (temp_prompt == 0)
4458 {
4459 temp_prompt = xmalloc (1);
4460 temp_prompt[0] = '\0';
4461 }
4462
4463 current_prompt_string = *prompt_string_pointer;
4464 prompt_string_pointer = &ps2_prompt;
4465
4466 #if defined (READLINE)
4467 if (!no_line_editing)
4468 {
4469 FREE (current_readline_prompt);
4470 current_readline_prompt = temp_prompt;
4471 }
4472 else
4473 #endif /* READLINE */
4474 {
4475 FREE (current_decoded_prompt);
4476 current_decoded_prompt = temp_prompt;
4477 }
4478 }
4479
4480 static void
4481 print_prompt ()
4482 {
4483 fprintf (stderr, "%s", current_decoded_prompt);
4484 fflush (stderr);
4485 }
4486
4487 /* Return a string which will be printed as a prompt. The string
4488 may contain special characters which are decoded as follows:
4489
4490 \a bell (ascii 07)
4491 \e escape (ascii 033)
4492 \d the date in Day Mon Date format
4493 \h the hostname up to the first `.'
4494 \H the hostname
4495 \n CRLF
4496 \s the name of the shell
4497 \t the time in 24-hour hh:mm:ss format
4498 \T the time in 12-hour hh:mm:ss format
4499 \@ the time in 12-hour am/pm format
4500 \v the version of bash (e.g., 2.00)
4501 \V the release of bash, version + patchlevel (e.g., 2.00.0)
4502 \w the current working directory
4503 \W the last element of $PWD
4504 \u your username
4505 \# the command number of this command
4506 \! the history number of this command
4507 \$ a $ or a # if you are root
4508 \nnn character code nnn in octal
4509 \\ a backslash
4510 \[ begin a sequence of non-printing chars
4511 \] end a sequence of non-printing chars
4512 */
4513 #define PROMPT_GROWTH 48
4514 char *
4515 decode_prompt_string (string)
4516 char *string;
4517 {
4518 WORD_LIST *list;
4519 char *result, *t;
4520 struct dstack save_dstack;
4521 #if defined (PROMPT_STRING_DECODE)
4522 int result_size, result_index;
4523 int c, n;
4524 char *temp, octal_string[4];
4525 time_t the_time;
4526
4527 result = xmalloc (result_size = PROMPT_GROWTH);
4528 result[result_index = 0] = 0;
4529 temp = (char *)NULL;
4530
4531 while (c = *string++)
4532 {
4533 if (posixly_correct && c == '!')
4534 {
4535 if (*string == '!')
4536 {
4537 temp = savestring ("!");
4538 goto add_string;
4539 }
4540 else
4541 {
4542 #if !defined (HISTORY)
4543 temp = savestring ("1");
4544 #else /* HISTORY */
4545 temp = itos (history_number ());
4546 #endif /* HISTORY */
4547 string--; /* add_string increments string again. */
4548 goto add_string;
4549 }
4550 }
4551 if (c == '\\')
4552 {
4553 c = *string;
4554
4555 switch (c)
4556 {
4557 case '0':
4558 case '1':
4559 case '2':
4560 case '3':
4561 case '4':
4562 case '5':
4563 case '6':
4564 case '7':
4565 strncpy (octal_string, string, 3);
4566 octal_string[3] = '\0';
4567
4568 n = read_octal (octal_string);
4569 temp = xmalloc (3);
4570
4571 if (n == CTLESC || n == CTLNUL)
4572 {
4573 string += 3;
4574 temp[0] = CTLESC;
4575 temp[1] = n;
4576 temp[2] = '\0';
4577 }
4578 else if (n == -1)
4579 {
4580 temp[0] = '\\';
4581 temp[1] = '\0';
4582 }
4583 else
4584 {
4585 string += 3;
4586 temp[0] = n;
4587 temp[1] = '\0';
4588 }
4589
4590 c = 0;
4591 goto add_string;
4592
4593 case 't':
4594 case 'd':
4595 case 'T':
4596 case '@':
4597 /* Make the current time/date into a string. */
4598 the_time = time (0);
4599 temp = ctime (&the_time);
4600
4601 temp = (c != 'd') ? savestring (temp + 11) : savestring (temp);
4602 temp[(c != 'd') ? 8 : 10] = '\0';
4603
4604 /* quick and dirty conversion to 12-hour time */
4605 if (c == 'T' || c == '@')
4606 {
4607 if (c == '@')
4608 {
4609 temp[5] = 'a'; /* am/pm format */
4610 temp[6] = 'm';
4611 temp[7] = '\0';
4612 }
4613 c = temp[2];
4614 temp[2] = '\0';
4615 n = atoi (temp);
4616 temp[2] = c;
4617 n -= 12;
4618 if (n > 0)
4619 {
4620 temp[0] = (n / 10) + '0';
4621 temp[1] = (n % 10) + '0';
4622 }
4623 if (n >= 0 && temp[5] == 'a')
4624 temp[5] = 'p';
4625 }
4626 goto add_string;
4627
4628 case 'r':
4629 temp = xmalloc (2);
4630 temp[0] = '\r';
4631 temp[1] = '\0';
4632 goto add_string;
4633
4634 case 'n':
4635 temp = xmalloc (3);
4636 temp[0] = no_line_editing ? '\n' : '\r';
4637 temp[1] = no_line_editing ? '\0' : '\n';
4638 temp[2] = '\0';
4639 goto add_string;
4640
4641 case 's':
4642 temp = base_pathname (shell_name);
4643 temp = savestring (temp);
4644 goto add_string;
4645
4646 case 'v':
4647 case 'V':
4648 temp = xmalloc (8);
4649 if (c == 'v')
4650 strcpy (temp, dist_version);
4651 else
4652 sprintf (temp, "%s.%d", dist_version, patch_level);
4653 goto add_string;
4654
4655 case 'w':
4656 case 'W':
4657 {
4658 /* Use the value of PWD because it is much more efficient. */
4659 char t_string[PATH_MAX];
4660 int tlen;
4661
4662 temp = get_string_value ("PWD");
4663
4664 if (temp == 0)
4665 {
4666 if (getcwd (t_string, sizeof(t_string)) == 0)
4667 {
4668 t_string[0] = '.';
4669 tlen = 1;
4670 }
4671 else
4672 tlen = strlen (t_string);
4673 }
4674 else
4675 {
4676 tlen = sizeof (t_string) - 1;
4677 strncpy (t_string, temp, tlen);
4678 }
4679 t_string[tlen] = '\0';
4680
4681 if (c == 'W')
4682 {
4683 t = strrchr (t_string, '/');
4684 if (t && t != t_string)
4685 strcpy (t_string, t + 1);
4686 }
4687 else
4688 /* polite_directory_format is guaranteed to return a string
4689 no longer than PATH_MAX - 1 characters. */
4690 strcpy (t_string, polite_directory_format (t_string));
4691
4692 /* If we're going to be expanding the prompt string later,
4693 quote the directory name. */
4694 if (promptvars || posixly_correct)
4695 temp = backslash_quote (t_string);
4696 else
4697 temp = savestring (t_string);
4698
4699 goto add_string;
4700 }
4701
4702 case 'u':
4703 temp = savestring (current_user.user_name);
4704 goto add_string;
4705
4706 case 'h':
4707 case 'H':
4708 temp = savestring (current_host_name);
4709 if (c == 'h' && (t = (char *)strchr (temp, '.')))
4710 *t = '\0';
4711 goto add_string;
4712
4713 case '#':
4714 temp = itos (current_command_number);
4715 goto add_string;
4716
4717 case '!':
4718 #if !defined (HISTORY)
4719 temp = savestring ("1");
4720 #else /* HISTORY */
4721 temp = itos (history_number ());
4722 #endif /* HISTORY */
4723 goto add_string;
4724
4725 case '$':
4726 t = temp = xmalloc (3);
4727 if ((promptvars || posixly_correct) && (current_user.euid != 0))
4728 *t++ = '\\';
4729 *t++ = current_user.euid == 0 ? '#' : '$';
4730 *t = '\0';
4731 goto add_string;
4732
4733 #if defined (READLINE)
4734 case '[':
4735 case ']':
4736 temp = xmalloc (3);
4737 temp[0] = '\001';
4738 temp[1] = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
4739 temp[2] = '\0';
4740 goto add_string;
4741 #endif /* READLINE */
4742
4743 case '\\':
4744 temp = xmalloc (2);
4745 temp[0] = c;
4746 temp[1] = '\0';
4747 goto add_string;
4748
4749 case 'a':
4750 case 'e':
4751 temp = xmalloc (2);
4752 temp[0] = (c == 'a') ? '\07' : '\033';
4753 temp[1] = '\0';
4754 goto add_string;
4755
4756 default:
4757 temp = xmalloc (3);
4758 temp[0] = '\\';
4759 temp[1] = c;
4760 temp[2] = '\0';
4761
4762 add_string:
4763 if (c)
4764 string++;
4765 result =
4766 sub_append_string (temp, result, &result_index, &result_size);
4767 temp = (char *)NULL; /* Freed in sub_append_string (). */
4768 result[result_index] = '\0';
4769 break;
4770 }
4771 }
4772 else
4773 {
4774 RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, PROMPT_GROWTH);
4775 result[result_index++] = c;
4776 result[result_index] = '\0';
4777 }
4778 }
4779 #else /* !PROMPT_STRING_DECODE */
4780 result = savestring (string);
4781 #endif /* !PROMPT_STRING_DECODE */
4782
4783 /* Save the delimiter stack and point `dstack' to temp space so any
4784 command substitutions in the prompt string won't result in screwing
4785 up the parser's quoting state. */
4786 save_dstack = dstack;
4787 dstack = temp_dstack;
4788 dstack.delimiter_depth = 0;
4789
4790 /* Perform variable and parameter expansion and command substitution on
4791 the prompt string. */
4792 if (promptvars || posixly_correct)
4793 {
4794 list = expand_string_unsplit (result, Q_DOUBLE_QUOTES);
4795 free (result);
4796 result = string_list (list);
4797 dispose_words (list);
4798 }
4799 else
4800 {
4801 t = dequote_string (result);
4802 free (result);
4803 result = t;
4804 }
4805
4806 dstack = save_dstack;
4807
4808 return (result);
4809 }
4810
4811 /* Report a syntax error, and restart the parser. Call here for fatal
4812 errors. */
4813 int
4814 yyerror ()
4815 {
4816 report_syntax_error ((char *)NULL);
4817 reset_parser ();
4818 return (0);
4819 }
4820
4821 /* Report a syntax error with line numbers, etc.
4822 Call here for recoverable errors. If you have a message to print,
4823 then place it in MESSAGE, otherwise pass NULL and this will figure
4824 out an appropriate message for you. */
4825 static void
4826 report_syntax_error (message)
4827 char *message;
4828 {
4829 char *msg, *t;
4830 int token_end, i;
4831 char msg2[2];
4832
4833 if (message)
4834 {
4835 parser_error (line_number, "%s", message);
4836 if (interactive && EOF_Reached)
4837 EOF_Reached = 0;
4838 last_command_exit_value = EX_USAGE;
4839 return;
4840 }
4841
4842 /* If the line of input we're reading is not null, try to find the
4843 objectionable token. */
4844 if (shell_input_line && *shell_input_line)
4845 {
4846 t = shell_input_line;
4847 i = shell_input_line_index;
4848 token_end = 0;
4849
4850 if (i && t[i] == '\0')
4851 i--;
4852
4853 while (i && (whitespace (t[i]) || t[i] == '\n'))
4854 i--;
4855
4856 if (i)
4857 token_end = i + 1;
4858
4859 while (i && (member (t[i], " \n\t;|&") == 0))
4860 i--;
4861
4862 while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
4863 i++;
4864
4865 /* Print the offending token. */
4866 if (token_end || (i == 0 && token_end == 0))
4867 {
4868 if (token_end)
4869 {
4870 msg = xmalloc (1 + (token_end - i));
4871 strncpy (msg, t + i, token_end - i);
4872 msg[token_end - i] = '\0';
4873 }
4874 else /* one-character token */
4875 {
4876 msg2[0] = t[i];
4877 msg2[1] = '\0';
4878 msg = msg2;
4879 }
4880
4881 parser_error (line_number, "syntax error near unexpected token `%s'", msg);
4882
4883 if (msg != msg2)
4884 free (msg);
4885 }
4886
4887 /* If not interactive, print the line containing the error. */
4888 if (interactive == 0)
4889 {
4890 msg = savestring (shell_input_line);
4891 token_end = strlen (msg);
4892 while (token_end && msg[token_end - 1] == '\n')
4893 msg[--token_end] = '\0';
4894
4895 parser_error (line_number, "`%s'", msg);
4896 free (msg);
4897 }
4898 }
4899 else
4900 {
4901 msg = EOF_Reached ? "syntax error: unexpected end of file" : "syntax error";
4902 parser_error (line_number, "%s", msg);
4903 /* When the shell is interactive, this file uses EOF_Reached
4904 only for error reporting. Other mechanisms are used to
4905 decide whether or not to exit. */
4906 if (interactive && EOF_Reached)
4907 EOF_Reached = 0;
4908 }
4909 last_command_exit_value = EX_USAGE;
4910 }
4911
4912 /* ??? Needed function. ??? We have to be able to discard the constructs
4913 created during parsing. In the case of error, we want to return
4914 allocated objects to the memory pool. In the case of no error, we want
4915 to throw away the information about where the allocated objects live.
4916 (dispose_command () will actually free the command. */
4917 static void
4918 discard_parser_constructs (error_p)
4919 int error_p;
4920 {
4921 }
4922
4923 /* Do that silly `type "bye" to exit' stuff. You know, "ignoreeof". */
4924
4925 /* A flag denoting whether or not ignoreeof is set. */
4926 int ignoreeof = 0;
4927
4928 /* The number of times that we have encountered an EOF character without
4929 another character intervening. When this gets above the limit, the
4930 shell terminates. */
4931 int eof_encountered = 0;
4932
4933 /* The limit for eof_encountered. */
4934 int eof_encountered_limit = 10;
4935
4936 /* If we have EOF as the only input unit, this user wants to leave
4937 the shell. If the shell is not interactive, then just leave.
4938 Otherwise, if ignoreeof is set, and we haven't done this the
4939 required number of times in a row, print a message. */
4940 static void
4941 handle_eof_input_unit ()
4942 {
4943 if (interactive)
4944 {
4945 /* shell.c may use this to decide whether or not to write out the
4946 history, among other things. We use it only for error reporting
4947 in this file. */
4948 if (EOF_Reached)
4949 EOF_Reached = 0;
4950
4951 /* If the user wants to "ignore" eof, then let her do so, kind of. */
4952 if (ignoreeof)
4953 {
4954 if (eof_encountered < eof_encountered_limit)
4955 {
4956 fprintf (stderr, "Use \"%s\" to leave the shell.\n",
4957 login_shell ? "logout" : "exit");
4958 eof_encountered++;
4959 /* Reset the prompt string to be $PS1. */
4960 prompt_string_pointer = (char **)NULL;
4961 prompt_again ();
4962 last_read_token = current_token = '\n';
4963 return;
4964 }
4965 }
4966
4967 /* In this case EOF should exit the shell. Do it now. */
4968 reset_parser ();
4969 exit_builtin ((WORD_LIST *)NULL);
4970 }
4971 else
4972 {
4973 /* We don't write history files, etc., for non-interactive shells. */
4974 EOF_Reached = 1;
4975 }
4976 }
Unnamed repository; edit this file 'description' to name the repository.