sds_res.c

这是一个Linux下的集成开发环境

/* $Header: /cvsroot/sourcenav/src/snavigator/demo/c++_demo/sds/sds_res.c,v 1.1.1.1 2002/04/18 23:35:34 mdejong Exp $ */

/**************************************************************************
 *                 ****** ISTK Release 1.2 *****                          *
 *                                                                        *
 *                                                                        *
 * This code has been produced by numerous authors at the CERN centre for *
 * high energy physics, Geneve, Switzerland, at the SSC laboratory in     *
 * Dallas, Texas, USA and at the Lawrence Berekeley Laboratory in         *
 * California, USA.                                                       *
 * The latter two institutions perform work under US Government contract. *
 * The intent of the work is to provide useful code for people who need   *
 * it, with an emphasis on free and collaborative exchange of ideas,      *
 * techniques and implementations.                                        *
 * Please read the disclaimer and copyright notices contained in the ISTK *
 * distribution and in distributed applications.                          *
 *                                                                        *
 **************************************************************************/


/* Reference release  Aug 10 1991 - C G Saltmarsh */
/* Has the basics used at CDG & SSC 1988-1991, plus vxworks
   support
*/

#include <string.h>
#include <stdlib.h>

#ifndef vms
#include <unistd.h>
#ifndef VXWORKS
#include <memory.h>
#endif
#endif

#if defined(vms)
#include "sdsgen.h"
#include "sds_externs.h"
#else
#include "Sds/sdsgen.h"
#include "Sds/sds_externs.h"
#endif

#define    STACK_INC  16

#define ALL_ELEMENTS 1
#define ONE_ELEMENT 2


void           sds_prev_object(rescon *,int);
void           sds_next_object(rescon * );
sds_handle     sds_vdescribe(rescon *,struct sds_header *,struct direc *,
                             char *, char *,struct type_list *,sds_code,
                             struct sds_odesc **);
sds_handle    sds_vresolve(rescon *,struct sds_header *,struct direc *,
                           char *, char *, struct type_list *,sds_code,
                           struct sds_odesc **, int);
int           sds_nextname(char *,char *,char **);
sds_handle    sds_res_init(rescon *,struct sds_header *, struct direc *,
                             char *,char *, struct type_list *,sds_code,int);
void          sds_fix_align(struct sds_header *, rescon *);
unsigned long sds_rsize(sds_handle, sds_code, unsigned char *);

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

static char    rnull = (char)0;

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

void
sds_cleanc(rescon *c)
{
  if (c->stack_size && c->start_stack)
    free((char *)c->start_stack);
  c->stack_size = 0;
  c->addr_inc = 0;
  c->thiso = 0;
  c->start_stack = 0;
  c->cette = 0;
  c->parent = 0;
  c->tptr = 0;
  c->nheap = 0;
  c->base_address = 0;
  c->firstpass = 1;
  c->done = 0;
}

