home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / cpm / draco / draco-1.ark / QLIST.DRC < prev    next >
Text File  |  1986-11-12  |  4KB  |  246 lines
  1. /*
  2.  * QLIST.DRC - list handling utilities for Quest.
  3.  */
  4.  
  5. type
  6.     INTLIST = struct {
  7.     *INTLIST il_next;
  8.     int il_this;
  9.     },
  10.  
  11.     PROPLIST = struct {
  12.     *PROPLIST pl_next;
  13.     int pl_id;
  14.     int pl_property;
  15.     },
  16.  
  17.     ATTRLIST = struct {
  18.     *ATTRLIST al_next;
  19.     int al_id;
  20.     int al_attribute;
  21.     int al_value;
  22.     };
  23.  
  24. int NextId;            /* next available id */
  25. *PROPLIST PropList;        /* list of properties */
  26. *ATTRLIST AttrList;        /* list of attribute-value pairs */
  27.  
  28. /*
  29.  * lInit - initialize list processing.
  30.  */
  31.  
  32. proc nonrec lInit()void:
  33.  
  34.     NextId := 0;
  35.     PropList := nil;
  36.     AttrList := nil;
  37. corp;
  38.  
  39. /*
  40.  * getId - return the next unique id.
  41.  */
  42.  
  43. proc nonrec getId()int:
  44.  
  45.     NextId := NextId + 1;
  46.     NextId
  47. corp;
  48.  
  49. /*
  50.  * lAdd - add an element to the front of a list.
  51.  */
  52.  
  53. proc nonrec lAdd(**INTLIST p; int val)void:
  54.     *INTLIST il;
  55.  
  56.     il := new(INTLIST);
  57.     il*.il_next := p*;
  58.     il*.il_this := val;
  59.     p* := il;
  60. corp;
  61.  
  62. /*
  63.  * lAppend - append an element to the end of a list.
  64.  */
  65.  
  66. proc nonrec lAppend(**INTLIST p; int val)void:
  67.     *INTLIST il;
  68.  
  69.     while p* ~= nil do
  70.     p := &p**.il_next;
  71.     od;
  72.     il := new(INTLIST);
  73.     il*.il_next := nil;
  74.     il*.il_this := val;
  75.     p* := il;
  76. corp;
  77.  
  78. /*
  79.  * lDelete - delete an element from a list.
  80.  */
  81.  
  82. proc nonrec lDelete(**INTLIST p; int val)void:
  83.     *INTLIST il;
  84.  
  85.     while p* ~= nil and p**.il_this ~= val do
  86.     p := &p**.il_next;
  87.     od;
  88.     if p* ~= nil then
  89.     il := p*;
  90.     p* := il*.il_next;
  91.     free(il);
  92.     fi;
  93. corp;
  94.  
  95. /*
  96.  * lGet - get the nth entry on a list.
  97.  */
  98.  
  99. proc nonrec lGet(*INTLIST p; int n)int:
  100.  
  101.     while
  102.     n := n - 1;
  103.     n ~= 0 and p ~= nil
  104.     do
  105.     p := p*.il_next;
  106.     od;
  107.     if p = nil then
  108.     0
  109.     else
  110.     p*.il_this
  111.     fi
  112. corp;
  113.  
  114. /*
  115.  * lIn - say if a value is in a list.
  116.  */
  117.  
  118. proc nonrec lIn(*INTLIST il; int n)bool:
  119.  
  120.     while il ~= nil and il*.il_this ~= n do
  121.     il := il*.il_next;
  122.     od;
  123.     il ~= nil
  124. corp;
  125.  
  126. /*
  127.  * _pFind - find the list element for a given id-property pair.
  128.  */
  129.  
  130. proc nonrec _pFind(int id, prop)**PROPLIST:
  131.     **PROPLIST ppl;
  132.  
  133.     ppl := &PropList;
  134.     while ppl* ~= nil and (ppl**.pl_id ~= id or ppl**.pl_property ~= prop) do
  135.     ppl := &ppl**.pl_next;
  136.     od;
  137.     ppl
  138. corp;
  139.  
  140. /*
  141.  * putProp - associate a property with an id.
  142.  */
  143.  
  144. proc nonrec putProp(int id, prop)void:
  145.     *PROPLIST pl;
  146.  
  147.     if _pFind(id, prop)* = nil then
  148.     pl := new(PROPLIST);
  149.     pl*.pl_next := PropList;
  150.     pl*.pl_id := id;
  151.     pl*.pl_property := prop;
  152.     PropList := pl;
  153.     fi;
  154. corp;
  155.  
  156. /*
  157.  * getProp - return 'true' if a property is associated with an id.
  158.  */
  159.  
  160. proc nonrec getProp(int id, prop)bool:
  161.  
  162.     _pFind(id, prop)* ~= nil
  163. corp;
  164.  
  165. /*
  166.  * delProp - delete the given property from the given id.
  167.  */
  168.  
  169. proc nonrec delProp(int id, prop)void:
  170.     **PROPLIST ppl;
  171.     *PROPLIST pl;
  172.  
  173.     ppl := _pFind(id, prop);
  174.     if ppl* ~= nil then
  175.     pl := ppl*;
  176.     ppl* := pl*.pl_next;
  177.     free(pl);
  178.     fi;
  179. corp;
  180.  
  181. /*
  182.  * _aFind - find the list element for a given id-attribute pair.
  183.  */
  184.  
  185. proc nonrec _aFind(int id, attr)**ATTRLIST:
  186.     **ATTRLIST pal;
  187.  
  188.     pal := &AttrList;
  189.     while pal* ~= nil and (pal**.al_id ~= id or pal**.al_attribute~=attr) do
  190.     pal := &pal**.al_next;
  191.     od;
  192.     pal
  193. corp;
  194.  
  195. /*
  196.  * putAttr - associate an attribute-value with an id.
  197.  */
  198.  
  199. proc nonrec putAttr(int id, attr, val)void:
  200.     **ATTRLIST pal;
  201.     *ATTRLIST al;
  202.  
  203.     pal := _aFind(id, attr);
  204.     if pal* = nil then
  205.     al := new(ATTRLIST);
  206.     al*.al_next := AttrList;
  207.     al*.al_id := id;
  208.     al*.al_attribute := attr;
  209.     AttrList := al;
  210.     else
  211.     al := pal*;
  212.     fi;
  213.     al*.al_value := val;
  214. corp;
  215.  
  216. /*
  217.  * getAttr - return the value of an attribute associated with an id.
  218.  */
  219.  
  220. proc nonrec getAttr(int id, attr)int:
  221.     **ATTRLIST pal;
  222.  
  223.     pal := _aFind(id, attr);
  224.     if pal* = nil then
  225.     0
  226.     else
  227.     pal**.al_value
  228.     fi
  229. corp;
  230.  
  231. /*
  232.  * delAttr - delete the given attribute from the given id.
  233.  */
  234.  
  235. proc nonrec delAttr(int id, attr)void:
  236.     **ATTRLIST pal;
  237.     *ATTRLIST al;
  238.  
  239.     pal := _aFind(id, attr);
  240.     if pal* ~= nil then
  241.     al := pal*;
  242.     pal* := al*.al_next;
  243.     free(al);
  244.     fi;
  245. corp;
  246.