home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource5 / 308_01 / listfunc.inc < prev    next >
Encoding:
Text File  |  1990-06-18  |  10.8 KB  |  619 lines
  1.  
  2. /*
  3.  *  adds.inc -- include file for LIST.C
  4.  */
  5.  
  6. static int add0(void *item, size_t itemsize, enum Place place);
  7. static int add1(void *item, size_t itemsize, enum Place place);
  8. static int add2(void *item, size_t itemsize, enum Place place);
  9. static int add3(void *item, size_t itemsize, enum Place place);
  10.  
  11. static int (*adds[MAXLISTS])(void *item, size_t itemsize, enum Place place) = {
  12. add0, add1, add2, add3 };
  13.  
  14. static int add0(void *item, size_t itemsize, enum Place place)
  15. {
  16.     list = listptr[0];
  17.     return ladd(item, itemsize, place);
  18. }
  19.  
  20. static int add1(void *item, size_t itemsize, enum Place place)
  21. {
  22.     list = listptr[1];
  23.     return ladd(item, itemsize, place);
  24. }
  25.  
  26. static int add2(void *item, size_t itemsize, enum Place place)
  27. {
  28.     list = listptr[2];
  29.     return ladd(item, itemsize, place);
  30. }
  31.  
  32. static int add3(void *item, size_t itemsize, enum Place place)
  33. {
  34.     list = listptr[3];
  35.     return ladd(item, itemsize, place);
  36. }
  37.  
  38.  
  39. /*
  40.  *  chgcomps.inc -- include file for LIST.C
  41.  */
  42.  
  43. static int chgcomp0(int (*newcompare)());
  44. static int chgcomp1(int (*newcompare)());
  45. static int chgcomp2(int (*newcompare)());
  46. static int chgcomp3(int (*newcompare)());
  47.  
  48. static int (*chgcomps[MAXLISTS])(int (*newcompare)()) = {
  49. chgcomp0, chgcomp1, chgcomp2, chgcomp3 };
  50.  
  51. static int chgcomp0(int (*newcompare)())
  52. {
  53.     if(! newcompare)  {
  54.     lerror = NULL_PTR;
  55.     return 0;
  56.     }
  57.     compare[0] = newcompare;
  58.     return 1;
  59. }
  60.  
  61. static int chgcomp1(int (*newcompare)())
  62. {
  63.     if(! newcompare)  {
  64.     lerror = NULL_PTR;
  65.     return 0;
  66.     }
  67.     compare[1] = newcompare;
  68.     return 1;
  69. }
  70.  
  71. static int chgcomp2(int (*newcompare)())
  72. {
  73.     if(! newcompare)  {
  74.     lerror = NULL_PTR;
  75.     return 0;
  76.     }
  77.     compare[2] = newcompare;
  78.     return 1;
  79. }
  80.  
  81. static int chgcomp3(int (*newcompare)())
  82. {
  83.     if(! newcompare)  {
  84.     lerror = NULL_PTR;
  85.     return 0;
  86.     }
  87.     compare[3] = newcompare;
  88.     return 1;
  89. }
  90.  
  91. /*
  92.  *  cmps.inc -- include file for LIST.C
  93.  */
  94.  
  95. static int cmp0(void *item1);
  96. static int cmp1(void *item1);
  97. static int cmp2(void *item1);
  98. static int cmp3(void *item1);
  99.  
  100. static int (*cmps[MAXLISTS])() = { cmp0, cmp1, cmp2, cmp3 };
  101.  
  102. static int cmp0(void *item1)
  103. {
  104.     list = listptr[0];
  105.     return lcmpitem(item1);
  106. }
  107.  
  108. static int cmp1(void *item1)
  109. {
  110.     list = listptr[1];
  111.     return lcmpitem(item1);
  112. }
  113.  
  114. static int cmp2(void *item1)
  115. {
  116.     list = listptr[2];
  117.     return lcmpitem(item1);
  118. }
  119.  
  120. static int cmp3(void *item1)
  121. {
  122.     list = listptr[3];
  123.     return lcmpitem(item1);
  124. }
  125.  
  126.  
  127. /*
  128.  *  compares.inc -- include file for LIST.C
  129.  */
  130.  
  131. static int comp0(void *item1, void *item2);
  132. static int comp1(void *item1, void *item2);
  133. static int comp2(void *item1, void *item2);
  134. static int comp3(void *item1, void *item2);
  135.  
  136. static int (*compares[MAXLISTS])(void *item1, void *item2) = {
  137. comp0, comp1, comp2, comp3 };
  138.  
  139. static int comp0(void *item1, void *item2)
  140. {
  141.     list = listptr[0];
  142.     return compare[0](item1, item2);
  143. }
  144.  
  145. static int comp1(void *item1, void *item2)
  146. {
  147.     list = listptr[1];
  148.     return compare[1](item1, item2);
  149. }
  150.  
  151. static int comp2(void *item1, void *item2)
  152. {
  153.     list = listptr[2];
  154.     return compare[2](item1, item2);
  155. }
  156.  
  157. static int comp3(void *item1, void *item2)
  158. {
  159.     list = listptr[3];
  160.     return compare[3](item1, item2);
  161. }
  162.  
  163. /*
  164.  *  dels.inc -- include file for LIST.C
  165.  */
  166.  
  167. static int del0();
  168. static int del1();
  169. static int del2();
  170. static int del3();
  171.  
  172. static int (*dels[MAXLISTS])() = { del0, del1, del2, del3 };
  173.  
  174. static int del0()
  175. {
  176.     list = listptr[0];
  177.     return ldelete();
  178. }
  179.  
  180. static int del1()
  181. {
  182.     list = listptr[1];
  183.     return ldelete();
  184. }
  185.  
  186. static int del2()
  187. {
  188.     list = listptr[2];
  189.     return ldelete();
  190. }
  191.  
  192. static int del3()
  193. {
  194.     list = listptr[3];
  195.     return ldelete();
  196. }
  197.  
  198. /*
  199.  *  destroys.inc -- include file for LIST.C
  200.  */
  201.  
  202. static int dest0(void);
  203. static int dest1(void);
  204. static int dest2(void);
  205. static int dest3(void);
  206.  
  207. static int (*destroys[MAXLISTS])(void) = { dest0, dest1, dest2, dest3 };
  208.  
  209. static int dest0(void)
  210. {
  211.     list = listptr[0];
  212.     return ldestroy();
  213. }
  214.  
  215. static int dest1(void)
  216. {
  217.     list = listptr[1];
  218.     return ldestroy();
  219. }
  220.  
  221. static int dest2(void)
  222. {
  223.     list = listptr[2];
  224.     return ldestroy();
  225. }
  226.  
  227. static int dest3(void)
  228. {
  229.     list = listptr[3];
  230.     return ldestroy();
  231. }
  232.  
  233.  
  234. /*
  235.  *  finds.inc -- include file for LIST.C
  236.  */
  237.  
  238. static int find0(void *item1);
  239. static int find1(void *item1);
  240. static int find2(void *item1);
  241. static int find3(void *item1);
  242.  
  243. static int (*finds[MAXLISTS])() = { find0, find1, find2, find3 };
  244.  
  245. static int find0(void *item1)
  246. {
  247.     list = listptr[0];
  248.     return lfinditem(item1);
  249. }
  250.  
  251. static int find1(void *item1)
  252. {
  253.     list = listptr[1];
  254.     return lfinditem(item1);
  255. }
  256.  
  257. static int find2(void *item1)
  258. {
  259.     list = listptr[2];
  260.     return lfinditem(item1);
  261. }
  262.  
  263. static int find3(void *item1)
  264. {
  265.     list = listptr[3];
  266.     return lfinditem(item1);
  267. }
  268.  
  269. /*
  270.  *  firsts.inc -- include file for LIST.C
  271.  */
  272.  
  273. static int firsts0(void);
  274. static int firsts1(void);
  275. static int firsts2(void);
  276. static int firsts3(void);
  277.  
  278. static int (*firsts[MAXLISTS])(void) = { firsts0, firsts1, firsts2, firsts3 };
  279.  
  280. static int firsts0(void)
  281. {
  282.     list = listptr[0];
  283.     return lfirst();
  284. }
  285.  
  286. static int firsts1(void)
  287. {
  288.     list = listptr[1];
  289.     return lfirst();
  290. }
  291.  
  292. static int firsts2(void)
  293. {
  294.     list = listptr[2];
  295.     return lfirst();
  296. }
  297.  
  298. static int firsts3(void)
  299. {
  300.     list = listptr[3];
  301.     return lfirst();
  302. }
  303.  
  304. /*
  305.  *  gitems.inc  -- include file for LIST.C
  306.  */
  307.  
  308. static int gitem0(void *itembuf);
  309. static int gitem1(void *itembuf);
  310. static int gitem2(void *itembuf);
  311. static int gitem3(void *itembuf);
  312.  
  313. static int (*gitems[MAXLISTS])(void *itembuf) = {
  314. gitem0, gitem1, gitem2, gitem3 };
  315.  
  316. static int gitem0(void *itembuf)
  317. {
  318.     list = listptr[0];
  319.     return lgetitem(itembuf);
  320. }
  321.  
  322. static int gitem1(void *itembuf)
  323. {
  324.     list = listptr[1];
  325.     return lgetitem(itembuf);
  326. }
  327.  
  328. static int gitem2(void *itembuf)
  329. {
  330.     list = listptr[2];
  331.     return lgetitem(itembuf);
  332. }
  333.  
  334. static int gitem3(void *itembuf)
  335. {
  336.     list = listptr[3];
  337.     return lgetitem(itembuf);
  338. }
  339.  
  340. /*
  341.  *  gptrs.inc -- include file for LIST.C
  342.  */
  343.  
  344. static void *gptr0(void);
  345. static void *gptr1(void);
  346. static void *gptr2(void);
  347. static void *gptr3(void);
  348.  
  349. static void *(*gptrs[MAXLISTS])(void) = { gptr0, gptr1, gptr2, gptr3 };
  350.  
  351. static void *gptr0(void)
  352. {
  353.     list = listptr[0];
  354.     return lgetptr();
  355. }
  356.  
  357. static void *gptr1(void)
  358. {
  359.     list = listptr[1];
  360.     return lgetptr();
  361. }
  362.  
  363. static void *gptr2(void)
  364. {
  365.     list = listptr[2];
  366.     return lgetptr();
  367. }
  368.  
  369. static void *gptr3(void)
  370. {
  371.     list = listptr[3];
  372.     return lgetptr();
  373. }
  374.  
  375. /*
  376.  *  gsizes.inc -- include file for LIST.C
  377.  */
  378.  
  379. static size_t gsize0(void);
  380. static size_t gsize1(void);
  381. static size_t gsize2(void);
  382. static size_t gsize3(void);
  383.  
  384. static size_t (*gsizes[MAXLISTS])(void) = { gsize0, gsize1, gsize2, gsize3 };
  385.  
  386. static size_t gsize0(void)
  387. {
  388.     list = listptr[0];
  389.     return lgetsize();
  390. }
  391.  
  392. static size_t gsize1(void)
  393. {
  394.     list = listptr[1];
  395.     return lgetsize();
  396. }
  397.  
  398. static size_t gsize2(void)
  399. {
  400.     list = listptr[2];
  401.     return lgetsize();
  402. }
  403.  
  404. static size_t gsize3(void)
  405. {
  406.     list = listptr[3];
  407.     return lgetsize();
  408. }
  409.  
  410. /*
  411.  *  lasts.inc -- include file for LIST.C
  412.  */
  413.  
  414. static int lasts0(void);
  415. static int lasts1(void);
  416. static int lasts2(void);
  417. static int lasts3(void);
  418.  
  419. static int (*lasts[MAXLISTS])(void) = { lasts0, lasts1, lasts2, lasts3 };
  420.  
  421. static int lasts0(void)
  422. {
  423.     list = listptr[0];
  424.     return llast();
  425. }
  426.  
  427. static int lasts1(void)
  428. {
  429.     list = listptr[1];
  430.     return llast();
  431. }
  432.  
  433. static int lasts2(void)
  434. {
  435.     list = listptr[2];
  436.     return llast();
  437. }
  438.  
  439. static int lasts3(void)
  440. {
  441.     list = listptr[3];
  442.     return llast();
  443. }
  444.  
  445. /*
  446.  *  nexts.inc -- include file for LIST.C
  447.  */
  448.  
  449. static int nexts0(void);
  450. static int nexts1(void);
  451. static int nexts2(void);
  452. static int nexts3(void);
  453.  
  454. static int (*nexts[MAXLISTS])(void) = { nexts0, nexts1, nexts2, nexts3 };
  455.  
  456. static int nexts0(void)
  457. {
  458.     list = listptr[0];
  459.     return lnext();
  460. }
  461.  
  462. static int nexts1(void)
  463. {
  464.     list = listptr[1];
  465.     return lnext();
  466. }
  467.  
  468. static int nexts2(void)
  469. {
  470.     list = listptr[2];
  471.     return lnext();
  472. }
  473.  
  474. static int nexts3(void)
  475. {
  476.     list = listptr[3];
  477.     return lnext();
  478. }
  479.  
  480. /*
  481.  *  prevs.inc -- include file for LIST.C
  482.  */
  483.  
  484. static int prevs0(void);
  485. static int prevs1(void);
  486. static int prevs2(void);
  487. static int prevs3(void);
  488.  
  489. static int (*prevs[MAXLISTS])(void) = { prevs0, prevs1, prevs2, prevs3 };
  490.  
  491. static int prevs0(void)
  492. {
  493.     list = listptr[0];
  494.     return lprev();
  495. }
  496.  
  497. static int prevs1(void)
  498. {
  499.     list = listptr[1];
  500.     return lprev();
  501. }
  502.  
  503. static int prevs2(void)
  504. {
  505.     list = listptr[2];
  506.     return lprev();
  507. }
  508.  
  509. static int prevs3(void)
  510. {
  511.     list = listptr[3];
  512.     return lprev();
  513. }
  514.  
  515. /*
  516.  *  rems.inc -- include file for LIST.C
  517.  */
  518.  
  519. static int rem0(void *itembuf);
  520. static int rem1(void *itembuf);
  521. static int rem2(void *itembuf);
  522. static int rem3(void *itembuf);
  523.  
  524. static int (*rems[MAXLISTS])(void *itembuf) = { rem0, rem1, rem2, rem3 };
  525.  
  526. static int rem0(void *itembuf)
  527. {
  528.     list = listptr[0];
  529.     return lremitem(itembuf);
  530. }
  531.  
  532. static int rem1(void *itembuf)
  533. {
  534.     list = listptr[1];
  535.     return lremitem(itembuf);
  536. }
  537.  
  538. static int rem2(void *itembuf)
  539. {
  540.     list = listptr[2];
  541.     return lremitem(itembuf);
  542. }
  543.  
  544. static int rem3(void *itembuf)
  545. {
  546.     list = listptr[3];
  547.     return lremitem(itembuf);
  548. }
  549.  
  550. /*
  551.  *  replace.inc -- include file for LIST.C
  552.  */
  553.  
  554. static int replace0(void *newitem, int newsize);
  555. static int replace1(void *newitem, int newsize);
  556. static int replace2(void *newitem, int newsize);
  557. static int replace3(void *newitem, int newsize);
  558.  
  559. static int (*replace[MAXLISTS])() = { replace0, replace1, replace2, replace3 };
  560.  
  561. static int replace0(void *newitem, int newsize)
  562. {
  563.     list = listptr[0];
  564.     return lreplitem(newitem, newsize);
  565. }
  566.  
  567. static int replace1(void *newitem, int newsize)
  568. {
  569.     list = listptr[1];
  570.     return lreplitem(newitem, newsize);
  571. }
  572.  
  573. static int replace2(void *newitem, int newsize)
  574. {
  575.     list = listptr[2];
  576.     return lreplitem(newitem, newsize);
  577. }
  578.  
  579. static int replace3(void *newitem, int newsize)
  580. {
  581.     list = listptr[3];
  582.     return lreplitem(newitem, newsize);
  583. }
  584.  
  585. /*
  586.  *  sorts.inc -- include file for LIST.C
  587.  */
  588.  
  589. static int sort0();
  590. static int sort1();
  591. static int sort2();
  592. static int sort3();
  593.  
  594. static int (*sorts[MAXLISTS])() = { sort0, sort1, sort2, sort3 };
  595.  
  596. static int sort0()
  597. {
  598.     list = listptr[0];
  599.     return lqsort();
  600. }
  601.  
  602. static int sort1()
  603. {
  604.     list = listptr[1];
  605.     return lqsort();
  606. }
  607.  
  608. static int sort2()
  609. {
  610.     list = listptr[2];
  611.     return lqsort();
  612. }
  613.  
  614. static int sort3()
  615. {
  616.     list = listptr[3];
  617.     return lqsort();
  618. }
  619.