typecode.c

早期freebsd实现

/*
 * Copyright (C) 1984 by Eric C. Cooper.
 * All rights reserved.
 */
#ifndef lint
static char RCSid[] = "$Header: typecode.c,v 2.4 86/06/26 12:38:30 jqj Exp $";
#endif

/* $Log:	typecode.c,v $
 * Revision 2.4  86/06/26  12:38:30  jqj
 * clear_ functions should be type void.
 * 
 * Revision 2.3  86/06/06  07:28:59  jqj
 * many mods for better symbol table management:  added CurrentModule,
 *  made check_dependency, make_symbol, check_def set/use/use a symbol
 *  table instead of a module name string, etc.  Result is that we can
 *  now handle DEPENDS UPON 2 versions of same program.
 * 
 * Revision 2.2  86/05/16  11:13:59  jqj
 * various bugs in widening created by previous edit (I still don't have
 * them all fixed, but at least it's now usable).
 * 
 * Revision 2.1  86/05/16  05:47:15  jqj
 * make enumeration tags local to modules rather than global, to allow
 * DEPENDS UPON two versions of the same program.  For same reason, use
 * gensymed symbol names that include version number.
 * 
 * Revision 2.0  85/11/21  07:21:47  jqj
 * 4.3BSD standard release
 * 
 * Revision 1.6  85/05/23  06:20:12  jqj
 * *** empty log message ***
 * 
 * Revision 1.6  85/05/23  06:20:12  jqj
 * Public Beta-test version, released 24 May 1985
 * 
 * Revision 1.5  85/05/06  08:13:43  jqj
 * Almost Beta-test version.
 * 
 * Revision 1.4  85/03/26  06:10:42  jqj
 * Revised public alpha-test version, released 26 March 1985
 * 
 * Revision 1.3  85/03/11  16:40:21  jqj
 * Public alpha-test version, released 11 March 1985
 * 
 * Revision 1.2  85/02/21  11:06:11  jqj
 * alpha test version
 * 
 * Revision 1.1  85/02/15  13:55:45  jqj
 * Initial revision
 * 
 */

#include "compiler.h"

#define candidate_name(str)	(str)

/*
 * This function is used to cope with the fact that C passes arrays
 * by reference but all other types by value.
 * The argument should be a base type.
 */
char *
refstr(typtr)
	struct type *typtr;
{
/*	if (typtr->o_class != O_TYPE)
		error(FATAL, "internal error (refstr): not a type");
 */
	return (typtr->type_constr == C_ARRAY ? "" : "&");
}

/*
 * Names of translation functions for types.
 * Warning: returns pointer to a static buffer.
 */
char *
xfn(kind, typtr)
	enum translation kind;
	struct type *typtr;
{
	static char buf[MAXSTR];
	char *name;

	switch (kind) {
	    case EXTERNALIZE:
		name = "externalize";
		break;
	    case INTERNALIZE:
		name = "internalize";
		break;
	}
	(void) sprintf(buf, "%s_%s", name, typtr->type_name);
	return (buf);
}

/*
 * Print the heading for a type externalizing or internalizing function.
 */
xfn_header(kind, typtr, ptr_type)
	enum translation kind;
	struct type *typtr, *ptr_type;
{
	FILE *f;

	switch (kind) {
	    case EXTERNALIZE:
		f = support1; break;
	    case INTERNALIZE:
		f = support2; break;
	}
	fprintf(f,
"\n\
int\n\
%s(p, buf)\n\
\tregister %s *p;\n\
\tregister Unspecified *buf;\n",
		xfn(kind, typtr), typename(ptr_type));
}

/*
 * create an alias for a type's datastructures.  Note that caller must
 * create the alias for the typedef name itself.
 */
copy_typefns(headerfile,new,old)
	FILE *headerfile; 
	char *new, *old;
{
	fprintf(headerfile,
"#define sizeof_%s sizeof_%s\n\
#define clear_%s clear_%s\n\
#define externalize_%s externalize_%s\n\
#define internalize_%s internalize_%s\n\n",
			new, old, new, old, new, old, new, old);
}


