sds.c

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

    printf("\
      magic 0x%lx\n\
      version 0x%lx\n\
      tlist size %d bytes\n\
      heap size %d bytes\n",
      (unsigned long)sds_head(sds)->magic_number,
      (unsigned long)sds_head(sds)->version,
      ts,
      hs);
  }
  else
    printf("Not assembled: no header\n");
  tptr = sds_tlist(sds);
  if ((tptr != TNULL) && (ts != 0))
  {
    int i = 0;
    while (tptr->elemcod != SDS_ENDLIST) 
    {
      printf("%x: %x code %x\n",
                   (unsigned)i,
                   (unsigned)tptr->nelems,
                   (unsigned)tptr->elemcod);
      tptr++;
      i++;
    }
  }
  else
    printf("NULL tlist\n");
  printf("***********************\n");
  cptr = sds_heap(sds);
  if (cptr != NULL)
    sds_printit(SDS_BYTE,(long)hs,cptr,0,0);
  else
    printf("NULL heap\n");
  printf("***********************\n");
  for (i=0;i<nobj;i++) 
  {
    printf("****************\n\
      name offset 0x%lx\n\
      data offset 0x%lx \n\
      timestamp 0x%lx \n\
      code 0x%lx \n\
      number of elements %ld \n\
      size of element %ld \n\
      reallocation flag %lx \n\
      structure type %lx \n\
      align %d\n",
        (unsigned long)dptr[i].obj_name,
        (unsigned long)dptr[i].offst,
        (unsigned long)dptr[i].wtime,
        (unsigned long)dptr[i].elemcod,
        (long)dptr[i].nelems,
        (long)dptr[i].elemsz,
        (unsigned long)dptr[i].illoca & 0xff,
        (unsigned long)dptr[i].structype,
        (int)dptr[i].align_type & 0xff);
    if (SDS_INDLIST & dptr[i].elemcod) 
    {
      sds_cleanup(sds);
      while ((indent = sds_describe(sds,i,&thing)) >= 0) 
      {
        if (thing[indent].elemcod & SDS_INDLIST)
          type_ptr = sds_typename(0);
        else
          type_ptr = sds_typename(thing[indent].elemcod);
        pindent(indent);
        printf("%s %ld (%lx %lx %lx)\n",
          thing[indent].name,
          (long)thing[indent].nelems,  
          (unsigned long)thing[indent].address,  
          (unsigned long)thing[indent].size,
          (unsigned long)(thing[indent].align & 0xff));
      }
    }
  }
  return(1);
}

/***********************************************************************/
sds_handle 
sds_list(sds,object,flag)
sds_handle sds;
sds_code   object,flag;
/***********************************************************************/
{

  int                 indent;
  struct  sds_odesc  *thing = 0;
  static  int         depth = -1;
  sds_code            i,nobj;
  char                inbuf[80],opbuff[128];
  char               *cptr;
  struct direc       *dptr = sds_direc(sds);

  depth++;
  *inbuf = (char)0;
  for (i=0;i<depth;i++) strcat(inbuf,"   ");

  if (object >= dptr[0].nelems) 
  {
    sds_push_error(SDS_NO_SUCH_OBJ,SDS_WARNING,"Listing");
    return 0L;
  }

  if (object == (unsigned long)0) 
  {
  /*  Print out the directory description  */
    if (flag & SDS_LIST_RAW) 
    {
      sds_praw_directory(sds);
      return 1L;
    }

    nobj = dptr[0].nelems;
    sprintf(opbuff," dataset '%s' %ld user objects created %s",
      sds_obind2name(sds,(sds_code)0),
      dptr[0].nelems-(unsigned long)1,  
      ctime((time_t *)&dptr[0].wtime));
    printf("%s",inbuf);
    for (i=0;i<(int)strlen(opbuff);i++) printf("-");
    printf("\n");
    printf("%s%s%s",inbuf,opbuff,inbuf);
    printf("- Sds version %3f ",sds_version(sds));
    for (i=0;i<(int)strlen(opbuff)- 19;i++) printf("-");
    printf("\n");

    for (i=1;i<nobj;i++) 
    {
    if ((SDS_INDLIST & dptr[i].elemcod) || (dptr[i].elemcod < NTYPES)) 
      sds_printohead(sds,i,thing,depth);
    else 
      if (dptr[i].elemcod == SDS_SDS) 
        cptr = (char*) sds_getp(dptr,i);
    else 
      printf("%s%ld :'%s' %ld structure(s) \n",
        inbuf, i,
        sds_obind2name(sds,i),
        dptr[i].nelems);
    }
  }
  else 
  {
  /*  Print the data object    */
  cptr = (char*) sds_getp(dptr,object);
  if (cptr == NULL || flag & SDS_HEADER_ONLY)
  {
    if (cptr == NULL && !(flag & SDS_HEADER_ONLY))
      printf("Object template only - no data\n");
    sds_printohead(sds,object,thing,depth);
  }
  else if (flag & SDS_LIST_RAW) 
  {
    sds_printit(SDS_BYTE,dptr[object].nelems*dptr[object].elemsz,cptr,0,0);
  }
    
  else 
    {
      sds_cleanup(sds);
      while ((indent = 
        sds_resolve(sds,object,&thing,SDS_OBJECT)) >= 0) 
        {
        if (flag & SDS_LIST_HEADERS)
          printf("%s %ld %s\n",
            thing[indent].name,
            thing[indent].nelems,
            sds_typename((int)thing[indent].elemcod));
        sds_printit(thing[indent].elemcod,
          thing[indent].nelems,
          thing[indent].address,
					thing[indent].nbits,
					thing[indent].startbit);
      }
    }
  }
  depth--;
  return 1L;
}
void
sds_printohead(sds,object_index,thing, depth)
sds_handle          sds,object_index;
struct  sds_odesc  *thing;
int                 depth;
{
  int    indent,ik,nelems;
  char  *nptr,*type_ptr;

  sds_cleanup(sds);
  while ((indent = sds_describe(sds,object_index,&thing)) >= 0) 
  {
    nelems = thing[indent].nelems;
    if (thing[indent].elemcod & SDS_INDLIST)
      type_ptr = sds_typename(0);
    else
      type_ptr = sds_typename((int)thing[indent].elemcod);
    pindent(indent+depth);
    nptr = thing[indent].name;
    printf("%s %s", nptr, type_ptr);
    if ((thing[indent].nbits))
      printf("(%d):%d\n",thing[indent].nbits,thing[indent].startbit);
    else if (nelems != (unsigned long)1)
    {
      printf("[%d]\n",nelems);  
      if (thing[indent].nnames == nelems) 
      {
        for (ik=1;ik<thing[indent].nnames;ik++) 
        {
          nptr += (int)strlen(nptr) +1;
          pindent(indent+depth);
          printf("%s\n",nptr);
        }
      }
    }
    else
      printf("\n");
  }
}
EXTERN void       sds_printit(sds_code ,sds_code ,char *,char,char);
/***********************************************************************/
void
sds_printit(sds_code type_code,sds_code total_size,
								char *object_pointer,char fb,char bs)
