home *** CD-ROM | disk | FTP | other *** search
/ Big Green CD 8 / BGCD_8_Dev.iso / NEXTSTEP / UNIX / Shells / zsh-3.0.5-MIHS / src / Src / linklist.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-28  |  4.1 KB  |  206 lines
  1. /*
  2.  * $Id: linklist.c,v 2.3 1996/10/15 20:16:35 hzoli Exp $
  3.  *
  4.  * linklist.c - linked lists
  5.  *
  6.  * This file is part of zsh, the Z shell.
  7.  *
  8.  * Copyright (c) 1992-1996 Paul Falstad
  9.  * All rights reserved.
  10.  *
  11.  * Permission is hereby granted, without written agreement and without
  12.  * license or royalty fees, to use, copy, modify, and distribute this
  13.  * software and to distribute modified versions of this software for any
  14.  * purpose, provided that the above copyright notice and the following
  15.  * two paragraphs appear in all copies of this software.
  16.  *
  17.  * In no event shall Paul Falstad or the Zsh Development Group be liable
  18.  * to any party for direct, indirect, special, incidental, or consequential
  19.  * damages arising out of the use of this software and its documentation,
  20.  * even if Paul Falstad and the Zsh Development Group have been advised of
  21.  * the possibility of such damage.
  22.  *
  23.  * Paul Falstad and the Zsh Development Group specifically disclaim any
  24.  * warranties, including, but not limited to, the implied warranties of
  25.  * merchantability and fitness for a particular purpose.  The software
  26.  * provided hereunder is on an "as is" basis, and Paul Falstad and the
  27.  * Zsh Development Group have no obligation to provide maintenance,
  28.  * support, updates, enhancements, or modifications.
  29.  *
  30.  */
  31.  
  32. #include "zsh.h"
  33.  
  34. /* Get an empty linked list header */
  35.  
  36. /**/
  37. LinkList
  38. newlinklist(void)
  39. {
  40.     LinkList list;
  41.  
  42.     list = (LinkList) alloc(sizeof *list);
  43.     list->first = NULL;
  44.     list->last = (LinkNode) list;
  45.     return list;
  46. }
  47.  
  48. /* Insert a node in a linked list after a given node */
  49.  
  50. /**/
  51. void
  52. insertlinknode(LinkList list, LinkNode node, void *dat)
  53. {
  54.     LinkNode tmp;
  55.  
  56.     tmp = node->next;
  57.     node->next = (LinkNode) alloc(sizeof *tmp);
  58.     node->next->last = node;
  59.     node->next->dat = dat;
  60.     node->next->next = tmp;
  61.     if (tmp)
  62.     tmp->last = node->next;
  63.     else
  64.     list->last = node->next;
  65. }
  66.  
  67. /* Insert a list in another list */
  68.  
  69. /**/
  70. void
  71. insertlinklist(LinkList l, LinkNode where, LinkList x)
  72. {
  73.     LinkNode nx;
  74.  
  75.     nx = where->next;
  76.     if (!l->first)
  77.     return;
  78.     where->next = l->first;
  79.     l->last->next = nx;
  80.     l->first->last = where;
  81.     if (nx)
  82.     nx->last = l->last;
  83.     else
  84.     x->last = l->last;
  85. }
  86.  
  87. /* Get top node in a linked list */
  88.  
  89. /**/
  90. void *
  91. getlinknode(LinkList list)
  92. {
  93.     void *dat;
  94.     LinkNode node;
  95.  
  96.     if (!(node = list->first))
  97.     return NULL;
  98.     dat = node->dat;
  99.     list->first = node->next;
  100.     if (node->next)
  101.     node->next->last = (LinkNode) list;
  102.     else
  103.     list->last = (LinkNode) list;
  104.     zfree(node, sizeof(struct linknode));
  105.     return dat;
  106. }
  107.  
  108. /* Get top node in a linked list without freeing */
  109.  
  110. /**/
  111. void *
  112. ugetnode(LinkList list)
  113. {
  114.     void *dat;
  115.     LinkNode node;
  116.  
  117.     if (!(node = list->first))
  118.     return NULL;
  119.     dat = node->dat;
  120.     list->first = node->next;
  121.     if (node->next)
  122.     node->next->last = (LinkNode) list;
  123.     else
  124.     list->last = (LinkNode) list;
  125.     return dat;
  126. }
  127.  
  128. /* Remove a node from a linked list */
  129.  
  130. /**/
  131. void *
  132. remnode(LinkList list, LinkNode nd)
  133. {
  134.     void *dat;
  135.  
  136.     nd->last->next = nd->next;
  137.     if (nd->next)
  138.     nd->next->last = nd->last;
  139.     else
  140.     list->last = nd->last;
  141.     dat = nd->dat;
  142.     zfree(nd, sizeof(struct linknode));
  143.  
  144.     return dat;
  145. }
  146.  
  147. /* Remove a node from a linked list without freeing */
  148.  
  149. /**/
  150. void *
  151. uremnode(LinkList list, LinkNode nd)
  152. {
  153.     void *dat;
  154.  
  155.     nd->last->next = nd->next;
  156.     if (nd->next)
  157.     nd->next->last = nd->last;
  158.     else
  159.     list->last = nd->last;
  160.     dat = nd->dat;
  161.     return dat;
  162. }
  163.  
  164. /* Free a linked list */
  165.  
  166. /**/
  167. void
  168. freelinklist(LinkList list, FreeFunc freefunc)
  169. {
  170.     LinkNode node, next;
  171.  
  172.     for (node = list->first; node; node = next) {
  173.     next = node->next;
  174.     if (freefunc)
  175.         freefunc(node->dat);
  176.     zfree(node, sizeof(struct linknode));
  177.     }
  178.     zfree(list, sizeof(struct linklist));
  179. }
  180.  
  181. /* Count the number of nodes in a linked list */
  182.  
  183. /**/
  184. int
  185. countlinknodes(LinkList list)
  186. {
  187.     LinkNode nd;
  188.     int ct = 0;
  189.  
  190.     for (nd = firstnode(list); nd; incnode(nd), ct++);
  191.     return ct;
  192. }
  193.  
  194. /**/
  195. void
  196. rolllist(LinkList l, LinkNode nd)
  197. {
  198.     l->last->next = l->first;
  199.     l->first->last = l->last;
  200.     l->first = nd;
  201.     l->last = nd->last;
  202.     nd->last = (LinkNode) l;
  203.     l->last->next = 0;
  204. }
  205.  
  206.