typecode.c

早期freebsd实现

\treturn (bp - buf);\n\
}\n";
	fprintf(support1, format,
		true_size, xfn(EXTERNALIZE, bt), ref);
	fprintf(support2, format,
		true_size, xfn(INTERNALIZE, bt), ref);
}

define_sequence_type(typtr)
	struct type *typtr;
{
	struct type *bt;
	char *ref, *format;

	typtr->type_xsize = -1;
	bt = typtr->type_basetype;
	/*
	 * Make sure the component type is defined
	 */
	if (typename(bt) == NULL) {
		struct object *name;
		name = make_symbol(gensym("T_s"),CurrentModule);
		define_type(name,bt);
	}
	if (recursive_flag)
		return;
	/*
	 * Print a C definition for the sequence.
	 */
	fprintf(header,
"\n\
typedef struct {\n\
\tCardinal length;\n\
\t%s *sequence;\n\
} %s;\n",
		typename(bt), typename(typtr));
	/*
	 * Generate sizeof and free functions for the sequence.
	 * The size is equal to 1 (for the length word)
	 * plus the sum of the sizes of each element.
	 */
	bt = typtr->type_basetype;
	ref = refstr(bt);
	if (bt->type_xsize != -1) {
		/*
		 * The element type is fixed-size, so just define a macro.
		 */
		fprintf(header,
"\n\
#define sizeof_%s(p) (1 + (p)->length * %d)\n",
			typename(typtr), bt->type_xsize);
		fprintf(support1,
"\n\
void\n\
clear_%s(p)\n\
\tregister %s *p;\n\
{\n\
\tDeallocate((Unspecified*) p->sequence);\n\
\tp->length = 0;  p->sequence = (%s*) 0;\n\
}\n",
			typename(typtr), typename(typtr),
			typename(bt) );
	} 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 = 1;\n\
\tregister int i;\n\
\n\
\tif (p->sequence == (%s*) 0) return(size);\n\
\tfor (i = 0; i < p->length; i += 1)\n\
\t\tsize += sizeof_%s(%sp->sequence[i]);\n\
\treturn (size);\n\
}\n",
			typename(typtr), typename(typtr), typename(bt),
			typename(bt), ref);
		fprintf(support1,
"\n\
void\n\
clear_%s(p)\n\
\tregister %s *p;\n\
{\n\
\tregister int i;\n\
\n\
\tif (p->sequence != (%s*) 0) for (i = 0; i < p->length; i += 1)\n\
\t\tclear_%s(%sp->sequence[i]);\n\
\tDeallocate((Unspecified*) p->sequence);\n\
\tp->length = 0;  p->sequence = (%s*) 0;\n\
}\n",
			typename(typtr), typename(typtr), typename(bt),
			typename(bt), ref,
			typename(bt) );

	}
	/*
	 * Define translation functions.
	 */
	xfn_header(EXTERNALIZE, typtr, typtr);
	xfn_header(INTERNALIZE, typtr, typtr);
	/*
	 * The externalize function (trivially) checks its pointer
	 * for consistency.
	 */
	fprintf(support1,
"{\n\
\tregister Unspecified *bp;\n\
\tregister int i;\n\
\n\
\tif (p->sequence == (%s*)0) p->length = 0;\n\
\tbp = buf + %s(&p->length, buf);\n",
		typename(bt),
		xfn(EXTERNALIZE, Cardinal_type));
	/*
	 * The internalize function needs to allocate space
	 * for the sequence elements dynamically.
	 */
	fprintf(support2,
"{\n\
\tregister Unspecified *bp;\n\
\tregister int i;\n\
\n\
\tbp = buf + %s(&p->length, buf);\n\
\tp->sequence = (%s *)\n\
\t\tAllocate(p->length * sizeof(%s)/sizeof(Cardinal));\n",
		xfn(INTERNALIZE, Cardinal_type),
		typename(bt), typename(bt));
	format =
"\tfor (i = 0; i < p->length; i++)\n\
\t\tbp += %s(%sp->sequence[i], bp);\n\
\treturn (bp - buf);\n\
}\n";
	fprintf(support1, format, xfn(EXTERNALIZE, bt), ref);
	fprintf(support2, format, xfn(INTERNALIZE, bt), ref);
}

