%{
/*
 *	RFC 822 address parsing routines.
 */

#ifndef	lint
static char	sccsid[]	= "%W%";
#endif	lint

#include	"mace.h"
#include	"headers.h"
#include	"flex.h"
#include	"addr.h"

#define		panic(s)	abort(s)
#define		nomem()		abort("nomem")

static flex	f	= { NULLSTR, NULLSTR, NULLSTR, };

/* $Log:	address.y,v $
 * Revision 1.5  88/12/29  00:44:14  john
 * Moved to MIPS
 * 
 * Revision 1.5  88/12/29  00:44:14  john
 * Move eatcomment() into address.y where it belongs, and fix it to
 * handle \-quoting of parens inside comments.
 * 
 * Revision 1.4  88/12/28  22:13:40  john
 * Fix \ quoting within quoted-strings and domain-literals (it was
 * missing).  Also fix missing cases for ']' as an atom.
 * 
 * Revision 1.3  88/12/28  00:14:03  john
 * Fix lexical analysis bug, parentheses were not being correctly
 * recognized as atoms.
 * 
 * Revision 1.2  88/10/30  07:46:22  john
 * Improve compliance of grammar to RFC822:
 * 	- insist on a domain at the end of a source-route
 * Change makeaddress() to do the right thing with a
 * source-routed address (i.e., make it an actual textual
 * representation of the source-routed address).
 * Fix bug in putdom.
 * 
 * Revision 1.1  88/10/26  09:54:04  john
 * Initial revision
 * 
 */

static char RCSid[] =
    "$Header: address.y,v 1.5 88/12/29 00:44:14 john Exp $";

static char	*errstr;
static char	*comstr;
static char	*cp;
static char	*savecp;
static char	*saveline;
static flex	 errbuf		= { NULLSTR, NULLSTR, NULLSTR };
static flex	 combuf		= { NULLSTR, NULLSTR, NULLSTR };
static int	 iseol;

static char	*text;
Addr		*adrlist;
Addr		*errlist;
%}

%union {
   char	 yChar;
   char	*yString;
   Dom	*yDom;
   Addr	*yAddr;
}

%token	EOL ATOM LIT_DOMAIN QUOTED_STRING

%type	<yString>	word domain_ref sub_domain local_part phrase
%type	<yDom>		domain route_list route
%type	<yAddr>		addr_spec non_local_addr_spec route_addr mailbox mbox_list group address

%start	addr_list

%%
addr_list:	addr_lel
       | addr_list addr_lel
       ;

addr_lel: address EOL {
	    $1->comment = comstr;
	    $1->error = errstr;
	    comstr = NULL;
	    errstr = NULL;
	    appAddr(&adrlist, $1);
	}
	| address ',' {
	    $1->comment = comstr;
	    $1->error = errstr;
	    comstr = NULL;
	    errstr = NULL;
	    appAddr(&adrlist, $1);
	}
	| error {
	    register Addr	*ap;

	    ap = newAddr();
	    if (savecp > saveline) {
		flex_str(&errbuf, " after \"");
		flex_nstr(&errbuf, saveline, savecp - saveline);
		flex_char(&errbuf, '"');
		if (cp && *cp) {
		    flex_str(&errbuf, ", before \"");
		    flex_str(&errbuf, cp);
		    flex_char(&errbuf, '"');
		}
	    }
	    else if (cp && *cp) {
		flex_str(&errbuf, " before \"");
		flex_str(&errbuf, cp);
		flex_char(&errbuf, '"');
	    }

	    if (errbuf.f_ptr != errbuf.f_str) {
		flex_char(&errbuf, '\0');
		errstr = newstring2(errstr, errbuf.f_str);
		flex_end(&errbuf);
	    }

	    ap->error = errstr;
	    errstr = NULL;
	    comstr = NULL;
	    appAddr(&errlist, ap);
	}
	;

address: mailbox {
	    $$ = $1;
	}
	| group {
	    $$ = $1;
	}
	;

group	: phrase ':' mbox_list ';' {
	    register Addr	*a;

	    for (a = $3; a; a = a->next)
		a->group = $1;
	    $$ = $3;
	}
	;

