NAME    [Toc]    [Back]

       stfd - routines that provide access to per file descriptor
       section of the symbol table

SYNOPSIS    [Toc]    [Back]

       #include <syms.h>

       long st_currentifd(
               void ); long st_ifdmax(
               void ); void st_setfd(
               long ifd ); long st_fdadd(
               char *filename ); long st_symadd(
               long iss,
               long value,
               long st,
               long sc,
               long freloc,
               long index ); long st_auxadd(
               AUXU aux ); long st_stradd(
               char *cp ); long st_lineadd(
               long line ); long st_pdadd(
               long isym ); long st_ifd_pcfd(
               pCFDR pcfd1 ); pCFDR st_pcfd_ifd(
               long ifd ); pSYMR st_psym_ifd_isym(
               long ifd,
               long isym ); pAUXU st_paux_ifd_iaux(
               long ifd,
               long iaux ); pAUXU st_paux_iaux(
               long iaux ); char *st_str_iss(
               long iss ); char *st_str_ifd_iss(
               long ifd,
               long iss ); pPDR st_ppd_ifd_isym(
               long ifd,
               long isym ); char *st_malloc(
               char *ptr ,
               long *size,
               long itemsize,
               long baseitems );

DESCRIPTION    [Toc]    [Back]

       The stfd routines provide an interface to objects  handled
       on  a  per  file descriptor (fd) level (for example, local
       symbols, auxiliaries, local strings, line  numbers,  optimization
  entries,  procedure  descriptor entries, and the
       file  descriptors).  These  routines  constitute  a  group
       because  they deal with objects corresponding to fields in
       the FDR structure.

       An fd routine can be activated by reading an existing  one
       into memory or by creating a new one. The compilation unit
       routines  st_readbinary()  and   st_readst()   read   file
       descriptors and their constituent parts into memory from a
       symbol table on disk.

       The st_fdadd() routine adds a file descriptor to the  list
       of  file descriptors. The lang field is initialized from a
       user-specified global st_lang that should be set to a constant
  designated  for  the  language  in symconst.h.  The
       fMerge field is initialized from the user-specified global
       st_merge  that specifies whether the file is to start with
       the attribute of being able to be  merged  with  identical
       files  at load time. The Bigendian field is initialized by
       the gethostsex() routine (see gethostsex(3)), which determines
  the  permanent  byte ordering for the auxiliary and
       line number entries for this file.

       The st_fdadd() routine adds the null  string  to  the  new
       files string table that is accessible by the constant issNull (0). It also adds the filename to  the  string  table
       and  sets  the rss field. Finally, the current file is set
       to the newly added file so that  later  calls  operate  on
       that file.

       All  routines for fd-level objects handle only the current
       file unless a file index is specified.  The  current  file
       can also be set with st_setfd().

       Programs  can  find the current file by calling st_currentifd(),
 which returns the current index. Programs can find
       the  number  of  files by calling st_ifdmax(). The fd routines
 only require working with indices to do most things.
       They allow more in-depth manipulation by allowing users to
       get the compile-time file descriptor (CFDR) that  contains
       memory  pointers  to  the  per  file  tables  (rather than
       indices or offsets used in disk files). Users can retrieve
       a  pointer  to  the CFDR by calling st_pcfd_ifd() with the
       index  to  the   desired   file.   The   inverse   mapping
       st_ifd_pcfd() exists, as well.

       Each  of  fd's  constituent  parts  has  an  add  routine:
       st_symadd(), st_stradd(),  st_lineadd(),  st_pdadd(),  and
       st_auxadd(). The parameters of the add routines correspond
       to the fields of the added object. The st_pdadd()  routine
       lets  users  fill in the isym field only. Further information
 can be added  by  directly  accessing  the  procedure
       descriptor entry.

       The  add  routines  return  an  index  that can be used to
       retrieve a pointer to part of the desired object with  one
       of  the  following routines: st_psym_isym(), st_str_iss(),
       and  st_paux_iaux().  Note:  These  routines  only  return
       objects  within  the  current file. The following routines
       allow   for   file   specification:    st_psym_ifd_isym(),
       st_aux_ifd_iaux(), and st_str_ifd_iss().

       The  st_ppd_ifd_isym() routine allows access to procedures
       through the file index for the file where they  occur  and
       the  isym field of the entry that points at the local symbol
 for that procedure.

       The return index from st_symadd() should be used to get  a
       dense  number  (see  stcu(3)).  That  number should be the
       ucode  block  number  for  the  object  that  the   symbol
       describes.

RESTRICTIONS    [Toc]    [Back]

       The interface will be added to incrementally, as needed.

SEE ALSO    [Toc]    [Back]

       stcu(3), stfe(3)



                                                          stfd(3)