Subversion Repositories Code-Repo

/*

 * esh - the 'pluggable' shell.

 *

 * Developed by Godmar Back for CS 3214 Fall 2009

 * Virginia Tech.

 *

 * This is based on an assignment I did in 1993 as an undergraduate

 * student at Technische Universitaet Berlin.

 *

 * Known bugs: leaks memory when parse errors occur.

 */

%{

#include <stdio.h>

#include <stdlib.h>

#define YYDEBUG	1

int yydebug;

void yyerror(const char *msg);

int yylex(void);

/*

 * Error messages, csh-style

 */

#define MISRED	"Missing name for redirect."

#define INVNUL  "Invalid null command."

#define AMBINP  "Ambiguous input redirect."

#define AMBOUT  "Ambiguous output redirect."

#include "esh.h"

#define obstack_chunk_alloc malloc

#define obstack_chunk_free free

struct cmd_helper {

    struct obstack words;   /* an obstack of char * to collect argv */

    char *iored_input;

    char *iored_output;

    bool append_to_output;

};

/* Initialize cmd_helper and, optionally, set first argv */

static void

init_cmd(struct cmd_helper *cmd, char *firstcmd, 

         char *iored_input, char *iored_output, bool append_to_output)

{

    obstack_init(&cmd->words);

    if (firstcmd)

        obstack_ptr_grow(&cmd->words, firstcmd);

    cmd->iored_output = iored_output;

    cmd->iored_input = iored_input;

    cmd->append_to_output = append_to_output;

}

/* print error message */

static void p_error(char *msg);

/* Convert cmd_helper to esh_command.

 * Ensures NULL-terminated argv[] array

 */

static struct esh_command * 

make_esh_command(struct cmd_helper *cmd)

{

    obstack_ptr_grow(&cmd->words, NULL);

    int sz = obstack_object_size(&cmd->words);

    char **argv = malloc(sz);

    memcpy(argv, obstack_finish(&cmd->words), sz);

    obstack_free(&cmd->words, NULL);

    if (*argv == NULL) {

        free(argv);

        return NULL; 

    }

    return esh_command_create(argv,

                              cmd->iored_input,

                              cmd->iored_output,

                              cmd->append_to_output);

}

/* Called by parser when command line is complete */

static void cmdline_complete(struct esh_command_line *);

/* work-around for bug in flex 2.31 and later */

static void yyunput (int c,char *buf_ptr  ) __attribute__((unused));

%}

/* LALR stack types */

%union {

  struct cmd_helper command;

  struct esh_pipeline * pipe;

  struct esh_command_line * cmdline;

  char *word;

}

/* Nonterminals */

%type <command> input output

%type <command> command

%type <pipe> pipeline

%type <cmdline> cmd_list

/* Terminals */

%token <word> WORD

%token GREATER_GREATER 

%%

cmd_line: cmd_list { cmdline_complete($1); }

cmd_list:	/* Null Command */ { $$ = esh_command_line_create_empty(); }

|		pipeline { 

            esh_pipeline_finish($1);

            $$ = esh_command_line_create($1);

        } 

|		cmd_list ';'

|		cmd_list '&' {

            $$ = $1;

            struct esh_pipeline * last;

            last = list_entry(list_back(&$1->pipes), 

                              struct esh_pipeline, elem);

            last->bg_job = true;

        }

|		cmd_list ';' pipeline	{ 

            esh_pipeline_finish($3);

            $$ = $1;

            list_push_back(&$$->pipes, &$3->elem);

        }

|		cmd_list '&' pipeline	{ 

            esh_pipeline_finish($3);

            $$ = $1;

            struct esh_pipeline * last;

            last = list_entry(list_back(&$1->pipes), 

                              struct esh_pipeline, elem);

            last->bg_job = true;

            list_push_back(&$$->pipes, &$3->elem);

        }

pipeline: command {

            struct esh_command * pcmd = make_esh_command(&$1);

            if (pcmd == NULL) { p_error(INVNUL); YYABORT; }

            $$ = esh_pipeline_create(pcmd);

		}

|		pipeline '|' command {

		    /* Error: 'ls >x | wc' */

            struct esh_command * last;

            last = list_entry(list_back(&$1->commands), 

                              struct esh_command, elem);

		    if (last->iored_output) { p_error(AMBOUT); YYABORT; }

		    /* Error: 'ls | <x wc' */

		    if ($3.iored_input) { p_error(AMBINP); YYABORT; }

            struct esh_command * pcmd = make_esh_command(&$3);

            if (pcmd == NULL) { p_error(INVNUL); YYABORT; }

            list_push_back(&$1->commands, &pcmd->elem);

            pcmd->pipeline = $1;

            $$ = $1;

		}

|		'|' error 	   { p_error(INVNUL); YYABORT; }

|		pipeline '|' error { p_error(INVNUL); YYABORT; }

command:   WORD { 

            init_cmd(&$$, $1, NULL, NULL, false);

        }

|		input   

|		output

|		command WORD {

            $$ = $1;

            obstack_ptr_grow(&$$.words, $2);

		}

|		command input {

            obstack_free(&$2.words, NULL);

            /* Error: ambiguous redirect 'a <b <c' */

            if($1.iored_input)   { p_error(AMBINP); YYABORT; }

            $$ = $1; 

            $$.iored_input = $2.iored_input;

		}

|		command output {

            obstack_free(&$2.words, NULL);

            /* Error: ambiguous redirect 'a >b >c' */

            if ($1.iored_output) { p_error(AMBOUT); YYABORT; }

            $$ = $1; 

            $$.iored_output = $2.iored_output;

            $$.append_to_output = $2.append_to_output;

		}

input:	'<' WORD { 

            init_cmd(&$$, NULL, $2, NULL, false);

        }

|		'<' error	  { p_error(MISRED); YYABORT; }

output:	'>' WORD { 

            init_cmd(&$$, NULL, NULL, $2, false);

        }

|		GREATER_GREATER WORD { 

            init_cmd(&$$, NULL, NULL, $2, true);

        }

		/* Error: missing redirect */

|		'>' error 	  { p_error(MISRED); YYABORT; }

|		GREATER_GREATER error { p_error(MISRED); YYABORT; }

%%

static char * inputline;    /* currently processed input line */

#define YY_INPUT(buf,result,max_size) \

    { \

        result = *inputline ? (buf[0] = *inputline++, 1) : YY_NULL; \

    }

#define YY_NO_UNPUT

#define YY_NO_INPUT

#include "lex.yy.c"

static void

p_error(char *msg) 

{ 

    /* print error */

    fprintf(stderr, "%s\n", msg); 

}

extern int yyparse (void);

/* do not use default error handling since errors are handled above. */

void 

yyerror(const char *msg) { }

static struct esh_command_line * commandline;

static void cmdline_complete(struct esh_command_line *cline)

{

    commandline = cline;

}

/* 

 * parse a commandline.

 */

struct esh_command_line *

esh_parse_command_line(char * line)

{

    inputline = line;

    commandline = NULL;

    int error = yyparse();

    return error ? NULL : commandline;

}