/***********************************************************************

*                                                                      *

*               This software is part of the ast package               *

*          Copyright (c) 1985-2012 AT&T Intellectual Property          *

*                      and is licensed under the                       *

*                 Eclipse Public License, Version 1.0                  *

*                    by AT&T Intellectual Property                     *

*                                                                      *

*                A copy of the License is available at                 *

*          http://www.eclipse.org/org/documents/epl-v10.html           *

*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *

*                                                                      *

*              Information and Software Systems Research               *

*                            AT&T Research                             *

*                           Florham Park NJ                            *

*                                                                      *

*                 Glenn Fowler <gsf@research.att.com>                  *

*                  David Korn <dgk@research.att.com>                   *

*                   Phong Vo <kpv@research.att.com>                    *

*                                                                      *

***********************************************************************/

#pragma prototyped

/*

 * Glenn Fowler

 * AT&T Research

 *

 * generate a license comment -- see proto(1)

 *

 * NOTE: coded for minimal library dependence

 *	 not so for the legal department

 */

#ifndef	_PPLIB_H

#include <ast.h>

#include <time.h>

#endif

#ifndef O_cloexec

#ifdef	O_CLOEXEC

#define O_cloexec		0

#else

#define O_cloexec		0

#endif

#endif

#undef	copy

#undef	BSD			/* guess who defines this */

#undef	END

#undef	INLINE

#undef	TEST

#undef	VERBOSE

#define NONE			0

#define INLINE			1

#define TEST			2

#define VERBOSE			3

#define USAGE			4

#define OPEN			5

#define CPL			6

#define EPL			7

#define BSD			8

#define ZLIB			9

#define MIT			10

#define GPL			11

#define SPECIAL			12

#define NONEXCLUSIVE		13

#define NONCOMMERCIAL		14

#define PROPRIETARY		15

#define AUTHOR			0

#define CLASS			1

#define COMPANY			2

#define COMPONENT		3

#define CONTRIBUTOR		4

#define CORPORATION		5

#define DOMAIN			6

#define ID			7

#define INCORPORATION		8

#define LICENSE			9

#define LOCATION		10

#define NAME			11

#define NOTICE			12

#define ORGANIZATION		13

#define PACKAGE			14

#define PARENT			15

#define QUERY			16

#define SINCE			17

#define SOURCE			18

#define START			19

#define STYLE			20

#define URL			21

#define URLMD5			22

#define VERSION			23

#define IDS			64

#define COMDATA			70

#define COMLINE			(COMDATA+4)

#define COMLONG			(COMDATA-32)

#define COMMENT(x,b,s,u)	comment(x,b,s,sizeof(s)-1,u)

#define PUT(b,c)		(((b)->nxt<(b)->end)?(*(b)->nxt++=(c)):((c),(-1)))

#define BUF(b)			((b)->buf)

#define USE(b)			((b)->siz=(b)->nxt-(b)->buf,(b)->nxt=(b)->buf,(b)->siz)

#define SIZ(b)			((b)->nxt-(b)->buf)

#define END(b)			(*((b)->nxt>=(b)->end?((b)->nxt=(b)->end-1):(b)->nxt)=0,(b)->nxt-(b)->buf)

#ifndef NiL

#define NiL			((char*)0)

#endif

typedef struct Buffer_s

{

	char*		buf;

	char*		nxt;

	char*		end;

	int		siz;

} Buffer_t;

typedef struct Item_s

{

	char*		data;

	int		size;

	int		quote;

} Item_t;

typedef struct Id_s

{

	Item_t		name;

	Item_t		value;

} Id_t;

/*

 * NOTE: key[] element order must match the corresponding macro

 */

#define KEY(s)			{s,sizeof(s)-1,0}

static const Item_t	key[] =

