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