/*********************************************************************/
/*                  pC++/Sage++  Copyright (C) 1993                  */
/*  Indiana University  University of Oregon  University of Rennes   */
/*********************************************************************/


/*------------------------------------------------------*
 *							*
 *	      Routines to read in BIF graph		*
 *							*
 *------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#ifdef SYS5
#include <string.h>
#else
#include <strings.h>
#endif

#ifdef __SPF
extern void addToCollection(const int line, const char *file, void *pointer, int type);
#endif

/*typedef unsigned int u_short;*/
#include "db.h"
#include "dep_str.h"
/*extern int strncmp(); */
#define NULL_CHECK(BASE,VALUE) ((VALUE) ? (BASE + (VALUE-1)): 0)

/*
 * External variables/functions referenced
 */
extern int debug;

int   language;			/* type of language of this dep file */

/*	       
 * Local variables
 */
static struct locs	floc;	/* used to read in preamble "floc" */
static struct preamble	head;	/* used to read in preamble "head" */
static struct bf_nd	bf;	/* used to read in bif nodes */
static struct ll_nd	ll;	/* used to read in ll nodes */
static struct sym_nd	sym;	/* used to read in symbol nodes */
static struct typ_nd	typ;	/* used to read in type nodes */
static struct lab_nd	lab;	/* used to read in label nodes */
static struct fil_nd	fil;	/* used to read in file nodes */
static struct cmt_nd	cmt;	/* used to read in comment nodes */
static struct dep_nd	dpd;	/* used to read in dep nodes */

static PTR_BLOB head_blob, cur_blob;
static PTR_BFND head_bfnd, cur_bfnd;
static PTR_LLND head_llnd, cur_llnd;
static PTR_SYMB head_symb, cur_symb;
static PTR_TYPE head_type, cur_type;
static PTR_DEP	head_dep,  cur_dep;
static PTR_LABEL head_lab, cur_lab;
static PTR_FNAME head_file;
static PTR_CMNT head_cmnt, cur_cmnt;
static PTR_BFND global_bfnd;

static char **strtbl;		/* starting address of string table */
static u_shrt tmp[10000];	/* temp working area */
static FILE *fd;		/* local copy of file id for the dep file */
static PTR_FILE lfi;
static int need_swap = 0;	/* set to 1 if we need to swap bytes */

void swab();
/********************************************************
 *			swap_w				*
 *							*
 *	     Swap bytes of one word (2 bytes)		*
 ********************************************************/
static void
swap_w(p)
	char *p;
{
    char c;

    c = *(p+1);
    *(p+1) = *p;
    *p = c;
}


/********************************************************
 *			swap_i				*
 *							*
 *	     Swap bytes of an integer (4 bytes)		*
 ********************************************************/
static void
swap_i(p)
	char *p;
{
    char c;

    c = *(p+3);			/* swap the 1st and 4th bytes */
    *(p+3) = *p;
    *p++ = c;
    c = *p;			/* swap the 2nd and 3rd bytes */
    *p = *(p+1);
    *(p+1) = c;
}


/********************************************************
 *			swap_l (phb)                    *
 *							*
 *	     Swap bytes of an 64bit long (8 bytes)      *
 ********************************************************/
/* UNDER CONSTRUCTION, FIXME */
/*static void
swap_l(p)
	char *p;
{
    char c;
    c = *(p+3);			// swap the 1st and 4th bytes 
    *(p+3) = *p;
    *p++ = c;
    c = *p;			// swap the 2nd and 3rd bytes 
    *p = *(p+1);
    *(p+1) = c;
}*/


/*------------------------------------------------------*
 *		   read_str_tbl				*
 *							*
 *	Read in the string table in dep file		*
 *------------------------------------------------------*/
static int
read_str_tbl()
{
    int	     i, n, sz;
    u_shrt  u;
    char    *s;
    char   **cp;

    /*
     * Fast forward to where the string table starts
     */
    if (fseek(fd, floc.strs, 0) < 0)
	return -1;

    /*
     * The first word is the total number of strings in the dep file
     */

    /* get size of string table */
    if ((int)fread( (char *) &u, sizeof(u_shrt), 1, fd) < 0) 
	return -1;

    if (need_swap)
	swap_w((char *)&u);
    sz = (int) u;
    if ((cp = strtbl = (char **)malloc(sz * sizeof(char *))) == NULL)
    {
        fprintf(stderr, "read_str_tbl: No more space\n");
        exit(1);
    }
#ifdef __SPF
    addToCollection(__LINE__, __FILE__,cp, 0);
#endif

    /*
     * Then followed by strings in the form of
     *		-------------------------
     *		| str length | contents	|
     *		-------------------------
     */
    for (i = 0; i < sz; i++) {
        /* get string length */
	if ((int)fread( (char *) &u, sizeof(u_shrt), 1, fd) < 0) 

	    return -1;
	if (need_swap)
	    swap_w((char *)&u);
	n = (int) u;
	if ((s = malloc(n+1)) == NULL) 
    {
	    fprintf(stderr, "read_str_tbl: No more space\n");
	    exit(1);
	}
#ifdef __SPF
    addToCollection(__LINE__, __FILE__,s, 0);
#endif
	if ((int)fread(s, sizeof(char), n, fd) < 0) /* now the content */
	    return -1;
	*(s+n) = '\0';
	*cp++ = s;
    }
    return 0;
}


/*--------------------------------------------------------------*
 *			read_preamble				*
 *	    Read in the preamble part of the dep file		*
 *--------------------------------------------------------------*/