{

	KEY("author"),

	KEY("class"),

	KEY("company"),

	KEY("component"),

	KEY("contributor"),

	KEY("corporation"),

	KEY("domain"),

	KEY("id"),

	KEY("incorporation"),

	KEY("license"),

	KEY("location"),

	KEY("name"),

	KEY("notice"),

	KEY("organization"),

	KEY("package"),

	KEY("parent"),

	KEY("query"),

	KEY("since"),

	KEY("source"),

	KEY("start"),

	KEY("type"),

	KEY("url"),

	KEY("urlmd5"),

	KEY("version"),

	{0}

};

#define ITEMS			(sizeof(key)/sizeof(key[0])-1)

#define LIC(s,c)		{s,sizeof(s)-1,c}

static const Item_t	lic[] =

{

	LIC("none", NONE),

	LIC("inline", SPECIAL),

	LIC("test", TEST),

	LIC("verbose", VERBOSE),

	LIC("usage", USAGE),

	LIC("open", OPEN),

	LIC("cpl", OPEN),

	LIC("epl", OPEN),

	LIC("bsd", OPEN),

	LIC("zlib", OPEN),

	LIC("mit", OPEN),

	LIC("gpl", GPL),

	LIC("special", SPECIAL),

	LIC("nonexclusive", SPECIAL),

	LIC("noncommercial", SPECIAL),

	LIC("proprietary", PROPRIETARY),

	{0}

};

typedef struct Notice_s

{

	int		test;

	int		type;

	int		verbose;

	int		ids;

	Item_t		item[ITEMS];

	Id_t		id[IDS];

	char		cc[3];

} Notice_t;

/*

 * return index given <name,size>

 */

static int

lookup(register const Item_t* item, const char* name, int size)

{

	register int	c;

	register int	i;

	c = name[0];

	for (i = 0; item[i].data; i++)

		if (c == item[i].data[0] && size == item[i].size && !strncmp(name, item[i].data, size))

			return i;

	return -1;

}

/*

 * copy s of size n to b

 * n<0 means 0 terminated string

 */

static void

copy(register Buffer_t* b, register char* s, int n)

{

	if (n < 0)

		n = strlen(s);

	while (n--)

		PUT(b, *s++);

}

/*

 * center and copy comment line s to p

 * if s==0 then

 *	n>0	first frame line

 *	n=0	blank line

 *	n<0	last frame line

 * if u>0 then s converted to upper case

 * if u<0 then s is left justified

 */

static void

comment(Notice_t* notice, register Buffer_t* b, register char* s, register int n, int u)

{

	register int	i;

	register int	m;

	register int	x;

	int		cc;

	cc = notice->cc[1];

	if (!s)

	{

		if (n)

		{

			PUT(b, notice->cc[n > 0 ? 0 : 1]);

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

				PUT(b, cc);

			PUT(b, notice->cc[n > 0 ? 1 : 2]);

		}

		else

			s = "";

	}

	if (s)

	{

		if (n > COMDATA)

			n = COMDATA;

		PUT(b, cc);

		m = (u < 0) ? 1 : (COMDATA - n) / 2;

		if ((x = COMDATA - m - n) < 0)

			n--;

		while (m-- > 0)

			PUT(b, ' ');

		while (n-- > 0)

		{

			i = *s++;

			if (u > 0 && i >= 'a' && i <= 'z')

				i = i - 'a' + 'A';

			PUT(b, i);

		}

		while (x-- > 0)

			PUT(b, ' ');

		PUT(b, cc);

	}

	PUT(b, '\n');

}

/*

 * expand simple ${...}

 */

static void

expand(Notice_t* notice, register Buffer_t* b, const Item_t* item)

