gcc/objc/archive.c

   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, "archiving: "); \
  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           char *tmp;
 621           len = __objc_read_nbyte_uint (stream, (buf[0] & _B_VALUE), &key);
 622           tmp = hash_value_for_key (stream->stream_table, (void*)key);
 623           *string = __objc_xmalloc (strlen (tmp) + 1);
 624           strcpy (*string, tmp);
 625         }
 626         break;
 627
 628       case _B_NSTR:
 629         {
 630           unsigned int nbytes = buf[0]&_B_VALUE;
 631           len = __objc_read_nbyte_uint(stream, nbytes, &nbytes);
 632           if (len) {
 633             (*string) = (char*)__objc_xmalloc(nbytes+1);
 634             if (key)
 635               hash_add (&stream->stream_table, (void*)key, *string);
 636             len = (*stream->read)(stream->physical, *string, nbytes);
 637             (*string)[nbytes] = '\0';
 638           }
 639         }
 640         break;
 641
 642       default:
 643         __objc_fatal("expected string, got opcode %c\n", (buf[0]&_B_CODE));
 644       }
 645     }
 646
 647   return len;
 648 }
 649
 650
 651 int
 652 objc_read_object (struct objc_typed_stream* stream, id* object)
 653 {
 654   unsigned char buf[sizeof (unsigned int)];
 655   int len;
 656   if ((len = (*stream->read)(stream->physical, buf, 1)))
 657     {
 658       SEL read_sel = sel_get_uid ("read:");
 659       unsigned int key = 0;
 660
 661       if ((buf[0]&_B_CODE) == _B_RCOMM) /* register common */
 662         {
 663           len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
 664           len = (*stream->read)(stream->physical, buf, 1);
 665         }
 666
 667       if (buf[0] == (_B_EXT | _BX_OBJECT))
 668         {
 669           Class* class;
 670
 671           /* get class */
 672           len = objc_read_class (stream, &class);
 673
 674           /* create instance */
 675           (*object) = class_create_instance(class);
 676
 677           /* register? */
 678           if (key)
 679             hash_add (&stream->object_table, (void*)key, *object);
 680
 681           /* send -read: */
 682           if (__objc_responds_to (*object, read_sel))
 683             (*get_imp(class, read_sel))(*object, read_sel, stream);
 684
 685           /* check null-byte */
 686           len = (*stream->read)(stream->physical, buf, 1);
 687           if (buf[0] != '\0')
 688             __objc_fatal("expected null-byte, got opcode %c", buf[0]);
 689         }
 690
 691       else if ((buf[0]&_B_CODE) == _B_UCOMM)
 692         {
 693           if (key)
 694             __objc_fatal("cannot register use upcode...");
 695           len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
 696           (*object) = hash_value_for_key (stream->object_table, (void*)key);
 697         }
 698
 699       else if (buf[0] == (_B_EXT | _BX_OBJREF)) /* a forward reference */
 700         {
 701           struct objc_list* other;
 702           len = objc_read_unsigned_int (stream, &key);
 703           other = (struct objc_list*)hash_value_for_key (stream->object_refs, (void*)key);
 704           hash_add (&stream->object_refs, (void*)key, (void*)list_cons(object, other));
 705         }
 706
 707       else if (buf[0] == (_B_EXT | _BX_OBJROOT)) /* a root object */
 708         {
 709           if (key)
 710             __objc_fatal("cannot register root object...");
 711           len = objc_read_object (stream, object);
 712           __objc_finish_read_root_object (stream);
 713         }
 714
 715       else
 716         __objc_fatal("expected object, got opcode %c", buf[0]);
 717     }
 718   return len;
 719 }
 720
 721 static int
 722 objc_read_class (struct objc_typed_stream* stream, Class** class)
 723 {
 724   unsigned char buf[sizeof (unsigned int)];
 725   int len;
 726   if ((len = (*stream->read)(stream->physical, buf, 1)))
 727     {
 728       unsigned int key = 0;
 729
 730       if ((buf[0]&_B_CODE) == _B_RCOMM) /* register following */
 731         {
 732           len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
 733           len = (*stream->read)(stream->physical, buf, 1);
 734         }
 735
 736       if (buf[0] == (_B_EXT | _BX_CLASS))
 737         {
 738           char* class_name;
 739           int version;
 740
 741           /* get class */
 742           len = objc_read_string (stream, &class_name);
 743           (*class) = objc_get_class(class_name);
 744           free (class_name);
 745
 746           /* register */
 747           if (key)
 748             hash_add (&stream->stream_table, (void*)key, *class);
 749
 750           objc_read_unsigned_int(stream, &version);
 751           hash_add (&stream->class_table, (*class)->name, (void*)version);
 752         }
 753
 754       else if ((buf[0]&_B_CODE) == _B_UCOMM)
 755         {
 756           if (key)
 757             __objc_fatal("cannot register use upcode...");
 758           len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
 759           (*class) = hash_value_for_key (stream->stream_table, (void*)key);
 760           if (!*class)
 761             __objc_fatal("cannot find class for key %x", key);
 762         }
 763
 764       else
 765         __objc_fatal("expected class, got opcode %c", buf[0]);
 766     }
 767   return len;
 768 }
 769
 770 int
 771 objc_read_selector (struct objc_typed_stream* stream, SEL* selector)
 772 {
 773   unsigned char buf[sizeof (unsigned int)];
 774   int len;
 775   if ((len = (*stream->read)(stream->physical, buf, 1)))
 776     {
 777       unsigned int key = 0;
 778
 779       if ((buf[0]&_B_CODE) == _B_RCOMM) /* register following */
 780         {
 781           len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
 782           len = (*stream->read)(stream->physical, buf, 1);
 783         }
 784
 785       if (buf[0] == (_B_EXT|_BX_SEL)) /* selector! */
 786         {
 787           char* selector_name;
 788
 789           /* get selector */
 790           len = objc_read_string (stream, &selector_name);
 791           (*selector) = sel_get_uid(selector_name);
 792           free (selector_name);
 793
 794           /* register */
 795           if (key)
 796             hash_add (&stream->stream_table, (void*)key, *selector);
 797         }
 798
 799       else if ((buf[0]&_B_CODE) == _B_UCOMM)
 800         {
 801           if (key)
 802             __objc_fatal("cannot register use upcode...");
 803           len = __objc_read_nbyte_uint(stream, (buf[0] & _B_VALUE), &key);
 804           (*selector) = hash_value_for_key (stream->stream_table, (void*)key);
 805         }
 806
 807       else
 808         __objc_fatal("expected selector, got opcode %c", buf[0]);
 809     }
 810   return len;
 811 }
 812
 813 static int
 814 objc_sizeof_type(const char* type)
 815 {
 816   switch(*type) {
 817   case _C_ID: return sizeof(id);
 818     break;
 819
 820   case _C_CLASS:
 821     return sizeof(Class*);
 822     break;
 823
 824   case _C_SEL:
 825     return sizeof(SEL);
 826     break;
 827
 828   case _C_CHR:
 829     return sizeof(char);
 830     break;
 831
 832   case _C_UCHR:
 833     return sizeof(unsigned char);
 834     break;
 835
 836   case _C_SHT:
 837     return sizeof(short);
 838     break;
 839
 840   case _C_USHT:
 841     return sizeof(unsigned short);
 842     break;
 843
 844   case _C_INT:
 845   case _C_LNG:
 846     return sizeof(int);
 847     break;
 848
 849   case _C_UINT:
 850   case _C_ULNG:
 851     return sizeof(unsigned int);
 852     break;
 853
 854   case _C_ATOM:
 855   case _C_CHARPTR:
 856     return sizeof(char*);
 857     break;
 858
 859   default:
 860     fprintf(stderr, "objc_sizeof_type: cannot parse typespec: %s\n", type);
 861     abort();
 862   }
 863 }
 864
 865
 866 static const char*
 867 __objc_skip_type (const char* type)
 868 {
 869   switch (*type) {
 870   case _C_ID:
 871   case _C_CLASS:
 872   case _C_SEL:
 873   case _C_CHR:
 874   case _C_UCHR:
 875   case _C_CHARPTR:
 876   case _C_ATOM:
 877   case _C_SHT:
 878   case _C_USHT:
 879   case _C_INT:
 880   case _C_UINT:
 881   case _C_LNG:
 882   case _C_ULNG:
 883   case _C_FLT:
 884   case _C_DBL:
 885     return ++type;
 886     break;
 887
 888   case _C_ARY_B:
 889     while(isdigit(*++type));
 890     type = __objc_skip_type(type);
 891     if (*type == _C_ARY_E)
 892       return ++type;
 893     else
 894       __objc_fatal("cannot parse typespec: %s", type);
 895     break;
 896
 897   default:
 898     fprintf(stderr, "__objc_skip_type: cannot parse typespec: %s\n", type);
 899     abort();
 900   }
 901 }
 902
 903 /*
 904 ** USER LEVEL FUNCTIONS
 905 */
 906
 907 /*
 908 ** Write one object, encoded in TYPE and pointed to by DATA to the
 909 ** typed stream STREAM.
 910 */
 911
 912 int
 913 objc_write_type(TypedStream* stream, const char* type, const void* data)
 914 {
 915   switch(*type) {
 916   case _C_ID:
 917     return objc_write_object (stream, *(id*)data);
 918     break;
 919
 920   case _C_CLASS:
 921     return objc_write_class (stream, *(Class**)data);
 922     break;
 923
 924   case _C_SEL:
 925     return objc_write_selector (stream, *(SEL*)data);
 926     break;
 927
 928   case _C_CHR:
 929     return objc_write_char(stream, *(char*)data);
 930     break;
 931
 932   case _C_UCHR:
 933     return objc_write_unsigned_char(stream, *(unsigned char*)data);
 934     break;
 935
 936   case _C_SHT:
 937     return objc_write_short(stream, *(short*)data);
 938     break;
 939
 940   case _C_USHT:
 941     return objc_write_unsigned_short(stream, *(unsigned short*)data);
 942     break;
 943
 944   case _C_INT:
 945   case _C_LNG:
 946     return objc_write_int(stream, *(int*)data);
 947     break;
 948
 949   case _C_UINT:
 950   case _C_ULNG:
 951     return objc_write_unsigned_int(stream, *(unsigned int*)data);
 952     break;
 953
 954   case _C_CHARPTR:
 955     return objc_write_string (stream, *(char**)data, strlen(*(char**)data));
 956     break;
 957
 958   case _C_ATOM:
 959     return objc_write_string_atomic (stream, *(char**)data, strlen(*(char**)data));
 960     break;
 961
 962   case _C_ARY_B:
 963     {
 964       int len = atoi(type+1);
 965       while (isdigit(*++type));
 966       return objc_write_array (stream, type, len, data);
 967     }
 968     break;
 969
 970   default:
 971     fprintf(stderr, "objc_write_type: cannot parse typespec: %s\n", type);
 972     abort();
 973   }
 974 }
 975
 976 /*
 977 ** Read one object, encoded in TYPE and pointed to by DATA to the
 978 ** typed stream STREAM.  DATA specifies the address of the types to
 979 ** read.  Expected type is checked against the type actually present
 980 ** on the stream.
 981 */
 982
 983 int
 984 objc_read_type(TypedStream* stream, const char* type, void* data)
 985 {
 986   char c;
 987   switch(c = *type) {
 988   case _C_ID:
 989     return objc_read_object (stream, (id*)data);
 990     break;
 991
 992   case _C_CLASS:
 993     return objc_read_class (stream, (Class**)data);
 994     break;
 995
 996   case _C_SEL:
 997     return objc_read_selector (stream, (SEL*)data);
 998     break;
 999
1000   case _C_CHR:
1001     return objc_read_char (stream, (char*)data);
1002     break;
1003
1004   case _C_UCHR:
1005     return objc_read_unsigned_char (stream, (unsigned char*)data);
1006     break;
1007
1008   case _C_SHT:
1009     return objc_read_short (stream, (short*)data);
1010     break;
1011
1012   case _C_USHT:
1013     return objc_read_unsigned_short (stream, (unsigned short*)data);
1014     break;
1015
1016   case _C_INT:
1017   case _C_LNG:
1018     return objc_read_int (stream, (int*)data);
1019     break;
1020
1021   case _C_UINT:
1022   case _C_ULNG:
1023     return objc_read_unsigned_int (stream, (unsigned int*)data);
1024     break;
1025
1026   case _C_CHARPTR:
1027   case _C_ATOM:
1028     return objc_read_string (stream, (char**)data);
1029     break;
1030
1031   case _C_ARY_B:
1032     {
1033       int len = atoi(type+1);
1034       while (isdigit(*++type));
1035       return objc_read_array (stream, type, len, data);
1036     }
1037     break;
1038
1039   default:
1040     fprintf(stderr, "objc_read_type: cannot parse typespec: %s\n", type);
1041     abort();
1042   }
1043 }
1044
1045 /*
1046 ** Write the object specified by the template TYPE to STREAM.  Last
1047 ** arguments specify addresses of values to be written.  It might
1048 ** seem surprising to specify values by address, but this is extremely
1049 ** convenient for copy-paste with objc_read_types calls.  A more
1050 ** down-to-the-earth cause for this passing of addresses is that values
1051 ** of arbitrary size is not well supported in ANSI C for functions with
1052 ** variable number of arguments.
1053 */
1054
1055 int
1056 objc_write_types (TypedStream* stream, const char* type, ...)
1057 {
1058   va_list args;
1059   const char *c;
1060   int res = 0;
1061
1062   va_start(args, type);
1063
1064   for (c = type; *c; c = __objc_skip_type (c))
1065     {
1066       switch(*c) {
1067       case _C_ID:
1068         res = objc_write_object (stream, *va_arg (args, id*));
1069         break;
1070
1071       case _C_CLASS:
1072         res = objc_write_class (stream, *va_arg(args, Class**));
1073         break;
1074
1075       case _C_SEL:
1076         res = objc_write_selector (stream, *va_arg(args, SEL*));
1077         break;
1078
1079       case _C_CHR:
1080         res = objc_write_char (stream, *va_arg (args, char*));
1081         break;
1082
1083       case _C_UCHR:
1084         res = objc_write_unsigned_char (stream,
1085                                         *va_arg (args, unsigned char*));
1086         break;
1087
1088       case _C_SHT:
1089         res = objc_write_short (stream, *va_arg(args, short*));
1090         break;
1091
1092       case _C_USHT:
1093         res = objc_write_unsigned_short (stream,
1094                                          *va_arg(args, unsigned short*));
1095         break;
1096
1097       case _C_INT:
1098       case _C_LNG:
1099         res = objc_write_int(stream, *va_arg(args, int*));
1100         break;
1101
1102       case _C_UINT:
1103       case _C_ULNG:
1104         res = objc_write_unsigned_int(stream, *va_arg(args, unsigned int*));
1105         break;
1106
1107       case _C_CHARPTR:
1108         {
1109           char** str = va_arg(args, char**);
1110           res = objc_write_string (stream, *str, strlen(*str));
1111         }
1112         break;
1113
1114       case _C_ATOM:
1115         {
1116           char** str = va_arg(args, char**);
1117           res = objc_write_string_atomic (stream, *str, strlen(*str));
1118         }
1119         break;
1120
1121       case _C_ARY_B:
1122         {
1123           int len = atoi(c+1);
1124           const char* t = c;
1125           while (isdigit(*++t));
1126           res = objc_write_array (stream, t, len, va_arg(args, void*));
1127           t = __objc_skip_type (t);
1128           if (*t != _C_ARY_E)
1129             __objc_fatal("expected `]', got: %s", t);
1130         }
1131         break;
1132
1133       default:
1134         fprintf(stderr, "objc_write_types: cannot parse typespec: %s\n", type);
1135         abort();
1136       }
1137     }
1138   va_end(args);
1139   return res;
1140 }
1141
1142
1143 /*
1144 ** Last arguments specify addresses of values to be read.  Expected
1145 ** type is checked against the type actually present on the stream.
1146 */
1147
1148 int
1149 objc_read_types(TypedStream* stream, const char* type, ...)
1150 {
1151   va_list args;
1152   const char *c;
1153   int res = 0;
1154
1155   va_start(args, type);
1156
1157   for (c = type; *c; c = __objc_skip_type(c))
1158     {
1159       switch(*c) {
1160       case _C_ID:
1161         res = objc_read_object(stream, va_arg(args, id*));
1162         break;
1163
1164       case _C_CLASS:
1165         res = objc_read_class(stream, va_arg(args, Class**));
1166         break;
1167
1168       case _C_SEL:
1169         res = objc_read_selector(stream, va_arg(args, SEL*));
1170         break;
1171
1172       case _C_CHR:
1173         res = objc_read_char(stream, va_arg(args, char*));
1174         break;
1175
1176       case _C_UCHR:
1177         res = objc_read_unsigned_char(stream, va_arg(args, unsigned char*));
1178         break;
1179
1180       case _C_SHT:
1181         res = objc_read_short(stream, va_arg(args, short*));
1182         break;
1183
1184       case _C_USHT:
1185         res = objc_read_unsigned_short(stream, va_arg(args, unsigned short*));
1186         break;
1187
1188       case _C_INT:
1189       case _C_LNG:
1190         res = objc_read_int(stream, va_arg(args, int*));
1191         break;
1192
1193       case _C_UINT:
1194       case _C_ULNG:
1195         res = objc_read_unsigned_int(stream, va_arg(args, unsigned int*));
1196         break;
1197
1198       case _C_CHARPTR:
1199       case _C_ATOM:
1200         {
1201           char** str = va_arg(args, char**);
1202           res = objc_read_string (stream, str);
1203         }
1204         break;
1205
1206       case _C_ARY_B:
1207         {
1208           int len = atoi(c+1);
1209           const char* t = c;
1210           while (isdigit(*++t));
1211           res = objc_read_array (stream, t, len, va_arg(args, void*));
1212           t = __objc_skip_type (t);
1213           if (*t != _C_ARY_E)
1214             __objc_fatal("expected `]', got: %s", t);
1215         }
1216         break;
1217
1218       default:
1219         fprintf(stderr, "objc_read_types: cannot parse typespec: %s\n", type);
1220         abort();
1221       }
1222     }
1223   va_end(args);
1224   return res;
1225 }
1226
1227 /*
1228 ** Write an array of COUNT elements of TYPE from the memory address DATA.
1229 ** This is equivalent of objc_write_type (stream, "[N<type>]", data)
1230 */
1231
1232 int
1233 objc_write_array (TypedStream* stream, const char* type,
1234                   int count, const void* data)
1235 {
1236   int off = objc_sizeof_type(type);
1237   const char* where = data;
1238
1239   while (count-- > 0)
1240     {
1241       objc_write_type(stream, type, where);
1242       where += off;
1243     }
1244   return 1;
1245 }
1246
1247 /*
1248 ** Read an array of COUNT elements of TYPE into the memory address
1249 ** DATA.  The memory pointed to by data is supposed to be allocated
1250 ** by the callee.  This is equivalent of
1251 **   objc_read_type (stream, "[N<type>]", data)
1252 */
1253
1254 int
1255 objc_read_array (TypedStream* stream, const char* type,
1256                  int count, void* data)
1257 {
1258   int off = objc_sizeof_type(type);
1259   char* where = (char*)data;
1260
1261   while (count-- > 0)
1262     {
1263       objc_read_type(stream, type, where);
1264       where += off;
1265     }
1266   return 1;
1267 }
1268
1269 static int
1270 __objc_fread(FILE* file, char* data, int len)
1271 {
1272   return fread(data, len, 1, file);
1273 }
1274
1275 static int
1276 __objc_fwrite(FILE* file, char* data, int len)
1277 {
1278   return fwrite(data, len, 1, file);
1279 }
1280
1281 static int
1282 __objc_feof(FILE* file)
1283 {
1284   return feof(file);
1285 }
1286
1287 static int
1288 __objc_no_write(FILE* file, char* data, int len)
1289 {
1290   __objc_fatal ("TypedStream not open for writing");
1291 }
1292
1293 static int
1294 __objc_no_read(FILE* file, char* data, int len)
1295 {
1296   __objc_fatal ("TypedStream not open for reading");
1297 }
1298
1299 static int
1300 __objc_read_typed_stream_signature (TypedStream* stream)
1301 {
1302   char buffer[80];
1303   int pos = 0;
1304   do
1305     (*stream->read)(stream->physical, buffer+pos, 1);
1306   while (buffer[pos++] != '\0');
1307   sscanf (buffer, "GNU TypedStream %d", &stream->version);
1308   if (stream->version != OBJC_TYPED_STREAM_VERSION)
1309     __objc_fatal ("cannot handle TypedStream version %d", stream->version);
1310   return 1;
1311 }
1312
1313 static int
1314 __objc_write_typed_stream_signature (TypedStream* stream)
1315 {
1316   char buffer[80];
1317   sprintf(buffer, "GNU TypedStream %d", OBJC_TYPED_STREAM_VERSION);
1318   stream->version = OBJC_TYPED_STREAM_VERSION;
1319   (*stream->write)(stream->physical, buffer, strlen(buffer)+1);
1320   return 1;
1321 }
1322
1323 static void __objc_finish_write_root_object(struct objc_typed_stream* stream)
1324 {
1325   hash_delete (stream->object_table);
1326   stream->object_table = hash_new(64,
1327                                   (hash_func_type)hash_ptr,
1328                                   (compare_func_type)compare_ptrs);
1329 }
1330
1331 static void __objc_finish_read_root_object(struct objc_typed_stream* stream)
1332 {
1333   node_ptr node;
1334   SEL awake_sel = sel_get_uid ("awake");
1335
1336   /* resolve object forward references */
1337   for (node = hash_next (stream->object_refs, NULL); node;
1338        node = hash_next (stream->object_refs, node))
1339     {
1340       struct objc_list* reflist = node->value;
1341       const void* key = node->key;
1342       id object = hash_value_for_key (stream->object_table, key);
1343       while(reflist)
1344         {
1345           *((id*)reflist->head) = object;
1346           reflist = reflist->tail;
1347         }
1348       list_free (node->value);
1349     }
1350
1351   /* empty object reference table */
1352   hash_delete (stream->object_refs);
1353   stream->object_refs = hash_new(8, (hash_func_type)hash_ptr,
1354                                  (compare_func_type)compare_ptrs);
1355
1356   /* call -awake for all objects read  */
1357   if (awake_sel)
1358     {
1359       for (node = hash_next (stream->object_table, NULL); node;
1360            node = hash_next (stream->object_table, node))
1361         {
1362           id object = node->value;
1363           if (__objc_responds_to (object, awake_sel))
1364             (*objc_msg_lookup(object, awake_sel))(object, awake_sel);
1365         }
1366     }
1367
1368   /* empty object table */
1369   hash_delete (stream->object_table);
1370   stream->object_table = hash_new(64,
1371                                   (hash_func_type)hash_ptr,
1372                                   (compare_func_type)compare_ptrs);
1373 }
1374
1375 /*
1376 ** Open the stream PHYSICAL in MODE
1377 */
1378
1379 TypedStream*
1380 objc_open_typed_stream (FILE* physical, int mode)
1381 {
1382   int fflush(FILE*);
1383
1384   TypedStream* s = (TypedStream*)__objc_xmalloc(sizeof(TypedStream));
1385
1386   s->mode = mode;
1387   s->physical = physical;
1388   s->stream_table = hash_new(64,
1389                              (hash_func_type)hash_ptr,
1390                              (compare_func_type)compare_ptrs);
1391   s->object_table = hash_new(64,
1392                              (hash_func_type)hash_ptr,
1393                              (compare_func_type)compare_ptrs);
1394   s->eof = (objc_typed_eof_func)__objc_feof;
1395   s->flush = (objc_typed_flush_func)fflush;
1396   s->writing_root_p = 0;
1397   if (mode == OBJC_READONLY)
1398     {
1399       s->class_table = hash_new(8, (hash_func_type)hash_string,
1400                                 (compare_func_type)compare_strings);
1401       s->object_refs = hash_new(8, (hash_func_type)hash_ptr,
1402                                 (compare_func_type)compare_ptrs);
1403       s->read = (objc_typed_read_func)__objc_fread;
1404       s->write = (objc_typed_write_func)__objc_no_write;
1405       __objc_read_typed_stream_signature (s);
1406     }
1407   else if (mode == OBJC_WRITEONLY)
1408     {
1409       s->class_table = 0;
1410       s->object_refs = 0;
1411       s->read = (objc_typed_read_func)__objc_no_read;
1412       s->write = (objc_typed_write_func)__objc_fwrite;
1413       __objc_write_typed_stream_signature (s);
1414     }
1415   else
1416     {
1417       objc_close_typed_stream (s);
1418       return NULL;
1419     }
1420   s->type = OBJC_FILE_STREAM;
1421   return s;
1422 }
1423
1424 /*
1425 ** Open the file named by FILE_NAME in MODE
1426 */
1427
1428 TypedStream*
1429 objc_open_typed_stream_for_file (const char* file_name, int mode)
1430 {
1431   FILE* file = NULL;
1432   TypedStream* s;
1433
1434   if (mode == OBJC_READONLY)
1435     file = fopen (file_name, "r");
1436   else
1437     file = fopen (file_name, "w");
1438
1439   if (file)
1440     {
1441       s = objc_open_typed_stream (file, mode);
1442       if (s)
1443         s->type |= OBJC_MANAGED_STREAM;
1444       return s;
1445     }
1446   else
1447     return NULL;
1448 }
1449
1450 /*
1451 ** Close STREAM freeing the structure it self.  If it was opened with
1452 ** objc_open_typed_stream_for_file, the file will also be closed.
1453 */
1454
1455 void
1456 objc_close_typed_stream (TypedStream* stream)
1457 {
1458   if (stream->mode == OBJC_READONLY)
1459     {
1460       __objc_finish_read_root_object (stream); /* Just in case... */
1461       hash_delete (stream->class_table);
1462       hash_delete (stream->object_refs);
1463     }
1464
1465   hash_delete (stream->stream_table);
1466   hash_delete (stream->object_table);
1467
1468   if (stream->type == (OBJC_MANAGED_STREAM | OBJC_FILE_STREAM))
1469     fclose ((FILE*)stream->physical);
1470
1471   free (stream);
1472 }
1473
1474 BOOL
1475 objc_end_of_typed_stream (TypedStream* stream)
1476 {
1477   return (*stream->eof)(stream->physical);
1478 }
1479
1480 void
1481 objc_flush_typed_stream (TypedStream* stream)
1482 {
1483   (*stream->flush)(stream->physical);
1484 }
1485
1486 int
1487 objc_get_stream_class_version (TypedStream* stream, Class* class)
1488 {
1489   if (stream->class_table)
1490     return (int) hash_value_for_key (stream->class_table, class->name);
1491   else
1492     return class_get_version (class);
1493 }
1494
1495 #endif /* __alpha__ */