fix.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 2003-2011 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 <[email protected]>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped

static const char usage[] =
"[+DESCRIPTION?The fix query generates a fixed binary flat schema from the"
"	input file schema on the standard output. If the input schema is"
"	variable width then the input file is used to estimate average and"
"	maximum field widths. The generated schema may be used as input for"
"	the \bflat\b method conversion query.]"
"[s:stamp?The identification date stamp.]:[stamp:=YYYY-MM-DD]"
;

#include <dsslib.h>
#include <tm.h>

#define FIELD_string	0
#define FIELD_number	1
#define FIELD_buffer	2

struct Field_s; typedef struct Field_s Field_t;
struct State_s; typedef struct State_s State_t;

struct Field_s
{
	Dtlink_t	link;
	Field_t*	train;
	Cxvariable_t*	variable;
	Cxnumber_t	max;
	size_t		width;
	int		representation;
	int		flags;
};

struct State_s
{
	Dtdisc_t	fielddisc;
	Vmalloc_t*	vm;
	Field_t*	train;
	Dt_t*		fields;
	char*		stamp;
};

static int
fieldcmp(Dt_t* dt, void* a, void* b, Dtdisc_t* disc)
{
	register Field_t*	fa = (Field_t*)a;
	register Field_t*	fb = (Field_t*)b;

	if (fa->representation < fb->representation)
		return -1;
	if (fa->representation > fb->representation)
		return 1;
	if (fa->width < fb->width)
		return 1;
	if (fa->width > fb->width)
		return -1;
	return strcmp(fa->variable->name, fb->variable->name);
}

extern Dsslib_t	dss_lib_fix;