{

	register char*	t;

	register char*	e;

	register int	q;

	register char*	x;

	register char*	z;

	register int	c;

	int		m;

	int		i;

	int		k;

	if (t = item->data)

	{

		q = item->quote;

		e = t + item->size;

		i = 0;

		while (t < e)

		{

			if (*t == '$' && t < (e + 2) && *(t + 1) == '{')

			{

				k = m = 0;

				x = t += 2;

				while (t < e && (c = *t++) != '}')

					if (c == '.')

						x = t;

					else if (c == '-')

					{

						k = 1;

						break;

					}

					else if (c == '/')

					{

						m = 1;

						break;

					}

				if ((c = lookup(key, x, t - x - 1)) >= 0 && (x = notice->item[c].data))

				{

					z = x + notice->item[c].size;

					while (x < z)

					{

						c = *x++;

						if (!m || c >= '0' && c <= '9')

							PUT(b, c);

					}

				}

				else if (k)

				{

					k = 0;

					i++;

				}

				if (k || m)

				{

					k = 1;

					while (t < e)

						if ((c = *t++) == '{')

							k++;

						else if (c == '}' && !--k)

							break;

				}

			}

			else if (q > 0 && *t == '\\' && (*(t + 1) == q || *(t + 1) == '\\'))

				t++;

			else if (*t == '}' && i)

			{

				t++;

				i--;

			}

			else

				PUT(b, *t++);

		}

	}

}

/*

 * generate a copright notice

 */

static void

copyright(Notice_t* notice, register Buffer_t* b)

{

	register char*	x;

	register char*	t;

	time_t		clock;

	copy(b, "Copyright (c) ", -1);

	if (notice->test)

	{

		clock = (time_t)1000212300;

		t = ctime(&clock) + 20;

	}

	else if (!(t = notice->item[SOURCE].data))

	{

		time(&clock);

		t = ctime(&clock) + 20;

	}

	if ((x = notice->item[START].data) && strncmp(t, x, 4) < 0)

		t = x;

	if ((x = notice->item[SINCE].data) && strncmp(x, t, 4) < 0)

	{

		expand(notice, b, &notice->item[SINCE]);

		PUT(b, '-');

	}

	copy(b, t, 4);

	if (notice->item[PARENT].data)

	{

		PUT(b, ' ');

		expand(notice, b, &notice->item[PARENT]);

	}

	if (notice->item[CORPORATION].data)

	{

		PUT(b, ' ');

		expand(notice, b, &notice->item[CORPORATION]);

		if (notice->item[INCORPORATION].data)

		{

			PUT(b, ' ');

			expand(notice, b, &notice->item[INCORPORATION]);

		}

	}

	else if (notice->item[COMPANY].data)

	{

		PUT(b, ' ');

		expand(notice, b, &notice->item[COMPANY]);

	}

}

typedef struct Stack_s

{

	char*	info;

	char*	file;

	int	line;

	int	size;

} Stack_t;

static int

push(Stack_t* sp, char* file, char* parent, char* info, int size, Buffer_t* buf)

{

	char*		s;

	char*		t;

	int		i;

	int		n;

	char		path[1024];

	if (size <= 8)

	{

		copy(buf, file, -1);

		copy(buf, ": no space", -1);

		PUT(buf, 0);

		return -1;

	}

	if (*file != '/' && parent && (s = strrchr(parent, '/')))

	{

		n = s - parent + 1;

		if ((strlen(file) + n + 1) <= sizeof(path))

		{

			memcpy(path, parent, n);

			strcpy(path + n, file);

			file = path;

		}

	}

	if ((i = open(file, O_RDONLY|O_cloexec)) < 0)

	{

		/* this hack viewpath lookup works for default package setups */

		if (file == path)

			for (s = path; *s; s++)

				if (s[0] == '/' && s[1] == 'a' && s[2] == 'r' && s[3] == 'c' && s[4] == 'h' && s[5] == '/')

				{

					t = s;

					for (s += 6; *s && *s != '/'; s++);

					while (*t++ = *s++);

					i = open(file, O_RDONLY|O_cloexec);

				}

		if (i < 0)

		{

			copy(buf, file, -1);

			copy(buf, ": cannot open", -1);

			PUT(buf, 0);

			return -1;

		}

	}

	n = read(i, info, size - 1);

	close(i);

	if (n < 0)

	{

		copy(buf, file, -1);

		copy(buf, ": cannot read", -1);

		PUT(buf, 0);

		return -1;

	}

	info[n++] = 0;

	sp->file = file;

	sp->info = info;

	sp->line = 0;

	sp->size = n;

	return 0;

}

