syntax_parser.y

%code requires 
{
#include <string>

#if __cplusplus > 199711L
#define register      // Deprecated in C++11 so remove the keyword
#endif
}

%union
{
  char        *string_val;
  std::string *cpp_string;
}

%token <cpp_string> WORD
%token NOTOKEN GREAT NEWLINE LESS PIPE GREATGREAT TWOGREAT GREATAMPERSAND GREATGREATAMPERSAND AMPERSAND CD SETENV UNSETENV PRINTENV PROCESS_SUB_OPEN PROCESS_SUB_CLOSE

%{
#include <cstdio>
#include "shell_interpreter.hh"
#include <regex.h>
#include <dirent.h> 
#include <cstdlib>
#include <unistd.h>
#include <string.h>
void yyerror(const char * s);
int yylex();

void expandWildCardsIfNecessary(char * arg);
int cmpfunc(const void * file1, const void * file2);
void expandWildCards(char * prefix, char * arg);

%}

%%

goal:
  commands
  ;

commands:
  command
  | commands command
  ;

command: simple_command
       ;

simple_command:	
    pipe_list iomodifier_opt_list background_optional NEWLINE {
    #ifdef PRINTING 
      printf("   Yacc: Execute command\n");
    #endif
    Shell::_currentCommand.execute();
  }
  | NEWLINE 
  | error NEWLINE { yyerrok; }
  ;

iomodifier_opt_list:
  iomodifier_opt_list iomodifier_opt
  |
  ;

command_and_args:
  command_word argument_list {
    Shell::_currentCommand.
    insertSimpleCommand( Command::_currentSimpleCommand );
  }
  | cd
  | UNSETENV
  | SETENV
  | PRINTENV
  ;

pipe_list:
  pipe_list PIPE command_and_args
  | command_and_args
  ;


argument_list:
  argument_list WORD {
    char * arg = strdup($2->c_str());
    if(Command::_currentSimpleCommand->_arguments.size() > 0 && strcmp(Command::_currentSimpleCommand->_arguments[0]->c_str(), "echo") == 0 && strchr(arg, '?')) {
      Command::_currentSimpleCommand->insertArgument( $2 );
    }
    else {
      expandWildCardsIfNecessary(arg);
    }
    if (arg) {
      free(arg);
    }
  }
  | /* can be empty */
  ;

cd:
  CD WORD {
    char* path = (char*)$2->c_str();
    if (chdir(path) == -1) {
      fprintf(stderr, "cd: can't cd to %s\n", path);
    }
  }
  | 
  CD {
    char* path = getenv((char*) "HOME");
    if (chdir(path) == -1) {
      fprintf(stderr, "cd: can't cd to %s\n", path);
    }
  }
  ;

command_word:
  WORD {
    #ifdef PRINTING 
      printf("   Yacc: insert command \"%s\"\n", $1->c_str());
    #endif
    Command::_currentSimpleCommand = new SimpleCommand();
    Command::_currentSimpleCommand->insertArgument( $1 );
  }
  ;

iomodifier_opt:
  GREATGREAT WORD {
    Shell::_currentCommand._outFile = $2;
    Shell::_currentCommand._append = true;
  }
  | GREAT WORD {
    #ifdef PRINTING 
      printf("   Yacc: insert output \"%s\"\n", $2->c_str());
    #endif
    if (Shell::_currentCommand._outFile != NULL) {
      printf("Ambiguous output redirect.\n"); // Call your error function
    }
    Shell::_currentCommand._outFile = $2;
  }
  | GREATGREATAMPERSAND WORD {
    Shell::_currentCommand._outFile = $2;
    Shell::_currentCommand._errFile = $2;
    Shell::_currentCommand._append = true;
  }
  | GREATAMPERSAND WORD {
    Shell::_currentCommand._outFile = $2;
    Shell::_currentCommand._errFile = $2;
  }
  | LESS WORD {
    #ifdef PRINTING 
      printf("   Yacc: insert input \"%s\"\n", $2->c_str());
    #endif
    Shell::_currentCommand._inFile = $2;
  }
  | TWOGREAT WORD {
    Shell::_currentCommand._errFile = $2;
  }
  ;

background_optional:
  AMPERSAND
  {
    Shell::_currentCommand._background = true;
  }
  |
  ;
%%
int maxEntries = 20;
int nEntries = 0;
char ** entries;

