![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to KernQueue.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / driverkit|
Return to KernQueue.m CVS log | Up to [Apple Darwin 0.x] / kernel / driverkit |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1994 NeXT Computer, Inc.
27: *
28: * Kernel generic queue object(s).
29: *
30: * HISTORY
31: *
32: * 24 June 1994 ? at NeXT
33: * Created.
34: */
35:
36: #import <driverkit/KernQueue.h>
37: #import <driverkit/KernQueuePrivate.h>
38:
39: @implementation KernQueue
40:
41: - init
42: {
43: [super init];
44:
45: _first = _last = self;
46:
47: return self;
48: }
49:
50: - free
51: {
52: if (_first != self) /* !isEmpty */
53: return self;
54:
55: return [super free];
56: }
57:
58: - first
59: {
60: if (_first == self) /* isEmpty */
61: return nil;
62:
63: return _first;
64: }
65:
66: - last
67: {
68: if (_last == self) /* isEmpty */
69: return nil;
70:
71: return _last;
72: }
73:
74: - dequeueFirst
75: {
76: id entry;
77:
78: if (_first == self) /* isEmpty */
79: return nil;
80:
81: entry = _first;
82: QEPrev(QENext(entry)) = self;
83: _first = QENext(entry);
84:
85: QENext(entry) = QEPrev(entry) = nil;
86:
87: return entry;
88: }
89:
90: - dequeueLast
91: {
92: id entry;
93:
94: if (_last == self) /* isEmpty */
95: return nil;
96:
97: entry = _last;
98: QENext(QEPrev(entry)) = self;
99: _last = QEPrev(entry);
100:
101: QENext(entry) = QEPrev(entry) = nil;
102:
103: return entry;
104: }
105:
106: - dequeueFirstObject
107: {
108: id entry;
109:
110: if (_first == self) /* isEmpty */
111: return nil;
112:
113: entry = _first;
114: QEPrev(QENext(entry)) = self;
115: _first = QENext(entry);
116:
117: QENext(entry) = QEPrev(entry) = nil;
118:
119: return QEObject(entry);
120: }
121:
122: - dequeueLastObject
123: {
124: id entry;
125:
126: if (_last == self) /* isEmpty */
127: return nil;
128:
129: entry = _last;
130: QENext(QEPrev(entry)) = self;
131: _last = QEPrev(entry);
132:
133: QENext(entry) = QEPrev(entry) = nil;
134:
135: return QEObject(entry);
136: }
137:
138: - enqueueObjectAsFirst: object
139: {
140: }
141:
142: - enqueueObjectAsLast: object
143: {
144: }
145:
146: - (BOOL)isEmpty
147: {
148: return _first == self;
149: }
150:
151: @end
152:
153: @implementation KernQueueEntry
154:
155: - initForQueue: queue
156: withObject: object
157: {
158: [super init];
159:
160: _queue = queue;
161: _object = object;
162:
163: _next = _prev = nil;
164:
165: return self;
166: }
167:
168: - free
169: {
170: if (_next != nil) /* isQueued */
171: return self;
172:
173: return [super free];
174: }
175:
176: - freeObject
177: {
178: return [_object free];
179: }
180:
181: - enterAsFirst
182: {
183: return [self enterAsFirstOnQueue:_queue];
184: }
185:
186: - enterAsFirstOnQueue: queue
187: {
188: if (_next != nil || queue == nil) /* isQueued || noQueue */
189: return nil;
190:
191: _queue = queue;
192:
193: _next = QFirst(queue);
194: _prev = queue;
195: QEPrev(_next) = self;
196: QFirst(queue) = self;
197:
198: return self;
199: }
200:
201: - enterAsLast
202: {
203: return [self enterAsLastOnQueue:_queue];
204: }
205:
206: - enterAsLastOnQueue: queue
207: {
208: if (_next != nil || queue == nil) /* isQueued || noQueue */
209: return nil;
210:
211: _queue = queue;
212:
213: _next = queue;
214: _prev = QLast(queue);
215: QENext(_prev) = self;
216: QLast(queue) = self;
217:
218: return self;
219: }
220:
221: - removeFromQueue
222: {
223: if (_next != nil) { /* isQueued */
224: QEPrev(_next) = _prev;
225: QENext(_prev) = _next;
226: _next = _prev = nil;
227: }
228:
229: return self;
230: }
231:
232: - insertAfterEntry: prevEntry
233: {
234: if (_prev != nil || QENext(prevEntry) == nil) /* isQueued ||
235: prevEntry !isQueued */
236: return nil;
237:
238: _queue = QEQueue(prevEntry);
239:
240: _next = QENext(prevEntry);
241: _prev = prevEntry;
242: QEPrev(QENext(prevEntry)) = self;
243: QENext(prevEntry) = self;
244:
245: return self;
246: }
247:
248: - insertBeforeEntry: nextEntry
249: {
250: if (_next != nil || QEPrev(nextEntry) == nil) /* isQueued ||
251: nextEntry !isQueued */
252: return nil;
253:
254: _queue = QEQueue(nextEntry);
255:
256: _next = nextEntry;
257: _prev = QEPrev(nextEntry);
258: QENext(QEPrev(nextEntry)) = self;
259: QEPrev(nextEntry) = self;
260:
261: return self;
262: }
263:
264: - next
265: {
266: if (_next == _queue) /* endOfQueue */
267: return nil;
268:
269: return _next;
270: }
271:
272: - prev
273: {
274: if (_prev == _queue) /* endOfQueue */
275: return nil;
276:
277: return _prev;
278: }
279:
280: - nextObject: (id *)nextEntry
281: {
282: if (_next == nil || _next == _queue) { /* endOfQueue */
283: *nextEntry = nil;
284: return nil;
285: }
286:
287: *nextEntry = _next;
288:
289: return QEObject(_next);
290: }
291:
292: - prevObject: (id *)prevEntry
293: {
294: if (_prev == nil || _prev == _queue) { /* endOfQueue */
295: *prevEntry = nil;
296: return nil;
297: }
298:
299: *prevEntry = _prev;
300:
301: return QEObject(_prev);
302: }
303:
304: - object
305: {
306: return _object;
307: }
308:
309: - queue
310: {
311: return _queue;
312: }
313:
314: - (BOOL)isQueued
315: {
316: return _next != nil;
317: }
318:
319: @end
320:
321: KernQueueEntry *
322: KernQueueFirst(
323: KernQueue *queue
324: )
325: {
326: if (QFirst(queue) == queue)
327: return nil;
328:
329: return QFirst(queue);
330: }
331:
332: KernQueueEntry *
333: KernQueueLast(
334: KernQueue *queue
335: )
336: {
337: if (QLast(queue) == queue)
338: return nil;
339:
340: return QLast(queue);
341: }
342:
343: KernQueueEntry *
344: KernQueueNext(
345: KernQueueEntry *entry
346: )
347: {
348: if (QENext(entry) == QEQueue(entry))
349: return nil;
350:
351: return QENext(entry);
352: }
353:
354: KernQueueEntry *
355: KernQueuePrev(
356: KernQueueEntry *entry
357: )
358: {
359: if (QEPrev(entry) == QEQueue(entry))
360: return nil;
361:
362: return QEPrev(entry);
363: }
364:
365: void *
366: KernQueueEntryObject(
367: KernQueueEntry *entry
368: )
369: {
370: return QEObject(entry);
371: }
372:
373: void *
374: KernQueueNextObject(
375: KernQueueEntry **entry
376: )
377: {
378: KernQueueEntry *next = QENext(*entry);
379:
380: if (next == nil || next == QEQueue(*entry))
381: return nil;
382:
383: *entry = next;
384:
385: return QEObject(next);
386: }
387:
388: void *
389: KernQueuePrevObject(
390: KernQueueEntry **entry
391: )
392: {
393: KernQueueEntry *prev = QEPrev(*entry);
394:
395: if (prev == nil || prev == QEQueue(*entry))
396: return nil;
397:
398: *entry = prev;
399:
400: return QEObject(prev);
401: }
402:
403: BOOL
404: KernQueueIsEmpty(
405: KernQueue *queue
406: )
407: {
408: return QFirst(queue) == queue;
409: }
410:
411: BOOL
412: KernQueueEntryIsQueued(
413: KernQueueEntry *entry
414: )
415: {
416: return QENext(entry) != nil;
417: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.