#include "stralloc.h"

#include "alloc.h"

#include "str.h"

#include "token822.h"

#include "gen_allocdefs.h"

static struct token822 comma = { TOKEN822_COMMA };

void token822_reverse(ta)

token822_alloc *ta;

{

 int i;

 int n;

 struct token822 temp;

 n = ta->len - 1;

 for (i = 0;i + i < n;++i)

  {

   temp = ta->t[i];

   ta->t[i] = ta->t[n - i];

   ta->t[n - i] = temp;

  }

}

GEN_ALLOC_ready(token822_alloc,struct token822,t,len,a,i,n,x,30,token822_ready)

GEN_ALLOC_readyplus(token822_alloc,struct token822,t,len,a,i,n,x,30,token822_readyplus)

GEN_ALLOC_append(token822_alloc,struct token822,t,len,a,i,n,x,30,token822_readyplus,token822_append)

static int needspace(t1,t2)

int t1;

int t2;

{

 if (!t1) return 0;

 if (t1 == TOKEN822_COLON) return 1;

 if (t1 == TOKEN822_COMMA) return 1;

 if (t2 == TOKEN822_LEFT) return 1;

 switch(t1)

  {

   case TOKEN822_ATOM: case TOKEN822_LITERAL:

   case TOKEN822_QUOTE: case TOKEN822_COMMENT:

     switch(t2)

      {

       case TOKEN822_ATOM: case TOKEN822_LITERAL:

       case TOKEN822_QUOTE: case TOKEN822_COMMENT:

         return 1;

      }

  }

 return 0;

}

static int atomok(ch)

char ch;

{

 switch(ch)

  {

   case ' ': case '\t': case '\r': case '\n':

   case '(': case '[': case '"':

   case '<': case '>': case ';': case ':':

   case '@': case ',': case '.':

     return 0;

  }

 return 1;

}

static void atomcheck(t)

struct token822 *t;

{

 int i;

 char ch;

 for (i = 0;i < t->slen;++i)

  {

   ch = t->s[i];

   if ((ch < 32) || (ch > 126) || (ch == ')') || (ch == ']') || (ch == '\\'))

    {

     t->type = TOKEN822_QUOTE;

     return;

    }

  }

}

int token822_unparse(sa,ta,linelen)

stralloc *sa;

token822_alloc *ta;

unsigned int linelen;

{

 struct token822 *t;

 int len;

 int ch;

 int i;

 int j;

 int lasttype;

 int newtype;

 char *s;

 char *lineb;

 char *linee;

 len = 0;

 lasttype = 0;

 for (i = 0;i < ta->len;++i)

  {

   t = ta->t + i;

   newtype = t->type;

   if (needspace(lasttype,newtype))

     ++len;

   lasttype = newtype;

   switch(newtype)

    {

     case TOKEN822_COMMA:

       len += 3; break;

     case TOKEN822_AT: case TOKEN822_DOT: case TOKEN822_LEFT: case TOKEN822_RIGHT:

     case TOKEN822_SEMI: case TOKEN822_COLON:

       ++len; break;

     case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL: case TOKEN822_COMMENT:

       if (t->type != TOKEN822_ATOM) len += 2;

       for (j = 0;j < t->slen;++j)

	 switch(ch = t->s[j])

	  {

	   case '"': case '[': case ']': case '(': case ')':

	   case '\\': case '\r': case '\n': ++len;

	   default: ++len;

	  }

       break;

    }

  }

 len += 2;

 if (!stralloc_ready(sa,len))

   return -1;

 s = sa->s;

 lineb = s;

 linee = 0;

 lasttype = 0;

 for (i = 0;i < ta->len;++i)

  {

   t = ta->t + i;

   newtype = t->type;

   if (needspace(lasttype,newtype))

     *s++ = ' ';

   lasttype = newtype;

   switch(newtype)

    {

     case TOKEN822_COMMA:

       *s++ = ',';

#define NSUW \

 s[0] = '\n'; s[1] = ' '; \

 if (linee && (!linelen || (s - lineb <= linelen))) \

  { while (linee < s) { linee[0] = linee[2]; ++linee; } linee -= 2; } \

 else { if (linee) lineb = linee + 1; linee = s; s += 2; }

       NSUW

       break;

     case TOKEN822_AT: *s++ = '@'; break;

     case TOKEN822_DOT: *s++ = '.'; break;

     case TOKEN822_LEFT: *s++ = '<'; break;

     case TOKEN822_RIGHT: *s++ = '>'; break;

     case TOKEN822_SEMI: *s++ = ';'; break;

     case TOKEN822_COLON: *s++ = ':'; break;

     case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL: case TOKEN822_COMMENT:

       if (t->type == TOKEN822_QUOTE) *s++ = '"';

       if (t->type == TOKEN822_LITERAL) *s++ = '[';

       if (t->type == TOKEN822_COMMENT) *s++ = '(';

       for (j = 0;j < t->slen;++j)

	 switch(ch = t->s[j])

	  {

	   case '"': case '[': case ']': case '(': case ')':

	   case '\\': case '\r': case '\n': *s++ = '\\';

	   default: *s++ = ch;

	  }

       if (t->type == TOKEN822_QUOTE) *s++ = '"';

       if (t->type == TOKEN822_LITERAL) *s++ = ']';

       if (t->type == TOKEN822_COMMENT) *s++ = ')';

       break;

    }

  }

 NSUW

 --s;

 sa->len = s - sa->s;

 return 1;

}