/***********************************************************************/
{

  sds_code    i,k;
  int         kmax,cline;
  char        *bptr;
  long        *iiptr;
  sds_handle  *liptr;
  float       *fptr;
  double      *ffptr;
  short       *sptr;

  switch((int)type_code) 
  {
    case  SDS_WORD :
    case  SDS_UNS_WORD :
        cline = 16;
        sptr = (short *)object_pointer;
        for (i = (unsigned long)0;i<total_size;i+=(unsigned long)cline)
        {
          kmax = (total_size-i)>cline?cline:(int)(total_size-i);
          for (k=0;k<kmax;k++) 
            printf("%d ",(int)*(sptr+k));
          sptr+=kmax;
          printf("\n");
        }
        break;
    case  SDS_POINTER:
    case    SDS_LONG  :
    case    SDS_UNS_LONG  :
        cline = 16;
        liptr = (sds_handle *)object_pointer;
        for (i = 0;i<total_size;i+=cline)
        {
          kmax = (total_size-i)>cline?cline:(total_size-i);
          for (k=0;k<kmax;k++) 
            printf("%ld ",*(liptr+k));
          liptr+=kmax;
          printf("\n");
        }
        break;
    case    SDS_DOUBLE_LONG  :
        cline = 16;
        iiptr = (long *)object_pointer;
        for (i = 0;i<total_size;i+=cline)
        {
          kmax = (total_size-i)>cline?cline:(total_size-i);
          for (k=0;k<kmax;k++) 
#if (BIGADDR == 1)
            printf("%ld ",*(iiptr+k));
          iiptr+=kmax;
#else
            printf("[%ld]%ld ",*(iiptr+2*k),*(iiptr+2*k+1));
          iiptr+=2*kmax;
#endif
          printf("\n");
        }
        break;
    case    SDS_TIME  :
        iiptr = (long *)object_pointer;
        for (i = 0;i<total_size;i++)
        {
          printf("%x :",(unsigned)*iiptr++);
          printf(" %x",(unsigned)*iiptr++);
          printf("\n");
        }
        break;
    case    SDS_FLOAT :
        cline = 8;
        fptr = (float *)object_pointer;
        for (i = 0;i<total_size;i+=cline)
        {
          kmax = (total_size-i)>cline?cline:(total_size-i);
          for (k=0;k<kmax;k++) 
            printf("%e ",*(fptr+k));
          fptr+=kmax;
          printf("\n");
        }
        break;
    case    SDS_DOUBLE:
        cline = 8;
        ffptr = (double *)object_pointer;
        for (i = 0;i<total_size;i+=cline)
        {
          kmax = (total_size-i)>cline?cline:(total_size-i);
          for (k=0;k<kmax;k++) 
            printf("%e ",*(ffptr+k));
          ffptr+=kmax;
          printf("\n");
        }
        break;
    case   SDS_PADB  :
        printf("%ld pad bytes\n",(long)total_size);
        break;
    case  SDS_BYTE  :
        cline = 16;
        bptr = (char *)object_pointer;
        for (i = 0;i<total_size;i+=cline)
        {
          kmax = (total_size-i)>cline?cline:(total_size-i);
          printf("\n%5x| ",(unsigned int)i);
          for (k=0;k<kmax;k++) 
            printf("%2x ",((unsigned int)*(bptr+k) & 0xff));
          for (k=0;k<cline-kmax;k++)
            printf("   ");
          printf("|");
          for (k=0;k<kmax;k++) 
            if (isprint((int)*(bptr+k))) 
                printf("%c",*(bptr+k));
            else printf(".");
          bptr+=kmax;
        }
        printf("\n");
        break;
    case  SDS_STRING  :
    case  SDS_FSTRING  :
        kmax = total_size;
        for (k=0;k<kmax;k++) 
          if (isprint((int)*(object_pointer+k))) 
              printf("%c",*(object_pointer+k));
          else printf(".");
        printf("\n");
        break;
    case  SDS_SDS:
        break;
    case  SDS_LONG_BITFIELD  :
        liptr = (sds_handle *)object_pointer;
        printf("0x%lx\n", ((*liptr >> bs) & ((1 << fb) - 1)));
        break;
    case  SDS_SHORT_BITFIELD  :
        sptr = (short *)object_pointer;
        printf("0x%x\n", ((*sptr >> bs) & ((1 << fb) - 1)));
        break;
    case  SDS_CHAR_BITFIELD  :
        bptr = (char *)object_pointer;
        printf("0x%x\n", ((*bptr >> bs) & ((1 << fb) - 1)));
        break;
    case    SDS_BITFIELD  :
        break;
    default       :
      printf("element type %lx unprintable\n",type_code);
      break;
  }
}
/***********************************************************************/
sds_code
align_delta(sds_off_t address,char alignment_size)
/***********************************************************************/
{
  long  i,j;
  long ad = address;
  
  if (!alignment_size)
    return(0);
  j = (long)(alignment_size & 0xff);
  i=ad%j;
  i = (i == 0)?0:j-i;
  return (sds_code)i;
}
/***********************************************************************/
void
pindent(n)
int  n;
/***********************************************************************/
{ int  i; for (i=0;i<n;i++) printf("   "); }