/***********************************************************************/
int
sds_describe(sds,object_index,thing_list)
sds_handle  sds;
sds_code  object_index;
struct   sds_odesc  **thing_list;
/***********************************************************************/
{

  struct direc     *dptr = sds_direc(sds);
  char             *heap = sds_heap(sds);
  char             *name = sds_obind2name(sds,0);
  struct type_list *tptr = sds_tlist(sds);
  struct sds_header *h   = sds_head(sds);
  rescon *c = sds_src(sds);
  if (!c) return -1;

  return (int)sds_vdescribe(c,h,dptr,heap,name,tptr,object_index,thing_list);
}
/***********************************************************************/
sds_handle
sds_vdescribe(c,h,dptr,heap,name,tptr,object,thing_list)
rescon               *c;
struct sds_header    *h;
sds_code              object;
struct   sds_odesc  **thing_list;
struct direc         *dptr;
char                 *heap;
char                 *name;
struct type_list     *tptr;
/***********************************************************************/
{

  int          ind;
  char        *temp_addr;

  if (c->firstpass)
  {
    if ((!sds_res_init(c,h,dptr,heap,name,tptr,object,SDS_OBJECT)) &&
        (sds_last_warning() != SDS_ZERO_LENGTH)) 
    {
      return -1L;
    }
    c->base_address = c->cette->address;
  }

  while (1) 
  {
    while ((c->tptr[c->cette->ind].elemcod & SDS_RETLIST)) 
    {
      sds_prev_object(c,ALL_ELEMENTS);
      if (c->cette == c->start_stack) 
      {
        c->firstpass = 1;
        sds_push_error(SDS_END_RES_STACK,SDS_RETURN,"Resolution calls");
        return -1L;
      }
    }
    if (c->firstpass) 
    {
      c->firstpass = 0;
    } 
    else 
    {
      c->cette->elemcod = c->tptr[c->cette->ind].elemcod;
      c->cette->nelems = c->tptr[c->cette->ind].nelems;
    }

    ind = c->cette->elemcod & ~SDS_CODE_MASK;
    if (c->cette->elemcod & SDS_INDLIST)
    {
      if (c->tptr[ind].elemcod & SDS_LENLIST) 
      {
        c->cette->namelist = &rnull;
        c->cette->maxn = c->tptr[ind].nelems >> 16;
        if (c->cette->maxn)
          c->cette->namelist =
                 (c->nheap + (c->tptr[ind].nelems & 0xffff));
        ind++;
      }
      if (c->tptr[ind].elemcod & SDS_SIZE_ALIGN) 
      {
        c->cette->size = c->tptr[ind].nelems;
        c->cette->align = (char)(c->tptr[ind].elemcod & 0xff);
        ind++;
      }
      c->cette->nnames =  (c->parent->maxn >= c->cette->nelems)?
         (unsigned long)c->cette->nelems:
          1;

      c->parent->maxn -= c->cette->nnames;
      c->cette->name = c->parent->namelist;
      if (c->cette->nnames != (unsigned long)0)
        c->parent->namelist =
             sds_jstr(c->parent->namelist,c->cette->nnames);
      c->cette->address += c->addr_inc;
      c->cette->address += align_delta(c->cette->address - c->base_address,
                                      c->cette->align);
      temp_addr = c->cette->address;
      c->cette->ind++;

      sds_next_object(c);
      c->cette->address = temp_addr;
      c->addr_inc = 0;
      c->cette->ind = ind;
      c->cette->nelems = c->tptr[ind].nelems;
      c->cette->elemcod = c->tptr[ind].elemcod;
      *thing_list = c->start_stack;
      return(c->thiso-1);
    }
    else 
    {
      ind = c->cette->ind; 
      c->cette->nelems = c->tptr[ind].nelems;
      if (((c->cette->elemcod = c->tptr[ind].elemcod) >= SDS_RETLIST)) 
      {
      }
      else 
      {
        int bitf = 0;
        c->cette->nnames =  (c->parent->maxn >= (unsigned long)1)?
                           (unsigned long)1:
                           (unsigned long)0;
        c->parent->maxn -= c->cette->nnames;
        c->cette->name = c->parent->namelist;
        if (c->cette->nnames != (unsigned long)0)
           c->parent->namelist =
                 sds_jstr(c->parent->namelist,c->cette->nnames);

        c->cette->size = (long)(sds_psize(c->cette->elemcod) & 0xff);
        c->cette->align = c->sds_al[c->cette->elemcod] & 0xff;
				c->cette->nbits = 0;
        if ((c->cette->elemcod == SDS_CHAR_BITFIELD) ||
            (c->cette->elemcod == SDS_SHORT_BITFIELD) ||
            (c->cette->elemcod == SDS_LONG_BITFIELD) ||
            (c->cette->elemcod == SDS_DOUBLE_LONG_BITFIELD))
        {
          bitf =  (c->cette->nelems & SDS_LAST_BITFIELD)?1:2;

					c->cette->nbits = (char )(c->cette->nelems & SDS_BITFIELD_NMASK);
					c->cette->startbit = (char )(c->cette->nelems >> 16);
					if (!(c->cette->nelems & SDS_LAST_BITFIELD))
						c->cette->size = 0;
					c->cette->nelems = 1;
        }

        c->cette->address += c->addr_inc;
        c->cette->address += 
          align_delta(c->cette->address - c->base_address,c->cette->align);

        *thing_list = c->start_stack;

        /* Don't increment address if we're in the middle of a bitfield */
        c->addr_inc = (bitf == 2)?0:c->cette->size * (c->cette->nelems);

        c->cette->ind += 1;
        return(c->thiso);
      }
    }
  }
}

