intf.nr

This Source-Navigator, an IDE for C/C++/Fortran/Java/Tcl/PHP/Python and a host of other languages.

int call_succeeded = sds_discard_all(sdsH);

Discard all system descriptive information about a dataset.

int call_succeeded = sds_destroy_all(sdsH);

Discard all system descriptive information about  a  dataset  and
the  objects  in it, having first free'd any Sds-system allocated
memory in the objects.


            typeH = sds_make_th(struct typelist *tl);


           storeH = sds_make_sh(struct storeage *st);


     objectH = sds_new_object(th,int number,char *names[]);
int call_succeeded =
   sds_oh_instantiations(objectH,         storeH[],          char
*instatiation_names[]);
int call_succeeded =
   sds_oh_struct_storage(objectH, storeH[], char *name = NULL);

oh = sds_copy(storeH, objectI, pointer = NULL);

Having open'd the dataset, you may now *copy* some or all of  the
objects  (including architecture conversion if necessary).  Space
will be allocated unless 'pointer' has a non-null value, in which
case data will be loaded starting at the pointer position: caveat
programmer.

objectH   =    sds_ohfromindex(sdsH,    objectI);    objectH    =
sds_ohfromname(sdsH, name);

Find the appropriate object handle from the index or name  of  an
object within a dataset.

objectH = sds_ohlikename(sdsH, part_name,int occurrence);

Find the occurence'th instance of  an  object  within  a  dataset
whose name contains 'part_name' as a substring.

void *ohptr = sds_ohptr(objectH);

Find the pointer to the data acessed through objectH.
Note: this call will give an error if the objectH  was  found  by
querying  a  proto-dataset: default behaviour is to print out the
error stack and stop.

char *ohname = sds_ohname(objectH);

Find the name of the data acessed through objectH.

int multiplicity = sds_ohmult(objectH);

Find the multiplicity of the data acessed through  objectH  -  ie
how many of each element - the array size.

int sizeof = sds_ohsizeof(objectH);

Find the size in bytes of one element of  an  object.   The  size
could    be    undetermined;    sds_error    is   then   set   to
SDS_SIZE_UNDETERMINED and the error level set to SDS_WARNING; the
size returned is 0.

int sizeof = sds_thsizeof(th);

Find the size in bytes of the  data  structure  accessed  by  the
type_handle.  The  size  could be undetermined; sds_error is then
set  to  SDS_SIZE_UNDETERMINED  and  the  error  level   set   to
SDS_WARNING; the size returned is 0.

int call_succeeded = sds_ohtstamp(int tstamp);

Sets the time stamp of an object.

int tstamp = sds_get_ohtstamp(objectH);

Returns the time stamp of an object.

int call_succeeded = sds_discard(objectH);

Discard all system descriptive information about an object.

int call_succeeded = sds_destroy(objectH);

Free  any  Sds-system  allocated  memory  in  the  object,   then
sds_discard() all system information.


        int descriptor_handle = sds_desc_handle(objectH);

Get a handle to refer to subsequent analysis calls on an object.

There are two main types of object analysis: linear and hierarch-
ical.   In  each case repeated calls to the analysis routines re-
turn information about the analysed objects. In linear  analysis,
a  sequence  of statements about the primitive elements that make
up the object is made - eg  10  floats,  23  int,  120  char,  10
floats,  23  int,  120 char......  This is effected by sequential
calls to

int level = sds_linear(descH, struct level_description **ld.sp);

In hierarchical elements, a series of index numbers  refering  to
an array of descriptor structures is returned from

int level = sds_hierarch(descH, struct level_description **ld);

each of which give: The start address of the field
Its name
Its type_code
The number of elements in the array (or 1).
Its size in bytes.

When no more fields remain for analysis, 0 is  returned  and  the
warning SDS_DONE_ANALYSIS is set.

int call_succeeded = sds_close_dh(descH);

Clean up all system stuff created for an analysis. Use  of  descH
before it is reallocated with sds_desc_handle() will cause an er-
ror; however  sds_close_dh()  is  called  automatically  when  an
analysis sequence is run completion. Re-closing an already closed
descH has no effect.

int   level   =    sds_find_level(descH,    field_name,    struct
level_description **ld);

Makes calls to sds_hierarch() until a match is made to the  field
named field_name.


             recordH = sds_begin_record(char *name);

sds_record_entry(recordH, handle, int  number,  void  *ptr,  char
*name);

sds_begin_sub_record(rh, name)

sds_end_sub_record(rh)

sds_end_and_declare(recordH, sdsH);

sds_destroy_record_def(recordH, int destroy_object);

sds_print_record_def(recordH);



             void sds_stop_if_error(char *comment);

Really crude. If there has been an Sds error, it prints  out  the
error stack and does exit(1); otherwise it is quiet.

int level = sds_push_error(int errcode, int errlevel, char  *err-
string);

Push a new error onto the stack. We assume that errstring is zero
terminated,  and  check to see if it is NULL. Returns the 'level'
of the error in the stack. Filename and line information is added
by the preprocessor from the defines __LINE__ and __FILE__.

  int error_code = sds_last_error();

Returns the last sds_error, which is 0 if no problems found.

  int error_code = sds_last_warning();

Returns the last sds_error at SDS_WARNING level, which is 0 if no
problems found.

  void sds_perror(char *comment);

Print out the top level comment, any filled parts  of  the  error
stack, and the last operating system error if there was one.



void sds_output_proginfo(int truefalse);

Default 0 == Do not print out line and file information.

void sds_exit_on_fatal(int truefalse);

Default 1 == An SDS_FATAL error causes exit(truefalse & 0xff);

void sds_output_errors(int level);

Default 0 == Do not output errors as they are registered; this is
when  you  want  to  wait  for  a  final catastrophe and then use
sds_perror(), or when you may be able to take corrective  action;
in  most  programs sds_output_errors(SDS_FATAL) will be appropri-
ate.

sds_clear_errors();

Start with a clean slate.

int error_code = sds_pop_error(int errlevel, char *errstring);

void printoutprog(int i);

Print out program info for the i'th entry on the stack

void printout(int i);

Print out the i'th entry on the stack

Currently, error levels are:

SDS_WARNING
SDS_ERROR
SDS_FATAL