mbox_list: mailbox {
	    $$ = $1;
	}
	| mbox_list ',' mailbox {
	    $3->comment = comstr;
	    $3->error = errstr;
	    comstr = NULL;
	    errstr = NULL;
	    appAddr(&($1), $3);
	    $$ = $1;
	}
	;

mailbox: addr_spec {
	    $$ = $1;
	}
	| route_addr {
	    $$ = $1;
	}
	| phrase route_addr {
	    $2->name = $1;
	    $$ = $2;
	}
	;

phrase	: word {
	    $$ = $1;
	}
	| phrase word {
	    $$ = newstring3($1, " ", $2);
	    free($1);
	    free($2);
       }
       ;

route_addr: '<' addr_spec '>' {
	   $$ = $2;
       }
       | '<' route non_local_addr_spec '>' {
	   prepDom(&($3->route), $2);
	   $$ = $3;
       }
       ;

route	: route_list ':' {
	    $$ = $1;
	}
	;

route_list: '@' domain {
	    $$ = $2;
	}
	| route_list ',' '@' domain {
	    appDom(&($1), $4);
	    $$ = $1;
	}
	;

addr_spec: non_local_addr_spec
	| local_part {
	    register Addr	*ap;

	    $$ = ap = newAddr();
	    ap->localp = $1;
	    ap->destdom = NULL;
	}
	;

non_local_addr_spec: local_part '@' domain {
	    register Addr	*ap;

	    $$ = ap = newAddr();
	    ap->localp = $1;
	    ap->destdom = $3;
	    ap->route = $3;
	}
	;

local_part: word {
		$$ = $1;
	    }
	    | local_part '.' word {
		$$ = newstring3($1, ".", $3);
		free($1);
		free($3);
	    }
	    | local_part '%' word {
		$$ = newstring3($1, "%", $3);
		free($1);
		free($3);
	    }
	    ;

domain	: sub_domain {
	    register Dom	*dp;

	    dp = newDom();
	    dp->sub[0] = $1;
	    dp->top = dp->sub;
	    $$ = dp;
	}
	| domain '.' sub_domain {
	    ($1->top)++;
	    *($1->top) = $3;
	    $$ = $1;
	}
	;

sub_domain: domain_ref {
	    $$ = $1;
	}
	| LIT_DOMAIN {
	    $$ = yylval.yString;
	}
	;

domain_ref: ATOM {
	    $$ = yyval.yString;
	}
	;

word	: ATOM {
	    $$ = yylval.yString;
	}
	| QUOTED_STRING {
	    $$ = yylval.yString;
	}
	;

%%

#include <stdio.h>
#include <ctype.h>

#define ERROR	-2


static char *
newstring3(a, b, c)
    char	*a;
    char	*b;
    char	*c;
{
    char	*p;
    char	*q;
    int		 i;

    i = strlen(a) + strlen(b) + strlen(c) + 1;
    if ((p = salloc((MALLOCT)i)) == NULL)
	nomem();
    q = p + strlen(strcpy(p, a));
    q += strlen(strcpy(q, b));
    Strcpy(q, c);
    return(p);
}


static char *
newstring2(a, b)
    char		*a;
    char		*b;
{
    char		*p;
    int			 i;

    if (a == (char *)0)
	a = "";
    i = strlen(a) + strlen(b) + 1;
    if ((p = salloc((MALLOCT)i)) == NULL)
	nomem();
    Strcpy(p, a);
    Strcat(p, b);
    return(p);
}

/*
 * <mess>: [ "<what>" ] unexpected [ <tail> ]
 */
static void
unexpected(mess, what, tail)
char	*mess;
char	*what;
char	*tail;
{
    flex_str(&errbuf, mess);
    flex_str(&errbuf, ": ");

    if (what != NULLSTR)
    {
	flex_char(&errbuf, '"');
	flex_str(&errbuf, what);
        flex_str(&errbuf, "\" ");
    }

    flex_str(&errbuf, "unexpected");

    if (tail != NULLSTR)
    {
	flex_char(&errbuf, ' ');
	flex_str(&errbuf, tail);
    }

    flex_char(&errbuf, '\0');
}