static int
read_preamble()
{
    int i;
    char filemagic[10];

    /* The first 8 bytes is the file magic (see /etc/magic) PHB */
    if ((int)fread(filemagic, sizeof(char), 8, fd) < 0)
        return -1;
    if (strncmp("sage.dep",filemagic,8) != 0) {
      fprintf(stderr, "This is not a legal .dep file\n");
      return -2;
    }

    /* First word (2 bytes) in the dep file is a pre-selected magic number */
    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0)
	return -1;
    if (*tmp != D_MAGIC) {	/* Is this a dep file? */
	need_swap = 1;		/* No... */
	swap_w((char *)tmp);		/*  ... Maybe we need to swap bytes */
	if(*tmp != D_MAGIC) {	/* Try again */
	  fprintf(stderr, "Are you sure this is a legal dep file? %x\n",*tmp);
	  return -2;
	}
    }
    
    /*
     * The second part is for double checking machanism.  Here we have
     * the starting locations (offsets) of low level nodes, symbol nodes,
     * type nodes, label nodes, comment nodes, file nodes, dep nodes and
     * string table (relative to the beginning of file).
     */

    /* Some more data */
    if ((int)fread( (char *) &floc, sizeof(struct locs), 1, fd) < 0)
	return -1;

    if (need_swap) {
	swap_i((char *)&floc.llnd);	/* !! long !! 64bit? (phb) */
	swap_i((char *)&floc.symb);	/* !! long !! 64bit? (phb) */
	swap_i((char *)&floc.type);	/* !! long !! 64bit? (phb) */
	swap_i((char *)&floc.labs);	/* !! long !! 64bit? (phb) */
	swap_i((char *)&floc.cmnt);	/* !! long !! 64bit? (phb) */
	swap_i((char *)&floc.file);	/* !! long !! 64bit? (phb) */
	swap_i((char *)&floc.deps);	/* !! long !! 64bit? (phb) */
	swap_i((char *)&floc.strs);	/* !! long !! 64bit? (phb) */
    }
    
    /* Reconstruct the string table first */
    if (read_str_tbl() < 0)
	return -1;

    /* rewind back to the point after "locs" information (8 is filemagic) */
    if (fseek(fd, sizeof(u_shrt)+sizeof(struct locs)+8, 0) < 0)
	return -1;

    /*
     * Read in the second part of preamble.  Here we have numbers of
     * all nodes (bif, low level, etc.) for this dep file
     */
    if ((int)fread( (char *) &head, sizeof(struct preamble), 1, fd) < 0)
	return -1;
    if (need_swap)
	swab((char *)&head, (char *)&head, sizeof(struct preamble));

    language = lfi->lang = (int)head.language;

    if ((sizeof(void *) * 8) != (int) head.ptrsize) {
	fprintf(stderr, "WARNING: .dep file created on a %d bit machine\n",
            head.ptrsize);
	return -2;
      }
	
    lfi->num_blobs = (int) head.num_blobs;
    lfi->num_bfnds = (int) head.num_bfnds;
    lfi->num_llnds = (int) head.num_llnds;
    lfi->num_symbs = (int) head.num_symbs;
    lfi->num_types = (int) head.num_types;
    lfi->num_label = (int) head.num_label;
    lfi->num_dep   = (int) head.num_dep;
    lfi->num_cmnt  = (int) head.num_cmnts;
    lfi->num_files = (int) head.num_files;

    /*
     * Now use those numbers to allocate all nodes for this dep file
     */
    lfi->head_blob = head_blob = (PTR_BLOB)(lfi->num_blobs>0? calloc(lfi->num_blobs, sizeof(struct blob)): NULL);
    lfi->head_bfnd = head_bfnd = (PTR_BFND)(lfi->num_bfnds>0? calloc(lfi->num_bfnds, sizeof(struct bfnd)): NULL);
    lfi->head_llnd = head_llnd = (PTR_LLND)(lfi->num_llnds>0? calloc(lfi->num_llnds, sizeof(struct llnd)): NULL);
    lfi->head_symb = head_symb = (PTR_SYMB)(lfi->num_symbs>0? calloc(lfi->num_symbs, sizeof(struct symb)): NULL);
    lfi->head_type = head_type = (PTR_TYPE)(lfi->num_types>0? calloc(lfi->num_types, sizeof(struct data_type)): NULL);
    lfi->head_dep  = head_dep  = (PTR_DEP)(lfi->num_dep >0 ?  calloc(lfi->num_dep,	 sizeof(struct dep)) : NULL);
    lfi->head_lab  = head_lab  = (PTR_LABEL)(lfi->num_label>0? calloc(lfi->num_label, sizeof(struct Label)): NULL);
    lfi->head_cmnt = head_cmnt = (PTR_CMNT)(lfi->num_cmnt>0 ? calloc(lfi->num_cmnt,	 sizeof(struct cmnt)): NULL);
    lfi->head_file = head_file = (PTR_FNAME)(lfi->num_files>0? calloc(lfi->num_files, sizeof(struct file_name)): NULL);
     
