![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to objc-act.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-act.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, 1993 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: /* Purpose: This module implements the Objective-C 4.0 language.
22:
23: compatibility issues (with the Stepstone translator):
24:
25: - does not recognize the following 3.3 constructs.
26: @requires, @classes, @messages, = (...)
27: - methods with variable arguments must conform to ANSI standard.
28: - tagged structure definitions that appear in BOTH the interface
29: and implementation are not allowed.
30: - public/private: all instance variables are public within the
31: context of the implementation...I consider this to be a bug in
32: the translator.
33: - statically allocated objects are not supported. the user will
34: receive an error if this service is requested.
35:
36: code generation `options':
37:
38: - OBJC_INT_SELECTORS */
39:
40: #include <stdio.h>
41: #include "config.h"
42: #include "tree.h"
43: #include "c-tree.h"
44: #include "c-lex.h"
45: #include "flags.h"
46: #include "objc-act.h"
47: #include "input.h"
48: #include "function.h"
49:
50: /* This is the default way of generating a method name. */
51: /* I am not sure it is really correct.
52: Perhaps there's a danger that it will make name conflicts
53: if method names contain underscores. -- rms. */
54: #ifndef OBJC_GEN_METHOD_LABEL
55: #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
56: do { \
57: char *temp; \
58: sprintf ((BUF), "_%s_%s_%s_%s", \
59: ((IS_INST) ? "i" : "c"), \
60: (CLASS_NAME), \
61: ((CAT_NAME)? (CAT_NAME) : ""), \
62: (SEL_NAME)); \
63: for (temp = (BUF); *temp; temp++) \
64: if (*temp == ':') *temp = '_'; \
65: } while (0)
66: #endif
67:
68: /* These need specifying. */
69: #ifndef OBJC_FORWARDING_STACK_OFFSET
70: #define OBJC_FORWARDING_STACK_OFFSET 0
71: #endif
72:
73: #ifndef OBJC_FORWARDING_MIN_OFFSET
74: #define OBJC_FORWARDING_MIN_OFFSET 0
75: #endif
76:
77: /* Define the special tree codes that we use. */
78:
79: /* Table indexed by tree code giving a string containing a character
80: classifying the tree code. Possibilities are
81: t, d, s, c, r, <, 1 and 2. See objc-tree.def for details. */
82:
83: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
84:
85: char *objc_tree_code_type[] = {
86: "x",
87: #include "objc-tree.def"
88: };
89: #undef DEFTREECODE
90:
91: /* Table indexed by tree code giving number of expression
92: operands beyond the fixed part of the node structure.
93: Not used for types or decls. */
94:
95: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
96:
97: int objc_tree_code_length[] = {
98: 0,
99: #include "objc-tree.def"
100: };
101: #undef DEFTREECODE
102:
103: /* Names of tree components.
104: Used for printing out the tree and error messages. */
105: #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
106:
107: char *objc_tree_code_name[] = {
108: "@@dummy",
109: #include "objc-tree.def"
110: };
111: #undef DEFTREECODE
112:
113: /* Set up for use of obstacks. */
114:
115: #include "obstack.h"
116:
117: #define obstack_chunk_alloc xmalloc
118: #define obstack_chunk_free free
119:
120: /* This obstack is used to accumulate the encoding of a data type. */
121: static struct obstack util_obstack;
122: /* This points to the beginning of obstack contents,
123: so we can free the whole contents. */
124: char *util_firstobj;
125:
126: /* for encode_method_def */
127: #include "rtl.h"
128: #include "c-parse.h"
129:
130: #define OBJC_VERSION 5
131: #define PROTOCOL_VERSION 2
132:
133: #define NULLT (tree) 0
134:
135: #define OBJC_ENCODE_INLINE_DEFS 0
136: #define OBJC_ENCODE_DONT_INLINE_DEFS 1
137:
138: /*** Private Interface (procedures) ***/
139:
140: /* used by compile_file */
141:
142: static void init_objc PROTO((void));
143: static void finish_objc PROTO((void));
144:
145: /* code generation */
146:
147: static void synth_module_prologue PROTO((void));
148: static char *build_module_descriptor PROTO((void));
149: static tree init_module_descriptor PROTO((void));
150: static tree build_objc_method_call PROTO((int, tree, tree, tree, tree, tree));
151: static void generate_strings PROTO((void));
152: static void build_selector_translation_table PROTO((void));
153: static tree build_ivar_chain PROTO((tree, int));
154:
155: static tree build_ivar_template PROTO((void));
156: static tree build_method_template PROTO((void));
157: static tree build_private_template PROTO((tree));
158: static void build_class_template PROTO((void));
159: static void build_category_template PROTO((void));
160: static tree build_super_template PROTO((void));
161: static tree build_category_initializer PROTO((tree, tree, tree, tree, tree));
162: static tree build_protocol_initializer PROTO((tree, tree, tree, tree));
163:
164: static void synth_forward_declarations PROTO((void));
165: static void generate_ivar_lists PROTO((void));
166: static void generate_dispatch_tables PROTO((void));
167: static void generate_shared_structures PROTO((void));
168: static tree generate_protocol_list PROTO((tree));
169: static void generate_forward_declaration_to_string_table PROTO((void));
170: static void build_protocol_reference PROTO((tree));
171:
172: static tree init_selector PROTO((int));
173: static tree build_keyword_selector PROTO((tree));
174: static tree synth_id_with_class_suffix PROTO((char *, tree));
175:
176: /* misc. bookkeeping */
177:
178: typedef struct hashed_entry *hash;
179: typedef struct hashed_attribute *attr;
180:
181: struct hashed_attribute
182: {
183: attr next;
184: tree value;
185: };
186: struct hashed_entry
187: {
188: attr list;
189: hash next;
190: tree key;
191: };
192:
193: static void hash_init PROTO((void));
194: static void hash_enter PROTO((hash *, tree));
195: static hash hash_lookup PROTO((hash *, tree));
196: static void hash_add_attr PROTO((hash, tree));
197: static tree lookup_method PROTO((tree, tree));
198: static tree lookup_instance_method_static PROTO((tree, tree));
199: static tree lookup_class_method_static PROTO((tree, tree));
200: static tree add_class PROTO((tree));
201: static void add_category PROTO((tree, tree));
202:
203: enum string_section
204: {
205: class_names, /* class, category, protocol, module names */
206: meth_var_names, /* method and variable names */
207: meth_var_types /* method and variable type descriptors */
208: };
209:
210: static tree add_objc_string PROTO((tree, enum string_section));
211: static tree build_objc_string_decl PROTO((tree, enum string_section));
212: static tree build_selector_reference_decl PROTO((tree));
213:
214: /* protocol additions */
215:
216: static tree add_protocol PROTO((tree));
217: static tree lookup_protocol PROTO((tree));
218: static tree lookup_and_install_protocols PROTO((tree));
219:
220: /* type encoding */
221:
222: static void encode_type_qualifiers PROTO((tree));
223: static void encode_pointer PROTO((tree, int, int));
224: static void encode_array PROTO((tree, int, int));
225: static void encode_aggregate PROTO((tree, int, int));
226: static void encode_bitfield PROTO((int, int));
227: static void encode_type PROTO((tree, int, int));
228: static void encode_field_decl PROTO((tree, int, int));
229:
230: static void really_start_method PROTO((tree, tree));
231: static int comp_method_with_proto PROTO((tree, tree));
232: static int comp_proto_with_proto PROTO((tree, tree));
233: static tree get_arg_type_list PROTO((tree, int, int));
234: static tree expr_last PROTO((tree));
235:
236: /* utilities for debugging and error diagnostics: */
237:
238: static void warn_with_method PROTO((char *, int, tree));
239: static void error_with_ivar PROTO((char *, tree, tree));
240: static char *gen_method_decl PROTO((tree, char *));
241: static char *gen_declaration PROTO((tree, char *));
242: static char *gen_declarator PROTO((tree, char *, char *));
243: static int is_complex_decl PROTO((tree));
244: static void adorn_decl PROTO((tree, char *));
245: static void dump_interface PROTO((FILE *, tree));
246:
247: /* everything else. */
248:
249: static void objc_fatal PROTO((void));
250: static tree define_decl PROTO((tree, tree));
251: static tree lookup_method_in_protocol_list PROTO((tree, tree, int));
252: static tree lookup_protocol_in_reflist PROTO((tree, tree));
253: static tree create_builtin_decl PROTO((enum tree_code, tree, char *));
254: static tree my_build_string PROTO((int, char *));
255: static void build_objc_symtab_template PROTO((void));
256: static tree init_def_list PROTO((void));
257: static tree init_objc_symtab PROTO((void));
258: static void forward_declare_categories PROTO((void));
259: static void generate_objc_symtab_decl PROTO((void));
260: static tree build_selector PROTO((tree));
261: static tree build_msg_pool_reference PROTO((int));
262: static tree build_selector_reference PROTO((tree));
263: static tree build_class_reference_decl PROTO((tree));
264: static void add_class_reference PROTO((tree));
265: static tree objc_copy_list PROTO((tree, tree *));
266: static tree build_protocol_template PROTO((void));
267: static tree build_descriptor_table_initializer PROTO((tree, int *));
268: static tree build_method_prototype_list_template PROTO((tree, int));
269: static tree build_method_prototype_template PROTO((void));
270: static int forwarding_offset PROTO((tree));
271: static tree encode_method_prototype PROTO((tree, tree));
272: static tree generate_descriptor_table PROTO((tree, char *, int, tree, tree));
273: static void generate_method_descriptors PROTO((tree));
274: static tree build_tmp_function_decl PROTO((void));
275: static void hack_method_prototype PROTO((tree, tree));
276: static void generate_protocol_references PROTO((tree));
277: static void generate_protocols PROTO((void));
278: static void check_ivars PROTO((tree, tree));
279: static tree build_ivar_list_template PROTO((tree, int));
280: static tree build_method_list_template PROTO((tree, int));
281: static tree build_ivar_list_initializer PROTO((tree, int *));
282: static tree generate_ivars_list PROTO((tree, char *, int, tree));
283: static tree build_dispatch_table_initializer PROTO((tree, int *));
284: static tree generate_dispatch_table PROTO((tree, char *, int, tree));
285: static tree build_shared_structure_initializer PROTO((tree, tree, tree, tree, int, tree, tree, tree));
286: static void generate_category PROTO((tree));
287: static int is_objc_type_qualifier PROTO((tree));
288: static tree adjust_type_for_id_default PROTO((tree));
289: static tree check_duplicates PROTO((hash));
290: static tree receiver_is_class_object PROTO((tree));
291: static int check_methods PROTO((tree, tree, int));
292: static int conforms_to_protocol PROTO((tree, tree));
293: static void check_protocols PROTO((tree, char *, char *));
294: static tree encode_method_def PROTO((tree));
295: static void gen_declspecs PROTO((tree, char *, int));
296: static void generate_classref_translation_entry PROTO((tree));
297: static void handle_class_ref PROTO((tree));
298:
299: /*** Private Interface (data) ***/
300:
301: /* reserved tag definitions: */
302:
303: #define TYPE_ID "id"
304: #define TAG_OBJECT "objc_object"
305: #define TAG_CLASS "objc_class"
306: #define TAG_SUPER "objc_super"
307: #define TAG_SELECTOR "objc_selector"
308:
309: #define UTAG_CLASS "_objc_class"
310: #define UTAG_IVAR "_objc_ivar"
311: #define UTAG_IVAR_LIST "_objc_ivar_list"
312: #define UTAG_METHOD "_objc_method"
313: #define UTAG_METHOD_LIST "_objc_method_list"
314: #define UTAG_CATEGORY "_objc_category"
315: #define UTAG_MODULE "_objc_module"
316: #define UTAG_SYMTAB "_objc_symtab"
317: #define UTAG_SUPER "_objc_super"
318:
319: #define UTAG_PROTOCOL "_objc_protocol"
320: #define UTAG_PROTOCOL_LIST "_objc_protocol_list"
321: #define UTAG_METHOD_PROTOTYPE "_objc_method_prototype"
322: #define UTAG_METHOD_PROTOTYPE_LIST "_objc__method_prototype_list"
323:
324: #define STRING_OBJECT_CLASS_NAME "NXConstantString"
325: #define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
326:
327: static char* TAG_GETCLASS;
328: static char* TAG_GETMETACLASS;
329: static char* TAG_MSGSEND;
330: static char* TAG_MSGSENDSUPER;
331: static char* TAG_EXECCLASS;
332:
333: /* Set by `continue_class' and checked by `is_public'. */
334:
335: #define TREE_STATIC_TEMPLATE(record_type) (TREE_PUBLIC (record_type))
336: #define TYPED_OBJECT(type) \
337: (TREE_CODE (type) == RECORD_TYPE && TREE_STATIC_TEMPLATE (type))
338:
339: /* Some commonly used instances of "identifier_node". */
340:
341: static tree self_id, ucmd_id;
342:
343: static tree self_decl, umsg_decl, umsg_super_decl;
344: static tree objc_get_class_decl, objc_get_meta_class_decl;
345:
346: static tree super_type, selector_type, id_type, objc_class_type;
347: static tree instance_type, protocol_type;
348:
349: /* Type checking macros. */
350:
351: #define IS_ID(TYPE) \
352: (TYPE_MAIN_VARIANT (TYPE) == TYPE_MAIN_VARIANT (id_type))
353: #define IS_PROTOCOL_QUALIFIED_ID(TYPE) \
354: (IS_ID (TYPE) && TYPE_PROTOCOL_LIST (TYPE))
355: #define IS_SUPER(TYPE) \
356: (super_type && TYPE_MAIN_VARIANT (TYPE) == TYPE_MAIN_VARIANT (super_type))
357:
358: static tree class_chain = NULLT;
359: static tree alias_chain = NULLT;
360: static tree interface_chain = NULLT;
361: static tree protocol_chain = NULLT;
362:
363: /* chains to manage selectors that are referenced and defined in the module */
364:
365: static tree cls_ref_chain = NULLT; /* classes referenced */
366: static tree sel_ref_chain = NULLT; /* selectors referenced */
367:
368: /* chains to manage uniquing of strings */
369:
370: static tree class_names_chain = NULLT;
371: static tree meth_var_names_chain = NULLT;
372: static tree meth_var_types_chain = NULLT;
373:
374: /* hash tables to manage the global pool of method prototypes */
375:
376: static hash *nst_method_hash_list = 0;
377: static hash *cls_method_hash_list = 0;
378:
379: /* backend data declarations */
380:
381: static tree UOBJC_SYMBOLS_decl;
382: static tree UOBJC_INSTANCE_VARIABLES_decl, UOBJC_CLASS_VARIABLES_decl;
383: static tree UOBJC_INSTANCE_METHODS_decl, UOBJC_CLASS_METHODS_decl;
384: static tree UOBJC_CLASS_decl, UOBJC_METACLASS_decl;
385: static tree UOBJC_SELECTOR_TABLE_decl;
386: static tree UOBJC_MODULES_decl;
387: static tree UOBJC_STRINGS_decl;
388:
389: /* The following are used when compiling a class implementation.
390: implementation_template will normally be an interface, however if
391: none exists this will be equal to implementation_context...it is
392: set in start_class. */
393:
394: static tree implementation_context = NULLT,
395: implementation_template = NULLT;
396:
397: struct imp_entry
398: {
399: struct imp_entry *next;
400: tree imp_context;
401: tree imp_template;
402: tree class_decl; /* _OBJC_CLASS_<my_name>; */
403: tree meta_decl; /* _OBJC_METACLASS_<my_name>; */
404: };
405:
406: static void handle_impent PROTO((struct imp_entry *));
407:
408: static struct imp_entry *imp_list = 0;
409: static int imp_count = 0; /* `@implementation' */
410: static int cat_count = 0; /* `@category' */
411:
412: static tree objc_class_template, objc_category_template, uprivate_record;
413: static tree objc_protocol_template;
414: static tree ucls_super_ref, uucls_super_ref;
415:
416: static tree objc_method_template, objc_ivar_template;
417: static tree objc_symtab_template, objc_module_template;
418: static tree objc_super_template, objc_object_reference;
419:
420: static tree objc_object_id, objc_class_id, objc_id_id;
421: static tree constant_string_id;
422: static tree constant_string_type;
423: static tree UOBJC_SUPER_decl;
424:
425: static tree method_context = NULLT;
426: static int method_slot = 0; /* used by start_method_def */
427:
428: #define BUFSIZE 1024
429:
430: static char *errbuf; /* a buffer for error diagnostics */
431:
432: /* data imported from tree.c */
433:
434: extern struct obstack permanent_obstack, *current_obstack, *rtl_obstack;
435:
436: /* data imported from toplev.c */
437:
438: extern char *dump_base_name;
439:
440: /* Generate code for GNU or NeXT runtime environment. */
441:
442: #ifdef NEXT_OBJC_RUNTIME
443: int flag_next_runtime = 1;
444: #else
445: int flag_next_runtime = 0;
446: #endif
447:
448: /* Open and close the file for outputting class declarations, if requested. */
449:
450: int flag_gen_declaration = 0;
451:
452: FILE *gen_declaration_file;
453:
454: /* Warn if multiple methods are seen for the same selector, but with
455: different argument types. */
456:
457: int warn_selector = 0;
458:
459: /* Warn if methods required by a protocol are not implemented in the
460: class adopting it. When turned off, methods inherited to that
461: class are also considered implemented */
462:
463: int flag_warn_protocol = 1;
464:
465: /* tells "encode_pointer/encode_aggregate" whether we are generating
466: type descriptors for instance variables (as opposed to methods).
467: Type descriptors for instance variables contain more information
468: than methods (for static typing and embedded structures). This
469: was added to support features being planned for dbkit2. */
470:
471: static int generating_instance_variables = 0;
472:
473: void
474: lang_init ()
475: {
476: /* the beginning of the file is a new line; check for # */
477: /* With luck, we discover the real source file's name from that
478: and put it in input_filename. */
479: ungetc (check_newline (), finput);
480:
481: /* If gen_declaration desired, open the output file. */
482: if (flag_gen_declaration)
483: {
484: int dump_base_name_length = strlen (dump_base_name);
485: register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
486: strcpy (dumpname, dump_base_name);
487: strcat (dumpname, ".decl");
488: gen_declaration_file = fopen (dumpname, "w");
489: if (gen_declaration_file == 0)
490: pfatal_with_name (dumpname);
491: }
492:
493: if (flag_next_runtime)
494: {
495: TAG_GETCLASS = "objc_getClass";
496: TAG_GETMETACLASS = "objc_getMetaClass";
497: TAG_MSGSEND = "objc_msgSend";
498: TAG_MSGSENDSUPER = "objc_msgSendSuper";
499: TAG_EXECCLASS = "__objc_execClass";
500: }
501: else
502: {
503: TAG_GETCLASS = "objc_get_class";
504: TAG_GETMETACLASS = "objc_get_meta_class";
505: TAG_MSGSEND = "objc_msg_lookup";
506: TAG_MSGSENDSUPER = "objc_msg_lookup_super";
507: TAG_EXECCLASS = "__objc_exec_class";
508: }
509:
510: if (doing_objc_thang)
511: init_objc ();
512: }
513:
514: static void
515: objc_fatal ()
516: {
517: fatal ("Objective-C text in C source file");
518: }
519:
520: void
521: objc_finish ()
522: {
523: if (doing_objc_thang)
524: finish_objc (); /* Objective-C finalization */
525:
526: if (gen_declaration_file)
527: fclose (gen_declaration_file);
528: }
529:
530: void
531: lang_finish ()
532: {
533: }
534:
535: char *
536: lang_identify ()
537: {
538: return "objc";
539: }
540:
541: int
542: lang_decode_option (p)
543: char *p;
544: {
545: if (!strcmp (p, "-lang-objc"))
546: doing_objc_thang = 1;
547: else if (!strcmp (p, "-gen-decls"))
548: flag_gen_declaration = 1;
549: else if (!strcmp (p, "-Wselector"))
550: warn_selector = 1;
551: else if (!strcmp (p, "-Wno-selector"))
552: warn_selector = 0;
553: else if (!strcmp (p, "-Wprotocol"))
554: flag_warn_protocol = 1;
555: else if (!strcmp (p, "-Wno-protocol"))
556: flag_warn_protocol = 0;
557: else if (!strcmp (p, "-fgnu-runtime"))
558: flag_next_runtime = 0;
559: else if (!strcmp (p, "-fno-next-runtime"))
560: flag_next_runtime = 0;
561: else if (!strcmp (p, "-fno-gnu-runtime"))
562: flag_next_runtime = 1;
563: else if (!strcmp (p, "-fnext-runtime"))
564: flag_next_runtime = 1;
565: else
566: return c_decode_option (p);
567:
568: return 1;
569: }
570:
571: static tree
572: define_decl (declarator, declspecs)
573: tree declarator;
574: tree declspecs;
575: {
576: tree decl = start_decl (declarator, declspecs, 0);
577: finish_decl (decl, NULLT, NULLT);
578: return decl;
579: }
580:
581: /* Return 1 if LHS and RHS are compatible types for assignment or
582: various other operations. Return 0 if they are incompatible, and
583: return -1 if we choose to not decide. When the operation is
584: REFLEXIVE, check for compatibility in either direction.
585:
586: For statically typed objects, an assignment of the form `a' = `b'
587: is permitted if:
588:
589: `a' is of type "id",
590: `a' and `b' are the same class type, or
591: `a' and `b' are of class types A and B such that B is a descendant of A. */
592:
593: int
594: maybe_objc_comptypes (lhs, rhs, reflexive)
595: tree lhs, rhs;
596: int reflexive;
597: {
598: if (doing_objc_thang)
599: return objc_comptypes (lhs, rhs, reflexive);
600: return -1;
601: }
602:
603: static tree
604: lookup_method_in_protocol_list (rproto_list, sel_name, class_meth)
605: tree rproto_list;
606: tree sel_name;
607: int class_meth;
608: {
609: tree rproto, p;
610: tree fnd = 0;
611:
612: for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
613: {
614: p = TREE_VALUE (rproto);
615:
616: if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
617: {
618: if ((fnd = lookup_method (class_meth
619: ? PROTOCOL_CLS_METHODS (p)
620: : PROTOCOL_NST_METHODS (p), sel_name)))
621: ;
622: else if (PROTOCOL_LIST (p))
623: fnd = lookup_method_in_protocol_list (PROTOCOL_LIST (p), sel_name, class_meth);
624: }
625: else
626: ; /* an identifier...if we could not find a protocol. */
627:
628: if (fnd)
629: return fnd;
630: }
631: return 0;
632: }
633:
634: static tree
635: lookup_protocol_in_reflist (rproto_list, lproto)
636: tree rproto_list;
637: tree lproto;
638: {
639: tree rproto, p;
640:
641: /* make sure the protocol is support by the object on the rhs */
642: if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE)
643: {
644: tree fnd = 0;
645: for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
646: {
647: p = TREE_VALUE (rproto);
648:
649: if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
650: {
651: if (lproto == p)
652: fnd = lproto;
653:
654: else if (PROTOCOL_LIST (p))
655: fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto);
656: }
657:
658: if (fnd)
659: return fnd;
660: }
661: }
662: else
663: ; /* an identifier...if we could not find a protocol. */
664:
665: return 0;
666: }
667:
668: /* Return 1 if LHS and RHS are compatible types for assignment
669: or various other operations. Return 0 if they are incompatible,
670: and return -1 if we choose to not decide. When the operation
671: is REFLEXIVE, check for compatibility in either direction. */
672:
673: int
674: objc_comptypes (lhs, rhs, reflexive)
675: tree lhs;
676: tree rhs;
677: int reflexive;
678: {
679: /* new clause for protocols */
680:
681: if (TREE_CODE (lhs) == POINTER_TYPE
682: && TREE_CODE (TREE_TYPE (lhs)) == RECORD_TYPE
683: && TREE_CODE (rhs) == POINTER_TYPE
684: && TREE_CODE (TREE_TYPE (rhs)) == RECORD_TYPE)
685: {
686: int lhs_is_proto = IS_PROTOCOL_QUALIFIED_ID (lhs);
687: int rhs_is_proto = IS_PROTOCOL_QUALIFIED_ID (rhs);
688:
689: if (lhs_is_proto)
690: {
691: tree lproto, lproto_list = TYPE_PROTOCOL_LIST (lhs);
692: tree rproto, rproto_list;
693: tree p;
694:
695: if (rhs_is_proto)
696: {
697: rproto_list = TYPE_PROTOCOL_LIST (rhs);
698:
699: /* Make sure the protocol is supported by the object
700: on the rhs. */
701: for (lproto = lproto_list; lproto; lproto = TREE_CHAIN (lproto))
702: {
703: p = TREE_VALUE (lproto);
704: rproto = lookup_protocol_in_reflist (rproto_list, p);
705:
706: if (!rproto)
707: warning ("object does not conform to the `%s' protocol",
708: IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
709: }
710: }
711: else if (TYPED_OBJECT (TREE_TYPE (rhs)))
712: {
713: tree rname = TYPE_NAME (TREE_TYPE (rhs));
714: tree rinter;
715:
716: /* Make sure the protocol is supported by the object
717: on the rhs. */
718: for (lproto = lproto_list; lproto; lproto = TREE_CHAIN (lproto))
719: {
720: p = TREE_VALUE (lproto);
721: rproto = 0;
722: rinter = lookup_interface (rname);
723:
724: while (rinter && !rproto)
725: {
726: tree cat;
727:
728: rproto_list = CLASS_PROTOCOL_LIST (rinter);
729: rproto = lookup_protocol_in_reflist (rproto_list, p);
730:
731: /* NEW!!! */
732: /* Check for protocols adopted by categories. */
733: cat = CLASS_CATEGORY_LIST (rinter);
734: while (cat && !rproto)
735: {
736: rproto_list = CLASS_PROTOCOL_LIST (cat);
737: rproto = lookup_protocol_in_reflist (rproto_list, p);
738:
739: cat = CLASS_CATEGORY_LIST (cat);
740: }
741:
742: rinter = lookup_interface (CLASS_SUPER_NAME (rinter));
743: }
744: if (!rproto)
745: warning ("class `%s' does not implement the `%s' protocol",
746: IDENTIFIER_POINTER (TYPE_NAME (TREE_TYPE (rhs))),
747: IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
748: }
749: }
750:
751: return 1; /* may change...based on whether there was any mismatch */
752: }
753: else if (rhs_is_proto)
754: {
755: /* lhs is not a protocol...warn if it is statically typed */
756:
757: if (TYPED_OBJECT (TREE_TYPE (lhs)))
758: return 0;
759: else
760: return 1; /* one of the types is a protocol */
761: }
762: else
763: return -1; /* defer to comptypes */
764: }
765: else if (TREE_CODE (lhs) == RECORD_TYPE && TREE_CODE (rhs) == RECORD_TYPE)
766: ; /* fall thru...this is the case we have been handling all along */
767: else
768: return -1; /* defer to comptypes */
769:
770: /* End of new protocol support. */
771:
772: /* `id' = `<class> *', `<class> *' = `id' */
773:
774: if ((TYPE_NAME (lhs) == objc_object_id && TYPED_OBJECT (rhs))
775: || (TYPE_NAME (rhs) == objc_object_id && TYPED_OBJECT (lhs)))
776: return 1;
777:
778: /* `id' = `Class', `Class' = `id' */
779:
780: else if ((TYPE_NAME (lhs) == objc_object_id
781: && TYPE_NAME (rhs) == objc_class_id)
782: || (TYPE_NAME (lhs) == objc_class_id
783: && TYPE_NAME (rhs) == objc_object_id))
784: return 1;
785:
786: /* `<class> *' = `<class> *' */
787:
788: else if (TYPED_OBJECT (lhs) && TYPED_OBJECT (rhs))
789: {
790: tree lname = TYPE_NAME (lhs);
791: tree rname = TYPE_NAME (rhs);
792: tree inter;
793:
794: if (lname == rname)
795: return 1;
796:
797: /* If the left hand side is a super class of the right hand side,
798: allow it. */
799: for (inter = lookup_interface (rname); inter;
800: inter = lookup_interface (CLASS_SUPER_NAME (inter)))
801: if (lname == CLASS_SUPER_NAME (inter))
802: return 1;
803:
804: /* Allow the reverse when reflexive. */
805: if (reflexive)
806: for (inter = lookup_interface (lname); inter;
807: inter = lookup_interface (CLASS_SUPER_NAME (inter)))
808: if (rname == CLASS_SUPER_NAME (inter))
809: return 1;
810:
811: return 0;
812: }
813: else
814: return -1; /* defer to comptypes */
815: }
816:
817: /* Called from c-decl.c before all calls to rest_of_decl_compilation. */
818:
819: void
820: objc_check_decl (decl)
821: tree decl;
822: {
823: tree type = TREE_TYPE (decl);
824:
825: if (TREE_CODE (type) == RECORD_TYPE
826: && TREE_STATIC_TEMPLATE (type)
827: && type != constant_string_type)
828: {
829: error_with_decl (decl, "`%s' cannot be statically allocated");
830: fatal ("statically allocated objects not supported");
831: }
832: }
833:
834: void
835: maybe_objc_check_decl (decl)
836: tree decl;
837: {
838: if (doing_objc_thang)
839: objc_check_decl (decl);
840: }
841:
842: /* Implement static typing. At this point, we know we have an interface. */
843:
844: tree
845: get_static_reference (interface, protocols)
846: tree interface;
847: tree protocols;
848: {
849: tree type = xref_tag (RECORD_TYPE, interface);
850:
851: if (protocols)
852: {
853: tree t, m = TYPE_MAIN_VARIANT (type);
854: struct obstack *ambient_obstack = current_obstack;
855:
856: current_obstack = &permanent_obstack;
857: t = copy_node (type);
858: TYPE_BINFO (t) = make_tree_vec (2);
859:
860: /* Add this type to the chain of variants of TYPE. */
861: TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
862: TYPE_NEXT_VARIANT (m) = t;
863:
864: current_obstack = ambient_obstack;
865:
866: /* Look up protocols and install in lang specific list. */
867: TYPE_PROTOCOL_LIST (t) = lookup_and_install_protocols (protocols);
868:
869: /* This forces a new pointer type to be created later
870: (in build_pointer_type)...so that the new template
871: we just created will actually be used...what a hack! */
872: if (TYPE_POINTER_TO (t))
873: TYPE_POINTER_TO (t) = NULL;
874:
875: type = t;
876: }
877:
878: return type;
879: }
880:
881: tree
882: get_object_reference (protocols)
883: tree protocols;
884: {
885: tree type_decl = lookup_name (objc_id_id);
886: tree type;
887:
888: if (type_decl && TREE_CODE (type_decl) == TYPE_DECL)
889: {
890: type = TREE_TYPE (type_decl);
891: if (TYPE_MAIN_VARIANT (type) != id_type)
892: warning ("Unexpected type for `id' (%s)",
893: gen_declaration (type, errbuf));
894: }
895: else
896: {
897: fatal ("Undefined type `id', please import <objc/objc.h>");
898: }
899:
900: /* This clause creates a new pointer type that is qualified with
901: the protocol specification...this info is used later to do more
902: elaborate type checking. */
903: if (protocols)
904: {
905: tree t, m = TYPE_MAIN_VARIANT (type);
906: struct obstack *ambient_obstack = current_obstack;
907:
908: current_obstack = &permanent_obstack;
909: t = copy_node (type);
910: TYPE_BINFO (t) = make_tree_vec (2);
911:
912: /* Add this type to the chain of variants of TYPE. */
913: TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
914: TYPE_NEXT_VARIANT (m) = t;
915:
916: current_obstack = ambient_obstack;
917:
918: /* look up protocols...and install in lang specific list */
919: TYPE_PROTOCOL_LIST (t) = lookup_and_install_protocols (protocols);
920:
921: /* This forces a new pointer type to be created later
922: (in build_pointer_type)...so that the new template
923: we just created will actually be used...what a hack! */
924: if (TYPE_POINTER_TO (t))
925: TYPE_POINTER_TO (t) = NULL;
926:
927: type = t;
928: }
929: return type;
930: }
931:
932: static tree
933: lookup_and_install_protocols (protocols)
934: tree protocols;
935: {
936: tree proto;
937: tree prev = NULL;
938: tree return_value = protocols;
939:
940: for (proto = protocols; proto; proto = TREE_CHAIN (proto))
941: {
942: tree ident = TREE_VALUE (proto);
943: tree p = lookup_protocol (ident);
944:
945: if (!p)
946: {
947: error ("Cannot find protocol declaration for `%s'",
948: IDENTIFIER_POINTER (ident));
949: if (prev)
950: TREE_CHAIN (prev) = TREE_CHAIN (proto);
951: else
952: return_value = TREE_CHAIN (proto);
953: }
954: else
955: {
956: /* replace identifier with actual protocol node */
957: TREE_VALUE (proto) = p;
958: prev = proto;
959: }
960: }
961: return return_value;
962: }
963:
964: /* Create and push a decl for a built-in external variable or field NAME.
965: CODE says which.
966: TYPE is its data type. */
967:
968: static tree
969: create_builtin_decl (code, type, name)
970: enum tree_code code;
971: tree type;
972: char *name;
973: {
974: tree decl = build_decl (code, get_identifier (name), type);
975: if (code == VAR_DECL)
976: {
977: TREE_STATIC (decl) = 1;
978: make_decl_rtl (decl, 0, 1);
979: pushdecl (decl);
980: }
981: return decl;
982: }
983:
984: /* purpose: "play" parser, creating/installing representations
985: of the declarations that are required by Objective-C.
986:
987: model:
988:
989: type_spec--------->sc_spec
990: (tree_list) (tree_list)
991: | |
992: | |
993: identifier_node identifier_node */
994:
995: static void
996: synth_module_prologue ()
997: {
998: tree temp_type;
999: tree super_p;
1000:
1001: /* defined in `objc.h' */
1002: objc_object_id = get_identifier (TAG_OBJECT);
1003:
1004: objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
1005:
1006: id_type = build_pointer_type (objc_object_reference);
1007:
1008: objc_id_id = get_identifier (TYPE_ID);
1009: objc_class_id = get_identifier (TAG_CLASS);
1010:
1011: objc_class_type = build_pointer_type (xref_tag (RECORD_TYPE, objc_class_id));
1012: protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
1013: get_identifier (PROTOCOL_OBJECT_CLASS_NAME)));
1014:
1015: /* Declare type of selector-objects that represent an operation name. */
1016:
1017: #ifdef OBJC_INT_SELECTORS
1018: /* `unsigned int' */
1019: selector_type = unsigned_type_node;
1020: #else
1021: /* `struct objc_selector *' */
1022: selector_type
1023: = build_pointer_type (xref_tag (RECORD_TYPE,
1024: get_identifier (TAG_SELECTOR)));
1025: #endif /* not OBJC_INT_SELECTORS */
1026:
1027: /* Forward declare type, or else the prototype for msgSendSuper will
1028: complain. */
1029:
1030: super_p = build_pointer_type (xref_tag (RECORD_TYPE,
1031: get_identifier (TAG_SUPER)));
1032:
1033:
1034: /* id objc_msgSend (id, SEL, ...); */
1035:
1036: temp_type
1037: = build_function_type (id_type,
1038: tree_cons (NULL_TREE, id_type,
1039: tree_cons (NULLT, selector_type, NULLT)));
1040:
1041: if (! flag_next_runtime)
1042: {
1043: umsg_decl = build_decl (FUNCTION_DECL,
1044: get_identifier (TAG_MSGSEND), temp_type);
1045: DECL_EXTERNAL (umsg_decl) = 1;
1046: TREE_PUBLIC (umsg_decl) = 1;
1047: DECL_INLINE (umsg_decl) = 1;
1048:
1049: if (flag_traditional && TAG_MSGSEND[0] != '_')
1050: DECL_BUILT_IN_NONANSI (umsg_decl) = 1;
1051:
1052: make_decl_rtl (umsg_decl, NULL_PTR, 1);
1053: pushdecl (umsg_decl);
1054: }
1055: else
1056: umsg_decl = builtin_function (TAG_MSGSEND, temp_type, NOT_BUILT_IN, 0);
1057:
1058: /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
1059:
1060: temp_type
1061: = build_function_type (id_type,
1062: tree_cons (NULL_TREE, super_p,
1063: tree_cons (NULLT, selector_type, NULLT)));
1064:
1065: umsg_super_decl = builtin_function (TAG_MSGSENDSUPER,
1066: temp_type, NOT_BUILT_IN, 0);
1067:
1068: /* id objc_getClass (const char *); */
1069:
1070: temp_type = build_function_type (id_type,
1071: tree_cons (NULLT,
1072: const_string_type_node,
1073: tree_cons (NULLT, void_type_node, NULLT)));
1074:
1075: objc_get_class_decl
1076: = builtin_function (TAG_GETCLASS, temp_type, NOT_BUILT_IN, 0);
1077:
1078: /* id objc_getMetaClass (const char *); */
1079:
1080: objc_get_meta_class_decl
1081: = builtin_function (TAG_GETMETACLASS, temp_type, NOT_BUILT_IN, 0);
1082:
1083: /* static SEL _OBJC_SELECTOR_TABLE[]; */
1084:
1085: if (! flag_next_runtime)
1086: UOBJC_SELECTOR_TABLE_decl
1087: = create_builtin_decl (VAR_DECL, build_array_type (selector_type, NULLT),
1088: "_OBJC_SELECTOR_TABLE");
1089:
1090: generate_forward_declaration_to_string_table ();
1091:
1092: /* Forward declare constant_string_id and constant_string_type. */
1093: constant_string_id = get_identifier (STRING_OBJECT_CLASS_NAME);
1094: constant_string_type = xref_tag (RECORD_TYPE, constant_string_id);
1095: }
1096:
1097: /* Custom build_string which sets TREE_TYPE! */
1098:
1099: static tree
1100: my_build_string (len, str)
1101: int len;
1102: char *str;
1103: {
1104: int wide_flag = 0;
1105: tree a_string = build_string (len, str);
1106: /* Some code from combine_strings, which is local to c-parse.y. */
1107: if (TREE_TYPE (a_string) == int_array_type_node)
1108: wide_flag = 1;
1109:
1110: TREE_TYPE (a_string) =
1111: build_array_type (wide_flag ? integer_type_node : char_type_node,
1112: build_index_type (build_int_2 (len - 1, 0)));
1113:
1114: TREE_CONSTANT (a_string) = 1; /* puts string in the ".text" segment */
1115: TREE_STATIC (a_string) = 1;
1116:
1117: return a_string;
1118: }
1119:
1120: /* Return a newly constructed OBJC_STRING_CST node whose value is
1121: the LEN characters at STR.
1122: The TREE_TYPE is not initialized. */
1123:
1124: tree
1125: build_objc_string (len, str)
1126: int len;
1127: char *str;
1128: {
1129: tree s = build_string (len, str);
1130:
1131: TREE_SET_CODE (s, OBJC_STRING_CST);
1132: return s;
1133: }
1134:
1135: /* Given a chain of OBJC_STRING_CST's, build a static instance of
1136: NXConstantString which points at the concatenation of those strings.
1137: We place the string object in the __string_objects section of the
1138: __OBJC segment. The Objective-C runtime will initialize the isa
1139: pointers of the string objects to point at the NXConstantString
1140: class object. */
1141:
1142: tree
1143: build_objc_string_object (strings)
1144: tree strings;
1145: {
1146: tree string, initlist, constructor;
1147: int length;
1148:
1149: if (!doing_objc_thang)
1150: objc_fatal ();
1151:
1152: if (lookup_interface (constant_string_id) == NULLT)
1153: {
1154: error ("Cannot find interface declaration for `%s'",
1155: IDENTIFIER_POINTER (constant_string_id));
1156: return error_mark_node;
1157: }
1158:
1159: add_class_reference (constant_string_id);
1160:
1161: /* combine_strings will work for OBJC_STRING_CST's too. */
1162: string = combine_strings (strings);
1163: TREE_SET_CODE (string, STRING_CST);
1164: length = TREE_STRING_LENGTH (string) - 1;
1165:
1166: /* & ((NXConstantString) {0, string, length}) */
1167:
1168: initlist = build_tree_list (NULLT, build_int_2 (0, 0));
1169: initlist = tree_cons (NULLT, build_unary_op (ADDR_EXPR, string, 1),
1170: initlist);
1171: initlist = tree_cons (NULLT, build_int_2 (length, 0), initlist);
1172: constructor = build (CONSTRUCTOR, constant_string_type, NULLT,
1173: nreverse (initlist));
1174: TREE_CONSTANT (constructor) = 1;
1175: TREE_STATIC (constructor) = 1;
1176: TREE_READONLY (constructor) = 1;
1177:
1178: return build_unary_op (ADDR_EXPR, constructor, 1);
1179: }
1180:
1181: /* Take care of defining and initializing _OBJC_SYMBOLS. */
1182:
1183: /* Predefine the following data type:
1184:
1185: struct _objc_symtab
1186: {
1187: long sel_ref_cnt;
1188: SEL *refs;
1189: short cls_def_cnt;
1190: short cat_def_cnt;
1191: void *defs[cls_def_cnt + cat_def_cnt];
1192: }; */
1193:
1194: static void
1195: build_objc_symtab_template ()
1196: {
1197: tree field_decl, field_decl_chain, index;
1198:
1199: objc_symtab_template = start_struct (RECORD_TYPE, get_identifier (UTAG_SYMTAB));
1200:
1201: /* long sel_ref_cnt; */
1202:
1203: field_decl = create_builtin_decl (FIELD_DECL,
1204: long_integer_type_node,
1205: "sel_ref_cnt");
1206: field_decl_chain = field_decl;
1207:
1208: /* SEL *refs; */
1209:
1210: field_decl = create_builtin_decl (FIELD_DECL,
1211: build_pointer_type (selector_type),
1212: "refs");
1213: chainon (field_decl_chain, field_decl);
1214:
1215: /* short cls_def_cnt; */
1216:
1217: field_decl = create_builtin_decl (FIELD_DECL,
1218: short_integer_type_node,
1219: "cls_def_cnt");
1220: chainon (field_decl_chain, field_decl);
1221:
1222: /* short cat_def_cnt; */
1223:
1224: field_decl = create_builtin_decl (FIELD_DECL,
1225: short_integer_type_node,
1226: "cat_def_cnt");
1227: chainon (field_decl_chain, field_decl);
1228:
1229: /* void *defs[cls_def_cnt + cat_def_cnt]; */
1230:
1231: index = build_index_type (build_int_2 (imp_count + cat_count - 1,
1232: imp_count == 0 && cat_count == 0
1233: ? -1 : 0));
1234: field_decl = create_builtin_decl (FIELD_DECL,
1235: build_array_type (ptr_type_node, index),
1236: "defs");
1237: chainon (field_decl_chain, field_decl);
1238:
1239: finish_struct (objc_symtab_template, field_decl_chain);
1240: }
1241:
1242: /* Create the initial value for the `defs' field of _objc_symtab.
1243: This is a CONSTRUCTOR. */
1244:
1245: static tree
1246: init_def_list ()
1247: {
1248: tree expr, initlist = NULLT;
1249: struct imp_entry *impent;
1250:
1251: if (imp_count)
1252: for (impent = imp_list; impent; impent = impent->next)
1253: {
1254: if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
1255: {
1256: expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
1257: initlist = tree_cons (NULLT, expr, initlist);
1258: }
1259: }
1260:
1261: if (cat_count)
1262: for (impent = imp_list; impent; impent = impent->next)
1263: {
1264: if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
1265: {
1266: expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
1267: initlist = tree_cons (NULLT, expr, initlist);
1268: }
1269: }
1270: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
1271: }
1272:
1273: /* Construct the initial value for all of _objc_symtab. */
1274:
1275: static tree
1276: init_objc_symtab ()
1277: {
1278: tree initlist;
1279:
1280: /* sel_ref_cnt = { ..., 5, ... } */
1281:
1282: initlist = build_tree_list (NULLT, build_int_2 (0, 0));
1283:
1284: /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
1285:
1286: if (flag_next_runtime || ! sel_ref_chain)
1287: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
1288: else
1289: initlist = tree_cons (NULLT, UOBJC_SELECTOR_TABLE_decl, initlist);
1290:
1291: /* cls_def_cnt = { ..., 5, ... } */
1292:
1293: initlist = tree_cons (NULLT, build_int_2 (imp_count, 0), initlist);
1294:
1295: /* cat_def_cnt = { ..., 5, ... } */
1296:
1297: initlist = tree_cons (NULLT, build_int_2 (cat_count, 0), initlist);
1298:
1299: /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
1300:
1301: if (imp_count || cat_count)
1302: initlist = tree_cons (NULLT, init_def_list (), initlist);
1303:
1304: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
1305: }
1306:
1307: /* Push forward-declarations of all the categories
1308: so that init_def_list can use them in a CONSTRUCTOR. */
1309:
1310: static void
1311: forward_declare_categories ()
1312: {
1313: struct imp_entry *impent;
1314: tree sav = implementation_context;
1315: for (impent = imp_list; impent; impent = impent->next)
1316: {
1317: if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
1318: {
1319: /* Set an invisible arg to synth_id_with_class_suffix. */
1320: implementation_context = impent->imp_context;
1321: impent->class_decl
1322: = create_builtin_decl (VAR_DECL, objc_category_template,
1323: IDENTIFIER_POINTER (synth_id_with_class_suffix ("_OBJC_CATEGORY", implementation_context)));
1324: }
1325: }
1326: implementation_context = sav;
1327: }
1328:
1329: /* Create the declaration of _OBJC_SYMBOLS, with type `strict _objc_symtab'
1330: and initialized appropriately. */
1331:
1332: static void
1333: generate_objc_symtab_decl ()
1334: {
1335: tree sc_spec;
1336:
1337: if (!objc_category_template)
1338: build_category_template ();
1339:
1340: /* forward declare categories */
1341: if (cat_count)
1342: forward_declare_categories ();
1343:
1344: if (!objc_symtab_template)
1345: build_objc_symtab_template ();
1346:
1347: sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_STATIC]);
1348:
1349: UOBJC_SYMBOLS_decl = start_decl (get_identifier ("_OBJC_SYMBOLS"),
1350: tree_cons (NULLT, objc_symtab_template, sc_spec), 1);
1351:
1352: end_temporary_allocation (); /* start_decl trying to be smart about inits */
1353: TREE_USED (UOBJC_SYMBOLS_decl) = 1;
1354: DECL_IGNORED_P (UOBJC_SYMBOLS_decl) = 1;
1355: finish_decl (UOBJC_SYMBOLS_decl, init_objc_symtab (), NULLT);
1356: }
1357:
1358: static tree
1359: init_module_descriptor ()
1360: {
1361: tree initlist, expr;
1362:
1363: /* version = { 1, ... } */
1364:
1365: expr = build_int_2 (OBJC_VERSION, 0);
1366: initlist = build_tree_list (NULLT, expr);
1367:
1368: /* size = { ..., sizeof (struct objc_module), ... } */
1369:
1370: expr = size_in_bytes (objc_module_template);
1371: initlist = tree_cons (NULLT, expr, initlist);
1372:
1373: /* name = { ..., "foo.m", ... } */
1374:
1375: expr = add_objc_string (get_identifier (input_filename), class_names);
1376: initlist = tree_cons (NULLT, expr, initlist);
1377:
1378: /* symtab = { ..., _OBJC_SYMBOLS, ... } */
1379:
1380: if (UOBJC_SYMBOLS_decl)
1381: expr = build_unary_op (ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
1382: else
1383: expr = build_int_2 (0, 0);
1384: initlist = tree_cons (NULLT, expr, initlist);
1385:
1386: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
1387: }
1388:
1389: /* Write out the data structures to describe Objective C classes defined.
1390: If appropriate, compile and output a setup function to initialize them.
1391: Return a string which is the name of a function to call to initialize
1392: the Objective C data structures for this file (and perhaps for other files
1393: also).
1394:
1395: struct objc_module { ... } _OBJC_MODULE = { ... };
1396:
1397: */
1398:
1399: static char *
1400: build_module_descriptor ()
1401: {
1402: tree decl_specs, field_decl, field_decl_chain;
1403:
1404: objc_module_template = start_struct (RECORD_TYPE, get_identifier (UTAG_MODULE));
1405:
1406: /* long version; */
1407:
1408: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]);
1409: field_decl = get_identifier ("version");
1410: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
1411: field_decl_chain = field_decl;
1412:
1413: /* long size; */
1414:
1415: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]);
1416: field_decl = get_identifier ("size");
1417: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
1418: chainon (field_decl_chain, field_decl);
1419:
1420: /* char *name; */
1421:
1422: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]);
1423: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("name"));
1424: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
1425: chainon (field_decl_chain, field_decl);
1426:
1427: /* struct objc_symtab *symtab; */
1428:
1429: decl_specs = get_identifier (UTAG_SYMTAB);
1430: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, decl_specs));
1431: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("symtab"));
1432: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
1433: chainon (field_decl_chain, field_decl);
1434:
1435: finish_struct (objc_module_template, field_decl_chain);
1436:
1437: /* create an instance of "objc_module" */
1438:
1439: decl_specs = tree_cons (NULLT, objc_module_template,
1440: build_tree_list (NULLT, ridpointers[(int) RID_STATIC]));
1441:
1442: UOBJC_MODULES_decl = start_decl (get_identifier ("_OBJC_MODULES"),
1443: decl_specs, 1);
1444:
1445: end_temporary_allocation (); /* start_decl trying to be smart about inits */
1446: DECL_IGNORED_P (UOBJC_MODULES_decl) = 1;
1447: finish_decl (UOBJC_MODULES_decl, init_module_descriptor (), NULLT);
1448:
1449: /* Mark the decl to avoid "defined but not used" warning. */
1450: DECL_IN_SYSTEM_HEADER (UOBJC_MODULES_decl) = 1;
1451:
1452: /* Generate a constructor call for the module descriptor.
1453: This code was generated by reading the grammar rules
1454: of c-parse.y; Therefore, it may not be the most efficient
1455: way of generating the requisite code. */
1456:
1457: if (flag_next_runtime)
1458: return 0;
1459:
1460: {
1461: tree parms, function_decl, decelerator, void_list_node;
1462: tree function_type;
1463: char *buf;
1464: char *global_object_name = 0;
1465: tree t;
1466:
1467: /* Use a global object (which is already required to be unique over
1468: the program) rather than the file name (which imposes extra
1469: constraints). -- [email protected], 10 Jan 1990. */
1470:
1471: /* Find the name of some global object defined in this file. */
1472: for (t = getdecls (); t; t = TREE_CHAIN (t))
1473: if (TREE_PUBLIC (t) && !DECL_EXTERNAL (t) && DECL_INITIAL (t) != 0)
1474: {
1475: global_object_name = IDENTIFIER_POINTER (DECL_NAME (t));
1476: break;
1477: }
1478:
1479: /* If none, use the name of the file. */
1480: if (!global_object_name)
1481: {
1482: char *p, *q;
1483: global_object_name
1484: = (char *) alloca (strlen (main_input_filename) + 1);
1485:
1486: p = main_input_filename;
1487: q = global_object_name;
1488:
1489: /* Replace any weird characters in the file name. */
1490: for (; *p; p++)
1491: if (! ((*p >= '0' && *p <= '9')
1492: || (*p >= 'A' && *p <= 'Z')
1493: || (*p >= 'a' && *p <= 'z')))
1494: *q++ = '_';
1495: else
1496: *q++ = *p;
1497: *q = 0;
1498: }
1499:
1500: /* Make the constructor name from the name we have found. */
1501: buf = (char *) xmalloc (sizeof (CONSTRUCTOR_NAME_FORMAT)
1502: + strlen (global_object_name));
1503: sprintf (buf, CONSTRUCTOR_NAME_FORMAT, global_object_name);
1504:
1505: /* Declare void __objc_execClass (void*); */
1506:
1507: void_list_node = build_tree_list (NULL_TREE, void_type_node);
1508: function_type
1509: = build_function_type (void_type_node,
1510: tree_cons (NULL_TREE, ptr_type_node,
1511: void_list_node));
1512: function_decl = build_decl (FUNCTION_DECL,
1513: get_identifier (TAG_EXECCLASS),
1514: function_type);
1515: DECL_EXTERNAL (function_decl) = 1;
1516: TREE_PUBLIC (function_decl) = 1;
1517: pushdecl (function_decl);
1518: rest_of_decl_compilation (function_decl, 0, 0, 0);
1519:
1520: parms
1521: = build_tree_list (NULLT,
1522: build_unary_op (ADDR_EXPR, UOBJC_MODULES_decl, 0));
1523: decelerator = build_function_call (function_decl, parms);
1524:
1525: /* void _GLOBAL_$I$<gnyf> () {objc_execClass (&L_OBJC_MODULES);} */
1526:
1527: start_function (void_list_node,
1528: build_parse_node (CALL_EXPR, get_identifier (buf),
1529: /* This has the format of the output
1530: of get_parm_info. */
1531: tree_cons (NULL_TREE, NULL_TREE,
1532: void_list_node),
1533: NULL_TREE),
1534: 0);
1535: #if 0 /* This should be turned back on later
1536: for the systems where collect is not needed. */
1537: /* Make these functions nonglobal
1538: so each file can use the same name. */
1539: TREE_PUBLIC (current_function_decl) = 0;
1540: #endif
1541: TREE_USED (current_function_decl) = 1;
1542: store_parm_decls ();
1543:
1544: assemble_external (function_decl);
1545: c_expand_expr_stmt (decelerator);
1546:
1547: finish_function (0);
1548:
1549: /* Return the name of the constructor function. */
1550: return buf;
1551: }
1552: }
1553:
1554: /* extern const char _OBJC_STRINGS[]; */
1555:
1556: static void
1557: generate_forward_declaration_to_string_table ()
1558: {
1559: tree sc_spec, decl_specs, expr_decl;
1560:
1561: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_EXTERN], NULLT);
1562: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_CHAR], sc_spec);
1563:
1564: expr_decl = build_nt (ARRAY_REF, get_identifier ("_OBJC_STRINGS"), NULLT);
1565:
1566: UOBJC_STRINGS_decl = define_decl (expr_decl, decl_specs);
1567: }
1568:
1569: /* Output all strings. */
1570:
1571: static void
1572: generate_strings ()
1573: {
1574: tree sc_spec, decl_specs, expr_decl;
1575: tree chain, string_expr;
1576: tree string, decl;
1577:
1578: for (chain = class_names_chain; chain; chain = TREE_CHAIN (chain))
1579: {
1580: string = TREE_VALUE (chain);
1581: decl = TREE_PURPOSE (chain);
1582: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
1583: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_CHAR], sc_spec);
1584: expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULLT);
1585: decl = start_decl (expr_decl, decl_specs, 1);
1586: end_temporary_allocation ();
1587: string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
1588: IDENTIFIER_POINTER (string));
1589: finish_decl (decl, string_expr, NULLT);
1590: }
1591:
1592: for (chain = meth_var_names_chain; chain; chain = TREE_CHAIN (chain))
1593: {
1594: string = TREE_VALUE (chain);
1595: decl = TREE_PURPOSE (chain);
1596: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
1597: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_CHAR], sc_spec);
1598: expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULLT);
1599: decl = start_decl (expr_decl, decl_specs, 1);
1600: end_temporary_allocation ();
1601: string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
1602: IDENTIFIER_POINTER (string));
1603: finish_decl (decl, string_expr, NULLT);
1604: }
1605:
1606: for (chain = meth_var_types_chain; chain; chain = TREE_CHAIN (chain))
1607: {
1608: string = TREE_VALUE (chain);
1609: decl = TREE_PURPOSE (chain);
1610: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
1611: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_CHAR], sc_spec);
1612: expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULLT);
1613: decl = start_decl (expr_decl, decl_specs, 1);
1614: end_temporary_allocation ();
1615: string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
1616: IDENTIFIER_POINTER (string));
1617: finish_decl (decl, string_expr, NULLT);
1618: }
1619: }
1620:
1621: static tree
1622: build_selector_reference_decl (name)
1623: tree name;
1624: {
1625: tree decl, ident;
1626: char buf[256];
1627: struct obstack *save_current_obstack = current_obstack;
1628: struct obstack *save_rtl_obstack = rtl_obstack;
1629: static int idx = 0;
1630:
1631: sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", idx++);
1632:
1633: /* new stuff */
1634: rtl_obstack = current_obstack = &permanent_obstack;
1635: ident = get_identifier (buf);
1636:
1637: decl = build_decl (VAR_DECL, ident, selector_type);
1638: DECL_EXTERNAL (decl) = 1;
1639: TREE_PUBLIC (decl) = 1;
1640: TREE_USED (decl) = 1;
1641: TREE_READONLY (decl) = 1;
1642:
1643: make_decl_rtl (decl, 0, 1); /* usually called from `rest_of_decl_compilation' */
1644: pushdecl_top_level (decl); /* our `extended/custom' pushdecl in c-decl.c */
1645:
1646: current_obstack = save_current_obstack;
1647: rtl_obstack = save_rtl_obstack;
1648:
1649: return decl;
1650: }
1651:
1652: /* Just a handy wrapper for add_objc_string. */
1653:
1654: static tree
1655: build_selector (ident)
1656: tree ident;
1657: {
1658: tree expr = add_objc_string (ident, meth_var_names);
1659:
1660: return build_c_cast (selector_type, expr); /* cast! */
1661: }
1662:
1663: /* Synthesize the following expr: (char *)&_OBJC_STRINGS[<offset>]
1664: The cast stops the compiler from issuing the following message:
1665: grok.m: warning: initialization of non-const * pointer from const *
1666: grok.m: warning: initialization between incompatible pointer types. */
1667:
1668: static tree
1669: build_msg_pool_reference (offset)
1670: int offset;
1671: {
1672: tree expr = build_int_2 (offset, 0);
1673: tree cast;
1674:
1675: expr = build_array_ref (UOBJC_STRINGS_decl, expr);
1676: expr = build_unary_op (ADDR_EXPR, expr, 0);
1677:
1678: cast = build_tree_list (build_tree_list (NULLT, ridpointers[(int) RID_CHAR]),
1679: build1 (INDIRECT_REF, NULLT, NULLT));
1680: TREE_TYPE (expr) = groktypename (cast);
1681: return expr;
1682: }
1683:
1684: static tree
1685: init_selector (offset)
1686: int offset;
1687: {
1688: tree expr = build_msg_pool_reference (offset);
1689: TREE_TYPE (expr) = selector_type; /* cast */
1690: return expr;
1691: }
1692:
1693: static void
1694: build_selector_translation_table ()
1695: {
1696: tree sc_spec, decl_specs;
1697: tree chain, initlist = NULLT;
1698: int offset = 0;
1699: tree decl, var_decl, name;
1700:
1701: /* The corresponding pop_obstacks is in finish_decl,
1702: called at the end of this function. */
1703: if (! flag_next_runtime)
1704: push_obstacks_nochange ();
1705:
1706: for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
1707: {
1708: tree expr;
1709:
1710: expr = build_selector (TREE_VALUE (chain));
1711:
1712: if (flag_next_runtime)
1713: {
1714: name = DECL_NAME (TREE_PURPOSE (chain));
1715:
1716: sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_STATIC]);
1717:
1718: /* static SEL _OBJC_SELECTOR_REFERENCES_n = ...; */
1719: decl_specs = tree_cons (NULLT, selector_type, sc_spec);
1720:
1721: var_decl = name;
1722:
1723: /* the `decl' that is returned from start_decl is the one that we
1724: forward declared in `build_selector_reference' */
1725: decl = start_decl (var_decl, decl_specs, 1);
1726: }
1727:
1728: /* add one for the '\0' character */
1729: offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;
1730:
1731: if (flag_next_runtime)
1732: {
1733: end_temporary_allocation ();
1734: finish_decl (decl, expr, NULLT);
1735: }
1736: else
1737: initlist = tree_cons (NULLT, expr, initlist);
1738: }
1739:
1740: if (! flag_next_runtime)
1741: {
1742: /* Cause the variable and its initial value to be actually output. */
1743: DECL_EXTERNAL (UOBJC_SELECTOR_TABLE_decl) = 0;
1744: TREE_STATIC (UOBJC_SELECTOR_TABLE_decl) = 1;
1745: /* NULL terminate the list and fix the decl for output. */
1746: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
1747: DECL_INITIAL (UOBJC_SELECTOR_TABLE_decl) = (tree) 1;
1748: initlist = build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
1749: finish_decl (UOBJC_SELECTOR_TABLE_decl, initlist, NULLT);
1750: }
1751: }
1752:
1753: /* sel_ref_chain is a list whose "value" fields will be instances of
1754: identifier_node that represent the selector. */
1755:
1756: static tree
1757: build_selector_reference (ident)
1758: tree ident;
1759: {
1760: tree *chain = &sel_ref_chain;
1761: tree decl;
1762: int index = 0;
1763:
1764: while (*chain)
1765: {
1766: if (TREE_VALUE (*chain) == ident)
1767: return (flag_next_runtime
1768: ? TREE_PURPOSE (*chain)
1769: : build_array_ref (UOBJC_SELECTOR_TABLE_decl,
1770: build_int_2 (index, 0)));
1771:
1772: index++;
1773: chain = &TREE_CHAIN (*chain);
1774: }
1775:
1776: decl = build_selector_reference_decl (ident);
1777:
1778: *chain = perm_tree_cons (decl, ident, NULLT);
1779:
1780: return (flag_next_runtime
1781: ? decl
1782: : build_array_ref (UOBJC_SELECTOR_TABLE_decl,
1783: build_int_2 (index, 0)));
1784: }
1785:
1786: static tree
1787: build_class_reference_decl (name)
1788: tree name;
1789: {
1790: tree decl, ident;
1791: char buf[256];
1792: struct obstack *save_current_obstack = current_obstack;
1793: struct obstack *save_rtl_obstack = rtl_obstack;
1794: static int idx = 0;
1795:
1796: sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", idx++);
1797:
1798: /* new stuff */
1799: rtl_obstack = current_obstack = &permanent_obstack;
1800: ident = get_identifier (buf);
1801:
1802: decl = build_decl (VAR_DECL, ident, objc_class_type);
1803: DECL_EXTERNAL (decl) = 1;
1804: TREE_PUBLIC (decl) = 1;
1805: TREE_USED (decl) = 1;
1806: TREE_READONLY (decl) = 1;
1807:
1808: make_decl_rtl (decl, 0, 1); /* usually called from `rest_of_decl_compilation' */
1809: pushdecl_top_level (decl); /* our `extended/custom' pushdecl in c-decl.c */
1810:
1811: current_obstack = save_current_obstack;
1812: rtl_obstack = save_rtl_obstack;
1813:
1814: return decl;
1815: }
1816:
1817: /* Create a class reference, but don't create a variable to reference
1818: it. */
1819:
1820: static void
1821: add_class_reference (ident)
1822: tree ident;
1823: {
1824: tree chain;
1825:
1826: if ((chain = cls_ref_chain))
1827: {
1828: tree tail;
1829: do
1830: {
1831: if (ident == TREE_VALUE (chain))
1832: return;
1833:
1834: tail = chain;
1835: chain = TREE_CHAIN (chain);
1836: }
1837: while (chain);
1838:
1839: /* append to the end of the list */
1840: TREE_CHAIN (tail) = perm_tree_cons (NULLT, ident, NULLT);
1841: }
1842: else
1843: cls_ref_chain = perm_tree_cons (NULLT, ident, NULLT);
1844: }
1845:
1846: /* Get a class reference, creating it if necessary. Also create the
1847: reference variable. */
1848:
1849: tree
1850: get_class_reference (ident)
1851: tree ident;
1852: {
1853: if (flag_next_runtime)
1854: {
1855: tree *chain;
1856: tree decl;
1857:
1858: for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
1859: if (TREE_VALUE (*chain) == ident)
1860: {
1861: if (! TREE_PURPOSE (*chain))
1862: TREE_PURPOSE (*chain) = build_class_reference_decl (ident);
1863: return TREE_PURPOSE (*chain);
1864: }
1865:
1866: decl = build_class_reference_decl (ident);
1867: *chain = perm_tree_cons (decl, ident, NULLT);
1868: return decl;
1869: }
1870: else
1871: {
1872: tree params;
1873:
1874: add_class_reference (ident);
1875:
1876: params = build_tree_list (NULLT,
1877: my_build_string (IDENTIFIER_LENGTH (ident) + 1,
1878: IDENTIFIER_POINTER (ident)));
1879:
1880: assemble_external (objc_get_class_decl);
1881: return build_function_call (objc_get_class_decl, params);
1882: }
1883: }
1884:
1885: /* sel_refdef_chain is a list whose "value" fields will be instances
1886: of identifier_node that represent the selector. It returns the
1887: offset of the selector from the beginning of the _OBJC_STRINGS
1888: pool. This offset is typically used by init_selector during code
1889: generation.
1890:
1891: For each string section we have a chain which maps identifier nodes
1892: to decls for the strings. */
1893:
1894: static tree
1895: add_objc_string (ident, section)
1896: tree ident;
1897: enum string_section section;
1898: {
1899: tree *chain, decl;
1900:
1901: if (section == class_names)
1902: chain = &class_names_chain;
1903: else if (section == meth_var_names)
1904: chain = &meth_var_names_chain;
1905: else if (section == meth_var_types)
1906: chain = &meth_var_types_chain;
1907:
1908: while (*chain)
1909: {
1910: if (TREE_VALUE (*chain) == ident)
1911: return TREE_PURPOSE (*chain);
1912:
1913: chain = &TREE_CHAIN (*chain);
1914: }
1915:
1916: decl = build_objc_string_decl (ident, section);
1917:
1918: *chain = perm_tree_cons (decl, ident, NULLT);
1919:
1920: return decl;
1921: }
1922:
1923: static tree
1924: build_objc_string_decl (name, section)
1925: tree name;
1926: enum string_section section;
1927: {
1928: tree decl, ident;
1929: char buf[256];
1930: struct obstack *save_current_obstack = current_obstack;
1931: struct obstack *save_rtl_obstack = rtl_obstack;
1932: static int class_names_idx = 0;
1933: static int meth_var_names_idx = 0;
1934: static int meth_var_types_idx = 0;
1935:
1936: if (section == class_names)
1937: sprintf (buf, "_OBJC_CLASS_NAME_%d", class_names_idx++);
1938: else if (section == meth_var_names)
1939: sprintf (buf, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
1940: else if (section == meth_var_types)
1941: sprintf (buf, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
1942:
1943: rtl_obstack = current_obstack = &permanent_obstack;
1944: ident = get_identifier (buf);
1945:
1946: decl = build_decl (VAR_DECL, ident, build_array_type (char_type_node, 0));
1947: DECL_EXTERNAL (decl) = 1;
1948: TREE_PUBLIC (decl) = 1;
1949: TREE_USED (decl) = 1;
1950: TREE_READONLY (decl) = 1;
1951: TREE_CONSTANT (decl) = 1;
1952:
1953: make_decl_rtl (decl, 0, 1); /* usually called from `rest_of_decl_compilation */
1954: pushdecl_top_level (decl); /* our `extended/custom' pushdecl in c-decl.c */
1955:
1956: current_obstack = save_current_obstack;
1957: rtl_obstack = save_rtl_obstack;
1958:
1959: return decl;
1960: }
1961:
1962:
1963: void
1964: objc_declare_alias (alias_ident, class_ident)
1965: tree alias_ident;
1966: tree class_ident;
1967: {
1968: if (!doing_objc_thang)
1969: objc_fatal ();
1970:
1971: if (is_class_name (class_ident) != class_ident)
1972: warning ("Cannot find class `%s'", IDENTIFIER_POINTER (class_ident));
1973: else if (is_class_name (alias_ident))
1974: warning ("Class `%s' already exists", IDENTIFIER_POINTER (alias_ident));
1975: else
1976: alias_chain = tree_cons (class_ident, alias_ident, alias_chain);
1977: }
1978:
1979: void
1980: objc_declare_class (ident_list)
1981: tree ident_list;
1982: {
1983: tree list;
1984:
1985: if (!doing_objc_thang)
1986: objc_fatal ();
1987:
1988: for (list = ident_list; list; list = TREE_CHAIN (list))
1989: {
1990: tree ident = TREE_VALUE (list);
1991: tree decl;
1992:
1993: if ((decl = lookup_name (ident)))
1994: {
1995: error ("`%s' redeclared as different kind of symbol",
1996: IDENTIFIER_POINTER (ident));
1997: error_with_decl (decl, "previous declaration of `%s'");
1998: }
1999:
2000: if (! is_class_name (ident))
2001: {
2002: tree record = xref_tag (RECORD_TYPE, ident);
2003: TREE_STATIC_TEMPLATE (record) = 1;
2004: class_chain = tree_cons (NULLT, ident, class_chain);
2005: }
2006: }
2007: }
2008:
2009: tree
2010: is_class_name (ident)
2011: tree ident;
2012: {
2013: tree chain;
2014:
2015: if (lookup_interface (ident))
2016: return ident;
2017:
2018: for (chain = class_chain; chain; chain = TREE_CHAIN (chain))
2019: {
2020: if (ident == TREE_VALUE (chain))
2021: return ident;
2022: }
2023:
2024: for (chain = alias_chain; chain; chain = TREE_CHAIN (chain))
2025: {
2026: if (ident == TREE_VALUE (chain))
2027: return TREE_PURPOSE (chain);
2028: }
2029:
2030: return 0;
2031: }
2032:
2033: tree
2034: lookup_interface (ident)
2035: tree ident;
2036: {
2037: tree chain;
2038:
2039: for (chain = interface_chain; chain; chain = TREE_CHAIN (chain))
2040: {
2041: if (ident == CLASS_NAME (chain))
2042: return chain;
2043: }
2044: return NULLT;
2045: }
2046:
2047: static tree
2048: objc_copy_list (list, head)
2049: tree list;
2050: tree *head;
2051: {
2052: tree newlist = NULL_TREE, tail = NULL_TREE;
2053:
2054: while (list)
2055: {
2056: tail = copy_node (list);
2057:
2058: /* The following statement fixes a bug when inheriting instance
2059: variables that are declared to be bitfields. finish_struct
2060: expects to find the width of the bitfield in DECL_INITIAL,
2061: which it nulls out after processing the decl of the super
2062: class...rather than change the way finish_struct works (which
2063: is risky), I create the situation it expects...s.naroff
2064: (7/23/89). */
2065:
2066: if (DECL_BIT_FIELD (tail) && DECL_INITIAL (tail) == 0)
2067: DECL_INITIAL (tail) = build_int_2 (DECL_FIELD_SIZE (tail), 0);
2068:
2069: newlist = chainon (newlist, tail);
2070: list = TREE_CHAIN (list);
2071: }
2072: *head = newlist;
2073: return tail;
2074: }
2075:
2076: /* Used by: build_private_template, get_class_ivars, and
2077: continue_class. COPY is 1 when called from @defs. In this case
2078: copy all fields. Otherwise don't copy leaf ivars since we rely on
2079: them being side-effected exactly once by finish_struct. */
2080:
2081: static tree
2082: build_ivar_chain (interface, copy)
2083: tree interface;
2084: int copy;
2085: {
2086: tree my_name, super_name, ivar_chain;
2087:
2088: my_name = CLASS_NAME (interface);
2089: super_name = CLASS_SUPER_NAME (interface);
2090:
2091: /* Possibly copy leaf ivars. */
2092: if (copy)
2093: objc_copy_list (CLASS_IVARS (interface), &ivar_chain);
2094: else
2095: ivar_chain = CLASS_IVARS (interface);
2096:
2097: while (super_name)
2098: {
2099: tree op1;
2100: tree super_interface = lookup_interface (super_name);
2101:
2102: if (!super_interface)
2103: {
2104: /* fatal did not work with 2 args...should fix */
2105: error ("Cannot find interface declaration for `%s', superclass of `%s'",
2106: IDENTIFIER_POINTER (super_name),
2107: IDENTIFIER_POINTER (my_name));
2108: exit (34);
2109: }
2110: if (super_interface == interface)
2111: {
2112: fatal ("Circular inheritance in interface declaration for `%s'",
2113: IDENTIFIER_POINTER (super_name));
2114: }
2115: interface = super_interface;
2116: my_name = CLASS_NAME (interface);
2117: super_name = CLASS_SUPER_NAME (interface);
2118:
2119: op1 = CLASS_IVARS (interface);
2120: if (op1)
2121: {
2122: tree head, tail = objc_copy_list (op1, &head);
2123:
2124: /* Prepend super class ivars...make a copy of the list, we
2125: do not want to alter the original. */
2126: TREE_CHAIN (tail) = ivar_chain;
2127: ivar_chain = head;
2128: }
2129: }
2130: return ivar_chain;
2131: }
2132:
2133: /* struct <classname> {
2134: struct objc_class *isa;
2135: ...
2136: }; */
2137:
2138: static tree
2139: build_private_template (class)
2140: tree class;
2141: {
2142: tree ivar_context;
2143:
2144: if (CLASS_STATIC_TEMPLATE (class))
2145: {
2146: uprivate_record = CLASS_STATIC_TEMPLATE (class);
2147: ivar_context = TYPE_FIELDS (CLASS_STATIC_TEMPLATE (class));
2148: }
2149: else
2150: {
2151: uprivate_record = start_struct (RECORD_TYPE, CLASS_NAME (class));
2152:
2153: ivar_context = build_ivar_chain (class, 0);
2154:
2155: finish_struct (uprivate_record, ivar_context);
2156:
2157: CLASS_STATIC_TEMPLATE (class) = uprivate_record;
2158:
2159: /* mark this record as class template - for class type checking */
2160: TREE_STATIC_TEMPLATE (uprivate_record) = 1;
2161: }
2162: instance_type = groktypename (build_tree_list (build_tree_list (NULLT, uprivate_record),
2163: build1 (INDIRECT_REF, NULLT, NULLT)));
2164: return ivar_context;
2165: }
2166:
2167: /* Begin code generation for protocols... */
2168:
2169: /* struct objc_protocol {
2170: char *protocol_name;
2171: struct objc_protocol **protocol_list;
2172: struct objc_method_desc *instance_methods;
2173: struct objc_method_desc *class_methods;
2174: }; */
2175:
2176: static tree
2177: build_protocol_template ()
2178: {
2179: tree decl_specs, field_decl, field_decl_chain;
2180: tree template;
2181:
2182: template = start_struct (RECORD_TYPE, get_identifier (UTAG_PROTOCOL));
2183:
2184: /* struct objc_class *isa; */
2185:
2186: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2187: get_identifier (UTAG_CLASS)));
2188: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("isa"));
2189: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2190: field_decl_chain = field_decl;
2191:
2192: /* char *protocol_name; */
2193:
2194: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]);
2195: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("protocol_name"));
2196: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2197: chainon (field_decl_chain, field_decl);
2198:
2199: /* struct objc_protocol **protocol_list; */
2200:
2201: decl_specs = build_tree_list (NULLT, template);
2202: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("protocol_list"));
2203: field_decl = build1 (INDIRECT_REF, NULLT, field_decl);
2204: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2205: chainon (field_decl_chain, field_decl);
2206:
2207: /* struct objc_method_list *instance_methods; */
2208:
2209: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2210: get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
2211: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("instance_methods"));
2212: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2213: chainon (field_decl_chain, field_decl);
2214:
2215: /* struct objc_method_list *class_methods; */
2216:
2217: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2218: get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
2219: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("class_methods"));
2220: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2221: chainon (field_decl_chain, field_decl);
2222:
2223: return finish_struct (template, field_decl_chain);
2224: }
2225:
2226: static tree
2227: build_descriptor_table_initializer (entries, size)
2228: tree entries;
2229: int *size;
2230: {
2231: tree initlist = NULLT;
2232:
2233: do
2234: {
2235: initlist = tree_cons (NULLT, build_selector (METHOD_SEL_NAME (entries)), initlist);
2236:
2237: initlist = tree_cons (NULLT, add_objc_string (METHOD_ENCODING (entries), meth_var_types), initlist);
2238:
2239: (*size)++;
2240: entries = TREE_CHAIN (entries);
2241: }
2242: while (entries);
2243:
2244: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
2245: }
2246:
2247: /* struct objc_method_prototype_list {
2248: int count;
2249: struct objc_method_prototype {
2250: SEL name;
2251: char *types;
2252: } list[1];
2253: }; */
2254:
2255: static tree
2256: build_method_prototype_list_template (list_type, size)
2257: tree list_type;
2258: int size;
2259: {
2260: tree objc_ivar_list_record;
2261: tree decl_specs, field_decl, field_decl_chain;
2262:
2263: /* generate an unnamed struct definition */
2264:
2265: objc_ivar_list_record = start_struct (RECORD_TYPE, NULLT);
2266:
2267: /* int method_count; */
2268:
2269: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_INT]);
2270: field_decl = get_identifier ("method_count");
2271:
2272: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2273: field_decl_chain = field_decl;
2274:
2275: /* struct objc_method method_list[]; */
2276:
2277: decl_specs = build_tree_list (NULLT, list_type);
2278: field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
2279: build_int_2 (size, 0));
2280:
2281: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2282: chainon (field_decl_chain, field_decl);
2283:
2284: finish_struct (objc_ivar_list_record, field_decl_chain);
2285:
2286: return objc_ivar_list_record;
2287: }
2288:
2289: static tree
2290: build_method_prototype_template ()
2291: {
2292: tree proto_record;
2293: tree decl_specs, field_decl, field_decl_chain;
2294:
2295: proto_record = start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD_PROTOTYPE));
2296:
2297: #ifdef OBJC_INT_SELECTORS
2298: /* unsigned int _cmd; */
2299: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_UNSIGNED], NULLT);
2300: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs);
2301: field_decl = get_identifier ("_cmd");
2302: #else /* OBJC_INT_SELECTORS */
2303: /* struct objc_selector *_cmd; */
2304: decl_specs = tree_cons (NULLT, xref_tag (RECORD_TYPE,
2305: get_identifier (TAG_SELECTOR)), NULLT);
2306: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("_cmd"));
2307: #endif /* OBJC_INT_SELECTORS */
2308:
2309: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2310: field_decl_chain = field_decl;
2311:
2312: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_CHAR], NULLT);
2313: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("method_types"));
2314: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2315: chainon (field_decl_chain, field_decl);
2316:
2317: finish_struct (proto_record, field_decl_chain);
2318:
2319: return proto_record;
2320: }
2321:
2322: static int
2323: forwarding_offset (parm)
2324: tree parm;
2325: {
2326: int offset_in_bytes;
2327:
2328: if (GET_CODE (DECL_INCOMING_RTL (parm)) == MEM)
2329: {
2330: rtx addr = XEXP (DECL_INCOMING_RTL (parm), 0);
2331:
2332: /* ??? Here we assume that the parm address is indexed
2333: off the frame pointer or arg pointer.
2334: If that is not true, we produce meaningless results,
2335: but do not crash. */
2336: if (GET_CODE (addr) == PLUS
2337: && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2338: offset_in_bytes = INTVAL (XEXP (addr, 1));
2339: else
2340: offset_in_bytes = 0;
2341:
2342: offset_in_bytes += OBJC_FORWARDING_STACK_OFFSET;
2343: }
2344: #ifdef OBJC_FORWARDING_REG_OFFSET
2345: else if (GET_CODE (DECL_INCOMING_RTL (parm)) == REG)
2346: {
2347: int regno = REGNO (DECL_INCOMING_RTL (parm));
2348:
2349: offset_in_bytes = 4 * (regno - OBJC_FORWARDING_FIRST_REG)
2350: + OBJC_FORWARDING_REG_OFFSET;
2351: }
2352: #endif /* OBJC_FORWARDING_REG_OFFSET */
2353: else
2354: return 0;
2355:
2356: /* This is the case where the parm is passed as an int or double
2357: and it is converted to a char, short or float and stored back
2358: in the parmlist. In this case, describe the parm
2359: with the variable's declared type, and adjust the address
2360: if the least significant bytes (which we are using) are not
2361: the first ones. */
2362: #if BYTES_BIG_ENDIAN
2363: if (TREE_TYPE (parm) != DECL_ARG_TYPE (parm))
2364: offset_in_bytes += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parm)))
2365: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parm))));
2366: #endif
2367:
2368: return offset_in_bytes;
2369: }
2370:
2371: static tree
2372: encode_method_prototype (method_decl, func_decl)
2373: tree method_decl;
2374: tree func_decl;
2375: {
2376: tree parms;
2377: int stack_size, i;
2378: tree user_args;
2379: int max_parm_end = 0;
2380: char buf[40];
2381: tree result;
2382:
2383: /* `oneway' and 'bycopy', for remote object are the only method qualifiers */
2384: encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl)));
2385:
2386: /* C type */
2387: encode_type (TREE_TYPE (TREE_TYPE (func_decl)),
2388: obstack_object_size (&util_obstack),
2389: OBJC_ENCODE_INLINE_DEFS);
2390:
2391: /* stack size */
2392: for (parms = DECL_ARGUMENTS (func_decl); parms;
2393: parms = TREE_CHAIN (parms))
2394: {
2395: int parm_end = (forwarding_offset (parms)
2396: + (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (parms)))
2397: / BITS_PER_UNIT));
2398:
2399: if (parm_end > max_parm_end)
2400: max_parm_end = parm_end;
2401: }
2402:
2403: stack_size = max_parm_end - OBJC_FORWARDING_MIN_OFFSET;
2404:
2405: sprintf (buf, "%d", stack_size);
2406: obstack_grow (&util_obstack, buf, strlen (buf));
2407:
2408: user_args = METHOD_SEL_ARGS (method_decl);
2409:
2410: /* argument types */
2411: for (parms = DECL_ARGUMENTS (func_decl), i = 0; parms;
2412: parms = TREE_CHAIN (parms), i++)
2413: {
2414: /* process argument qualifiers for user supplied arguments */
2415: if (i > 1)
2416: {
2417: encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (user_args)));
2418: user_args = TREE_CHAIN (user_args);
2419: }
2420:
2421: /* type */
2422: encode_type (TREE_TYPE (parms),
2423: obstack_object_size (&util_obstack),
2424: OBJC_ENCODE_INLINE_DEFS);
2425:
2426: /* compute offset */
2427: sprintf (buf, "%d", forwarding_offset (parms));
2428: obstack_grow (&util_obstack, buf, strlen (buf));
2429: }
2430:
2431: obstack_1grow (&util_obstack, '\0');
2432: result = get_identifier (obstack_finish (&util_obstack));
2433: obstack_free (&util_obstack, util_firstobj);
2434: return result;
2435: }
2436:
2437: static tree
2438: generate_descriptor_table (type, name, size, list, proto)
2439: tree type;
2440: char *name;
2441: int size;
2442: tree list;
2443: tree proto;
2444: {
2445: tree sc_spec, decl_specs, decl, initlist;
2446:
2447: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
2448: decl_specs = tree_cons (NULLT, type, sc_spec);
2449:
2450: decl = start_decl (synth_id_with_class_suffix (name, proto),
2451: decl_specs, 1);
2452: end_temporary_allocation ();
2453:
2454: initlist = build_tree_list (NULLT, build_int_2 (size, 0));
2455: initlist = tree_cons (NULLT, list, initlist);
2456:
2457: finish_decl (decl, build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)), NULLT);
2458:
2459: return decl;
2460: }
2461:
2462: static void
2463: generate_method_descriptors (protocol) /* generate_dispatch_tables */
2464: tree protocol;
2465: {
2466: static tree objc_method_prototype_template;
2467: tree initlist, chain, method_list_template;
2468: tree cast, variable_length_type;
2469: int size;
2470:
2471: if (!objc_method_prototype_template)
2472: objc_method_prototype_template = build_method_prototype_template ();
2473:
2474: cast = build_tree_list (build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2475: get_identifier (UTAG_METHOD_PROTOTYPE_LIST))), NULLT);
2476: variable_length_type = groktypename (cast);
2477:
2478: chain = PROTOCOL_CLS_METHODS (protocol);
2479: if (chain)
2480: {
2481: size = 0;
2482:
2483: initlist = build_descriptor_table_initializer (chain, &size);
2484:
2485: method_list_template
2486: = build_method_prototype_list_template (objc_method_prototype_template,
2487: size);
2488:
2489: UOBJC_CLASS_METHODS_decl
2490: = generate_descriptor_table (method_list_template,
2491: "_OBJC_PROTOCOL_CLASS_METHODS",
2492: size, initlist, protocol);
2493: /* cast! */
2494: TREE_TYPE (UOBJC_CLASS_METHODS_decl) = variable_length_type;
2495: }
2496: else
2497: UOBJC_CLASS_METHODS_decl = 0;
2498:
2499: chain = PROTOCOL_NST_METHODS (protocol);
2500: if (chain)
2501: {
2502: size = 0;
2503: initlist = build_descriptor_table_initializer (chain, &size);
2504:
2505: method_list_template
2506: = build_method_prototype_list_template (objc_method_prototype_template,
2507: size);
2508:
2509: UOBJC_INSTANCE_METHODS_decl
2510: = generate_descriptor_table (method_list_template,
2511: "_OBJC_PROTOCOL_INSTANCE_METHODS",
2512: size, initlist, protocol);
2513: /* cast! */
2514: TREE_TYPE (UOBJC_INSTANCE_METHODS_decl) = variable_length_type;
2515: }
2516: else
2517: UOBJC_INSTANCE_METHODS_decl = 0;
2518: }
2519:
2520: static tree
2521: build_tmp_function_decl ()
2522: {
2523: tree decl_specs, expr_decl, parms;
2524:
2525: /* struct objc_object *objc_xxx (id, SEL, ...); */
2526: pushlevel (0);
2527: decl_specs = build_tree_list (NULLT, objc_object_reference);
2528: push_parm_decl (build_tree_list (decl_specs,
2529: build1 (INDIRECT_REF, NULLT, NULLT)));
2530:
2531: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2532: get_identifier (TAG_SELECTOR)));
2533: expr_decl = build1 (INDIRECT_REF, NULLT, NULLT);
2534:
2535: push_parm_decl (build_tree_list (decl_specs, expr_decl));
2536: parms = get_parm_info (0);
2537: poplevel (0, 0, 0);
2538:
2539: decl_specs = build_tree_list (NULLT, objc_object_reference);
2540: expr_decl = build_nt (CALL_EXPR, get_identifier ("objc_xxx"), parms, NULLT);
2541: expr_decl = build1 (INDIRECT_REF, NULLT, expr_decl);
2542:
2543: return define_decl (expr_decl, decl_specs);
2544: }
2545:
2546: static void
2547: hack_method_prototype (nst_methods, tmp_decl)
2548: tree nst_methods;
2549: tree tmp_decl;
2550: {
2551: tree parms;
2552:
2553: /* Hack to avoid problem with static typing of self arg. */
2554: TREE_SET_CODE (nst_methods, CLASS_METHOD_DECL);
2555: start_method_def (nst_methods);
2556: TREE_SET_CODE (nst_methods, INSTANCE_METHOD_DECL);
2557:
2558: if (METHOD_ADD_ARGS (nst_methods) == (tree) 1)
2559: parms = get_parm_info (0); /* we have a `, ...' */
2560: else
2561: parms = get_parm_info (1); /* place a `void_at_end' */
2562:
2563: poplevel (0, 0, 0); /* Must be called BEFORE start_function. */
2564:
2565: /* Usually called from store_parm_decls -> init_function_start. */
2566:
2567: init_emit (); /* needed to make assign_parms work (with -O). */
2568:
2569: DECL_ARGUMENTS (tmp_decl) = TREE_PURPOSE (parms);
2570:
2571: {
2572: /* Code taken from start_function. */
2573: tree restype = TREE_TYPE (TREE_TYPE (tmp_decl));
2574: /* Promote the value to int before returning it. */
2575: if (TREE_CODE (restype) == INTEGER_TYPE
2576: && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
2577: restype = integer_type_node;
2578: DECL_RESULT (tmp_decl) = build_decl (RESULT_DECL, 0, restype);
2579: }
2580:
2581: /* Typically called from expand_function_start for function definitions. */
2582: assign_parms (tmp_decl, 0);
2583:
2584: /* install return type */
2585: TREE_TYPE (TREE_TYPE (tmp_decl)) = groktypename (TREE_TYPE (nst_methods));
2586: }
2587:
2588: static void
2589: generate_protocol_references (plist)
2590: tree plist;
2591: {
2592: tree lproto;
2593:
2594: /* forward declare protocols referenced */
2595: for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
2596: {
2597: tree proto = TREE_VALUE (lproto);
2598:
2599: if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
2600: && PROTOCOL_NAME (proto))
2601: {
2602: if (! PROTOCOL_FORWARD_DECL (proto))
2603: build_protocol_reference (proto);
2604:
2605: if (PROTOCOL_LIST (proto))
2606: generate_protocol_references (PROTOCOL_LIST (proto));
2607: }
2608: }
2609: }
2610:
2611: static void
2612: generate_protocols ()
2613: {
2614: tree p, tmp_decl, encoding;
2615: tree sc_spec, decl_specs, decl;
2616: tree initlist, protocol_name_expr, refs_decl, refs_expr;
2617: tree cast_type2 = 0;
2618:
2619: tmp_decl = build_tmp_function_decl ();
2620:
2621: if (! objc_protocol_template)
2622: objc_protocol_template = build_protocol_template ();
2623:
2624: /* if a protocol was directly referenced, pull in indirect references */
2625: for (p = protocol_chain; p; p = TREE_CHAIN (p))
2626: if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p))
2627: generate_protocol_references (PROTOCOL_LIST (p));
2628:
2629: for (p = protocol_chain; p; p = TREE_CHAIN (p))
2630: {
2631: tree nst_methods = PROTOCOL_NST_METHODS (p);
2632: tree cls_methods = PROTOCOL_CLS_METHODS (p);
2633:
2634: /* if protocol wasn't referenced, don't generate any code */
2635: if (! PROTOCOL_FORWARD_DECL (p))
2636: continue;
2637:
2638: /* Make sure we link in the Protocol class. */
2639: add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
2640:
2641: while (nst_methods)
2642: {
2643: hack_method_prototype (nst_methods, tmp_decl);
2644: encoding = encode_method_prototype (nst_methods, tmp_decl);
2645: METHOD_ENCODING (nst_methods) = encoding;
2646:
2647: nst_methods = TREE_CHAIN (nst_methods);
2648: }
2649:
2650: while (cls_methods)
2651: {
2652: hack_method_prototype (cls_methods, tmp_decl);
2653: encoding = encode_method_prototype (cls_methods, tmp_decl);
2654: METHOD_ENCODING (cls_methods) = encoding;
2655:
2656: cls_methods = TREE_CHAIN (cls_methods);
2657: }
2658: generate_method_descriptors (p);
2659:
2660: if (PROTOCOL_LIST (p))
2661: refs_decl = generate_protocol_list (p);
2662: else
2663: refs_decl = 0;
2664:
2665: /* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
2666:
2667: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
2668: decl_specs = tree_cons (NULLT, objc_protocol_template, sc_spec);
2669:
2670: decl = start_decl (synth_id_with_class_suffix ("_OBJC_PROTOCOL", p),
2671: decl_specs, 1);
2672: end_temporary_allocation ();
2673:
2674: protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
2675:
2676: if (refs_decl)
2677: {
2678: if (!cast_type2)
2679: cast_type2
2680: = groktypename (build_tree_list (build_tree_list (NULLT, objc_protocol_template),
2681: build1 (INDIRECT_REF, NULLT,
2682: build1 (INDIRECT_REF, NULLT, NULLT))));
2683:
2684: refs_expr = build_unary_op (ADDR_EXPR, refs_decl, 0);
2685: TREE_TYPE (refs_expr) = cast_type2;
2686: }
2687: else
2688: refs_expr = build_int_2 (0, 0);
2689:
2690: /* UOBJC_INSTANCE_METHODS_decl/UOBJC_CLASS_METHODS_decl are set
2691: by generate_method_descriptors, which is called above. */
2692: initlist = build_protocol_initializer (protocol_name_expr, refs_expr,
2693: UOBJC_INSTANCE_METHODS_decl,
2694: UOBJC_CLASS_METHODS_decl);
2695: finish_decl (decl, initlist, NULLT);
2696:
2697: /* Mark the decl as used to avoid "defined but not used" warning. */
2698: TREE_USED (decl) = 1;
2699: }
2700: }
2701:
2702: static tree
2703: build_protocol_initializer (protocol_name, protocol_list,
2704: instance_methods, class_methods)
2705: tree protocol_name;
2706: tree protocol_list;
2707: tree instance_methods;
2708: tree class_methods;
2709: {
2710: tree initlist = NULLT, expr;
2711: static tree cast_type = 0;
2712:
2713: if (!cast_type)
2714: cast_type
2715: = groktypename (build_tree_list
2716: (build_tree_list (NULLT,
2717: xref_tag (RECORD_TYPE,
2718: get_identifier (UTAG_CLASS))),
2719: build1 (INDIRECT_REF, NULLT, NULLT)));
2720:
2721: /* filling the "isa" in with one allows the runtime system to
2722: detect that the version change...should remove before final release */
2723:
2724: expr = build_int_2 (PROTOCOL_VERSION, 0);
2725: TREE_TYPE (expr) = cast_type;
2726: initlist = tree_cons (NULLT, expr, initlist);
2727: initlist = tree_cons (NULLT, protocol_name, initlist);
2728: initlist = tree_cons (NULLT, protocol_list, initlist);
2729:
2730: if (!instance_methods)
2731: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
2732: else
2733: {
2734: expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
2735: initlist = tree_cons (NULLT, expr, initlist);
2736: }
2737: if (!class_methods)
2738: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
2739: else
2740: {
2741: expr = build_unary_op (ADDR_EXPR, class_methods, 0);
2742: initlist = tree_cons (NULLT, expr, initlist);
2743: }
2744: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
2745: }
2746: /* end code generation for protocols... */
2747:
2748: /* struct objc_category {
2749: char *category_name;
2750: char *class_name;
2751: struct objc_method_list *instance_methods;
2752: struct objc_method_list *class_methods;
2753: struct objc_protocol_list *protocols;
2754: }; */
2755:
2756: static void
2757: build_category_template ()
2758: {
2759: tree decl_specs, field_decl, field_decl_chain;
2760:
2761: objc_category_template = start_struct (RECORD_TYPE,
2762: get_identifier (UTAG_CATEGORY));
2763: /* char *category_name; */
2764:
2765: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]);
2766: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("category_name"));
2767: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2768: field_decl_chain = field_decl;
2769:
2770: /* char *class_name; */
2771:
2772: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]);
2773: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("class_name"));
2774: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2775: chainon (field_decl_chain, field_decl);
2776:
2777: /* struct objc_method_list *instance_methods; */
2778:
2779: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2780: get_identifier (UTAG_METHOD_LIST)));
2781: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("instance_methods"));
2782: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2783: chainon (field_decl_chain, field_decl);
2784:
2785: /* struct objc_method_list *class_methods; */
2786:
2787: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2788: get_identifier (UTAG_METHOD_LIST)));
2789: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("class_methods"));
2790: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2791: chainon (field_decl_chain, field_decl);
2792:
2793: /* struct objc_protocol **protocol_list; */
2794:
2795: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2796: get_identifier (UTAG_PROTOCOL)));
2797: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("protocol_list"));
2798: field_decl = build1 (INDIRECT_REF, NULLT, field_decl);
2799: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT)
2800: ;
2801: chainon (field_decl_chain, field_decl);
2802:
2803: finish_struct (objc_category_template, field_decl_chain);
2804: }
2805:
2806: /* struct objc_class {
2807: struct objc_class *isa;
2808: struct objc_class *super_class;
2809: char *name;
2810: long version;
2811: long info;
2812: long instance_size;
2813: struct objc_ivar_list *ivars;
2814: struct objc_method_list *methods;
2815: if (flag_next_runtime)
2816: struct objc_cache *cache;
2817: else {
2818: struct sarray *dtable;
2819: struct objc_class *subclass_list;
2820: struct objc_class *sibling_class;
2821: }
2822: struct objc_protocol_list *protocols;
2823: }; */
2824:
2825: static void
2826: build_class_template ()
2827: {
2828: tree decl_specs, field_decl, field_decl_chain;
2829:
2830: objc_class_template = start_struct (RECORD_TYPE, get_identifier (UTAG_CLASS));
2831:
2832: /* struct objc_class *isa; */
2833:
2834: decl_specs = build_tree_list (NULLT, objc_class_template);
2835: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("isa"));
2836: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2837: field_decl_chain = field_decl;
2838:
2839: /* struct objc_class *super_class; */
2840:
2841: decl_specs = build_tree_list (NULLT, objc_class_template);
2842: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("super_class"));
2843: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2844: chainon (field_decl_chain, field_decl);
2845:
2846: /* char *name; */
2847:
2848: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]);
2849: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("name"));
2850: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2851: chainon (field_decl_chain, field_decl);
2852:
2853: /* long version; */
2854:
2855: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]);
2856: field_decl = get_identifier ("version");
2857: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2858: chainon (field_decl_chain, field_decl);
2859:
2860: /* long info; */
2861:
2862: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]);
2863: field_decl = get_identifier ("info");
2864: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2865: chainon (field_decl_chain, field_decl);
2866:
2867: /* long instance_size; */
2868:
2869: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]);
2870: field_decl = get_identifier ("instance_size");
2871: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2872: chainon (field_decl_chain, field_decl);
2873:
2874: /* struct objc_ivar_list *ivars; */
2875:
2876: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2877: get_identifier (UTAG_IVAR_LIST)));
2878: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("ivars"));
2879: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2880: chainon (field_decl_chain, field_decl);
2881:
2882: /* struct objc_method_list *methods; */
2883:
2884: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2885: get_identifier (UTAG_METHOD_LIST)));
2886: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("methods"));
2887: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2888: chainon (field_decl_chain, field_decl);
2889:
2890: if (flag_next_runtime)
2891: {
2892: /* struct objc_cache *cache; */
2893:
2894: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2895: get_identifier ("objc_cache")));
2896: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("cache"));
2897: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2898: chainon (field_decl_chain, field_decl);
2899: }
2900: else
2901: {
2902: /* struct sarray *dtable; */
2903:
2904: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2905: get_identifier ("sarray")));
2906: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("dtable"));
2907: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2908: chainon (field_decl_chain, field_decl);
2909:
2910: /* struct objc_class *subclass_list; */
2911:
2912: decl_specs = build_tree_list (NULLT, objc_class_template);
2913: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("subclass_list"));
2914: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2915: chainon (field_decl_chain, field_decl);
2916:
2917: /* struct objc_class *sibling_class; */
2918:
2919: decl_specs = build_tree_list (NULLT, objc_class_template);
2920: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("sibling_class"));
2921: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2922: chainon (field_decl_chain, field_decl);
2923: }
2924:
2925: /* struct objc_protocol **protocol_list; */
2926:
2927: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE,
2928: get_identifier (UTAG_PROTOCOL)));
2929: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("protocol_list"));
2930: field_decl = build1 (INDIRECT_REF, NULLT, field_decl);
2931: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
2932: chainon (field_decl_chain, field_decl);
2933:
2934:
2935: finish_struct (objc_class_template, field_decl_chain);
2936: }
2937:
2938: /* Generate appropriate forward declarations for an implementation. */
2939:
2940: static void
2941: synth_forward_declarations ()
2942: {
2943: tree sc_spec, decl_specs, an_id;
2944:
2945: /* extern struct objc_class _OBJC_CLASS_<my_name>; */
2946:
2947: an_id = synth_id_with_class_suffix ("_OBJC_CLASS", implementation_context);
2948:
2949: sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_EXTERN]);
2950: decl_specs = tree_cons (NULLT, objc_class_template, sc_spec);
2951: UOBJC_CLASS_decl = define_decl (an_id, decl_specs);
2952: TREE_USED (UOBJC_CLASS_decl) = 1;
2953:
2954: /* extern struct objc_class _OBJC_METACLASS_<my_name>; */
2955:
2956: an_id = synth_id_with_class_suffix ("_OBJC_METACLASS",
2957: implementation_context);
2958:
2959: UOBJC_METACLASS_decl = define_decl (an_id, decl_specs);
2960: TREE_USED (UOBJC_METACLASS_decl) = 1;
2961:
2962: /* pre-build the following entities - for speed/convenience. */
2963:
2964: an_id = get_identifier ("super_class");
2965: ucls_super_ref = build_component_ref (UOBJC_CLASS_decl, an_id);
2966: uucls_super_ref = build_component_ref (UOBJC_METACLASS_decl, an_id);
2967: }
2968:
2969: static void
2970: error_with_ivar (message, decl, rawdecl)
2971: char *message;
2972: tree decl;
2973: tree rawdecl;
2974: {
2975: count_error (0);
2976:
2977: report_error_function (DECL_SOURCE_FILE (decl));
2978:
2979: fprintf (stderr, "%s:%d: ",
2980: DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
2981: bzero (errbuf, BUFSIZE);
2982: fprintf (stderr, "%s `%s'\n", message, gen_declaration (rawdecl, errbuf));
2983: }
2984:
2985: #define USERTYPE(t) (TREE_CODE (t) == RECORD_TYPE || \
2986: TREE_CODE (t) == UNION_TYPE || \
2987: TREE_CODE (t) == ENUMERAL_TYPE)
2988:
2989: static void
2990: check_ivars (inter, imp)
2991: tree inter;
2992: tree imp;
2993: {
2994: tree intdecls = CLASS_IVARS (inter);
2995: tree impdecls = CLASS_IVARS (imp);
2996: tree rawintdecls = CLASS_RAW_IVARS (inter);
2997: tree rawimpdecls = CLASS_RAW_IVARS (imp);
2998:
2999: while (1)
3000: {
3001: tree t1, t2;
3002:
3003: if (intdecls == 0 && impdecls == 0)
3004: break;
3005: if (intdecls == 0 || impdecls == 0)
3006: {
3007: error ("inconsistent instance variable specification");
3008: break;
3009: }
3010: t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
3011:
3012: if (!comptypes (t1, t2))
3013: {
3014: if (DECL_NAME (intdecls) == DECL_NAME (impdecls))
3015: {
3016: error_with_ivar ("conflicting instance variable type",
3017: impdecls, rawimpdecls);
3018: error_with_ivar ("previous declaration of",
3019: intdecls, rawintdecls);
3020: }
3021: else /* both the type and the name don't match */
3022: {
3023: error ("inconsistent instance variable specification");
3024: break;
3025: }
3026: }
3027: else if (DECL_NAME (intdecls) != DECL_NAME (impdecls))
3028: {
3029: error_with_ivar ("conflicting instance variable name",
3030: impdecls, rawimpdecls);
3031: error_with_ivar ("previous declaration of",
3032: intdecls, rawintdecls);
3033: }
3034: intdecls = TREE_CHAIN (intdecls);
3035: impdecls = TREE_CHAIN (impdecls);
3036: rawintdecls = TREE_CHAIN (rawintdecls);
3037: rawimpdecls = TREE_CHAIN (rawimpdecls);
3038: }
3039: }
3040:
3041: /* Set super_type to the data type node for struct objc_super *,
3042: first defining struct objc_super itself.
3043: This needs to be done just once per compilation. */
3044:
3045: static tree
3046: build_super_template ()
3047: {
3048: tree record, decl_specs, field_decl, field_decl_chain;
3049:
3050: record = start_struct (RECORD_TYPE, get_identifier (UTAG_SUPER));
3051:
3052: /* struct objc_object *self; */
3053:
3054: decl_specs = build_tree_list (NULLT, objc_object_reference);
3055: field_decl = get_identifier ("self");
3056: field_decl = build1 (INDIRECT_REF, NULLT, field_decl);
3057: field_decl = grokfield (input_filename, lineno,
3058: field_decl, decl_specs, NULLT);
3059: field_decl_chain = field_decl;
3060:
3061: /* struct objc_class *class; */
3062:
3063: decl_specs = get_identifier (UTAG_CLASS);
3064: decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, decl_specs));
3065: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("class"));
3066:
3067: field_decl = grokfield (input_filename, lineno,
3068: field_decl, decl_specs, NULLT);
3069: chainon (field_decl_chain, field_decl);
3070:
3071: finish_struct (record, field_decl_chain);
3072:
3073: /* `struct objc_super *' */
3074: super_type = groktypename (build_tree_list (build_tree_list (NULLT, record),
3075: build1 (INDIRECT_REF,
3076: NULLT, NULLT)));
3077: return record;
3078: }
3079:
3080: /* struct objc_ivar {
3081: char *ivar_name;
3082: char *ivar_type;
3083: int ivar_offset;
3084: }; */
3085:
3086: static tree
3087: build_ivar_template ()
3088: {
3089: tree objc_ivar_id, objc_ivar_record;
3090: tree decl_specs, field_decl, field_decl_chain;
3091:
3092: objc_ivar_id = get_identifier (UTAG_IVAR);
3093: objc_ivar_record = start_struct (RECORD_TYPE, objc_ivar_id);
3094:
3095: /* char *ivar_name; */
3096:
3097: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]);
3098: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("ivar_name"));
3099:
3100: field_decl = grokfield (input_filename, lineno, field_decl,
3101: decl_specs, NULLT);
3102: field_decl_chain = field_decl;
3103:
3104: /* char *ivar_type; */
3105:
3106: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]);
3107: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("ivar_type"));
3108:
3109: field_decl = grokfield (input_filename, lineno, field_decl,
3110: decl_specs, NULLT);
3111: chainon (field_decl_chain, field_decl);
3112:
3113: /* int ivar_offset; */
3114:
3115: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_INT]);
3116: field_decl = get_identifier ("ivar_offset");
3117:
3118: field_decl = grokfield (input_filename, lineno, field_decl,
3119: decl_specs, NULLT);
3120: chainon (field_decl_chain, field_decl);
3121:
3122: finish_struct (objc_ivar_record, field_decl_chain);
3123:
3124: return objc_ivar_record;
3125: }
3126:
3127: /* struct {
3128: int ivar_count;
3129: struct objc_ivar ivar_list[ivar_count];
3130: }; */
3131:
3132: static tree
3133: build_ivar_list_template (list_type, size)
3134: tree list_type;
3135: int size;
3136: {
3137: tree objc_ivar_list_record;
3138: tree decl_specs, field_decl, field_decl_chain;
3139:
3140: objc_ivar_list_record = start_struct (RECORD_TYPE, NULLT);
3141:
3142: /* int ivar_count; */
3143:
3144: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_INT]);
3145: field_decl = get_identifier ("ivar_count");
3146:
3147: field_decl = grokfield (input_filename, lineno, field_decl,
3148: decl_specs, NULLT);
3149: field_decl_chain = field_decl;
3150:
3151: /* struct objc_ivar ivar_list[]; */
3152:
3153: decl_specs = build_tree_list (NULLT, list_type);
3154: field_decl = build_nt (ARRAY_REF, get_identifier ("ivar_list"),
3155: build_int_2 (size, 0));
3156:
3157: field_decl = grokfield (input_filename, lineno,
3158: field_decl, decl_specs, NULLT);
3159: chainon (field_decl_chain, field_decl);
3160:
3161: finish_struct (objc_ivar_list_record, field_decl_chain);
3162:
3163: return objc_ivar_list_record;
3164: }
3165:
3166: /* struct {
3167: int method_next;
3168: int method_count;
3169: struct objc_method method_list[method_count];
3170: }; */
3171:
3172: static tree
3173: build_method_list_template (list_type, size)
3174: tree list_type;
3175: int size;
3176: {
3177: tree objc_ivar_list_record;
3178: tree decl_specs, field_decl, field_decl_chain;
3179:
3180: objc_ivar_list_record = start_struct (RECORD_TYPE, NULLT);
3181:
3182: /* int method_next; */
3183:
3184: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_INT]);
3185: field_decl = get_identifier ("method_next");
3186:
3187: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
3188: field_decl_chain = field_decl;
3189:
3190: /* int method_count; */
3191:
3192: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_INT]);
3193: field_decl = get_identifier ("method_count");
3194:
3195: field_decl = grokfield (input_filename, lineno,
3196: field_decl, decl_specs, NULLT);
3197: chainon (field_decl_chain, field_decl);
3198:
3199: /* struct objc_method method_list[]; */
3200:
3201: decl_specs = build_tree_list (NULLT, list_type);
3202: field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
3203: build_int_2 (size, 0));
3204:
3205: field_decl = grokfield (input_filename, lineno,
3206: field_decl, decl_specs, NULLT);
3207: chainon (field_decl_chain, field_decl);
3208:
3209: finish_struct (objc_ivar_list_record, field_decl_chain);
3210:
3211: return objc_ivar_list_record;
3212: }
3213:
3214: static tree
3215: build_ivar_list_initializer (field_decl, size)
3216: tree field_decl;
3217: int *size;
3218: {
3219: tree initlist = NULLT;
3220:
3221: do
3222: {
3223: /* set name */
3224: if (DECL_NAME (field_decl))
3225: initlist = tree_cons (NULLT,
3226: add_objc_string (DECL_NAME (field_decl),
3227: meth_var_names),
3228: initlist);
3229: else
3230: /* unnamed bit-field ivar (yuck). */
3231: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3232:
3233: /* set type */
3234: encode_field_decl (field_decl,
3235: obstack_object_size (&util_obstack),
3236: OBJC_ENCODE_DONT_INLINE_DEFS);
3237: obstack_1grow (&util_obstack, 0); /* null terminate string */
3238: initlist
3239: = tree_cons
3240: (NULLT,
3241: add_objc_string (get_identifier (obstack_finish (&util_obstack)),
3242: meth_var_types),
3243: initlist);
3244: obstack_free (&util_obstack, util_firstobj);
3245:
3246: /* set offset */
3247: initlist
3248: = tree_cons
3249: (NULLT,
3250: build_int_2 ((TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field_decl))
3251: / BITS_PER_UNIT),
3252: 0),
3253: initlist);
3254: (*size)++;
3255: field_decl = TREE_CHAIN (field_decl);
3256: }
3257: while (field_decl);
3258:
3259: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
3260: }
3261:
3262: static tree
3263: generate_ivars_list (type, name, size, list)
3264: tree type;
3265: char *name;
3266: int size;
3267: tree list;
3268: {
3269: tree sc_spec, decl_specs, decl, initlist;
3270:
3271: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
3272: decl_specs = tree_cons (NULLT, type, sc_spec);
3273:
3274: decl = start_decl (synth_id_with_class_suffix (name, implementation_context),
3275: decl_specs, 1);
3276: end_temporary_allocation ();
3277:
3278: initlist = build_tree_list (NULLT, build_int_2 (size, 0));
3279: initlist = tree_cons (NULLT, list, initlist);
3280:
3281: finish_decl (decl, build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)), NULLT);
3282:
3283: return decl;
3284: }
3285:
3286: static void
3287: generate_ivar_lists ()
3288: {
3289: tree initlist, ivar_list_template, chain;
3290: tree cast, variable_length_type;
3291: int size;
3292:
3293: generating_instance_variables = 1;
3294:
3295: if (!objc_ivar_template)
3296: objc_ivar_template = build_ivar_template ();
3297:
3298: cast
3299: = build_tree_list
3300: (build_tree_list (NULLT, xref_tag (RECORD_TYPE,
3301: get_identifier (UTAG_IVAR_LIST))),
3302: NULLT);
3303: variable_length_type = groktypename (cast);
3304:
3305: /* only generate class variables for the root of the inheritance
3306: hierarchy since these will be the same for every class */
3307:
3308: if (CLASS_SUPER_NAME (implementation_template) == NULLT
3309: && (chain = TYPE_FIELDS (objc_class_template)))
3310: {
3311: size = 0;
3312: initlist = build_ivar_list_initializer (chain, &size);
3313:
3314: ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
3315:
3316: UOBJC_CLASS_VARIABLES_decl =
3317: generate_ivars_list (ivar_list_template, "_OBJC_CLASS_VARIABLES",
3318: size, initlist);
3319: /* cast! */
3320: TREE_TYPE (UOBJC_CLASS_VARIABLES_decl) = variable_length_type;
3321: }
3322: else
3323: UOBJC_CLASS_VARIABLES_decl = 0;
3324:
3325: chain = CLASS_IVARS (implementation_template);
3326: if (chain)
3327: {
3328: size = 0;
3329: initlist = build_ivar_list_initializer (chain, &size);
3330:
3331: ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
3332:
3333: UOBJC_INSTANCE_VARIABLES_decl =
3334: generate_ivars_list (ivar_list_template, "_OBJC_INSTANCE_VARIABLES",
3335: size, initlist);
3336: /* cast! */
3337: TREE_TYPE (UOBJC_INSTANCE_VARIABLES_decl) = variable_length_type;
3338: }
3339: else
3340: UOBJC_INSTANCE_VARIABLES_decl = 0;
3341:
3342: generating_instance_variables = 0;
3343: }
3344:
3345: static tree
3346: build_dispatch_table_initializer (entries, size)
3347: tree entries;
3348: int *size;
3349: {
3350: tree initlist = NULLT;
3351:
3352: do
3353: {
3354: initlist = tree_cons (NULLT, build_selector (METHOD_SEL_NAME (entries)),
3355: initlist);
3356:
3357: initlist = tree_cons (NULLT, add_objc_string (METHOD_ENCODING (entries),
3358: meth_var_types),
3359: initlist);
3360:
3361: initlist = tree_cons (NULLT, METHOD_DEFINITION (entries), initlist);
3362:
3363: (*size)++;
3364: entries = TREE_CHAIN (entries);
3365: }
3366: while (entries);
3367:
3368: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
3369: }
3370:
3371: /* To accomplish method prototyping without generating all kinds of
3372: inane warnings, the definition of the dispatch table entries were
3373: changed from:
3374:
3375: struct objc_method { SEL _cmd; id (*_imp)(); };
3376: to:
3377: struct objc_method { SEL _cmd; void *_imp; }; */
3378:
3379: static tree
3380: build_method_template ()
3381: {
3382: tree _SLT_record;
3383: tree decl_specs, field_decl, field_decl_chain;
3384:
3385: _SLT_record = start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD));
3386:
3387: #ifdef OBJC_INT_SELECTORS
3388: /* unsigned int _cmd; */
3389: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_UNSIGNED], NULLT);
3390: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs);
3391: field_decl = get_identifier ("_cmd");
3392: #else /* not OBJC_INT_SELECTORS */
3393: /* struct objc_selector *_cmd; */
3394: decl_specs = tree_cons (NULLT,
3395: xref_tag (RECORD_TYPE,
3396: get_identifier (TAG_SELECTOR)),
3397: NULLT);
3398: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("_cmd"));
3399: #endif /* not OBJC_INT_SELECTORS */
3400:
3401: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
3402: field_decl_chain = field_decl;
3403:
3404: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_CHAR], NULLT);
3405: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("method_types"));
3406: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
3407: chainon (field_decl_chain, field_decl);
3408:
3409: /* void *_imp; */
3410:
3411: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_VOID], NULLT);
3412: field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("_imp"));
3413: field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
3414: chainon (field_decl_chain, field_decl);
3415:
3416: finish_struct (_SLT_record, field_decl_chain);
3417:
3418: return _SLT_record;
3419: }
3420:
3421:
3422: static tree
3423: generate_dispatch_table (type, name, size, list)
3424: tree type;
3425: char *name;
3426: int size;
3427: tree list;
3428: {
3429: tree sc_spec, decl_specs, decl, initlist;
3430:
3431: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
3432: decl_specs = tree_cons (NULLT, type, sc_spec);
3433:
3434: decl = start_decl (synth_id_with_class_suffix (name, implementation_context),
3435: decl_specs, 1);
3436: end_temporary_allocation ();
3437:
3438: initlist = build_tree_list (NULLT, build_int_2 (0, 0));
3439: initlist = tree_cons (NULLT, build_int_2 (size, 0), initlist);
3440: initlist = tree_cons (NULLT, list, initlist);
3441:
3442: finish_decl (decl, build_nt (CONSTRUCTOR, NULLT, nreverse (initlist)), NULLT);
3443:
3444: return decl;
3445: }
3446:
3447: static void
3448: generate_dispatch_tables ()
3449: {
3450: tree initlist, chain, method_list_template;
3451: tree cast, variable_length_type;
3452: int size;
3453:
3454: if (!objc_method_template)
3455: objc_method_template = build_method_template ();
3456:
3457: cast
3458: = build_tree_list
3459: (build_tree_list (NULLT, xref_tag (RECORD_TYPE,
3460: get_identifier (UTAG_METHOD_LIST))),
3461: NULLT);
3462: variable_length_type = groktypename (cast);
3463:
3464: chain = CLASS_CLS_METHODS (implementation_context);
3465: if (chain)
3466: {
3467: size = 0;
3468: initlist = build_dispatch_table_initializer (chain, &size);
3469:
3470: method_list_template = build_method_list_template (objc_method_template,
3471: size);
3472:
3473: UOBJC_CLASS_METHODS_decl
3474: = generate_dispatch_table (method_list_template,
3475: ((TREE_CODE (implementation_context)
3476: == CLASS_IMPLEMENTATION_TYPE)
3477: ? "_OBJC_CLASS_METHODS"
3478: : "_OBJC_CATEGORY_CLASS_METHODS"),
3479: size, initlist);
3480: /* cast! */
3481: TREE_TYPE (UOBJC_CLASS_METHODS_decl) = variable_length_type;
3482: }
3483: else
3484: UOBJC_CLASS_METHODS_decl = 0;
3485:
3486: chain = CLASS_NST_METHODS (implementation_context);
3487: if (chain)
3488: {
3489: size = 0;
3490: initlist = build_dispatch_table_initializer (chain, &size);
3491:
3492: method_list_template = build_method_list_template (objc_method_template,
3493: size);
3494: if (TREE_CODE (implementation_context) == CLASS_IMPLEMENTATION_TYPE)
3495: UOBJC_INSTANCE_METHODS_decl =
3496: generate_dispatch_table (method_list_template,
3497: "_OBJC_INSTANCE_METHODS",
3498: size, initlist);
3499: else
3500: /* we have a category */
3501: UOBJC_INSTANCE_METHODS_decl =
3502: generate_dispatch_table (method_list_template,
3503: "_OBJC_CATEGORY_INSTANCE_METHODS",
3504: size, initlist);
3505: /* cast! */
3506: TREE_TYPE (UOBJC_INSTANCE_METHODS_decl) = variable_length_type;
3507: }
3508: else
3509: UOBJC_INSTANCE_METHODS_decl = 0;
3510: }
3511:
3512: static tree
3513: generate_protocol_list (i_or_p)
3514: tree i_or_p;
3515: {
3516: static tree cast_type = 0;
3517: tree initlist, decl_specs, sc_spec;
3518: tree refs_decl, expr_decl, lproto, e, plist;
3519: int size = 0;
3520:
3521: if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE
3522: || TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
3523: plist = CLASS_PROTOCOL_LIST (i_or_p);
3524: else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
3525: plist = PROTOCOL_LIST (i_or_p);
3526: else
3527: abort ();
3528:
3529: if (!cast_type)
3530: cast_type
3531: = groktypename
3532: (build_tree_list
3533: (build_tree_list (NULLT,
3534: xref_tag (RECORD_TYPE,
3535: get_identifier (UTAG_PROTOCOL))),
3536: build1 (INDIRECT_REF, NULLT, NULLT)));
3537:
3538: /* compute size */
3539: for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
3540: if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
3541: && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto)))
3542: size++;
3543:
3544: /* build initializer */
3545: initlist = tree_cons (NULLT, build_int_2 (0, 0), NULLT);
3546:
3547: e = build_int_2 (size, 0);
3548: TREE_TYPE (e) = cast_type;
3549: initlist = tree_cons (NULLT, e, initlist);
3550:
3551: for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
3552: {
3553: tree pval = TREE_VALUE (lproto);
3554:
3555: if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
3556: && PROTOCOL_FORWARD_DECL (pval))
3557: {
3558: e = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (pval), 0);
3559: initlist = tree_cons (NULLT, e, initlist);
3560: }
3561: }
3562:
3563: /* static struct objc_protocol *refs[n]; */
3564:
3565: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
3566: decl_specs = tree_cons (NULLT, xref_tag (RECORD_TYPE,
3567: get_identifier (UTAG_PROTOCOL)),
3568: sc_spec);
3569:
3570: if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
3571: expr_decl = build_nt (ARRAY_REF,
3572: synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS",
3573: i_or_p),
3574: build_int_2 (size + 2, 0));
3575: else if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE)
3576: expr_decl = build_nt (ARRAY_REF,
3577: synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS",
3578: i_or_p),
3579: build_int_2 (size + 2, 0));
3580: else if (TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
3581: expr_decl = build_nt (ARRAY_REF,
3582: synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS",
3583: i_or_p),
3584: build_int_2 (size + 2, 0));
3585:
3586: expr_decl = build1 (INDIRECT_REF, NULLT, expr_decl);
3587:
3588: refs_decl = start_decl (expr_decl, decl_specs, 1);
3589: end_temporary_allocation ();
3590:
3591: finish_decl (refs_decl, build_nt (CONSTRUCTOR, NULLT,
3592: nreverse (initlist)), NULLT);
3593:
3594: return refs_decl;
3595: }
3596:
3597: static tree
3598: build_category_initializer (cat_name, class_name,
3599: instance_methods, class_methods, protocol_list)
3600: tree cat_name;
3601: tree class_name;
3602: tree instance_methods;
3603: tree class_methods;
3604: tree protocol_list;
3605: {
3606: tree initlist = NULLT, expr;
3607:
3608: initlist = tree_cons (NULLT, cat_name, initlist);
3609: initlist = tree_cons (NULLT, class_name, initlist);
3610:
3611: if (!instance_methods)
3612: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3613: else
3614: {
3615: expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
3616: initlist = tree_cons (NULLT, expr, initlist);
3617: }
3618: if (!class_methods)
3619: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3620: else
3621: {
3622: expr = build_unary_op (ADDR_EXPR, class_methods, 0);
3623: initlist = tree_cons (NULLT, expr, initlist);
3624: }
3625:
3626: /* protocol_list = */
3627: if (!protocol_list)
3628: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3629: else
3630: {
3631: static tree cast_type2;
3632:
3633: if (!cast_type2)
3634: cast_type2
3635: = groktypename
3636: (build_tree_list
3637: (build_tree_list (NULLT,
3638: xref_tag (RECORD_TYPE,
3639: get_identifier (UTAG_PROTOCOL))),
3640: build1 (INDIRECT_REF, NULLT,
3641: build1 (INDIRECT_REF, NULLT, NULLT))));
3642:
3643: expr = build_unary_op (ADDR_EXPR, protocol_list, 0);
3644: TREE_TYPE (expr) = cast_type2;
3645: initlist = tree_cons (NULLT, expr, initlist);
3646: }
3647:
3648: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
3649: }
3650:
3651: /* struct objc_class {
3652: struct objc_class *isa;
3653: struct objc_class *super_class;
3654: char *name;
3655: long version;
3656: long info;
3657: long instance_size;
3658: struct objc_ivar_list *ivars;
3659: struct objc_method_list *methods;
3660: if (flag_next_runtime)
3661: struct objc_cache *cache;
3662: else {
3663: struct sarray *dtable;
3664: struct objc_class *subclass_list;
3665: struct objc_class *sibling_class;
3666: }
3667: struct objc_protocol_list *protocols;
3668: }; */
3669:
3670: static tree
3671: build_shared_structure_initializer (isa, super, name, size, status,
3672: dispatch_table, ivar_list, protocol_list)
3673: tree isa;
3674: tree super;
3675: tree name;
3676: tree size;
3677: int status;
3678: tree dispatch_table;
3679: tree ivar_list;
3680: tree protocol_list;
3681: {
3682: tree initlist = NULLT, expr;
3683:
3684: /* isa = */
3685: initlist = tree_cons (NULLT, isa, initlist);
3686:
3687: /* super_class = */
3688: initlist = tree_cons (NULLT, super, initlist);
3689:
3690: /* name = */
3691: initlist = tree_cons (NULLT, name, initlist);
3692:
3693: /* version = */
3694: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3695:
3696: /* info = */
3697: initlist = tree_cons (NULLT, build_int_2 (status, 0), initlist);
3698:
3699: /* instance_size = */
3700: initlist = tree_cons (NULLT, size, initlist);
3701:
3702: /* objc_ivar_list = */
3703: if (!ivar_list)
3704: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3705: else
3706: {
3707: expr = build_unary_op (ADDR_EXPR, ivar_list, 0);
3708: initlist = tree_cons (NULLT, expr, initlist);
3709: }
3710:
3711: /* objc_method_list = */
3712: if (!dispatch_table)
3713: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3714: else
3715: {
3716: expr = build_unary_op (ADDR_EXPR, dispatch_table, 0);
3717: initlist = tree_cons (NULLT, expr, initlist);
3718: }
3719:
3720: if (flag_next_runtime)
3721: /* method_cache = */
3722: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3723: else
3724: {
3725: /* dtable = */
3726: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3727:
3728: /* subclass_list = */
3729: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3730:
3731: /* sibling_class = */
3732: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3733: }
3734:
3735: /* protocol_list = */
3736: if (! protocol_list)
3737: initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
3738: else
3739: {
3740: static tree cast_type2;
3741:
3742: if (!cast_type2)
3743: cast_type2
3744: = groktypename
3745: (build_tree_list
3746: (build_tree_list (NULLT,
3747: xref_tag (RECORD_TYPE,
3748: get_identifier (UTAG_PROTOCOL))),
3749: build1 (INDIRECT_REF, NULLT,
3750: build1 (INDIRECT_REF, NULLT, NULLT))));
3751:
3752: expr = build_unary_op (ADDR_EXPR, protocol_list, 0);
3753: TREE_TYPE (expr) = cast_type2;
3754: initlist = tree_cons (NULLT, expr, initlist);
3755: }
3756:
3757: return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
3758: }
3759:
3760: /* static struct objc_category _OBJC_CATEGORY_<name> = { ... }; */
3761: static void
3762: generate_category (cat)
3763: tree cat;
3764: {
3765: tree sc_spec, decl_specs, decl;
3766: tree initlist, cat_name_expr, class_name_expr;
3767: tree protocol_decl, category;
3768:
3769: add_class_reference (CLASS_NAME (cat));
3770: cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
3771:
3772: class_name_expr = add_objc_string (CLASS_NAME (cat), class_names);
3773:
3774: category = CLASS_CATEGORY_LIST (implementation_template);
3775:
3776: /* find the category interface from the class it is associated with */
3777: while (category)
3778: {
3779: if (CLASS_SUPER_NAME (cat) == CLASS_SUPER_NAME (category))
3780: break;
3781: category = CLASS_CATEGORY_LIST (category);
3782: }
3783:
3784: if (category && CLASS_PROTOCOL_LIST (category))
3785: {
3786: generate_protocol_references (CLASS_PROTOCOL_LIST (category));
3787: protocol_decl = generate_protocol_list (category);
3788: }
3789: else
3790: protocol_decl = 0;
3791:
3792: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
3793: decl_specs = tree_cons (NULLT, objc_category_template, sc_spec);
3794:
3795: decl = start_decl (synth_id_with_class_suffix ("_OBJC_CATEGORY",
3796: implementation_context),
3797: decl_specs, 1);
3798: end_temporary_allocation ();
3799:
3800: initlist = build_category_initializer (cat_name_expr, class_name_expr,
3801: UOBJC_INSTANCE_METHODS_decl,
3802: UOBJC_CLASS_METHODS_decl,
3803: protocol_decl);
3804:
3805: TREE_USED (decl) = 1;
3806: finish_decl (decl, initlist, NULLT);
3807: }
3808:
3809: /* static struct objc_class _OBJC_METACLASS_Foo={ ... };
3810: static struct objc_class _OBJC_CLASS_Foo={ ... }; */
3811:
3812: static void
3813: generate_shared_structures ()
3814: {
3815: tree sc_spec, decl_specs, decl;
3816: tree name_expr, super_expr, root_expr;
3817: tree my_root_id = NULLT, my_super_id = NULLT;
3818: tree cast_type, initlist, protocol_decl;
3819:
3820: my_super_id = CLASS_SUPER_NAME (implementation_template);
3821: if (my_super_id)
3822: {
3823: add_class_reference (my_super_id);
3824:
3825: /* Compute "my_root_id" - this is required for code generation.
3826: the "isa" for all meta class structures points to the root of
3827: the inheritance hierarchy (e.g. "__Object")... */
3828: my_root_id = my_super_id;
3829: do
3830: {
3831: tree my_root_int = lookup_interface (my_root_id);
3832:
3833: if (my_root_int && CLASS_SUPER_NAME (my_root_int))
3834: my_root_id = CLASS_SUPER_NAME (my_root_int);
3835: else
3836: break;
3837: }
3838: while (1);
3839: }
3840: else /* no super class */
3841: {
3842: my_root_id = CLASS_NAME (implementation_template);
3843: }
3844:
3845: cast_type
3846: = groktypename (build_tree_list (build_tree_list (NULLT,
3847: objc_class_template),
3848: build1 (INDIRECT_REF, NULLT, NULLT)));
3849:
3850: name_expr = add_objc_string (CLASS_NAME (implementation_template),
3851: class_names);
3852:
3853: /* install class `isa' and `super' pointers at runtime */
3854: if (my_super_id)
3855: {
3856: super_expr = add_objc_string (my_super_id, class_names);
3857: super_expr = build_c_cast (cast_type, super_expr); /* cast! */
3858: }
3859: else
3860: super_expr = build_int_2 (0, 0);
3861:
3862: root_expr = add_objc_string (my_root_id, class_names);
3863: root_expr = build_c_cast (cast_type, root_expr); /* cast! */
3864:
3865: if (CLASS_PROTOCOL_LIST (implementation_template))
3866: {
3867: generate_protocol_references (CLASS_PROTOCOL_LIST (implementation_template));
3868: protocol_decl = generate_protocol_list (implementation_template);
3869: }
3870: else
3871: protocol_decl = 0;
3872:
3873: /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */
3874:
3875: sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_STATIC]);
3876: decl_specs = tree_cons (NULLT, objc_class_template, sc_spec);
3877:
3878: decl = start_decl (DECL_NAME (UOBJC_METACLASS_decl), decl_specs, 1);
3879: end_temporary_allocation ();
3880:
3881: initlist
3882: = build_shared_structure_initializer
3883: (root_expr, super_expr, name_expr,
3884: build_int_2 ((TREE_INT_CST_LOW (TYPE_SIZE (objc_class_template))
3885: / BITS_PER_UNIT),
3886: 0),
3887: 2 /*CLS_META*/,
3888: UOBJC_CLASS_METHODS_decl,
3889: UOBJC_CLASS_VARIABLES_decl,
3890: protocol_decl);
3891:
3892: finish_decl (decl, initlist, NULLT);
3893:
3894: /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */
3895:
3896: decl = start_decl (DECL_NAME (UOBJC_CLASS_decl), decl_specs, 1);
3897: end_temporary_allocation ();
3898:
3899: initlist
3900: = build_shared_structure_initializer
3901: (build_unary_op (ADDR_EXPR, UOBJC_METACLASS_decl, 0),
3902: super_expr, name_expr,
3903: build_int_2 ((TREE_INT_CST_LOW (TYPE_SIZE (CLASS_STATIC_TEMPLATE (implementation_template)))
3904: / BITS_PER_UNIT),
3905: 0),
3906: 1 /*CLS_FACTORY*/,
3907: UOBJC_INSTANCE_METHODS_decl,
3908: UOBJC_INSTANCE_VARIABLES_decl,
3909: protocol_decl);
3910:
3911: finish_decl (decl, initlist, NULLT);
3912: }
3913:
3914: static tree
3915: synth_id_with_class_suffix (preamble, ctxt)
3916: char *preamble;
3917: tree ctxt;
3918: {
3919: char *string;
3920: if (TREE_CODE (ctxt) == CLASS_IMPLEMENTATION_TYPE
3921: || TREE_CODE (ctxt) == CLASS_INTERFACE_TYPE)
3922: {
3923: char *class_name
3924: = IDENTIFIER_POINTER (CLASS_NAME (implementation_context));
3925: string = (char *) alloca (strlen (preamble) + strlen (class_name) + 3);
3926: sprintf (string, "%s_%s", preamble,
3927: IDENTIFIER_POINTER (CLASS_NAME (ctxt)));
3928: }
3929: else if (TREE_CODE (ctxt) == CATEGORY_IMPLEMENTATION_TYPE
3930: || TREE_CODE (ctxt) == CATEGORY_INTERFACE_TYPE)
3931: {
3932: /* we have a category */
3933: char *class_name
3934: = IDENTIFIER_POINTER (CLASS_NAME (implementation_context));
3935: char *class_super_name
3936: = IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context));
3937: string = (char *) alloca (strlen (preamble)
3938: + strlen (class_name)
3939: + strlen (class_super_name)
3940: + 3);
3941: sprintf (string, "%s_%s_%s", preamble, class_name, class_super_name);
3942: }
3943: else if (TREE_CODE (ctxt) == PROTOCOL_INTERFACE_TYPE)
3944: {
3945: char *protocol_name = IDENTIFIER_POINTER (PROTOCOL_NAME (ctxt));
3946: string = (char *) alloca (strlen (preamble) + strlen (protocol_name) + 3);
3947: sprintf (string, "%s_%s", preamble, protocol_name);
3948: }
3949: return get_identifier (string);
3950: }
3951:
3952: static int
3953: is_objc_type_qualifier (node)
3954: tree node;
3955: {
3956: return (TREE_CODE (node) == IDENTIFIER_NODE
3957: && (node == ridpointers [(int) RID_CONST]
3958: || node == ridpointers [(int) RID_VOLATILE]
3959: || node == ridpointers [(int) RID_IN]
3960: || node == ridpointers [(int) RID_OUT]
3961: || node == ridpointers [(int) RID_INOUT]
3962: || node == ridpointers [(int) RID_BYCOPY]
3963: || node == ridpointers [(int) RID_ONEWAY]));
3964: }
3965:
3966: /* If type is empty or only type qualifiers are present, add default
3967: type of id (otherwise grokdeclarator will default to int). */
3968:
3969: static tree
3970: adjust_type_for_id_default (type)
3971: tree type;
3972: {
3973: tree declspecs, chain;
3974:
3975: if (!type)
3976: return build_tree_list (build_tree_list (NULLT, objc_object_reference),
3977: build1 (INDIRECT_REF, NULLT, NULLT));
3978:
3979: declspecs = TREE_PURPOSE (type);
3980:
3981: /* Determine if a typespec is present. */
3982: for (chain = declspecs;
3983: chain;
3984: chain = TREE_CHAIN (chain))
3985: {
3986: if (!is_objc_type_qualifier (TREE_VALUE (chain)))
3987: return type;
3988: }
3989:
3990: return build_tree_list (tree_cons (NULLT, objc_object_reference, declspecs),
3991: build1 (INDIRECT_REF, NULLT, NULLT));
3992: }
3993:
3994: /* usage:
3995: keyworddecl:
3996: selector ':' '(' typename ')' identifier
3997:
3998: purpose:
3999: transform an Objective-C keyword argument into
4000: the C equivalent parameter declarator.
4001:
4002: in: key_name, an "identifier_node" (optional).
4003: arg_type, a "tree_list" (optional).
4004: arg_name, an "identifier_node".
4005:
4006: note: it would be really nice to strongly type the preceding
4007: arguments in the function prototype; however, then i
4008: could not use the "accessor" macros defined in "tree.h".
4009:
4010: out: an instance of "keyword_decl". */
4011:
4012: tree
4013: build_keyword_decl (key_name, arg_type, arg_name)
4014: tree key_name;
4015: tree arg_type;
4016: tree arg_name;
4017: {
4018: tree keyword_decl;
4019:
4020: /* if no type is specified, default to "id" */
4021: arg_type = adjust_type_for_id_default (arg_type);
4022:
4023: keyword_decl = make_node (KEYWORD_DECL);
4024:
4025: TREE_TYPE (keyword_decl) = arg_type;
4026: KEYWORD_ARG_NAME (keyword_decl) = arg_name;
4027: KEYWORD_KEY_NAME (keyword_decl) = key_name;
4028:
4029: return keyword_decl;
4030: }
4031:
4032: /* Given a chain of keyword_decl's, synthesize the full keyword selector. */
4033: static tree
4034: build_keyword_selector (selector)
4035: tree selector;
4036: {
4037: int len = 0;
4038: tree key_chain, key_name;
4039: char *buf;
4040:
4041: for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
4042: {
4043: if (TREE_CODE (selector) == KEYWORD_DECL)
4044: key_name = KEYWORD_KEY_NAME (key_chain);
4045: else if (TREE_CODE (selector) == TREE_LIST)
4046: key_name = TREE_PURPOSE (key_chain);
4047:
4048: if (key_name)
4049: len += IDENTIFIER_LENGTH (key_name) + 1;
4050: else /* just a ':' arg */
4051: len++;
4052: }
4053: buf = (char *)alloca (len + 1);
4054: bzero (buf, len + 1);
4055:
4056: for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
4057: {
4058: if (TREE_CODE (selector) == KEYWORD_DECL)
4059: key_name = KEYWORD_KEY_NAME (key_chain);
4060: else if (TREE_CODE (selector) == TREE_LIST)
4061: key_name = TREE_PURPOSE (key_chain);
4062:
4063: if (key_name)
4064: strcat (buf, IDENTIFIER_POINTER (key_name));
4065: strcat (buf, ":");
4066: }
4067: return get_identifier (buf);
4068: }
4069:
4070: /* used for declarations and definitions */
4071:
4072: tree
4073: build_method_decl (code, ret_type, selector, add_args)
4074: enum tree_code code;
4075: tree ret_type;
4076: tree selector;
4077: tree add_args;
4078: {
4079: tree method_decl;
4080:
4081: /* if no type is specified, default to "id" */
4082: ret_type = adjust_type_for_id_default (ret_type);
4083:
4084: method_decl = make_node (code);
4085: TREE_TYPE (method_decl) = ret_type;
4086:
4087: /* If we have a keyword selector, create an identifier_node that
4088: represents the full selector name (`:' included)... */
4089: if (TREE_CODE (selector) == KEYWORD_DECL)
4090: {
4091: METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector);
4092: METHOD_SEL_ARGS (method_decl) = selector;
4093: METHOD_ADD_ARGS (method_decl) = add_args;
4094: }
4095: else
4096: {
4097: METHOD_SEL_NAME (method_decl) = selector;
4098: METHOD_SEL_ARGS (method_decl) = NULLT;
4099: METHOD_ADD_ARGS (method_decl) = NULLT;
4100: }
4101:
4102: return method_decl;
4103: }
4104:
4105: #define METHOD_DEF 0
4106: #define METHOD_REF 1
4107:
4108: /* Used by `build_message_expr' and `comp_method_types'. Return an
4109: argument list for method METH. CONTEXT is either METHOD_DEF or
4110: METHOD_REF, saying whether we are trying to define a method or call
4111: one. SUPERFLAG says this is for a send to super; this makes a
4112: difference for the NeXT calling sequence in which the lookup and
4113: the method call are done together. */
4114:
4115: static tree
4116: get_arg_type_list (meth, context, superflag)
4117: tree meth;
4118: int context;
4119: int superflag;
4120: {
4121: tree arglist, akey;
4122:
4123: /* receiver type */
4124: if (flag_next_runtime && superflag)
4125: arglist = build_tree_list (NULLT, super_type);
4126: else if (context == METHOD_DEF)
4127: arglist = build_tree_list (NULLT, TREE_TYPE (self_decl));
4128: else
4129: arglist = build_tree_list (NULLT, id_type);
4130:
4131: /* selector type - will eventually change to `int' */
4132: chainon (arglist, build_tree_list (NULLT, selector_type));
4133:
4134: /* build a list of argument types */
4135: for (akey = METHOD_SEL_ARGS (meth); akey; akey = TREE_CHAIN (akey))
4136: {
4137: tree arg_decl = groktypename_in_parm_context (TREE_TYPE (akey));
4138: chainon (arglist, build_tree_list (NULLT, TREE_TYPE (arg_decl)));
4139: }
4140:
4141: if (METHOD_ADD_ARGS (meth) == (tree)1)
4142: /* We have a `, ...' immediately following the selector,
4143: finalize the arglist...simulate get_parm_info (0). */
4144: ;
4145: else if (METHOD_ADD_ARGS (meth))
4146: {
4147: /* we have a variable length selector */
4148: tree add_arg_list = TREE_CHAIN (METHOD_ADD_ARGS (meth));
4149: chainon (arglist, add_arg_list);
4150: }
4151: else
4152: /* finalize the arglist...simulate get_parm_info (1) */
4153: chainon (arglist, build_tree_list (NULLT, void_type_node));
4154:
4155: return arglist;
4156: }
4157:
4158: static tree
4159: check_duplicates (hsh)
4160: hash hsh;
4161: {
4162: tree meth = NULLT;
4163:
4164: if (hsh)
4165: {
4166: meth = hsh->key;
4167:
4168: if (hsh->list)
4169: {
4170: /* we have two methods with the same name and different types */
4171: attr loop;
4172: char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL) ? '-' : '+';
4173:
4174: warning ("multiple declarations for method `%s'",
4175: IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
4176:
4177: warn_with_method ("using", type, meth);
4178: for (loop = hsh->list; loop; loop = loop->next)
4179: warn_with_method ("also found", type, loop->value);
4180: }
4181: }
4182: return meth;
4183: }
4184:
4185: /* If RECEIVER is a class reference, return the identifier node for the
4186: referenced class. RECEIVER is created by get_class_reference, so we
4187: check the exact form created depending on which runtimes are used. */
4188:
4189: static tree
4190: receiver_is_class_object (receiver)
4191: tree receiver;
4192: {
4193: tree chain, exp, arg;
4194: if (flag_next_runtime)
4195: {
4196: /* The receiver is a variable created by build_class_reference_decl. */
4197: if (TREE_CODE (receiver) == VAR_DECL
4198: && TREE_TYPE (receiver) == objc_class_type)
4199: /* Look up the identifier. */
4200: for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
4201: if (TREE_PURPOSE (chain) == receiver)
4202: return TREE_VALUE (chain);
4203: }
4204: else
4205: {
4206: /* The receiver is a function call that returns an id. Check if
4207: it is a call to objc_getClass, if so, pick up the class name. */
4208: if ((exp = TREE_OPERAND (receiver, 0))
4209: && TREE_CODE (exp) == ADDR_EXPR
4210: && (exp = TREE_OPERAND (exp, 0))
4211: && TREE_CODE (exp) == FUNCTION_DECL
4212: && exp == objc_get_class_decl
4213: /* we have a call to objc_getClass! */
4214: && (arg = TREE_OPERAND (receiver, 1))
4215: && TREE_CODE (arg) == TREE_LIST
4216: && (arg = TREE_VALUE (arg)))
4217: {
4218: STRIP_NOPS (arg);
4219: if (TREE_CODE (arg) == ADDR_EXPR
4220: && (arg = TREE_OPERAND (arg, 0))
4221: && TREE_CODE (arg) == STRING_CST)
4222: /* finally, we have the class name */
4223: return get_identifier (TREE_STRING_POINTER (arg));
4224: }
4225: }
4226: return 0;
4227: }
4228:
4229: /* If we are currently building a message expr, this holds
4230: the identifier of the selector of the message. This is
4231: used when printing warnings about argument mismatches. */
4232:
4233: static tree building_objc_message_expr = 0;
4234:
4235: tree
4236: maybe_building_objc_message_expr ()
4237: {
4238: return building_objc_message_expr;
4239: }
4240:
4241: /* Construct an expression for sending a message.
4242: MESS has the object to send to in TREE_PURPOSE
4243: and the argument list (including selector) in TREE_VALUE.
4244:
4245: (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
4246: (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
4247:
4248: tree
4249: build_message_expr (mess)
4250: tree mess;
4251: {
4252: tree receiver = TREE_PURPOSE (mess);
4253: tree selector, self_object;
4254: tree rtype, sel_name;
4255: tree args = TREE_VALUE (mess);
4256: tree method_params = NULLT;
4257: tree method_prototype = NULLT;
4258: tree retval;
4259: int statically_typed = 0, statically_allocated = 0;
4260: tree class_ident = 0;
4261:
4262: /* 1 if this is sending to the superclass. */
4263: int super;
4264:
4265: if (!doing_objc_thang)
4266: objc_fatal ();
4267:
4268: if (TREE_CODE (receiver) == ERROR_MARK)
4269: return error_mark_node;
4270:
4271: /* determine receiver type */
4272: rtype = TREE_TYPE (receiver);
4273: super = IS_SUPER (rtype);
4274:
4275: if (! super)
4276: {
4277: if (TREE_STATIC_TEMPLATE (rtype))
4278: statically_allocated = 1;
4279: else if (TREE_CODE (rtype) == POINTER_TYPE
4280: && TREE_STATIC_TEMPLATE (TREE_TYPE (rtype)))
4281: statically_typed = 1;
4282: else if ((flag_next_runtime
4283: || (TREE_CODE (receiver) == CALL_EXPR && IS_ID (rtype)))
4284: && (class_ident = receiver_is_class_object (receiver)))
4285: ;
4286: else if (! IS_ID (rtype)
4287: /* Allow any type that matches objc_class_type. */
4288: && ! comptypes (rtype, objc_class_type))
4289: {
4290: bzero (errbuf, BUFSIZE);
4291: warning ("invalid receiver type `%s'",
4292: gen_declaration (rtype, errbuf));
4293: }
4294: if (statically_allocated)
4295: receiver = build_unary_op (ADDR_EXPR, receiver, 0);
4296:
4297: /* Don't evaluate the receiver twice. */
4298: receiver = save_expr (receiver);
4299: self_object = receiver;
4300: }
4301: else
4302: /* If sending to `super', use current self as the object. */
4303: self_object = self_decl;
4304:
4305: /* Obtain the full selector name. */
4306:
4307: if (TREE_CODE (args) == IDENTIFIER_NODE)
4308: /* a unary selector */
4309: sel_name = args;
4310: else if (TREE_CODE (args) == TREE_LIST)
4311: sel_name = build_keyword_selector (args);
4312:
4313: /* Build the parameters list for looking up the method.
4314: These are the object itself and the selector. */
4315:
4316: selector = build_selector_reference (sel_name);
4317:
4318: /* Build the parameter list to give to the method. */
4319:
4320: method_params = NULLT;
4321: if (TREE_CODE (args) == TREE_LIST)
4322: {
4323: tree chain = args, prev = NULLT;
4324:
4325: /* We have a keyword selector--check for comma expressions. */
4326: while (chain)
4327: {
4328: tree element = TREE_VALUE (chain);
4329:
4330: /* We have a comma expression, must collapse... */
4331: if (TREE_CODE (element) == TREE_LIST)
4332: {
4333: if (prev)
4334: TREE_CHAIN (prev) = element;
4335: else
4336: args = element;
4337: }
4338: prev = chain;
4339: chain = TREE_CHAIN (chain);
4340: }
4341: method_params = args;
4342: }
4343:
4344: /* Determine operation return type. */
4345:
4346: if (IS_SUPER (rtype))
4347: {
4348: tree iface;
4349:
4350: if (CLASS_SUPER_NAME (implementation_template))
4351: {
4352: iface = lookup_interface (CLASS_SUPER_NAME (implementation_template));
4353:
4354: if (TREE_CODE (method_context) == INSTANCE_METHOD_DECL)
4355: method_prototype = lookup_instance_method_static (iface, sel_name);
4356: else
4357: method_prototype = lookup_class_method_static (iface, sel_name);
4358:
4359: if (iface && !method_prototype)
4360: warning ("`%s' does not respond to `%s'",
4361: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_template)),
4362: IDENTIFIER_POINTER (sel_name));
4363: }
4364: else
4365: {
4366: error ("no super class declared in interface for `%s'",
4367: IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
4368: return error_mark_node;
4369: }
4370:
4371: }
4372: else if (statically_allocated)
4373: {
4374: tree ctype = TREE_TYPE (rtype);
4375: tree iface = lookup_interface (TYPE_NAME (rtype));
4376:
4377: if (iface)
4378: method_prototype = lookup_instance_method_static (iface, sel_name);
4379:
4380: /* NEW!!! */
4381: if (! method_prototype && TYPE_PROTOCOL_LIST (ctype))
4382: method_prototype
4383: = lookup_method_in_protocol_list (TYPE_PROTOCOL_LIST (ctype),
4384: sel_name, 0);
4385:
4386: if (!method_prototype)
4387: warning ("`%s' does not respond to `%s'",
4388: IDENTIFIER_POINTER (TYPE_NAME (rtype)),
4389: IDENTIFIER_POINTER (sel_name));
4390: }
4391: else if (statically_typed)
4392: {
4393: tree ctype = TREE_TYPE (rtype);
4394:
4395: /* `self' is now statically_typed...all methods should be visible
4396: within the context of the implementation... */
4397: if (implementation_context
4398: && CLASS_NAME (implementation_context) == TYPE_NAME (ctype))
4399: {
4400: method_prototype = lookup_instance_method_static (implementation_template, sel_name);
4401:
4402: /* NEW!!! */
4403: if (! method_prototype && TYPE_PROTOCOL_LIST (ctype))
4404: method_prototype
4405: = lookup_method_in_protocol_list (TYPE_PROTOCOL_LIST (ctype),
4406: sel_name, 0);
4407:
4408: if (! method_prototype
4409: && implementation_template != implementation_context)
4410: /* the method is not published in the interface...check locally */
4411: method_prototype
4412: = lookup_method (CLASS_NST_METHODS (implementation_context),
4413: sel_name);
4414: }
4415: else
4416: {
4417: tree iface;
4418:
4419: if ((iface = lookup_interface (TYPE_NAME (ctype))))
4420: method_prototype = lookup_instance_method_static (iface, sel_name);
4421:
4422: if (! method_prototype)
4423: {
4424: tree protocol_list = TYPE_PROTOCOL_LIST (ctype);
4425: if (protocol_list)
4426: method_prototype
4427: = lookup_method_in_protocol_list (protocol_list, sel_name, 0);
4428: }
4429: }
4430:
4431: if (!method_prototype)
4432: warning ("`%s' does not respond to `%s'",
4433: IDENTIFIER_POINTER (TYPE_NAME (ctype)),
4434: IDENTIFIER_POINTER (sel_name));
4435: }
4436: else if (class_ident)
4437: {
4438: if (implementation_context
4439: && CLASS_NAME (implementation_context) == class_ident)
4440: {
4441: method_prototype
4442: = lookup_class_method_static (implementation_template, sel_name);
4443:
4444: if (!method_prototype
4445: && implementation_template != implementation_context)
4446: /* the method is not published in the interface...check locally */
4447: method_prototype
4448: = lookup_method (CLASS_CLS_METHODS (implementation_context),
4449: sel_name);
4450: }
4451: else
4452: {
4453: tree iface;
4454:
4455: if ((iface = lookup_interface (class_ident)))
4456: method_prototype = lookup_class_method_static (iface, sel_name);
4457: }
4458:
4459: if (!method_prototype)
4460: {
4461: warning ("cannot find class (factory) method.");
4462: warning ("return type for `%s' defaults to id",
4463: IDENTIFIER_POINTER (sel_name));
4464: }
4465: }
4466: else if (IS_PROTOCOL_QUALIFIED_ID (rtype))
4467: {
4468: /* An anonymous object that has been qualified with a protocol. */
4469:
4470: tree protocol_list = TYPE_PROTOCOL_LIST (rtype);
4471:
4472: method_prototype = lookup_method_in_protocol_list (protocol_list,
4473: sel_name, 0);
4474:
4475: if (!method_prototype)
4476: {
4477: hash hsh;
4478:
4479: warning ("method `%s' not implemented by protocol.",
4480: IDENTIFIER_POINTER (sel_name));
4481:
4482: /* try and find the method signiture in the global pools! */
4483:
4484: if (!(hsh = hash_lookup (nst_method_hash_list, sel_name)))
4485: hsh = hash_lookup (cls_method_hash_list, sel_name);
4486:
4487: if (!(method_prototype = check_duplicates (hsh)))
4488: warning ("return type defaults to id");
4489: }
4490: }
4491: else
4492: {
4493: hash hsh;
4494:
4495: /* we think we have an instance...loophole: extern id Object; */
4496: hsh = hash_lookup (nst_method_hash_list, sel_name);
4497: if (!hsh)
4498: /* for various loopholes...like sending messages to self in a
4499: factory context... */
4500: hsh = hash_lookup (cls_method_hash_list, sel_name);
4501:
4502: method_prototype = check_duplicates (hsh);
4503: if (!method_prototype)
4504: {
4505: warning ("cannot find method.");
4506: warning ("return type for `%s' defaults to id",
4507: IDENTIFIER_POINTER (sel_name));
4508: }
4509: }
4510:
4511: /* Save the selector name for printing error messages. */
4512: building_objc_message_expr = sel_name;
4513:
4514: retval = build_objc_method_call (super, method_prototype,
4515: receiver, self_object,
4516: selector, method_params);
4517:
4518: building_objc_message_expr = 0;
4519:
4520: return retval;
4521: }
4522:
4523: /* Build a tree expression to send OBJECT the operation SELECTOR,
4524: looking up the method on object LOOKUP_OBJECT (often same as OBJECT),
4525: assuming the method has prototype METHOD_PROTOTYPE.
4526: (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.)
4527: Use METHOD_PARAMS as list of args to pass to the method.
4528: If SUPER_FLAG is nonzero, we look up the superclass's method. */
4529:
4530: static tree
4531: build_objc_method_call (super_flag, method_prototype, lookup_object, object,
4532: selector, method_params)
4533: int super_flag;
4534: tree method_prototype, lookup_object, object, selector, method_params;
4535: {
4536: tree sender = (super_flag ? umsg_super_decl : umsg_decl);
4537: tree rcv_p = (super_flag
4538: ? build_pointer_type (xref_tag (RECORD_TYPE,
4539: get_identifier (TAG_SUPER)))
4540: : id_type);
4541:
4542: if (flag_next_runtime)
4543: {
4544: if (! method_prototype)
4545: {
4546: method_params = tree_cons (NULLT, lookup_object,
4547: tree_cons (NULLT, selector,
4548: method_params));
4549: assemble_external (sender);
4550: return build_function_call (sender, method_params);
4551: }
4552: else
4553: {
4554: /* This is a real kludge, but it is used only for the Next.
4555: Clobber the data type of SENDER temporarily to accept
4556: all the arguments for this operation, and to return
4557: whatever this operation returns. */
4558: tree arglist = NULLT;
4559: tree retval;
4560:
4561: /* Save the proper contents of SENDER's data type. */
4562: tree savarg = TYPE_ARG_TYPES (TREE_TYPE (sender));
4563: tree savret = TREE_TYPE (TREE_TYPE (sender));
4564:
4565: /* Install this method's argument types. */
4566: arglist = get_arg_type_list (method_prototype, METHOD_REF,
4567: super_flag);
4568: TYPE_ARG_TYPES (TREE_TYPE (sender)) = arglist;
4569:
4570: /* Install this method's return type. */
4571: TREE_TYPE (TREE_TYPE (sender))
4572: = groktypename (TREE_TYPE (method_prototype));
4573:
4574: /* Call SENDER with all the parameters. This will do type
4575: checking using the arg types for this method. */
4576: method_params = tree_cons (NULLT, lookup_object,
4577: tree_cons (NULLT, selector,
4578: method_params));
4579: assemble_external (sender);
4580: retval = build_function_call (sender, method_params);
4581:
4582: /* Restore SENDER's return/argument types. */
4583: TYPE_ARG_TYPES (TREE_TYPE (sender)) = savarg;
4584: TREE_TYPE (TREE_TYPE (sender)) = savret;
4585: return retval;
4586: }
4587: }
4588: else
4589: {
4590: /* This is the portable way.
4591: First call the lookup function to get a pointer to the method,
4592: then cast the pointer, then call it with the method arguments. */
4593: tree method;
4594:
4595: /* Avoid trouble since we may evaluate each of these twice. */
4596: object = save_expr (object);
4597: selector = save_expr (selector);
4598:
4599: lookup_object = build_c_cast (rcv_p, lookup_object); /* cast! */
4600:
4601: assemble_external (sender);
4602: method
4603: = build_function_call (sender,
4604: tree_cons (NULLT, lookup_object,
4605: tree_cons (NULLT, selector, NULLT)));
4606:
4607: /* If we have a method prototype, construct the data type this
4608: method needs, and cast what we got from SENDER into a pointer
4609: to that type. */
4610: if (method_prototype)
4611: {
4612: tree arglist = get_arg_type_list (method_prototype, METHOD_REF,
4613: super_flag);
4614: tree valtype = groktypename (TREE_TYPE (method_prototype));
4615: tree fake_function_type = build_function_type (valtype, arglist);
4616: TREE_TYPE (method) = build_pointer_type (fake_function_type);
4617: }
4618: else
4619: TREE_TYPE (method)
4620: = build_pointer_type (build_function_type (ptr_type_node, NULLT));
4621:
4622: /* Pass the object to the method. */
4623: assemble_external (method);
4624: return build_function_call (method,
4625: tree_cons (NULLT, object,
4626: tree_cons (NULLT, selector,
4627: method_params)));
4628: }
4629: }
4630:
4631: static void
4632: build_protocol_reference (p)
4633: tree p;
4634: {
4635: tree decl, ident, ptype;
4636: struct obstack *save_current_obstack = current_obstack;
4637: struct obstack *save_rtl_obstack = rtl_obstack;
4638:
4639: rtl_obstack = current_obstack = &permanent_obstack;
4640:
4641: /* extern struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
4642:
4643: ident = synth_id_with_class_suffix ("_OBJC_PROTOCOL", p);
4644: ptype
4645: = groktypename (build_tree_list (build_tree_list (NULLT,
4646: objc_protocol_template),
4647: NULLT));
4648:
4649: if (IDENTIFIER_GLOBAL_VALUE (ident))
4650: decl = IDENTIFIER_GLOBAL_VALUE (ident); /* Set by pushdecl. */
4651: else
4652: {
4653: decl = build_decl (VAR_DECL, ident, ptype);
4654: DECL_EXTERNAL (decl) = 1;
4655: TREE_PUBLIC (decl) = 1;
4656: TREE_USED (decl) = 1;
4657:
4658: /* usually called from `rest_of_decl_compilation' */
4659: make_decl_rtl (decl, 0, 1);
4660: /* our `extended/custom' pushdecl in c-decl.c */
4661: pushdecl_top_level (decl);
4662: }
4663: current_obstack = save_current_obstack;
4664: rtl_obstack = save_rtl_obstack;
4665:
4666: PROTOCOL_FORWARD_DECL (p) = decl;
4667: }
4668:
4669: tree
4670: build_protocol_expr (protoname)
4671: tree protoname;
4672: {
4673: tree expr;
4674: tree p;
4675:
4676: if (!doing_objc_thang)
4677: objc_fatal ();
4678:
4679: p = lookup_protocol (protoname);
4680:
4681: if (!p)
4682: {
4683: error ("Cannot find protocol declaration for `%s'",
4684: IDENTIFIER_POINTER (protoname));
4685: return error_mark_node;
4686: }
4687:
4688: if (!PROTOCOL_FORWARD_DECL (p))
4689: build_protocol_reference (p);
4690:
4691: expr = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
4692:
4693: TREE_TYPE (expr) = protocol_type;
4694:
4695: return expr;
4696: }
4697:
4698: tree
4699: build_selector_expr (selnamelist)
4700: tree selnamelist;
4701: {
4702: tree selname;
4703:
4704: if (!doing_objc_thang)
4705: objc_fatal ();
4706:
4707: /* obtain the full selector name */
4708: if (TREE_CODE (selnamelist) == IDENTIFIER_NODE)
4709: /* a unary selector */
4710: selname = selnamelist;
4711: else if (TREE_CODE (selnamelist) == TREE_LIST)
4712: selname = build_keyword_selector (selnamelist);
4713:
4714: return build_selector_reference (selname);
4715: }
4716:
4717: tree
4718: build_encode_expr (type)
4719: tree type;
4720: {
4721: tree result;
4722: char *string;
4723:
4724: if (!doing_objc_thang)
4725: objc_fatal ();
4726:
4727: encode_type (type, obstack_object_size (&util_obstack),
4728: OBJC_ENCODE_INLINE_DEFS);
4729: obstack_1grow (&util_obstack, 0); /* null terminate string */
4730: string = obstack_finish (&util_obstack);
4731:
4732: /* synthesize a string that represents the encoded struct/union */
4733: result = my_build_string (strlen (string) + 1, string);
4734: obstack_free (&util_obstack, util_firstobj);
4735: return result;
4736: }
4737:
4738: tree
4739: build_ivar_reference (id)
4740: tree id;
4741: {
4742: if (TREE_CODE (method_context) == CLASS_METHOD_DECL)
4743: {
4744: /* Historically, a class method that produced objects (factory
4745: method) would assign `self' to the instance that it
4746: allocated. This would effectively turn the class method into
4747: an instance method. Following this assignment, the instance
4748: variables could be accessed. That practice, while safe,
4749: violates the simple rule that a class method should not refer
4750: to an instance variable. It's better to catch the cases
4751: where this is done unknowingly than to support the above
4752: paradigm. */
4753: warning ("instance variable `%s' accessed in class method",
4754: IDENTIFIER_POINTER (id));
4755: TREE_TYPE (self_decl) = instance_type; /* cast */
4756: }
4757:
4758: return build_component_ref (build_indirect_ref (self_decl, "->"), id);
4759: }
4760:
4761: #define HASH_ALLOC_LIST_SIZE 170
4762: #define ATTR_ALLOC_LIST_SIZE 170
4763: #define SIZEHASHTABLE 257
4764:
4765: /* make positive */
4766: #define HASHFUNCTION(key) ((HOST_WIDE_INT) key & 0x7fffffff)
4767:
4768: static void
4769: hash_init ()
4770: {
4771: nst_method_hash_list = (hash *)xmalloc (SIZEHASHTABLE * sizeof (hash));
4772: cls_method_hash_list = (hash *)xmalloc (SIZEHASHTABLE * sizeof (hash));
4773:
4774: if (!nst_method_hash_list || !cls_method_hash_list)
4775: perror ("unable to allocate space in objc-tree.c");
4776: else
4777: {
4778: int i;
4779:
4780: for (i = 0; i < SIZEHASHTABLE; i++)
4781: {
4782: nst_method_hash_list[i] = 0;
4783: cls_method_hash_list[i] = 0;
4784: }
4785: }
4786: }
4787:
4788: static void
4789: hash_enter (hashlist, method)
4790: hash *hashlist;
4791: tree method;
4792: {
4793: static hash hash_alloc_list = 0;
4794: static int hash_alloc_index = 0;
4795: hash obj;
4796: int slot = HASHFUNCTION (METHOD_SEL_NAME (method)) % SIZEHASHTABLE;
4797:
4798: if (! hash_alloc_list || hash_alloc_index >= HASH_ALLOC_LIST_SIZE)
4799: {
4800: hash_alloc_index = 0;
4801: hash_alloc_list = (hash) xmalloc (sizeof (struct hashed_entry)
4802: * HASH_ALLOC_LIST_SIZE);
4803: if (! hash_alloc_list)
4804: perror ("unable to allocate in objc-tree.c");
4805: }
4806: obj = &hash_alloc_list[hash_alloc_index++];
4807: obj->list = 0;
4808: obj->next = hashlist[slot];
4809: obj->key = method;
4810:
4811: hashlist[slot] = obj; /* append to front */
4812: }
4813:
4814: static hash
4815: hash_lookup (hashlist, sel_name)
4816: hash *hashlist;
4817: tree sel_name;
4818: {
4819: hash target;
4820:
4821: target = hashlist[HASHFUNCTION (sel_name) % SIZEHASHTABLE];
4822:
4823: while (target)
4824: {
4825: if (sel_name == METHOD_SEL_NAME (target->key))
4826: return target;
4827:
4828: target = target->next;
4829: }
4830: return 0;
4831: }
4832:
4833: static void
4834: hash_add_attr (entry, value)
4835: hash entry;
4836: tree value;
4837: {
4838: static attr attr_alloc_list = 0;
4839: static int attr_alloc_index = 0;
4840: attr obj;
4841:
4842: if (! attr_alloc_list || attr_alloc_index >= ATTR_ALLOC_LIST_SIZE)
4843: {
4844: attr_alloc_index = 0;
4845: attr_alloc_list = (attr) xmalloc (sizeof (struct hashed_attribute)
4846: * ATTR_ALLOC_LIST_SIZE);
4847: if (! attr_alloc_list)
4848: perror ("unable to allocate in objc-tree.c");
4849: }
4850: obj = &attr_alloc_list[attr_alloc_index++];
4851: obj->next = entry->list;
4852: obj->value = value;
4853:
4854: entry->list = obj; /* append to front */
4855: }
4856:
4857: static tree
4858: lookup_method (mchain, method)
4859: tree mchain;
4860: tree method;
4861: {
4862: tree key;
4863:
4864: if (TREE_CODE (method) == IDENTIFIER_NODE)
4865: key = method;
4866: else
4867: key = METHOD_SEL_NAME (method);
4868:
4869: while (mchain)
4870: {
4871: if (METHOD_SEL_NAME (mchain) == key)
4872: return mchain;
4873: mchain = TREE_CHAIN (mchain);
4874: }
4875: return NULLT;
4876: }
4877:
4878: static tree
4879: lookup_instance_method_static (interface, ident)
4880: tree interface;
4881: tree ident;
4882: {
4883: tree inter = interface;
4884: tree chain = CLASS_NST_METHODS (inter);
4885: tree meth = NULLT;
4886:
4887: do
4888: {
4889: if ((meth = lookup_method (chain, ident)))
4890: return meth;
4891:
4892: if (CLASS_CATEGORY_LIST (inter))
4893: {
4894: tree category = CLASS_CATEGORY_LIST (inter);
4895: chain = CLASS_NST_METHODS (category);
4896:
4897: do
4898: {
4899: if ((meth = lookup_method (chain, ident)))
4900: return meth;
4901:
4902: /* NEW!!! */
4903: /* Check for instance methods in protocols in categories. */
4904: if (CLASS_PROTOCOL_LIST (category))
4905: {
4906: if ((meth = (lookup_method_in_protocol_list
4907: (CLASS_PROTOCOL_LIST (category), ident, 0))))
4908: return meth;
4909: }
4910:
4911: if ((category = CLASS_CATEGORY_LIST (category)))
4912: chain = CLASS_NST_METHODS (category);
4913: }
4914: while (category);
4915: }
4916:
4917: if (CLASS_PROTOCOL_LIST (inter))
4918: {
4919: if ((meth = (lookup_method_in_protocol_list
4920: (CLASS_PROTOCOL_LIST (inter), ident, 0))))
4921: return meth;
4922: }
4923:
4924: if ((inter = lookup_interface (CLASS_SUPER_NAME (inter))))
4925: chain = CLASS_NST_METHODS (inter);
4926: }
4927: while (inter);
4928:
4929: return meth;
4930: }
4931:
4932: static tree
4933: lookup_class_method_static (interface, ident)
4934: tree interface;
4935: tree ident;
4936: {
4937: tree inter = interface;
4938: tree chain = CLASS_CLS_METHODS (inter);
4939: tree meth = NULLT;
4940: tree root_inter = NULLT;
4941:
4942: do
4943: {
4944: if ((meth = lookup_method (chain, ident)))
4945: return meth;
4946:
4947: if (CLASS_CATEGORY_LIST (inter))
4948: {
4949: tree category = CLASS_CATEGORY_LIST (inter);
4950: chain = CLASS_CLS_METHODS (category);
4951:
4952: do
4953: {
4954: if ((meth = lookup_method (chain, ident)))
4955: return meth;
4956:
4957: /* NEW!!! */
4958: /* Check for class methods in protocols in categories. */
4959: if (CLASS_PROTOCOL_LIST (category))
4960: {
4961: if ((meth = (lookup_method_in_protocol_list
4962: (CLASS_PROTOCOL_LIST (category), ident, 1))))
4963: return meth;
4964: }
4965:
4966: if ((category = CLASS_CATEGORY_LIST (category)))
4967: chain = CLASS_CLS_METHODS (category);
4968: }
4969: while (category);
4970: }
4971:
4972: /* NEW!!! */
4973: /* Check for class methods in protocols. */
4974: if (CLASS_PROTOCOL_LIST (inter))
4975: {
4976: if ((meth = (lookup_method_in_protocol_list
4977: (CLASS_PROTOCOL_LIST (inter), ident, 1))))
4978: return meth;
4979: }
4980:
4981: root_inter = inter;
4982: if ((inter = lookup_interface (CLASS_SUPER_NAME (inter))))
4983: chain = CLASS_CLS_METHODS (inter);
4984: }
4985: while (inter);
4986:
4987: /* NEW!!! */
4988: /* Simulate wrap around. */
4989: return lookup_instance_method_static (root_inter, ident);
4990: }
4991:
4992: tree
4993: add_class_method (class, method)
4994: tree class;
4995: tree method;
4996: {
4997: tree mth;
4998: hash hsh;
4999:
5000: /* We will have allocated the method parameter declarations on the
5001: maybepermanent_obstack. Need to make sure they stick around! */
5002: preserve_data ();
5003:
5004: if (!(mth = lookup_method (CLASS_CLS_METHODS (class), method)))
5005: {
5006: /* put method on list in reverse order */
5007: TREE_CHAIN (method) = CLASS_CLS_METHODS (class);
5008: CLASS_CLS_METHODS (class) = method;
5009: }
5010: else
5011: {
5012: if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
5013: error ("duplicate definition of class method `%s'.",
5014: IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
5015: else
5016: {
5017: /* check types, if different complain */
5018: if (!comp_proto_with_proto (method, mth))
5019: error ("duplicate declaration of class method `%s'.",
5020: IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
5021: }
5022: }
5023:
5024: if (!(hsh = hash_lookup (cls_method_hash_list, METHOD_SEL_NAME (method))))
5025: {
5026: /* install on a global chain */
5027: hash_enter (cls_method_hash_list, method);
5028: }
5029: else
5030: {
5031: /* check types, if different add to a list */
5032: if (!comp_proto_with_proto (method, hsh->key))
5033: hash_add_attr (hsh, method);
5034: }
5035: return method;
5036: }
5037:
5038: tree
5039: add_instance_method (class, method)
5040: tree class;
5041: tree method;
5042: {
5043: tree mth;
5044: hash hsh;
5045:
5046: /* We will have allocated the method parameter declarations on the
5047: maybepermanent_obstack. Need to make sure they stick around! */
5048: preserve_data ();
5049:
5050: if (!(mth = lookup_method (CLASS_NST_METHODS (class), method)))
5051: {
5052: /* put method on list in reverse order */
5053: TREE_CHAIN (method) = CLASS_NST_METHODS (class);
5054: CLASS_NST_METHODS (class) = method;
5055: }
5056: else
5057: {
5058: if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
5059: error ("duplicate definition of instance method `%s'.",
5060: IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
5061: else
5062: {
5063: /* check types, if different complain */
5064: if (!comp_proto_with_proto (method, mth))
5065: error ("duplicate declaration of instance method `%s'.",
5066: IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
5067: }
5068: }
5069:
5070: if (!(hsh = hash_lookup (nst_method_hash_list, METHOD_SEL_NAME (method))))
5071: {
5072: /* install on a global chain */
5073: hash_enter (nst_method_hash_list, method);
5074: }
5075: else
5076: {
5077: /* check types, if different add to a list */
5078: if (!comp_proto_with_proto (method, hsh->key))
5079: hash_add_attr (hsh, method);
5080: }
5081: return method;
5082: }
5083:
5084: static tree
5085: add_class (class)
5086: tree class;
5087: {
5088: /* put interfaces on list in reverse order */
5089: TREE_CHAIN (class) = interface_chain;
5090: interface_chain = class;
5091: return interface_chain;
5092: }
5093:
5094: static void
5095: add_category (class, category)
5096: tree class;
5097: tree category;
5098: {
5099: /* put categories on list in reverse order */
5100:
5101: tree cat = CLASS_CATEGORY_LIST (class);
5102: while (cat)
5103: {
5104: if (CLASS_SUPER_NAME (cat) == CLASS_SUPER_NAME (category))
5105: warning ("duplicate interface declaration for category `%s(%s)'",
5106: IDENTIFIER_POINTER (CLASS_NAME (class)),
5107: IDENTIFIER_POINTER (CLASS_SUPER_NAME (category)));
5108: cat = CLASS_CATEGORY_LIST (cat);
5109: }
5110:
5111: CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (class);
5112: CLASS_CATEGORY_LIST (class) = category;
5113: }
5114:
5115: /* Called after parsing each instance variable declaration. Necessary to
5116: preserve typedefs and implement public/private...
5117:
5118: PUBLIC is 1 for public, 0 for protected, and 2 for private. */
5119:
5120: tree
5121: add_instance_variable (class, public, declarator, declspecs, width)
5122: tree class;
5123: int public;
5124: tree declarator;
5125: tree declspecs;
5126: tree width;
5127: {
5128: tree field_decl, raw_decl;
5129:
5130: raw_decl = build_tree_list (declspecs /*purpose*/, declarator/*value*/);
5131:
5132: if (CLASS_RAW_IVARS (class))
5133: chainon (CLASS_RAW_IVARS (class), raw_decl);
5134: else
5135: CLASS_RAW_IVARS (class) = raw_decl;
5136:
5137: field_decl = grokfield (input_filename, lineno,
5138: declarator, declspecs, width);
5139:
5140: /* overload the public attribute, it is not used for FIELD_DECL's */
5141: switch (public)
5142: {
5143: case 0:
5144: TREE_PUBLIC (field_decl) = 0;
5145: TREE_PRIVATE (field_decl) = 0;
5146: TREE_PROTECTED (field_decl) = 1;
5147: break;
5148:
5149: case 1:
5150: TREE_PUBLIC (field_decl) = 1;
5151: TREE_PRIVATE (field_decl) = 0;
5152: TREE_PROTECTED (field_decl) = 0;
5153: break;
5154:
5155: case 2:
5156: TREE_PUBLIC (field_decl) = 0;
5157: TREE_PRIVATE (field_decl) = 1;
5158: TREE_PROTECTED (field_decl) = 0;
5159: break;
5160:
5161: }
5162:
5163: if (CLASS_IVARS (class))
5164: chainon (CLASS_IVARS (class), field_decl);
5165: else
5166: CLASS_IVARS (class) = field_decl;
5167:
5168: return class;
5169: }
5170:
5171: tree
5172: is_ivar (decl_chain, ident)
5173: tree decl_chain;
5174: tree ident;
5175: {
5176: for ( ; decl_chain; decl_chain = TREE_CHAIN (decl_chain))
5177: if (DECL_NAME (decl_chain) == ident)
5178: return decl_chain;
5179: return NULL_TREE;
5180: }
5181:
5182: /* True if the ivar is private and we are not in its implementation. */
5183:
5184: int
5185: is_private (decl)
5186: tree decl;
5187: {
5188: if (TREE_PRIVATE (decl)
5189: && ! is_ivar (CLASS_IVARS (implementation_template), DECL_NAME (decl)))
5190: {
5191: error ("instance variable `%s' is declared private",
5192: IDENTIFIER_POINTER (DECL_NAME (decl)));
5193: return 1;
5194: }
5195: else
5196: return 0;
5197: }
5198:
5199: /* we have an instance variable reference, check to see if it is public...*/
5200:
5201: int
5202: is_public (expr, identifier)
5203: tree expr;
5204: tree identifier;
5205: {
5206: tree basetype = TREE_TYPE (expr);
5207: enum tree_code code = TREE_CODE (basetype);
5208: tree decl;
5209:
5210: if (code == RECORD_TYPE)
5211: {
5212: if (TREE_STATIC_TEMPLATE (basetype))
5213: {
5214: if (!lookup_interface (TYPE_NAME (basetype)))
5215: {
5216: error ("Cannot find interface declaration for `%s'",
5217: IDENTIFIER_POINTER (TYPE_NAME (basetype)));
5218: return 0;
5219: }
5220:
5221: if ((decl = is_ivar (TYPE_FIELDS (basetype), identifier)))
5222: {
5223: if (TREE_PUBLIC (decl))
5224: return 1;
5225:
5226: /* important difference between the Stepstone translator:
5227: all instance variables should be public within the context
5228: of the implementation. */
5229: if (implementation_context
5230: && (((TREE_CODE (implementation_context)
5231: == CLASS_IMPLEMENTATION_TYPE)
5232: || (TREE_CODE (implementation_context)
5233: == CATEGORY_IMPLEMENTATION_TYPE))
5234: && (CLASS_NAME (implementation_context)
5235: == TYPE_NAME (basetype))))
5236: return ! is_private (decl);
5237:
5238: error ("instance variable `%s' is declared %s",
5239: IDENTIFIER_POINTER (identifier),
5240: TREE_PRIVATE (decl) ? "private" : "protected");
5241: return 0;
5242: }
5243: }
5244: else if (implementation_context && (basetype == objc_object_reference))
5245: {
5246: TREE_TYPE (expr) = uprivate_record;
5247: warning ("static access to object of type `id'");
5248: }
5249: }
5250: return 1;
5251: }
5252:
5253: /* implement @defs (<classname>) within struct bodies. */
5254:
5255: tree
5256: get_class_ivars (interface)
5257: tree interface;
5258: {
5259: if (!doing_objc_thang)
5260: objc_fatal ();
5261:
5262: return build_ivar_chain (interface, 1);
5263: }
5264:
5265: /* make sure all entries in "chain" are also in "list" */
5266:
5267: static int
5268: check_methods (chain, list, mtype)
5269: tree chain;
5270: tree list;
5271: int mtype;
5272: {
5273: int first = 1;
5274:
5275: while (chain)
5276: {
5277: if (!lookup_method (list, chain))
5278: {
5279: if (first)
5280: {
5281: if (TREE_CODE (implementation_context) == CLASS_IMPLEMENTATION_TYPE)
5282: warning ("incomplete implementation of class `%s'",
5283: IDENTIFIER_POINTER (CLASS_NAME (implementation_context)));
5284: else if (TREE_CODE (implementation_context) == CATEGORY_IMPLEMENTATION_TYPE)
5285: warning ("incomplete implementation of category `%s'",
5286: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context)));
5287: first = 0;
5288: }
5289: warning ("method definition for `%c%s' not found",
5290: mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
5291: }
5292: chain = TREE_CHAIN (chain);
5293: }
5294: return first;
5295: }
5296:
5297: static int
5298: conforms_to_protocol (class, protocol)
5299: tree class;
5300: tree protocol;
5301: {
5302: while (protocol)
5303: {
5304: tree p = CLASS_PROTOCOL_LIST (class);
5305: while (p && TREE_VALUE (p) != TREE_VALUE (protocol))
5306: p = TREE_CHAIN (p);
5307: if (!p)
5308: {
5309: tree super = (CLASS_SUPER_NAME (class)
5310: ? lookup_interface (CLASS_SUPER_NAME (class))
5311: : NULL_TREE);
5312: int tmp = super ? conforms_to_protocol (super, protocol) : 0;
5313: if (!tmp)
5314: return 0;
5315: }
5316: protocol = TREE_CHAIN (protocol);
5317: }
5318: return 1;
5319: }
5320:
5321: /* Make sure all methods in CHAIN are accessible as MTYPE methods in
5322: CONTEXT. This is one of two mechanisms to check protocol integrity
5323: */
5324:
5325: static int
5326: check_methods_accessible (chain, context, mtype)
5327: tree chain;
5328: tree context; /* implementation_context */
5329: int mtype;
5330: {
5331: int first = 1;
5332: tree list;
5333:
5334: while (chain)
5335: {
5336: while (context)
5337: {
5338: if (mtype == '+')
5339: list = CLASS_CLS_METHODS (context);
5340: else
5341: list = CLASS_NST_METHODS (context);
5342:
5343: if (lookup_method (list, chain))
5344: break;
5345:
5346: else if (TREE_CODE (context) == CLASS_IMPLEMENTATION_TYPE
5347: || TREE_CODE (context) == CLASS_INTERFACE_TYPE)
5348: context = (CLASS_SUPER_NAME (context)
5349: ? lookup_interface (CLASS_SUPER_NAME (context))
5350: : NULL_TREE);
5351:
5352: else if (TREE_CODE (context) == CATEGORY_IMPLEMENTATION_TYPE
5353: || TREE_CODE (context) == CATEGORY_INTERFACE_TYPE)
5354: context = (CLASS_NAME (context)
5355: ? lookup_interface (CLASS_NAME (context))
5356: : NULL_TREE);
5357: else
5358: abort ();
5359: }
5360:
5361: if (context == NULL_TREE)
5362: {
5363: if (first)
5364: {
5365: if (TREE_CODE (implementation_context)
5366: == CLASS_IMPLEMENTATION_TYPE)
5367: warning ("incomplete implementation of class `%s'",
5368: IDENTIFIER_POINTER
5369: (CLASS_NAME (implementation_context)));
5370: else if (TREE_CODE (implementation_context)
5371: == CATEGORY_IMPLEMENTATION_TYPE)
5372: warning ("incomplete implementation of category `%s'",
5373: IDENTIFIER_POINTER
5374: (CLASS_SUPER_NAME (implementation_context)));
5375: first = 0;
5376: }
5377: warning ("method definition for `%c%s' not found",
5378: mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
5379: }
5380:
5381: chain = TREE_CHAIN (chain); /* next method... */
5382: }
5383: return first;
5384: }
5385:
5386: static void
5387: check_protocols (proto_list, type, name)
5388: tree proto_list;
5389: char *type;
5390: char *name;
5391: {
5392: for ( ; proto_list; proto_list = TREE_CHAIN (proto_list))
5393: {
5394: tree p = TREE_VALUE (proto_list);
5395:
5396: if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
5397: {
5398: int f1, f2;
5399:
5400: /* Ensure that all protocols have bodies! */
5401: if (flag_warn_protocol) {
5402: f1 = check_methods (PROTOCOL_CLS_METHODS (p),
5403: CLASS_CLS_METHODS (implementation_context),
5404: '+');
5405: f2 = check_methods (PROTOCOL_NST_METHODS (p),
5406: CLASS_NST_METHODS (implementation_context),
5407: '-');
5408: } else {
5409: f1 = check_methods_accessible (PROTOCOL_CLS_METHODS (p),
5410: implementation_context,
5411: '+');
5412: f2 = check_methods_accessible (PROTOCOL_NST_METHODS (p),
5413: implementation_context,
5414: '-');
5415: }
5416:
5417: if (!f1 || !f2)
5418: warning ("%s `%s' does not fully implement the `%s' protocol",
5419: type, name, IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
5420:
5421: }
5422: else
5423: ; /* an identifier...if we could not find a protocol. */
5424:
5425: /* Check protocols recursively. */
5426: if (PROTOCOL_LIST (p))
5427: {
5428: tree super_class
5429: = lookup_interface (CLASS_SUPER_NAME (implementation_template));
5430: if (! conforms_to_protocol (super_class, PROTOCOL_LIST (p)))
5431: check_protocols (PROTOCOL_LIST (p), type, name);
5432: }
5433: }
5434: }
5435:
5436: /* Make sure that the class CLASS_NAME is defined
5437: CODE says which kind of thing CLASS_NAME ought to be.
5438: It can be CLASS_INTERFACE_TYPE, CLASS_IMPLEMENTATION_TYPE,
5439: CATEGORY_INTERFACE_TYPE, or CATEGORY_IMPLEMENTATION_TYPE.
5440:
5441: If CODE is CLASS_INTERFACE_TYPE, we also do a push_obstacks_nochange
5442: whose matching pop is in continue_class. */
5443:
5444: tree
5445: start_class (code, class_name, super_name, protocol_list)
5446: enum tree_code code;
5447: tree class_name;
5448: tree super_name;
5449: tree protocol_list;
5450: {
5451: tree class, decl;
5452:
5453: if (code == CLASS_INTERFACE_TYPE)
5454: {
5455: push_obstacks_nochange ();
5456: end_temporary_allocation ();
5457: }
5458:
5459: if (!doing_objc_thang)
5460: objc_fatal ();
5461:
5462: class = make_node (code);
5463: TYPE_BINFO (class) = make_tree_vec (5);
5464:
5465: CLASS_NAME (class) = class_name;
5466: CLASS_SUPER_NAME (class) = super_name;
5467: CLASS_CLS_METHODS (class) = NULL_TREE;
5468:
5469: if (! is_class_name (class_name) && (decl = lookup_name (class_name)))
5470: {
5471: error ("`%s' redeclared as different kind of symbol",
5472: IDENTIFIER_POINTER (class_name));
5473: error_with_decl (decl, "previous declaration of `%s'");
5474: }
5475:
5476: if (code == CLASS_IMPLEMENTATION_TYPE)
5477: {
5478: {
5479: static tree implemented_classes = 0;
5480: tree chain = implemented_classes;
5481: for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain))
5482: if (TREE_VALUE (chain) == class_name)
5483: {
5484: error ("reimplementation of class `%s'",
5485: IDENTIFIER_POINTER (class_name));
5486: return error_mark_node;
5487: }
5488: implemented_classes = perm_tree_cons (NULLT, class_name,
5489: implemented_classes);
5490: }
5491:
5492: /* pre-build the following entities - for speed/convenience. */
5493: if (!self_id)
5494: self_id = get_identifier ("self");
5495: if (!ucmd_id)
5496: ucmd_id = get_identifier ("_cmd");
5497:
5498: if (!objc_super_template)
5499: objc_super_template = build_super_template ();
5500:
5501: method_slot = 0; /* reset for multiple classes per file */
5502:
5503: implementation_context = class;
5504:
5505: /* lookup the interface for this implementation. */
5506:
5507: if (!(implementation_template = lookup_interface (class_name)))
5508: {
5509: warning ("Cannot find interface declaration for `%s'",
5510: IDENTIFIER_POINTER (class_name));
5511: add_class (implementation_template = implementation_context);
5512: }
5513:
5514: /* if a super class has been specified in the implementation,
5515: insure it conforms to the one specified in the interface */
5516:
5517: if (super_name
5518: && (super_name != CLASS_SUPER_NAME (implementation_template)))
5519: {
5520: tree previous_name = CLASS_SUPER_NAME (implementation_template);
5521: char *name = previous_name ? IDENTIFIER_POINTER (previous_name) : "";
5522: error ("conflicting super class name `%s'",
5523: IDENTIFIER_POINTER (super_name));
5524: error ("previous declaration of `%s'", name);
5525: }
5526: else if (! super_name)
5527: {
5528: CLASS_SUPER_NAME (implementation_context)
5529: = CLASS_SUPER_NAME (implementation_template);
5530: }
5531: }
5532: else if (code == CLASS_INTERFACE_TYPE)
5533: {
5534: if (lookup_interface (class_name))
5535: warning ("duplicate interface declaration for class `%s'",
5536: IDENTIFIER_POINTER (class_name));
5537: else
5538: add_class (class);
5539:
5540: if (protocol_list)
5541: CLASS_PROTOCOL_LIST (class)
5542: = lookup_and_install_protocols (protocol_list);
5543: }
5544: else if (code == CATEGORY_INTERFACE_TYPE)
5545: {
5546: tree class_category_is_assoc_with;
5547:
5548: /* for a category, class_name is really the name of the class that
5549: the following set of methods will be associated with...we must
5550: find the interface so that can derive the objects template */
5551:
5552: if (!(class_category_is_assoc_with = lookup_interface (class_name)))
5553: {
5554: error ("Cannot find interface declaration for `%s'",
5555: IDENTIFIER_POINTER (class_name));
5556: exit (1);
5557: }
5558: else
5559: add_category (class_category_is_assoc_with, class);
5560:
5561: if (protocol_list)
5562: CLASS_PROTOCOL_LIST (class)
5563: = lookup_and_install_protocols (protocol_list);
5564: }
5565: else if (code == CATEGORY_IMPLEMENTATION_TYPE)
5566: {
5567: /* pre-build the following entities - for speed/convenience. */
5568: if (!self_id)
5569: self_id = get_identifier ("self");
5570: if (!ucmd_id)
5571: ucmd_id = get_identifier ("_cmd");
5572:
5573: if (!objc_super_template)
5574: objc_super_template = build_super_template ();
5575:
5576: method_slot = 0; /* reset for multiple classes per file */
5577:
5578: implementation_context = class;
5579:
5580: /* for a category, class_name is really the name of the class that
5581: the following set of methods will be associated with...we must
5582: find the interface so that can derive the objects template */
5583:
5584: if (!(implementation_template = lookup_interface (class_name)))
5585: {
5586: error ("Cannot find interface declaration for `%s'",
5587: IDENTIFIER_POINTER (class_name));
5588: exit (1);
5589: }
5590: }
5591: return class;
5592: }
5593:
5594: tree
5595: continue_class (class)
5596: tree class;
5597: {
5598: if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE
5599: || TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
5600: {
5601: struct imp_entry *imp_entry;
5602: tree ivar_context;
5603:
5604: /* check consistency of the instance variables. */
5605:
5606: if (CLASS_IVARS (class))
5607: check_ivars (implementation_template, class);
5608:
5609: /* code generation */
5610:
5611: ivar_context = build_private_template (implementation_template);
5612:
5613: if (!objc_class_template)
5614: build_class_template ();
5615:
5616: if (!(imp_entry = (struct imp_entry *) xmalloc (sizeof (struct imp_entry))))
5617: perror ("unable to allocate in objc-tree.c");
5618:
5619: imp_entry->next = imp_list;
5620: imp_entry->imp_context = class;
5621: imp_entry->imp_template = implementation_template;
5622:
5623: synth_forward_declarations ();
5624: imp_entry->class_decl = UOBJC_CLASS_decl;
5625: imp_entry->meta_decl = UOBJC_METACLASS_decl;
5626:
5627: /* append to front and increment count */
5628: imp_list = imp_entry;
5629: if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
5630: imp_count++;
5631: else
5632: cat_count++;
5633:
5634: return ivar_context;
5635: }
5636: else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
5637: {
5638: tree record = xref_tag (RECORD_TYPE, CLASS_NAME (class));
5639:
5640: if (!TYPE_FIELDS (record))
5641: {
5642: finish_struct (record, build_ivar_chain (class, 0));
5643: CLASS_STATIC_TEMPLATE (class) = record;
5644:
5645: /* mark this record as a class template - for static typing */
5646: TREE_STATIC_TEMPLATE (record) = 1;
5647: }
5648: return NULLT;
5649: }
5650: else
5651: return error_mark_node;
5652: }
5653:
5654: /* This is called once we see the "@end" in an interface/implementation. */
5655:
5656: void
5657: finish_class (class)
5658: tree class;
5659: {
5660: if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
5661: {
5662: /* all code generation is done in finish_objc */
5663:
5664: if (implementation_template != implementation_context)
5665: {
5666: /* ensure that all method listed in the interface contain bodies! */
5667: check_methods (CLASS_CLS_METHODS (implementation_template),
5668: CLASS_CLS_METHODS (implementation_context), '+');
5669: check_methods (CLASS_NST_METHODS (implementation_template),
5670: CLASS_NST_METHODS (implementation_context), '-');
5671:
5672: if (CLASS_PROTOCOL_LIST (implementation_template))
5673: check_protocols (CLASS_PROTOCOL_LIST (implementation_template),
5674: "class",
5675: IDENTIFIER_POINTER (CLASS_NAME (implementation_context)));
5676: }
5677: }
5678: else if (TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
5679: {
5680: tree category = CLASS_CATEGORY_LIST (implementation_template);
5681:
5682: /* find the category interface from the class it is associated with */
5683: while (category)
5684: {
5685: if (CLASS_SUPER_NAME (class) == CLASS_SUPER_NAME (category))
5686: break;
5687: category = CLASS_CATEGORY_LIST (category);
5688: }
5689:
5690: if (category)
5691: {
5692: /* ensure that all method listed in the interface contain bodies! */
5693: check_methods (CLASS_CLS_METHODS (category),
5694: CLASS_CLS_METHODS (implementation_context), '+');
5695: check_methods (CLASS_NST_METHODS (category),
5696: CLASS_NST_METHODS (implementation_context), '-');
5697:
5698: if (CLASS_PROTOCOL_LIST (category))
5699: check_protocols (CLASS_PROTOCOL_LIST (category),
5700: "category",
5701: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context)));
5702: }
5703: }
5704: else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
5705: {
5706: tree decl_specs;
5707: char *class_name = IDENTIFIER_POINTER (CLASS_NAME (class));
5708: char *string = (char *) alloca (strlen (class_name) + 3);
5709:
5710: /* extern struct objc_object *_<my_name>; */
5711:
5712: sprintf (string, "_%s", class_name);
5713:
5714: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_EXTERN]);
5715: decl_specs = tree_cons (NULLT, objc_object_reference, decl_specs);
5716: define_decl (build1 (INDIRECT_REF, NULLT, get_identifier (string)),
5717: decl_specs);
5718: }
5719: }
5720:
5721: static tree
5722: add_protocol (protocol)
5723: tree protocol;
5724: {
5725: /* put protocol on list in reverse order */
5726: TREE_CHAIN (protocol) = protocol_chain;
5727: protocol_chain = protocol;
5728: return protocol_chain;
5729: }
5730:
5731: static tree
5732: lookup_protocol (ident)
5733: tree ident;
5734: {
5735: tree chain;
5736:
5737: for (chain = protocol_chain; chain; chain = TREE_CHAIN (chain))
5738: {
5739: if (ident == PROTOCOL_NAME (chain))
5740: return chain;
5741: }
5742: return NULLT;
5743: }
5744:
5745: tree
5746: start_protocol (code, name, list)
5747: enum tree_code code;
5748: tree name;
5749: tree list;
5750: {
5751: tree protocol;
5752:
5753: if (!doing_objc_thang)
5754: objc_fatal ();
5755:
5756: /* This is as good a place as any. Need to invoke push_tag_toplevel. */
5757: if (!objc_protocol_template)
5758: objc_protocol_template = build_protocol_template ();
5759:
5760: protocol = make_node (code);
5761: TYPE_BINFO (protocol) = make_tree_vec (2);
5762:
5763: PROTOCOL_NAME (protocol) = name;
5764: PROTOCOL_LIST (protocol) = list;
5765:
5766: lookup_and_install_protocols (list);
5767:
5768: if (lookup_protocol (name))
5769: warning ("duplicate declaration for protocol `%s'",
5770: IDENTIFIER_POINTER (name));
5771: else
5772: add_protocol (protocol);
5773:
5774: PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
5775:
5776: return protocol;
5777: }
5778:
5779: void
5780: finish_protocol (protocol)
5781: tree protocol;
5782: {
5783: }
5784:
5785:
5786: /* "Encode" a data type into a string, which grows in util_obstack.
5787: ??? What is the FORMAT? Someone please document this! */
5788:
5789: static void
5790: encode_type_qualifiers (declspecs)
5791: tree declspecs;
5792: {
5793: tree spec;
5794:
5795: for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
5796: {
5797: if (ridpointers[RID_CONST] == TREE_VALUE (spec))
5798: obstack_1grow (&util_obstack, 'r');
5799: else if (ridpointers[RID_IN] == TREE_VALUE (spec))
5800: obstack_1grow (&util_obstack, 'n');
5801: else if (ridpointers[RID_INOUT] == TREE_VALUE (spec))
5802: obstack_1grow (&util_obstack, 'N');
5803: else if (ridpointers[RID_OUT] == TREE_VALUE (spec))
5804: obstack_1grow (&util_obstack, 'o');
5805: else if (ridpointers[RID_BYCOPY] == TREE_VALUE (spec))
5806: obstack_1grow (&util_obstack, 'O');
5807: else if (ridpointers[RID_ONEWAY] == TREE_VALUE (spec))
5808: obstack_1grow (&util_obstack, 'V');
5809: }
5810: }
5811:
5812: /* Encode a pointer type. */
5813:
5814: static void
5815: encode_pointer (type, curtype, format)
5816: tree type;
5817: int curtype;
5818: int format;
5819: {
5820: tree pointer_to = TREE_TYPE (type);
5821:
5822: if (TREE_CODE (pointer_to) == RECORD_TYPE)
5823: {
5824: if (TYPE_NAME (pointer_to)
5825: && TREE_CODE (TYPE_NAME (pointer_to)) == IDENTIFIER_NODE)
5826: {
5827: char *name = IDENTIFIER_POINTER (TYPE_NAME (pointer_to));
5828:
5829: if (strcmp (name, TAG_OBJECT) == 0) /* '@' */
5830: {
5831: obstack_1grow (&util_obstack, '@');
5832: return;
5833: }
5834: else if (TREE_STATIC_TEMPLATE (pointer_to))
5835: {
5836: if (generating_instance_variables)
5837: {
5838: obstack_1grow (&util_obstack, '@');
5839: obstack_1grow (&util_obstack, '"');
5840: obstack_grow (&util_obstack, name, strlen (name));
5841: obstack_1grow (&util_obstack, '"');
5842: return;
5843: }
5844: else
5845: {
5846: obstack_1grow (&util_obstack, '@');
5847: return;
5848: }
5849: }
5850: else if (strcmp (name, TAG_CLASS) == 0) /* '#' */
5851: {
5852: obstack_1grow (&util_obstack, '#');
5853: return;
5854: }
5855: #ifndef OBJC_INT_SELECTORS
5856: else if (strcmp (name, TAG_SELECTOR) == 0) /* ':' */
5857: {
5858: obstack_1grow (&util_obstack, ':');
5859: return;
5860: }
5861: #endif /* OBJC_INT_SELECTORS */
5862: }
5863: }
5864: else if (TREE_CODE (pointer_to) == INTEGER_TYPE
5865: && TYPE_MODE (pointer_to) == QImode)
5866: {
5867: obstack_1grow (&util_obstack, '*');
5868: return;
5869: }
5870:
5871: /* we have a type that does not get special treatment... */
5872:
5873: /* NeXT extension */
5874: obstack_1grow (&util_obstack, '^');
5875: encode_type (pointer_to, curtype, format);
5876: }
5877:
5878: static void
5879: encode_array (type, curtype, format)
5880: tree type;
5881: int curtype;
5882: int format;
5883: {
5884: tree an_int_cst = TYPE_SIZE (type);
5885: tree array_of = TREE_TYPE (type);
5886: char buffer[40];
5887:
5888: /* An incomplete array is treated like a pointer. */
5889: if (an_int_cst == NULL)
5890: {
5891: /* split for obvious reasons. North-Keys 30 Mar 1991 */
5892: encode_pointer (type, curtype, format);
5893: return;
5894: }
5895:
5896: sprintf (buffer, "[%d",
5897: (TREE_INT_CST_LOW (an_int_cst)
5898: / TREE_INT_CST_LOW (TYPE_SIZE (array_of))));
5899: obstack_grow (&util_obstack, buffer, strlen (buffer));
5900: encode_type (array_of, curtype, format);
5901: obstack_1grow (&util_obstack, ']');
5902: return;
5903: }
5904:
5905: static void
5906: encode_aggregate (type, curtype, format)
5907: tree type;
5908: int curtype;
5909: int format;
5910: {
5911: enum tree_code code = TREE_CODE (type);
5912:
5913: switch (code)
5914: {
5915: case RECORD_TYPE:
5916: {
5917: if (obstack_object_size (&util_obstack) > 0
5918: && *(obstack_next_free (&util_obstack) - 1) == '^')
5919: {
5920: tree name = TYPE_NAME (type);
5921:
5922: /* we have a reference - this is a NeXT extension */
5923:
5924: if (obstack_object_size (&util_obstack) - curtype == 1
5925: && format == OBJC_ENCODE_INLINE_DEFS)
5926: {
5927: /* output format of struct for first level only! */
5928:
5929: tree fields = TYPE_FIELDS (type);
5930:
5931: if (name && TREE_CODE (name) == IDENTIFIER_NODE)
5932: {
5933: obstack_1grow (&util_obstack, '{');
5934: obstack_grow (&util_obstack,
5935: IDENTIFIER_POINTER (name),
5936: strlen (IDENTIFIER_POINTER (name)));
5937: obstack_1grow (&util_obstack, '=');
5938: }
5939: else
5940: obstack_grow (&util_obstack, "{?=", 3);
5941:
5942: for ( ; fields; fields = TREE_CHAIN (fields))
5943: encode_field_decl (fields, curtype, format);
5944: obstack_1grow (&util_obstack, '}');
5945: }
5946: else if (name && TREE_CODE (name) == IDENTIFIER_NODE)
5947: {
5948: obstack_1grow (&util_obstack, '{');
5949: obstack_grow (&util_obstack,
5950: IDENTIFIER_POINTER (name),
5951: strlen (IDENTIFIER_POINTER (name)));
5952: obstack_1grow (&util_obstack, '}');
5953: }
5954: else /* we have an untagged structure or a typedef */
5955: obstack_grow (&util_obstack, "{?}", 3);
5956: }
5957: else
5958: {
5959: tree name = TYPE_NAME (type);
5960: tree fields = TYPE_FIELDS (type);
5961:
5962: if (format == OBJC_ENCODE_INLINE_DEFS
5963: || generating_instance_variables)
5964: {
5965: obstack_1grow (&util_obstack, '{');
5966: if (name && TREE_CODE (name) == IDENTIFIER_NODE)
5967: obstack_grow (&util_obstack,
5968: IDENTIFIER_POINTER (name),
5969: strlen (IDENTIFIER_POINTER (name)));
5970: else
5971: obstack_1grow (&util_obstack, '?');
5972:
5973: obstack_1grow (&util_obstack, '=');
5974:
5975: for (; fields; fields = TREE_CHAIN (fields))
5976: {
5977: if (generating_instance_variables)
5978: {
5979: tree fname = DECL_NAME (fields);
5980:
5981: obstack_1grow (&util_obstack, '"');
5982: if (fname && TREE_CODE (fname) == IDENTIFIER_NODE)
5983: {
5984: obstack_grow (&util_obstack,
5985: IDENTIFIER_POINTER (fname),
5986: strlen (IDENTIFIER_POINTER (fname)));
5987: }
5988: obstack_1grow (&util_obstack, '"');
5989: }
5990: encode_field_decl (fields, curtype, format);
5991: }
5992: obstack_1grow (&util_obstack, '}');
5993: }
5994: else
5995: {
5996: obstack_1grow (&util_obstack, '{');
5997: if (name && TREE_CODE (name) == IDENTIFIER_NODE)
5998: obstack_grow (&util_obstack,
5999: IDENTIFIER_POINTER (name),
6000: strlen (IDENTIFIER_POINTER (name)));
6001: else /* we have an untagged structure or a typedef */
6002: obstack_1grow (&util_obstack, '?');
6003: obstack_1grow (&util_obstack, '}');
6004: }
6005: }
6006: break;
6007: }
6008: case UNION_TYPE:
6009: {
6010: if (*obstack_next_free (&util_obstack) == '^'
6011: || format != OBJC_ENCODE_INLINE_DEFS)
6012: {
6013: /* we have a reference - this is a NeXT extension--
6014: or we don't want the details. */
6015: if (TYPE_NAME (type)
6016: && TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6017: {
6018: obstack_1grow (&util_obstack, '(');
6019: obstack_grow (&util_obstack,
6020: IDENTIFIER_POINTER (TYPE_NAME (type)),
6021: strlen (IDENTIFIER_POINTER (TYPE_NAME (type))));
6022: obstack_1grow (&util_obstack, ')');
6023: }
6024: else /* we have an untagged structure or a typedef */
6025: obstack_grow (&util_obstack, "(?)", 3);
6026: }
6027: else
6028: {
6029: tree fields = TYPE_FIELDS (type);
6030: obstack_1grow (&util_obstack, '(');
6031: for ( ; fields; fields = TREE_CHAIN (fields))
6032: encode_field_decl (fields, curtype, format);
6033: obstack_1grow (&util_obstack, ')');
6034: }
6035: break;
6036: }
6037:
6038: case ENUMERAL_TYPE:
6039: obstack_1grow (&util_obstack, 'i');
6040: break;
6041: }
6042: }
6043:
6044: /* Support bitfields, the current version of Objective-C does not support
6045: them. the string will consist of one or more "b:n"'s where n is an
6046: integer describing the width of the bitfield. Currently, classes in
6047: the kit implement a method "-(char *)describeBitfieldStruct:" that
6048: simulates this...if they do not implement this method, the archiver
6049: assumes the bitfield is 16 bits wide (padded if necessary) and packed
6050: according to the GNU compiler. After looking at the "kit", it appears
6051: that all classes currently rely on this default behavior, rather than
6052: hand generating this string (which is tedious). */
6053:
6054: static void
6055: encode_bitfield (width, format)
6056: int width;
6057: int format;
6058: {
6059: char buffer[40];
6060: sprintf (buffer, "b%d", width);
6061: obstack_grow (&util_obstack, buffer, strlen (buffer));
6062: }
6063:
6064: /* FORMAT will be OBJC_ENCODE_INLINE_DEFS or OBJC_ENCODE_DONT_INLINE_DEFS. */
6065:
6066: static void
6067: encode_type (type, curtype, format)
6068: tree type;
6069: int curtype;
6070: int format;
6071: {
6072: enum tree_code code = TREE_CODE (type);
6073:
6074: if (code == INTEGER_TYPE)
6075: {
6076: if (TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) == 0
6077: && TREE_INT_CST_HIGH (TYPE_MIN_VALUE (type)) == 0)
6078: {
6079: /* unsigned integer types */
6080:
6081: if (TYPE_MODE (type) == QImode) /* 'C' */
6082: obstack_1grow (&util_obstack, 'C');
6083: else if (TYPE_MODE (type) == HImode) /* 'S' */
6084: obstack_1grow (&util_obstack, 'S');
6085: else if (TYPE_MODE (type) == SImode)
6086: {
6087: if (type == long_unsigned_type_node)
6088: obstack_1grow (&util_obstack, 'L'); /* 'L' */
6089: else
6090: obstack_1grow (&util_obstack, 'I'); /* 'I' */
6091: }
6092: else if (TYPE_MODE (type) == DImode) /* 'Q' */
6093: obstack_1grow (&util_obstack, 'Q');
6094: }
6095: else /* signed integer types */
6096: {
6097: if (TYPE_MODE (type) == QImode) /* 'c' */
6098: obstack_1grow (&util_obstack, 'c');
6099: else if (TYPE_MODE (type) == HImode) /* 's' */
6100: obstack_1grow (&util_obstack, 's');
6101: else if (TYPE_MODE (type) == SImode) /* 'i' */
6102: {
6103: if (type == long_integer_type_node)
6104: obstack_1grow (&util_obstack, 'l'); /* 'l' */
6105: else
6106: obstack_1grow (&util_obstack, 'i'); /* 'i' */
6107: }
6108: else if (TYPE_MODE (type) == DImode) /* 'q' */
6109: obstack_1grow (&util_obstack, 'q');
6110: }
6111: }
6112: else if (code == REAL_TYPE)
6113: {
6114: /* floating point types */
6115:
6116: if (TYPE_MODE (type) == SFmode) /* 'f' */
6117: obstack_1grow (&util_obstack, 'f');
6118: else if (TYPE_MODE (type) == DFmode
6119: || TYPE_MODE (type) == TFmode) /* 'd' */
6120: obstack_1grow (&util_obstack, 'd');
6121: }
6122:
6123: else if (code == VOID_TYPE) /* 'v' */
6124: obstack_1grow (&util_obstack, 'v');
6125:
6126: else if (code == ARRAY_TYPE)
6127: encode_array (type, curtype, format);
6128:
6129: else if (code == POINTER_TYPE)
6130: encode_pointer (type, curtype, format);
6131:
6132: else if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
6133: encode_aggregate (type, curtype, format);
6134:
6135: else if (code == FUNCTION_TYPE) /* '?' */
6136: obstack_1grow (&util_obstack, '?');
6137: }
6138:
6139: static void
6140: encode_field_decl (field_decl, curtype, format)
6141: tree field_decl;
6142: int curtype;
6143: int format;
6144: {
6145: tree type;
6146:
6147: /* If this field is obviously a bitfield, or is a bitfield that has been
6148: clobbered to look like a ordinary integer mode, go ahead and generate
6149: the bitfield typing information. */
6150: type = TREE_TYPE (field_decl);
6151: if (DECL_BIT_FIELD (field_decl))
6152: encode_bitfield (DECL_FIELD_SIZE (field_decl), format);
6153: else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
6154: && DECL_FIELD_SIZE (field_decl)
6155: && TYPE_MODE (type) > DECL_MODE (field_decl))
6156: encode_bitfield (DECL_FIELD_SIZE (field_decl), format);
6157: else
6158: encode_type (TREE_TYPE (field_decl), curtype, format);
6159: }
6160:
6161: static tree
6162: expr_last (complex_expr)
6163: tree complex_expr;
6164: {
6165: tree next;
6166:
6167: if (complex_expr)
6168: while ((next = TREE_OPERAND (complex_expr, 0)))
6169: complex_expr = next;
6170: return complex_expr;
6171: }
6172:
6173: /* The selector of the current method,
6174: or NULL if we aren't compiling a method. */
6175:
6176: tree
6177: maybe_objc_method_name (decl)
6178: tree decl;
6179: {
6180: if (method_context)
6181: return METHOD_SEL_NAME (method_context);
6182: else
6183: return 0;
6184: }
6185:
6186: /* Transform a method definition into a function definition as follows:
6187: - synthesize the first two arguments, "self" and "_cmd". */
6188:
6189: void
6190: start_method_def (method)
6191: tree method;
6192: {
6193: tree decl_specs;
6194:
6195: /* Required to implement _msgSuper. */
6196: method_context = method;
6197: UOBJC_SUPER_decl = NULLT;
6198:
6199: pushlevel (0); /* Must be called BEFORE start_function. */
6200:
6201: /* Generate prototype declarations for arguments..."new-style". */
6202:
6203: if (TREE_CODE (method_context) == INSTANCE_METHOD_DECL)
6204: decl_specs = build_tree_list (NULLT, uprivate_record);
6205: else
6206: /* really a `struct objc_class *'...however we allow people to
6207: assign to self...which changes its type midstream. */
6208: decl_specs = build_tree_list (NULLT, objc_object_reference);
6209:
6210: push_parm_decl (build_tree_list (decl_specs,
6211: build1 (INDIRECT_REF, NULLT, self_id)));
6212:
6213: #ifdef OBJC_INT_SELECTORS
6214: decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_UNSIGNED]);
6215: decl_specs = tree_cons (NULLT, ridpointers[(int) RID_INT], decl_specs);
6216: push_parm_decl (build_tree_list (decl_specs, ucmd_id));
6217: #else /* not OBJC_INT_SELECTORS */
6218: decl_specs = build_tree_list (NULLT,
6219: xref_tag (RECORD_TYPE,
6220: get_identifier (TAG_SELECTOR)));
6221: push_parm_decl (build_tree_list (decl_specs,
6222: build1 (INDIRECT_REF, NULLT, ucmd_id)));
6223: #endif /* not OBJC_INT_SELECTORS */
6224:
6225: /* generate argument declarations if a keyword_decl */
6226: if (METHOD_SEL_ARGS (method))
6227: {
6228: tree arglist = METHOD_SEL_ARGS (method);
6229: do
6230: {
6231: tree arg_spec = TREE_PURPOSE (TREE_TYPE (arglist));
6232: tree arg_decl = TREE_VALUE (TREE_TYPE (arglist));
6233:
6234: if (arg_decl)
6235: {
6236: tree last_expr = expr_last (arg_decl);
6237:
6238: /* unite the abstract decl with its name */
6239: TREE_OPERAND (last_expr, 0) = KEYWORD_ARG_NAME (arglist);
6240: push_parm_decl (build_tree_list (arg_spec, arg_decl));
6241: /* unhook...restore the abstract declarator */
6242: TREE_OPERAND (last_expr, 0) = NULLT;
6243: }
6244: else
6245: push_parm_decl (build_tree_list (arg_spec,
6246: KEYWORD_ARG_NAME (arglist)));
6247:
6248: arglist = TREE_CHAIN (arglist);
6249: }
6250: while (arglist);
6251: }
6252:
6253: if (METHOD_ADD_ARGS (method) > (tree)1)
6254: {
6255: /* we have a variable length selector - in "prototype" format */
6256: tree akey = TREE_PURPOSE (METHOD_ADD_ARGS (method));
6257: while (akey)
6258: {
6259: /* This must be done prior to calling pushdecl. pushdecl is
6260: going to change our chain on us. */
6261: tree nextkey = TREE_CHAIN (akey);
6262: pushdecl (akey);
6263: akey = nextkey;
6264: }
6265: }
6266: }
6267:
6268: static void
6269: warn_with_method (message, mtype, method)
6270: char *message;
6271: char mtype;
6272: tree method;
6273: {
6274: if (count_error (1) == 0)
6275: return;
6276:
6277: report_error_function (DECL_SOURCE_FILE (method));
6278:
6279: fprintf (stderr, "%s:%d: warning: ",
6280: DECL_SOURCE_FILE (method), DECL_SOURCE_LINE (method));
6281: bzero (errbuf, BUFSIZE);
6282: fprintf (stderr, "%s `%c%s'\n",
6283: message, mtype, gen_method_decl (method, errbuf));
6284: }
6285:
6286: /* return 1 if `method' is consistent with `proto' */
6287:
6288: static int
6289: comp_method_with_proto (method, proto)
6290: tree method, proto;
6291: {
6292: static tree function_type = 0;
6293:
6294: /* create a function_type node once */
6295: if (!function_type)
6296: {
6297: struct obstack *ambient_obstack = current_obstack;
6298:
6299: current_obstack = &permanent_obstack;
6300: function_type = make_node (FUNCTION_TYPE);
6301: current_obstack = ambient_obstack;
6302: }
6303:
6304: /* Install argument types - normally set by build_function_type. */
6305: TYPE_ARG_TYPES (function_type) = get_arg_type_list (proto, METHOD_DEF, 0);
6306:
6307: /* install return type */
6308: TREE_TYPE (function_type) = groktypename (TREE_TYPE (proto));
6309:
6310: return comptypes (TREE_TYPE (METHOD_DEFINITION (method)), function_type);
6311: }
6312:
6313: /* return 1 if `proto1' is consistent with `proto2' */
6314:
6315: static int
6316: comp_proto_with_proto (proto1, proto2)
6317: tree proto1, proto2;
6318: {
6319: static tree function_type1 = 0, function_type2 = 0;
6320:
6321: /* create a couple function_type node's once */
6322: if (!function_type1)
6323: {
6324: struct obstack *ambient_obstack = current_obstack;
6325:
6326: current_obstack = &permanent_obstack;
6327: function_type1 = make_node (FUNCTION_TYPE);
6328: function_type2 = make_node (FUNCTION_TYPE);
6329: current_obstack = ambient_obstack;
6330: }
6331:
6332: /* Install argument types - normally set by build_function_type. */
6333: TYPE_ARG_TYPES (function_type1) = get_arg_type_list (proto1, METHOD_REF, 0);
6334: TYPE_ARG_TYPES (function_type2) = get_arg_type_list (proto2, METHOD_REF, 0);
6335:
6336: /* install return type */
6337: TREE_TYPE (function_type1) = groktypename (TREE_TYPE (proto1));
6338: TREE_TYPE (function_type2) = groktypename (TREE_TYPE (proto2));
6339:
6340: return comptypes (function_type1, function_type2);
6341: }
6342:
6343: /* - generate an identifier for the function. the format is "_n_cls",
6344: where 1 <= n <= nMethods, and cls is the name the implementation we
6345: are processing.
6346: - install the return type from the method declaration.
6347: - if we have a prototype, check for type consistency. */
6348:
6349: static void
6350: really_start_method (method, parmlist)
6351: tree method, parmlist;
6352: {
6353: tree sc_spec, ret_spec, ret_decl, decl_specs;
6354: tree method_decl, method_id;
6355: char *buf, *sel_name, *class_name, *cat_name;
6356:
6357: /* synth the storage class & assemble the return type */
6358: sc_spec = tree_cons (NULLT, ridpointers[(int) RID_STATIC], NULLT);
6359: ret_spec = TREE_PURPOSE (TREE_TYPE (method));
6360: decl_specs = chainon (sc_spec, ret_spec);
6361:
6362: sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
6363: class_name = IDENTIFIER_POINTER (CLASS_NAME (implementation_context));
6364: cat_name = ((TREE_CODE (implementation_context)
6365: == CLASS_IMPLEMENTATION_TYPE)
6366: ? NULL
6367: : IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context)));
6368: method_slot++;
6369: /* Make sure this is big enough for any plausible method label. */
6370: buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name)
6371: + (cat_name ? strlen (cat_name) : 0));
6372:
6373: OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL,
6374: class_name, cat_name, sel_name, method_slot);
6375:
6376: method_id = get_identifier (buf);
6377:
6378: method_decl = build_nt (CALL_EXPR, method_id, parmlist, NULLT);
6379:
6380: /* check the declarator portion of the return type for the method */
6381: if ((ret_decl = TREE_VALUE (TREE_TYPE (method))))
6382: {
6383: /* unite the complex decl (specified in the abstract decl) with the
6384: function decl just synthesized..(int *), (int (*)()), (int (*)[]). */
6385: tree save_expr = expr_last (ret_decl);
6386:
6387: TREE_OPERAND (save_expr, 0) = method_decl;
6388: method_decl = ret_decl;
6389: /* fool the parser into thinking it is starting a function */
6390: start_function (decl_specs, method_decl, 0);
6391: /* unhook...this has the effect of restoring the abstract declarator */
6392: TREE_OPERAND (save_expr, 0) = NULLT;
6393: }
6394: else
6395: {
6396: TREE_VALUE (TREE_TYPE (method)) = method_decl;
6397: /* fool the parser into thinking it is starting a function */
6398: start_function (decl_specs, method_decl, 0);
6399: /* unhook...this has the effect of restoring the abstract declarator */
6400: TREE_VALUE (TREE_TYPE (method)) = NULLT;
6401: }
6402:
6403: METHOD_DEFINITION (method) = current_function_decl;
6404:
6405: /* Check consistency...start_function, pushdecl, duplicate_decls. */
6406:
6407: if (implementation_template != implementation_context)
6408: {
6409: tree proto;
6410:
6411: if (TREE_CODE (method) == INSTANCE_METHOD_DECL)
6412: proto = lookup_instance_method_static (implementation_template,
6413: METHOD_SEL_NAME (method));
6414: else
6415: proto = lookup_class_method_static (implementation_template,
6416: METHOD_SEL_NAME (method));
6417:
6418: if (proto && ! comp_method_with_proto (method, proto))
6419: {
6420: char type = (TREE_CODE (method) == INSTANCE_METHOD_DECL ? '-' : '+');
6421:
6422: warn_with_method ("conflicting types for", type, method);
6423: warn_with_method ("previous declaration of", type, proto);
6424: }
6425: }
6426: }
6427:
6428: /* The following routine is always called...this "architecture" is to
6429: accommodate "old-style" variable length selectors.
6430:
6431: - a:a b:b // prototype ; id c; id d; // old-style. */
6432:
6433: void
6434: continue_method_def ()
6435: {
6436: tree parmlist;
6437:
6438: if (METHOD_ADD_ARGS (method_context) == (tree)1)
6439: /* We have a `, ...' immediately following the selector. */
6440: parmlist = get_parm_info (0);
6441: else
6442: parmlist = get_parm_info (1); /* place a `void_at_end' */
6443:
6444: /* Set self_decl from the first argument...this global is used by
6445: build_ivar_reference calling build_indirect_ref. */
6446: self_decl = TREE_PURPOSE (parmlist);
6447:
6448: poplevel (0, 0, 0); /* must be called BEFORE start_function. */
6449:
6450: really_start_method (method_context, parmlist);
6451:
6452: store_parm_decls (); /* must be called AFTER start_function. */
6453: }
6454:
6455: /* Called by the parser, from the `pushlevel' production. */
6456:
6457: void
6458: add_objc_decls ()
6459: {
6460: if (!UOBJC_SUPER_decl)
6461: {
6462: UOBJC_SUPER_decl = start_decl (get_identifier (UTAG_SUPER),
6463: build_tree_list (NULLT,
6464: objc_super_template),
6465: 0);
6466:
6467: finish_decl (UOBJC_SUPER_decl, NULLT, NULLT);
6468:
6469: /* this prevents `unused variable' warnings when compiling with -Wall. */
6470: DECL_IN_SYSTEM_HEADER (UOBJC_SUPER_decl) = 1;
6471: }
6472: }
6473:
6474: /* _n_Method (id self, SEL sel, ...)
6475: {
6476: struct objc_super _S;
6477: _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
6478: } */
6479:
6480: tree
6481: get_super_receiver ()
6482: {
6483: if (method_context)
6484: {
6485: tree super_expr, super_expr_list;
6486:
6487: /* set receiver to self */
6488: super_expr = build_component_ref (UOBJC_SUPER_decl, self_id);
6489: super_expr = build_modify_expr (super_expr, NOP_EXPR, self_decl);
6490: super_expr_list = build_tree_list (NULLT, super_expr);
6491:
6492: /* set class to begin searching */
6493: super_expr = build_component_ref (UOBJC_SUPER_decl,
6494: get_identifier ("class"));
6495:
6496: if (TREE_CODE (implementation_context) == CLASS_IMPLEMENTATION_TYPE)
6497: {
6498: /* [_cls, __cls]Super are "pre-built" in
6499: synth_forward_declarations. */
6500:
6501: super_expr = build_modify_expr (super_expr, NOP_EXPR,
6502: ((TREE_CODE (method_context)
6503: == INSTANCE_METHOD_DECL)
6504: ? ucls_super_ref
6505: : uucls_super_ref));
6506: }
6507: else /* we have a category... */
6508: {
6509: tree super_name = CLASS_SUPER_NAME (implementation_template);
6510: tree super_class;
6511:
6512: if (!super_name) /* Barf if super used in a category of Object. */
6513: {
6514: error ("no super class declared in interface for `%s'",
6515: IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
6516: return error_mark_node;
6517: }
6518:
6519: if (flag_next_runtime)
6520: {
6521: super_class = get_class_reference (super_name);
6522: if (TREE_CODE (method_context) == CLASS_METHOD_DECL)
6523: super_class
6524: = build_component_ref (build_indirect_ref (super_class, "->"),
6525: get_identifier ("isa"));
6526: }
6527: else
6528: {
6529: add_class_reference (super_name);
6530: super_class = (TREE_CODE (method_context) == INSTANCE_METHOD_DECL
6531: ? objc_get_class_decl : objc_get_meta_class_decl);
6532: assemble_external (super_class);
6533: super_class
6534: = build_function_call
6535: (super_class,
6536: build_tree_list (NULLT,
6537: my_build_string (IDENTIFIER_LENGTH (super_name) + 1,
6538: IDENTIFIER_POINTER (super_name))));
6539: }
6540:
6541: /* cast! */
6542: TREE_TYPE (super_class) = TREE_TYPE (ucls_super_ref);
6543: super_expr = build_modify_expr (super_expr, NOP_EXPR, super_class);
6544: }
6545: chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr));
6546:
6547: super_expr = build_unary_op (ADDR_EXPR, UOBJC_SUPER_decl, 0);
6548: chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr));
6549:
6550: return build_compound_expr (super_expr_list);
6551: }
6552: else
6553: {
6554: error ("[super ...] must appear in a method context");
6555: return error_mark_node;
6556: }
6557: }
6558:
6559: static tree
6560: encode_method_def (func_decl)
6561: tree func_decl;
6562: {
6563: tree parms;
6564: int stack_size;
6565: int max_parm_end = 0;
6566: char buffer[40];
6567: tree result;
6568:
6569: /* return type */
6570: encode_type (TREE_TYPE (TREE_TYPE (func_decl)),
6571: obstack_object_size (&util_obstack),
6572: OBJC_ENCODE_INLINE_DEFS);
6573: /* stack size */
6574: for (parms = DECL_ARGUMENTS (func_decl); parms;
6575: parms = TREE_CHAIN (parms))
6576: {
6577: int parm_end = (forwarding_offset (parms)
6578: + (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (parms)))
6579: / BITS_PER_UNIT));
6580:
6581: if (parm_end > max_parm_end)
6582: max_parm_end = parm_end;
6583: }
6584:
6585: stack_size = max_parm_end - OBJC_FORWARDING_MIN_OFFSET;
6586:
6587: sprintf (buffer, "%d", stack_size);
6588: obstack_grow (&util_obstack, buffer, strlen (buffer));
6589:
6590: /* argument types */
6591: for (parms = DECL_ARGUMENTS (func_decl); parms;
6592: parms = TREE_CHAIN (parms))
6593: {
6594: /* type */
6595: encode_type (TREE_TYPE (parms),
6596: obstack_object_size (&util_obstack),
6597: OBJC_ENCODE_INLINE_DEFS);
6598:
6599: /* compute offset */
6600: sprintf (buffer, "%d", forwarding_offset (parms));
6601: obstack_grow (&util_obstack, buffer, strlen (buffer));
6602: }
6603:
6604: obstack_1grow (&util_obstack, 0); /* null terminate string */
6605: result = get_identifier (obstack_finish (&util_obstack));
6606: obstack_free (&util_obstack, util_firstobj);
6607: return result;
6608: }
6609:
6610: void
6611: finish_method_def ()
6612: {
6613: METHOD_ENCODING (method_context) = encode_method_def (current_function_decl);
6614:
6615: finish_function (0);
6616:
6617: /* this must be done AFTER finish_function, since the optimizer may
6618: find "may be used before set" errors. */
6619: method_context = NULLT; /* required to implement _msgSuper. */
6620: }
6621:
6622: int
6623: lang_report_error_function (decl)
6624: tree decl;
6625: {
6626: if (method_context)
6627: {
6628: fprintf (stderr, "In method `%s'\n",
6629: IDENTIFIER_POINTER (METHOD_SEL_NAME (method_context)));
6630: return 1;
6631: }
6632: else
6633: return 0;
6634: }
6635:
6636: static int
6637: is_complex_decl (type)
6638: tree type;
6639: {
6640: return (TREE_CODE (type) == ARRAY_TYPE
6641: || TREE_CODE (type) == FUNCTION_TYPE
6642: || (TREE_CODE (type) == POINTER_TYPE && ! IS_ID (type)));
6643: }
6644:
6645:
6646: /* Code to convert a decl node into text for a declaration in C. */
6647:
6648: static char tmpbuf[256];
6649:
6650: static void
6651: adorn_decl (decl, str)
6652: tree decl;
6653: char *str;
6654: {
6655: enum tree_code code = TREE_CODE (decl);
6656:
6657: if (code == ARRAY_REF)
6658: {
6659: tree an_int_cst = TREE_OPERAND (decl, 1);
6660:
6661: if (an_int_cst && TREE_CODE (an_int_cst) == INTEGER_CST)
6662: sprintf (str + strlen (str), "[%d]", TREE_INT_CST_LOW (an_int_cst));
6663: else
6664: strcat (str, "[]");
6665: }
6666: else if (code == ARRAY_TYPE)
6667: {
6668: tree an_int_cst = TYPE_SIZE (decl);
6669: tree array_of = TREE_TYPE (decl);
6670:
6671: if (an_int_cst && TREE_CODE (an_int_cst) == INTEGER_TYPE)
6672: sprintf (str + strlen (str), "[%d]",
6673: (TREE_INT_CST_LOW (an_int_cst)
6674: / TREE_INT_CST_LOW (TYPE_SIZE (array_of))));
6675: else
6676: strcat (str, "[]");
6677: }
6678: else if (code == CALL_EXPR)
6679: {
6680: tree chain = TREE_PURPOSE (TREE_OPERAND (decl, 1));
6681:
6682: strcat (str, "(");
6683: while (chain)
6684: {
6685: gen_declaration (chain, str);
6686: chain = TREE_CHAIN (chain);
6687: if (chain)
6688: strcat (str, ", ");
6689: }
6690: strcat (str, ")");
6691: }
6692: else if (code == FUNCTION_TYPE)
6693: {
6694: tree chain = TYPE_ARG_TYPES (decl); /* a list of types */
6695:
6696: strcat (str, "(");
6697: while (chain && TREE_VALUE (chain) != void_type_node)
6698: {
6699: gen_declaration (TREE_VALUE (chain), str);
6700: chain = TREE_CHAIN (chain);
6701: if (chain && TREE_VALUE (chain) != void_type_node)
6702: strcat (str, ", ");
6703: }
6704: strcat (str, ")");
6705: }
6706: else if (code == INDIRECT_REF)
6707: {
6708: strcpy (tmpbuf, "*");
6709: if (TREE_TYPE (decl) && TREE_CODE (TREE_TYPE (decl)) == TREE_LIST)
6710: {
6711: tree chain;
6712:
6713: for (chain = nreverse (copy_list (TREE_TYPE (decl)));
6714: chain;
6715: chain = TREE_CHAIN (chain))
6716: {
6717: if (TREE_CODE (TREE_VALUE (chain)) == IDENTIFIER_NODE)
6718: {
6719: strcat (tmpbuf, " ");
6720: strcat (tmpbuf, IDENTIFIER_POINTER (TREE_VALUE (chain)));
6721: }
6722: }
6723: if (str[0])
6724: strcat (tmpbuf, " ");
6725: }
6726: strcat (tmpbuf, str);
6727: strcpy (str, tmpbuf);
6728: }
6729: else if (code == POINTER_TYPE)
6730: {
6731: strcpy (tmpbuf, "*");
6732: if (TREE_READONLY (decl) || TYPE_VOLATILE (decl))
6733: {
6734: if (TREE_READONLY (decl))
6735: strcat (tmpbuf, " const");
6736: if (TYPE_VOLATILE (decl))
6737: strcat (tmpbuf, " volatile");
6738: if (str[0])
6739: strcat (tmpbuf, " ");
6740: }
6741: strcat (tmpbuf, str);
6742: strcpy (str, tmpbuf);
6743: }
6744: }
6745:
6746: static char *
6747: gen_declarator (decl, buf, name)
6748: tree decl;
6749: char *buf;
6750: char *name;
6751: {
6752: if (decl)
6753: {
6754: enum tree_code code = TREE_CODE (decl);
6755: char *str;
6756: tree op;
6757: int wrap = 0;
6758:
6759: switch (code)
6760: {
6761: case ARRAY_REF:
6762: case INDIRECT_REF:
6763: case CALL_EXPR:
6764: op = TREE_OPERAND (decl, 0);
6765:
6766: /* we have a pointer to a function or array...(*)(), (*)[] */
6767: if ((code == ARRAY_REF || code == CALL_EXPR)
6768: && op && TREE_CODE (op) == INDIRECT_REF)
6769: wrap = 1;
6770:
6771: str = gen_declarator (op, buf, name);
6772:
6773: if (wrap)
6774: {
6775: strcpy (tmpbuf, "(");
6776: strcat (tmpbuf, str);
6777: strcat (tmpbuf, ")");
6778: strcpy (str, tmpbuf);
6779: }
6780:
6781: adorn_decl (decl, str);
6782: break;
6783:
6784: case ARRAY_TYPE:
6785: case FUNCTION_TYPE:
6786: case POINTER_TYPE:
6787: strcpy (buf, name);
6788: str = buf;
6789:
6790: /* this clause is done iteratively...rather than recursively */
6791: do
6792: {
6793: op = (is_complex_decl (TREE_TYPE (decl))
6794: ? TREE_TYPE (decl) : NULLT);
6795:
6796: adorn_decl (decl, str);
6797:
6798: /* we have a pointer to a function or array...(*)(), (*)[] */
6799: if (code == POINTER_TYPE
6800: && op && (TREE_CODE (op) == FUNCTION_TYPE
6801: || TREE_CODE (op) == ARRAY_TYPE))
6802: {
6803: strcpy (tmpbuf, "(");
6804: strcat (tmpbuf, str);
6805: strcat (tmpbuf, ")");
6806: strcpy (str, tmpbuf);
6807: }
6808:
6809: decl = (is_complex_decl (TREE_TYPE (decl))
6810: ? TREE_TYPE (decl) : NULLT);
6811: }
6812: while (decl && (code = TREE_CODE (decl)));
6813:
6814: break;
6815:
6816: case IDENTIFIER_NODE:
6817: /* will only happen if we are processing a "raw" expr-decl. */
6818: strcpy (buf, IDENTIFIER_POINTER (decl));
6819: return buf;
6820: }
6821:
6822: return str;
6823: }
6824: else /* we have an abstract declarator or a _DECL node */
6825: {
6826: strcpy (buf, name);
6827: return buf;
6828: }
6829: }
6830:
6831: static void
6832: gen_declspecs (declspecs, buf, raw)
6833: tree declspecs;
6834: char *buf;
6835: int raw;
6836: {
6837: if (raw)
6838: {
6839: tree chain;
6840:
6841: for (chain = nreverse (copy_list (declspecs));
6842: chain; chain = TREE_CHAIN (chain))
6843: {
6844: tree aspec = TREE_VALUE (chain);
6845:
6846: if (TREE_CODE (aspec) == IDENTIFIER_NODE)
6847: strcat (buf, IDENTIFIER_POINTER (aspec));
6848: else if (TREE_CODE (aspec) == RECORD_TYPE)
6849: {
6850: if (TYPE_NAME (aspec))
6851: {
6852: tree protocol_list = TYPE_PROTOCOL_LIST (aspec);
6853:
6854: if (! TREE_STATIC_TEMPLATE (aspec))
6855: strcat (buf, "struct ");
6856: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (aspec)));
6857:
6858: /* NEW!!! */
6859: if (protocol_list)
6860: {
6861: tree chain = protocol_list;
6862:
6863: strcat (buf, " <");
6864: while (chain)
6865: {
6866: strcat (buf, IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (chain))));
6867: chain = TREE_CHAIN (chain);
6868: if (chain)
6869: strcat (buf, ", ");
6870: }
6871: strcat (buf, ">");
6872: }
6873: }
6874: else
6875: strcat (buf, "untagged struct");
6876: }
6877: else if (TREE_CODE (aspec) == UNION_TYPE)
6878: {
6879: if (TYPE_NAME (aspec))
6880: {
6881: if (! TREE_STATIC_TEMPLATE (aspec))
6882: strcat (buf, "union ");
6883: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (aspec)));
6884: }
6885: else
6886: strcat (buf, "untagged union");
6887: }
6888: else if (TREE_CODE (aspec) == ENUMERAL_TYPE)
6889: {
6890: if (TYPE_NAME (aspec))
6891: {
6892: if (! TREE_STATIC_TEMPLATE (aspec))
6893: strcat (buf, "enum ");
6894: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (aspec)));
6895: }
6896: else
6897: strcat (buf, "untagged enum");
6898: }
6899: else if (TREE_CODE (aspec) == TYPE_DECL && DECL_NAME (aspec))
6900: {
6901: strcat (buf, IDENTIFIER_POINTER (DECL_NAME (aspec)));
6902: }
6903: /* NEW!!! */
6904: else if (IS_ID (aspec))
6905: {
6906: tree protocol_list = TYPE_PROTOCOL_LIST (aspec);
6907:
6908: strcat (buf, "id");
6909: if (protocol_list)
6910: {
6911: tree chain = protocol_list;
6912:
6913: strcat (buf, " <");
6914: while (chain)
6915: {
6916: strcat (buf, IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (chain))));
6917: chain = TREE_CHAIN (chain);
6918: if (chain)
6919: strcat (buf, ", ");
6920: }
6921: strcat (buf, ">");
6922: }
6923: }
6924: if (TREE_CHAIN (chain))
6925: strcat (buf, " ");
6926: }
6927: }
6928: else
6929: {
6930: /* type qualifiers */
6931:
6932: if (TREE_READONLY (declspecs))
6933: strcat (buf, "const ");
6934: if (TYPE_VOLATILE (declspecs))
6935: strcat (buf, "volatile ");
6936:
6937: switch (TREE_CODE (declspecs))
6938: {
6939: /* type specifiers */
6940:
6941: case INTEGER_TYPE: /* signed integer types */
6942: declspecs = TYPE_MAIN_VARIANT (declspecs);
6943:
6944: if (declspecs == short_integer_type_node) /* 's' */
6945: strcat (buf, "short int ");
6946: else if (declspecs == integer_type_node) /* 'i' */
6947: strcat (buf, "int ");
6948: else if (declspecs == long_integer_type_node) /* 'l' */
6949: strcat (buf, "long int ");
6950: else if (declspecs == long_long_integer_type_node) /* 'l' */
6951: strcat (buf, "long long int ");
6952: else if (declspecs == signed_char_type_node /* 'c' */
6953: || declspecs == char_type_node)
6954: strcat (buf, "char ");
6955:
6956: /* unsigned integer types */
6957:
6958: else if (declspecs == short_unsigned_type_node) /* 'S' */
6959: strcat (buf, "unsigned short ");
6960: else if (declspecs == unsigned_type_node) /* 'I' */
6961: strcat (buf, "unsigned int ");
6962: else if (declspecs == long_unsigned_type_node) /* 'L' */
6963: strcat (buf, "unsigned long ");
6964: else if (declspecs == long_long_unsigned_type_node) /* 'L' */
6965: strcat (buf, "unsigned long long ");
6966: else if (declspecs == unsigned_char_type_node) /* 'C' */
6967: strcat (buf, "unsigned char ");
6968: break;
6969:
6970: case REAL_TYPE: /* floating point types */
6971: declspecs = TYPE_MAIN_VARIANT (declspecs);
6972:
6973: if (declspecs == float_type_node) /* 'f' */
6974: strcat (buf, "float ");
6975: else if (declspecs == double_type_node) /* 'd' */
6976: strcat (buf, "double ");
6977: else if (declspecs == long_double_type_node) /* 'd' */
6978: strcat (buf, "long double ");
6979: break;
6980:
6981: case RECORD_TYPE:
6982: if (TYPE_NAME (declspecs)
6983: && TREE_CODE (TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
6984: {
6985: tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
6986:
6987: if (! TREE_STATIC_TEMPLATE (declspecs))
6988: strcat (buf, "struct ");
6989: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (declspecs)));
6990: /* NEW!!! */
6991: if (protocol_list)
6992: {
6993: tree chain = protocol_list;
6994:
6995: strcat (buf, " <");
6996: while (chain)
6997: {
6998: strcat (buf, IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (chain))));
6999: chain = TREE_CHAIN (chain);
7000: if (chain)
7001: strcat (buf, ", ");
7002: }
7003: strcat (buf, ">");
7004: }
7005: }
7006: else
7007: strcat (buf, "untagged struct");
7008:
7009: strcat (buf, " ");
7010: break;
7011:
7012: case UNION_TYPE:
7013: if (TYPE_NAME (declspecs)
7014: && TREE_CODE (TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
7015: {
7016: strcat (buf, "union ");
7017: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (declspecs)));
7018: strcat (buf, " ");
7019: }
7020: else
7021: strcat (buf, "untagged union ");
7022: break;
7023:
7024: case ENUMERAL_TYPE:
7025: if (TYPE_NAME (declspecs)
7026: && TREE_CODE (TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
7027: {
7028: strcat (buf, "enum ");
7029: strcat (buf, IDENTIFIER_POINTER (TYPE_NAME (declspecs)));
7030: strcat (buf, " ");
7031: }
7032: else
7033: strcat (buf, "untagged enum ");
7034: break;
7035:
7036: case VOID_TYPE:
7037: strcat (buf, "void ");
7038: break;
7039:
7040: /* NEW!!! */
7041: case POINTER_TYPE:
7042: {
7043: tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
7044:
7045: strcat (buf, "id");
7046: if (protocol_list)
7047: {
7048: tree chain = protocol_list;
7049:
7050: strcat (buf, " <");
7051: while (chain)
7052: {
7053: strcat (buf, IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (chain))));
7054: chain = TREE_CHAIN (chain);
7055: if (chain)
7056: strcat (buf, ", ");
7057: }
7058: strcat (buf, ">");
7059: }
7060: }
7061: }
7062: }
7063: }
7064:
7065: static char *
7066: gen_declaration (atype_or_adecl, buf)
7067: tree atype_or_adecl;
7068: char *buf;
7069: {
7070: char declbuf[256];
7071:
7072: if (TREE_CODE (atype_or_adecl) == TREE_LIST)
7073: {
7074: tree declspecs; /* "identifier_node", "record_type" */
7075: tree declarator; /* "array_ref", "indirect_ref", "call_expr"... */
7076:
7077: /* we have a "raw", abstract declarator (typename) */
7078: declarator = TREE_VALUE (atype_or_adecl);
7079: declspecs = TREE_PURPOSE (atype_or_adecl);
7080:
7081: gen_declspecs (declspecs, buf, 1);
7082: if (declarator)
7083: {
7084: strcat (buf, " ");
7085: strcat (buf, gen_declarator (declarator, declbuf, ""));
7086: }
7087: }
7088: else
7089: {
7090: tree atype;
7091: tree declspecs; /* "integer_type", "real_type", "record_type"... */
7092: tree declarator; /* "array_type", "function_type", "pointer_type". */
7093:
7094: if (TREE_CODE (atype_or_adecl) == FIELD_DECL
7095: || TREE_CODE (atype_or_adecl) == PARM_DECL
7096: || TREE_CODE (atype_or_adecl) == FUNCTION_DECL)
7097: atype = TREE_TYPE (atype_or_adecl);
7098: else
7099: atype = atype_or_adecl; /* assume we have a *_type node */
7100:
7101: if (is_complex_decl (atype))
7102: {
7103: tree chain;
7104:
7105: /* get the declaration specifier...it is at the end of the list */
7106: declarator = chain = atype;
7107: do
7108: chain = TREE_TYPE (chain); /* not TREE_CHAIN (chain); */
7109: while (is_complex_decl (chain));
7110: declspecs = chain;
7111: }
7112: else
7113: {
7114: declspecs = atype;
7115: declarator = NULLT;
7116: }
7117:
7118: gen_declspecs (declspecs, buf, 0);
7119:
7120: if (TREE_CODE (atype_or_adecl) == FIELD_DECL
7121: || TREE_CODE (atype_or_adecl) == PARM_DECL
7122: || TREE_CODE (atype_or_adecl) == FUNCTION_DECL)
7123: {
7124: char *decl_name = (DECL_NAME (atype_or_adecl)
7125: ? IDENTIFIER_POINTER (DECL_NAME (atype_or_adecl))
7126: : "");
7127:
7128: if (declarator)
7129: {
7130: strcat (buf, " ");
7131: strcat (buf, gen_declarator (declarator, declbuf, decl_name));
7132: }
7133: else if (decl_name[0])
7134: {
7135: strcat (buf, " ");
7136: strcat (buf, decl_name);
7137: }
7138: }
7139: else if (declarator)
7140: {
7141: strcat (buf, " ");
7142: strcat (buf, gen_declarator (declarator, declbuf, ""));
7143: }
7144: }
7145: return buf;
7146: }
7147:
7148: #define RAW_TYPESPEC(meth) (TREE_VALUE (TREE_PURPOSE (TREE_TYPE (meth))))
7149:
7150: static char *
7151: gen_method_decl (method, buf)
7152: tree method;
7153: char *buf;
7154: {
7155: tree chain;
7156:
7157: if (RAW_TYPESPEC (method) != objc_object_reference)
7158: {
7159: strcpy (buf, "(");
7160: gen_declaration (TREE_TYPE (method), buf);
7161: strcat (buf, ")");
7162: }
7163:
7164: chain = METHOD_SEL_ARGS (method);
7165: if (chain)
7166: { /* we have a chain of keyword_decls */
7167: do
7168: {
7169: if (KEYWORD_KEY_NAME (chain))
7170: strcat (buf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
7171:
7172: strcat (buf, ":");
7173: if (RAW_TYPESPEC (chain) != objc_object_reference)
7174: {
7175: strcat (buf, "(");
7176: gen_declaration (TREE_TYPE (chain), buf);
7177: strcat (buf, ")");
7178: }
7179: strcat (buf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
7180: if ((chain = TREE_CHAIN (chain)))
7181: strcat (buf, " ");
7182: }
7183: while (chain);
7184:
7185: if (METHOD_ADD_ARGS (method) == (tree)1)
7186: strcat (buf, ", ...");
7187: else if (METHOD_ADD_ARGS (method))
7188: {
7189: /* we have a tree list node as generate by get_parm_info. */
7190: chain = TREE_PURPOSE (METHOD_ADD_ARGS (method));
7191: /* know we have a chain of parm_decls */
7192: while (chain)
7193: {
7194: strcat (buf, ", ");
7195: gen_declaration (chain, buf);
7196: chain = TREE_CHAIN (chain);
7197: }
7198: }
7199: }
7200: else /* we have a unary selector */
7201: strcat (buf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
7202:
7203: return buf;
7204: }
7205:
7206: /* debug info... */
7207:
7208: static void
7209: dump_interface (fp, chain)
7210: FILE *fp;
7211: tree chain;
7212: {
7213: char *buf = (char *)xmalloc (256);
7214: char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain));
7215: tree ivar_decls = CLASS_RAW_IVARS (chain);
7216: tree nst_methods = CLASS_NST_METHODS (chain);
7217: tree cls_methods = CLASS_CLS_METHODS (chain);
7218:
7219: fprintf (fp, "\n@interface %s", my_name);
7220:
7221: if (CLASS_SUPER_NAME (chain))
7222: {
7223: char *super_name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain));
7224: fprintf (fp, " : %s\n", super_name);
7225: }
7226: else
7227: fprintf (fp, "\n");
7228:
7229: if (ivar_decls)
7230: {
7231: fprintf (fp, "{\n");
7232: do
7233: {
7234: bzero (buf, 256);
7235: fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls, buf));
7236: ivar_decls = TREE_CHAIN (ivar_decls);
7237: }
7238: while (ivar_decls);
7239: fprintf (fp, "}\n");
7240: }
7241:
7242: while (nst_methods)
7243: {
7244: bzero (buf, 256);
7245: fprintf (fp, "- %s;\n", gen_method_decl (nst_methods, buf));
7246: nst_methods = TREE_CHAIN (nst_methods);
7247: }
7248:
7249: while (cls_methods)
7250: {
7251: bzero (buf, 256);
7252: fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods, buf));
7253: cls_methods = TREE_CHAIN (cls_methods);
7254: }
7255: fprintf (fp, "\n@end");
7256: }
7257:
7258: static void
7259: init_objc ()
7260: {
7261: /* Add the special tree codes of Objective C to the tables. */
7262:
7263: #define LAST_CODE LAST_AND_UNUSED_TREE_CODE
7264:
7265: gcc_obstack_init (&util_obstack);
7266: util_firstobj = (char *) obstack_finish (&util_obstack);
7267:
7268: tree_code_type
7269: = (char **) xrealloc (tree_code_type,
7270: sizeof (char *) * LAST_OBJC_TREE_CODE);
7271: tree_code_length
7272: = (int *) xrealloc (tree_code_length,
7273: sizeof (int) * LAST_OBJC_TREE_CODE);
7274: tree_code_name
7275: = (char **) xrealloc (tree_code_name,
7276: sizeof (char *) * LAST_OBJC_TREE_CODE);
7277: bcopy (objc_tree_code_type,
7278: tree_code_type + (int) LAST_CODE,
7279: (((int) LAST_OBJC_TREE_CODE - (int) LAST_CODE)
7280: * sizeof (char *)));
7281: bcopy (objc_tree_code_length,
7282: tree_code_length + (int) LAST_CODE,
7283: (((int) LAST_OBJC_TREE_CODE - (int) LAST_CODE)
7284: * sizeof (int)));
7285: bcopy (objc_tree_code_name,
7286: tree_code_name + (int) LAST_CODE,
7287: (((int) LAST_OBJC_TREE_CODE - (int) LAST_CODE)
7288: * sizeof (char *)));
7289:
7290: errbuf = (char *)xmalloc (BUFSIZE);
7291: hash_init ();
7292: synth_module_prologue ();
7293: }
7294:
7295: static void
7296: finish_objc ()
7297: {
7298: struct imp_entry *impent;
7299: tree chain;
7300: /* The internally generated initializers appear to have missing braces.
7301: Don't warn about this. */
7302: int save_warn_missing_braces = warn_missing_braces;
7303: warn_missing_braces = 0;
7304:
7305: generate_forward_declaration_to_string_table ();
7306:
7307: #ifdef OBJC_PROLOGUE
7308: OBJC_PROLOGUE;
7309: #endif
7310:
7311: if (implementation_context || class_names_chain
7312: || meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
7313: generate_objc_symtab_decl ();
7314:
7315: for (impent = imp_list; impent; impent = impent->next)
7316: {
7317: implementation_context = impent->imp_context;
7318: implementation_template = impent->imp_template;
7319:
7320: UOBJC_CLASS_decl = impent->class_decl;
7321: UOBJC_METACLASS_decl = impent->meta_decl;
7322:
7323: if (TREE_CODE (implementation_context) == CLASS_IMPLEMENTATION_TYPE)
7324: {
7325: /* all of the following reference the string pool... */
7326: generate_ivar_lists ();
7327: generate_dispatch_tables ();
7328: generate_shared_structures ();
7329: }
7330: else
7331: {
7332: generate_dispatch_tables ();
7333: generate_category (implementation_context);
7334: }
7335: }
7336:
7337: /* If we are using an array of selectors, we must always
7338: finish up the array decl even if no selectors were used. */
7339: if (! flag_next_runtime || sel_ref_chain)
7340: build_selector_translation_table ();
7341:
7342: if (protocol_chain)
7343: generate_protocols ();
7344:
7345: if (implementation_context || class_names_chain
7346: || meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
7347: {
7348: /* Arrange for Objc data structures to be initialized at run time. */
7349: char *init_name = build_module_descriptor ();
7350: if (init_name)
7351: assemble_constructor (init_name);
7352: }
7353:
7354: /* dump the class references...this forces the appropriate classes
7355: to be linked into the executable image, preserving unix archive
7356: semantics...this can be removed when we move to a more dynamically
7357: linked environment. */
7358: for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
7359: {
7360: handle_class_ref (chain);
7361: if (TREE_PURPOSE (chain))
7362: generate_classref_translation_entry (chain);
7363: }
7364:
7365: for (impent = imp_list; impent; impent = impent->next)
7366: handle_impent (impent);
7367:
7368: /* dump the string table last */
7369:
7370: generate_strings ();
7371:
7372: if (flag_gen_declaration)
7373: {
7374: add_class (implementation_context);
7375: dump_interface (gen_declaration_file, implementation_context);
7376: }
7377:
7378: if (warn_selector)
7379: {
7380: int slot;
7381: hash hsh;
7382:
7383: /* Run through the selector hash tables and print a warning for any
7384: selector which has multiple methods. */
7385:
7386: for (slot = 0; slot < SIZEHASHTABLE; slot++)
7387: for (hsh = cls_method_hash_list[slot]; hsh; hsh = hsh->next)
7388: if (hsh->list)
7389: {
7390: tree meth = hsh->key;
7391: char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL
7392: ? '-' : '+');
7393: attr loop;
7394:
7395: warning ("potential selector conflict for method `%s'",
7396: IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
7397: warn_with_method ("found", type, meth);
7398: for (loop = hsh->list; loop; loop = loop->next)
7399: warn_with_method ("found", type, loop->value);
7400: }
7401:
7402: for (slot = 0; slot < SIZEHASHTABLE; slot++)
7403: for (hsh = nst_method_hash_list[slot]; hsh; hsh = hsh->next)
7404: if (hsh->list)
7405: {
7406: tree meth = hsh->key;
7407: char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL
7408: ? '-' : '+');
7409: attr loop;
7410:
7411: warning ("potential selector conflict for method `%s'",
7412: IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
7413: warn_with_method ("found", type, meth);
7414: for (loop = hsh->list; loop; loop = loop->next)
7415: warn_with_method ("found", type, loop->value);
7416: }
7417: }
7418:
7419: warn_missing_braces = save_warn_missing_braces;
7420: }
7421:
7422: /* Subroutines of finish_objc. */
7423:
7424: static void
7425: generate_classref_translation_entry (chain)
7426: tree chain;
7427: {
7428: tree expr, name, decl_specs, decl, sc_spec;
7429: tree type;
7430:
7431: type = TREE_TYPE (TREE_PURPOSE (chain));
7432:
7433: expr = add_objc_string (TREE_VALUE (chain), class_names);
7434: expr = build_c_cast (type, expr); /* cast! */
7435:
7436: name = DECL_NAME (TREE_PURPOSE (chain));
7437:
7438: sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_STATIC]);
7439:
7440: /* static struct objc_class * _OBJC_CLASS_REFERENCES_n = ...; */
7441: decl_specs = tree_cons (NULLT, type, sc_spec);
7442:
7443: /* the `decl' that is returned from start_decl is the one that we
7444: forward declared in `build_class_reference'. */
7445: decl = start_decl (name, decl_specs, 1);
7446: end_temporary_allocation ();
7447: finish_decl (decl, expr, NULLT);
7448: return;
7449: }
7450:
7451: static void
7452: handle_class_ref (chain)
7453: tree chain;
7454: {
7455: char *name = IDENTIFIER_POINTER (TREE_VALUE (chain));
7456: if (! flag_next_runtime)
7457: {
7458: tree decl;
7459: char *string = (char *) alloca (strlen (name) + 30);
7460: tree exp;
7461:
7462: sprintf (string, "%sobjc_class_name_%s",
7463: (flag_next_runtime ? "." : "__"), name);
7464:
7465: /* Make a decl for this name, so we can use its address in a tree. */
7466: decl = build_decl (VAR_DECL, get_identifier (string), char_type_node);
7467: DECL_EXTERNAL (decl) = 1;
7468: TREE_PUBLIC (decl) = 1;
7469:
7470: pushdecl (decl);
7471: rest_of_decl_compilation (decl, 0, 0, 0);
7472:
7473: /* Make following constant read-only (why not)? */
7474: readonly_data_section ();
7475:
7476: exp = build1 (ADDR_EXPR, string_type_node, decl);
7477:
7478: /* Align the section properly. */
7479: assemble_constant_align (exp);
7480:
7481: /* Inform the assembler about this new external thing. */
7482: assemble_external (decl);
7483:
7484: /* Output a constant to reference this address. */
7485: output_constant (exp, int_size_in_bytes (string_type_node));
7486: }
7487: else
7488: {
7489: /* This overreliance on our assembler (i.e. lack of portability)
7490: should be dealt with at some point. The GNU strategy (above)
7491: won't work either, but it is a start. */
7492: char *string = (char *) alloca (strlen (name) + 30);
7493: sprintf (string, ".reference .objc_class_name_%s", name);
7494: assemble_asm (my_build_string (strlen (string) + 1, string));
7495: }
7496: }
7497:
7498: static void
7499: handle_impent (impent)
7500: struct imp_entry *impent;
7501: {
7502: implementation_context = impent->imp_context;
7503: implementation_template = impent->imp_template;
7504:
7505: if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
7506: {
7507: char *class_name = IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
7508: char *string = (char *) alloca (strlen (class_name) + 30);
7509:
7510: if (flag_next_runtime)
7511: {
7512: /* Grossly unportable.
7513: People should know better than to assume
7514: such things about assembler syntax! */
7515: sprintf (string, ".objc_class_name_%s=0", class_name);
7516: assemble_asm (my_build_string (strlen (string) + 1, string));
7517:
7518: sprintf (string, ".globl .objc_class_name_%s", class_name);
7519: assemble_asm (my_build_string (strlen (string) + 1, string));
7520: }
7521: else
7522: {
7523: sprintf (string, "%sobjc_class_name_%s",
7524: (flag_next_runtime ? "." : "__"), class_name);
7525: assemble_global (string);
7526: assemble_label (string);
7527: }
7528: }
7529: else if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
7530: {
7531: char *class_name = IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
7532: char *class_super_name
7533: = IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context));
7534: char *string = (char *) alloca (strlen (class_name)
7535: + strlen (class_super_name) + 30);
7536:
7537: /* Do the same for categories. Even though no references to these
7538: symbols are generated automatically by the compiler, it gives
7539: you a handle to pull them into an archive by hand. */
7540: if (flag_next_runtime)
7541: {
7542: /* Grossly unportable. */
7543: sprintf (string, ".objc_category_name_%s_%s=0",
7544: class_name, class_super_name);
7545: assemble_asm (my_build_string (strlen (string) + 1, string));
7546:
7547: sprintf (string, ".globl .objc_category_name_%s_%s",
7548: class_name, class_super_name);
7549: assemble_asm (my_build_string (strlen (string) + 1, string));
7550: }
7551: else
7552: {
7553: sprintf (string, "%sobjc_category_name_%s_%s",
7554: (flag_next_runtime ? "." : "__"),
7555: class_name, class_super_name);
7556: assemble_global (string);
7557: assemble_label (string);
7558: }
7559: }
7560: }
7561:
7562: #ifdef DEBUG
7563:
7564: static void
7565: objc_debug (fp)
7566: FILE *fp;
7567: {
7568: char *buf = (char *)xmalloc (256);
7569:
7570: { /* dump function prototypes */
7571: tree loop = UOBJC_MODULES_decl;
7572:
7573: fprintf (fp, "\n\nfunction prototypes:\n");
7574: while (loop)
7575: {
7576: if (TREE_CODE (loop) == FUNCTION_DECL && DECL_INITIAL (loop))
7577: {
7578: /* we have a function definition - generate prototype */
7579: bzero (errbuf, BUFSIZE);
7580: gen_declaration (loop, errbuf);
7581: fprintf (fp, "%s;\n", errbuf);
7582: }
7583: loop = TREE_CHAIN (loop);
7584: }
7585: }
7586: { /* dump global chains */
7587: tree loop;
7588: int i, index = 0, offset = 0;
7589: hash hashlist;
7590:
7591: for (i = 0; i < SIZEHASHTABLE; i++)
7592: {
7593: if (hashlist = nst_method_hash_list[i])
7594: {
7595: fprintf (fp, "\n\nnst_method_hash_list[%d]:\n", i);
7596: do
7597: {
7598: bzero (buf, 256);
7599: fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf));
7600: hashlist = hashlist->next;
7601: }
7602: while (hashlist);
7603: }
7604: }
7605: for (i = 0; i < SIZEHASHTABLE; i++)
7606: {
7607: if (hashlist = cls_method_hash_list[i])
7608: {
7609: fprintf (fp, "\n\ncls_method_hash_list[%d]:\n", i);
7610: do
7611: {
7612: bzero (buf, 256);
7613: fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf));
7614: hashlist = hashlist->next;
7615: }
7616: while (hashlist);
7617: }
7618: }
7619: fprintf (fp, "\nsel_refdef_chain:\n");
7620: for (loop = sel_refdef_chain; loop; loop = TREE_CHAIN (loop))
7621: {
7622: fprintf (fp, "(index: %4d offset: %4d) %s\n", index, offset,
7623: IDENTIFIER_POINTER (TREE_VALUE (loop)));
7624: index++;
7625: /* add one for the '\0' character */
7626: offset += IDENTIFIER_LENGTH (TREE_VALUE (loop)) + 1;
7627: }
7628: fprintf (fp, "\n (max_selector_index: %4d.\n", max_selector_index);
7629: }
7630: }
7631: #endif
7632:
7633: void
7634: print_lang_statistics ()
7635: {
7636: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.