static void
yyerror(s)
    char	*s;
{
   static char	c[2]	= { '\0', '\0' };

   switch(yychar) {
       default:
	   c[0] = yylval.yChar;
	   unexpected(s, c, NULLSTR);
	   errstr = newstring2(errstr, errbuf.f_str);
	   break;
       case LIT_DOMAIN:
       case QUOTED_STRING:
       case ATOM:
	   unexpected(s, yylval.yString, NULLSTR);
	   errstr = newstring2(errstr, errbuf.f_str);
	   break;
       case EOL:
       case 0: /* EOF */
	   unexpected(s, NULLSTR, "end-of-header");
	   errstr = newstring2(errstr, errbuf.f_str);
	   break;
   }
   flex_end(&errbuf);
}


parseit(line)
    char	*line;
{
    saveline = cp = text = line;
    adrlist = NULL;
    errlist = NULL;
    if (combuf.f_str == NULLSTR)
	flex_init(&combuf);
    flex_end(&combuf);
    if (errbuf.f_str == NULLSTR)
	flex_init(&errbuf);
    flex_end(&errbuf);
    (void)yyparse();
}


char *
eatcomment(s)
register char *s;
{
	register int parencount;

	parencount = 0;
	for (;;) {
		if (*s == '\\') {	/* quoted-pair */
			s++;
			if (*s == '\0')
				return ((char *)0);
			s++;
			if (*s == '\0')
				return ((char *)0);
			continue;
		}
		if (*s == '(')
			parencount++;
		else if (*s == ')')
			parencount--;

		if (parencount == 0)
			return (++s);
		else if (parencount < 0)
			panic("eatcomment botch");

		if (*++s == '\0')
			return ((char *)0);
	}
}


yylex()
{
    register char	*p;

    savecp = cp;
    while (isascii(*cp) && (isspace(*cp) || (*cp == '('))) {
	if (*cp == '(') {
	    p = eatcomment(cp);
	    if (p == (char *)0)
		return (EOF);
	    flex_nstr(&combuf, cp + 1, (p - 2) - cp);
	    flex_char(&combuf, '\0');
	    if (comstr == NULL) {
		if ((comstr = salloc((MALLOCT)(strlen(combuf.f_str) + 1))) == NULL)
		    nomem();
		Strcpy(comstr, combuf.f_str);
	    }
	    else
		comstr = newstring3(comstr, ", ", combuf.f_str);
	    flex_end(&combuf);
	    cp = p;
	}
	else
	    cp++;
    }

    if (!isascii(*cp))
	return(ERROR);

    switch (*cp) {
	case '\0':
	    if (iseol) {
		iseol = 0;
		return(EOF);
	    }
	    iseol = 1;
	    return(EOL);
	case ',':
	case ':':
	case ';':
	case '.':
	case '@':
	case '%':
	case '<':
	case '>':
	case '(':
	case ')':
	case ']':
	    yylval.yChar = *cp;
	    return(*cp++);
	case '[':       /* LIT_DOMAIN */
	    for (p = cp + 1; *p && *p != ']'; ) {
		if (*p == '\\') {
		    p++;
		    if (*p == '\0')
			return(EOF);
		}
		p++;
	    }
	    if (*p == '\0')
		return(EOF);
	    if ((yylval.yString = salloc((MALLOCT)(p - cp + 2))) == NULL)
		nomem();
	    Strncpy(yylval.yString, cp, p - cp + 1);
	    yylval.yString[p - cp + 1] = '\0';
	    cp = ++p;
	    return(LIT_DOMAIN);
	case '"':       /* QUOTED_STRING */
	    for (p = cp + 1; *p && *p != '"'; ) {
		if (*p == '\\') {
		    p++;
		    if (*p == '\0')
			return(EOF);
		}
		p++;
	    }
	    if (*p == '\0')
		return(EOF);
	    if ((yylval.yString = salloc((MALLOCT)(p - cp))) == NULL)
		nomem();
	    Strncpy(yylval.yString, cp + 1, p - cp);
	    yylval.yString[p - cp - 1] = '\0';
	    cp = ++p;
	    return(QUOTED_STRING);
    }
    for (p = cp; ; p++)
	switch (*p) {
	    case ',':
	    case ':':
	    case ';':
	    case '.':
	    case '@':
	    case '%':
	    case '<':
	    case '>':
	    case '(':
	    case ')':
	    case '[':
	    case ']':
	    case '"':
	    case '\0':
		goto out;
	    default:
		if (isspace(*p))
		    goto out;
	}
out:
    if ((yylval.yString = salloc((MALLOCT)(p - cp + 1))) == NULL)
	nomem();
    Strncpy(yylval.yString, cp, p - cp);
    yylval.yString[p - cp] = '\0';
    cp = p;
    return(ATOM);
}

