Start development on BSD 2

[unix-history] / .ref-BSD-1 / ashell / sh_parse.c

#include "sh.h"

/*
* syntax
*      empty
*      syn0
*/
syntax(p1, p2)
       register struct shvar2 *p1, *p2;
{

       while (p1 != p2)
               if (any(p1->value[0], ";&\n"))
                       p1 = p1->next;
               else
                       return (syn0(p1, p2));
       return (0);
}

/*
* syn0
*      syn1
*      syn1 & syntax
*/
syn0(p1, p2)
       struct shvar2 *p1, *p2;
{
       register struct shvar2 *p;
       register *t, *t1;
       int l;

       l = 0;
       for (p = p1; p != p2; p = p->next)
               switch (p->value[0]) {
                       case '(':
                               l++;
                               continue;
                       case ')':
                               l--;
                               if (l < 0)
                                       seterr("Too many )'s");
                               continue;
                       case '&':
                               if (l != 0)
                                       break;
                               t1 = syn1(p1, p);
                               if (t1[DTYP] == TLST) {
                                       t = calloc(2, 5);
                                       t[DTYP] = TPAR;
                                       t[DFLG] = FAND|FPRS|FINT;
                                       t[DSPR] = t1;
                                       t1 = t;
                               } else
                                       t1[DFLG] =| FAND|FPRS|FINT;
                               t = calloc(2, 4);
                               t[DTYP] = TLST;
                               t[DFLG] = 0;
                               t[DLEF] = t1;
                               t[DRIT] = syntax(p, p2);
                               return(t);
               }
       if (l == 0)
               return (syn1(p1, p2));
       seterr("Too many ('s");
       return(0);
}

/*
* syn1
*      syn2
*      syn2 ; syn1
*/
syn1(p1, p2)
       struct shvar2 *p1, *p2;
{
       register struct shvar *p;
       register *t;
       int l;

       l = 0;
       for (p = p1; p != p2; p = p->next)
               switch (p->value[0]) {
                       case '(':
                               l++;
                               continue;
                       case ')':
                               l--;
                               continue;
                       case ';':
                       case '\n':
                               if (l != 0)
                                       break;
                               t = calloc(2, 4);
                               t[DTYP] = TLST;
                               t[DLEF] = syn2(p1, p);
                               t[DRIT] = syntax(p->next, p2);
                               return (t);
               }
       return (syn2(p1, p2));
}

/*
* syn2
*      syn3
*      syn3 | syn2
*      syn3 |* syn2
*/
syn2(p1, p2)
       struct shvar2 *p1, *p2;
{
       register struct shvar2 *p, *pn;
       register int *t;
       int l;

       l = 0;
       for (p = p1; p != p2; p = p->next)
               switch (p->value[0]) {
                       case '(':
                               l++;
                               continue;
                       case ')':
                               l--;
                               continue;
                       case '|':
                       case '^':
                               if (l != 0)
                                       continue;
                               t = calloc(2, 4);
                               t[DTYP] = TFIL;
                               t[DLEF] = syn3(p1, p);
                               pn = p->next;
                               if (pn != p2 && pn->value[0] == '*') {
                                       t[DFLG] = FDIAG;
                                       if (pn->value[1] != 0)
                                               pn->value++;
                                       else
                                               p = pn;
                               }
                               t[DRIT] = syn2(p->next, p2);
                               return (t);
               }
       return (syn3(p1, p2));
}

/*
* syn3
*      ( syn0 ) [ < in  ] [ > out ]
*      word word* [ < in ] [ > out ]
*/
syn3(p1, p2)
       struct shvar2 *p1, *p2;
{
       register struct shvar2 *p;
       struct shvar *lp, *rp;
       register int *t;
       int n, l, c;

       n = 0;
       l = 0;
       for (p = p1; p != p2; p = p->next)
               switch (p->value[0]) {
                       case '(':
                               l++;
                               continue;
                       case ')':
                               l--;
                               continue;
                       case '>':
                       case '<':
                               if (l != 0)
                                       continue;
                               if (p->next == p2)
                                       continue;
                               if (any(p->next->value[0], "<>(*"))
                                       continue;
                               n--;
                               continue;
                       default:
                               if (l != 0)
                                       continue;
                               n++;
                               continue;
               }
       if (n < 0)
               n = 0;
       t = calloc(2, 5 + n + 1);
       n = 0;
       if (p2->value[0] == ')')
               t[DFLG] = FPAR;
       lp = 0;
       rp = 0;
       l = 0;
       for (p = p1; p != p2; p = p->next) {
               c = p->value[0];
               switch (c) {
                       case '(':
                               if (l == 0) {
                                       if (lp != 0)
                                               seterr("Badly placed (");
                                       lp = p->next;
                               }
                               l++;
                               continue;
                       case ')':
                               l--;
                               if (l == 0)
                                       rp = p;
                               continue;
                       case '>':
                               if (l != 0)
                                       continue;
                               if (p->next != p2) {
                                       p = p->next;
                                       if (p->value[0] == '>')
                                               t[DFLG] =| FCAT;
                                       else
                                               p = p->prev;
                               }
                               if (p->next != p2) {
                                       p = p->next;
                                       if (p->value[0] == '*') {
                                               t[DFLG] =| FDIAG;
                                               if (p->value[1]) {
                                                       p->value++;
                                                       p = p->prev;
                                               }
                                       } else
                                               p = p->prev;
                               }
                       case '<':
                               if (l != 0)
                                       continue;
                               if (p->next == p2) {
                                       seterr("Missing file for redirect");
                                       continue;
                               }
                               p = p->next;
                               if (any(p->value[0], "<>(")) {
                                       seterr("Syntax error in redirection");
                                       continue;
                               }
                               if (c == '<') {
                                       if (t[DLEF] != 0) {
                                               seterr("Multiple < redirect");
                                               continue;
                                       }
                                       t[DLEF] = p->value;
                                       continue;
                               }
                               if (t[DRIT] != 0) {
                                       seterr("Multiple output redirect");
                                       continue;
                               }
                               t[DRIT] = p->value;
                               continue;
                       default:
                               if (l != 0)
                                       continue;
                               t[DCOM + n] = p->value;
                               n++;
                               continue;
               }
       }
       if (lp != 0) {
               if (n != 0)
                       seterr("Only redirect allowed outside ()'s");
               t[DTYP] = TPAR;
               t[DSPR] = syn0(lp, rp);
       } else {
               if (n == 0)
                       seterr("Inappropriate empty command");
               t[DCOM + n] = 0;
               t[DTYP] = TCOM;
       }
       return (t);
}

freesyn(t)
       register int *t;
{
       register char **v;

       if (t == 0)
               return;
       switch (t[DTYP]) {
               case TCOM:
                       for (v = &t[DCOM]; *v; v++)
                               xfree(*v);
                       goto lr;
               case TPAR:
                       freesyn(t[DSPR]);
lr:
                       xfree(t[DLEF]);
                       xfree(t[DRIT]);
                       break;
               case TFIL:
               case TLST:
                       freesyn(t[DLEF]);
                       freesyn(t[DRIT]);
                       break;
       }
       cfree(t);
}