home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / TEXT / UTILITY / SSPELL11.ZIP / CACHE.C next >
Encoding:
C/C++ Source or Header  |  1992-01-26  |  4.6 KB  |  175 lines
  1. /* **************************************************************** */
  2. /*             sspell - similar to Unix spell                       */
  3. /*                        version 1.1                               */
  4. /*                                                                  */
  5. /* Author: Maurice Castro                                           */
  6. /* Release Date: 26 Jan 1992                                        */
  7. /* Bug Reports: maurice@bruce.cs.monash.edu.au                      */
  8. /*                                                                  */
  9. /* This code has been placed by the Author into the Public Domain.  */
  10. /* The code is NOT covered by any warranty, the user of the code is */
  11. /* solely responsible for determining the fitness of the program    */
  12. /* for their purpose. No liability is accepted by the author for    */
  13. /* the direct or indirect losses incurred through the use of this   */
  14. /* program.                                                         */
  15. /*                                                                  */
  16. /* Segments of this code may be used for any purpose that the user  */
  17. /* deems appropriate. It would be polite to acknowledge the source  */
  18. /* of the code. If you modify the code and redistribute it please   */
  19. /* include a message indicating your changes and how users may      */
  20. /* contact you for support.                                         */
  21. /*                                                                  */
  22. /* The author reserves the right to issue the official version of   */
  23. /* this program. If you have useful suggestions or changes for the  */
  24. /* code, please forward them to the author so that they might be    */
  25. /* incorporated into the official version                           */
  26. /*                                                                  */
  27. /* Please forward bug reports to the author via Internet.           */
  28. /*                                                                  */
  29. /* **************************************************************** */
  30.  
  31. #include "cache.h"
  32. #include <stdio.h>
  33. #include "strfn.h"
  34.  
  35. #define NOTINCACHE (0)
  36. #define INCACHE (1)
  37.  
  38. /* this provides a cache of enteries in a list format. The format is a 
  39.    move to front linked list. */
  40.  
  41. /* Author: Maurice Castro */
  42.  
  43. typedef struct liststr
  44. {
  45.    char *name;
  46.    struct liststr *next;
  47.    } LIST;
  48.  
  49. static int maxcachesize;
  50. static int incache;
  51. LIST *list;
  52.  
  53. void initcache(size)
  54. int size;
  55. {
  56.    list = NULL;
  57.    maxcachesize = size;
  58.    incache = 0;
  59.    }
  60.  
  61. int searchcache(match, actual)
  62. char *match;
  63. char *actual;
  64. { 
  65.    LIST *cur;
  66.    LIST *prev;
  67.    int mtc;
  68.   
  69.    if (list == NULL) return(NOTINCACHE);
  70.  
  71.    cur = list;
  72.    prev = NULL;
  73.    mtc = 0;
  74.  
  75.    while (cur->next != NULL)
  76.    {
  77.       if (!stricmp(match, cur->name)) 
  78.       {
  79.          mtc = 1;
  80.          break;
  81.          }
  82.       prev = cur;
  83.       cur = cur->next;
  84.       }
  85.    if (!mtc) 
  86.       return(NOTINCACHE);
  87.    if (prev != NULL)
  88.    {
  89.       prev->next = cur->next;
  90.       cur->next = list;
  91.       list = cur;
  92.       }
  93.    strcpy(actual, cur->name);
  94.    return(INCACHE);
  95.    }
  96.  
  97. int addtocache(item)
  98. char *item;
  99. {
  100.     int i;
  101.     LIST *cur;
  102.     LIST *prev;
  103.     LIST *newel;
  104.  
  105.     /* make new element */
  106.     newel = (LIST *) malloc(sizeof(LIST));
  107.     if (newel == NULL)
  108.        return(0);
  109.     newel->name = (char *) malloc(sizeof(char)*(strlen(item)+1));
  110.     strcpy(newel->name, item);
  111.     newel->next = NULL;
  112.  
  113.     /* cache full */
  114.     if (incache >= maxcachesize)   
  115.     {
  116.        /* traverse cache */
  117.        i = 0;
  118.        cur = list;
  119.        while (i < maxcachesize)
  120.        {
  121.           prev = cur;
  122.           cur = cur->next;
  123.           i++;
  124.           }
  125.  
  126.        /* add new element */
  127.        prev->next = NULL;
  128.        newel->next = list;
  129.        list = newel;
  130.        incache = maxcachesize;
  131.  
  132.        /* fix overspill */
  133.        while (cur != NULL)
  134.        {
  135.           prev = cur;
  136.           cur = cur->next; 
  137.           free(prev->name);
  138.           free(prev);
  139.           }
  140.        return(1);
  141.        }
  142.  
  143.     /* cache not full yet */
  144.     incache++;
  145.  
  146.     prev = NULL;
  147.     cur = list;
  148.     while (cur != NULL)
  149.     {
  150.        prev = cur;
  151.        cur = cur->next;
  152.        }
  153.     if (prev == NULL)
  154.     {
  155.        list = newel;
  156.        return(1);
  157.        }
  158.     newel->next = list;
  159.     list = newel;
  160.     return(1);
  161.     }
  162.  
  163. /* for debugging use only */
  164.  
  165. void printcache()
  166. {
  167.     LIST *cur;
  168.     cur = list;
  169.     while (cur != NULL)
  170.     {
  171.         printf("%s\n", cur->name);
  172.         cur = cur->next;
  173.         }
  174.     }
  175.