parser.c

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "parser.h"

/* --- symbolic constants --- */
#define COMMANDMAX 20
#define BUFFERMAX 256
#define PBUFFERMAX 50
#define PIPE  ('|')
#define BG    ('&')
#define RIN   ('<')
#define RUT   ('>')
#define IDCHARS "_-.,/~+"

/* --- symbolic macros --- */
#define ispipe(c) ((c) == PIPE)
#define isbg(c)   ((c) == BG)
#define isrin(c)  ((c) == RIN)
#define isrut(c)  ((c) == RUT)
#define isspec(c) (ispipe(c) || isbg(c) || isrin(c) || isrut(c))

/* --- static memory allocation --- */
static Cmd  cmdbuf[COMMANDMAX], *cmds;
static char cbuf[BUFFERMAX], *cp;
static char *pbuf[PBUFFERMAX], **pp;

/*
 * parse : A simple commandline parser.
 */

/* --- parse the commandline and build shell commmand structure --- */
int parsecommand(char *cmdline, Shellcmd *shellcmd)
{
  int i, n;
  Cmd *cmd0;

  char *t = cmdline;
  char *tok;

  // Initialize list
  for (i = 0; i < COMMANDMAX-1; i++) cmdbuf[i].next = &cmdbuf[i+1];

  cmdbuf[COMMANDMAX-1].next = NULL;
  cmds = cmdbuf;
  cp = cbuf;
  pp = pbuf;

  shellcmd->rd_stdin    = NULL;
  shellcmd->rd_stdout   = NULL;
  shellcmd->rd_stderr   = NULL;
  shellcmd->background = 0; // false 
  shellcmd->the_cmds       = NULL;

  do {
    if ((n = acmd(t, &cmd0)) <= 0)
      return -1;
    t += n;

    cmd0->next = shellcmd->the_cmds;
    shellcmd->the_cmds = cmd0;

    int newtoken = 1;
    while (newtoken) {
      n = nexttoken(t, &tok);
      if (n == 0)
      {
        return 1;
      }
      t += n;

      switch(*tok) {
        case PIPE:
          newtoken = 0;
          break;
        case BG:
          n = nexttoken(t, &tok);
          if (n == 0)
          {
            shellcmd->background = 1;
            return 1;
          }
          else
          {
            fprintf(stderr, "illegal bakgrounding\n");
            return -1;
          }
          newtoken = 0;
          break;
        case RIN:
          if (shellcmd->rd_stdin != NULL)
          {
            fprintf(stderr, "duplicate redirection of stdin\n");
            return -1;
          }
          if ((n = nexttoken(t, &(shellcmd->rd_stdin))) < 0) 
            return -1;
          if (!isidentifier(shellcmd->rd_stdin))
          {
            fprintf(stderr, "Illegal filename: \"%s\"\n", shellcmd->rd_stdin);
            return -1;
          }
          t += n;
          break;
        case RUT:
          if (shellcmd->rd_stdout != NULL)
          {
            fprintf(stderr, "duplicate redirection of stdout\n");
            return -1;
          }
          if ((n = nexttoken(t, &(shellcmd->rd_stdout))) < 0) 
            return -1;
          if (!isidentifier(shellcmd->rd_stdout))
          {
            fprintf(stderr, "Illegal filename: \"%s\"\n", shellcmd->rd_stdout);
            return -1;
          }
          t += n;
          break;
        default:
          return -1;
      }
    }
  } while (1);
  return 0;
}

int nexttoken( char *s, char **tok)
{
  char *s0 = s;
  char c;

  *tok = cp;
  while (isspace(c = *s++) && c);
  if (c == '\0')
  {
    return 0;
  }
  if (isspec(c))
  {
    *cp++ = c;
    *cp++ = '\0';
  }
  else
  {
    *cp++ = c;
    do
    {
      c = *cp++ = *s++;
    } while (!isspace(c) && !isspec(c) && (c != '\0'));
    --s;
    --cp;
    *cp++ = '\0';
  }
  return s - s0;
}

int acmd (char *s, Cmd **cmd)
{
  char *tok;
  int n, cnt = 0;
  Cmd *cmd0 = cmds;
  cmds = cmds->next;
  cmd0->next = NULL;
  cmd0->cmd = pp;

  while (1) {
    n = nexttoken(s, &tok);
    if (n == 0 || isspec(*tok))
    {
      *cmd = cmd0;
      *pp++ = NULL;
      return cnt;
    }
    else
    {
      *pp++ = tok;
      cnt += n;
      s += n;
    }
  }
}

int isidentifier (char *s)
{
  while (*s)
  {
    char *p = strrchr (IDCHARS,  *s);
    if (! isalnum(*s++) && (p == NULL))
      return 0;
  }
  return 1;
}