define_choice_type(typtr)
	struct type *typtr;
{
	struct type *designator, *bt;
	list p,q,candidates;
	char *format, *ref, *member;

	typtr->type_xsize = -1;

	designator = typtr->type_designator;
	candidates = typtr->type_candidates;
	if (! recursive_flag)
		fprintf(header,
"\n\
extern struct %s;\n\
typedef struct %s %s;\n",
			typename(typtr), typename(typtr), typename(typtr));
	/*
	 * Make sure each arm type is defined
	 */
	for (p = candidates; p != NIL; p = cdr(p)) {
		bt = (struct type *) cdar(p);
		if (typename(bt) == NULL) {
			struct object *name;
			name = make_symbol(gensym("T_c"),CurrentModule);
			define_type(name,bt);
		}
	}
	if (recursive_flag)
		return;
	/*
	 * Print a C definition for the choice.
	 * First, be prepared for recursive references of the SEQUENCE OF form
	 */
	fprintf(header,
"\n\
struct %s {\n\
\t%s designator;\n\
\tunion {\n",
		typename(typtr), typename(designator));
	for (p = candidates; p != NIL; p = cdr(p)) {
		bt = (struct type *) cdar(p);
		for (q = caar(p); q != NIL; q = cdr(q)) {
			member = enumname_of(caar(q));
			fprintf(header,
"\t\t%s u_%s;\n\
#define %s_case u.u_%s\n",
				typename(bt), member,
				candidate_name(member), member);
			if (strcmp(name_of(caar(q)),candidate_name(member)) != 0)
				fprintf(header1,"#define %s_case %s_case\n",
					name_of(caar(q)),
					candidate_name(member) );
		}
	}
	fprintf(header,
"\t} u;\n\
};\n" );
	/*
	 * Generate a sizeof function for the choice.
	 * The size is equal to 1 (for the designator word)
	 * plus the size of the corresponding candidate.
	 * We could check if all the candidates happen to be the same size,
	 * but we don't bother and always call it variable-size.
	 */
	fprintf(support1,
"\n\
int\n\
sizeof_%s(p)\n\
\tregister %s *p;\n\
{\n\
\tregister int size = 1;\n\
\n\
\tswitch (p->designator) {\n",
		typename(typtr), typename(typtr));
	for (p = candidates; p != NIL; p = cdr(p)) {
		bt = (struct type *) cdar(p);
		ref = refstr(bt);
		for (q = caar(p); q != NIL; q = cdr(q)) {
			member = enumname_of(caar(q));
			fprintf(support1,
"\t    case %s:\n\
\t\tsize += sizeof_%s(%sp->%s_case);\n\
\t\tbreak;\n",
				member, typename(bt), ref, 
				candidate_name(member));
		}
	}
	fprintf(support1,
"\t}\n\
\treturn (size);\n\
}\n"
		);
	/*
	 * Now generate the freeing function.  Here we do bother
	 * not to free constant-sized structures, just for kicks.
	 * However, we always generate a freeing function, even if
	 * all the arms of the choice are constant sized.
	 */
	fprintf(support1,
"\n\
void\n\
clear_%s(p)\n\
\tregister %s *p;\n\
{\n\
\tswitch (p->designator) {\n",
		typename(typtr), typename(typtr));
	for (p = candidates; p != NIL; p = cdr(p)) {
		bt = (struct type *) cdar(p);
		ref = refstr(bt);
		for (q = caar(p); q != NIL; q = cdr(q)) {
			member = enumname_of(caar(q));
			if (bt->type_xsize == -1)
				fprintf(support1,
"\t    case %s:\n\
\t\tbreak;\n",
					member);
			else
				fprintf(support1,
"\t    case %s:\n\
\t\tclear_%s(%sp->%s_case);\n\
\t\tbreak;\n",
					member, typename(bt), ref, 
					candidate_name(member));
		}
	}
	fprintf(support1,
"\t}\n\
}\n"
		);
	/*
	 * Define translation functions.
	 */
	xfn_header(EXTERNALIZE, typtr, typtr);
	xfn_header(INTERNALIZE, typtr, typtr);
	format =
"{\n\
\tregister Unspecified *bp;\n\
\n\
\tbp = buf + %s(&p->designator, buf);\n\
\tswitch (p->designator) {\n";
	fprintf(support1, format, xfn(EXTERNALIZE, designator));
	fprintf(support2, format, xfn(INTERNALIZE, designator));
	format =
"\t    case %s:\n\
\t\tbp += %s(%sp->%s_case, bp);\n\
\t\tbreak;\n";
	for (p = candidates; p != NIL; p = cdr(p)) {
		bt = (struct type *) cdar(p);
		ref = refstr(bt);
		for (q = caar(p); q != NIL; q = cdr(q)) {
			member = enumname_of(caar(q));
			fprintf(support1, format,
				member, xfn(EXTERNALIZE, bt),
				ref, candidate_name(member));
			fprintf(support2, format,
				member, xfn(INTERNALIZE, bt),
				ref, candidate_name(member));
		}
	}
	format =
"\t}\n\
\treturn (bp - buf);\n\
}\n";
	fprintf(support1, format);
	fprintf(support2, format);
}