/*
**  Create and initialize a new address.
*/
Addr *
newAddr()
{
    register Addr	*ap;

    if ((ap = (Addr *)salloc((MALLOCT)sizeof *ap)) == NULL)
	nomem();
    memset((char *)ap, '\0', sizeof *ap);
    return(ap);
}


/*
**  Append addresslist "addr" to addresslist "head".
*/
appAddr(head, addr)
    Addr		**head;
    Addr		 *addr;
{
    register Addr	*ap;
    register char	*p;
    register int	i;

    if (*head) {
	for (ap = *head; ap->next; ap = ap->next)
	    ;
	ap->next = addr;
    }
    else
	*head = addr;

    if (head == &adrlist)
    {
	while (isspace(*text))
	    text++;

	if (*(p = cp) != '\0')
	{
	    p--;

	    if (isspace(p[-1]))
	    {
		p--;

		while (isspace(*p))
			p--;

		p++;
	    }
	}

	if ((addr->text = salloc((MALLOCT)(p - text + 1))) == NULLSTR)
	    nomem();

	strncpy(addr->text, text, i = p - text);
	addr->text[i] = '\0';

	text = cp;
    }
    else
	addr->text = NULLSTR;
}



/*
**  Create and initialize a new domain.
*/
Dom *
newDom()
{
    register Dom	*dp;

    if ((dp = (Dom *)salloc((MALLOCT)sizeof *dp)) == NULL)
	nomem();
    memset((char *)dp, '\0', sizeof *dp);
    dp->top = dp->sub;
    return(dp);
}


/*
**  Append domainlist "dom" to domainlist "head".
*/
appDom(head, dom)
    Dom			**head;
    Dom			*dom;
{
    register Dom	*dp;

    if (*head) {
	for (dp = *head; dp->next; dp = dp->next)
	    ;
	dp->next = dom;
    }
    else
    *head = dom;
}


/*
**  Prepend domainlist "dom" before domainlist "head".
*/
prepDom(head, dom)
    Dom			**head;
    Dom			 *dom;
{
    register Dom	 *dp;

    for (dp = dom; dp->next; dp = dp->next)
	;
    dp->next = *head;
    *head = dom;
}

static void
putdom(d)
register Dom *d;
{
	register char **p;

	for (p = d->sub; p != d->top; p++)
	{
		flex_str(&f, *p);
		flex_char(&f, RFC_SPEC_DOT);
	}

	flex_str(&f, *p);
}

/*
 *	Take an Addr struct and return a textual representation that
 *	a delivery agent can use to deliver the message.
 */
char	*
make_address(a)
register Addr	*a;
{
	register Dom	*d;
	register char	*p;

	if (f.f_str == NULLSTR)
		flex_init(&f);

	d = a->route;

	while (d != (Dom *)0 && d->next != (Dom *)0)
	{
		/* source route */

		flex_char(&f, RFC_SPEC_AT);
		putdom(d);
		flex_char(&f, d->next->next ? RFC_SPEC_COMMA : RFC_SPEC_COLON);
		d = d->next;
	}

	flex_str(&f, a->localp);

	if (d != (Dom *)0)
	{
		flex_char(&f, RFC_SPEC_AT);
		putdom(d);
	}

	flex_char(&f, '\0');
	p = newstr(f.f_str);
	flex_end(&f);

	return p;
}

/*
 *	Parse a textual address list and return it as a list of Addr structs.
 *
 *	Returns NULLSTR for ok; otherwise an error string.
 */
char	*
parse_address(ap, s)
Addr	**ap;
char	*s;
{
	register Addr	*a;

	parseit(s);

	if (errlist != (Addr *)0)
	{
		for (a = errlist; a != (Addr *)0; a = a->next)
		{
			if (a->error != NULLSTR)
				return a->error;
		}

		abort("make_address");
		/* NOTREACHED */
	}

	for (a = adrlist; a != (Addr *)0; a = a->next)
	{
		if (a->localp == (char *)0 || a->localp[0] == '\0')
			return "null local-part in address";
	}

	*ap = adrlist;

	return NULLSTR;
}