int token822_unquote(sa,ta)

stralloc *sa;

token822_alloc *ta;

{

 struct token822 *t;

 int len;

 int i;

 int j;

 char *s;

 len = 0;

 for (i = 0;i < ta->len;++i)

  {

   t = ta->t + i;

   switch(t->type)

    {

     case TOKEN822_COMMA: case TOKEN822_AT: case TOKEN822_DOT: case TOKEN822_LEFT: 

     case TOKEN822_RIGHT: case TOKEN822_SEMI: case TOKEN822_COLON: 

       ++len; break;

     case TOKEN822_LITERAL:

       len += 2;

     case TOKEN822_ATOM: case TOKEN822_QUOTE:

       len += t->slen;

    }

  }

 if (!stralloc_ready(sa,len))

   return -1;

 s = sa->s;

 for (i = 0;i < ta->len;++i)

  {

   t = ta->t + i;

   switch(t->type)

    {

     case TOKEN822_COMMA: *s++ = ','; break;

     case TOKEN822_AT: *s++ = '@'; break;

     case TOKEN822_DOT: *s++ = '.'; break;

     case TOKEN822_LEFT: *s++ = '<'; break;

     case TOKEN822_RIGHT: *s++ = '>'; break;

     case TOKEN822_SEMI: *s++ = ';'; break;

     case TOKEN822_COLON: *s++ = ':'; break;

     case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL:

       if (t->type == TOKEN822_LITERAL) *s++ = '[';

       for (j = 0;j < t->slen;++j)

	 *s++ = t->s[j];

       if (t->type == TOKEN822_LITERAL) *s++ = ']';

       break;

     case TOKEN822_COMMENT: break;

    }

  }

 sa->len = s - sa->s;

 return 1;

}

int token822_parse(ta,sa,buf)

token822_alloc *ta;

stralloc *sa;

stralloc *buf;

{

 int i;

 int salen;

 int level;

 struct token822 *t;

 int numtoks;

 int numchars;

 char *cbuf;

 salen = sa->len;

 numchars = 0;

 numtoks = 0;

 for (i = 0;i < salen;++i)

   switch(sa->s[i])

    {

     case '.': case ',': case '@': case '<': case '>': case ':': case ';':

       ++numtoks; break;

     case ' ': case '\t': case '\r': case '\n': break;

     case ')': case ']': return 0;

     /* other control chars and non-ASCII chars are also bad, in theory */

     case '(':

       level = 1;

       while (level)

	{

	 if (++i >= salen) return 0;

	 switch(sa->s[i])

	  {

	   case '(': ++level; break;

	   case ')': --level; break;

	   case '\\': if (++i >= salen) return 0;

	   default: ++numchars;

	  }

	}

       ++numtoks;

       break;

     case '"':

       level = 1;

       while (level)

	{

	 if (++i >= salen) return 0;

	 switch(sa->s[i])

	  {

	   case '"': --level; break;

	   case '\\': if (++i >= salen) return 0;

	   default: ++numchars;

	  }

	}

       ++numtoks;

       break;

     case '[':

       level = 1;

       while (level)

	{

	 if (++i >= salen) return 0;

	 switch(sa->s[i])

	  {

	   case ']': --level; break;

	   case '\\': if (++i >= salen) return 0;

	   default: ++numchars;

	  }

	}

       ++numtoks;

       break;

     default:

       do

	{

	 if (sa->s[i] == '\\') if (++i >= salen) break;

	 ++numchars;

	 if (++i >= salen)

	   break;

	}

       while (atomok(sa->s[i]));

       --i;

       ++numtoks;

    }

 if (!token822_ready(ta,numtoks))

   return -1;

 if (!stralloc_ready(buf,numchars))

   return -1;

 cbuf = buf->s;

 ta->len = numtoks;

 t = ta->t;

 for (i = 0;i < salen;++i)

   switch(sa->s[i])

    {

     case '.': t->type = TOKEN822_DOT; ++t; break;

     case ',': t->type = TOKEN822_COMMA; ++t; break;

     case '@': t->type = TOKEN822_AT; ++t; break;

     case '<': t->type = TOKEN822_LEFT; ++t; break;

     case '>': t->type = TOKEN822_RIGHT; ++t; break;

     case ':': t->type = TOKEN822_COLON; ++t; break;

     case ';': t->type = TOKEN822_SEMI; ++t; break;

     case ' ': case '\t': case '\r': case '\n': break;

     case '(':

       t->type = TOKEN822_COMMENT; t->s = cbuf; t->slen = 0;

       level = 1;

       while (level)

	{

	 ++i; /* assert: < salen */

	 switch(sa->s[i])

	  {

	   case '(': ++level; break;

	   case ')': --level; break;

	   case '\\': ++i; /* assert: < salen */

	   default: *cbuf++ = sa->s[i]; ++t->slen;

	  }

	}

       ++t;

       break;

     case '"':

       t->type = TOKEN822_QUOTE; t->s = cbuf; t->slen = 0;

       level = 1;

       while (level)

	{

	 ++i; /* assert: < salen */

	 switch(sa->s[i])

	  {

	   case '"': --level; break;

	   case '\\': ++i; /* assert: < salen */

	   default: *cbuf++ = sa->s[i]; ++t->slen;

	  }

	}

       ++t;

       break;

     case '[':

       t->type = TOKEN822_LITERAL; t->s = cbuf; t->slen = 0;

       level = 1;

       while (level)

	{

	 ++i; /* assert: < salen */

	 switch(sa->s[i])

	  {

	   case ']': --level; break;

	   case '\\': ++i; /* assert: < salen */

	   default: *cbuf++ = sa->s[i]; ++t->slen;

	  }

	}

       ++t;

       break;

     default:

       t->type = TOKEN822_ATOM; t->s = cbuf; t->slen = 0;

       do

	{

	 if (sa->s[i] == '\\') if (++i >= salen) break;

	 *cbuf++ = sa->s[i]; ++t->slen;

	 if (++i >= salen)

	   break;

	}

       while (atomok(sa->s[i]));

       atomcheck(t);

       --i;

       ++t;

    }

 return 1;

}

