[BACK]Return to gram.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / plugins / sudoers

Diff for /embedaddon/sudo/plugins/sudoers/gram.c between versions 1.1.1.4 and 1.1.1.5

version 1.1.1.4, 2013/07/22 10:46:12 version 1.1.1.5, 2014/06/15 16:12:54
Line 109 Line 109
 /*  /*
  * Globals   * Globals
  */   */
 extern int sudolineno;  
 extern int last_token;  
 extern char *sudoers;  
 bool sudoers_warnings = true;  bool sudoers_warnings = true;
 bool parse_error = false;  bool parse_error = false;
 int errorlineno = -1;  int errorlineno = -1;
char *errorfile = NULL;const char *errorfile = NULL;
   
struct defaults_list defaults;struct defaults_list defaults = TAILQ_HEAD_INITIALIZER(defaults);
struct userspec_list userspecs;struct userspec_list userspecs = TAILQ_HEAD_INITIALIZER(userspecs);
   
 /*  /*
  * Local protoypes   * Local protoypes
Line 128  static void  add_userspec(struct member *, struct priv Line 125  static void  add_userspec(struct member *, struct priv
 static struct defaults *new_default(char *, char *, int);  static struct defaults *new_default(char *, char *, int);
 static struct member *new_member(char *, int);  static struct member *new_member(char *, int);
 static struct sudo_digest *new_digest(int, const char *);  static struct sudo_digest *new_digest(int, const char *);
#line 95 "gram.y"#line 92 "gram.y"
 #ifndef YYSTYPE_DEFINED  #ifndef YYSTYPE_DEFINED
 #define YYSTYPE_DEFINED  #define YYSTYPE_DEFINED
 typedef union {  typedef union {
Line 146  typedef union { Line 143  typedef union {
     int tok;      int tok;
 } YYSTYPE;  } YYSTYPE;
 #endif /* YYSTYPE_DEFINED */  #endif /* YYSTYPE_DEFINED */
#line 149 "gram.c"#line 146 "gram.c"
 #define COMMAND 257  #define COMMAND 257
 #define ALIAS 258  #define ALIAS 258
 #define DEFVAR 259  #define DEFVAR 259
Line 698  YYSTYPE yylval; Line 695  YYSTYPE yylval;
 short *yyss;  short *yyss;
 short *yysslim;  short *yysslim;
 YYSTYPE *yyvs;  YYSTYPE *yyvs;
int yystacksize;unsigned int yystacksize;
#line 681 "gram.y"#line 685 "gram.y"
 void  void
 sudoerserror(const char *s)  sudoerserror(const char *s)
 {  {
Line 741  new_default(char *var, char *val, int op) Line 738  new_default(char *var, char *val, int op)
     d = ecalloc(1, sizeof(struct defaults));      d = ecalloc(1, sizeof(struct defaults));
     d->var = var;      d->var = var;
     d->val = val;      d->val = val;
     tq_init(&d->binding);  
     /* d->type = 0; */      /* d->type = 0; */
     d->op = op;      d->op = op;
    d->prev = d;    /* d->binding = NULL */
    /* d->next = NULL; */    HLTQ_INIT(d, entries);
   
     debug_return_ptr(d);      debug_return_ptr(d);
 }  }
Line 759  new_member(char *name, int type) Line 755  new_member(char *name, int type)
     m = ecalloc(1, sizeof(struct member));      m = ecalloc(1, sizeof(struct member));
     m->name = name;      m->name = name;
     m->type = type;      m->type = type;
    m->prev = m;    HLTQ_INIT(m, entries);
    /* m->next = NULL; */ 
   
     debug_return_ptr(m);      debug_return_ptr(m);
 }  }
Line 787  static void Line 782  static void
 add_defaults(int type, struct member *bmem, struct defaults *defs)  add_defaults(int type, struct member *bmem, struct defaults *defs)
 {  {
     struct defaults *d;      struct defaults *d;
    struct member_list binding;    struct member_list *binding;
     debug_decl(add_defaults, SUDO_DEBUG_PARSER)      debug_decl(add_defaults, SUDO_DEBUG_PARSER)
   
    /*    if (defs != NULL) {
     * We can only call list2tq once on bmem as it will zero        /*
     * out the prev pointer when it consumes bmem.         * We use a single binding for each entry in defs.
     */         */
    list2tq(&binding, bmem);        binding = emalloc(sizeof(*binding));
         if (bmem != NULL)
             HLTQ_TO_TAILQ(binding, bmem, entries);
         else
             TAILQ_INIT(binding);
   
    /*        /*
     * Set type and binding (who it applies to) for new entries.         * Set type and binding (who it applies to) for new entries.
     */         * Then add to the global defaults list.
    for (d = defs; d != NULL; d = d->next) {         */
        d->type = type;        HLTQ_FOREACH(d, defs, entries) {
        d->binding = binding;            d->type = type;
             d->binding = binding;
         }
         TAILQ_CONCAT_HLTQ(&defaults, defs, entries);
     }      }
     tq_append(&defaults, defs);  
   
     debug_return;      debug_return;
 }  }
   
 /*  /*
  * Allocate a new struct userspec, populate it, and insert it at the   * Allocate a new struct userspec, populate it, and insert it at the
 * and of the userspecs list. * end of the userspecs list.
  */   */
 static void  static void
 add_userspec(struct member *members, struct privilege *privs)  add_userspec(struct member *members, struct privilege *privs)
Line 819  add_userspec(struct member *members, struct privilege  Line 820  add_userspec(struct member *members, struct privilege 
     debug_decl(add_userspec, SUDO_DEBUG_PARSER)      debug_decl(add_userspec, SUDO_DEBUG_PARSER)
   
     u = ecalloc(1, sizeof(*u));      u = ecalloc(1, sizeof(*u));
    list2tq(&u->users, members);    HLTQ_TO_TAILQ(&u->users, members, entries);
    list2tq(&u->privileges, privs);    HLTQ_TO_TAILQ(&u->privileges, privs, entries);
    u->prev = u;    TAILQ_INSERT_TAIL(&userspecs, u, entries);
    /* u->next = NULL; */ 
    tq_append(&userspecs, u); 
   
     debug_return;      debug_return;
 }  }