/*
 * Generate a new full name of the form <module><version>_<name>
 */
char *
make_full_name(module,version,name)
	char *module;
	int version;
	char *name;
{
	char buf[MAXSTR];
	if (module == NULL || *module == '\0')
		return(copy(name));
	sprintf(buf,"%s%d_%s",module,version,name);
	return(copy(buf));
}

/*
 * Generate defininitions for named types
 * and their size and translation functions.
 * We assume that each type with a type_name field has already been
 * generated.
 */
define_type(name, typtr)
	struct object *name;
	struct type *typtr;
{
	char *fullname;
	/*
	 * create the symbol -- it has already been made via make_symbol()
	 * which, along with allocating an object, set o_name
	 */
	name->o_class = O_TYPE;
	name->o_type = typtr;
	fullname = make_full_name(name->o_module, name->o_modversion,
			name_of(name));
	code_type(fullname, typtr);
	if (!recursive_flag) {
		/* widen scope */
		if (typtr->type_constr == C_ENUMERATION)
			/* special scope-widening */
			widen_enumeration_typedef(header1,fullname,
					name_of(name),typtr);
		else
			fprintf(header1, "typedef %s %s;\n",
				fullname, name_of(name));
		copy_typefns(header1,name_of(name),fullname);
	}
}

/*
 * Actually generate some code.  This routine may be called recursively
 * if subtypes have no name.
 */
code_type(name, typtr)
	char *name;
	struct type *typtr;
{
	/*
	 * check for simple case of "foo: TYPE = bar;" rename
	 */
	if (typename(typtr) != NULL) {
		if (!recursive_flag) {
			/* create alias for typedef */
			fprintf(header,"typedef %s %s;\n",
				typename(typtr), name);
			copy_typefns(header,name, typename(typtr));
		}
		return;
	}
	/*
	 * general case:  "foo: TYPE = <type>;"
	 * actually generate some code
	 */
	switch (typtr->type_constr) {
	case C_PROCEDURE:
		/* no code gets generated for these Types */
		typename(typtr) = name;
		break;
	case C_NUMERIC:
	case C_BOOLEAN:
	case C_STRING:
		/* create alias for typedef */
		fprintf(header,"typedef %s %s;\n",
			typename(typtr), name);
		copy_typefns(header,name,typename(typtr));
		typename(typtr) = name;
		break;
	case C_ENUMERATION:
		typename(typtr) = name;
		define_enumeration_type(typtr);
		break;
	case C_ARRAY:
		typename(typtr) = name;
		define_array_type(typtr);
		break;
	case C_SEQUENCE:
		typename(typtr) = name;
		define_sequence_type(typtr);
		break;
	case C_RECORD:
		typename(typtr) = name;
		define_record_type(typtr);
		break;
	case C_CHOICE:
		typename(typtr) = name;
		define_choice_type(typtr);
		break;
	case C_ERROR:
		typename(typtr) = name;
		if (typtr->type_list != NIL)
			define_record_type(typtr);
		break;
	}
	return;
}