home *** CD-ROM | disk | FTP | other *** search
/ Boldly Go Collection / version40.iso / TS / 17A / DRWIN101.ZIP / SYMBOL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-23  |  4.2 KB  |  207 lines
  1. #include <alloc.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5.  
  6. #include "symbol.h"
  7.  
  8. symtab *symopen(int sz,symcmpf cf)
  9. {
  10.   symtab *s;
  11.  
  12.   s=malloc(sizeof(symtab));            /*allocate symbol table struct*/
  13.   if (s==NULL) return NULL;            /*if no memory, return*/
  14.   s->siz=sz;                           /*record size of symbol records*/
  15.   s->num=0;                            /*reset number of records*/
  16.   s->cmp=cf;                           /*record compare function*/
  17.   s->sym=NULL;                         /*pointer to first symbol*/
  18.   s->cur=NULL;                         /*reset current record pointer*/
  19.   return s;
  20. }   /*symopen*/
  21.  
  22.  
  23. void symclose(symtab *st)
  24. {
  25.   symrec *sym;
  26.   symrec *lsym;
  27.  
  28.   if (st==NULL) return;
  29.   sym=st->sym;
  30.   while (sym) {
  31.     lsym=sym;
  32.     sym=sym->nxt;
  33.     free(lsym);
  34.   }   /*while*/
  35.   free(st);
  36. }   /*symclose*/
  37.  
  38.  
  39. void *symfind(symtab *st,void *rec)
  40. {
  41.   symrec *sym;
  42.   int cmp;
  43.  
  44.   if (st==NULL) return NULL;
  45.   for (sym=st->sym;sym;sym=sym->nxt) {
  46.     cmp=st->cmp(sym->rec,rec);
  47.     if (cmp>0) break;
  48.     else if (cmp==0) {
  49.       st->cur=sym;
  50.       return (void*)sym->rec;
  51.     }   /*else if found*/
  52.   }   /*while*/
  53.   return NULL;
  54. }   /*symfind*/
  55.  
  56.  
  57. void *symins(symtab *st,void *rec)
  58. {
  59.   symrec *rsym,*lsym;                  /*left/right symbols in list*/
  60.   symrec *new;
  61.   int cmp;
  62.  
  63.   if (st==NULL) return NULL;
  64.   lsym=NULL;
  65.   for (rsym=st->sym;rsym;rsym=rsym->nxt) {
  66.     cmp=st->cmp(rsym->rec,rec);
  67.     if (cmp>0) break;
  68.     else if (cmp==0) {
  69.       st->cur=rsym;
  70.       return (void *)rsym->rec;
  71.     }
  72.     lsym=rsym;
  73.   }   /*for*/
  74.   new=malloc(sizeof(symrec)-1+(st->siz));
  75.   if (new==NULL) return NULL;
  76.   (st->num)++;
  77.   if (lsym)
  78.     lsym->nxt=new;
  79.   else
  80.     st->sym=new;
  81.   if (rsym) rsym->prv=new;
  82.   new->prv=lsym;
  83.   new->nxt=rsym;
  84.   memcpy(new->rec,rec,st->siz);
  85.   st->cur=new;
  86.   return (void*)new->rec;
  87. }   /*symins*/
  88.  
  89.  
  90. void *symdel(symtab *st,void *rec)
  91. {
  92.   symrec *sym,*lsym;
  93.   int cmp;
  94.  
  95.   if (st==NULL) return NULL;
  96.   lsym=NULL;
  97.   for (sym=st->sym;sym;sym=sym->nxt) {
  98.     cmp=st->cmp(sym->rec,rec);
  99.     if (cmp>0) return NULL;
  100.     else if (cmp==0) {
  101.       if (lsym)
  102.         lsym->nxt=sym->nxt;
  103.       else
  104.         st->sym=sym->nxt;
  105.       if (sym->nxt) (sym->nxt)->prv=lsym;
  106.       free(sym);
  107.       (st->num)--;
  108.       if (st->num<0) st->num=0;
  109.       return symfirst(rec);
  110.     }
  111.     lsym=sym;
  112.   }   /*for*/
  113.   return NULL;
  114. }   /*symdel*/
  115.  
  116.  
  117. void *symfirst(symtab *st)
  118. {
  119.   if (st==NULL) return NULL;
  120.   if (st->sym==NULL) return NULL;
  121.   st->cur=st->sym;
  122.   return (void*)(st->cur)->rec;
  123. }   /*symfirst*/
  124.  
  125.  
  126. void *symcurr(symtab *st)
  127. {
  128.   if (st==NULL) return NULL;
  129.   return (void*)(st->cur)->rec;
  130. }   /*symcurr*/
  131.  
  132.  
  133. void *symnext(symtab *st)
  134. {
  135.   if (st==NULL) return NULL;
  136.   if (st->cur==NULL) return NULL;
  137.   st->cur=(st->cur)->nxt;
  138.   if (st->cur==NULL) return NULL;
  139.   return (void*)(st->cur)->rec;
  140. }   /*symnext*/
  141.  
  142.  
  143. void *symprev(symtab *st)
  144. {
  145.   if (st==NULL) return NULL;
  146.   if (st->cur==NULL) return NULL;
  147.   st->cur=(st->cur)->prv;
  148.   if (st->cur==NULL) return NULL;
  149.   return (void*)(st->cur)->rec;
  150. }   /*symprev*/
  151.  
  152.  
  153. void *symlast(symtab *st)
  154. {
  155.  
  156.   if (st==NULL) return NULL;
  157.   if (st->sym==NULL) return NULL;
  158.   for (st->cur=st->sym;(st->cur)->nxt;st->cur=(st->cur)->nxt) ;
  159.   return (void*)(st->cur)->rec;
  160. }   /*symlast*/
  161.  
  162.  
  163. void *symsucc(symtab *st,void *rec)
  164. {
  165.   symrec *sym;
  166.   int cmp;
  167.  
  168.   if (st==NULL) return NULL;
  169.   for (sym=st->sym;sym;sym=sym->nxt) {
  170.     cmp=st->cmp(sym->rec,rec);
  171.     if (cmp>0) break;
  172.     else if (cmp==0) {
  173.       st->cur=sym;
  174.       if (!sym->nxt) return NULL;
  175.       return (void*)((sym->nxt)->rec);
  176.     }   /*else if found*/
  177.   }   /*while*/
  178.   return NULL;
  179. }   /*symsucc*/
  180.  
  181.  
  182. void *sympred(symtab *st,void *rec)
  183. {
  184.   symrec *sym;
  185.   int cmp;
  186.  
  187.   if (st==NULL) return NULL;
  188.   for (sym=st->sym;sym;sym=sym->nxt) {
  189.     cmp=st->cmp(sym->rec,rec);
  190.     if (cmp>0) break;
  191.     else if (cmp==0) {
  192.       st->cur=sym;
  193.       if (!sym->prv) return NULL;
  194.       return (void*)((sym->prv)->rec);
  195.     }   /*else if found*/
  196.   }   /*while*/
  197.   return NULL;
  198. }   /*sympred*/
  199.  
  200.  
  201. int  symnum(symtab* st)
  202. {
  203.   if (!st) return 0;
  204.   return st->num;
  205. }   /*symnum*/
  206.  
  207.