/* A Bison parser, made from parse.y */ #define IF 258 #define THEN 259 #define ELSE 260 #define ELIF 261 #define FI 262 #define CASE 263 #define ESAC 264 #define FOR 265 #define WHILE 266 #define UNTIL 267 #define DO 268 #define DONE 269 #define FUNCTION 270 #define IN 271 #define BANG 272 #define WORD 273 #define NUMBER 274 #define AND_AND 275 #define OR_OR 276 #define GREATER_GREATER 277 #define LESS_LESS 278 #define LESS_AND 279 #define GREATER_AND 280 #define SEMI_SEMI 281 #define LESS_LESS_MINUS 282 #define AND_GREATER 283 #define LESS_GREATER 284 #define GREATER_BAR 285 #define yacc_EOF 286 #line 21 "parse.y" #include #include #include #include "shell.h" #include "flags.h" #if defined (READLINE) #include #endif /* READLINE */ #include #if defined (JOB_CONTROL) # include "jobs.h" #endif /* JOB_CONTROL */ #define YYDEBUG 1 extern int eof_encountered; extern int no_line_editing; extern int interactive, interactive_shell; /* **************************************************************** */ /* */ /* "Forward" declarations */ /* */ /* **************************************************************** */ /* This is kind of sickening. In order to let these variables be seen by all the functions that need them, I am forced to place their declarations far away from the place where they should logically be found. */ static int reserved_word_acceptable (); /* PROMPT_STRING_POINTER points to one of these, never to an actual string. */ char *ps1_prompt, *ps2_prompt; /* Handle on the current prompt string. Indirectly points through ps1_ or ps2_prompt. */ char **prompt_string_pointer = (char **)NULL; char *current_prompt_string; /* The number of lines read from input while creating the current command. */ int current_command_line_count = 0; /* Variables to manage the task of reading here documents, because we need to defer the reading until after a complete command has been collected. */ REDIRECT *redirection_needing_here_doc = (REDIRECT *)NULL; int need_here_doc = 0; #line 72 "parse.y" typedef union { WORD_DESC *word; /* the word that we read. */ int number; /* the number that we read. */ WORD_LIST *word_list; COMMAND *command; REDIRECT *redirect; ELEMENT element; PATTERN_LIST *pattern; } YYSTYPE; #ifndef YYLTYPE typedef struct yyltype { int timestamp; int first_line; int first_column; int last_line; int last_column; char *text; } yyltype; #define YYLTYPE yyltype #endif #include #ifndef __STDC__ #define const #endif #define YYFINAL 228 #define YYFLAG -32768 #define YYNTBASE 43 #define YYTRANSLATE(x) ((unsigned)(x) <= 286 ? yytranslate[x] : 68) static const char yytranslate[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 33, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 31, 2, 41, 42, 2, 2, 2, 38, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 32, 37, 2, 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 39, 35, 40, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 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, 2, 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, 34 }; static const short yyrline[] = { 0, 113, 122, 129, 145, 155, 157, 161, 163, 165, 167, 169, 171, 173, 179, 185, 189, 193, 197, 201, 206, 211, 216, 221, 228, 235, 237, 239, 241, 243, 245, 247, 257, 259, 263, 265, 269, 273, 284, 286, 290, 292, 296, 298, 301, 305, 307, 309, 311, 314, 316, 319, 321, 323, 328, 330, 332, 335, 338, 341, 344, 347, 351, 353, 355, 360, 364, 366, 368, 372, 373, 377, 379, 381, 383, 387, 389, 393, 395, 397, 399, 403, 405, 414, 423, 424, 425, 427, 431, 433, 435, 437, 439, 441, 443, 450, 451, 452, 455, 456, 465, 472, 479, 488, 490, 492, 494, 496, 498, 505, 508 }; static const char * const yytname[] = { 0, "error","$illegal.","IF","THEN","ELSE","ELIF","FI","CASE","ESAC","FOR", "WHILE","UNTIL","DO","DONE","FUNCTION","IN","BANG","WORD","NUMBER","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" }; static const short yyr1[] = { 0, 43, 43, 43, 43, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 46, 46, 47, 47, 48, 48, 49, 49, 50, 50, 50, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 52, 52, 52, 53, 54, 54, 54, 55, 55, 56, 56, 56, 56, 57, 57, 58, 58, 58, 58, 59, 59, 60, 61, 61, 61, 61, 62, 62, 62, 62, 62, 62, 62, 63, 63, 63, 64, 64, 65, 65, 65, 66, 66, 66, 66, 66, 66, 67, 67 }; static const short yyr2[] = { 0, 2, 1, 2, 1, 0, 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, 2, 1, 2, 1, 1, 1, 2, 2, 6, 6, 7, 7, 10, 10, 6, 7, 6, 1, 5, 5, 3, 1, 5, 6, 4, 5, 7, 6, 3, 4, 6, 5, 1, 2, 4, 4, 5, 5, 1, 2, 5, 5, 6, 6, 1, 3, 2, 1, 3, 3, 3, 4, 4, 4, 4, 4, 1, 2, 1, 1, 1, 0, 2, 1, 2, 2, 4, 4, 3, 3, 1, 2, 4, 1 }; static const short yydefact[] = { 0, 0, 98, 0, 0, 98, 98, 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 0, 0, 98, 98, 35, 38, 0, 40, 110, 41, 42, 54, 58, 0, 100, 107, 3, 0, 0, 98, 98, 0, 0, 98, 108, 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, 0, 37, 44, 34, 35, 39, 36, 43, 1, 98, 98, 101, 102, 98, 98, 0, 99, 83, 84, 93, 0, 98, 0, 98, 98, 0, 0, 98, 12, 14, 20, 16, 28, 22, 18, 26, 24, 30, 33, 9, 10, 65, 57, 0, 0, 105, 106, 0, 0, 94, 98, 98, 98, 98, 98, 98, 0, 98, 5, 98, 0, 0, 98, 61, 0, 103, 104, 0, 0, 109, 98, 98, 62, 0, 0, 0, 86, 87, 85, 0, 69, 98, 75, 0, 98, 98, 0, 0, 0, 55, 56, 0, 59, 0, 0, 64, 88, 89, 90, 91, 92, 53, 70, 76, 0, 51, 81, 0, 0, 0, 0, 45, 6, 96, 95, 97, 98, 46, 60, 63, 98, 98, 98, 98, 52, 0, 0, 98, 47, 48, 0, 66, 0, 0, 0, 98, 82, 71, 72, 98, 98, 98, 68, 73, 74, 77, 78, 0, 0, 67, 79, 80, 49, 50, 0, 0, 0 }; static const short yydefgoto[] = { 226, 159, 25, 26, 27, 28, 29, 30, 31, 32, 33, 145, 151, 152, 153, 154, 180, 38, 89, 90, 188, 39, 34, 117, 91 }; static const short yypact[] = { 202, -18,-32768, 9, 23,-32768,-32768, 31, 394, 10, 466, 38, 44, 35, 56, 54, 74, 77, 87,-32768,-32768, 92, 100,-32768,-32768, 18,-32768, 426, 450,-32768,-32768, 84,-32768,-32768, 86, 96, 88,-32768, 118, 266,-32768, 102, 135, 136, 121, 88, 128, 145, 154, 61, 64, 158, 159, 170, 172, 173,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 160, 157, 10,-32768,-32768,-32768,-32768,-32768,-32768, 84,-32768, -32768,-32768, 330, 330,-32768,-32768, 394,-32768,-32768, 111, 88, 1,-32768, 19,-32768,-32768, 162, 7,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768, 298, 298, 3, 3, 362, 140, 88,-32768,-32768,-32768,-32768,-32768,-32768, -8,-32768,-32768, -32768, 182, 184,-32768,-32768, 7,-32768,-32768, 330, 330, 88,-32768,-32768,-32768, 194, 266, 266, 266, 266, 266, 200,-32768,-32768,-32768, 27,-32768,-32768, 197, 107, 175, -32768,-32768, 7,-32768, 209, 214,-32768,-32768,-32768, 17, 17, 17,-32768,-32768,-32768, 30,-32768,-32768, 204, 58, 219, 183,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768, 123, 210,-32768,-32768, -32768, 37, 72, 266, 266, 266,-32768,-32768, 208, 156, -32768,-32768,-32768,-32768, 221, 234,-32768,-32768, 226, 215, -32768,-32768,-32768,-32768,-32768, 248, 250,-32768 }; static const short yypgoto[] = {-32768, -32768, -15, 237, 223,-32768,-32768,-32768, 239,-32768, -94, 65,-32768, 119,-32768, 126, 101, -5,-32768, -139,-32768, -38,-32768, 20, 14 }; #define YYLAST 503 static const short yytable[] = { 42, 43, 92, 94, 135, 156, 98, 168, 169, 170, 171, 172, 73, 76, 36, 37, 78, 127, 70, 71, 35, -36, 45, 81, 82, 88, -36, 40, -36, -36, -36, 157, 129, -36, 88, 130, 177, 122, 123, 196, 88, 41, 164, 115, 116, 178, 23, 119, 178, 44, 211, 46, 88, 58, 59, 128, 56, -36, 131, -36, 88, 136, 57, 88, 73, 170, 171, 172, 179, 190, 88, 179, 64, 60, 61, 62, 212, 213, 143, 102, 103, 120, 105, 106, 146, 147, 148, 149, 150, 155, 132, 133, 65, 198, 63, 66, 163, 36, 36, 104, 199, 121, 107, 10, 118, 67, 11, 12, 13, 14, 68, 15, 16, 17, 18, 176, 81, 82, 69, 80, 21, 22, 86, 85, 158, 184, 160, 83, 84, 36, 36, 122, 123, 141, 93, 137, 138, 165, 166, 185, 186, 187, 124, 125, 126, 142, 143, 144, 95, 96, 202, 181, 182, 36, 36, 204, 205, 206, 198, 2, 118, 210, 97, 100, 3, 207, 4, 5, 6, 216, 99, 7, 101, 87, 9, 10, 108, 109, 11, 12, 13, 14, 218, 15, 16, 17, 18, 203, 110, 88, 111, 112, 21, 22, 209, 23, 161, 24, 162, 114, 113, 167, 215, 1, 134, 2, 219, 220, 221, 173, 3, 183, 4, 5, 6, 189, 191, 7, 192, 8, 9, 10, 178, 201, 11, 12, 13, 14, 208, 15, 16, 17, 18, 200, 217, 19, 20, 2, 21, 22, 224, 23, 3, 24, 4, 5, 6, 222, 227, 7, 228, 87, 9, 10, 79, 225, 11, 12, 13, 14, 223, 15, 16, 17, 18, 77, 74, 88, 214, 2, 21, 22, 174, 23, 3, 24, 4, 5, 6, 175, 197, 7, 0, 87, 9, 10, 0, 0, 11, 12, 13, 14, 0, 15, 16, 17, 18, 0, 0, 88, 0, 2, 21, 22, 0, 23, 3, 24, 4, 5, 6, 0, 0, 7, 0, 8, 9, 10, 0, 0, 11, 12, 13, 14, 0, 15, 16, 17, 18, 0, 0, 88, 0, 2, 21, 22, 0, 23, 3, 24, 4, 5, 6, 0, 0, 7, 0, 8, 9, 10, 0, 0, 11, 12, 13, 14, 0, 15, 16, 17, 18, 0, 0, 0, 0, 2, 21, 22, 0, 23, 3, 24, 4, 5, 6, 0, 0, 7, 0, 0, 9, 10, 0, 0, 11, 12, 13, 14, 0, 15, 16, 17, 18, 0, 0, 88, 0, 2, 21, 22, 0, 23, 3, 24, 4, 5, 6, 0, 0, 7, 0, 0, 9, 10, 0, 0, 11, 12, 13, 14, 0, 15, 16, 17, 18, 0, 0, 0, 0, 2, 21, 22, 0, 23, 3, 24, 4, 5, 6, 0, 0, 7, 0, 0, 72, 10, 0, 0, 11, 12, 13, 14, 0, 15, 16, 17, 18, 0, 0, 0, 0, 0, 21, 22, 0, 23, 0, 24, 75, 10, 0, 0, 11, 12, 13, 14, 0, 15, 16, 17, 18, 0, 0, 0, 0, 0, 21, 22, 47, 48, 49, 50, 0, 51, 0, 52, 53, 0, 0, 0, 0, 0, 54, 55 }; static const short yycheck[] = { 5, 6, 40, 41, 98, 13, 44, 146, 147, 148, 149, 150, 27, 28, 0, 33, 31, 16, 23, 24, 0, 3, 8, 20, 21, 33, 8, 18, 10, 11, 12, 39, 13, 15, 33, 16, 9, 20, 21, 9, 33, 18, 136, 81, 82, 18, 39, 85, 18, 18, 13, 41, 33, 18, 19, 93, 18, 39, 39, 41, 33, 99, 18, 33, 79, 204, 205, 206, 41, 163, 33, 41, 18, 38, 18, 19, 39, 5, 6, 18, 19, 86, 18, 19, 122, 123, 124, 125, 126, 127, 95, 96, 18, 35, 38, 18, 134, 83, 84, 38, 42, 87, 38, 19, 84, 18, 22, 23, 24, 25, 18, 27, 28, 29, 30, 153, 20, 21, 18, 33, 36, 37, 4, 35, 129, 18, 131, 31, 32, 115, 116, 20, 21, 119, 32, 115, 116, 142, 143, 32, 33, 34, 31, 32, 33, 5, 6, 7, 13, 13, 188, 156, 157, 139, 140, 193, 194, 195, 35, 3, 140, 199, 41, 18, 8, 42, 10, 11, 12, 207, 42, 15, 18, 17, 18, 19, 18, 18, 22, 23, 24, 25, 26, 27, 28, 29, 30, 192, 18, 33, 18, 18, 36, 37, 199, 39, 14, 41, 14, 42, 40, 7, 207, 1, 42, 3, 211, 212, 213, 9, 8, 14, 10, 11, 12, 40, 7, 15, 4, 17, 18, 19, 18, 40, 22, 23, 24, 25, 18, 27, 28, 29, 30, 14, 26, 33, 34, 3, 36, 37, 14, 39, 8, 41, 10, 11, 12, 26, 0, 15, 0, 17, 18, 19, 31, 40, 22, 23, 24, 25, 26, 27, 28, 29, 30, 28, 27, 33, 203, 3, 36, 37, 153, 39, 8, 41, 10, 11, 12, 153, 179, 15, -1, 17, 18, 19, -1, -1, 22, 23, 24, 25, -1, 27, 28, 29, 30, -1, -1, 33, -1, 3, 36, 37, -1, 39, 8, 41, 10, 11, 12, -1, -1, 15, -1, 17, 18, 19, -1, -1, 22, 23, 24, 25, -1, 27, 28, 29, 30, -1, -1, 33, -1, 3, 36, 37, -1, 39, 8, 41, 10, 11, 12, -1, -1, 15, -1, 17, 18, 19, -1, -1, 22, 23, 24, 25, -1, 27, 28, 29, 30, -1, -1, -1, -1, 3, 36, 37, -1, 39, 8, 41, 10, 11, 12, -1, -1, 15, -1, -1, 18, 19, -1, -1, 22, 23, 24, 25, -1, 27, 28, 29, 30, -1, -1, 33, -1, 3, 36, 37, -1, 39, 8, 41, 10, 11, 12, -1, -1, 15, -1, -1, 18, 19, -1, -1, 22, 23, 24, 25, -1, 27, 28, 29, 30, -1, -1, -1, -1, 3, 36, 37, -1, 39, 8, 41, 10, 11, 12, -1, -1, 15, -1, -1, 18, 19, -1, -1, 22, 23, 24, 25, -1, 27, 28, 29, 30, -1, -1, -1, -1, -1, 36, 37, -1, 39, -1, 41, 18, 19, -1, -1, 22, 23, 24, 25, -1, 27, 28, 29, 30, -1, -1, -1, -1, -1, 36, 37, 22, 23, 24, 25, -1, 27, -1, 29, 30, -1, -1, -1, -1, -1, 36, 37 }; #define YYPURE 1 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ #line 3 "bison.simple" /* Skeleton output parser for bison, Copyright (C) 1984 Bob Corbett and Richard Stallman 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 the Free Software Foundation; either version 1, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #if !defined (alloca) && ((!defined (__STDC__) && defined (sparc)) || defined (__sparc__)) #include #endif /* 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. */ /* 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 YYEMPTY -2 #define YYEOF 0 #define YYFAIL goto yyerrlab; #define YYACCEPT return(0) #define YYABORT return(1) #define YYERROR goto yyerrlab #define YYTERROR 1 #define YYERRCODE 256 #ifndef YYIMPURE #define YYLEX yylex() #endif #ifndef YYPURE #define YYLEX yylex(&yylval, &yylloc) #endif /* If nonreentrant, generate the variables here */ #ifndef YYIMPURE int yychar; /* the lookahead symbol */ YYSTYPE yylval; /* the semantic value of the */ /* lookahead symbol */ YYLTYPE yylloc; /* location data for the lookahead */ /* symbol */ int yynerrs; /* number of parse errors so far */ #endif /* YYIMPURE */ #if YYDEBUG != 0 int yydebug; /* nonzero means print parse trace */ /* Since this is uninitialized, it does not stop multiple parsers from coexisting. */ #endif /* YYMAXDEPTH indicates the initial size of the parser's stacks */ #ifndef YYMAXDEPTH #define YYMAXDEPTH 200 #endif /* YYMAXLIMIT is the maximum size the stacks can grow to (effective only if the built-in stack extension method is used). */ #ifndef YYMAXLIMIT #define YYMAXLIMIT 10000 #endif #line 90 "bison.simple" int yyparse() { register int yystate; register int yyn; register short *yyssp; register YYSTYPE *yyvsp; YYLTYPE *yylsp; int yyerrstatus; /* number of tokens to shift before error messages enabled */ int yychar1; /* lookahead token as an internal (translated) token number */ short yyssa[YYMAXDEPTH]; /* the state stack */ YYSTYPE yyvsa[YYMAXDEPTH]; /* the semantic value stack */ YYLTYPE yylsa[YYMAXDEPTH]; /* the location stack */ short *yyss = yyssa; /* refer to the stacks thru separate pointers */ YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ YYLTYPE *yyls = yylsa; int yymaxdepth = YYMAXDEPTH; #ifndef YYPURE int yychar; YYSTYPE yylval; YYLTYPE yylloc; int yynerrs; #endif YYSTYPE yyval; /* the variable used to return */ /* semantic values from the action */ /* routines */ int yylen; #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Starting parse\n"); #endif yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. */ yyssp = yyss - 1; yyvsp = yyvs; yylsp = yyls; /* 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: *++yyssp = yystate; if (yyssp >= yyss + yymaxdepth - 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; YYLTYPE *yyls1 = yyls; short *yyss1 = yyss; /* Get the current used size of the three stacks, in elements. */ int size = yyssp - yyss + 1; #ifdef yyoverflow /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. */ yyoverflow("parser stack overflow", &yyss1, size * sizeof (*yyssp), &yyvs1, size * sizeof (*yyvsp), &yyls1, size * sizeof (*yylsp), &yymaxdepth); yyss = yyss1; yyvs = yyvs1; yyls = yyls1; #else /* no yyoverflow */ /* Extend the stack our own way. */ if (yymaxdepth >= YYMAXLIMIT) yyerror("parser stack overflow"); yymaxdepth *= 2; if (yymaxdepth > YYMAXLIMIT) yymaxdepth = YYMAXLIMIT; yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp)); bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp)); yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp)); bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp)); #ifdef YYLSP_NEEDED yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp)); bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp)); #endif #endif /* no yyoverflow */ yyssp = yyss + size - 1; yyvsp = yyvs + size - 1; #ifdef YYLSP_NEEDED yylsp = yyls + size - 1; #endif #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Stack size increased to %d\n", yymaxdepth); #endif if (yyssp >= yyss + yymaxdepth - 1) YYABORT; } #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Entering state %d\n", yystate); #endif /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ yyresume: /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yyn == YYFLAG) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ /* yychar is either YYEMPTY or YYEOF or a valid token in external form. */ if (yychar == YYEMPTY) { #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Reading a token: "); #endif yychar = YYLEX; } /* Convert token to internal form (in yychar1) for indexing tables with */ if (yychar <= 0) /* This means end of input. */ { yychar1 = 0; yychar = YYEOF; /* Don't call YYLEX any more */ #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Now at end of input.\n"); #endif } else { yychar1 = YYTRANSLATE(yychar); #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]); #endif } yyn += yychar1; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; yyn = yytable[yyn]; /* yyn is what to do for this token type in this state. Negative => reduce, -yyn is rule number. Positive => shift, yyn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (yyn < 0) { if (yyn == YYFLAG) goto yyerrlab; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; /* Shift the lookahead token. */ #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); #endif /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; #ifdef YYLSP_NEEDED *++yylsp = yylloc; #endif /* 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: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; /* Do a reduction. yyn is the number of a rule to reduce with. */ yyreduce: yylen = yyr2[yyn]; yyval = yyvsp[1-yylen]; /* implement default value of the action */ #if YYDEBUG != 0 if (yydebug) { if (yylen == 1) fprintf (stderr, "Reducing 1 value via line %d, ", yyrline[yyn]); else fprintf (stderr, "Reducing %d values via line %d, ", yylen, yyrline[yyn]); } #endif switch (yyn) { case 1: #line 114 "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); YYACCEPT; ; break;} case 2: #line 123 "parse.y" { /* Case of regular command, but not a very interesting one. Return a NULL command. */ global_command = (COMMAND *)NULL; YYACCEPT; ; break;} case 3: #line 131 "parse.y" { /* Error during parsing. Return NULL command. */ global_command = (COMMAND *)NULL; eof_encountered = 0; discard_parser_constructs (1); if (interactive) { YYACCEPT; } else { YYABORT; } ; break;} case 4: #line 146 "parse.y" { /* Case of EOF seen by itself. Do ignoreeof or not. */ global_command = (COMMAND *)NULL; handle_eof_input_unit (); YYACCEPT; ; break;} case 5: #line 156 "parse.y" { yyval.word_list = (WORD_LIST *)NULL; ; break;} case 6: #line 158 "parse.y" { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-1].word_list); ; break;} case 7: #line 162 "parse.y" { yyval.redirect = make_redirection ( 1, r_output_direction, yyvsp[0].word); ; break;} case 8: #line 164 "parse.y" { yyval.redirect = make_redirection ( 0, r_input_direction, yyvsp[0].word); ; break;} case 9: #line 166 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_output_direction, yyvsp[0].word); ; break;} case 10: #line 168 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_input_direction, yyvsp[0].word); ; break;} case 11: #line 170 "parse.y" { yyval.redirect = make_redirection ( 1, r_appending_to, yyvsp[0].word); ; break;} case 12: #line 172 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_appending_to, yyvsp[0].word); ; break;} case 13: #line 174 "parse.y" { yyval.redirect = make_redirection ( 0, r_reading_until, yyvsp[0].word); redirection_needing_here_doc = yyval.redirect; need_here_doc = 1; ; break;} case 14: #line 180 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_reading_until, yyvsp[0].word); redirection_needing_here_doc = yyval.redirect; need_here_doc = 1; ; break;} case 15: #line 186 "parse.y" { yyval.redirect = make_redirection ( 0, r_duplicating_input, yyvsp[0].number); ; break;} case 16: #line 190 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_input, yyvsp[0].number); ; break;} case 17: #line 194 "parse.y" { yyval.redirect = make_redirection ( 1, r_duplicating_output, yyvsp[0].number); ; break;} case 18: #line 198 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_output, yyvsp[0].number); ; break;} case 19: #line 202 "parse.y" { yyval.redirect = make_redirection (0, r_duplicating_input_word, yyvsp[0].word); ; break;} case 20: #line 207 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_input_word, yyvsp[0].word); ; break;} case 21: #line 212 "parse.y" { yyval.redirect = make_redirection (1, r_duplicating_output_word, yyvsp[0].word); ; break;} case 22: #line 217 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_output_word, yyvsp[0].word); ; break;} case 23: #line 222 "parse.y" { yyval.redirect = make_redirection (0, r_deblank_reading_until, yyvsp[0].word); redirection_needing_here_doc = yyval.redirect; need_here_doc = 1; ; break;} case 24: #line 229 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_deblank_reading_until, yyvsp[0].word); redirection_needing_here_doc = yyval.redirect; need_here_doc = 1; ; break;} case 25: #line 236 "parse.y" { yyval.redirect = make_redirection ( 1, r_close_this, 0); ; break;} case 26: #line 238 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, 0); ; break;} case 27: #line 240 "parse.y" { yyval.redirect = make_redirection ( 0, r_close_this, 0); ; break;} case 28: #line 242 "parse.y" { yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, 0); ; break;} case 29: #line 244 "parse.y" { yyval.redirect = make_redirection ( 1, r_err_and_out, yyvsp[0].word); ; break;} case 30: #line 246 "parse.y" { yyval.redirect = make_redirection ( yyvsp[-2].number, r_input_output, yyvsp[0].word); ; break;} case 31: #line 248 "parse.y" { REDIRECT *t1, *t2; extern WORD_DESC *copy_word (); t1 = make_redirection ( 0, r_input_direction, yyvsp[0].word); t2 = make_redirection ( 1, r_output_direction, copy_word (yyvsp[0].word)); t1->next = t2; yyval.redirect = t1; ; break;} case 32: #line 258 "parse.y" { yyval.redirect = make_redirection ( 1, r_output_force, yyvsp[0].word); ; break;} case 33: #line 260 "parse.y" { yyval.redirect = make_redirection ( yyvsp[-2].number, r_output_force, yyvsp[0].word); ; break;} case 34: #line 264 "parse.y" { yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; ; break;} case 35: #line 266 "parse.y" { yyval.element.redirect = yyvsp[0].redirect; yyval.element.word = 0; ; break;} case 36: #line 270 "parse.y" { yyval.redirect = yyvsp[0].redirect; ; break;} case 37: #line 274 "parse.y" { register REDIRECT *t = yyvsp[-1].redirect; while (t->next) t = t->next; t->next = yyvsp[0].redirect; yyval.redirect = yyvsp[-1].redirect; ; break;} case 38: #line 285 "parse.y" { yyval.command = make_simple_command (yyvsp[0].element, (COMMAND *)NULL); ; break;} case 39: #line 287 "parse.y" { yyval.command = make_simple_command (yyvsp[0].element, yyvsp[-1].command); ; break;} case 40: #line 291 "parse.y" { yyval.command = clean_simple_command (yyvsp[0].command); ; break;} case 41: #line 293 "parse.y" { yyval.command = yyvsp[0].command; ; break;} case 42: #line 297 "parse.y" { yyval.command = yyvsp[0].command; ; break;} case 43: #line 299 "parse.y" { yyvsp[-1].command->redirects = yyvsp[0].redirect; yyval.command = yyvsp[-1].command; ; break;} case 44: #line 302 "parse.y" { yyvsp[0].command->redirects = yyvsp[-1].redirect; yyval.command = yyvsp[0].command; ; break;} case 45: #line 306 "parse.y" { yyval.command = make_for_command (yyvsp[-4].word, (WORD_LIST *)add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ; break;} case 46: #line 308 "parse.y" { yyval.command = make_for_command (yyvsp[-4].word, (WORD_LIST *)add_string_to_list ("$@", (WORD_LIST *)NULL), yyvsp[-1].command); ; break;} case 47: #line 310 "parse.y" { yyval.command = make_for_command (yyvsp[-5].word, (WORD_LIST *)add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ; break;} case 48: #line 312 "parse.y" { yyval.command = make_for_command (yyvsp[-5].word, (WORD_LIST *)add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ; break;} case 49: #line 315 "parse.y" { yyval.command = make_for_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command); ; break;} case 50: #line 317 "parse.y" { yyval.command = make_for_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command); ; break;} case 51: #line 320 "parse.y" { yyval.command = make_case_command (yyvsp[-4].word, (PATTERN_LIST *)NULL); ; break;} case 52: #line 322 "parse.y" { yyval.command = make_case_command (yyvsp[-5].word, yyvsp[-2].pattern); ; break;} case 53: #line 324 "parse.y" { /* Nobody likes this... report_syntax_error ("Inserted `;;'"); */ yyval.command = make_case_command (yyvsp[-4].word, yyvsp[-1].pattern); ; break;} case 54: #line 329 "parse.y" { yyval.command = yyvsp[0].command; ; break;} case 55: #line 331 "parse.y" { yyval.command = make_while_command (yyvsp[-3].command, yyvsp[-1].command); ; break;} case 56: #line 333 "parse.y" { yyval.command = make_until_command (yyvsp[-3].command, yyvsp[-1].command); ; break;} case 57: #line 336 "parse.y" { yyvsp[-1].command->flags |= CMD_WANT_SUBSHELL; yyval.command = yyvsp[-1].command; ; break;} case 58: #line 339 "parse.y" { yyval.command = yyvsp[0].command; ; break;} case 59: #line 342 "parse.y" { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command); ; break;} case 60: #line 345 "parse.y" { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command); ; break;} case 61: #line 348 "parse.y" { yyval.command = make_function_def (yyvsp[-2].word, yyvsp[0].command); ; break;} case 62: #line 352 "parse.y" { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, (COMMAND *)NULL); ; break;} case 63: #line 354 "parse.y" { yyval.command = make_if_command (yyvsp[-5].command, yyvsp[-3].command, yyvsp[-1].command); ; break;} case 64: #line 356 "parse.y" { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[-1].command); ; break;} case 65: #line 361 "parse.y" { yyval.command = make_group_command (yyvsp[-1].command); ; break;} case 66: #line 365 "parse.y" { yyval.command = make_if_command (yyvsp[-2].command, yyvsp[0].command, (COMMAND *)NULL); ; break;} case 67: #line 367 "parse.y" { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[0].command); ; break;} case 68: #line 369 "parse.y" { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, yyvsp[0].command); ; break;} case 70: #line 374 "parse.y" { yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; ; break;} case 71: #line 378 "parse.y" { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ; break;} case 72: #line 380 "parse.y" { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ; break;} case 73: #line 382 "parse.y" { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ; break;} case 74: #line 384 "parse.y" { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ; break;} case 76: #line 390 "parse.y" { yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; ; break;} case 77: #line 394 "parse.y" { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, yyvsp[-1].command); ; break;} case 78: #line 396 "parse.y" { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, (COMMAND *)NULL); ; break;} case 79: #line 398 "parse.y" { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, yyvsp[-1].command); ; break;} case 80: #line 400 "parse.y" { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, (COMMAND *)NULL); ; break;} case 81: #line 404 "parse.y" { yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); ; break;} case 82: #line 406 "parse.y" { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-2].word_list); ; break;} case 83: #line 415 "parse.y" { yyval.command = yyvsp[0].command; if (need_here_doc) make_here_document (redirection_needing_here_doc); need_here_doc = 0; ; break;} case 86: #line 426 "parse.y" { yyval.command = command_connect (yyvsp[-2].command, 0, '&'); ; break;} case 88: #line 432 "parse.y" { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ; break;} case 89: #line 434 "parse.y" { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ; break;} case 90: #line 436 "parse.y" { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '&'); ; break;} case 91: #line 438 "parse.y" { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ; break;} case 92: #line 440 "parse.y" { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ; break;} case 93: #line 442 "parse.y" { yyval.command = yyvsp[0].command; ; break;} case 94: #line 444 "parse.y" { yyvsp[0].command->flags |= CMD_INVERT_RETURN; yyval.command = yyvsp[0].command; ; break;} case 100: #line 466 "parse.y" { yyval.command = yyvsp[0].command; if (need_here_doc) make_here_document (redirection_needing_here_doc); need_here_doc = 0; ; break;} case 101: #line 473 "parse.y" { yyval.command = command_connect (yyvsp[-1].command, (COMMAND *)NULL, '&'); if (need_here_doc) make_here_document (redirection_needing_here_doc); need_here_doc = 0; ; break;} case 102: #line 480 "parse.y" { yyval.command = yyvsp[-1].command; if (need_here_doc) make_here_document (redirection_needing_here_doc); need_here_doc = 0; ; break;} case 103: #line 489 "parse.y" { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ; break;} case 104: #line 491 "parse.y" { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ; break;} case 105: #line 493 "parse.y" { yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, '&'); ; break;} case 106: #line 495 "parse.y" { yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, ';'); ; break;} case 107: #line 497 "parse.y" { yyval.command = yyvsp[0].command; ; break;} case 108: #line 499 "parse.y" { yyvsp[0].command->flags |= CMD_INVERT_RETURN; yyval.command = yyvsp[0].command; ; break;} case 109: #line 507 "parse.y" { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '|'); ; break;} case 110: #line 509 "parse.y" { yyval.command = yyvsp[0].command; ; break;} } /* the action file gets copied in in place of this dollarsign */ #line 327 "bison.simple" yyvsp -= yylen; yyssp -= yylen; #ifdef YYLSP_NEEDED yylsp -= yylen; #endif #if YYDEBUG != 0 if (yydebug) { short *ssp1 = yyss - 1; fprintf (stderr, "state stack now"); while (ssp1 != yyssp) fprintf (stderr, " %d", *++ssp1); fprintf (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; } #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. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTBASE] + *yyssp; if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; yyerrlab: /* here on detecting error */ if (! yyerrstatus) /* If not already recovering from an error, report this error. */ { ++yynerrs; yyerror("parse error"); } if (yyerrstatus == 3) { /* 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 yychar = YYEMPTY; } /* 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. */ #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; #endif yyerrpop: /* pop the current state because it cannot handle the error token */ if (yyssp == yyss) YYABORT; yyvsp--; yystate = *--yyssp; #ifdef YYLSP_NEEDED yylsp--; #endif #if YYDEBUG != 0 if (yydebug) { short *ssp1 = yyss - 1; fprintf (stderr, "Error: state stack now"); while (ssp1 != yyssp) fprintf (stderr, " %d", *++ssp1); fprintf (stderr, "\n"); } #endif yyerrhandle: yyn = yypact[yystate]; if (yyn == YYFLAG) goto yyerrdefault; yyn += YYTERROR; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) goto yyerrdefault; yyn = yytable[yyn]; if (yyn < 0) { if (yyn == YYFLAG) goto yyerrpop; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; #if YYDEBUG != 0 if (yydebug) fprintf(stderr, "Shifting error token, "); #endif *++yyvsp = yylval; #ifdef YYLSP_NEEDED *++yylsp = yylloc; #endif yystate = yyn; goto yynewstate; } #line 511 "parse.y" /* Initial size to allocate for tokens, and the amount to grow them by. */ #define TOKEN_DEFAULT_GROW_SIZE 512 /* The token currently being read. */ int current_token = 0; /* The last read token, or NULL. read_token () uses this for context checking. */ int last_read_token = 0; /* The token read prior to last_read_token. */ int token_before_that = 0; /* Global var is non-zero when end of file has been reached. */ int EOF_Reached = 0; /* yy_getc () returns the next available character from input or EOF. yy_ungetc (c) makes `c' the next character to read. init_yy_io (get, unget), makes the function `get' the installed function for getting the next character, and makes `unget' the installed function for un-getting a character. */ return_EOF () /* does nothing good. */ { return (EOF); } /* Variables containing the current get and unget functions. */ /* Some stream `types'. */ #define st_stream 0 #define st_string 1 Function *get_yy_char = return_EOF; Function *unget_yy_char = return_EOF; int yy_input_type = st_stream; FILE *yy_input_dev = (FILE *)NULL; /* The current stream name. In the case of a file, this is a filename. */ char *stream_name = (char *)NULL; /* Function to set get_yy_char and unget_yy_char. */ init_yy_io (get_function, unget_function, type, location) Function *get_function, *unget_function; int type; FILE *location; { get_yy_char = get_function; unget_yy_char = unget_function; yy_input_type = type; yy_input_dev = location; } /* Call this to get the next character of input. */ yy_getc () { return (*get_yy_char) (); } /* Call this to unget C. That is, to make C the next character to be read. */ yy_ungetc (c) { return (*unget_yy_char) (c); } /* **************************************************************** */ /* */ /* Let input be read from readline (). */ /* */ /* **************************************************************** */ #if defined (READLINE) char *current_readline_prompt = (char *)NULL; char *current_readline_line = (char *)NULL; int current_readline_line_index = 0; static int readline_initialized_yet = 0; int yy_readline_get () { if (!current_readline_line) { extern sighandler sigint_sighandler (); extern int interrupt_immediately; extern char *readline (); SigHandler *old_sigint; #if defined (JOB_CONTROL) extern pid_t shell_pgrp; extern int job_control; #endif /* JOB_CONTROL */ if (!readline_initialized_yet) { initialize_readline (); readline_initialized_yet = 1; } #if defined (JOB_CONTROL) if (job_control) give_terminal_to (shell_pgrp); #endif /* JOB_CONTROL */ old_sigint = (SigHandler *)signal (SIGINT, sigint_sighandler); interrupt_immediately++; if (!current_readline_prompt) current_readline_line = readline (""); else current_readline_line = readline (current_readline_prompt); interrupt_immediately--; signal (SIGINT, old_sigint); /* Reset the prompt to whatever is in the decoded value of prompt_string_pointer. */ reset_readline_prompt (); current_readline_line_index = 0; if (!current_readline_line) { current_readline_line_index = 0; return (EOF); } current_readline_line = (char *)xrealloc (current_readline_line, 2 + strlen (current_readline_line)); strcat (current_readline_line, "\n"); } if (!current_readline_line[current_readline_line_index]) { free (current_readline_line); current_readline_line = (char *)NULL; return (yy_readline_get ()); } else { int c = current_readline_line[current_readline_line_index++]; return (c); } } int yy_readline_unget (c) { if (current_readline_line_index && current_readline_line) current_readline_line[--current_readline_line_index] = c; return (c); } with_input_from_stdin () { init_yy_io (yy_readline_get, yy_readline_unget, st_string, (FILE *)current_readline_line); stream_name = savestring ("readline stdin"); } #else /* !READLINE */ with_input_from_stdin () { with_input_from_stream (stdin, "stdin"); } #endif /* !READLINE */ /* **************************************************************** */ /* */ /* Let input come from STRING. STRING is zero terminated. */ /* */ /* **************************************************************** */ int yy_string_get () { /* If the string doesn't exist, or is empty, EOF found. */ if (!(char *)yy_input_dev || !*(char *)yy_input_dev) return (EOF); else { register char *temp = (char *)yy_input_dev; int c = *temp++; yy_input_dev = (FILE *)temp; return (c); } } int yy_string_unget (c) int c; { register char *temp = (char *)yy_input_dev; *(--temp) = c; yy_input_dev = (FILE *)temp; return (c); } with_input_from_string (string, name) char *string; char *name; { init_yy_io (yy_string_get, yy_string_unget, st_string, (FILE *)string); stream_name = savestring (name); } /* **************************************************************** */ /* */ /* Let input come from STREAM. */ /* */ /* **************************************************************** */ int yy_stream_get () { if (yy_input_dev) #if defined (USG) || (defined (_POSIX_VERSION) && defined (Ultrix)) return (sysv_getc (yy_input_dev)); #else return (getc (yy_input_dev)); #endif /* USG || (posix & ultrix) */ else return (EOF); } int yy_stream_unget (c) int c; { return (ungetc (c, yy_input_dev)); } with_input_from_stream (stream, name) FILE *stream; char *name; { init_yy_io (yy_stream_get, yy_stream_unget, st_stream, stream); stream_name = savestring (name); } typedef struct stream_saver { struct stream_saver *next; Function *getter, *putter; int type, line; char *location, *name; } STREAM_SAVER; /* The globally known line number. */ int line_number = 0; STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL; push_stream () { STREAM_SAVER *temp = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER)); temp->type = yy_input_type; temp->location = (char *)yy_input_dev; temp->getter = get_yy_char; temp->putter = unget_yy_char; temp->line = line_number; temp->name = stream_name; stream_name = (char *)NULL; temp->next = stream_list; stream_list = temp; EOF_Reached = line_number = 0; } pop_stream () { if (!stream_list) { EOF_Reached = 1; } else { STREAM_SAVER *temp = stream_list; EOF_Reached = 0; stream_list = stream_list->next; if (stream_name) free (stream_name); stream_name = temp->name; init_yy_io (temp->getter, temp->putter, temp->type, (FILE *)temp->location); line_number = temp->line; free (temp); } } /* * This is used to inhibit alias expansion and reserved word recognition * inside case statement pattern lists. A `case statement pattern list' * is: * everything between the `in' in a `case word in' and the next ')' * or `esac' * everything between a `;;' and the next `)' or `esac' */ static int in_case_pattern_list = 0; #if defined (ALIAS) /* * Pseudo-global variables used in implementing token-wise alias expansion. */ static int expand_next_token = 0; static char *current_token_being_expanded = (char *)NULL; static char *pending_token_being_expanded = (char *)NULL; /* * Pushing and popping strings. This works together with shell_getc to * implement alias expansion on a per-token basis. */ typedef struct string_saver { struct string_saver *next; int expand_alias; /* Value to set expand_alias to when string is popped. */ char *saved_line; int saved_line_size, saved_line_index, saved_line_terminator; char *saved_token_being_expanded; } STRING_SAVER; STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL; static void save_expansion (); /* * Push the current shell_input_line onto a stack of such lines and make S * the current input. Used when expanding aliases. EXPAND is used to set * the value of expand_next_token when the string is popped, so that the * word after the alias in the original line is handled correctly when the * alias expands to multiple words. TOKEN is the token that was expanded * into S; it is saved and used to prevent infinite recursive expansion. */ static void push_string (s, expand, token) char *s; int expand; char *token; { extern char *shell_input_line; extern int shell_input_line_size, shell_input_line_index, shell_input_line_terminator; STRING_SAVER *temp = (STRING_SAVER *) xmalloc (sizeof (STRING_SAVER)); temp->expand_alias = expand; temp->saved_line = shell_input_line; temp->saved_line_size = shell_input_line_size; temp->saved_line_index = shell_input_line_index; temp->saved_line_terminator = shell_input_line_terminator; temp->saved_token_being_expanded = current_token_being_expanded; temp->next = pushed_string_list; pushed_string_list = temp; save_expansion (token); current_token_being_expanded = token; shell_input_line = s; shell_input_line_size = strlen (s); shell_input_line_index = 0; shell_input_line_terminator = '\0'; expand_next_token = 0; } /* * Make the top of the pushed_string stack be the current shell input. * Only called when there is something on the stack. Called from shell_getc * when it thinks it has consumed the string generated by an alias expansion * and needs to return to the original input line. */ static void pop_string () { extern char *shell_input_line; extern int shell_input_line_size, shell_input_line_index, shell_input_line_terminator; STRING_SAVER *t; if (shell_input_line) free (shell_input_line); shell_input_line = pushed_string_list->saved_line; shell_input_line_index = pushed_string_list->saved_line_index; shell_input_line_size = pushed_string_list->saved_line_size; shell_input_line_terminator = pushed_string_list->saved_line_terminator; expand_next_token = pushed_string_list->expand_alias; pending_token_being_expanded = pushed_string_list->saved_token_being_expanded; t = pushed_string_list; pushed_string_list = pushed_string_list->next; free((char *)t); } static void free_string_list () { register STRING_SAVER *t = pushed_string_list, *t1; while (t) { t1 = t->next; if (t->saved_line) free (t->saved_line); if (t->saved_token_being_expanded) free (t->saved_token_being_expanded); free ((char *)t); t = t1; } pushed_string_list = (STRING_SAVER *)NULL; } /* This is a stack to save the values of all tokens for which alias expansion has been performed during the current call to read_token (). It is used to prevent alias expansion loops: alias foo=bar alias bar=baz alias baz=foo Ideally this would be taken care of by push and pop string, but because of when strings are popped the stack will not contain the correct strings to test against. (The popping is done in shell_getc, so that when the current string is exhausted, shell_getc can simply pop that string off the stack, restore the previous string, and continue with the character following the token whose expansion was originally pushed on the stack.) What we really want is a record of all tokens that have been expanded for aliases during the `current' call to read_token(). This does that, at the cost of being somewhat special-purpose (OK, OK vile and unclean). Brian, you had better rewrite this whole piece of garbage before the next version is released. */ typedef struct _exp_saver { struct _exp_saver *next; char *saved_token; } EXPANSION_SAVER; EXPANSION_SAVER *expanded_token_stack = (EXPANSION_SAVER *)NULL; static void save_expansion (s) char *s; { EXPANSION_SAVER *t; t = (EXPANSION_SAVER *) xmalloc (sizeof (EXPANSION_SAVER)); t->saved_token = savestring (s); t->next = expanded_token_stack; expanded_token_stack = t; } /* * Return 1 if TOKEN has already been expanded in the current `stack' of * expansions. If it has been expanded already, it will appear as the value * of saved_token for some entry in the stack of expansions created for the * current token being expanded. */ static int token_has_been_expanded (token) char *token; { register EXPANSION_SAVER *t = expanded_token_stack; while (t) { if (STREQ (token, t->saved_token)) return (1); t = t->next; } return (0); } static void free_expansion_stack () { register EXPANSION_SAVER *t = expanded_token_stack, *t1; while (t) { t1 = t->next; free (t->saved_token); free (t); t = t1; } expanded_token_stack = (EXPANSION_SAVER *)NULL; } #endif /* ALIAS */ /* Return a line of text, taken from wherever yylex () reads input. If there is no more input, then we return NULL. */ char * read_a_line () { char *line_buffer = (char *)NULL; int indx = 0, buffer_size = 0; int c; while (1) { c = yy_getc (); if (c == 0) continue; /* If there is no more input, then we return NULL. */ if (c == EOF) { c = '\n'; if (!line_buffer) return ((char *)NULL); } /* `+2' in case the final (200'th) character in the buffer is a newline; otherwise the code below that NULL-terminates it will write over the 201st slot and kill the range checking in free(). */ if (indx + 2 > buffer_size) if (!buffer_size) line_buffer = (char *)xmalloc (buffer_size = 200); else line_buffer = (char *)xrealloc (line_buffer, buffer_size += 200); line_buffer[indx++] = c; if (c == '\n') { line_buffer[indx] = '\0'; return (line_buffer); } } } /* Return a line as in read_a_line (), but insure that the prompt is the secondary prompt. */ char * read_secondary_line () { prompt_string_pointer = &ps2_prompt; prompt_again (); return (read_a_line ()); } /* **************************************************************** */ /* */ /* YYLEX () */ /* */ /* **************************************************************** */ /* Reserved words. These are only recognized as the first word of a command. TOKEN_WORD_ALIST. */ STRING_INT_ALIST word_token_alist[] = { {"if", IF}, {"then", THEN}, {"else", ELSE}, {"elif", ELIF}, {"fi", FI}, {"case", CASE}, {"esac", ESAC}, {"for", FOR}, {"while", WHILE}, {"until", UNTIL}, {"do", DO}, {"done", DONE}, {"in", IN}, {"function", FUNCTION}, {"{", '{'}, {"}", '}'}, {"!", BANG}, {(char *)NULL, 0} }; /* Where shell input comes from. History expansion is performed on each line when the shell is interactive. */ char *shell_input_line = (char *)NULL; int shell_input_line_index = 0; int shell_input_line_size = 0; /* Amount allocated for shell_input_line. */ int shell_input_line_len = 0; /* strlen (shell_input_line) */ /* Either zero, or EOF. */ int shell_input_line_terminator = 0; /* Return the next shell input character. This always reads characters from shell_input_line; when that line is exhausted, it is time to read the next line. */ int shell_getc (remove_quoted_newline) int remove_quoted_newline; { int c; QUIT; #if defined (ALIAS) /* If shell_input_line[shell_input_line_index] == 0, but there is something on the pushed list of strings, then we don't want to go off and get another line. We let the code down below handle it. */ if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) && (pushed_string_list == (STRING_SAVER *)NULL))) #else /* !ALIAS */ if (!shell_input_line || !shell_input_line[shell_input_line_index]) #endif /* !ALIAS */ { register int i, l; char *pre_process_line (), *expansions; restart_read_next_line: line_number++; restart_read: QUIT; /* XXX experimental */ i = 0; shell_input_line_terminator = 0; #if defined (JOB_CONTROL) notify_and_cleanup (); #endif clearerr (stdin); while (c = yy_getc ()) { if (i + 2 > shell_input_line_size) shell_input_line = (char *) xrealloc (shell_input_line, shell_input_line_size += 256); if (c == EOF) { clearerr (stdin); if (!i) shell_input_line_terminator = EOF; shell_input_line[i] = '\0'; break; } shell_input_line[i++] = c; if (c == '\n') { shell_input_line[--i] = '\0'; current_command_line_count++; break; } } shell_input_line_index = 0; shell_input_line_len = i; /* == strlen (shell_input_line) */ if (!shell_input_line || !shell_input_line[0]) goto after_pre_process; if (interactive) { expansions = pre_process_line (shell_input_line, 1, 1); free (shell_input_line); shell_input_line = expansions; shell_input_line_len = shell_input_line ? strlen (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; } after_pre_process: if (shell_input_line) { if (echo_input_at_read) fprintf (stderr, "%s\n", shell_input_line); } else { shell_input_line_size = 0; prompt_string_pointer = ¤t_prompt_string; prompt_again (); goto restart_read; } /* Add the newline to the end of this string, iff the string does not already end in an EOF character. */ if (shell_input_line_terminator != EOF) { l = shell_input_line_len; /* was a call to strlen */ if (l + 3 > shell_input_line_size) shell_input_line = (char *)xrealloc (shell_input_line, 1 + (shell_input_line_size += 2)); strcpy (shell_input_line + l, "\n"); } } c = shell_input_line[shell_input_line_index]; if (c) shell_input_line_index++; if (c == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n') { prompt_again (); goto restart_read_next_line; } #if defined (ALIAS) /* * If c is NULL, we have reached the end of the current input string. If * pushed_string_list is non-empty, it's time to pop to the previous string * because we have fully consumed the result of the last alias expansion. * Do it transparently; just return the next character of the string popped * to. We need to hang onto current_token_being_expanded until the token * currently being read has been recognized; we can't restore it in * pop_string () because the token currently being read would be * inappropriately compared with it. We defer restoration until the next * call to read_token (). */ if (!c && (pushed_string_list != (STRING_SAVER *)NULL)) { pop_string (); c = shell_input_line[shell_input_line_index]; if (c) shell_input_line_index++; } #endif /* ALIAS */ if (!c && shell_input_line_terminator == EOF) { if (shell_input_line_index != 0) return ('\n'); else return (EOF); } return (c); } /* Put C back into the input for the shell. */ shell_ungetc (c) int c; { if (shell_input_line && shell_input_line_index) shell_input_line[--shell_input_line_index] = c; } /* Discard input until CHARACTER is seen. */ discard_until (character) int character; { int c; while ((c = shell_getc (0)) != EOF && c != character) ; if (c != EOF) shell_ungetc (c); } #if defined (HISTORY_REEDITING) /* Tell readline () that we have some text for it to edit. */ re_edit (text) char *text; { #if defined (READLINE) if (strcmp (stream_name, "readline stdin") == 0) bash_re_edit (text); #endif /* READLINE */ } #endif /* HISTORY_REEDITING */ /* Non-zero means do no history expansion on this line, regardless of what history_expansion says. */ int history_expansion_inhibited = 0; /* Do pre-processing on LINE. If PRINT_CHANGES is non-zero, then print the results of expanding the line if there were any changes. If there is an error, return NULL, otherwise the expanded line is returned. If ADDIT is non-zero the line is added to the history list after history expansion. ADDIT is just a suggestion; REMEMBER_ON_HISTORY can veto, and does. Right now this does history expansion. */ char * pre_process_line (line, print_changes, addit) char *line; int print_changes, addit; { extern int remember_on_history; extern int history_expansion; extern int history_expand (); char *history_value; char *return_value; int expanded = 0; return_value = line; /* History expand the line. If this results in no errors, then add that line to the history if ADDIT is non-zero. */ if (!history_expansion_inhibited && history_expansion) { expanded = history_expand (line, &history_value); if (expanded) { if (print_changes) fprintf (stderr, "%s\n", history_value); /* If there was an error, return NULL. */ if (expanded < 0) { free (history_value); #if defined (HISTORY_REEDITING) /* New hack. We can allow the user to edit the failed history expansion. */ re_edit (line); #endif /* HISTORY_REEDITING */ return ((char *)NULL); } } /* Let other expansions know that return_value can be free'ed, and that a line has been added to the history list. Note that we only add lines that have something in them. */ expanded = 1; return_value = history_value; } if (addit && remember_on_history && *return_value) { extern int history_control; switch (history_control) { case 0: bash_add_history (return_value); break; case 1: if (*return_value != ' ') bash_add_history (return_value); break; case 2: { HIST_ENTRY *temp; using_history (); temp = previous_history (); if (!temp || (strcmp (temp->line, return_value) != 0)) bash_add_history (return_value); using_history (); } break; } } if (!expanded) return_value = savestring (line); return (return_value); } /* Place to remember the token. We try to keep the buffer at a reasonable size, but it can grow. */ char *token = (char *)NULL; /* Current size of the token buffer. */ int token_buffer_size = 0; /* Command to read_token () explaining what we want it to do. */ #define READ 0 #define RESET 1 #define prompt_is_ps1 \ (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt) /* Function for yyparse to call. yylex keeps track of the last two tokens read, and calls read_token. */ yylex () { if (interactive && (!current_token || current_token == '\n')) { /* Before we print a prompt, we might have to check mailboxes. We do this only if it is time to do so. Notice that only here is the mail alarm reset; nothing takes place in check_mail () except the checking of mail. Please don't change this. */ if (prompt_is_ps1 && time_to_check_mail ()) { check_mail (); reset_mail_timer (); } /* Allow the execution of a random command just before the printing of each primary prompt. If the shell variable PROMPT_COMMAND is set then the value of it is the command to execute. */ if (prompt_is_ps1) { char *command_to_execute = get_string_value ("PROMPT_COMMAND"); if (command_to_execute) { extern Function *last_shell_builtin, *this_shell_builtin; extern int last_command_exit_value; Function *temp_last, *temp_this; int temp_exit_value, temp_eof_encountered; temp_last = last_shell_builtin; temp_this = this_shell_builtin; temp_exit_value = last_command_exit_value; temp_eof_encountered = eof_encountered; parse_and_execute (savestring (command_to_execute), "PROMPT_COMMAND"); last_shell_builtin = temp_last; this_shell_builtin = temp_this; last_command_exit_value = temp_exit_value; eof_encountered = temp_eof_encountered; } } prompt_again (); } token_before_that = last_read_token; last_read_token = current_token; current_token = read_token (READ); return (current_token); } /* Called from shell.c when Control-C is typed at top level. Or by the error rule at top level. */ reset_parser () { read_token (RESET); } /* When non-zero, we have read the required tokens which allow ESAC to be the next one read. */ static int allow_esac_as_next = 0; /* When non-zero, accept single '{' as a token itself. */ static int allow_open_brace = 0; /* DELIMITER is the value of the delimiter that is currently enclosing, or zero for none. */ static int delimiter = 0; static int old_delimiter = 0; /* When non-zero, an open-brace used to create a group is awaiting a close brace partner. */ static int open_brace_awaiting_satisfaction = 0; /* If non-zero, it is the token that we want read_token to return regardless of what text is (or isn't) present to be read. read_token resets this. */ int token_to_read = 0; /* Read the next token. Command can be READ (normal operation) or RESET (to normalize state). */ read_token (command) int command; { extern int interactive_shell; /* Whether the current shell is interactive. */ int character; /* Current character. */ int peek_char; /* Temporary look-ahead character. */ int result; /* The thing to return. */ WORD_DESC *the_word; /* The value for YYLVAL when a WORD is read. */ if (token_buffer_size < TOKEN_DEFAULT_GROW_SIZE) { if (token) free (token); token = (char *)xmalloc (token_buffer_size = TOKEN_DEFAULT_GROW_SIZE); } if (command == RESET) { delimiter = old_delimiter = 0; open_brace_awaiting_satisfaction = 0; in_case_pattern_list = 0; #if defined (ALIAS) if (pushed_string_list) { free_string_list (); pushed_string_list = (STRING_SAVER *)NULL; } if (pending_token_being_expanded) { free (pending_token_being_expanded); pending_token_being_expanded = (char *)NULL; } if (current_token_being_expanded) { free (current_token_being_expanded); current_token_being_expanded = (char *)NULL; } if (expanded_token_stack) { free_expansion_stack (); expanded_token_stack = (EXPANSION_SAVER *)NULL; } expand_next_token = 0; #endif /* ALIAS */ if (shell_input_line) { free (shell_input_line); shell_input_line = (char *)NULL; shell_input_line_size = shell_input_line_index = 0; } last_read_token = '\n'; token_to_read = '\n'; return ('\n'); } if (token_to_read) { int rt = token_to_read; token_to_read = 0; return (rt); } #if defined (ALIAS) /* * Now we can replace current_token_being_expanded with * pending_token_being_expanded, since the token that would be * inappropriately compared has already been returned. * * To see why restoring current_token_being_expanded in pop_string () * could be a problem, consider "alias foo=foo". Then try to * expand `foo'. The initial value of current_token_being_expanded is * NULL, so that is what is pushed onto pushed_string_list as the * value of saved_token_being_expanded. "foo" then becomes shell_input_line. * read_token calls shell_getc for `f', `o', `o', and then shell_getc * hits the end of shell_input_line. pushed_string_list is not empty * so it gets popped. If we were to blindly restore * current_token_being_expanded at this point, `foo' would be compared * with a NULL string in the check for recursive expansion, and would * infinitely recurse. */ if (pending_token_being_expanded) { if (current_token_being_expanded) free (current_token_being_expanded); current_token_being_expanded = pending_token_being_expanded; pending_token_being_expanded = (char *)NULL; } /* If we hit read_token () and there are no saved strings on the pushed_string_list, then we are no longer currently expanding a token. This can't be done in pop_stream, because pop_stream may pop the stream before the current token has finished being completely expanded (consider what happens when we alias foo to foo, and then try to expand it). */ if (!pushed_string_list && current_token_being_expanded) { free (current_token_being_expanded); current_token_being_expanded = (char *)NULL; if (expanded_token_stack) { free_expansion_stack (); expanded_token_stack = (EXPANSION_SAVER *)NULL; } } /* This is a place to jump back to once we have successfully expanded a token with an alias and pushed the string with push_string () */ re_read_token: #endif /* ALIAS */ /* Read a single word from input. Start by skipping blanks. */ while ((character = shell_getc (1)) != EOF && whitespace (character)); if (character == EOF) return (yacc_EOF); if (character == '#' && !interactive) { /* A comment. Discard until EOL or EOF, and then return a newline. */ discard_until ('\n'); shell_getc (0); /* If we're about to return an unquoted newline, we can go and collect the text of any pending here document. */ if (need_here_doc) make_here_document (redirection_needing_here_doc); need_here_doc = 0; #if defined (ALIAS) expand_next_token = 0; #endif /* ALIAS */ return ('\n'); } if (character == '\n') { /* If we're about to return an unquoted newline, we can go and collect the text of any pending here document. */ if (need_here_doc) make_here_document (redirection_needing_here_doc); need_here_doc = 0; #if defined (ALIAS) expand_next_token = 0; #endif /* ALIAS */ return (character); } if (member (character, "()<>;&|")) { #if defined (ALIAS) /* Turn off alias tokenization iff this character sequence would not leave us ready to read a command. */ if (character == '<' || character == '>') expand_next_token = 0; #endif /* ALIAS */ /* Please note that the shell does not allow whitespace to appear in between tokens which are character pairs, such as "<<" or ">>". I believe this is the correct behaviour. */ if (character == (peek_char = shell_getc (1))) { switch (character) { /* If '<' then we could be at "<<" or at "<<-". We have to look ahead one more character. */ case '<': peek_char = shell_getc (1); if (peek_char == '-') return (LESS_LESS_MINUS); else { shell_ungetc (peek_char); return (LESS_LESS); } case '>': return (GREATER_GREATER); case ';': in_case_pattern_list = 1; #if defined (ALIAS) expand_next_token = 0; #endif /* ALIAS */ return (SEMI_SEMI); case '&': return (AND_AND); case '|': return (OR_OR); } } else { if (peek_char == '&') { switch (character) { case '<': return (LESS_AND); case '>': return (GREATER_AND); } } if (character == '<' && peek_char == '>') return (LESS_GREATER); if (character == '>' && peek_char == '|') return (GREATER_BAR); if (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) { allow_open_brace = 1; #if defined (ALIAS) expand_next_token = 0; #endif /* ALIAS */ } if (in_case_pattern_list && (character == ')')) in_case_pattern_list = 0; return (character); } /* Hack <&- (close stdin) case. */ if (character == '-') { switch (last_read_token) { case LESS_AND: case GREATER_AND: return (character); } } /* Okay, if we got this far, we have to read a word. Read one, and then check it against the known ones. */ { /* Index into the token that we are building. */ int token_index = 0; /* ALL_DIGITS becomes zero when we see a non-digit. */ int all_digits = digit (character); /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */ int dollar_present = 0; /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */ int quoted = 0; /* Non-zero means to ignore the value of the next character, and just to add it no matter what. */ int pass_next_character = 0; /* Non-zero means parsing a dollar-paren construct. It is the count of un-quoted closes we need to see. */ int dollar_paren_level = 0; /* Non-zero means parsing a dollar-bracket construct ($[...]). It is the count of un-quoted `]' characters we need to see. */ int dollar_bracket_level = 0; /* Another level variable. This one is for dollar_parens inside of double-quotes. */ int delimited_paren_level = 0; for (;;) { if (character == EOF) goto got_token; if (pass_next_character) { pass_next_character = 0; goto got_character; } if (delimiter && character == '\\' && delimiter != '\'') { peek_char = shell_getc (0); if (peek_char != '\\') shell_ungetc (peek_char); else { token[token_index++] = character; goto got_character; } } /* Handle backslashes. Quote lots of things when not inside of double-quotes, quote some things inside of double-quotes. */ if (character == '\\' && delimiter != '\'') { peek_char = shell_getc (0); /* Backslash-newline is ignored in all cases excepting when quoted with single quotes. */ if (peek_char == '\n') { character = '\n'; goto next_character; } else { shell_ungetc (peek_char); /* If the next character is to be quoted, do it now. */ if (!delimiter || delimiter == '`' || ((delimiter == '"' ) && (member (peek_char, slashify_in_quotes)))) { pass_next_character++; quoted = 1; goto got_character; } } } /* This is a hack, in its present form. If a backquote substitution appears within double quotes, everything within the backquotes should be read as part of a single word. Jesus. Now I see why Korn introduced the $() form. */ if (delimiter && delimiter == '"' && character == '`') { old_delimiter = delimiter; delimiter = character; goto got_character; } if (delimiter) { if (character == delimiter) { if (delimited_paren_level) { #if defined (NOTDEF) report_error ("Expected ')' before %c", character); return ('\n'); #else goto got_character; #endif /* NOTDEF */ } delimiter = 0; if (old_delimiter == '"' && character == '`') { delimiter = old_delimiter; old_delimiter = 0; } goto got_character; } } if (!delimiter || delimiter == '`' || delimiter == '"') { if (character == '$') { peek_char = shell_getc (1); shell_ungetc (peek_char); if (peek_char == '(') { if (!delimiter) dollar_paren_level++; else delimited_paren_level++; pass_next_character++; goto got_character; } else if (peek_char == '[') { if (!delimiter) dollar_bracket_level++; pass_next_character++; goto got_character; } } /* If we are parsing a $() or $[] construct, we need to balance parens and brackets inside the construct. This whole function could use a rewrite. */ if (character == '(') { if (delimiter && delimited_paren_level) delimited_paren_level++; if (!delimiter && dollar_paren_level) dollar_paren_level++; } if (character == '[') { if (!delimiter && dollar_bracket_level) dollar_bracket_level++; } /* This code needs to take into account whether we are inside a case statement pattern list, and whether this paren is supposed to terminate it (hey, it could happen). It's not as simple as just using in_case_pattern_list, because we're not parsing anything while we're reading a $( ) construct. Maybe we should move that whole mess into the yacc parser. */ if (character == ')') { if (delimiter && delimited_paren_level) delimited_paren_level--; if (!delimiter && dollar_paren_level) { dollar_paren_level--; goto got_character; } } if (character == ']') { if (!delimiter && dollar_bracket_level) { dollar_bracket_level--; goto got_character; } } } if (!dollar_paren_level && !dollar_bracket_level && !delimiter && member (character, " \t\n;&()|<>")) { shell_ungetc (character); goto got_token; } if (!delimiter) { if (character == '"' || character == '`' || character == '\'') { quoted = 1; delimiter = character; goto got_character; } } if (all_digits) all_digits = digit (character); if (character == '$') dollar_present = 1; got_character: token[token_index++] = character; if (token_index == (token_buffer_size - 1)) token = (char *)xrealloc (token, (token_buffer_size += TOKEN_DEFAULT_GROW_SIZE)); { char *decode_prompt_string (); next_character: if (character == '\n' && interactive && yy_input_type != st_string) prompt_again (); } /* We want to remove quoted newlines (that is, a \ pair) unless we are within single quotes or pass_next_character is set (the shell equivalent of literal-next). */ character = shell_getc ((delimiter != '\'') && (!pass_next_character)); } got_token: token[token_index] = '\0'; if ((delimiter || dollar_paren_level || dollar_bracket_level) && character == EOF) { if (dollar_paren_level && !delimiter) delimiter = ')'; else if (dollar_bracket_level && !delimiter) delimiter = ']'; report_error ("Unexpected EOF. Looking for `%c'.", delimiter); return (-1); } if (all_digits) { /* Check to see what thing we should return. If the last_read_token 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 ((character == '<' || character == '>') || (last_read_token == LESS_AND || last_read_token == GREATER_AND)) { yylval.number = atoi (token); /* was sscanf (token, "%d", &(yylval.number)); */ return (NUMBER); } } /* Handle special case. IN is recognized if the last token was WORD and the token before that was FOR or CASE. */ if ((last_read_token == WORD) && ((token_before_that == FOR) || (token_before_that == CASE)) && (STREQ (token, "in"))) { if (token_before_that == CASE) { in_case_pattern_list = 1; allow_esac_as_next++; } return (IN); } /* Ditto for DO in the FOR case. */ if ((last_read_token == WORD) && (token_before_that == FOR) && (STREQ (token, "do"))) return (DO); /* Ditto for ESAC in the CASE case. Specifically, this handles "case word in esac", which is a legal construct, certainly because someone will pass an empty arg to the case construct, and we don't want it to barf. Of course, we should insist that the case construct has at least one pattern in it, but the designers disagree. */ if (allow_esac_as_next) { allow_esac_as_next--; if (STREQ (token, "esac")) { in_case_pattern_list = 0; return (ESAC); } } /* Ditto for `{' in the FUNCTION case. */ if (allow_open_brace) { allow_open_brace = 0; if (STREQ (token, "{")) { open_brace_awaiting_satisfaction++; return ('{'); } } #if defined (ALIAS) #define command_token_position(token) \ ((token) != SEMI_SEMI && reserved_word_acceptable (token)) /* 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 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 token is not the same as the current or any previously processed alias. Special cases that disqualify: In a pattern list in a case statement (in_case_pattern_list). */ if (interactive_shell && !quoted && !in_case_pattern_list && (command_token_position (last_read_token) || expand_next_token)) { char *alias_expand_word (), *expanded; if (current_token_being_expanded && ((STREQ (token, current_token_being_expanded)) || (token_has_been_expanded (token)))) goto no_expansion; expanded = alias_expand_word (token); if (expanded) { int len = strlen (expanded), expand_next; char *temp; /* Erase the current token. */ token_index = 0; expand_next = (expanded[len - 1] == ' ') || (expanded[len - 1] == '\t'); temp = savestring (token); push_string (expanded, expand_next, temp); goto re_read_token; } else /* This is an eligible token that does not have an expansion. */ no_expansion: expand_next_token = 0; } else { expand_next_token = 0; } #endif /* ALIAS */ /* Check to see if it is a reserved word. */ if (!dollar_present && !quoted && reserved_word_acceptable (last_read_token)) { int i; for (i = 0; word_token_alist[i].word != (char *)NULL; i++) if (STREQ (token, word_token_alist[i].word)) { if (in_case_pattern_list && (word_token_alist[i].token != ESAC)) break; if (word_token_alist[i].token == ESAC) in_case_pattern_list = 0; if (word_token_alist[i].token == '{') open_brace_awaiting_satisfaction++; return (word_token_alist[i].token); } } /* What if we are attempting to satisfy an open-brace grouper? */ if (open_brace_awaiting_satisfaction && strcmp (token, "}") == 0) { open_brace_awaiting_satisfaction--; return ('}'); } the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC)); the_word->word = (char *)xmalloc (1 + strlen (token)); strcpy (the_word->word, token); the_word->dollar_present = dollar_present; the_word->quoted = quoted; the_word->assignment = assignment (token); yylval.word = the_word; result = WORD; if (last_read_token == FUNCTION) allow_open_brace = 1; } return (result); } #if defined (NOTDEF) /* Obsoleted function no longer used. */ /* Return 1 if this token is a legal shell `identifier'; that is, it consists solely of letters, digits, and underscores, and does not begin with a digit. */ legal_identifier (name) char *name; { register char *s; if (!name || !*name) return (0); if (digit (*name)) return (0); for (s = name; s && *s; s++) { if (!isletter (*s) && !digit (*s) && (*s != '_')) return (0); } return (1); } #endif /* NOTDEF */ /* Return 1 if TOKEN is a token that after being read would allow a reserved word to be seen, else 0. */ static int reserved_word_acceptable (token) int token; { if (member (token, "\n;()|&{") || token == AND_AND || token == BANG || token == DO || token == ELIF || token == ELSE || token == IF || token == OR_OR || token == SEMI_SEMI || token == THEN || token == UNTIL || token == WHILE || token == 0) return (1); else return (0); } #if defined (READLINE) /* Called after each time readline is called. This insures that whatever the new prompt string is gets propagated to readline's local prompt variable. */ reset_readline_prompt () { if (prompt_string_pointer && *prompt_string_pointer) { char *temp_prompt, *decode_prompt_string (); temp_prompt = decode_prompt_string (*prompt_string_pointer); if (!temp_prompt) temp_prompt = savestring (""); if (current_readline_prompt) free (current_readline_prompt); current_readline_prompt = temp_prompt; } } #endif /* A list of tokens which can be followed by newlines, but not by semi-colons. When concatenating multiple lines of history, the newline separator for such tokens is replaced with a space. */ int no_semi_successors[] = { '\n', '{', '(', ')', ';', CASE, DO, ELSE, IF, IN, SEMI_SEMI, THEN, UNTIL, WHILE, 0 }; /* Add a line to the history list. The variable COMMAND_ORIENTED_HISTORY controls the style of history remembering; when non-zero, and LINE is not the first line of a complete parser construct, append LINE to the last history line instead of adding it as a new line. */ bash_add_history (line) char *line; { extern int command_oriented_history; int add_it = 1; if (command_oriented_history && current_command_line_count > 1) { register int offset; register HIST_ENTRY *current, *old; char *chars_to_add, *new_line; /* If we are not within a delimited expression, try to be smart about which separators can be semi-colons and which must be newlines. */ if (!delimiter) { register int i; chars_to_add = (char *)NULL; for (i = 0; no_semi_successors[i]; i++) { if (token_before_that == no_semi_successors[i]) { chars_to_add = " "; break; } } if (!chars_to_add) chars_to_add = "; "; } else chars_to_add = "\n"; using_history (); current = previous_history (); if (current) { offset = where_history (); new_line = (char *) xmalloc (1 + strlen (current->line) + strlen (line) + strlen (chars_to_add)); sprintf (new_line, "%s%s%s", current->line, chars_to_add, line); old = replace_history_entry (offset, new_line, current->data); free (new_line); if (old) { /* Note that the old data is not freed, since it was simply copied to the new history entry. */ if (old->line) free (old->line); free (old); } add_it = 0; } } if (add_it) { extern int history_lines_this_session; add_history (line); history_lines_this_session++; } using_history (); } /* Issue a prompt, or prepare to issue a prompt when the next character is read. */ prompt_again () { char *temp_prompt, *decode_prompt_string (); ps1_prompt = get_string_value ("PS1"); ps2_prompt = get_string_value ("PS2"); if (!prompt_string_pointer) prompt_string_pointer = &ps1_prompt; if (*prompt_string_pointer) temp_prompt = decode_prompt_string (*prompt_string_pointer); else temp_prompt = savestring (""); current_prompt_string = *prompt_string_pointer; prompt_string_pointer = &ps2_prompt; #if defined (READLINE) if (!no_line_editing) { if (current_readline_prompt) free (current_readline_prompt); current_readline_prompt = temp_prompt; } else #endif /* READLINE */ { if (interactive) { fprintf (stderr, "%s", temp_prompt); fflush (stderr); } free (temp_prompt); } } #include "maxpath.h" /* Return a string which will be printed as a prompt. The string may contain special characters which are decoded as follows: \t the time \d the date \n CRLF \s the name of the shell \w the current working directory \W the last element of PWD \u your username \h the hostname \# the command number of this command \! the history number of this command \$ a $ or a # if you are root \ character code in octal \\ a backslash */ #include #include #define PROMPT_GROWTH 50 char * decode_prompt_string (string) char *string; { int result_size = PROMPT_GROWTH; int result_index = 0; char *result = (char *)xmalloc (PROMPT_GROWTH); int c; char *temp = (char *)NULL; result[0] = 0; while (c = *string++) { if (c == '\\') { c = *string; switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': { char octal_string[4]; int n; strncpy (octal_string, string, 3); octal_string[3] = '\0'; n = read_octal (octal_string); temp = savestring ("\\"); if (n != -1) { string += 3; temp[0] = n; } c = 0; goto add_string; } case 't': case 'd': /* Make the current time/date into a string. */ { long the_time = time (0); char *ttemp = ctime (&the_time); temp = savestring (ttemp); if (c == 't') { strcpy (temp, temp + 11); temp[8] = '\0'; } else temp[10] = '\0'; goto add_string; } case 'n': if (!no_line_editing) temp = savestring ("\r\n"); else temp = savestring ("\n"); goto add_string; case 's': { extern char *shell_name; temp = savestring (shell_name); goto add_string; } case 'w': case 'W': { /* Use the value of PWD because it is much more effecient. */ #define EFFICIENT #ifdef EFFICIENT char *polite_directory_format (), t_string[MAXPATHLEN]; temp = get_string_value ("PWD"); if (!temp) getwd (t_string); else strcpy (t_string, temp); #else getwd (t_string); #endif /* EFFICIENT */ if (c == 'W') { char *dir = (char *)rindex (t_string, '/'); if (dir && dir != t_string) strcpy (t_string, dir + 1); temp = savestring (t_string); } else temp = savestring (polite_directory_format (t_string)); goto add_string; } case 'u': { extern char *current_user_name; temp = savestring (current_user_name); goto add_string; } case 'h': { extern char *current_host_name; char *t_string; temp = savestring (current_host_name); if (t_string = (char *)index (temp, '.')) *t_string = '\0'; goto add_string; } case '#': { extern int current_command_number; char number_buffer[20]; sprintf (number_buffer, "%d", current_command_number); temp = savestring (number_buffer); goto add_string; } case '!': { extern int history_base, where_history (); char number_buffer[20]; using_history (); if (get_string_value ("HISTSIZE")) sprintf (number_buffer, "%d", history_base + where_history ()); else strcpy (number_buffer, "!"); temp = savestring (number_buffer); goto add_string; } case '$': temp = savestring (geteuid () == 0 ? "#" : "$"); goto add_string; case '\\': temp = savestring ("\\"); goto add_string; default: temp = savestring ("\\ "); temp[1] = c; add_string: if (c) string++; result = (char *)sub_append_string (temp, result, &result_index, &result_size); temp = (char *)NULL; /* Free ()'ed in sub_append_string (). */ result[result_index] = '\0'; break; } } else { while (3 + result_index > result_size) result = (char *)xrealloc (result, result_size += PROMPT_GROWTH); result[result_index++] = c; result[result_index] = '\0'; } } /* I don't really think that this is a good idea. Do you? */ if (!find_variable ("NO_PROMPT_VARS")) { WORD_LIST *expand_string (), *list; char *string_list (); list = expand_string (result, 1); free (result); result = string_list (list); dispose_words (list); } return (result); } /* Report a syntax error, and restart the parser. Call here for fatal errors. */ yyerror () { report_syntax_error ((char *)NULL); reset_parser (); } /* 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 out an appropriate message for you. */ report_syntax_error (message) char *message; { if (message) { if (!interactive) { char *name = stream_name ? stream_name : "stdin"; report_error ("%s:%d: `%s'", name, line_number, message); } else report_error ("%s", message); return; } if (shell_input_line && *shell_input_line) { char *error_token, *t = shell_input_line; register int i = shell_input_line_index; int token_end = 0; if (!t[i] && i) i--; while (i && (t[i] == ' ' || t[i] == '\t' || t[i] == '\n')) i--; if (i) token_end = i + 1; while (i && !member (t[i], " \n\t;|&")) i--; while (i != token_end && member (t[i], " \n\t")) i++; if (token_end) { error_token = (char *)alloca (1 + (token_end - i)); strncpy (error_token, t + i, token_end - i); error_token[token_end - i] = '\0'; report_error ("syntax error near `%s'", error_token); } else if ((i == 0) && (token_end == 0)) /* a 1-character token */ { error_token = (char *) alloca (2); strncpy(error_token, t + i, 1); error_token[1] = '\0'; report_error ("syntax error near `%s'", error_token); } if (!interactive) { char *temp = savestring (shell_input_line); char *name = stream_name ? stream_name : "stdin"; int l = strlen (temp); while (l && temp[l - 1] == '\n') temp[--l] = '\0'; report_error ("%s:%d: `%s'", name, line_number, temp); free (temp); } } else report_error ("Syntax error"); } /* ??? Needed function. ??? We have to be able to discard the constructs 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. */ discard_parser_constructs (error_p) int error_p; { /* if (error_p) { fprintf (stderr, "*"); } */ } /* Do that silly `type "bye" to exit' stuff. You know, "ignoreeof". */ /* The number of times that we have encountered an EOF character without another character intervening. When this gets above the limit, the shell terminates. */ int eof_encountered = 0; /* The limit for eof_encountered. */ int eof_encountered_limit = 10; /* If we have EOF as the only input unit, this user wants to leave the shell. If the shell is not interactive, then just leave. Otherwise, if ignoreeof is set, and we haven't done this the required number of times in a row, print a message. */ handle_eof_input_unit () { extern int login_shell, EOF_Reached; if (interactive) { /* If the user wants to "ignore" eof, then let her do so, kind of. */ if (find_variable ("ignoreeof") || find_variable ("IGNOREEOF")) { if (eof_encountered < eof_encountered_limit) { fprintf (stderr, "Use \"%s\" to leave the shell.\n", login_shell ? "logout" : "exit"); eof_encountered++; /* Reset the prompt string to be $PS1. */ prompt_string_pointer = (char **)NULL; prompt_again (); last_read_token = current_token = '\n'; return; } } /* In this case EOF should exit the shell. Do it now. */ reset_parser (); exit_builtin ((WORD_LIST *)NULL); } else { /* We don't write history files, etc., for non-interactive shells. */ EOF_Reached = 1; } }