sds_res.c

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

struct  sds_odesc  *thing_list;
int  start_level,end_level;
/***********************************************************************/
{
  int  lev;

  if (start_level < 0) start_level = 0;
  if (end_level < 0) end_level = 0;
  if (start_level > end_level) start_level = end_level;
  *name = 0;
  for (lev=start_level;lev <= end_level;lev++) 
  {
    if ((thing_list[lev].name != NULL) &&
        (*thing_list[lev].name != 0)) 
        {
      strcat(name,thing_list[lev].name);
      strcat(name,".");
    }
  }
  *(strchr(name,0)-1) = 0;
  return((int)thing_list[lev].nnames);
}
/***********************************************************************/
sds_handle
sds_res_init(c,h,dptr,heap,name,tptr,object,flag)
rescon            *c;
struct sds_header *h;
int                flag;
sds_code           object;
struct direc      *dptr;
char              *heap;
char              *name;
struct type_list  *tptr;
/***********************************************************************/
  {

  int  retval = 1;

  if (dptr == DNULL)
    {
    sds_push_error(SDS_NO_SUCH_SDS,SDS_ERROR,"Initialise resolution calls");
    return (sds_handle)0;
    }
  sds_cleanc(c);
  c->addr_inc = 0;
  c->nheap = heap;
  c->tdum[1].elemcod = SDS_RETLIST;
  sds_fix_align(h,c);

  sds_next_object(c);
  c->cette->nelems = (unsigned long)0;
  c->cette->address   = (char *)0;
  c->cette->name   = name;
  c->cette->namelist   = &rnull;

  if (flag == SDS_OBJECT) 
    {
    c->cette->nnames   = 
    c->cette->maxn   = dptr[object].obj_name >> 16;
    if (c->cette->maxn)
      c->cette->namelist = (c->nheap + (dptr[object].obj_name & 0xffff));
    }

  sds_next_object(c);

  if (flag == SDS_OBJECT) 
    {
    c->cette->elemcod   = dptr[object].elemcod;
    c->cette->address   = (char*) sds_getp(dptr,object);
    c->cette->align     = dptr[object].align_type;
    if ((c->cette->nelems = dptr[object].nelems) == 0L)
      {
      retval = 0;
      sds_push_error(SDS_ZERO_LENGTH,SDS_WARNING,"Initialise resolution calls");
      }
    c->cette->size   = dptr[object].elemsz;
    }
  else 
    {
    c->cette->elemcod  = object;
    c->cette->address   = (char *)0;
    c->cette->align     = (char)0;
    c->cette->nelems    = (unsigned long)1;
    }
  c->tdum[0].elemcod  =  c->cette->elemcod;
  c->tdum[0].nelems  =  c->cette->nelems;

  if ((c->cette->elemcod & SDS_INDLIST)) 
    {
    c->tptr = tptr;
    c->cette->ind = 
      (unsigned long)tlist_size(c->tptr)/sizeof(struct type_list); 
    c->cette->ind -= 3;
    }  
  else 
    {
    c->tptr = c->tdum;
    c->cette->ind  = (unsigned long)0;
    }
  c->parent->ind = c->cette->ind;

  return(retval);
  }
/***********************************************************************/
int
sds_resolve(sds,object_index,thing_list,flag)
sds_handle  sds;
sds_code  object_index,flag;
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_vresolve(c,h,dptr,heap,name,tptr,object_index,thing_list,flag);
}
/***********************************************************************/
sds_handle
sds_vresolve(c,h,dptr,heap,name,tptr,object,thing_list,flag)
rescon              *c;
struct sds_header   *h;
int                  flag;
sds_code             object;
struct   sds_odesc **thing_list;
struct direc        *dptr;
char                *heap;
char                *name;
struct type_list    *tptr;
/***********************************************************************/
{

  int  ind = 0;
  char *temp_addr;

  if (c->firstpass)
  { 
    if (c->done || !sds_res_init(c,h,dptr,heap,name,tptr,object,flag))
    {
      c->done = 0;
      return -1L;
    }
    c->firstpass = 0;
    c->base_address = c->cette->address;
    if ((flag & SDS_OBJECT)  && (dptr[object].structype == SDS_RECORDS))
      c->r = ((sds_record_handle *)sds_getp(dptr,object))->recent_head;
    else
      c->r = 0;
  }

  while (1) 
  {
    while ((c->tptr[c->cette->ind].elemcod & SDS_RETLIST)) 
    {
      sds_prev_object(c,ONE_ELEMENT);
      if (c->cette == c->start_stack) 
      {
        c->firstpass = 1;
        c->done = 1;
        sds_push_error(SDS_END_RES_STACK,SDS_RETURN,"Resolution calls");
        return -1L;
      }
    }
    ind = c->cette->elemcod & ~SDS_CODE_MASK;
    if (c->cette->elemcod & SDS_INDLIST)
    {
      if (c->tptr[ind].elemcod & SDS_LENLIST) 
      {
        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->address += c->addr_inc;
      c->cette->address += align_delta(c->cette->address - c->base_address,
                                      c->cette->align);
      temp_addr = c->cette->address;
      if ((c->cette->nelems == 0) || ((--(c->cette->nelems)) == 0)) 
      {
        c->cette->ind += 1;
        c->cette->nelems = c->tptr[c->cette->ind & ~SDS_CODE_MASK].nelems;
        c->cette->elemcod = c->tptr[c->cette->ind & ~SDS_CODE_MASK].elemcod;
      }
      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;
    } 
    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->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;
        if (c->r)
        {
          while (c->r->elemtype & SDS_CODE_MASK)
            c->r = c->r->next;
          c->cette->address = c->r->pointer;
          c->r = c->r->next;
        }
        return(c->thiso);
      }
    }
  }
}
/***********************************************************************/
unsigned long
sds_tlsize(sds,code,alignment_type)
sds_handle  sds;
long  code;
char  *alignment_type;
/*  This figures out the size of an object described by ty_list
 *  The size returned is that of the object in the ORIGINAL system -
 *  While this is going on, I also work out
 *  what sort of datum the thing is. This is needed for
 *  sparchitecture as alignment depends on data type    */