#ifdef __SPF
    if (lfi->head_blob) addToCollection(__LINE__, __FILE__,lfi->head_blob, 0);
    if (lfi->head_bfnd) addToCollection(__LINE__, __FILE__,lfi->head_bfnd, 0);
    if (lfi->head_llnd) addToCollection(__LINE__, __FILE__,lfi->head_llnd, 0);
    if (lfi->head_symb) addToCollection(__LINE__, __FILE__,lfi->head_symb, 0);
    if (lfi->head_type) addToCollection(__LINE__, __FILE__,lfi->head_type, 0);
    if (lfi->head_dep) addToCollection(__LINE__, __FILE__,lfi->head_dep, 0);
    if (lfi->head_lab) addToCollection(__LINE__, __FILE__,lfi->head_lab, 0);
    if (lfi->head_cmnt) addToCollection(__LINE__, __FILE__,lfi->head_cmnt, 0);
    if (lfi->head_file) addToCollection(__LINE__, __FILE__,lfi->head_file, 0);
#endif

    lfi->global_bfnd = global_bfnd = head_bfnd + ((int)head.global_bfnd - 1);

    cur_blob   = head_blob;
    cur_bfnd   = lfi->num_bfnds>0 ? head_bfnd + (lfi->num_bfnds - 1) : NULL;
    cur_llnd   = lfi->num_llnds>0 ? head_llnd + (lfi->num_llnds - 1) : NULL;
    cur_symb   = lfi->num_symbs>0 ? head_symb + (lfi->num_symbs - 1) : NULL;
    cur_type   = lfi->num_types>0 ? head_type + (lfi->num_types - 1) : NULL;
    cur_dep    = lfi->num_dep  >0 ? head_dep  + (lfi->num_dep	- 1) : NULL;
    cur_lab    = lfi->num_label>0 ? head_lab  + (lfi->num_label - 1) : NULL;
    cur_cmnt   = lfi->num_cmnt >0 ? head_cmnt + (lfi->num_cmnt	- 1) : NULL;

    for (i = 0; i < lfi->num_bfnds; i++) {
	(head_bfnd + i)->id	= i + 1;
	(head_bfnd + i)->thread = head_bfnd + (i + 1);
    }
    if (lfi->num_bfnds > 0)	/* the thread field of the last entry was... */
	cur_bfnd->thread = NULL; /* ...changed in the previous loop */

    for (i = 0; i < lfi->num_llnds; i++) {
	(head_llnd + i)->id	= i + 1;
	(head_llnd + i)->thread = head_llnd + (i + 1);
    }
    if (lfi->num_llnds > 0)
	cur_llnd->thread = NULL;

    for (i = 0; i < lfi->num_symbs; i++) {
	(head_symb + i)->id	= i + 1;
	(head_symb + i)->thread = head_symb + (i + 1);
    }
    if (lfi->num_symbs > 0)
	cur_symb->thread = NULL;

    for (i = 0; i < lfi->num_types; i++) {
	(head_type + i)->id	= i + 1;
	(head_type + i)->thread = head_type + (i + 1);
    }
    if (lfi->num_types > 0)
	cur_type->thread = NULL;

    for (i = 0; i < lfi->num_files; i++){
	(head_file + i)->id = i + 1;
	(head_file + i)->next = head_file + (i + 1);
    }
    if (lfi->num_files > 0)
	(head_file+(lfi->num_files-1))->next = NULL;

    for (i = 0; i < lfi->num_dep; i++) {
	(head_dep + i)->id     = i + 1;
	(head_dep + i)->thread = head_dep + (i + 1);
    }
    if (lfi->num_dep > 0)
	cur_dep->thread = NULL;

    for (i = 0; i < lfi->num_label; i++) {
	(head_lab + i)->id     = i + 1;
	(head_lab + i)->next = head_lab + (i + 1);
    }
    if (lfi->num_label > 0)
	cur_lab->next = NULL;

    for (i = 0; i < lfi->num_cmnt; i++) {
	(head_cmnt + i)->id	= i + 1;
	(head_cmnt + i)->thread = head_cmnt + (i + 1);
    }
    if (lfi->num_cmnt > 0)
	cur_cmnt->thread = NULL;
    return 0;
}


/*------------------------------------------------------*
 *		    read_blob_nodes			*
 *							*
 *		Reads in a blob list			*
 *------------------------------------------------------*/
static PTR_BLOB
read_blob_nodes() 
{
    int i, n;
    PTR_BLOB head, blnd_ptr = NULL;

    /* read in the count */
    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0) { 
	perror("read_blob_nodes:");
	return NULL;
    }
    if (need_swap)
	    swap_w((char *)tmp);
    if (!(n = (int)(*tmp)))
	return NULL;		/* count = 0; empty list */

    head = cur_blob;

    /* read in blob list */
    if ((int)fread( (char *) tmp, sizeof(u_shrt), n, fd) < 0) { 
	perror("read_blob_nodes:");
	return NULL;
    }
    if (need_swap)
	    swab((char *)tmp, (char*)tmp, n*sizeof(u_shrt));

    for (i = 0; i < n; i++) {	/* re-contruct the blob nodes */
	blnd_ptr	= cur_blob++;
	blnd_ptr->next	= cur_blob;
	blnd_ptr->ref	= head_bfnd + (tmp[i] - 1);
    }
    blnd_ptr->next = NULL;

    return head;
}


/*--------------------------------------------------------------*
 *			read_bif_nodes				*
 *								*
 *		routines to read in bif nodes			*
 *--------------------------------------------------------------*/