Line 835  add_userspec(struct member *members, struct privilege  Line 834  add_userspec(struct member *members, struct privilege 
 void  void
 init_parser(const char *path, bool quiet)  init_parser(const char *path, bool quiet)
 {  {
    struct defaults *d;    struct member_list *binding;
    struct member *m, *binding;    struct defaults *d, *d_next;
    struct userspec *us;    struct userspec *us, *us_next;
    struct privilege *priv; 
    struct cmndspec *cs; 
    struct sudo_command *c; 
     debug_decl(init_parser, SUDO_DEBUG_PARSER)      debug_decl(init_parser, SUDO_DEBUG_PARSER)
   
    while ((us = tq_pop(&userspecs)) != NULL) {    TAILQ_FOREACH_SAFE(us, &userspecs, entries, us_next) {
        while ((m = tq_pop(&us->users)) != NULL) {        struct member *m, *m_next;
         struct privilege *priv, *priv_next;
 
         TAILQ_FOREACH_SAFE(m, &us->users, entries, m_next) {
             efree(m->name);              efree(m->name);
             efree(m);              efree(m);
         }          }
        while ((priv = tq_pop(&us->privileges)) != NULL) {        TAILQ_FOREACH_SAFE(priv, &us->privileges, entries, priv_next) {
            struct member *runasuser = NULL, *runasgroup = NULL;            struct member_list *runasuserlist = NULL, *runasgrouplist = NULL;
             struct cmndspec *cs, *cs_next;
 #ifdef HAVE_SELINUX  #ifdef HAVE_SELINUX
             char *role = NULL, *type = NULL;              char *role = NULL, *type = NULL;
 #endif /* HAVE_SELINUX */  #endif /* HAVE_SELINUX */
Line 857  init_parser(const char *path, bool quiet) Line 857  init_parser(const char *path, bool quiet)
             char *privs = NULL, *limitprivs = NULL;              char *privs = NULL, *limitprivs = NULL;
 #endif /* HAVE_PRIV_SET */  #endif /* HAVE_PRIV_SET */
   
            while ((m = tq_pop(&priv->hostlist)) != NULL) {            TAILQ_FOREACH_SAFE(m, &priv->hostlist, entries, m_next) {
                 efree(m->name);                  efree(m->name);
                 efree(m);                  efree(m);
             }              }
            while ((cs = tq_pop(&priv->cmndlist)) != NULL) {            TAILQ_FOREACH_SAFE(cs, &priv->cmndlist, entries, cs_next) {
 #ifdef HAVE_SELINUX  #ifdef HAVE_SELINUX
                 /* Only free the first instance of a role/type. */                  /* Only free the first instance of a role/type. */
                 if (cs->role != role) {                  if (cs->role != role) {
Line 884  init_parser(const char *path, bool quiet) Line 884  init_parser(const char *path, bool quiet)
                     efree(cs->limitprivs);                      efree(cs->limitprivs);
                 }                  }
 #endif /* HAVE_PRIV_SET */  #endif /* HAVE_PRIV_SET */
                if (tq_last(&cs->runasuserlist) != runasuser) {                /* Only free the first instance of runas user/group lists. */
                    runasuser = tq_last(&cs->runasuserlist);                if (cs->runasuserlist && cs->runasuserlist != runasuserlist) {
                    while ((m = tq_pop(&cs->runasuserlist)) != NULL) {                    runasuserlist = cs->runasuserlist;
                     TAILQ_FOREACH_SAFE(m, runasuserlist, entries, m_next) {
                         efree(m->name);                          efree(m->name);
                         efree(m);                          efree(m);
                     }                      }
                       efree(runasuserlist);
                 }                  }
                if (tq_last(&cs->runasgrouplist) != runasgroup) {                if (cs->runasgrouplist && cs->runasgrouplist != runasgrouplist) {
                    runasgroup = tq_last(&cs->runasgrouplist);                    runasgrouplist = cs->runasgrouplist;
                    while ((m = tq_pop(&cs->runasgrouplist)) != NULL) {                    TAILQ_FOREACH_SAFE(m, runasgrouplist, entries, m_next) {
                         efree(m->name);                          efree(m->name);
                         efree(m);                          efree(m);
                     }                      }
                       efree(runasgrouplist);
                 }                  }
                 if (cs->cmnd->type == COMMAND) {                  if (cs->cmnd->type == COMMAND) {
                        c = (struct sudo_command *) cs->cmnd->name;                        struct sudo_command *c =
                             (struct sudo_command *) cs->cmnd->name;
                         efree(c->cmnd);                          efree(c->cmnd);
                         efree(c->args);                          efree(c->args);
                 }                  }
Line 911  init_parser(const char *path, bool quiet) Line 915  init_parser(const char *path, bool quiet)
         }          }
         efree(us);          efree(us);
     }      }
    tq_init(&userspecs);    TAILQ_INIT(&userspecs);
   
     binding = NULL;      binding = NULL;
    while ((d = tq_pop(&defaults)) != NULL) {    TAILQ_FOREACH_SAFE(d, &defaults, entries, d_next) {
        if (tq_last(&d->binding) != binding) {        if (d->binding != binding) {
            binding = tq_last(&d->binding);            struct member *m, *m_next;
            while ((m = tq_pop(&d->binding)) != NULL) {
             binding = d->binding;
             TAILQ_FOREACH_SAFE(m, d->binding, entries, m_next) {
                 if (m->type == COMMAND) {                  if (m->type == COMMAND) {
                        c = (struct sudo_command *) m->name;                        struct sudo_command *c =
                             (struct sudo_command *) m->name;
                         efree(c->cmnd);                          efree(c->cmnd);
                         efree(c->args);                          efree(c->args);
                 }                  }
                 efree(m->name);                  efree(m->name);
                 efree(m);                  efree(m);
             }              }
               efree(d->binding);
         }          }
         efree(d->var);          efree(d->var);
         efree(d->val);          efree(d->val);
         efree(d);          efree(d);
     }      }
    tq_init(&defaults);    TAILQ_INIT(&defaults);
   
     init_aliases();      init_aliases();
   
Line 947  init_parser(const char *path, bool quiet) Line 955  init_parser(const char *path, bool quiet)
   
     debug_return;      debug_return;
 }  }
#line 898 "gram.c"#line 906 "gram.c"
 /* allocate initial stack or double stack size, up to YYMAXDEPTH */  /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 #if defined(__cplusplus) || defined(__STDC__)  #if defined(__cplusplus) || defined(__STDC__)
 static int yygrowstack(void)  static int yygrowstack(void)
Line 955  static int yygrowstack(void) Line 963  static int yygrowstack(void)
 static int yygrowstack()  static int yygrowstack()
 #endif  #endif
 {  {
    int newsize, i;    unsigned int newsize;
     long sslen;
     short *newss;      short *newss;
     YYSTYPE *newvs;      YYSTYPE *newvs;
   
    newsize = yystacksize ? yystacksize : YYINITSTACKSIZE;    if ((newsize = yystacksize) == 0)
    if (newsize >= YYMAXDEPTH)        newsize = YYINITSTACKSIZE;
     else if (newsize >= YYMAXDEPTH)
         return -1;          return -1;
     else if ((newsize *= 2) > YYMAXDEPTH)      else if ((newsize *= 2) > YYMAXDEPTH)
         newsize = YYMAXDEPTH;          newsize = YYMAXDEPTH;
 #ifdef SIZE_MAX  #ifdef SIZE_MAX
 #define YY_SIZE_MAX SIZE_MAX  #define YY_SIZE_MAX SIZE_MAX
 #else  #else
#define YY_SIZE_MAX 0x7fffffff#ifdef __STDC__
 #define YY_SIZE_MAX 0xffffffffU
 #else
 #define YY_SIZE_MAX (unsigned int)0xffffffff
 #endif  #endif
   #endif
     if (YY_SIZE_MAX / newsize < sizeof *newss)      if (YY_SIZE_MAX / newsize < sizeof *newss)
         goto bail;          goto bail;
    i = yyssp - yyss;    sslen = yyssp - yyss;
     newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :      newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
       (short *)malloc(newsize * sizeof *newss); /* overflow check above */        (short *)malloc(newsize * sizeof *newss); /* overflow check above */
     if (newss == NULL)      if (newss == NULL)
         goto bail;          goto bail;
     yyss = newss;      yyss = newss;
    yyssp = newss + i;    yyssp = newss + sslen;
     newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :      newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
       (YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */        (YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */
     if (newvs == NULL)      if (newvs == NULL)
         goto bail;          goto bail;
     yyvs = newvs;      yyvs = newvs;
    yyvsp = newvs + i;    yyvsp = newvs + sslen;
     yystacksize = newsize;      yystacksize = newsize;
     yysslim = yyss + newsize - 1;      yysslim = yyss + newsize - 1;
     return 0;      return 0;
Line 1150  yyreduce: Line 1164  yyreduce:
     switch (yyn)      switch (yyn)
     {      {
 case 1:  case 1:
#line 185 "gram.y"#line 182 "gram.y"
 { ; }  { ; }
 break;  break;
 case 5:  case 5:
#line 193 "gram.y"#line 190 "gram.y"
 {  {
                             ;                              ;
                         }                          }
 break;  break;
 case 6:  case 6:
#line 196 "gram.y"#line 193 "gram.y"
 {  {
                             yyerrok;                              yyerrok;
                         }                          }
 break;  break;
 case 7:  case 7:
#line 199 "gram.y"#line 196 "gram.y"
 {  {
                             add_userspec(yyvsp[-1].member, yyvsp[0].privilege);                              add_userspec(yyvsp[-1].member, yyvsp[0].privilege);
                         }                          }
 break;  break;
 case 8:  case 8:
#line 202 "gram.y"#line 199 "gram.y"
 {  {
                             ;                              ;
                         }                          }
 break;  break;
 case 9:  case 9:
#line 205 "gram.y"#line 202 "gram.y"
 {  {
                             ;                              ;
                         }                          }
 break;  break;
 case 10:  case 10:
#line 208 "gram.y"#line 205 "gram.y"
 {  {
                             ;                              ;
                         }                          }
 break;  break;
 case 11:  case 11:
#line 211 "gram.y"#line 208 "gram.y"
 {  {
                             ;                              ;
                         }                          }
 break;  break;
 case 12:  case 12:
#line 214 "gram.y"#line 211 "gram.y"
 {  {
                             add_defaults(DEFAULTS, NULL, yyvsp[0].defaults);                              add_defaults(DEFAULTS, NULL, yyvsp[0].defaults);
                         }                          }
 break;  break;
 case 13:  case 13:
#line 217 "gram.y"#line 214 "gram.y"
 {  {
                             add_defaults(DEFAULTS_USER, yyvsp[-1].member, yyvsp[0].defaults);                              add_defaults(DEFAULTS_USER, yyvsp[-1].member, yyvsp[0].defaults);
                         }                          }
 break;  break;
 case 14:  case 14:
#line 220 "gram.y"#line 217 "gram.y"
 {  {
                             add_defaults(DEFAULTS_RUNAS, yyvsp[-1].member, yyvsp[0].defaults);                              add_defaults(DEFAULTS_RUNAS, yyvsp[-1].member, yyvsp[0].defaults);
                         }                          }
 break;  break;
 case 15:  case 15:
#line 223 "gram.y"#line 220 "gram.y"
 {  {
                             add_defaults(DEFAULTS_HOST, yyvsp[-1].member, yyvsp[0].defaults);                              add_defaults(DEFAULTS_HOST, yyvsp[-1].member, yyvsp[0].defaults);
                         }                          }
 break;  break;
 case 16:  case 16:
#line 226 "gram.y"#line 223 "gram.y"
 {  {
                             add_defaults(DEFAULTS_CMND, yyvsp[-1].member, yyvsp[0].defaults);                              add_defaults(DEFAULTS_CMND, yyvsp[-1].member, yyvsp[0].defaults);
                         }                          }
 break;  break;
 case 18:  case 18:
#line 232 "gram.y"#line 229 "gram.y"
 {  {
                            list_append(yyvsp[-2].defaults, yyvsp[0].defaults);                            HLTQ_CONCAT(yyvsp[-2].defaults, yyvsp[0].defaults, entries);
                             yyval.defaults = yyvsp[-2].defaults;                              yyval.defaults = yyvsp[-2].defaults;
                         }                          }
 break;  break;
 case 19:  case 19:
#line 238 "gram.y"#line 235 "gram.y"
 {  {
                             yyval.defaults = new_default(yyvsp[0].string, NULL, true);                              yyval.defaults = new_default(yyvsp[0].string, NULL, true);
                         }                          }
 break;  break;
 case 20:  case 20:
#line 241 "gram.y"#line 238 "gram.y"
 {  {
                             yyval.defaults = new_default(yyvsp[0].string, NULL, false);                              yyval.defaults = new_default(yyvsp[0].string, NULL, false);
                         }                          }
 break;  break;
 case 21:  case 21:
#line 244 "gram.y"#line 241 "gram.y"
 {  {
                             yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, true);                              yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, true);
                         }                          }
 break;  break;
 case 22:  case 22:
#line 247 "gram.y"#line 244 "gram.y"
 {  {
                             yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, '+');                              yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, '+');
                         }                          }
 break;  break;
 case 23:  case 23:
#line 250 "gram.y"#line 247 "gram.y"
 {  {
                             yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, '-');                              yyval.defaults = new_default(yyvsp[-2].string, yyvsp[0].string, '-');
                         }                          }
 break;  break;
 case 25:  case 25:
#line 256 "gram.y"#line 253 "gram.y"
 {  {
                            list_append(yyvsp[-2].privilege, yyvsp[0].privilege);                            HLTQ_CONCAT(yyvsp[-2].privilege, yyvsp[0].privilege, entries);
                             yyval.privilege = yyvsp[-2].privilege;                              yyval.privilege = yyvsp[-2].privilege;
                         }                          }
 break;  break;
 case 26:  case 26:
#line 262 "gram.y"#line 259 "gram.y"
 {  {
                             struct privilege *p = ecalloc(1, sizeof(*p));                              struct privilege *p = ecalloc(1, sizeof(*p));
                            list2tq(&p->hostlist, yyvsp[-2].member);                            HLTQ_TO_TAILQ(&p->hostlist, yyvsp[-2].member, entries);
                            list2tq(&p->cmndlist, yyvsp[0].cmndspec);                            HLTQ_TO_TAILQ(&p->cmndlist, yyvsp[0].cmndspec, entries);
                            p->prev = p;                            HLTQ_INIT(p, entries);
                            /* p->next = NULL; */ 
                             yyval.privilege = p;                              yyval.privilege = p;
                         }                          }
 break;  break;
 case 27:  case 27:
#line 272 "gram.y"#line 268 "gram.y"
 {  {
                             yyval.member = yyvsp[0].member;                              yyval.member = yyvsp[0].member;
                             yyval.member->negated = false;                              yyval.member->negated = false;
                         }                          }
 break;  break;
 case 28:  case 28:
#line 276 "gram.y"#line 272 "gram.y"
 {  {
                             yyval.member = yyvsp[0].member;                              yyval.member = yyvsp[0].member;
                             yyval.member->negated = true;                              yyval.member->negated = true;
                         }                          }
 break;  break;
 case 29:  case 29:
#line 282 "gram.y"#line 278 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, ALIAS);                              yyval.member = new_member(yyvsp[0].string, ALIAS);
                         }                          }
 break;  break;
 case 30:  case 30:
#line 285 "gram.y"#line 281 "gram.y"
 {  {
                             yyval.member = new_member(NULL, ALL);                              yyval.member = new_member(NULL, ALL);
                         }                          }
 break;  break;
 case 31:  case 31:
#line 288 "gram.y"#line 284 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, NETGROUP);                              yyval.member = new_member(yyvsp[0].string, NETGROUP);
                         }                          }
 break;  break;
 case 32:  case 32:
#line 291 "gram.y"#line 287 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, NTWKADDR);                              yyval.member = new_member(yyvsp[0].string, NTWKADDR);
                         }                          }
 break;  break;
 case 33:  case 33:
#line 294 "gram.y"#line 290 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, WORD);                              yyval.member = new_member(yyvsp[0].string, WORD);
                         }                          }
 break;  break;
 case 35:  case 35:
#line 300 "gram.y"#line 296 "gram.y"
 {  {
                            list_append(yyvsp[-2].cmndspec, yyvsp[0].cmndspec);                            struct cmndspec *prev;
                             prev = HLTQ_LAST(yyvsp[-2].cmndspec, cmndspec, entries);
                             HLTQ_CONCAT(yyvsp[-2].cmndspec, yyvsp[0].cmndspec, entries);
 #ifdef HAVE_SELINUX  #ifdef HAVE_SELINUX
                             /* propagate role and type */                              /* propagate role and type */
                             if (yyvsp[0].cmndspec->role == NULL)                              if (yyvsp[0].cmndspec->role == NULL)
                                yyvsp[0].cmndspec->role = yyvsp[0].cmndspec->prev->role;                                yyvsp[0].cmndspec->role = prev->role;
                             if (yyvsp[0].cmndspec->type == NULL)                              if (yyvsp[0].cmndspec->type == NULL)
                                yyvsp[0].cmndspec->type = yyvsp[0].cmndspec->prev->type;                                yyvsp[0].cmndspec->type = prev->type;
 #endif /* HAVE_SELINUX */  #endif /* HAVE_SELINUX */
 #ifdef HAVE_PRIV_SET  #ifdef HAVE_PRIV_SET
                             /* propagate privs & limitprivs */                              /* propagate privs & limitprivs */
                             if (yyvsp[0].cmndspec->privs == NULL)                              if (yyvsp[0].cmndspec->privs == NULL)
                                yyvsp[0].cmndspec->privs = yyvsp[0].cmndspec->prev->privs;                                yyvsp[0].cmndspec->privs = prev->privs;
                             if (yyvsp[0].cmndspec->limitprivs == NULL)                              if (yyvsp[0].cmndspec->limitprivs == NULL)
                                yyvsp[0].cmndspec->limitprivs = yyvsp[0].cmndspec->prev->limitprivs;                                yyvsp[0].cmndspec->limitprivs = prev->limitprivs;
 #endif /* HAVE_PRIV_SET */  #endif /* HAVE_PRIV_SET */
                             /* propagate tags and runas list */                              /* propagate tags and runas list */
                             if (yyvsp[0].cmndspec->tags.nopasswd == UNSPEC)                              if (yyvsp[0].cmndspec->tags.nopasswd == UNSPEC)
                                yyvsp[0].cmndspec->tags.nopasswd = yyvsp[0].cmndspec->prev->tags.nopasswd;                                yyvsp[0].cmndspec->tags.nopasswd = prev->tags.nopasswd;
                             if (yyvsp[0].cmndspec->tags.noexec == UNSPEC)                              if (yyvsp[0].cmndspec->tags.noexec == UNSPEC)
                                yyvsp[0].cmndspec->tags.noexec = yyvsp[0].cmndspec->prev->tags.noexec;                                yyvsp[0].cmndspec->tags.noexec = prev->tags.noexec;
                             if (yyvsp[0].cmndspec->tags.setenv == UNSPEC &&                              if (yyvsp[0].cmndspec->tags.setenv == UNSPEC &&
                                yyvsp[0].cmndspec->prev->tags.setenv != IMPLIED)                                prev->tags.setenv != IMPLIED)
                                yyvsp[0].cmndspec->tags.setenv = yyvsp[0].cmndspec->prev->tags.setenv;                                yyvsp[0].cmndspec->tags.setenv = prev->tags.setenv;
                             if (yyvsp[0].cmndspec->tags.log_input == UNSPEC)                              if (yyvsp[0].cmndspec->tags.log_input == UNSPEC)
                                yyvsp[0].cmndspec->tags.log_input = yyvsp[0].cmndspec->prev->tags.log_input;                                yyvsp[0].cmndspec->tags.log_input = prev->tags.log_input;
                             if (yyvsp[0].cmndspec->tags.log_output == UNSPEC)                              if (yyvsp[0].cmndspec->tags.log_output == UNSPEC)
                                yyvsp[0].cmndspec->tags.log_output = yyvsp[0].cmndspec->prev->tags.log_output;                                yyvsp[0].cmndspec->tags.log_output = prev->tags.log_output;
                            if ((tq_empty(&yyvsp[0].cmndspec->runasuserlist) &&                            if ((yyvsp[0].cmndspec->runasuserlist == NULL &&
                                 tq_empty(&yyvsp[0].cmndspec->runasgrouplist)) &&                                 yyvsp[0].cmndspec->runasgrouplist == NULL) &&
                                (!tq_empty(&yyvsp[0].cmndspec->prev->runasuserlist) ||                                (prev->runasuserlist != NULL ||
                                 !tq_empty(&yyvsp[0].cmndspec->prev->runasgrouplist))) {                                 prev->runasgrouplist != NULL)) {
                                yyvsp[0].cmndspec->runasuserlist = yyvsp[0].cmndspec->prev->runasuserlist;                                yyvsp[0].cmndspec->runasuserlist = prev->runasuserlist;
                                yyvsp[0].cmndspec->runasgrouplist = yyvsp[0].cmndspec->prev->runasgrouplist;                                yyvsp[0].cmndspec->runasgrouplist = prev->runasgrouplist;
                             }                              }
                             yyval.cmndspec = yyvsp[-2].cmndspec;                              yyval.cmndspec = yyvsp[-2].cmndspec;
                         }                          }
 break;  break;
 case 36:  case 36:
#line 339 "gram.y"#line 337 "gram.y"
 {  {
                             struct cmndspec *cs = ecalloc(1, sizeof(*cs));                              struct cmndspec *cs = ecalloc(1, sizeof(*cs));
                             if (yyvsp[-4].runas != NULL) {                              if (yyvsp[-4].runas != NULL) {
                                list2tq(&cs->runasuserlist, yyvsp[-4].runas->runasusers);                                if (yyvsp[-4].runas->runasusers != NULL) {
                                list2tq(&cs->runasgrouplist, yyvsp[-4].runas->runasgroups);                                    cs->runasuserlist =
                                         emalloc(sizeof(*cs->runasuserlist));
                                     HLTQ_TO_TAILQ(cs->runasuserlist,
                                         yyvsp[-4].runas->runasusers, entries);
                                 }
                                 if (yyvsp[-4].runas->runasgroups != NULL) {
                                     cs->runasgrouplist =
                                         emalloc(sizeof(*cs->runasgrouplist));
                                     HLTQ_TO_TAILQ(cs->runasgrouplist,
                                         yyvsp[-4].runas->runasgroups, entries);
                                 }
                                 efree(yyvsp[-4].runas);                                  efree(yyvsp[-4].runas);
                             } else {  
                                 tq_init(&cs->runasuserlist);  
                                 tq_init(&cs->runasgrouplist);  
                             }                              }
 #ifdef HAVE_SELINUX  #ifdef HAVE_SELINUX
                             cs->role = yyvsp[-3].seinfo.role;                              cs->role = yyvsp[-3].seinfo.role;
Line 1386  case 36: Line 1408  case 36:
 #endif  #endif
                             cs->tags = yyvsp[-1].tag;                              cs->tags = yyvsp[-1].tag;
                             cs->cmnd = yyvsp[0].member;                              cs->cmnd = yyvsp[0].member;
                            cs->prev = cs;                            HLTQ_INIT(cs, entries);
                            cs->next = NULL; 
                             /* sudo "ALL" implies the SETENV tag */                              /* sudo "ALL" implies the SETENV tag */
                             if (cs->cmnd->type == ALL && !cs->cmnd->negated &&                              if (cs->cmnd->type == ALL && !cs->cmnd->negated &&
                                 cs->tags.setenv == UNSPEC)                                  cs->tags.setenv == UNSPEC)
Line 1396  case 36: Line 1417  case 36:
                         }                          }
 break;  break;
 case 37:  case 37:
