move flex program sources into src/ directory

The *.[chly] sources are now in the src directory. This implies a
bunch of changes in Makefile.am and friends to account for the new
location. The .gitignore files are now more local to places where various object files and generated source files occur.

1 files changed, 502 insertions, 0 deletions

diff --git a/src/tables.c b/src/tables.c
new file mode 100644
index 0000000..f3f056f
--- /dev/null
+++ b/src/tables.c
@@ -0,0 +1,502 @@
+/*  tables.c - tables serialization code
+ *
+ *  Copyright (c) 1990 The Regents of the University of California.
+ *  All rights reserved.
+ *
+ *  This code is derived from software contributed to Berkeley by
+ *  Vern Paxson.
+ *
+ *  The United States Government has rights in this work pursuant
+ *  to contract no. DE-AC03-76SF00098 between the United States
+ *  Department of Energy and the University of California.
+ *
+ *  This file is part of flex.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *  Neither the name of the University nor the names of its contributors
+ *  may be used to endorse or promote products derived from this software
+ *  without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ *  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE.
+ */
+
+
+#include "flexdef.h"
+#include "tables.h"
+
+/** Convert size_t to t_flag.
+ *  @param n in {1,2,4}
+ *  @return YYTD_DATA*. 
+ */
+#define BYTES2TFLAG(n)\
+    (((n) == sizeof(flex_int8_t))\
+        ? YYTD_DATA8\
+        :(((n)== sizeof(flex_int16_t))\
+            ? YYTD_DATA16\
+            : YYTD_DATA32))
+
+/** Clear YYTD_DATA* bit flags
+ * @return the flag with the YYTD_DATA* bits cleared
+ */
+#define TFLAGS_CLRDATA(flg) ((flg) & ~(YYTD_DATA8 | YYTD_DATA16 | YYTD_DATA32))
+
+int     yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v);
+int     yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v);
+int     yytbl_write8 (struct yytbl_writer *wr, flex_uint8_t v);
+int     yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len);
+static flex_int32_t yytbl_data_geti (const struct yytbl_data *tbl, int i);
+/* XXX Not used
+static flex_int32_t yytbl_data_getijk (const struct yytbl_data *tbl, int i,
+				  int j, int k);
+ */
+
+
+/** Initialize the table writer.
+ *  @param wr an uninitialized writer
+ *  @param the output file
+ *  @return 0 on success
+ */
+int yytbl_writer_init (struct yytbl_writer *wr, FILE * out)
+{
+	wr->out = out;
+	wr->total_written = 0;
+	return 0;
+}
+
+/** Initialize a table header.
+ *  @param th  The uninitialized structure
+ *  @param version_str the  version string
+ *  @param name the name of this table set
+ */
+int yytbl_hdr_init (struct yytbl_hdr *th, const char *version_str,
+		    const char *name)
+{
+	memset (th, 0, sizeof (struct yytbl_hdr));
+
+	th->th_magic = YYTBL_MAGIC;
+	th->th_hsize = 14 + strlen (version_str) + 1 + strlen (name) + 1;
+	th->th_hsize += yypad64 (th->th_hsize);
+	th->th_ssize = 0;	// Not known at this point.
+	th->th_flags = 0;
+	th->th_version = copy_string (version_str);
+	th->th_name = copy_string (name);
+	return 0;
+}
+
+/** Allocate and initialize a table data structure.
+ *  @param tbl a pointer to an uninitialized table
+ *  @param id  the table identifier
+ *  @return 0 on success
+ */
+int yytbl_data_init (struct yytbl_data *td, enum yytbl_id id)
+{
+
+	memset (td, 0, sizeof (struct yytbl_data));
+	td->td_id = id;
+	td->td_flags = YYTD_DATA32;
+	return 0;
+}
+
+/** Clean up table and data array.
+ *  @param td will be destroyed
+ *  @return 0 on success
+ */
+int yytbl_data_destroy (struct yytbl_data *td)
+{
+	if (td->td_data)
+		free (td->td_data);
+	td->td_data = 0;
+	free (td);
+	return 0;
+}
+
+/** Write enough padding to bring the file pointer to a 64-bit boundary. */
+static int yytbl_write_pad64 (struct yytbl_writer *wr)
+{
+	int     pad, bwritten = 0;
+
+	pad = yypad64 (wr->total_written);
+	while (pad-- > 0)
+		if (yytbl_write8 (wr, 0) < 0)
+			return -1;
+		else
+			bwritten++;
+	return bwritten;
+}
+
+/** write the header.
+ *  @param out the output stream
+ *  @param th table header to be written
+ *  @return -1 on error, or bytes written on success.
+ */
+int yytbl_hdr_fwrite (struct yytbl_writer *wr, const struct yytbl_hdr *th)
+{
+	int  sz, rv;
+	int     bwritten = 0;
+
+	if (yytbl_write32 (wr, th->th_magic) < 0
+	    || yytbl_write32 (wr, th->th_hsize) < 0)
+		flex_die (_("th_magic|th_hsize write32 failed"));
+	bwritten += 8;
+
+	if (fgetpos (wr->out, &(wr->th_ssize_pos)) != 0)
+		flex_die (_("fgetpos failed"));
+
+	if (yytbl_write32 (wr, th->th_ssize) < 0
+	    || yytbl_write16 (wr, th->th_flags) < 0)
+		flex_die (_("th_ssize|th_flags write failed"));
+	bwritten += 6;
+
+	sz = strlen (th->th_version) + 1;
+	if ((rv = yytbl_writen (wr, th->th_version, sz)) != sz)
+		flex_die (_("th_version writen failed"));
+	bwritten += rv;
+
+	sz = strlen (th->th_name) + 1;
+	if ((rv = yytbl_writen (wr, th->th_name, sz)) != sz)
+		flex_die (_("th_name writen failed"));
+	bwritten += rv;
+
+	/* add padding */
+	if ((rv = yytbl_write_pad64 (wr)) < 0)
+		flex_die (_("pad64 failed"));
+	bwritten += rv;
+
+	/* Sanity check */
+	if (bwritten != (int) th->th_hsize)
+		flex_die (_("pad64 failed"));
+
+	return bwritten;
+}
+
+
+/** Write this table.
+ *  @param out the file writer
+ *  @param td table data to be written
+ *  @return -1 on error, or bytes written on success.
+ */
+int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td)
+{
+	int  rv;
+	flex_int32_t bwritten = 0;
+	flex_int32_t i, total_len;
+	fpos_t  pos;
+
+	if ((rv = yytbl_write16 (wr, td->td_id)) < 0)
+		return -1;
+	bwritten += rv;
+
+	if ((rv = yytbl_write16 (wr, td->td_flags)) < 0)
+		return -1;
+	bwritten += rv;
+
+	if ((rv = yytbl_write32 (wr, td->td_hilen)) < 0)
+		return -1;
+	bwritten += rv;
+
+	if ((rv = yytbl_write32 (wr, td->td_lolen)) < 0)
+		return -1;
+	bwritten += rv;
+
+	total_len = yytbl_calc_total_len (td);
+	for (i = 0; i < total_len; i++) {
+		switch (YYTDFLAGS2BYTES (td->td_flags)) {
+		case sizeof (flex_int8_t):
+			rv = yytbl_write8 (wr, yytbl_data_geti (td, i));
+			break;
+		case sizeof (flex_int16_t):
+			rv = yytbl_write16 (wr, yytbl_data_geti (td, i));
+			break;
+		case sizeof (flex_int32_t):
+			rv = yytbl_write32 (wr, yytbl_data_geti (td, i));
+			break;
+		default:
+			flex_die (_("invalid td_flags detected"));
+		}
+		if (rv < 0) {
+			flex_die (_("error while writing tables"));
+			return -1;
+		}
+		bwritten += rv;
+	}
+
+	/* Sanity check */
+	if (bwritten != (int) (12 + total_len * YYTDFLAGS2BYTES (td->td_flags))) {
+		flex_die (_("insanity detected"));
+		return -1;
+	}
+
+	/* add padding */
+	if ((rv = yytbl_write_pad64 (wr)) < 0) {
+		flex_die (_("pad64 failed"));
+		return -1;
+	}
+	bwritten += rv;
+
+	/* Now go back and update the th_hsize member */
+	if (fgetpos (wr->out, &pos) != 0
+	    || fsetpos (wr->out, &(wr->th_ssize_pos)) != 0
+	    || yytbl_write32 (wr, wr->total_written) < 0
+	    || fsetpos (wr->out, &pos)) {
+		flex_die (_("get|set|fwrite32 failed"));
+		return -1;
+	}
+	else
+		/* Don't count the int we just wrote. */
+		wr->total_written -= sizeof (flex_int32_t);
+	return bwritten;
+}
+
+/** Write n bytes.
+ *  @param  wr   the table writer
+ *  @param  v    data to be written
+ *  @param  len  number of bytes
+ *  @return  -1 on error. number of bytes written on success.
+ */
+int yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len)
+{
+	int  rv;
+
+	rv = fwrite (v, 1, len, wr->out);
+	if (rv != len)
+		return -1;
+	wr->total_written += len;
+	return len;
+}
+
+/** Write four bytes in network byte order
+ *  @param  wr  the table writer
+ *  @param  v    a dword in host byte order
+ *  @return  -1 on error. number of bytes written on success.
+ */
+int yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v)
+{
+	flex_uint32_t vnet;
+	size_t  bytes, rv;
+
+	vnet = htonl (v);
+	bytes = sizeof (flex_uint32_t);
+	rv = fwrite (&vnet, bytes, 1, wr->out);
+	if (rv != 1)
+		return -1;
+	wr->total_written += bytes;
+	return bytes;
+}
+
+/** Write two bytes in network byte order.
+ *  @param  wr  the table writer
+ *  @param  v    a word in host byte order
+ *  @return  -1 on error. number of bytes written on success.
+ */
+int yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v)
+{
+	flex_uint16_t vnet;
+	size_t  bytes, rv;
+
+	vnet = htons (v);
+	bytes = sizeof (flex_uint16_t);
+	rv = fwrite (&vnet, bytes, 1, wr->out);
+	if (rv != 1)
+		return -1;
+	wr->total_written += bytes;
+	return bytes;
+}
+
+/** Write a byte.
+ *  @param  wr  the table writer
+ *  @param  v    the value to be written
+ *  @return  -1 on error. number of bytes written on success.
+ */
+int yytbl_write8 (struct yytbl_writer *wr, flex_uint8_t v)
+{
+	size_t  bytes, rv;
+
+	bytes = sizeof (flex_uint8_t);
+	rv = fwrite (&v, bytes, 1, wr->out);
+	if (rv != 1)
+		return -1;
+	wr->total_written += bytes;
+	return bytes;
+}
+
+
+/* XXX Not Used */
+#if 0
+/** Extract data element [i][j] from array data tables. 
+ * @param tbl data table
+ * @param i index into higher dimension array. i should be zero for one-dimensional arrays.
+ * @param j index into lower dimension array.
+ * @param k index into struct, must be 0 or 1. Only valid for YYTD_ID_TRANSITION table
+ * @return data[i][j + k]
+ */
+static flex_int32_t yytbl_data_getijk (const struct yytbl_data *tbl, int i,
+				  int j, int k)
+{
+	flex_int32_t lo;
+
+	k %= 2;
+	lo = tbl->td_lolen;
+
+	switch (YYTDFLAGS2BYTES (tbl->td_flags)) {
+	case sizeof (flex_int8_t):
+		return ((flex_int8_t *) (tbl->td_data))[(i * lo + j) * (k + 1) +
+						   k];
+	case sizeof (flex_int16_t):
+		return ((flex_int16_t *) (tbl->td_data))[(i * lo + j) * (k +
+								    1) +
+						    k];
+	case sizeof (flex_int32_t):
+		return ((flex_int32_t *) (tbl->td_data))[(i * lo + j) * (k +
+								    1) +
+						    k];
+	default:
+		flex_die (_("invalid td_flags detected"));
+		break;
+	}
+
+	return 0;
+}
+#endif /* Not used */
+
+/** Extract data element [i] from array data tables treated as a single flat array of integers.
+ * Be careful for 2-dimensional arrays or for YYTD_ID_TRANSITION, which is an array
+ * of structs. 
+ * @param tbl data table
+ * @param i index into array.
+ * @return data[i]
+ */
+static flex_int32_t yytbl_data_geti (const struct yytbl_data *tbl, int i)
+{
+
+	switch (YYTDFLAGS2BYTES (tbl->td_flags)) {
+	case sizeof (flex_int8_t):
+		return ((flex_int8_t *) (tbl->td_data))[i];
+	case sizeof (flex_int16_t):
+		return ((flex_int16_t *) (tbl->td_data))[i];
+	case sizeof (flex_int32_t):
+		return ((flex_int32_t *) (tbl->td_data))[i];
+	default:
+		flex_die (_("invalid td_flags detected"));
+		break;
+	}
+	return 0;
+}
+
+/** Set data element [i] in array data tables treated as a single flat array of integers.
+ * Be careful for 2-dimensional arrays or for YYTD_ID_TRANSITION, which is an array
+ * of structs. 
+ * @param tbl data table
+ * @param i index into array.
+ * @param newval new value for data[i]
+ */
+static void yytbl_data_seti (const struct yytbl_data *tbl, int i,
+			     flex_int32_t newval)
+{
+
+	switch (YYTDFLAGS2BYTES (tbl->td_flags)) {
+	case sizeof (flex_int8_t):
+		((flex_int8_t *) (tbl->td_data))[i] = (flex_int8_t) newval;
+		break;
+	case sizeof (flex_int16_t):
+		((flex_int16_t *) (tbl->td_data))[i] = (flex_int16_t) newval;
+		break;
+	case sizeof (flex_int32_t):
+		((flex_int32_t *) (tbl->td_data))[i] = (flex_int32_t) newval;
+		break;
+	default:
+		flex_die (_("invalid td_flags detected"));
+		break;
+	}
+}
+
+/** Calculate the number of bytes  needed to hold the largest
+ *  absolute value in this data array.
+ *  @param tbl  the data table
+ *  @return sizeof(n) where n in {flex_int8_t, flex_int16_t, flex_int32_t}
+ */
+static size_t min_int_size (struct yytbl_data *tbl)
+{
+	flex_uint32_t i, total_len;
+	flex_int32_t max = 0;
+
+	total_len = yytbl_calc_total_len (tbl);
+
+	for (i = 0; i < total_len; i++) {
+		flex_int32_t n;
+
+		n = abs (yytbl_data_geti (tbl, i));
+
+		if (n > max)
+			max = n;
+	}
+
+	if (max <= INT8_MAX)
+		return sizeof (flex_int8_t);
+	else if (max <= INT16_MAX)
+		return sizeof (flex_int16_t);
+	else
+		return sizeof (flex_int32_t);
+}
+
+/** Transform data to smallest possible of (int32, int16, int8).
+ * For example, we may have generated an int32 array due to user options
+ * (e.g., %option align), but if the maximum value in that array
+ * is 80 (for example), then we can serialize it with only 1 byte per int.
+ * This is NOT the same as compressed DFA tables. We're just trying
+ * to save storage space here.
+ *
+ * @param tbl the table to be compressed
+ */
+void yytbl_data_compress (struct yytbl_data *tbl)
+{
+	flex_int32_t i, newsz, total_len;
+	struct yytbl_data newtbl;
+
+	yytbl_data_init (&newtbl, tbl->td_id);
+	newtbl.td_hilen = tbl->td_hilen;
+	newtbl.td_lolen = tbl->td_lolen;
+	newtbl.td_flags = tbl->td_flags;
+
+	newsz = min_int_size (tbl);
+
+
+	if (newsz == (int) YYTDFLAGS2BYTES (tbl->td_flags))
+		/* No change in this table needed. */
+		return;
+
+	if (newsz > (int) YYTDFLAGS2BYTES (tbl->td_flags)) {
+		flex_die (_("detected negative compression"));
+		return;
+	}
+
+	total_len = yytbl_calc_total_len (tbl);
+	newtbl.td_data = calloc (total_len, newsz);
+	newtbl.td_flags =
+		TFLAGS_CLRDATA (newtbl.td_flags) | BYTES2TFLAG (newsz);
+
+	for (i = 0; i < total_len; i++) {
+		flex_int32_t g;
+
+		g = yytbl_data_geti (tbl, i);
+		yytbl_data_seti (&newtbl, i, g);
+	}
+
+
+	/* Now copy over the old table */
+	free (tbl->td_data);
+	*tbl = newtbl;
+}
+
+/* vim:set noexpandtab cindent tabstop=8 softtabstop=0 shiftwidth=8 textwidth=0: */