uerfdbc.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

	for(sseg = first_sseg; sseg; sseg = sseg->next) {
		printf("std segment %s (%d %d) %s  count %d\n",
			sseg->name, sseg->type, sseg->type_id,
			sseg->label, sseg->elements_count);
		printf("    doc=%s\n", sseg->doc);
		for(sse=sseg->elements; sse; sse=sse->next) {
			printf("         %d %s\n", sse->id, sse->name);
		}
	}
	for(oitem = first_oitem; oitem; oitem = oitem->next) {
		printf("os item %s (%d)  type %d, class %d, size %d cnt %d\n",
			oitem->name, oitem->id, oitem->type, oitem->class, oitem->size,
			oitem->map_count);
		printf("    doc=%s\n", oitem->doc);
		for( oi = oitem->map; oi; oi=oi->next)
			printf("    %lu  %lu  %s\n",
				oi->os_value, oi->std_value, oi->std_name);
	}
}

char *ep_malloc(size)
int size;
{
	char *m;
	if(opt_d)
		fprintf(stderr, "ep_malloc %d\n", size);
	m=malloc(size);
	if(!m) {
		print_where();
		errval = 1;
		fprintf(stderr,"  Error, ep_malloc failed\n");
		exit(3);
	}
	return(m);
}


check_data() {
	check_std_items();
	check_std_segs();
	check_os_items();
}

	/* output the data file (bin file) */
output_data() {
	bin_out = fopen(BIN_NAME, "w");
	if( bin_out == NULL )  {
		fprintf(stderr, "Error, unable to open %s\n", BIN_NAME);
		errval = 1;
		exit(4);
	}
	fprintf(bin_out, "%d\n/*| Start of ultrix_dsd.bin */\n\n3\n\n", uerf_version);
	out_std_items();
	fprintf(bin_out, "\n");
	out_std_segs();
	fprintf(bin_out, "\n");
	out_os_items();
	fprintf(bin_out, "/* End of ultrix_dsd.bin */\n");
}

invalid_sitem(s, str)
struct std_item *s;
char *str;
{
	errval = 1;
	fprintf(stderr, "Error, In std item '%s' (id %d), invalid or missing %s\n",
		s->name, s->id, str);
}

invalid_sseg(s, str)
struct std_segment *s;
char *str;
{
	errval = 1;
	fprintf(stderr, "Error, In std segment '%s' (id %s %d), invalid or missing %s\n",
		s->name, encode_type(s->type,seg_table), s->type_id, str);
}

invalid_oitem(s, str)
struct os_item *s;
char *str;
{
	errval = 1;
	fprintf(stderr, "Error, In os item '%s' (id %d), invalid or missing %s\n",
		s->name, s->id, str);
}

	/* data checks on std_items,
		and any necessary references to other structures */
	/* Also, adjust things such as upper/lower case. */
