![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qhead.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / libC / otask|
Return to qhead.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / libC / otask |
1.1 root 1: #include "task.h"
2:
3: /* a qhead's qh_queue has its pointer q_ptr pointing the last
4: element of a circular list, so that q_ptr->o_next is the
5: first element of that list.
6:
7: STRUCTURE:
8: qhead <--> oqueue <--> qtail (qhead and qtail are independent)
9: oqueue --> circular queue of objects
10:
11: "pen and paper is recommended when trying to understand
12: the list manipulations."
13: */
14:
15: /* construct qhead <--> (possible)oqueue --> 0 */
16: qhead::qhead(int mode, int max)
17: {
18: if (0 < max) {
19: qh_queue = new oqueue(max);
20: qh_queue->q_head = this;
21: };
22: qh_mode = mode;
23: }
24:
25:
26: /* destroy q if not pointed to by a qtail */
27: qhead::~qhead()
28: {
29: oqueue* q = qh_queue;
30:
31: if (q->q_tail)
32: q->q_head = 0;
33: else
34: delete q;
35:
36: }
37:
38:
39: /* remove and return object from head of q */
40: object*
41: qhead::get()
42: {
43: register oqueue* q = qh_queue;
44: ll:
45: if (q->q_count) {
46: register object* oo = q->q_ptr;
47: register object* p = oo->o_next;
48: oo->o_next = p->o_next;
49: p->o_next = 0;
50: if (q->q_count-- == q->q_max) {
51: qtail* t = q->q_tail;
52: if (t) t->alert();
53: };
54: return p;
55: }
56:
57: switch (qh_mode) {
58: case WMODE:
59: this_task()->sleep(this);
60: goto ll;
61: case EMODE:
62: task_error(E_GETEMPTY);
63: goto ll;
64: case ZMODE:
65: return 0;
66: }
67: }
68:
69: /* create a tail for this queue */
70: qtail*
71: qhead::tail()
72: {
73: oqueue* q = qh_queue;
74: register qtail* t = q->q_tail;
75:
76: if (t == 0) {
77: t = new qtail(qh_mode,0);
78: q->q_tail = t;
79: t->qt_queue = q;
80: }
81:
82: return t;
83: }
84:
85:
86: /* make room for a filter upstream from this qhead */
87: /* result: (this)qhead<-->newq (new)qhead<-->oldq ?<-->qtail? */
88: qhead*
89: qhead::cut()
90: {
91: oqueue* oldq = qh_queue;
92: qhead* h = new qhead(qh_mode,oldq->q_max);
93: oqueue* newq = h->qh_queue;
94:
95: oldq->q_head = h;
96: h->qh_queue = oldq;
97:
98: qh_queue = newq;
99: newq->q_head = this;
100:
101: return h;
102: }
103:
104:
105: /* this qhead is supposed to be upstream to the qtail t
106: add the contents of this's queue to t's queue
107: destroy this, t, and this's queue
108: alert the spliced qhead and qtail if a significant state change happened
109: */
110: void
111: qhead::splice(qtail* t)
112: {
113: oqueue* qt = t->qt_queue;
114: oqueue* qh = qh_queue;
115:
116: int qtcount = qt->q_count;
117: int qhcount = qh->q_count;
118: int halert = (qtcount==0 && qhcount); /* becomes non-empty */
119: int talert = (qh->q_max <= qhcount && qhcount+qtcount<qt->q_max);
120: /* becomes non-full */
121: if (qhcount) {
122: object* ooh = qh->q_ptr;
123: object* oot = qt->q_ptr;
124: qt->q_ptr = ooh;
125: if (qtcount) { /* add the contents of qh to qt */
126: object* tf = oot->o_next;
127: oot->o_next = ooh->o_next;
128: ooh->o_next = tf;
129: }
130: qt->q_count = qhcount + qtcount;
131: qh->q_count = 0;
132: }
133:
134: (qh->q_tail)->qt_queue = qt;
135: qt->q_tail = qh->q_tail;
136: qh->q_tail = 0;
137:
138: delete t;
139: delete this;
140:
141: if (halert) qt->q_head->alert();
142: if (talert) qt->q_tail->alert();
143: }
144:
145:
146: /* insert new object at head of queue (after queue->q_ptr) */
147: int
148: qhead::putback(object* p)
149: {
150: oqueue* q = qh_queue;
151:
152: if (p->o_next) task_error(E_BACKOBJ);
153: ll:
154: if (q->q_count++ < q->q_max) {
155: if (q->q_count == 1) {
156: q->q_ptr = p;
157: p->o_next = p;
158: }
159: else {
160: object* oo = q->q_ptr;
161: p->o_next = oo->o_next;
162: oo->o_next = p;
163: }
164: return 1;
165: }
166:
167: switch (qh_mode) {
168: case WMODE:
169: case EMODE:
170: task_error(E_BACKFULL);
171: goto ll;
172: case ZMODE:
173: return 0;
174: }
175: }
176:
177: int
178: qhead::pending()
179: {
180: return rdcount() == 0;
181: }
182:
183: void
184: qhead::print(int n, int baseClass)
185: {
186: if (!baseClass)
187: printf("qhead ");
188:
189: oqueue* q = qh_queue;
190:
191: printf("mode=%d, max=%d, count=%d, tail=%d\n",
192: qh_mode, q->q_max, q->q_count, q->q_tail);
193:
194: if (n&VERBOSE) {
195: int m = n & ~(CHAIN|VERBOSE);
196: if (q->q_tail) {
197: printf("\ttail of queue:\n");
198: q->q_tail->print(m);
199: } else printf("\tno tail\n");
200: q->print(m);
201: }
202:
203: object::print(n, 1);
204: }
205:
206:
207: void
208: oqueue::print(int n)
209: {
210: object* p = q_ptr;
211:
212: if (q_count == 0) return;
213:
214: printf("\tobjectects on queue:\n");
215:
216: do {
217: p->print(n);
218: p = p->o_next;
219: } while (p != q_ptr);
220:
221: printf("\n");
222: }
223:
224: int qhead::o_type()
225: {
226: return QHEAD;
227: }
228:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.