widen_enumeration_typedef(header1,fullname,tpname,typtr)
	FILE *header1;
	char *fullname;
	char *tpname;
	struct type *typtr;
{
	list p,q;

	fprintf(header1, "\n#define %s %s\ntypedef enum {\n",
			fullname,tpname);
	for (p = typtr->type_list; p != NIL; p = cdr(p)) {
		q=car(p);
		fprintf(header1, "\t%s = %s", name_of(car(q)),
				((char *) cdr(q)) );
		if (cdr(p) != NIL)
			fprintf(header1, ",\n");
		else
			fprintf(header1, "\n");
	}
	fprintf(header1, "} %s;\n", tpname);
}

define_enumeration_type(typtr)
	struct type *typtr;
{
	list p,q;
	struct object *optr;

	typtr->type_xsize = 1;
	if (recursive_flag)
		return;
	/*
	 * Print a C definition for the enumeration.
	 */
	fprintf(header, "\ntypedef enum {\n");
	for (p = typtr->type_list; p != NIL; p = cdr(p)) {
		q=car(p);
		optr = (struct object *) car(q);
		fprintf(header, "\t%s = %s",enumname_of(car(q)),
/*				make_full_name(optr->o_module,		      */
/*					optr->o_modversion,name_of(car(q))),  */
				((char *) cdr(q)) );
		if (cdr(p) != NIL)
			fprintf(header, ",\n");
		else
			fprintf(header, "\n");
	}
	fprintf(header, "} %s;\n", typename(typtr));
	/*
	 * We use the same sizeof and translation functions
	 * for all enumerated types.
	 */
	copy_typefns(header,typename(typtr),"enumeration");
}


define_record_type(typtr)
	struct type *typtr;
{
	struct type *bt;
	list p, q;
	int fixed_size;
	char *format, *ref, *member;

	/*
	 * Make sure all subtypes are defined and have sizes
	 */
	for (p = typtr->type_list; p != NIL; p = cdr(p)) {
		bt = (struct type *) cdar(p);
		if (typename(bt) == NULL) {
			struct object *name;
			name = make_symbol(gensym("T_r"),CurrentModule);
			define_type(name,bt);
		}
	}
	/*
	 * Generate size field.
	 * The size is equal to the sum of the sizes of each field.
	 */
	fixed_size = 0;
	typtr->type_xsize = 0;
	for (p = typtr->type_list; p != NIL; p = cdr(p)) {
		bt = (struct type *) cdar(p);
		if (bt->type_xsize == -1)
			typtr->type_xsize = -1;
		else
			fixed_size += bt->type_xsize;
	}
	if (typtr->type_xsize != -1)
		typtr->type_xsize = fixed_size;
	if (recursive_flag)
		return;
	/*
	 * Print a C definition for the record.
	 */
	fprintf(header, "\ntypedef struct {\n");
	for (p = typtr->type_list; p != NIL; p = cdr(p)) {
		bt = (struct type *) cdar(p);
		q = caar(p);
		member = (char *) car(q);
		fprintf(header, "\t%s %s;\n", typename(bt), member);
	}
	fprintf(header, "} %s;\n", typename(typtr));
	/*
	 * Generate sizeof and free functions for the record.
	 */
	if (typtr->type_xsize != -1) {
		/*
		 * The record is fixed-size, so just define a macro.
		 */
		fprintf(header,
"\n\
#define sizeof_%s(p) %d\n\
\n\
#define clear_%s(p)\n",
			typename(typtr), typtr->type_xsize,
			typename(typtr));
	} else {
		/*
		 * There are some variable-size fields, so define functions.
		 */
		fprintf(support1,
"\n\
int\n\
sizeof_%s(p)\n\
\tregister %s *p;\n\
{\n\
\tregister int size = %d;\n\
\n",
			typename(typtr), typename(typtr), fixed_size);
		for (p = typtr->type_list; p != NIL; p = cdr(p)) {
			bt = (struct type *) cdar(p);
			if (bt->type_xsize != -1)
				continue;
			ref = refstr(bt);
			q = caar(p);
			member = (char *) car(q);
			fprintf(support1,
"\tsize += sizeof_%s(%sp->%s);\n",
				typename(bt), ref, member);
		}
		fprintf(support1,
"\treturn (size);\n\
}\n"
			);
		fprintf(support1,
"\n\
void\n\
clear_%s(p)\n\
\tregister %s *p;\n\
{\n\
\n",
			typename(typtr), typename(typtr));
		for (p = typtr->type_list; p != NIL; p = cdr(p)) {
			bt = (struct type *) cdar(p);
			if (bt->type_xsize != -1)
				continue;
			ref = refstr(bt);
			q = caar(p);
			member = (char *) car(q);
			fprintf(support1,
"\tclear_%s(%sp->%s);\n",
				typename(bt), ref, member);
		}
		fprintf(support1, "}\n" );
	}
	/*
	 * Define translation functions.
	 */
	xfn_header(EXTERNALIZE, typtr, typtr);
	xfn_header(INTERNALIZE, typtr, typtr);
	format =
"{\n\
\tregister Unspecified *bp;\n\
\n\
\tbp = buf;\n";
	fprintf(support1, format);
	fprintf(support2, format);
	format =
"\tbp += %s(%sp->%s, bp);\n";
	for (p = typtr->type_list; p != NIL; p = cdr(p)) {
		bt = (struct type *) cdar(p);
		ref = refstr(bt);
		q = caar(p);
		member = (char *) car(q);
		fprintf(support1, format,
			xfn(EXTERNALIZE, bt), ref, member);
		fprintf(support2, format,
			xfn(INTERNALIZE, bt), ref, member);
	}
	format =
"\treturn (bp - buf);\n\
}\n";
	fprintf(support1, format);
	fprintf(support2, format);
}

