-
-/* A Bison parser, made from /usr/homes/chet/src/bash/src/parse.y
- by GNU Bison version 1.28 */
+/* A Bison parser, made from /usr/homes/chet/src/bash/src/parse.y
+ by GNU bison 1.34. */
#define YYBISON 1 /* Identify Bison output. */
-#define IF 257
-#define THEN 258
-#define ELSE 259
-#define ELIF 260
-#define FI 261
-#define CASE 262
-#define ESAC 263
-#define FOR 264
-#define SELECT 265
-#define WHILE 266
-#define UNTIL 267
-#define DO 268
-#define DONE 269
-#define FUNCTION 270
-#define COND_START 271
-#define COND_END 272
-#define COND_ERROR 273
-#define IN 274
-#define BANG 275
-#define TIME 276
-#define TIMEOPT 277
-#define WORD 278
-#define ASSIGNMENT_WORD 279
-#define NUMBER 280
-#define ARITH_CMD 281
-#define ARITH_FOR_EXPRS 282
-#define COND_CMD 283
-#define AND_AND 284
-#define OR_OR 285
-#define GREATER_GREATER 286
-#define LESS_LESS 287
-#define LESS_AND 288
-#define GREATER_AND 289
-#define SEMI_SEMI 290
-#define LESS_LESS_MINUS 291
-#define AND_GREATER 292
-#define LESS_GREATER 293
-#define GREATER_BAR 294
-#define yacc_EOF 295
+# define IF 257
+# define THEN 258
+# define ELSE 259
+# define ELIF 260
+# define FI 261
+# define CASE 262
+# define ESAC 263
+# define FOR 264
+# define SELECT 265
+# define WHILE 266
+# define UNTIL 267
+# define DO 268
+# define DONE 269
+# define FUNCTION 270
+# define COND_START 271
+# define COND_END 272
+# define COND_ERROR 273
+# define IN 274
+# define BANG 275
+# define TIME 276
+# define TIMEOPT 277
+# define WORD 278
+# define ASSIGNMENT_WORD 279
+# define NUMBER 280
+# define ARITH_CMD 281
+# define ARITH_FOR_EXPRS 282
+# define COND_CMD 283
+# define AND_AND 284
+# define OR_OR 285
+# define GREATER_GREATER 286
+# define LESS_LESS 287
+# define LESS_AND 288
+# define LESS_LESS_LESS 289
+# define GREATER_AND 290
+# define SEMI_SEMI 291
+# define LESS_LESS_MINUS 292
+# define AND_GREATER 293
+# define LESS_GREATER 294
+# define GREATER_BAR 295
+# define yacc_EOF 296
#line 21 "/usr/homes/chet/src/bash/src/parse.y"
#include "memalloc.h"
+#define NEED_STRFTIME_DECL /* used in externs.h */
+
#include "shell.h"
#include "trap.h"
#include "flags.h"
#include "builtins/common.h"
#include "builtins/builtext.h"
+#include "shmbutil.h"
+
#if defined (READLINE)
# include "bashline.h"
# include <readline/readline.h>
# include <sys/param.h>
# endif
# include <time.h>
+# if defined (TM_IN_SYS_TIME)
+# include <sys/types.h>
+# include <sys/time.h>
+# endif /* TM_IN_SYS_TIME */
# include "maxpath.h"
#endif /* PROMPT_STRING_DECODE */
#define RE_READ_TOKEN -99
#define NO_EXPANSION -100
-#define YYDEBUG 0
+#ifdef DEBUG
+# define YYDEBUG 1
+#else
+# define YYDEBUG 0
+#endif
+
+#if defined (HANDLE_MULTIBYTE)
+# define last_shell_getc_is_singlebyte \
+ ((shell_input_line_index > 1) \
+ ? shell_input_line_property[shell_input_line_index - 1] \
+ : 1)
+# define MBTEST(x) ((x) && last_shell_getc_is_singlebyte)
+#else
+# define last_shell_getc_is_singlebyte 1
+# define MBTEST(x) ((x))
+#endif
#if defined (EXTENDED_GLOB)
extern int extended_glob;
static char *read_a_line __P((int));
-static char *ansiexpand __P((char *, int, int, int *));
-static char *mk_msgstr __P((char *, int *));
-static char *localeexpand __P((char *, int, int, int, int *));
static int reserved_word_acceptable __P((int));
static int yylex __P((void));
static int alias_expand_token __P((char *));
static int special_case_tokens __P((char *));
static int read_token __P((int));
static char *parse_matched_pair __P((int, int, int, int *, int));
+#if defined (ARRAY_VARS)
+static char *parse_compound_assignment __P((int *));
+#endif
#if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
+static int parse_dparen __P((int));
static int parse_arith_cmd __P((char **));
#endif
#if defined (COND_COMMAND)
+static void cond_error __P((void));
static COND_COM *cond_expr __P((void));
static COND_COM *cond_or __P((void));
static COND_COM *cond_and __P((void));
static int cond_skip_newlines __P((void));
static COMMAND *parse_cond_command __P((void));
#endif
+#if defined (ARRAY_VARS)
+static int token_is_assignment __P((char *, int));
+static int token_is_ident __P((char *, int));
+#endif
static int read_token_word __P((int));
static void discard_parser_constructs __P((int));
+static char *error_token_from_token __P((int));
+static char *error_token_from_text __P((void));
+static void print_offending_line __P((void));
static void report_syntax_error __P((char *));
+
static void handle_eof_input_unit __P((void));
static void prompt_again __P((void));
#if 0
char *history_delimiting_chars __P((void));
#endif
+#if defined (HANDLE_MULTIBYTE)
+static void set_line_mbstate __P((void));
+static char *shell_input_line_property = NULL;
+#else
+# define set_line_mbstate()
+#endif
+
extern int yyerror __P((const char *));
+#ifdef DEBUG
+extern int yydebug;
+#endif
+
/* Default prompt strings */
char *primary_prompt = PPROMPT;
char *secondary_prompt = SPROMPT;
static REDIRECTEE redir;
-#line 232 "/usr/homes/chet/src/bash/src/parse.y"
+#line 276 "/usr/homes/chet/src/bash/src/parse.y"
+#ifndef YYSTYPE
typedef union {
WORD_DESC *word; /* the word that we read. */
int number; /* the number that we read. */
REDIRECT *redirect;
ELEMENT element;
PATTERN_LIST *pattern;
-} YYSTYPE;
-#include <stdio.h>
-
-#ifndef __cplusplus
-#ifndef __STDC__
-#define const
+} yystype;
+# define YYSTYPE yystype
#endif
+#ifndef YYDEBUG
+# define YYDEBUG 0
#endif
-#define YYFINAL 295
+#define YYFINAL 301
#define YYFLAG -32768
-#define YYNTBASE 53
-
-#define YYTRANSLATE(x) ((unsigned)(x) <= 295 ? yytranslate[x] : 88)
-
-static const char yytranslate[] = { 0,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 43,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 41, 2, 51,
- 52, 2, 2, 2, 48, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 42, 47,
- 2, 46, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 49, 45, 50, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
- 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
- 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
- 37, 38, 39, 40, 44
-};
+#define YYNTBASE 54
-#if YYDEBUG != 0
-static const short yyprhs[] = { 0,
- 0, 3, 5, 8, 10, 12, 15, 18, 21, 25,
- 29, 32, 36, 39, 43, 46, 50, 53, 57, 60,
- 64, 67, 71, 74, 78, 81, 85, 88, 92, 95,
- 99, 102, 105, 109, 111, 113, 115, 117, 120, 122,
- 125, 127, 129, 132, 134, 136, 138, 144, 150, 152,
- 154, 156, 158, 160, 162, 164, 171, 178, 186, 194,
- 205, 216, 226, 236, 244, 252, 258, 264, 271, 278,
- 286, 294, 305, 316, 323, 331, 338, 344, 351, 356,
- 358, 361, 365, 371, 379, 386, 390, 392, 396, 401,
- 408, 414, 416, 419, 424, 429, 435, 441, 444, 448,
- 450, 454, 457, 459, 462, 466, 470, 474, 479, 484,
- 489, 494, 499, 501, 503, 505, 507, 508, 511, 513,
- 516, 519, 524, 529, 533, 537, 539, 541, 544, 547,
- 551, 555, 560, 562, 564
+/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
+#define YYTRANSLATE(x) ((unsigned)(x) <= 296 ? yytranslate[x] : 90)
+
+/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
+static const char yytranslate[] =
+{
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 44, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 42, 2,
+ 52, 53, 2, 2, 2, 49, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 43,
+ 48, 2, 47, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 50, 46, 51, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 1, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 40, 41, 45
};
-static const short yyrhs[] = { 83,
- 43, 0, 43, 0, 1, 43, 0, 44, 0, 24,
- 0, 54, 24, 0, 46, 24, 0, 47, 24, 0,
- 26, 46, 24, 0, 26, 47, 24, 0, 32, 24,
- 0, 26, 32, 24, 0, 33, 24, 0, 26, 33,
- 24, 0, 34, 26, 0, 26, 34, 26, 0, 35,
- 26, 0, 26, 35, 26, 0, 34, 24, 0, 26,
- 34, 24, 0, 35, 24, 0, 26, 35, 24, 0,
- 37, 24, 0, 26, 37, 24, 0, 35, 48, 0,
- 26, 35, 48, 0, 34, 48, 0, 26, 34, 48,
- 0, 38, 24, 0, 26, 39, 24, 0, 39, 24,
- 0, 40, 24, 0, 26, 40, 24, 0, 24, 0,
- 25, 0, 55, 0, 55, 0, 57, 55, 0, 56,
- 0, 58, 56, 0, 58, 0, 60, 0, 60, 57,
- 0, 65, 0, 61, 0, 64, 0, 12, 78, 14,
- 78, 15, 0, 13, 78, 14, 78, 15, 0, 63,
- 0, 68, 0, 67, 0, 69, 0, 70, 0, 71,
- 0, 62, 0, 10, 24, 82, 14, 78, 15, 0,
- 10, 24, 82, 49, 78, 50, 0, 10, 24, 42,
- 82, 14, 78, 15, 0, 10, 24, 42, 82, 49,
- 78, 50, 0, 10, 24, 82, 20, 54, 81, 82,
- 14, 78, 15, 0, 10, 24, 82, 20, 54, 81,
- 82, 49, 78, 50, 0, 10, 24, 82, 20, 81,
- 82, 14, 78, 15, 0, 10, 24, 82, 20, 81,
- 82, 49, 78, 50, 0, 10, 28, 81, 82, 14,
- 78, 15, 0, 10, 28, 81, 82, 49, 78, 50,
- 0, 10, 28, 14, 78, 15, 0, 10, 28, 49,
- 78, 50, 0, 11, 24, 82, 14, 77, 15, 0,
- 11, 24, 82, 49, 77, 50, 0, 11, 24, 42,
- 82, 14, 77, 15, 0, 11, 24, 42, 82, 49,
- 77, 50, 0, 11, 24, 82, 20, 54, 81, 82,
- 14, 77, 15, 0, 11, 24, 82, 20, 54, 81,
- 82, 49, 77, 50, 0, 8, 24, 82, 20, 82,
- 9, 0, 8, 24, 82, 20, 75, 82, 9, 0,
- 8, 24, 82, 20, 73, 9, 0, 24, 51, 52,
- 82, 66, 0, 16, 24, 51, 52, 82, 66, 0,
- 16, 24, 82, 66, 0, 60, 0, 60, 57, 0,
- 51, 78, 52, 0, 3, 78, 4, 78, 7, 0,
- 3, 78, 4, 78, 5, 78, 7, 0, 3, 78,
- 4, 78, 72, 7, 0, 49, 78, 50, 0, 27,
- 0, 17, 29, 18, 0, 6, 78, 4, 78, 0,
- 6, 78, 4, 78, 5, 78, 0, 6, 78, 4,
- 78, 72, 0, 74, 0, 75, 74, 0, 82, 76,
- 52, 78, 0, 82, 76, 52, 82, 0, 82, 51,
- 76, 52, 78, 0, 82, 51, 76, 52, 82, 0,
- 74, 36, 0, 75, 74, 36, 0, 24, 0, 76,
- 45, 24, 0, 82, 79, 0, 77, 0, 82, 80,
- 0, 80, 43, 82, 0, 80, 41, 82, 0, 80,
- 42, 82, 0, 80, 30, 82, 80, 0, 80, 31,
- 82, 80, 0, 80, 41, 82, 80, 0, 80, 42,
- 82, 80, 0, 80, 43, 82, 80, 0, 85, 0,
- 43, 0, 42, 0, 44, 0, 0, 82, 43, 0,
- 84, 0, 84, 41, 0, 84, 42, 0, 84, 30,
- 82, 84, 0, 84, 31, 82, 84, 0, 84, 41,
- 84, 0, 84, 42, 84, 0, 85, 0, 86, 0,
- 21, 86, 0, 87, 86, 0, 87, 21, 86, 0,
- 21, 87, 86, 0, 86, 45, 82, 86, 0, 59,
- 0, 22, 0, 22, 23, 0
+#if YYDEBUG
+static const short yyprhs[] =
+{
+ 0, 0, 3, 5, 8, 10, 12, 15, 18, 21,
+ 25, 29, 32, 36, 39, 43, 46, 50, 53, 57,
+ 60, 64, 67, 71, 74, 78, 81, 85, 88, 92,
+ 95, 99, 102, 106, 109, 112, 116, 118, 120, 122,
+ 124, 127, 129, 132, 134, 136, 139, 141, 143, 145,
+ 151, 157, 159, 161, 163, 165, 167, 169, 171, 178,
+ 185, 193, 201, 212, 223, 233, 243, 251, 259, 265,
+ 271, 278, 285, 293, 301, 312, 323, 330, 338, 345,
+ 351, 358, 363, 365, 368, 372, 378, 386, 393, 397,
+ 399, 403, 408, 415, 421, 423, 426, 431, 436, 442,
+ 448, 451, 455, 457, 461, 464, 466, 469, 473, 477,
+ 481, 486, 491, 496, 501, 506, 508, 510, 512, 514,
+ 516, 518, 519, 522, 524, 527, 530, 535, 540, 544,
+ 548, 550, 552, 555, 558, 562, 566, 571, 573, 575
+};
+static const short yyrhs[] =
+{
+ 85, 82, 0, 44, 0, 1, 44, 0, 45, 0,
+ 24, 0, 55, 24, 0, 47, 24, 0, 48, 24,
+ 0, 26, 47, 24, 0, 26, 48, 24, 0, 32,
+ 24, 0, 26, 32, 24, 0, 33, 24, 0, 26,
+ 33, 24, 0, 35, 24, 0, 26, 35, 24, 0,
+ 34, 26, 0, 26, 34, 26, 0, 36, 26, 0,
+ 26, 36, 26, 0, 34, 24, 0, 26, 34, 24,
+ 0, 36, 24, 0, 26, 36, 24, 0, 38, 24,
+ 0, 26, 38, 24, 0, 36, 49, 0, 26, 36,
+ 49, 0, 34, 49, 0, 26, 34, 49, 0, 39,
+ 24, 0, 26, 40, 24, 0, 40, 24, 0, 41,
+ 24, 0, 26, 41, 24, 0, 24, 0, 25, 0,
+ 56, 0, 56, 0, 58, 56, 0, 57, 0, 59,
+ 57, 0, 59, 0, 61, 0, 61, 58, 0, 66,
+ 0, 62, 0, 65, 0, 12, 79, 14, 79, 15,
+ 0, 13, 79, 14, 79, 15, 0, 64, 0, 69,
+ 0, 68, 0, 70, 0, 71, 0, 72, 0, 63,
+ 0, 10, 24, 84, 14, 79, 15, 0, 10, 24,
+ 84, 50, 79, 51, 0, 10, 24, 43, 84, 14,
+ 79, 15, 0, 10, 24, 43, 84, 50, 79, 51,
+ 0, 10, 24, 84, 20, 55, 83, 84, 14, 79,
+ 15, 0, 10, 24, 84, 20, 55, 83, 84, 50,
+ 79, 51, 0, 10, 24, 84, 20, 83, 84, 14,
+ 79, 15, 0, 10, 24, 84, 20, 83, 84, 50,
+ 79, 51, 0, 10, 28, 83, 84, 14, 79, 15,
+ 0, 10, 28, 83, 84, 50, 79, 51, 0, 10,
+ 28, 14, 79, 15, 0, 10, 28, 50, 79, 51,
+ 0, 11, 24, 84, 14, 78, 15, 0, 11, 24,
+ 84, 50, 78, 51, 0, 11, 24, 43, 84, 14,
+ 78, 15, 0, 11, 24, 43, 84, 50, 78, 51,
+ 0, 11, 24, 84, 20, 55, 83, 84, 14, 78,
+ 15, 0, 11, 24, 84, 20, 55, 83, 84, 50,
+ 78, 51, 0, 8, 24, 84, 20, 84, 9, 0,
+ 8, 24, 84, 20, 76, 84, 9, 0, 8, 24,
+ 84, 20, 74, 9, 0, 24, 52, 53, 84, 67,
+ 0, 16, 24, 52, 53, 84, 67, 0, 16, 24,
+ 84, 67, 0, 61, 0, 61, 58, 0, 52, 79,
+ 53, 0, 3, 79, 4, 79, 7, 0, 3, 79,
+ 4, 79, 5, 79, 7, 0, 3, 79, 4, 79,
+ 73, 7, 0, 50, 79, 51, 0, 27, 0, 17,
+ 29, 18, 0, 6, 79, 4, 79, 0, 6, 79,
+ 4, 79, 5, 79, 0, 6, 79, 4, 79, 73,
+ 0, 75, 0, 76, 75, 0, 84, 77, 53, 79,
+ 0, 84, 77, 53, 84, 0, 84, 52, 77, 53,
+ 79, 0, 84, 52, 77, 53, 84, 0, 75, 37,
+ 0, 76, 75, 37, 0, 24, 0, 77, 46, 24,
+ 0, 84, 80, 0, 78, 0, 84, 81, 0, 81,
+ 44, 84, 0, 81, 42, 84, 0, 81, 43, 84,
+ 0, 81, 30, 84, 81, 0, 81, 31, 84, 81,
+ 0, 81, 42, 84, 81, 0, 81, 43, 84, 81,
+ 0, 81, 44, 84, 81, 0, 87, 0, 44, 0,
+ 45, 0, 44, 0, 43, 0, 45, 0, 0, 84,
+ 44, 0, 86, 0, 86, 42, 0, 86, 43, 0,
+ 86, 30, 84, 86, 0, 86, 31, 84, 86, 0,
+ 86, 42, 86, 0, 86, 43, 86, 0, 87, 0,
+ 88, 0, 21, 88, 0, 89, 88, 0, 89, 21,
+ 88, 0, 21, 89, 88, 0, 88, 46, 84, 88,
+ 0, 60, 0, 22, 0, 22, 23, 0
};
#endif
-#if YYDEBUG != 0
-static const short yyrline[] = { 0,
- 282, 291, 298, 313, 323, 325, 329, 334, 339, 344,
- 349, 354, 359, 365, 371, 376, 381, 386, 391, 396,
- 401, 406, 411, 418, 425, 430, 435, 440, 445, 450,
- 455, 460, 465, 472, 474, 476, 480, 484, 495, 497,
- 501, 503, 505, 521, 525, 527, 529, 531, 533, 535,
- 537, 539, 541, 543, 545, 549, 551, 553, 555, 557,
- 559, 561, 563, 567, 569, 571, 573, 577, 581, 585,
- 589, 593, 597, 603, 605, 607, 611, 614, 617, 622,
- 624, 655, 662, 664, 666, 671, 675, 679, 683, 685,
- 687, 691, 692, 696, 698, 700, 702, 706, 707, 711,
- 713, 722, 730, 731, 737, 738, 745, 749, 751, 753,
- 760, 762, 764, 768, 769, 770, 773, 774, 783, 789,
- 798, 806, 808, 810, 817, 820, 824, 826, 831, 836,
- 841, 848, 851, 855, 857
+#if YYDEBUG
+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
+static const short yyrline[] =
+{
+ 0, 326, 335, 342, 357, 367, 369, 373, 378, 383,
+ 388, 393, 398, 403, 409, 415, 420, 425, 430, 435,
+ 440, 445, 450, 455, 460, 465, 472, 479, 484, 489,
+ 494, 499, 504, 509, 514, 519, 526, 528, 530, 534,
+ 538, 549, 551, 555, 557, 559, 575, 579, 581, 583,
+ 585, 587, 589, 591, 593, 595, 597, 599, 603, 605,
+ 607, 609, 611, 613, 615, 617, 621, 623, 625, 627,
+ 631, 635, 639, 643, 647, 651, 657, 659, 661, 665,
+ 668, 671, 676, 678, 709, 716, 718, 720, 725, 729,
+ 733, 737, 739, 741, 745, 746, 750, 752, 754, 756,
+ 760, 761, 765, 767, 776, 784, 785, 791, 792, 799,
+ 803, 805, 807, 814, 816, 818, 822, 823, 826, 827,
+ 828, 831, 832, 841, 847, 856, 864, 866, 868, 875,
+ 878, 882, 884, 889, 894, 899, 906, 909, 913, 915
};
#endif
-#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
-
-static const char * const yytname[] = { "$","error","$undefined.","IF","THEN",
-"ELSE","ELIF","FI","CASE","ESAC","FOR","SELECT","WHILE","UNTIL","DO","DONE",
-"FUNCTION","COND_START","COND_END","COND_ERROR","IN","BANG","TIME","TIMEOPT",
-"WORD","ASSIGNMENT_WORD","NUMBER","ARITH_CMD","ARITH_FOR_EXPRS","COND_CMD","AND_AND",
-"OR_OR","GREATER_GREATER","LESS_LESS","LESS_AND","GREATER_AND","SEMI_SEMI","LESS_LESS_MINUS",
-"AND_GREATER","LESS_GREATER","GREATER_BAR","'&'","';'","'\\n'","yacc_EOF","'|'",
-"'>'","'<'","'-'","'{'","'}'","'('","')'","inputunit","word_list","redirection",
-"simple_command_element","redirection_list","simple_command","command","shell_command",
-"for_command","arith_for_command","select_command","case_command","function_def",
-"function_body","subshell","if_command","group_command","arith_command","cond_command",
-"elif_clause","case_clause","pattern_list","case_clause_sequence","pattern",
-"list","compound_list","list0","list1","list_terminator","newline_list","simple_list",
-"simple_list1","pipeline_command","pipeline","timespec", NULL
+#if (YYDEBUG) || defined YYERROR_VERBOSE
+
+/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
+static const char *const yytname[] =
+{
+ "$", "error", "$undefined.", "IF", "THEN", "ELSE", "ELIF", "FI", "CASE",
+ "ESAC", "FOR", "SELECT", "WHILE", "UNTIL", "DO", "DONE", "FUNCTION",
+ "COND_START", "COND_END", "COND_ERROR", "IN", "BANG", "TIME", "TIMEOPT",
+ "WORD", "ASSIGNMENT_WORD", "NUMBER", "ARITH_CMD", "ARITH_FOR_EXPRS",
+ "COND_CMD", "AND_AND", "OR_OR", "GREATER_GREATER", "LESS_LESS",
+ "LESS_AND", "LESS_LESS_LESS", "GREATER_AND", "SEMI_SEMI",
+ "LESS_LESS_MINUS", "AND_GREATER", "LESS_GREATER", "GREATER_BAR", "'&'",
+ "';'", "'\\n'", "yacc_EOF", "'|'", "'>'", "'<'", "'-'", "'{'", "'}'",
+ "'('", "')'", "inputunit", "word_list", "redirection",
+ "simple_command_element", "redirection_list", "simple_command",
+ "command", "shell_command", "for_command", "arith_for_command",
+ "select_command", "case_command", "function_def", "function_body",
+ "subshell", "if_command", "group_command", "arith_command",
+ "cond_command", "elif_clause", "case_clause", "pattern_list",
+ "case_clause_sequence", "pattern", "list", "compound_list", "list0",
+ "list1", "simple_list_terminator", "list_terminator", "newline_list",
+ "simple_list", "simple_list1", "pipeline_command", "pipeline",
+ "timespec", 0
};
#endif
-static const short yyr1[] = { 0,
- 53, 53, 53, 53, 54, 54, 55, 55, 55, 55,
- 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
- 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
- 55, 55, 55, 56, 56, 56, 57, 57, 58, 58,
- 59, 59, 59, 59, 60, 60, 60, 60, 60, 60,
- 60, 60, 60, 60, 60, 61, 61, 61, 61, 61,
- 61, 61, 61, 62, 62, 62, 62, 63, 63, 63,
- 63, 63, 63, 64, 64, 64, 65, 65, 65, 66,
- 66, 67, 68, 68, 68, 69, 70, 71, 72, 72,
- 72, 73, 73, 74, 74, 74, 74, 75, 75, 76,
- 76, 77, 78, 78, 79, 79, 79, 80, 80, 80,
- 80, 80, 80, 81, 81, 81, 82, 82, 83, 83,
- 83, 84, 84, 84, 84, 84, 85, 85, 85, 85,
- 85, 86, 86, 87, 87
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const short yyr1[] =
+{
+ 0, 54, 54, 54, 54, 55, 55, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 56, 56, 56, 56,
+ 56, 56, 56, 56, 56, 56, 57, 57, 57, 58,
+ 58, 59, 59, 60, 60, 60, 60, 61, 61, 61,
+ 61, 61, 61, 61, 61, 61, 61, 61, 62, 62,
+ 62, 62, 62, 62, 62, 62, 63, 63, 63, 63,
+ 64, 64, 64, 64, 64, 64, 65, 65, 65, 66,
+ 66, 66, 67, 67, 68, 69, 69, 69, 70, 71,
+ 72, 73, 73, 73, 74, 74, 75, 75, 75, 75,
+ 76, 76, 77, 77, 78, 79, 79, 80, 80, 80,
+ 81, 81, 81, 81, 81, 81, 82, 82, 83, 83,
+ 83, 84, 84, 85, 85, 85, 86, 86, 86, 86,
+ 86, 87, 87, 87, 87, 87, 88, 88, 89, 89
};
-static const short yyr2[] = { 0,
- 2, 1, 2, 1, 1, 2, 2, 2, 3, 3,
- 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
- 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
- 2, 2, 3, 1, 1, 1, 1, 2, 1, 2,
- 1, 1, 2, 1, 1, 1, 5, 5, 1, 1,
- 1, 1, 1, 1, 1, 6, 6, 7, 7, 10,
- 10, 9, 9, 7, 7, 5, 5, 6, 6, 7,
- 7, 10, 10, 6, 7, 6, 5, 6, 4, 1,
- 2, 3, 5, 7, 6, 3, 1, 3, 4, 6,
- 5, 1, 2, 4, 4, 5, 5, 2, 3, 1,
- 3, 2, 1, 2, 3, 3, 3, 4, 4, 4,
- 4, 4, 1, 1, 1, 1, 0, 2, 1, 2,
- 2, 4, 4, 3, 3, 1, 1, 2, 2, 3,
- 3, 4, 1, 1, 2
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
+static const short yyr2[] =
+{
+ 0, 2, 1, 2, 1, 1, 2, 2, 2, 3,
+ 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
+ 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
+ 3, 2, 3, 2, 2, 3, 1, 1, 1, 1,
+ 2, 1, 2, 1, 1, 2, 1, 1, 1, 5,
+ 5, 1, 1, 1, 1, 1, 1, 1, 6, 6,
+ 7, 7, 10, 10, 9, 9, 7, 7, 5, 5,
+ 6, 6, 7, 7, 10, 10, 6, 7, 6, 5,
+ 6, 4, 1, 2, 3, 5, 7, 6, 3, 1,
+ 3, 4, 6, 5, 1, 2, 4, 4, 5, 5,
+ 2, 3, 1, 3, 2, 1, 2, 3, 3, 3,
+ 4, 4, 4, 4, 4, 1, 1, 1, 1, 1,
+ 1, 0, 2, 1, 2, 2, 4, 4, 3, 3,
+ 1, 1, 2, 2, 3, 3, 4, 1, 1, 2
};
-static const short yydefact[] = { 0,
- 0, 117, 0, 0, 0, 117, 117, 0, 0, 0,
- 134, 34, 35, 0, 87, 0, 0, 0, 0, 0,
- 0, 0, 0, 2, 4, 0, 0, 117, 117, 36,
- 39, 41, 133, 42, 45, 55, 49, 46, 44, 51,
- 50, 52, 53, 54, 0, 119, 126, 127, 0, 3,
- 103, 0, 0, 117, 117, 0, 117, 0, 0, 117,
- 0, 128, 0, 135, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 11, 13, 19, 15, 27, 21,
- 17, 25, 23, 29, 31, 32, 7, 8, 0, 0,
- 34, 40, 37, 43, 1, 117, 117, 120, 121, 117,
- 0, 129, 117, 118, 102, 104, 113, 0, 117, 0,
- 117, 115, 114, 116, 117, 117, 117, 0, 117, 117,
- 0, 0, 88, 131, 117, 12, 14, 20, 16, 28,
- 22, 18, 26, 24, 30, 33, 9, 10, 86, 82,
- 38, 0, 0, 124, 125, 0, 130, 0, 117, 117,
- 117, 117, 117, 117, 0, 117, 0, 117, 0, 0,
- 0, 0, 117, 0, 117, 0, 0, 117, 80, 79,
- 0, 122, 123, 0, 0, 132, 117, 117, 83, 0,
- 0, 0, 106, 107, 105, 0, 92, 117, 0, 117,
- 117, 0, 5, 0, 117, 0, 66, 67, 117, 117,
- 117, 117, 0, 0, 0, 0, 47, 48, 0, 81,
- 77, 0, 0, 85, 108, 109, 110, 111, 112, 76,
- 98, 93, 0, 74, 100, 0, 0, 0, 0, 56,
- 6, 117, 0, 57, 0, 0, 0, 0, 68, 0,
- 117, 69, 78, 84, 117, 117, 117, 117, 99, 75,
- 0, 0, 117, 58, 59, 0, 117, 117, 64, 65,
- 70, 71, 0, 89, 0, 0, 0, 117, 101, 94,
- 95, 117, 117, 0, 0, 117, 117, 117, 91, 96,
- 97, 0, 0, 62, 63, 0, 0, 90, 60, 61,
- 72, 73, 0, 0, 0
+/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
+ doesn't specify something else to do. Zero means the default is an
+ error. */
+static const short yydefact[] =
+{
+ 0, 0, 121, 0, 0, 0, 121, 121, 0, 0,
+ 0, 138, 36, 37, 0, 89, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 2, 4, 0, 0, 121,
+ 121, 38, 41, 43, 137, 44, 47, 57, 51, 48,
+ 46, 53, 52, 54, 55, 56, 0, 123, 130, 131,
+ 0, 3, 105, 0, 0, 121, 121, 0, 121, 0,
+ 0, 121, 0, 132, 0, 139, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 11, 13, 21,
+ 17, 29, 15, 23, 19, 27, 25, 31, 33, 34,
+ 7, 8, 0, 0, 36, 42, 39, 45, 116, 117,
+ 1, 121, 121, 124, 125, 121, 0, 133, 121, 122,
+ 104, 106, 115, 0, 121, 0, 121, 119, 118, 120,
+ 121, 121, 121, 0, 121, 121, 0, 0, 90, 135,
+ 121, 12, 14, 22, 18, 30, 16, 24, 20, 28,
+ 26, 32, 35, 9, 10, 88, 84, 40, 0, 0,
+ 128, 129, 0, 134, 0, 121, 121, 121, 121, 121,
+ 121, 0, 121, 0, 121, 0, 0, 0, 0, 121,
+ 0, 121, 0, 0, 121, 82, 81, 0, 126, 127,
+ 0, 0, 136, 121, 121, 85, 0, 0, 0, 108,
+ 109, 107, 0, 94, 121, 0, 121, 121, 0, 5,
+ 0, 121, 0, 68, 69, 121, 121, 121, 121, 0,
+ 0, 0, 0, 49, 50, 0, 83, 79, 0, 0,
+ 87, 110, 111, 112, 113, 114, 78, 100, 95, 0,
+ 76, 102, 0, 0, 0, 0, 58, 6, 121, 0,
+ 59, 0, 0, 0, 0, 70, 0, 121, 71, 80,
+ 86, 121, 121, 121, 121, 101, 77, 0, 0, 121,
+ 60, 61, 0, 121, 121, 66, 67, 72, 73, 0,
+ 91, 0, 0, 0, 121, 103, 96, 97, 121, 121,
+ 0, 0, 121, 121, 121, 93, 98, 99, 0, 0,
+ 64, 65, 0, 0, 92, 62, 63, 74, 75, 0,
+ 0, 0
};
-static const short yydefgoto[] = { 293,
- 194, 30, 31, 94, 32, 33, 34, 35, 36, 37,
- 38, 39, 170, 40, 41, 42, 43, 44, 180, 186,
- 187, 188, 227, 51, 52, 105, 106, 116, 53, 45,
- 144, 107, 48, 49
+static const short yydefgoto[] =
+{
+ 299, 200, 31, 32, 97, 33, 34, 35, 36, 37,
+ 38, 39, 40, 176, 41, 42, 43, 44, 45, 186,
+ 192, 193, 194, 233, 52, 53, 110, 111, 100, 121,
+ 54, 46, 150, 112, 49, 50
};
-static const short yypact[] = { 267,
- -30,-32768, 2, 1, 7,-32768,-32768, 13, 25, 393,
- 17, 29,-32768, 557,-32768, 44, 47, 48, 82, 61,
- 78, 83, 105,-32768,-32768, 111, 125,-32768,-32768,-32768,
--32768, 178,-32768, 541,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768, 50, 34,-32768, 113, 435,-32768,
--32768, 155, 309,-32768, 118, 35, 120, 150, 151, 115,
- 149, 113, 519,-32768, 117, 146, 152, 107, 108, 153,
- 159, 164, 171, 173,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 123, 156,
--32768,-32768,-32768, 541,-32768,-32768,-32768, 351, 351,-32768,
- 519, 113,-32768,-32768,-32768, 201,-32768, 0,-32768, 72,
--32768,-32768,-32768,-32768,-32768,-32768,-32768, 97,-32768,-32768,
- 175, 179,-32768, 113,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
--32768, 309, 309, 4, 4, 477, 113, 137,-32768,-32768,
--32768,-32768,-32768,-32768, -2,-32768, 157,-32768, 183, 184,
- 18, 38,-32768, 185,-32768, 192, 208,-32768, 541,-32768,
- 179,-32768,-32768, 351, 351, 113,-32768,-32768,-32768, 222,
- 309, 309, 309, 309, 309, 224, 200,-32768, 12,-32768,
--32768, 223,-32768, 211,-32768, 187,-32768,-32768,-32768,-32768,
--32768,-32768, 225, 309, 211, 195,-32768,-32768, 179, 541,
--32768, 239, 244,-32768,-32768,-32768, 20, 20, 20,-32768,
--32768, 220, 15,-32768,-32768, 233, -38, 243, 209,-32768,
--32768,-32768, 69,-32768, 245, 213, 246, 214,-32768, 201,
--32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
- 43, 241,-32768,-32768,-32768, 102,-32768,-32768,-32768,-32768,
--32768,-32768, 114, 54, 309, 309, 309,-32768,-32768,-32768,
- 309,-32768,-32768, 254, 221,-32768,-32768,-32768,-32768,-32768,
- 309, 258, 226,-32768,-32768, 259, 231,-32768,-32768,-32768,
--32768,-32768, 282, 285,-32768
+static const short yypact[] =
+{
+ 273, -24,-32768, -2, 11, 6,-32768,-32768, 12, 9,
+ 402, 41, 10,-32768, 552,-32768, 46, 52, -5, 58,
+ 64, 68, 102, 117, 135,-32768,-32768, 146, 149,-32768,
+ -32768,-32768,-32768, 169,-32768, 202,-32768,-32768,-32768,-32768,
+ -32768,-32768,-32768,-32768,-32768,-32768, -33, 42,-32768, 91,
+ 445,-32768,-32768, 142, 316,-32768, 133, 72, 136, 172,
+ 174, 97, 171, 91, 531,-32768, 139, 173, 182, 99,
+ 188, 138, 189, 190, 191, 194, 195,-32768,-32768,-32768,
+ -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+ -32768,-32768, 145, 168,-32768,-32768,-32768, 202,-32768,-32768,
+ -32768,-32768,-32768, 359, 359,-32768, 531, 91,-32768,-32768,
+ -32768, 249,-32768, -12,-32768, 13,-32768,-32768,-32768,-32768,
+ -32768,-32768,-32768, 57,-32768,-32768, 170, 39,-32768, 91,
+ -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+ -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 316, 316,
+ 28, 28, 488, 91, 74,-32768,-32768,-32768,-32768,-32768,
+ -32768, 90,-32768, 220,-32768, 183, 178, 110, 113,-32768,
+ 198,-32768, 209, 215,-32768, 202,-32768, 39,-32768,-32768,
+ 359, 359, 91,-32768,-32768,-32768, 224, 316, 316, 316,
+ 316, 316, 230, 196,-32768, 16,-32768,-32768, 231,-32768,
+ 258,-32768, 197,-32768,-32768,-32768,-32768,-32768,-32768, 236,
+ 316, 258, 201,-32768,-32768, 39, 202,-32768, 247, 255,
+ -32768,-32768,-32768, 66, 66, 66,-32768,-32768, 223, 17,
+ -32768,-32768, 237, 92, 251, 211,-32768,-32768,-32768, 121,
+ -32768, 252, 218, 256, 219,-32768, 249,-32768,-32768,-32768,
+ -32768,-32768,-32768,-32768,-32768,-32768,-32768, 115, 253,-32768,
+ -32768,-32768, 122,-32768,-32768,-32768,-32768,-32768,-32768, 125,
+ 106, 316, 316, 316,-32768,-32768,-32768, 316,-32768,-32768,
+ 260, 245,-32768,-32768,-32768,-32768,-32768, 316, 272, 259,
+ -32768,-32768, 289, 264,-32768,-32768,-32768,-32768,-32768, 288,
+ 322,-32768
};
-static const short yypgoto[] = {-32768,
- 122, -32, 255, 121,-32768,-32768, -118,-32768,-32768,-32768,
--32768,-32768, -161,-32768,-32768,-32768,-32768,-32768, 31,-32768,
- 109,-32768, 70, -157, -6,-32768, -166, -148, -27,-32768,
- 11, 5, -7, 288
+static const short yypgoto[] =
+{
+ -32768, 160, -32, 283, 156,-32768,-32768, -122,-32768,-32768,
+ -32768,-32768,-32768, -167,-32768,-32768,-32768,-32768,-32768, 65,
+ -32768, 140,-32768, 104, -162, -6,-32768, -173,-32768, -157,
+ -27,-32768, 4, 2, 3, 329
};
-#define YYLAST 604
-
-
-static const short yytable[] = { 58,
- 59, 93, 62, 169, 47, 203, 252, 206, 195, 211,
- 46, 190, 50, 253, 215, 216, 217, 218, 219, 154,
- 224, 89, 90, 250, 55, 54, 108, 110, 56, 118,
- 57, 199, 122, 96, 97, 225, 60, 240, 225, 64,
- 104, 102, 104, 237, 238, 232, 191, 243, 111, 149,
- 150, 201, 169, 61, 104, 124, 241, 104, 278, 178,
- 104, 141, 226, 96, 97, 226, 200, 75, 142, 143,
- 76, 77, 146, 78, 98, 99, 112, 113, 114, 65,
- 104, 155, 257, 115, 83, 156, 202, 252, 161, 162,
- 169, 157, 95, 147, 268, 79, 148, 171, 217, 218,
- 219, 84, 47, 47, 159, 80, 85, 81, 160, 145,
- 163, 104, 166, 167, 104, 272, 164, 258, 286, 287,
- 158, 181, 182, 183, 184, 185, 189, 276, 86, 82,
- 128, 131, 129, 132, 87, 204, 93, 204, 176, 104,
- 209, 177, 178, 179, 104, 165, 47, 47, 88, 192,
- 273, 196, 172, 173, 130, 133, 104, 100, 103, 109,
- 223, 117, 277, 119, 120, 121, 123, 233, 125, 126,
- 212, 213, 139, 204, 204, 127, 134, 141, 47, 47,
- 193, 2, 135, 228, 229, 145, 3, 136, 4, 5,
- 6, 7, 235, 236, 137, 9, 138, 197, 112, 113,
- 114, 91, 13, 14, 256, 15, 207, 140, 193, 16,
- 17, 18, 19, 263, 20, 21, 22, 23, 265, 266,
- 267, 104, 208, 26, 27, 271, 168, 28, 214, 29,
- 149, 150, 220, 198, 231, 221, 234, 230, 264, 239,
- 281, 151, 152, 153, 242, 244, 270, 245, 204, 204,
- 274, 275, 112, 113, 114, 249, 225, 254, 255, 259,
- 261, 280, 260, 262, 269, 282, 283, 1, 284, 2,
- 285, 288, 289, 291, 3, 290, 4, 5, 6, 7,
- 292, 294, 8, 9, 295, 205, 92, 10, 11, 210,
- 12, 13, 14, 15, 279, 251, 222, 63, 16, 17,
- 18, 19, 0, 20, 21, 22, 23, 0, 0, 24,
- 25, 2, 26, 27, 0, 28, 3, 29, 4, 5,
- 6, 7, 0, 0, 8, 9, 0, 0, 0, 10,
- 11, 0, 12, 13, 14, 15, 0, 0, 0, 0,
- 16, 17, 18, 19, 0, 20, 21, 22, 23, 0,
- 0, 104, 0, 2, 26, 27, 0, 28, 3, 29,
- 4, 5, 6, 7, 0, 0, 8, 9, 0, 0,
- 0, 10, 11, 0, 12, 13, 14, 15, 0, 0,
- 0, 0, 16, 17, 18, 19, 0, 20, 21, 22,
- 23, 0, 0, 0, 0, 2, 26, 27, 0, 28,
- 3, 29, 4, 5, 6, 7, 0, 0, 8, 9,
- 0, 0, 0, 0, 11, 0, 12, 13, 14, 15,
- 0, 0, 0, 0, 16, 17, 18, 19, 0, 20,
- 21, 22, 23, 0, 0, 0, 0, 2, 26, 27,
- 0, 28, 3, 29, 4, 5, 6, 7, 0, 0,
- 8, 9, 0, 0, 0, 101, 0, 0, 12, 13,
- 14, 15, 0, 0, 0, 0, 16, 17, 18, 19,
- 0, 20, 21, 22, 23, 0, 0, 0, 0, 2,
- 26, 27, 0, 28, 3, 29, 4, 5, 6, 7,
- 0, 0, 8, 9, 0, 0, 0, 0, 0, 0,
- 12, 13, 14, 15, 0, 0, 0, 0, 16, 17,
- 18, 19, 0, 20, 21, 22, 23, 0, 0, 104,
- 0, 2, 26, 27, 0, 28, 3, 29, 4, 5,
- 6, 7, 0, 0, 8, 9, 0, 0, 0, 0,
- 0, 0, 12, 13, 14, 15, 0, 0, 0, 0,
- 16, 17, 18, 19, 0, 20, 21, 22, 23, 0,
- 0, 0, 0, 0, 26, 27, 14, 28, 0, 29,
- 0, 0, 16, 17, 18, 19, 0, 20, 21, 22,
- 23, 0, 0, 0, 0, 0, 26, 27, 66, 67,
- 68, 69, 0, 70, 0, 71, 72, 0, 0, 0,
- 0, 0, 73, 74
+#define YYLAST 600
+
+
+static const short yytable[] =
+{
+ 59, 60, 48, 96, 47, 175, 201, 209, 160, 212,
+ 217, 98, 99, 63, 221, 222, 223, 224, 225, 79,
+ 51, 80, 55, 92, 93, 230, 256, 162, 113, 115,
+ 58, 123, 109, 163, 127, 56, 61, 246, 62, 57,
+ 231, 231, 2, 238, 81, 243, 244, 3, 249, 4,
+ 5, 6, 7, 107, 247, 175, 9, 109, 101, 102,
+ 109, 109, 66, 164, 65, 147, 15, 129, 232, 232,
+ 77, 169, 101, 102, 148, 149, 78, 170, 152, 183,
+ 184, 185, 82, 109, 103, 104, 116, 161, 83, 29,
+ 84, 30, 86, 175, 167, 168, 155, 156, 223, 224,
+ 225, 109, 154, 177, 196, 48, 48, 171, 151, 153,
+ 165, 284, 184, 85, 166, 117, 118, 119, 172, 173,
+ 292, 293, 120, 133, 205, 134, 87, 207, 187, 188,
+ 189, 190, 191, 195, 109, 263, 278, 105, 258, 282,
+ 197, 88, 210, 96, 210, 259, 108, 215, 135, 126,
+ 48, 48, 178, 179, 109, 182, 198, 109, 202, 89,
+ 206, 258, 137, 208, 138, 109, 109, 229, 274, 109,
+ 90, 264, 279, 91, 239, 283, 114, 218, 219, 122,
+ 210, 210, 48, 48, 147, 151, 124, 139, 125, 128,
+ 234, 235, 130, 94, 13, 14, 145, 131, 203, 241,
+ 242, 16, 17, 18, 19, 20, 132, 21, 22, 23,
+ 24, 262, 136, 140, 141, 142, 27, 28, 143, 144,
+ 269, 146, 199, 174, 213, 271, 272, 273, 14, 204,
+ 214, 220, 277, 227, 16, 17, 18, 19, 20, 226,
+ 21, 22, 23, 24, 199, 270, 236, 287, 240, 27,
+ 28, 245, 248, 276, 250, 210, 210, 280, 281, 251,
+ 255, 231, 261, 117, 118, 119, 260, 265, 286, 266,
+ 268, 267, 288, 289, 1, 290, 2, 275, 294, 155,
+ 156, 3, 237, 4, 5, 6, 7, 295, 300, 8,
+ 9, 157, 158, 159, 10, 11, 291, 12, 13, 14,
+ 15, 117, 118, 119, 297, 16, 17, 18, 19, 20,
+ 296, 21, 22, 23, 24, 298, 95, 25, 26, 2,
+ 27, 28, 301, 29, 3, 30, 4, 5, 6, 7,
+ 211, 216, 8, 9, 228, 285, 257, 10, 11, 64,
+ 12, 13, 14, 15, 0, 0, 0, 0, 16, 17,
+ 18, 19, 20, 0, 21, 22, 23, 24, 0, 0,
+ 109, 0, 2, 27, 28, 0, 29, 3, 30, 4,
+ 5, 6, 7, 0, 0, 8, 9, 0, 0, 0,
+ 10, 11, 0, 12, 13, 14, 15, 0, 0, 0,
+ 0, 16, 17, 18, 19, 20, 0, 21, 22, 23,
+ 24, 0, 0, 0, 0, 2, 27, 28, 0, 29,
+ 3, 30, 4, 5, 6, 7, 0, 0, 8, 9,
+ 0, 0, 0, 0, 11, 0, 12, 13, 14, 15,
+ 0, 0, 0, 0, 16, 17, 18, 19, 20, 0,
+ 21, 22, 23, 24, 0, 0, 0, 0, 2, 27,
+ 28, 0, 29, 3, 30, 4, 5, 6, 7, 0,
+ 0, 8, 9, 0, 0, 0, 106, 0, 0, 12,
+ 13, 14, 15, 0, 0, 0, 0, 16, 17, 18,
+ 19, 20, 0, 21, 22, 23, 24, 0, 0, 0,
+ 0, 2, 27, 28, 0, 29, 3, 30, 4, 5,
+ 6, 7, 0, 0, 8, 9, 0, 0, 0, 0,
+ 0, 0, 12, 13, 14, 15, 0, 0, 0, 0,
+ 16, 17, 18, 19, 20, 0, 21, 22, 23, 24,
+ 0, 0, 109, 0, 2, 27, 28, 0, 29, 3,
+ 30, 4, 5, 6, 7, 0, 0, 8, 9, 0,
+ 0, 0, 0, 0, 0, 12, 13, 14, 15, 0,
+ 0, 0, 0, 16, 17, 18, 19, 20, 0, 21,
+ 22, 23, 24, 0, 0, 0, 0, 0, 27, 28,
+ 0, 29, 0, 30, 67, 68, 69, 70, 71, 0,
+ 72, 0, 73, 74, 0, 0, 0, 0, 0, 75,
+ 76
};
-static const short yycheck[] = { 6,
- 7, 34, 10, 122, 0, 163, 45, 165, 157, 171,
- 0, 14, 43, 52, 181, 182, 183, 184, 185, 20,
- 9, 28, 29, 9, 24, 24, 54, 55, 28, 57,
- 24, 14, 60, 30, 31, 24, 24, 204, 24, 23,
- 43, 49, 43, 201, 202, 194, 49, 209, 14, 30,
- 31, 14, 171, 29, 43, 63, 205, 43, 5, 6,
- 43, 94, 51, 30, 31, 51, 49, 24, 96, 97,
- 24, 24, 100, 26, 41, 42, 42, 43, 44, 51,
- 43, 109, 14, 49, 24, 14, 49, 45, 116, 117,
- 209, 20, 43, 101, 52, 48, 103, 125, 265, 266,
- 267, 24, 98, 99, 111, 24, 24, 26, 115, 99,
- 14, 43, 119, 120, 43, 14, 20, 49, 276, 277,
- 49, 149, 150, 151, 152, 153, 154, 14, 24, 48,
- 24, 24, 26, 26, 24, 163, 169, 165, 146, 43,
- 168, 5, 6, 7, 43, 49, 142, 143, 24, 156,
- 49, 158, 142, 143, 48, 48, 43, 45, 4, 42,
- 188, 42, 49, 14, 14, 51, 18, 195, 52, 24,
- 177, 178, 50, 201, 202, 24, 24, 210, 174, 175,
- 24, 3, 24, 190, 191, 175, 8, 24, 10, 11,
- 12, 13, 199, 200, 24, 17, 24, 15, 42, 43,
- 44, 24, 25, 26, 232, 27, 15, 52, 24, 32,
- 33, 34, 35, 241, 37, 38, 39, 40, 246, 247,
- 248, 43, 15, 46, 47, 253, 52, 49, 7, 51,
- 30, 31, 9, 50, 24, 36, 50, 15, 245, 15,
- 268, 41, 42, 43, 50, 7, 253, 4, 276, 277,
- 257, 258, 42, 43, 44, 36, 24, 15, 50, 15,
- 15, 268, 50, 50, 24, 272, 273, 1, 15, 3,
- 50, 278, 15, 15, 8, 50, 10, 11, 12, 13,
- 50, 0, 16, 17, 0, 164, 32, 21, 22, 169,
- 24, 25, 26, 27, 264, 226, 188, 10, 32, 33,
- 34, 35, -1, 37, 38, 39, 40, -1, -1, 43,
- 44, 3, 46, 47, -1, 49, 8, 51, 10, 11,
- 12, 13, -1, -1, 16, 17, -1, -1, -1, 21,
- 22, -1, 24, 25, 26, 27, -1, -1, -1, -1,
- 32, 33, 34, 35, -1, 37, 38, 39, 40, -1,
- -1, 43, -1, 3, 46, 47, -1, 49, 8, 51,
- 10, 11, 12, 13, -1, -1, 16, 17, -1, -1,
- -1, 21, 22, -1, 24, 25, 26, 27, -1, -1,
- -1, -1, 32, 33, 34, 35, -1, 37, 38, 39,
- 40, -1, -1, -1, -1, 3, 46, 47, -1, 49,
- 8, 51, 10, 11, 12, 13, -1, -1, 16, 17,
- -1, -1, -1, -1, 22, -1, 24, 25, 26, 27,
- -1, -1, -1, -1, 32, 33, 34, 35, -1, 37,
- 38, 39, 40, -1, -1, -1, -1, 3, 46, 47,
- -1, 49, 8, 51, 10, 11, 12, 13, -1, -1,
- 16, 17, -1, -1, -1, 21, -1, -1, 24, 25,
- 26, 27, -1, -1, -1, -1, 32, 33, 34, 35,
- -1, 37, 38, 39, 40, -1, -1, -1, -1, 3,
- 46, 47, -1, 49, 8, 51, 10, 11, 12, 13,
- -1, -1, 16, 17, -1, -1, -1, -1, -1, -1,
- 24, 25, 26, 27, -1, -1, -1, -1, 32, 33,
- 34, 35, -1, 37, 38, 39, 40, -1, -1, 43,
- -1, 3, 46, 47, -1, 49, 8, 51, 10, 11,
- 12, 13, -1, -1, 16, 17, -1, -1, -1, -1,
- -1, -1, 24, 25, 26, 27, -1, -1, -1, -1,
- 32, 33, 34, 35, -1, 37, 38, 39, 40, -1,
- -1, -1, -1, -1, 46, 47, 26, 49, -1, 51,
- -1, -1, 32, 33, 34, 35, -1, 37, 38, 39,
- 40, -1, -1, -1, -1, -1, 46, 47, 32, 33,
- 34, 35, -1, 37, -1, 39, 40, -1, -1, -1,
- -1, -1, 46, 47
+static const short yycheck[] =
+{
+ 6, 7, 0, 35, 0, 127, 163, 169, 20, 171,
+ 177, 44, 45, 10, 187, 188, 189, 190, 191, 24,
+ 44, 26, 24, 29, 30, 9, 9, 14, 55, 56,
+ 24, 58, 44, 20, 61, 24, 24, 210, 29, 28,
+ 24, 24, 3, 200, 49, 207, 208, 8, 215, 10,
+ 11, 12, 13, 50, 211, 177, 17, 44, 30, 31,
+ 44, 44, 52, 50, 23, 97, 27, 64, 52, 52,
+ 24, 14, 30, 31, 101, 102, 24, 20, 105, 5,
+ 6, 7, 24, 44, 42, 43, 14, 114, 24, 50,
+ 26, 52, 24, 215, 121, 122, 30, 31, 271, 272,
+ 273, 44, 108, 130, 14, 103, 104, 50, 104, 106,
+ 116, 5, 6, 49, 120, 43, 44, 45, 124, 125,
+ 282, 283, 50, 24, 14, 26, 24, 14, 155, 156,
+ 157, 158, 159, 160, 44, 14, 14, 46, 46, 14,
+ 50, 24, 169, 175, 171, 53, 4, 174, 49, 52,
+ 148, 149, 148, 149, 44, 152, 162, 44, 164, 24,
+ 50, 46, 24, 50, 26, 44, 44, 194, 53, 44,
+ 24, 50, 50, 24, 201, 50, 43, 183, 184, 43,
+ 207, 208, 180, 181, 216, 181, 14, 49, 14, 18,
+ 196, 197, 53, 24, 25, 26, 51, 24, 15, 205,
+ 206, 32, 33, 34, 35, 36, 24, 38, 39, 40,
+ 41, 238, 24, 24, 24, 24, 47, 48, 24, 24,
+ 247, 53, 24, 53, 15, 252, 253, 254, 26, 51,
+ 15, 7, 259, 37, 32, 33, 34, 35, 36, 9,
+ 38, 39, 40, 41, 24, 251, 15, 274, 51, 47,
+ 48, 15, 51, 259, 7, 282, 283, 263, 264, 4,
+ 37, 24, 51, 43, 44, 45, 15, 15, 274, 51,
+ 51, 15, 278, 279, 1, 15, 3, 24, 284, 30,
+ 31, 8, 24, 10, 11, 12, 13, 15, 0, 16,
+ 17, 42, 43, 44, 21, 22, 51, 24, 25, 26,
+ 27, 43, 44, 45, 15, 32, 33, 34, 35, 36,
+ 51, 38, 39, 40, 41, 51, 33, 44, 45, 3,
+ 47, 48, 0, 50, 8, 52, 10, 11, 12, 13,
+ 170, 175, 16, 17, 194, 270, 232, 21, 22, 10,
+ 24, 25, 26, 27, -1, -1, -1, -1, 32, 33,
+ 34, 35, 36, -1, 38, 39, 40, 41, -1, -1,
+ 44, -1, 3, 47, 48, -1, 50, 8, 52, 10,
+ 11, 12, 13, -1, -1, 16, 17, -1, -1, -1,
+ 21, 22, -1, 24, 25, 26, 27, -1, -1, -1,
+ -1, 32, 33, 34, 35, 36, -1, 38, 39, 40,
+ 41, -1, -1, -1, -1, 3, 47, 48, -1, 50,
+ 8, 52, 10, 11, 12, 13, -1, -1, 16, 17,
+ -1, -1, -1, -1, 22, -1, 24, 25, 26, 27,
+ -1, -1, -1, -1, 32, 33, 34, 35, 36, -1,
+ 38, 39, 40, 41, -1, -1, -1, -1, 3, 47,
+ 48, -1, 50, 8, 52, 10, 11, 12, 13, -1,
+ -1, 16, 17, -1, -1, -1, 21, -1, -1, 24,
+ 25, 26, 27, -1, -1, -1, -1, 32, 33, 34,
+ 35, 36, -1, 38, 39, 40, 41, -1, -1, -1,
+ -1, 3, 47, 48, -1, 50, 8, 52, 10, 11,
+ 12, 13, -1, -1, 16, 17, -1, -1, -1, -1,
+ -1, -1, 24, 25, 26, 27, -1, -1, -1, -1,
+ 32, 33, 34, 35, 36, -1, 38, 39, 40, 41,
+ -1, -1, 44, -1, 3, 47, 48, -1, 50, 8,
+ 52, 10, 11, 12, 13, -1, -1, 16, 17, -1,
+ -1, -1, -1, -1, -1, 24, 25, 26, 27, -1,
+ -1, -1, -1, 32, 33, 34, 35, 36, -1, 38,
+ 39, 40, 41, -1, -1, -1, -1, -1, 47, 48,
+ -1, 50, -1, 52, 32, 33, 34, 35, 36, -1,
+ 38, -1, 40, 41, -1, -1, -1, -1, -1, 47,
+ 48
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
-#line 3 "/usr/local/share/bison.simple"
-/* This file comes from bison-1.28. */
+#line 3 "/usr/local/share/bison/bison.simple"
/* Skeleton output parser for bison,
- Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
+ Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
-/* This is the parser code that is written into each bison parser
- when the %semantic_parser declaration is not specified in the grammar.
- It was written by Richard Stallman by simplifying the hairy parser
- used when %semantic_parser is specified. */
+/* This is the parser code that is written into each bison parser when
+ the %semantic_parser declaration is not specified in the grammar.
+ It was written by Richard Stallman by simplifying the hairy parser
+ used when %semantic_parser is specified. */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+ infringing on user name space. This should be done even for local
+ variables, as they might otherwise be expanded by user macros.
+ There are some unavoidable exceptions within include files to
+ define necessary library symbols; they are noted "INFRINGES ON
+ USER NAME SPACE" below. */
+
+#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# if YYSTACK_USE_ALLOCA
+# define YYSTACK_ALLOC alloca
+# else
+# ifndef YYSTACK_USE_ALLOCA
+# if defined (alloca) || defined (_ALLOCA_H)
+# define YYSTACK_ALLOC alloca
+# else
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's `empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# else
+# if defined (__STDC__) || defined (__cplusplus)
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# endif
+# define YYSTACK_ALLOC malloc
+# define YYSTACK_FREE free
+# endif
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ short yyss;
+ YYSTYPE yyvs;
+# if YYLSP_NEEDED
+ YYLTYPE yyls;
+# endif
+};
-#ifndef YYSTACK_USE_ALLOCA
-#ifdef alloca
-#define YYSTACK_USE_ALLOCA
-#else /* alloca not defined */
-#ifdef __GNUC__
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
-#else /* not GNU C. */
-#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
-#define YYSTACK_USE_ALLOCA
-#include <alloca.h>
-#else /* not sparc */
-/* We think this test detects Watcom and Microsoft C. */
-/* This used to test MSDOS, but that is a bad idea
- since that symbol is in the user namespace. */
-#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
-#if 0 /* No need for malloc.h, which pollutes the namespace;
- instead, just don't use alloca. */
-#include <malloc.h>
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# if YYLSP_NEEDED
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+ + 2 * YYSTACK_GAP_MAX)
+# else
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
+ + YYSTACK_GAP_MAX)
+# endif
+
+/* Relocate the TYPE STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Type, Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ yymemcpy ((char *) yyptr, (char *) (Stack), \
+ yysize * (YYSIZE_T) sizeof (Type)); \
+ Stack = &yyptr->Stack; \
+ yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (0)
+
+#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
+
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
#endif
-#else /* not MSDOS, or __TURBOC__ */
-#if defined(_AIX)
-/* I don't know what this was needed for, but it pollutes the namespace.
- So I turned it off. rms, 2 May 1997. */
-/* #include <malloc.h> */
- #pragma alloca
-#define YYSTACK_USE_ALLOCA
-#else /* not MSDOS, or __TURBOC__, or _AIX */
-#if 0
-#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
- and on HPUX 10. Eventually we can turn this on. */
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
-#endif /* __hpux */
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
#endif
-#endif /* not _AIX */
-#endif /* not MSDOS, or __TURBOC__ */
-#endif /* not sparc */
-#endif /* not GNU C */
-#endif /* alloca not defined */
-#endif /* YYSTACK_USE_ALLOCA not defined */
-
-#ifdef YYSTACK_USE_ALLOCA
-#define YYSTACK_ALLOC alloca
-#else
-#define YYSTACK_ALLOC malloc
+#if ! defined (YYSIZE_T)
+# if defined (__STDC__) || defined (__cplusplus)
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# endif
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
#endif
-
-/* Note: there must be only one dollar sign in this file.
- It is replaced by the list of actions, each action
- as one case of the switch. */
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrlab1
-/* Like YYERROR except do call yyerror.
- This remains here temporarily to ease the
- transition to the new meaning of YYERROR, for GCC.
+/* Like YYERROR except do call yyerror. This remains here temporarily
+ to ease the transition to the new meaning of YYERROR, for GCC.
Once GCC version 2 has supplanted version 1, this can go. */
#define YYFAIL goto yyerrlab
#define YYRECOVERING() (!!yyerrstatus)
-#define YYBACKUP(token, value) \
+#define YYBACKUP(Token, Value) \
do \
if (yychar == YYEMPTY && yylen == 1) \
- { yychar = (token), yylval = (value); \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
yychar1 = YYTRANSLATE (yychar); \
YYPOPSTACK; \
goto yybackup; \
} \
else \
- { yyerror ("syntax error: cannot back up"); YYERROR; } \
+ { \
+ yyerror ("syntax error: cannot back up"); \
+ YYERROR; \
+ } \
while (0)
#define YYTERROR 1
#define YYERRCODE 256
-#ifndef YYPURE
-#define YYLEX yylex()
-#endif
-#ifdef YYPURE
-#ifdef YYLSP_NEEDED
-#ifdef YYLEX_PARAM
-#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
-#else
-#define YYLEX yylex(&yylval, &yylloc)
-#endif
-#else /* not YYLSP_NEEDED */
-#ifdef YYLEX_PARAM
-#define YYLEX yylex(&yylval, YYLEX_PARAM)
-#else
-#define YYLEX yylex(&yylval)
-#endif
-#endif /* not YYLSP_NEEDED */
-#endif
+/* YYLLOC_DEFAULT -- Compute the default location (before the actions
+ are run).
-/* If nonreentrant, generate the variables here */
+ When YYLLOC_DEFAULT is run, CURRENT is set the location of the
+ first token. By default, to implement support for ranges, extend
+ its range to the last symbol. */
-#ifndef YYPURE
-
-int yychar; /* the lookahead symbol */
-YYSTYPE yylval; /* the semantic value of the */
- /* lookahead symbol */
-
-#ifdef YYLSP_NEEDED
-YYLTYPE yylloc; /* location data for the lookahead */
- /* symbol */
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N) \
+ Current.last_line = Rhs[N].last_line; \
+ Current.last_column = Rhs[N].last_column;
#endif
-int yynerrs; /* number of parse errors so far */
-#endif /* not YYPURE */
-
-#if YYDEBUG != 0
-int yydebug; /* nonzero means print parse trace */
-/* Since this is uninitialized, it does not stop multiple parsers
- from coexisting. */
-#endif
-/* YYINITDEPTH indicates the initial size of the parser's stacks */
+/* YYLEX -- calling `yylex' with the right arguments. */
+#if YYPURE
+# if YYLSP_NEEDED
+# ifdef YYLEX_PARAM
+# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
+# else
+# define YYLEX yylex (&yylval, &yylloc)
+# endif
+# else /* !YYLSP_NEEDED */
+# ifdef YYLEX_PARAM
+# define YYLEX yylex (&yylval, YYLEX_PARAM)
+# else
+# define YYLEX yylex (&yylval)
+# endif
+# endif /* !YYLSP_NEEDED */
+#else /* !YYPURE */
+# define YYLEX yylex ()
+#endif /* !YYPURE */
+
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+/* Nonzero means print parse trace. It is left uninitialized so that
+ multiple parsers can coexist. */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+#endif /* !YYDEBUG */
+
+/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH
-#define YYINITDEPTH 200
+# define YYINITDEPTH 200
#endif
-/* YYMAXDEPTH is the maximum size the stacks can grow to
- (effective only if the built-in stack extension method is used). */
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+ if the built-in stack extension method is used).
+
+ Do not make this value too large; the results are undefined if
+ SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
#if YYMAXDEPTH == 0
-#undef YYMAXDEPTH
+# undef YYMAXDEPTH
#endif
#ifndef YYMAXDEPTH
-#define YYMAXDEPTH 10000
+# define YYMAXDEPTH 10000
#endif
\f
-/* Define __yy_memcpy. Note that the size argument
- should be passed with type unsigned int, because that is what the non-GCC
- definitions require. With GCC, __builtin_memcpy takes an arg
- of type size_t, but it can handle unsigned int. */
-
-#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
-#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
-#else /* not GNU C or C++ */
-#ifndef __cplusplus
+#if ! defined (yyoverflow) && ! defined (yymemcpy)
+# if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
+# define yymemcpy __builtin_memcpy
+# else /* not GNU C or C++ */
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
-__yy_memcpy (to, from, count)
- char *to;
- char *from;
- unsigned int count;
+# if defined (__STDC__) || defined (__cplusplus)
+yymemcpy (char *yyto, const char *yyfrom, YYSIZE_T yycount)
+# else
+yymemcpy (yyto, yyfrom, yycount)
+ char *yyto;
+ const char *yyfrom;
+ YYSIZE_T yycount;
+# endif
{
- register char *f = from;
- register char *t = to;
- register int i = count;
+ register const char *yyf = yyfrom;
+ register char *yyt = yyto;
+ register YYSIZE_T yyi = yycount;
- while (i-- > 0)
- *t++ = *f++;
+ while (yyi-- != 0)
+ *yyt++ = *yyf++;
}
+# endif
+#endif
-#else /* __cplusplus */
+#ifdef YYERROR_VERBOSE
-/* This is the most reliable way to avoid incompatibilities
- in available built-in functions on various systems. */
-static void
-__yy_memcpy (char *to, char *from, unsigned int count)
+# ifndef yystrlen
+# if defined (__GLIBC__) && defined (_STRING_H)
+# define yystrlen strlen
+# else
+/* Return the length of YYSTR. */
+static YYSIZE_T
+# if defined (__STDC__) || defined (__cplusplus)
+yystrlen (const char *yystr)
+# else
+yystrlen (yystr)
+ const char *yystr;
+# endif
{
- register char *t = to;
- register char *f = from;
- register int i = count;
+ register const char *yys = yystr;
+
+ while (*yys++ != '\0')
+ continue;
- while (i-- > 0)
- *t++ = *f++;
+ return yys - yystr - 1;
}
+# endif
+# endif
+
+# ifndef yystpcpy
+# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+# define yystpcpy stpcpy
+# else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+ YYDEST. */
+static char *
+# if defined (__STDC__) || defined (__cplusplus)
+yystpcpy (char *yydest, const char *yysrc)
+# else
+yystpcpy (yydest, yysrc)
+ char *yydest;
+ const char *yysrc;
+# endif
+{
+ register char *yyd = yydest;
+ register const char *yys = yysrc;
-#endif
+ while ((*yyd++ = *yys++) != '\0')
+ continue;
+
+ return yyd - 1;
+}
+# endif
+# endif
#endif
\f
-#line 217 "/usr/local/share/bison.simple"
+#line 319 "/usr/local/share/bison/bison.simple"
+
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
to the proper pointer type. */
#ifdef YYPARSE_PARAM
-#ifdef __cplusplus
-#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL
-#else /* not __cplusplus */
-#define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-#endif /* not __cplusplus */
-#else /* not YYPARSE_PARAM */
-#define YYPARSE_PARAM_ARG
-#define YYPARSE_PARAM_DECL
-#endif /* not YYPARSE_PARAM */
+# if defined (__STDC__) || defined (__cplusplus)
+# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+# define YYPARSE_PARAM_DECL
+# else
+# define YYPARSE_PARAM_ARG YYPARSE_PARAM
+# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+# endif
+#else /* !YYPARSE_PARAM */
+# define YYPARSE_PARAM_ARG
+# define YYPARSE_PARAM_DECL
+#endif /* !YYPARSE_PARAM */
/* Prevent warning if -Wstrict-prototypes. */
#ifdef __GNUC__
-#ifdef YYPARSE_PARAM
+# ifdef YYPARSE_PARAM
int yyparse (void *);
-#else
+# else
int yyparse (void);
+# endif
#endif
+
+/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
+ variables are global, or local to YYPARSE. */
+
+#define YY_DECL_NON_LSP_VARIABLES \
+/* The lookahead symbol. */ \
+int yychar; \
+ \
+/* The semantic value of the lookahead symbol. */ \
+YYSTYPE yylval; \
+ \
+/* Number of parse errors so far. */ \
+int yynerrs;
+
+#if YYLSP_NEEDED
+# define YY_DECL_VARIABLES \
+YY_DECL_NON_LSP_VARIABLES \
+ \
+/* Location data for the lookahead symbol. */ \
+YYLTYPE yylloc;
+#else
+# define YY_DECL_VARIABLES \
+YY_DECL_NON_LSP_VARIABLES
#endif
+
+/* If nonreentrant, generate the variables here. */
+
+#if !YYPURE
+YY_DECL_VARIABLES
+#endif /* !YYPURE */
+
int
-yyparse(YYPARSE_PARAM_ARG)
+yyparse (YYPARSE_PARAM_ARG)
YYPARSE_PARAM_DECL
{
+ /* If reentrant, generate the variables here. */
+#if YYPURE
+ YY_DECL_VARIABLES
+#endif /* !YYPURE */
+
register int yystate;
register int yyn;
+ int yyresult;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+ /* Lookahead token as an internal (translated) token number. */
+ int yychar1 = 0;
+
+ /* Three stacks and their tools:
+ `yyss': related to states,
+ `yyvs': related to semantic values,
+ `yyls': related to locations.
+
+ Refer to the stacks thru separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ short yyssa[YYINITDEPTH];
+ short *yyss = yyssa;
register short *yyssp;
- register YYSTYPE *yyvsp;
- int yyerrstatus; /* number of tokens to shift before error messages enabled */
- int yychar1 = 0; /* lookahead token as an internal (translated) token number */
-
- short yyssa[YYINITDEPTH]; /* the state stack */
- YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
- short *yyss = yyssa; /* refer to the stacks thru separate pointers */
- YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs = yyvsa;
+ register YYSTYPE *yyvsp;
-#ifdef YYLSP_NEEDED
- YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
+#if YYLSP_NEEDED
+ /* The location stack. */
+ YYLTYPE yylsa[YYINITDEPTH];
YYLTYPE *yyls = yylsa;
YYLTYPE *yylsp;
+#endif
-#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
+#if YYLSP_NEEDED
+# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
#else
-#define YYPOPSTACK (yyvsp--, yyssp--)
+# define YYPOPSTACK (yyvsp--, yyssp--)
#endif
- int yystacksize = YYINITDEPTH;
- int yyfree_stacks = 0;
+ YYSIZE_T yystacksize = YYINITDEPTH;
-#ifdef YYPURE
- int yychar;
- YYSTYPE yylval;
- int yynerrs;
-#ifdef YYLSP_NEEDED
- YYLTYPE yylloc;
-#endif
-#endif
- YYSTYPE yyval; /* the variable used to return */
- /* semantic values from the action */
- /* routines */
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+#if YYLSP_NEEDED
+ YYLTYPE yyloc;
+#endif
+ /* When reducing, the number of symbols on the RHS of the reduced
+ rule. */
int yylen;
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Starting parse\n");
-#endif
+ YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
- yyssp = yyss - 1;
+ yyssp = yyss;
yyvsp = yyvs;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
yylsp = yyls;
#endif
+ goto yysetstate;
-/* Push a new state, which is found in yystate . */
-/* In all cases, when you get here, the value and location stacks
- have just been pushed. so pushing a state here evens the stacks. */
-yynewstate:
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate. |
+`------------------------------------------------------------*/
+ yynewstate:
+ /* In all cases, when you get here, the value and location stacks
+ have just been pushed. so pushing a state here evens the stacks.
+ */
+ yyssp++;
- *++yyssp = yystate;
+ yysetstate:
+ *yyssp = yystate;
if (yyssp >= yyss + yystacksize - 1)
{
- /* Give user a chance to reallocate the stack */
- /* Use copies of these so that the &'s don't force the real ones into memory. */
- YYSTYPE *yyvs1 = yyvs;
- short *yyss1 = yyss;
-#ifdef YYLSP_NEEDED
- YYLTYPE *yyls1 = yyls;
-#endif
-
/* Get the current used size of the three stacks, in elements. */
- int size = yyssp - yyss + 1;
+ YYSIZE_T yysize = yyssp - yyss + 1;
#ifdef yyoverflow
- /* Each stack pointer address is followed by the size of
- the data in use in that stack, in bytes. */
-#ifdef YYLSP_NEEDED
- /* This used to be a conditional around just the two extra args,
- but that might be undefined if yyoverflow is a macro. */
- yyoverflow("parser stack overflow",
- &yyss1, size * sizeof (*yyssp),
- &yyvs1, size * sizeof (*yyvsp),
- &yyls1, size * sizeof (*yylsp),
- &yystacksize);
-#else
- yyoverflow("parser stack overflow",
- &yyss1, size * sizeof (*yyssp),
- &yyvs1, size * sizeof (*yyvsp),
- &yystacksize);
-#endif
-
- yyss = yyss1; yyvs = yyvs1;
-#ifdef YYLSP_NEEDED
- yyls = yyls1;
-#endif
+ {
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ short *yyss1 = yyss;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. */
+# if YYLSP_NEEDED
+ YYLTYPE *yyls1 = yyls;
+ /* This used to be a conditional around just the two extra args,
+ but that might be undefined if yyoverflow is a macro. */
+ yyoverflow ("parser stack overflow",
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yyls1, yysize * sizeof (*yylsp),
+ &yystacksize);
+ yyls = yyls1;
+# else
+ yyoverflow ("parser stack overflow",
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yystacksize);
+# endif
+ yyss = yyss1;
+ yyvs = yyvs1;
+ }
#else /* no yyoverflow */
/* Extend the stack our own way. */
if (yystacksize >= YYMAXDEPTH)
- {
- yyerror("parser stack overflow");
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
- return 2;
- }
+ goto yyoverflowlab;
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
-#ifndef YYSTACK_USE_ALLOCA
- yyfree_stacks = 1;
-#endif
- yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
- __yy_memcpy ((char *)yyss, (char *)yyss1,
- size * (unsigned int) sizeof (*yyssp));
- yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
- __yy_memcpy ((char *)yyvs, (char *)yyvs1,
- size * (unsigned int) sizeof (*yyvsp));
-#ifdef YYLSP_NEEDED
- yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
- __yy_memcpy ((char *)yyls, (char *)yyls1,
- size * (unsigned int) sizeof (*yylsp));
-#endif
+
+ {
+ short *yyss1 = yyss;
+ union yyalloc *yyptr =
+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+ if (! yyptr)
+ goto yyoverflowlab;
+ YYSTACK_RELOCATE (short, yyss);
+ YYSTACK_RELOCATE (YYSTYPE, yyvs);
+# if YYLSP_NEEDED
+ YYSTACK_RELOCATE (YYLTYPE, yyls);
+# endif
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
#endif /* no yyoverflow */
- yyssp = yyss + size - 1;
- yyvsp = yyvs + size - 1;
-#ifdef YYLSP_NEEDED
- yylsp = yyls + size - 1;
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+#if YYLSP_NEEDED
+ yylsp = yyls + yysize - 1;
#endif
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Stack size increased to %d\n", yystacksize);
-#endif
+ YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+ (unsigned long int) yystacksize));
if (yyssp >= yyss + yystacksize - 1)
YYABORT;
}
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Entering state %d\n", yystate);
-#endif
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
goto yybackup;
- yybackup:
+
+
+/*-----------.
+| yybackup. |
+`-----------*/
+yybackup:
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
if (yychar == YYEMPTY)
{
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Reading a token: ");
-#endif
+ YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
}
yychar1 = 0;
yychar = YYEOF; /* Don't call YYLEX any more */
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Now at end of input.\n");
-#endif
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
- yychar1 = YYTRANSLATE(yychar);
+ yychar1 = YYTRANSLATE (yychar);
-#if YYDEBUG != 0
+#if YYDEBUG
+ /* We have to keep this `#if YYDEBUG', since we use variables
+ which are defined only if `YYDEBUG' is set. */
if (yydebug)
{
- fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
- /* Give the individual parser a way to print the precise meaning
- of a token, for further debugging info. */
-#ifdef YYPRINT
+ YYFPRINTF (stderr, "Next token is %d (%s",
+ yychar, yytname[yychar1]);
+ /* Give the individual parser a way to print the precise
+ meaning of a token, for further debugging info. */
+# ifdef YYPRINT
YYPRINT (stderr, yychar, yylval);
-#endif
- fprintf (stderr, ")\n");
+# endif
+ YYFPRINTF (stderr, ")\n");
}
#endif
}
YYACCEPT;
/* Shift the lookahead token. */
-
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
-#endif
+ YYDPRINTF ((stderr, "Shifting token %d (%s), ",
+ yychar, yytname[yychar1]));
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
*++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
*++yylsp = yylloc;
#endif
- /* count tokens shifted since error; after three, turn off error status. */
- if (yyerrstatus) yyerrstatus--;
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
yystate = yyn;
goto yynewstate;
-/* Do the default action for the current state. */
-yydefault:
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
+ goto yyreduce;
+
-/* Do a reduction. yyn is the number of a rule to reduce with. */
+/*-----------------------------.
+| yyreduce -- Do a reduction. |
+`-----------------------------*/
yyreduce:
+ /* yyn is the number of a rule to reduce with. */
yylen = yyr2[yyn];
- if (yylen > 0)
- yyval = yyvsp[1-yylen]; /* implement default value of the action */
-#if YYDEBUG != 0
+ /* If YYLEN is nonzero, implement the default value of the action:
+ `$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to the semantic value of
+ the lookahead token. This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+#if YYLSP_NEEDED
+ /* Similarly for the default location. Let the user run additional
+ commands if for instance locations are ranges. */
+ yyloc = yylsp[1-yylen];
+ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+#endif
+
+#if YYDEBUG
+ /* We have to keep this `#if YYDEBUG', since we use variables which
+ are defined only if `YYDEBUG' is set. */
if (yydebug)
{
- int i;
+ int yyi;
- fprintf (stderr, "Reducing via rule %d (line %d), ",
- yyn, yyrline[yyn]);
+ YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
+ yyn, yyrline[yyn]);
/* Print the symbols being reduced, and their result. */
- for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
- fprintf (stderr, "%s ", yytname[yyrhs[i]]);
- fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+ for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
+ YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+ YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
}
#endif
-
switch (yyn) {
case 1:
-#line 283 "/usr/homes/chet/src/bash/src/parse.y"
+#line 327 "/usr/homes/chet/src/bash/src/parse.y"
{
/* Case of regular command. Discard the error
safety net,and return the command just parsed. */
global_command = yyvsp[-1].command;
eof_encountered = 0;
- discard_parser_constructs (0);
+ /* discard_parser_constructs (0); */
YYACCEPT;
- ;
- break;}
+ }
+ break;
case 2:
-#line 292 "/usr/homes/chet/src/bash/src/parse.y"
+#line 336 "/usr/homes/chet/src/bash/src/parse.y"
{
/* Case of regular command, but not a very
interesting one. Return a NULL command. */
global_command = (COMMAND *)NULL;
YYACCEPT;
- ;
- break;}
+ }
+ break;
case 3:
-#line 299 "/usr/homes/chet/src/bash/src/parse.y"
+#line 343 "/usr/homes/chet/src/bash/src/parse.y"
{
/* Error during parsing. Return NULL command. */
global_command = (COMMAND *)NULL;
eof_encountered = 0;
- discard_parser_constructs (1);
+ /* discard_parser_constructs (1); */
if (interactive)
{
YYACCEPT;
{
YYABORT;
}
- ;
- break;}
+ }
+ break;
case 4:
-#line 314 "/usr/homes/chet/src/bash/src/parse.y"
+#line 358 "/usr/homes/chet/src/bash/src/parse.y"
{
/* Case of EOF seen by itself. Do ignoreeof or
not. */
global_command = (COMMAND *)NULL;
handle_eof_input_unit ();
YYACCEPT;
- ;
- break;}
+ }
+ break;
case 5:
-#line 324 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); ;
- break;}
+#line 368 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); }
+ break;
case 6:
-#line 326 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-1].word_list); ;
- break;}
+#line 370 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-1].word_list); }
+ break;
case 7:
-#line 330 "/usr/homes/chet/src/bash/src/parse.y"
+#line 374 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (1, r_output_direction, redir);
- ;
- break;}
+ }
+ break;
case 8:
-#line 335 "/usr/homes/chet/src/bash/src/parse.y"
+#line 379 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (0, r_input_direction, redir);
- ;
- break;}
+ }
+ break;
case 9:
-#line 340 "/usr/homes/chet/src/bash/src/parse.y"
+#line 384 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (yyvsp[-2].number, r_output_direction, redir);
- ;
- break;}
+ }
+ break;
case 10:
-#line 345 "/usr/homes/chet/src/bash/src/parse.y"
+#line 389 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (yyvsp[-2].number, r_input_direction, redir);
- ;
- break;}
+ }
+ break;
case 11:
-#line 350 "/usr/homes/chet/src/bash/src/parse.y"
+#line 394 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (1, r_appending_to, redir);
- ;
- break;}
+ }
+ break;
case 12:
-#line 355 "/usr/homes/chet/src/bash/src/parse.y"
+#line 399 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (yyvsp[-2].number, r_appending_to, redir);
- ;
- break;}
+ }
+ break;
case 13:
-#line 360 "/usr/homes/chet/src/bash/src/parse.y"
+#line 404 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (0, r_reading_until, redir);
redir_stack[need_here_doc++] = yyval.redirect;
- ;
- break;}
+ }
+ break;
case 14:
-#line 366 "/usr/homes/chet/src/bash/src/parse.y"
+#line 410 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (yyvsp[-2].number, r_reading_until, redir);
redir_stack[need_here_doc++] = yyval.redirect;
- ;
- break;}
+ }
+ break;
case 15:
-#line 372 "/usr/homes/chet/src/bash/src/parse.y"
+#line 416 "/usr/homes/chet/src/bash/src/parse.y"
+{
+ redir.filename = yyvsp[0].word;
+ yyval.redirect = make_redirection (0, r_reading_string, redir);
+ }
+ break;
+case 16:
+#line 421 "/usr/homes/chet/src/bash/src/parse.y"
+{
+ redir.filename = yyvsp[0].word;
+ yyval.redirect = make_redirection (yyvsp[-2].number, r_reading_string, redir);
+ }
+ break;
+case 17:
+#line 426 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.dest = yyvsp[0].number;
yyval.redirect = make_redirection (0, r_duplicating_input, redir);
- ;
- break;}
-case 16:
-#line 377 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 18:
+#line 431 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.dest = yyvsp[0].number;
yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_input, redir);
- ;
- break;}
-case 17:
-#line 382 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 19:
+#line 436 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.dest = yyvsp[0].number;
yyval.redirect = make_redirection (1, r_duplicating_output, redir);
- ;
- break;}
-case 18:
-#line 387 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 20:
+#line 441 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.dest = yyvsp[0].number;
yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_output, redir);
- ;
- break;}
-case 19:
-#line 392 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 21:
+#line 446 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (0, r_duplicating_input_word, redir);
- ;
- break;}
-case 20:
-#line 397 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 22:
+#line 451 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_input_word, redir);
- ;
- break;}
-case 21:
-#line 402 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 23:
+#line 456 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (1, r_duplicating_output_word, redir);
- ;
- break;}
-case 22:
-#line 407 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 24:
+#line 461 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_output_word, redir);
- ;
- break;}
-case 23:
-#line 412 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 25:
+#line 466 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection
(0, r_deblank_reading_until, redir);
redir_stack[need_here_doc++] = yyval.redirect;
- ;
- break;}
-case 24:
-#line 419 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 26:
+#line 473 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection
(yyvsp[-2].number, r_deblank_reading_until, redir);
redir_stack[need_here_doc++] = yyval.redirect;
- ;
- break;}
-case 25:
-#line 426 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 27:
+#line 480 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.dest = 0;
yyval.redirect = make_redirection (1, r_close_this, redir);
- ;
- break;}
-case 26:
-#line 431 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 28:
+#line 485 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.dest = 0;
yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, redir);
- ;
- break;}
-case 27:
-#line 436 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 29:
+#line 490 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.dest = 0;
yyval.redirect = make_redirection (0, r_close_this, redir);
- ;
- break;}
-case 28:
-#line 441 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 30:
+#line 495 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.dest = 0;
yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, redir);
- ;
- break;}
-case 29:
-#line 446 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 31:
+#line 500 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (1, r_err_and_out, redir);
- ;
- break;}
-case 30:
-#line 451 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 32:
+#line 505 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (yyvsp[-2].number, r_input_output, redir);
- ;
- break;}
-case 31:
-#line 456 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 33:
+#line 510 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (0, r_input_output, redir);
- ;
- break;}
-case 32:
-#line 461 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 34:
+#line 515 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (1, r_output_force, redir);
- ;
- break;}
-case 33:
-#line 466 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 35:
+#line 520 "/usr/homes/chet/src/bash/src/parse.y"
{
redir.filename = yyvsp[0].word;
yyval.redirect = make_redirection (yyvsp[-2].number, r_output_force, redir);
- ;
- break;}
-case 34:
-#line 473 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; ;
- break;}
-case 35:
-#line 475 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; ;
- break;}
+ }
+ break;
case 36:
-#line 477 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.element.redirect = yyvsp[0].redirect; yyval.element.word = 0; ;
- break;}
+#line 527 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; }
+ break;
case 37:
-#line 481 "/usr/homes/chet/src/bash/src/parse.y"
+#line 529 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; }
+ break;
+case 38:
+#line 531 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.element.redirect = yyvsp[0].redirect; yyval.element.word = 0; }
+ break;
+case 39:
+#line 535 "/usr/homes/chet/src/bash/src/parse.y"
{
yyval.redirect = yyvsp[0].redirect;
- ;
- break;}
-case 38:
-#line 485 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 40:
+#line 539 "/usr/homes/chet/src/bash/src/parse.y"
{
register REDIRECT *t;
;
t->next = yyvsp[0].redirect;
yyval.redirect = yyvsp[-1].redirect;
- ;
- break;}
-case 39:
-#line 496 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_simple_command (yyvsp[0].element, (COMMAND *)NULL); ;
- break;}
-case 40:
-#line 498 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_simple_command (yyvsp[0].element, yyvsp[-1].command); ;
- break;}
+ }
+ break;
case 41:
-#line 502 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = clean_simple_command (yyvsp[0].command); ;
- break;}
+#line 550 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_simple_command (yyvsp[0].element, (COMMAND *)NULL); }
+ break;
case 42:
-#line 504 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 552 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_simple_command (yyvsp[0].element, yyvsp[-1].command); }
+ break;
case 43:
-#line 506 "/usr/homes/chet/src/bash/src/parse.y"
+#line 556 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = clean_simple_command (yyvsp[0].command); }
+ break;
+case 44:
+#line 558 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
+case 45:
+#line 560 "/usr/homes/chet/src/bash/src/parse.y"
{
COMMAND *tc;
else
tc->redirects = yyvsp[0].redirect;
yyval.command = yyvsp[-1].command;
- ;
- break;}
-case 44:
-#line 522 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
-case 45:
-#line 526 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+ }
+ break;
case 46:
-#line 528 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 576 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 47:
-#line 530 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_while_command (yyvsp[-3].command, yyvsp[-1].command); ;
- break;}
+#line 580 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 48:
-#line 532 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_until_command (yyvsp[-3].command, yyvsp[-1].command); ;
- break;}
+#line 582 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 49:
-#line 534 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 584 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_while_command (yyvsp[-3].command, yyvsp[-1].command); }
+ break;
case 50:
-#line 536 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 586 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_until_command (yyvsp[-3].command, yyvsp[-1].command); }
+ break;
case 51:
-#line 538 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 588 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 52:
-#line 540 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 590 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 53:
-#line 542 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 592 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 54:
-#line 544 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 594 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 55:
-#line 546 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 596 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 56:
-#line 550 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_for_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
- break;}
+#line 598 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 57:
-#line 552 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_for_command (yyvsp[-4].word, add_string_to_list ("$@", (WORD_LIST *)NULL), yyvsp[-1].command); ;
- break;}
+#line 600 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
case 58:
-#line 554 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_for_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
- break;}
+#line 604 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_for_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); }
+ break;
case 59:
-#line 556 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_for_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
- break;}
+#line 606 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_for_command (yyvsp[-4].word, add_string_to_list ("$@", (WORD_LIST *)NULL), yyvsp[-1].command); }
+ break;
case 60:
-#line 558 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_for_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command); ;
- break;}
+#line 608 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_for_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); }
+ break;
case 61:
-#line 560 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_for_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command); ;
- break;}
+#line 610 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_for_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); }
+ break;
case 62:
-#line 562 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_for_command (yyvsp[-7].word, (WORD_LIST *)NULL, yyvsp[-1].command); ;
- break;}
+#line 612 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_for_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command); }
+ break;
case 63:
-#line 564 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_for_command (yyvsp[-7].word, (WORD_LIST *)NULL, yyvsp[-1].command); ;
- break;}
+#line 614 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_for_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command); }
+ break;
case 64:
-#line 568 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_arith_for_command (yyvsp[-5].word_list, yyvsp[-1].command, arith_for_lineno); ;
- break;}
+#line 616 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_for_command (yyvsp[-7].word, (WORD_LIST *)NULL, yyvsp[-1].command); }
+ break;
case 65:
-#line 570 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_arith_for_command (yyvsp[-5].word_list, yyvsp[-1].command, arith_for_lineno); ;
- break;}
+#line 618 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_for_command (yyvsp[-7].word, (WORD_LIST *)NULL, yyvsp[-1].command); }
+ break;
case 66:
-#line 572 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_arith_for_command (yyvsp[-3].word_list, yyvsp[-1].command, arith_for_lineno); ;
- break;}
+#line 622 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_arith_for_command (yyvsp[-5].word_list, yyvsp[-1].command, arith_for_lineno); }
+ break;
case 67:
-#line 574 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_arith_for_command (yyvsp[-3].word_list, yyvsp[-1].command, arith_for_lineno); ;
- break;}
+#line 624 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_arith_for_command (yyvsp[-5].word_list, yyvsp[-1].command, arith_for_lineno); }
+ break;
case 68:
-#line 578 "/usr/homes/chet/src/bash/src/parse.y"
-{
- yyval.command = make_select_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command);
- ;
- break;}
+#line 626 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_arith_for_command (yyvsp[-3].word_list, yyvsp[-1].command, arith_for_lineno); }
+ break;
case 69:
-#line 582 "/usr/homes/chet/src/bash/src/parse.y"
-{
- yyval.command = make_select_command (yyvsp[-4].word, add_string_to_list ("$@", (WORD_LIST *)NULL), yyvsp[-1].command);
- ;
- break;}
+#line 628 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_arith_for_command (yyvsp[-3].word_list, yyvsp[-1].command, arith_for_lineno); }
+ break;
case 70:
-#line 586 "/usr/homes/chet/src/bash/src/parse.y"
+#line 632 "/usr/homes/chet/src/bash/src/parse.y"
{
- yyval.command = make_select_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command);
- ;
- break;}
+ yyval.command = make_select_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command);
+ }
+ break;
case 71:
-#line 590 "/usr/homes/chet/src/bash/src/parse.y"
+#line 636 "/usr/homes/chet/src/bash/src/parse.y"
{
- yyval.command = make_select_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command);
- ;
- break;}
+ yyval.command = make_select_command (yyvsp[-4].word, add_string_to_list ("$@", (WORD_LIST *)NULL), yyvsp[-1].command);
+ }
+ break;
case 72:
-#line 594 "/usr/homes/chet/src/bash/src/parse.y"
+#line 640 "/usr/homes/chet/src/bash/src/parse.y"
{
- yyval.command = make_select_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command);
- ;
- break;}
+ yyval.command = make_select_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command);
+ }
+ break;
case 73:
-#line 598 "/usr/homes/chet/src/bash/src/parse.y"
+#line 644 "/usr/homes/chet/src/bash/src/parse.y"
{
- yyval.command = make_select_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command);
- ;
- break;}
+ yyval.command = make_select_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command);
+ }
+ break;
case 74:
-#line 604 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_case_command (yyvsp[-4].word, (PATTERN_LIST *)NULL); ;
- break;}
+#line 648 "/usr/homes/chet/src/bash/src/parse.y"
+{
+ yyval.command = make_select_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command);
+ }
+ break;
case 75:
-#line 606 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_case_command (yyvsp[-5].word, yyvsp[-2].pattern); ;
- break;}
+#line 652 "/usr/homes/chet/src/bash/src/parse.y"
+{
+ yyval.command = make_select_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command);
+ }
+ break;
case 76:
-#line 608 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_case_command (yyvsp[-4].word, yyvsp[-1].pattern); ;
- break;}
+#line 658 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_case_command (yyvsp[-4].word, (PATTERN_LIST *)NULL); }
+ break;
case 77:
-#line 612 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command, function_dstart, function_bstart); ;
- break;}
+#line 660 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_case_command (yyvsp[-5].word, yyvsp[-2].pattern); }
+ break;
case 78:
-#line 615 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command, function_dstart, function_bstart); ;
- break;}
+#line 662 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_case_command (yyvsp[-4].word, yyvsp[-1].pattern); }
+ break;
case 79:
-#line 618 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_function_def (yyvsp[-2].word, yyvsp[0].command, function_dstart, function_bstart); ;
- break;}
+#line 666 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command, function_dstart, function_bstart); }
+ break;
case 80:
-#line 623 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
+#line 669 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command, function_dstart, function_bstart); }
+ break;
case 81:
-#line 625 "/usr/homes/chet/src/bash/src/parse.y"
+#line 672 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_function_def (yyvsp[-2].word, yyvsp[0].command, function_dstart, function_bstart); }
+ break;
+case 82:
+#line 677 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
+case 83:
+#line 679 "/usr/homes/chet/src/bash/src/parse.y"
{
COMMAND *tc;
else
tc->redirects = yyvsp[0].redirect;
yyval.command = yyvsp[-1].command;
- ;
- break;}
-case 82:
-#line 656 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 84:
+#line 710 "/usr/homes/chet/src/bash/src/parse.y"
{
yyval.command = make_subshell_command (yyvsp[-1].command);
yyval.command->flags |= CMD_WANT_SUBSHELL;
- ;
- break;}
-case 83:
-#line 663 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, (COMMAND *)NULL); ;
- break;}
-case 84:
-#line 665 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_if_command (yyvsp[-5].command, yyvsp[-3].command, yyvsp[-1].command); ;
- break;}
+ }
+ break;
case 85:
-#line 667 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[-1].command); ;
- break;}
+#line 717 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, (COMMAND *)NULL); }
+ break;
case 86:
-#line 672 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_group_command (yyvsp[-1].command); ;
- break;}
+#line 719 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_if_command (yyvsp[-5].command, yyvsp[-3].command, yyvsp[-1].command); }
+ break;
case 87:
-#line 676 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_arith_command (yyvsp[0].word_list); ;
- break;}
+#line 721 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[-1].command); }
+ break;
case 88:
-#line 680 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[-1].command; ;
- break;}
+#line 726 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_group_command (yyvsp[-1].command); }
+ break;
case 89:
-#line 684 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_if_command (yyvsp[-2].command, yyvsp[0].command, (COMMAND *)NULL); ;
- break;}
+#line 730 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_arith_command (yyvsp[0].word_list); }
+ break;
case 90:
-#line 686 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[0].command); ;
- break;}
+#line 734 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[-1].command; }
+ break;
case 91:
-#line 688 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, yyvsp[0].command); ;
- break;}
+#line 738 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_if_command (yyvsp[-2].command, yyvsp[0].command, (COMMAND *)NULL); }
+ break;
+case 92:
+#line 740 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[0].command); }
+ break;
case 93:
-#line 693 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; ;
- break;}
-case 94:
-#line 697 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ;
- break;}
+#line 742 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, yyvsp[0].command); }
+ break;
case 95:
-#line 699 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ;
- break;}
+#line 747 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; }
+ break;
case 96:
-#line 701 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ;
- break;}
+#line 751 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); }
+ break;
case 97:
-#line 703 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ;
- break;}
+#line 753 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); }
+ break;
+case 98:
+#line 755 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); }
+ break;
case 99:
-#line 708 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyvsp[-1].pattern->next = yyvsp[-2].pattern; yyval.pattern = yyvsp[-1].pattern; ;
- break;}
-case 100:
-#line 712 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); ;
- break;}
+#line 757 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); }
+ break;
case 101:
-#line 714 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-2].word_list); ;
- break;}
+#line 762 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyvsp[-1].pattern->next = yyvsp[-2].pattern; yyval.pattern = yyvsp[-1].pattern; }
+ break;
case 102:
-#line 723 "/usr/homes/chet/src/bash/src/parse.y"
+#line 766 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); }
+ break;
+case 103:
+#line 768 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-2].word_list); }
+ break;
+case 104:
+#line 777 "/usr/homes/chet/src/bash/src/parse.y"
{
yyval.command = yyvsp[0].command;
if (need_here_doc)
gather_here_documents ();
- ;
- break;}
-case 104:
-#line 732 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 106:
+#line 786 "/usr/homes/chet/src/bash/src/parse.y"
{
yyval.command = yyvsp[0].command;
- ;
- break;}
-case 106:
-#line 739 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 108:
+#line 793 "/usr/homes/chet/src/bash/src/parse.y"
{
if (yyvsp[-2].command->type == cm_connection)
yyval.command = connect_async_list (yyvsp[-2].command, (COMMAND *)NULL, '&');
else
yyval.command = command_connect (yyvsp[-2].command, (COMMAND *)NULL, '&');
- ;
- break;}
-case 108:
-#line 750 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
- break;}
-case 109:
-#line 752 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
- break;}
+ }
+ break;
case 110:
-#line 754 "/usr/homes/chet/src/bash/src/parse.y"
+#line 804 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); }
+ break;
+case 111:
+#line 806 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); }
+ break;
+case 112:
+#line 808 "/usr/homes/chet/src/bash/src/parse.y"
{
if (yyvsp[-3].command->type == cm_connection)
yyval.command = connect_async_list (yyvsp[-3].command, yyvsp[0].command, '&');
else
yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '&');
- ;
- break;}
-case 111:
-#line 761 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
- break;}
-case 112:
-#line 763 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
- break;}
+ }
+ break;
case 113:
-#line 765 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
-case 119:
-#line 784 "/usr/homes/chet/src/bash/src/parse.y"
+#line 815 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); }
+ break;
+case 114:
+#line 817 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); }
+ break;
+case 115:
+#line 819 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
+case 123:
+#line 842 "/usr/homes/chet/src/bash/src/parse.y"
{
yyval.command = yyvsp[0].command;
if (need_here_doc)
gather_here_documents ();
- ;
- break;}
-case 120:
-#line 790 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 124:
+#line 848 "/usr/homes/chet/src/bash/src/parse.y"
{
if (yyvsp[-1].command->type == cm_connection)
yyval.command = connect_async_list (yyvsp[-1].command, (COMMAND *)NULL, '&');
yyval.command = command_connect (yyvsp[-1].command, (COMMAND *)NULL, '&');
if (need_here_doc)
gather_here_documents ();
- ;
- break;}
-case 121:
-#line 799 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 125:
+#line 857 "/usr/homes/chet/src/bash/src/parse.y"
{
yyval.command = yyvsp[-1].command;
if (need_here_doc)
gather_here_documents ();
- ;
- break;}
-case 122:
-#line 807 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
- break;}
-case 123:
-#line 809 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
- break;}
-case 124:
-#line 811 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 126:
+#line 865 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); }
+ break;
+case 127:
+#line 867 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); }
+ break;
+case 128:
+#line 869 "/usr/homes/chet/src/bash/src/parse.y"
{
if (yyvsp[-2].command->type == cm_connection)
yyval.command = connect_async_list (yyvsp[-2].command, yyvsp[0].command, '&');
else
yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, '&');
- ;
- break;}
-case 125:
-#line 818 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, ';'); ;
- break;}
-case 126:
-#line 821 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
-case 127:
-#line 825 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
-case 128:
-#line 827 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 129:
+#line 876 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, ';'); }
+ break;
+case 130:
+#line 879 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
+case 131:
+#line 883 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
+case 132:
+#line 885 "/usr/homes/chet/src/bash/src/parse.y"
{
yyvsp[0].command->flags |= CMD_INVERT_RETURN;
yyval.command = yyvsp[0].command;
- ;
- break;}
-case 129:
-#line 832 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 133:
+#line 890 "/usr/homes/chet/src/bash/src/parse.y"
{
yyvsp[0].command->flags |= yyvsp[-1].number;
yyval.command = yyvsp[0].command;
- ;
- break;}
-case 130:
-#line 837 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 134:
+#line 895 "/usr/homes/chet/src/bash/src/parse.y"
{
yyvsp[0].command->flags |= yyvsp[-2].number|CMD_INVERT_RETURN;
yyval.command = yyvsp[0].command;
- ;
- break;}
-case 131:
-#line 842 "/usr/homes/chet/src/bash/src/parse.y"
+ }
+ break;
+case 135:
+#line 900 "/usr/homes/chet/src/bash/src/parse.y"
{
yyvsp[0].command->flags |= yyvsp[-1].number|CMD_INVERT_RETURN;
yyval.command = yyvsp[0].command;
- ;
- break;}
-case 132:
-#line 850 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '|'); ;
- break;}
-case 133:
-#line 852 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.command = yyvsp[0].command; ;
- break;}
-case 134:
-#line 856 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.number = CMD_TIME_PIPELINE; ;
- break;}
-case 135:
-#line 858 "/usr/homes/chet/src/bash/src/parse.y"
-{ yyval.number = CMD_TIME_PIPELINE|CMD_TIME_POSIX; ;
- break;}
+ }
+ break;
+case 136:
+#line 908 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '|'); }
+ break;
+case 137:
+#line 910 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.command = yyvsp[0].command; }
+ break;
+case 138:
+#line 914 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.number = CMD_TIME_PIPELINE; }
+ break;
+case 139:
+#line 916 "/usr/homes/chet/src/bash/src/parse.y"
+{ yyval.number = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
+ break;
}
- /* the action file gets copied in in place of this dollarsign */
-#line 543 "/usr/local/share/bison.simple"
+
+#line 705 "/usr/local/share/bison/bison.simple"
+
\f
yyvsp -= yylen;
yyssp -= yylen;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
yylsp -= yylen;
#endif
-#if YYDEBUG != 0
+#if YYDEBUG
if (yydebug)
{
- short *ssp1 = yyss - 1;
- fprintf (stderr, "state stack now");
- while (ssp1 != yyssp)
- fprintf (stderr, " %d", *++ssp1);
- fprintf (stderr, "\n");
+ short *yyssp1 = yyss - 1;
+ YYFPRINTF (stderr, "state stack now");
+ while (yyssp1 != yyssp)
+ YYFPRINTF (stderr, " %d", *++yyssp1);
+ YYFPRINTF (stderr, "\n");
}
#endif
*++yyvsp = yyval;
-
-#ifdef YYLSP_NEEDED
- yylsp++;
- if (yylen == 0)
- {
- yylsp->first_line = yylloc.first_line;
- yylsp->first_column = yylloc.first_column;
- yylsp->last_line = (yylsp-1)->last_line;
- yylsp->last_column = (yylsp-1)->last_column;
- yylsp->text = 0;
- }
- else
- {
- yylsp->last_line = (yylsp+yylen-1)->last_line;
- yylsp->last_column = (yylsp+yylen-1)->last_column;
- }
+#if YYLSP_NEEDED
+ *++yylsp = yyloc;
#endif
- /* Now "shift" the result of the reduction.
- Determine what state that goes to,
- based on the state we popped back to
- and the rule number reduced by. */
+ /* Now `shift' the result of the reduction. Determine what state
+ that goes to, based on the state we popped back to and the rule
+ number reduced by. */
yyn = yyr1[yyn];
goto yynewstate;
-yyerrlab: /* here on detecting error */
- if (! yyerrstatus)
- /* If not already recovering from an error, report this error. */
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
{
++yynerrs;
if (yyn > YYFLAG && yyn < YYLAST)
{
- int size = 0;
- char *msg;
- int x, count;
-
- count = 0;
- /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
- for (x = (yyn < 0 ? -yyn : 0);
- x < (sizeof(yytname) / sizeof(char *)); x++)
- if (yycheck[x + yyn] == x)
- size += strlen(yytname[x]) + 15, count++;
- msg = (char *) malloc(size + 15);
- if (msg != 0)
+ YYSIZE_T yysize = 0;
+ char *yymsg;
+ int yyx, yycount;
+
+ yycount = 0;
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. */
+ for (yyx = yyn < 0 ? -yyn : 0;
+ yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+ if (yycheck[yyx + yyn] == yyx)
+ yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+ yysize += yystrlen ("parse error, unexpected ") + 1;
+ yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
+ yymsg = (char *) YYSTACK_ALLOC (yysize);
+ if (yymsg != 0)
{
- strcpy(msg, "parse error");
+ char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+ yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
- if (count < 5)
+ if (yycount < 5)
{
- count = 0;
- for (x = (yyn < 0 ? -yyn : 0);
- x < (sizeof(yytname) / sizeof(char *)); x++)
- if (yycheck[x + yyn] == x)
+ yycount = 0;
+ for (yyx = yyn < 0 ? -yyn : 0;
+ yyx < (int) (sizeof (yytname) / sizeof (char *));
+ yyx++)
+ if (yycheck[yyx + yyn] == yyx)
{
- strcat(msg, count == 0 ? ", expecting `" : " or `");
- strcat(msg, yytname[x]);
- strcat(msg, "'");
- count++;
+ const char *yyq = ! yycount ? ", expecting " : " or ";
+ yyp = yystpcpy (yyp, yyq);
+ yyp = yystpcpy (yyp, yytname[yyx]);
+ yycount++;
}
}
- yyerror(msg);
- free(msg);
+ yyerror (yymsg);
+ YYSTACK_FREE (yymsg);
}
else
- yyerror ("parse error; also virtual memory exceeded");
+ yyerror ("parse error; also virtual memory exhausted");
}
else
-#endif /* YYERROR_VERBOSE */
- yyerror("parse error");
+#endif /* defined (YYERROR_VERBOSE) */
+ yyerror ("parse error");
}
-
goto yyerrlab1;
-yyerrlab1: /* here on error raised explicitly by an action */
+
+/*--------------------------------------------------.
+| yyerrlab1 -- error raised explicitly by an action |
+`--------------------------------------------------*/
+yyerrlab1:
if (yyerrstatus == 3)
{
- /* if just tried and failed to reuse lookahead token after an error, discard it. */
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
/* return failure if at end of input */
if (yychar == YYEOF)
YYABORT;
-
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
-#endif
-
+ YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
+ yychar, yytname[yychar1]));
yychar = YYEMPTY;
}
- /* Else will try to reuse lookahead token
- after shifting the error token. */
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
yyerrstatus = 3; /* Each real token shifted decrements this */
goto yyerrhandle;
-yyerrdefault: /* current state does not do anything special for the error token. */
+/*-------------------------------------------------------------------.
+| yyerrdefault -- current state does not do anything special for the |
+| error token. |
+`-------------------------------------------------------------------*/
+yyerrdefault:
#if 0
/* This is wrong; only states that explicitly want error tokens
should shift them. */
- yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
- if (yyn) goto yydefault;
+
+ /* If its default is to accept any token, ok. Otherwise pop it. */
+ yyn = yydefact[yystate];
+ if (yyn)
+ goto yydefault;
#endif
-yyerrpop: /* pop the current state because it cannot handle the error token */
- if (yyssp == yyss) YYABORT;
+/*---------------------------------------------------------------.
+| yyerrpop -- pop the current state because it cannot handle the |
+| error token |
+`---------------------------------------------------------------*/
+yyerrpop:
+ if (yyssp == yyss)
+ YYABORT;
yyvsp--;
yystate = *--yyssp;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
yylsp--;
#endif
-#if YYDEBUG != 0
+#if YYDEBUG
if (yydebug)
{
- short *ssp1 = yyss - 1;
- fprintf (stderr, "Error: state stack now");
- while (ssp1 != yyssp)
- fprintf (stderr, " %d", *++ssp1);
- fprintf (stderr, "\n");
+ short *yyssp1 = yyss - 1;
+ YYFPRINTF (stderr, "Error: state stack now");
+ while (yyssp1 != yyssp)
+ YYFPRINTF (stderr, " %d", *++yyssp1);
+ YYFPRINTF (stderr, "\n");
}
#endif
+/*--------------.
+| yyerrhandle. |
+`--------------*/
yyerrhandle:
-
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yyerrdefault;
if (yyn == YYFINAL)
YYACCEPT;
-#if YYDEBUG != 0
- if (yydebug)
- fprintf(stderr, "Shifting error token, ");
-#endif
+ YYDPRINTF ((stderr, "Shifting error token, "));
*++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
*++yylsp = yylloc;
#endif
yystate = yyn;
goto yynewstate;
- yyacceptlab:
- /* YYACCEPT comes here. */
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
- return 0;
- yyabortlab:
- /* YYABORT comes here. */
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+/*---------------------------------------------.
+| yyoverflowab -- parser overflow comes here. |
+`---------------------------------------------*/
+yyoverflowlab:
+ yyerror ("parser stack overflow");
+ yyresult = 2;
+ /* Fall through. */
+
+yyreturn:
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
#endif
- }
- return 1;
+ return yyresult;
}
-#line 860 "/usr/homes/chet/src/bash/src/parse.y"
+#line 918 "/usr/homes/chet/src/bash/src/parse.y"
/* Possible states for the parser that require it to do special things. */
bash_input.ungetter = unget;
}
+char *
+yy_input_name ()
+{
+ return (bash_input.name ? bash_input.name : "stdin");
+}
+
/* Call this to get the next character of input. */
static int
yy_getc ()
shell_input_line_index = 0;
shell_input_line_terminator = '\0';
parser_state &= ~PST_ALEXPNEXT;
+
+ set_line_mbstate ();
}
/*
#endif
free ((char *)t);
+
+ set_line_mbstate ();
}
static void
{ (char *)NULL, 0}
};
-/* XXX - we should also have an alist with strings for other tokens, so we
- can give more descriptive error messages. Look at y.tab.h for the
- other tokens. */
+/* other tokens that can be returned by read_token() */
+STRING_INT_ALIST other_token_alist[] = {
+ /* Multiple-character tokens with special values */
+ { "-p", TIMEOPT },
+ { "&&", AND_AND },
+ { "||", OR_OR },
+ { ">>", GREATER_GREATER },
+ { "<<", LESS_LESS },
+ { "<&", LESS_AND },
+ { ">&", GREATER_AND },
+ { ";;", SEMI_SEMI },
+ { "<<-", LESS_LESS_MINUS },
+ { "<<<", LESS_LESS_LESS },
+ { "&>", AND_GREATER },
+ { "<>", LESS_GREATER },
+ { ">|", GREATER_BAR },
+ { "EOF", yacc_EOF },
+ /* Tokens whose value is the character itself */
+ { ">", '>' },
+ { "<", '<' },
+ { "-", '-' },
+ { "{", '{' },
+ { "}", '}' },
+ { ";", ';' },
+ { "(", '(' },
+ { ")", ')' },
+ { "|", '|' },
+ { "&", '&' },
+ { "newline", '\n' },
+ { (char *)NULL, 0}
+};
+
+/* others not listed here:
+ WORD look at yylval.word
+ ASSIGNMENT_WORD look at yylval.word
+ NUMBER look at yylval.number
+ ARITH_CMD look at yylval.word_list
+ ARITH_FOR_EXPRS look at yylval.word_list
+ COND_CMD look at yylval.command
+*/
/* These are used by read_token_word, but appear up here so that shell_getc
can use them to decide when to add otherwise blank lines to the history. */
shell_input_line_index = 0;
shell_input_line_len = i; /* == strlen (shell_input_line) */
+ set_line_mbstate ();
+
#if defined (HISTORY)
if (remember_on_history && shell_input_line && shell_input_line[0])
{
/* We have to force the xrealloc below because we don't know
the true allocated size of shell_input_line anymore. */
shell_input_line_size = shell_input_line_len;
+
+ set_line_mbstate ();
}
}
/* Try to do something intelligent with blank lines encountered while
shell_input_line[shell_input_line_len] = '\n';
shell_input_line[shell_input_line_len + 1] = '\0';
+
+ set_line_mbstate ();
}
}
if (uc)
shell_input_line_index++;
- if (uc == '\\' && remove_quoted_newline &&
- shell_input_line[shell_input_line_index] == '\n')
+ if MBTEST(uc == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n')
{
prompt_again ();
line_number++;
return (uc);
}
-/* Put C back into the input for the shell. */
+/* Put C back into the input for the shell. This might need changes for
+ HANDLE_MULTIBYTE around EOLs. Since we (currently) never push back a
+ character different than we read, shell_input_line_property doesn't need
+ to change when manipulating shell_input_line. The define for
+ last_shell_getc_is_singlebyte should take care of it, though. */
static void
shell_ungetc (c)
int c;
/* OK, we have a token. Let's try to alias expand it, if (and only if)
it's eligible.
- It is eligible for expansion if the shell is in interactive mode, and
+ It is eligible for expansion if EXPAND_ALIASES is set, and
the token is unquoted and the last token read was a command
separator (or expand_next_token is set), and we are currently
processing an alias (pushed_string_list is non-empty) and this
yylval.command = parse_cond_command ();
if (cond_token != COND_END)
{
- if (EOF_Reached && cond_token != COND_ERROR) /* [[ */
- parser_error (cond_lineno, "unexpected EOF while looking for `]]'");
- else if (cond_token != COND_ERROR)
- parser_error (cond_lineno, "syntax error in conditional expression");
+ cond_error ();
return (-1);
}
token_to_read = COND_END;
return (yacc_EOF);
}
- if (character == '#' && (!interactive || interactive_comments))
+ if MBTEST(character == '#' && (!interactive || interactive_comments))
{
/* A comment. Discard until EOL or EOF, and then return a newline. */
discard_until ('\n');
}
/* Shell meta-characters. */
- if (shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
+ if MBTEST(shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
{
#if defined (ALIAS)
/* Turn off alias tokenization iff this character sequence would
peek_char = shell_getc (1);
if (peek_char == '-')
return (LESS_LESS_MINUS);
+ else if (peek_char == '<')
+ return (LESS_LESS_LESS);
else
{
shell_ungetc (peek_char);
#if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
case '(': /* ) */
-# if defined (ARITH_FOR_COMMAND)
- if (last_read_token == FOR)
- {
- int cmdtyp, len;
- char *wval, *wv2;
- WORD_DESC *wd;
-
- arith_for_lineno = line_number;
- cmdtyp = parse_arith_cmd (&wval);
- if (cmdtyp == 1)
- {
- /* parse_arith_cmd adds quotes at the beginning and end
- of the string it returns; we need to take those out. */
- len = strlen (wval);
- wv2 = (char *)xmalloc (len);
- strncpy (wv2, wval + 1, len - 2);
- wv2[len - 2] = '\0';
- wd = make_word (wv2);
- yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
- free (wval);
- free (wv2);
- return (ARITH_FOR_EXPRS);
- }
- else
- return -1; /* ERROR */
- }
-# endif
-# if defined (DPAREN_ARITHMETIC)
- if (reserved_word_acceptable (last_read_token))
- {
- int cmdtyp, sline;
- char *wval;
- WORD_DESC *wd;
-
- sline = line_number;
- cmdtyp = parse_arith_cmd (&wval);
- if (cmdtyp == 1) /* arithmetic command */
- {
- wd = make_word (wval);
- wd->flags = W_QUOTED;
- yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
- free (wval); /* make_word copies it */
- return (ARITH_CMD);
- }
- else if (cmdtyp == 0) /* nested subshell */
- {
- push_string (wval, 0, (alias_t *)NULL);
- if ((parser_state & PST_CASEPAT) == 0)
- parser_state |= PST_SUBSHELL;
- return (character);
- }
- else /* ERROR */
- return -1;
- }
- break;
-# endif
+ result = parse_dparen (character);
+ if (result == -2)
+ break;
+ else
+ return result;
#endif
}
}
- else if (character == '<' && peek_char == '&')
+ else if MBTEST(character == '<' && peek_char == '&')
return (LESS_AND);
- else if (character == '>' && peek_char == '&')
+ else if MBTEST(character == '>' && peek_char == '&')
return (GREATER_AND);
- else if (character == '<' && peek_char == '>')
+ else if MBTEST(character == '<' && peek_char == '>')
return (LESS_GREATER);
- else if (character == '>' && peek_char == '|')
+ else if MBTEST(character == '>' && peek_char == '|')
return (GREATER_BAR);
- else if (peek_char == '>' && character == '&')
+ else if MBTEST(peek_char == '>' && character == '&')
return (AND_GREATER);
shell_ungetc (peek_char);
/* If we look like we are reading the start of a function
definition, then let the reader know about it so that
we will do the right thing with `{'. */
- if (character == ')' && last_read_token == '(' && token_before_that == WORD)
+ if MBTEST(character == ')' && last_read_token == '(' && token_before_that == WORD)
{
parser_state |= PST_ALLOWOPNBRC;
#if defined (ALIAS)
/* case pattern lists may be preceded by an optional left paren. If
we're not trying to parse a case pattern list, the left paren
indicates a subshell. */
- if (character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
+ if MBTEST(character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
parser_state |= PST_SUBSHELL;
/*(*/
- else if ((parser_state & PST_CASEPAT) && character == ')')
+ else if MBTEST((parser_state & PST_CASEPAT) && character == ')')
parser_state &= ~PST_CASEPAT;
/*(*/
- else if ((parser_state & PST_SUBSHELL) && character == ')')
+ else if MBTEST((parser_state & PST_SUBSHELL) && character == ')')
parser_state &= ~PST_SUBSHELL;
#if defined (PROCESS_SUBSTITUTION)
/* Check for the constructs which introduce process substitution.
Shells running in `posix mode' don't do process substitution. */
- if (posixly_correct ||
- ((character != '>' && character != '<') || peek_char != '('))
+ if MBTEST(posixly_correct || ((character != '>' && character != '<') || peek_char != '(')) /*)*/
#endif /* PROCESS_SUBSTITUTION */
return (character);
}
- /* Hack <&- (close stdin) case. */
- if (character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
+ /* Hack <&- (close stdin) case. Also <&N- (dup and close). */
+ if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
return (character);
/* Okay, if we got this far, we have to read a word. Read one,
return result;
}
-/* Match a $(...) or other grouping construct. This has to handle embedded
- quoted strings ('', ``, "") and nested constructs. It also must handle
- reprompting the user, if necessary, after reading a newline, and returning
- correct error values if it reads EOF. */
-
+/*
+ * Match a $(...) or other grouping construct. This has to handle embedded
+ * quoted strings ('', ``, "") and nested constructs. It also must handle
+ * reprompting the user, if necessary, after reading a newline (unless the
+ * P_NONL flag is passed), and returning correct error values if it reads
+ * EOF.
+ */
#define P_FIRSTCLOSE 0x01
#define P_ALLOWESC 0x02
}
RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
- if (ch == CTLESC || ch == CTLNUL)
+ if MBTEST(ch == CTLESC || ch == CTLNUL)
ret[retind++] = CTLESC;
ret[retind++] = ch;
continue;
}
- else if (ch == CTLESC || ch == CTLNUL) /* special shell escapes */
+ else if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
{
RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
ret[retind++] = CTLESC;
ret[retind++] = ch;
continue;
}
- else if (ch == close) /* ending delimiter */
+ else if MBTEST(ch == close) /* ending delimiter */
count--;
#if 1
/* handle nested ${...} specially. */
- else if (open != close && was_dollar && open == '{' && ch == open) /* } */
+ else if MBTEST(open != close && was_dollar && open == '{' && ch == open) /* } */
count++;
#endif
- else if (((flags & P_FIRSTCLOSE) == 0) && ch == open) /* nested begin */
+ else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open) /* nested begin */
count++;
/* Add this character. */
if (open == '\'') /* '' inside grouping construct */
{
- if ((flags & P_ALLOWESC) && ch == '\\')
+ if MBTEST((flags & P_ALLOWESC) && ch == '\\')
pass_next_character++;
continue;
}
- if (ch == '\\') /* backslashes */
+ if MBTEST(ch == '\\') /* backslashes */
pass_next_character++;
if (open != close) /* a grouping construct */
{
- if (shellquote (ch))
+ if MBTEST(shellquote (ch))
{
/* '', ``, or "" inside $(...) or other grouping construct. */
push_delimiter (dstack, ch);
- if (was_dollar && ch == '\'') /* $'...' inside group */
+ if MBTEST(was_dollar && ch == '\'') /* $'...' inside group */
nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC);
else
nestret = parse_matched_pair (ch, ch, ch, &nestlen, 0);
free (ret);
return &matched_pair_error;
}
- if (was_dollar && ch == '\'')
+ if MBTEST(was_dollar && ch == '\'')
{
/* Translate $'...' here. */
ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
nestlen = strlen (nestret);
retind -= 2; /* back up before the $' */
}
- else if (was_dollar && ch == '"')
+ else if MBTEST(was_dollar && ch == '"')
{
/* Locale expand $"..." here. */
ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
nestlen = ttranslen;
retind -= 2; /* back up before the $" */
}
+
if (nestlen)
{
RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64);
/* Parse an old-style command substitution within double quotes as a
single word. */
/* XXX - sh and ksh93 don't do this - XXX */
- else if (open == '"' && ch == '`')
+ else if MBTEST(open == '"' && ch == '`')
{
nestret = parse_matched_pair (0, '`', '`', &nestlen, 0);
if (nestret == &matched_pair_error)
}
FREE (nestret);
}
- else if (was_dollar && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
+ else if MBTEST(was_dollar && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
/* check for $(), $[], or ${} inside quoted string. */
{
if (open == ch) /* undo previous increment */
}
FREE (nestret);
}
- was_dollar = (ch == '$');
+ was_dollar = MBTEST(ch == '$');
}
ret[retind] = '\0';
}
#if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
+/* Parse a double-paren construct. It can be either an arithmetic
+ command, an arithmetic `for' command, or a nested subshell. Returns
+ the parsed token, -1 on error, or -2 if we didn't do anything and
+ should just go on. */
+static int
+parse_dparen (c)
+ int c;
+{
+ int cmdtyp, len, sline;
+ char *wval, *wv2;
+ WORD_DESC *wd;
+
+#if defined (ARITH_FOR_COMMAND)
+ if (last_read_token == FOR)
+ {
+ arith_for_lineno = line_number;
+ cmdtyp = parse_arith_cmd (&wval);
+ if (cmdtyp == 1)
+ {
+ /* parse_arith_cmd adds quotes at the beginning and end
+ of the string it returns; we need to take those out. */
+ len = strlen (wval);
+ wv2 = (char *)xmalloc (len);
+ strncpy (wv2, wval + 1, len - 2);
+ wv2[len - 2] = '\0';
+ wd = make_word (wv2);
+ yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
+ free (wval);
+ free (wv2);
+ return (ARITH_FOR_EXPRS);
+ }
+ else
+ return -1; /* ERROR */
+ }
+#endif
+
+#if defined (DPAREN_ARITHMETIC)
+ if (reserved_word_acceptable (last_read_token))
+ {
+ sline = line_number;
+ cmdtyp = parse_arith_cmd (&wval);
+ if (cmdtyp == 1) /* arithmetic command */
+ {
+ wd = make_word (wval);
+ wd->flags = W_QUOTED;
+ yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
+ free (wval); /* make_word copies it */
+ return (ARITH_CMD);
+ }
+ else if (cmdtyp == 0) /* nested subshell */
+ {
+ push_string (wval, 0, (alias_t *)NULL);
+ if ((parser_state & PST_CASEPAT) == 0)
+ parser_state |= PST_SUBSHELL;
+ return (c);
+ }
+ else /* ERROR */
+ return -1;
+ }
+#endif
+
+ return -2; /* XXX */
+}
+
/* We've seen a `(('. Look for the matching `))'. If we get it, return 1.
If not, assume it's a nested subshell for backwards compatibility and
return 0. In any case, put the characters we've consumed into a locally-
return -1;
/* Check that the next character is the closing right paren. If
not, this is a syntax error. ( */
- if ((c = shell_getc (0)) != ')')
+ c = shell_getc (0);
+ if MBTEST(c != ')')
rval = 0;
tokstr = (char *)xmalloc (ttoklen + 4);
#endif /* DPAREN_ARITHMETIC || ARITH_FOR_COMMAND */
#if defined (COND_COMMAND)
+static void
+cond_error ()
+{
+ char *etext;
+
+ if (EOF_Reached && cond_token != COND_ERROR) /* [[ */
+ parser_error (cond_lineno, "unexpected EOF while looking for `]]'");
+ else if (cond_token != COND_ERROR)
+ {
+ if (etext = error_token_from_token (cond_token))
+ {
+ parser_error (cond_lineno, "syntax error in conditional expression: unexpected token `%s'", etext);
+ free (etext);
+ }
+ else
+ parser_error (cond_lineno, "syntax error in conditional expression");
+ }
+}
+
static COND_COM *
cond_expr ()
{
WORD_DESC *op;
COND_COM *term, *tleft, *tright;
int tok, lineno;
+ char *etext;
/* Read a token. It can be a left paren, a `!', a unary operator, or a
word that should be the first argument of a binary operator. Start by
{
if (term)
dispose_cond_node (term); /* ( */
- parser_error (lineno, "expected `)'");
+ if (etext = error_token_from_token (cond_token))
+ {
+ parser_error (lineno, "unexpected token `%s', expected `)'", etext);
+ free (etext);
+ }
+ else
+ parser_error (lineno, "expected `)'");
COND_RETURN_ERROR ();
}
term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
else
{
dispose_word (op);
- parser_error (line_number, "unexpected argument to conditional unary operator");
+ if (etext = error_token_from_token (tok))
+ {
+ parser_error (line_number, "unexpected argument `%s' to conditional unary operator", etext);
+ free (etext);
+ }
+ else
+ parser_error (line_number, "unexpected argument to conditional unary operator");
COND_RETURN_ERROR ();
}
}
else
{
- parser_error (line_number, "conditional binary operator expected");
+ if (etext = error_token_from_token (tok))
+ {
+ parser_error (line_number, "unexpected token `%s', conditional binary operator expected", etext);
+ free (etext);
+ }
+ else
+ parser_error (line_number, "conditional binary operator expected");
dispose_cond_node (tleft);
COND_RETURN_ERROR ();
}
}
else
{
- parser_error (line_number, "unexpected argument to conditional binary operator");
+ if (etext = error_token_from_token (tok))
+ {
+ parser_error (line_number, "unexpected argument `%s' to conditional binary operator", etext);
+ free (etext);
+ }
+ else
+ parser_error (line_number, "unexpected argument to conditional binary operator");
dispose_cond_node (tleft);
dispose_word (op);
COND_RETURN_ERROR ();
{
if (tok < 256)
parser_error (line_number, "unexpected token `%c' in conditional command", tok);
+ else if (etext = error_token_from_token (tok))
+ {
+ parser_error (line_number, "unexpected token `%s' in conditional command", etext);
+ free (etext);
+ }
else
parser_error (line_number, "unexpected token %d in conditional command", tok);
COND_RETURN_ERROR ();
}
#endif
+#if defined (ARRAY_VARS)
+/* When this is called, it's guaranteed that we don't care about anything
+ in t beyond i. We do save and restore the chars, though. */
+static int
+token_is_assignment (t, i)
+ char *t;
+ int i;
+{
+ unsigned char c, c1;
+ int r;
+
+ c = t[i]; c1 = t[i+1];
+ t[i] = '='; t[i+1] = '\0';
+ r = assignment (t);
+ t[i] = c; t[i+1] = c1;
+ return r;
+}
+
+static int
+token_is_ident (t, i)
+ char *t;
+ int i;
+{
+ unsigned char c;
+ int r;
+
+ c = t[i];
+ t[i] = '\0';
+ r = legal_identifier (t);
+ t[i] = c;
+ return r;
+}
+#endif
+
static int
read_token_word (character)
int character;
int result, peek_char;
char *ttok, *ttrans;
int ttoklen, ttranslen;
- long lvalue;
+ intmax_t lvalue;
if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
token = (char *)xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
/* Handle backslashes. Quote lots of things when not inside of
double-quotes, quote some things inside of double-quotes. */
- if (character == '\\')
+ if MBTEST(character == '\\')
{
peek_char = shell_getc (0);
}
/* Parse a matched pair of quote characters. */
- if (shellquote (character))
+ if MBTEST(shellquote (character))
{
push_delimiter (dstack, character);
ttok = parse_matched_pair (character, character, character, &ttoklen, 0);
if (extended_glob && PATTERN_CHAR (character))
{
peek_char = shell_getc (1);
- if (peek_char == '(') /* ) */
+ if MBTEST(peek_char == '(') /* ) */
{
push_delimiter (dstack, peek_char);
ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
{
peek_char = shell_getc (1);
/* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
- if (peek_char == '(' ||
+ if MBTEST(peek_char == '(' || \
((peek_char == '{' || peek_char == '[') && character == '$')) /* ) ] } */
{
if (peek_char == '{') /* } */
goto next_character;
}
/* This handles $'...' and $"..." new-style quoted strings. */
- else if (character == '$' && (peek_char == '\'' || peek_char == '"'))
+ else if MBTEST(character == '$' && (peek_char == '\'' || peek_char == '"'))
{
int first_line;
}
/* This could eventually be extended to recognize all of the
shell's single-character parameter expansions, and set flags.*/
- else if (character == '$' && peek_char == '$')
+ else if MBTEST(character == '$' && peek_char == '$')
{
ttok = (char *)xmalloc (3);
ttok[0] = ttok[1] = '$';
}
#if defined (ARRAY_VARS)
+ /* Identify possible array subscript assignment; match [...] */
+ else if MBTEST(character == '[' && token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index)) /* ] */
+ {
+ ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
+ if (ttok == &matched_pair_error)
+ return -1; /* Bail immediately. */
+ RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
+ token_buffer_size,
+ TOKEN_DEFAULT_GROW_SIZE);
+ token[token_index++] = character;
+ strcpy (token + token_index, ttok);
+ token_index += ttoklen;
+ FREE (ttok);
+ all_digit_token = 0;
+ goto next_character;
+ }
/* Identify possible compound array variable assignment. */
- else if (character == '=' && token_index > 0)
+ else if MBTEST(character == '=' && token_index > 0 && token_is_assignment (token, token_index))
{
peek_char = shell_getc (1);
- if (peek_char == '(') /* ) */
+ if MBTEST(peek_char == '(') /* ) */
{
- ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
- if (ttok == &matched_pair_error)
- return -1; /* Bail immediately. */
- if (ttok[0] == '(') /* ) */
- {
- FREE (ttok);
- return -1;
- }
- RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
+ ttok = parse_compound_assignment (&ttoklen);
+
+ RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 4,
token_buffer_size,
TOKEN_DEFAULT_GROW_SIZE);
- token[token_index++] = character;
- token[token_index++] = peek_char;
- strcpy (token + token_index, ttok);
- token_index += ttoklen;
+
+ token[token_index++] = '=';
+ token[token_index++] = '(';
+ if (ttok)
+ {
+ strcpy (token + token_index, ttok);
+ token_index += ttoklen;
+ }
+ token[token_index++] = ')';
FREE (ttok);
all_digit_token = 0;
goto next_character;
/* When not parsing a multi-character word construct, shell meta-
characters break words. */
- if (shellbreak (character))
+ if MBTEST(shellbreak (character))
{
shell_ungetc (character);
goto got_token;
next_character:
if (character == '\n' && interactive &&
- (bash_input.type == st_stdin || bash_input.type == st_stream))
+ (bash_input.type == st_stdin || bash_input.type == st_stream))
prompt_again ();
/* We want to remove quoted newlines (that is, a \<newline> pair)
is a `<', or a `&', or the character which ended this token is
a '>' or '<', then, and ONLY then, is this input token a NUMBER.
Otherwise, it is just a word, and should be returned as such. */
- if (all_digit_token && (character == '<' || character == '>' ||
- last_read_token == LESS_AND ||
+ if MBTEST(all_digit_token && (character == '<' || character == '>' || \
+ last_read_token == LESS_AND || \
last_read_token == GREATER_AND))
{
if (legal_number (token, &lvalue) && (int)lvalue == lvalue)
}
/* Check for special case tokens. */
- result = special_case_tokens (token);
+ result = (last_shell_getc_is_singlebyte) ? special_case_tokens (token) : -1;
if (result >= 0)
return result;
/* Posix.2 does not allow reserved words to be aliased, so check for all
of them, including special cases, before expanding the current token
as an alias. */
- if (posixly_correct)
+ if MBTEST(posixly_correct)
CHECK_FOR_RESERVED_WORD (token);
/* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
/* If not in Posix.2 mode, check for reserved words after alias
expansion. */
- if (posixly_correct == 0)
+ if MBTEST(posixly_correct == 0)
#endif
CHECK_FOR_RESERVED_WORD (token);
return (result);
}
-/* $'...' ANSI-C expand the portion of STRING between START and END and
- return the result. The result cannot be longer than the input string. */
-static char *
-ansiexpand (string, start, end, lenp)
- char *string;
- int start, end, *lenp;
-{
- char *temp, *t;
- int len, tlen;
-
- temp = (char *)xmalloc (end - start + 1);
- for (tlen = 0, len = start; len < end; )
- temp[tlen++] = string[len++];
- temp[tlen] = '\0';
-
- if (*temp)
- {
- t = ansicstr (temp, tlen, 0, (int *)NULL, lenp);
- free (temp);
- return (t);
- }
- else
- {
- if (lenp)
- *lenp = 0;
- return (temp);
- }
-}
-
-/* Change a bash string into a string suitable for inclusion in a `po' file.
- This backslash-escapes `"' and `\' and changes newlines into \\\n"\n". */
-static char *
-mk_msgstr (string, foundnlp)
- char *string;
- int *foundnlp;
-{
- register int c, len;
- char *result, *r, *s;
-
- for (len = 0, s = string; s && *s; s++)
- {
- len++;
- if (*s == '"' || *s == '\\')
- len++;
- else if (*s == '\n')
- len += 5;
- }
-
- r = result = (char *)xmalloc (len + 3);
- *r++ = '"';
-
- for (s = string; s && (c = *s); s++)
- {
- if (c == '\n') /* <NL> -> \n"<NL>" */
- {
- *r++ = '\\';
- *r++ = 'n';
- *r++ = '"';
- *r++ = '\n';
- *r++ = '"';
- if (foundnlp)
- *foundnlp = 1;
- continue;
- }
- if (c == '"' || c == '\\')
- *r++ = '\\';
- *r++ = c;
- }
-
- *r++ = '"';
- *r++ = '\0';
-
- return result;
-}
-
-/* $"..." -- Translate the portion of STRING between START and END
- according to current locale using gettext (if available) and return
- the result. The caller will take care of leaving the quotes intact.
- The string will be left without the leading `$' by the caller.
- If translation is performed, the translated string will be double-quoted
- by the caller. The length of the translated string is returned in LENP,
- if non-null. */
-static char *
-localeexpand (string, start, end, lineno, lenp)
- char *string;
- int start, end, lineno, *lenp;
-{
- int len, tlen, foundnl;
- char *temp, *t, *t2;
-
- temp = (char *)xmalloc (end - start + 1);
- for (tlen = 0, len = start; len < end; )
- temp[tlen++] = string[len++];
- temp[tlen] = '\0';
-
- /* If we're just dumping translatable strings, don't do anything with the
- string itself, but if we're dumping in `po' file format, convert it into a form more palatable to gettext(3)
- and friends by quoting `"' and `\' with backslashes and converting <NL>
- into `\n"<NL>"'. If we find a newline in TEMP, we first output a
- `msgid ""' line and then the translated string; otherwise we output the
- `msgid' and translated string all on one line. */
- if (dump_translatable_strings)
- {
- if (dump_po_strings)
- {
- foundnl = 0;
- t = mk_msgstr (temp, &foundnl);
- t2 = foundnl ? "\"\"\n" : "";
-
- printf ("#: %s:%d\nmsgid %s%s\nmsgstr \"\"\n",
- (bash_input.name ? bash_input.name : "stdin"), lineno, t2, t);
- free (t);
- }
- else
- printf ("\"%s\"\n", temp);
-
- if (lenp)
- *lenp = tlen;
- return (temp);
- }
- else if (*temp)
- {
- t = localetrans (temp, tlen, &len);
- free (temp);
- if (lenp)
- *lenp = len;
- return (t);
- }
- else
- {
- if (lenp)
- *lenp = 0;
- return (temp);
- }
-}
-
/* Return 1 if TOKSYM is a token that after being read would allow
a reserved word to be seen, else 0. */
static int
reserved_word_acceptable (toksym)
int toksym;
{
- if (toksym == '\n' || toksym == ';' || toksym == '(' || toksym == ')' ||
- toksym == '|' || toksym == '&' || toksym == '{' ||
- toksym == '}' || /* XXX */
- toksym == AND_AND ||
- toksym == BANG ||
- toksym == TIME || toksym == TIMEOPT ||
- toksym == DO ||
- toksym == ELIF ||
- toksym == ELSE ||
- toksym == FI ||
- toksym == IF ||
- toksym == OR_OR ||
- toksym == SEMI_SEMI ||
- toksym == THEN ||
- toksym == UNTIL ||
- toksym == WHILE ||
- toksym == DONE || /* XXX these two are experimental */
- toksym == ESAC ||
- toksym == 0)
- return (1);
- else
- return (0);
+ switch (toksym)
+ {
+ case '\n':
+ case ';':
+ case '(':
+ case ')':
+ case '|':
+ case '&':
+ case '{':
+ case '}': /* XXX */
+ case AND_AND:
+ case BANG:
+ case DO:
+ case DONE:
+ case ELIF:
+ case ELSE:
+ case ESAC:
+ case FI:
+ case IF:
+ case OR_OR:
+ case SEMI_SEMI:
+ case THEN:
+ case TIME:
+ case TIMEOPT:
+ case UNTIL:
+ case WHILE:
+ case 0:
+ return 1;
+ default:
+ return 0;
+ }
}
-
+
/* Return the index of TOKEN in the alist of reserved words, or -1 if
TOKEN is not a shell reserved word. */
int
may contain special characters which are decoded as follows:
\a bell (ascii 07)
- \e escape (ascii 033)
\d the date in Day Mon Date format
+ \e escape (ascii 033)
\h the hostname up to the first `.'
\H the hostname
\j the number of active jobs
\l the basename of the shell's tty device name
\n CRLF
+ \r CR
\s the name of the shell
\t the time in 24-hour hh:mm:ss format
\T the time in 12-hour hh:mm:ss format
- \@ the time in 12-hour am/pm format
+ \@ the time in 12-hour hh:mm am/pm format
+ \A the time in 24-hour hh:mm format
+ \D{fmt} the result of passing FMT to strftime(3)
+ \u your username
\v the version of bash (e.g., 2.00)
\V the release of bash, version + patchlevel (e.g., 2.00.0)
\w the current working directory
\W the last element of $PWD
- \u your username
- \# the command number of this command
\! the history number of this command
+ \# the command number of this command
\$ a $ or a # if you are root
\nnn character code nnn in octal
\\ a backslash
int result_size, result_index;
int c, n;
char *temp, octal_string[4];
+ struct tm *tm;
time_t the_time;
+ char timebuf[128];
+ char *timefmt;
result = (char *)xmalloc (result_size = PROMPT_GROWTH);
result[result_index = 0] = 0;
for (c = 0; n != -1 && c < 3 && ISOCTAL (*string); c++)
string++;
- c = 0;
+ c = 0; /* tested at add_string: */
goto add_string;
- case 't':
case 'd':
+ case 't':
case 'T':
case '@':
case 'A':
/* Make the current time/date into a string. */
- the_time = time (0);
- temp = ctime (&the_time);
+ (void) time (&the_time);
+ tm = localtime (&the_time);
+
+ if (c == 'd')
+ n = strftime (timebuf, sizeof (timebuf), "%a %b %d", tm);
+ else if (c == 't')
+ n = strftime (timebuf, sizeof (timebuf), "%H:%M:%S", tm);
+ else if (c == 'T')
+ n = strftime (timebuf, sizeof (timebuf), "%I:%M:%S", tm);
+ else if (c == '@')
+ n = strftime (timebuf, sizeof (timebuf), "%I:%M %p", tm);
+ else if (c == 'A')
+ n = strftime (timebuf, sizeof (timebuf), "%H:%M", tm);
+
+ timebuf[sizeof(timebuf) - 1] = '\0';
+ temp = savestring (timebuf);
+ goto add_string;
- temp = (c != 'd') ? savestring (temp + 11) : savestring (temp);
- temp[(c != 'd') ? 8 : 10] = '\0';
- temp[(c != 'A') ? 10 : 5] = '\0';
+ case 'D': /* strftime format */
+ if (string[1] != '{') /* } */
+ goto not_escape;
- /* quick and dirty conversion to 12-hour time */
- if (c == 'T' || c == '@')
+ (void) time (&the_time);
+ tm = localtime (&the_time);
+ string += 2; /* skip { */
+ timefmt = xmalloc (strlen (string) + 3);
+ for (t = timefmt; *string && *string != '}'; )
+ *t++ = *string++;
+ *t = '\0';
+ c = *string; /* tested at add_string */
+ if (timefmt[0] == '\0')
{
- if (c == '@')
- {
- temp[5] = 'a'; /* am/pm format */
- temp[6] = 'm';
- temp[7] = '\0';
- }
- c = temp[2];
- temp[2] = '\0';
- n = atoi (temp);
- temp[2] = c;
- n -= 12;
- if (n > 0)
- {
- temp[0] = (n / 10) + '0';
- temp[1] = (n % 10) + '0';
- }
- if (n >= 0 && temp[5] == 'a')
- temp[5] = 'p';
+ timefmt[0] = '%';
+ timefmt[1] = 'X'; /* locale-specific current time */
+ timefmt[2] = '\0';
}
+ n = strftime (timebuf, sizeof (timebuf), timefmt, tm);
+ free (timefmt);
+
+ timebuf[sizeof(timebuf) - 1] = '\0';
+ if (promptvars || posixly_correct)
+ /* Make sure that expand_prompt_string is called with a
+ second argument of Q_DOUBLE_QUOTES if we use this
+ function here. */
+ temp = sh_backslash_quote_for_double_quotes (timebuf);
+ else
+ temp = savestring (timebuf);
goto add_string;
-
- case 'r':
- temp = (char *)xmalloc (2);
- temp[0] = '\r';
- temp[1] = '\0';
- goto add_string;
-
+
case 'n':
temp = (char *)xmalloc (3);
temp[0] = no_line_editing ? '\n' : '\r';
case 'v':
case 'V':
- temp = (char *)xmalloc (8);
+ temp = (char *)xmalloc (16);
if (c == 'v')
strcpy (temp, dist_version);
else
quote the directory name. */
if (promptvars || posixly_correct)
/* Make sure that expand_prompt_string is called with a
- second argument of Q_DOUBLE_QUOTE if we use this
+ second argument of Q_DOUBLE_QUOTES if we use this
function here. */
temp = sh_backslash_quote_for_double_quotes (t_string);
else
#endif /* READLINE */
case '\\':
- temp = (char *)xmalloc (2);
- temp[0] = c;
- temp[1] = '\0';
- goto add_string;
-
case 'a':
case 'e':
+ case 'r':
temp = (char *)xmalloc (2);
- temp[0] = (c == 'a') ? '\07' : '\033';
+ if (c == 'a')
+ temp[0] = '\07';
+ else if (c == 'e')
+ temp[0] = '\033';
+ else if (c == 'r')
+ temp[0] = '\r';
+ else /* (c == '\\') */
+ temp[0] = c;
temp[1] = '\0';
goto add_string;
default:
+not_escape:
temp = (char *)xmalloc (3);
temp[0] = '\\';
temp[1] = c;
return (result);
}
+/************************************************
+ * *
+ * ERROR HANDLING *
+ * *
+ ************************************************/
+
/* Report a syntax error, and restart the parser. Call here for fatal
errors. */
int
return (0);
}
+static char *
+error_token_from_token (token)
+ int token;
+{
+ char *t;
+
+ if (t = find_token_in_alist (token, word_token_alist, 0))
+ return t;
+
+ if (t = find_token_in_alist (token, other_token_alist, 0))
+ return t;
+
+ t = (char *)NULL;
+ /* This stuff is dicy and needs closer inspection */
+ switch (current_token)
+ {
+ case WORD:
+ case ASSIGNMENT_WORD:
+ if (yylval.word)
+ t = savestring (yylval.word->word);
+ break;
+ case NUMBER:
+ t = itos (yylval.number);
+ break;
+ case ARITH_CMD:
+ if (yylval.word_list)
+ t = string_list (yylval.word_list);
+ break;
+ case ARITH_FOR_EXPRS:
+ if (yylval.word_list)
+ t = string_list_internal (yylval.word_list, " ; ");
+ break;
+ case COND_CMD:
+ t = (char *)NULL; /* punt */
+ break;
+ }
+
+ return t;
+}
+
+static char *
+error_token_from_text ()
+{
+ char *msg, *t;
+ int token_end, i;
+
+ t = shell_input_line;
+ i = shell_input_line_index;
+ token_end = 0;
+ msg = (char *)NULL;
+
+ if (i && t[i] == '\0')
+ i--;
+
+ while (i && (whitespace (t[i]) || t[i] == '\n'))
+ i--;
+
+ if (i)
+ token_end = i + 1;
+
+ while (i && (member (t[i], " \n\t;|&") == 0))
+ i--;
+
+ while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
+ i++;
+
+ /* Return our idea of the offending token. */
+ if (token_end || (i == 0 && token_end == 0))
+ {
+ if (token_end)
+ msg = substring (t, i, token_end);
+ else /* one-character token */
+ {
+ msg = (char *)xmalloc (2);
+ msg[0] = t[i];
+ msg[1] = '\0';
+ }
+ }
+
+ return (msg);
+}
+
+static void
+print_offending_line ()
+{
+ char *msg;
+ int token_end;
+
+ msg = savestring (shell_input_line);
+ token_end = strlen (msg);
+ while (token_end && msg[token_end - 1] == '\n')
+ msg[--token_end] = '\0';
+
+ parser_error (line_number, "`%s'", msg);
+ free (msg);
+}
+
/* Report a syntax error with line numbers, etc.
Call here for recoverable errors. If you have a message to print,
then place it in MESSAGE, otherwise pass NULL and this will figure
report_syntax_error (message)
char *message;
{
- char *msg, *t;
- int token_end, i;
- char msg2[2];
+ char *msg;
if (message)
{
}
/* If the line of input we're reading is not null, try to find the
- objectionable token. */
- if (shell_input_line && *shell_input_line)
+ objectionable token. First, try to figure out what token the
+ parser's complaining about by looking at current_token. */
+ if (current_token != 0 && EOF_Reached == 0 && (msg = error_token_from_token (current_token)))
{
- t = shell_input_line;
- i = shell_input_line_index;
- token_end = 0;
-
- if (i && t[i] == '\0')
- i--;
-
- while (i && (whitespace (t[i]) || t[i] == '\n'))
- i--;
+ parser_error (line_number, "syntax error near unexpected token `%s'", msg);
+ free (msg);
- if (i)
- token_end = i + 1;
-
- while (i && (member (t[i], " \n\t;|&") == 0))
- i--;
+ if (interactive == 0)
+ print_offending_line ();
- while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
- i++;
+ last_command_exit_value = EX_USAGE;
+ return;
+ }
- /* Print the offending token. */
- if (token_end || (i == 0 && token_end == 0))
+ /* If looking at the current token doesn't prove fruitful, try to find the
+ offending token by analyzing the text of the input line near the current
+ input line index and report what we find. */
+ if (shell_input_line && *shell_input_line)
+ {
+ msg = error_token_from_text ();
+ if (msg)
{
- if (token_end)
- msg = substring (t, i, token_end);
- else /* one-character token */
- {
- msg2[0] = t[i];
- msg2[1] = '\0';
- msg = msg2;
- }
-
- parser_error (line_number, "syntax error near unexpected token `%s'", msg);
-
- if (msg != msg2)
- free (msg);
+ parser_error (line_number, "syntax error near `%s'", msg);
+ free (msg);
}
/* If not interactive, print the line containing the error. */
if (interactive == 0)
- {
- msg = savestring (shell_input_line);
- token_end = strlen (msg);
- while (token_end && msg[token_end - 1] == '\n')
- msg[--token_end] = '\0';
-
- parser_error (line_number, "`%s'", msg);
- free (msg);
- }
+ print_offending_line ();
}
else
{
if (interactive && EOF_Reached)
EOF_Reached = 0;
}
+
last_command_exit_value = EX_USAGE;
}
created during parsing. In the case of error, we want to return
allocated objects to the memory pool. In the case of no error, we want
to throw away the information about where the allocated objects live.
- (dispose_command () will actually free the command. */
+ (dispose_command () will actually free the command.) */
static void
discard_parser_constructs (error_p)
int error_p;
{
}
+/************************************************
+ * *
+ * EOF HANDLING *
+ * *
+ ************************************************/
+
/* Do that silly `type "bye" to exit' stuff. You know, "ignoreeof". */
/* A flag denoting whether or not ignoreeof is set. */
fprintf (stderr, "Use \"%s\" to leave the shell.\n",
login_shell ? "logout" : "exit");
eof_encountered++;
+ /* Reset the parsing state. */
+ last_read_token = current_token = '\n';
/* Reset the prompt string to be $PS1. */
prompt_string_pointer = (char **)NULL;
prompt_again ();
- last_read_token = current_token = '\n';
return;
}
}
}
}
+/************************************************
+ * *
+ * STRING PARSING FUNCTIONS *
+ * *
+ ************************************************/
+
+/* It's very important that these two functions treat the characters
+ between ( and ) identically. */
+
static WORD_LIST parse_string_error;
/* Take a string and run it through the shell parser, returning the
const char *whom;
{
WORD_LIST *wl;
- int tok, orig_line_number, orig_input_terminator;
+ int tok, orig_current_token, orig_line_number, orig_input_terminator;
int orig_line_count;
+ int old_echo_input, old_expand_aliases;
#if defined (HISTORY)
int old_remember_on_history, old_history_expansion_inhibited;
#endif
orig_line_number = line_number;
orig_line_count = current_command_line_count;
orig_input_terminator = shell_input_line_terminator;
+ old_echo_input = echo_input_at_read;
+ old_expand_aliases = expand_aliases;
push_stream (1);
- last_read_token = '\n';
+ last_read_token = WORD; /* WORD to allow reserved words here */
current_command_line_count = 0;
+ echo_input_at_read = expand_aliases = 0;
with_input_from_string (s, whom);
wl = (WORD_LIST *)NULL;
if (tok != WORD && tok != ASSIGNMENT_WORD)
{
line_number = orig_line_number + line_number - 1;
+ orig_current_token = current_token;
+ current_token = tok;
yyerror ((char *)NULL); /* does the right thing */
+ current_token = orig_current_token;
if (wl)
dispose_words (wl);
wl = &parse_string_error;
# endif /* BANG_HISTORY */
#endif /* HISTORY */
+ echo_input_at_read = old_echo_input;
+ expand_aliases = old_expand_aliases;
+
current_command_line_count = orig_line_count;
shell_input_line_terminator = orig_input_terminator;
return (REVERSE_LIST (wl, WORD_LIST *));
}
+
+static char *
+parse_compound_assignment (retlenp)
+ int *retlenp;
+{
+ WORD_LIST *wl, *rl;
+ int tok, orig_line_number, orig_token_size;
+ char *saved_token, *ret;
+
+ saved_token = token;
+ orig_token_size = token_buffer_size;
+ orig_line_number = line_number;
+
+ last_read_token = WORD; /* WORD to allow reserved words here */
+
+ token = (char *)NULL;
+ token_buffer_size = 0;
+
+ wl = (WORD_LIST *)NULL; /* ( */
+ while ((tok = read_token (READ)) != ')')
+ {
+ if (tok == '\n') /* Allow newlines in compound assignments */
+ continue;
+ if (tok != WORD && tok != ASSIGNMENT_WORD)
+ {
+ current_token = tok; /* for error reporting */
+ if (tok == yacc_EOF) /* ( */
+ parser_error (orig_line_number, "unexpected EOF while looking for matching `)'");
+ else
+ yyerror ((char *)NULL); /* does the right thing */
+ if (wl)
+ dispose_words (wl);
+ wl = &parse_string_error;
+ break;
+ }
+ wl = make_word_list (yylval.word, wl);
+ }
+
+ FREE (token);
+ token = saved_token;
+ token_buffer_size = orig_token_size;
+
+ if (wl == &parse_string_error)
+ {
+ last_command_exit_value = EXECUTION_FAILURE;
+ last_read_token = '\n'; /* XXX */
+ if (interactive_shell == 0 && posixly_correct)
+ jump_to_top_level (FORCE_EOF);
+ else
+ jump_to_top_level (DISCARD);
+ }
+
+ last_read_token = WORD;
+ if (wl)
+ {
+ rl = REVERSE_LIST (wl, WORD_LIST *);
+ ret = string_list (rl);
+ dispose_words (rl);
+ }
+ else
+ ret = (char *)NULL;
+
+ if (retlenp)
+ *retlenp = (ret && *ret) ? strlen (ret) : 0;
+ return ret;
+}
+
+/************************************************
+ * *
+ * MULTIBYTE CHARACTER HANDLING *
+ * *
+ ************************************************/
+
+#if defined (HANDLE_MULTIBYTE)
+static void
+set_line_mbstate ()
+{
+ int i, previ, len;
+ mbstate_t mbs, prevs;
+ size_t mbclen;
+
+ if (shell_input_line == NULL)
+ return;
+ len = strlen (shell_input_line); /* XXX - shell_input_line_len ? */
+ FREE (shell_input_line_property);
+ shell_input_line_property = (char *)xmalloc (len + 1);
+
+ memset (&prevs, '\0', sizeof (mbstate_t));
+ for (i = previ = 0; i < len; i++)
+ {
+ mbs = prevs;
+
+ if (shell_input_line[i] == EOF)
+ {
+ int j;
+ for (j = i; j < len; j++)
+ shell_input_line_property[j] = 1;
+ break;
+ }
+
+ mbclen = mbrlen (shell_input_line + previ, i - previ + 1, &mbs);
+ if (mbclen == 1 || mbclen == (size_t)-1)
+ {
+ mbclen = 1;
+ previ = i + 1;
+ }
+ else if (mbclen == (size_t)-2)
+ mbclen = 0;
+ else if (mbclen > 1)
+ {
+ mbclen = 0;
+ previ = i + 1;
+ prevs = mbs;
+ }
+ else
+ {
+ /* mbrlen doesn't return any other values */
+ }
+
+ shell_input_line_property[i] = mbclen;
+ }
+}
+#endif /* HANDLE_MULTIBYTE */
projects / platform / upstream / bash.git / blobdiff