/***********************************************************************/
{
  unsigned long  laddr = 0,lsize = 0,thing_size = (unsigned long)0;
  struct  sds_odesc  *thing;
  int  thiso;

  *alignment_type = (char)0;
  sds_cleanup(sds);
  while ((thiso = sds_resolve(sds,code,&thing,SDS_CODE)) >= 0) 
  {
    lsize = thing[thiso].nelems * thing[thiso].size;
    laddr = (unsigned long)thing[thiso].address;
    *alignment_type = 
      (thing[thiso].align > *alignment_type)?
      thing[thiso].align:*alignment_type;
  }
  thing_size = lsize + (unsigned long)laddr; 
  thing_size += align_delta(thing_size,*alignment_type);
  return(thing_size);
}
/***********************************************************************/
unsigned long
sds_rsize(sds,code,alignment_type)
sds_handle  sds;
sds_code  code;
unsigned char  *alignment_type;
/***********************************************************************/
{
  struct  type_list  *tptr = sds_tlist(sds);
  unsigned long  size = (unsigned long)0;
  unsigned long  ind = code & ~SDS_CODE_MASK;
  int  i;

  for (i=0;i<2;i++,ind++)
    if (tptr[ind].elemcod & SDS_SIZE_ALIGN) 
    {
      size = tptr[ind].nelems;
      *alignment_type = (char)(tptr[ind].elemcod & 0xff);
    }
  return(size);
}
    
/***********************************************************************/
sds_handle
sds_sizeof_object(sds, object_index)
sds_handle    sds;
sds_code    object_index;
/***********************************************************************/
{
    unsigned char junk;
    struct direc *dptr = sds_direc(sds);
    sds_handle    size;

    size = sds_element_size(sds, dptr[object_index].elemcod, &junk);
    return size * dptr[object_index].nelems;
}
/***********************************************************************/
sds_handle
sds_element_size(sds,code,alignment_type)
sds_handle  sds;
sds_code    code;
unsigned char  *alignment_type;
/***********************************************************************/
/*  How big is a thing - a primitive or a reference to a tlist     */
/*  If the size is < 0, this signals an unknown thing.    */
/*  Size 0 is 'undetermined' (eg SDS)        */
{
  rescon *c = sds_src(sds);

  if (!c) return 0;

  if (code == SDS_SDS) 
    return 0L;
  else if (code & SDS_INDLIST)
    return (long)sds_rsize(sds,code,alignment_type);
  else 
  {
                long size;
    sds_fix_align(sds_head(sds),c);
    *alignment_type = c->sds_al[code];
    if (!(size = (long)sds_psize(code)))
      sds_push_error(SDS_UNDEFINED_TYPE,SDS_ERROR,"Get object size");
    return size;
  }
}
/***********************************************************************/
void
sds_fix_align(struct sds_header *header, rescon *c)
/***********************************************************************/
{
  int    arch = SDS_ARC;

  if (!header)
    c->sds_al = sds_arc_aligns(arch);
  else 
  {
    int state = (!sds_header_ok(header))?sds_last_warning():0;
    arch = (state == SDS_SWAPPED_BYTES)?
      (header->magic_number & 0x00ff0000) >> 16:
      (header->magic_number & 0x0000ff00) >> 8;
    c->sds_al = sds_arc_aligns(arch-1);
  }
}
/***********************************************************************/
sds_handle
object_size(dptr,tptr,heap)
struct direc     *dptr;
struct type_list  *tptr;
char        *heap;
/***********************************************************************/
{
  long  code = dptr->elemcod;
  long size;
  rescon *c = sds_new_rescon();

  if (code & SDS_INDLIST)
  {
    size = object_tlsize(c,dptr,heap,"",tptr);
  }
  else
  {
    sds_fix_align(0,c);
    dptr->align_type = c->sds_al[code];
    if (!(size = (long)sds_psize(code)))
      sds_push_error(SDS_UNDEFINED_TYPE,SDS_ERROR,"Get object size");
  }
  sds_delete_rescon(c);
  return size;
}
/***********************************************************************/
sds_handle
object_tlsize(c,dptr,heap,name,tptr)
rescon             *c;
struct direc       *dptr;
char               *heap;
char               *name;
struct type_list   *tptr;
/***********************************************************************/
{
  unsigned long  laddr = 0,lsize = 0,thing_size = (unsigned long)0;
  struct  sds_odesc  *thing;
  int  thiso;
  long  code = dptr->elemcod;

  while ((thiso = sds_vresolve(c,0,dptr,heap,name,tptr,code,&thing,SDS_CODE)) >= 0)
  {
    lsize = thing[thiso].nelems * thing[thiso].size;
    laddr = (unsigned long)thing[thiso].address;
    dptr->align_type =
      (thing[thiso].align > (char)dptr->align_type)?
      thing[thiso].align:dptr->align_type;
  }
  thing_size = lsize + (unsigned long)laddr;
  thing_size += align_delta(thing_size,dptr->align_type);
  return(thing_size);
}