static int
read_bif_nodes() 
{
    PTR_BFND bfnd_ptr;
    int i;

    for (i = 0; i < lfi->num_bfnds; i++) {
        /* read in a bif node */
	if ((int)fread( (char *) &bf, sizeof(struct bf_nd), 1, fd) < 0) 
	    return -1;
	if (need_swap)
	    swab((char *)&bf, (char *)&bf, sizeof(struct bf_nd));
	if (debug)
	    fprintf(stderr,"Processing bif %d\n",i);
	bfnd_ptr		 = head_bfnd + i;
	bfnd_ptr->variant	 = (int) bf.variant;
	bfnd_ptr->filename	 = NULL_CHECK(head_file, bf.filename);
	bfnd_ptr->control_parent = NULL_CHECK(head_bfnd, bf.cp);
	bfnd_ptr->label		 = NULL_CHECK(head_lab, bf.label);
	bfnd_ptr->entry.Template.bf_ptr1  = NULL_CHECK(head_bfnd,bf.bf_ptr1);
	bfnd_ptr->entry.Template.cmnt_ptr = NULL_CHECK(head_cmnt,bf.cmnt_ptr);
	bfnd_ptr->entry.Template.symbol	  = NULL_CHECK(head_symb,bf.symbol);
	bfnd_ptr->entry.Template.ll_ptr1  = NULL_CHECK(head_llnd,bf.ll_ptr1);
	bfnd_ptr->entry.Template.ll_ptr2  = NULL_CHECK(head_llnd,bf.ll_ptr2);
	bfnd_ptr->entry.Template.ll_ptr3  = NULL_CHECK(head_llnd,bf.ll_ptr3);
	bfnd_ptr->entry.Template.dep_ptr1 = NULL_CHECK(head_dep, bf.dep_ptr1);
	bfnd_ptr->entry.Template.dep_ptr2 = NULL_CHECK(head_dep, bf.dep_ptr2);
	bfnd_ptr->entry.Template.lbl_ptr  = NULL_CHECK(head_lab, bf.lbl_ptr);
	bfnd_ptr->g_line		  = (int) bf.g_line;
	bfnd_ptr->l_line		  = (int) bf.l_line;
	bfnd_ptr->decl_specs		  = (int) bf.decl_specs;
	bfnd_ptr->entry.Template.bl_ptr1  = read_blob_nodes();
	bfnd_ptr->entry.Template.bl_ptr2  = read_blob_nodes();
    }
    return 0;
}


/*--------------------------------------------------------------*
 *			read_ll_nodes				*
 *								*
 *		      routines to read ll_nodes			*
 *--------------------------------------------------------------*/
static int
read_ll_nodes()
{
    PTR_LLND llnd_ptr;
    int i;

    for(i = 0; i < lfi->num_llnds; i++) {
	if ((int)fread( (char *) &ll, sizeof(struct ll_nd), 1, fd) < 0)
	    return -1;
	if (need_swap)
	    swab((char *)&ll, (char *)&ll, sizeof(struct ll_nd));

	llnd_ptr	  = head_llnd + i;
	llnd_ptr->variant = (int) ll.variant; 
	llnd_ptr->type	  = NULL_CHECK(head_type, ll.type);

	switch(llnd_ptr->variant) {
	case INT_VAL :
	    if ((int)fread( (char *) &llnd_ptr->entry.ival, sizeof(int), 1, fd) < 0)
		return -1;
	    if (need_swap)
		swap_i((char *)&llnd_ptr->entry.ival);
	    break;
	case BOOL_VAL :
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0)
		return -1;
	    if (need_swap)
		swap_w((char *)tmp);
	    llnd_ptr->entry.bval = (int)(*tmp);
	    break;
	case CHAR_VAL :
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0)
		return -1;
	    if (need_swap)
		swap_w((char *)tmp);
	    llnd_ptr->entry.cval = (char)(*tmp);
	    break;
	case DOUBLE_VAL:
	case FLOAT_VAL :
	case STMT_STR  :
	case STRING_VAL:
	case KEYWORD_VAL:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0)
		return -1;
	    if (need_swap)
		swap_w((char *)tmp);
	    llnd_ptr->entry.string_val = *(strtbl+(*tmp));
	    break;
	case RANGE_OP  :
	case UPPER_OP  :
	case LOWER_OP  :
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 2, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 2*sizeof(u_shrt));
	    llnd_ptr->entry.array_op.symbol= NULL_CHECK(head_symb,(*tmp));
	    llnd_ptr->entry.array_op.dim   = (int)tmp[1];
	    break;
	case LABEL_REF :
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0)
		return -1;
	    if (need_swap)
		swap_w((char *)tmp);
	    llnd_ptr->entry.label_list.lab_ptr= NULL_CHECK(head_lab,(*tmp));
	    break;
/*	case ARITH_ASSGN_OP:*/	/* New added for VPC++	*/
/*	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 3, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 3*sizeof(u_shrt));
*/		
/* The next line is a _REAL_ hack, I added the cast (PHB) */
/*	    llnd_ptr->entry.Template.symbol = (PTR_SYMB) ((int) tmp[0]);
	    llnd_ptr->entry.Template.ll_ptr1 = NULL_CHECK(head_llnd,tmp[1]);
	    llnd_ptr->entry.Template.ll_ptr2 = NULL_CHECK(head_llnd,tmp[2]);
	    break;
*/	    
	default:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 3, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 3*sizeof(u_shrt));
	    llnd_ptr->entry.Template.symbol =NULL_CHECK(head_symb,(*tmp));
	    llnd_ptr->entry.Template.ll_ptr1=NULL_CHECK(head_llnd,tmp[1]);
	    llnd_ptr->entry.Template.ll_ptr2=NULL_CHECK(head_llnd,tmp[2]);
	}
    }
    return 0;
}


/*--------------------------------------------------------------*
 *								*
 *		  routines to read symbol table			*
 *								*
 *--------------------------------------------------------------*/