/*

 * read the license file and generate a comment in p, length size

 * license length in p returned, -1 on error

 * -1 return places 0 terminated error string in p

 */

int

astlicense(char* p, int size, char* file, char* options, int cc1, int cc2, int cc3)

{

	register char*	s;

	register char*	v;

	register char*	x;

	register int	c;

	int		i;

	int		h;

	int		k;

	int		n;

	int		q;

	int		contributor;

	int		first;

	int		level;

	int		quote;

	char*		data;

	char		tmpbuf[COMLINE];

	char		info[8 * 1024];

	Stack_t		input[4];

	Notice_t	notice;

	Item_t		item;

	Buffer_t	buf;

	Buffer_t	tmp;

	buf.end = (buf.buf = buf.nxt = p) + size;

	tmp.end = (tmp.buf = tmp.nxt = tmpbuf) + sizeof(tmpbuf);

	level = 0;

	data = info;

	level = -1;

	if (options)

	{

		level++;

		input[level].file = "<options>";

		input[level].info = options;

		input[level].line = 0;

	}

	if (file && *file)

	{

		if (push(&input[++level], file, 0, data, &info[sizeof(info)] - data, &buf))

			return -1;

		data += input[level].size;

	}

	if (level < 0)

		return 0;

	s = input[level].info;

	notice.test = 0;

	notice.type = NONE;

	notice.verbose = 0;

	notice.ids = 0;

	notice.cc[0] = cc1;

	notice.cc[1] = cc2;

	notice.cc[2] = cc3;

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

		notice.item[i].data = 0;

	notice.item[STYLE] = notice.item[CLASS] = lic[notice.type];

	notice.item[STYLE].quote = notice.item[CLASS].quote = 0;

	contributor = i = k = 0;

	for (;;)

	{

		first = 1;

		while (c = *s)

		{

			while (c == ' ' || c == '\t' || c == '\n' && ++input[level].line || c == '\r' || c == ',' || c == ';' || c == ')')

				c = *++s;

			if (!c)

				break;

			if (c == '#')

			{

				while (*++s && *s != '\n');

				if (*s)

					s++;

				input[level].line++;

				continue;

			}

			if (c == '.')

			{

				while ((c = *++s) && (c == ' ' || c == '\t'));

				file = s;

				while (c && c != ' ' && c != '\t' && c != '\r' && c != '\n')

					c = *++s;

				*s = 0;

				while (c && c != '\n')

					c = *++s;

				if (*file)

				{

					input[level].info = s + (c != 0);

					if (++level >= (sizeof(input) / sizeof(input[0])) || push(&input[level], file, input[level-1].file, data, &info[sizeof(info)] - data, &buf))

						return -1;

					data += input[level].size;

					s = input[level].info;

				}

				continue;

			}

			if (c == '\n')

			{

				s++;

				input[level].line++;

				continue;

			}

			if (c == '[')

				c = *++s;

			x = s;

			n = 0;

			while (c && c != '+' && c != '=' && c != ']' && c != ')' && c != ',' && c != ' ' && c != '\t' && c != '\n' && c != '\r')

				c = *++s;

			n = s - x;

			h = lookup(key, x, n);

			if (c == '+' || c == ']')

				c = *++s;

			quote = 0;

			if (c == '=' || first)

			{

				if (c == '=')

				{

					q = ((c = *++s) == '"' || c == '\'') ? *s++ : 0;

					if (c == '(')

					{

						s++;

						if (h == LICENSE)

							contributor = 0;

						else if (h == CONTRIBUTOR)

							contributor = 1;

						else

						{

							q = 1;

							i = 0;

							for (;;)

							{

								switch (*s++)

								{

								case 0:

									s--;

									break;

								case '(':

									if (!i)

										q++;

									continue;

								case ')':

									if (!i && !--q)

										break;

									continue;

								case '"':

								case '\'':

									if (!i)

										i = *(s - 1);

									else if (i == *(s - 1))

										i = 0;

									continue;

								case '\\':

									if (*s == i && i == '"')

										i++;

									continue;

								case '\n':

									input[level].line++;

									continue;

								default:

									continue;

								}

								break;

							}

						}

						continue;

					}

					v = s;

					while ((c = *s) && (q == '"' && (c == '\\' && (*(s + 1) == '"' || *(s + 1) == '\\') && s++ && (quote = q)) || q && c != q || !q && c != ' ' && c != '\t' && c != '\n' && c != '\r' && c != ',' && c != ';'))

					{

						if (c == '\n')

							input[level].line++;

						s++;

					}

				}

				else

				{

					h = STYLE;

					v = x;

				}

				if (c == '\n')

					input[level].line++;

				if (contributor)

				{

					for (i = 0; i < notice.ids; i++)

						if (n == notice.id[i].name.size && !strncmp(x, notice.id[i].name.data, n))

							break;

					if (i < IDS)

					{

						notice.id[i].name.data = x;

						notice.id[i].name.size = n;

						notice.id[i].name.quote = 0;

						notice.id[i].value.data = v;

						notice.id[i].value.size = s - v;

						notice.id[i].value.quote = quote;

						if (notice.ids <= i)

							notice.ids = i + 1;

					}

				}

				else if (h == QUERY)

				{

					if ((s - v) == 3 && v[0] == 'a' && v[1] == 'l' && v[2] == 'l')

					{

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

							if (notice.item[i].size)

							{

								expand(&notice, &buf, &key[i]);

								PUT(&buf, '=');

								for (h = 0;; h++)

									if (h >= notice.item[i].size)

									{

										h = 0;

										break;

									}

									else if (notice.item[i].data[h] == ' ' || notice.item[i].data[h] == '\t')

										break;

								if (h)

									PUT(&buf, '\'');

								expand(&notice, &buf, &notice.item[i]);

								if (h)

									PUT(&buf, '\'');

								PUT(&buf, '\n');

							}

					}

					else

					{

						if ((h = lookup(key, v, s - v)) < 0)

						{

							item.data = v;

							item.size = s - v;

							item.quote = 0;

							expand(&notice, &buf, &item);

						}

						else

							expand(&notice, &buf, &notice.item[h]);

						PUT(&buf, '\n');

					}

					return END(&buf;;

				}

				else

				{

					if (h == STYLE)

						switch (c = lookup(lic, v, s - v))

						{

						case NONE:

							return 0;

						case TEST:

							notice.test = 1;

							h = -1;

							break;

						case VERBOSE:

							notice.verbose = 1;

							h = -1;

							break;

						case USAGE:

							notice.type = c;

							h = -1;

							break;

						case -1:

							c = SPECIAL;

							/*FALLTHROUGH*/

						default:

							notice.type = c;

							notice.item[CLASS].data = lic[lic[c].quote].data;

							notice.item[CLASS].size = lic[lic[c].quote].size;

							if (notice.item[STYLE].data != lic[NONE].data)

								h = -1;

							break;

						}

					if (h >= 0)

					{

						notice.item[h].data = (notice.item[h].size = s - v) ? v : (char*)0;

						notice.item[h].quote = quote;

						k = 1;

					}

				}

			}

			else

			{

				if (input[level].file)

				{

					copy(&buf, "\"", -1);

					copy(&buf, input[level].file, -1);

					copy(&buf, "\", line ", -1);

					x = &tmpbuf[sizeof(tmpbuf)];

					*--x = 0;

					n = ++input[level].line;

					do *--x = ("0123456789")[n % 10]; while (n /= 10);

					copy(&buf, x, -1);

					copy(&buf, ": ", -1);

				}

				copy(&buf, "option error: assignment expected", -1);

				PUT(&buf, 0);

				return -1;

			}

			if (*s)

				s++;

			first = 0;

		}

		if (!level--)

			break;

		s = input[level].info;

	}

	if (!k)

		return 0;

	if (notice.type == INLINE && (!notice.verbose || !notice.item[NOTICE].data))

		return 0;

	if (notice.type != USAGE)

	{

		if (!notice.type)

			notice.type = SPECIAL;

		comment(&notice, &buf, NiL, 1, 0);

		comment(&notice, &buf, NiL, 0, 0);

		if (notice.item[PACKAGE].data)

		{

			copy(&tmp, "This software is part of the ", -1);

			expand(&notice, &tmp, &notice.item[PACKAGE]);

			copy(&tmp, " package", -1);

			comment(&notice, &buf, BUF(&tmp), USE(&tmp), 0);

		}

		if (notice.type >= OPEN)

		{

			copyright(&notice, &tmp);

			comment(&notice, &buf, BUF(&tmp), USE(&tmp), 0);

			if (notice.type >= SPECIAL)

				COMMENT(&notice, &buf, "All Rights Reserved", 0);

		}

		if (notice.type == CPL || notice.type == EPL)

		{

			copy(&tmp, notice.item[PACKAGE].data ? "and" : "This software", -1);

			copy(&tmp, " is licensed under the", -1);

			comment(&notice, &buf, BUF(&tmp), USE(&tmp), 0);

			if (notice.type == EPL)

				copy(&tmp, "Eclipse Public License", -1);

			else

				copy(&tmp, "Common Public License", -1);

			if (notice.item[VERSION].data)

			{

				copy(&tmp, ", Version ", -1);

				expand(&notice, &tmp, &notice.item[VERSION]);

			}

			comment(&notice, &buf, BUF(&tmp), USE(&tmp), 0);

			if (notice.item[CORPORATION].data || notice.item[COMPANY].data)

			{

				copy(&tmp, "by ", -1);

				if (notice.item[PARENT].data)

				{

					expand(&notice, &tmp, &notice.item[PARENT]);

					copy(&tmp, " ", -1);

				}

				if (notice.item[CORPORATION].data)

				{

					expand(&notice, &tmp, &notice.item[CORPORATION]);

					if (notice.item[INCORPORATION].data)

					{

						copy(&tmp, " ", -1);

						expand(&notice, &tmp, &notice.item[INCORPORATION]);

					}

				}

				else if (notice.item[COMPANY].data)

					expand(&notice, &tmp, &notice.item[COMPANY]);

				comment(&notice, &buf, BUF(&tmp), USE(&tmp), 0);

			}

			comment(&notice, &buf, NiL, 0, 0);

			COMMENT(&notice, &buf, "A copy of the License is available at", 0);

			if (notice.item[URL].data)

			{

				expand(&notice, &tmp, &notice.item[URL]);

				comment(&notice, &buf, BUF(&tmp), USE(&tmp), 0);

				if (notice.item[URLMD5].data)

				{

					copy(&tmp, "(with md5 checksum ", -1);

					expand(&notice, &tmp, &notice.item[URLMD5]);

					copy(&tmp, ")", -1);

					comment(&notice, &buf, BUF(&tmp), USE(&tmp), 0);

				}

			}

			else if (notice.type == EPL)

				COMMENT(&notice, &buf, "http://www.eclipse.org/org/documents/epl-v10.html", 0);

			else

				COMMENT(&notice, &buf, "http://www.opensource.org/licenses/cpl", 0);

			comment(&notice, &buf, NiL, 0, 0);

		}

		else if (notice.type == OPEN)