![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IORegistryEntry.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Kernel|
Return to IORegistryEntry.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Kernel |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1998 Apple Computer, Inc. All rights reserved.
24: *
25: * HISTORY
26: * 12 Nov 98 sdouglas created.
27: *
28: */
29:
30: #include <IOKit/IORegistryEntry.h>
31: #include <libkern/c++/OSContainers.h>
32: #include <IOKit/IOService.h>
33: #include <IOKit/IOKitKeys.h>
34:
35: #include <IOKit/IOLib.h>
36:
37: #include <IOKit/assert.h>
38:
39: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
40:
41: #define super OSObject
42:
43: OSDefineMetaClassAndStructors(IORegistryEntry, OSObject)
44:
45: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
46:
47: static IORegistryEntry * gRegistryRoot;
48: static OSDictionary * gIORegistryPlanes;
49:
50: const OSSymbol * gIONameKey;
51: const OSSymbol * gIOLocationKey;
52:
53: enum {
54: kParentSetIndex = 0,
55: kChildSetIndex = 1,
56: kNumSetIndex
57: };
58: enum {
59: kIOMaxPlaneName = 32
60: };
61:
62: class IORegistryPlane : public OSObject {
63:
64: friend IORegistryEntry;
65:
66: OSDeclareAbstractStructors(IORegistryPlane)
67:
68: const OSSymbol * nameKey;
69: const OSSymbol * keys[ kNumSetIndex ];
70: const OSSymbol * pathNameKey;
71: const OSSymbol * pathLocationKey;
72: int reserved[2];
73:
74: public:
75: virtual bool serialize(OSSerialize *s) const;
76: };
77:
78: OSDefineMetaClassAndStructors(IORegistryPlane, OSObject)
79:
80:
81: static lock_t * gIORegistryLock;
82: static IORecursiveLock * gPropertiesLock;
83: static SInt32 gIORegistryGenerationCount;
84:
85: #define UNLOCK lock_done( gIORegistryLock )
86: #define RLOCK lock_read( gIORegistryLock )
87: #define WLOCK lock_write( gIORegistryLock ); \
88: gIORegistryGenerationCount++
89: // make atomic
90:
91: #define PUNLOCK IORecursiveLockUnlock( gPropertiesLock )
92: #define PLOCK IORecursiveLockLock( gPropertiesLock )
93:
94: #define IOREGSPLITTABLES
95:
96: #ifdef IOREGSPLITTABLES
97: #define registryTable() fRegistryTable
98: #else
99: #define registryTable() fPropertyTable
100: #endif
101:
102: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
103:
104: IORegistryEntry * IORegistryEntry::initialize( void )
105: {
106: bool ok;
107:
108: if( !gRegistryRoot) {
109:
110: gRegistryRoot = new IORegistryEntry;
111: gIORegistryLock = lock_alloc(true, NULL, NULL);
112: gPropertiesLock = IORecursiveLockAlloc();
113: gIORegistryPlanes = OSDictionary::withCapacity( 1 );
114:
115: assert( gRegistryRoot && gIORegistryLock && gPropertiesLock
116: && gIORegistryPlanes );
117: ok = gRegistryRoot->init();
118:
119: gIONameKey = OSSymbol::withCStringNoCopy( "IOName" );
120: gIOLocationKey = OSSymbol::withCStringNoCopy( "IOLocation" );
121:
122: assert( ok && gIONameKey && gIOLocationKey );
123:
124: gRegistryRoot->setName( "Root" );
125: gRegistryRoot->setProperty( kIORegistryPlanesKey, gIORegistryPlanes );
126: }
127:
128: return( gRegistryRoot );
129: }
130:
131: IORegistryEntry * IORegistryEntry::getRegistryRoot( void )
132: {
133: return( gRegistryRoot );
134: }
135:
136: SInt32 IORegistryEntry::getGenerationCount( void )
137: {
138: return( gIORegistryGenerationCount );
139: }
140:
141:
142: const IORegistryPlane * IORegistryEntry::makePlane( const char * name )
143: {
144: IORegistryPlane * plane;
145: const OSSymbol * nameKey;
146: const OSSymbol * parentKey;
147: const OSSymbol * childKey;
148: const OSSymbol * pathNameKey;
149: const OSSymbol * pathLocationKey;
150: char key[ kIOMaxPlaneName + 16 ];
151: char * end;
152:
153: strncpy( key, name, kIOMaxPlaneName );
154: key[ kIOMaxPlaneName ] = 0;
155: end = key + strlen( name );
156:
157: nameKey = OSSymbol::withCString( key);
158:
159: strcpy( end, "ParentLinks" );
160: parentKey = OSSymbol::withCString( key);
161:
162: strcpy( end, "ChildLinks" );
163: childKey = OSSymbol::withCString( key);
164:
165: strcpy( end, "Name" );
166: pathNameKey = OSSymbol::withCString( key);
167:
168: strcpy( end, "Location" );
169: pathLocationKey = OSSymbol::withCString( key);
170:
171: plane = new IORegistryPlane;
172:
173: if( plane && plane->init()
174: && nameKey && parentKey && childKey
175: && pathNameKey && pathLocationKey ) {
176:
177: plane->nameKey = nameKey;
178: plane->keys[ kParentSetIndex ] = parentKey;
179: plane->keys[ kChildSetIndex ] = childKey;
180: plane->pathNameKey = pathNameKey;
181: plane->pathLocationKey = pathLocationKey;
182:
183: WLOCK;
184: gIORegistryPlanes->setObject( nameKey, plane );
185: UNLOCK;
186:
187: } else {
188:
189: if( plane)
190: plane->release();
191: if( pathLocationKey)
192: pathLocationKey->release();
193: if( pathNameKey)
194: pathNameKey->release();
195: if( parentKey)
196: parentKey->release();
197: if( childKey)
198: childKey->release();
199: if( nameKey)
200: nameKey->release();
201: plane = 0;
202: }
203:
204: return( plane);
205: }
206:
207: const IORegistryPlane * IORegistryEntry::getPlane( const char * name )
208: {
209: const IORegistryPlane * plane;
210:
211: RLOCK;
212: plane = (const IORegistryPlane *) gIORegistryPlanes->getObject( name );
213: UNLOCK;
214:
215: return( plane );
216: }
217:
218: bool IORegistryPlane::serialize(OSSerialize *s) const
219: {
220: return( nameKey->serialize(s) );
221: }
222:
223: enum { kIORegCapacityIncrement = 4 };
224:
225: bool IORegistryEntry::init( OSDictionary * dict = 0 )
226: {
227: OSString * prop;
228:
229: if( !super::init())
230: return( false);
231:
232: if( dict) {
233: dict->retain();
234: fPropertyTable = dict;
235:
236: } else {
237: fPropertyTable = OSDictionary::withCapacity( kIORegCapacityIncrement );
238: if( fPropertyTable)
239: fPropertyTable->setCapacityIncrement( kIORegCapacityIncrement );
240: }
241:
242: if( !fPropertyTable)
243: return( false);
244:
245: #ifdef IOREGSPLITTABLES
246: fRegistryTable = OSDictionary::withCapacity( kIORegCapacityIncrement );
247: if( fRegistryTable)
248: fRegistryTable->setCapacityIncrement( kIORegCapacityIncrement );
249:
250: if( (prop = OSDynamicCast( OSString, getProperty( gIONameKey)))) {
251: OSSymbol * sym = (OSSymbol *)OSSymbol::withString( prop);
252: // ok for OSSymbol too
253: setName( sym);
254: sym->release();
255: }
256:
257: #endif /* IOREGSPLITTABLES */
258:
259: return( true);
260: }
261:
262: bool IORegistryEntry::init( IORegistryEntry * old,
263: const IORegistryPlane * plane )
264: {
265: OSArray * all;
266: IORegistryEntry * next;
267: unsigned int index;
268:
269: if( !super::init())
270: return( false);
271:
272: WLOCK;
273:
274: fPropertyTable = old->getPropertyTable();
275: old->fPropertyTable = 0;
276: #ifdef IOREGSPLITTABLES
277: fRegistryTable = old->fRegistryTable;
278: old->fRegistryTable = 0;
279: #endif /* IOREGSPLITTABLES */
280:
281: all = getParentSetReference( plane );
282: if( all) for( index = 0;
283: (next = (IORegistryEntry *) all->getObject(index));
284: index++ ) {
285: next->makeLink( this, kChildSetIndex, plane );
286: next->breakLink( old, kChildSetIndex, plane );
287: }
288:
289: all = getChildSetReference( plane );
290: if( all) for( index = 0;
291: (next = (IORegistryEntry *) all->getObject(index));
292: index++ ) {
293: next->makeLink( this, kParentSetIndex, plane );
294: next->breakLink( old, kParentSetIndex, plane );
295: }
296:
297: UNLOCK;
298:
299: return( true );
300: }
301:
302: void IORegistryEntry::free( void )
303: {
304:
305: #ifdef DEBUG
306: OSArray * links;
307: const OSSymbol * key;
308: const IORegistryPlane * plane;
309: OSCollectionIterator * iter;
310:
311: if( registryTable()) {
312: iter = OSCollectionIterator::withCollection( gIORegistryPlanes );
313: if( iter) {
314: while( (key = (const OSSymbol *) iter->getNextObject())) {
315: if( 0 == (plane = (const IORegistryPlane *)
316: OSDynamicCast( IORegistryPlane,
317: gIORegistryPlanes->getObject( key ))))
318: continue;
319: if( (links = getParentSetReference( plane ))
320: || (links = getChildSetReference( plane )) ) {
321:
322: IOLog("%s: Still attached in %s at free()\n",
323: getName(), plane->nameKey->getCStringNoCopy());
324: }
325: }
326: iter->release();
327: }
328: }
329: #endif
330:
331: if( getPropertyTable())
332: getPropertyTable()->release();
333:
334: #ifdef IOREGSPLITTABLES
335: if( registryTable())
336: registryTable()->release();
337: #endif /* IOREGSPLITTABLES */
338:
339: super::free();
340: }
341:
342: void IORegistryEntry::setPropertyTable( OSDictionary * dict )
343: {
344: if( fPropertyTable)
345: fPropertyTable->release();
346: if( dict)
347: dict->retain();
348: fPropertyTable = dict;
349: }
350:
351: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
352:
353: /* Wrappers to synchronize property table */
354:
355: #define wrap1(func,type,constant) \
356: OSObject * \
357: IORegistryEntry::func ## Property( type * aKey) constant \
358: { \
359: OSObject * obj; \
360: \
361: PLOCK; \
362: obj = getPropertyTable()->func ## Object( aKey ); \
363: PUNLOCK; \
364: \
365: return( obj ); \
366: }
367:
368: #define wrap2(func,type) \
369: OSObject * \
370: IORegistryEntry::func ## Object( OSObject * anObject, type * aKey) \
371: { \
372: OSObject * obj; \
373: \
374: PLOCK; \
375: obj = getPropertyTable()->func ## Object( anObject, aKey ); \
376: PUNLOCK; \
377: \
378: return( obj ); \
379: }
380:
381: #define wrap3(func,type,constant) \
382: void \
383: IORegistryEntry::func ## Property( type * aKey) constant \
384: { \
385: PLOCK; \
386: getPropertyTable()->func ## Object( aKey ); \
387: PUNLOCK; \
388: }
389:
390: bool IORegistryEntry::serializeProperties( OSSerialize * s ) const
391: {
392: bool ok;
393:
394: // setProperty( getRetainCount(), 32, "__retain" );
395:
396: PLOCK;
397: ok = getPropertyTable()->serialize( s );
398: PUNLOCK;
399:
400: return( ok );
401: }
402:
403: OSDictionary * IORegistryEntry::dictionaryWithProperties( void ) const
404: {
405: OSDictionary * dict;
406:
407: PLOCK;
408: dict = OSDictionary::withDictionary( getPropertyTable(),
409: getPropertyTable()->getCapacity() );
410: PUNLOCK;
411:
412: return( dict );
413: }
414:
415: IOReturn IORegistryEntry::setProperties( OSObject * properties )
416: {
417: return( kIOReturnUnsupported );
418: }
419:
420: wrap1(get, const OSSymbol, const) // getProperty() definition
421: wrap1(get, const OSString, const) // getProperty() definition
422: wrap1(get, const char, const) // getProperty() definition
423:
424: wrap3(remove, const OSSymbol,) // removeProperty() definition
425: wrap3(remove, const OSString,) // removeProperty() definition
426: wrap3(remove, const char,) // removeProperty() definition
427:
428: bool
429: IORegistryEntry::setProperty( const OSSymbol * aKey, OSObject * anObject)
430: {
431: bool ret = false;
432: PLOCK;
433: ret = getPropertyTable()->setObject( aKey, anObject );
434: PUNLOCK;
435:
436: return ret;
437: }
438:
439: bool
440: IORegistryEntry::setProperty( const OSString * aKey, OSObject * anObject)
441: {
442: bool ret = false;
443: PLOCK;
444: ret = getPropertyTable()->setObject( aKey, anObject );
445: PUNLOCK;
446:
447: return ret;
448: }
449:
450: bool
451: IORegistryEntry::setProperty( const char * aKey, OSObject * anObject)
452: {
453: bool ret = false;
454: PLOCK;
455: ret = getPropertyTable()->setObject( aKey, anObject );
456: PUNLOCK;
457:
458: return ret;
459: }
460:
461: bool
462: IORegistryEntry::setProperty(const char * aKey, const char * aString)
463: {
464: bool ret = false;
465: OSSymbol * aSymbol = (OSSymbol *) OSSymbol::withCString( aString );
466:
467: if( aSymbol) {
468: PLOCK;
469: ret = getPropertyTable()->setObject( aKey, aSymbol );
470: PUNLOCK;
471: aSymbol->release();
472: }
473: return( ret );
474: }
475:
476: bool
477: IORegistryEntry::setProperty(const char * aKey, bool aBoolean)
478: {
479: bool ret = false;
480: OSBoolean * aBooleanObj = OSBoolean::withBoolean( aBoolean );
481:
482: if( aBooleanObj) {
483: PLOCK;
484: ret = getPropertyTable()->setObject( aKey, aBooleanObj );
485: PUNLOCK;
486: aBooleanObj->release();
487: }
488: return( ret );
489: }
490:
491: bool
492: IORegistryEntry::setProperty( const char * aKey,
493: unsigned long long aValue,
494: unsigned int aNumberOfBits)
495: {
496: bool ret = false;
497: OSNumber * anOffset = OSNumber::withNumber( aValue, aNumberOfBits );
498:
499: if( anOffset) {
500: PLOCK;
501: ret = getPropertyTable()->setObject( aKey, anOffset );
502: PUNLOCK;
503: anOffset->release();
504: }
505: return( ret );
506: }
507:
508: bool
509: IORegistryEntry::setProperty( const char * aKey,
510: void * bytes,
511: unsigned int length)
512: {
513: bool ret = false;
514: OSData * data = OSData::withBytes( bytes, length );
515:
516: if( data) {
517: PLOCK;
518: ret = getPropertyTable()->setObject( aKey, data );
519: PUNLOCK;
520: data->release();
521: }
522: return( ret );
523: }
524:
525: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
526:
527: /* Name, location, paths */
528:
529: const char * IORegistryEntry::getName( const IORegistryPlane * plane = 0 ) const
530: {
531: OSSymbol * sym = 0;
532:
533: RLOCK;
534: if( plane)
535: sym = (OSSymbol *) registryTable()->getObject( plane->pathNameKey );
536: if( !sym)
537: sym = (OSSymbol *) registryTable()->getObject( gIONameKey );
538: UNLOCK;
539:
540: if( sym)
541: return( sym->getCStringNoCopy());
542: else
543: return( (getMetaClass())->getClassName());
544: }
545:
546: const OSSymbol * IORegistryEntry::copyName(
547: const IORegistryPlane * plane = 0 ) const
548: {
549: OSSymbol * sym = 0;
550:
551: RLOCK;
552: if( plane)
553: sym = (OSSymbol *) registryTable()->getObject( plane->pathNameKey );
554: if( !sym)
555: sym = (OSSymbol *) registryTable()->getObject( gIONameKey );
556: if( sym)
557: sym->retain();
558: UNLOCK;
559:
560: if( sym)
561: return( sym );
562: else
563: return( OSSymbol::withCString((getMetaClass())->getClassName()) );
564: }
565:
566: const OSSymbol * IORegistryEntry::copyLocation(
567: const IORegistryPlane * plane = 0 ) const
568: {
569: OSSymbol * sym = 0;
570:
571: RLOCK;
572: if( plane)
573: sym = (OSSymbol *) registryTable()->getObject( plane->pathLocationKey );
574: if( !sym)
575: sym = (OSSymbol *) registryTable()->getObject( gIOLocationKey );
576: if( sym)
577: sym->retain();
578: UNLOCK;
579:
580: return( sym );
581: }
582:
583: const char * IORegistryEntry::getLocation( const IORegistryPlane * plane = 0 ) const
584: {
585: const OSSymbol * sym = copyLocation( plane );
586: const char * result = 0;
587:
588: if( sym) {
589: result = sym->getCStringNoCopy();
590: sym->release();
591: }
592:
593: return( result );
594: }
595:
596: void IORegistryEntry::setName( const OSSymbol * name,
597: const IORegistryPlane * plane = 0 )
598: {
599: const OSSymbol * key;
600:
601: if( name) {
602: if( plane)
603: key = plane->pathNameKey;
604: else
605: key = gIONameKey;
606:
607: WLOCK;
608: registryTable()->setObject( key, (OSObject *) name);
609: UNLOCK;
610: }
611: }
612:
613: void IORegistryEntry::setName( const char * name,
614: const IORegistryPlane * plane = 0 )
615: {
616: OSSymbol * sym = (OSSymbol *)OSSymbol::withCString( name );
617: if ( sym ) {
618: setName( sym, plane );
619: sym->release();
620: }
621: }
622:
623: void IORegistryEntry::setLocation( const OSSymbol * location,
624: const IORegistryPlane * plane = 0 )
625: {
626: const OSSymbol * key;
627:
628: if( location) {
629: if( plane)
630: key = plane->pathLocationKey;
631: else
632: key = gIOLocationKey;
633:
634: WLOCK;
635: registryTable()->setObject( key, (OSObject *) location);
636: UNLOCK;
637: }
638: }
639:
640: void IORegistryEntry::setLocation( const char * location,
641: const IORegistryPlane * plane = 0 )
642: {
643: OSSymbol * sym = (OSSymbol *)OSSymbol::withCString( location );
644: if ( sym ) {
645: setLocation( sym, plane );
646: sym->release();
647: }
648: }
649:
650: bool
651: IORegistryEntry::compareName( OSString * name, OSString ** matched = 0 ) const
652: {
653: const OSSymbol * sym = copyName();
654: bool isEqual;
655:
656: isEqual = sym->isEqualTo( name );
657:
658: if( isEqual && matched) {
659: name->retain();
660: *matched = name;
661: }
662:
663: if( sym)
664: sym->release();
665:
666: return( isEqual );
667: }
668:
669: bool
670: IORegistryEntry::compareNames( OSObject * names, OSString ** matched = 0 ) const
671: {
672: OSString * string;
673: OSCollection * collection;
674: OSIterator * iter = 0;
675: bool result = false;
676:
677: if( (collection = OSDynamicCast( OSCollection, names))) {
678: iter = OSCollectionIterator::withCollection( collection );
679: string = 0;
680: } else
681: string = OSDynamicCast( OSString, names);
682:
683: do {
684: if( string)
685: result = compareName( string, matched );
686:
687: } while( (false == result)
688: && iter && (string = OSDynamicCast( OSString, iter->getNextObject())));
689:
690: if( iter)
691: iter->release();
692:
693: return( result);
694: }
695:
696:
697: bool IORegistryEntry::getPath( char * path, int * length,
698: const IORegistryPlane * plane ) const
699: {
700: OSArray * stack;
701: IORegistryEntry * root;
702: const IORegistryEntry * entry;
703: IORegistryEntry * parent;
704: const OSSymbol * alias;
705: int index;
706: int len, maxLength, compLen;
707: char * nextComp;
708: bool ok;
709:
710: if( !path || !length || !plane)
711: return( false);
712:
713: len = 0;
714: maxLength = *length - 2;
715: nextComp = path;
716:
717: len = plane->nameKey->getLength();
718: if( len >= maxLength)
719: return( false);
720: strcpy( nextComp, plane->nameKey->getCStringNoCopy());
721: nextComp[ len++ ] = ':';
722: nextComp += len;
723:
724: if( (alias = hasAlias( plane ))) {
725: len += alias->getLength();
726: ok = (maxLength > len);
727: *length = len;
728: if( ok)
729: strcpy( nextComp, alias->getCStringNoCopy());
730: return( ok );
731: }
732:
733: entry = this;
734: parent = entry->getParentEntry( plane );
735: if( !parent)
736: // Error if not attached in plane
737: return( false);
738:
739: stack = OSArray::withCapacity( getDepth( plane ));
740: if( !stack)
741: return( false);
742:
743: RLOCK;
744:
745: root = gRegistryRoot->getChildEntry( plane );
746: while( parent && (entry != root)) {
747: // stop below root
748: stack->setObject( (OSObject *) entry );
749: entry = parent;
750: parent = entry->getParentEntry( plane );
751: }
752:
753: index = stack->getCount();
754: ok = true;
755:
756: if( 0 == index) {
757:
758: *nextComp++ = '/';
759: *nextComp = 0;
760: len++;
761:
762: } else while( ok && ((--index) >= 0)) {
763:
764: entry = (IORegistryEntry *) stack->getObject((unsigned int) index );
765: assert( entry );
766:
767: compLen = maxLength - len;
768: ok = entry->getPathComponent( nextComp + 1, &compLen, plane );
769:
770: if( ok && compLen) {
771: compLen++;
772: *nextComp = '/';
773: len += compLen;
774: nextComp += compLen;
775: }
776: }
777: *length = len;
778:
779: UNLOCK;
780:
781: stack->release();
782:
783: return( ok );
784: }
785:
786: bool IORegistryEntry::getPathComponent( char * path, int * length,
787: const IORegistryPlane * plane ) const
788: {
789: int len, locLen, maxLength;
790: const char * compName;
791: const char * loc;
792: bool ok;
793:
794: maxLength = *length;
795:
796: compName = getName( plane );
797: len = strlen( compName );
798: if( (loc = getLocation( plane )))
799: locLen = 1 + strlen( loc );
800: else
801: locLen = 0;
802:
803: ok = ((len + locLen) < maxLength);
804: if( ok) {
805: strcpy( path, compName );
806: if( loc) {
807: path += len;
808: len += locLen;
809: *path++ = '@';
810: strcpy( path, loc );
811: }
812: *length = len;
813: }
814:
815: return( ok );
816: }
817:
818: const char * IORegistryEntry::matchPathLocation( const char * cmp,
819: const IORegistryPlane * plane )
820: {
821: const char * str;
822: const char * result = 0;
823: int num1, num2;
824: char c1, c2;
825:
826: str = getLocation( plane );
827: if( str) {
828: c2 = str[0];
829: do {
830: num1 = strtoul( cmp, (char **) &cmp, 16 );
831: if( c2) {
832: num2 = strtoul( str, (char **) &str, 16 );
833: c2 = str[0];
834: } else
835: num2 = 0;
836:
837: if( num1 != num2)
838: break;
839:
840: c1 = *cmp++;
841: if( ',' != c1) {
842: result = cmp - 1;
843: break;
844: }
845:
846: if( c2) {
847: if( c2 != ',')
848: break;
849: str++;
850: }
851:
852: } while( true);
853: }
854:
855: return( result );
856: }
857:
858: IORegistryEntry * IORegistryEntry::getChildFromComponent( const char ** opath,
859: const IORegistryPlane * plane )
860: {
861: IORegistryEntry * entry = 0;
862: OSArray * set;
863: unsigned int index;
864: const char * path;
865: const char * cmp = 0;
866: size_t len;
867: const char * str;
868:
869: set = getChildSetReference( plane );
870: if( set) {
871:
872: path = *opath;
873:
874: for( index = 0;
875: (entry = (IORegistryEntry *) set->getObject(index));
876: index++ ) {
877:
878: cmp = path;
879:
880: if( *cmp != '@') {
881: str = entry->getName( plane );
882: len = strlen( str );
883: if( strncmp( str, cmp, len ))
884: continue;
885: cmp += len;
886: if( *cmp != '@' )
887: break;
888: }
889: cmp++;
890: if( (cmp = entry->matchPathLocation( cmp, plane )))
891: break;
892: }
893: if( entry)
894: *opath = cmp;
895: }
896:
897: return( entry );
898: }
899:
900: const OSSymbol * IORegistryEntry::hasAlias( const IORegistryPlane * plane,
901: char * opath = 0, int * length = 0 ) const
902: {
903: IORegistryEntry * entry;
904: IORegistryEntry * entry2;
905: const OSSymbol * key;
906: const OSSymbol * bestKey = 0;
907: OSIterator * iter;
908: OSData * data;
909: const char * path = "/aliases";
910:
911: entry = IORegistryEntry::fromPath( path, plane );
912: if( entry) {
913: RLOCK;
914: if( (iter = OSCollectionIterator::withCollection(
915: entry->getPropertyTable() ))) {
916:
917: while( (key = (OSSymbol *) iter->getNextObject())) {
918:
919: data = (OSData *) entry->getProperty( key );
920: path = (const char *) data->getBytesNoCopy();
921: if( (entry2 = IORegistryEntry::fromPath( path, plane,
922: opath, length ))) {
923: if( this == entry2) {
924: if( !bestKey
925: || (bestKey->getLength() > key->getLength()))
926: // pick the smallest alias
927: bestKey = key;
928: }
929: entry2->release();
930: }
931: }
932: iter->release();
933: }
934: entry->release();
935: UNLOCK;
936: }
937: return( bestKey );
938: }
939:
940: const char * IORegistryEntry::dealiasPath(
941: const char ** opath,
942: const IORegistryPlane * plane )
943: {
944: IORegistryEntry * entry;
945: OSData * data;
946: const char * path = *opath;
947: const char * rpath = 0;
948: const char * end;
949: char c;
950: char temp[ kIOMaxPlaneName + 1 ];
951:
952: if( path[0] == '/')
953: return( rpath );
954:
955: // check for alias
956: end = path;
957: while( (c = *end++) && (c != '/') && (c != ':'))
958: {}
959: end--;
960: if( (end - path) < kIOMaxPlaneName) {
961: strncpy( temp, path, end - path );
962: temp[ end - path ] = 0;
963:
964: RLOCK;
965: entry = IORegistryEntry::fromPath( "/aliases", plane );
966: if( entry) {
967: data = (OSData *) entry->getProperty( temp );
968: if( data ) {
969: rpath = (const char *) data->getBytesNoCopy();
970: if( rpath)
971: *opath = end;
972: }
973: entry->release();
974: }
975: UNLOCK;
976: }
977:
978: return( rpath );
979: }
980:
981: IORegistryEntry * IORegistryEntry::fromPath(
982: const char * path,
983: const IORegistryPlane * plane = 0,
984: char * opath = 0,
985: int * length = 0,
986: IORegistryEntry * fromEntry = 0 )
987: {
988: IORegistryEntry * where = 0;
989: IORegistryEntry * next;
990: const char * alias;
991: const char * end;
992: int len = 0;
993: int len2;
994: char c;
995: char temp[ kIOMaxPlaneName + 1 ];
996:
997: if( 0 == path)
998: return( 0 );
999:
1000: if( 0 == plane) {
1001: // get plane name
1002: end = strchr( path, ':' );
1003: if( end && ((end - path) < kIOMaxPlaneName)) {
1004: strncpy( temp, path, end - path );
1005: temp[ end - path ] = 0;
1006: plane = getPlane( temp );
1007: path = end + 1;
1008: }
1009: }
1010: if( 0 == plane)
1011: return( 0 );
1012:
1013: // check for alias
1014: end = path;
1015: if( (alias = dealiasPath( &end, plane))) {
1016: if( length)
1017: len = *length;
1018: where = IORegistryEntry::fromPath( alias, plane,
1019: opath, &len, fromEntry );
1020: if( where)
1021: path = end;
1022: else
1023: len = 0;
1024: }
1025:
1026: RLOCK;
1027:
1028: do {
1029: if( 0 == where) {
1030: if( (0 == fromEntry) && (*path++ == '/'))
1031: fromEntry = gRegistryRoot->getChildEntry( plane );
1032: where = fromEntry;
1033: if( 0 == where)
1034: break;
1035: } else {
1036: c = *path++;
1037: if( c != '/') {
1038: if( c && (c != ':')) // check valid terminator
1039: where = 0;
1040: break;
1041: }
1042: }
1043: next = where->getChildFromComponent( &path, plane );
1044: if( next)
1045: where = next;
1046: } while( next );
1047:
1048: if( where) {
1049: // check residual path
1050: if( where != fromEntry)
1051: path--;
1052:
1053: if( opath && length) {
1054: // copy out residual path
1055: len2 = len + strlen( path );
1056: if( len2 < *length)
1057: strcpy( opath + len, path );
1058: *length = len2;
1059:
1060: } else if( path[0])
1061: // no residual path => must be no tail for success
1062: where = 0;
1063: }
1064:
1065: if( where)
1066: where->retain();
1067:
1068: UNLOCK;
1069:
1070: return( where );
1071: }
1072:
1073: IORegistryEntry * IORegistryEntry::childFromPath(
1074: const char * path,
1075: const IORegistryPlane * plane = 0,
1076: char * opath = 0,
1077: int * len = 0 )
1078: {
1079: return( IORegistryEntry::fromPath( path, plane, opath, len, this ));
1080: }
1081:
1082: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1083:
1084: #define IOLinkIterator OSCollectionIterator
1085:
1086: #undef super
1087: #define super OSObject
1088:
1089: inline bool IORegistryEntry::arrayMember( OSArray * set,
1090: const IORegistryEntry * member,
1091: unsigned int * index = 0 ) const
1092: {
1093: int i;
1094: OSObject * probeObject;
1095:
1096: for( i = 0; (probeObject = set->getObject(i)); i++) {
1097: if (probeObject == (OSObject *) member) {
1098: if( index)
1099: *index = i;
1100: return( true );
1101: }
1102: }
1103: return( false );
1104: }
1105:
1106: bool IORegistryEntry::makeLink( IORegistryEntry * to,
1107: unsigned int relation,
1108: const IORegistryPlane * plane ) const
1109: {
1110: OSArray * links;
1111: bool result = false;
1112:
1113: if( (links = (OSArray *)
1114: registryTable()->getObject( plane->keys[ relation ] ))) {
1115:
1116: result = arrayMember( links, to );
1117: if( !result)
1118: result = links->setObject( to );
1119:
1120: } else {
1121:
1122: links = OSArray::withObjects( (OSObject **) &to, 1, 1 );
1123: result = (links != 0);
1124: if( result) {
1125: result = registryTable()->setObject( plane->keys[ relation ],
1126: links );
1127: links->release();
1128: }
1129: }
1130:
1131: return( result);
1132: }
1133:
1134: void IORegistryEntry::breakLink( IORegistryEntry * to,
1135: unsigned int relation,
1136: const IORegistryPlane * plane ) const
1137: {
1138: OSArray * links;
1139: unsigned int index;
1140:
1141: if( (links = (OSArray *)
1142: registryTable()->getObject( plane->keys[ relation ]))) {
1143:
1144: if( arrayMember( links, to, &index )) {
1145: links->removeObject( index );
1146: if( 0 == links->getCount())
1147: registryTable()->removeObject( plane->keys[ relation ]);
1148: }
1149: }
1150: }
1151:
1152:
1153: OSArray * IORegistryEntry::getParentSetReference(
1154: const IORegistryPlane * plane ) const
1155: {
1156: if( plane)
1157: return( (OSArray *) registryTable()->getObject(
1158: plane->keys[ kParentSetIndex ]));
1159: else
1160: return( 0 );
1161: }
1162:
1163: OSIterator * IORegistryEntry::getParentIterator(
1164: const IORegistryPlane * plane ) const
1165: {
1166: OSArray * links;
1167: OSIterator * iter;
1168:
1169: if( !plane)
1170: return( 0 );
1171:
1172: RLOCK;
1173: links = getParentSetReference( plane );
1174: if( 0 == links)
1175: links = OSArray::withCapacity( 1 );
1176: else
1177: links = OSArray::withArray( links, links->getCount() );
1178: UNLOCK;
1179:
1180: iter = IOLinkIterator::withCollection( links );
1181:
1182: if( links)
1183: links->release();
1184:
1185: return( iter );
1186: }
1187:
1188: IORegistryEntry * IORegistryEntry::getParentEntry( const IORegistryPlane * plane ) const
1189: {
1190: IORegistryEntry * entry = 0;
1191: OSArray * links;
1192:
1193: RLOCK;
1194:
1195: if( (links = getParentSetReference( plane )))
1196: entry = (IORegistryEntry *) links->getObject( 0 );
1197:
1198: UNLOCK;
1199:
1200: return( entry);
1201: }
1202:
1203: OSArray * IORegistryEntry::getChildSetReference( const IORegistryPlane * plane ) const
1204: {
1205: if( plane)
1206: return( (OSArray *) registryTable()->getObject(
1207: plane->keys[ kChildSetIndex ]));
1208: else
1209: return( 0 );
1210: }
1211:
1212: OSIterator * IORegistryEntry::getChildIterator( const IORegistryPlane * plane ) const
1213: {
1214: OSArray * links;
1215: OSIterator * iter;
1216:
1217: if( !plane)
1218: return( 0 );
1219:
1220: RLOCK;
1221: links = getChildSetReference( plane );
1222: if( 0 == links)
1223: links = OSArray::withCapacity( 1 );
1224: else
1225: links = OSArray::withArray( links, links->getCount() );
1226: UNLOCK;
1227:
1228: iter = IOLinkIterator::withCollection( links );
1229:
1230: if( links)
1231: links->release();
1232:
1233: return( iter );
1234: }
1235:
1236:
1237: IORegistryEntry * IORegistryEntry::getChildEntry(
1238: const IORegistryPlane * plane ) const
1239: {
1240: IORegistryEntry * entry = 0;
1241: OSArray * links;
1242:
1243: RLOCK;
1244:
1245: if( (links = getChildSetReference( plane )))
1246: entry = (IORegistryEntry *) links->getObject( 0 );
1247:
1248: UNLOCK;
1249:
1250: return( entry);
1251: }
1252:
1253: void IORegistryEntry::applyToChildren( IORegistryEntryApplierFunction applier,
1254: void * context,
1255: const IORegistryPlane * plane ) const
1256: {
1257: OSArray * array;
1258: unsigned int index;
1259: IORegistryEntry * next;
1260:
1261: if( !plane)
1262: return;
1263:
1264: RLOCK;
1265: array = OSArray::withArray( getChildSetReference( plane ));
1266: UNLOCK;
1267: if( array) {
1268: for( index = 0;
1269: (next = (IORegistryEntry *) array->getObject( index ));
1270: index++)
1271: (*applier)(next, context);
1272: array->release();
1273: }
1274: }
1275:
1276: void IORegistryEntry::applyToParents( IORegistryEntryApplierFunction applier,
1277: void * context,
1278: const IORegistryPlane * plane ) const
1279: {
1280: OSArray * array;
1281: unsigned int index;
1282: IORegistryEntry * next;
1283:
1284: if( !plane)
1285: return;
1286:
1287: RLOCK;
1288: array = OSArray::withArray( getParentSetReference( plane ));
1289: UNLOCK;
1290: if( array) {
1291: for( index = 0;
1292: (next = (IORegistryEntry *) array->getObject( index ));
1293: index++)
1294: (*applier)(next, context);
1295: array->release();
1296: }
1297: }
1298:
1299: bool IORegistryEntry::isChild( IORegistryEntry * child,
1300: const IORegistryPlane * plane,
1301: bool onlyChild = false ) const
1302: {
1303: OSArray * links;
1304: bool ret = false;
1305:
1306: RLOCK;
1307:
1308: if( (links = getChildSetReference( plane ))) {
1309: if( (!onlyChild) || (1 == links->getCount()))
1310: ret = arrayMember( links, child );
1311: }
1312: if( ret && (links = child->getParentSetReference( plane )))
1313: ret = arrayMember( links, this );
1314:
1315: UNLOCK;
1316:
1317: return( ret);
1318: }
1319:
1320: bool IORegistryEntry::isParent( IORegistryEntry * parent,
1321: const IORegistryPlane * plane,
1322: bool onlyParent = false ) const
1323:
1324: {
1325: OSArray * links;
1326: bool ret = false;
1327:
1328: RLOCK;
1329:
1330: if( (links = getParentSetReference( plane ))) {
1331: if( (!onlyParent) || (1 == links->getCount()))
1332: ret = arrayMember( links, parent );
1333: }
1334: if( ret && (links = parent->getChildSetReference( plane )))
1335: ret = arrayMember( links, this );
1336:
1337: UNLOCK;
1338:
1339: return( ret);
1340: }
1341:
1342: bool IORegistryEntry::inPlane( const IORegistryPlane * plane ) const
1343: {
1344: bool ret;
1345:
1346: RLOCK;
1347:
1348: ret = (0 != getParentSetReference( plane ));
1349:
1350: UNLOCK;
1351:
1352: return( ret );
1353: }
1354:
1355: bool IORegistryEntry::attachToParent( IORegistryEntry * parent,
1356: const IORegistryPlane * plane )
1357: {
1358: OSArray * links;
1359: bool ret;
1360: bool needParent;
1361:
1362: if( this == parent)
1363: return( false );
1364:
1365: WLOCK;
1366:
1367: ret = makeLink( parent, kParentSetIndex, plane );
1368:
1369: if( (links = parent->getChildSetReference( plane )))
1370: needParent = (false == arrayMember( links, this ));
1371: else
1372: needParent = true;
1373:
1374: // ret &= parent->makeLink( this, kChildSetIndex, plane );
1375:
1376: UNLOCK;
1377:
1378: if( needParent)
1379: ret &= parent->attachToChild( this, plane );
1380:
1381: return( ret );
1382: }
1383:
1384: bool IORegistryEntry::attachToChild( IORegistryEntry * child,
1385: const IORegistryPlane * plane )
1386: {
1387: OSArray * links;
1388: bool ret;
1389: bool needChild;
1390:
1391: if( this == child)
1392: return( false );
1393:
1394: WLOCK;
1395:
1396: ret = makeLink( child, kChildSetIndex, plane );
1397:
1398: if( (links = child->getParentSetReference( plane )))
1399: needChild = (false == arrayMember( links, this ));
1400: else
1401: needChild = true;
1402:
1403: UNLOCK;
1404:
1405: if( needChild)
1406: ret &= child->attachToParent( this, plane );
1407:
1408: return( ret );
1409: }
1410:
1411: void IORegistryEntry::detachFromParent( IORegistryEntry * parent,
1412: const IORegistryPlane * plane )
1413: {
1414: OSArray * links;
1415: bool needParent;
1416:
1417: WLOCK;
1418:
1419: parent->retain();
1420:
1421: breakLink( parent, kParentSetIndex, plane );
1422:
1423: if( (links = parent->getChildSetReference( plane )))
1424: needParent = arrayMember( links, this );
1425: else
1426: needParent = false;
1427:
1428: // parent->breakLink( this, kChildSetIndex, plane );
1429:
1430: UNLOCK;
1431:
1432: if( needParent)
1433: parent->detachFromChild( this, plane );
1434:
1435: parent->release();
1436: }
1437:
1438: void IORegistryEntry::detachFromChild( IORegistryEntry * child,
1439: const IORegistryPlane * plane )
1440: {
1441: OSArray * links;
1442: bool needChild;
1443:
1444: WLOCK;
1445:
1446: child->retain();
1447:
1448: breakLink( child, kChildSetIndex, plane );
1449:
1450: if( (links = child->getParentSetReference( plane )))
1451: needChild = arrayMember( links, this );
1452: else
1453: needChild = false;
1454:
1455: UNLOCK;
1456:
1457: if( needChild)
1458: child->detachFromParent( this, plane );
1459:
1460: child->release();
1461: }
1462:
1463: void IORegistryEntry::detachAbove( const IORegistryPlane * plane )
1464: {
1465: IORegistryEntry * parent;
1466:
1467: retain();
1468: while( (parent = getParentEntry( plane )))
1469: detachFromParent( parent, plane );
1470: release();
1471: }
1472:
1473: void IORegistryEntry::detachAll( const IORegistryPlane * plane )
1474: {
1475: OSOrderedSet * all;
1476: IORegistryEntry * next;
1477: IORegistryIterator * regIter;
1478:
1479: regIter = IORegistryIterator::iterateOver( this, plane, true );
1480: if( 0 == regIter)
1481: return;
1482: all = regIter->iterateAll();
1483: regIter->release();
1484:
1485: detachAbove( plane );
1486: if( all) {
1487: while( (next = (IORegistryEntry *) all->getLastObject())) {
1488:
1489: next->retain();
1490: all->removeObject(next);
1491:
1492: next->detachAbove( plane );
1493: next->release();
1494: }
1495: all->release();
1496: }
1497: }
1498:
1499: unsigned int IORegistryEntry::getDepth( const IORegistryPlane * plane ) const
1500: {
1501: unsigned int depth = 1;
1502: OSArray * parents;
1503: unsigned int oneDepth, maxParentDepth, count;
1504: IORegistryEntry * one;
1505: const IORegistryEntry * next;
1506: unsigned int index;
1507:
1508: RLOCK;
1509:
1510: next = this;
1511: while( (parents = next->getParentSetReference( plane ))) {
1512:
1513: count = parents->getCount();
1514: if( 0 == count)
1515: break;
1516: if( 1 == count) {
1517: depth++;
1518: next = (IORegistryEntry *) parents->getObject( 0 );
1519: } else {
1520: // painful
1521: maxParentDepth = 0;
1522: for( index = 0;
1523: (one = (IORegistryEntry *) parents->getObject( index ));
1524: index++ ) {
1525: oneDepth = one->getDepth( plane );
1526: if( oneDepth > maxParentDepth)
1527: maxParentDepth = oneDepth;
1528: }
1529: depth += maxParentDepth;
1530: break;
1531: }
1532: }
1533:
1534: UNLOCK;
1535:
1536: return( depth);
1537: }
1538:
1539: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1540:
1541: #undef super
1542: #define super OSIterator
1543:
1544: OSDefineMetaClassAndStructors(IORegistryIterator, OSIterator)
1545:
1546: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1547:
1548: IORegistryIterator *
1549: IORegistryIterator::iterateOver( IORegistryEntry * root,
1550: const IORegistryPlane * plane,
1551: IOOptionBits options = 0 )
1552: {
1553: IORegistryIterator * create;
1554:
1555: if( 0 == root)
1556: return( 0);
1557: if( 0 == plane)
1558: return( 0);
1559:
1560: create = new IORegistryIterator;
1561: if( create) {
1562: if( create->init()) {
1563:
1564: root->retain();
1565: create->root = root;
1566: create->where = &create->start;
1567: create->start.current = root;
1568: create->plane = plane;
1569: create->options = options;
1570:
1571: } else {
1572: create->release();
1573: create = 0;
1574: }
1575: }
1576: return( create);
1577: }
1578:
1579: IORegistryIterator *
1580: IORegistryIterator::iterateOver( const IORegistryPlane * plane,
1581: IOOptionBits options = 0 )
1582: {
1583: return( iterateOver( gRegistryRoot, plane, options ));
1584: }
1585:
1586: bool IORegistryIterator::isValid( void )
1587: {
1588: bool ok;
1589: IORegCursor * next;
1590:
1591: ok = true;
1592: next = where;
1593:
1594: RLOCK;
1595: while( ok && next) {
1596: if( where->iter)
1597: ok = where->iter->isValid();
1598: next = next->next;
1599: }
1600: UNLOCK;
1601:
1602: return( ok);
1603: }
1604:
1605: void IORegistryIterator::enterEntry( const IORegistryPlane * enterPlane )
1606: {
1607: IORegCursor * prev;
1608:
1609: prev = where;
1610: where = (IORegCursor *) IOMalloc( sizeof( IORegCursor));
1611: assert( where);
1612:
1613: if( where) {
1614: where->iter = 0;
1615: where->next = prev;
1616: where->current = prev->current;
1617: plane = enterPlane;
1618: }
1619: }
1620:
1621: void IORegistryIterator::enterEntry( void )
1622: {
1623: enterEntry( plane );
1624: }
1625:
1626: bool IORegistryIterator::exitEntry( void )
1627: {
1628: IORegCursor * gone;
1629:
1630: if( where->iter) {
1631: where->iter->release();
1632: where->iter = 0;
1633: if( where->current)// && (where != &start))
1634: where->current->release();
1635: }
1636:
1637: if( where != &start) {
1638: gone = where;
1639: where = gone->next;
1640: IOFree( gone, sizeof( IORegCursor));
1641: return( true);
1642:
1643: } else
1644: return( false);
1645: }
1646:
1647: void IORegistryIterator::reset( void )
1648: {
1649: while( exitEntry())
1650: {}
1651:
1652: if( done) {
1653: done->release();
1654: done = 0;
1655: }
1656:
1657: where->current = root;
1658: }
1659:
1660: void IORegistryIterator::free( void )
1661: {
1662: reset();
1663:
1664: if( root)
1665: root->release();
1666:
1667: super::free();
1668: }
1669:
1670:
1671: IORegistryEntry * IORegistryIterator::getNextObjectFlat( void )
1672: {
1673: IORegistryEntry * next = 0;
1674: OSArray * links = 0;
1675:
1676: RLOCK;
1677:
1678: if( (0 == where->iter)) {
1679: // just entered - create new iter
1680: if( isValid()
1681: && where->current
1682: && (links = ( (options & kIORegistryIterateParents) ?
1683: where->current->getParentSetReference( plane ) :
1684: where->current->getChildSetReference( plane ) )) )
1685:
1686: where->iter = OSCollectionIterator::withCollection( links );
1687:
1688: } else
1689: // next sibling - release current
1690: if( where->current)
1691: where->current->release();
1692:
1693: if( where->iter)
1694: next = (IORegistryEntry *) where->iter->getNextObject();
1695:
1696: if( next)
1697: next->retain();
1698:
1699: where->current = next;
1700:
1701: UNLOCK;
1702:
1703: return( next);
1704: }
1705:
1706: IORegistryEntry * IORegistryIterator::getNextObjectRecursive( void )
1707: {
1708: IORegistryEntry * next;
1709:
1710: do
1711: next = getNextObjectFlat();
1712: while( (0 == next) && exitEntry());
1713:
1714: if( next) {
1715: if( 0 == done)
1716: done = OSOrderedSet::withCapacity( 10 );
1717: if( done->setObject((OSObject *) next)) {
1718: // done set didn't contain this one, so recurse
1719: enterEntry();
1720: }
1721: }
1722: return( next);
1723: }
1724:
1725: IORegistryEntry * IORegistryIterator::getNextObject( void )
1726: {
1727: if( options & kIORegistryIterateRecursively)
1728: return( getNextObjectRecursive());
1729: else
1730: return( getNextObjectFlat());
1731: }
1732:
1733: IORegistryEntry * IORegistryIterator::getCurrentEntry( void )
1734: {
1735: if( isValid())
1736: return( where->current);
1737: else
1738: return( 0);
1739: }
1740:
1741: OSOrderedSet * IORegistryIterator::iterateAll( void )
1742: {
1743: reset();
1744: while( getNextObjectRecursive())
1745: {}
1746: if( done)
1747: done->retain();
1748: return( done);
1749: }
1750:
1751:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.