static int
read_symb_nodes()
{
    PTR_SYMB symb_ptr;
    int i;

    for(i = 0; i < lfi->num_symbs; i++) {
	if ((int)fread( (char *) &sym, sizeof(struct sym_nd), 1, fd) < 0)
	    return -1;
	if (need_swap)
	    swab((char *)&sym, (char *)&sym, sizeof(struct sym_nd));

	symb_ptr	    = head_symb + i;
	symb_ptr->variant   = (int) sym.variant;
	symb_ptr->type	    = NULL_CHECK(head_type, sym.type);
	symb_ptr->attr	    = (int) sym.attr;
	symb_ptr->next_symb = NULL_CHECK(head_symb, sym.next);
	symb_ptr->scope	    = NULL_CHECK(head_bfnd, sym.scope);
	symb_ptr->ident	    = *(strtbl + sym.ident);

	switch (symb_ptr->variant) {
	case DEFAULT	:
	case TYPE_NAME	:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0)
		return -1;
            if (need_swap)
		swab((char *)tmp, (char *)tmp, 1*sizeof(u_shrt));
            symb_ptr->entry.Template.base_name = NULL_CHECK(head_symb,tmp[0]);
	    break;
	case CONST_NAME	:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 2, fd) < 0)
		return -1;
	    if (need_swap)
		/*swap_w((char *)tmp);*/
                swab((char *)tmp, (char *)tmp, (2)*sizeof(u_shrt));
	    symb_ptr->entry.const_value = NULL_CHECK(head_llnd,(*tmp));
            symb_ptr->entry.Template.base_name = NULL_CHECK(head_symb,tmp[1]);
	    break;
	case ENUM_NAME	:
	case FIELD_NAME	:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 5, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 5*sizeof(u_shrt));
	    symb_ptr->entry.field.tag	= (int)(*tmp);
	    symb_ptr->entry.field.next	= NULL_CHECK(head_symb,tmp[1]);
	    symb_ptr->entry.field.base_name= NULL_CHECK(head_symb,tmp[2]);
	    symb_ptr->entry.field.declared_name = NULL_CHECK(head_symb,tmp[3]);
	    symb_ptr->entry.field.restricted_bit= NULL_CHECK(head_llnd,tmp[4]);
	    break;
	case VARIABLE_NAME:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 3+1, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, (3+1)*sizeof(u_shrt));
	    symb_ptr->entry.var_decl.local  = (int)(*tmp);
	    symb_ptr->entry.var_decl.next_in= NULL_CHECK(head_symb,tmp[1]);
	    symb_ptr->entry.var_decl.next_out=NULL_CHECK(head_symb,tmp[2]);
            symb_ptr->entry.Template.base_name = NULL_CHECK(head_symb,tmp[3]);
	    break;
	case PROGRAM_NAME:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 2+1, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, (2+1)*sizeof(u_shrt));

	    symb_ptr->entry.prog_decl.symb_list = NULL_CHECK(head_symb,(*tmp));
	    symb_ptr->entry.prog_decl.prog_hedr = NULL_CHECK(head_bfnd,tmp[1]);
            symb_ptr->entry.Template.base_name = NULL_CHECK(head_symb,tmp[2]);
	    break;
	    break;
	case PROCEDURE_NAME :
        case PROCESS_NAME:
	case FUNCTION_NAME:	 
	case INTERFACE_NAME:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 8+1, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, (8+1)*sizeof(u_shrt));

	    symb_ptr->entry.proc_decl.num_input	 = (int)(*tmp);
	    symb_ptr->entry.proc_decl.num_output = (int)tmp[1];
	    symb_ptr->entry.proc_decl.num_io	 = (int)tmp[2];
	    symb_ptr->entry.proc_decl.in_list =NULL_CHECK(head_symb,tmp[3]);
	    symb_ptr->entry.proc_decl.out_list =NULL_CHECK(head_symb,tmp[4]);
	    symb_ptr->entry.proc_decl.symb_list=NULL_CHECK(head_symb,tmp[5]);
	    symb_ptr->entry.proc_decl.proc_hedr=NULL_CHECK(head_bfnd,tmp[6]);
            symb_ptr->entry.proc_decl.local_size = (int)tmp[7];
            symb_ptr->entry.Template.base_name = NULL_CHECK(head_symb,tmp[8]);
	    break;
	case MODULE_NAME:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 2+1, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, (2+1)*sizeof(u_shrt));

	    symb_ptr->entry.Template.symb_list = NULL_CHECK(head_symb,(*tmp));
	    symb_ptr->entry.Template.func_hedr = NULL_CHECK(head_bfnd,tmp[1]);
            symb_ptr->entry.Template.base_name = NULL_CHECK(head_symb,tmp[2]);
	    break;
	case MEMBER_FUNC:	/*  NEW ADDED FOR VPC */
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 11, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 11*sizeof(u_shrt));
	    symb_ptr->entry.member_func.num_input  = (int)(*tmp);
	    symb_ptr->entry.member_func.num_output = (int)tmp[1];
	    symb_ptr->entry.member_func.num_io	   = (int)tmp[2];
	    symb_ptr->entry.member_func.in_list =NULL_CHECK(head_symb,tmp[3]);
	    symb_ptr->entry.member_func.out_list =NULL_CHECK(head_symb,tmp[4]);
	    symb_ptr->entry.member_func.symb_list  =NULL_CHECK(head_symb,tmp[5]);
	    symb_ptr->entry.member_func.func_hedr  =NULL_CHECK(head_bfnd,tmp[6]);
	    symb_ptr->entry.member_func.next	   =NULL_CHECK(head_symb,tmp[7]);
	    symb_ptr->entry.member_func.base_name  =NULL_CHECK(head_symb,tmp[8]);
	    symb_ptr->entry.member_func.declared_name =NULL_CHECK(head_symb,tmp[9]);
            symb_ptr->entry.member_func.local_size = (int)tmp[10];
	
	    break;
	case VAR_FIELD :
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 4, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 4*sizeof(u_shrt));
	    symb_ptr->entry.variant_field.tag  = tmp[0];
	    symb_ptr->entry.variant_field.next = NULL_CHECK(head_symb, tmp[1]);
	    symb_ptr->entry.variant_field.base_name = NULL_CHECK(head_symb, tmp[2]);
	    symb_ptr->entry.variant_field.variant_list = NULL_CHECK(head_llnd, tmp[3]);
	    break;
	default:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0)
		return -1;
            if (need_swap)
		swab((char *)tmp, (char *)tmp, 1*sizeof(u_shrt));
            symb_ptr->entry.Template.base_name = NULL_CHECK(head_symb,tmp[0]);
	    break;
	}
    }
    return 0;
}


