home *** CD-ROM | disk | FTP | other *** search
/ Phoenix Heaven Sunny 2 / APPARE2.BIN / oh_towns / art2 / src.lzh / FIFO.C < prev    next >
C/C++ Source or Header  |  1995-06-17  |  5KB  |  240 lines
  1. /*
  2.     fifo.c
  3.  
  4. ＦＩＦＯバッファ一般アルゴリズム
  5.  
  6.     fifo_new(data_size)
  7.     fifo_destroy(id)
  8.  
  9.     fifo_set(id, data)
  10.     fifo_get(id, data)
  11.     fifo_isEmpty(id)
  12.     fifo_getLeftNum(id)
  13.  
  14. リスト一般アルゴリズム
  15.  
  16.     LIST    *list_new(int size)
  17.     void    list_destroy(LIST *list)
  18.  
  19.     void    list_top(LIST *list)
  20.     void    list_next(LIST *list)
  21.     void    list_prev(LIST *list)
  22.     void    list_moveTo(LIST *list, int index)
  23.     void    *list_getData(LIST *list)
  24.     int        list_setData(LIST *list, void *data)
  25.     int        list_insertData(LIST *list, void *data)
  26.     void    list_deleteData(LIST *list)
  27.  
  28.     int        list_isOut(LIST *list)
  29.     int        list_getDataNum(LIST *list)
  30.     int        list_isEmpty(LIST *list)
  31. */
  32.  
  33. #include <stdio.h>
  34. #include <stdlib.h>
  35. #include <winb.h>
  36. #include <te.h>
  37. #include <fntb.h>
  38. #include <gui.h>
  39. #include <memory.h>
  40.  
  41. #include "fifo.h"
  42.  
  43. #define DATANUM 400
  44.  
  45. FIFO    *fifo_new(int data_size)
  46. {
  47.     FIFO *fifo;
  48.     fifo = TL_calloc(1,sizeof(FIFO));
  49.     if (fifo == NULL)
  50.         return NULL;
  51.     if ((fifo->data = TL_calloc(DATANUM, data_size)) == NULL)
  52.     {
  53.         TL_free(fifo);
  54.         return NULL;
  55.     }
  56.     fifo->datanum = 0;
  57.     fifo->datasize = data_size;
  58.     return fifo;
  59. }
  60.  
  61. void    fifo_destroy(FIFO *fifo)
  62. {
  63.     TL_free(fifo->data);
  64.     TL_free(fifo);
  65. }
  66.  
  67. int        fifo_set(FIFO *fifo, void *data)
  68. {
  69.     char *p;
  70.     if (fifo->datanum >= DATANUM-2)
  71.         return 0;
  72.     p = fifo->data + fifo->datasize*fifo->datanum;
  73.     memcpy(p, data, fifo->datasize);
  74.     fifo->datanum++;
  75.     return 0;
  76. }
  77.  
  78. int        fifo_get(FIFO *fifo, void *data)
  79. {
  80.     if (fifo->datanum <= 0)
  81.         return -1;
  82.     memcpy(data, fifo->data, fifo->datasize);
  83.     fifo->datanum--;
  84.     if (fifo->datanum > 0)
  85.         memcpy(fifo->data,fifo->data+fifo->datasize,
  86.                fifo->datanum*fifo->datasize);
  87.     return 0;
  88. }
  89.  
  90. int        fifo_isEmpty(FIFO *fifo)
  91. {
  92.     if (fifo->datanum <= 0)
  93.         return 1;
  94.     else
  95.         return 0;
  96. }
  97.  
  98. int        fifo_getLeftNum(FIFO *fifo)
  99. {
  100.     return fifo->datanum;
  101. }
  102.  
  103. /*--------------------------------------------------------*/
  104. /*                       リスト一般                       */
  105. /*--------------------------------------------------------*/
  106.  
  107. LIST    *list_new(int size)
  108. {
  109.     LIST *list;
  110.     list = TL_calloc(1,sizeof(LIST)+sizeof(LISTE));
  111.     if (list == NULL)
  112.         return NULL;
  113.     list->datanum = 0;
  114.     list->datasize = size;
  115.     list->outdata = (LISTE*)(list+1);
  116.     list->cur = list->outdata;
  117.     list->outdata->prev = list->outdata->next = list->outdata;
  118.     list->pos = 0;
  119.     return list;
  120. }
  121.  
  122. void    list_destroy(LIST *list)
  123. {
  124.     while (!list_isEmpty(list))
  125.       { list_top(list);  list_deleteData(list); }
  126.     TL_free(list);
  127. }
  128.  
  129. void    list_top(LIST *list)
  130. {
  131.     if (list->datanum <= 0)
  132.         return;
  133.     list->cur = list->outdata->next;
  134.     list->pos = 0;
  135. }
  136.  
  137. void    list_next(LIST *list)
  138. {
  139.     if (list->pos >= list->datanum)
  140.         return;
  141.     list->pos++;
  142.     list->cur = list->cur->next;
  143. }
  144.  
  145. void    list_prev(LIST *list)
  146. {
  147.     if (list->pos < 0)
  148.         return;
  149.     list->pos--;
  150.     list->cur = list->cur->prev;
  151. }
  152.  
  153. void    list_moveTo(LIST *list, int index)
  154. {
  155.     int i;
  156.     i = index - list->pos;
  157.     for (;i>0;i--)
  158.         list_next(list);
  159.     for (;i<0;i++)
  160.         list_prev(list);
  161. }
  162.  
  163. int        list_getData(LIST *list, void *data)
  164. {
  165.     if (list->pos < 0 || list->datanum <= list->pos)
  166.         return -1;
  167.     memcpy(data, list->cur+1, list->datasize);
  168.     return 0;
  169. }
  170.  
  171. int        list_setData(LIST *list, void *data)
  172. {
  173.     if (list->pos < 0 || list->datanum <= list->pos)
  174.         return -1;
  175.     memcpy(list->cur+1, data, list->datasize);
  176.     return 0;
  177. }
  178.  
  179. int        list_insertData(LIST *list, void *data)
  180. {
  181.     LISTE *le;
  182.     if (list->pos < 0)
  183.         return -1;
  184.     le = TL_calloc(1, sizeof(LISTE) + list->datasize);
  185.     if (le == NULL)
  186.         return -1;
  187.     memcpy(le+1,data,list->datasize);
  188.     /*
  189.         旧：    □            →    □        →        □
  190.                 cur->prev    ←    cur        ←        cur->next
  191.             
  192.         新：    □            →    □        →        □        →        □
  193.                 cur->prev    ←    le        ←        cur        ←        cur->next
  194.                                 (cur->prev)        (cur)            (cur->next)
  195.     */
  196.     le->next = list->cur;
  197.     le->prev = list->cur->prev;
  198.     list->cur->prev->next = le;
  199.     list->cur->prev = le;
  200.     list->pos++;
  201.     list->datanum++;
  202.     return 0;
  203. }
  204.  
  205. int        list_deleteData(LIST *list)
  206. {
  207.     LISTE *e;
  208.     if (list->pos < 0 || list->datanum <= list->pos)
  209.         return -1;
  210.     list->cur->prev->next = list->cur->next;
  211.     list->cur->next->prev = list->cur->prev;
  212.     e = list->cur;
  213.     list->cur = list->cur->next;
  214.     TL_free(e);
  215.     list->datanum--;
  216.     return 0;
  217. }
  218.  
  219. int        list_isOut(LIST *list)
  220. {
  221.     if (list->pos < 0 || list->datanum <= list->pos)
  222.         return 1;
  223.     else
  224.         return 0;
  225. }
  226.  
  227. int        list_getDataNum(LIST *list)
  228. {
  229.     return list->datanum;
  230. }
  231.  
  232. int        list_isEmpty(LIST *list)
  233. {
  234.     if (list->datanum == 0)
  235.         return 1;
  236.     else
  237.         return 0;
  238. }
  239.  
  240.