Imported Upstream version 2.6.0

1 files changed, 0 insertions, 502 deletions

diff --git a/tables.c b/tables.c
deleted file mode 100644
index f3f056f..0000000
--- a/tables.c
+++ /dev/null
@@ -1,502 +0,0 @@
-/*  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: */