dsd_build.c

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

#ifndef lint
static char sccsid[]  =  "@(#)dsd_build.c	4.2   (ULTRIX)   10/16/90";
#endif lint 
/*
**	.title DSD Table Build Functions
**	.ident / 1.16 /
**
**
**	  File:	dsd_build.c
** Description:	DSD Table Build Functions
**	Author:	Luis Arce
**	  Date:	10-Nov-1986
**
**
**	Copyright 1986, Digital Equipment Corporation
**
**
**++
**	The DSD table build functions is a separate module that builds
**	the proper STD and O/S data structures using the data from the 
**	binary tables.
**
**	Several externs are created to allow outside access to the 
**	information in the structures.
**
**	The output structures can be compiled alone and then linked
**	with other onother object module.
**--
*/


#include <sys/file.h>
#include <limits.h>
#include <stdio.h>
#include "generic_dsd.h"	/* DSD table structure definitions */
#include "os_dsd.h"
#include "std_dsd.h"

/**********************************************************************/

#define os_codes_max			 1000
#define os_items_max			 1000
#define std_codes_max			10000
#define std_regs_max			10000
#define std_items_max			 5000
#define std_items_in_seg_max		10000
#define std_segs_max			 1500
#define labels_max			15000
#define strings_area_max	       200000

DD$OS_CODES_DSD      os_codes[os_codes_max+2];
DD$OS_ITEMS_DSD      os_items[os_items_max+2];
DD$STD_CODES_DSD     std_codes[std_codes_max+2];
DD$STD_REGS_DSD      std_regs[std_regs_max+2];
DD$STD_ITEMS_DSD     std_items[std_items_max+2];
DD$STD_SEG_ITEMS_DSD std_seg_items[std_items_in_seg_max+2];
DD$STD_SEGS_DSD      std_segs[std_segs_max+2];
DD$DSP_LABELS        labels[labels_max+2];
char		     strings_area[strings_area_max+2];

long		os_codes_count		= 1;
long		os_items_count		= 1;
long		std_codes_count		= 1;
long		std_regs_count		= 1;
long		std_items_count		= 1;
long		std_seg_items_count	= 1;
long		std_segs_count		= 1;
long		labels_count		= 1;
long		strings_area_count	= 1;

char            label[256];



/********************************************************************/

void  print_stuff ();
short get_item_size ();
long  get_item_index ();
long  save_label();

/********************************************************************/