/*----------------------------------------------------------------------*
 *									*
 *		    routines to read type table				*
 *									*
 *----------------------------------------------------------------------*/
static int
read_type_nodes()
{
    PTR_TYPE type_ptr;
    int i, uss1, uss2;

    for(i = 0; i < lfi->num_types; i++) {
	if ((int)fread( (char *) &typ, sizeof(struct typ_nd), 1, fd) < 0)
	    return -1;
	if (need_swap)
	    swab((char *)&typ, (char *)&typ, sizeof(struct typ_nd));

	type_ptr		= head_type + i;
	type_ptr->variant	= (int)typ.variant;
	type_ptr->name		= NULL_CHECK(head_symb,typ.name);

	switch (type_ptr->variant) {
	case T_INT	:
	case T_FLOAT	:
	case T_DOUBLE	:
	case T_CHAR	:
	case T_BOOL	:
        case T_COMPLEX  :
        case T_DCOMPLEX  :
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 2, fd) < 0)
		return -1;
	    if (need_swap)
		swap_w((char *)tmp); 
		/* swab((char *)tmp, (char *)tmp, sizeof(u_shrt)); */
	    type_ptr->entry.Template.ranges    = NULL_CHECK(head_llnd,tmp[0]);
	    type_ptr->entry.Template.kind_len  = NULL_CHECK(head_llnd,tmp[1]);
	    break;
	case T_STRING	:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 3, fd) < 0)
		return -1;
	    if (need_swap)
		swap_w((char *)tmp); 
	    type_ptr->entry.Template.ranges    = NULL_CHECK(head_llnd,tmp[0]);
	    type_ptr->entry.Template.kind_len  = NULL_CHECK(head_llnd,tmp[1]);
	    type_ptr->entry.Template.dummy1    = (int)tmp[2];
	    break;
	case DEFAULT	:
	case T_VOID	:	/* NEW ADDED FOR VPC */
        case T_UNKNOWN  :
	case T_ENUM_FIELD:
	    break;
	case T_SUBRANGE	:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 3, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 3*sizeof(u_shrt));
	    type_ptr->entry.subrange.base_type = NULL_CHECK(head_type,tmp[0]);
	    type_ptr->entry.subrange.lower     = NULL_CHECK(head_llnd,tmp[1]);
	    type_ptr->entry.subrange.upper     = NULL_CHECK(head_llnd,tmp[2]);
	    break;
	case T_ARRAY	:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 3, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 3*sizeof(u_shrt));
	    type_ptr->entry.ar_decl.num_dimensions = (int)tmp[0];
	    type_ptr->entry.ar_decl.base_type = NULL_CHECK(head_type,tmp[1]);
	    type_ptr->entry.ar_decl.ranges    = NULL_CHECK(head_llnd,tmp[2]);
	    break;
	case T_LIST	:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0)
		return -1;
	    if (need_swap)
		swap_w((char *)tmp);
	    type_ptr->entry.base_type = NULL_CHECK(head_type,(*tmp));
	    break;

	case T_RECORD	:
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 2, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 2*sizeof(u_shrt));
	    type_ptr->entry.re_decl.num_fields = (int)(*tmp);
	    type_ptr->entry.re_decl.first      = NULL_CHECK(head_symb,tmp[1]);
	    break;
	case T_DESCRIPT:	/*  NEW ADDED FOR VPC */
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 7, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 7*sizeof(u_shrt));
	    type_ptr->entry.descriptive.signed_flag	= (int)tmp[0] ;
					           uss1  = (int)tmp[1];
					           uss2  = (int)tmp[2];
	    type_ptr->entry.descriptive.long_short_flag = (int) ((uss1 << 16) | uss2);
	    type_ptr->entry.descriptive.mod_flag	= (int)tmp[3] ;
	    type_ptr->entry.descriptive.storage_flag	= (int)tmp[4] ;
	    type_ptr->entry.descriptive.access_flag	= (int)tmp[5] ;
	    type_ptr->entry.descriptive.base_type	= NULL_CHECK(head_type,tmp[6]);
	    break;
        case T_REFERENCE:	/*  NEW ADDED FOR VPC */
	case T_POINTER: {	/*  NEW ADDED FOR VPC */
	    short int s;
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 4, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 4*sizeof(u_shrt));
	    type_ptr->entry.Template.base_type = NULL_CHECK(head_type,tmp[0]);
	    s = tmp[1];		/* hack!! since this is a singed short */
	    type_ptr->entry.Template.dummy1    = (int) s;
					 uss1  = (int)tmp[2];
					 uss2  = (int)tmp[3];
	    type_ptr->entry.Template.dummy5    = (int) ((uss1 << 16) | uss2);
	    }
	    break;
	case T_FUNCTION:	/*  NEW ADDED FOR VPC */
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 1, fd) < 0)
		return -1;
	    if (need_swap)
		swap_w((char *)tmp);
	    type_ptr->entry.Template.base_type = NULL_CHECK(head_type,(*tmp));
	    break;
	case T_DERIVED_TYPE :	/*  NEW ADDED FOR VPC */
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 2, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 2*sizeof(u_shrt));
	    type_ptr->entry.derived_type.symbol = NULL_CHECK(head_symb,tmp[0]);
	    type_ptr->entry.derived_type.scope_symbol = NULL_CHECK(head_symb,tmp[1]);
	    break;
        case T_MEMBER_POINTER:  /* for C::*  same as derived collection in structure */
	case T_DERIVED_COLLECTION:	/*  NEW ADDED FOR PC++ */
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 2, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 2*sizeof(u_shrt));
	    type_ptr->entry.col_decl.collection_name = NULL_CHECK(head_symb,tmp[0]);
	    type_ptr->entry.col_decl.base_type = NULL_CHECK(head_type,tmp[1]);
	    break;
	case T_DERIVED_TEMPLATE:	/*  NEW ADDED FOR PC++ */
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 2, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 2*sizeof(u_shrt));
	    type_ptr->entry.templ_decl.templ_name = NULL_CHECK(head_symb,tmp[0]);
	    type_ptr->entry.templ_decl.args = NULL_CHECK(head_llnd,tmp[1]);
	    break;

	case T_ENUM  :
	case T_UNION :		/*  NEW ADDED FOR VPC */
	case T_CLASS :		/*  NEW ADDED FOR VPC */
	case T_STRUCT :		/*  NEW ADDED FOR VPC */
	case T_DERIVED_CLASS :	/*  NEW ADDED FOR VPC */
	case T_COLLECTION:	/*  NEW ADDED FOR PC++ */
	    if ((int)fread( (char *) tmp, sizeof(u_shrt), 4, fd) < 0)
		return -1;
	    if (need_swap)
		swab((char *)tmp, (char *)tmp, 4*sizeof(u_shrt));
	    type_ptr->entry.derived_class.num_fields = (int)tmp[0] ;
	    type_ptr->entry.derived_class.first	     = NULL_CHECK(head_symb,tmp[1]);
	    type_ptr->entry.derived_class.original_class = NULL_CHECK(head_bfnd,tmp[2]);
	    type_ptr->entry.derived_class.base_type = NULL_CHECK(head_type,tmp[3]);
	    break;

	default :
	    break;
	}
    }
    return 0;
}