check_std_items(){
	struct std_index *si;
	struct std_reg_field *sr;
	struct std_reg_field_index *sri;
	int need_nl, i;

	for(sitem = first_sitem; sitem; sitem = sitem->next) {
		if( !sitem->name || !strlen(sitem->name) ) {
			invalid_sitem(sitem, "NAME");
			sitem->name = " ";
		}
		convert_tolower(sitem->name);
		if( sitem->id <= 0)
			invalid_sitem(sitem, "ID");
		if( sitem->type <= 0)
			invalid_sitem(sitem, "TYPE");
		if( sitem->class <= 0)
			invalid_sitem(sitem, "CLASS");
		if( sitem->size <= 0)
			invalid_sitem(sitem, "SIZE");
				/* it's okay to omit display when type is indexed */
		if( sitem->label_type <= 0) {
			if( sitem->type != DT_SHORT_INDEX &&
				sitem->type != DT_INDEXED &&
				sitem->type != DT_TINY_INDEX ) {
					invalid_sitem(sitem, "DISPLAY");
			} else {
				sitem->label_type = DF_DEFAULT;
			}
		}
		if( !sitem->label || !strlen(sitem->label) ) {
			/* it's okay to omit the LABEL */
				/* this has been concluded because labels were found
					to be omitted from sti_rdch_stat2(old id 333),
					rv_slave2(old id 449), cierrcode(old id 517) */
			/* invalid_sitem(sitem, "LABEL"); */
			sitem->label = " ";
		}
		convert_toupper(sitem->label);
		if( !sitem->doc || !strlen(sitem->doc) ) {
			sitem->doc = "nil";
		}
		switch(sitem->type){
			case DT_SHORT_INDEX:
			case DT_INDEXED:
				for(si=sitem->map_index; si; si=si->next) {
					if( !si->name || !strlen(si->name) ) {
						invalid_sitem(sitem, "index name");
						si->name = " ";
					}
					if( si->value <=0 ) {
						invalid_sitem(sitem, "index value");
					}
					convert_tolower(si->name);
					if( !si->label || !strlen(si->label) ) {
						invalid_sitem(sitem, "index label");
						si->label = " ";
					}
					convert_toupper(si->label);
						/* label_plain is directly derived from label */
					if( !si->label_plain || !strlen(si->label_plain) )
						si->label_plain = " ";
				}
				break;


			case DT_SHORT_REGISTER:
			case DT_REGISTER:
				for(sr=sitem->map_reg; sr; sr=sr->next) {
					if( !sr->label || !strlen(sr->label) ) {
						/* it is okay to omit a register label */
						/* invalid_sitem(sitem, "register LABEL"); */
						sr->label = " ";
					}
					convert_toupper(sr->label);
					if( !sr->doc || !strlen(sr->doc) )
						sr->doc = "nil";
					if( sr->class == DC_CODED ) {
						for(sri=sr->map_std_reg_field_index;
							sri; sri=sri->next) {
							if( !sri->label  || !strlen(sri->label) ) {
							  invalid_sitem(sitem, 
										"register MAP missing label");
							  sri->label = " ";
							}
							convert_toupper(sri->label);
							/* don't check sri->value since anything is valid */
						}
					}
					if( sr->class <= 0 ) {
						invalid_sitem(sitem, "register CLASS");
						fprintf(stderr, "  register LABEL=%s\n", sr->label);
					}
					if( sr->size <= 0 ) {
						invalid_sitem(sitem, "register SIZE");
						fprintf(stderr, "  register LABEL=%s\n", sr->label);
					}
						/* it's okay to omit display if class is coded */
					if( sr->label_type <= 0 ) {
						if( sr->class == DC_CODED || sr->class == DC_FILLER ) {
							sr->label_type = DF_DEFAULT;
						} else {
							invalid_sitem(sitem, "register DISPLAY");
							fprintf(stderr, "  register LABEL=%s\n", sr->label);
						}
					}
				}
				break;

		}
	}
		/* now check for duplicate id numbers */
	for(sitem = first_sitem; sitem; sitem = sitem->next) {
		struct std_item *s2;
		if( sitem->id <= 0 )
			continue;
		for(s2 = sitem->next; s2; s2 = s2->next) {
			if(sitem->id == s2->id) {
			  errval = 1;
			  fprintf(stderr,
			  "Error, Duplicate std item id number (%d) in std items '%s' and '%s'\n",
			  sitem->id, sitem->name, s2->name);
			}
		}
	}
}

	/* data checks on std_segs,
		and any necessary references to other structures */
	/* Also, adjust things such as upper/lower case. */
