path: root/tables.c

/*  tables.h - 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"

#define yypad64(n) ((8-((n)%8))%8)
#define TFLAGS2BYTES(flags)\
        (((flags) & YYT_DATA8)\
            ? sizeof(int8_t)\
            :(((flags) & YYT_DATA16)\
                ? sizeof(int16_t)\
                :sizeof(int32_t)))

int     yytbl_fwrite32 (FILE * out, uint32_t v);
int     yytbl_fwrite16 (FILE * out, uint16_t v);
int     yytbl_fwrite8 (FILE * out, uint8_t v);

/** Initialize a table header.
 *  @param th  The uninitialized structure
 *  @param version_str the  version string
 *  @param name the name of this table set
 */
void yytbl_hdr_init (struct yytbl_hdr *th, const char *version_str,
		     const char *name)
{
	memset (th, 0, sizeof (struct yytbl_hdr));

	th->th_magic = 0xF13C57B1;
	th->th_hsize =
		yypad64 (20 + strlen (version_str) + 1 + strlen (name) +
			 1);
	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);
}

/** Allocate and initialize a table data structure.
 * @param id  the table identifier
 * @return a flex_alloc'd structure. Caller must flex_free it.
 */
struct yytbl_data *yytbl_data_create (enum yytbl_id id)
{
	struct yytbl_data *td;

	td = (struct yytbl_data *) flex_alloc (sizeof (struct yytbl_data));
	memset (td, 0, sizeof (struct yytbl_data));

	td->t_id = id;
	return td;
}

/** 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 (FILE * out, const struct yytbl_hdr *th)
{
	size_t  sz, rv;
	int     pad, bwritten = 0;

	if (yytbl_fwrite32 (out, th->th_magic) < 0
	    || yytbl_fwrite32 (out, th->th_hsize) < 0
	    || yytbl_fwrite32 (out, th->th_ssize) < 0
	    || yytbl_fwrite16 (out, th->th_flags) < 0)
		return -1;
	else
		bwritten += 3 * 4 + 2;

	sz = strlen (th->th_version) + 1;
	if ((rv = fwrite (th->th_version, 1, sz, out)) != sz)
		return -1;
	bwritten += rv;

	sz = strlen (th->th_name) + 1;
	if ((rv = fwrite (th->th_name, 1, sz, out)) != sz)
		return 1;
	bwritten += rv;

	/* add padding */
	pad = yypad64 (bwritten) - bwritten;
	while (pad-- > 0)
		if (yytbl_fwrite8 (out, 0) < 0)
			return -1;
		else
			bwritten++;

	/* Sanity check */
	if (bwritten != th->th_hsize) {
		/* Oops. */
		return -1;
	}

	return bwritten;
}

/** Write four bytes in network byte order
 * @param  out  the output stream
 * @param  v    a dword in host byte order
 * @return  -1 on error. number of bytes written on success.
 */
int yytbl_fwrite32 (FILE * out, uint32_t v)
{
	uint32_t vnet;
	size_t  bytes, rv;

	vnet = htonl (v);
	bytes = sizeof (uint32_t);
	rv = fwrite (&vnet, bytes, 1, out);
	if (rv != bytes)
		return -1;
	return bytes;
}

/** Write two bytes in network byte order.
 * @param  out  the output stream
 * @param  v    a word in host byte order
 * @return  -1 on error. number of bytes written on success.
 */
int yytbl_fwrite16 (FILE * out, uint16_t v)
{
	uint16_t vnet;
	size_t  bytes, rv;

	vnet = htons (v);
	bytes = sizeof (uint16_t);
	rv = fwrite (&vnet, bytes, 1, out);
	if (rv != bytes)
		return -1;
	return bytes;
}

/** Write a byte.
 * @param  out  the output stream
 * @param  v    the value to be written
 * @return  -1 on error. number of bytes written on success.
 */
int yytbl_fwrite8 (FILE * out, uint8_t v)
{
	size_t  bytes, rv;

	bytes = sizeof (uint8_t);
	rv = fwrite (&v, bytes, 1, out);
	if (rv != bytes)
		return -1;
	return bytes;
}

/** Calculate the number of bytes  needed to hold the largest
 *  absolute value in this array.
 * @param arr  array
 * @param len  number of elements in array
 * @param sz   sizeof individual element
 * @return 1,2, or 4
 */
static int min_int_size (const void *arr, int32_t len, int sz)
{
	int32_t curr, max = 0, i;

	for (i = 0; i < len; i++) {
		switch (sz) {
		case 1:
			curr = abs (((int8_t *) arr)[i]);
			break;
		case 2:
			curr = abs (((int16_t *) arr)[i]);
			break;
		case 4:
			curr = abs (((int32_t *) arr)[i]);
			break;
		default:
			fprintf (stderr,
				 "Illegal size (%d) in min_int_size\n",
				 sz);
			return 32;
		}
		if (curr > max)
			max = curr;
	}
	if (max < INT8_MAX)
		return sizeof (int8_t);
	else if (max < INT16_MAX)
		return sizeof (int16_t);
	else
		return sizeof (int32_t);
}


/* Extract data element [i][j] from int array data tables. 
 * @param tbl data table
 * @param i index into major array. i is zero for one-dimensional arrays.
 * @param j index into 
 * @return data[i][j]
 */
static int32_t yytbl_data_geti (const struct yytbl_data *tbl, int i, int j)
{
	/* TODO */
	return 0;
}

/* Transform data to smallest possible of (int32, int16, int8).
 * For example, we may generate an int32 array due to user options
 * (e.g., %option align) but if the maximum value in that array
 * is 80, then we serialize it with 1 byte per int.
 *
 * @param tbl the table to be compressed
 */
void yytbl_data_compress (struct yytbl_data *tbl)
{
	int32_t i, sz;
	void   *newdata = 0;

	if (tbl->t_id != YYT_ID_TRANSITION
	    && tbl->t_id != YYT_ID_START_STATE_LIST) {
		if (tbl->t_hilen == 0) {
			/* Data is a single-dimensional array of ints */
			sz = min_int_size (tbl->t_data, tbl->t_lolen,
					   TFLAGS2BYTES (tbl->t_flags));
			if (sz == TFLAGS2BYTES (tbl->t_flags))
				/* No change in this table needed. */
				return;

			if (sz > TFLAGS2BYTES (tbl->t_flags)) {
				/* TODO: ERROR. The code is wrong somewhere. */
				return;
			}

			newdata = flex_alloc (sz * tbl->t_lolen);
			for (i = 0; i < tbl->t_lolen; i++) {
				int32_t n;

				n = yytbl_data_geti (tbl, 0, i);
				switch (sz) {
				case sizeof (int8_t):
					((int8_t *) newdata)[i] =
						(int8_t) n;
					break;
				case sizeof (int16_t):

					((int16_t *) newdata)[i] =
						(int16_t) n;
					break;
				case sizeof (int32_t):

					((int32_t *) newdata)[i] =
						(int32_t) n;
					break;
				default:	/* TODO: ERROR: unknown 'sz' */
					break;
				}
			}
			free (tbl->t_data);
			tbl->t_data = newdata;

		}
		else {
			/* Data is a two-dimensional array of ints */
		}
	}
	else if (tbl->t_id == YYT_ID_TRANSITION) {
		/* Data is an array of structs */
	}
	else if (tbl->t_id == YYT_ID_START_STATE_LIST) {
		/* Data is an array of pointers */
	}
}

/* vim:set expandtab cindent tabstop=4 softtabstop=4 shiftwidth=4 textwidth=0: */