/*----------------------------------------------------------------------*
 *			    read_label_nodes				*
 *									*
 *			  Reads the label nodes				*
 *----------------------------------------------------------------------*/
static int
read_label_nodes()
{
    PTR_LABEL lab_ptr;
    int i;

    for (i=0; i < lfi->num_label; i++) {
	if ((int)fread( (char *) &lab, sizeof(struct lab_nd), 1, fd) < 0)
	    return -1;
	if (need_swap) {
	    swab((char *)&lab, (char *)&lab, sizeof(struct lab_nd)-sizeof(long));
	    swap_i((char *)&lab.stat_no);
	}
	
	lab_ptr	= head_lab +i;
	lab_ptr->stateno = lab.stat_no;
	lab_ptr->labtype = lab.labtype;
	lab_ptr->statbody= NULL_CHECK(head_bfnd, lab.body);
	lab_ptr->label_name= NULL_CHECK(head_symb,lab.name); /* for VPC */
    }
    return 0;
}


/*----------------------------------------------------------------------*
 *			  read_dep_nodes				*
 *									*
 *			Reads the dep nodes				*
 *----------------------------------------------------------------------*/
static int
read_dep_nodes()
{
    PTR_DEP dep;
    int i, j;

    for ( i=0; i < lfi->num_dep; i++ ) {
	if ((int)fread( (char *) &dpd, sizeof(struct dep_nd), 1, fd) < 0)
	    return -1;
	if (need_swap)
	    swab((char *)&dpd, (char *)&dpd, sizeof(struct dep_nd));

	dep = head_dep + (--dpd.id);
	dep->type	= (int)dpd.type;
	dep->symbol	= NULL_CHECK(head_symb,dpd.sym);
	dep->from.stmt	= NULL_CHECK(head_bfnd,dpd.from_stmt);
	dep->from.refer = NULL_CHECK(head_llnd,dpd.from_ref);
	dep->to.stmt	= NULL_CHECK(head_bfnd,dpd.to_stmt);
	dep->to.refer	= NULL_CHECK(head_llnd,dpd.to_ref);
      /* i dont know what these are!!!
	dep->from_hook	= NULL_CHECK(head_bfnd,dpd.from_hook);
	dep->to_hook	= NULL_CHECK(head_bfnd,dpd.to_hook);
       */
	dep->from_fwd	= NULL_CHECK(head_dep,dpd.from_fwd);
	dep->from_back	= NULL_CHECK(head_dep,dpd.from_back);
	dep->to_fwd	= NULL_CHECK(head_dep,dpd.to_fwd);
	dep->to_back	= NULL_CHECK(head_dep,dpd.to_back);

	for (j=0; j<MAX_DEP; j++ ) {
	    dep->direct[j] = (char)dpd.dire[j];
	}
    }
    return 0;
}