check_std_segs()
{
	struct std_segment_element *sse;

	for(sseg = first_sseg; sseg; sseg = sseg->next) {
		if( !sseg->name || !strlen(sseg->name) ) {
			sseg->name = " ";
			invalid_sseg(sseg, "NAME");
		}
		convert_toupper(sseg->name);
		if( sseg->type_id <= 0 ) {
			invalid_sseg(sseg, "ID number");
		}
		if( sseg->type <= 0 ) {
			invalid_sseg(sseg, "ID type");
		}
		if( !sseg->label || !strlen(sseg->label) ) {
			/* it's okay to omit label */
			/* invalid_sseg(sseg, "LABEL"); */
			sseg->label = " ";
		}
		convert_toupper(sseg->label);
		if( !sseg->doc || !strlen(sseg->doc) ) {
			sseg->doc = " ";
		}
		for(sse=sseg->elements; sse; sse=sse->next) {
			if( !sse->name || !strlen(sse->name) ) {
				invalid_sseg(sseg, "ELEMENT");
				sse->name = " ";
			}
			convert_tolower(sse->name);
			sse->id = find_id_of_sitem(sse->name);
			if( !sse->id ) {
				errval = 1;
				fprintf(stderr,
					"Error, In std segment '%s' (id %s %d), no std item named '%s'\n",
					sseg->name, encode_type(sseg->type,seg_table),
					sseg->type_id, sse->name);
			}
		}
	}
		/* now check for duplicate id numbers */
	for(sseg = first_sseg; sseg; sseg = sseg->next) {
		struct std_segment *s2;
		if(sseg->type <= 0 || sseg->type_id <= 0)
			continue;
		for(s2 = sseg->next; s2; s2 = s2->next) {
			if(sseg->type == s2->type && sseg->type_id == s2->type_id) {
				errval = 1;
				fprintf(stderr,
						"Error, Duplicate std segment id type (%s) and number (%d)\n",
						encode_type(sseg->type,seg_table), sseg->type_id);
				fprintf(stderr, " in std segments '%s' and '%s'\n",
						sseg->name, s2->name);
			}
		}
	}
}

	/* data checks on os_items,
		and any necessary references to other structures */
	/* Also, adjust things such as upper/lower case. */
check_os_items()
{
	struct os_index *oi;

	for(oitem = first_oitem; oitem; oitem = oitem->next) {
		if( !oitem->name || !strlen(oitem->name) ) {
			invalid_oitem(oitem, "NAME");
			oitem->name = " ";
		}
		if( oitem->id <= 0 )
			invalid_oitem(oitem, "ID");
		if( oitem->type <= 0 )
			invalid_oitem(oitem, "TYPE");
		if( oitem->class <= 0 )
			invalid_oitem(oitem, "CLASS");
		if( oitem->size <= 0 )
			invalid_oitem(oitem, "SIZE");
		if( !oitem->doc || !strlen(oitem->doc) )
			oitem->doc = "nil";
		convert_tolower(oitem->name);
		for( oi = oitem->map; oi; oi=oi->next) {
			if( !oi->std_name || !strlen(oi->std_name) )
				oi->std_name = " ";
			convert_tolower(oi->std_name);
			oi->std_value = find_id_of_index(oi->std_name);
			if( !oi->std_value ) {
				errval = 1;
				fprintf(stderr,
					"Error, In os item %s (id %d), no std_item_index %s\n",
					oitem->name, oitem->id, oi->std_name);
			}
		}
	}
		/* now check for duplicate id numbers */
	for(oitem = first_oitem; oitem; oitem = oitem->next) {
		struct os_item *o2;
		if( oitem->id <= 0 )
			continue;
		for(o2 = oitem->next; o2; o2 = o2->next) {
			if(oitem->id == o2->id) {
			  errval = 1;
			  fprintf(stderr,
			  "Error, Duplicate os item id number (%d) in os items '%s' and '%s'\n",
			  oitem->id, oitem->name, o2->name);
			}
		}
	}
}

	/* output to bin file for std_items */