/***********************************************************************/
char  *
sds_jstr(str,n)
char  *str;
unsigned long   n;
/***********************************************************************/
{

  unsigned long  j;
  if (n == (unsigned long)0) return(str);
  for (j=0;j<n;j++)
    str = strchr(str,0) + 1;
  return(str);
}
/***********************************************************************/
void
sds_prev_object(rescon *c,int flag)
/***********************************************************************/
{
  int number_to_inc = 1;

  c->cette--;
  c->parent--;
  c->thiso--;

  if (flag == ALL_ELEMENTS)
    number_to_inc = c->cette->nelems;

  if (!(c->cette->elemcod & SDS_INDLIST))
    c->cette->elemcod = c->tptr[c->cette->ind].elemcod;

  if (c->cette->elemcod & SDS_RETLIST)
  {
    c->addr_inc = 0;
  }
  else if (c->cette != c->start_stack) 
  {
    c->addr_inc = c->cette->size * number_to_inc;
    c->addr_inc += align_delta(c->addr_inc,c->cette->align);
  }
}
/***********************************************************************/
void
sds_next_object(rescon *c)
/***********************************************************************/
{
  if (c->stack_size == 0) 
  {
    c->thiso = 0;
    c->stack_size = STACK_INC;
    c->cette = c->start_stack = 
      (struct sds_odesc *)sds_calloc(c->stack_size , sizeof(struct sds_odesc)); 
  } 
  else 
  {
    c->thiso++;
    if (c->thiso == c->stack_size) 
    {
      c->stack_size += STACK_INC;
      c->start_stack = 
        (struct sds_odesc *)sds_realloc((char *)c->start_stack,
          (unsigned)c->stack_size*sizeof(struct sds_odesc));
    }
  }
  c->cette = &c->start_stack[c->thiso];
  if (c->thiso)
  {
    c->parent = &c->start_stack[c->thiso-1];
  } 
  else 
  {
    c->parent = c->cette;
  }
}
/***********************************************************************/
sds_handle
sds_find_thing(sds,name,thing)
sds_handle  sds;
char  *name;
struct  sds_odesc  **thing;
/***********************************************************************/
{

  struct  sds_odesc  *thinglist;
  int nocomp = 1,level = 0,dlev,firstpass = 1;
  long  object = 0,nomen,addr_inc;
  char  *thingname,lname[128],*cptr = name;
  rescon *c = sds_src(sds);
  if (!c) return 0;
  lname[0] = 0;

  sds_cleanup(sds);
  while (sds_nextname(name,lname,&cptr)) 
  {
    level++;
    if (firstpass) 
    {
      firstpass = 0;
      if (!(object = sds_name2ind(sds,lname))) 
      {
        sds_push_error(SDS_NO_SUCH_OBJ,SDS_WARNING,"Searching for object");
        return (sds_handle)0;
      }  
    }
    while ((dlev = sds_describe(sds,object,&thinglist)) == level) 
    {
      nocomp = 1;
      thingname = thinglist[dlev].name;
      for (nomen = (long)0;nomen < thinglist[dlev].nnames;nomen++) 
      {
        if (!(nocomp = strcmp(lname,thingname))) 
        {
          addr_inc = nomen*thinglist[dlev].size;
          addr_inc += align_delta(addr_inc,thinglist[dlev].align);
          thinglist[dlev].address += addr_inc;
          if (thinglist[dlev].elemcod &
            SDS_INDLIST)
            thinglist[dlev+1].address += addr_inc;
          thinglist[dlev].nelems -= nomen;
          break;
        }
        else 
          thingname = strchr(thingname,0) + 1;
      }
      *thing = &thinglist[dlev];
      if (!nocomp) 
        break;
    }  
    if (nocomp)
    {
      sds_cleanup(sds);
      sds_push_error(SDS_NO_SUCH_OBJ,SDS_WARNING,"Searching for object");
      return (sds_handle)0;
    }
  }
  return(object);
}
/***********************************************************************/
int
sds_nextname(char *name,char *buffer,char **cptr)
/***********************************************************************/
{
  char *bptr = *cptr;

  if (*cptr == 0 || name == 0) 
    return 0;

  if ((*cptr = (char *)strchr(*cptr,'.')) != NULL) 
  {
    strncpy(buffer,bptr,(*cptr-bptr));
    buffer[*cptr-bptr] = 0;
    bptr = ++(*cptr);
  }
  else  
  {
    strcpy(buffer,bptr);
    *cptr = 0;
  }
  return 1;
}
/***********************************************************************/
int
sds_make_name(name,thing_list,start_level,end_level)
char  *name;