main ()
{

FILE	*ifp;				/* file pointer */
long    ofd;				/* output file descriptor */

long    i;
long    j;
long	off;
short   item_id;
long	status;
long    format;
long	count;

long    file_ver;
char    file_name[32];
char    name[256];
float	version;

strcpy(file_name,"uerf.bin");

if ((ifp = fopen("ultrix_dsd.bin", "r")) == NULL)
    {
    printf("\nCan't open input file ultrix_dsd.bin!\n");
    return(DD$BAD_BIN_FILE);
    }
status = fscanf(ifp, "%ld", &file_ver);
if (status != 1)
    {
    printf("\nError reading .bin file - no file version!\n");
    print_stuff(status);
    return(DD$BAD_BIN_FILE);
    }

status = fscanf(ifp, "%[^|]|", name);	/* Bypass header */

status = fscanf(ifp, " Start of %s */ %ld", name, &format);

if (status != 2)
    {
    printf("\nError reading .bin file! a\n");
    print_stuff(status);
    return(DD$BAD_BIN_FILE);
    }
if (format != 3)
    {
    printf("\nWrong format .bin file!\n");
    return(DD$BAD_BIN_FILE);
    }

status = fscanf(ifp, " %f %ld",
			&version,
			&count);
if (status != 2)
    {
    printf("\nError reading .bin file! b\n");
    print_stuff(status);
    return(DD$BAD_BIN_FILE);
    }


/************************* STD-ITEM LOOP *************************/

for (std_items_count = 1; std_items_count <= count; std_items_count++)
    {
    if (std_items_count >= std_items_max)
        {
        printf("\nERROR - Not enough STD_ITEMS space!\n");
        print_stuff(99);
        return(DD$BAD_BIN_FILE);
        }
    std_items[std_items_count].COUNT = 0;
    std_items[std_items_count].INDEX = 0;

    status = fscanf(ifp, " %hd %s %hd",
			&std_items[std_items_count].ID,
			name,
			&std_items[std_items_count].TYPE);
    if (status != 3)
	{
	printf("\nError reading .bin file! c, count = %d\n", count);
        print_stuff(status);
	return(DD$BAD_BIN_FILE);
	}

    switch (std_items[std_items_count].TYPE)
      {
      case DT_BYTE_VECTOR:
      case DT_COUNTED_SHORT_VECTOR:
      case DT_COUNTED_LONG_VECTOR:
      case DT_ADDR_CNT_VECTOR:
	status = fscanf(ifp, " %hd",
			&std_items[std_items_count].COUNT);
	if (status != 1)
	    {
	    printf("\nError reading .bin file! d, count = %d\n", count);
            print_stuff(status);
	    return(DD$BAD_BIN_FILE);
	    }
        status = fscanf(ifp, " %hd |%[^|]|",
			&labels[labels_count].TYPE,
                        label);
        if (status != 2)
	    {
	    printf("\nError reading .bin file! e, count = %d\n", count);
            print_stuff(status);
	    return(DD$BAD_BIN_FILE);
	    }
	std_items[std_items_count].LABEL_IX = save_label();
      break;


			/********* CODED ITEM PROCESSING *********/

      case DT_SHORT_INDEX:
      case DT_INDEXED:
        status = fscanf(ifp, " %hd |%[^|]|",
			&labels[labels_count].TYPE,
                        label);
        if (status != 2)
	    {
	    printf("\nError reading .bin file! fcount = %d\n", count);
            print_stuff(status);
	    return(DD$BAD_BIN_FILE);
	    }
	std_items[std_items_count].LABEL_IX = save_label();

        status = fscanf(ifp, " %hd",
			&std_items[std_items_count].COUNT);
        if (status != 1)
	    {
	    printf("\nError reading .bin file! g, count = %d\n", count);
            print_stuff(status);
	    return(DD$BAD_BIN_FILE);
	    }

	if (std_items[std_items_count].COUNT != 0);
	    {
	    std_items[std_items_count].INDEX = std_codes_count;

				/******** CODE STRUCTURES ******/

	    for (i = 0; i < std_items[std_items_count].COUNT;
                            i++, std_codes_count++)
	        {
                if (std_codes_count >= std_codes_max)
                    {
                    printf("\nERROR - Not enough STD_CODES space!\n");
                    print_stuff(99);
                    return(DD$BAD_BIN_FILE);
                    }
	        status = fscanf (ifp, " %ld %s |%[^|]|", 
			&std_codes[std_codes_count].CODE,
			name,
                        label);
	        if (status != 3)
		    {
		    printf("\nError reading .bin file! h, count = %d, i = %d\n", count, i);
                    print_stuff(status);
		    return(DD$BAD_BIN_FILE);
		    }
		std_codes[std_codes_count].LABEL_IX = save_label();
	        }
	    }
      break;


			/******* REGISTER ITEM PROCESSING *******/

      case DT_SHORT_REGISTER:
      case DT_REGISTER:
        status = fscanf(ifp, " %hd |%[^|]|",
			&labels[labels_count].TYPE,
                        label);
        if (status != 2)
	    {
	    printf("\nError reading .bin file! i, count = %d\n", count);
            print_stuff(status);
	    return(DD$BAD_BIN_FILE);
	    }
	std_items[std_items_count].LABEL_IX = save_label();

        status = fscanf(ifp, " %hd",
			&std_items[std_items_count].COUNT);
        if (status != 1)
	    {
	    printf("\nError reading .bin file! j, count = %d\n", count);
            print_stuff(status);
	    return(DD$BAD_BIN_FILE);
	    }

	if (std_items[std_items_count].COUNT != 0);
	    {
	    std_items[std_items_count].INDEX = std_regs_count;

	    		/********** REGISTER FIELD LOOP **********/

	    for (i = 0; i < std_items[std_items_count].COUNT;
                            i++, std_regs_count++)
	        {
                if (std_regs_count >= std_regs_max)
                    {
                    printf("\nERROR - Not enough STD_REGS space!\n");
                    print_stuff(99);
                    return(DD$BAD_BIN_FILE);
                    }
                status = fscanf (ifp, " %hd %hd %hd |%[^|]|",
                	&std_regs[std_regs_count].SIZE,
                	&std_regs[std_regs_count].TYPE,
                        &labels[labels_count].TYPE,
                        label);
                if (status != 4)
		    {
		    printf("\nError reading .bin file! k, count = %d, i = %d\n", count, i);
                    print_stuff(status);
		    return(DD$BAD_BIN_FILE);
		    }
		std_regs[std_regs_count].LABEL_IX = save_label();
		std_regs[std_regs_count].COUNT = 0;
		std_regs[std_regs_count].CODE_IX = 0;
	        if (std_regs[std_regs_count].TYPE == DC_CODED)
		    {
	            status = fscanf(ifp, " %hd",
				&std_regs[std_regs_count].COUNT);
	            if (status != 1)
		        {
  		        printf("\nError reading .bin file! l, count = %d, i = %d\n", count, i);
                        print_stuff(status);
		        return(DD$BAD_BIN_FILE);
		        }

		    if (std_regs[std_regs_count].COUNT != 0)
			{
                        std_regs[std_regs_count].CODE_IX = std_codes_count;

			/********* CODED FIELD PROCESSING *********/

	                for (j = 0; j < std_regs[std_regs_count].COUNT;
                                    j++, std_codes_count++)
	        	    {
                            if (std_codes_count >= std_codes_max)
                                {
                                printf("\nERROR - Not enough STD_CODES space!\n");
                                print_stuff(99);
                                return(DD$BAD_BIN_FILE);
                                }
		            status = fscanf (ifp, " %ld |%[^|]|",
				&std_codes[std_codes_count].CODE,
                        	label);
		            if (status != 2)
		                {
        		        printf("\nError reading .bin file! m, count = %d, i = %d, j = %d\n", count, i, j);
                                print_stuff(status);
		                return(DD$BAD_BIN_FILE);
		                }
			    std_codes[std_codes_count].LABEL_IX = save_label();
			    }
		        }
		    }
	        }
	    }
      break;
      default:
        status = fscanf(ifp, " %hd |%[^|]|",
			&labels[labels_count].TYPE,
                        label);
        if (status != 2)
	    {
	    printf("\nError reading .bin file! n, count = %d\n", count);
            print_stuff(status);
	    return(DD$BAD_BIN_FILE);
	    }
	std_items[std_items_count].LABEL_IX = save_label();
      break;
      }
    }


/**************************** STD_SEGMENT_STRUCT ***********************/

status = fscanf(ifp, " %f %ld",
	    		&version,
	    		&count);
if (status != 2)
    {
    printf("\nError reading .bin file! o\n");
    print_stuff(status);
    return(DD$BAD_BIN_FILE);
    }

for (std_segs_count = 0; std_segs_count < count; std_segs_count++)
    {
    if (std_segs_count >= std_segs_max)
        {
        printf("\nERROR - Not enough STD_SEGS space!\n");
        print_stuff(99);
        return(DD$BAD_BIN_FILE);
        }
    status = fscanf(ifp, " %hd %hd |%[^|]| %hd",
			&std_segs[std_segs_count].TYPE,
			&std_segs[std_segs_count].SUBTYPE,
                        label,
			&std_segs[std_segs_count].COUNT);
    if (status != 4)
	{
	printf("\nError reading .bin file! p, count = %d\n", count);
        print_stuff(status);
	return(DD$BAD_BIN_FILE);
	}
    std_segs[std_segs_count].LABEL_IX = save_label();
    if (std_segs[std_segs_count].COUNT != 0)
	{
	std_segs[std_segs_count].SEG_ITEM_IX = std_seg_items_count;
	off = (DD$HEADER_BYTES + DD$VALID_BYTES(std_segs[std_segs_count].COUNT));
	off +=3;
	off &= 0xfffffffc;		/* longword alignment needed.  */
	std_segs[std_segs_count].STR_OFFSET = off; 

		/************ ITEMS IN SEGMENT LOOP *****************/

	for (i = 1; i <= std_segs[std_segs_count].COUNT;
		i++, std_seg_items_count++)
	    {
            if (std_seg_items_count >= std_items_in_seg_max)