home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume25 / ease3.5 / part04 < prev    next >
Text File  |  1991-12-09  |  29KB  |  1,390 lines
  1. Subject:  v25i020:  Ease 3.5 - high-level sendmail.cf language, Part04/06
  2. Newsgroups: comp.sources.unix
  3. Approved: vixie@pa.dec.com
  4.  
  5. Submitted-by: Bruce G. Barnett <barnett@crdgw1.ge.com>
  6. Posting-number: Volume 25, Issue 20
  7. Archive-name: ease3.5/part04
  8.  
  9. #! /bin/sh
  10. # This is a shell archive.  Remove anything before this line, then unpack
  11. # it by saving it into a file and typing "sh file".  To overwrite existing
  12. # files, type "sh file -c".  You can also feed this as standard input via
  13. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  14. # will see the following message at the end:
  15. #        "End of archive 4 (of 6)."
  16. # Contents:  src/parser.y
  17. # Wrapped by vixie@cognition.pa.dec.com on Tue Dec 10 08:45:57 1991
  18. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  19. if test -f 'src/parser.y' -a "${1}" != "-c" ; then 
  20.   echo shar: Will not clobber existing file \"'src/parser.y'\"
  21. else
  22. echo shar: Extracting \"'src/parser.y'\" \(26290 characters\)
  23. sed "s/^X//" >'src/parser.y' <<'END_OF_FILE'
  24. X%{
  25. X#ifdef FLUKE
  26. X# ifndef LINT
  27. X    static char RCSid[] = "@(#)FLUKE  $Header: /home/kreskin/u0/barnett/Src/Ease/ease/src/RCS/parser.y,v 3.4 1991/10/15 17:02:04 barnett Exp $";
  28. X# endif LINT
  29. X#endif FLUKE
  30. X
  31. X/*
  32. X *    parser.y -- EASE parser.
  33. X *
  34. X *            Contains code for yacc(1) which produces a parser (y.tab.c)
  35. X *            for Ease, a specification format for sendmail configuration
  36. X *            files.
  37. X *
  38. X *    author   -- James S. Schoner, Purdue University Computing Center,
  39. X *                          West Lafayette, Indiana  47907
  40. X *
  41. X *    date     -- July 2, 1985
  42. X *
  43. X *    Copyright (c) 1985 by Purdue Research Foundation
  44. X *
  45. X *    All rights reserved.
  46. X *
  47. X * $Log: parser.y,v $
  48. X * Revision 3.4  1991/10/15  17:02:04  barnett
  49. X * Detect if (one_or_more) next ($2) error
  50. X *
  51. X * Revision 3.3  1991/09/09  16:33:23  barnett
  52. X * Minor bug fix release
  53. X *
  54. X * Revision 3.2  1991/05/16  10:45:25  barnett
  55. X * Better support for System V machines
  56. X * Support for machines with read only text segments
  57. X *
  58. X * Revision 3.1  1991/02/25  22:09:52  barnett
  59. X * Fixed some portability problems
  60. X *
  61. X * Revision 3.0  1991/02/22  18:50:27  barnett
  62. X * Added support for HP/UX and IDA sendmail.
  63. X *
  64. X * Revision 2.1  1990/01/30  15:48:35  jeff
  65. X * Added SunOS/Ultrix/IDA extensions  Jan 24, 1989 Bruce Barnett
  66. X *
  67. X * Version 2.0  90/01/30  15:44:34  jeff
  68. X * Baseline release for netwide posting.
  69. X * 
  70. X */
  71. X
  72. X#include "fixstrings.h"
  73. X#include <stdio.h>
  74. X#include "symtab.h"
  75. X#include <ctype.h>
  76. extern void       BindID ();
  77. extern void       EmitDef ();
  78. extern char      *ListAppend ();
  79. extern char       *MakeCond ();
  80. extern char      *MakeRStr ();
  81. extern char       *ConvOpt ();
  82. extern char      *ConvFlg ();
  83. extern char      *MacScan ();
  84. extern char      *ConvMat ();
  85. extern void       StartRuleset ();
  86. extern char      *MakePosTok ();
  87. extern char      *GetField ();
  88. extern char      *Bracket ();
  89. extern char      *DbmParen ();
  90. extern char      *MakeRSCall ();
  91. extern char      *CheckMailer ();
  92. extern char      *CheckRS ();
  93. extern char      *MakeField ();
  94. extern char       MakeMac ();
  95. extern void       AssignType ();
  96. extern void       RemoveSymbol ();
  97. extern void       yyerror ();
  98. extern void       FatalError ();
  99. extern short RMatch;        /* ruleset match flag               */
  100. extern short number_of_fields;    /* number of fields on the line          */
  101. X#ifdef DATA_RW
  102. char *Cbuf = " ";        /* character buffer                 */
  103. char *Mbuf = "$ ";        /* macro buffer                        */
  104. X#else
  105. char *Cbuf = NULL;
  106. char *Mbuf = NULL;
  107. extern char *Strdup(); 
  108. X#endif
  109. char *Tsb;            /* pointer to temporary string buffer */
  110. char *Tsb1;            /* pointer to another temporary string buffer */
  111. char *Flaglist;            /* pointer to header flag list          */
  112. X
  113. X#define DIM(x)    (sizeof x/sizeof x[0])
  114. extern int yychar;
  115. extern int    yydebug;
  116. X
  117. X#ifndef    DATA_RW
  118. void InitParser()
  119. X{
  120. X    if(!(Cbuf = Strdup(" ")) || !(Mbuf = Strdup("$ ")))
  121. X        FatalError("Out of memory in InitParser()", (char *)NULL);
  122. X}
  123. X#endif
  124. X
  125. static void    
  126. XFree( ptr )
  127. char *ptr;
  128. X  {
  129. X      if (ptr == (char *)0) {
  130. X/*      fprintf(stderr,"Freeing a null pointer\n"); */
  131. X      } else {
  132. X      if (free(ptr) < 0 ) {
  133. X          fprintf(stderr,"Free() returned an error\n");
  134. X      }
  135. X      }
  136. X      fflush(stderr);
  137. X  };
  138. static char *
  139. yydisplay(ch)
  140. X     register int ch;
  141. X{
  142. X    static char buf[15];
  143. X    static char * token[] = {
  144. X#include "y.tok.h"
  145. X    0 };
  146. X
  147. X    switch (ch) {
  148. X      case 0:
  149. X    return "[end of file]";
  150. X/* YYERRCODE is 256. See below */
  151. X/*      case YYERRCODE:
  152. X    return "[error]"; */
  153. X      case '\b':
  154. X    return "'\\b'";
  155. X      case '\f':
  156. X    return "'\\f'";
  157. X      case '\n':
  158. X    return "'\\n'";
  159. X      case '\r':
  160. X    return "'\\r'";
  161. X      case '\t':
  162. X    return "'\\t'";
  163. X    }
  164. X    /* I should use YYERRCODE - but it hasn't been defined yet */
  165. X    /* when /usr/lib/yaccpar is added to this file, it will be defined */
  166. X    if (ch == 256 ) return ("[error]"); 
  167. X    if (ch > 256 && ch < 256 + DIM(token))
  168. X      return token[ch - 257];
  169. X    if (isascii(ch) && isprint(ch))
  170. X      sprintf(buf, "'%c'",ch);
  171. X    else if (ch < 256)
  172. X      sprintf(buf, "Char %o4.3o", ch);
  173. X    else 
  174. X      sprintf(buf, "token %d", ch);
  175. X    return buf;
  176. X}
  177. static yyyylex() 
  178. X{
  179. X    if (yychar < 0) {
  180. X        /* don't make this match =yylex - because sed changes
  181. X           =yylex to =yyyylex in the Makefile. 
  182. X           the pieces it changes is in /usr/lib/yaccparr and I don't
  183. X           want to modify THAT!  - bgb */
  184. X
  185. X        if ((yychar = yylex ()) < 0)    /* call yylex, not yyyylex */
  186. X            yychar = 0;
  187. X#ifdef YYDEBUG
  188. X    if (yydebug)
  189. X        printf("[yydebug] reading %s\n",
  190. X            yydisplay(yychar));
  191. X        fflush(stdout);
  192. X#endif
  193. X        return yychar;
  194. X    }
  195. X}
  196. X     
  197. X
  198. X%}
  199. X
  200. X%union {            /* value stack element type    */
  201. X    int      ival;        /* integer token            */
  202. X    char      *psb;        /* string token               */
  203. X    struct he *phe;        /* pointer to hash entry       */
  204. X    enum opts optval;    /* sendmail options           */
  205. X    enum flgs flgval;    /* mailer flags               */
  206. X    enum mats mpval;    /* mailer attribute parameters */
  207. X}
  208. X
  209. X%start config
  210. X
  211. X%token     <phe>    IDENT
  212. X%token  <psb>    SCONST
  213. X%token  <ival>    ICONST SEPCHAR
  214. X%token BIND CANON CLASS CONCAT FOR HEADER HOST HOSTNUM IF IFSET IN
  215. X%token MACRO MAILER MAP MARGV MATCH MEOL MFLAGS MMAXSIZE MPATH
  216. X%token MRECIPIENT MSENDER NEXT OPTIONS PRECEDENCE READCLASS RESOLVE
  217. X%token RETRY RETURN RULESET TRUSTED USER
  218. X%token YPALIAS YPMAP YPPASSWD EVAL RESOLVED QUOTE ASM PROGRAM DEFAULT ALIAS
  219. X%token DBM
  220. X
  221. X%token ASGN COLON COMMA DEFINE DOLLAR FIELD LBRACE LPAREN RBRACE
  222. X%token RPAREN SEMI STAR SLASH
  223. X
  224. X%token AAOPT AOPT BBOPT CCOPT COPT DDOPT DOPT DOPTB DOPTI DOPTQ EOPT
  225. X%token EOPTE EOPTM EOPTP EOPTW EOPTZ FFOPT FOPT GOPT HHOPT IOPT LLOPT
  226. X%token MOPT NNOPT NOPT OOPT PPOPT QOPT QQOPT ROPT SOPT SSOPT TOPT TTOPT
  227. X%token UOPT VOPT WWOPT XOPT XXOPT YOPT YYOPT ZOPT ZZOPT
  228. X%token RROPT BOPT SLOPT HOPT IIOPT
  229. X
  230. X%token AAFLAG CCFLAG DDFLAG EEFLAG EFLAG FFFLAG FFLAG HFLAG IIFLAG LFLAG
  231. X%token LLFLAG MFLAG MMFLAG NFLAG PFLAG PPFLAG RFLAG RRFLAG SFLAG SSFLAG
  232. X%token UFLAG UUFLAG XFLAG XXFLAG
  233. X%token HHFLAG VVFLAG BBFLAG
  234. X
  235. X%type    <psb>        mval strval ifcon conval ifres elseres nameset namelist
  236. X%type    <psb>        doptid eoptid idlist fcond dlist mflags route mdefs
  237. X%type    <psb>        matchaddr matchtok action actionstmt mailerspec mtdef
  238. X%type    <psb>        rwaddr rwtok ftype reftok rword cantok resolution
  239. X%type    <psb>        dbmtok dbmval dbmvaltok dbmstuff
  240. X%type    <psb>        userspec hword hostid dheader mdefine
  241. X%type    <psb>        catstring catstringlist canval canvaltok
  242. X%type    <ival>        anychar
  243. X%type    <phe>        cdef
  244. X%type    <optval>    optid
  245. X%type    <flgval>    flagid
  246. X%type    <mpval>        mvar
  247. X%type    <psb>        ifresmatch elseresmatch ifresroute elseresroute 
  248. X/* needed special class with no comma's allowed */
  249. X%type    <ival>        anycharbutcomma
  250. X%type    <psb>        matchaddrnocomma matchtoknocomma
  251. X
  252. X%left COMMA
  253. X%left LPAREN RPAREN
  254. X%nonassoc SCONST
  255. X
  256. X%%
  257. config        :    /* empty */
  258. X        |    config blockdef
  259. X        |    error blockdef
  260. X        ;
  261. X
  262. blockdef    :    BIND bindings
  263. X        |    MACRO macdefs
  264. X        |    CLASS classdefs
  265. X        |    OPTIONS optdefs
  266. X        |    PRECEDENCE precdefs
  267. X        |    TRUSTED tlist
  268. X        |    HEADER hdefs
  269. X        |    MAILER mlist
  270. X        |    RULESET rdef
  271. X        |    FIELD fdefs
  272. X        ;
  273. X
  274. bindings    :    /* empty */
  275. X        |    bindings IDENT ASGN RULESET ICONST SEMI {
  276. X                BindID ($2, $5, ID_RULESET);
  277. X            }
  278. X        |    error SEMI {
  279. X                yyerrok;
  280. X            }
  281. X        ;
  282. X
  283. macdefs        :    /* empty */
  284. X        |    macdefs IDENT ASGN mdefine SEMI {
  285. X                EmitDef (def_macro, $2, $4, (char *) NULL);
  286. X            }
  287. X        |    error SEMI {
  288. X                yyerrok;
  289. X            }
  290. X        ;
  291. X
  292. X/* macro value
  293. X * can be string
  294. X * or ifset()
  295. X * or concat
  296. X */
  297. mdefine            :       mval {
  298. X                        $$ = $1;
  299. X            }
  300. X        |    IFSET LPAREN IDENT COMMA ifres RPAREN {
  301. X                $$ = MakeCond ($3, MacScan($5));
  302. X            }
  303. X        ;
  304. mval        :    strval                %prec COMMA {
  305. X                $$ = $1;
  306. X            }
  307. X        |    CONCAT LPAREN conval RPAREN {
  308. X                $$ = $3;
  309. X            } 
  310. X        ;
  311. X
  312. strval        :    SCONST {
  313. X                $$ = $1;
  314. X            }
  315. X        |    strval SCONST {
  316. X                $$ = ListAppend ($1, $2, (char *) NULL);
  317. X                Free ($1);
  318. X            }
  319. X        ;
  320. X
  321. X/* conval specifies what can be in a concat() function */
  322. conval        :    strval COMMA ifcon {
  323. X                $$ = ListAppend ($1, $3, (char *) NULL);
  324. X                Free ($1);
  325. X                Free ($3);
  326. X            }
  327. X        |    ifcon COMMA strval {
  328. X                $$ = ListAppend ($1, $3, (char *) NULL);
  329. X                Free ($1);
  330. X                Free ($3);
  331. X            }
  332. X        |    ifcon {
  333. X                $$ = $1;
  334. X            }
  335. X        |    error {
  336. X                $$ = NULL;
  337. X            }
  338. X        ;
  339. X
  340. ifcon        :    IFSET LPAREN IDENT COMMA ifres RPAREN {
  341. X                $$ = MakeCond ($3, MacScan($5));
  342. X            }
  343. X        ;
  344. X
  345. ifres        :    mval elseres {
  346. X                if ($2 != NULL) {
  347. X                    $$ = ListAppend ($1, $2, "$|");
  348. X                    Free ($1);
  349. X                    Free ($2);
  350. X                } else
  351. X                    $$ = $1;
  352. X            }
  353. X        |    error {
  354. X                $$ = NULL;
  355. X            }
  356. X        ;
  357. X
  358. elseres        :    /* empty */ {
  359. X                $$ = NULL;
  360. X            }
  361. X        |    COMMA mval {
  362. X                $$ = $2;
  363. X            }
  364. X        ;
  365. X
  366. classdefs    :    /* empty */ 
  367. X        |    classdefs IDENT ASGN nameset {
  368. X                EmitDef (def_class, $2, $4, (char *) NULL);
  369. X            }
  370. X                |     classdefs ASM LPAREN SCONST RPAREN SEMI {
  371. X                printf("%s\n",$4);
  372. X                        }
  373. X        |    error
  374. X        ;
  375. X
  376. nameset        :    LBRACE namelist RBRACE SEMI {
  377. X                $$ = $2;
  378. X            }
  379. X        |    LBRACE RBRACE SEMI {
  380. X                $$ = NULL;
  381. X            }
  382. X        |    LBRACE error RBRACE SEMI {
  383. X                $$ = NULL;
  384. X            }
  385. X        |    READCLASS LPAREN strval RPAREN SEMI {
  386. X                $$ = MakeRStr ($3, (char *) NULL);
  387. X            }
  388. X        |    READCLASS LPAREN strval COMMA strval RPAREN SEMI {
  389. X                $$ = MakeRStr ($3, $5);
  390. X            }
  391. X        |    READCLASS LPAREN error RPAREN SEMI {
  392. X                $$ = NULL;
  393. X            }
  394. X        |    error SEMI {
  395. X                $$ = NULL;
  396. X                yyerrok;
  397. X            }
  398. X        ;
  399. X
  400. namelist    :    IDENT {
  401. X                $$ = ListAppend ($1->psb, (char *) NULL, (char *) NULL);
  402. X                RemoveSymbol ($1);
  403. X            }
  404. X        |    strval {
  405. X                $$ = $1;
  406. X            }
  407. X        |    namelist COMMA IDENT {
  408. X                $$ = ListAppend ($1, $3->psb, " ");
  409. X                Free ($1);
  410. X                RemoveSymbol ($3);
  411. X            }
  412. X        |    namelist COMMA strval {
  413. X                $$ = ListAppend ($1, $3, " ");
  414. X                Free ($1);
  415. X                Free ($3);
  416. X            }
  417. X        ;
  418. X
  419. optdefs        :    /* empty */
  420. X        |    optdefs optid ASGN strval SEMI {
  421. X                EmitDef (def_option, (struct he *) NULL, ConvOpt ($2), $4);
  422. X            }
  423. X        |    optdefs DOPT ASGN doptid SEMI {
  424. X                EmitDef (def_option, (struct he *) NULL, ConvOpt (opt_d), $4);
  425. X            }
  426. X        |    optdefs EOPT ASGN eoptid SEMI {
  427. X                EmitDef (def_option, (struct he *) NULL, ConvOpt (opt_e), $4);
  428. X            }
  429. X                |     optdefs ASM LPAREN SCONST RPAREN SEMI {
  430. X                printf("%s\n",$4);
  431. X                        }
  432. X        |    error SEMI {
  433. X                yyerrok;
  434. X            }
  435. X        ;
  436. X
  437. optid        :    AAOPT {
  438. X                $$ = opt_A;
  439. X            }
  440. X        |    AOPT {
  441. X                $$ = opt_a;
  442. X            }
  443. X        |    BBOPT {
  444. X                $$ = opt_B;
  445. X            }
  446. X        |    BOPT {
  447. X                $$ = opt_b;
  448. X            }
  449. X        |    CCOPT {
  450. X                $$ = opt_C;
  451. X            }
  452. X        |    COPT {
  453. X                $$ = opt_c;
  454. X            }
  455. X        |    DDOPT {
  456. X                $$ = opt_D;
  457. X            }
  458. X        |    FFOPT {
  459. X                $$ = opt_F;
  460. X            }
  461. X        |    FOPT {
  462. X                $$ = opt_f;
  463. X            }
  464. X        |    GOPT {
  465. X                $$ = opt_g;
  466. X            }
  467. X        |    HOPT {
  468. X                $$ = opt_h;
  469. X            }
  470. X        |    HHOPT {
  471. X                $$ = opt_H;
  472. X            }
  473. X        |    IOPT {
  474. X                $$ = opt_i;
  475. X            }
  476. X        |    IIOPT {
  477. X                $$ = opt_I;
  478. X            }
  479. X        |    LLOPT {
  480. X                $$ = opt_L;
  481. X            }
  482. X        |    MOPT {
  483. X                $$ = opt_m;
  484. X            }
  485. X        |    NNOPT {
  486. X                $$ = opt_N;
  487. X            }
  488. X        |    NOPT {
  489. X                $$ = opt_n;
  490. X            }
  491. X        |    PPOPT {
  492. X                $$ = opt_P;
  493. X            }
  494. X        |    OOPT {
  495. X                $$ = opt_o;
  496. X            }
  497. X        |    QQOPT {
  498. X                $$ = opt_Q;
  499. X            }
  500. X        |    QOPT {
  501. X                $$ = opt_q;
  502. X            }
  503. X        |    ROPT {
  504. X                $$ = opt_r;
  505. X            }
  506. X        |    RROPT {
  507. X                $$ = opt_R;
  508. X            }
  509. X        |    SSOPT {
  510. X                $$ = opt_S;
  511. X            }
  512. X        |    SOPT {
  513. X                $$ = opt_s;
  514. X            }
  515. X        |    TTOPT {
  516. X                $$ = opt_T;
  517. X            }
  518. X        |    TOPT {
  519. X                $$ = opt_t;
  520. X            }
  521. X        |    UOPT {
  522. X                $$ = opt_u;
  523. X            }
  524. X        |    VOPT {
  525. X                $$ = opt_v;
  526. X            }
  527. X        |    WWOPT {
  528. X                $$ = opt_W;
  529. X            }
  530. X        |    XOPT {
  531. X                $$ = opt_x;
  532. X            }
  533. X        |    XXOPT {
  534. X                $$ = opt_X;
  535. X            }
  536. X        |    YOPT {
  537. X                $$ = opt_y;
  538. X            }
  539. X        |    YYOPT {
  540. X                $$ = opt_Y;
  541. X            }
  542. X        |    ZOPT {
  543. X                $$ = opt_z;
  544. X            }
  545. X        |    ZZOPT {
  546. X                $$ = opt_Z;
  547. X            }
  548. X        |    SLOPT {
  549. X                $$ = opt_SL;    /* SLASH .e.g. O/ in IDA */
  550. X            }
  551. X        ;
  552. X
  553. doptid        :    DOPTI {
  554. X                $$ = ConvOpt (d_opt_i);
  555. X            }
  556. X        |    DOPTB {
  557. X                $$ = ConvOpt (d_opt_b);
  558. X            }
  559. X        |    DOPTQ {
  560. X                $$ = ConvOpt (d_opt_q);
  561. X            }
  562. X        ;
  563. X
  564. eoptid        :    EOPTP {
  565. X                $$ = ConvOpt (e_opt_p);
  566. X            }
  567. X        |    EOPTE {
  568. X                $$ = ConvOpt (e_opt_e);
  569. X            }
  570. X        |    EOPTM {
  571. X                $$ = ConvOpt (e_opt_m);
  572. X            }
  573. X        |    EOPTW {
  574. X                $$ = ConvOpt (e_opt_w);
  575. X            }
  576. X        |    EOPTZ {
  577. X                $$ = ConvOpt (e_opt_z);
  578. X            }
  579. X        ;
  580. X
  581. precdefs    :    /* empty */
  582. X        |    precdefs IDENT ASGN ICONST SEMI {
  583. X                BindID ($2, $4, ID_PREC);
  584. X                EmitDef (def_prec, $2, (char *) NULL, (char *) NULL);
  585. X            }
  586. X        ;
  587. X
  588. tlist        :    /* empty */
  589. X        |    tlist LBRACE IDENT idlist RBRACE SEMI {
  590. X                EmitDef (def_trusted, (struct he *) NULL, 
  591. X                     ListAppend ($3->psb, $4, " "), (char *) NULL);
  592. X                Free ($4); /* Gets a Null pointer */
  593. X                RemoveSymbol ($3);
  594. X            }
  595. X        |    tlist LBRACE RBRACE SEMI
  596. X        |    error SEMI {
  597. X                yyerrok;
  598. X            }
  599. X        ;
  600. X
  601. hdefs        :    /* empty */
  602. X        |    hdefs FOR fcond dheader SEMI {
  603. X                EmitDef (def_header, (struct he *) NULL, $3, $4);
  604. X            }
  605. X        |    hdefs FOR fcond LBRACE { Flaglist = $3; } 
  606. X                dheaders RBRACE SEMI
  607. X        |    hdefs DEFINE dlist SEMI {
  608. X                EmitDef (def_header, (struct he *) NULL, (char *) NULL, $3);
  609. X            }
  610. X        |    error SEMI {
  611. X                yyerrok;
  612. X            }
  613. X        ;
  614. X
  615. fcond        :    LPAREN RPAREN {
  616. X                $$ = NULL;
  617. X            }
  618. X        |    LPAREN mflags RPAREN {
  619. X                $$ = $2;
  620. X            }
  621. X        |    LPAREN error RPAREN {
  622. X                $$ = NULL;
  623. X            }
  624. X        ;
  625. X
  626. mflags        :    flagid {
  627. X                $$ = ListAppend (ConvFlg ($1), (char *) NULL, (char *) NULL);
  628. X            }
  629. X        |    mflags COMMA flagid {
  630. X                $$ = ListAppend ($1, ConvFlg($3), (char *) NULL);
  631. X                Free ($1);
  632. X            }
  633. X        ;
  634. X
  635. flagid        :    FFLAG {
  636. X                $$ = flg_f;
  637. X            }
  638. X        |    RFLAG {
  639. X                $$ = flg_r;
  640. X            }
  641. X        |    SSFLAG {
  642. X                $$ = flg_S;
  643. X            }
  644. X        |    NFLAG {
  645. X                $$ = flg_n;
  646. X            }
  647. X        |    LFLAG {
  648. X                $$ = flg_l;
  649. X            }
  650. X        |    SFLAG {
  651. X                $$ = flg_s;
  652. X            }
  653. X        |    MFLAG {
  654. X                $$ = flg_m;
  655. X            }
  656. X        |    FFFLAG {
  657. X                $$ = flg_F;
  658. X            }
  659. X        |    DDFLAG {
  660. X                $$ = flg_D;
  661. X            }
  662. X        |    MMFLAG {
  663. X                $$ = flg_M;
  664. X            }
  665. X        |    XFLAG {
  666. X                $$ = flg_x;
  667. X            }
  668. X        |    PPFLAG {
  669. X                $$ = flg_P;
  670. X            }
  671. X        |    UFLAG {
  672. X                $$ = flg_u;
  673. X            }
  674. X        |    HFLAG {
  675. X                $$ = flg_h;
  676. X            }
  677. X        |    AAFLAG {
  678. X                $$ = flg_A;
  679. X            }
  680. X        |    BBFLAG {
  681. X                $$ = flg_B;
  682. X            }
  683. X        |    UUFLAG {
  684. X                $$ = flg_U;
  685. X            }
  686. X        |    EFLAG {
  687. X                $$ = flg_e;
  688. X            }
  689. X        |    XXFLAG {
  690. X                $$ = flg_X;
  691. X            }
  692. X        |    LLFLAG {
  693. X                $$ = flg_L;
  694. X            }
  695. X        |    PFLAG {
  696. X                $$ = flg_p;
  697. X            }
  698. X        |    IIFLAG {
  699. X                $$ = flg_I;
  700. X            }
  701. X        |    CCFLAG {
  702. X                $$ = flg_C;
  703. X            }
  704. X        |    EEFLAG {
  705. X                $$ = flg_E;
  706. X            }
  707. X        |    RRFLAG {
  708. X                $$ = flg_R;
  709. X            }
  710. X        |    HHFLAG {
  711. X                $$ = flg_H;
  712. X            }
  713. X        |    VVFLAG {
  714. X                $$ = flg_V;
  715. X            }
  716. X        ;
  717. X
  718. dheader        :    /* empty */ {
  719. X                $$ = NULL;
  720. X            }
  721. X        |    DEFINE dlist {
  722. X                $$ = $2;
  723. X            }
  724. X        |    error {
  725. X                $$ = NULL;
  726. X            }
  727. X        ;
  728. X
  729. dheaders    :    /* empty */
  730. X        |    dheaders DEFINE dlist SEMI {
  731. X                EmitDef (def_header, (struct he *) NULL, Flaglist, $3);
  732. X            }
  733. X                |     dheaders ASM LPAREN SCONST RPAREN SEMI {
  734. X                printf("%s\n",$4);
  735. X                        }
  736. X        |    error
  737. X        ;
  738. X
  739. dlist        :    LPAREN strval COMMA catstringlist RPAREN {
  740. X                $$ = ListAppend ($2, MacScan ($4), " ");
  741. X                Free ($2);
  742. X                Free ($4);
  743. X            }
  744. X        |    LPAREN error RPAREN {
  745. X                $$ = NULL;
  746. X            }
  747. X        ;
  748. X
  749. catstringlist    :    catstring {
  750. X                  $$ = $1;
  751. X            }
  752. X        |    catstring COMMA catstringlist {
  753. X                  $$ = ListAppend( $1, $3, (char *) NULL);
  754. X                  Free($1);
  755. X            }
  756. catstring    :    SCONST {
  757. X                $$ = $1;
  758. X            }
  759. X        |    CONCAT LPAREN conval RPAREN {
  760. X                $$ = $3;
  761. X            }
  762. X        |    ifcon {
  763. X                $$ = $1;
  764. X            }
  765. X        ;
  766. X
  767. mlist        :    /* empty */
  768. X        |    mlist IDENT LBRACE mdefs RBRACE SEMI {
  769. X                EmitDef (def_mailer, $2, $4, (char *) NULL);
  770. X            }
  771. X        |    mlist IDENT LBRACE RBRACE SEMI {
  772. X                EmitDef (def_mailer, $2, (char *) NULL, (char *) NULL);
  773. X            }
  774. X        |    error SEMI {
  775. X                yyerrok;
  776. X            }
  777. X        ;
  778. X
  779. mdefs        :    mtdef {
  780. X                $$ = $1;
  781. X            }
  782. X        |    mdefs COMMA mtdef {
  783. X                $$ = ListAppend ($1, $3, ", ");
  784. X                Free ($1);
  785. X                Free ($3);
  786. X            }
  787. X        ;    
  788. X
  789. mtdef        :    mvar ASGN mval {
  790. X                $$ = ListAppend (ConvMat ($1), MacScan ($3), "=");
  791. X                Free ($3);
  792. X            }
  793. X        |    MFLAGS ASGN LBRACE mflags RBRACE {
  794. X                $$ = ListAppend (ConvMat (mat_flags), $4, "=");
  795. X            }
  796. X        |    MSENDER ASGN IDENT {
  797. X                $$ = ListAppend (ConvMat (mat_sender), CheckRS ($3), "=");
  798. X            }
  799. X        |    MSENDER ASGN IDENT SLASH IDENT {
  800. X                $$ = ListAppend(
  801. X                 Tsb = ListAppend (ConvMat(mat_sender), CheckRS ($3), "="),
  802. X                 Tsb1 = ListAppend ("/", CheckRS ($5), (char *) NULL),
  803. X                         (char *) NULL);
  804. X                Free (Tsb);
  805. X                Free (Tsb1);
  806. X            }
  807. X        |    MRECIPIENT ASGN IDENT {
  808. X                $$ = ListAppend (ConvMat (mat_recipient), CheckRS ($3), "=");
  809. X            }
  810. X        |    MRECIPIENT ASGN IDENT SLASH IDENT {
  811. X                $$ = ListAppend(
  812. X                 Tsb = ListAppend (ConvMat(mat_recipient), CheckRS ($3), "="),
  813. X                 Tsb1 = ListAppend ("/", CheckRS ($5), (char *) NULL),
  814. X                         (char *) NULL);
  815. X                Free (Tsb);
  816. X                Free (Tsb1);
  817. X            }
  818. X        |    error {
  819. X                $$ = NULL;
  820. X            }
  821. X        ;
  822. X
  823. mvar        :    MPATH {
  824. X                $$ = mat_path;
  825. X            }
  826. X        |    MARGV {
  827. X                $$ = mat_argv;
  828. X            }
  829. X        |    MEOL {
  830. X                $$ = mat_eol;
  831. X            }
  832. X        |    MMAXSIZE {
  833. X                $$ = mat_maxsize;
  834. X            }
  835. X        ;
  836. X
  837. rdef        :    /* empty */
  838. X        |    rdef IDENT { StartRuleset ($2); } rulelist
  839. X        ;
  840. X
  841. rulelist    :    LBRACE ruledefs RBRACE {
  842. X                RMatch = FALSE;
  843. X            }
  844. X        |    error {
  845. X                RMatch = FALSE;
  846. X            }
  847. X        ;
  848. X
  849. ruledefs    :    /* empty */ {
  850. X                RMatch = TRUE;
  851. X            }
  852. X        |    ruledefs IF LPAREN matchaddr RPAREN actionstmt {
  853. X                  number_of_fields    =0;
  854. X                EmitDef (def_ruleset, (struct he *) NULL, 
  855. X                     ListAppend ($4, $6, "\t"), (char *) NULL);
  856. X            Free ($4);
  857. X            Free ($6);
  858. X            }
  859. X                |     ruledefs ASM LPAREN SCONST RPAREN SEMI {
  860. X                  printf("%s\n",$4);
  861. X                        }
  862. X        |    error SEMI {
  863. X                yyerrok;
  864. X            }
  865. X        ;
  866. X
  867. matchaddr    :    /* empty */ {
  868. X                $$ = NULL;
  869. X            }
  870. X        |    matchaddr matchtok {
  871. X                $$ = ListAppend ($1, $2, (char *) NULL);
  872. X                Free ($1); /* NULL */
  873. X            }
  874. X        |    error {
  875. X                $$ = NULL;
  876. X            }
  877. X        ;
  878. X
  879. X/* just like matchaddr - but comma's aren't allowed */
  880. matchaddrnocomma    :    /* empty */ {
  881. X                $$ = NULL;
  882. X            }
  883. X        |    matchaddrnocomma matchtoknocomma {
  884. X                $$ = ListAppend ($1, $2, (char *) NULL);
  885. X                Free ($1); /* NULL */
  886. X            }
  887. X        |    error {
  888. X                $$ = NULL;
  889. X            }
  890. X        ;
  891. X
  892. matchtok    :    IDENT {
  893. X                $$ = GetField ($1);
  894. X            }
  895. X        |    anychar {
  896. X                *Cbuf = $1;
  897. X                $$ = ListAppend (Cbuf, (char *) NULL, (char *) NULL);
  898. X            }
  899. X        |    mval {
  900. X                $$ = MacScan ($1);
  901. X            }
  902. X        |    DOLLAR IDENT {
  903. X                Mbuf[1] = MakeMac ($2, ID_MACRO);
  904. X                $$ = ListAppend (Mbuf, (char *) NULL, (char *) NULL);
  905. X            }
  906. X                |       YPALIAS LPAREN matchtok RPAREN {
  907. X                 $$ = ListAppend("${",$3,(char *) NULL);
  908. X/*             Free ($3); */
  909. X        }
  910. X                |       YPPASSWD LPAREN matchtok RPAREN {
  911. X                 $$ = ListAppend("$\"",$3,(char *) NULL);
  912. X        }
  913. X                |       RESOLVED LPAREN matchtok RPAREN {
  914. X                 $$ = ListAppend("$#",$3,(char *) NULL);
  915. X        }
  916. X        |    IFSET LPAREN IDENT COMMA ifresmatch RPAREN {
  917. X                $$ = MakeCond ($3, MacScan($5));
  918. X            }
  919. X    ;
  920. X
  921. X/* the next one is just like matchtok - but you can't have a comma in it */
  922. matchtoknocomma    :    IDENT {
  923. X                $$ = GetField ($1);
  924. X            }
  925. X        |    anycharbutcomma {
  926. X                *Cbuf = $1;
  927. X                $$ = ListAppend (Cbuf, (char *) NULL, (char *) NULL);
  928. X            }
  929. X        |    mval {
  930. X                $$ = MacScan ($1);
  931. X            }
  932. X        |    DOLLAR IDENT {
  933. X                Mbuf[1] = MakeMac ($2, ID_MACRO);
  934. X                $$ = ListAppend (Mbuf, (char *) NULL, (char *) NULL);
  935. X            }
  936. X                |       YPALIAS LPAREN matchtok RPAREN {
  937. X                 $$ = ListAppend("${",$3,(char *) NULL);
  938. X/*             Free ($3); */
  939. X        }
  940. X                |       YPPASSWD LPAREN matchtok RPAREN {
  941. X                 $$ = ListAppend("$\"",$3,(char *) NULL);
  942. X        }
  943. X                |       RESOLVED LPAREN matchtok RPAREN {
  944. X                 $$ = ListAppend("$#",$3,(char *) NULL);
  945. X        }
  946. X        |    IFSET LPAREN IDENT COMMA ifresmatch RPAREN {
  947. X                $$ = MakeCond ($3, MacScan($5));
  948. X            }
  949. X    ;
  950. X
  951. ifresmatch    :    matchaddrnocomma elseresmatch {
  952. X                if ($2 != NULL) {
  953. X                    $$ = ListAppend ($1, $2, "$|");
  954. X                    Free ($1);
  955. X                    Free ($2);
  956. X                } else
  957. X                    $$ = $1;
  958. X            }
  959. X        |    error {
  960. X                $$ = NULL;
  961. X            }
  962. X        ;
  963. X
  964. elseresmatch    :
  965. X            COMMA matchaddrnocomma {
  966. X                $$ = $2;
  967. X            }
  968. X        ;
  969. X
  970. actionstmt    :    action LPAREN rwaddr RPAREN SEMI {
  971. X                $$ = ListAppend ($1, $3, (char *) NULL);
  972. X                Free ($3);
  973. X            }
  974. X        |    RESOLVE LPAREN resolution RPAREN SEMI {
  975. X                $$ = $3;
  976. X            }
  977. X        |    error SEMI {
  978. X                $$ = NULL;
  979. X                yyerrok;
  980. X            }
  981. X        ;
  982. X
  983. action        :    RETRY {
  984. X                $$ = NULL;
  985. X            }
  986. X        |    NEXT {
  987. X                $$ = "$:";
  988. X            }
  989. X        |    RETURN {
  990. X                $$ = "$@";
  991. X            }
  992. X        ;
  993. X
  994. rwaddr        :    /* empty */ {
  995. X                $$ = NULL;
  996. X            }
  997. X        |    rwaddr rwtok {
  998. X                $$ = ListAppend ($1, $2, (char *) NULL);
  999. X                Free ($1);    /* NULL */
  1000. X            }
  1001. X        |    rwaddr IDENT LPAREN rwaddr RPAREN {
  1002. X                $$ = ListAppend ($1, (Tsb = MakeRSCall ($2, $4)), (char *) NULL);
  1003. X                Free ($1);    /* NULL */
  1004. X                Free ($4);
  1005. X                Free (Tsb);
  1006. X            }
  1007. X        |    error {
  1008. X                $$ = NULL;
  1009. X            }
  1010. X        ;
  1011. X
  1012. rwtok        :    anychar {
  1013. X                *Cbuf = $1;
  1014. X                $$ = ListAppend (Cbuf, (char *) NULL, (char *) NULL);
  1015. X            }
  1016. X        |    mval {
  1017. X                $$ = MacScan ($1);
  1018. X            }
  1019. X        |    cantok {
  1020. X                $$ = $1;
  1021. X            }
  1022. X        |    dbmtok {
  1023. X                $$ = $1;
  1024. X            }
  1025. X        |    ALIAS LPAREN reftok  RPAREN {
  1026. X                $$ = ListAppend("$(@", $3, "$:$)");
  1027. X            }
  1028. X        |    ALIAS LPAREN reftok DEFAULT LPAREN rwaddr RPAREN RPAREN {
  1029. X                $$ = ListAppend(Tsb = 
  1030. X                        ListAppend ( "$(@", 
  1031. X                                $3, 
  1032. X                                (char *)NULL),
  1033. X                        Tsb1 = ListAppend("$:", $6, "$)" ),
  1034. X                        (char *) NULL);
  1035. X                Free (Tsb);
  1036. X                Free (Tsb1);
  1037. X                Free ($3);
  1038. X                Free ($6);
  1039. X            }
  1040. X        |    reftok {
  1041. X                $$ = $1;
  1042. X            }
  1043. X        |    ifcon {
  1044. X                $$ = $1;
  1045. X            }
  1046. X                |    YPMAP LPAREN IDENT COMMA rwaddr RPAREN {
  1047. X                *Cbuf = MakeMac ($3, ID_MACRO);
  1048. X                $$ = ListAppend(Tsb = ListAppend ("${", (char *)Cbuf, (char *)NULL),
  1049. X                        Tsb1 = ListAppend ($5, "$}", (char *) NULL),
  1050. X                         (char *) NULL);
  1051. X                Free (Tsb);
  1052. X                Free (Tsb1);
  1053. X                Free ($5);
  1054. X            }
  1055. X
  1056. X                |    PROGRAM LPAREN IDENT COMMA rwaddr RPAREN {
  1057. X                *Cbuf = MakeMac ($3, ID_MACRO);
  1058. X                $$ = ListAppend(Tsb = ListAppend ("$<", (char *)Cbuf, (char *)NULL),
  1059. X                        Tsb1 = ListAppend ($5, "", (char *) NULL),
  1060. X                         (char *) NULL);
  1061. X                Free (Tsb);
  1062. X                Free (Tsb1);
  1063. X                Free ($5);
  1064. X            }
  1065. X
  1066. X                |    action LPAREN rwaddr RPAREN {
  1067. X                $$ = ListAppend ($1, $3, (char *) NULL);
  1068. X                Free ($3);
  1069. X            }
  1070. X        ;
  1071. X
  1072. X
  1073. cantok        :    CANON LPAREN canval RPAREN {
  1074. X                $$ = Bracket ($3, TRUE);
  1075. X                Free ($3);
  1076. X            }
  1077. X
  1078. X                ;
  1079. canval        :    canvaltok {
  1080. X                $$ = $1;
  1081. X            }
  1082. X        |    canval canvaltok {
  1083. X                $$ = ListAppend ($1, $2, (char *) NULL);
  1084. X                Free ($1);
  1085. X/*                Free ($2); */
  1086. X            }
  1087. X        ;
  1088. X
  1089. canvaltok    :    IDENT {
  1090. X                $$ = ListAppend ($1->psb, (char *) NULL, (char *) NULL);
  1091. X                RemoveSymbol ($1);
  1092. X            }
  1093. X        |    SCONST {
  1094. X                $$ = ListAppend (MacScan ($1), (char *) NULL, (char *) NULL);
  1095. X                Free ($1);
  1096. X            }
  1097. X                |    NEXT LPAREN RPAREN {    /* I Used next earlier, but now use default - because it is clearer syntax */
  1098. X                $$ = "$:";
  1099. X            }
  1100. X                |    NEXT LPAREN canval RPAREN {
  1101. X                $$ = ListAppend("$:", $3, (char *)NULL);
  1102. X            }
  1103. X                |    DEFAULT LPAREN RPAREN {
  1104. X                $$ = "$:";
  1105. X            }
  1106. X                |    DEFAULT LPAREN canval RPAREN {
  1107. X                $$ = ListAppend("$:", $3, (char *)NULL);
  1108. X            }
  1109. X        |    reftok {
  1110. X                $$ = $1;
  1111. X            }
  1112. X        |    SEPCHAR {
  1113. X                *Cbuf = $1;
  1114. X                $$ = ListAppend (Cbuf, (char *) NULL, (char *) NULL);
  1115. X            }
  1116. X        |    HOSTNUM LPAREN reftok RPAREN {
  1117. X                $$ = Bracket ($3, FALSE);
  1118. X                Free ($3);
  1119. X            }
  1120. X        ;
  1121. X
  1122. dbmtok        :    DBM LPAREN DOLLAR IDENT COMMA dbmstuff RPAREN {
  1123. X                $$ = DbmParen ($4->psb, $6);
  1124. X                RemoveSymbol($4);
  1125. X                Free ($6);
  1126. X            }
  1127. X                ;
  1128. dbmstuff    :    dbmval COMMA dbmval {
  1129. X                $$ = ListAppend ($1, Tsb = ListAppend ("$@", $3, (char *) NULL),
  1130. X                         (char *) NULL);
  1131. X                Free (Tsb);
  1132. X            }
  1133. X        |        dbmval {
  1134. X                $$ = $1;
  1135. X            }
  1136. X        ;
  1137. X
  1138. dbmval        :    dbmvaltok {
  1139. X                $$ = $1;
  1140. X            }
  1141. X        |    dbmval dbmvaltok {
  1142. X                $$ = ListAppend ($1, $2, (char *) NULL);
  1143. X                Free ($1);
  1144. X/*                Free ($2); */
  1145. X            }
  1146. X        ;
  1147. X
  1148. dbmvaltok    :    IDENT {
  1149. X                $$ = ListAppend ($1->psb, (char *) NULL, (char *) NULL);
  1150. X                RemoveSymbol ($1);
  1151. X            }
  1152. X        |    SCONST {
  1153. X                $$ = ListAppend (MacScan ($1), (char *) NULL, (char *) NULL);
  1154. X                Free ($1);
  1155. X            }
  1156. X                |    NEXT LPAREN RPAREN {    /* I Used next earlier, but now use default - because it is clearer syntax */
  1157. X                $$ = "$:";
  1158. X            }
  1159. X                |    NEXT LPAREN dbmval RPAREN {
  1160. X                $$ = ListAppend("$:", $3, (char *)NULL);
  1161. X            }
  1162. X                |    DEFAULT LPAREN RPAREN {
  1163. X                $$ = "$:";
  1164. X            }
  1165. X                |    DEFAULT LPAREN dbmval RPAREN {
  1166. X                $$ = ListAppend("$:", $3, (char *)NULL);
  1167. X            }
  1168. X        |    reftok {
  1169. X                $$ = $1;
  1170. X            }
  1171. X        |    SEPCHAR {
  1172. X                *Cbuf = $1;
  1173. X                $$ = ListAppend (Cbuf, (char *) NULL, (char *) NULL);
  1174. X            }
  1175. X        ;
  1176. X
  1177. reftok        :    DOLLAR IDENT {
  1178. X                Mbuf[1] = MakeMac ($2, ID_MACRO);
  1179. X                $$ = ListAppend (Mbuf, (char *) NULL, (char *) NULL);
  1180. X            }
  1181. X        |    DOLLAR ICONST {
  1182. X                $$ = ListAppend (MakePosTok ($2), (char *) NULL, (char *) NULL);
  1183. X            }
  1184. X                |    EVAL LPAREN IDENT RPAREN {
  1185. X                *Cbuf = MakeMac ($3, ID_MACRO);
  1186. X                $$ = ListAppend("$&", (char *)Cbuf, (char *)NULL);
  1187. X            }
  1188. X        ;
  1189. X
  1190. X
  1191. X/* because of ifset, we have to treat comma's special
  1192. X otherwise ifset(a,b,c) might be ambiguous if
  1193. X c is an address with a comma in it.
  1194. X*/
  1195. anychar        :    anycharbutcomma {
  1196. X                  $$ = $1;
  1197. X        }
  1198. X          |    COMMA {
  1199. X                $$ = ',';
  1200. X            }
  1201. X
  1202. X        ;
  1203. X
  1204. anycharbutcomma        :    SEPCHAR {
  1205. X                $$ = $1;
  1206. X            }
  1207. X        |    COLON {
  1208. X                $$ = ':';
  1209. X            }
  1210. X        |    STAR {
  1211. X                $$ = '*';
  1212. X            }
  1213. X        |    SEMI {
  1214. X                $$ = ';';
  1215. X            }
  1216. X        |    LBRACE {
  1217. X                $$ = '{';
  1218. X            }
  1219. X        |    RBRACE {
  1220. X                $$ = '}';
  1221. X            }
  1222. X        |    SLASH {
  1223. X                $$ = '/';
  1224. X            }
  1225. X        |    ASGN {
  1226. X                $$ = '=';
  1227. X            }
  1228. X        ;
  1229. X
  1230. resolution    :    mailerspec COMMA route {
  1231. X                $$ = ListAppend ($1, $3, (char *) NULL);
  1232. X                Free ($1);
  1233. X                Free ($3);
  1234. X            }
  1235. X        |    mailerspec {
  1236. X            $$ = $1;
  1237. X            }
  1238. X        |    error {
  1239. X                $$ = NULL;
  1240. X            }
  1241. X        ;
  1242. X
  1243. mailerspec    :    MAILER LPAREN rword RPAREN {
  1244. X                $$ = ListAppend ("$#", $3, (char *) NULL);
  1245. X            }
  1246. X        ;
  1247. X
  1248. route        :    HOST LPAREN hword RPAREN COMMA userspec {
  1249. X                $$ = ListAppend (Tsb = ListAppend ("$@", $3, (char *) NULL),
  1250. X                         $6, (char *) NULL);
  1251. X                Free (Tsb);
  1252. X
  1253. X
  1254. X                Free ($6);
  1255. X            }
  1256. X        |    userspec {
  1257. X                $$ = $1;
  1258. X            }
  1259. X        |    IFSET LPAREN IDENT COMMA ifresroute RPAREN {
  1260. X                $$ = MakeCond ($3, MacScan($5));
  1261. X            }
  1262. X        ;
  1263. X
  1264. ifresroute        :    LPAREN route RPAREN  elseresroute {
  1265. X                if ($4 != NULL) {
  1266. X                    $$ = ListAppend ($2, $4, "$|");
  1267. X                    Free ($2);
  1268. X                    Free ($4);
  1269. X                } else
  1270. X                    $$ = $2;
  1271. X            }
  1272. X        |    error {
  1273. X                $$ = NULL;
  1274. X            }
  1275. X        ;
  1276. X
  1277. elseresroute    :
  1278. X            COMMA LPAREN route RPAREN {
  1279. X                $$ = $3;
  1280. X            }
  1281. X        ;
  1282. X
  1283. hword        :    hostid {
  1284. X                $$ = $1;
  1285. X            }
  1286. X        |    HOSTNUM LPAREN reftok RPAREN {
  1287. X                $$ = Bracket ($3, FALSE);
  1288. X                Free ($3);
  1289. X            }
  1290. X        ;
  1291. X
  1292. hostid        :    /* empty */ {
  1293. X                $$ = NULL;
  1294. X            }
  1295. X        |    hostid IDENT {
  1296. X                $$ = ListAppend ($1, $2->psb, (char *) NULL);
  1297. X                RemoveSymbol ($2);
  1298. X                Free ($1);
  1299. X            }
  1300. X        |    hostid rwtok {
  1301. X                $$ = ListAppend ($1, $2, (char *) NULL);
  1302. X                Free ($1);    /* NULL */
  1303. X            }
  1304. X        ;
  1305. X
  1306. userspec    :    USER LPAREN rwaddr RPAREN {
  1307. X                $$ = ListAppend ("$:", $3, (char *) NULL);
  1308. X                Free ($3);
  1309. X            }
  1310. X        ;
  1311. X
  1312. rword        :    IDENT {
  1313. X                $$ = CheckMailer ($1);
  1314. X            }
  1315. X        |    reftok {
  1316. X                $$ = $1;
  1317. X            }
  1318. X        ;
  1319. X
  1320. fdefs        :    /* empty */
  1321. X        |    fdefs IDENT idlist COLON ftype SEMI {
  1322. X                AssignType (ListAppend ($2->psb, $3, " "), $5);
  1323. X                Free ($3);    /* NULL */
  1324. X            }
  1325. X        |    error SEMI {
  1326. X                yyerrok;
  1327. X            }
  1328. X        ;
  1329. X
  1330. idlist        :    /* empty */ {
  1331. X                $$ = NULL;
  1332. X            }
  1333. X        |    idlist COMMA IDENT {
  1334. X                $$ = ListAppend ($1, $3->psb, " ");
  1335. X                Free ($1);
  1336. X            }
  1337. X        ;
  1338. X
  1339. ftype        :    MATCH LPAREN ICONST RPAREN cdef {
  1340. X                $$ = ListAppend (MakeField ($3, $5, FALSE, FALSE), 
  1341. X                             (char *) NULL, (char *) NULL);
  1342. X            }
  1343. X        |    MATCH LPAREN ICONST RPAREN MAP IDENT {
  1344. X                $$ = ListAppend (MakeField ($3, $6, FALSE, TRUE), 
  1345. X                             (char *) NULL, (char *) NULL);
  1346. X            }
  1347. X        |    MATCH HOST {
  1348. X                $$ = ListAppend ("$%y", 
  1349. X                             (char *) NULL, (char *) NULL);
  1350. X            }
  1351. X        |    MATCH LPAREN ICONST STAR RPAREN {
  1352. X                $$ = ListAppend (MakeField ($3, (struct he *) NULL, TRUE, FALSE), 
  1353. X                         (char *) NULL, (char *) NULL);
  1354. X            }
  1355. X        |    error {
  1356. X                $$ = NULL;
  1357. X            }
  1358. X        ;
  1359. X
  1360. cdef        :    /* empty */ {
  1361. X                $$ = NULL;
  1362. X            }
  1363. X        |    IN IDENT {
  1364. X                $$ = $2;
  1365. X            }
  1366. X        ;
  1367. END_OF_FILE
  1368. if test 26290 -ne `wc -c <'src/parser.y'`; then
  1369.     echo shar: \"'src/parser.y'\" unpacked with wrong size!
  1370. fi
  1371. # end of 'src/parser.y'
  1372. fi
  1373. echo shar: End of archive 4 \(of 6\).
  1374. cp /dev/null ark4isdone
  1375. MISSING=""
  1376. for I in 1 2 3 4 5 6 ; do
  1377.     if test ! -f ark${I}isdone ; then
  1378.     MISSING="${MISSING} ${I}"
  1379.     fi
  1380. done
  1381. if test "${MISSING}" = "" ; then
  1382.     echo You have unpacked all 6 archives.
  1383.     rm -f ark[1-9]isdone
  1384. else
  1385.     echo You still need to unpack the following archives:
  1386.     echo "        " ${MISSING}
  1387. fi
  1388. ##  End of shell archive.
  1389. exit 0
  1390.