Back to index

radiance  4R0+20100331
Classes | Functions | Variables
modobject.c File Reference
#include "copyright.h"
#include "standard.h"
#include "object.h"
#include "otypes.h"

Go to the source code of this file.

Classes

struct  ohtab

Functions

static int otndx (char *, struct ohtab *)
OBJECT objndx (OBJREC *op)
OBJECT lastmod (OBJECT obj, char *mname)
OBJECT modifier (char *mname)
void insertobject (OBJECT obj)
void clearobjndx ()
static int nexthsiz (int oldsiz)

Variables

static const char RCSid [] = "$Id: modobject.c,v 2.12 2004/07/14 02:37:23 greg Exp $"
static struct ohtab modtab
static struct ohtab objtab

Class Documentation

struct ohtab

Definition at line 19 of file modobject.c.

Class Members
int hsiz
OBJECT * htab

Function Documentation

void clearobjndx ( void  )

Definition at line 108 of file modobject.c.

{
       if (modtab.htab != NULL) {
              free((void *)modtab.htab);
              modtab.htab = NULL;
              modtab.hsiz = 100;
       }
       if (objtab.htab != NULL) {
              free((void *)objtab.htab);
              objtab.htab = NULL;
              objtab.hsiz = 100;
       }
}

Here is the caller graph for this function:

void insertobject ( OBJECT  obj)

Definition at line 87 of file modobject.c.

{
       register int  i;

       if (ismodifier(objptr(obj)->otype)) {
              i = otndx(objptr(obj)->oname, &modtab);
              modtab.htab[i] = obj;
       }
#ifdef  GETOBJ
       else {
              i = otndx(objptr(obj)->oname, &objtab);
              objtab.htab[i] = obj;
       }
#endif
       for (i = 0; addobjnotify[i] != NULL; i++)
              (*addobjnotify[i])(obj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

OBJECT lastmod ( OBJECT  obj,
char *  mname 
)

Definition at line 43 of file modobject.c.

{
       register OBJREC  *op;
       register int  i;

       i = modifier(mname);        /* try hash table first */
       if ((obj == OVOID) | (i < obj))
              return(i);
       for (i = obj; i-- > 0; ) {  /* need to search */
              op = objptr(i);
              if (ismodifier(op->otype) && !strcmp(op->oname, mname))
                     return(i);
       }
       return(OVOID);
}

Here is the call graph for this function:

Here is the caller graph for this function:

OBJECT modifier ( char *  mname)

Definition at line 63 of file modobject.c.

{
       register int  ndx;

       ndx = otndx(mname, &modtab);
       return(modtab.htab[ndx]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int nexthsiz ( int  oldsiz) [static]

Definition at line 124 of file modobject.c.

{
       static int  hsiztab[] = {
              251, 509, 1021, 2039, 4093, 8191, 16381, 0
       };
       register int  *hsp;

       for (hsp = hsiztab; *hsp; hsp++)
              if (*hsp > oldsiz)
                     return(*hsp);
       return(oldsiz*2 + 1);              /* not always prime */
}

Here is the caller graph for this function:

OBJECT objndx ( OBJREC op)

Definition at line 28 of file modobject.c.

{
       register int  i, j;

       for (i = nobjects>>OBJBLKSHFT; i >= 0; i--) {
              j = op - objblock[i];
              if ((j >= 0) & (j < OBJBLKSIZ))
                     return((i<<OBJBLKSHFT) + j);
       }
       return(OVOID);
}

Here is the caller graph for this function:

static int otndx ( char *  name,
struct ohtab tab 
) [static]

Definition at line 140 of file modobject.c.

{
       OBJECT  *oldhtab;
       int  hval, i;
       register int  ndx;

       if (tab->htab == NULL) {           /* new table */
              tab->hsiz = nexthsiz(tab->hsiz);
              tab->htab = (OBJECT *)malloc(tab->hsiz*sizeof(OBJECT));
              if (tab->htab == NULL)
                     error(SYSTEM, "out of memory in otndx");
              ndx = tab->hsiz;
              while (ndx--)               /* empty it */
                     tab->htab[ndx] = OVOID;
       }
                                   /* look up object */
       hval = shash(name);
tryagain:
       for (i = 0; i < tab->hsiz; i++) {
              ndx = (hval + (unsigned long)i*i) % tab->hsiz;
              if (tab->htab[ndx] == OVOID ||
                            !strcmp(objptr(tab->htab[ndx])->oname, name))
                     return(ndx);
       }
                                   /* table is full, reallocate */
       oldhtab = tab->htab;
       ndx = tab->hsiz;
       tab->htab = NULL;
       while (ndx--)
              if (oldhtab[ndx] != OVOID) {
                     i = otndx(objptr(oldhtab[ndx])->oname, tab);
                     tab->htab[i] = oldhtab[ndx];
              }
       free((void *)oldhtab);
       goto tryagain;                     /* should happen only once! */
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

struct ohtab modtab [static]
struct ohtab objtab [static]
const char RCSid[] = "$Id: modobject.c,v 2.12 2004/07/14 02:37:23 greg Exp $" [static]

Definition at line 2 of file modobject.c.