out_std_items()
{
	struct std_index *si;
	struct std_reg_field *sr;
	struct std_reg_field_index *sri;
	int need_nl, i;

	fprintf(bin_out, "1.2 %d\n", cnt_std_items);
	for(sitem = first_sitem; sitem; sitem = sitem->next) {
		need_nl = 0;
		fprintf(bin_out, "%d %s %d ", sitem->id, sitem->name, sitem->type);
		switch(sitem->type){
			case DT_BYTE_VECTOR:
			case DT_COUNTED_SHORT_VECTOR:
			case DT_COUNTED_LONG_VECTOR:
			case DT_ADDR_CNT_VECTOR:
				fprintf(bin_out, "%d %d |%s|\n",
						sitem->size, sitem->label_type, sitem->label);
				break;

			case DT_SHORT_INDEX:
			case DT_TINY_INDEX:
			case DT_INDEXED:
				fprintf(bin_out, "%d |%s| %d",
					sitem->label_type, sitem->label, sitem->map_index_count);
				need_nl = 1;
				/* print 13 entries for first line, 15 thereafter */
				for(i=13,si=sitem->map_index; si; si=si->next) {
					need_nl = 1;
					fprintf(bin_out,
						" %lu %s |%s|", si->value, si->name, si->label);
					if( !--i ) {
						fprintf(bin_out, "\n");
						i = 15;
						need_nl = 0;
					}
				}
				break;

			case DT_SHORT_REGISTER:
			case DT_REGISTER:
				fprintf(bin_out, "%d |%s| %d\n",
					sitem->label_type, sitem->label, sitem->map_reg_count);
				for(sr=sitem->map_reg; sr; sr=sr->next) {
					fprintf(bin_out, "%d %d %d |%s|",
						sr->size, sr->class, sr->label_type, sr->label);
					need_nl = 1;
					if( sr->class == DC_CODED ) {
						fprintf(bin_out,
							" %d", sr->map_std_reg_field_index_count);
						for(i=12,sri=sr->map_std_reg_field_index;
							sri; sri=sri->next) {
							need_nl = 1;
							fprintf(bin_out,
								" %lu |%s|", sri->value, sri->label);
							if( !--i ) {
								fprintf(bin_out, "\n");
								i = 12;
								need_nl = 0;
							}
						}
					}
					if( need_nl ) {
						fprintf(bin_out, "\n");
						need_nl = 0;
					}
				}
				break;

			default:
				fprintf(bin_out, "%d |%s|\n", sitem->label_type, sitem->label);
				break;
		}
		if( need_nl )
			fprintf(bin_out, "\n");
	}
}

	/* output to bin file for std_segs */
out_std_segs()
{
	struct std_segment_element *sse;

	fprintf(bin_out, "2.1 %d\n", cnt_std_segs);
	for(sseg = first_sseg; sseg; sseg = sseg->next) {
		fprintf(bin_out, "%d %d |%s|", sseg->type, sseg->type_id, sseg->label);
		fprintf(bin_out, " %d", sseg->elements_count);
		for(sse=sseg->elements; sse; sse=sse->next) {
			fprintf(bin_out, " %d", sse->id);
		}
		fprintf(bin_out, "\n");
	}
}

	/* output to bin file for os_items */
out_os_items()
{
	int i;
	struct os_index *oi;

	fprintf(bin_out, "4.1 %d\n", cnt_os_items);
	for(oitem = first_oitem; oitem; oitem = oitem->next) {
		fprintf(bin_out, "%d %d", oitem->id, oitem->type);
		switch(oitem->type) {
			case DT_BYTE_VECTOR:
			case DT_COUNTED_SHORT_VECTOR:
			case DT_COUNTED_LONG_VECTOR:
			case DT_ADDR_CNT_VECTOR:
			case DT_ASCIZ:
			case DT_BIT_VECTOR:
			case DT_SHORT_VECTOR:
			case DT_LONG_VECTOR:
				fprintf(bin_out, " %d", oitem->size);
				break;

			case DT_TINY_INDEX:
			case DT_SHORT_INDEX:
			case DT_INDEXED:
				fprintf(bin_out, " %d", oitem->map_count);
				for( i=50, oi = oitem->map; oi; oi=oi->next) {
					fprintf(bin_out, " %lu %lu", oi->os_value, oi->std_value);
					if(!--i) {
						fprintf(bin_out, "\n");
						i=50;
					}
				}
				break;

			default:
				break;
		}
		fprintf(bin_out, "\n");
	}
}