/***********************************************************************/
sds_handle
sds_set_object_type(sds, object,structure_flag)
sds_handle sds,object;
int structure_flag;
/***********************************************************************/
{
  struct direc   *dptr = sds_direc(sds);
  if (dptr == NULL)
  {
    sds_push_error(SDS_NO_SUCH_SDS,SDS_ERROR,"Set object type");
    return 0L;
  }
  if ((object < 0) || (object >= dptr[0].nelems))
  {
    sds_push_error(SDS_NO_SUCH_OBJ,SDS_ERROR,"Set object type");
    return 0L;
  }
  dptr[(int)object].structype = structure_flag;
  return sds;
}

/***********************************************************************/
sds_handle 
sds_get_object_type(sds,object)
sds_handle sds,object;
/***********************************************************************/
{
  struct direc   *dptr = sds_direc(sds);
  if (dptr == DNULL)
  {
    sds_push_error(SDS_NO_SUCH_SDS,SDS_ERROR,"Get object type");
    return 0L;
  }
  if ((object < 0) ||
      (object >= dptr[0].nelems))
  {
    sds_push_error(SDS_NO_SUCH_OBJ,SDS_ERROR,"Get object type");
    return 0L;
  }
  return dptr[(int)object].structype;
}

/***********************************************************************/
sds_handle 
sds_set_object_location(sds, object,location_flag)
sds_handle sds,object;
int location_flag;
/***********************************************************************/
{
  struct direc   *dptr = sds_direc(sds);
  if (dptr == DNULL)
  {
    sds_push_error(SDS_NO_SUCH_SDS,SDS_ERROR,"Set object location");
    return 0L;
  }
  if ((object < 1) || (object >= dptr[0].nelems))
  {
    sds_push_error(SDS_NO_SUCH_OBJ,SDS_ERROR,"Set object location");
    return 0L;
  }
  dptr[(int)object].illoca = location_flag;
  return 1L;
}

/***********************************************************************/
sds_handle
sds_mark_disjoint(sds,object)
sds_handle sds;
sds_handle object;
/***********************************************************************/
{ return sds_set_object_location(sds,object,SDS_DISJOINT_OBJECT); }