void expandWildCardsIfNecessary(char * arg) {
  maxEntries = 20;
  nEntries = 0;
  entries = (char **) malloc (maxEntries * sizeof(char *));

  if (strchr(arg, '*') || strchr(arg, '?')) {
    expandWildCards(NULL, arg);
    qsort(entries, nEntries, sizeof(char *), cmpfunc);
    for (int i = 0; i < nEntries; i++) {
      std::string * curr = new std::string(entries[i]);
      Command::_currentSimpleCommand->insertArgument(curr);
    }
  }
  else {
    std::string * newarg = new std::string(arg);
    Command::_currentSimpleCommand->insertArgument(newarg);
  }
  for (int i = 0; i < nEntries; i++) {
    if (entries[i]) {
      free(entries[i]);  // Free each strdup'd string
    }
  }
  if (entries) {
    free(entries);
  }
  return;
}

int cmpfunc (const void *file1, const void *file2) {
  const char *_file1 = *(const char **)file1;
  const char *_file2 = *(const char **)file2;
  return strcmp(_file1, _file2);
}

void expandWildCards(char * prefix, char * arg) {
  char * temp = arg;
  char * save = (char *) malloc (strlen(arg) + 10);
  char * dir = save;
  char * toDelete = dir;
  if (temp[0] == '/') {
    *save = *temp;
    save++; temp++;
  }

  while (*temp != '/' && *temp) {
    *save = *temp;
    save++; temp++;
  }
  *save = '\0';

  if (strchr(dir, '*') || strchr(dir, '?')) {
    if (!prefix && arg[0] == '/') {
      prefix = strdup("/");
      dir++;
    }

    char * reg = (char *) malloc (2*strlen(arg) + 10);
    char * a = dir;
    char * r = reg;

    *(r++) = '^';
    while (*a) {
      if (*a == '*') {
        *(r++) = '.';
        *(r++) = '*';
      }
      else if (*a == '?') {
        *(r++) = '.';
      }
      else if (*a == '.') {
        *(r++) = '\\';
        *(r++) = '.';
      }
      else {
        *(r++) = *a;
      }
      a++;
    }
    *(r++) = '$'; *r = '\0';

    regex_t re;  
    int expbuf = regcomp(&re, reg, REG_EXTENDED|REG_NOSUB);

    char * toOpen = strdup((prefix)?prefix:".");
    DIR * dir = opendir(toOpen);
    if (dir == NULL) {
      free(toDelete);
      perror("opendir");
      return;
    }

    struct dirent * ent;
    regmatch_t match;

    while ((ent = readdir(dir)) != NULL) {
      if (!regexec(&re, ent->d_name, 1, &match, 0)) {
        if (*temp) {
          if (ent->d_type == DT_DIR) {
            char * nPrefix = (char *) malloc (150);
            if (!strcmp(toOpen, ".")) {
              nPrefix = strdup(ent->d_name);
            }
            else if (!strcmp(toOpen, "/")) {
              sprintf(nPrefix, "%s%s", toOpen, ent->d_name);
            }
            else {
              sprintf(nPrefix, "%s/%s", toOpen, ent->d_name);
            }
            expandWildCards(nPrefix, (*temp == '/')?++temp:temp);
          }
        } else {
          if (nEntries == maxEntries) {
            maxEntries *= 2;
            entries = (char **) realloc (entries, maxEntries * sizeof(char *));
          }
          char * argument = (char *) malloc (100);
          argument[0] = '\0';
          if (prefix) sprintf(argument, "%s/%s", prefix, ent->d_name);

          if (ent->d_name[0] == '.') {
            if (arg[0] == '.') {
              entries[nEntries++] = (argument[0] != '\0')?strdup(argument):strdup(ent->d_name);
            }
          } else {
            entries[nEntries++] = (argument[0] != '\0')?strdup(argument):strdup(ent->d_name);
          }
          free(argument);
        }
      }
    }
    regfree(&re);
    closedir(dir);
    if (toOpen) {
      free(toOpen);
    }
    if (reg) {
      free(reg);
    }
  } else {
    char * preToSend = (char *) malloc (100);
    if (prefix) {
      sprintf(preToSend, "%s/%s", prefix, dir);
    }
    else {
      preToSend = strdup(dir);
    }

    if (*temp) {
      expandWildCards(preToSend, ++temp);
    }
  }
  if (toDelete) {
    free(toDelete);
  }
}



void
yyerror(const char * s)
{
  fprintf(stderr,"%s", s);
}