define_array_type(typtr)
	struct type *typtr;
{
	struct type *bt;
	int true_size;
	char *ref, *format;

	bt = typtr->type_basetype;
	/*
	 * Make sure the component type is defined and sized
	 */
	if (typename(bt) == NULL) {
		struct object *name;
		name = make_symbol(gensym("T_a"),CurrentModule);
		define_type(name,bt);
	}
	ref = refstr(bt);
	true_size = typtr->type_size;
	if (bt->type_xsize != -1)
		typtr->type_xsize = true_size * bt->type_xsize;
	else
		typtr->type_xsize = -1;
	if (recursive_flag)
		return;
	/*
	 * Print a C definition for the array.
	 */
	fprintf(header, "\ntypedef %s %s[%d];\n",
		typename(bt), typename(typtr), true_size);
	/*
	 * Generate a sizeof and free functions for the array.
	 * The size is equal to the sum of the sizes of each element.
	 */
	if (bt->type_xsize != -1) {
		/*
		 * The element type, and hence the array, is fixed-size,
		 * so just define a macro.
		 */
		fprintf(header,
"\n\
#define sizeof_%s(p) %d\n\
\n\
#define clear_%s(p)\n",
			typename(typtr), typtr->type_xsize,
			typename(typtr));
	} else {
		/*
		 * The element type is variable-size, so define a function.
		 */
		fprintf(support1,
"\n\
int\n\
sizeof_%s(p)\n\
\tregister %s *p;\n\
{\n\
\tregister int size = 0;\n\
\tregister int i;\n\
\n\
\tfor (i = 0; i < %d; i += 1)\n\
\t\tsize += sizeof_%s(%sp[i]);\n\
\treturn (size);\n\
}\n",
			typename(typtr), typename(bt), true_size,
			typename(bt), ref);
		fprintf(support1,
"\n\
void\n\
clear_%s(p)\n\
\t%s *p;\n\
{\n\
\tregister int i;\n\
\n\
\tfor (i = 0; i < %d; i += 1)\n\
\t\tclear_%s(%sp[i]);\n\
}\n",
			typename(typtr), typename(bt), true_size,
			typename(bt), ref);
	}
	/*
	 * Define translation functions.
	 */
	xfn_header(EXTERNALIZE, typtr, bt);
	xfn_header(INTERNALIZE, typtr, bt);
	format =
"{\n\
\tregister Unspecified *bp;\n\
\tregister int i;\n\
\n\
\tbp = buf;\n\
\tfor (i = 0; i < %d; i += 1)\n\
\t\tbp += %s(%sp[i], bp);\n\