static int gotaddr(taout,taaddr,callback)

token822_alloc *taout;

token822_alloc *taaddr;

int (*callback)();

{

 int i;

 if (callback(taaddr) != 1)

   return 0;

 if (!token822_readyplus(taout,taaddr->len))

   return 0;

 for (i = 0;i < taaddr->len;++i)

   taout->t[taout->len++] = taaddr->t[i];

 taaddr->len = 0;

 return 1;

}

int token822_addrlist(taout,taaddr,ta,callback)

token822_alloc *taout;

token822_alloc *taaddr;

token822_alloc *ta;

int (*callback)();

{

 struct token822 *t;

 struct token822 *beginning;

 int ingroup;

 int wordok;

 taout->len = 0;

 taaddr->len = 0;

 if (!token822_readyplus(taout,1)) return -1;

 if (!token822_readyplus(taaddr,1)) return -1;

 ingroup = 0;

 wordok = 1;

 beginning = ta->t + 2;

 t = ta->t + ta->len - 1;

 /* rfc 822 address lists are easy to parse from right to left */

#define FLUSH if (taaddr->len) if (!gotaddr(taout,taaddr,callback)) return -1;

#define FLUSHCOMMA if (taaddr->len) { \

if (!gotaddr(taout,taaddr,callback)) return -1; \

if (!token822_append(taout,&comma)) return -1; }

#define ADDRLEFT if (!token822_append(taaddr,t--)) return -1;

#define OUTLEFT if (!token822_append(taout,t--)) return -1;

 while (t >= beginning)

  {

   switch(t->type)

    {

     case TOKEN822_SEMI:

       FLUSHCOMMA

       if (ingroup) return 0;

       ingroup = 1;

       wordok = 1;

       break;

     case TOKEN822_COLON:

       FLUSH

       if (!ingroup) return 0;

       ingroup = 0;

       while ((t >= beginning) && (t->type != TOKEN822_COMMA))

	 OUTLEFT

       if (t >= beginning)

	 OUTLEFT

       wordok = 1;

       continue;

     case TOKEN822_RIGHT:

       FLUSHCOMMA

       OUTLEFT

       while ((t >= beginning) && (t->type != TOKEN822_LEFT))

	 ADDRLEFT

       /* important to use address here even if it's empty: <> */

       if (!gotaddr(taout,taaddr,callback)) return -1;

       if (t < beginning) return 0;

       OUTLEFT

       while ((t >= beginning) && ((t->type == TOKEN822_COMMENT) || (t->type == TOKEN822_ATOM) || (t->type == TOKEN822_QUOTE) || (t->type == TOKEN822_AT) || (t->type == TOKEN822_DOT)))

	 OUTLEFT

       wordok = 0;

       continue;

     case TOKEN822_ATOM: case TOKEN822_QUOTE: case TOKEN822_LITERAL:

       if (!wordok)

	 FLUSHCOMMA

       wordok = 0;

       ADDRLEFT

       continue;

     case TOKEN822_COMMENT:

       /* comment is lexically a space; shouldn't affect wordok */

       break;

     case TOKEN822_COMMA:

       FLUSH

       wordok = 1;

       break;

     default:

       wordok = 1;

       ADDRLEFT

       continue;

    }

   OUTLEFT

  }

 FLUSH

 ++t;

 while (t > ta->t)

   if (!token822_append(taout,--t)) return -1;

 token822_reverse(taout);

 return 1;

}