![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to objc-actions.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to objc-actions.c CVS log | Up to [GCC 2.x] / gcc |
1.1 ! root 1: /* Implement classes and message passing for Objective C. ! 2: Copyright (C) 1992 Free Software Foundation, Inc. ! 3: Author: Steve Naroff. ! 4: ! 5: This file is part of GNU CC. ! 6: ! 7: GNU CC is free software; you can redistribute it and/or modify ! 8: it under the terms of the GNU General Public License as published by ! 9: the Free Software Foundation; either version 2, or (at your option) ! 10: any later version. ! 11: ! 12: GNU CC is distributed in the hope that it will be useful, ! 13: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 15: GNU General Public License for more details. ! 16: ! 17: You should have received a copy of the GNU General Public License ! 18: along with GNU CC; see the file COPYING. If not, write to ! 19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 20: ! 21: /* ! 22: * Purpose: This module implements the Objective-C 4.0 language. ! 23: * ! 24: * compatibility issues (with the Stepstone translator): ! 25: * ! 26: * - does not recognize the following 3.3 constructs. ! 27: * @requires, @classes, @messages, = (...) ! 28: * - methods with variable arguments must conform to ANSI standard. ! 29: * - tagged structure definitions that appear in BOTH the interface ! 30: * and implementation are not allowed. ! 31: * - public/private: all instance variables are public within the ! 32: * context of the implementation...I consider this to be a bug in ! 33: * the translator. ! 34: * - statically allocated objects are not supported. the user will ! 35: * receive an error if this service is requested. ! 36: * ! 37: * code generation `options': ! 38: * ! 39: * - OBJC_INT_SELECTORS, OBJC_NONUNIQUE_SELECTORS ! 40: */ ! 41: ! 42: #include <stdio.h> ! 43: #include "config.h" ! 44: #include "tree.h" ! 45: #include "c-tree.h" ! 46: #include "c-lex.h" ! 47: #include "flags.h" ! 48: #include "objc-actions.h" ! 49: #include "input.h" ! 50: ! 51: /* Define the special tree codes that we use. */ ! 52: ! 53: /* Table indexed by tree code giving a string containing a character ! 54: classifying the tree code. Possibilities are ! 55: t, d, s, c, r, <, 1 and 2. See objc-tree.def for details. */ ! 56: ! 57: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE, ! 58: ! 59: char *objc_tree_code_type[] = { ! 60: "x", ! 61: #include "objc-tree.def" ! 62: }; ! 63: #undef DEFTREECODE ! 64: ! 65: /* Table indexed by tree code giving number of expression ! 66: operands beyond the fixed part of the node structure. ! 67: Not used for types or decls. */ ! 68: ! 69: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH, ! 70: ! 71: int objc_tree_code_length[] = { ! 72: 0, ! 73: #include "objc-tree.def" ! 74: }; ! 75: #undef DEFTREECODE ! 76: ! 77: /* Names of tree components. ! 78: Used for printing out the tree and error messages. */ ! 79: #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME, ! 80: ! 81: char *objc_tree_code_name[] = { ! 82: "@@dummy", ! 83: #include "objc-tree.def" ! 84: }; ! 85: #undef DEFTREECODE ! 86: ! 87: /* for encode_method_def */ ! 88: #include "rtl.h" ! 89: ! 90: #define OBJC_VERSION 2 ! 91: ! 92: #define NULLT (tree) 0 ! 93: ! 94: #define OBJC_ENCODE_INLINE_DEFS 0 ! 95: #define OBJC_ENCODE_DONT_INLINE_DEFS 1 ! 96: ! 97: /*** Private Interface (procedures) ***/ ! 98: ! 99: /* code generation */ ! 100: ! 101: static void synth_module_prologue (); ! 102: static char *build_module_descriptor (); ! 103: static tree init_module_descriptor (); ! 104: static void build_module_entry (); ! 105: static tree build_objc_method_call (); ! 106: static void build_message_selector_pool (); ! 107: static void build_selector_translation_table (); ! 108: static tree build_ivar_chain (); ! 109: ! 110: static tree build_ivar_template (); ! 111: static tree build_method_template (); ! 112: static tree build_private_template (); ! 113: static void build_class_template (); ! 114: static void build_category_template (); ! 115: static tree build_super_template (); ! 116: ! 117: static void synth_forward_declarations (); ! 118: static void generate_ivar_lists (); ! 119: static void generate_dispatch_tables (); ! 120: static void generate_shared_structures (); ! 121: ! 122: static tree build_msg_pool_reference (); ! 123: static tree init_selector (); ! 124: static tree build_keword_selector (); ! 125: static tree synth_id_with_class_suffix (); ! 126: ! 127: /* misc. bookkeeping */ ! 128: ! 129: typedef struct hashedEntry *hash; ! 130: typedef struct hashedAttribute *attr; ! 131: ! 132: struct hashedAttribute { ! 133: attr next; ! 134: tree value; ! 135: }; ! 136: struct hashedEntry { ! 137: attr list; ! 138: hash next; ! 139: tree key; ! 140: }; ! 141: static void hash_init (); ! 142: static void hash_enter (); ! 143: static hash hash_lookup (); ! 144: static void hash_add_attr (); ! 145: static tree lookup_method (); ! 146: static tree lookup_instance_method_static (); ! 147: static tree lookup_class_method_static (); ! 148: static tree add_class (); ! 149: static int add_selector_reference (); ! 150: static void add_class_reference (); ! 151: static int add_objc_string (); ! 152: ! 153: /* type encoding */ ! 154: ! 155: static void encode_aggregate (); ! 156: static void encode_bitfield (); ! 157: static void encode_type (); ! 158: static void encode_field_decl (); ! 159: ! 160: static void really_start_method (); ! 161: static int comp_method_with_proto (); ! 162: static int comp_proto_with_proto (); ! 163: static tree get_arg_type_list (); ! 164: static tree expr_last (); ! 165: ! 166: /* utilities for debugging and error diagnostics: */ ! 167: ! 168: static void warn_with_method (); ! 169: static void error_with_method (); ! 170: static void error_with_ivar (); ! 171: static char *gen_method_decl (); ! 172: static char *gen_declaration (); ! 173: static char *gen_declarator (); ! 174: static int is_complex_decl (); ! 175: static void adorn_decl (); ! 176: static void dump_interfaces (); ! 177: ! 178: /*** Private Interface (data) ***/ ! 179: ! 180: /* reserved tag definitions: */ ! 181: ! 182: #define TYPE_ID "id" ! 183: #define TAG_OBJECT "objc_object" ! 184: #define TAG_CLASS "objc_class" ! 185: #define TAG_SUPER "objc_super" ! 186: #define TAG_SELECTOR "objc_selector" ! 187: ! 188: #define _TAG_CLASS "_objc_class" ! 189: #define _TAG_IVAR "_objc_ivar" ! 190: #define _TAG_IVAR_LIST "_objc_ivar_list" ! 191: #define _TAG_METHOD "_objc_method" ! 192: #define _TAG_METHOD_LIST "_objc_method_list" ! 193: #define _TAG_CATEGORY "_objc_category" ! 194: #define _TAG_MODULE "_objc_module" ! 195: #define _TAG_SYMTAB "_objc_symtab" ! 196: #define _TAG_SUPER "_objc_super" ! 197: ! 198: /* set by `continue_class ()' and checked by `is_public ()' */ ! 199: ! 200: #define TREE_STATIC_TEMPLATE(record_type) (TREE_PUBLIC(record_type)) ! 201: #define TYPED_OBJECT(type) \ ! 202: (TREE_CODE (type) == RECORD_TYPE && TREE_STATIC_TEMPLATE (type)) ! 203: ! 204: /* some commonly used instances of "identifier_node". */ ! 205: ! 206: static tree self_id, _cmd_id, _msg_id, _msgSuper_id; ! 207: static tree objc_getClass_id, objc_getMetaClass_id; ! 208: ! 209: static tree self_decl, _msg_decl, _msgSuper_decl; ! 210: static tree objc_getClass_decl, objc_getMetaClass_decl; ! 211: ! 212: static tree super_type, _selector_type, id_type, class_type; ! 213: static tree instance_type; ! 214: ! 215: static tree interface_chain = NULLT; ! 216: ! 217: /* chains to manage selectors that are referenced and defined in the module */ ! 218: ! 219: static tree cls_ref_chain = NULLT; /* classes referenced */ ! 220: static tree sel_ref_chain = NULLT; /* selectors referenced */ ! 221: static tree sel_refdef_chain = NULLT; /* selectors references & defined */ ! 222: static int max_selector_index; /* total # of selector referenced */ ! 223: ! 224: /* hash tables to manage the global pool of method prototypes */ ! 225: ! 226: static hash *nst_method_hash_list = 0; ! 227: static hash *cls_method_hash_list = 0; ! 228: ! 229: /* the following are used when compiling a class implementation. ! 230: * ! 231: * implementation_template will normally be an anInterface, however if ! 232: * none exists this will be equal to implementation_context...it is ! 233: * set in start_class. ! 234: */ ! 235: ! 236: /* backend data declarations */ ! 237: ! 238: static tree _OBJC_SYMBOLS_decl; ! 239: static tree _OBJC_INSTANCE_VARIABLES_decl, _OBJC_CLASS_VARIABLES_decl; ! 240: static tree _OBJC_INSTANCE_METHODS_decl, _OBJC_CLASS_METHODS_decl; ! 241: static tree _OBJC_CLASS_decl, _OBJC_METACLASS_decl; ! 242: #ifdef OBJC_NONUNIQUE_SELECTORS ! 243: static tree _OBJC_SELECTOR_REFERENCES_decl; ! 244: #endif ! 245: static tree _OBJC_MODULES_decl; ! 246: static tree _OBJC_STRINGS_decl; ! 247: ! 248: static tree implementation_context = NULLT, ! 249: implementation_template = NULLT; ! 250: ! 251: struct imp_entry { ! 252: struct imp_entry *next; ! 253: tree imp_context; ! 254: tree imp_template; ! 255: tree class_decl; /* _OBJC_CLASS_<my_name>; */ ! 256: tree meta_decl; /* _OBJC_METACLASS_<my_name>; */ ! 257: }; ! 258: static struct imp_entry *imp_list = 0; ! 259: static int imp_count = 0; /* `@implementation' */ ! 260: static int cat_count = 0; /* `@category' */ ! 261: ! 262: static tree objc_class_template, objc_category_template, _PRIVATE_record; ! 263: static tree _clsSuper_ref, __clsSuper_ref; ! 264: ! 265: static tree objc_method_template, objc_ivar_template; ! 266: static tree objc_symtab_template, objc_module_template; ! 267: static tree objc_super_template, objc_object_reference; ! 268: ! 269: static tree objc_object_id, objc_class_id; ! 270: #ifdef OBJC_NONUNIQUE_SELECTORS ! 271: static tree _OBJC_SELECTOR_REFERENCES_id; ! 272: #endif ! 273: static tree _OBJC_SUPER_decl; ! 274: ! 275: static tree method_context = NULLT; ! 276: static int method_slot = 0; /* used by start_method_def */ ! 277: ! 278: #define BUFSIZE 512 ! 279: ! 280: static char *errbuf; /* a buffer for error diagnostics */ ! 281: static char *utlbuf; /* a buffer for general utility */ ! 282: ! 283: extern char *strcpy (), *strcat (); ! 284: ! 285: extern tree groktypename_in_parm_context (); ! 286: ! 287: extern struct obstack permanent_obstack, *current_obstack, *rtl_obstack; ! 288: ! 289: /* data imported from toplev.c */ ! 290: ! 291: extern char *dump_base_name; ! 292: ! 293: /* Open and close the file for outputting class declarations, if requested. */ ! 294: ! 295: int flag_gen_declaration = 0; ! 296: ! 297: FILE *gen_declaration_file; ! 298: ! 299: /* Warn if multiple methods are seen for the same selector, but with ! 300: different argument types. */ ! 301: ! 302: int warn_selector = 0; ! 303: ! 304: void ! 305: lang_init () ! 306: { ! 307: /* the beginning of the file is a new line; check for # */ ! 308: /* With luck, we discover the real source file's name from that ! 309: and put it in input_filename. */ ! 310: ungetc (check_newline (), finput); ! 311: ! 312: /* If gen_declaration desired, open the output file. */ ! 313: if (flag_gen_declaration) ! 314: { ! 315: int dump_base_name_length = strlen (dump_base_name); ! 316: register char *dumpname = (char *) xmalloc (dump_base_name_length + 7); ! 317: strcpy (dumpname, dump_base_name); ! 318: strcat (dumpname, ".decl"); ! 319: gen_declaration_file = fopen (dumpname, "w"); ! 320: if (gen_declaration_file == 0) ! 321: pfatal_with_name (dumpname); ! 322: } ! 323: ! 324: if (doing_objc_thang) ! 325: init_objc (); ! 326: } ! 327: ! 328: void ! 329: objc_finish () ! 330: { ! 331: if (doing_objc_thang) ! 332: finish_objc (); /* Objective-C finalization */ ! 333: ! 334: if (gen_declaration_file) ! 335: fclose (gen_declaration_file); ! 336: } ! 337: ! 338: void ! 339: lang_finish () ! 340: { ! 341: } ! 342: ! 343: int ! 344: lang_decode_option (p) ! 345: char *p; ! 346: { ! 347: if (!strcmp (p, "-lang-objc")) ! 348: doing_objc_thang = 1; ! 349: else if (!strcmp (p, "-gen-decls")) ! 350: flag_gen_declaration = 1; ! 351: else if (!strcmp (p, "-Wselector")) ! 352: warn_selector = 1; ! 353: else if (!strcmp (p, "-Wno-selector")) ! 354: warn_selector = 0; ! 355: else ! 356: return c_decode_option (p); ! 357: ! 358: return 1; ! 359: } ! 360: ! 361: static tree ! 362: define_decl (declarator, declspecs) ! 363: tree declarator; ! 364: tree declspecs; ! 365: { ! 366: tree decl = start_decl (declarator, declspecs, 0); ! 367: finish_decl (decl, NULLT, NULLT); ! 368: return decl; ! 369: } ! 370: ! 371: /* ! 372: * rules for statically typed objects...called from `c-typeck.comptypes'. ! 373: * ! 374: * an assignment of the form `a' = `b' is permitted if: ! 375: * ! 376: * - `a' is of type "id". ! 377: * - `a' and `b' are the same class type. ! 378: * - `a' and `b' are of class types A and B such that B is a descendant ! 379: * of A. ! 380: */ ! 381: ! 382: int ! 383: maybe_objc_comptypes (lhs, rhs) ! 384: tree lhs, rhs; ! 385: { ! 386: if (doing_objc_thang) ! 387: return objc_comptypes (lhs, rhs); ! 388: return 0; ! 389: } ! 390: ! 391: int ! 392: objc_comptypes (lhs, rhs) ! 393: tree lhs; ! 394: tree rhs; ! 395: { ! 396: /* `id' = `<class> *', `<class> *' = `id' */ ! 397: ! 398: if ((TYPE_NAME (lhs) == objc_object_id && TYPED_OBJECT (rhs)) ! 399: || (TYPED_OBJECT (lhs) && TYPE_NAME (rhs) == objc_object_id)) ! 400: return 1; ! 401: ! 402: /* `id' = `Class', `Class' = `id' */ ! 403: ! 404: ! 405: else if ((TYPE_NAME (lhs) == objc_object_id && ! 406: TYPE_NAME (rhs) == objc_class_id) || ! 407: (TYPE_NAME (lhs) == objc_class_id && ! 408: TYPE_NAME (rhs) == objc_object_id)) ! 409: return 1; ! 410: ! 411: /* `<class> *' = `<class> *' */ ! 412: ! 413: else if (TYPED_OBJECT (lhs) && TYPED_OBJECT (rhs)) ! 414: { ! 415: tree lname = TYPE_NAME (lhs), rname = TYPE_NAME (rhs); ! 416: ! 417: if (lname == rname) ! 418: return 1; ! 419: else ! 420: { ! 421: /* if the left hand side is a super class of the right hand side, ! 422: allow it... ! 423: */ ! 424: tree rinter = lookup_interface (rname); ! 425: ! 426: while (rinter) ! 427: { ! 428: if (lname == CLASS_SUPER_NAME (rinter)) ! 429: return 1; ! 430: ! 431: rinter = lookup_interface (CLASS_SUPER_NAME (rinter)); ! 432: } ! 433: ! 434: return 0; ! 435: } ! 436: } ! 437: else ! 438: return 0; ! 439: } ! 440: ! 441: /* Called from c-decl.c before all calls to rest_of_decl_compilation. */ ! 442: ! 443: void ! 444: maybe_objc_check_decl (decl) ! 445: tree decl; ! 446: { ! 447: if (doing_objc_thang) ! 448: objc_check_decl (decl); ! 449: } ! 450: ! 451: void ! 452: objc_check_decl (decl) ! 453: tree decl; ! 454: { ! 455: tree type = TREE_TYPE (decl); ! 456: static int alreadyWarned = 0; ! 457: ! 458: if (TREE_CODE (type) == RECORD_TYPE && TREE_STATIC_TEMPLATE (type)) ! 459: { ! 460: if (!alreadyWarned) ! 461: { ! 462: error ("GNU compiler does not support statically allocated objects"); ! 463: alreadyWarned = 1; ! 464: } ! 465: error_with_decl (decl, "`%s' cannot be statically allocated"); ! 466: } ! 467: } ! 468: ! 469: /* implement static typing. at this point, we know we have an interface... */ ! 470: ! 471: tree ! 472: get_static_reference (interface) ! 473: tree interface; ! 474: { ! 475: return xref_tag (RECORD_TYPE, CLASS_NAME (interface)); ! 476: } ! 477: ! 478: /* ! 479: * purpose: "play" parser, creating/installing representations ! 480: * of the declarations that are required by Objective-C. ! 481: * ! 482: * model: ! 483: * ! 484: * type_spec--------->sc_spec ! 485: * (tree_list) (tree_list) ! 486: * | | ! 487: * | | ! 488: * identifier_node identifier_node ! 489: */ ! 490: static void ! 491: synth_module_prologue () ! 492: { ! 493: tree sc_spec, type_spec, decl_specs, expr_decl, parms, record; ! 494: ! 495: /* defined in `objc.h' */ ! 496: objc_object_id = get_identifier (TAG_OBJECT); ! 497: ! 498: objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id); ! 499: ! 500: id_type = groktypename (build_tree_list ( ! 501: build_tree_list (NULLT, objc_object_reference), ! 502: build1 (INDIRECT_REF, NULLT, NULLT))); ! 503: ! 504: objc_class_id = get_identifier (TAG_CLASS); ! 505: ! 506: class_type = groktypename (build_tree_list ! 507: (build_tree_list ! 508: (NULLT, xref_tag (RECORD_TYPE, objc_class_id)), ! 509: build1 (INDIRECT_REF, NULLT, NULLT))); ! 510: ! 511: /* Declare SEL type before prototypes for objc_msgSend(), or else those ! 512: struct tags are considered local to the prototype and won't match the one ! 513: in <objc/objc-runtime.h>. */ ! 514: ! 515: #ifdef OBJC_INT_SELECTORS ! 516: /* `unsigned int' */ ! 517: _selector_type = unsigned_type_node; ! 518: #else ! 519: /* `struct objc_selector *' */ ! 520: _selector_type = groktypename (build_tree_list ( ! 521: build_tree_list (NULLT, ! 522: xref_tag (RECORD_TYPE, ! 523: get_identifier (TAG_SELECTOR))), ! 524: build1 (INDIRECT_REF, NULLT, NULLT))); ! 525: #endif /* not OBJC_INT_SELECTORS */ ! 526: ! 527: /* forward declare type...or else the prototype for `super' will bitch */ ! 528: groktypename (build_tree_list (build_tree_list (NULLT, ! 529: xref_tag (RECORD_TYPE, get_identifier (TAG_SUPER))), ! 530: build1 (INDIRECT_REF, NULLT, NULLT))); ! 531: ! 532: _msg_id = get_identifier ("objc_msgSend"); ! 533: _msgSuper_id = get_identifier ("objc_msgSendSuper"); ! 534: objc_getClass_id = get_identifier ("objc_getClass"); ! 535: objc_getMetaClass_id = get_identifier ("objc_getMetaClass"); ! 536: ! 537: /* struct objc_object *objc_msgSend (id, SEL, ...); */ ! 538: pushlevel (0); ! 539: decl_specs = build_tree_list (NULLT, objc_object_reference); ! 540: push_parm_decl (build_tree_list (decl_specs, ! 541: build1 (INDIRECT_REF, NULLT, NULLT))); ! 542: ! 543: #ifdef OBJC_INT_SELECTORS ! 544: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_UNSIGNED]); ! 545: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs); ! 546: expr_decl = NULLT; ! 547: #else ! 548: decl_specs = build_tree_list (NULLT, ! 549: xref_tag (RECORD_TYPE, ! 550: get_identifier (TAG_SELECTOR))); ! 551: expr_decl = build1 (INDIRECT_REF, NULLT, NULLT); ! 552: #endif /* not OBJC_INT_SELECTORS */ ! 553: ! 554: push_parm_decl (build_tree_list (decl_specs, expr_decl)); ! 555: parms = get_parm_info (0); ! 556: poplevel (0, 0, 0); ! 557: ! 558: decl_specs = build_tree_list (NULLT, objc_object_reference); ! 559: expr_decl = build_nt (CALL_EXPR, _msg_id, parms, NULLT); ! 560: expr_decl = build1 (INDIRECT_REF, NULLT, expr_decl); ! 561: ! 562: _msg_decl = define_decl (expr_decl, decl_specs); ! 563: ! 564: /* struct objc_object *objc_msgSendSuper (struct objc_super *, SEL, ...); */ ! 565: pushlevel (0); ! 566: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, ! 567: get_identifier (TAG_SUPER))); ! 568: push_parm_decl (build_tree_list (decl_specs, ! 569: build1 (INDIRECT_REF, NULLT, NULLT))); ! 570: ! 571: #ifdef OBJC_INT_SELECTORS ! 572: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_UNSIGNED]); ! 573: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs); ! 574: expr_decl = NULLT; ! 575: #else /* not OBJC_INT_SELECTORS */ ! 576: decl_specs = build_tree_list (NULLT, ! 577: xref_tag (RECORD_TYPE, ! 578: get_identifier (TAG_SELECTOR))); ! 579: expr_decl = build1 (INDIRECT_REF, NULLT, NULLT); ! 580: #endif /* not OBJC_INT_SELECTORS */ ! 581: ! 582: push_parm_decl (build_tree_list (decl_specs, expr_decl)); ! 583: parms = get_parm_info (0); ! 584: poplevel (0, 0, 0); ! 585: ! 586: decl_specs = build_tree_list (NULLT, objc_object_reference); ! 587: expr_decl = build_nt (CALL_EXPR, _msgSuper_id, parms, NULLT); ! 588: expr_decl = build1 (INDIRECT_REF, NULLT, expr_decl); ! 589: ! 590: _msgSuper_decl = define_decl (expr_decl, decl_specs); ! 591: ! 592: /* id objc_getClass (); */ ! 593: parms = build_tree_list (NULLT, NULLT); ! 594: expr_decl = build_nt (CALL_EXPR, objc_getClass_id, parms, NULLT); ! 595: expr_decl = build1 (INDIRECT_REF, NULLT, expr_decl); ! 596: ! 597: objc_getClass_decl = define_decl (expr_decl, decl_specs); ! 598: ! 599: /* id objc_getMetaClass (); */ ! 600: parms = build_tree_list (NULLT, NULLT); ! 601: expr_decl = build_nt (CALL_EXPR, objc_getMetaClass_id, parms, NULLT); ! 602: expr_decl = build1 (INDIRECT_REF, NULLT, expr_decl); ! 603: ! 604: objc_getMetaClass_decl = define_decl (expr_decl, decl_specs); ! 605: ! 606: #ifdef OBJC_NONUNIQUE_SELECTORS ! 607: _OBJC_SELECTOR_REFERENCES_id = get_identifier ("_OBJC_SELECTOR_REFERENCES"); ! 608: ! 609: /* extern SEL _OBJC_SELECTOR_REFERENCES[]; */ ! 610: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_EXTERN], NULLT); ! 611: ! 612: #ifdef OBJC_INT_SELECTORS ! 613: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_UNSIGNED], sc_spec); ! 614: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs); ! 615: expr_decl = _OBJC_SELECTOR_REFERENCES_id; ! 616: #else /* not OBJC_INT_SELECTORS */ ! 617: decl_specs = build_tree_list (NULLT, ! 618: xref_tag (RECORD_TYPE, ! 619: get_identifier (TAG_SELECTOR))); ! 620: expr_decl = build1 (INDIRECT_REF, NULLT, _OBJC_SELECTOR_REFERENCES_id); ! 621: #endif /* not OBJC_INT_SELECTORS */ ! 622: ! 623: expr_decl = build_nt (ARRAY_REF, expr_decl, NULLT); ! 624: _OBJC_SELECTOR_REFERENCES_decl = define_decl (expr_decl, decl_specs); ! 625: #endif ! 626: } ! 627: ! 628: /* ! 629: * custom "build_string ()" which sets TREE_TYPE! ! 630: */ ! 631: static tree ! 632: my_build_string (len, str) ! 633: int len; ! 634: char *str; ! 635: { ! 636: int wide_flag = 0; ! 637: tree aString = build_string (len, str); ! 638: /* ! 639: * some code from "combine_strings ()", which is local to c-parse.y. ! 640: */ ! 641: if (TREE_TYPE (aString) == int_array_type_node) ! 642: wide_flag = 1; ! 643: ! 644: TREE_TYPE (aString) = ! 645: build_array_type (wide_flag ? integer_type_node : char_type_node, ! 646: build_index_type (build_int_2 (len - 1, 0))); ! 647: ! 648: TREE_CONSTANT (aString) = 1; /* puts string in the ".text" segment */ ! 649: TREE_STATIC (aString) = 1; ! 650: ! 651: return aString; ! 652: } ! 653: ! 654: /* ! 655: * struct objc_symtab { ! 656: * long sel_ref_cnt; ! 657: * char *refs; ! 658: * long cls_def_cnt; ! 659: * long cat_def_cnt; ! 660: * void *defs[cls_def_cnt + cat_def_cnt]; ! 661: * }; ! 662: */ ! 663: static void ! 664: build_objc_symtab_template () ! 665: { ! 666: tree decl_specs, field_decl, field_decl_chain; ! 667: ! 668: objc_symtab_template = start_struct (RECORD_TYPE, get_identifier (_TAG_SYMTAB)); ! 669: ! 670: /* long sel_ref_cnt; */ ! 671: ! 672: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]); ! 673: field_decl = get_identifier ("sel_ref_cnt"); ! 674: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 675: field_decl_chain = field_decl; ! 676: ! 677: #ifdef OBJC_INT_SELECTORS ! 678: /* unsigned int *sel_ref; */ ! 679: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_UNSIGNED]); ! 680: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs); ! 681: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("refs")); ! 682: #else /* not OBJC_INT_SELECTORS */ ! 683: /* struct objc_selector **sel_ref; */ ! 684: decl_specs = build_tree_list (NULLT, ! 685: xref_tag (RECORD_TYPE, ! 686: get_identifier (TAG_SELECTOR))); ! 687: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("refs")); ! 688: field_decl = build1 (INDIRECT_REF, NULLT, field_decl); ! 689: #endif /* not OBJC_INT_SELECTORS */ ! 690: ! 691: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 692: chainon (field_decl_chain, field_decl); ! 693: ! 694: /* short cls_def_cnt; */ ! 695: ! 696: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_SHORT]); ! 697: field_decl = get_identifier ("cls_def_cnt"); ! 698: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 699: chainon (field_decl_chain, field_decl); ! 700: ! 701: /* short cat_def_cnt; */ ! 702: ! 703: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_SHORT]); ! 704: field_decl = get_identifier ("cat_def_cnt"); ! 705: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 706: chainon (field_decl_chain, field_decl); ! 707: ! 708: /* void *defs[cls_def_cnt + cat_def_cnt]; */ ! 709: ! 710: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_VOID]); ! 711: field_decl = build_nt (ARRAY_REF, get_identifier ("defs"), ! 712: build_int_2 (imp_count + cat_count, 0)); ! 713: field_decl = build1 (INDIRECT_REF, NULLT, field_decl); ! 714: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 715: chainon (field_decl_chain, field_decl); ! 716: ! 717: finish_struct (objc_symtab_template, field_decl_chain); ! 718: } ! 719: ! 720: static tree ! 721: init_def_list () ! 722: { ! 723: tree expr, initlist = NULLT; ! 724: struct imp_entry *impent; ! 725: ! 726: if (imp_count) ! 727: for (impent = imp_list; impent; impent = impent->next) ! 728: { ! 729: if (TREE_CODE (impent->imp_context) == IMPLEMENTATION_TYPE) ! 730: { ! 731: expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0); ! 732: initlist = tree_cons (NULLT, expr, initlist); ! 733: } ! 734: } ! 735: ! 736: if (cat_count) ! 737: for (impent = imp_list; impent; impent = impent->next) ! 738: { ! 739: if (TREE_CODE (impent->imp_context) == CATEGORY_TYPE) ! 740: { ! 741: expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0); ! 742: initlist = tree_cons (NULLT, expr, initlist); ! 743: } ! 744: } ! 745: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)); ! 746: } ! 747: ! 748: /* ! 749: * struct objc_symtab { ! 750: * long sel_ref_cnt; ! 751: * char *refs; ! 752: * long cls_def_cnt; ! 753: * long cat_def_cnt; ! 754: * void *defs[cls_def_cnt + cat_def_cnt]; ! 755: * }; ! 756: */ ! 757: static tree ! 758: init_objc_symtab () ! 759: { ! 760: tree initlist; ! 761: ! 762: /* sel_ref_cnt = { ..., 5, ... } */ ! 763: ! 764: if (sel_ref_chain) ! 765: initlist = build_tree_list (NULLT, build_int_2 (max_selector_index, 0)); ! 766: else ! 767: initlist = build_tree_list (NULLT, build_int_2 (0, 0)); ! 768: ! 769: /* refs = { ..., _OBJC_SELECTOR_REFERENCES, ... } */ ! 770: ! 771: #ifndef OBJC_NONUNIQUE_SELECTORS ! 772: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist); ! 773: #else ! 774: if (sel_ref_chain) ! 775: initlist = tree_cons (NULLT, _OBJC_SELECTOR_REFERENCES_decl, initlist); ! 776: else ! 777: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist); ! 778: #endif ! 779: ! 780: /* cls_def_cnt = { ..., 5, ... } */ ! 781: ! 782: initlist = tree_cons (NULLT, build_int_2 (imp_count, 0), initlist); ! 783: ! 784: /* cat_def_cnt = { ..., 5, ... } */ ! 785: ! 786: initlist = tree_cons (NULLT, build_int_2 (cat_count, 0), initlist); ! 787: ! 788: /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */ ! 789: ! 790: if (imp_count || cat_count) ! 791: initlist = tree_cons (NULLT, init_def_list (), initlist); ! 792: ! 793: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)); ! 794: } ! 795: ! 796: static void ! 797: forward_declare_categories () ! 798: { ! 799: struct imp_entry *impent; ! 800: tree sav = implementation_context; ! 801: for (impent = imp_list; impent; impent = impent->next) ! 802: { ! 803: if (TREE_CODE (impent->imp_context) == CATEGORY_TYPE) ! 804: { ! 805: tree sc_spec, decl_specs, decl; ! 806: ! 807: sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_EXTERN]); ! 808: decl_specs = tree_cons (NULLT, objc_category_template, sc_spec); ! 809: ! 810: implementation_context = impent->imp_context; ! 811: impent->class_decl = define_decl ( ! 812: synth_id_with_class_suffix ("_OBJC_CATEGORY"), ! 813: decl_specs); ! 814: } ! 815: } ! 816: implementation_context = sav; ! 817: } ! 818: ! 819: static void ! 820: generate_objc_symtab_decl () ! 821: { ! 822: tree sc_spec; ! 823: ! 824: if (!objc_category_template) ! 825: build_category_template (); ! 826: ! 827: /* forward declare categories */ ! 828: if (cat_count) ! 829: forward_declare_categories (); ! 830: ! 831: if (!objc_symtab_template) ! 832: build_objc_symtab_template (); ! 833: ! 834: sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_STATIC]); ! 835: ! 836: _OBJC_SYMBOLS_decl = start_decl (get_identifier ("_OBJC_SYMBOLS"), ! 837: tree_cons (NULLT, objc_symtab_template, sc_spec), 1); ! 838: ! 839: finish_decl (_OBJC_SYMBOLS_decl, init_objc_symtab (), NULLT); ! 840: } ! 841: ! 842: /* ! 843: * tree_node------->tree_node----->... ! 844: * | | ! 845: * | (value) | (value) ! 846: * | | ! 847: * expr expr ! 848: */ ! 849: static tree ! 850: init_module_descriptor () ! 851: { ! 852: tree initlist, expr; ! 853: ! 854: /* version = { 1, ... } */ ! 855: ! 856: expr = build_int_2 (OBJC_VERSION, 0); ! 857: initlist = build_tree_list (NULLT, expr); ! 858: ! 859: /* size = { ..., sizeof (struct objc_module), ... } */ ! 860: ! 861: expr = build_int_2 (TREE_INT_CST_LOW (TYPE_SIZE (objc_module_template)) / ! 862: BITS_PER_UNIT, 0); ! 863: initlist = tree_cons (NULLT, expr, initlist); ! 864: ! 865: /* name = { ..., "foo.m", ... } */ ! 866: ! 867: expr = build_msg_pool_reference ( ! 868: add_objc_string (get_identifier (input_filename))); ! 869: initlist = tree_cons (NULLT, expr, initlist); ! 870: ! 871: /* symtab = { ..., _OBJC_SYMBOLS, ... } */ ! 872: ! 873: if (_OBJC_SYMBOLS_decl) ! 874: expr = build_unary_op (ADDR_EXPR, _OBJC_SYMBOLS_decl, 0); ! 875: else ! 876: expr = build_int_2 (0, 0); ! 877: initlist = tree_cons (NULLT, expr, initlist); ! 878: ! 879: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)); ! 880: } ! 881: ! 882: /* Write out the data structures to describe Objective C classes defined. ! 883: If appropriate, compile and output a setup function to initialize them. ! 884: Return a string which is the name of a function to call to initialize ! 885: the Objective C data structures for this file (and perhaps for other files ! 886: also). */ ! 887: ! 888: static char * ! 889: build_module_descriptor () ! 890: { ! 891: tree decl_specs, field_decl, field_decl_chain; ! 892: ! 893: objc_module_template = start_struct (RECORD_TYPE, get_identifier (_TAG_MODULE)); ! 894: ! 895: /* long version; */ ! 896: ! 897: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]); ! 898: field_decl = get_identifier ("version"); ! 899: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 900: field_decl_chain = field_decl; ! 901: ! 902: /* long size; */ ! 903: ! 904: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]); ! 905: field_decl = get_identifier ("size"); ! 906: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 907: chainon (field_decl_chain, field_decl); ! 908: ! 909: /* char *name; */ ! 910: ! 911: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]); ! 912: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("name")); ! 913: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 914: chainon (field_decl_chain, field_decl); ! 915: ! 916: /* struct objc_symtab *symtab; */ ! 917: ! 918: decl_specs = get_identifier (_TAG_SYMTAB); ! 919: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, decl_specs)); ! 920: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("symtab")); ! 921: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 922: chainon (field_decl_chain, field_decl); ! 923: ! 924: finish_struct (objc_module_template, field_decl_chain); ! 925: ! 926: /* create an instance of "objc_module" */ ! 927: ! 928: decl_specs = tree_cons (NULLT, objc_module_template, ! 929: build_tree_list (NULLT, ridpointers[(int) RID_STATIC])); ! 930: ! 931: _OBJC_MODULES_decl = start_decl (get_identifier ("_OBJC_MODULES"), ! 932: decl_specs, 1); ! 933: ! 934: finish_decl (_OBJC_MODULES_decl, init_module_descriptor (), NULLT); ! 935: ! 936: /* Mark the decl as used to avoid "defined but not used" warning. */ ! 937: TREE_USED (_OBJC_MODULES_decl) = 1; ! 938: ! 939: /* Generate a constructor call for the module descriptor. ! 940: This code was generated by reading the grammar rules ! 941: of c-parse.y; Therefore, it may not be the most efficient ! 942: way of generating the requisite code. */ ! 943: #ifndef NEXT_OBJC_RUNTIME ! 944: { ! 945: tree parms, function_decl, decelerator, void_list_node; ! 946: tree function_type; ! 947: char *buf; ! 948: char *global_object_name = 0; ! 949: tree t; ! 950: ! 951: /* Use a global object (which is already required to be unique over ! 952: the program) rather than the file name (which imposes extra ! 953: constraints). -- [email protected], 10 Jan 1990. */ ! 954: ! 955: /* Find the name of some global object defined in this file. */ ! 956: for (t = getdecls (); t; t = TREE_CHAIN (t)) ! 957: if (TREE_PUBLIC (t) && !TREE_EXTERNAL (t) && DECL_INITIAL (t) != 0) ! 958: { ! 959: global_object_name = IDENTIFIER_POINTER (DECL_NAME (t)); ! 960: break; ! 961: } ! 962: ! 963: /* If none, use the name of the file. */ ! 964: if (!global_object_name) ! 965: { ! 966: char *p, *q; ! 967: global_object_name ! 968: = (char *) alloca (strlen (main_input_filename) + 1); ! 969: ! 970: p = main_input_filename; ! 971: q = global_object_name; ! 972: ! 973: /* Replace any weird characters in the file name. */ ! 974: for (; *p; p++) ! 975: if (! ((*p >= '0' && *p <= '9') ! 976: || (*p >= 'A' && *p <= 'Z') ! 977: || (*p >= 'a' && *p <= 'z'))) ! 978: *q++ = '_'; ! 979: else ! 980: *q++ = *p; ! 981: *q = 0; ! 982: } ! 983: ! 984: /* Make the constructor name from the name we have found. */ ! 985: buf = (char *) xmalloc (sizeof (CONSTRUCTOR_NAME_FORMAT) ! 986: + strlen (global_object_name)); ! 987: sprintf (buf, CONSTRUCTOR_NAME_FORMAT, global_object_name); ! 988: ! 989: /* Declare void __objc_execClass (void*); */ ! 990: ! 991: void_list_node = build_tree_list (NULL_TREE, void_type_node); ! 992: function_type ! 993: = build_function_type (void_type_node, ! 994: tree_cons (NULL_TREE, ptr_type_node, ! 995: void_list_node)); ! 996: function_decl = build_decl (FUNCTION_DECL, ! 997: get_identifier ("__objc_execClass"), ! 998: function_type); ! 999: TREE_EXTERNAL (function_decl) = 1; ! 1000: TREE_PUBLIC (function_decl) = 1; ! 1001: pushdecl (function_decl); ! 1002: rest_of_decl_compilation (function_decl, 0, 0, 0); ! 1003: ! 1004: parms ! 1005: = build_tree_list (NULLT, ! 1006: build_unary_op (ADDR_EXPR, _OBJC_MODULES_decl, 0)); ! 1007: decelerator = build_function_call (function_decl, parms); ! 1008: ! 1009: /* void __objc_file_init () {objc_execClass(&L_OBJC_MODULES);} */ ! 1010: ! 1011: start_function (void_list_node, ! 1012: build_parse_node (CALL_EXPR, get_identifier (buf), ! 1013: /* This has the format of the output ! 1014: of get_parm_info. */ ! 1015: tree_cons (NULL_TREE, NULL_TREE, ! 1016: void_list_node), ! 1017: NULL_TREE), ! 1018: 0, 0); ! 1019: #if 0 /* This should be turned back on later ! 1020: for the systems where collect is not needed. */ ! 1021: /* Make these functions nonglobal ! 1022: so each file can use the same name. */ ! 1023: TREE_PUBLIC (current_function_decl) = 0; ! 1024: #endif ! 1025: TREE_USED (current_function_decl) = 1; ! 1026: store_parm_decls (); ! 1027: ! 1028: assemble_external (function_decl); ! 1029: c_expand_expr_stmt (decelerator); ! 1030: ! 1031: finish_function (0); ! 1032: ! 1033: /* Return the name of the constructor function. */ ! 1034: return buf; ! 1035: } ! 1036: #else /* NEXT_OBJC_RUNTIME */ ! 1037: return 0; ! 1038: #endif /* NEXT_OBJC_RUNTIME */ ! 1039: } ! 1040: ! 1041: /* extern const char _OBJC_STRINGS[]; */ ! 1042: ! 1043: static void ! 1044: generate_forward_declaration_to_string_table () ! 1045: { ! 1046: tree sc_spec, decl_specs, expr_decl; ! 1047: ! 1048: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_EXTERN], NULLT); ! 1049: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_CHAR], sc_spec); ! 1050: ! 1051: expr_decl = build_nt (ARRAY_REF, get_identifier ("_OBJC_STRINGS"), NULLT); ! 1052: ! 1053: _OBJC_STRINGS_decl = define_decl (expr_decl, decl_specs); ! 1054: } ! 1055: ! 1056: /* static char _OBJC_STRINGS[] = "..."; */ ! 1057: ! 1058: static void ! 1059: build_message_selector_pool () ! 1060: { ! 1061: tree sc_spec, decl_specs, expr_decl; ! 1062: tree chain, string_expr; ! 1063: int goolengthtmp = 0, msg_pool_size = 0; ! 1064: char *string_goo; ! 1065: ! 1066: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT); ! 1067: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_CHAR], sc_spec); ! 1068: ! 1069: expr_decl = build_nt (ARRAY_REF, get_identifier ("_OBJC_STRINGS"), NULLT); ! 1070: ! 1071: _OBJC_STRINGS_decl = start_decl (expr_decl, decl_specs, 1); ! 1072: ! 1073: for (chain = sel_refdef_chain; chain; chain = TREE_CHAIN (chain)) ! 1074: msg_pool_size += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1; ! 1075: ! 1076: msg_pool_size++; ! 1077: ! 1078: string_goo = (char *)xmalloc (msg_pool_size); ! 1079: bzero (string_goo, msg_pool_size); ! 1080: ! 1081: for (chain = sel_refdef_chain; chain; chain = TREE_CHAIN (chain)) ! 1082: { ! 1083: strcpy (string_goo + goolengthtmp, IDENTIFIER_POINTER (TREE_VALUE (chain))); ! 1084: goolengthtmp += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1; ! 1085: } ! 1086: ! 1087: string_expr = my_build_string (msg_pool_size, string_goo); ! 1088: ! 1089: finish_decl (_OBJC_STRINGS_decl, string_expr, NULLT); ! 1090: } ! 1091: ! 1092: /* ! 1093: * synthesize the following expr: (char *)&_OBJC_STRINGS[<offset>] ! 1094: * ! 1095: * the cast stops the compiler from issuing the following message: ! 1096: * ! 1097: * grok.m: warning: initialization of non-const * pointer from const * ! 1098: * grok.m: warning: initialization between incompatible pointer types ! 1099: */ ! 1100: static tree ! 1101: build_msg_pool_reference (offset) ! 1102: int offset; ! 1103: { ! 1104: tree expr = build_int_2 (offset, 0); ! 1105: tree cast; ! 1106: ! 1107: expr = build_array_ref (_OBJC_STRINGS_decl, expr); ! 1108: expr = build_unary_op (ADDR_EXPR, expr, 0); ! 1109: ! 1110: cast = build_tree_list (build_tree_list (NULLT, ridpointers[(int) RID_CHAR]), ! 1111: build1 (INDIRECT_REF, NULLT, NULLT)); ! 1112: TREE_TYPE (expr) = groktypename (cast); ! 1113: return expr; ! 1114: } ! 1115: ! 1116: #ifndef OBJC_NONUNIQUE_SELECTORS ! 1117: static tree ! 1118: build_selector_reference (idx) ! 1119: int idx; ! 1120: { ! 1121: tree ref, decl, name, ident; ! 1122: char buf[256]; ! 1123: struct obstack *save_current_obstack = current_obstack; ! 1124: struct obstack *save_rtl_obstack = rtl_obstack; ! 1125: ! 1126: sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", idx); ! 1127: ! 1128: /* new stuff */ ! 1129: rtl_obstack = current_obstack = &permanent_obstack; ! 1130: ident = get_identifier (buf); ! 1131: ! 1132: if (IDENTIFIER_GLOBAL_VALUE (ident)) ! 1133: decl = IDENTIFIER_GLOBAL_VALUE (ident); /* set by pushdecl() */ ! 1134: else ! 1135: { ! 1136: decl = build_decl (VAR_DECL, ident, _selector_type); ! 1137: TREE_EXTERNAL (decl) = 1; ! 1138: TREE_PUBLIC (decl) = 1; ! 1139: TREE_USED (decl) = 1; ! 1140: ! 1141: make_decl_rtl (decl, 0, 1); /* usually called from `rest_of_decl_compilation' */ ! 1142: pushdecl_top_level (decl); /* our `extended/custom' pushdecl in c-decl.c */ ! 1143: } ! 1144: current_obstack = save_current_obstack; ! 1145: rtl_obstack = save_rtl_obstack; ! 1146: ! 1147: return decl; ! 1148: } ! 1149: #endif ! 1150: ! 1151: static tree ! 1152: init_selector (offset) ! 1153: int offset; ! 1154: { ! 1155: tree expr = build_msg_pool_reference (offset); ! 1156: TREE_TYPE (expr) = _selector_type; /* cast */ ! 1157: return expr; ! 1158: } ! 1159: ! 1160: static void ! 1161: build_selector_translation_table () ! 1162: { ! 1163: tree sc_spec, decl_specs, expr_decl; ! 1164: tree chain, initlist = NULLT; ! 1165: int offset = 0; ! 1166: #ifndef OBJC_NONUNIQUE_SELECTORS ! 1167: tree decl, var_decl; ! 1168: int idx = 0; ! 1169: char buf[256]; ! 1170: #else/ ! 1171: ! 1172: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT); ! 1173: ! 1174: #ifdef OBJC_INT_SELECTORS ! 1175: /* static unsigned int _OBJC_SELECTOR_REFERENCES[] = { 1, 2, ... }; */ ! 1176: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_UNSIGNED], sc_spec); ! 1177: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs); ! 1178: expr_decl = _OBJC_SELECTOR_REFERENCES_id; ! 1179: #else /* not OBJC_INT_SELECTORS */ ! 1180: /* static struct objc_selector *_OBJC_SELECTOR_REFERENCES[] = { 1, 2, .}; */ ! 1181: decl_specs = build_tree_list (NULLT, ! 1182: xref_tag (RECORD_TYPE, ! 1183: get_identifier (TAG_SELECTOR))); ! 1184: expr_decl = build1 (INDIRECT_REF, NULLT, _OBJC_SELECTOR_REFERENCES_id); ! 1185: #endif /* not OBJC_INT_SELECTORS */ ! 1186: ! 1187: expr_decl = build_nt (ARRAY_REF, expr_decl, NULLT); ! 1188: _OBJC_SELECTOR_REFERENCES_decl = start_decl (expr_decl, decl_specs, 1); ! 1189: #endif ! 1190: ! 1191: for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain)) ! 1192: { ! 1193: tree expr; ! 1194: ! 1195: #ifndef OBJC_NONUNIQUE_SELECTORS ! 1196: sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", idx); ! 1197: sc_spec = build_tree_list (NULLT, ridpointers[RID_STATIC]); ! 1198: ! 1199: #ifdef OBJC_INT_SELECTORS ! 1200: /* static unsigned int _OBJC_SELECTOR_REFERENCES_n = ...; */ ! 1201: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_UNSIGNED], sc_spec); ! 1202: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs); ! 1203: var_decl = get_identifier (buf); ! 1204: #else /* not OBJC_INT_SELECTORS */ ! 1205: /* static struct objc_selector *_OBJC_SELECTOR_REFERENCES_n = ...; */ ! 1206: decl_specs = tree_cons (NULLT, ! 1207: xref_tag (RECORD_TYPE, ! 1208: get_identifier (TAG_SELECTOR)), ! 1209: sc_spec); ! 1210: var_decl = build1 (INDIRECT_REF, NULLT, get_identifier (buf)); ! 1211: #endif /* not OBJC_INT_SELECTORS */ ! 1212: ! 1213: /* the `decl' that is returned from start_decl is the one that we ! 1214: * forward declared in `build_selector_reference()' ! 1215: */ ! 1216: decl = start_decl (var_decl, decl_specs, 1); ! 1217: #endif ! 1218: ! 1219: expr = init_selector (offset); ! 1220: ! 1221: /* add one for the '\0' character */ ! 1222: offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1; ! 1223: ! 1224: #ifndef OBJC_NONUNIQUE_SELECTORS ! 1225: finish_decl (decl, expr, NULLT); ! 1226: idx++; ! 1227: #else ! 1228: initlist = tree_cons (NULLT, expr, initlist); ! 1229: #endif ! 1230: } ! 1231: ! 1232: #ifdef OBJC_NONUNIQUE_SELECTORS ! 1233: initlist = build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)); ! 1234: finish_decl (_OBJC_SELECTOR_REFERENCES_decl, initlist, NULLT); ! 1235: #endif ! 1236: } ! 1237: ! 1238: static void ! 1239: add_class_reference (ident) ! 1240: tree ident; ! 1241: { ! 1242: tree chain; ! 1243: ! 1244: if (chain = cls_ref_chain) ! 1245: { ! 1246: tree tail; ! 1247: do ! 1248: { ! 1249: if (ident == TREE_VALUE (chain)) ! 1250: return; ! 1251: ! 1252: tail = chain; ! 1253: chain = TREE_CHAIN (chain); ! 1254: } ! 1255: while (chain); ! 1256: ! 1257: /* append to the end of the list */ ! 1258: TREE_CHAIN (tail) = perm_tree_cons (NULLT, ident, NULLT); ! 1259: } ! 1260: else ! 1261: cls_ref_chain = perm_tree_cons (NULLT, ident, NULLT); ! 1262: } ! 1263: ! 1264: /* ! 1265: * sel_ref_chain is a list whose "value" fields will be instances of ! 1266: * identifier_node that represent the selector. ! 1267: */ ! 1268: static int ! 1269: add_selector_reference (ident) ! 1270: tree ident; ! 1271: { ! 1272: tree chain; ! 1273: int index = 0; ! 1274: ! 1275: /* this adds it to sel_refdef_chain, the global pool of selectors */ ! 1276: add_objc_string (ident); ! 1277: ! 1278: if (chain = sel_ref_chain) ! 1279: { ! 1280: tree tail; ! 1281: do ! 1282: { ! 1283: if (ident == TREE_VALUE (chain)) ! 1284: return index; ! 1285: ! 1286: index++; ! 1287: tail = chain; ! 1288: chain = TREE_CHAIN (chain); ! 1289: } ! 1290: while (chain); ! 1291: ! 1292: /* append to the end of the list */ ! 1293: TREE_CHAIN (tail) = perm_tree_cons (NULLT, ident, NULLT); ! 1294: } ! 1295: else ! 1296: sel_ref_chain = perm_tree_cons (NULLT, ident, NULLT); ! 1297: ! 1298: max_selector_index++; ! 1299: return index; ! 1300: } ! 1301: ! 1302: /* ! 1303: * sel_refdef_chain is a list whose "value" fields will be instances of ! 1304: * identifier_node that represent the selector. It returns the offset of ! 1305: * the selector from the beginning of the _OBJC_STRINGS pool. This offset ! 1306: * is typically used by "init_selector ()" during code generation. ! 1307: */ ! 1308: static int ! 1309: add_objc_string (ident) ! 1310: tree ident; ! 1311: { ! 1312: tree chain; ! 1313: int offset = 0; ! 1314: ! 1315: if (chain = sel_refdef_chain) ! 1316: { ! 1317: tree tail; ! 1318: do ! 1319: { ! 1320: if (ident == TREE_VALUE (chain)) ! 1321: return offset; ! 1322: ! 1323: /* add one for the '\0' character */ ! 1324: offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1; ! 1325: tail = chain; ! 1326: chain = TREE_CHAIN (chain); ! 1327: } ! 1328: while (chain); ! 1329: ! 1330: /* append to the end of the list */ ! 1331: TREE_CHAIN (tail) = perm_tree_cons (NULLT, ident, NULLT); ! 1332: } ! 1333: else ! 1334: sel_refdef_chain = perm_tree_cons (NULLT, ident, NULLT); ! 1335: ! 1336: return offset; ! 1337: } ! 1338: ! 1339: tree ! 1340: lookup_interface (ident) ! 1341: tree ident; ! 1342: { ! 1343: tree chain; ! 1344: ! 1345: for (chain = interface_chain; chain; chain = TREE_CHAIN (chain)) ! 1346: { ! 1347: if (ident == CLASS_NAME (chain)) ! 1348: return chain; ! 1349: } ! 1350: return NULLT; ! 1351: } ! 1352: ! 1353: static tree ! 1354: objc_copy_list (list, head) ! 1355: tree list; ! 1356: tree *head; ! 1357: { ! 1358: tree newlist = NULL_TREE, tail = NULL_TREE; ! 1359: ! 1360: while (list) ! 1361: { ! 1362: tail = copy_node (list); ! 1363: ! 1364: /* the following statement fixes a bug when inheriting instance ! 1365: variables that are declared to be bitfields. finish_struct () expects ! 1366: to find the width of the bitfield in DECL_INITIAL (), which it ! 1367: nulls out after processing the decl of the super class...rather ! 1368: than change the way finish_struct () works (which is risky), ! 1369: I create the situation it expects...s.naroff (7/23/89). ! 1370: */ ! 1371: if (DECL_BIT_FIELD (tail) && DECL_INITIAL (tail) == 0) ! 1372: DECL_INITIAL (tail) = build_int_2 (DECL_FRAME_SIZE (tail), 0); ! 1373: ! 1374: newlist = chainon (newlist, tail); ! 1375: list = TREE_CHAIN (list); ! 1376: } ! 1377: *head = newlist; ! 1378: return tail; ! 1379: } ! 1380: ! 1381: /* used by: ! 1382: * build_private_template (), get_class_ivars (), and get_static_reference (). ! 1383: */ ! 1384: static tree ! 1385: build_ivar_chain (interface) ! 1386: tree interface; ! 1387: { ! 1388: tree my_name, super_name, ivar_chain; ! 1389: ! 1390: my_name = CLASS_NAME (interface); ! 1391: super_name = CLASS_SUPER_NAME (interface); ! 1392: ! 1393: /* "leaf" ivars never get copied...there is no reason to. */ ! 1394: ivar_chain = CLASS_IVARS (interface); ! 1395: ! 1396: while (super_name) ! 1397: { ! 1398: tree op1; ! 1399: tree super_interface = lookup_interface (super_name); ! 1400: ! 1401: if (!super_interface) ! 1402: { ! 1403: /* fatal did not work with 2 args...should fix */ ! 1404: error ("Cannot find interface declaration for `%s', superclass of `%s'", ! 1405: IDENTIFIER_POINTER (super_name), IDENTIFIER_POINTER (my_name)); ! 1406: exit (34); ! 1407: } ! 1408: if (super_interface == interface) ! 1409: { ! 1410: fatal ("Circular inheritance in interface declaration for `%s'", ! 1411: IDENTIFIER_POINTER (super_name)); ! 1412: } ! 1413: interface = super_interface; ! 1414: my_name = CLASS_NAME (interface); ! 1415: super_name = CLASS_SUPER_NAME (interface); ! 1416: ! 1417: op1 = CLASS_IVARS (interface); ! 1418: if (op1) ! 1419: { ! 1420: tree head, tail = objc_copy_list (op1, &head); ! 1421: ! 1422: /* prepend super class ivars...make a copy of the list, we ! 1423: * do not want to alter the original. ! 1424: */ ! 1425: TREE_CHAIN (tail) = ivar_chain; ! 1426: ivar_chain = head; ! 1427: } ! 1428: } ! 1429: return ivar_chain; ! 1430: } ! 1431: ! 1432: /* ! 1433: * struct <classname> { ! 1434: * struct objc_class *isa; ! 1435: * ... ! 1436: * }; ! 1437: */ ! 1438: static tree ! 1439: build_private_template (class) ! 1440: tree class; ! 1441: { ! 1442: tree ivar_context; ! 1443: ! 1444: if (CLASS_STATIC_TEMPLATE (class)) ! 1445: { ! 1446: _PRIVATE_record = CLASS_STATIC_TEMPLATE (class); ! 1447: ivar_context = TYPE_FIELDS (CLASS_STATIC_TEMPLATE (class)); ! 1448: } ! 1449: else ! 1450: { ! 1451: _PRIVATE_record = start_struct (RECORD_TYPE, CLASS_NAME (class)); ! 1452: ! 1453: ivar_context = build_ivar_chain (class); ! 1454: ! 1455: finish_struct (_PRIVATE_record, ivar_context); ! 1456: ! 1457: CLASS_STATIC_TEMPLATE (class) = _PRIVATE_record; ! 1458: ! 1459: /* mark this record as class template - for class type checking */ ! 1460: TREE_STATIC_TEMPLATE (_PRIVATE_record) = 1; ! 1461: } ! 1462: instance_type = groktypename ( ! 1463: build_tree_list (build_tree_list (NULLT, _PRIVATE_record), ! 1464: build1 (INDIRECT_REF, NULLT, NULLT))); ! 1465: return ivar_context; ! 1466: } ! 1467: ! 1468: /* ! 1469: * struct objc_category { ! 1470: * char *category_name; ! 1471: * char *class_name; ! 1472: * struct objc_method_list *instance_methods; ! 1473: * struct objc_method_list *class_methods; ! 1474: * }; ! 1475: */ ! 1476: static void ! 1477: build_category_template () ! 1478: { ! 1479: tree decl_specs, field_decl, field_decl_chain; ! 1480: ! 1481: objc_category_template = start_struct (RECORD_TYPE, ! 1482: get_identifier (_TAG_CATEGORY)); ! 1483: /* char *category_name; */ ! 1484: ! 1485: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]); ! 1486: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("category_name")); ! 1487: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1488: field_decl_chain = field_decl; ! 1489: ! 1490: /* char *class_name; */ ! 1491: ! 1492: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]); ! 1493: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("class_name")); ! 1494: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1495: chainon (field_decl_chain, field_decl); ! 1496: ! 1497: /* struct objc_method_list *instance_methods; */ ! 1498: ! 1499: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, ! 1500: get_identifier (_TAG_METHOD_LIST))); ! 1501: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("instance_methods")); ! 1502: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1503: chainon (field_decl_chain, field_decl); ! 1504: ! 1505: /* struct objc_method_list *class_methods; */ ! 1506: ! 1507: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, ! 1508: get_identifier (_TAG_METHOD_LIST))); ! 1509: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("class_methods")); ! 1510: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1511: chainon (field_decl_chain, field_decl); ! 1512: ! 1513: finish_struct (objc_category_template, field_decl_chain); ! 1514: } ! 1515: ! 1516: /* ! 1517: * struct objc_class { ! 1518: * struct objc_class *isa; ! 1519: * struct objc_class *super_class; ! 1520: * char *name; ! 1521: * long version; ! 1522: * long info; ! 1523: * long instance_size; ! 1524: * struct objc_ivar_list *ivars; ! 1525: * struct objc_method_list *methods; ! 1526: * struct objc_cache *cache; ! 1527: * }; ! 1528: */ ! 1529: static void ! 1530: build_class_template () ! 1531: { ! 1532: tree decl_specs, field_decl, field_decl_chain; ! 1533: ! 1534: objc_class_template = start_struct (RECORD_TYPE, get_identifier (_TAG_CLASS)); ! 1535: ! 1536: /* struct objc_class *isa; */ ! 1537: ! 1538: decl_specs = build_tree_list (NULLT, objc_class_template); ! 1539: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("isa")); ! 1540: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1541: field_decl_chain = field_decl; ! 1542: ! 1543: /* struct objc_class *super_class; */ ! 1544: ! 1545: decl_specs = build_tree_list (NULLT, objc_class_template); ! 1546: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("super_class")); ! 1547: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1548: chainon (field_decl_chain, field_decl); ! 1549: ! 1550: /* char *name; */ ! 1551: ! 1552: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]); ! 1553: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("name")); ! 1554: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1555: chainon (field_decl_chain, field_decl); ! 1556: ! 1557: /* long version; */ ! 1558: ! 1559: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]); ! 1560: field_decl = get_identifier ("version"); ! 1561: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1562: chainon (field_decl_chain, field_decl); ! 1563: ! 1564: /* long info; */ ! 1565: ! 1566: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]); ! 1567: field_decl = get_identifier ("info"); ! 1568: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1569: chainon (field_decl_chain, field_decl); ! 1570: ! 1571: /* long instance_size; */ ! 1572: ! 1573: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]); ! 1574: field_decl = get_identifier ("instance_size"); ! 1575: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1576: chainon (field_decl_chain, field_decl); ! 1577: ! 1578: /* struct objc_ivar_list *ivars; */ ! 1579: ! 1580: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, ! 1581: get_identifier (_TAG_IVAR_LIST))); ! 1582: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("ivars")); ! 1583: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1584: chainon (field_decl_chain, field_decl); ! 1585: ! 1586: /* struct objc_method_list *methods; */ ! 1587: ! 1588: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, ! 1589: get_identifier (_TAG_METHOD_LIST))); ! 1590: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("methods")); ! 1591: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1592: chainon (field_decl_chain, field_decl); ! 1593: ! 1594: /* struct objc_cache *cache; */ ! 1595: ! 1596: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, ! 1597: get_identifier ("objc_cache"))); ! 1598: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("cache")); ! 1599: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1600: chainon (field_decl_chain, field_decl); ! 1601: ! 1602: finish_struct (objc_class_template, field_decl_chain); ! 1603: } ! 1604: ! 1605: /* ! 1606: * generate appropriate forward declarations for an implementation ! 1607: */ ! 1608: static void ! 1609: synth_forward_declarations () ! 1610: { ! 1611: tree sc_spec, decl_specs, factory_id, anId; ! 1612: ! 1613: /* extern struct objc_class _OBJC_CLASS_<my_name>; */ ! 1614: ! 1615: anId = synth_id_with_class_suffix ("_OBJC_CLASS"); ! 1616: ! 1617: sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_EXTERN]); ! 1618: decl_specs = tree_cons (NULLT, objc_class_template, sc_spec); ! 1619: _OBJC_CLASS_decl = define_decl (anId, decl_specs); ! 1620: ! 1621: /* extern struct objc_class _OBJC_METACLASS_<my_name>; */ ! 1622: ! 1623: anId = synth_id_with_class_suffix ("_OBJC_METACLASS"); ! 1624: ! 1625: _OBJC_METACLASS_decl = define_decl (anId, decl_specs); ! 1626: ! 1627: /* pre-build the following entities - for speed/convenience. */ ! 1628: ! 1629: anId = get_identifier ("super_class"); ! 1630: _clsSuper_ref = build_component_ref (_OBJC_CLASS_decl, anId); ! 1631: __clsSuper_ref = build_component_ref (_OBJC_METACLASS_decl, anId); ! 1632: } ! 1633: ! 1634: static void ! 1635: error_with_ivar (message, decl, rawdecl) ! 1636: char *message; ! 1637: tree decl; ! 1638: tree rawdecl; ! 1639: { ! 1640: count_error (0); ! 1641: fprintf (stderr, "%s:%d: ", ! 1642: DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl)); ! 1643: bzero (errbuf, BUFSIZE); ! 1644: fprintf (stderr, "%s `%s'\n", message, gen_declaration (rawdecl, errbuf)); ! 1645: } ! 1646: ! 1647: #define USERTYPE(t) (TREE_CODE (t) == RECORD_TYPE || \ ! 1648: TREE_CODE (t) == UNION_TYPE || \ ! 1649: TREE_CODE (t) == ENUMERAL_TYPE) ! 1650: ! 1651: static void ! 1652: check_ivars (inter, imp) ! 1653: tree inter; ! 1654: tree imp; ! 1655: { ! 1656: tree intdecls = CLASS_IVARS (inter); ! 1657: tree impdecls = CLASS_IVARS (imp); ! 1658: tree rawintdecls = CLASS_RAW_IVARS (inter); ! 1659: tree rawimpdecls = CLASS_RAW_IVARS (imp); ! 1660: ! 1661: while (1) ! 1662: { ! 1663: tree t1, t2; ! 1664: ! 1665: if (intdecls == 0 && impdecls == 0) ! 1666: break; ! 1667: if (intdecls == 0 || impdecls == 0) ! 1668: { ! 1669: error ("inconsistent instance variable specification"); ! 1670: break; ! 1671: } ! 1672: t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls); ! 1673: ! 1674: if (!comptypes (t1, t2)) ! 1675: { ! 1676: if (DECL_NAME (intdecls) == DECL_NAME (impdecls)) ! 1677: { ! 1678: error_with_ivar ("conflicting instance variable type", ! 1679: impdecls, rawimpdecls); ! 1680: error_with_ivar ("previous declaration of", ! 1681: intdecls, rawintdecls); ! 1682: } ! 1683: else /* both the type and the name don't match */ ! 1684: { ! 1685: error ("inconsistent instance variable specification"); ! 1686: break; ! 1687: } ! 1688: } ! 1689: else if (DECL_NAME (intdecls) != DECL_NAME (impdecls)) ! 1690: { ! 1691: error_with_ivar ("conflicting instance variable name", ! 1692: impdecls, rawimpdecls); ! 1693: error_with_ivar ("previous declaration of", ! 1694: intdecls, rawintdecls); ! 1695: } ! 1696: intdecls = TREE_CHAIN (intdecls); ! 1697: impdecls = TREE_CHAIN (impdecls); ! 1698: rawintdecls = TREE_CHAIN (rawintdecls); ! 1699: rawimpdecls = TREE_CHAIN (rawimpdecls); ! 1700: } ! 1701: } ! 1702: ! 1703: /* ! 1704: * struct objc_super { ! 1705: * id self; ! 1706: * struct objc_class *class; ! 1707: * }; ! 1708: */ ! 1709: static tree ! 1710: build_super_template () ! 1711: { ! 1712: tree record, decl_specs, field_decl, field_decl_chain; ! 1713: ! 1714: record = start_struct (RECORD_TYPE, get_identifier (_TAG_SUPER)); ! 1715: ! 1716: /* struct objc_object *self; */ ! 1717: ! 1718: decl_specs = build_tree_list (NULLT, objc_object_reference); ! 1719: field_decl = get_identifier ("self"); ! 1720: field_decl = build1 (INDIRECT_REF, NULLT, field_decl); ! 1721: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1722: field_decl_chain = field_decl; ! 1723: ! 1724: /* struct objc_class *class; */ ! 1725: ! 1726: decl_specs = get_identifier (_TAG_CLASS); ! 1727: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, decl_specs)); ! 1728: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("class")); ! 1729: ! 1730: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1731: chainon (field_decl_chain, field_decl); ! 1732: ! 1733: finish_struct (record, field_decl_chain); ! 1734: ! 1735: /* `struct objc_super *' */ ! 1736: super_type = groktypename (build_tree_list (build_tree_list (NULLT, record), ! 1737: build1 (INDIRECT_REF, NULLT, NULLT))); ! 1738: return record; ! 1739: } ! 1740: ! 1741: /* ! 1742: * struct objc_ivar { ! 1743: * char *ivar_name; ! 1744: * char *ivar_type; ! 1745: * int ivar_offset; ! 1746: * }; ! 1747: */ ! 1748: static tree ! 1749: build_ivar_template () ! 1750: { ! 1751: tree objc_ivar_id, objc_ivar_record; ! 1752: tree decl_specs, field_decl, field_decl_chain; ! 1753: ! 1754: objc_ivar_id = get_identifier (_TAG_IVAR); ! 1755: objc_ivar_record = start_struct (RECORD_TYPE, objc_ivar_id); ! 1756: ! 1757: /* char *ivar_name; */ ! 1758: ! 1759: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]); ! 1760: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("ivar_name")); ! 1761: ! 1762: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1763: field_decl_chain = field_decl; ! 1764: ! 1765: /* char *ivar_type; */ ! 1766: ! 1767: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]); ! 1768: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("ivar_type")); ! 1769: ! 1770: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1771: chainon (field_decl_chain, field_decl); ! 1772: ! 1773: /* int ivar_offset; */ ! 1774: ! 1775: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_INT]); ! 1776: field_decl = get_identifier ("ivar_offset"); ! 1777: ! 1778: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1779: chainon (field_decl_chain, field_decl); ! 1780: ! 1781: finish_struct (objc_ivar_record, field_decl_chain); ! 1782: ! 1783: return objc_ivar_record; ! 1784: } ! 1785: ! 1786: /* ! 1787: * struct { ! 1788: * int ivar_count; ! 1789: * struct objc_ivar ivar_list[ivar_count]; ! 1790: * }; ! 1791: */ ! 1792: static tree ! 1793: build_ivar_list_template (list_type, size) ! 1794: tree list_type; ! 1795: int size; ! 1796: { ! 1797: tree objc_ivar_list_id, objc_ivar_list_record; ! 1798: tree decl_specs, field_decl, field_decl_chain; ! 1799: ! 1800: objc_ivar_list_record = start_struct (RECORD_TYPE, NULLT); ! 1801: ! 1802: /* int ivar_count; */ ! 1803: ! 1804: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_INT]); ! 1805: field_decl = get_identifier ("ivar_count"); ! 1806: ! 1807: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1808: field_decl_chain = field_decl; ! 1809: ! 1810: /* struct objc_ivar ivar_list[]; */ ! 1811: ! 1812: decl_specs = build_tree_list (NULLT, list_type); ! 1813: field_decl = build_nt (ARRAY_REF, get_identifier ("ivar_list"), ! 1814: build_int_2 (size, 0)); ! 1815: ! 1816: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1817: chainon (field_decl_chain, field_decl); ! 1818: ! 1819: finish_struct (objc_ivar_list_record, field_decl_chain); ! 1820: ! 1821: return objc_ivar_list_record; ! 1822: } ! 1823: ! 1824: /* ! 1825: * struct { ! 1826: * int method_next; ! 1827: * int method_count; ! 1828: * struct objc_method method_list[method_count]; ! 1829: * }; ! 1830: */ ! 1831: static tree ! 1832: build_method_list_template (list_type, size) ! 1833: tree list_type; ! 1834: int size; ! 1835: { ! 1836: tree objc_ivar_list_id, objc_ivar_list_record; ! 1837: tree decl_specs, field_decl, field_decl_chain; ! 1838: ! 1839: objc_ivar_list_record = start_struct (RECORD_TYPE, NULLT); ! 1840: ! 1841: /* int method_next; */ ! 1842: ! 1843: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_INT]); ! 1844: field_decl = get_identifier ("method_next"); ! 1845: ! 1846: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1847: field_decl_chain = field_decl; ! 1848: ! 1849: /* int method_count; */ ! 1850: ! 1851: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_INT]); ! 1852: field_decl = get_identifier ("method_count"); ! 1853: ! 1854: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1855: chainon (field_decl_chain, field_decl); ! 1856: ! 1857: /* struct objc_method method_list[]; */ ! 1858: ! 1859: decl_specs = build_tree_list (NULLT, list_type); ! 1860: field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"), ! 1861: build_int_2 (size, 0)); ! 1862: ! 1863: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 1864: chainon (field_decl_chain, field_decl); ! 1865: ! 1866: finish_struct (objc_ivar_list_record, field_decl_chain); ! 1867: ! 1868: return objc_ivar_list_record; ! 1869: } ! 1870: ! 1871: static tree ! 1872: build_ivar_list_initializer (field_decl, size) ! 1873: tree field_decl; ! 1874: int *size; ! 1875: { ! 1876: tree initlist = NULLT; ! 1877: ! 1878: do ! 1879: { ! 1880: int offset; ! 1881: ! 1882: /* set name */ ! 1883: if (DECL_NAME (field_decl)) ! 1884: { ! 1885: offset = add_objc_string (DECL_NAME (field_decl)); ! 1886: initlist = tree_cons (NULLT, build_msg_pool_reference (offset), initlist); ! 1887: } ! 1888: else ! 1889: { ! 1890: /* unnamed bit-field ivar (yuck). */ ! 1891: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist); ! 1892: } ! 1893: ! 1894: /* set type */ ! 1895: bzero (utlbuf, BUFSIZE); ! 1896: encode_field_decl (field_decl, utlbuf, OBJC_ENCODE_DONT_INLINE_DEFS); ! 1897: ! 1898: offset = add_objc_string (get_identifier (utlbuf)); ! 1899: initlist = tree_cons (NULLT, build_msg_pool_reference (offset), initlist); ! 1900: ! 1901: /* set offset */ ! 1902: initlist = tree_cons (NULLT, ! 1903: build_int_2 (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field_decl)) / BITS_PER_UNIT, 0), ! 1904: ! 1905: initlist); ! 1906: (*size)++; ! 1907: field_decl = TREE_CHAIN (field_decl); ! 1908: } ! 1909: while (field_decl); ! 1910: ! 1911: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)); ! 1912: } ! 1913: ! 1914: static tree ! 1915: generate_ivars_list (type, name, size, list) ! 1916: tree type; ! 1917: char *name; ! 1918: int size; ! 1919: tree list; ! 1920: { ! 1921: tree sc_spec, decl_specs, decl, initlist; ! 1922: ! 1923: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT); ! 1924: decl_specs = tree_cons (NULLT, type, sc_spec); ! 1925: ! 1926: decl = start_decl (synth_id_with_class_suffix (name), decl_specs, 1); ! 1927: ! 1928: initlist = build_tree_list (NULLT, build_int_2 (size, 0)); ! 1929: initlist = tree_cons (NULLT, list, initlist); ! 1930: ! 1931: finish_decl (decl, build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)), NULLT); ! 1932: ! 1933: return decl; ! 1934: } ! 1935: ! 1936: static void ! 1937: generate_ivar_lists () ! 1938: { ! 1939: tree initlist, ivar_list_template, chain; ! 1940: tree cast, variable_length_type; ! 1941: int size; ! 1942: ! 1943: if (!objc_ivar_template) ! 1944: objc_ivar_template = build_ivar_template (); ! 1945: ! 1946: cast = build_tree_list (build_tree_list (NULLT, xref_tag (RECORD_TYPE, ! 1947: get_identifier (_TAG_IVAR_LIST))), NULLT); ! 1948: variable_length_type = groktypename (cast); ! 1949: ! 1950: /* only generate class variables for the root of the inheritance ! 1951: hierarchy since these will be the same for every class */ ! 1952: ! 1953: if (CLASS_SUPER_NAME (implementation_template) == NULLT ! 1954: && (chain = TYPE_FIELDS (objc_class_template))) ! 1955: { ! 1956: size = 0; ! 1957: initlist = build_ivar_list_initializer (chain, &size); ! 1958: ! 1959: ivar_list_template = build_ivar_list_template (objc_ivar_template, size); ! 1960: ! 1961: _OBJC_CLASS_VARIABLES_decl = ! 1962: generate_ivars_list (ivar_list_template, "_OBJC_CLASS_VARIABLES", ! 1963: size, initlist); ! 1964: /* cast! */ ! 1965: TREE_TYPE (_OBJC_CLASS_VARIABLES_decl) = variable_length_type; ! 1966: } ! 1967: else ! 1968: _OBJC_CLASS_VARIABLES_decl = 0; ! 1969: ! 1970: chain = CLASS_IVARS (implementation_template); ! 1971: if (chain) ! 1972: { ! 1973: size = 0; ! 1974: initlist = build_ivar_list_initializer (chain, &size); ! 1975: ! 1976: ivar_list_template = build_ivar_list_template (objc_ivar_template, size); ! 1977: ! 1978: _OBJC_INSTANCE_VARIABLES_decl = ! 1979: generate_ivars_list (ivar_list_template, "_OBJC_INSTANCE_VARIABLES", ! 1980: size, initlist); ! 1981: /* cast! */ ! 1982: TREE_TYPE (_OBJC_INSTANCE_VARIABLES_decl) = variable_length_type; ! 1983: } ! 1984: else ! 1985: _OBJC_INSTANCE_VARIABLES_decl = 0; ! 1986: } ! 1987: ! 1988: static tree ! 1989: build_dispatch_table_initializer (entries, size) ! 1990: tree entries; ! 1991: int *size; ! 1992: { ! 1993: tree initlist = NULLT; ! 1994: ! 1995: do ! 1996: { ! 1997: int offset = add_objc_string (METHOD_SEL_NAME (entries)); ! 1998: ! 1999: initlist = tree_cons (NULLT, init_selector (offset), initlist); ! 2000: ! 2001: offset = add_objc_string (METHOD_ENCODING (entries)); ! 2002: initlist = tree_cons (NULLT, build_msg_pool_reference (offset), initlist); ! 2003: ! 2004: initlist = tree_cons (NULLT, METHOD_DEFINITION (entries), initlist); ! 2005: ! 2006: (*size)++; ! 2007: entries = TREE_CHAIN (entries); ! 2008: } ! 2009: while (entries); ! 2010: ! 2011: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)); ! 2012: } ! 2013: ! 2014: /* ! 2015: * To accomplish method prototyping without generating all kinds of ! 2016: * inane warnings, the definition of the dispatch table entries were ! 2017: * changed from: ! 2018: * ! 2019: * struct objc_method { SEL _cmd; id (*_imp)(); }; ! 2020: * to: ! 2021: * struct objc_method { SEL _cmd; void *_imp; }; ! 2022: */ ! 2023: static tree ! 2024: build_method_template () ! 2025: { ! 2026: tree _SLT_record; ! 2027: tree decl_specs, field_decl, field_decl_chain, parms; ! 2028: ! 2029: _SLT_record = start_struct (RECORD_TYPE, get_identifier (_TAG_METHOD)); ! 2030: ! 2031: #ifdef OBJC_INT_SELECTORS ! 2032: /* unsigned int _cmd; */ ! 2033: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_UNSIGNED], NULLT); ! 2034: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs); ! 2035: field_decl = get_identifier ("_cmd"); ! 2036: #else /* not OBJC_INT_SELECTORS */ ! 2037: /* struct objc_selector *_cmd; */ ! 2038: decl_specs = tree_cons (NULLT, ! 2039: xref_tag (RECORD_TYPE, ! 2040: get_identifier (TAG_SELECTOR)), ! 2041: NULLT); ! 2042: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("_cmd")); ! 2043: #endif /* not OBJC_INT_SELECTORS */ ! 2044: ! 2045: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 2046: field_decl_chain = field_decl; ! 2047: ! 2048: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_CHAR], NULLT); ! 2049: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("method_types")); ! 2050: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 2051: chainon (field_decl_chain, field_decl); ! 2052: ! 2053: /* void *_imp; */ ! 2054: ! 2055: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_VOID], NULLT); ! 2056: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("_imp")); ! 2057: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT); ! 2058: chainon (field_decl_chain, field_decl); ! 2059: ! 2060: finish_struct (_SLT_record, field_decl_chain); ! 2061: ! 2062: return _SLT_record; ! 2063: } ! 2064: ! 2065: ! 2066: static tree ! 2067: generate_dispatch_table (type, name, size, list) ! 2068: tree type; ! 2069: char *name; ! 2070: int size; ! 2071: tree list; ! 2072: { ! 2073: tree sc_spec, decl_specs, decl, initlist; ! 2074: ! 2075: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT); ! 2076: decl_specs = tree_cons (NULLT, type, sc_spec); ! 2077: ! 2078: decl = start_decl (synth_id_with_class_suffix (name), decl_specs, 1); ! 2079: ! 2080: initlist = build_tree_list (NULLT, build_int_2 (0, 0)); ! 2081: initlist = tree_cons (NULLT, build_int_2 (size, 0), initlist); ! 2082: initlist = tree_cons (NULLT, list, initlist); ! 2083: ! 2084: finish_decl (decl, build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)), NULLT); ! 2085: ! 2086: return decl; ! 2087: } ! 2088: ! 2089: static void ! 2090: generate_dispatch_tables () ! 2091: { ! 2092: tree initlist, chain, method_list_template; ! 2093: tree cast, variable_length_type; ! 2094: int size; ! 2095: ! 2096: if (!objc_method_template) ! 2097: objc_method_template = build_method_template (); ! 2098: ! 2099: cast = build_tree_list (build_tree_list (NULLT, xref_tag (RECORD_TYPE, ! 2100: get_identifier (_TAG_METHOD_LIST))), NULLT); ! 2101: variable_length_type = groktypename (cast); ! 2102: ! 2103: chain = CLASS_CLS_METHODS (implementation_context); ! 2104: if (chain) ! 2105: { ! 2106: size = 0; ! 2107: initlist = build_dispatch_table_initializer (chain, &size); ! 2108: ! 2109: method_list_template = build_method_list_template (objc_method_template, ! 2110: size); ! 2111: if (TREE_CODE (implementation_context) == IMPLEMENTATION_TYPE) ! 2112: _OBJC_CLASS_METHODS_decl = ! 2113: generate_dispatch_table (method_list_template, ! 2114: "_OBJC_CLASS_METHODS", ! 2115: size, initlist); ! 2116: else ! 2117: /* we have a category */ ! 2118: _OBJC_CLASS_METHODS_decl = ! 2119: generate_dispatch_table (method_list_template, ! 2120: "_OBJC_CATEGORY_CLASS_METHODS", ! 2121: size, initlist); ! 2122: /* cast! */ ! 2123: TREE_TYPE (_OBJC_CLASS_METHODS_decl) = variable_length_type; ! 2124: } ! 2125: else ! 2126: _OBJC_CLASS_METHODS_decl = 0; ! 2127: ! 2128: chain = CLASS_NST_METHODS (implementation_context); ! 2129: if (chain) ! 2130: { ! 2131: size = 0; ! 2132: initlist = build_dispatch_table_initializer (chain, &size); ! 2133: ! 2134: method_list_template = build_method_list_template (objc_method_template, ! 2135: size); ! 2136: if (TREE_CODE (implementation_context) == IMPLEMENTATION_TYPE) ! 2137: _OBJC_INSTANCE_METHODS_decl = ! 2138: generate_dispatch_table (method_list_template, ! 2139: "_OBJC_INSTANCE_METHODS", ! 2140: size, initlist); ! 2141: else ! 2142: /* we have a category */ ! 2143: _OBJC_INSTANCE_METHODS_decl = ! 2144: generate_dispatch_table (method_list_template, ! 2145: "_OBJC_CATEGORY_INSTANCE_METHODS", ! 2146: size, initlist); ! 2147: /* cast! */ ! 2148: TREE_TYPE (_OBJC_INSTANCE_METHODS_decl) = variable_length_type; ! 2149: } ! 2150: else ! 2151: _OBJC_INSTANCE_METHODS_decl = 0; ! 2152: } ! 2153: ! 2154: static tree ! 2155: build_category_initializer (cat_name, class_name, ! 2156: instance_methods, class_methods) ! 2157: tree cat_name; ! 2158: tree class_name; ! 2159: tree instance_methods; ! 2160: tree class_methods; ! 2161: { ! 2162: tree initlist = NULLT, expr; ! 2163: ! 2164: initlist = tree_cons (NULLT, cat_name, initlist); ! 2165: initlist = tree_cons (NULLT, class_name, initlist); ! 2166: ! 2167: if (!instance_methods) ! 2168: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist); ! 2169: else ! 2170: { ! 2171: expr = build_unary_op (ADDR_EXPR, instance_methods, 0); ! 2172: initlist = tree_cons (NULLT, expr, initlist); ! 2173: } ! 2174: if (!class_methods) ! 2175: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist); ! 2176: else ! 2177: { ! 2178: expr = build_unary_op (ADDR_EXPR, class_methods, 0); ! 2179: initlist = tree_cons (NULLT, expr, initlist); ! 2180: } ! 2181: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)); ! 2182: } ! 2183: ! 2184: /* ! 2185: * struct objc_class { ! 2186: * struct objc_class *isa; ! 2187: * struct objc_class *super_class; ! 2188: * char *name; ! 2189: * long version; ! 2190: * long info; ! 2191: * long instance_size; ! 2192: * struct objc_ivar_list *ivars; ! 2193: * struct objc_method_list *methods; ! 2194: * struct objc_cache *cache; ! 2195: * }; ! 2196: */ ! 2197: static tree ! 2198: build_shared_structure_initializer (isa, super, name, size, status, ! 2199: dispatch_table, ivar_list) ! 2200: tree isa; ! 2201: tree super; ! 2202: tree name; ! 2203: tree size; ! 2204: int status; ! 2205: tree dispatch_table; ! 2206: tree ivar_list; ! 2207: { ! 2208: tree initlist = NULLT, expr; ! 2209: ! 2210: /* isa = */ ! 2211: initlist = tree_cons (NULLT, isa, initlist); ! 2212: ! 2213: /* super_class = */ ! 2214: initlist = tree_cons (NULLT, super, initlist); ! 2215: ! 2216: /* name = */ ! 2217: initlist = tree_cons (NULLT, name, initlist); ! 2218: ! 2219: /* version = */ ! 2220: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist); ! 2221: ! 2222: /* info = */ ! 2223: initlist = tree_cons (NULLT, build_int_2 (status), initlist); ! 2224: ! 2225: /* instance_size = */ ! 2226: initlist = tree_cons (NULLT, size, initlist); ! 2227: ! 2228: /* objc_ivar_list = */ ! 2229: if (!ivar_list) ! 2230: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist); ! 2231: else ! 2232: { ! 2233: expr = build_unary_op (ADDR_EXPR, ivar_list, 0); ! 2234: initlist = tree_cons (NULLT, expr, initlist); ! 2235: } ! 2236: ! 2237: /* objc_method_list = */ ! 2238: if (!dispatch_table) ! 2239: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist); ! 2240: else ! 2241: { ! 2242: expr = build_unary_op (ADDR_EXPR, dispatch_table, 0); ! 2243: initlist = tree_cons (NULLT, expr, initlist); ! 2244: } ! 2245: ! 2246: /* method_cache = */ ! 2247: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist); ! 2248: ! 2249: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)); ! 2250: } ! 2251: ! 2252: /* ! 2253: * static struct objc_category _OBJC_CATEGORY_<name> = { ... }; ! 2254: */ ! 2255: static void ! 2256: generate_category (cat) ! 2257: tree cat; ! 2258: { ! 2259: tree sc_spec, decl_specs, decl; ! 2260: tree initlist, cat_name_expr, class_name_expr; ! 2261: int offset; ! 2262: ! 2263: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT); ! 2264: decl_specs = tree_cons (NULLT, objc_category_template, sc_spec); ! 2265: ! 2266: decl = start_decl (synth_id_with_class_suffix ("_OBJC_CATEGORY"), ! 2267: decl_specs, 1); ! 2268: ! 2269: offset = add_objc_string (CLASS_SUPER_NAME (cat)); ! 2270: cat_name_expr = build_msg_pool_reference (offset); ! 2271: ! 2272: offset = add_objc_string (CLASS_NAME (cat)); ! 2273: class_name_expr = build_msg_pool_reference (offset); ! 2274: ! 2275: initlist = build_category_initializer ( ! 2276: cat_name_expr, class_name_expr, ! 2277: _OBJC_INSTANCE_METHODS_decl, _OBJC_CLASS_METHODS_decl); ! 2278: ! 2279: finish_decl (decl, initlist, NULLT); ! 2280: } ! 2281: ! 2282: /* ! 2283: * static struct objc_class _OBJC_METACLASS_Foo={ ... }; ! 2284: * static struct objc_class _OBJC_CLASS_Foo={ ... }; ! 2285: */ ! 2286: static void ! 2287: generate_shared_structures () ! 2288: { ! 2289: tree sc_spec, decl_specs, expr_decl, decl; ! 2290: tree name_expr, super_expr, root_expr; ! 2291: tree my_root_id = NULLT, my_super_id = NULLT; ! 2292: tree cast_type, initlist; ! 2293: int offset; ! 2294: ! 2295: my_super_id = CLASS_SUPER_NAME (implementation_template); ! 2296: if (my_super_id) ! 2297: { ! 2298: add_class_reference (my_super_id); ! 2299: ! 2300: /* compute "my_root_id" - this is required for code generation. ! 2301: * the "isa" for all meta class structures points to the root of ! 2302: * the inheritance hierarchy (e.g. "__Object")... ! 2303: */ ! 2304: my_root_id = my_super_id; ! 2305: do ! 2306: { ! 2307: tree my_root_int = lookup_interface (my_root_id); ! 2308: ! 2309: if (my_root_int && CLASS_SUPER_NAME (my_root_int)) ! 2310: my_root_id = CLASS_SUPER_NAME (my_root_int); ! 2311: else ! 2312: break; ! 2313: } ! 2314: while (1); ! 2315: } ! 2316: else /* no super class */ ! 2317: { ! 2318: my_root_id = CLASS_NAME (implementation_template); ! 2319: } ! 2320: ! 2321: cast_type = groktypename (build_tree_list (build_tree_list (NULLT, ! 2322: objc_class_template), build1 (INDIRECT_REF, NULLT, NULLT))); ! 2323: ! 2324: offset = add_objc_string (CLASS_NAME (implementation_template)); ! 2325: name_expr = build_msg_pool_reference (offset); ! 2326: ! 2327: /* install class `isa' and `super' pointers at runtime */ ! 2328: if (my_super_id) ! 2329: { ! 2330: offset = add_objc_string (my_super_id); ! 2331: super_expr = build_msg_pool_reference (offset); ! 2332: TREE_TYPE (super_expr) = cast_type; /* cast! */ ! 2333: } ! 2334: else ! 2335: super_expr = build_int_2 (0, 0); ! 2336: ! 2337: offset = add_objc_string (my_root_id); ! 2338: root_expr = build_msg_pool_reference (offset); ! 2339: TREE_TYPE (root_expr) = cast_type; /* cast! */ ! 2340: ! 2341: /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */ ! 2342: ! 2343: sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_STATIC]); ! 2344: decl_specs = tree_cons (NULLT, objc_class_template, sc_spec); ! 2345: ! 2346: decl = start_decl (DECL_NAME (_OBJC_METACLASS_decl), decl_specs, 1); ! 2347: ! 2348: initlist = build_shared_structure_initializer ( ! 2349: root_expr, super_expr, name_expr, ! 2350: build_int_2 (TREE_INT_CST_LOW (TYPE_SIZE (objc_class_template)) / BITS_PER_UNIT, 0), ! 2351: 2 /*CLS_META*/, ! 2352: _OBJC_CLASS_METHODS_decl, _OBJC_CLASS_VARIABLES_decl); ! 2353: ! 2354: finish_decl (decl, initlist, NULLT); ! 2355: ! 2356: /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */ ! 2357: ! 2358: decl = start_decl (DECL_NAME (_OBJC_CLASS_decl), decl_specs, 1); ! 2359: ! 2360: initlist = build_shared_structure_initializer ( ! 2361: build_unary_op (ADDR_EXPR, _OBJC_METACLASS_decl, 0), ! 2362: super_expr, name_expr, ! 2363: build_int_2 (TREE_INT_CST_LOW (TYPE_SIZE (CLASS_STATIC_TEMPLATE (implementation_template))) / BITS_PER_UNIT, 0), ! 2364: 1 /*CLS_FACTORY*/, ! 2365: _OBJC_INSTANCE_METHODS_decl, _OBJC_INSTANCE_VARIABLES_decl); ! 2366: ! 2367: finish_decl (decl, initlist, NULLT); ! 2368: } ! 2369: ! 2370: static tree ! 2371: synth_id_with_class_suffix (preamble) ! 2372: char *preamble; ! 2373: { ! 2374: if (TREE_CODE (implementation_context) == IMPLEMENTATION_TYPE) ! 2375: sprintf (utlbuf, "%s_%s", preamble, ! 2376: IDENTIFIER_POINTER (CLASS_NAME (implementation_context))); ! 2377: else ! 2378: /* we have a category */ ! 2379: sprintf (utlbuf, "%s_%s_%s", preamble, ! 2380: IDENTIFIER_POINTER (CLASS_NAME (implementation_context)), ! 2381: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context))); ! 2382: return get_identifier (utlbuf); ! 2383: } ! 2384: ! 2385: /* ! 2386: * usage: ! 2387: * keyworddecl: ! 2388: * selector ':' '(' typename ')' identifier ! 2389: * ! 2390: * purpose: ! 2391: * transform an Objective-C keyword argument into ! 2392: * the C equivalent parameter declarator. ! 2393: * ! 2394: * in: key_name, an "identifier_node" (optional). ! 2395: * arg_type, a "tree_list" (optional). ! 2396: * arg_name, an "identifier_node". ! 2397: * ! 2398: * note: it would be really nice to strongly type the preceding ! 2399: * arguments in the function prototype; however, then i ! 2400: * could not use the "accessor" macros defined in "tree.h". ! 2401: * ! 2402: * out: an instance of "keyword_decl". ! 2403: * ! 2404: */ ! 2405: ! 2406: tree ! 2407: build_keyword_decl (key_name, arg_type, arg_name) ! 2408: tree key_name; ! 2409: tree arg_type; ! 2410: tree arg_name; ! 2411: { ! 2412: tree keyword_decl; ! 2413: ! 2414: /* if no type is specified, default to "id" */ ! 2415: if (arg_type == NULLT) ! 2416: arg_type = build_tree_list (build_tree_list (NULLT, objc_object_reference), ! 2417: build1 (INDIRECT_REF, NULLT, NULLT)); ! 2418: ! 2419: keyword_decl = make_node (KEYWORD_DECL); ! 2420: ! 2421: TREE_TYPE (keyword_decl) = arg_type; ! 2422: KEYWORD_ARG_NAME (keyword_decl) = arg_name; ! 2423: KEYWORD_KEY_NAME (keyword_decl) = key_name; ! 2424: ! 2425: return keyword_decl; ! 2426: } ! 2427: ! 2428: /* ! 2429: * given a chain of keyword_decl's, synthesize the full keyword selector. ! 2430: */ ! 2431: static tree ! 2432: build_keyword_selector (selector) ! 2433: tree selector; ! 2434: { ! 2435: int len = 0; ! 2436: tree key_chain, key_name; ! 2437: char *buf; ! 2438: ! 2439: for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain)) ! 2440: { ! 2441: if (TREE_CODE (selector) == KEYWORD_DECL) ! 2442: key_name = KEYWORD_KEY_NAME (key_chain); ! 2443: else if (TREE_CODE (selector) == TREE_LIST) ! 2444: key_name = TREE_PURPOSE (key_chain); ! 2445: ! 2446: if (key_name) ! 2447: len += IDENTIFIER_LENGTH (key_name) + 1; ! 2448: else /* just a ':' arg */ ! 2449: len++; ! 2450: } ! 2451: buf = (char *)alloca (len + 1); ! 2452: bzero (buf, len + 1); ! 2453: ! 2454: for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain)) ! 2455: { ! 2456: if (TREE_CODE (selector) == KEYWORD_DECL) ! 2457: key_name = KEYWORD_KEY_NAME (key_chain); ! 2458: else if (TREE_CODE (selector) == TREE_LIST) ! 2459: key_name = TREE_PURPOSE (key_chain); ! 2460: ! 2461: if (key_name) ! 2462: strcat (buf, IDENTIFIER_POINTER (key_name)); ! 2463: strcat (buf, ":"); ! 2464: } ! 2465: return get_identifier (buf); ! 2466: } ! 2467: ! 2468: /* used for declarations and definitions */ ! 2469: ! 2470: tree ! 2471: build_method_decl (code, ret_type, selector, add_args) ! 2472: enum tree_code code; ! 2473: tree ret_type; ! 2474: tree selector; ! 2475: tree add_args; ! 2476: { ! 2477: tree method_decl; ! 2478: ! 2479: /* if no type is specified, default to "id" */ ! 2480: if (ret_type == NULLT) ! 2481: ret_type = build_tree_list (build_tree_list (NULLT, objc_object_reference), ! 2482: build1 (INDIRECT_REF, NULLT, NULLT)); ! 2483: ! 2484: method_decl = make_node (code); ! 2485: TREE_TYPE (method_decl) = ret_type; ! 2486: ! 2487: /* ! 2488: * if we have a keyword selector, create an identifier_node that ! 2489: * represents the full selector name (`:' included)... ! 2490: */ ! 2491: if (TREE_CODE (selector) == KEYWORD_DECL) ! 2492: { ! 2493: METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector); ! 2494: METHOD_SEL_ARGS (method_decl) = selector; ! 2495: METHOD_ADD_ARGS (method_decl) = add_args; ! 2496: } ! 2497: else ! 2498: { ! 2499: METHOD_SEL_NAME (method_decl) = selector; ! 2500: METHOD_SEL_ARGS (method_decl) = NULLT; ! 2501: METHOD_ADD_ARGS (method_decl) = NULLT; ! 2502: } ! 2503: ! 2504: return method_decl; ! 2505: } ! 2506: ! 2507: #define METHOD_DEF 0 ! 2508: #define METHOD_REF 1 ! 2509: /* ! 2510: * used by `build_message_expr' and `comp_method_types'. ! 2511: * ! 2512: * add_args is a tree_list node the following info on a parameter list: ! 2513: * ! 2514: * The TREE_PURPOSE is a chain of decls of those parms. ! 2515: * The TREE_VALUE is a list of structure, union and enum tags defined. ! 2516: * The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE. ! 2517: * This tree_list node is later fed to `grokparms'. ! 2518: * ! 2519: * VOID_AT_END nonzero means append `void' to the end of the type-list. ! 2520: * Zero means the parmlist ended with an ellipsis so don't append `void'. ! 2521: */ ! 2522: static tree ! 2523: get_arg_type_list (meth, context, superflag) ! 2524: tree meth; ! 2525: int context; ! 2526: int superflag; ! 2527: { ! 2528: tree arglist, akey; ! 2529: ! 2530: /* receiver type */ ! 2531: if (superflag) ! 2532: arglist = build_tree_list (NULLT, super_type); ! 2533: else ! 2534: { ! 2535: if (context == METHOD_DEF) ! 2536: arglist = build_tree_list (NULLT, TREE_TYPE (self_decl)); ! 2537: else ! 2538: arglist = build_tree_list (NULLT, id_type); ! 2539: } ! 2540: ! 2541: /* selector type - will eventually change to `int' */ ! 2542: chainon (arglist, build_tree_list (NULLT, _selector_type)); ! 2543: ! 2544: /* build a list of argument types */ ! 2545: for (akey = METHOD_SEL_ARGS (meth); akey; akey = TREE_CHAIN (akey)) ! 2546: { ! 2547: tree arg_decl = groktypename_in_parm_context (TREE_TYPE (akey)); ! 2548: chainon (arglist, build_tree_list (NULLT, TREE_TYPE (arg_decl))); ! 2549: } ! 2550: ! 2551: if (METHOD_ADD_ARGS (meth) == (tree)1) ! 2552: /* ! 2553: * we have a `, ...' immediately following the selector, ! 2554: * finalize the arglist...simulate get_parm_info (0) ! 2555: */ ! 2556: ; ! 2557: else if (METHOD_ADD_ARGS (meth)) ! 2558: { ! 2559: /* we have a variable length selector */ ! 2560: tree add_arg_list = TREE_CHAIN (METHOD_ADD_ARGS (meth)); ! 2561: chainon (arglist, add_arg_list); ! 2562: } ! 2563: else /* finalize the arglist...simulate get_parm_info (1) */ ! 2564: chainon (arglist, build_tree_list (NULLT, void_type_node)); ! 2565: ! 2566: return arglist; ! 2567: } ! 2568: ! 2569: static tree ! 2570: check_duplicates (hsh) ! 2571: hash hsh; ! 2572: { ! 2573: tree meth = NULLT; ! 2574: ! 2575: if (hsh) ! 2576: { ! 2577: meth = hsh->key; ! 2578: ! 2579: if (hsh->list) ! 2580: { ! 2581: /* we have two methods with the same name and different types */ ! 2582: attr loop; ! 2583: char type; ! 2584: ! 2585: type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL) ? '-' : '+'; ! 2586: ! 2587: warning ("multiple declarations for method `%s'", ! 2588: IDENTIFIER_POINTER (METHOD_SEL_NAME (meth))); ! 2589: ! 2590: warn_with_method ("using", type, meth); ! 2591: for (loop = hsh->list; loop; loop = loop->next) ! 2592: warn_with_method ("also found", type, loop->value); ! 2593: } ! 2594: } ! 2595: return meth; ! 2596: } ! 2597: ! 2598: static tree ! 2599: receiver_is_class_object (receiver) ! 2600: tree receiver; ! 2601: { ! 2602: /* the receiver is a function call that returns an id... ! 2603: * ...check if it is a call to objc_getClass, if so, give it ! 2604: * special treatment. ! 2605: */ ! 2606: tree exp = 0; ! 2607: ! 2608: if ((exp = TREE_OPERAND (receiver, 0)) && (TREE_CODE (exp) == ADDR_EXPR)) ! 2609: { ! 2610: if ((exp = TREE_OPERAND (exp, 0)) && ! 2611: (TREE_CODE (exp) == FUNCTION_DECL) && exp == objc_getClass_decl) ! 2612: { ! 2613: /* we have a call to objc_getClass! */ ! 2614: tree arg = 0; ! 2615: ! 2616: if ((arg = TREE_OPERAND (receiver, 1)) && ! 2617: (TREE_CODE (arg) == TREE_LIST) && ! 2618: (arg = TREE_VALUE (arg)) && ! 2619: (TREE_CODE (arg) == NOP_EXPR) && ! 2620: (arg = TREE_OPERAND (arg, 0)) && ! 2621: (TREE_CODE (arg) == ADDR_EXPR) && ! 2622: (arg = TREE_OPERAND (arg, 0)) && ! 2623: (TREE_CODE (arg) == STRING_CST)) ! 2624: /* finally, we have the class name */ ! 2625: return get_identifier (TREE_STRING_POINTER (arg)); ! 2626: } ! 2627: } ! 2628: return 0; ! 2629: } ! 2630: ! 2631: /* If we are currently building a message expr, this holds ! 2632: the identifier of the selector of the message. This is ! 2633: used when printing warnings about argument mismatches. */ ! 2634: ! 2635: static tree building_objc_message_expr = 0; ! 2636: ! 2637: tree ! 2638: maybe_building_objc_message_expr () ! 2639: { ! 2640: return building_objc_message_expr; ! 2641: } ! 2642: ! 2643: /* Construct an expression for sending a message. ! 2644: MESS has the object to send to in TREE_PURPOSE ! 2645: and the argument list (including selector) in TREE_VALUE. */ ! 2646: ! 2647: tree ! 2648: build_message_expr (mess) ! 2649: tree mess; ! 2650: { ! 2651: tree receiver = TREE_PURPOSE (mess); ! 2652: tree selector, self_object; ! 2653: tree rtype, sel_name; ! 2654: tree args = TREE_VALUE (mess); ! 2655: tree method_params = NULLT; ! 2656: tree method_prototype = NULLT; ! 2657: int selTransTbl_index; ! 2658: tree retval; ! 2659: int statically_typed = 0, statically_allocated = 0; ! 2660: tree class_ident = 0; ! 2661: ! 2662: /* 1 if this is sending to the superclass. */ ! 2663: int super; ! 2664: ! 2665: if (!doing_objc_thang) ! 2666: fatal ("Objective-C text in C source file"); ! 2667: ! 2668: if (TREE_CODE (receiver) == ERROR_MARK) ! 2669: return error_mark_node; ! 2670: ! 2671: /* determine receiver type */ ! 2672: rtype = TREE_TYPE (receiver); ! 2673: super = (TREE_TYPE (receiver) == super_type); ! 2674: ! 2675: if (! super) ! 2676: { ! 2677: if (TREE_STATIC_TEMPLATE (rtype)) ! 2678: statically_allocated = 1; ! 2679: else if (TREE_CODE (rtype) == POINTER_TYPE ! 2680: && TREE_STATIC_TEMPLATE (TREE_TYPE (rtype))) ! 2681: statically_typed = 1; ! 2682: /* classfix -smn */ ! 2683: else if (TREE_CODE (receiver) == CALL_EXPR && rtype == id_type ! 2684: && (class_ident = receiver_is_class_object (receiver))) ! 2685: ; ! 2686: else if (rtype != id_type && rtype != class_type) ! 2687: { ! 2688: bzero (errbuf, BUFSIZE); ! 2689: warning ("invalid receiver type `%s'", gen_declaration (rtype, errbuf)); ! 2690: } ! 2691: if (statically_allocated) ! 2692: receiver = build_unary_op (ADDR_EXPR, receiver, 0); ! 2693: ! 2694: self_object = receiver; ! 2695: } ! 2696: else ! 2697: /* If sending to `super', use current self as the object. */ ! 2698: self_object = self_decl; ! 2699: ! 2700: /* Obtain the full selector name. */ ! 2701: ! 2702: if (TREE_CODE (args) == IDENTIFIER_NODE) ! 2703: /* a unary selector */ ! 2704: sel_name = args; ! 2705: else if (TREE_CODE (args) == TREE_LIST) ! 2706: sel_name = build_keyword_selector (args); ! 2707: ! 2708: selTransTbl_index = add_selector_reference (sel_name); ! 2709: ! 2710: /* Build the parameters list for looking up the method. ! 2711: These are the object itself and the selector. */ ! 2712: ! 2713: #ifndef OBJC_NONUNIQUE_SELECTORS ! 2714: selector = build_selector_reference (selTransTbl_index); ! 2715: #else ! 2716: selector = build_array_ref (_OBJC_SELECTOR_REFERENCES_decl, ! 2717: build_int_2 (selTransTbl_index, 0)); ! 2718: #endif ! 2719: ! 2720: /* Build the parameter list to give to the method. */ ! 2721: ! 2722: method_params = NULLT; ! 2723: if (TREE_CODE (args) == TREE_LIST) ! 2724: { ! 2725: tree chain = args, prev = NULLT; ! 2726: ! 2727: /* We have a keyword selector--check for comma expressions. */ ! 2728: while (chain) ! 2729: { ! 2730: tree element = TREE_VALUE (chain); ! 2731: ! 2732: /* We have a comma expression, must collapse... */ ! 2733: if (TREE_CODE (element) == TREE_LIST) ! 2734: { ! 2735: if (prev) ! 2736: TREE_CHAIN (prev) = element; ! 2737: else ! 2738: args = element; ! 2739: } ! 2740: prev = chain; ! 2741: chain = TREE_CHAIN (chain); ! 2742: } ! 2743: method_params = args; ! 2744: } ! 2745: ! 2746: /* Determine operation return type. */ ! 2747: ! 2748: if (rtype == super_type) ! 2749: { ! 2750: tree iface; ! 2751: ! 2752: if (CLASS_SUPER_NAME (implementation_template)) ! 2753: { ! 2754: iface = lookup_interface (CLASS_SUPER_NAME (implementation_template)); ! 2755: ! 2756: if (TREE_CODE (method_context) == INSTANCE_METHOD_DECL) ! 2757: method_prototype = lookup_instance_method_static (iface, sel_name); ! 2758: else ! 2759: method_prototype = lookup_class_method_static (iface, sel_name); ! 2760: ! 2761: if (iface && !method_prototype) ! 2762: warning ("`%s' does not respond to `%s'", ! 2763: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_template)), ! 2764: IDENTIFIER_POINTER (sel_name)); ! 2765: } ! 2766: else ! 2767: { ! 2768: error ("no super class declared in interface for `%s'", ! 2769: IDENTIFIER_POINTER (CLASS_NAME (implementation_template))); ! 2770: return error_mark_node; ! 2771: } ! 2772: ! 2773: } ! 2774: else if (statically_allocated) ! 2775: { ! 2776: tree iface = lookup_interface (TYPE_NAME (rtype)); ! 2777: ! 2778: if (iface && !(method_prototype = lookup_instance_method_static (iface, sel_name))) ! 2779: warning ("`%s' does not respond to `%s'", ! 2780: IDENTIFIER_POINTER (TYPE_NAME (rtype)), ! 2781: IDENTIFIER_POINTER (sel_name)); ! 2782: } ! 2783: else if (statically_typed) ! 2784: { ! 2785: tree ctype = TREE_TYPE (rtype); ! 2786: ! 2787: /* `self' is now statically_typed...all methods should be visible ! 2788: * within the context of the implementation... ! 2789: */ ! 2790: if (implementation_context ! 2791: && CLASS_NAME (implementation_context) == TYPE_NAME (ctype)) ! 2792: { ! 2793: method_prototype = lookup_instance_method_static (implementation_template, sel_name); ! 2794: ! 2795: if (!method_prototype && implementation_template != implementation_context) ! 2796: /* the method is not published in the interface...check locally */ ! 2797: method_prototype = lookup_method (CLASS_NST_METHODS (implementation_context), ! 2798: sel_name); ! 2799: } ! 2800: else ! 2801: { ! 2802: tree iface; ! 2803: ! 2804: if (iface = lookup_interface (TYPE_NAME (ctype))) ! 2805: method_prototype = lookup_instance_method_static (iface, sel_name); ! 2806: } ! 2807: ! 2808: if (!method_prototype) ! 2809: warning ("`%s' does not respond to `%s'", ! 2810: IDENTIFIER_POINTER (TYPE_NAME (ctype)), ! 2811: IDENTIFIER_POINTER (sel_name)); ! 2812: } ! 2813: else if (class_ident) ! 2814: { ! 2815: if (implementation_context ! 2816: && CLASS_NAME (implementation_context) == class_ident) ! 2817: { ! 2818: method_prototype ! 2819: = lookup_class_method_static (implementation_template, sel_name); ! 2820: ! 2821: if (!method_prototype ! 2822: && implementation_template != implementation_context) ! 2823: /* the method is not published in the interface...check locally */ ! 2824: method_prototype ! 2825: = lookup_method (CLASS_CLS_METHODS (implementation_context), ! 2826: sel_name); ! 2827: } ! 2828: else ! 2829: { ! 2830: tree iface; ! 2831: ! 2832: if (iface = lookup_interface (class_ident)) ! 2833: method_prototype = lookup_class_method_static (iface, sel_name); ! 2834: } ! 2835: ! 2836: if (!method_prototype) ! 2837: { ! 2838: warning ("cannot find class (factory) method."); ! 2839: warning ("return type for `%s' defaults to id", ! 2840: IDENTIFIER_POINTER (sel_name)); ! 2841: } ! 2842: } ! 2843: else ! 2844: { ! 2845: hash hsh; ! 2846: ! 2847: /* we think we have an instance...loophole: extern id Object; */ ! 2848: hsh = hash_lookup (nst_method_hash_list, sel_name); ! 2849: if (!hsh) ! 2850: /* for various loopholes...like sending messages to self in a ! 2851: factory context... */ ! 2852: hsh = hash_lookup (cls_method_hash_list, sel_name); ! 2853: ! 2854: method_prototype = check_duplicates (hsh); ! 2855: if (!method_prototype) ! 2856: { ! 2857: warning ("cannot find method."); ! 2858: warning ("return type for `%s' defaults to id", ! 2859: IDENTIFIER_POINTER (sel_name)); ! 2860: } ! 2861: } ! 2862: ! 2863: /* Save the selector name for printing error messages. */ ! 2864: building_objc_message_expr = sel_name; ! 2865: ! 2866: retval = build_objc_method_call (super, method_prototype, ! 2867: receiver, self_object, ! 2868: selector, method_params); ! 2869: ! 2870: building_objc_message_expr = 0; ! 2871: ! 2872: return retval; ! 2873: } ! 2874: ! 2875: /* Build a tree expression to send OBJECT the operation SELECTOR, ! 2876: looking up the method on object LOOKUP_OBJECT (often same as OBJECT), ! 2877: assuming the method has prototype METHOD_PROTOTYPE. ! 2878: (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.) ! 2879: Use METHOD_PARAMS as list of args to pass to the method. ! 2880: If SUPER_FLAG is nonzero, we look up the superclass's method. */ ! 2881: ! 2882: static tree ! 2883: build_objc_method_call (super_flag, method_prototype, lookup_object, object, ! 2884: selector, method_params) ! 2885: int super_flag; ! 2886: tree method_prototype, lookup_object, object, selector, method_params; ! 2887: { ! 2888: tree sender = (super_flag ? _msgSuper_decl : _msg_decl); ! 2889: ! 2890: #ifdef NEXT_OBJC_RUNTIME ! 2891: if (!method_prototype) ! 2892: { ! 2893: method_params = tree_cons (NULLT, lookup_object, ! 2894: tree_cons (NULLT, selector, method_params)); ! 2895: return build_function_call (sender, method_params); ! 2896: } ! 2897: else ! 2898: { ! 2899: /* This is a real kludge, but it is used only for the Next. ! 2900: Clobber the data type of SENDER temporarily to accept ! 2901: all the arguments for this operation, and to return ! 2902: whatever this operation returns. */ ! 2903: tree arglist = NULLT; ! 2904: tree retval; ! 2905: ! 2906: /* Save the proper contents of SENDER's data type. */ ! 2907: tree savarg = TYPE_ARG_TYPES (TREE_TYPE (sender)); ! 2908: tree savret = TREE_TYPE (TREE_TYPE (sender)); ! 2909: ! 2910: /* Install this method's argument types. */ ! 2911: arglist = get_arg_type_list (method_prototype, METHOD_REF, super_flag); ! 2912: TYPE_ARG_TYPES (TREE_TYPE (sender)) = arglist; ! 2913: ! 2914: /* Install this method's return type. */ ! 2915: TREE_TYPE (TREE_TYPE (sender)) ! 2916: = groktypename (TREE_TYPE (method_prototype)); ! 2917: ! 2918: /* Call SENDER with all the parameters. ! 2919: This will do type checking using the arg types for this method. */ ! 2920: method_params = tree_cons (NULLT, lookup_object, ! 2921: tree_cons (NULLT, selector, method_params)); ! 2922: retval = build_function_call (sender, method_params); ! 2923: ! 2924: /* Restore SENDER's return/argument types. */ ! 2925: TYPE_ARG_TYPES (TREE_TYPE (sender)) = savarg; ! 2926: TREE_TYPE (TREE_TYPE (sender)) = savret; ! 2927: return retval; ! 2928: } ! 2929: #else /* not NEXT_OBJC_RUNTIME */ ! 2930: /* This is the portable way. ! 2931: First call the lookup function to get a pointer to the method, ! 2932: then cast the pointer, then call it with the method arguments. */ ! 2933: tree method; ! 2934: ! 2935: /* Avoid trouble since we may evaluate each of these twice. */ ! 2936: object = save_expr (object); ! 2937: selector = save_expr (selector); ! 2938: ! 2939: method ! 2940: = build_function_call (sender, ! 2941: tree_cons (NULLT, lookup_object, ! 2942: tree_cons (NULLT, selector, NULLT))); ! 2943: ! 2944: /* If we have a method prototype, construct the data type this method needs, ! 2945: and cast what we got from SENDER into a pointer to that type. */ ! 2946: if (method_prototype) ! 2947: { ! 2948: tree arglist = get_arg_type_list (method_prototype, METHOD_REF, super_flag); ! 2949: tree valtype = groktypename (TREE_TYPE (method_prototype)); ! 2950: tree fake_function_type = build_function_type (valtype, arglist); ! 2951: TREE_TYPE (method) = build_pointer_type (fake_function_type); ! 2952: } ! 2953: else ! 2954: { ! 2955: TREE_TYPE (method) ! 2956: = build_pointer_type (build_function_type (ptr_type_node, NULLT)); ! 2957: } ! 2958: /* Pass the object to the method. */ ! 2959: return build_function_call (method, ! 2960: tree_cons (NULLT, object, ! 2961: tree_cons (NULLT, selector, ! 2962: method_params))); ! 2963: #endif /* not NEXT_OBJC_RUNTIME */ ! 2964: } ! 2965: ! 2966: tree ! 2967: build_selector_expr (selnamelist) ! 2968: tree selnamelist; ! 2969: { ! 2970: tree selname; ! 2971: int selTransTbl_index; ! 2972: ! 2973: if (!doing_objc_thang) ! 2974: fatal ("Objective-C text in C source file"); ! 2975: ! 2976: /* obtain the full selector name */ ! 2977: if (TREE_CODE (selnamelist) == IDENTIFIER_NODE) ! 2978: /* a unary selector */ ! 2979: selname = selnamelist; ! 2980: else if (TREE_CODE (selnamelist) == TREE_LIST) ! 2981: selname = build_keyword_selector (selnamelist); ! 2982: ! 2983: selTransTbl_index = add_selector_reference (selname); ! 2984: ! 2985: #ifndef OBJC_NONUNIQUE_SELECTORS ! 2986: return build_selector_reference (selTransTbl_index); ! 2987: #else ! 2988: /* synthesize a reference into the selector translation table */ ! 2989: return build_array_ref (_OBJC_SELECTOR_REFERENCES_decl, ! 2990: build_int_2 (selTransTbl_index, 0)); ! 2991: #endif ! 2992: } ! 2993: ! 2994: tree ! 2995: build_encode_expr (type) ! 2996: tree type; ! 2997: { ! 2998: if (!doing_objc_thang) ! 2999: fatal ("Objective-C text in C source file"); ! 3000: ! 3001: if (!utlbuf) ! 3002: utlbuf = (char *)xmalloc (BUFSIZE); ! 3003: bzero (utlbuf, BUFSIZE); ! 3004: ! 3005: encode_type (type, utlbuf, OBJC_ENCODE_INLINE_DEFS); ! 3006: ! 3007: /* synthesize a string that represents the encoded struct/union */ ! 3008: return my_build_string (strlen (utlbuf) + 1, utlbuf); ! 3009: } ! 3010: ! 3011: tree ! 3012: build_ivar_reference (id) ! 3013: tree id; ! 3014: { ! 3015: if (TREE_CODE (method_context) == CLASS_METHOD_DECL) ! 3016: TREE_TYPE (self_decl) = instance_type; /* cast */ ! 3017: ! 3018: return build_component_ref (build_indirect_ref (self_decl, "->"), id); ! 3019: } ! 3020: ! 3021: #define HASH_ALLOC_LIST_SIZE 170 ! 3022: #define ATTR_ALLOC_LIST_SIZE 170 ! 3023: #define SIZEHASHTABLE 257 ! 3024: #define HASHFUNCTION(key) ((int)key >> 2) /* divide by 4 */ ! 3025: ! 3026: static void ! 3027: hash_init () ! 3028: { ! 3029: nst_method_hash_list = (hash *)xmalloc (SIZEHASHTABLE * sizeof (hash)); ! 3030: cls_method_hash_list = (hash *)xmalloc (SIZEHASHTABLE * sizeof (hash)); ! 3031: ! 3032: if (!nst_method_hash_list || !cls_method_hash_list) ! 3033: perror ("unable to allocate space in objc-tree.c"); ! 3034: else ! 3035: { ! 3036: int i; ! 3037: ! 3038: for (i = 0; i < SIZEHASHTABLE; i++) ! 3039: { ! 3040: nst_method_hash_list[i] = 0; ! 3041: cls_method_hash_list[i] = 0; ! 3042: } ! 3043: } ! 3044: } ! 3045: ! 3046: static void ! 3047: hash_enter (hashlist, method) ! 3048: hash *hashlist; ! 3049: tree method; ! 3050: { ! 3051: static hash hash_alloc_list = 0; ! 3052: static int hash_alloc_index = 0; ! 3053: hash obj; ! 3054: int slot = HASHFUNCTION (METHOD_SEL_NAME (method)) % SIZEHASHTABLE; ! 3055: ! 3056: if (!hash_alloc_list || hash_alloc_index >= HASH_ALLOC_LIST_SIZE) ! 3057: { ! 3058: hash_alloc_index = 0; ! 3059: hash_alloc_list = (hash)xmalloc (sizeof (struct hashedEntry) * ! 3060: HASH_ALLOC_LIST_SIZE); ! 3061: if (!hash_alloc_list) ! 3062: perror ("unable to allocate in objc-tree.c"); ! 3063: } ! 3064: obj = &hash_alloc_list[hash_alloc_index++]; ! 3065: obj->list = 0; ! 3066: obj->next = hashlist[slot]; ! 3067: obj->key = method; ! 3068: ! 3069: hashlist[slot] = obj; /* append to front */ ! 3070: } ! 3071: ! 3072: static hash ! 3073: hash_lookup (hashlist, sel_name) ! 3074: hash *hashlist; ! 3075: tree sel_name; ! 3076: { ! 3077: hash target; ! 3078: ! 3079: target = hashlist[HASHFUNCTION (sel_name) % SIZEHASHTABLE]; ! 3080: ! 3081: while (target) ! 3082: { ! 3083: if (sel_name == METHOD_SEL_NAME (target->key)) ! 3084: return target; ! 3085: ! 3086: target = target->next; ! 3087: } ! 3088: return 0; ! 3089: } ! 3090: ! 3091: static void ! 3092: hash_add_attr (entry, value) ! 3093: hash entry; ! 3094: tree value; ! 3095: { ! 3096: static attr attr_alloc_list = 0; ! 3097: static int attr_alloc_index = 0; ! 3098: attr obj; ! 3099: ! 3100: if (!attr_alloc_list || attr_alloc_index >= ATTR_ALLOC_LIST_SIZE) ! 3101: { ! 3102: attr_alloc_index = 0; ! 3103: attr_alloc_list = (attr)xmalloc (sizeof (struct hashedAttribute) * ! 3104: ATTR_ALLOC_LIST_SIZE); ! 3105: if (!attr_alloc_list) ! 3106: perror ("unable to allocate in objc-tree.c"); ! 3107: } ! 3108: obj = &attr_alloc_list[attr_alloc_index++]; ! 3109: obj->next = entry->list; ! 3110: obj->value = value; ! 3111: ! 3112: entry->list = obj; /* append to front */ ! 3113: } ! 3114: ! 3115: static tree ! 3116: lookup_method (mchain, method) ! 3117: tree mchain; ! 3118: tree method; ! 3119: { ! 3120: tree key; ! 3121: ! 3122: if (TREE_CODE (method) == IDENTIFIER_NODE) ! 3123: key = method; ! 3124: else ! 3125: key = METHOD_SEL_NAME (method); ! 3126: ! 3127: while (mchain) ! 3128: { ! 3129: if (METHOD_SEL_NAME (mchain) == key) ! 3130: return mchain; ! 3131: mchain = TREE_CHAIN (mchain); ! 3132: } ! 3133: return NULLT; ! 3134: } ! 3135: ! 3136: static tree ! 3137: lookup_instance_method_static (interface, ident) ! 3138: tree interface; ! 3139: tree ident; ! 3140: { ! 3141: tree inter = interface; ! 3142: tree chain = CLASS_NST_METHODS (inter); ! 3143: tree meth = NULLT; ! 3144: ! 3145: do ! 3146: { ! 3147: if (meth = lookup_method (chain, ident)) ! 3148: return meth; ! 3149: ! 3150: if (CLASS_CATEGORY_LIST (inter)) ! 3151: { ! 3152: tree category = CLASS_CATEGORY_LIST (inter); ! 3153: chain = CLASS_NST_METHODS (category); ! 3154: ! 3155: do ! 3156: { ! 3157: if (meth = lookup_method (chain, ident)) ! 3158: return meth; ! 3159: ! 3160: if (category = CLASS_CATEGORY_LIST (category)) ! 3161: chain = CLASS_NST_METHODS (category); ! 3162: } ! 3163: while (category); ! 3164: } ! 3165: ! 3166: if (inter = lookup_interface (CLASS_SUPER_NAME (inter))) ! 3167: chain = CLASS_NST_METHODS (inter); ! 3168: } ! 3169: while (inter); ! 3170: ! 3171: return meth; ! 3172: } ! 3173: ! 3174: static tree ! 3175: lookup_class_method_static (interface, ident) ! 3176: tree interface; ! 3177: tree ident; ! 3178: { ! 3179: tree inter = interface; ! 3180: tree chain = CLASS_CLS_METHODS (inter); ! 3181: tree meth = NULLT; ! 3182: ! 3183: do ! 3184: { ! 3185: if (meth = lookup_method (chain, ident)) ! 3186: return meth; ! 3187: ! 3188: if (CLASS_CATEGORY_LIST (inter)) ! 3189: { ! 3190: tree category = CLASS_CATEGORY_LIST (inter); ! 3191: chain = CLASS_CLS_METHODS (category); ! 3192: ! 3193: do ! 3194: { ! 3195: if (meth = lookup_method (chain, ident)) ! 3196: return meth; ! 3197: ! 3198: if (category = CLASS_CATEGORY_LIST (category)) ! 3199: chain = CLASS_CLS_METHODS (category); ! 3200: } ! 3201: while (category); ! 3202: } ! 3203: ! 3204: if (inter = lookup_interface (CLASS_SUPER_NAME (inter))) ! 3205: chain = CLASS_CLS_METHODS (inter); ! 3206: } ! 3207: while (inter); ! 3208: ! 3209: return meth; ! 3210: } ! 3211: ! 3212: tree ! 3213: add_class_method (class, method) ! 3214: tree class; ! 3215: tree method; ! 3216: { ! 3217: tree mth; ! 3218: hash hsh; ! 3219: ! 3220: if (!(mth = lookup_method (CLASS_CLS_METHODS (class), method))) ! 3221: { ! 3222: /* put method on list in reverse order */ ! 3223: TREE_CHAIN (method) = CLASS_CLS_METHODS (class); ! 3224: CLASS_CLS_METHODS (class) = method; ! 3225: } ! 3226: else ! 3227: { ! 3228: if (TREE_CODE (class) == IMPLEMENTATION_TYPE) ! 3229: error ("duplicate definition of class method `%s'.", ! 3230: IDENTIFIER_POINTER (METHOD_SEL_NAME (mth))); ! 3231: else ! 3232: { ! 3233: /* check types, if different complain */ ! 3234: if (!comp_proto_with_proto (method, mth)) ! 3235: error ("duplicate declaration of class method `%s'.", ! 3236: IDENTIFIER_POINTER (METHOD_SEL_NAME (mth))); ! 3237: } ! 3238: } ! 3239: ! 3240: if (!(hsh = hash_lookup (cls_method_hash_list, METHOD_SEL_NAME (method)))) ! 3241: { ! 3242: /* install on a global chain */ ! 3243: hash_enter (cls_method_hash_list, method); ! 3244: } ! 3245: else ! 3246: { ! 3247: /* check types, if different add to a list */ ! 3248: if (!comp_proto_with_proto (method, hsh->key)) ! 3249: hash_add_attr (hsh, method); ! 3250: } ! 3251: return method; ! 3252: } ! 3253: ! 3254: tree ! 3255: add_instance_method (class, method) ! 3256: tree class; ! 3257: tree method; ! 3258: { ! 3259: tree mth; ! 3260: hash hsh; ! 3261: ! 3262: if (!(mth = lookup_method (CLASS_NST_METHODS (class), method))) ! 3263: { ! 3264: /* put method on list in reverse order */ ! 3265: TREE_CHAIN (method) = CLASS_NST_METHODS (class); ! 3266: CLASS_NST_METHODS (class) = method; ! 3267: } ! 3268: else ! 3269: { ! 3270: if (TREE_CODE (class) == IMPLEMENTATION_TYPE) ! 3271: error ("duplicate definition of instance method `%s'.", ! 3272: IDENTIFIER_POINTER (METHOD_SEL_NAME (mth))); ! 3273: else ! 3274: { ! 3275: /* check types, if different complain */ ! 3276: if (!comp_proto_with_proto (method, mth)) ! 3277: error ("duplicate declaration of instance method `%s'.", ! 3278: IDENTIFIER_POINTER (METHOD_SEL_NAME (mth))); ! 3279: } ! 3280: } ! 3281: ! 3282: if (!(hsh = hash_lookup (nst_method_hash_list, METHOD_SEL_NAME (method)))) ! 3283: { ! 3284: /* install on a global chain */ ! 3285: hash_enter (nst_method_hash_list, method); ! 3286: } ! 3287: else ! 3288: { ! 3289: /* check types, if different add to a list */ ! 3290: if (!comp_proto_with_proto (method, hsh->key)) ! 3291: hash_add_attr (hsh, method); ! 3292: } ! 3293: return method; ! 3294: } ! 3295: ! 3296: static tree ! 3297: add_class (class) ! 3298: tree class; ! 3299: { ! 3300: /* put interfaces on list in reverse order */ ! 3301: TREE_CHAIN (class) = interface_chain; ! 3302: interface_chain = class; ! 3303: return interface_chain; ! 3304: } ! 3305: ! 3306: static void ! 3307: add_category (class, category) ! 3308: tree class; ! 3309: tree category; ! 3310: { ! 3311: /* put categories on list in reverse order */ ! 3312: CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (class); ! 3313: CLASS_CATEGORY_LIST (class) = category; ! 3314: } ! 3315: ! 3316: /* called after parsing each instance variable declaration. Necessary to ! 3317: * preserve typedefs and implement public/private... ! 3318: */ ! 3319: tree ! 3320: add_instance_variable (class, public, declarator, declspecs, width) ! 3321: tree class; ! 3322: int public; ! 3323: tree declarator; ! 3324: tree declspecs; ! 3325: tree width; ! 3326: { ! 3327: tree field_decl, raw_decl; ! 3328: ! 3329: raw_decl = build_tree_list (declspecs /*purpose*/, declarator/*value*/); ! 3330: ! 3331: if (CLASS_RAW_IVARS (class)) ! 3332: chainon (CLASS_RAW_IVARS (class), raw_decl); ! 3333: else ! 3334: CLASS_RAW_IVARS (class) = raw_decl; ! 3335: ! 3336: field_decl = grokfield (input_filename, lineno, ! 3337: declarator, declspecs, width); ! 3338: ! 3339: /* overload the public attribute, it is not used for FIELD_DECL's */ ! 3340: if (public) ! 3341: TREE_PUBLIC (field_decl) = 1; ! 3342: ! 3343: if (CLASS_IVARS (class)) ! 3344: chainon (CLASS_IVARS (class), field_decl); ! 3345: else ! 3346: CLASS_IVARS (class) = field_decl; ! 3347: ! 3348: return class; ! 3349: } ! 3350: ! 3351: tree ! 3352: is_ivar (decl_chain, ident) ! 3353: tree decl_chain; ! 3354: tree ident; ! 3355: { ! 3356: for ( ; decl_chain; decl_chain = TREE_CHAIN (decl_chain)) ! 3357: if (DECL_NAME (decl_chain) == ident) ! 3358: return decl_chain; ! 3359: return NULL_TREE; ! 3360: } ! 3361: ! 3362: /* we have an instance variable reference, check to see if it is public...*/ ! 3363: ! 3364: int ! 3365: is_public (expr, identifier) ! 3366: tree expr; ! 3367: tree identifier; ! 3368: { ! 3369: tree basetype = TREE_TYPE (expr); ! 3370: enum tree_code code = TREE_CODE (basetype); ! 3371: tree decl; ! 3372: ! 3373: if (code == RECORD_TYPE) ! 3374: { ! 3375: if (TREE_STATIC_TEMPLATE (basetype)) ! 3376: { ! 3377: if (decl = is_ivar (TYPE_FIELDS (basetype), identifier)) ! 3378: { ! 3379: /* important diffence between the Stepstone translator: ! 3380: ! 3381: all instance variables should be public within the context ! 3382: of the implementation... ! 3383: */ ! 3384: if (implementation_context) ! 3385: { ! 3386: if ((TREE_CODE (implementation_context) == IMPLEMENTATION_TYPE ! 3387: && CLASS_NAME (implementation_context) == TYPE_NAME (basetype)) ! 3388: || (TREE_CODE (implementation_context) == CATEGORY_TYPE ! 3389: && CLASS_NAME (implementation_context) == TYPE_NAME (basetype))) ! 3390: return 1; ! 3391: } ! 3392: ! 3393: if (TREE_PUBLIC (decl)) ! 3394: return 1; ! 3395: ! 3396: error ("instance variable `%s' is declared private", ! 3397: IDENTIFIER_POINTER (identifier)); ! 3398: return 0; ! 3399: } ! 3400: } ! 3401: else if (implementation_context && (basetype == objc_object_reference)) ! 3402: { ! 3403: TREE_TYPE (expr) = _PRIVATE_record; ! 3404: if (extra_warnings) ! 3405: { ! 3406: warning ("static access to object of type `id'"); ! 3407: warning ("please change to type `%s *'", ! 3408: IDENTIFIER_POINTER (CLASS_NAME (implementation_context))); ! 3409: } ! 3410: } ! 3411: } ! 3412: return 1; ! 3413: } ! 3414: ! 3415: /* implement @defs (<classname>) within struct bodies. */ ! 3416: ! 3417: tree ! 3418: get_class_ivars (interface) ! 3419: tree interface; ! 3420: { ! 3421: if (!doing_objc_thang) ! 3422: fatal ("Objective-C text in C source file"); ! 3423: ! 3424: return build_ivar_chain (interface); ! 3425: } ! 3426: ! 3427: tree ! 3428: get_class_reference (interface) ! 3429: tree interface; ! 3430: { ! 3431: tree params; ! 3432: ! 3433: add_class_reference (CLASS_NAME (interface)); ! 3434: ! 3435: params = build_tree_list (NULLT, ! 3436: my_build_string (IDENTIFIER_LENGTH (CLASS_NAME (interface)) + 1, ! 3437: IDENTIFIER_POINTER (CLASS_NAME (interface)))); ! 3438: ! 3439: return build_function_call (objc_getClass_decl, params); ! 3440: } ! 3441: ! 3442: /* make sure all entries in "chain" are also in "list" */ ! 3443: ! 3444: static void ! 3445: check_methods (chain, list, mtype) ! 3446: tree chain; ! 3447: tree list; ! 3448: int mtype; ! 3449: { ! 3450: int first = 1; ! 3451: ! 3452: while (chain) ! 3453: { ! 3454: if (!lookup_method (list, chain)) ! 3455: { ! 3456: if (first) ! 3457: { ! 3458: if (TREE_CODE (implementation_context) == IMPLEMENTATION_TYPE) ! 3459: warning ("incomplete implementation of class `%s'", ! 3460: IDENTIFIER_POINTER (CLASS_NAME (implementation_context))); ! 3461: else if (TREE_CODE (implementation_context) == CATEGORY_TYPE) ! 3462: warning ("incomplete implementation of category `%s'", ! 3463: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context))); ! 3464: first = 0; ! 3465: } ! 3466: warning ("method definition for `%c%s' not found", ! 3467: mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain))); ! 3468: } ! 3469: chain = TREE_CHAIN (chain); ! 3470: } ! 3471: } ! 3472: ! 3473: tree ! 3474: start_class (code, class_name, super_name) ! 3475: enum tree_code code; ! 3476: tree class_name; ! 3477: tree super_name; ! 3478: { ! 3479: tree class; ! 3480: ! 3481: if (!doing_objc_thang) ! 3482: fatal ("Objective-C text in C source file"); ! 3483: ! 3484: class = make_node (code); ! 3485: ! 3486: CLASS_NAME (class) = class_name; ! 3487: CLASS_SUPER_NAME (class) = super_name; ! 3488: CLASS_CLS_METHODS (class) = NULL_TREE; ! 3489: ! 3490: if (code == IMPLEMENTATION_TYPE) ! 3491: { ! 3492: /* pre-build the following entities - for speed/convenience. */ ! 3493: if (!self_id) ! 3494: self_id = get_identifier ("self"); ! 3495: if (!_cmd_id) ! 3496: _cmd_id = get_identifier ("_cmd"); ! 3497: ! 3498: if (!objc_super_template) ! 3499: objc_super_template = build_super_template (); ! 3500: ! 3501: method_slot = 0; /* reset for multiple classes per file */ ! 3502: ! 3503: implementation_context = class; ! 3504: ! 3505: /* lookup the interface for this implementation. */ ! 3506: ! 3507: if (!(implementation_template = lookup_interface (class_name))) ! 3508: { ! 3509: warning ("Cannot find interface declaration for `%s'", ! 3510: IDENTIFIER_POINTER (class_name)); ! 3511: add_class (implementation_template = implementation_context); ! 3512: } ! 3513: ! 3514: /* if a super class has been specified in the implementation, ! 3515: insure it conforms to the one specified in the interface */ ! 3516: ! 3517: if (super_name ! 3518: && (super_name != CLASS_SUPER_NAME (implementation_template))) ! 3519: { ! 3520: error ("conflicting super class name `%s'", ! 3521: IDENTIFIER_POINTER (super_name)); ! 3522: error ("previous declaration of `%s'", ! 3523: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_template))); ! 3524: } ! 3525: } ! 3526: else if (code == INTERFACE_TYPE) ! 3527: { ! 3528: if (lookup_interface (class_name)) ! 3529: warning ("duplicate interface declaration for class `%s'", ! 3530: IDENTIFIER_POINTER (class_name)); ! 3531: else ! 3532: add_class (class); ! 3533: } ! 3534: else if (code == PROTOCOL_TYPE) ! 3535: { ! 3536: tree class_category_is_assoc_with; ! 3537: ! 3538: /* for a category, class_name is really the name of the class that ! 3539: the following set of methods will be associated with...we must ! 3540: find the interface so that can derive the objects template */ ! 3541: ! 3542: if (!(class_category_is_assoc_with = lookup_interface (class_name))) ! 3543: { ! 3544: error ("Cannot find interface declaration for `%s'", ! 3545: IDENTIFIER_POINTER (class_name)); ! 3546: exit (1); ! 3547: } ! 3548: else ! 3549: add_category (class_category_is_assoc_with, class); ! 3550: } ! 3551: else if (code == CATEGORY_TYPE) ! 3552: { ! 3553: /* pre-build the following entities - for speed/convenience. */ ! 3554: if (!self_id) ! 3555: self_id = get_identifier ("self"); ! 3556: if (!_cmd_id) ! 3557: _cmd_id = get_identifier ("_cmd"); ! 3558: ! 3559: if (!objc_super_template) ! 3560: objc_super_template = build_super_template (); ! 3561: ! 3562: method_slot = 0; /* reset for multiple classes per file */ ! 3563: ! 3564: implementation_context = class; ! 3565: ! 3566: /* for a category, class_name is really the name of the class that ! 3567: the following set of methods will be associated with...we must ! 3568: find the interface so that can derive the objects template */ ! 3569: ! 3570: if (!(implementation_template = lookup_interface (class_name))) ! 3571: { ! 3572: error ("Cannot find interface declaration for `%s'", ! 3573: IDENTIFIER_POINTER (class_name)); ! 3574: exit (1); ! 3575: } ! 3576: } ! 3577: return class; ! 3578: } ! 3579: ! 3580: tree ! 3581: continue_class (class) ! 3582: tree class; ! 3583: { ! 3584: if (TREE_CODE (class) == IMPLEMENTATION_TYPE ! 3585: || TREE_CODE (class) == CATEGORY_TYPE) ! 3586: { ! 3587: struct imp_entry *impEntry; ! 3588: tree ivar_context; ! 3589: ! 3590: /* check consistency of the instance variables. */ ! 3591: ! 3592: if (CLASS_IVARS (class)) ! 3593: check_ivars (implementation_template, class); ! 3594: ! 3595: /* code generation */ ! 3596: ! 3597: ivar_context = build_private_template (implementation_template); ! 3598: ! 3599: if (!objc_class_template) ! 3600: build_class_template (); ! 3601: ! 3602: if (!(impEntry = (struct imp_entry *)xmalloc (sizeof (struct imp_entry)))) ! 3603: perror ("unable to allocate in objc-tree.c"); ! 3604: ! 3605: impEntry->next = imp_list; ! 3606: impEntry->imp_context = class; ! 3607: impEntry->imp_template = implementation_template; ! 3608: ! 3609: synth_forward_declarations (); ! 3610: impEntry->class_decl = _OBJC_CLASS_decl; ! 3611: impEntry->meta_decl = _OBJC_METACLASS_decl; ! 3612: ! 3613: /* append to front and increment count */ ! 3614: imp_list = impEntry; ! 3615: if (TREE_CODE (class) == IMPLEMENTATION_TYPE) ! 3616: imp_count++; ! 3617: else ! 3618: cat_count++; ! 3619: ! 3620: return ivar_context; ! 3621: } ! 3622: else if (TREE_CODE (class) == INTERFACE_TYPE) ! 3623: { ! 3624: tree record = xref_tag (RECORD_TYPE, CLASS_NAME (class)); ! 3625: ! 3626: if (!TYPE_FIELDS (record)) ! 3627: { ! 3628: finish_struct (record, build_ivar_chain (class)); ! 3629: CLASS_STATIC_TEMPLATE (class) = record; ! 3630: ! 3631: /* mark this record as a class template - for static typing */ ! 3632: TREE_STATIC_TEMPLATE (record) = 1; ! 3633: } ! 3634: return NULLT; ! 3635: } ! 3636: else ! 3637: return error_mark_node; ! 3638: } ! 3639: ! 3640: /* ! 3641: * this is called once we see the "@end" in an interface/implementation. ! 3642: */ ! 3643: void ! 3644: finish_class (class) ! 3645: tree class; ! 3646: { ! 3647: if (TREE_CODE (class) == IMPLEMENTATION_TYPE) ! 3648: { ! 3649: /* all code generation is done in finish_objc */ ! 3650: ! 3651: if (implementation_template != implementation_context) ! 3652: { ! 3653: /* ensure that all method listed in the interface contain bodies! */ ! 3654: check_methods (CLASS_CLS_METHODS (implementation_template), ! 3655: CLASS_CLS_METHODS (implementation_context), '+'); ! 3656: check_methods (CLASS_NST_METHODS (implementation_template), ! 3657: CLASS_NST_METHODS (implementation_context), '-'); ! 3658: } ! 3659: } ! 3660: else if (TREE_CODE (class) == CATEGORY_TYPE) ! 3661: { ! 3662: tree category = CLASS_CATEGORY_LIST (implementation_template); ! 3663: ! 3664: /* find the category interface from the class it is associated with */ ! 3665: while (category) ! 3666: { ! 3667: if (CLASS_SUPER_NAME (class) == CLASS_SUPER_NAME (category)) ! 3668: break; ! 3669: category = CLASS_CATEGORY_LIST (category); ! 3670: } ! 3671: ! 3672: if (category) ! 3673: { ! 3674: /* ensure that all method listed in the interface contain bodies! */ ! 3675: check_methods (CLASS_CLS_METHODS (category), ! 3676: CLASS_CLS_METHODS (implementation_context), '+'); ! 3677: check_methods (CLASS_NST_METHODS (category), ! 3678: CLASS_NST_METHODS (implementation_context), '-'); ! 3679: } ! 3680: } ! 3681: else if (TREE_CODE (class) == INTERFACE_TYPE) ! 3682: { ! 3683: tree decl_specs; ! 3684: ! 3685: /* extern struct objc_object *_<my_name>; */ ! 3686: ! 3687: sprintf (utlbuf, "_%s", IDENTIFIER_POINTER (CLASS_NAME (class))); ! 3688: ! 3689: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_EXTERN]); ! 3690: decl_specs = tree_cons (NULLT, objc_object_reference, decl_specs); ! 3691: define_decl (build1 (INDIRECT_REF, NULLT, get_identifier (utlbuf)), decl_specs); ! 3692: } ! 3693: } ! 3694: ! 3695: static void ! 3696: encode_pointer (type, str, format) ! 3697: tree type; ! 3698: char *str; ! 3699: int format; ! 3700: { ! 3701: tree pointer_to = TREE_TYPE (type); ! 3702: ! 3703: if (TREE_CODE (pointer_to) == RECORD_TYPE) ! 3704: { ! 3705: if (TYPE_NAME (pointer_to) ! 3706: && TREE_CODE (TYPE_NAME (pointer_to)) == IDENTIFIER_NODE) ! 3707: { ! 3708: char *name = IDENTIFIER_POINTER (TYPE_NAME (pointer_to)); ! 3709: ! 3710: if ((strcmp (name, TAG_OBJECT) == 0) || /* '@' */ ! 3711: (TREE_STATIC_TEMPLATE (pointer_to))) ! 3712: { ! 3713: strcat (str, "@"); ! 3714: return; ! 3715: } ! 3716: else if (strcmp (name, TAG_CLASS) == 0) /* '#' */ ! 3717: { ! 3718: strcat (str, "#"); ! 3719: return; ! 3720: } ! 3721: #ifndef OBJC_INT_SELECTORS ! 3722: else if (strcmp (name, TAG_SELECTOR) == 0) /* ':' */ ! 3723: { ! 3724: strcat (str, ":"); ! 3725: return; ! 3726: } ! 3727: #endif /* OBJC_INT_SELECTORS */ ! 3728: } ! 3729: } ! 3730: else if (TREE_CODE (pointer_to) == INTEGER_TYPE ! 3731: && TYPE_MODE (pointer_to) == QImode) ! 3732: { ! 3733: strcat (str, "*"); ! 3734: return; ! 3735: } ! 3736: ! 3737: /* we have a type that does not get special treatment... */ ! 3738: ! 3739: /* NeXT extension */ ! 3740: strcat (str, "^"); ! 3741: encode_type (pointer_to, str, format); ! 3742: } ! 3743: ! 3744: static void ! 3745: encode_array (type, str, format) ! 3746: tree type; ! 3747: char *str; ! 3748: int format; ! 3749: { ! 3750: tree anIntCst = TYPE_SIZE (type); ! 3751: tree array_of = TREE_TYPE (type); ! 3752: ! 3753: /* An incomplete array is treated like a pointer. */ ! 3754: if (anIntCst == NULL) ! 3755: { ! 3756: /* split for obvious reasons. North-Keys 30 Mar 1991 */ ! 3757: encode_pointer (type, str, format); ! 3758: return; ! 3759: } ! 3760: ! 3761: sprintf (str + strlen (str), "[%d", ! 3762: TREE_INT_CST_LOW (anIntCst) ! 3763: / TREE_INT_CST_LOW (TYPE_SIZE (array_of))); ! 3764: encode_type (array_of, str, format); ! 3765: strcat (str, "]"); ! 3766: return; ! 3767: } ! 3768: ! 3769: static void ! 3770: encode_aggregate (type, str, format) ! 3771: tree type; ! 3772: char *str; ! 3773: int format; ! 3774: { ! 3775: enum tree_code code = TREE_CODE (type); ! 3776: ! 3777: switch (code) ! 3778: { ! 3779: case RECORD_TYPE: ! 3780: { ! 3781: if (str[strlen (str)-1] == '^') ! 3782: { ! 3783: /* we have a reference - this is a NeXT extension */ ! 3784: if (TYPE_NAME (type) ! 3785: && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)) ! 3786: sprintf (str + strlen (str), "{%s}", ! 3787: IDENTIFIER_POINTER (TYPE_NAME (type))); ! 3788: else /* we have an untagged structure or a typedef */ ! 3789: sprintf (str + strlen (str), "{?}"); ! 3790: } ! 3791: else ! 3792: { ! 3793: tree fields = TYPE_FIELDS (type); ! 3794: ! 3795: if (format == OBJC_ENCODE_INLINE_DEFS) ! 3796: { ! 3797: strcat (str, "{"); ! 3798: for ( ; fields; fields = TREE_CHAIN (fields)) ! 3799: encode_field_decl (fields, str, format); ! 3800: strcat (str, "}"); ! 3801: } ! 3802: else ! 3803: { ! 3804: if (TYPE_NAME (type) ! 3805: && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)) ! 3806: sprintf (str + strlen (str), "{%s}", ! 3807: IDENTIFIER_POINTER (TYPE_NAME (type))); ! 3808: else /* we have an untagged structure or a typedef */ ! 3809: sprintf (str + strlen (str), "{?}"); ! 3810: } ! 3811: } ! 3812: break; ! 3813: } ! 3814: case UNION_TYPE: ! 3815: { ! 3816: if (str[strlen (str)-1] == '^') ! 3817: { ! 3818: if (TYPE_NAME (type) ! 3819: && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)) ! 3820: /* we have a reference - this is a NeXT extension */ ! 3821: sprintf (str + strlen (str), "(%s)", ! 3822: IDENTIFIER_POINTER (TYPE_NAME (type))); ! 3823: else /* we have an untagged structure */ ! 3824: sprintf (str + strlen (str), "(?)"); ! 3825: } ! 3826: else ! 3827: { ! 3828: tree fields = TYPE_FIELDS (type); ! 3829: ! 3830: if (format == OBJC_ENCODE_INLINE_DEFS) ! 3831: { ! 3832: strcat (str, "("); ! 3833: for ( ; fields; fields = TREE_CHAIN (fields)) ! 3834: encode_field_decl (fields, str, format); ! 3835: strcat (str, ")"); ! 3836: } ! 3837: else ! 3838: { ! 3839: if (TYPE_NAME (type) && ! 3840: (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)) ! 3841: /* we have a reference - this is a NeXT extension */ ! 3842: sprintf (str + strlen (str), "(%s)", ! 3843: IDENTIFIER_POINTER (TYPE_NAME (type))); ! 3844: else /* we have an untagged structure */ ! 3845: sprintf (str + strlen (str), "(?)"); ! 3846: } ! 3847: } ! 3848: break; ! 3849: } ! 3850: case ENUMERAL_TYPE: ! 3851: strcat (str, "i"); ! 3852: break; ! 3853: } ! 3854: } ! 3855: ! 3856: /* ! 3857: * support bitfields, the current version of Objective-C does not support ! 3858: * them. the string will consist of one or more "b:n"'s where n is an ! 3859: * integer describing the width of the bitfield. Currently, classes in ! 3860: * the kit implement a method "-(char *)describeBitfieldStruct:" that ! 3861: * simulates this...if they do not implement this method, the archiver ! 3862: * assumes the bitfield is 16 bits wide (padded if necessary) and packed ! 3863: * according to the GNU compiler. After looking at the "kit", it appears ! 3864: * that all classes currently rely on this default behavior, rather than ! 3865: * hand generating this string (which is tedious). ! 3866: */ ! 3867: static void ! 3868: encode_bitfield (width, str, format) ! 3869: int width; ! 3870: char *str; ! 3871: int format; ! 3872: { ! 3873: sprintf (str + strlen (str), "b%d", width); ! 3874: } ! 3875: ! 3876: /* ! 3877: * format will be: ! 3878: * ! 3879: * OBJC_ENCODE_INLINE_DEFS or OBJC_ENCODE_DONT_INLINE_DEFS ! 3880: */ ! 3881: static void ! 3882: encode_type (type, str, format) ! 3883: tree type; ! 3884: char *str; ! 3885: int format; ! 3886: { ! 3887: enum tree_code code = TREE_CODE (type); ! 3888: ! 3889: if (code == INTEGER_TYPE) ! 3890: { ! 3891: if (TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) == 0) ! 3892: { ! 3893: /* unsigned integer types */ ! 3894: ! 3895: if (TYPE_MODE (type) == QImode) /* 'C' */ ! 3896: strcat (str, "C"); ! 3897: else if (TYPE_MODE (type) == HImode) /* 'S' */ ! 3898: strcat (str, "S"); ! 3899: else if (TYPE_MODE (type) == SImode) ! 3900: { ! 3901: if (type == long_unsigned_type_node) ! 3902: strcat (str, "L"); /* 'L' */ ! 3903: else ! 3904: strcat (str, "I"); /* 'I' */ ! 3905: } ! 3906: } ! 3907: else /* signed integer types */ ! 3908: { ! 3909: if (TYPE_MODE (type) == QImode) /* 'c' */ ! 3910: strcat (str, "c"); ! 3911: else if (TYPE_MODE (type) == HImode) /* 's' */ ! 3912: strcat (str, "s"); ! 3913: else if (TYPE_MODE (type) == SImode) /* 'i' */ ! 3914: { ! 3915: if (type == long_integer_type_node) ! 3916: strcat (str, "l"); /* 'l' */ ! 3917: else ! 3918: strcat (str, "i"); /* 'i' */ ! 3919: } ! 3920: } ! 3921: } ! 3922: else if (code == REAL_TYPE) ! 3923: { ! 3924: /* floating point types */ ! 3925: ! 3926: if (TYPE_MODE (type) == SFmode) /* 'f' */ ! 3927: strcat (str, "f"); ! 3928: else if (TYPE_MODE (type) == DFmode ! 3929: || TYPE_MODE (type) == TFmode) /* 'd' */ ! 3930: strcat (str, "d"); ! 3931: } ! 3932: ! 3933: else if (code == VOID_TYPE) /* 'v' */ ! 3934: strcat (str, "v"); ! 3935: ! 3936: else if (code == ARRAY_TYPE) ! 3937: encode_array (type, str, format); ! 3938: ! 3939: else if (code == POINTER_TYPE) ! 3940: encode_pointer (type, str, format); ! 3941: ! 3942: else if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE) ! 3943: encode_aggregate (type, str, format); ! 3944: ! 3945: else if (code == FUNCTION_TYPE) /* '?' */ ! 3946: strcat (str, "?"); ! 3947: } ! 3948: ! 3949: static void ! 3950: encode_field_decl (field_decl, str, format) ! 3951: tree field_decl; ! 3952: char *str; ! 3953: int format; ! 3954: { ! 3955: if (DECL_BIT_FIELD (field_decl)) ! 3956: encode_bitfield (DECL_FRAME_SIZE (field_decl), str, format); ! 3957: else ! 3958: encode_type (TREE_TYPE (field_decl), str, format); ! 3959: } ! 3960: ! 3961: static tree ! 3962: expr_last (complex_expr) ! 3963: tree complex_expr; ! 3964: { ! 3965: tree next; ! 3966: ! 3967: if (complex_expr) ! 3968: while (next = TREE_OPERAND (complex_expr, 0)) ! 3969: complex_expr = next; ! 3970: return complex_expr; ! 3971: } ! 3972: ! 3973: /* The selector of the current method, ! 3974: or NULL if we aren't compiling a method. */ ! 3975: ! 3976: tree ! 3977: maybe_objc_method_name (decl) ! 3978: tree decl; ! 3979: { ! 3980: if (method_context) ! 3981: return METHOD_SEL_NAME (method_context); ! 3982: else ! 3983: return 0; ! 3984: } ! 3985: ! 3986: /* ! 3987: * Transform a method definition into a function definition as follows: ! 3988: * ! 3989: * - synthesize the first two arguments, "self" and "_cmd". ! 3990: */ ! 3991: ! 3992: void ! 3993: start_method_def (method) ! 3994: tree method; ! 3995: { ! 3996: tree decl_specs; ! 3997: ! 3998: /* required to implement _msgSuper () */ ! 3999: method_context = method; ! 4000: _OBJC_SUPER_decl = NULLT; ! 4001: ! 4002: pushlevel (0); /* must be called BEFORE "start_function ()" */ ! 4003: ! 4004: /* generate prototype declarations for arguments..."new-style" */ ! 4005: ! 4006: if (TREE_CODE (method_context) == INSTANCE_METHOD_DECL) ! 4007: decl_specs = build_tree_list (NULLT, _PRIVATE_record); ! 4008: else ! 4009: /* really a `struct objc_class *'...however we allow people to ! 4010: assign to self...which changes its type midstream. ! 4011: */ ! 4012: decl_specs = build_tree_list (NULLT, objc_object_reference); ! 4013: ! 4014: push_parm_decl (build_tree_list (decl_specs, ! 4015: build1 (INDIRECT_REF, NULLT, self_id))); ! 4016: ! 4017: #ifdef OBJC_INT_SELECTORS ! 4018: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_UNSIGNED]); ! 4019: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs); ! 4020: push_parm_decl (build_tree_list (decl_specs, _cmd_id)); ! 4021: #else /* not OBJC_INT_SELECTORS */ ! 4022: decl_specs = build_tree_list (NULLT, ! 4023: xref_tag (RECORD_TYPE, ! 4024: get_identifier (TAG_SELECTOR))); ! 4025: push_parm_decl (build_tree_list (decl_specs, ! 4026: build1 (INDIRECT_REF, NULLT, _cmd_id))); ! 4027: #endif /* not OBJC_INT_SELECTORS */ ! 4028: ! 4029: /* generate argument delclarations if a keyword_decl */ ! 4030: if (METHOD_SEL_ARGS (method)) ! 4031: { ! 4032: tree arglist = METHOD_SEL_ARGS (method); ! 4033: do ! 4034: { ! 4035: tree arg_spec = TREE_PURPOSE (TREE_TYPE (arglist)); ! 4036: tree arg_decl = TREE_VALUE (TREE_TYPE (arglist)); ! 4037: ! 4038: if (arg_decl) ! 4039: { ! 4040: tree last_expr = expr_last (arg_decl); ! 4041: ! 4042: /* unite the abstract decl with its name */ ! 4043: TREE_OPERAND (last_expr, 0) = KEYWORD_ARG_NAME (arglist); ! 4044: push_parm_decl (build_tree_list (arg_spec, arg_decl)); ! 4045: /* unhook...restore the abstract declarator */ ! 4046: TREE_OPERAND (last_expr, 0) = NULLT; ! 4047: } ! 4048: else ! 4049: push_parm_decl (build_tree_list (arg_spec, KEYWORD_ARG_NAME (arglist))); ! 4050: ! 4051: arglist = TREE_CHAIN (arglist); ! 4052: } ! 4053: while (arglist); ! 4054: } ! 4055: ! 4056: if (METHOD_ADD_ARGS (method) > (tree)1) ! 4057: { ! 4058: /* we have a variable length selector - in "prototype" format */ ! 4059: tree akey = TREE_PURPOSE (METHOD_ADD_ARGS (method)); ! 4060: while (akey) ! 4061: { ! 4062: /* this must be done prior to calling pushdecl (). pushdecl () is ! 4063: * going to change our chain on us... ! 4064: */ ! 4065: tree nextkey = TREE_CHAIN (akey); ! 4066: pushdecl (akey); ! 4067: akey = nextkey; ! 4068: } ! 4069: } ! 4070: } ! 4071: ! 4072: static void ! 4073: error_with_method (message, mtype, method) ! 4074: char *message; ! 4075: char mtype; ! 4076: tree method; ! 4077: { ! 4078: count_error (0); ! 4079: fprintf (stderr, "%s:%d: ", ! 4080: DECL_SOURCE_FILE (method), DECL_SOURCE_LINE (method)); ! 4081: bzero (errbuf, BUFSIZE); ! 4082: fprintf (stderr, "%s `%c%s'\n", message, mtype, gen_method_decl (method, errbuf)); ! 4083: } ! 4084: ! 4085: static void ! 4086: warn_with_method (message, mtype, method) ! 4087: char *message; ! 4088: char mtype; ! 4089: tree method; ! 4090: { ! 4091: count_error (1); ! 4092: fprintf (stderr, "%s:%d: ", ! 4093: DECL_SOURCE_FILE (method), DECL_SOURCE_LINE (method)); ! 4094: bzero (errbuf, BUFSIZE); ! 4095: fprintf (stderr, "%s `%c%s'\n", message, mtype, gen_method_decl (method, errbuf)); ! 4096: } ! 4097: ! 4098: /* return 1 if `method' is consistent with `proto' */ ! 4099: ! 4100: static int ! 4101: comp_method_with_proto (method, proto) ! 4102: tree method, proto; ! 4103: { ! 4104: static tree function_type = 0; ! 4105: ! 4106: /* create a function_type node once */ ! 4107: if (!function_type) ! 4108: { ! 4109: struct obstack *ambient_obstack = current_obstack; ! 4110: ! 4111: current_obstack = &permanent_obstack; ! 4112: function_type = make_node (FUNCTION_TYPE); ! 4113: current_obstack = ambient_obstack; ! 4114: } ! 4115: ! 4116: /* install argument types - normally set by "build_function_type ()". */ ! 4117: TYPE_ARG_TYPES (function_type) = get_arg_type_list (proto, METHOD_DEF, 0); ! 4118: ! 4119: /* install return type */ ! 4120: TREE_TYPE (function_type) = groktypename (TREE_TYPE (proto)); ! 4121: ! 4122: return comptypes (TREE_TYPE (METHOD_DEFINITION (method)), function_type); ! 4123: } ! 4124: ! 4125: /* return 1 if `proto1' is consistent with `proto2' */ ! 4126: ! 4127: static int ! 4128: comp_proto_with_proto (proto1, proto2) ! 4129: tree proto1, proto2; ! 4130: { ! 4131: static tree function_type1 = 0, function_type2 = 0; ! 4132: ! 4133: /* create a couple function_type node's once */ ! 4134: if (!function_type1) ! 4135: { ! 4136: struct obstack *ambient_obstack = current_obstack; ! 4137: ! 4138: current_obstack = &permanent_obstack; ! 4139: function_type1 = make_node (FUNCTION_TYPE); ! 4140: function_type2 = make_node (FUNCTION_TYPE); ! 4141: current_obstack = ambient_obstack; ! 4142: } ! 4143: ! 4144: /* install argument types - normally set by "build_function_type ()". */ ! 4145: TYPE_ARG_TYPES (function_type1) = get_arg_type_list (proto1, METHOD_REF, 0); ! 4146: TYPE_ARG_TYPES (function_type2) = get_arg_type_list (proto2, METHOD_REF, 0); ! 4147: ! 4148: /* install return type */ ! 4149: TREE_TYPE (function_type1) = groktypename (TREE_TYPE (proto1)); ! 4150: TREE_TYPE (function_type2) = groktypename (TREE_TYPE (proto2)); ! 4151: ! 4152: return comptypes (function_type1, function_type2); ! 4153: } ! 4154: ! 4155: /* ! 4156: * - generate an identifier for the function. the format is "_n_cls", ! 4157: * where 1 <= n <= nMethods, and cls is the name the implementation we ! 4158: * are processing. ! 4159: * - install the return type from the method declaration. ! 4160: * - if we have a prototype, check for type consistency. ! 4161: */ ! 4162: static void ! 4163: really_start_method (method, parmlist) ! 4164: tree method, parmlist; ! 4165: { ! 4166: tree sc_spec, ret_spec, ret_decl, decl_specs; ! 4167: tree method_decl, method_id; ! 4168: char buf[256]; ! 4169: ! 4170: /* synth the storage class & assemble the return type */ ! 4171: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT); ! 4172: ret_spec = TREE_PURPOSE (TREE_TYPE (method)); ! 4173: decl_specs = chainon (sc_spec, ret_spec); ! 4174: ! 4175: if (TREE_CODE (implementation_context) == IMPLEMENTATION_TYPE) ! 4176: #ifdef OBJC_GEN_METHOD_LABEL ! 4177: OBJC_GEN_METHOD_LABEL (buf, ! 4178: TREE_CODE (method) == INSTANCE_METHOD_DECL, ! 4179: IDENTIFIER_POINTER (CLASS_NAME (implementation_context)), ! 4180: NULL, ! 4181: IDENTIFIER_POINTER (METHOD_SEL_NAME (method))); ! 4182: #else ! 4183: sprintf (buf, "_%d_%s", ++method_slot, ! 4184: IDENTIFIER_POINTER (CLASS_NAME (implementation_context))); ! 4185: #endif ! 4186: else /* we have a category */ ! 4187: #ifdef OBJC_GEN_METHOD_LABEL ! 4188: OBJC_GEN_METHOD_LABEL (buf, ! 4189: TREE_CODE (method) == INSTANCE_METHOD_DECL, ! 4190: IDENTIFIER_POINTER (CLASS_NAME (implementation_context)), ! 4191: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context)), ! 4192: IDENTIFIER_POINTER (METHOD_SEL_NAME (method))); ! 4193: #else ! 4194: sprintf (buf, "_%d_%s_%s", ++method_slot, ! 4195: IDENTIFIER_POINTER (CLASS_NAME (implementation_context)), ! 4196: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context))); ! 4197: #endif ! 4198: ! 4199: method_id = get_identifier (buf); ! 4200: ! 4201: method_decl = build_nt (CALL_EXPR, method_id, parmlist, NULLT); ! 4202: ! 4203: /* check the delclarator portion of the return type for the method */ ! 4204: if (ret_decl = TREE_VALUE (TREE_TYPE (method))) ! 4205: { ! 4206: /* ! 4207: * unite the complex decl (specified in the abstract decl) with the ! 4208: * function decl just synthesized...(int *), (int (*)()), (int (*)[]). ! 4209: */ ! 4210: tree save_expr = expr_last (ret_decl); ! 4211: ! 4212: TREE_OPERAND (save_expr, 0) = method_decl; ! 4213: method_decl = ret_decl; ! 4214: /* fool the parser into thinking it is starting a function */ ! 4215: start_function (decl_specs, method_decl, 0); ! 4216: /* unhook...this has the effect of restoring the abstract declarator */ ! 4217: TREE_OPERAND (save_expr, 0) = NULLT; ! 4218: } ! 4219: else ! 4220: { ! 4221: TREE_VALUE (TREE_TYPE (method)) = method_decl; ! 4222: /* fool the parser into thinking it is starting a function */ ! 4223: start_function (decl_specs, method_decl, 0); ! 4224: /* unhook...this has the effect of restoring the abstract declarator */ ! 4225: TREE_VALUE (TREE_TYPE (method)) = NULLT; ! 4226: } ! 4227: ! 4228: METHOD_DEFINITION (method) = current_function_decl; ! 4229: ! 4230: /* check consistency...start_function (), pushdecl (), duplicate_decls (). */ ! 4231: ! 4232: if (implementation_template != implementation_context) ! 4233: { ! 4234: tree chain, proto; ! 4235: ! 4236: if (TREE_CODE (method) == INSTANCE_METHOD_DECL) ! 4237: chain = CLASS_NST_METHODS (implementation_template); ! 4238: else ! 4239: chain = CLASS_CLS_METHODS (implementation_template); ! 4240: ! 4241: if (proto = lookup_method (chain, METHOD_SEL_NAME (method))) ! 4242: { ! 4243: if (!comp_method_with_proto (method, proto)) ! 4244: { ! 4245: fprintf (stderr, "%s: In method `%s'\n", input_filename, ! 4246: IDENTIFIER_POINTER (METHOD_SEL_NAME (method))); ! 4247: if (TREE_CODE (method) == INSTANCE_METHOD_DECL) ! 4248: { ! 4249: error_with_method ("conflicting types for", '-', method); ! 4250: error_with_method ("previous declaration of", '-', proto); ! 4251: } ! 4252: else ! 4253: { ! 4254: error_with_method ("conflicting types for", '+', method); ! 4255: error_with_method ("previous declaration of", '+', proto); ! 4256: } ! 4257: } ! 4258: } ! 4259: } ! 4260: } ! 4261: ! 4262: /* ! 4263: * the following routine is always called...this "architecture" is to ! 4264: * accommodate "old-style" variable length selectors. ! 4265: * ! 4266: * - a:a b:b // prototype ; id c; id d; // old-style ! 4267: */ ! 4268: void ! 4269: continue_method_def () ! 4270: { ! 4271: tree parmlist; ! 4272: ! 4273: if (METHOD_ADD_ARGS (method_context) == (tree)1) ! 4274: /* ! 4275: * we have a `, ...' immediately following the selector. ! 4276: */ ! 4277: parmlist = get_parm_info (0); ! 4278: else ! 4279: parmlist = get_parm_info (1); /* place a `void_at_end' */ ! 4280: ! 4281: /* set self_decl from the first argument...this global is used by ! 4282: * build_ivar_reference ().build_indirect_ref (). ! 4283: */ ! 4284: self_decl = TREE_PURPOSE (parmlist); ! 4285: ! 4286: poplevel (0, 0, 0); /* must be called BEFORE "start_function ()" */ ! 4287: ! 4288: really_start_method (method_context, parmlist); ! 4289: ! 4290: store_parm_decls (); /* must be called AFTER "start_function ()" */ ! 4291: } ! 4292: ! 4293: void ! 4294: add_objc_decls () ! 4295: { ! 4296: if (!_OBJC_SUPER_decl) ! 4297: _OBJC_SUPER_decl = start_decl (get_identifier (_TAG_SUPER), ! 4298: build_tree_list (NULLT, objc_super_template), 0); ! 4299: ! 4300: /* this prevents `unused variable' warnings when compiling with `-Wall' */ ! 4301: TREE_USED (_OBJC_SUPER_decl) = 1; ! 4302: } ! 4303: ! 4304: /* ! 4305: * _n_Method (id self, SEL sel, ...) ! 4306: * { ! 4307: * struct objc_super _S; ! 4308: * ! 4309: * _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...); ! 4310: * } ! 4311: */ ! 4312: tree ! 4313: get_super_receiver () ! 4314: { ! 4315: if (method_context) ! 4316: { ! 4317: tree super_expr, super_expr_list; ! 4318: ! 4319: /* set receiver to self */ ! 4320: super_expr = build_component_ref (_OBJC_SUPER_decl, self_id); ! 4321: super_expr = build_modify_expr (super_expr, NOP_EXPR, self_decl); ! 4322: super_expr_list = build_tree_list (NULLT, super_expr); ! 4323: ! 4324: /* set class to begin searching */ ! 4325: super_expr = build_component_ref (_OBJC_SUPER_decl, get_identifier ("class")); ! 4326: ! 4327: if (TREE_CODE (implementation_context) == IMPLEMENTATION_TYPE) ! 4328: { ! 4329: /* [_cls, __cls]Super are "pre-built" in synth_foward_declarations () */ ! 4330: ! 4331: if (TREE_CODE (method_context) == INSTANCE_METHOD_DECL) ! 4332: super_expr = build_modify_expr (super_expr, NOP_EXPR, _clsSuper_ref); ! 4333: else ! 4334: super_expr = build_modify_expr (super_expr, NOP_EXPR, __clsSuper_ref); ! 4335: } ! 4336: else /* we have a category... */ ! 4337: { ! 4338: tree params, super_name = CLASS_SUPER_NAME (implementation_template); ! 4339: tree funcCall; ! 4340: ! 4341: if (!super_name) /* Barf if super used in a category of Object. */ ! 4342: { ! 4343: error("no super class declared in interface for `%s'", ! 4344: IDENTIFIER_POINTER (CLASS_NAME (implementation_template))); ! 4345: return error_mark_node; ! 4346: } ! 4347: ! 4348: add_class_reference (super_name); ! 4349: ! 4350: params = build_tree_list (NULLT, ! 4351: my_build_string (IDENTIFIER_LENGTH (super_name) + 1, ! 4352: IDENTIFIER_POINTER (super_name))); ! 4353: ! 4354: if (TREE_CODE (method_context) == INSTANCE_METHOD_DECL) ! 4355: funcCall = build_function_call (objc_getClass_decl, params); ! 4356: else ! 4357: funcCall = build_function_call (objc_getMetaClass_decl, params); ! 4358: ! 4359: /* cast! */ ! 4360: TREE_TYPE (funcCall) = TREE_TYPE (_clsSuper_ref); ! 4361: super_expr = build_modify_expr (super_expr, NOP_EXPR, funcCall); ! 4362: } ! 4363: chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr)); ! 4364: ! 4365: super_expr = build_unary_op (ADDR_EXPR, _OBJC_SUPER_decl, 0); ! 4366: chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr)); ! 4367: ! 4368: return build_compound_expr (super_expr_list); ! 4369: } ! 4370: else ! 4371: { ! 4372: error ("[super ...] must appear in a method context"); ! 4373: return error_mark_node; ! 4374: } ! 4375: } ! 4376: ! 4377: static tree ! 4378: encode_method_def (func_decl) ! 4379: tree func_decl; ! 4380: { ! 4381: tree parms; ! 4382: int stack_size = 0; ! 4383: ! 4384: bzero (utlbuf, BUFSIZE); ! 4385: ! 4386: /* return type */ ! 4387: encode_type (TREE_TYPE (TREE_TYPE (func_decl)), utlbuf, ! 4388: OBJC_ENCODE_DONT_INLINE_DEFS); ! 4389: /* stack size */ ! 4390: for (parms = DECL_ARGUMENTS (func_decl); parms; ! 4391: parms = TREE_CHAIN (parms)) ! 4392: stack_size += TREE_INT_CST_LOW (TYPE_SIZE (DECL_ARG_TYPE (parms))) ! 4393: / BITS_PER_UNIT; ! 4394: ! 4395: sprintf (&utlbuf[strlen (utlbuf)], "%d", stack_size); ! 4396: ! 4397: /* argument types */ ! 4398: for (parms = DECL_ARGUMENTS (func_decl); parms; ! 4399: parms = TREE_CHAIN (parms)) ! 4400: { ! 4401: int offset_in_bytes; ! 4402: ! 4403: /* type */ ! 4404: encode_type (TREE_TYPE (parms), utlbuf, OBJC_ENCODE_DONT_INLINE_DEFS); ! 4405: ! 4406: /* compute offset */ ! 4407: if (GET_CODE (DECL_INCOMING_RTL (parms)) == MEM) ! 4408: { ! 4409: rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0); ! 4410: ! 4411: /* ??? Here we assume that the parm address is indexed ! 4412: off the frame pointer or arg pointer. ! 4413: If that is not true, we produce meaningless results, ! 4414: but do not crash. */ ! 4415: if (GET_CODE (addr) == PLUS ! 4416: && GET_CODE (XEXP (addr, 1)) == CONST_INT) ! 4417: offset_in_bytes = INTVAL (XEXP (addr, 1)); ! 4418: else ! 4419: offset_in_bytes = 0; ! 4420: ! 4421: /* This is the case where the parm is passed as an int or double ! 4422: and it is converted to a char, short or float and stored back ! 4423: in the parmlist. In this case, describe the parm ! 4424: with the variable's declared type, and adjust the address ! 4425: if the least significant bytes (which we are using) are not ! 4426: the first ones. */ ! 4427: #if BYTES_BIG_ENDIAN ! 4428: if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms)) ! 4429: offset_in_bytes += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms))) ! 4430: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))); ! 4431: #endif ! 4432: } ! 4433: else ! 4434: offset_in_bytes = 0; ! 4435: ! 4436: /* The "+ 4" is a total hack to account for the return pc and ! 4437: saved fp on the 68k. We should redefine this format! */ ! 4438: sprintf (&utlbuf[strlen (utlbuf)], "%d", offset_in_bytes + 8); ! 4439: } ! 4440: ! 4441: return get_identifier (utlbuf); ! 4442: } ! 4443: ! 4444: void ! 4445: finish_method_def () ! 4446: { ! 4447: METHOD_ENCODING (method_context) = ! 4448: encode_method_def (current_function_decl); ! 4449: ! 4450: finish_function (0); ! 4451: ! 4452: /* this must be done AFTER finish_function, since the optimizer may ! 4453: find "may be used before set" errors. */ ! 4454: method_context = NULLT; /* required to implement _msgSuper () */ ! 4455: } ! 4456: ! 4457: int ! 4458: lang_report_error_function (decl) ! 4459: tree decl; ! 4460: { ! 4461: if (method_context) ! 4462: { ! 4463: fprintf (stderr, "In method `%s'\n", ! 4464: IDENTIFIER_POINTER (METHOD_SEL_NAME (method_context))); ! 4465: return 1; ! 4466: } ! 4467: else ! 4468: return 0; ! 4469: } ! 4470: ! 4471: static int ! 4472: is_complex_decl (type) ! 4473: tree type; ! 4474: { ! 4475: return (TREE_CODE (type) == ARRAY_TYPE ! 4476: || TREE_CODE (type) == FUNCTION_TYPE ! 4477: || TREE_CODE (type) == POINTER_TYPE); ! 4478: } ! 4479: ! 4480: ! 4481: /* Code to convert a decl node into text for a declaration in C. */ ! 4482: ! 4483: static char tmpbuf[256]; ! 4484: ! 4485: static void ! 4486: adorn_decl (decl, str) ! 4487: tree decl; ! 4488: char *str; ! 4489: { ! 4490: enum tree_code code = TREE_CODE (decl); ! 4491: ! 4492: if (code == ARRAY_REF) ! 4493: { ! 4494: tree anIntCst = TREE_OPERAND (decl, 1); ! 4495: ! 4496: sprintf (str + strlen (str), "[%d]", TREE_INT_CST_LOW (anIntCst)); ! 4497: } ! 4498: else if (code == ARRAY_TYPE) ! 4499: { ! 4500: tree anIntCst = TYPE_SIZE (decl); ! 4501: tree array_of = TREE_TYPE (decl); ! 4502: ! 4503: sprintf (str + strlen (str), "[%d]", ! 4504: TREE_INT_CST_LOW (anIntCst)/TREE_INT_CST_LOW (TYPE_SIZE (array_of))); ! 4505: } ! 4506: else if (code == CALL_EXPR) ! 4507: strcat (str, "()"); ! 4508: else if (code == FUNCTION_TYPE) ! 4509: { ! 4510: tree chain = TYPE_ARG_TYPES (decl); /* a list of types */ ! 4511: strcat (str, "("); ! 4512: while (chain && TREE_VALUE (chain) != void_type_node) ! 4513: { ! 4514: gen_declaration (TREE_VALUE (chain), str); ! 4515: chain = TREE_CHAIN (chain); ! 4516: if (chain && TREE_VALUE (chain) != void_type_node) ! 4517: strcat (str, ","); ! 4518: } ! 4519: strcat (str, ")"); ! 4520: } ! 4521: else ! 4522: { ! 4523: strcpy (tmpbuf, "*"); strcat (tmpbuf, str); ! 4524: strcpy (str, tmpbuf); ! 4525: } ! 4526: } ! 4527: ! 4528: static char * ! 4529: gen_declarator (decl, buf, name) ! 4530: tree decl; ! 4531: char *buf; ! 4532: char *name; ! 4533: { ! 4534: if (decl) ! 4535: { ! 4536: enum tree_code code = TREE_CODE (decl); ! 4537: char *str; ! 4538: tree op; ! 4539: int wrap = 0; ! 4540: ! 4541: switch (code) ! 4542: { ! 4543: case ARRAY_REF: case INDIRECT_REF: case CALL_EXPR: ! 4544: { ! 4545: op = TREE_OPERAND (decl, 0); ! 4546: ! 4547: /* we have a pointer to a function or array...(*)(), (*)[] */ ! 4548: if ((code == ARRAY_REF || code == CALL_EXPR) && ! 4549: (op && TREE_CODE (op) == INDIRECT_REF)) ! 4550: wrap = 1; ! 4551: ! 4552: str = gen_declarator (op, buf, name); ! 4553: ! 4554: if (wrap) ! 4555: { ! 4556: strcpy (tmpbuf, "("); strcat (tmpbuf, str); strcat (tmpbuf, ")"); ! 4557: strcpy (str, tmpbuf); ! 4558: } ! 4559: ! 4560: adorn_decl (decl, str); ! 4561: break; ! 4562: } ! 4563: case ARRAY_TYPE: case FUNCTION_TYPE: case POINTER_TYPE: ! 4564: { ! 4565: str = strcpy (buf, name); ! 4566: ! 4567: /* this clause is done iteratively...rather than recursively */ ! 4568: do ! 4569: { ! 4570: op = is_complex_decl (TREE_TYPE (decl)) ! 4571: ? TREE_TYPE (decl) ! 4572: : NULLT; ! 4573: ! 4574: adorn_decl (decl, str); ! 4575: ! 4576: /* we have a pointer to a function or array...(*)(), (*)[] */ ! 4577: if ((code == POINTER_TYPE) && ! 4578: (op && (TREE_CODE (op) == FUNCTION_TYPE ! 4579: || TREE_CODE (op) == ARRAY_TYPE))) ! 4580: { ! 4581: strcpy (tmpbuf, "("); strcat (tmpbuf, str); strcat (tmpbuf, ")"); ! 4582: strcpy (str, tmpbuf); ! 4583: } ! 4584: ! 4585: decl = is_complex_decl (TREE_TYPE (decl)) ! 4586: ? TREE_TYPE (decl) ! 4587: : NULLT; ! 4588: } ! 4589: while (decl && (code = TREE_CODE (decl))); ! 4590: ! 4591: break; ! 4592: } ! 4593: case IDENTIFIER_NODE: ! 4594: /* will only happen if we are processing a "raw" expr-decl. */ ! 4595: return strcpy (buf, IDENTIFIER_POINTER (decl)); ! 4596: } ! 4597: ! 4598: return str; ! 4599: } ! 4600: else /* we have an abstract declarator or a _DECL node */ ! 4601: { ! 4602: return strcpy (buf, name); ! 4603: } ! 4604: } ! 4605: ! 4606: static void ! 4607: gen_declspecs (declspecs, buf, raw) ! 4608: tree declspecs; ! 4609: char *buf; ! 4610: int raw; ! 4611: { ! 4612: if (raw) ! 4613: { ! 4614: tree chain; ! 4615: ! 4616: for (chain = declspecs; chain; chain = TREE_CHAIN (chain)) ! 4617: { ! 4618: tree aspec = TREE_VALUE (chain); ! 4619: ! 4620: if (TREE_CODE (aspec) == IDENTIFIER_NODE) ! 4621: strcat (buf, IDENTIFIER_POINTER (aspec)); ! 4622: else if (TREE_CODE (aspec) == RECORD_TYPE) ! 4623: { ! 4624: if (TYPE_NAME (aspec)) ! 4625: { ! 4626: if (!TREE_STATIC_TEMPLATE (aspec)) ! 4627: strcat (buf, "struct "); ! 4628: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (aspec))); ! 4629: } ! 4630: else ! 4631: strcat (buf, "untagged struct"); ! 4632: } ! 4633: else if (TREE_CODE (aspec) == UNION_TYPE) ! 4634: { ! 4635: if (TYPE_NAME (aspec)) ! 4636: { ! 4637: if (!TREE_STATIC_TEMPLATE (aspec)) ! 4638: strcat (buf, "union "); ! 4639: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (aspec))); ! 4640: } ! 4641: else ! 4642: strcat (buf, "untagged union"); ! 4643: } ! 4644: else if (TREE_CODE (aspec) == ENUMERAL_TYPE) ! 4645: { ! 4646: if (TYPE_NAME (aspec)) ! 4647: { ! 4648: if (!TREE_STATIC_TEMPLATE (aspec)) ! 4649: strcat (buf, "enum "); ! 4650: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (aspec))); ! 4651: } ! 4652: else ! 4653: strcat (buf, "untagged enum"); ! 4654: } ! 4655: strcat (buf, " "); ! 4656: } ! 4657: } ! 4658: else ! 4659: switch (TREE_CODE (declspecs)) ! 4660: { ! 4661: /* type specifiers */ ! 4662: ! 4663: case INTEGER_TYPE: /* signed integer types */ ! 4664: ! 4665: if (declspecs == short_integer_type_node) /* 's' */ ! 4666: strcat (buf, "short int "); ! 4667: else if (declspecs == integer_type_node) /* 'i' */ ! 4668: strcat (buf, "int "); ! 4669: else if (declspecs == long_integer_type_node) /* 'l' */ ! 4670: strcat (buf, "long int "); ! 4671: else if (declspecs == signed_char_type_node || /* 'c' */ ! 4672: declspecs == char_type_node) ! 4673: strcat (buf, "char "); ! 4674: ! 4675: /* unsigned integer types */ ! 4676: ! 4677: else if (declspecs == short_unsigned_type_node) /* 'S' */ ! 4678: strcat (buf, "unsigned short "); ! 4679: else if (declspecs == unsigned_type_node) /* 'I' */ ! 4680: strcat (buf, "unsigned int "); ! 4681: else if (declspecs == long_unsigned_type_node) /* 'L' */ ! 4682: strcat (buf, "unsigned long "); ! 4683: else if (declspecs == unsigned_char_type_node) /* 'C' */ ! 4684: strcat (buf, "unsigned char "); ! 4685: break; ! 4686: ! 4687: case REAL_TYPE: /* floating point types */ ! 4688: ! 4689: if (declspecs == float_type_node) /* 'f' */ ! 4690: strcat (buf, "float "); ! 4691: else if (declspecs == double_type_node) /* 'd' */ ! 4692: strcat (buf, "double "); ! 4693: else if (declspecs == long_double_type_node) /* 'd' */ ! 4694: strcat (buf, "long double "); ! 4695: break; ! 4696: ! 4697: case RECORD_TYPE: ! 4698: if (!TREE_STATIC_TEMPLATE (declspecs)) ! 4699: strcat (buf, "struct "); ! 4700: if (TYPE_NAME (declspecs) && ! 4701: (TREE_CODE (TYPE_NAME (declspecs)) == IDENTIFIER_NODE)) ! 4702: { ! 4703: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (declspecs))); ! 4704: strcat (buf, " "); ! 4705: } ! 4706: break; ! 4707: case UNION_TYPE: ! 4708: strcat (buf, "union "); ! 4709: if (TYPE_NAME (declspecs) && ! 4710: (TREE_CODE (TYPE_NAME (declspecs)) == IDENTIFIER_NODE)) ! 4711: { ! 4712: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (declspecs))); ! 4713: strcat (buf, " "); ! 4714: } ! 4715: break; ! 4716: case ENUMERAL_TYPE: ! 4717: strcat (buf, "enum "); ! 4718: if (TYPE_NAME (declspecs) && ! 4719: (TREE_CODE (TYPE_NAME (declspecs)) == IDENTIFIER_NODE)) ! 4720: { ! 4721: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (declspecs))); ! 4722: strcat (buf, " "); ! 4723: } ! 4724: break; ! 4725: case VOID_TYPE: ! 4726: strcat (buf, "void "); ! 4727: } ! 4728: } ! 4729: ! 4730: static char * ! 4731: gen_declaration (atype_or_adecl, buf) ! 4732: tree atype_or_adecl; ! 4733: char *buf; ! 4734: { ! 4735: char declbuf[256]; ! 4736: ! 4737: if (TREE_CODE (atype_or_adecl) == TREE_LIST) ! 4738: { ! 4739: tree declspecs; /* "identifier_node", "record_type" */ ! 4740: tree declarator; /* "array_ref", "indirect_ref", "call_expr"... */ ! 4741: ! 4742: /* we have a "raw", abstract delclarator (typename) */ ! 4743: declarator = TREE_VALUE (atype_or_adecl); ! 4744: declspecs = TREE_PURPOSE (atype_or_adecl); ! 4745: ! 4746: gen_declspecs (declspecs, buf, 1); ! 4747: strcat (buf, gen_declarator (declarator, declbuf, "")); ! 4748: } ! 4749: else ! 4750: { ! 4751: tree atype; ! 4752: tree declspecs; /* "integer_type", "real_type", "record_type"... */ ! 4753: tree declarator; /* "array_type", "function_type", "pointer_type". */ ! 4754: ! 4755: if (TREE_CODE (atype_or_adecl) == FIELD_DECL ! 4756: || TREE_CODE (atype_or_adecl) == PARM_DECL ! 4757: || TREE_CODE (atype_or_adecl) == FUNCTION_DECL) ! 4758: atype = TREE_TYPE (atype_or_adecl); ! 4759: else ! 4760: atype = atype_or_adecl; /* assume we have a *_type node */ ! 4761: ! 4762: if (is_complex_decl (atype)) ! 4763: { ! 4764: tree chain; ! 4765: ! 4766: /* get the declaration specifier...it is at the end of the list */ ! 4767: declarator = chain = atype; ! 4768: do ! 4769: chain = TREE_TYPE (chain); /* not TREE_CHAIN (chain); */ ! 4770: while (is_complex_decl (chain)); ! 4771: declspecs = chain; ! 4772: } ! 4773: else ! 4774: { ! 4775: declspecs = atype; ! 4776: declarator = NULLT; ! 4777: } ! 4778: ! 4779: gen_declspecs (declspecs, buf, 0); ! 4780: ! 4781: if (TREE_CODE (atype_or_adecl) == FIELD_DECL ! 4782: || TREE_CODE (atype_or_adecl) == PARM_DECL ! 4783: || TREE_CODE (atype_or_adecl) == FUNCTION_DECL) ! 4784: { ! 4785: if (declarator) ! 4786: { ! 4787: strcat (buf, gen_declarator (declarator, declbuf, ! 4788: IDENTIFIER_POINTER (DECL_NAME (atype_or_adecl)))); ! 4789: } ! 4790: else ! 4791: strcat (buf, IDENTIFIER_POINTER (DECL_NAME (atype_or_adecl))); ! 4792: } ! 4793: else ! 4794: { ! 4795: strcat (buf, gen_declarator (declarator, declbuf, "")); ! 4796: } ! 4797: } ! 4798: return buf; ! 4799: } ! 4800: ! 4801: #define RAW_TYPESPEC(meth) (TREE_VALUE (TREE_PURPOSE (TREE_TYPE (meth)))) ! 4802: ! 4803: static char * ! 4804: gen_method_decl (method, buf) ! 4805: tree method; ! 4806: char *buf; ! 4807: { ! 4808: tree chain; ! 4809: ! 4810: if (RAW_TYPESPEC (method) != objc_object_reference) ! 4811: { ! 4812: strcpy (buf, "("); ! 4813: gen_declaration (TREE_TYPE (method), buf); ! 4814: strcat (buf, ")"); ! 4815: } ! 4816: ! 4817: chain = METHOD_SEL_ARGS (method); ! 4818: if (chain) ! 4819: { /* we have a chain of keyword_decls */ ! 4820: do ! 4821: { ! 4822: if (KEYWORD_KEY_NAME (chain)) ! 4823: strcat (buf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain))); ! 4824: ! 4825: strcat (buf, ":"); ! 4826: if (RAW_TYPESPEC (chain) != objc_object_reference) ! 4827: { ! 4828: strcat (buf, "("); ! 4829: gen_declaration (TREE_TYPE (chain), buf); ! 4830: strcat (buf, ")"); ! 4831: } ! 4832: strcat (buf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain))); ! 4833: if (chain = TREE_CHAIN (chain)) ! 4834: strcat (buf, " "); ! 4835: } ! 4836: while (chain); ! 4837: ! 4838: if (METHOD_ADD_ARGS (method) == (tree)1) ! 4839: strcat (buf, ", ..."); ! 4840: else if (METHOD_ADD_ARGS (method)) ! 4841: { /* we have a tree list node as generate by `get_parm_info ()' */ ! 4842: chain = TREE_PURPOSE (METHOD_ADD_ARGS (method)); ! 4843: /* know we have a chain of parm_decls */ ! 4844: while (chain) ! 4845: { ! 4846: strcat (buf, ", "); ! 4847: gen_declaration (chain, buf); ! 4848: chain = TREE_CHAIN (chain); ! 4849: } ! 4850: } ! 4851: } ! 4852: else /* we have a unary selector */ ! 4853: { ! 4854: strcat (buf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method))); ! 4855: } ! 4856: ! 4857: return buf; ! 4858: } ! 4859: ! 4860: void ! 4861: gen_prototype (fp, decl) ! 4862: FILE *fp; ! 4863: tree decl; ! 4864: { ! 4865: /* we have a function definition - generate prototype */ ! 4866: bzero (errbuf, BUFSIZE); ! 4867: gen_declaration (decl, errbuf); ! 4868: fprintf (fp, "%s;\n", errbuf); ! 4869: } ! 4870: /* ! 4871: * debug info... ! 4872: */ ! 4873: static void ! 4874: dump_interface (fp, chain) ! 4875: FILE *fp; ! 4876: tree chain; ! 4877: { ! 4878: char *buf = (char *)xmalloc (256); ! 4879: char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain)); ! 4880: tree ivar_decls = CLASS_RAW_IVARS (chain); ! 4881: tree nst_methods = CLASS_NST_METHODS (chain); ! 4882: tree cls_methods = CLASS_CLS_METHODS (chain); ! 4883: ! 4884: fprintf (fp, "\n@interface %s", my_name); ! 4885: ! 4886: if (CLASS_SUPER_NAME (chain)) ! 4887: { ! 4888: char *super_name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain)); ! 4889: fprintf (fp, " : %s\n", super_name); ! 4890: } ! 4891: else ! 4892: fprintf (fp, "\n"); ! 4893: ! 4894: if (ivar_decls) ! 4895: { ! 4896: fprintf (fp, "{\n"); ! 4897: do ! 4898: { ! 4899: bzero (buf, 256); ! 4900: fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls, buf)); ! 4901: ivar_decls = TREE_CHAIN (ivar_decls); ! 4902: } ! 4903: while (ivar_decls); ! 4904: fprintf (fp, "}\n"); ! 4905: } ! 4906: ! 4907: while (nst_methods) ! 4908: { ! 4909: bzero (buf, 256); ! 4910: fprintf (fp, "- %s;\n", gen_method_decl (nst_methods, buf)); ! 4911: nst_methods = TREE_CHAIN (nst_methods); ! 4912: } ! 4913: ! 4914: while (cls_methods) ! 4915: { ! 4916: bzero (buf, 256); ! 4917: fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods, buf)); ! 4918: cls_methods = TREE_CHAIN (cls_methods); ! 4919: } ! 4920: fprintf (fp, "\n@end"); ! 4921: } ! 4922: ! 4923: void ! 4924: init_objc () ! 4925: { ! 4926: /* Add the special tree codes of Objective C to the tables. */ ! 4927: ! 4928: tree_code_type ! 4929: = (char **) realloc (tree_code_type, ! 4930: sizeof (char *) * LAST_OBJC_TREE_CODE); ! 4931: tree_code_length ! 4932: = (int *) realloc (tree_code_length, ! 4933: sizeof (int) * LAST_OBJC_TREE_CODE); ! 4934: tree_code_name ! 4935: = (char **) realloc (tree_code_name, ! 4936: sizeof (char *) * LAST_OBJC_TREE_CODE); ! 4937: bcopy (objc_tree_code_type, ! 4938: tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE, ! 4939: (((int) LAST_OBJC_TREE_CODE - (int) LAST_AND_UNUSED_TREE_CODE) ! 4940: * sizeof (char *))); ! 4941: bcopy (objc_tree_code_length, ! 4942: tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE, ! 4943: (((int) LAST_OBJC_TREE_CODE - (int) LAST_AND_UNUSED_TREE_CODE) ! 4944: * sizeof (int))); ! 4945: bcopy (objc_tree_code_name, ! 4946: tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE, ! 4947: (((int) LAST_OBJC_TREE_CODE - (int) LAST_AND_UNUSED_TREE_CODE) ! 4948: * sizeof (char *))); ! 4949: ! 4950: errbuf = (char *)xmalloc (BUFSIZE); ! 4951: utlbuf = (char *)xmalloc (BUFSIZE); ! 4952: hash_init (); ! 4953: synth_module_prologue (); ! 4954: } ! 4955: ! 4956: void ! 4957: finish_objc () ! 4958: { ! 4959: struct imp_entry *impent; ! 4960: tree chain; ! 4961: ! 4962: generate_forward_declaration_to_string_table (); ! 4963: ! 4964: #ifdef OBJC_PROLOGUE ! 4965: OBJC_PROLOGUE; ! 4966: #endif ! 4967: ! 4968: if (implementation_context || sel_refdef_chain) ! 4969: generate_objc_symtab_decl (); ! 4970: ! 4971: for (impent = imp_list; impent; impent = impent->next) ! 4972: { ! 4973: implementation_context = impent->imp_context; ! 4974: implementation_template = impent->imp_template; ! 4975: ! 4976: _OBJC_CLASS_decl = impent->class_decl; ! 4977: _OBJC_METACLASS_decl = impent->meta_decl; ! 4978: ! 4979: if (TREE_CODE (implementation_context) == IMPLEMENTATION_TYPE) ! 4980: { ! 4981: /* all of the following reference the string pool... */ ! 4982: generate_ivar_lists (); ! 4983: generate_dispatch_tables (); ! 4984: generate_shared_structures (); ! 4985: } ! 4986: else ! 4987: { ! 4988: generate_dispatch_tables (); ! 4989: generate_category (implementation_context); ! 4990: } ! 4991: } ! 4992: ! 4993: if (sel_ref_chain) ! 4994: build_selector_translation_table (); ! 4995: ! 4996: if (implementation_context || sel_refdef_chain) ! 4997: { ! 4998: /* Arrange for Objc data structures to be initialized at run time. */ ! 4999: ! 5000: char *init_name = build_module_descriptor (); ! 5001: if (init_name) ! 5002: assemble_constructor (init_name); ! 5003: } ! 5004: ! 5005: /* dump the string table last */ ! 5006: ! 5007: if (sel_refdef_chain) ! 5008: { ! 5009: build_message_selector_pool (); ! 5010: } ! 5011: ! 5012: /* dump the class references...this forces the appropriate classes ! 5013: to be linked into the executable image, preserving unix archive ! 5014: semantics...this can be removed when we move to a more dynamically ! 5015: linked environment ! 5016: */ ! 5017: for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain)) ! 5018: { ! 5019: tree decl; ! 5020: ! 5021: #if 0 /* Grossly unportable. */ ! 5022: sprintf (utlbuf, ".reference .objc_class_name_%s", ! 5023: IDENTIFIER_POINTER (TREE_VALUE (chain))); ! 5024: assemble_asm (my_build_string (strlen (utlbuf) + 1, utlbuf)); ! 5025: #else ! 5026: sprintf (utlbuf, ".objc_class_name_%s", ! 5027: IDENTIFIER_POINTER (TREE_VALUE (chain))); ! 5028: #endif ! 5029: /* Make a decl for this name, so we can use its address in a tree. */ ! 5030: decl = build_decl (VAR_DECL, get_identifier (utlbuf), char_type_node); ! 5031: TREE_EXTERNAL (decl) = 1; ! 5032: TREE_PUBLIC (decl) = 1; ! 5033: ! 5034: pushdecl (decl); ! 5035: rest_of_decl_compilation (decl, 0, 0, 0); ! 5036: ! 5037: /* Make following constant read-only (why not)? */ ! 5038: text_section (); ! 5039: ! 5040: /* Output a constant to reference this address. */ ! 5041: output_constant (build1 (ADDR_EXPR, string_type_node, decl), ! 5042: int_size_in_bytes (string_type_node)); ! 5043: } ! 5044: ! 5045: for (impent = imp_list; impent; impent = impent->next) ! 5046: { ! 5047: implementation_context = impent->imp_context; ! 5048: implementation_template = impent->imp_template; ! 5049: ! 5050: if (TREE_CODE (impent->imp_context) == IMPLEMENTATION_TYPE) ! 5051: { ! 5052: #if 0 /* Grossly unportable. ! 5053: People should know better than to assume ! 5054: such things about assembler syntax! */ ! 5055: sprintf (utlbuf, ".objc_class_name_%s=0", ! 5056: IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); ! 5057: assemble_asm (my_build_string (strlen (utlbuf) + 1, utlbuf)); ! 5058: #endif ! 5059: sprintf (utlbuf, ".objc_class_name_%s", ! 5060: IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); ! 5061: assemble_global (utlbuf); ! 5062: assemble_label (utlbuf); ! 5063: } ! 5064: else if (TREE_CODE (impent->imp_context) == CATEGORY_TYPE) ! 5065: { ! 5066: /* Do the same for categories. Even though no references to these ! 5067: symbols are generated automatically by the compiler, it gives ! 5068: you a handle to pull them into an archive by hand. */ ! 5069: #if 0 /* Grossly unportable. */ ! 5070: sprintf (utlbuf, ".objc_category_name_%s_%s=0", ! 5071: IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)), ! 5072: IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context))); ! 5073: assemble_asm (my_build_string (strlen (utlbuf) + 1, utlbuf)); ! 5074: #endif ! 5075: sprintf (utlbuf, ".objc_category_name_%s_%s", ! 5076: IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)), ! 5077: IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context))); ! 5078: assemble_global (utlbuf); ! 5079: assemble_label (utlbuf); ! 5080: } ! 5081: } ! 5082: #if 0 /* If GAS has such a bug, let's fix it. */ ! 5083: /*** this fixes a gross bug in the assembler...it `expects' #APP to have ! 5084: *** a matching #NO_APP, or it crashes (sometimes). app_disable () will ! 5085: *** insure this is the case. 5/19/89, s.naroff. ! 5086: ***/ ! 5087: if (cls_ref_chain || imp_list) ! 5088: app_disable (); ! 5089: #endif ! 5090: ! 5091: if (flag_gen_declaration) ! 5092: { ! 5093: add_class (implementation_context); ! 5094: dump_interface (gen_declaration_file, implementation_context); ! 5095: } ! 5096: if (warn_selector) ! 5097: { ! 5098: int slot; ! 5099: ! 5100: /* Run through the selector hash tables and print a warning for any ! 5101: selector which has multiple methods. */ ! 5102: ! 5103: for (slot = 0; slot < SIZEHASHTABLE; slot++) ! 5104: { ! 5105: hash hsh; ! 5106: ! 5107: for (hsh = cls_method_hash_list[slot]; hsh; hsh = hsh->next) ! 5108: { ! 5109: if (hsh->list) ! 5110: { ! 5111: tree meth = hsh->key; ! 5112: char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL) ! 5113: ? '-' : '+'; ! 5114: attr loop; ! 5115: ! 5116: warning ("potential selector conflict for method `%s'", ! 5117: IDENTIFIER_POINTER (METHOD_SEL_NAME (meth))); ! 5118: warn_with_method ("found", type, meth); ! 5119: for (loop = hsh->list; loop; loop = loop->next) ! 5120: warn_with_method ("found", type, loop->value); ! 5121: } ! 5122: } ! 5123: } ! 5124: ! 5125: for (slot = 0; slot < SIZEHASHTABLE; slot++) ! 5126: { ! 5127: hash hsh; ! 5128: ! 5129: for (hsh = nst_method_hash_list[slot]; hsh; hsh = hsh->next) ! 5130: { ! 5131: if (hsh->list) ! 5132: { ! 5133: tree meth = hsh->key; ! 5134: char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL) ! 5135: ? '-' : '+'; ! 5136: attr loop; ! 5137: ! 5138: warning ("potential selector conflict for method `%s'", ! 5139: IDENTIFIER_POINTER (METHOD_SEL_NAME (meth))); ! 5140: warn_with_method ("found", type, meth); ! 5141: for (loop = hsh->list; loop; loop = loop->next) ! 5142: warn_with_method ("found", type, loop->value); ! 5143: } ! 5144: } ! 5145: } ! 5146: } ! 5147: } ! 5148: ! 5149: #ifdef DEBUG ! 5150: ! 5151: static void ! 5152: objc_debug (fp) ! 5153: FILE *fp; ! 5154: { ! 5155: char *buf = (char *)xmalloc (256); ! 5156: ! 5157: { /* dump function prototypes */ ! 5158: tree loop = _OBJC_MODULES_decl; ! 5159: ! 5160: fprintf (fp, "\n\nfunction prototypes:\n"); ! 5161: while (loop) ! 5162: { ! 5163: if (TREE_CODE (loop) == FUNCTION_DECL && DECL_INITIAL (loop)) ! 5164: { ! 5165: /* we have a function definition - generate prototype */ ! 5166: bzero (errbuf, BUFSIZE); ! 5167: gen_declaration (loop, errbuf); ! 5168: fprintf (fp, "%s;\n", errbuf); ! 5169: } ! 5170: loop = TREE_CHAIN (loop); ! 5171: } ! 5172: } ! 5173: { /* dump global chains */ ! 5174: tree loop; ! 5175: int i, index = 0, offset = 0; ! 5176: hash hashlist; ! 5177: ! 5178: for (i = 0; i < SIZEHASHTABLE; i++) ! 5179: { ! 5180: if (hashlist = nst_method_hash_list[i]) ! 5181: { ! 5182: fprintf (fp, "\n\nnst_method_hash_list[%d]:\n", i); ! 5183: do ! 5184: { ! 5185: bzero (buf, 256); ! 5186: fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf)); ! 5187: hashlist = hashlist->next; ! 5188: } ! 5189: while (hashlist); ! 5190: } ! 5191: } ! 5192: for (i = 0; i < SIZEHASHTABLE; i++) ! 5193: { ! 5194: if (hashlist = cls_method_hash_list[i]) ! 5195: { ! 5196: fprintf (fp, "\n\ncls_method_hash_list[%d]:\n", i); ! 5197: do ! 5198: { ! 5199: bzero (buf, 256); ! 5200: fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf)); ! 5201: hashlist = hashlist->next; ! 5202: } ! 5203: while (hashlist); ! 5204: } ! 5205: } ! 5206: fprintf (fp, "\nsel_refdef_chain:\n"); ! 5207: for (loop = sel_refdef_chain; loop; loop = TREE_CHAIN (loop)) ! 5208: { ! 5209: fprintf (fp, "(index: %4d offset: %4d) %s\n", index, offset, ! 5210: IDENTIFIER_POINTER (TREE_VALUE (loop))); ! 5211: index++; ! 5212: /* add one for the '\0' character */ ! 5213: offset += IDENTIFIER_LENGTH (TREE_VALUE (loop)) + 1; ! 5214: } ! 5215: fprintf (fp, "\n (max_selector_index: %4d.\n", max_selector_index); ! 5216: } ! 5217: } ! 5218: #endif ! 5219: ! 5220: void ! 5221: print_lang_statistics () ! 5222: { ! 5223: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.