static int
fix_beg(Cx_t* cx, Cxexpr_t* expr, void* data, Cxdisc_t* disc)
{
	char**		argv = (char**)data;
	int		errors = error_info.errors;
	char*		s;
	State_t*	state;
	Cxvariable_t*	variable;
	Field_t*	field;
	Vmalloc_t*	vm;

	if (!(vm = vmopen(Vmdcheap, Vmlast, 0)) || !(state = vmnewof(vm, 0, State_t, 1, 0)))
	{
		if (vm)
			vmclose(vm);
		if (disc->errorf)
			(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
		return -1;
	}
	state->vm = vm;
	if (dssoptlib(cx->buf, &dss_lib_fix, usage, disc))
		goto bad;
	s = sfstruse(cx->buf);
	for (;;)
	{
		switch (optget(argv, s))
		{
		case 's':
			if (!(state->stamp = strdup(opt_info.arg)))
			{
				if (disc->errorf)
					(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
				return -1;
			}
			continue;
		case '?':
			if (disc->errorf)
				(*disc->errorf)(NiL, disc, ERROR_USAGE|4, "%s", opt_info.arg);
			else
				goto bad;
			continue;
		case ':':
			if (disc->errorf)
				(*disc->errorf)(NiL, disc, 2, "%s", opt_info.arg);
			else
				goto bad;
			continue;
		}
		break;
	}
	if (error_info.errors > errors)
		goto bad;
	argv += opt_info.index;
	state->fielddisc.comparf = fieldcmp;
	if (!(state->fields = dtnew(vm, &state->fielddisc, Dtoset)))
	{
		if (disc->errorf)
			(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
		goto bad;
	}
	for (variable = (Cxvariable_t*)dtfirst(cx->fields); variable; variable = (Cxvariable_t*)dtnext(cx->fields, variable))
	{
		if (!(field = vmnewof(vm, 0, Field_t, 1, 0)))
		{
			if (disc->errorf)
				(*disc->errorf)(NiL, disc, ERROR_SYSTEM|2, "out of space");
			goto bad;
		}
		field->variable = variable;
		switch (variable->type->representation)
		{
		case CX_buffer:
			field->representation = FIELD_buffer;
			break;
		case CX_string:
			field->representation = FIELD_string;
			break;
		default:
			field->representation = FIELD_number;
			break;
		}
		if (field->width = variable->format.width)
		{
			field->flags = variable->format.flags;
			dtinsert(state->fields, field);
		}
		else if (field->width = variable->type->format.width)
		{
			field->flags = variable->type->format.flags;
			dtinsert(state->fields, field);
		}
		else
		{
			field->train = state->train;
			state->train = field;
		}
	}
	expr->data = state;
	return 0;
 bad:
	vmclose(vm);
	return -1;
}

static int
fix_act(Cx_t* cx, Cxexpr_t* expr, void* data, Cxdisc_t* disc)
{
	register State_t*	state = (State_t*)expr->data;
	register Field_t*	field;
	Cxoperand_t		arg;

	for (field = state->train; field; field = field->train)
	{
		if (cxcast(cx, &arg, field->variable, field->variable->type, data, NiL))
			return -1;
		if (field->representation == FIELD_number)
		{
			if (arg.value.number < 0)
			{
				arg.value.number = -arg.value.number;
				field->flags = CX_UNSIGNED;
			}
			if (field->max < arg.value.number)
				field->max = arg.value.number;
		}
		else if (field->width < arg.value.buffer.size)
		{
			error(-1, "AHA fix_act %s.width %d  arg.size %d", field->variable->name, field->width, arg.value.buffer.size);
			field->width = arg.value.buffer.size;
		}
	}
	return 0;
}

static int
fix_end(Cx_t* cx, Cxexpr_t* expr, void* data, Cxdisc_t* disc)
{
	register State_t*	state = (State_t*)expr->data;
	register Field_t*	field;
	register size_t		w;
	register size_t		x;
	register size_t		r;
	register size_t		b;
	Dsslib_t*		lib;
	char*			s;

	b = 0;
	for (field = state->train; field; field = field->train)
	{
		if (field->representation == FIELD_number)
		{
			if (field->max != (Cxinteger_t)field->max)
			{
				field->width = 8;
				field->flags = CX_FLOAT;
			}
			else
			{
				field->flags ^= CX_UNSIGNED|CX_INTEGER;
				if (field->max > (unsigned long)0xffffffff)
					field->width = 8;
				else if (field->max > (unsigned long)0xffff)
					field->width = 4;
				else
					field->width = 2;
			}
		}
		else
		{
			if ((w = (field->width * 3) / 2) < 8)
				w = 8;
			else if (w < (1<<15))
				for (x = w, w = 1; w < x; w <<= 1);
			error(-1, "AHA fix_end %s.width %d w %d", field->variable->name, field->width, w);
			if (field->representation == FIELD_string)
				field->width = w;
			else
			{
				b += w;
				field->width = 4;
			}
		}
		dtinsert(state->fields, field);
	}
	r = 0;
	for (field = (Field_t*)dtfirst(state->fields); field; field = (Field_t*)dtnext(state->fields, field))
		r += field->width;
	x = r;
	if ((r += 2 * b) < 16)
		r = 16;
	else if (r < (1<<15))
		for (w = r, r = 1; r < w; r <<= 1);
	sfprintf(expr->op, "<METHOD>flat</>\n");
	sfprintf(expr->op, "<FLAT>\n");
	sfprintf(expr->op, "	<NAME>%s</>\n", DSS(cx)->meth->name);
	s = (char*)DSS(cx)->meth->description;
	if ((w = strlen(s)) && s[w-1] == '.')
		w--;
	sfprintf(expr->op, "	<DESCRIPTION>%-*.*s fixed width binary format.</>\n", w, w, s);
	if (!state->stamp)
		state->stamp = fmttime("%Y-%m-%d", time(NiL));
	sfprintf(expr->op, "	<IDENT>@(#)$Id: %s bin %s $</>\n", DSS(cx)->meth->name, state->stamp);
	sfprintf(expr->op, "	<MAGIC>\n");
	sfprintf(expr->op, "		<STRING>%s</>\n", DSS(cx)->meth->name);
	sfprintf(expr->op, "		<VERSION>");
	for (s = state->stamp; *s; s++)
		if (isdigit(*s))
			sfputc(expr->op, *s);
	sfprintf(expr->op, "</>\n");
	sfprintf(expr->op, "		<SWAP>be</>\n");
	sfprintf(expr->op, "	</>\n");
	sfprintf(expr->op, "	<COMPRESS>pzip %s-bin</>\n", DSS(cx)->meth->name);
	w = 0;
	for (lib = (Dsslib_t*)dtfirst(cx->state->libraries); lib; lib = (Dsslib_t*)dtnext(cx->state->libraries, lib))
		if (lib->types && !lib->meth)
		{
			sfprintf(expr->op, "	<LIBRARY>%s</>\n", lib->name);
			if (!w && streq(lib->name, "num_t"))
				w = 1;
		}
	if (!w)
		sfprintf(expr->op, "	<LIBRARY>num_t</>\n");
	for (field = (Field_t*)dtfirst(state->fields); field; field = (Field_t*)dtnext(state->fields, field))
	{
		sfprintf(expr->op, "	<FIELD>\n");
		sfprintf(expr->op, "		<NAME>%s</>\n", field->variable->name);
		sfprintf(expr->op, "		<DESCRIPTION>%s</>\n", field->variable->description);
		sfprintf(expr->op, "		<TYPE>%s</>\n", field->variable->type->name);
		sfprintf(expr->op, "		<PHYSICAL>\n");
		switch (field->representation)
		{
		case FIELD_buffer:
			sfprintf(expr->op, "			<TYPE>buffer</>\n");
			break;
		case FIELD_number:
			if (field->flags & CX_UNSIGNED)
				sfprintf(expr->op, "			<TYPE>unsigned be_t</>\n");
			else if (field->flags & CX_INTEGER)
				sfprintf(expr->op, "			<TYPE>be_t</>\n");
			else
				sfprintf(expr->op, "			<TYPE>ibm_t</>\n");
			break;
		}
		sfprintf(expr->op, "			<WIDTH>%d</>\n", field->width);
		sfprintf(expr->op, "		</>\n");
		sfprintf(expr->op, "	</>\n");
	}
	if (r > x)
	{
		sfprintf(expr->op, "	<FIELD>\n");
		sfprintf(expr->op, "		<NAME>%s</>\n", b ? "_HEAP_" : "_PAD_");
		sfprintf(expr->op, "		<DESCRIPTION>%s</>\n", b ? "Variable width data heap." : "Fixed size roundup pad.");
		sfprintf(expr->op, "		<TYPE>void</>\n");
		sfprintf(expr->op, "		<PHYSICAL>\n");
		sfprintf(expr->op, "			<WIDTH>%I*u</>\n", sizeof(r), r - x);
		sfprintf(expr->op, "		</>\n");
		sfprintf(expr->op, "	</>\n");
	}
	sfprintf(expr->op, "</>\n");
	vmclose(state->vm);
	return 0;
}

static Cxquery_t	queries[] =
{
	{
		"fix",
		"generate fixed binary schema from input schema",
		CXH,
		fix_beg,
		0,
		fix_act,
		fix_end
	},
	{0}
};

Dsslib_t	dss_lib_fix =
{
	"fix",
	"fix query"
	"[-1lms5P?\n@(#)$Id: dss fix query (AT&T Research) 2003-01-30 $\n]"
	USAGE_LICENSE,
	CXH,
	0,
	0,
	0,
	0,
	0,
	0,
	&queries[0]
};