/*----------------------------------------------------------------------*
 *			  read_cmnt_nodes				*
 *									*
 *			Reads the comment nodes				*
 *----------------------------------------------------------------------*/
static int
read_cmnt_nodes()
{
    PTR_CMNT cmnt = lfi->head_cmnt;
    int i;

    for (i = 0; i < lfi->num_cmnt; i++) {
	if ((int)fread( (char *) &cmt, sizeof(struct cmt_nd), 1, fd) < 0)
	    return -1;
	if (need_swap)
	    swab((char *)&cmt, (char *)&cmt, sizeof(struct cmt_nd));

	cmnt->type   = (int) cmt.type;
	cmnt->next   = NULL_CHECK(head_cmnt, cmt.next);
	cmnt->string = *(strtbl + cmt.str);
	cmnt++;
    }
    return 0;
}


/*
 * strip_dot_slash tries to strip "./" from the filename
 */
static
void strip_dot_slash(s)
    char *s;
{
    char *p, *q, ch;

    while ((ch = *s++))
	if (ch == '.') {
	    if (*s == '/') {
		p = q = s++ - 1;
		while ((*p++ = *s++));
		s = q;
	    } else if (*s == '.')
		s++;
	}
}


/*----------------------------------------------------------------------*
 *			  read_filename_nodes				*
 *									*
 *			Reads the filename nodes			*
 *----------------------------------------------------------------------*/
static int
read_filename_nodes()
{
    int i;
    PTR_FNAME fp = head_file;

    for (i = 0; i < lfi->num_files; i++) {
	if ((int)fread( (char *) &fil, sizeof(struct fil_nd), 1, fd) < 0)
	    return -1;
	if (need_swap)
	    swab((char *)&fil, (char *)&fil, sizeof(struct fil_nd));

	strip_dot_slash(fp->name = *(strtbl + fil.name));
	fp++;
    }
    lfi->filename  = head_file->name;
    return 0;
}


/*------------------------------------------------------*
 *		    read_nodes				*
 *							*
 *		Drives the read routines		*
 *------------------------------------------------------*/
int
read_nodes(fi)
	PTR_FILE fi;
{
    need_swap = 0;
    lfi = fi;
    fd = fi->fid;
    if (read_preamble() < 0)
	return -1;

    if (read_bif_nodes() < 0)
	return -1;
    if (debug)
	fprintf(stderr,"bif nodes loaded\n");

    if (ftell(fd) != floc.llnd) {
	fprintf (stderr,"read_nodes: wrong location of low level nodes\n");
	if (fseek(fd, floc.llnd, 0) < 0)
	    return -1;
    }
    if (read_ll_nodes() < 0) {
	perror("read_ll_nodes:");
	return -1;
    }

    if (debug)
	fprintf(stderr,"low level nodes loaded\n");

    if (ftell(fd) != floc.symb) {
	fprintf(stderr,"read_nodes: wrong location of symbol nodes\n");
	if(fseek(fd, floc.symb, 0) < 0)
	    return -1;
    }
    if (read_symb_nodes() < 0)
	return -1;
    if (debug)
	fprintf(stderr,"symbol table loaded \n");

    if (ftell(fd) != floc.type) {
	fprintf(stderr,"read_nodes: wrong location of type nodes\n");
	if(fseek(fd, floc.type, 0) < 0)
	    return -1;
    }
    if (read_type_nodes() < 0)
	return -1;
    if (debug)
	fprintf(stderr,"type table loaded \n");

    if (ftell(fd) != floc.labs) {
	fprintf(stderr,"read_nodes: wrong location of label nodes\n");
	if(fseek(fd, floc.labs, 0) < 0)
	    return -1;
    }
    if (read_label_nodes() < 0)
	return -1;
    if (debug)
	fprintf(stderr,"label table loaded\n");

    if (ftell(fd) != floc.cmnt) {
	fprintf(stderr,"read_nodes: wrong location of comment nodes\n");
	if(fseek(fd, floc.cmnt, 0) < 0)
	    return -1;
    }
    if (read_cmnt_nodes() < 0)
	return -1;
    if (debug)
	fprintf(stderr,"comment strings loaded \n");

    if (ftell(fd) != floc.file) {
	fprintf(stderr,"read_nodes: wrong location of filename nodes\n");
	if(fseek(fd, floc.file, 0) < 0)
	    return -1;
    }
    if (read_filename_nodes() < 0)
	return -1;
    if (debug)
	fprintf(stderr,"filename table loaded\n");

    if (ftell(fd) != floc.deps) {
	fprintf(stderr,"read_nodes: wrong location of dependence arc nodes\n");
	if(fseek(fd, floc.deps, 0) < 0)
	    return -1;
    }
    if (read_dep_nodes() < 0)
	return -1;
    if (debug)
	fprintf(stderr,"dependence arcs loaded \n");

    /* Now set up the returned values */
    global_bfnd->control_parent = (PTR_BFND) fi;
    fi->cur_blob  = cur_blob;
    fi->cur_bfnd  = cur_bfnd;
    fi->cur_llnd  = cur_llnd;
    fi->cur_symb  = cur_symb;
    fi->cur_type  = cur_type;
    fi->cur_dep	  = cur_dep;
    fi->cur_lab	  = cur_lab;
    fi->cur_cmnt  = cur_cmnt;
    return 0;
}