#line 369 "gram.y"#line 373 "gram.y"
 {  {
                             yyval.digest = new_digest(SUDO_DIGEST_SHA224, yyvsp[0].string);                              yyval.digest = new_digest(SUDO_DIGEST_SHA224, yyvsp[0].string);
                         }                          }
 break;  break;
 case 38:  case 38:
#line 372 "gram.y"#line 376 "gram.y"
 {  {
                             yyval.digest = new_digest(SUDO_DIGEST_SHA256, yyvsp[0].string);                              yyval.digest = new_digest(SUDO_DIGEST_SHA256, yyvsp[0].string);
                         }                          }
 break;  break;
 case 39:  case 39:
#line 375 "gram.y"#line 379 "gram.y"
 {  {
                             yyval.digest = new_digest(SUDO_DIGEST_SHA384, yyvsp[0].string);                              yyval.digest = new_digest(SUDO_DIGEST_SHA384, yyvsp[0].string);
                         }                          }
 break;  break;
 case 40:  case 40:
#line 378 "gram.y"#line 382 "gram.y"
 {  {
                             yyval.digest = new_digest(SUDO_DIGEST_SHA512, yyvsp[0].string);                              yyval.digest = new_digest(SUDO_DIGEST_SHA512, yyvsp[0].string);
                         }                          }
 break;  break;
 case 41:  case 41:
#line 383 "gram.y"#line 387 "gram.y"
 {  {
                             yyval.member = yyvsp[0].member;                              yyval.member = yyvsp[0].member;
                         }                          }
 break;  break;
 case 42:  case 42:
#line 386 "gram.y"#line 390 "gram.y"
 {  {
                             /* XXX - yuck */                              /* XXX - yuck */
                             struct sudo_command *c = (struct sudo_command *)(yyvsp[0].member->name);                              struct sudo_command *c = (struct sudo_command *)(yyvsp[0].member->name);
Line 1435  case 42: Line 1456  case 42:
                         }                          }
 break;  break;
 case 43:  case 43:
#line 394 "gram.y"#line 398 "gram.y"
 {  {
                             yyval.member = yyvsp[0].member;                              yyval.member = yyvsp[0].member;
                             yyval.member->negated = false;                              yyval.member->negated = false;
                         }                          }
 break;  break;
 case 44:  case 44:
#line 398 "gram.y"#line 402 "gram.y"
 {  {
                             yyval.member = yyvsp[0].member;                              yyval.member = yyvsp[0].member;
                             yyval.member->negated = true;                              yyval.member->negated = true;
                         }                          }
 break;  break;
 case 45:  case 45:
#line 404 "gram.y"#line 408 "gram.y"
 {  {
                             yyval.string = yyvsp[0].string;                              yyval.string = yyvsp[0].string;
                         }                          }
 break;  break;
 case 46:  case 46:
#line 409 "gram.y"#line 413 "gram.y"
 {  {
                             yyval.string = yyvsp[0].string;                              yyval.string = yyvsp[0].string;
                         }                          }
 break;  break;
 case 47:  case 47:
#line 414 "gram.y"#line 418 "gram.y"
 {  {
                             yyval.seinfo.role = NULL;                              yyval.seinfo.role = NULL;
                             yyval.seinfo.type = NULL;                              yyval.seinfo.type = NULL;
                         }                          }
 break;  break;
 case 48:  case 48:
#line 418 "gram.y"#line 422 "gram.y"
 {  {
                             yyval.seinfo.role = yyvsp[0].string;                              yyval.seinfo.role = yyvsp[0].string;
                             yyval.seinfo.type = NULL;                              yyval.seinfo.type = NULL;
                         }                          }
 break;  break;
 case 49:  case 49:
#line 422 "gram.y"#line 426 "gram.y"
 {  {
                             yyval.seinfo.type = yyvsp[0].string;                              yyval.seinfo.type = yyvsp[0].string;
                             yyval.seinfo.role = NULL;                              yyval.seinfo.role = NULL;
                         }                          }
 break;  break;
 case 50:  case 50:
#line 426 "gram.y"#line 430 "gram.y"
 {  {
                             yyval.seinfo.role = yyvsp[-1].string;                              yyval.seinfo.role = yyvsp[-1].string;
                             yyval.seinfo.type = yyvsp[0].string;                              yyval.seinfo.type = yyvsp[0].string;
                         }                          }
 break;  break;
 case 51:  case 51:
#line 430 "gram.y"#line 434 "gram.y"
 {  {
                             yyval.seinfo.type = yyvsp[-1].string;                              yyval.seinfo.type = yyvsp[-1].string;
                             yyval.seinfo.role = yyvsp[0].string;                              yyval.seinfo.role = yyvsp[0].string;
                         }                          }
 break;  break;
 case 52:  case 52:
#line 436 "gram.y"#line 440 "gram.y"
 {  {
                             yyval.string = yyvsp[0].string;                              yyval.string = yyvsp[0].string;
                         }                          }
 break;  break;
 case 53:  case 53:
#line 440 "gram.y"#line 444 "gram.y"
 {  {
                             yyval.string = yyvsp[0].string;                              yyval.string = yyvsp[0].string;
                         }                          }
 break;  break;
 case 54:  case 54:
#line 445 "gram.y"#line 449 "gram.y"
 {  {
                             yyval.privinfo.privs = NULL;                              yyval.privinfo.privs = NULL;
                             yyval.privinfo.limitprivs = NULL;                              yyval.privinfo.limitprivs = NULL;
                         }                          }
 break;  break;
 case 55:  case 55:
#line 449 "gram.y"#line 453 "gram.y"
 {  {
                             yyval.privinfo.privs = yyvsp[0].string;                              yyval.privinfo.privs = yyvsp[0].string;
                             yyval.privinfo.limitprivs = NULL;                              yyval.privinfo.limitprivs = NULL;
                         }                          }
 break;  break;
 case 56:  case 56:
#line 453 "gram.y"#line 457 "gram.y"
 {  {
                             yyval.privinfo.privs = NULL;                              yyval.privinfo.privs = NULL;
                             yyval.privinfo.limitprivs = yyvsp[0].string;                              yyval.privinfo.limitprivs = yyvsp[0].string;
                         }                          }
 break;  break;
 case 57:  case 57:
#line 457 "gram.y"#line 461 "gram.y"
 {  {
                             yyval.privinfo.privs = yyvsp[-1].string;                              yyval.privinfo.privs = yyvsp[-1].string;
                             yyval.privinfo.limitprivs = yyvsp[0].string;                              yyval.privinfo.limitprivs = yyvsp[0].string;
                         }                          }
 break;  break;
 case 58:  case 58:
#line 461 "gram.y"#line 465 "gram.y"
 {  {
                             yyval.privinfo.limitprivs = yyvsp[-1].string;                              yyval.privinfo.limitprivs = yyvsp[-1].string;
                             yyval.privinfo.privs = yyvsp[0].string;                              yyval.privinfo.privs = yyvsp[0].string;
                         }                          }
 break;  break;
 case 59:  case 59:
#line 467 "gram.y"#line 471 "gram.y"
 {  {
                             yyval.runas = NULL;                              yyval.runas = NULL;
                         }                          }
 break;  break;
 case 60:  case 60:
#line 470 "gram.y"#line 474 "gram.y"
 {  {
                             yyval.runas = yyvsp[-1].runas;                              yyval.runas = yyvsp[-1].runas;
                         }                          }
 break;  break;
 case 61:  case 61:
#line 475 "gram.y"#line 479 "gram.y"
 {  {
                             yyval.runas = ecalloc(1, sizeof(struct runascontainer));                              yyval.runas = ecalloc(1, sizeof(struct runascontainer));
                             yyval.runas->runasusers = new_member(NULL, MYSELF);                              yyval.runas->runasusers = new_member(NULL, MYSELF);
Line 1563  case 61: Line 1584  case 61:
                         }                          }
 break;  break;
 case 62:  case 62:
#line 480 "gram.y"#line 484 "gram.y"
 {  {
                             yyval.runas = ecalloc(1, sizeof(struct runascontainer));                              yyval.runas = ecalloc(1, sizeof(struct runascontainer));
                             yyval.runas->runasusers = yyvsp[0].member;                              yyval.runas->runasusers = yyvsp[0].member;
Line 1571  case 62: Line 1592  case 62:
                         }                          }
 break;  break;
 case 63:  case 63:
#line 485 "gram.y"#line 489 "gram.y"
 {  {
                             yyval.runas = ecalloc(1, sizeof(struct runascontainer));                              yyval.runas = ecalloc(1, sizeof(struct runascontainer));
                             yyval.runas->runasusers = yyvsp[-2].member;                              yyval.runas->runasusers = yyvsp[-2].member;
Line 1579  case 63: Line 1600  case 63:
                         }                          }
 break;  break;
 case 64:  case 64:
#line 490 "gram.y"#line 494 "gram.y"
 {  {
                             yyval.runas = ecalloc(1, sizeof(struct runascontainer));                              yyval.runas = ecalloc(1, sizeof(struct runascontainer));
                             /* $$->runasusers = NULL; */                              /* $$->runasusers = NULL; */
Line 1587  case 64: Line 1608  case 64:
                         }                          }
 break;  break;
 case 65:  case 65:
#line 495 "gram.y"#line 499 "gram.y"
 {  {
                             yyval.runas = ecalloc(1, sizeof(struct runascontainer));                              yyval.runas = ecalloc(1, sizeof(struct runascontainer));
                             yyval.runas->runasusers = new_member(NULL, MYSELF);                              yyval.runas->runasusers = new_member(NULL, MYSELF);
Line 1595  case 65: Line 1616  case 65:
                         }                          }
 break;  break;
 case 66:  case 66:
#line 502 "gram.y"#line 506 "gram.y"
 {  {
                             yyval.tag.nopasswd = yyval.tag.noexec = yyval.tag.setenv =                              yyval.tag.nopasswd = yyval.tag.noexec = yyval.tag.setenv =
                                 yyval.tag.log_input = yyval.tag.log_output = UNSPEC;                                  yyval.tag.log_input = yyval.tag.log_output = UNSPEC;
                         }                          }
 break;  break;
 case 67:  case 67:
#line 506 "gram.y"#line 510 "gram.y"
 {  {
                             yyval.tag.nopasswd = true;                              yyval.tag.nopasswd = true;
                         }                          }
 break;  break;
 case 68:  case 68:
#line 509 "gram.y"#line 513 "gram.y"
 {  {
                             yyval.tag.nopasswd = false;                              yyval.tag.nopasswd = false;
                         }                          }
 break;  break;
 case 69:  case 69:
#line 512 "gram.y"#line 516 "gram.y"
 {  {
                             yyval.tag.noexec = true;                              yyval.tag.noexec = true;
                         }                          }
 break;  break;
 case 70:  case 70:
#line 515 "gram.y"#line 519 "gram.y"
 {  {
                             yyval.tag.noexec = false;                              yyval.tag.noexec = false;
                         }                          }
 break;  break;
 case 71:  case 71:
#line 518 "gram.y"#line 522 "gram.y"
 {  {
                             yyval.tag.setenv = true;                              yyval.tag.setenv = true;
                         }                          }
 break;  break;
 case 72:  case 72:
#line 521 "gram.y"#line 525 "gram.y"
 {  {
                             yyval.tag.setenv = false;                              yyval.tag.setenv = false;
                         }                          }
 break;  break;
 case 73:  case 73:
#line 524 "gram.y"#line 528 "gram.y"
 {  {
                             yyval.tag.log_input = true;                              yyval.tag.log_input = true;
                         }                          }
 break;  break;
 case 74:  case 74:
#line 527 "gram.y"#line 531 "gram.y"
 {  {
                             yyval.tag.log_input = false;                              yyval.tag.log_input = false;
                         }                          }
 break;  break;
 case 75:  case 75:
#line 530 "gram.y"#line 534 "gram.y"
 {  {
                             yyval.tag.log_output = true;                              yyval.tag.log_output = true;
                         }                          }
 break;  break;
 case 76:  case 76:
#line 533 "gram.y"#line 537 "gram.y"
 {  {
                             yyval.tag.log_output = false;                              yyval.tag.log_output = false;
                         }                          }
 break;  break;
 case 77:  case 77:
#line 538 "gram.y"#line 542 "gram.y"
 {  {
                             yyval.member = new_member(NULL, ALL);                              yyval.member = new_member(NULL, ALL);
                         }                          }
 break;  break;
 case 78:  case 78:
#line 541 "gram.y"#line 545 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, ALIAS);                              yyval.member = new_member(yyvsp[0].string, ALIAS);
                         }                          }
 break;  break;
 case 79:  case 79:
#line 544 "gram.y"#line 548 "gram.y"
 {  {
                             struct sudo_command *c = ecalloc(1, sizeof(*c));                              struct sudo_command *c = ecalloc(1, sizeof(*c));
                             c->cmnd = yyvsp[0].command.cmnd;                              c->cmnd = yyvsp[0].command.cmnd;
Line 1683  case 79: Line 1704  case 79:
                         }                          }
 break;  break;
 case 82:  case 82:
#line 556 "gram.y"#line 560 "gram.y"
 {  {
                             char *s;                              char *s;
                             if ((s = alias_add(yyvsp[-2].string, HOSTALIAS, yyvsp[0].member)) != NULL) {                              if ((s = alias_add(yyvsp[-2].string, HOSTALIAS, yyvsp[0].member)) != NULL) {
Line 1693  case 82: Line 1714  case 82:
                         }                          }
 break;  break;
 case 84:  case 84:
#line 566 "gram.y"#line 570 "gram.y"
 {  {
                            list_append(yyvsp[-2].member, yyvsp[0].member);                            HLTQ_CONCAT(yyvsp[-2].member, yyvsp[0].member, entries);
                             yyval.member = yyvsp[-2].member;                              yyval.member = yyvsp[-2].member;
                         }                          }
 break;  break;
 case 87:  case 87:
#line 576 "gram.y"#line 580 "gram.y"
 {  {
                             char *s;                              char *s;
                             if ((s = alias_add(yyvsp[-2].string, CMNDALIAS, yyvsp[0].member)) != NULL) {                              if ((s = alias_add(yyvsp[-2].string, CMNDALIAS, yyvsp[0].member)) != NULL) {
Line 1710  case 87: Line 1731  case 87:
                         }                          }
 break;  break;
 case 89:  case 89:
#line 586 "gram.y"#line 590 "gram.y"
 {  {
                            list_append(yyvsp[-2].member, yyvsp[0].member);                            HLTQ_CONCAT(yyvsp[-2].member, yyvsp[0].member, entries);
                             yyval.member = yyvsp[-2].member;                              yyval.member = yyvsp[-2].member;
                         }                          }
 break;  break;
 case 92:  case 92:
#line 596 "gram.y"#line 600 "gram.y"
 {  {
                             char *s;                              char *s;
                             if ((s = alias_add(yyvsp[-2].string, RUNASALIAS, yyvsp[0].member)) != NULL) {                              if ((s = alias_add(yyvsp[-2].string, RUNASALIAS, yyvsp[0].member)) != NULL) {
Line 1727  case 92: Line 1748  case 92:
                         }                          }
 break;  break;
 case 95:  case 95:
#line 609 "gram.y"#line 613 "gram.y"
 {  {
                             char *s;                              char *s;
                             if ((s = alias_add(yyvsp[-2].string, USERALIAS, yyvsp[0].member)) != NULL) {                              if ((s = alias_add(yyvsp[-2].string, USERALIAS, yyvsp[0].member)) != NULL) {
Line 1737  case 95: Line 1758  case 95:
                         }                          }
 break;  break;
 case 97:  case 97:
#line 619 "gram.y"#line 623 "gram.y"
 {  {
                            list_append(yyvsp[-2].member, yyvsp[0].member);                            HLTQ_CONCAT(yyvsp[-2].member, yyvsp[0].member, entries);
                             yyval.member = yyvsp[-2].member;                              yyval.member = yyvsp[-2].member;
                         }                          }
 break;  break;
 case 98:  case 98:
#line 625 "gram.y"#line 629 "gram.y"
 {  {
                             yyval.member = yyvsp[0].member;                              yyval.member = yyvsp[0].member;
                             yyval.member->negated = false;                              yyval.member->negated = false;
                         }                          }
 break;  break;
 case 99:  case 99:
#line 629 "gram.y"#line 633 "gram.y"
 {  {
                             yyval.member = yyvsp[0].member;                              yyval.member = yyvsp[0].member;
                             yyval.member->negated = true;                              yyval.member->negated = true;
                         }                          }
 break;  break;
 case 100:  case 100:
#line 635 "gram.y"#line 639 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, ALIAS);                              yyval.member = new_member(yyvsp[0].string, ALIAS);
                         }                          }
 break;  break;
 case 101:  case 101:
#line 638 "gram.y"#line 642 "gram.y"
 {  {
                             yyval.member = new_member(NULL, ALL);                              yyval.member = new_member(NULL, ALL);
                         }                          }
 break;  break;
 case 102:  case 102:
#line 641 "gram.y"#line 645 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, NETGROUP);                              yyval.member = new_member(yyvsp[0].string, NETGROUP);
                         }                          }
 break;  break;
 case 103:  case 103:
#line 644 "gram.y"#line 648 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, USERGROUP);                              yyval.member = new_member(yyvsp[0].string, USERGROUP);
                         }                          }
 break;  break;
 case 104:  case 104:
#line 647 "gram.y"#line 651 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, WORD);                              yyval.member = new_member(yyvsp[0].string, WORD);
                         }                          }
 break;  break;
 case 106:  case 106:
#line 653 "gram.y"#line 657 "gram.y"
 {  {
                            list_append(yyvsp[-2].member, yyvsp[0].member);                            HLTQ_CONCAT(yyvsp[-2].member, yyvsp[0].member, entries);
                             yyval.member = yyvsp[-2].member;                              yyval.member = yyvsp[-2].member;
                         }                          }
 break;  break;
 case 107:  case 107:
#line 659 "gram.y"#line 663 "gram.y"
 {  {
                             yyval.member = yyvsp[0].member;                              yyval.member = yyvsp[0].member;
                             yyval.member->negated = false;                              yyval.member->negated = false;
                         }                          }
 break;  break;
 case 108:  case 108:
#line 663 "gram.y"#line 667 "gram.y"
 {  {
                             yyval.member = yyvsp[0].member;                              yyval.member = yyvsp[0].member;
                             yyval.member->negated = true;                              yyval.member->negated = true;
                         }                          }
 break;  break;
 case 109:  case 109:
#line 669 "gram.y"#line 673 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, ALIAS);                              yyval.member = new_member(yyvsp[0].string, ALIAS);
                         }                          }
 break;  break;
 case 110:  case 110:
#line 672 "gram.y"#line 676 "gram.y"
 {  {
                             yyval.member = new_member(NULL, ALL);                              yyval.member = new_member(NULL, ALL);
                         }                          }
 break;  break;
 case 111:  case 111:
#line 675 "gram.y"#line 679 "gram.y"
 {  {
                             yyval.member = new_member(yyvsp[0].string, WORD);                              yyval.member = new_member(yyvsp[0].string, WORD);
                         }                          }
 break;  break;
#line 1777 "gram.c"#line 1798 "gram.c"
     }      }
     yyssp -= yym;      yyssp -= yym;
     yystate = *yyssp;      yystate = *yyssp;
Removed from v.1.1.1.4  
changed lines
  Added in v.1.1.1.5

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>