![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to archive.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / objc|
Return to archive.c CVS log | Up to [GCC 2.x] / gcc / objc |
1.1 root 1: /* GNU Objective C Runtime archiving
2: Copyright (C) 1993 Free Software Foundation, Inc.
3:
4: Author: Kresten Krab Thorup
5:
6: This file is part of GNU CC.
7:
8: GNU CC is free software; you can redistribute it and/or modify it under the
9: terms of the GNU General Public License as published by the Free Software
10: Foundation; either version 2, or (at your option) any later version.
11:
12: GNU CC is distributed in the hope that it will be useful, but WITHOUT ANY
13: WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
14: FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
15: details.
16:
17: You should have received a copy of the GNU General Public License along with
18: GNU CC; see the file COPYING. If not, write to the Free Software
19: Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21: /* As a special exception, if you link this library with files compiled with
22: GCC to produce an executable, this does not cause the resulting executable
23: to be covered by the GNU General Public License. This exception does not
24: however invalidate any other reasons why the executable file might be
25: covered by the GNU General Public License. */
26:
27: /*
28: ** Note: This version assumes that int and longs are both 32bit.
29: */
30:
31: #ifndef __alpha__
32:
33: #include "runtime.h"
34: #include "typedstream.h"
35:
36: #define __objc_fatal(format, args...) \
37: { fprintf(stderr, "archining: "); \
38: fprintf(stderr, format, ## args); \
39: fprintf(stderr, "\n"); abort(); }
40:
41: /* Declare some functions... */
42:
43: static int
44: objc_read_class (struct objc_typed_stream* stream, Class** class);
45:
46: static int
47: objc_sizeof_type(const char* type);
48:
49: static int
50: objc_write_use_common (struct objc_typed_stream* stream, unsigned int key);
51:
52: static int
53: objc_write_register_common (struct objc_typed_stream* stream,
54: unsigned int key);
55:
56: static int
57: objc_write_class (struct objc_typed_stream* stream,
58: struct objc_class* class);
59:
60: static const char*
61: __objc_skip_type (const char* type);
62:
63: static void __objc_finish_write_root_object(struct objc_typed_stream*);
64: static void __objc_finish_read_root_object(struct objc_typed_stream*);
65:
66: static __inline__ int
67: __objc_code_unsigned_char (unsigned char* buf, unsigned char val)
68: {
69: if ((val&_B_VALUE) == val)
70: {
71: buf[0] = val|_B_SINT;
72: return 1;
73: }
74: else
75: {
76: buf[0] = _B_NINT|0x01;
77: buf[1] = val;
78: return 2;
79: }
80: }
81:
82: int
83: objc_write_unsigned_char (struct objc_typed_stream* stream,
84: unsigned char value)
85: {
86: unsigned char buf[sizeof (unsigned char)+1];
87: int len = __objc_code_unsigned_char (buf, value);
88: return (*stream->write)(stream->physical, buf, len);
89: }
90:
91: static __inline__ int
92: __objc_code_char (unsigned char* buf, char val)
93: {
94: if (val >= 0)
95: return __objc_code_unsigned_char (buf, val);
96: else
97: {
98: buf[0] = _B_NINT|_B_SIGN|0x01;
99: buf[1] = -val;
100: return 2;
101: }
102: }
103:
104: int
105: objc_write_char (struct objc_typed_stream* stream, char value)
106: {
107: unsigned char buf[sizeof (char)+1];
108: int len = __objc_code_char (buf, value);
109: return (*stream->write)(stream->physical, buf, len);
110: }
111:
112: static __inline__ int
113: __objc_code_unsigned_short (unsigned char* buf, unsigned short val)
114: {
115: if (val <= 0xffU)
116: return __objc_code_unsigned_char (buf, val);
117:
118: else
119: {
120: buf[0] = _B_NINT|0x02;
121: buf[1] = val/0x100;
122: buf[2] = val%0x100;
123: return 3;
124: }
125: }
126:
127: int
128: objc_write_unsigned_short (struct objc_typed_stream* stream, unsigned short value)
129: {
130: unsigned char buf[sizeof (unsigned short)+1];
131: int len = __objc_code_unsigned_short (buf, value);
132: return (*stream->write)(stream->physical, buf, len);
133: }
134:
135: static __inline__ int
136: __objc_code_short (unsigned char* buf, short val)
137: {
138: if (val > 0)
139: return __objc_code_unsigned_short (buf, val);
140:
141: if (val > -0x7f) /* val > -128 */
142: return __objc_code_char (buf, val);
143:
144: else
145: {
146: int len = __objc_code_unsigned_short (buf, -val);
147: buf[0] |= _B_SIGN;
148: return len;
149: }
150: }
151:
152: int
153: objc_write_short (struct objc_typed_stream* stream, short value)
154: {
155: unsigned char buf[sizeof (short)+1];
156: int len = __objc_code_short (buf, value);
157: return (*stream->write)(stream->physical, buf, len);
158: }
159:
160:
161: static __inline__ int
162: __objc_code_unsigned_int (unsigned char* buf, unsigned int val)
163: {
164: if (val < 0x10000)
165: return __objc_code_unsigned_short (buf, val%0x10000);
166:
167: else if (val < 0x1000000)
168: {
169: buf[0] = _B_NINT|3;
170: buf[1] = val/0x10000;
171: buf[2] = (val%0x10000)/0x100;
172: buf[3] = val%0x100;
173: return 4;
174: }
175:
176: else
177: {
178: buf[0] = _B_NINT|4;
179: buf[1] = val/0x1000000;
180: buf[2] = (val%0x1000000)/0x10000;
181: buf[3] = (val%0x10000)/0x100;
182: buf[4] = val%0x100;
183: return 5;
184: }
185: }
186:
187: int
188: objc_write_unsigned_int (struct objc_typed_stream* stream, unsigned int value)
189: {
190: unsigned char buf[sizeof(unsigned int)+1];
191: int len = __objc_code_unsigned_int (buf, value);
192: return (*stream->write)(stream->physical, buf, len);
193: }
194:
195: static __inline__ int
196: __objc_code_int (unsigned char* buf, int val)
197: {
198: if (val >= 0)
199: return __objc_code_unsigned_int (buf, val);
200:
201: if (val > -0x7f)
202: return __objc_code_char (buf, val);
203:
204: else
205: {
206: int len = __objc_code_unsigned_int (buf, -val);
207: buf[0] |= _B_SIGN;
208: return len;
209: }
210: }
211:
212: int
213: objc_write_int (struct objc_typed_stream* stream, int value)
214: {
215: unsigned char buf[sizeof(int)+1];
216: int len = __objc_code_int (buf, value);
217: return (*stream->write)(stream->physical, buf, len);
218: }
219:
220: int
221: objc_write_string (struct objc_typed_stream* stream,
222: const unsigned char* string, unsigned int nbytes)
223: {
224: unsigned char buf[sizeof(unsigned int)+1];
225: int len = __objc_code_unsigned_int (buf, nbytes);
226:
227: if ((buf[0]&_B_CODE) == _B_SINT)
228: buf[0] = (buf[0]&_B_VALUE)|_B_SSTR;
229:
230: else /* _B_NINT */
231: buf[0] = (buf[0]&_B_VALUE)|_B_NSTR;
232:
233: if ((*stream->write)(stream->physical, buf, len) != 0)
234: return (*stream->write)(stream->physical, string, nbytes);
235: else
236: return 0;
237: }
238:
239: int
240: objc_write_string_atomic (struct objc_typed_stream* stream,
241: unsigned char* string, unsigned int nbytes)
242: {
243: unsigned int key;
244: if ((key = (unsigned int)hash_value_for_key (stream->stream_table, string)))
245: return objc_write_use_common (stream, key);
246: else
247: {
248: int length;
249: hash_add (&stream->stream_table, (void*)key=(unsigned int)string, string);
250: if ((length = objc_write_register_common (stream, key)))
251: return objc_write_string (stream, string, nbytes);
252: return length;
253: }
254: }
255:
256: static int
257: objc_write_register_common (struct objc_typed_stream* stream, unsigned int key)
258: {
259: unsigned char buf[sizeof (unsigned int)+2];
260: int len = __objc_code_unsigned_int (buf+1, key);
261: if (len == 1)
262: {
263: buf[0] = _B_RCOMM|0x01;
264: buf[1] &= _B_VALUE;
265: return (*stream->write)(stream->physical, buf, len+1);
266: }
267: else
268: {
269: buf[1] = (buf[1]&_B_VALUE)|_B_RCOMM;
270: return (*stream->write)(stream->physical, buf+1, len);
271: }
272: }
273:
274: static int
275: objc_write_use_common (struct objc_typed_stream* stream, unsigned int key)
276: {
277: unsigned char buf[sizeof (unsigned int)+2];
278: int len = __objc_code_unsigned_int (buf+1, key);
279: if (len == 1)
280: {
281: buf[0] = _B_UCOMM|0x01;
282: buf[1] &= _B_VALUE;
283: return (*stream->write)(stream->physical, buf, 2);
284: }
285: else
286: {
287: buf[1] = (buf[1]&_B_VALUE)|_B_UCOMM;
288: return (*stream->write)(stream->physical, buf+1, len);
289: }
290: }
291:
292: static __inline__ int
293: __objc_write_extension (struct objc_typed_stream* stream, unsigned char code)
294: {
295: if (code <= _B_VALUE)
296: {
297: unsigned char buf = code|_B_EXT;
298: return (*stream->write)(stream->physical, &buf, 1);
299: }
300: else
301: abort();
302: }
303:
304: __inline__ int
305: __objc_write_object (struct objc_typed_stream* stream, id object)
306: {
307: unsigned char buf = '\0';
308: SEL write_sel = sel_get_uid ("write:");
309: if (object)
310: {
311: __objc_write_extension (stream, _BX_OBJECT);
312: objc_write_class (stream, object->class_pointer);
313: (*objc_msg_lookup(object, write_sel))(object, write_sel, stream);
314: return (*stream->write)(stream->physical, &buf, 1);
315: }
316: else
317: return objc_write_use_common(stream, 0);
318: }
319:
320: int
321: objc_write_object_reference (struct objc_typed_stream* stream, id object)
322: {
323: unsigned int key;
324: if ((key = (unsigned int)hash_value_for_key (stream->object_table, object)))
325: return objc_write_use_common (stream, key);
326:
327: __objc_write_extension (stream, _BX_OBJREF);
328: return objc_write_unsigned_int (stream, (unsigned int)object);
329: }
330:
331: int
332: objc_write_root_object (struct objc_typed_stream* stream, id object)
333: {
334: int len;
335: if (stream->writing_root_p)
336: __objc_fatal ("objc_write_root_object called recursively")
337: else
338: {
339: stream->writing_root_p = 1;
340: __objc_write_extension (stream, _BX_OBJROOT);
341: if((len = objc_write_object (stream, object)))
342: __objc_finish_write_root_object(stream);
343: stream->writing_root_p = 0;
344: }
345: return len;
346: }
347:
348: int
349: objc_write_object (struct objc_typed_stream* stream, id object)
350: {
351: unsigned int key;
352: if ((key = (unsigned int)hash_value_for_key (stream->object_table, object)))
353: return objc_write_use_common (stream, key);
354:
355: else if (object == nil)
356: return objc_write_use_common(stream, 0);
357:
358: else
359: {
360: int length;
361: hash_add (&stream->object_table, (void*)key=(unsigned int)object, object);
362: if ((length = objc_write_register_common (stream, key)))
363: return __objc_write_object (stream, object);
364: return length;
365: }
366: }
367:
368: __inline__ int
369: __objc_write_class (struct objc_typed_stream* stream, struct objc_class* class)
370: {
371: __objc_write_extension (stream, _BX_CLASS);
372: objc_write_string_atomic(stream, (char*)class->name,
373: strlen((char*)class->name));
374: return objc_write_unsigned_int (stream, CLS_GETNUMBER(class));
375: }
376:
377:
378: static int
379: objc_write_class (struct objc_typed_stream* stream,
380: struct objc_class* class)
381: {
382: unsigned int key;
383: if ((key = (unsigned int)hash_value_for_key (stream->stream_table, class)))
384: return objc_write_use_common (stream, key);
385: else
386: {
387: int length;
388: hash_add (&stream->stream_table, (void*)key=(unsigned int)class, class);
389: if ((length = objc_write_register_common (stream, key)))
390: return __objc_write_class (stream, class);
391: return length;
392: }
393: }
394:
395:
396: __inline__ int
397: __objc_write_selector (struct objc_typed_stream* stream, SEL selector)
398: {
399: const char* sel_name = sel_get_name (selector);
400: __objc_write_extension (stream, _BX_SEL);
401: return objc_write_string (stream, sel_name, strlen ((char*)sel_name));
402: }
403:
404: int
405: objc_write_selector (struct objc_typed_stream* stream, SEL selector)
406: {
407: const char* sel_name = sel_get_name (selector);
408: unsigned int key;
409: if ((key = (unsigned int)hash_value_for_key (stream->stream_table, sel_name)))
410: return objc_write_use_common (stream, key);
411: else
412: {
413: int length;
414: hash_add (&stream->stream_table, (void*)key=(unsigned int)sel_name, (char*)sel_name);
415: if ((length = objc_write_register_common (stream, key)))
416: return __objc_write_selector (stream, selector);
417: return length;
418: }
419: }
420:
421:
422:
423: /*
424: ** Read operations
425: */
426:
427: __inline__ int
428: objc_read_char (struct objc_typed_stream* stream, char* val)
429: {
430: unsigned char buf;
431: int len;
432: len = (*stream->read)(stream->physical, &buf, 1);
433: if (len != 0)
434: {
435: if ((buf & _B_CODE) == _B_SINT)
436: (*val) = (buf & _B_VALUE);
437:
438: else if ((buf & _B_NUMBER) == 1)
439: {
440: len = (*stream->read)(stream->physical, val, 1);
441: if (buf&_B_SIGN)
442: (*val) = -1*(*val);
443: }
444:
445: else
446: __objc_fatal("expected 8bit signed int, got %dbit int",
447: (int)(buf&_B_NUMBER)*8);
448: }
449: return len;
450: }
451:
452:
453: __inline__ int
454: objc_read_unsigned_char (struct objc_typed_stream* stream, unsigned char* val)
455: {
456: unsigned char buf;
457: int len;
458: if ((len = (*stream->read)(stream->physical, &buf, 1)))
459: {
460: if ((buf & _B_CODE) == _B_SINT)
461: (*val) = (buf & _B_VALUE);
462:
463: else if ((buf & _B_NUMBER) == 1)
464: len = (*stream->read)(stream->physical, val, 1);
465:
466: else
467: __objc_fatal("expected 8bit unsigned int, got %dbit int",
468: (int)(buf&_B_NUMBER)*8);
469: }
470: return len;
471: }
472:
473: __inline__ int
474: objc_read_short (struct objc_typed_stream* stream, short* value)
475: {
476: unsigned char buf[sizeof(short)+1];
477: int len;
478: if ((len = (*stream->read)(stream->physical, buf, 1)))
479: {
480: if ((buf[0] & _B_CODE) == _B_SINT)
481: (*value) = (buf[0] & _B_VALUE);
482:
483: else
484: {
485: int pos = 1;
486: int nbytes = buf[0] & _B_NUMBER;
487: if (nbytes > sizeof (short))
488: __objc_fatal("expected short, got bigger (%dbits)", nbytes*8);
489: len = (*stream->read)(stream->physical, buf+1, nbytes);
490: (*value) = 0;
491: while (pos <= nbytes)
492: (*value) = ((*value)*0x100) + buf[pos++];
493: if (buf[0] & _B_SIGN)
494: (*value) = -(*value);
495: }
496: }
497: return len;
498: }
499:
500: __inline__ int
501: objc_read_unsigned_short (struct objc_typed_stream* stream,
502: unsigned short* value)
503: {
504: unsigned char buf[sizeof(unsigned short)+1];
505: int len;
506: if ((len = (*stream->read)(stream->physical, buf, 1)))
507: {
508: if ((buf[0] & _B_CODE) == _B_SINT)
509: (*value) = (buf[0] & _B_VALUE);
510:
511: else
512: {
513: int pos = 1;
514: int nbytes = buf[0] & _B_NUMBER;
515: if (nbytes > sizeof (short))
516: __objc_fatal("expected short, got int or bigger");
517: len = (*stream->read)(stream->physical, buf+1, nbytes);
518: (*value) = 0;
519: while (pos <= nbytes)
520: (*value) = ((*value)*0x100) + buf[pos++];
521: }
522: }
523: return len;
524: }
525:
526:
527: __inline__ int
528: objc_read_int (struct objc_typed_stream* stream, int* value)
529: {
530: unsigned char buf[sizeof(int)+1];
531: int len;
532: if ((len = (*stream->read)(stream->physical, buf, 1)))
533: {
534: if ((buf[0] & _B_CODE) == _B_SINT)
535: (*value) = (buf[0] & _B_VALUE);
536:
537: else
538: {
539: int pos = 1;
540: int nbytes = buf[0] & _B_NUMBER;
541: if (nbytes > sizeof (int))
542: __objc_fatal("expected int, got bigger");
543: len = (*stream->read)(stream->physical, buf+1, nbytes);
544: (*value) = 0;
545: while (pos <= nbytes)
546: (*value) = ((*value)*0x100) + buf[pos++];
547: if (buf[0] & _B_SIGN)
548: (*value) = -(*value);
549: }
550: }
551: return len;
552: }
553:
554: __inline__ int
555: __objc_read_nbyte_uint (struct objc_typed_stream* stream,
556: unsigned int nbytes, unsigned int* val)
557: {
558: int len, pos = 0;
559: unsigned char buf[sizeof(unsigned int)+1];
560:
561: if (nbytes > sizeof (int))
562: __objc_fatal("expected int, got bigger");
563:
564: len = (*stream->read)(stream->physical, buf, nbytes);
565: (*val) = 0;
566: while (pos < nbytes)
567: (*val) = ((*val)*0x100) + buf[pos++];
568: return len;
569: }
570:
571:
572: __inline__ int
573: objc_read_unsigned_int (struct objc_typed_stream* stream,
574: unsigned int* value)
575: {
576: unsigned char buf[sizeof(unsigned int)+1];
577: int len;
578: if ((len = (*stream->read)(stream->physical, buf, 1)))
579: {
580: if ((buf[0] & _B_CODE) == _B_SINT)
581: (*value) = (buf[0] & _B_VALUE);
582:
583: else
584: len = __objc_read_nbyte_uint (stream, (buf[0] & _B_VALUE), value);
585:
586: }
587: return len;
588: }
589:
590: __inline__ int
591: objc_read_string (struct objc_typed_stream* stream,
592: char** string)
593: {
594: unsigned char buf[sizeof(unsigned int)+1];
595: int len;
596: if ((len = (*stream->read)(stream->physical, buf, 1)))
597: {
598: unsigned int key = 0;
599:
600: if ((buf[0]&_B_CODE) == _B_RCOMM) /* register following */
601: {
602: len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
603: len = (*stream->read)(stream->physical, buf, 1);
604: }
605:
606: switch (buf[0]&_B_CODE) {
607: case _B_SSTR:
608: {
609: int length = buf[0]&_B_VALUE;
610: (*string) = (char*)__objc_xmalloc(length+1);
611: if (key)
612: hash_add (&stream->stream_table, (void*)key, *string);
613: len = (*stream->read)(stream->physical, *string, length);
614: (*string)[length] = '\0';
615: }
616: break;
617:
618: case _B_UCOMM:
619: {
620: len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
621: (*string) = hash_value_for_key (stream->stream_table, (void*)key);
622: }
623: break;
624:
625: case _B_NSTR:
626: {
627: unsigned int nbytes = buf[0]&_B_VALUE;
628: len = __objc_read_nbyte_uint(stream, nbytes, &nbytes);
629: if (len) {
630: (*string) = (char*)__objc_xmalloc(nbytes);
631: if (key)
632: hash_add (&stream->stream_table, (void*)key, *string);
633: len = (*stream->read)(stream->physical, *string, buf[0]&_B_VALUE);
634: (*string)[nbytes] = '\0';
635: }
636: }
637: break;
638:
639: default:
640: __objc_fatal("expected string, got opcode %c\n", (buf[0]&_B_CODE));
641: }
642: }
643:
644: return len;
645: }
646:
647:
648: int
649: objc_read_object (struct objc_typed_stream* stream, id* object)
650: {
651: unsigned char buf[sizeof (unsigned int)];
652: int len;
653: if ((len = (*stream->read)(stream->physical, buf, 1)))
654: {
655: SEL read_sel = sel_get_uid ("read:");
656: unsigned int key = 0;
657:
658: if ((buf[0]&_B_CODE) == _B_RCOMM) /* register common */
659: {
660: len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
661: len = (*stream->read)(stream->physical, buf, 1);
662: }
663:
664: if (buf[0] == (_B_EXT | _BX_OBJECT))
665: {
666: Class* class;
667:
668: /* get class */
669: len = objc_read_class (stream, &class);
670:
671: /* create instance */
672: (*object) = class_create_instance(class);
673:
674: /* register? */
675: if (key)
676: hash_add (&stream->object_table, (void*)key, *object);
677:
678: /* send -read: */
679: if (__objc_responds_to (*object, read_sel))
680: (*get_imp(class, read_sel))(*object, read_sel, stream);
681:
682: /* check null-byte */
683: len = (*stream->read)(stream->physical, buf, 1);
684: if (buf[0] != '\0')
685: __objc_fatal("expected null-byte, got opcode %c", buf[0]);
686: }
687:
688: else if ((buf[0]&_B_CODE) == _B_UCOMM)
689: {
690: if (key)
691: __objc_fatal("cannot register use upcode...");
692: len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
693: (*object) = hash_value_for_key (stream->object_table, (void*)key);
694: }
695:
696: else if (buf[0] == (_B_EXT | _BX_OBJREF)) /* a forward reference */
697: {
698: struct objc_list* other;
699: len = objc_read_unsigned_int (stream, &key);
700: other = (struct objc_list*)hash_value_for_key (stream->object_refs, (void*)key);
701: hash_add (&stream->object_refs, (void*)key, (void*)list_cons(object, other));
702: }
703:
704: else if (buf[0] == (_B_EXT | _BX_OBJROOT)) /* a root object */
705: {
706: if (key)
707: __objc_fatal("cannot register root object...");
708: len = objc_read_object (stream, object);
709: __objc_finish_read_root_object (stream);
710: }
711:
712: else
713: __objc_fatal("expected object, got opcode %c", buf[0]);
714: }
715: return len;
716: }
717:
718: static int
719: objc_read_class (struct objc_typed_stream* stream, Class** class)
720: {
721: unsigned char buf[sizeof (unsigned int)];
722: int len;
723: if ((len = (*stream->read)(stream->physical, buf, 1)))
724: {
725: unsigned int key = 0;
726:
727: if ((buf[0]&_B_CODE) == _B_RCOMM) /* register following */
728: {
729: len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
730: len = (*stream->read)(stream->physical, buf, 1);
731: }
732:
733: if (buf[0] == (_B_EXT | _BX_CLASS))
734: {
735: char* class_name;
736: int version;
737:
738: /* get class */
739: len = objc_read_string (stream, &class_name);
740: (*class) = objc_get_class(class_name);
741: free (class_name);
742:
743: /* register */
744: if (key)
745: hash_add (&stream->stream_table, (void*)key, *class);
746:
747: objc_read_unsigned_int(stream, &version);
748: hash_add (&stream->class_table, (*class)->name, (void*)version);
749: }
750:
751: else if ((buf[0]&_B_CODE) == _B_UCOMM)
752: {
753: if (key)
754: __objc_fatal("cannot register use upcode...");
755: len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
756: (*class) = hash_value_for_key (stream->stream_table, (void*)key);
757: if (!*class)
758: __objc_fatal("cannot find class for key %x", key);
759: }
760:
761: else
762: __objc_fatal("expected class, got opcode %c", buf[0]);
763: }
764: return len;
765: }
766:
767: int
768: objc_read_selector (struct objc_typed_stream* stream, SEL* selector)
769: {
770: unsigned char buf[sizeof (unsigned int)];
771: int len;
772: if ((len = (*stream->read)(stream->physical, buf, 1)))
773: {
774: unsigned int key = 0;
775:
776: if ((buf[0]&_B_CODE) == _B_RCOMM) /* register following */
777: {
778: len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
779: len = (*stream->read)(stream->physical, buf, 1);
780: }
781:
782: if (buf[0] == (_B_EXT|_BX_SEL)) /* selector! */
783: {
784: char* selector_name;
785:
786: /* get selector */
787: len = objc_read_string (stream, &selector_name);
788: (*selector) = sel_get_uid(selector_name);
789: free (selector_name);
790:
791: /* register */
792: if (key)
793: hash_add (&stream->stream_table, (void*)key, *selector);
794: }
795:
796: else if ((buf[0]&_B_CODE) == _B_UCOMM)
797: {
798: if (key)
799: __objc_fatal("cannot register use upcode...");
800: len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
801: (*selector) = hash_value_for_key (stream->stream_table, (void*)key);
802: }
803:
804: else
805: __objc_fatal("expected selector, got opcode %c", buf[0]);
806: }
807: return len;
808: }
809:
810: static int
811: objc_sizeof_type(const char* type)
812: {
813: switch(*type) {
814: case _C_ID: return sizeof(id);
815: break;
816:
817: case _C_CLASS:
818: return sizeof(Class*);
819: break;
820:
821: case _C_SEL:
822: return sizeof(SEL);
823: break;
824:
825: case _C_CHR:
826: return sizeof(char);
827: break;
828:
829: case _C_UCHR:
830: return sizeof(unsigned char);
831: break;
832:
833: case _C_SHT:
834: return sizeof(short);
835: break;
836:
837: case _C_USHT:
838: return sizeof(unsigned short);
839: break;
840:
841: case _C_INT:
842: case _C_LNG:
843: return sizeof(int);
844: break;
845:
846: case _C_UINT:
847: case _C_ULNG:
848: return sizeof(unsigned int);
849: break;
850:
851: case _C_ATOM:
852: case _C_CHARPTR:
853: return sizeof(char*);
854: break;
855:
856: default:
857: fprintf(stderr, "objc_write_type: cannot parse typespec: %s\n", type);
858: abort();
859: }
860: }
861:
862:
863: static const char*
864: __objc_skip_type (const char* type)
865: {
866: switch (*type) {
867: case _C_ID:
868: case _C_CLASS:
869: case _C_SEL:
870: case _C_CHR:
871: case _C_UCHR:
872: case _C_CHARPTR:
873: case _C_ATOM:
874: case _C_SHT:
875: case _C_USHT:
876: case _C_INT:
877: case _C_UINT:
878: case _C_LNG:
879: case _C_ULNG:
880: case _C_FLT:
881: case _C_DBL:
882: return ++type;
883: break;
884:
885: case _C_ARY_B:
886: while(isdigit(*++type));
887: type = __objc_skip_type(type);
888: if (*type == _C_ARY_E)
889: return ++type;
890: else
891: __objc_fatal("cannot parse typespec: %s", type);
892: break;
893:
894: default:
895: fprintf(stderr, "objc_read_types: cannot parse typespec: %s\n", type);
896: abort();
897: }
898: }
899:
900: /*
901: ** USER LEVEL FUNCTIONS
902: */
903:
904: /*
905: ** Write one object, encoded in TYPE and pointed to by DATA to the
906: ** typed stream STREAM.
907: */
908:
909: int
910: objc_write_type(TypedStream* stream, const char* type, const void* data)
911: {
912: switch(*type) {
913: case _C_ID:
914: return objc_write_object (stream, *(id*)data);
915: break;
916:
917: case _C_CLASS:
918: return objc_write_class (stream, *(Class**)data);
919: break;
920:
921: case _C_SEL:
922: return objc_write_selector (stream, *(SEL*)data);
923: break;
924:
925: case _C_CHR:
926: return objc_write_char(stream, *(char*)data);
927: break;
928:
929: case _C_UCHR:
930: return objc_write_unsigned_char(stream, *(unsigned char*)data);
931: break;
932:
933: case _C_SHT:
934: return objc_write_short(stream, *(short*)data);
935: break;
936:
937: case _C_USHT:
938: return objc_write_unsigned_short(stream, *(unsigned short*)data);
939: break;
940:
941: case _C_INT:
942: case _C_LNG:
943: return objc_write_int(stream, *(int*)data);
944: break;
945:
946: case _C_UINT:
947: case _C_ULNG:
948: return objc_write_unsigned_int(stream, *(unsigned int*)data);
949: break;
950:
951: case _C_CHARPTR:
952: return objc_write_string (stream, (char*)data, strlen((char*)data));
953: break;
954:
955: case _C_ATOM:
956: return objc_write_string_atomic (stream, (char*)data, strlen((char*)data));
957: break;
958:
959: case _C_ARY_B:
960: {
961: int len = atoi(type+1);
962: while (isdigit(*++type));
963: return objc_write_array (stream, type, len, data);
964: }
965: break;
966:
967: default:
968: fprintf(stderr, "objc_write_type: cannot parse typespec: %s\n", type);
969: abort();
970: }
971: }
972:
973: /*
974: ** Read one object, encoded in TYPE and pointed to by DATA to the
975: ** typed stream STREAM. DATA specifies the address of the types to
976: ** read. Expected type is checked against the type actually present
977: ** on the stream.
978: */
979:
980: int
981: objc_read_type(TypedStream* stream, const char* type, void* data)
982: {
983: char c;
984: switch(c = *type) {
985: case _C_ID:
986: return objc_read_object (stream, (id*)data);
987: break;
988:
989: case _C_CLASS:
990: return objc_read_class (stream, (Class**)data);
991: break;
992:
993: case _C_SEL:
994: return objc_read_selector (stream, (SEL*)data);
995: break;
996:
997: case _C_CHR:
998: return objc_read_char (stream, (char*)data);
999: break;
1000:
1001: case _C_UCHR:
1002: return objc_read_unsigned_char (stream, (unsigned char*)data);
1003: break;
1004:
1005: case _C_SHT:
1006: return objc_read_short (stream, (short*)data);
1007: break;
1008:
1009: case _C_USHT:
1010: return objc_read_unsigned_short (stream, (unsigned short*)data);
1011: break;
1012:
1013: case _C_INT:
1014: case _C_LNG:
1015: return objc_read_int (stream, (int*)data);
1016: break;
1017:
1018: case _C_UINT:
1019: case _C_ULNG:
1020: return objc_read_unsigned_int (stream, (unsigned int*)data);
1021: break;
1022:
1023: case _C_CHARPTR:
1024: case _C_ATOM:
1025: return objc_read_string (stream, (char**)data);
1026: break;
1027:
1028: case _C_ARY_B:
1029: {
1030: int len = atoi(type+1);
1031: while (isdigit(*++type));
1032: return objc_read_array (stream, type, len, data);
1033: }
1034: break;
1035:
1036: default:
1037: fprintf(stderr, "objc_write_type: cannot parse typespec: %s\n", type);
1038: abort();
1039: }
1040: }
1041:
1042: /*
1043: ** Write the object specified by the template TYPE to STREAM. Last
1044: ** arguments specify addresses of values to be written. It might
1045: ** seem surprising to specify values by address, but this is extremely
1046: ** convenient for copy-paste with objc_read_types calls. A more
1047: ** down-to-the-earth cause for this passing of addresses is that values
1048: ** of arbitrary size is not well supported in ANSI C for functions with
1049: ** variable number of arguments.
1050: */
1051:
1052: int
1053: objc_write_types (TypedStream* stream, const char* type, ...)
1054: {
1055: va_list args;
1056: const char *c;
1057: int res = 0;
1058:
1059: va_start(args, type);
1060:
1061: for (c = type; *c; c = __objc_skip_type (c))
1062: {
1063: switch(*c) {
1064: case _C_ID:
1065: res = objc_write_object (stream, *va_arg (args, id*));
1066: break;
1067:
1068: case _C_CLASS:
1069: res = objc_write_class (stream, *va_arg(args, Class**));
1070: break;
1071:
1072: case _C_SEL:
1073: res = objc_write_selector (stream, *va_arg(args, SEL*));
1074: break;
1075:
1076: case _C_CHR:
1077: res = objc_write_char (stream, *va_arg (args, char*));
1078: break;
1079:
1080: case _C_UCHR:
1081: res = objc_write_unsigned_char (stream,
1082: *va_arg (args, unsigned char*));
1083: break;
1084:
1085: case _C_SHT:
1086: res = objc_write_short (stream, *va_arg(args, short*));
1087: break;
1088:
1089: case _C_USHT:
1090: res = objc_write_unsigned_short (stream,
1091: *va_arg(args, unsigned short*));
1092: break;
1093:
1094: case _C_INT:
1095: case _C_LNG:
1096: res = objc_write_int(stream, *va_arg(args, int*));
1097: break;
1098:
1099: case _C_UINT:
1100: case _C_ULNG:
1101: res = objc_write_unsigned_int(stream, *va_arg(args, unsigned int*));
1102: break;
1103:
1104: case _C_CHARPTR:
1105: {
1106: char* str = va_arg(args, char*);
1107: res = objc_write_string (stream, str, strlen(str));
1108: }
1109: break;
1110:
1111: case _C_ATOM:
1112: {
1113: char* str = va_arg(args, char*);
1114: res = objc_write_string_atomic (stream, str, strlen(str));
1115: }
1116: break;
1117:
1118: case _C_ARY_B:
1119: {
1120: int len = atoi(c+1);
1121: const char* t = c;
1122: while (isdigit(*++t));
1123: res = objc_write_array (stream, t, len, va_arg(args, void*));
1124: t = __objc_skip_type (t);
1125: if (*t != _C_ARY_E)
1126: __objc_fatal("expected `]', got: %s", t);
1127: }
1128: break;
1129:
1130: default:
1131: fprintf(stderr, "objc_write_type: cannot parse typespec: %s\n", type);
1132: abort();
1133: }
1134: }
1135: va_end(args);
1136: return res;
1137: }
1138:
1139:
1140: /*
1141: ** Last arguments specify addresses of values to be read. Expected
1142: ** type is checked against the type actually present on the stream.
1143: */
1144:
1145: int
1146: objc_read_types(TypedStream* stream, const char* type, ...)
1147: {
1148: va_list args;
1149: const char *c;
1150: int res = 0;
1151:
1152: va_start(args, type);
1153:
1154: for (c = type; *c; c = __objc_skip_type(c))
1155: {
1156: switch(*c) {
1157: case _C_ID:
1158: res = objc_read_object(stream, va_arg(args, id*));
1159: break;
1160:
1161: case _C_CLASS:
1162: res = objc_read_class(stream, va_arg(args, Class**));
1163: break;
1164:
1165: case _C_SEL:
1166: res = objc_read_selector(stream, va_arg(args, SEL*));
1167: break;
1168:
1169: case _C_CHR:
1170: res = objc_read_char(stream, va_arg(args, char*));
1171: break;
1172:
1173: case _C_UCHR:
1174: res = objc_read_unsigned_char(stream, va_arg(args, unsigned char*));
1175: break;
1176:
1177: case _C_SHT:
1178: res = objc_read_short(stream, va_arg(args, short*));
1179: break;
1180:
1181: case _C_USHT:
1182: res = objc_read_unsigned_short(stream, va_arg(args, unsigned short*));
1183: break;
1184:
1185: case _C_INT:
1186: case _C_LNG:
1187: res = objc_read_int(stream, va_arg(args, int*));
1188: break;
1189:
1190: case _C_UINT:
1191: case _C_ULNG:
1192: res = objc_read_unsigned_int(stream, va_arg(args, unsigned int*));
1193: break;
1194:
1195: case _C_CHARPTR:
1196: case _C_ATOM:
1197: {
1198: char** str = va_arg(args, char**);
1199: res = objc_read_string (stream, str);
1200: }
1201: break;
1202:
1203: case _C_ARY_B:
1204: {
1205: int len = atoi(c+1);
1206: const char* t = c;
1207: while (isdigit(*++t));
1208: res = objc_read_array (stream, t, len, va_arg(args, void*));
1209: t = __objc_skip_type (t);
1210: if (*t != _C_ARY_E)
1211: __objc_fatal("expected `]', got: %s", t);
1212: }
1213: break;
1214:
1215: default:
1216: fprintf(stderr, "objc_read_type: cannot parse typespec: %s\n", type);
1217: abort();
1218: }
1219: }
1220: va_end(args);
1221: return res;
1222: }
1223:
1224: /*
1225: ** Write an array of COUNT elements of TYPE from the memory address DATA.
1226: ** This is equivalent of objc_write_type (stream, "[N<type>]", data)
1227: */
1228:
1229: int
1230: objc_write_array (TypedStream* stream, const char* type,
1231: int count, const void* data)
1232: {
1233: int off = objc_sizeof_type(type);
1234: const char* where = data;
1235:
1236: while (count-- > 0)
1237: {
1238: objc_write_type(stream, type, where);
1239: where += off;
1240: }
1241: return 1;
1242: }
1243:
1244: /*
1245: ** Read an array of COUNT elements of TYPE into the memory address
1246: ** DATA. The memory pointed to by data is supposed to be allocated
1247: ** by the callee. This is equivalent of
1248: ** objc_read_type (stream, "[N<type>]", data)
1249: */
1250:
1251: int
1252: objc_read_array (TypedStream* stream, const char* type,
1253: int count, void* data)
1254: {
1255: int off = objc_sizeof_type(type);
1256: char* where = (char*)data;
1257:
1258: while (count-- > 0)
1259: {
1260: objc_read_type(stream, type, where);
1261: where += off;
1262: }
1263: return 1;
1264: }
1265:
1266: static int
1267: __objc_fread(FILE* file, char* data, int len)
1268: {
1269: return fread(data, len, 1, file);
1270: }
1271:
1272: static int
1273: __objc_fwrite(FILE* file, char* data, int len)
1274: {
1275: return fwrite(data, len, 1, file);
1276: }
1277:
1278: static int
1279: __objc_feof(FILE* file)
1280: {
1281: return feof(file);
1282: }
1283:
1284: static int
1285: __objc_no_write(FILE* file, char* data, int len)
1286: {
1287: __objc_fatal ("TypedStream not open for writing");
1288: }
1289:
1290: static int
1291: __objc_no_read(FILE* file, char* data, int len)
1292: {
1293: __objc_fatal ("TypedStream not open for reading");
1294: }
1295:
1296: static int
1297: __objc_read_typed_stream_signature (TypedStream* stream)
1298: {
1299: char buffer[80];
1300: int pos = 0;
1301: do
1302: (*stream->read)(stream->physical, buffer+pos, 1);
1303: while (buffer[pos++] != '\0');
1304: sscanf (buffer, "GNU TypedStream %d", &stream->version);
1305: if (stream->version != OBJC_TYPED_STREAM_VERSION)
1306: __objc_fatal ("cannot handle TypedStream version %d", stream->version);
1307: return 1;
1308: }
1309:
1310: static int
1311: __objc_write_typed_stream_signature (TypedStream* stream)
1312: {
1313: char buffer[80];
1314: sprintf(buffer, "GNU TypedStream %d", OBJC_TYPED_STREAM_VERSION);
1315: stream->version = OBJC_TYPED_STREAM_VERSION;
1316: (*stream->write)(stream->physical, buffer, strlen(buffer)+1);
1317: return 1;
1318: }
1319:
1320: static void __objc_finish_write_root_object(struct objc_typed_stream* stream)
1321: {
1322: hash_delete (stream->object_table);
1323: stream->object_table = hash_new(64,
1324: (hash_func_type)hash_ptr,
1325: (compare_func_type)compare_ptrs);
1326: }
1327:
1328: static void __objc_finish_read_root_object(struct objc_typed_stream* stream)
1329: {
1330: node_ptr node;
1331: SEL awake_sel = sel_get_uid ("awake");
1332:
1333: /* resolve object forward references */
1334: for (node = hash_next (stream->object_refs, NULL); node;
1335: node = hash_next (stream->object_refs, node))
1336: {
1337: struct objc_list* reflist = node->value;
1338: const void* key = node->key;
1339: id object = hash_value_for_key (stream->object_table, key);
1340: while(reflist)
1341: {
1342: *((id*)reflist->head) = object;
1343: reflist = reflist->tail;
1344: }
1345: list_free (node->value);
1346: }
1347:
1348: /* empty object reference table */
1349: hash_delete (stream->object_refs);
1350: stream->object_refs = hash_new(8, (hash_func_type)hash_ptr,
1351: (compare_func_type)compare_ptrs);
1352:
1353: /* call -awake for all objects read */
1354: if (awake_sel)
1355: {
1356: for (node = hash_next (stream->object_table, NULL); node;
1357: node = hash_next (stream->object_table, node))
1358: {
1359: id object = node->value;
1360: if (__objc_responds_to (object, awake_sel))
1361: (*objc_msg_lookup(object, awake_sel))(object, awake_sel);
1362: }
1363: }
1364:
1365: /* empty object table */
1366: hash_delete (stream->object_table);
1367: stream->object_table = hash_new(64,
1368: (hash_func_type)hash_ptr,
1369: (compare_func_type)compare_ptrs);
1370: }
1371:
1372: /*
1373: ** Open the stream PHYSICAL in MODE
1374: */
1375:
1376: TypedStream*
1377: objc_open_typed_stream (FILE* physical, int mode)
1378: {
1379: int fflush(FILE*);
1380:
1381: TypedStream* s = (TypedStream*)__objc_xmalloc(sizeof(TypedStream));
1382:
1383: s->mode = mode;
1384: s->physical = physical;
1385: s->stream_table = hash_new(64,
1386: (hash_func_type)hash_ptr,
1387: (compare_func_type)compare_ptrs);
1388: s->object_table = hash_new(64,
1389: (hash_func_type)hash_ptr,
1390: (compare_func_type)compare_ptrs);
1391: s->eof = (objc_typed_eof_func)__objc_feof;
1392: s->flush = (objc_typed_flush_func)fflush;
1393: s->writing_root_p = 0;
1394: if (mode == OBJC_READONLY)
1395: {
1396: s->class_table = hash_new(8, (hash_func_type)hash_string,
1397: (compare_func_type)compare_strings);
1398: s->object_refs = hash_new(8, (hash_func_type)hash_ptr,
1399: (compare_func_type)compare_ptrs);
1400: s->read = (objc_typed_read_func)__objc_fread;
1401: s->write = (objc_typed_write_func)__objc_no_write;
1402: __objc_read_typed_stream_signature (s);
1403: }
1404: else if (mode == OBJC_WRITEONLY)
1405: {
1406: s->class_table = 0;
1407: s->object_refs = 0;
1408: s->read = (objc_typed_read_func)__objc_no_read;
1409: s->write = (objc_typed_write_func)__objc_fwrite;
1410: __objc_write_typed_stream_signature (s);
1411: }
1412: else
1413: {
1414: objc_close_typed_stream (s);
1415: return NULL;
1416: }
1417: s->type = OBJC_FILE_STREAM;
1418: return s;
1419: }
1420:
1421: /*
1422: ** Open the file named by FILE_NAME in MODE
1423: */
1424:
1425: TypedStream*
1426: objc_open_typed_stream_for_file (const char* file_name, int mode)
1427: {
1428: FILE* file = NULL;
1429: TypedStream* s;
1430:
1431: if (mode == OBJC_READONLY)
1432: file = fopen (file_name, "r");
1433: else
1434: file = fopen (file_name, "w");
1435:
1436: if (file)
1437: {
1438: s = objc_open_typed_stream (file, mode);
1439: if (s)
1440: s->type |= OBJC_MANAGED_STREAM;
1441: return s;
1442: }
1443: else
1444: return NULL;
1445: }
1446:
1447: /*
1448: ** Close STREAM freeing the structure it self. If it was opened with
1449: ** objc_open_typed_stream_for_file, the file will also be closed.
1450: */
1451:
1452: void
1453: objc_close_typed_stream (TypedStream* stream)
1454: {
1455: if (stream->mode == OBJC_READONLY)
1456: {
1457: __objc_finish_read_root_object (stream); /* Just in case... */
1458: hash_delete (stream->class_table);
1459: hash_delete (stream->object_refs);
1460: }
1461:
1462: hash_delete (stream->stream_table);
1463: hash_delete (stream->object_table);
1464:
1465: if (stream->type == (OBJC_MANAGED_STREAM | OBJC_FILE_STREAM))
1466: fclose ((FILE*)stream->physical);
1467:
1468: free (stream);
1469: }
1470:
1471: BOOL
1472: objc_end_of_typed_stream (TypedStream* stream)
1473: {
1474: return (*stream->eof)(stream->physical);
1475: }
1476:
1477: void
1478: objc_flush_typed_stream (TypedStream* stream)
1479: {
1480: (*stream->flush)(stream->physical);
1481: }
1482:
1483: int
1484: objc_get_stream_class_version (TypedStream* stream, Class* class)
1485: {
1486: if (stream->class_table)
1487: return (int) hash_value_for_key (stream->class_table, class->name);
1488: else
1489: return class_get_version (class);
1490: }
1491:
1492: #endif /* __alpha__ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.