#include <stdio.h>
#include "config.h"
#include "tree.h"
#include "flags.h"
#ifdef OBJCPLUS
#include "cp-tree.h"
#include "lex.h"
#else
#include "c-tree.h"
#include "c-lex.h"
#endif
#include "objc-act.h"
#include "input.h"
#include "except.h"
#include "function.h"
#ifndef OBJC_GEN_METHOD_LABEL
#define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
do { \
char *temp; \
sprintf ((BUF), "_%s_%s_%s_%s", \
((IS_INST) ? "i" : "c"), \
(CLASS_NAME), \
((CAT_NAME)? (CAT_NAME) : ""), \
(SEL_NAME)); \
for (temp = (BUF); *temp; temp++) \
if (*temp == ':') *temp = '_'; \
} while (0)
#endif
#ifndef OBJC_FORWARDING_STACK_OFFSET
#define OBJC_FORWARDING_STACK_OFFSET 0
#endif
#ifndef OBJC_FORWARDING_MIN_OFFSET
#define OBJC_FORWARDING_MIN_OFFSET 0
#endif
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
char objc_tree_code_type[] = {
'x',
#include "objc-tree.def"
};
#undef DEFTREECODE
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
int objc_tree_code_length[] = {
0,
#include "objc-tree.def"
};
#undef DEFTREECODE
#define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
char *objc_tree_code_name[] = {
"@@dummy",
#include "objc-tree.def"
};
#undef DEFTREECODE
#include "obstack.h"
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
static struct obstack util_obstack;
char *util_firstobj;
static tree objc_static_instances;
static tree static_instances_decl;
#include "rtl.h"
#include "regs.h"
#ifdef OBJCPLUS
#include <parse.h>
#else
#include <objc-parse.h>
#endif
#define OBJC_VERSION 5
#define PROTOCOL_VERSION 2
#define OBJC_ENCODE_INLINE_DEFS 0
#define OBJC_ENCODE_DONT_INLINE_DEFS 1
#ifdef OBJCPLUS
extern tree make_anon_name PROTO((void));
extern tree const_string_type_node;
extern int cp_silent;
#define xref_tag(code, name) xref_tag (record_type_node, name, 1)
static int cplus_struct_hack = 0;
static tree
objcplus_start_struct (code, name)
enum tree_code code;
tree name;
{
tree s = xref_tag (record_type_node, name ? name : make_anon_name ());
int temp = allocation_temporary_p ();
int momentary = suspend_momentary ();
if (temp)
end_temporary_allocation ();
cplus_struct_hack = (momentary << 1) | temp;
pushclass (s, 0);
return s;
}
static tree
objcplus_finish_struct (t, fieldlist)
tree t;
tree fieldlist;
{
tree s, field, next_field;
for(field = fieldlist; field; field = next_field) {
next_field = TREE_CHAIN(field);
TREE_CHAIN(field) = NULL_TREE;
finish_member_declaration(field);
}
s = finish_struct (t, NULL_TREE, 0);
if (cplus_struct_hack & 1)
resume_temporary_allocation ();
if (cplus_struct_hack & 2)
resume_momentary (1);
return s;
}
static void
objcplus_finish_function (nested)
int nested;
{
finish_function (lineno, 1, 0);
}
extern tree groktypename_in_parm_context PROTO ((tree));
static void
objcplus_finish_decl (decl, init, asmspec)
tree decl, init, asmspec;
{
cp_finish_decl (decl, init, asmspec, 1, 0);
}
static tree
objcplus_lookup_name (name)
tree name;
{
return lookup_name (name, -1);
}
static tree objcplus_parmlist = NULL_TREE;
tree
objcplus_push_parm_decl (parm)
tree parm;
{
if (objcplus_parmlist)
objcplus_parmlist = chainon (objcplus_parmlist, build_tree_list (0, parm));
else
objcplus_parmlist = build_tree_list (0, parm);
return objcplus_parmlist;
}
static tree
objcplus_get_parm_info (void_at_end)
int void_at_end;
{
tree parm_info = objcplus_parmlist;
TREE_PARMLIST (parm_info) = 1;
if (void_at_end)
chainon (parm_info, void_list_node);
objcplus_parmlist = NULL_TREE;
return parm_info;
}
static tree
objcplus_TYPE_NAME (type)
tree type;
{
if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
return DECL_NAME (TYPE_NAME (type));
else
return TYPE_NAME (type);
}
static tree
objcplus_TYPE_SIZE (type)
tree type;
{
tree size = TYPE_SIZE (type);
if (size == NULL_TREE && !cp_silent)
{
warning ("Requesting size of incomplete type `%s'",
IDENTIFIER_POINTER (objcplus_TYPE_NAME (type)));
layout_type (type);
size = TYPE_SIZE (type);
}
return build_int_2 (TREE_INT_CST_LOW (size), 0);
}
#define pushlevel(tag_transparent)
#define poplevel(keep, reverse, functionbody)
#define grokfield(filename, line, declarator, declspecs, width) \
((width) ? grokbitfield (declarator, declspecs, width) \
: grokfield (declarator, declspecs, 0, 0, 0))
#define build_component_ref(datum, component) \
build_component_ref (datum, component, NULL_TREE, 1)
#define comptypes(type1, type2) comptypes (type1, type2, 0)
#define start_decl(declarator, declspecs, spspecs) \
start_decl (declarator, declspecs, spspecs, NULL_TREE, NULL_TREE)
#define start_function(declspecs, declarator, raises, attrs, pre_parsed_p) \
start_function (declspecs, declarator, attrs, pre_parsed_p)
#elif defined (NEXT_SEMANTICS)
#define start_decl(declarator, declspecs, spspecs) \
start_decl (declarator, declspecs, spspecs, NULL_TREE, NULL_TREE)
#define objcplus_finish_struct(code, name) finish_struct (code, name, NULL_TREE)
#define xref_tag (code_type_node, name, binfo, globalize) \
xref_tag (code_type_node, name, binfo)
#endif
static void init_objc PROTO((void));
static void finish_objc PROTO((void));
tree is_class_name PROTO((tree));
static void synth_module_prologue PROTO((void));
static tree build_constructor PROTO((tree, tree));
static char *build_module_descriptor PROTO((void));
static tree init_module_descriptor PROTO((tree));
static tree build_objc_method_call PROTO((int, tree, tree, tree, tree, tree));
static void generate_strings PROTO((void));
static void build_selector_translation_table PROTO((void));
static tree build_ivar_chain PROTO((tree, int));
static tree build_ivar_template PROTO((void));
static tree build_method_template PROTO((void));
static tree build_private_template PROTO((tree));
static void build_class_template PROTO((void));
static void build_category_template PROTO((void));
static tree build_super_template PROTO((void));
static tree build_category_initializer PROTO((tree, tree, tree, tree, tree, tree));
static tree build_protocol_initializer PROTO((tree, tree, tree, tree, tree));
static void synth_forward_declarations PROTO((void));
static void generate_ivar_lists PROTO((void));
static void generate_dispatch_tables PROTO((void));
static void generate_shared_structures PROTO((void));
static tree generate_protocol_list PROTO((tree));
static void generate_forward_declaration_to_string_table PROTO((void));
static void build_protocol_reference PROTO((tree));
static tree init_selector PROTO((int));
static tree build_keyword_selector PROTO((tree));
static tree synth_id_with_class_suffix PROTO((char *, tree));
extern int apply_args_register_offset PROTO((int));
typedef struct hashed_entry *hash;
typedef struct hashed_attribute *attr;
struct hashed_attribute
{
attr next;
tree value;
};
struct hashed_entry
{
attr list;
hash next;
tree key;
};
static void hash_init PROTO((void));
static void hash_enter PROTO((hash *, tree));
static hash hash_lookup PROTO((hash *, tree));
static void hash_add_attr PROTO((hash, tree));
static tree lookup_method PROTO((tree, tree));
static tree lookup_instance_method_static PROTO((tree, tree));
static tree lookup_class_method_static PROTO((tree, tree));
static tree add_class PROTO((tree));
static void add_category PROTO((tree, tree));
#if defined (NEXT_SEMANTICS)
static void add_static_object PROTO((tree, tree));
#endif
enum string_section
{
class_names,
meth_var_names,
meth_var_types
};
static tree add_objc_string PROTO((tree,
enum string_section));
static tree build_objc_string_decl PROTO((tree,
enum string_section));
static tree build_selector_reference_decl PROTO((tree));
static tree add_protocol PROTO((tree));
static tree lookup_protocol PROTO((tree));
static tree lookup_and_install_protocols PROTO((tree));
static void encode_type_qualifiers PROTO((tree));
static void encode_pointer PROTO((tree, int, int));
static void encode_array PROTO((tree, int, int));
static void encode_aggregate PROTO((tree, int, int));
static void encode_bitfield PROTO((int, int));
static void encode_type PROTO((tree, int, int));
static void encode_field_decl PROTO((tree, int, int));
static void really_start_method PROTO((tree, tree));
static int comp_method_with_proto PROTO((tree, tree));
static int comp_proto_with_proto PROTO((tree, tree));
static tree get_arg_type_list PROTO((tree, int, int));
static tree expr_last PROTO((tree));
static void warn_with_method PROTO((char *, int, tree));
static void error_with_ivar PROTO((char *, tree, tree));
static char *gen_method_decl PROTO((tree, char *));
static char *gen_declaration PROTO((tree, char *));
static char *gen_declarator PROTO((tree, char *, char *));
static int is_complex_decl PROTO((tree));
static void adorn_decl PROTO((tree, char *));
static void dump_interface PROTO((FILE *, tree));
static void objc_fatal PROTO((void));
static tree define_decl PROTO((tree, tree));
static tree lookup_method_in_protocol_list PROTO((tree, tree, int));
static tree lookup_protocol_in_reflist PROTO((tree, tree));
static tree create_builtin_decl PROTO((enum tree_code,
tree, char *));
static tree my_build_string PROTO((int, char *));
static void build_objc_symtab_template PROTO((void));
static tree init_def_list PROTO((tree));
static tree init_objc_symtab PROTO((tree));
static void forward_declare_categories PROTO((void));
static void generate_objc_symtab_decl PROTO((void));
static tree build_selector PROTO((tree));
static tree build_msg_pool_reference PROTO((int));
static tree build_typed_selector_reference PROTO((tree, tree));
static tree build_selector_reference PROTO((tree));
static tree build_class_reference_decl PROTO((tree));
static void add_class_reference PROTO((tree));
static tree objc_copy_list PROTO((tree, tree *));
static tree build_protocol_template PROTO((void));
static tree build_descriptor_table_initializer PROTO((tree, tree));
static tree build_method_prototype_list_template PROTO((tree, int));
static tree build_method_prototype_template PROTO((void));
static int forwarding_offset PROTO((tree));
static tree encode_method_prototype PROTO((tree, tree));
static tree generate_descriptor_table PROTO((tree, char *, int, tree, tree));
static void generate_method_descriptors PROTO((tree));
static tree build_tmp_function_decl PROTO((void));
static void hack_method_prototype PROTO((tree, tree));
static void generate_protocol_references PROTO((tree));
static void generate_protocols PROTO((void));
static void check_ivars PROTO((tree, tree));
static tree build_ivar_list_template PROTO((tree, int));
static tree build_method_list_template PROTO((tree, int));
static tree build_ivar_list_initializer PROTO((tree, tree));
static tree generate_ivars_list PROTO((tree, char *, int, tree));
static tree build_dispatch_table_initializer PROTO((tree, tree));
static tree generate_dispatch_table PROTO((tree, char *, int, tree));
static tree build_shared_structure_initializer PROTO((tree, tree, tree, tree, tree, int, tree, tree, tree));
static void generate_category PROTO((tree));
static int is_objc_type_qualifier PROTO((tree));
static tree adjust_type_for_id_default PROTO((tree, int));
static tree check_duplicates PROTO((hash));
static tree receiver_is_class_object PROTO((tree));
static int check_methods PROTO((tree, tree, int));
static int check_methods_accessible PROTO((tree, tree, int));
static int conforms_to_protocol PROTO((tree, tree));
static void check_protocols PROTO((tree, char *, char *));
static tree encode_method_def PROTO((tree));
static void gen_declspecs PROTO((tree, char *, int));
static void generate_classref_translation_entry PROTO((tree));
static void handle_any_ref PROTO((tree, int));
static void handle_class_ref PROTO((tree));
#define TYPE_ID "id"
#define TAG_OBJECT "objc_object"
#define TAG_CLASS "objc_class"
#define TAG_SUPER "objc_super"
#define TAG_SELECTOR "objc_selector"
#define UTAG_CLASS "_objc_class"
#define UTAG_IVAR "_objc_ivar"
#define UTAG_IVAR_LIST "_objc_ivar_list"
#define UTAG_METHOD "_objc_method"
#define UTAG_METHOD_LIST "_objc_method_list"
#define UTAG_CATEGORY "_objc_category"
#define UTAG_MODULE "_objc_module"
#define UTAG_SYMTAB "_objc_symtab"
#define UTAG_SUPER "_objc_super"
#define UTAG_SELECTOR "_objc_selector"
#define UTAG_PROTOCOL "_objc_protocol"
#define UTAG_PROTOCOL_LIST "_objc_protocol_list"
#define UTAG_METHOD_PROTOTYPE "_objc_method_prototype"
#define UTAG_METHOD_PROTOTYPE_LIST "_objc__method_prototype_list"
#define STRING_OBJECT_CLASS_NAME_NEW "NSConstantString"
#define STRING_OBJECT_CLASS_NAME_OLD "NXConstantString"
#define STRING_OBJECT_GLOBAL_NAME "_NSConstantStringClassReference"
#define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
static char* TAG_GETCLASS;
static char* TAG_GETMETACLASS;
static char* TAG_GETORIGCLASS;
static char* TAG_MSGSEND;
static char* TAG_MSGSENDSUPER;
static char* TAG_MSGSEND_STRET;
static char* TAG_MSGSENDSUPER_STRET;
static char* TAG_EXECCLASS;
static char* TAG_ATOM;
static tree self_id, ucmd_id;
#ifndef NEXT_OBJC_RUNTIME
static tree unused_list;
#endif
static tree self_decl, umsg_decl, umsg_super_decl;
static tree umsg_stret_decl, umsg_super_stret_decl;
static tree objc_get_class_decl, objc_get_meta_class_decl;
static tree objc_get_orig_class_decl;
static tree instance_type, protocol_type;
#ifdef OBJCPLUS
static tree objc_module_type;
#endif
static tree class_chain = NULL_TREE;
static tree alias_chain = NULL_TREE;
static tree interface_chain = NULL_TREE;
static tree protocol_chain = NULL_TREE;
static tree cls_ref_chain = NULL_TREE;
static tree sel_ref_chain = NULL_TREE;
#if defined (NEXT_SEMANTICS)
static tree obj_def_chain = NULL_TREE;
static tree proto_def_chain = NULL_TREE;
#endif
static tree class_names_chain = NULL_TREE;
static tree meth_var_names_chain = NULL_TREE;
static tree meth_var_types_chain = NULL_TREE;
static hash *nst_method_hash_list = 0;
static hash *cls_method_hash_list = 0;
static tree UOBJC_SYMBOLS_decl;
static tree UOBJC_INSTANCE_VARIABLES_decl, UOBJC_CLASS_VARIABLES_decl;
static tree UOBJC_INSTANCE_METHODS_decl, UOBJC_CLASS_METHODS_decl;
static tree UOBJC_CLASS_decl, UOBJC_METACLASS_decl;
static tree UOBJC_SELECTOR_TABLE_decl = 0;
static tree UOBJC_MODULES_decl;
static tree UOBJC_STRINGS_decl;
static tree implementation_context = NULL_TREE,
implementation_template = NULL_TREE;
extern tree objc_implementation_context;
struct imp_entry
{
struct imp_entry *next;
tree imp_context;
tree imp_template;
tree class_decl;
tree meta_decl;
};
static void handle_impent PROTO((struct imp_entry *));
static struct imp_entry *imp_list = 0;
static int imp_count = 0;
static int cat_count = 0;
static int obj_count = 0;
static int proto_count = 0;
static int sel_count = 0;
static int no_objc = 1;
static tree objc_class_template, objc_category_template, uprivate_record;
static tree objc_protocol_template;
static tree objc_selector_template;
static tree ucls_super_ref, uucls_super_ref;
static tree objc_method_template, objc_ivar_template;
static tree objc_symtab_template, objc_module_template;
static tree objc_super_template, objc_object_reference;
static int constantStringTypeSet = 0;
static tree constant_string_id;
static tree constant_string_id_old;
static tree constant_string_id_new;
static tree constant_string_global_id = 0;
static tree constant_string_type;
static tree constant_string_type_old;
static tree constant_string_type_new;
static tree string_class_decl = 0;
static tree UOBJC_SUPER_decl = NULL_TREE;
static tree protocol_id;
static tree method_context = NULL_TREE;
static int method_slot = 0;
#define BUFSIZE 1024
static char *errbuf;
typedef enum c_language_kind
{
clk_c,
clk_cplusplus,
clk_objective_c,
clk_objective_cplusplus
}c_language_kind;
int c_language = clk_objective_cplusplus;
extern struct obstack permanent_obstack,
*current_obstack, *rtl_obstack, *expression_obstack,
*function_maybepermanent_obstack;
extern char *dump_base_name;
#ifdef NEXT_OBJC_RUNTIME
int flag_next_runtime = 1;
#else
int flag_next_runtime = 0;
#endif
int flag_selector_table;
int flag_class_references;
int flag_static_objects;
int flag_typed_selectors;
int flag_gen_declaration = 0;
FILE *gen_declaration_file;
int warn_selector = 0;
int flag_warn_protocol = 1;
static int generating_instance_variables = 0;
#ifdef OBJCPLUS
int doing_objc_thang = 1;
int objc_old_semantics_expected = 0;
#endif
#ifdef OBJCPLUS
void objc_lang_init ()
#else
void lang_init ()
#endif
{
#ifndef OBJCPLUS
ungetc (check_newline (), finput);
#endif
if (flag_gen_declaration)
{
int dump_base_name_length = strlen (dump_base_name);
register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
strcpy (dumpname, dump_base_name);
strcat (dumpname, ".decl");
gen_declaration_file = fopen (dumpname, "w");
if (gen_declaration_file == 0)
pfatal_with_name (dumpname);
}
if (flag_next_runtime)
{
TAG_GETCLASS = "objc_getClass";
TAG_GETMETACLASS = "objc_getMetaClass";
TAG_GETORIGCLASS = "objc_getOrigClass";
TAG_MSGSEND = "objc_msgSend";
TAG_MSGSENDSUPER = "objc_msgSendSuper";
TAG_MSGSEND_STRET = "objc_msgSend_stret";
TAG_MSGSENDSUPER_STRET = "objc_msgSendSuper_stret";
TAG_EXECCLASS = "__objc_execClass";
TAG_ATOM = "NXAtom";
#ifdef NEXT_PDO
flag_selector_table = 1;
flag_class_references = 0;
flag_static_objects = 1;
#else
flag_selector_table = 0;
flag_class_references = 1;
flag_static_objects = 0;
#endif
}
else
{
TAG_GETCLASS = "objc_get_class";
TAG_GETMETACLASS = "objc_get_meta_class";
TAG_GETORIGCLASS = "objc_get_orig_class";
TAG_MSGSEND = "objc_msg_lookup";
TAG_MSGSENDSUPER = "objc_msg_lookup_super";
TAG_EXECCLASS = "__objc_exec_class";
TAG_ATOM = "GNUAtom";
flag_selector_table = 1;
flag_class_references = 0;
}
#ifndef OBJCPLUS
if (doing_objc_thang)
#else
doing_objc_thang = 1;
#endif
init_objc ();
}
static void
objc_fatal ()
{
#ifdef OBJCPLUS
fatal ("Objective-C text in C++ source file: use -x objective-c++");
#else
fatal ("Objective-C text in C source file: use -x objective-c");
#endif
}
void
#ifdef OBJCPLUS
objc_finish ()
#else
finish_file ()
#endif
{
if (doing_objc_thang)
finish_objc ();
if (gen_declaration_file)
fclose (gen_declaration_file);
}
void
#ifdef OBJCPLUS
objc_lang_finish ()
#else
lang_finish ()
#endif
{
}
#ifndef OBJCPLUS
char *
lang_identify ()
{
if (no_objc)
return "c";
else
return "objc";
}
#endif
int
lang_decode_option (argc, argv)
int argc;
char **argv;
{
char *p = argv[0];
#ifdef NEXT_SEMANTICS
if (!strcmp (p, "-fobjc")
|| !strcmp (p, "-ObjC")
|| !strcmp (p, "-ObjC++")
)
doing_objc_thang = 1;
#endif
else if (!strcmp (p, "-lang-objc"))
doing_objc_thang = 1;
else if (!strcmp (p, "-gen-decls"))
flag_gen_declaration = 1;
else if (!strcmp (p, "-Wselector"))
warn_selector = 1;
else if (!strcmp (p, "-Wno-selector"))
warn_selector = 0;
else if (!strcmp (p, "-Wprotocol"))
flag_warn_protocol = 1;
else if (!strcmp (p, "-Wno-protocol"))
flag_warn_protocol = 0;
else if (!strcmp (p, "-fgnu-runtime"))
flag_next_runtime = 0;
else if (!strcmp (p, "-fno-next-runtime"))
flag_next_runtime = 0;
else if (!strcmp (p, "-fno-gnu-runtime"))
flag_next_runtime = 1;
else if (!strcmp (p, "-fnext-runtime"))
flag_next_runtime = 1;
else if (!strcmp (p, "-fselector-table"))
flag_selector_table = 1;
else
return cplus_decode_option (argc, argv);
return 1;
}
static tree
define_decl (declarator, declspecs)
tree declarator;
tree declspecs;
{
tree decl;
int save_flag_dump_symbols = flag_dump_symbols;
int save_flag_gen_index = flag_gen_index;
flag_dump_symbols = 0;
flag_gen_index = 0;
objc_old_semantics_expected = 1;
decl = start_decl (declarator, declspecs, 0);
objc_old_semantics_expected = 0;
objcplus_finish_decl (decl, NULL_TREE, NULL_TREE);
flag_dump_symbols = save_flag_dump_symbols;
flag_gen_index = save_flag_gen_index;
return decl;
}
int
maybe_objc_comptypes (lhs, rhs, reflexive)
tree lhs, rhs;
int reflexive;
{
if (doing_objc_thang)
return objc_comptypes (lhs, rhs, reflexive);
return -1;
}
static tree
lookup_method_in_protocol_list (rproto_list, sel_name, class_meth)
tree rproto_list;
tree sel_name;
int class_meth;
{
tree rproto, p;
tree fnd = 0;
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
if ((fnd = lookup_method (class_meth
? PROTOCOL_CLS_METHODS (p)
: PROTOCOL_NST_METHODS (p), sel_name)))
;
else if (PROTOCOL_LIST (p))
fnd = lookup_method_in_protocol_list (PROTOCOL_LIST (p),
sel_name, class_meth);
}
else
;
if (fnd)
return fnd;
}
#if 0
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
if (! PROTOCOL_DEFINED (p))
warning ("protocol definition for `%s' needed for typechecking",
IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
#endif
return 0;
}
static tree
lookup_protocol_in_reflist (rproto_list, lproto)
tree rproto_list;
tree lproto;
{
tree rproto, p;
if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE)
{
tree fnd = 0;
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
if (lproto == p)
fnd = lproto;
else if (PROTOCOL_LIST (p))
fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto);
}
if (fnd)
return fnd;
}
}
else
;
return 0;
}
int
objc_comptypes (lhs, rhs, reflexive)
tree lhs;
tree rhs;
int reflexive;
{
if (TREE_CODE (lhs) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (lhs)) == RECORD_TYPE
&& TREE_CODE (rhs) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (rhs)) == RECORD_TYPE)
{
int lhs_is_proto = IS_PROTOCOL_QUALIFIED_ID (lhs);
int rhs_is_proto = IS_PROTOCOL_QUALIFIED_ID (rhs);
if (lhs_is_proto)
{
tree lproto, lproto_list = TYPE_PROTOCOL_LIST (lhs);
tree rproto, rproto_list;
tree p;
if (rhs_is_proto)
{
rproto_list = TYPE_PROTOCOL_LIST (rhs);
for (lproto = lproto_list; lproto; lproto = TREE_CHAIN (lproto))
{
p = TREE_VALUE (lproto);
rproto = lookup_protocol_in_reflist (rproto_list, p);
if (!rproto)
warning ("object does not conform to the `%s' protocol",
IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
}
else if (TYPED_OBJECT (TREE_TYPE (rhs)))
{
tree rname = objcplus_TYPE_NAME (TREE_TYPE (rhs));
tree rinter;
for (lproto = lproto_list; lproto; lproto = TREE_CHAIN (lproto))
{
p = TREE_VALUE (lproto);
rproto = 0;
rinter = lookup_interface (rname);
while (rinter && !rproto)
{
tree cat;
rproto_list = CLASS_PROTOCOL_LIST (rinter)? CLASS_PROTOCOL_LIST (rinter):
TYPE_PROTOCOL_LIST(TREE_TYPE(rhs));
rproto = lookup_protocol_in_reflist (rproto_list, p);
cat = CLASS_CATEGORY_LIST (rinter);
while (cat && !rproto)
{
rproto_list = CLASS_PROTOCOL_LIST (cat);
rproto = lookup_protocol_in_reflist (rproto_list, p);
cat = CLASS_CATEGORY_LIST (cat);
}
rinter = lookup_interface (CLASS_SUPER_NAME (rinter));
}
if (!rproto)
warning ("class `%s' does not implement the `%s' protocol",
IDENTIFIER_POINTER (objcplus_TYPE_NAME (TREE_TYPE (rhs))),
IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
}
return 1;
}
else if (rhs_is_proto)
{
if (TYPED_OBJECT (TREE_TYPE (lhs)))
return 0;
else
return 1;
}
else
return -1;
}
else if (TREE_CODE (lhs) == RECORD_TYPE && TREE_CODE (rhs) == RECORD_TYPE)
;
else
return -1;
if ((objcplus_TYPE_NAME (lhs) == objc_object_id && TYPED_OBJECT (rhs))
|| (objcplus_TYPE_NAME (rhs) == objc_object_id && TYPED_OBJECT (lhs)))
return 1;
else if ((objcplus_TYPE_NAME (lhs) == objc_object_id
&& objcplus_TYPE_NAME (rhs) == objc_class_id)
|| (objcplus_TYPE_NAME (lhs) == objc_class_id
&& objcplus_TYPE_NAME (rhs) == objc_object_id))
return 1;
else if (TYPED_OBJECT (lhs) && TYPED_OBJECT (rhs))
{
tree lname = objcplus_TYPE_NAME (lhs);
tree rname = objcplus_TYPE_NAME (rhs);
tree inter;
if (lname == rname)
return 1;
for (inter = lookup_interface (rname); inter;
inter = lookup_interface (CLASS_SUPER_NAME (inter)))
if (lname == CLASS_SUPER_NAME (inter))
return 1;
if (reflexive)
for (inter = lookup_interface (lname); inter;
inter = lookup_interface (CLASS_SUPER_NAME (inter)))
if (rname == CLASS_SUPER_NAME (inter))
return 1;
return 0;
}
else
return -1;
}
void
objc_check_type (type)
tree type;
{
if (type != NULL_TREE && TREE_CODE (type) == RECORD_TYPE
&& TREE_STATIC_TEMPLATE (type))
{
error ("Objective-C class `%s' cannot be used with C++ `new' or `delete'",
IDENTIFIER_POINTER(objcplus_TYPE_NAME(type)));
}
}
void
objc_check_decl (decl)
tree decl;
{
tree type = TREE_TYPE (decl);
if (TREE_CODE (type) == RECORD_TYPE
&& TREE_STATIC_TEMPLATE (type)
&& type != constant_string_type)
{
error_with_decl (decl, "`%s' cannot be statically allocated");
fatal ("statically allocated objects not supported");
}
}
void
maybe_objc_check_decl (decl)
tree decl;
{
if (doing_objc_thang)
objc_check_decl (decl);
}
tree
get_static_reference (interface, protocols)
tree interface;
tree protocols;
{
tree type = xref_tag (RECORD_TYPE, interface);
if (protocols)
{
tree t, m = TYPE_MAIN_VARIANT (type);
struct obstack *ambient_obstack = current_obstack;
current_obstack = &permanent_obstack;
t = copy_node (type);
#if 0
TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
TYPE_NEXT_VARIANT (m) = t;
#endif
current_obstack = ambient_obstack;
TYPE_PROTOCOL_LIST (t) = lookup_and_install_protocols (protocols);
TYPE_MAIN_VARIANT(t) = t;
TYPE_NEXT_VARIANT(t) = 0;
if (TYPE_POINTER_TO (t))
TYPE_POINTER_TO (t) = NULL;
type = t;
}
return type;
}
int
is_protocol_qualified_id (type)
tree type;
{
return IS_PROTOCOL_QUALIFIED_ID (type);
}
tree
get_object_reference (protocols)
tree protocols;
{
tree type_decl = objcplus_lookup_name (objc_id_id);
tree type;
if (type_decl && TREE_CODE (type_decl) == TYPE_DECL)
{
type = TREE_TYPE (type_decl);
if (TYPE_MAIN_VARIANT (type) != id_type)
warning ("Unexpected type for `id' (%s)",
gen_declaration (type, errbuf));
}
else
{
fatal ("Undefined type `id', please import <objc/objc.h>");
}
if (protocols)
{
tree t, m = TYPE_MAIN_VARIANT (type);
struct obstack *ambient_obstack = current_obstack;
current_obstack = &permanent_obstack;
t = copy_node (type);
#if 0
TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
TYPE_NEXT_VARIANT (m) = t;
#endif
current_obstack = ambient_obstack;
TYPE_PROTOCOL_LIST (t) = lookup_and_install_protocols (protocols);
if (TYPE_POINTER_TO (t))
TYPE_POINTER_TO (t) = NULL;
type = t;
}
return type;
}
static tree
check_protocol_recursively (proto, list)
tree proto, list;
{
tree p;
for (p = list; p; p = TREE_CHAIN (p))
{
tree pp = TREE_VALUE (p);
if (TREE_CODE (pp) == IDENTIFIER_NODE)
pp = lookup_protocol (pp);
if (pp == proto)
fatal ("protocol `%s' has circular dependency",
IDENTIFIER_POINTER (PROTOCOL_NAME (pp)));
if (pp)
check_protocol_recursively (proto, PROTOCOL_LIST (pp));
}
}
static tree
lookup_and_install_protocols (protocols)
tree protocols;
{
tree proto;
tree prev = NULL;
tree return_value = protocols;
for (proto = protocols; proto; proto = TREE_CHAIN (proto))
{
tree ident = TREE_VALUE (proto);
tree p = lookup_protocol (ident);
if (!p)
{
error ("Cannot find protocol declaration for `%s'",
IDENTIFIER_POINTER (ident));
if (prev)
TREE_CHAIN (prev) = TREE_CHAIN (proto);
else
return_value = TREE_CHAIN (proto);
}
else
{
TREE_VALUE (proto) = p;
prev = proto;
}
}
return return_value;
}
static tree
create_builtin_decl (code, type, name)
enum tree_code code;
tree type;
char *name;
{
tree decl;
#ifdef OBJCPLUS
if (code == VAR_DECL)
decl = build_decl (code, get_identifier (name), type);
else
decl = build_lang_field_decl (code, get_identifier (name), type);
#else
decl = build_decl (code, get_identifier (name), type);
#endif
if (code == VAR_DECL)
{
TREE_STATIC (decl) = 1;
DECL_EXTERNAL (decl) = 1;
make_decl_rtl (decl, 0, 1);
pushdecl (decl);
}
DECL_ARTIFICIAL (decl) = 1;
return decl;
}
#ifndef NEXT_PDO
static void
setup_string_decl ()
{
if (!string_class_decl)
{
if (!constant_string_global_id)
{
constant_string_global_id = get_identifier(STRING_OBJECT_GLOBAL_NAME);
if (constant_string_global_id == NULL_TREE)
{
return;
}
}
string_class_decl = objcplus_lookup_name(constant_string_global_id);
}
}
#endif
static void
synth_module_prologue ()
{
tree temp_type;
tree super_p;
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
objc_object_id = get_identifier (TAG_OBJECT);
objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
id_type = build_pointer_type (objc_object_reference);
objc_id_id = get_identifier (TYPE_ID);
objc_class_id = get_identifier (TAG_CLASS);
objc_class_type = build_pointer_type (xref_tag (RECORD_TYPE, objc_class_id));
#ifndef OBJCPLUS
protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (PROTOCOL_OBJECT_CLASS_NAME)));
#else
{ tree proto_id =
get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
objc_declare_class(tree_cons (NULL_TREE, proto_id, NULL_TREE));
protocol_type = build_pointer_type (xref_tag (RECORD_TYPE, proto_id));
}
#endif
#ifdef OBJCPLUS
objc_module_type = build_pointer_type (xref_tag (RECORD_TYPE, get_identifier ("_OBJC_MODULES")));
#endif
#ifdef OBJC_INT_SELECTORS
selector_type = unsigned_type_node;
#else
selector_type
= build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)));
#endif
super_p = build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (TAG_SUPER)));
temp_type
= build_function_type (id_type,
tree_cons (NULL_TREE, id_type,
tree_cons (NULL_TREE, selector_type,
NULL_TREE)));
if (! flag_next_runtime)
{
umsg_decl = build_decl (FUNCTION_DECL,
get_identifier (TAG_MSGSEND), temp_type);
DECL_EXTERNAL (umsg_decl) = 1;
TREE_PUBLIC (umsg_decl) = 1;
DECL_INLINE (umsg_decl) = 1;
DECL_ARTIFICIAL (umsg_decl) = 1;
make_decl_rtl (umsg_decl, NULL_PTR, 1);
pushdecl (umsg_decl);
}
else
umsg_decl = builtin_function (TAG_MSGSEND, temp_type, NOT_BUILT_IN, 0);
temp_type
= build_function_type (id_type,
tree_cons (NULL_TREE, super_p,
tree_cons (NULL_TREE, selector_type,
NULL_TREE)));
umsg_super_decl = builtin_function (TAG_MSGSENDSUPER,
temp_type, NOT_BUILT_IN, 0);
{
tree stret_temp_type
= build_function_type (id_type,
tree_cons (NULL_TREE, id_type,
tree_cons (NULL_TREE, selector_type,
NULL_TREE)));
if (! flag_next_runtime)
fatal ("Assertion \"flag_next_runtime\" failed");
umsg_stret_decl =
builtin_function (TAG_MSGSEND_STRET, stret_temp_type, NOT_BUILT_IN, 0);
stret_temp_type
= build_function_type (id_type,
tree_cons (NULL_TREE, super_p,
tree_cons (NULL_TREE, selector_type,
NULL_TREE)));
umsg_super_stret_decl = builtin_function (TAG_MSGSENDSUPER_STRET,
stret_temp_type, NOT_BUILT_IN, 0);
}
#ifdef OBJCPLUS
temp_type = build_function_type (id_type,
tree_cons (NULL_TREE,
const_string_type_node,
void_list_node));
#else
temp_type = build_function_type (id_type,
tree_cons (NULL_TREE,
const_string_type_node,
tree_cons (NULL_TREE, void_type_node, NULL_TREE)));
#endif
objc_get_class_decl
= builtin_function (TAG_GETCLASS, temp_type, NOT_BUILT_IN, 0);
objc_get_orig_class_decl
= builtin_function (TAG_GETORIGCLASS, temp_type, NOT_BUILT_IN, 0);
objc_get_meta_class_decl
= builtin_function (TAG_GETMETACLASS, temp_type, NOT_BUILT_IN, 0);
#ifdef OBJCPLUS
{
extern tree unsigned_char_type_node;
temp_type = build_array_type (selector_type, unsigned_char_type_node);
}
#else
temp_type = build_array_type (selector_type, NULL_TREE);
#endif
layout_type (temp_type);
if (flag_selector_table)
{
UOBJC_SELECTOR_TABLE_decl
= create_builtin_decl (VAR_DECL, temp_type,
"_OBJC_SELECTOR_TABLE");
DECL_SIZE (UOBJC_SELECTOR_TABLE_decl) = 0;
TREE_USED (UOBJC_SELECTOR_TABLE_decl) = 1;
}
generate_forward_declaration_to_string_table ();
constant_string_id_old = get_identifier (STRING_OBJECT_CLASS_NAME_OLD);
constant_string_id_new = get_identifier (STRING_OBJECT_CLASS_NAME_NEW);
objc_declare_class(tree_cons (NULL_TREE, constant_string_id_old, NULL_TREE));
objc_declare_class(tree_cons (NULL_TREE, constant_string_id_new, NULL_TREE));
constant_string_type_old = xref_tag (RECORD_TYPE, constant_string_id_old);
constant_string_type_new = xref_tag (RECORD_TYPE, constant_string_id_new);
protocol_id = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
#ifdef OBJCPLUS
pop_lang_context ();
#endif
}
static tree
my_build_string (len, str)
int len;
char *str;
{
int wide_flag = 0;
tree a_string = build_string (len, str);
if (TREE_TYPE (a_string) == int_array_type_node)
wide_flag = 1;
TREE_TYPE (a_string)
= build_array_type (wide_flag ? integer_type_node : char_type_node,
build_index_type (build_int_2 (len - 1, 0)));
TREE_CONSTANT (a_string) = 1;
TREE_STATIC (a_string) = 1;
return a_string;
}
tree
build_objc_string (len, str)
int len;
char *str;
{
tree s = build_string (len, str);
TREE_SET_CODE (s, OBJC_STRING_CST);
return s;
}
tree
build_objc_string_object (strings)
tree strings;
{
tree string, initlist, constructor;
int length;
if (!doing_objc_thang)
objc_fatal ();
if (!constantStringTypeSet)
{
if (lookup_interface (constant_string_id_new) == NULL_TREE)
{
if (lookup_interface (constant_string_id_old) == NULL_TREE)
{
error ("Cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (constant_string_id_new));
return error_mark_node;
}
constant_string_id = constant_string_id_old;
constant_string_type = constant_string_type_old;
constantStringTypeSet = 1;
add_class_reference (constant_string_id);
}
else
{
constant_string_id = constant_string_id_new;
constant_string_type = constant_string_type_new;
constantStringTypeSet = 1;
}
}
string = combine_strings (strings);
TREE_SET_CODE (string, STRING_CST);
length = TREE_STRING_LENGTH (string) - 1;
{
struct obstack *save_current_obstack = current_obstack;
struct obstack *save_expression_obstack = expression_obstack;
current_obstack = &permanent_obstack;
expression_obstack = &permanent_obstack;
string = copy_node (string);
#ifdef NEXT_SEMANTICS
if (constant_string_id == constant_string_id_old)
#endif
initlist = build_tree_list (NULL_TREE, build_int_2 (0, 0));
#ifdef NEXT_SEMANTICS
else
{
setup_string_decl();
if (string_class_decl == NULL_TREE)
{
error ("Cannot find reference tag for class `%s'",
IDENTIFIER_POINTER (constant_string_id_new));
return error_mark_node;
}
initlist = build_tree_list
(NULL_TREE,
copy_node (build_unary_op (ADDR_EXPR, string_class_decl, 0)));
}
#endif
initlist = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, string, 1),
initlist);
initlist = tree_cons (NULL_TREE, build_int_2 (length, 0), initlist);
constructor = build_constructor (constant_string_type,
nreverse (initlist));
constructor = copy_node (constructor);
add_static_object (constructor, constant_string_id);
constructor = build_unary_op (ADDR_EXPR, constructor, 1);
current_obstack = save_current_obstack;
expression_obstack = save_expression_obstack;
}
return constructor;
}
static tree
build_constructor (type, elts)
tree type, elts;
{
tree constructor = build (CONSTRUCTOR, type, NULL_TREE, elts);
TREE_CONSTANT (constructor) = 1;
TREE_STATIC (constructor) = 1;
TREE_READONLY (constructor) = 1;
TREE_HAS_CONSTRUCTOR (constructor) = 1;
return constructor;
}
static void
build_objc_symtab_template ()
{
tree field_decl, field_decl_chain, index;
objc_symtab_template
= objcplus_start_struct (RECORD_TYPE, get_identifier (UTAG_SYMTAB));
field_decl = create_builtin_decl (FIELD_DECL,
long_integer_type_node,
"sel_ref_cnt");
field_decl_chain = field_decl;
field_decl = create_builtin_decl (FIELD_DECL,
build_pointer_type (selector_type),
"refs");
chainon (field_decl_chain, field_decl);
field_decl = create_builtin_decl (FIELD_DECL,
short_integer_type_node,
"cls_def_cnt");
chainon (field_decl_chain, field_decl);
field_decl = create_builtin_decl (FIELD_DECL,
short_integer_type_node,
"cat_def_cnt");
chainon (field_decl_chain, field_decl);
if (flag_static_objects)
{
field_decl = create_builtin_decl (FIELD_DECL,
long_integer_type_node,
"obj_def_cnt");
chainon (field_decl_chain, field_decl);
field_decl = create_builtin_decl (FIELD_DECL,
long_integer_type_node,
"proto_def_cnt");
chainon (field_decl_chain, field_decl);
}
index
= build_index_type (build_int_2 (imp_count + cat_count
+ obj_count + proto_count - 1,
(imp_count == 0
&& cat_count == 0
&& obj_count == 0
&& proto_count == 0)
? -1 : 0));
field_decl = create_builtin_decl (FIELD_DECL,
build_array_type (ptr_type_node, index),
"defs");
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (objc_symtab_template, field_decl_chain);
}
static tree
init_def_list (type)
tree type;
{
tree expr, initlist = NULL_TREE;
struct imp_entry *impent;
if (imp_count)
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
{
expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (cat_count)
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
#ifdef NEXT_PDO
if (obj_count)
{
tree elem;
for (elem = obj_def_chain; elem; elem = TREE_CHAIN (elem))
{
initlist = tree_cons (NULL_TREE, TREE_VALUE (elem), initlist);
}
}
if (proto_count)
{
tree elem;
for (elem = proto_def_chain; elem; elem = TREE_CHAIN (elem))
{
initlist = tree_cons (NULL_TREE, TREE_VALUE (elem), initlist);
}
}
#endif
return build_constructor (type, nreverse (initlist));
}
static tree
init_objc_symtab (type)
tree type;
{
tree initlist;
initlist = build_tree_list (NULL_TREE, build_int_2 (sel_count, 0));
if (! flag_selector_table || ! sel_ref_chain)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
initlist = tree_cons (NULL_TREE,
build_unary_op (ADDR_EXPR,
UOBJC_SELECTOR_TABLE_decl, 1),
initlist);
initlist = tree_cons (NULL_TREE, build_int_2 (imp_count, 0), initlist);
initlist = tree_cons (NULL_TREE, build_int_2 (cat_count, 0), initlist);
if (flag_static_objects) {
initlist = tree_cons (NULL_TREE, build_int_2 (obj_count, 0), initlist);
initlist = tree_cons (NULL_TREE, build_int_2 (proto_count, 0), initlist);
}
if (imp_count || cat_count || obj_count || proto_count)
{
tree field = TYPE_FIELDS (type);
while (TREE_CHAIN (field))
field = TREE_CHAIN (field);
initlist = tree_cons (NULL_TREE, init_def_list (TREE_TYPE (field)),
initlist);
}
return build_constructor (type, nreverse (initlist));
}
static void
forward_declare_categories ()
{
struct imp_entry *impent;
tree sav = implementation_context;
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
implementation_context = impent->imp_context;
impent->class_decl
= create_builtin_decl (VAR_DECL, objc_category_template,
IDENTIFIER_POINTER (synth_id_with_class_suffix ("_OBJC_CATEGORY", implementation_context)));
}
}
implementation_context = sav;
}
static void
generate_objc_symtab_decl ()
{
tree sc_spec;
if (!objc_category_template)
build_category_template ();
if (cat_count)
forward_declare_categories ();
if (!objc_symtab_template)
build_objc_symtab_template ();
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
UOBJC_SYMBOLS_decl = start_decl (get_identifier ("_OBJC_SYMBOLS"),
tree_cons (NULL_TREE, objc_symtab_template, sc_spec), 1);
end_temporary_allocation ();
TREE_USED (UOBJC_SYMBOLS_decl) = 1;
DECL_IGNORED_P (UOBJC_SYMBOLS_decl) = 1;
DECL_ARTIFICIAL (UOBJC_SYMBOLS_decl) = 1;
objcplus_finish_decl (UOBJC_SYMBOLS_decl,
init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)),
NULL_TREE);
}
static tree
init_module_descriptor (type)
tree type;
{
tree initlist, expr;
char *p;
expr = build_int_2 (OBJC_VERSION, 0);
initlist = build_tree_list (NULL_TREE, expr);
expr = size_in_bytes (objc_module_template);
initlist = tree_cons (NULL_TREE, expr, initlist);
#ifndef DIR_SEPARATOR
#define DIR_SEPARATOR '/'
#endif
p = input_filename + strlen (input_filename);
while (p != input_filename && p[-1] != '/' && p[-1] != DIR_SEPARATOR) --p;
expr = add_objc_string (get_identifier (p), class_names);
initlist = tree_cons (NULL_TREE, expr, initlist);
#if ! defined(NEXT_SEMANTICS) && ! defined(NEXT_PDO)
if (!flag_next_runtime)
{
if (static_instances_decl)
expr = build_unary_op (ADDR_EXPR, static_instances_decl, 0);
else
expr = build_int_2 (0, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
#endif
if (UOBJC_SYMBOLS_decl)
expr = build_unary_op (ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
else
expr = build_int_2 (0, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
return build_constructor (type, nreverse (initlist));
}
static char *
build_module_descriptor ()
{
tree decl_specs, field_decl, field_decl_chain;
objc_module_template
= objcplus_start_struct (RECORD_TYPE, get_identifier (UTAG_MODULE));
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("version");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("size");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = get_identifier (UTAG_SYMTAB);
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE, decl_specs));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("symtab"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (objc_module_template, field_decl_chain);
decl_specs = tree_cons (NULL_TREE, objc_module_template,
build_tree_list (NULL_TREE,
ridpointers[(int) RID_STATIC]));
UOBJC_MODULES_decl = start_decl (get_identifier ("_OBJC_MODULES"),
decl_specs, 1);
end_temporary_allocation ();
DECL_IGNORED_P (UOBJC_MODULES_decl) = 1;
objcplus_finish_decl (UOBJC_MODULES_decl,
init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)),
NULL_TREE);
DECL_IN_SYSTEM_HEADER (UOBJC_MODULES_decl) = 1;
#ifndef NEXT_PDO
if (flag_next_runtime)
return 0;
#endif
{
tree parms, function_decl, decelerator, void_list_node;
tree function_type;
extern tree get_file_function_name ();
tree init_function_name;
#ifdef NEXT_PDO
static char cname[256];
extern char *first_global_object_name;
extern char *second_global_object_name;
strcpy(cname, "_GLOBAL_$I$_OBJC_INIT_FUNCTION_");
if (first_global_object_name)
strcat(cname, first_global_object_name);
else if (second_global_object_name)
strcat(cname, second_global_object_name);
init_function_name = get_identifier (cname);
#else
init_function_name = get_file_function_name ('I');
#endif
void_list_node = build_tree_list (NULL_TREE, void_type_node);
function_type
= build_function_type (void_type_node,
tree_cons (NULL_TREE, ptr_type_node,
void_list_node));
#ifdef OBJCPLUS
function_decl = build_lang_decl (FUNCTION_DECL,
get_identifier (TAG_EXECCLASS),
function_type);
#else
function_decl = build_decl (FUNCTION_DECL,
get_identifier (TAG_EXECCLASS),
function_type);
#endif
DECL_EXTERNAL (function_decl) = 1;
DECL_ARTIFICIAL (function_decl) = 1;
TREE_PUBLIC (function_decl) = 1;
pushdecl (function_decl);
rest_of_decl_compilation (function_decl, 0, 0, 0);
parms
= build_tree_list (NULL_TREE,
build_unary_op (ADDR_EXPR, UOBJC_MODULES_decl, 0));
decelerator = build_function_call (function_decl, parms);
{ tree parmlist;
#ifdef OBJCPLUS
parmlist = build_tree_list (NULL_TREE, void_type_node);
TREE_PARMLIST (parmlist) = 1; push_lang_context (lang_name_c);
#else
parmlist = tree_cons (NULL_TREE, NULL_TREE, void_list_node);
#endif
start_function (void_list_node,
build_parse_node (CALL_EXPR, init_function_name,
parmlist, NULL_TREE),
NULL_TREE, NULL_TREE, 0);
}
#ifndef OBJCPLUS
pop_lang_context ();
#endif
#if defined (_WIN32) && defined (NEXT_PDO)
TREE_PUBLIC (current_function_decl) = 0;
#endif
#ifndef OBJCPLUS
TREE_USED (current_function_decl) = 1;
#endif
store_parm_decls ();
assemble_external (function_decl);
#ifndef OBJCPLUS
c_expand_expr_stmt (decelerator);
#else
#if 1
pushlevel (0);
clear_last_expr ();
push_momentary ();
expand_start_bindings (0);
c_expand_expr_stmt (decelerator);
expand_end_bindings (getdecls(), 1, 0);
poplevel (1, 0, 0);
pop_momentary ();
#endif
#endif
objcplus_finish_function (0);
#ifdef OBJCPLUS
pop_lang_context ();
#endif
return IDENTIFIER_POINTER (init_function_name);
}
}
static void
generate_forward_declaration_to_string_table ()
{
tree sc_spec, decl_specs, expr_decl;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_EXTERN], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
expr_decl
= build_nt (ARRAY_REF, get_identifier ("_OBJC_STRINGS"), NULL_TREE);
UOBJC_STRINGS_decl = define_decl (expr_decl, decl_specs);
}
static void
generate_strings ()
{
tree sc_spec, decl_specs, expr_decl;
tree chain, string_expr;
tree string, decl;
for (chain = class_names_chain; chain; chain = TREE_CHAIN (chain))
{
string = TREE_VALUE (chain);
decl = TREE_PURPOSE (chain);
sc_spec
= tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULL_TREE);
decl = start_decl (expr_decl, decl_specs, 1);
end_temporary_allocation ();
string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
IDENTIFIER_POINTER (string));
objcplus_finish_decl (decl, string_expr, NULL_TREE);
}
for (chain = meth_var_names_chain; chain; chain = TREE_CHAIN (chain))
{
string = TREE_VALUE (chain);
decl = TREE_PURPOSE (chain);
sc_spec
= tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULL_TREE);
decl = start_decl (expr_decl, decl_specs, 1);
end_temporary_allocation ();
string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
IDENTIFIER_POINTER (string));
objcplus_finish_decl (decl, string_expr, NULL_TREE);
}
for (chain = meth_var_types_chain; chain; chain = TREE_CHAIN (chain))
{
string = TREE_VALUE (chain);
decl = TREE_PURPOSE (chain);
sc_spec
= tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULL_TREE);
decl = start_decl (expr_decl, decl_specs, 1);
end_temporary_allocation ();
string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
IDENTIFIER_POINTER (string));
objcplus_finish_decl (decl, string_expr, NULL_TREE);
}
}
static tree
get_proto_encoding (proto)
tree proto;
{
tree encoding;
if (proto)
{
tree tmp_decl;
if (! METHOD_ENCODING (proto))
{
tmp_decl = build_tmp_function_decl ();
hack_method_prototype (proto, tmp_decl);
encoding = encode_method_prototype (proto, tmp_decl);
METHOD_ENCODING (proto) = encoding;
}
else
encoding = METHOD_ENCODING (proto);
return add_objc_string (encoding, meth_var_types);
}
else
return build_int_2 (0, 0);
}
static tree
build_typed_selector_reference (ident, proto)
tree ident, proto;
{
tree *chain = &sel_ref_chain;
tree expr;
int index = 0;
while (*chain)
{
if (TREE_PURPOSE (*chain) == ident && TREE_VALUE (*chain) == proto)
goto return_at_index;
index++;
chain = &TREE_CHAIN (*chain);
}
*chain = perm_tree_cons (proto, ident, NULL_TREE);
return_at_index:
expr = build_unary_op (ADDR_EXPR,
build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_2 (index, 0)),
1);
return build_c_cast (selector_type, expr);
}
static tree
build_selector_reference_decl (name)
tree name;
{
tree decl, ident;
char buf[256];
struct obstack *save_current_obstack = current_obstack;
struct obstack *save_rtl_obstack = rtl_obstack;
static int idx = 0;
sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", idx++);
rtl_obstack = current_obstack = &permanent_obstack;
ident = get_identifier (buf);
#ifdef MACHO_PIC
machopic_define_ident (ident);
#endif
decl = build_decl (VAR_DECL, ident, selector_type);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
TREE_USED (decl) = 1;
TREE_READONLY (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
DECL_CONTEXT (decl) = 0;
make_decl_rtl (decl, 0, 1);
pushdecl_top_level (decl);
current_obstack = save_current_obstack;
rtl_obstack = save_rtl_obstack;
return decl;
}
static tree
build_selector (ident)
tree ident;
{
tree expr = add_objc_string (ident, meth_var_names);
if (flag_typed_selectors)
return expr;
else
return build_c_cast (selector_type, expr);
}
static tree
build_msg_pool_reference (offset)
int offset;
{
tree expr = build_int_2 (offset, 0);
tree cast;
expr = build_array_ref (UOBJC_STRINGS_decl, expr);
expr = build_unary_op (ADDR_EXPR, expr, 0);
cast = build_tree_list (build_tree_list (NULL_TREE,
ridpointers[(int) RID_CHAR]),
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE));
TREE_TYPE (expr) = groktypename (cast);
return expr;
}
static tree
init_selector (offset)
int offset;
{
tree expr = build_msg_pool_reference (offset);
TREE_TYPE (expr) = selector_type;
return expr;
}
static void
build_selector_translation_table ()
{
tree sc_spec, decl_specs;
tree chain, initlist = NULL_TREE;
int offset = 0;
tree decl, var_decl, name;
if (flag_selector_table)
push_obstacks_nochange ();
for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
{
tree expr;
expr = build_selector (TREE_VALUE (chain));
if (! flag_selector_table)
{
name = DECL_NAME (TREE_PURPOSE (chain));
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
decl_specs = tree_cons (NULL_TREE, selector_type, sc_spec);
var_decl = name;
decl = start_decl (var_decl, decl_specs, 1);
}
offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;
if (! flag_selector_table)
{
end_temporary_allocation ();
objcplus_finish_decl (decl, expr, NULL_TREE);
}
else
{
if (flag_typed_selectors)
{
tree eltlist = NULL_TREE;
tree encoding = get_proto_encoding (TREE_PURPOSE (chain));
eltlist = tree_cons (NULL_TREE, expr, NULL_TREE);
eltlist = tree_cons (NULL_TREE, encoding, eltlist);
expr = build_constructor (objc_selector_template,
nreverse (eltlist));
}
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (flag_selector_table)
{
DECL_EXTERNAL (UOBJC_SELECTOR_TABLE_decl) = 0;
TREE_STATIC (UOBJC_SELECTOR_TABLE_decl) = 1;
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
DECL_INITIAL (UOBJC_SELECTOR_TABLE_decl) = (tree) 1;
#ifdef OBJCPLUS
TREE_TYPE (UOBJC_SELECTOR_TABLE_decl) = build_array_type (selector_type, NULL_TREE);
#endif
initlist = build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
nreverse (initlist));
objcplus_finish_decl (UOBJC_SELECTOR_TABLE_decl, initlist, NULL_TREE);
}
}
static tree
build_selector_reference (ident)
tree ident;
{
tree *chain = &sel_ref_chain;
tree expr;
int index = 0;
#ifdef NEXT_PDO
sel_count++;
#endif
while (*chain)
{
if (TREE_VALUE (*chain) == ident)
return ((flag_selector_table == 0)
? TREE_PURPOSE (*chain)
: build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_2 (index, 0)));
index++;
chain = &TREE_CHAIN (*chain);
}
if (flag_selector_table)
expr = build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_2 (index, 0));
else
expr = build_selector_reference_decl (ident);
*chain = perm_tree_cons (expr, ident, NULL_TREE);
return expr;
}
#define OBJECT_CLASS_POINTER(CONSTR) TREE_VALUE(CONSTRUCTOR_ELTS (object))
#if defined (NEXT_SEMANTICS) || defined (NEXT_PDO)
static void
add_static_object (object, ident)
tree object;
tree ident;
{
tree chain;
tree addr;
if (!flag_static_objects)
return;
preserve_data ();
#if 0
if (TREE_CODE (object) == CONSTRUCTOR)
chain = CONSTRUCTOR_ELTS (object);
else
abort ();
#endif
if (TREE_CODE (ident) != IDENTIFIER_NODE)
abort ();
TREE_READONLY (object) = 0;
if (TREE_TYPE(object))
TYPE_READONLY (TREE_TYPE (object)) = 0;
#ifdef XXX
TREE_VALUE (chain) = add_objc_string (ident, class_names);
#endif
if (mark_addressable (object))
{
struct obstack *ambient_obstack = current_obstack;
struct obstack *save_expr_stack = expression_obstack;
current_obstack = &permanent_obstack;
expression_obstack = &permanent_obstack;
if (ident == protocol_id)
{
proto_def_chain
= tree_cons (NULL_TREE,
copy_node (build_unary_op (ADDR_EXPR, object, 1)),
proto_def_chain);
proto_count += 1;
}
else
{
obj_def_chain
= tree_cons (NULL_TREE,
copy_node (build_unary_op (ADDR_EXPR, object, 1)),
obj_def_chain);
obj_count += 1;
}
add_class_reference (ident);
current_obstack = ambient_obstack;
expression_obstack = save_expr_stack;
}
else
abort ();
}
#endif
static tree
build_class_reference_decl (name)
tree name;
{
tree decl, ident;
char buf[256];
struct obstack *save_current_obstack = current_obstack;
struct obstack *save_rtl_obstack = rtl_obstack;
static int idx = 0;
sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", idx++);
rtl_obstack = current_obstack = &permanent_obstack;
ident = get_identifier (buf);
#ifdef MACHO_PIC
machopic_define_ident (ident);
#endif
decl = build_decl (VAR_DECL, ident, objc_class_type);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
TREE_USED (decl) = 1;
TREE_READONLY (decl) = 1;
DECL_CONTEXT (decl) = 0;
DECL_ARTIFICIAL (decl) = 1;
make_decl_rtl (decl, 0, 1);
pushdecl_top_level (decl);
current_obstack = save_current_obstack;
rtl_obstack = save_rtl_obstack;
return decl;
}
static void
add_class_reference (ident)
tree ident;
{
tree chain;
if ((chain = cls_ref_chain))
{
tree tail;
do
{
if (ident == TREE_VALUE (chain))
return;
tail = chain;
chain = TREE_CHAIN (chain);
}
while (chain);
TREE_CHAIN (tail) = perm_tree_cons (NULL_TREE, ident, NULL_TREE);
}
else
cls_ref_chain = perm_tree_cons (NULL_TREE, ident, NULL_TREE);
}
tree
get_class_reference (ident)
tree ident;
{
if (flag_class_references)
{
tree *chain;
tree decl;
for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
if (TREE_VALUE (*chain) == ident)
{
if (! TREE_PURPOSE (*chain))
TREE_PURPOSE (*chain) = build_class_reference_decl (ident);
return TREE_PURPOSE (*chain);
}
decl = build_class_reference_decl (ident);
*chain = perm_tree_cons (decl, ident, NULL_TREE);
return decl;
}
else
{
tree params;
add_class_reference (ident);
params = build_tree_list (NULL_TREE,
my_build_string (IDENTIFIER_LENGTH (ident) + 1,
IDENTIFIER_POINTER (ident)));
assemble_external (objc_get_class_decl);
return build_function_call (objc_get_class_decl, params);
}
}
tree
get_orig_class_reference (ident)
tree ident;
{
tree params;
add_class_reference (ident);
params = build_tree_list (NULL_TREE,
my_build_string (IDENTIFIER_LENGTH (ident) + 1,
IDENTIFIER_POINTER (ident)));
assemble_external (objc_get_orig_class_decl);
return build_function_call (objc_get_orig_class_decl, params);
}
static tree
add_objc_string (ident, section)
tree ident;
enum string_section section;
{
tree *chain, decl;
if (section == class_names)
chain = &class_names_chain;
else if (section == meth_var_names)
chain = &meth_var_names_chain;
else if (section == meth_var_types)
chain = &meth_var_types_chain;
while (*chain)
{
if (TREE_VALUE (*chain) == ident)
return build_unary_op (ADDR_EXPR, TREE_PURPOSE (*chain), 1);
chain = &TREE_CHAIN (*chain);
}
decl = build_objc_string_decl (ident, section);
*chain = perm_tree_cons (decl, ident, NULL_TREE);
return build_unary_op (ADDR_EXPR, decl, 1);
}
static tree
build_objc_string_decl (name, section)
tree name;
enum string_section section;
{
tree decl, ident;
char buf[256];
struct obstack *save_current_obstack = current_obstack;
struct obstack *save_rtl_obstack = rtl_obstack;
static int class_names_idx = 0;
static int meth_var_names_idx = 0;
static int meth_var_types_idx = 0;
if (section == class_names)
sprintf (buf, "_OBJC_CLASS_NAME_%d", class_names_idx++);
else if (section == meth_var_names)
sprintf (buf, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
else if (section == meth_var_types)
sprintf (buf, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
rtl_obstack = current_obstack = &permanent_obstack;
ident = get_identifier (buf);
decl = build_decl (VAR_DECL, ident, build_array_type (char_type_node, 0));
#ifdef OBJCPLUS
DECL_ARTIFICIAL (decl) = 1;
#endif
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 0;
TREE_USED (decl) = 1;
#ifndef OBJCPLUS // temporary...need to add CONST to generate_strings
TREE_READONLY (decl) = 1;
#endif
TREE_CONSTANT (decl) = 1;
make_decl_rtl (decl, 0, 1);
pushdecl_top_level (decl);
current_obstack = save_current_obstack;
rtl_obstack = save_rtl_obstack;
return decl;
}
void
objc_declare_alias (alias_ident, class_ident)
tree alias_ident;
tree class_ident;
{
if (!doing_objc_thang)
objc_fatal ();
#ifdef OBJCPLUS
if(current_namespace != global_namespace) {
error("Objective-C declarations may only appear in global scope");
}
#endif
if (is_class_name (class_ident) != class_ident)
warning ("Cannot find class `%s'", IDENTIFIER_POINTER (class_ident));
else if (is_class_name (alias_ident))
warning ("Class `%s' already exists", IDENTIFIER_POINTER (alias_ident));
else
alias_chain = tree_cons (class_ident, alias_ident, alias_chain);
}
void
objc_declare_class (ident_list)
tree ident_list;
{
tree list;
if (!doing_objc_thang)
objc_fatal ();
#ifdef OBJCPLUS
if(current_namespace != global_namespace) {
error("Objective-C declarations may only appear in global scope");
}
#endif
for (list = ident_list; list; list = TREE_CHAIN (list))
{
tree ident = TREE_VALUE (list);
tree decl;
#ifdef OBJCPLUS
if (((decl = objcplus_lookup_name (ident)) != 0) && !is_class_name(ident))
#else
if ((decl = objcplus_lookup_name (ident)) != 0)
#endif
{
error ("`%s' redeclared as different kind of symbol",
IDENTIFIER_POINTER (ident));
error_with_decl (decl, "previous declaration of `%s'");
}
if (! is_class_name (ident))
{
tree record;
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
record = xref_tag (RECORD_TYPE, ident);
#ifdef OBJCPLUS
pop_lang_context ();
#endif
TREE_STATIC_TEMPLATE (record) = 1;
class_chain = tree_cons (NULL_TREE, ident, class_chain);
}
}
}
tree
is_class_name (ident)
tree ident;
{
tree chain;
if (lookup_interface (ident))
return ident;
for (chain = class_chain; chain; chain = TREE_CHAIN (chain))
{
if (ident == TREE_VALUE (chain))
return ident;
}
for (chain = alias_chain; chain; chain = TREE_CHAIN (chain))
{
if (ident == TREE_VALUE (chain))
return TREE_PURPOSE (chain);
}
return 0;
}
tree
lookup_interface (ident)
tree ident;
{
tree chain;
for (chain = interface_chain; chain; chain = TREE_CHAIN (chain))
{
if (ident == CLASS_NAME (chain))
return chain;
}
return NULL_TREE;
}
static tree
objc_copy_list (list, head)
tree list;
tree *head;
{
tree newlist = NULL_TREE, tail = NULL_TREE;
while (list)
{
tail = copy_node (list);
if (DECL_BIT_FIELD (tail) && DECL_INITIAL (tail) == 0)
DECL_INITIAL (tail) = build_int_2 (DECL_FIELD_SIZE (tail), 0);
newlist = chainon (newlist, tail);
list = TREE_CHAIN (list);
}
*head = newlist;
return tail;
}
static tree
build_ivar_chain (interface, copy)
tree interface;
int copy;
{
tree my_name, super_name, ivar_chain;
my_name = CLASS_NAME (interface);
super_name = CLASS_SUPER_NAME (interface);
if (copy)
objc_copy_list (CLASS_IVARS (interface), &ivar_chain);
else
ivar_chain = CLASS_IVARS (interface);
while (super_name)
{
tree op1;
tree super_interface = lookup_interface (super_name);
if (!super_interface)
{
error ("Cannot find interface declaration for `%s', superclass of `%s'",
IDENTIFIER_POINTER (super_name),
IDENTIFIER_POINTER (my_name));
exit (FATAL_EXIT_CODE);
}
if (super_interface == interface)
{
fatal ("Circular inheritance in interface declaration for `%s'",
IDENTIFIER_POINTER (super_name));
}
interface = super_interface;
my_name = CLASS_NAME (interface);
super_name = CLASS_SUPER_NAME (interface);
op1 = CLASS_IVARS (interface);
if (op1)
{
tree head, tail = objc_copy_list (op1, &head);
TREE_CHAIN (tail) = ivar_chain;
ivar_chain = head;
}
}
return ivar_chain;
}
static tree
build_private_template (class)
tree class;
{
tree ivar_context;
if (CLASS_STATIC_TEMPLATE (class))
{
uprivate_record = CLASS_STATIC_TEMPLATE (class);
ivar_context = TYPE_FIELDS (CLASS_STATIC_TEMPLATE (class));
}
else
{
uprivate_record = objcplus_start_struct (RECORD_TYPE, CLASS_NAME (class));
ivar_context = build_ivar_chain (class, 0);
objcplus_finish_struct (uprivate_record, ivar_context);
CLASS_STATIC_TEMPLATE (class) = uprivate_record;
TREE_STATIC_TEMPLATE (uprivate_record) = 1;
}
instance_type
= groktypename (build_tree_list (build_tree_list (NULL_TREE,
uprivate_record),
build1 (INDIRECT_REF, NULL_TREE,
NULL_TREE)));
return ivar_context;
}
static tree
build_protocol_template ()
{
tree decl_specs, field_decl, field_decl_chain;
tree template;
template = objcplus_start_struct (RECORD_TYPE, get_identifier (UTAG_PROTOCOL));
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_CLASS)));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("isa"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, template);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_list"));
field_decl = build1 (INDIRECT_REF, NULL_TREE, field_decl);
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs
= build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("instance_methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs
= build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class_methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
#ifdef OBJC_HPUX_PADDING
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("risc_pad"));
field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
#endif
return objcplus_finish_struct (template, field_decl_chain);
}
static tree
build_descriptor_table_initializer (type, entries)
tree type;
tree entries;
{
tree initlist = NULL_TREE;
do
{
tree eltlist = NULL_TREE;
eltlist
= tree_cons (NULL_TREE,
build_selector (METHOD_SEL_NAME (entries)), NULL_TREE);
eltlist
= tree_cons (NULL_TREE,
add_objc_string (METHOD_ENCODING (entries),
meth_var_types),
eltlist);
initlist
= tree_cons (NULL_TREE,
build_constructor (type, nreverse (eltlist)), initlist);
entries = TREE_CHAIN (entries);
}
while (entries);
return build_constructor (build_array_type (type, 0), nreverse (initlist));
}
static tree
build_method_prototype_list_template (list_type, size)
tree list_type;
int size;
{
tree objc_ivar_list_record;
tree decl_specs, field_decl, field_decl_chain;
objc_ivar_list_record = objcplus_start_struct (RECORD_TYPE, NULL_TREE);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
field_decl = get_identifier ("method_count");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = build_tree_list (NULL_TREE, list_type);
field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
build_int_2 (size, 0));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (objc_ivar_list_record, field_decl_chain);
return objc_ivar_list_record;
}
static tree
build_method_prototype_template ()
{
tree proto_record;
tree decl_specs, field_decl, field_decl_chain;
proto_record
= objcplus_start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD_PROTOTYPE));
#ifdef OBJC_INT_SELECTORS
decl_specs
= tree_cons (NULL_TREE, ridpointers[(int) RID_UNSIGNED], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_INT], decl_specs);
field_decl = get_identifier ("_cmd");
#else
decl_specs = tree_cons (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)), NULL_TREE);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("_cmd"));
#endif
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], NULL_TREE);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("method_types"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (proto_record, field_decl_chain);
return proto_record;
}
static int offset_is_register;
static int
forwarding_offset (parm)
tree parm;
{
int offset_in_bytes;
if (GET_CODE (DECL_INCOMING_RTL (parm)) == MEM)
{
rtx addr = XEXP (DECL_INCOMING_RTL (parm), 0);
if (GET_CODE (addr) == PLUS
&& GET_CODE (XEXP (addr, 1)) == CONST_INT)
offset_in_bytes = INTVAL (XEXP (addr, 1));
else
offset_in_bytes = 0;
if (flag_next_runtime)
offset_in_bytes += OBJC_FORWARDING_STACK_OFFSET;
offset_is_register = 0;
}
else if (GET_CODE (DECL_INCOMING_RTL (parm)) == REG)
{
int regno = REGNO (DECL_INCOMING_RTL (parm));
#ifdef OBJC_FORWARDING_REG_OFFSET
if (flag_next_runtime)
{
OBJC_FORWARDING_REG_OFFSET (offset_is_register, offset_in_bytes, regno);
}
else
#endif
{
offset_in_bytes = apply_args_register_offset (regno);
offset_is_register = 1;
}
}
else
return 0;
#if BYTES_BIG_ENDIAN
if (TREE_TYPE (parm) != DECL_ARG_TYPE (parm))
offset_in_bytes += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parm)))
- GET_MODE_SIZE (GET_MODE (DECL_RTL (parm))));
#endif
return offset_in_bytes;
}
static tree
encode_method_prototype (method_decl, func_decl)
tree method_decl;
tree func_decl;
{
tree parms;
int stack_size, i;
tree user_args;
int max_parm_end = 0;
char buf[40];
tree result;
encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl)));
encode_type (TREE_TYPE (TREE_TYPE (func_decl)),
obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
for (parms = DECL_ARGUMENTS (func_decl); parms;
parms = TREE_CHAIN (parms))
{
int parm_end = forwarding_offset (parms);
if (parm_end > 0)
parm_end += TREE_INT_CST_LOW (objcplus_TYPE_SIZE (TREE_TYPE (parms))) / BITS_PER_UNIT;
else
parm_end = -parm_end;
if (max_parm_end < parm_end)
max_parm_end = parm_end;
}
stack_size = max_parm_end - ( flag_next_runtime
? OBJC_FORWARDING_MIN_OFFSET
: 0);
sprintf (buf, "%d", stack_size);
obstack_grow (&util_obstack, buf, strlen (buf));
user_args = METHOD_SEL_ARGS (method_decl);
for (parms = DECL_ARGUMENTS (func_decl), i = 0; parms;
parms = TREE_CHAIN (parms), i++)
{
if (i > 1)
{
encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (user_args)));
user_args = TREE_CHAIN (user_args);
}
encode_type (TREE_TYPE (parms),
obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
sprintf (buf, "%d", forwarding_offset (parms));
#ifndef TARGET_SPARC
if (offset_is_register && !flag_next_runtime)
obstack_1grow (&util_obstack, '+');
#endif
obstack_grow (&util_obstack, buf, strlen (buf));
}
obstack_1grow (&util_obstack, '\0');
result = get_identifier (obstack_finish (&util_obstack));
obstack_free (&util_obstack, util_firstobj);
return result;
}
static tree
generate_descriptor_table (type, name, size, list, proto)
tree type;
char *name;
int size;
tree list;
tree proto;
{
tree sc_spec, decl_specs, decl, initlist;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, type, sc_spec);
decl = start_decl (synth_id_with_class_suffix (name, proto),
decl_specs, 1);
end_temporary_allocation ();
initlist = build_tree_list (NULL_TREE, build_int_2 (size, 0));
initlist = tree_cons (NULL_TREE, list, initlist);
objcplus_finish_decl (decl, build_constructor (type, nreverse (initlist)),
NULL_TREE);
return decl;
}
static void
generate_method_descriptors (protocol)
tree protocol;
{
static tree objc_method_prototype_template;
tree initlist, chain, method_list_template;
tree cast, variable_length_type;
int size;
if (!objc_method_prototype_template)
objc_method_prototype_template = build_method_prototype_template ();
cast = build_tree_list (build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_PROTOTYPE_LIST))),
NULL_TREE);
variable_length_type = groktypename (cast);
chain = PROTOCOL_CLS_METHODS (protocol);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_prototype_list_template (objc_method_prototype_template,
size);
initlist
= build_descriptor_table_initializer (objc_method_prototype_template,
chain);
UOBJC_CLASS_METHODS_decl
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_CLASS_METHODS",
size, initlist, protocol);
TREE_TYPE (UOBJC_CLASS_METHODS_decl) = variable_length_type;
}
else
UOBJC_CLASS_METHODS_decl = 0;
chain = PROTOCOL_NST_METHODS (protocol);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_prototype_list_template (objc_method_prototype_template,
size);
initlist
= build_descriptor_table_initializer (objc_method_prototype_template,
chain);
UOBJC_INSTANCE_METHODS_decl
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_INSTANCE_METHODS",
size, initlist, protocol);
TREE_TYPE (UOBJC_INSTANCE_METHODS_decl) = variable_length_type;
}
else
UOBJC_INSTANCE_METHODS_decl = 0;
}
static tree
build_tmp_function_decl ()
{
tree decl_specs, expr_decl, parms;
static int xxx = 0;
char buffer[80];
pushlevel (0);
decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
objcplus_push_parm_decl (build_tree_list
(build_tree_list (decl_specs,
build1 (INDIRECT_REF, NULL_TREE,
NULL_TREE)),
build_tree_list (NULL_TREE, NULL_TREE)));
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)));
expr_decl = build1 (INDIRECT_REF, NULL_TREE, NULL_TREE);
objcplus_push_parm_decl (build_tree_list (build_tree_list (decl_specs, expr_decl),
build_tree_list (NULL_TREE, NULL_TREE)));
parms = objcplus_get_parm_info (0);
poplevel (0, 0, 0);
decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
sprintf (buffer, "__objc_tmp_%x", xxx++);
expr_decl = build_nt (CALL_EXPR, get_identifier (buffer), parms, NULL_TREE);
expr_decl = build1 (INDIRECT_REF, NULL_TREE, expr_decl);
return define_decl (expr_decl, decl_specs);
}
static void
hack_method_prototype (nst_methods, tmp_decl)
tree nst_methods;
tree tmp_decl;
{
tree parms;
#ifdef OBJCPLUS
extern tree last_function_parms;
#endif
TREE_SET_CODE (nst_methods, CLASS_METHOD_DECL);
start_method_def (nst_methods);
TREE_SET_CODE (nst_methods, INSTANCE_METHOD_DECL);
if (METHOD_ADD_ARGS (nst_methods) == (tree) 1)
parms = objcplus_get_parm_info (0);
else
parms = objcplus_get_parm_info (1);
poplevel (0, 0, 0);
init_emit ();
temp_slots = 0;
#ifdef OBJCPLUS
grokparms (parms, 1);
DECL_ARGUMENTS(tmp_decl) = last_function_parms;
#else
DECL_ARGUMENTS(tmp_decl) = TREE_PURPOSE(parms);
#endif
{
tree restype = TREE_TYPE (TREE_TYPE (tmp_decl));
if (TREE_CODE (restype) == INTEGER_TYPE
&& TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
restype = integer_type_node;
DECL_RESULT (tmp_decl) = build_decl (RESULT_DECL, 0, restype);
}
assign_parms (tmp_decl, 0);
TREE_TYPE (TREE_TYPE (tmp_decl)) = groktypename (TREE_TYPE (nst_methods));
}
static void
generate_protocol_references (plist)
tree plist;
{
tree lproto;
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
{
tree proto = TREE_VALUE (lproto);
if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_NAME (proto))
{
if (! PROTOCOL_FORWARD_DECL (proto))
build_protocol_reference (proto);
if (PROTOCOL_LIST (proto))
generate_protocol_references (PROTOCOL_LIST (proto));
}
}
}
static void
generate_protocols ()
{
tree p, tmp_decl, encoding;
tree sc_spec, decl_specs, decl;
tree initlist, protocol_name_expr, refs_decl, refs_expr;
tree cast_type2 = 0;
tmp_decl = build_tmp_function_decl ();
if (! objc_protocol_template)
objc_protocol_template = build_protocol_template ();
for (p = protocol_chain; p; p = TREE_CHAIN (p))
if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p))
generate_protocol_references (PROTOCOL_LIST (p));
for (p = protocol_chain; p; p = TREE_CHAIN (p))
{
tree nst_methods = PROTOCOL_NST_METHODS (p);
tree cls_methods = PROTOCOL_CLS_METHODS (p);
if (! PROTOCOL_FORWARD_DECL (p))
continue;
add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
while (nst_methods)
{
if (! METHOD_ENCODING (nst_methods))
{
hack_method_prototype (nst_methods, tmp_decl);
encoding = encode_method_prototype (nst_methods, tmp_decl);
METHOD_ENCODING (nst_methods) = encoding;
}
nst_methods = TREE_CHAIN (nst_methods);
}
while (cls_methods)
{
if (! METHOD_ENCODING (cls_methods))
{
hack_method_prototype (cls_methods, tmp_decl);
encoding = encode_method_prototype (cls_methods, tmp_decl);
METHOD_ENCODING (cls_methods) = encoding;
}
cls_methods = TREE_CHAIN (cls_methods);
}
generate_method_descriptors (p);
if (PROTOCOL_LIST (p))
refs_decl = generate_protocol_list (p);
else
refs_decl = 0;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC],
NULL_TREE);
decl_specs = tree_cons (NULL_TREE, objc_protocol_template, sc_spec);
decl = start_decl (synth_id_with_class_suffix ("_OBJC_PROTOCOL", p),
decl_specs, 1);
end_temporary_allocation ();
protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
if (refs_decl)
{
if (!cast_type2)
cast_type2
= groktypename
(build_tree_list (build_tree_list (NULL_TREE,
objc_protocol_template),
build1 (INDIRECT_REF, NULL_TREE,
build1 (INDIRECT_REF, NULL_TREE,
NULL_TREE))));
refs_expr = build_unary_op (ADDR_EXPR, refs_decl, 0);
TREE_TYPE (refs_expr) = cast_type2;
}
else
refs_expr = build_int_2 (0, 0);
initlist = build_protocol_initializer (TREE_TYPE (decl),
protocol_name_expr, refs_expr,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_CLASS_METHODS_decl);
TREE_PUBLIC (decl) = 0;
objcplus_finish_decl (decl, initlist, NULL_TREE);
TREE_USED (decl) = 1;
}
}
static tree
build_protocol_initializer (type, protocol_name, protocol_list,
instance_methods, class_methods)
tree type;
tree protocol_name;
tree protocol_list;
tree instance_methods;
tree class_methods;
{
tree initlist = NULL_TREE, expr;
static tree cast_type = 0;
struct obstack *save_current_obstack = current_obstack;
struct obstack *save_expression_obstack = expression_obstack;
if (!cast_type)
cast_type
= groktypename
(build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_CLASS))),
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE)));
expr = build_int_2 (PROTOCOL_VERSION, 0);
TREE_TYPE (expr) = cast_type;
initlist = tree_cons (NULL_TREE, expr, initlist);
initlist = tree_cons (NULL_TREE, protocol_name, initlist);
initlist = tree_cons (NULL_TREE, protocol_list, initlist);
if (!instance_methods)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!class_methods)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, class_methods, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return build_constructor (type, nreverse (initlist));
}
static void
build_category_template ()
{
tree decl_specs, field_decl, field_decl_chain;
objc_category_template = objcplus_start_struct (RECORD_TYPE,
get_identifier (UTAG_CATEGORY));
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("category_name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class_name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_LIST)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("instance_methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_LIST)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class_methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_list"));
field_decl = build1 (INDIRECT_REF, NULL_TREE, field_decl);
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (objc_category_template, field_decl_chain);
}
#ifndef NEXT_PDO
static void
build_selector_template ()
{
tree decl_specs, field_decl, field_decl_chain;
objc_selector_template
= objcplus_start_struct (RECORD_TYPE, get_identifier (UTAG_SELECTOR));
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sel_id"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sel_type"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (objc_selector_template, field_decl_chain);
}
#endif
static void
build_class_template ()
{
int save_flag_dump_symbols = flag_dump_symbols;
int save_flag_gen_index = flag_gen_index;
tree decl_specs, field_decl, field_decl_chain;
flag_dump_symbols = 0;
flag_gen_index = 0;
objc_class_template
= objcplus_start_struct (RECORD_TYPE, get_identifier (UTAG_CLASS));
decl_specs = build_tree_list (NULL_TREE, objc_class_template);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("isa"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = build_tree_list (NULL_TREE, objc_class_template);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("super_class"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("name"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("version");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("info");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
field_decl = get_identifier ("instance_size");
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_IVAR_LIST)));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("ivars"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_LIST)));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("methods"));
field_decl
= grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
if (flag_next_runtime)
{
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier ("objc_cache")));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("cache"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
}
else
{
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier ("sarray")));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("dtable"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, objc_class_template);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("subclass_list"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, objc_class_template);
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sibling_class"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
}
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL)));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_list"));
field_decl
= build1 (INDIRECT_REF, NULL_TREE, field_decl);
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (objc_class_template, field_decl_chain);
flag_dump_symbols = save_flag_dump_symbols;
flag_gen_index = save_flag_gen_index;
}
static void
synth_forward_declarations ()
{
tree sc_spec, decl_specs, an_id;
an_id = synth_id_with_class_suffix ("_OBJC_CLASS", implementation_context);
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_CONST]);
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_EXTERN], sc_spec);
decl_specs = tree_cons (NULL_TREE, objc_class_template, sc_spec);
UOBJC_CLASS_decl = define_decl (an_id, decl_specs);
TREE_USED (UOBJC_CLASS_decl) = 1;
DECL_ARTIFICIAL (UOBJC_CLASS_decl) = 1;
an_id = synth_id_with_class_suffix ("_OBJC_METACLASS",
implementation_context);
UOBJC_METACLASS_decl = define_decl (an_id, decl_specs);
TREE_USED (UOBJC_METACLASS_decl) = 1;
DECL_ARTIFICIAL(UOBJC_METACLASS_decl) = 1;
an_id = get_identifier ("super_class");
ucls_super_ref = build_component_ref (UOBJC_CLASS_decl, an_id);
uucls_super_ref = build_component_ref (UOBJC_METACLASS_decl, an_id);
}
static void
error_with_ivar (message, decl, rawdecl)
char *message;
tree decl;
tree rawdecl;
{
count_error (0);
report_error_function (DECL_SOURCE_FILE (decl));
bzero (errbuf, BUFSIZE);
error_with_file_and_line (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
"%s `%s'", message,
gen_declaration (rawdecl, errbuf));
}
#define USERTYPE(t) (TREE_CODE (t) == RECORD_TYPE || \
TREE_CODE (t) == UNION_TYPE || \
TREE_CODE (t) == ENUMERAL_TYPE)
static void
check_ivars (inter, imp)
tree inter;
tree imp;
{
tree intdecls = CLASS_IVARS (inter);
tree impdecls = CLASS_IVARS (imp);
tree rawintdecls = CLASS_RAW_IVARS (inter);
tree rawimpdecls = CLASS_RAW_IVARS (imp);
while (1)
{
tree t1, t2;
if (intdecls == 0 && impdecls == 0)
break;
if (intdecls == 0 || impdecls == 0)
{
error ("inconsistent instance variable specification");
break;
}
t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
if (!comptypes (t1, t2))
{
if (DECL_NAME (intdecls) == DECL_NAME (impdecls))
{
error_with_ivar ("conflicting instance variable type",
impdecls, rawimpdecls);
error_with_ivar ("previous declaration of",
intdecls, rawintdecls);
}
else
{
error ("inconsistent instance variable specification");
break;
}
}
else if (DECL_NAME (intdecls) != DECL_NAME (impdecls))
{
error_with_ivar ("conflicting instance variable name",
impdecls, rawimpdecls);
error_with_ivar ("previous declaration of",
intdecls, rawintdecls);
}
intdecls = TREE_CHAIN (intdecls);
impdecls = TREE_CHAIN (impdecls);
rawintdecls = TREE_CHAIN (rawintdecls);
rawimpdecls = TREE_CHAIN (rawimpdecls);
}
}
static tree
build_super_template ()
{
int save_flag_dump_symbols = flag_dump_symbols;
int save_flag_gen_index = flag_gen_index;
tree record, decl_specs, field_decl, field_decl_chain;
flag_dump_symbols = 0;
flag_gen_index = 0;
record = objcplus_start_struct (RECORD_TYPE, get_identifier (UTAG_SUPER));
decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
field_decl = get_identifier ("self");
field_decl = build1 (INDIRECT_REF, NULL_TREE, field_decl);
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = get_identifier (UTAG_CLASS);
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE, decl_specs));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class"));
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (record, field_decl_chain);
super_type = groktypename (build_tree_list (build_tree_list (NULL_TREE,
record),
build1 (INDIRECT_REF,
NULL_TREE, NULL_TREE)));
flag_dump_symbols = save_flag_dump_symbols;
flag_gen_index = save_flag_gen_index;
return record;
}
static tree
build_ivar_template ()
{
tree objc_ivar_id, objc_ivar_record;
tree decl_specs, field_decl, field_decl_chain;
objc_ivar_id = get_identifier (UTAG_IVAR);
objc_ivar_record = objcplus_start_struct (RECORD_TYPE, objc_ivar_id);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("ivar_name"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("ivar_type"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
field_decl = get_identifier ("ivar_offset");
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (objc_ivar_record, field_decl_chain);
return objc_ivar_record;
}
static tree
build_ivar_list_template (list_type, size)
tree list_type;
int size;
{
tree objc_ivar_list_record;
tree decl_specs, field_decl, field_decl_chain;
objc_ivar_list_record = objcplus_start_struct (RECORD_TYPE, NULL_TREE);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
field_decl = get_identifier ("ivar_count");
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = build_tree_list (NULL_TREE, list_type);
field_decl = build_nt (ARRAY_REF, get_identifier ("ivar_list"),
build_int_2 (size, 0));
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (objc_ivar_list_record, field_decl_chain);
return objc_ivar_list_record;
}
static tree
build_method_list_template (list_type, size)
tree list_type;
int size;
{
tree objc_ivar_list_record;
tree decl_specs, field_decl, field_decl_chain;
objc_ivar_list_record = objcplus_start_struct (RECORD_TYPE, NULL_TREE);
#ifdef __osf__
decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("method_next"));
field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
#else
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
field_decl = get_identifier ("method_next");
field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULL_TREE);
field_decl_chain = field_decl;
#endif __osf__
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
field_decl = get_identifier ("method_count");
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = build_tree_list (NULL_TREE, list_type);
field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
build_int_2 (size, 0));
field_decl = grokfield (input_filename, lineno,
field_decl, decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (objc_ivar_list_record, field_decl_chain);
return objc_ivar_list_record;
}
static tree
build_ivar_list_initializer (type, field_decl)
tree type;
tree field_decl;
{
tree initlist = NULL_TREE;
do
{
tree ivar = NULL_TREE;
if (DECL_NAME (field_decl))
ivar = tree_cons (NULL_TREE,
add_objc_string (DECL_NAME (field_decl),
meth_var_names),
ivar);
else
ivar = tree_cons (NULL_TREE, build_int_2 (0, 0), ivar);
encode_field_decl (field_decl,
obstack_object_size (&util_obstack),
OBJC_ENCODE_DONT_INLINE_DEFS);
obstack_1grow (&util_obstack, 0);
ivar
= tree_cons
(NULL_TREE,
add_objc_string (get_identifier (obstack_finish (&util_obstack)),
meth_var_types),
ivar);
obstack_free (&util_obstack, util_firstobj);
ivar
= tree_cons
(NULL_TREE,
build_int_2 ((TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field_decl))
/ BITS_PER_UNIT),
0),
ivar);
initlist = tree_cons (NULL_TREE,
build_constructor (type, nreverse (ivar)),
initlist);
field_decl = TREE_CHAIN (field_decl);
}
while (field_decl);
return build_constructor (build_array_type (type, 0), nreverse (initlist));
}
static tree
generate_ivars_list (type, name, size, list)
tree type;
char *name;
int size;
tree list;
{
tree sc_spec, decl_specs, decl, initlist;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, type, sc_spec);
decl = start_decl (synth_id_with_class_suffix (name, implementation_context),
decl_specs, 1);
end_temporary_allocation ();
initlist = build_tree_list (NULL_TREE, build_int_2 (size, 0));
initlist = tree_cons (NULL_TREE, list, initlist);
objcplus_finish_decl (decl,
build_constructor (TREE_TYPE (decl), nreverse (initlist)),
NULL_TREE);
return decl;
}
static void
generate_ivar_lists ()
{
tree initlist, ivar_list_template, chain;
tree cast, variable_length_type;
int size;
generating_instance_variables = 1;
if (!objc_ivar_template)
objc_ivar_template = build_ivar_template ();
cast
= build_tree_list
(build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_IVAR_LIST))),
NULL_TREE);
variable_length_type = groktypename (cast);
if (CLASS_SUPER_NAME (implementation_template) == NULL_TREE
&& (chain = TYPE_FIELDS (objc_class_template)))
{
size = list_length (chain);
ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
initlist = build_ivar_list_initializer (objc_ivar_template, chain);
UOBJC_CLASS_VARIABLES_decl
= generate_ivars_list (ivar_list_template, "_OBJC_CLASS_VARIABLES",
size, initlist);
TREE_TYPE (UOBJC_CLASS_VARIABLES_decl) = variable_length_type;
}
else
UOBJC_CLASS_VARIABLES_decl = 0;
chain = CLASS_IVARS (implementation_template);
if (chain)
{
size = list_length (chain);
ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
initlist = build_ivar_list_initializer (objc_ivar_template, chain);
UOBJC_INSTANCE_VARIABLES_decl
= generate_ivars_list (ivar_list_template, "_OBJC_INSTANCE_VARIABLES",
size, initlist);
TREE_TYPE (UOBJC_INSTANCE_VARIABLES_decl) = variable_length_type;
}
else
UOBJC_INSTANCE_VARIABLES_decl = 0;
generating_instance_variables = 0;
}
static tree
build_dispatch_table_initializer (type, entries)
tree type;
tree entries;
{
tree initlist = NULL_TREE;
do
{
tree elemlist = NULL_TREE;
elemlist = tree_cons (NULL_TREE, build_selector (METHOD_SEL_NAME (entries)),
NULL_TREE);
elemlist = tree_cons (NULL_TREE, add_objc_string (METHOD_ENCODING (entries),
meth_var_types),
elemlist);
elemlist = tree_cons (NULL_TREE,
build_unary_op (ADDR_EXPR, METHOD_DEFINITION (entries), 1),
elemlist);
initlist = tree_cons (NULL_TREE,
build_constructor (type, nreverse (elemlist)),
initlist);
entries = TREE_CHAIN (entries);
}
while (entries);
return build_constructor (build_array_type (type, 0), nreverse (initlist));
}
static tree
build_method_template ()
{
tree _SLT_record;
tree decl_specs, field_decl, field_decl_chain;
_SLT_record = objcplus_start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD));
#ifdef OBJC_INT_SELECTORS
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_UNSIGNED],
NULL_TREE);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_INT], decl_specs);
field_decl = get_identifier ("_cmd");
#else
decl_specs = tree_cons (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)),
NULL_TREE);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("_cmd"));
#endif
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
field_decl_chain = field_decl;
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], NULL_TREE);
field_decl = build1 (INDIRECT_REF, NULL_TREE,
get_identifier ("method_types"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_VOID], NULL_TREE);
field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("_imp"));
field_decl = grokfield (input_filename, lineno, field_decl,
decl_specs, NULL_TREE);
chainon (field_decl_chain, field_decl);
objcplus_finish_struct (_SLT_record, field_decl_chain);
return _SLT_record;
}
static tree
generate_dispatch_table (type, name, size, list)
tree type;
char *name;
int size;
tree list;
{
tree sc_spec, decl_specs, decl, initlist;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, type, sc_spec);
decl = start_decl (synth_id_with_class_suffix (name, implementation_context),
decl_specs, 1);
end_temporary_allocation ();
initlist = build_tree_list (NULL_TREE, build_int_2 (0, 0));
initlist = tree_cons (NULL_TREE, build_int_2 (size, 0), initlist);
initlist = tree_cons (NULL_TREE, list, initlist);
objcplus_finish_decl (decl,
build_constructor (TREE_TYPE (decl), nreverse (initlist)),
NULL_TREE);
return decl;
}
static void
generate_dispatch_tables ()
{
tree initlist, chain, method_list_template;
tree cast, variable_length_type;
int size;
if (!objc_method_template)
objc_method_template = build_method_template ();
cast
= build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_METHOD_LIST))),
NULL_TREE);
variable_length_type = groktypename (cast);
chain = CLASS_CLS_METHODS (implementation_context);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_list_template (objc_method_template, size);
initlist
= build_dispatch_table_initializer (objc_method_template, chain);
UOBJC_CLASS_METHODS_decl
= generate_dispatch_table (method_list_template,
((TREE_CODE (implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
? "_OBJC_CLASS_METHODS"
: "_OBJC_CATEGORY_CLASS_METHODS"),
size, initlist);
TREE_TYPE (UOBJC_CLASS_METHODS_decl) = variable_length_type;
}
else
UOBJC_CLASS_METHODS_decl = 0;
chain = CLASS_NST_METHODS (implementation_context);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_list_template (objc_method_template, size);
initlist
= build_dispatch_table_initializer (objc_method_template, chain);
if (TREE_CODE (implementation_context) == CLASS_IMPLEMENTATION_TYPE)
UOBJC_INSTANCE_METHODS_decl
= generate_dispatch_table (method_list_template,
"_OBJC_INSTANCE_METHODS",
size, initlist);
else
UOBJC_INSTANCE_METHODS_decl
= generate_dispatch_table (method_list_template,
"_OBJC_CATEGORY_INSTANCE_METHODS",
size, initlist);
TREE_TYPE (UOBJC_INSTANCE_METHODS_decl) = variable_length_type;
}
else
UOBJC_INSTANCE_METHODS_decl = 0;
}
static tree
generate_protocol_list (i_or_p)
tree i_or_p;
{
static tree cast_type = 0;
tree initlist, decl_specs, sc_spec;
tree refs_decl, expr_decl, lproto, e, plist;
int size = 0;
if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE
|| TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
plist = CLASS_PROTOCOL_LIST (i_or_p);
else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
plist = PROTOCOL_LIST (i_or_p);
else
abort ();
if (!cast_type)
cast_type
= groktypename
(build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL))),
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE)));
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto)))
size++;
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), NULL_TREE);
e = build_int_2 (size, 0);
TREE_TYPE (e) = cast_type;
initlist = tree_cons (NULL_TREE, e, initlist);
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
{
tree pval = TREE_VALUE (lproto);
if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_FORWARD_DECL (pval))
{
e = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (pval), 0);
initlist = tree_cons (NULL_TREE, e, initlist);
}
}
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL)),
sc_spec);
if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
expr_decl = build_nt (ARRAY_REF,
synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS",
i_or_p),
build_int_2 (size + 2, 0));
else if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE)
expr_decl = build_nt (ARRAY_REF,
synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS",
i_or_p),
build_int_2 (size + 2, 0));
else if (TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
expr_decl
= build_nt (ARRAY_REF,
synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS",
i_or_p),
build_int_2 (size + 2, 0));
expr_decl = build1 (INDIRECT_REF, NULL_TREE, expr_decl);
refs_decl = start_decl (expr_decl, decl_specs, 1);
end_temporary_allocation ();
objcplus_finish_decl (refs_decl, build_constructor (TREE_TYPE (refs_decl),
nreverse (initlist)),
NULL_TREE);
return refs_decl;
}
static tree
build_category_initializer (type, cat_name, class_name,
instance_methods, class_methods, protocol_list)
tree type;
tree cat_name;
tree class_name;
tree instance_methods;
tree class_methods;
tree protocol_list;
{
tree initlist = NULL_TREE, expr;
initlist = tree_cons (NULL_TREE, cat_name, initlist);
initlist = tree_cons (NULL_TREE, class_name, initlist);
if (!instance_methods)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!class_methods)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, class_methods, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!protocol_list)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
static tree cast_type2;
if (!cast_type2)
cast_type2
= groktypename
(build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL))),
build1 (INDIRECT_REF, NULL_TREE,
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE))));
expr = build_unary_op (ADDR_EXPR, protocol_list, 0);
TREE_TYPE (expr) = cast_type2;
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return build_constructor (type, nreverse (initlist));
}
static tree
build_shared_structure_initializer (type, isa, super, name, size, status,
dispatch_table, ivar_list, protocol_list)
tree type;
tree isa;
tree super;
tree name;
tree size;
int status;
tree dispatch_table;
tree ivar_list;
tree protocol_list;
{
tree initlist = NULL_TREE, expr;
initlist = tree_cons (NULL_TREE, isa, initlist);
initlist = tree_cons (NULL_TREE, super, initlist);
initlist = tree_cons (NULL_TREE, default_conversion (name), initlist);
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
initlist = tree_cons (NULL_TREE, build_int_2 (status, 0), initlist);
initlist = tree_cons (NULL_TREE, size, initlist);
if (!ivar_list)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, ivar_list, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!dispatch_table)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
expr = build_unary_op (ADDR_EXPR, dispatch_table, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (flag_next_runtime)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
}
if (! protocol_list)
initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
else
{
static tree cast_type2;
if (!cast_type2)
cast_type2
= groktypename
(build_tree_list
(build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL))),
build1 (INDIRECT_REF, NULL_TREE,
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE))));
expr = build_unary_op (ADDR_EXPR, protocol_list, 0);
TREE_TYPE (expr) = cast_type2;
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return build_constructor (type, nreverse (initlist));
}
static void
generate_category (cat)
tree cat;
{
tree sc_spec, decl_specs, decl;
tree initlist, cat_name_expr, class_name_expr;
tree protocol_decl, category;
add_class_reference (CLASS_NAME (cat));
cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
class_name_expr = add_objc_string (CLASS_NAME (cat), class_names);
category = CLASS_CATEGORY_LIST (implementation_template);
while (category)
{
if (CLASS_SUPER_NAME (cat) == CLASS_SUPER_NAME (category))
break;
category = CLASS_CATEGORY_LIST (category);
}
if (category && CLASS_PROTOCOL_LIST (category))
{
generate_protocol_references (CLASS_PROTOCOL_LIST (category));
protocol_decl = generate_protocol_list (category);
}
else
protocol_decl = 0;
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
decl_specs = tree_cons (NULL_TREE, objc_category_template, sc_spec);
decl = start_decl (synth_id_with_class_suffix ("_OBJC_CATEGORY",
implementation_context),
decl_specs, 1);
end_temporary_allocation ();
initlist = build_category_initializer (TREE_TYPE (decl),
cat_name_expr, class_name_expr,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_CLASS_METHODS_decl,
protocol_decl);
TREE_USED (decl) = 1;
objcplus_finish_decl (decl, initlist, NULL_TREE);
}
static void
generate_shared_structures ()
{
tree sc_spec, decl_specs, decl;
tree name_expr, super_expr, root_expr;
tree my_root_id = NULL_TREE, my_super_id = NULL_TREE;
tree cast_type, initlist, protocol_decl;
my_super_id = CLASS_SUPER_NAME (implementation_template);
if (my_super_id)
{
add_class_reference (my_super_id);
my_root_id = my_super_id;
do
{
tree my_root_int = lookup_interface (my_root_id);
if (my_root_int && CLASS_SUPER_NAME (my_root_int))
my_root_id = CLASS_SUPER_NAME (my_root_int);
else
break;
}
while (1);
}
else
my_root_id = CLASS_NAME (implementation_template);
cast_type
= groktypename (build_tree_list (build_tree_list (NULL_TREE,
objc_class_template),
build1 (INDIRECT_REF,
NULL_TREE, NULL_TREE)));
name_expr = add_objc_string (CLASS_NAME (implementation_template),
class_names);
if (my_super_id)
{
super_expr = add_objc_string (my_super_id, class_names);
super_expr = build_c_cast (cast_type, super_expr);
}
else
super_expr = build_int_2 (0, 0);
root_expr = add_objc_string (my_root_id, class_names);
root_expr = build_c_cast (cast_type, root_expr);
if (CLASS_PROTOCOL_LIST (implementation_template))
{
generate_protocol_references
(CLASS_PROTOCOL_LIST (implementation_template));
protocol_decl = generate_protocol_list (implementation_template);
}
else
protocol_decl = 0;
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_CONST]);
decl_specs = tree_cons (NULL_TREE, objc_class_template, sc_spec);
decl = start_decl (DECL_NAME (UOBJC_METACLASS_decl), decl_specs, 1);
end_temporary_allocation ();
initlist
= build_shared_structure_initializer
(TREE_TYPE (decl),
root_expr, super_expr, name_expr,
build_int_2 ((TREE_INT_CST_LOW (objcplus_TYPE_SIZE (objc_class_template))
/ BITS_PER_UNIT),
0),
2 ,
UOBJC_CLASS_METHODS_decl,
UOBJC_CLASS_VARIABLES_decl,
protocol_decl);
#ifdef SHOULD_THIS_REALLY_BE_PRIVATE
TREE_PUBLIC (decl) = 0;
#endif
objcplus_finish_decl (decl, initlist, NULL_TREE);
decl = start_decl (DECL_NAME (UOBJC_CLASS_decl), decl_specs, 1);
end_temporary_allocation ();
initlist
= build_shared_structure_initializer
(TREE_TYPE (decl),
build_unary_op (ADDR_EXPR, UOBJC_METACLASS_decl, 0),
super_expr, name_expr,
build_int_2
((TREE_INT_CST_LOW
(objcplus_TYPE_SIZE (CLASS_STATIC_TEMPLATE (implementation_template)))
/ BITS_PER_UNIT),
0),
1 ,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_INSTANCE_VARIABLES_decl,
protocol_decl);
#ifdef SHOULD_THIS_REALLY_BE_PRIVATE
TREE_PUBLIC (decl) = 0;
#endif
objcplus_finish_decl (decl, initlist, NULL_TREE);
}
static tree
synth_id_with_class_suffix (preamble, ctxt)
char *preamble;
tree ctxt;
{
char *string;
if (TREE_CODE (ctxt) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (ctxt) == CLASS_INTERFACE_TYPE)
{
char *class_name
= IDENTIFIER_POINTER (CLASS_NAME (implementation_context));
string = (char *) alloca (strlen (preamble) + strlen (class_name) + 3);
sprintf (string, "%s_%s", preamble,
IDENTIFIER_POINTER (CLASS_NAME (ctxt)));
}
else if (TREE_CODE (ctxt) == CATEGORY_IMPLEMENTATION_TYPE
|| TREE_CODE (ctxt) == CATEGORY_INTERFACE_TYPE)
{
char *class_name
= IDENTIFIER_POINTER (CLASS_NAME (implementation_context));
char *class_super_name
= IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context));
string = (char *) alloca (strlen (preamble)
+ strlen (class_name)
+ strlen (class_super_name)
+ 3);
sprintf (string, "%s_%s_%s", preamble, class_name, class_super_name);
}
else if (TREE_CODE (ctxt) == PROTOCOL_INTERFACE_TYPE)
{
char *protocol_name = IDENTIFIER_POINTER (PROTOCOL_NAME (ctxt));
string
= (char *) alloca (strlen (preamble) + strlen (protocol_name) + 3);
sprintf (string, "%s_%s", preamble, protocol_name);
}
return get_identifier (string);
}
static int
is_objc_type_qualifier (node)
tree node;
{
return (TREE_CODE (node) == IDENTIFIER_NODE
&& (node == ridpointers [(int) RID_CONST]
|| node == ridpointers [(int) RID_VOLATILE]
|| node == ridpointers [(int) RID_IN]
|| node == ridpointers [(int) RID_OUT]
|| node == ridpointers [(int) RID_INOUT]
|| node == ridpointers [(int) RID_BYCOPY]
|| node == ridpointers [(int) RID_BYREF]
|| node == ridpointers [(int) RID_ONEWAY]));
}
static tree
adjust_type_for_id_default (type, is_return_type)
tree type;
{
tree declspecs, chain, result = 0;
int synth_void = 0;
if (!type)
return build_tree_list (build_tree_list (NULL_TREE, objc_object_reference),
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE));
declspecs = TREE_PURPOSE (type);
for (chain = declspecs;
chain;
chain = TREE_CHAIN (chain))
{
tree node = TREE_VALUE (chain);
if (!is_objc_type_qualifier (node))
{
result = type;
break;
}
else if (node == ridpointers [(int) RID_ONEWAY])
synth_void = 1;
}
if (!result)
{
if (is_return_type && synth_void)
result = build_tree_list (tree_cons (NULL_TREE,
ridpointers [(int) RID_VOID],
declspecs),
NULL_TREE);
else
result = build_tree_list (tree_cons (NULL_TREE,
objc_object_reference,
declspecs),
build1 (INDIRECT_REF, NULL_TREE, NULL_TREE));
}
{
int inout_seen = 0;
int pointerp = 0;
if (TREE_VALUE (result))
pointerp = (TREE_CODE (TREE_VALUE (result)) == INDIRECT_REF);
for (chain = declspecs;
chain;
chain = TREE_CHAIN (chain))
{
tree node = TREE_VALUE (chain);
if (node == ridpointers [(int) RID_OUT]
|| node == ridpointers [(int) RID_INOUT]
|| node == ridpointers [(int) RID_IN])
inout_seen++;
if (!pointerp)
{
if (node == ridpointers [(int) RID_OUT]
|| node == ridpointers [(int) RID_INOUT])
warning ("qualifiers \"out\" and \"inout\" are for pointers only");
}
else if (!is_return_type && node == ridpointers [(int) RID_ONEWAY])
warning ("qualifier \"oneway\" is for return types only");
}
if (inout_seen > 1)
warning ("inconsistent combination of \"in\", \"out\", and \"inout\"");
if (inout_seen && is_return_type)
warning ("qualifiers \"in\", \"out\", and \"inout\" are for arguments only");
}
return result;
}
tree
build_keyword_decl (key_name, arg_type, arg_name)
tree key_name;
tree arg_type;
tree arg_name;
{
tree keyword_decl;
arg_type = adjust_type_for_id_default (arg_type, 0);
keyword_decl = make_node (KEYWORD_DECL);
TREE_TYPE (keyword_decl) = arg_type;
KEYWORD_ARG_NAME (keyword_decl) = arg_name;
KEYWORD_KEY_NAME (keyword_decl) = key_name;
return keyword_decl;
}
static tree
build_keyword_selector (selector)
tree selector;
{
int len = 0;
tree key_chain, key_name;
char *buf;
for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
{
if (TREE_CODE (selector) == KEYWORD_DECL)
key_name = KEYWORD_KEY_NAME (key_chain);
else if (TREE_CODE (selector) == TREE_LIST)
key_name = TREE_PURPOSE (key_chain);
if (key_name)
len += IDENTIFIER_LENGTH (key_name) + 1;
else
len++;
}
buf = (char *)alloca (len + 1);
bzero (buf, len + 1);
for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
{
if (TREE_CODE (selector) == KEYWORD_DECL)
key_name = KEYWORD_KEY_NAME (key_chain);
else if (TREE_CODE (selector) == TREE_LIST)
key_name = TREE_PURPOSE (key_chain);
if (key_name)
strcat (buf, IDENTIFIER_POINTER (key_name));
strcat (buf, ":");
}
return get_identifier (buf);
}
static tree
adjust_for_return_type_mods (method_decl, ret_type_mods)
tree method_decl;
tree ret_type_mods;
{
tree chain;
if (!ret_type_mods)
return method_decl;
for (chain = ret_type_mods;
chain;
chain = TREE_CHAIN (chain))
{
tree node = TREE_VALUE (chain);
if (TREE_CODE (node) != IDENTIFIER_NODE)
continue;
if (node == ridpointers[(int) RID_AUTO]
|| node == ridpointers[(int) RID_EXTERN]
|| node == ridpointers[(int) RID_INLINE]
|| node == ridpointers[(int) RID_REGISTER]
|| node == ridpointers[(int) RID_STATIC]
|| node == ridpointers[(int) RID_FRIEND]
|| node == ridpointers[(int) RID_MUTABLE]
|| node == ridpointers[(int) RID_VIRTUAL]
|| node == ridpointers[(int) RID_TYPEDEF])
error ("invalid storage class `%s' in Objective-C return type",
IDENTIFIER_POINTER (node));
}
return method_decl;
}
tree
build_method_decl (code, ret_type, selector, add_args, ret_type_mods)
enum tree_code code;
tree ret_type;
tree selector;
tree add_args;
tree ret_type_mods;
{
tree method_decl;
ret_type = adjust_type_for_id_default (ret_type, 1);
method_decl = make_node (code);
TREE_TYPE (method_decl) = ret_type;
if (TREE_CODE (selector) == KEYWORD_DECL)
{
METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector);
METHOD_SEL_ARGS (method_decl) = selector;
METHOD_ADD_ARGS (method_decl) = add_args;
}
else
{
METHOD_SEL_NAME (method_decl) = selector;
METHOD_SEL_ARGS (method_decl) = NULL_TREE;
METHOD_ADD_ARGS (method_decl) = NULL_TREE;
}
method_decl = adjust_for_return_type_mods (method_decl, ret_type_mods);
#if 0
{
char buffer[512];
sprintf(buffer, "`%s' <%s%s%s>",
IDENTIFIER_POINTER(METHOD_SEL_NAME(method_decl)),
STATIC_METHOD_FLAG(method_decl) ? "static" : "extern",
DIRECT_METHOD_FLAG(method_decl) ? " direct" : "",
INLINE_METHOD_FLAG(method_decl) ? " inline" : "");
warning ("build_method_decl:%s\n", buffer);
}
#endif
if (flag_dump_symbols)
printf (" %s %u\n", IDENTIFIER_POINTER (DECL_NAME (method_decl)), lineno);
if (flag_gen_index)
dump_symbol_info (NULL, IDENTIFIER_POINTER (DECL_NAME (method_decl)), lineno);
return method_decl;
}
#define METHOD_DEF 0
#define METHOD_REF 1
static tree
get_arg_type_list (meth, context, superflag)
tree meth;
int context;
int superflag;
{
tree arglist, akey;
if (flag_next_runtime && superflag)
arglist = build_tree_list (NULL_TREE, super_type);
else if (context == METHOD_DEF)
arglist = build_tree_list (NULL_TREE, TREE_TYPE (self_decl));
else
arglist = build_tree_list (NULL_TREE, id_type);
chainon (arglist, build_tree_list (NULL_TREE, selector_type));
for (akey = METHOD_SEL_ARGS (meth); akey; akey = TREE_CHAIN (akey))
{
tree arg_decl = groktypename_in_parm_context (TREE_TYPE (akey));
chainon (arglist, build_tree_list (NULL_TREE, TREE_TYPE (arg_decl)));
}
if (METHOD_ADD_ARGS (meth) == (tree)1)
;
else if (METHOD_ADD_ARGS (meth))
{
tree add_arg_list = TREE_CHAIN (METHOD_ADD_ARGS (meth));
chainon (arglist, add_arg_list);
}
else
{
#ifdef OBJCPLUS
chainon (arglist, void_list_node);
#else
chainon (arglist, build_tree_list (NULL_TREE, void_type_node));
#endif
}
return arglist;
}
static tree
check_duplicates (hsh)
hash hsh;
{
tree meth = NULL_TREE;
if (hsh)
{
meth = hsh->key;
if (hsh->list)
{
attr loop;
char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL) ? '-' : '+';
warning ("multiple declarations for method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
warn_with_method ("using", type, meth);
for (loop = hsh->list; loop; loop = loop->next)
warn_with_method ("also found", type, loop->value);
}
}
return meth;
}
static tree
receiver_is_class_object (receiver)
tree receiver;
{
tree chain, exp, arg;
if (flag_class_references)
{
if (objc_method_context && receiver == self_decl
&& TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
{
return CLASS_NAME (objc_implementation_context);
}
if (TREE_CODE (receiver) == VAR_DECL
&& TREE_TYPE (receiver) == objc_class_type)
for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
if (TREE_PURPOSE (chain) == receiver)
return TREE_VALUE (chain);
}
else
{
if (TREE_CODE (receiver) == CALL_EXPR
&& (exp = TREE_OPERAND (receiver, 0))
&& TREE_CODE (exp) == ADDR_EXPR
&& (exp = TREE_OPERAND (exp, 0))
&& TREE_CODE (exp) == FUNCTION_DECL
&& exp == objc_get_class_decl
&& (arg = TREE_OPERAND (receiver, 1))
&& TREE_CODE (arg) == TREE_LIST
&& (arg = TREE_VALUE (arg)))
{
STRIP_NOPS (arg);
if (TREE_CODE (arg) == ADDR_EXPR
&& (arg = TREE_OPERAND (arg, 0))
&& TREE_CODE (arg) == STRING_CST)
return get_identifier (TREE_STRING_POINTER (arg));
}
}
return 0;
}
static tree building_objc_message_expr = 0;
tree
maybe_building_objc_message_expr ()
{
return building_objc_message_expr;
}
tree
build_message_expr (mess)
tree mess;
{
tree receiver = TREE_PURPOSE (mess);
tree selector, self_object;
tree rtype, sel_name;
tree args = TREE_VALUE (mess);
tree method_params = NULL_TREE;
tree method_prototype = NULL_TREE;
tree retval;
int statically_typed = 0, statically_allocated = 0;
tree class_ident = 0;
int super;
if (!doing_objc_thang)
objc_fatal ();
if (TREE_CODE (receiver) == ERROR_MARK)
return error_mark_node;
rtype = TREE_TYPE (receiver);
super = IS_SUPER (rtype);
if (! super)
{
if (TREE_STATIC_TEMPLATE (rtype))
statically_allocated = 1;
else if (TREE_CODE (rtype) == POINTER_TYPE
&& TREE_STATIC_TEMPLATE (TREE_TYPE (rtype)))
statically_typed = 1;
else if ((flag_next_runtime
|| (TREE_CODE (receiver) == CALL_EXPR && IS_ID (rtype)))
&& (class_ident = receiver_is_class_object (receiver)))
;
else if (! IS_ID (rtype)
&& ! comptypes (rtype, objc_class_type))
{
#ifdef OBJCPLUS
tree converted;
converted = convert (id_type, receiver);
if (converted != NULL_TREE && converted != error_mark_node)
{
STRIP_NOPS (converted);
receiver = converted;
rtype = TREE_TYPE (receiver);
if (TREE_CODE (rtype) == POINTER_TYPE
&& TREE_STATIC_TEMPLATE (TREE_TYPE (rtype)))
statically_typed = 1;
}
else
#endif
{
bzero (errbuf, BUFSIZE);
warning ("invalid receiver type `%s'",
gen_declaration (rtype, errbuf));
}
}
if (statically_allocated)
receiver = build_unary_op (ADDR_EXPR, receiver, 0);
receiver = save_expr (receiver);
self_object = receiver;
}
else
self_object = self_decl;
if (TREE_CODE (args) == IDENTIFIER_NODE)
sel_name = args;
else if (TREE_CODE (args) == TREE_LIST)
{
sel_name = build_keyword_selector (args);
}
else
{
fprintf (stderr, "Internal objc parser error, please report to bug-gcc\n");
fflush (stderr);
abort ();
}
method_params = NULL_TREE;
if (TREE_CODE (args) == TREE_LIST)
{
tree chain = args, prev = NULL_TREE;
while (chain)
{
tree element = TREE_VALUE (chain);
if (TREE_CODE (element) == TREE_LIST)
{
if (prev)
TREE_CHAIN (prev) = element;
else
args = element;
}
prev = chain;
chain = TREE_CHAIN (chain);
}
method_params = args;
}
if (IS_SUPER (rtype))
{
tree iface;
if (CLASS_SUPER_NAME (implementation_template))
{
iface
= lookup_interface (CLASS_SUPER_NAME (implementation_template));
if (TREE_CODE (method_context) == INSTANCE_METHOD_DECL)
method_prototype = lookup_instance_method_static (iface, sel_name);
else
method_prototype = lookup_class_method_static (iface, sel_name);
if (iface && !method_prototype)
warning ("`%s' does not respond to `%s'",
IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_template)),
IDENTIFIER_POINTER (sel_name));
}
else
{
error ("no super class declared in interface for `%s'",
IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
return error_mark_node;
}
}
else if (statically_allocated)
{
tree ctype = TREE_TYPE (rtype);
tree iface = lookup_interface (objcplus_TYPE_NAME (rtype));
if (iface)
method_prototype = lookup_instance_method_static (iface, sel_name);
if (! method_prototype && ctype && TYPE_PROTOCOL_LIST (ctype))
method_prototype
= lookup_method_in_protocol_list (TYPE_PROTOCOL_LIST (ctype),
sel_name, 0);
if (!method_prototype)
warning ("`%s' does not respond to `%s'",
IDENTIFIER_POINTER (objcplus_TYPE_NAME (rtype)),
IDENTIFIER_POINTER (sel_name));
}
else if (statically_typed)
{
tree ctype = TREE_TYPE (rtype);
if (implementation_context
&& CLASS_NAME (implementation_context) == objcplus_TYPE_NAME (ctype))
{
method_prototype
= lookup_instance_method_static (implementation_template,
sel_name);
if (! method_prototype && TYPE_PROTOCOL_LIST (ctype))
method_prototype
= lookup_method_in_protocol_list (TYPE_PROTOCOL_LIST (ctype),
sel_name, 0);
if (! method_prototype
&& implementation_template != implementation_context)
method_prototype
= lookup_method (CLASS_NST_METHODS (implementation_context),
sel_name);
}
else
{
tree iface;
if ((iface = lookup_interface (objcplus_TYPE_NAME (ctype))))
method_prototype = lookup_instance_method_static (iface, sel_name);
if (! method_prototype)
{
tree protocol_list = TYPE_PROTOCOL_LIST (ctype);
if (protocol_list)
method_prototype
= lookup_method_in_protocol_list (protocol_list,
sel_name, 0);
}
if (!method_prototype && !iface)
warning ("declaration for class `%s' is missing",
IDENTIFIER_POINTER (objcplus_TYPE_NAME (ctype)));
}
if (!method_prototype)
warning ("`%s' does not respond to `%s'",
IDENTIFIER_POINTER (objcplus_TYPE_NAME (ctype)),
IDENTIFIER_POINTER (sel_name));
}
else if (class_ident)
{
if (implementation_context
&& CLASS_NAME (implementation_context) == class_ident)
{
method_prototype
= lookup_class_method_static (implementation_template, sel_name);
if (!method_prototype
&& implementation_template != implementation_context)
method_prototype
= lookup_method (CLASS_CLS_METHODS (implementation_context),
sel_name);
}
else
{
tree iface;
if ((iface = lookup_interface (class_ident)))
method_prototype = lookup_class_method_static (iface, sel_name);
}
if (!method_prototype)
{
warning ("cannot find class (factory) method.");
warning ("return type for `%s' defaults to id",
IDENTIFIER_POINTER (sel_name));
}
}
else if (IS_PROTOCOL_QUALIFIED_ID (rtype))
{
tree protocol_list = TYPE_PROTOCOL_LIST (rtype);
method_prototype = lookup_method_in_protocol_list (protocol_list,
sel_name, 0);
if (!method_prototype)
{
hash hsh;
tree proto;
warning ("method `%s' not implemented by protocol(s).",
IDENTIFIER_POINTER (sel_name));
warning ("receiver knows only protocol: `%s'",
IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (protocol_list))));
for (proto = TREE_CHAIN (protocol_list); proto; proto = TREE_CHAIN (proto))
{
warning ("and protocol `%s'",
IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (protocol_list))));
}
if (!(hsh = hash_lookup (nst_method_hash_list, sel_name)))
hsh = hash_lookup (cls_method_hash_list, sel_name);
if (!(method_prototype = check_duplicates (hsh)))
warning ("return type defaults to id");
}
}
else
{
hash hsh;
hsh = hash_lookup (nst_method_hash_list, sel_name);
if (!hsh)
hsh = hash_lookup (cls_method_hash_list, sel_name);
method_prototype = check_duplicates (hsh);
if (!method_prototype)
{
warning ("cannot find method.");
warning ("return type for `%s' defaults to id",
IDENTIFIER_POINTER (sel_name));
}
}
if (method_prototype && DIRECT_METHOD_FLAG (method_prototype))
{
#if 0
warning ("method `%s' has direct qualifier.",
IDENTIFIER_POINTER (METHOD_SEL_NAME (method_prototype)));
#endif
if (!statically_typed && !class_ident)
{
bzero (errbuf, BUFSIZE);
error ("invalid receiver type `%s' for direct method",
IS_SUPER (rtype) ? "super" : gen_declaration (rtype, errbuf));
}
}
building_objc_message_expr = sel_name;
if (flag_typed_selectors)
selector = build_typed_selector_reference (sel_name, method_prototype);
else
selector = build_selector_reference (sel_name);
retval = build_objc_method_call (super, method_prototype,
receiver, self_object,
selector, method_params);
building_objc_message_expr = 0;
return retval;
}
static int
is_protocol_contained_in_protocols PROTO((tree, tree));
is_protocol_contained_in_protocol (protocol1, protocol2)
tree protocol1;
tree protocol2;
{
if (protocol1 == protocol2)
return 1;
return is_protocol_contained_in_protocols(protocol1, PROTOCOL_LIST(protocol2));
}
static int
is_protocol_contained_in_protocols (protocol, protocols)
tree protocol;
tree protocols;
{
while (protocols) {
if (is_protocol_contained_in_protocol(protocol, TREE_VALUE(protocols))) return 1;
protocols = TREE_CHAIN (protocols);
}
return 0;
}
static int
check_protocol (p, type, name)
tree p;
char *type;
char *name;
{
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
int f1, f2;
if (flag_warn_protocol) {
f1 = check_methods (PROTOCOL_CLS_METHODS (p),
CLASS_CLS_METHODS (implementation_context),
'+');
f2 = check_methods (PROTOCOL_NST_METHODS (p),
CLASS_NST_METHODS (implementation_context),
'-');
} else {
f1 = check_methods_accessible (PROTOCOL_CLS_METHODS (p),
implementation_context,
'+');
f2 = check_methods_accessible (PROTOCOL_NST_METHODS (p),
implementation_context,
'-');
}
if (!f1 || !f2)
warning ("%s `%s' does not fully implement the `%s' protocol",
type, name, IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
else
;
if (PROTOCOL_LIST (p))
{
tree subs = PROTOCOL_LIST(p);
tree super_class = lookup_interface (CLASS_SUPER_NAME (implementation_template));
while (subs) {
tree sub = TREE_VALUE(subs);
if (!super_class || !conforms_to_protocol (super_class, sub))
check_protocol (sub, type, name);
subs = TREE_CHAIN(subs);
}
}
}
static tree
method_id_for_method(tree method)
{
tree method_origin, method_id;
char *buf, *selector_name, *class_name, *category_name;
method_origin = METHOD_ORIGIN (method);
if (method_origin == NULL_TREE)
{
fatal ("Origin of method `%s' cannot be determined",
IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
}
selector_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
class_name = IDENTIFIER_POINTER (CLASS_NAME (method_origin));
if (DIRECT_METHOD_FLAG (method))
{
category_name = "__direct__";
}
else
{
category_name =
((TREE_CODE (implementation_context) == CLASS_IMPLEMENTATION_TYPE)
? NULL : IDENTIFIER_POINTER (CLASS_SUPER_NAME (method_origin)));
}
method_slot++;
buf = (char *) alloca (50 + strlen (selector_name) + strlen (class_name)
+ (category_name ? strlen (category_name) : 0));
OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL,
class_name, category_name, selector_name, 0);
method_id = get_identifier (buf);
return method_id;
}
static tree
build_function_decl_for_prototype (method_prototype)
tree method_prototype;
{
tree name, return_type, args, function_type, decl;
name = method_id_for_method (method_prototype);
args = get_arg_type_list (method_prototype, METHOD_REF, 0);
return_type = groktypename (TREE_TYPE (method_prototype));
function_type = build_function_type (return_type, args);
#ifndef OBJCPLUS
decl = build_decl (FUNCTION_DECL, name, function_type);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = ! STATIC_METHOD_FLAG (method_prototype);
make_decl_rtl (decl, NULL_PTR, 1);
pushdecl (decl);
#else
decl = build_lang_decl (FUNCTION_DECL, name, function_type);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = ! STATIC_METHOD_FLAG (method_prototype);
pushdecl (decl);
make_function_rtl (decl);
#endif
return decl;
}
static tree
build_objc_method_call (super_flag, method_prototype, lookup_object, object,
selector, method_params)
int super_flag;
tree method_prototype, lookup_object, object, selector, method_params;
{
tree sender = (super_flag ? umsg_super_decl : umsg_decl);
tree rcv_p = (super_flag
? build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (TAG_SUPER)))
: id_type);
if (flag_next_runtime)
{
if (! method_prototype)
{
method_params = tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
method_params));
assemble_external (sender);
return build_function_call (sender, method_params);
}
else if (DIRECT_METHOD_FLAG (method_prototype))
{
tree function_decl;
method_params = tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
method_params));
function_decl = METHOD_DEFINITION (method_prototype);
if (! function_decl)
{
function_decl =
objcplus_lookup_name (method_id_for_method (method_prototype));
if (! function_decl)
{
function_decl =
build_function_decl_for_prototype (method_prototype);
}
}
return build_function_call (function_decl, method_params);
}
else
{
tree arglist = NULL_TREE;
tree retval, savarg, savret;
#ifdef STRUCT_VALUE
tree ret_type = groktypename (TREE_TYPE (method_prototype));
if (TREE_CODE (ret_type) == RECORD_TYPE
#if defined (DEFAULT_PCC_STRUCT_RETURN) && DEFAULT_PCC_STRUCT_RETURN == 0
&& RETURN_IN_MEMORY (ret_type)
#endif
&& STRUCT_VALUE == 0)
sender = (super_flag ? umsg_super_stret_decl : umsg_stret_decl);
#endif
savarg = TYPE_ARG_TYPES (TREE_TYPE (sender));
savret = TREE_TYPE (TREE_TYPE (sender));
arglist = get_arg_type_list (method_prototype, METHOD_REF,
super_flag);
TYPE_ARG_TYPES (TREE_TYPE (sender)) = arglist;
TREE_TYPE (TREE_TYPE (sender))
= groktypename (TREE_TYPE (method_prototype));
method_params = tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
method_params));
assemble_external (sender);
retval = build_function_call (sender, method_params);
TYPE_ARG_TYPES (TREE_TYPE (sender)) = savarg;
TREE_TYPE (TREE_TYPE (sender)) = savret;
return retval;
}
}
else
{
tree method;
object = save_expr (object);
selector = save_expr (selector);
lookup_object = build_c_cast (rcv_p, lookup_object);
assemble_external (sender);
method
= build_function_call (sender,
tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
NULL_TREE)));
if (method_prototype)
{
tree arglist = get_arg_type_list (method_prototype, METHOD_REF,
super_flag);
tree valtype = groktypename (TREE_TYPE (method_prototype));
tree fake_function_type = build_function_type (valtype, arglist);
TREE_TYPE (method) = build_pointer_type (fake_function_type);
}
else
TREE_TYPE (method)
= build_pointer_type (build_function_type (ptr_type_node, NULL_TREE));
assemble_external (method);
return build_function_call (method,
tree_cons (NULL_TREE, object,
tree_cons (NULL_TREE, selector,
method_params)));
}
}
static void
build_protocol_reference (p)
tree p;
{
tree decl, ident, ptype, constructor;
struct obstack *save_current_obstack = current_obstack;
struct obstack *save_rtl_obstack = rtl_obstack;
if (! PROTOCOL_DEFINED (p))
{
error ("protocol `%s' used but not never defined",
IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
rtl_obstack = current_obstack = &permanent_obstack;
ident = synth_id_with_class_suffix ("_OBJC_PROTOCOL", p);
ptype
= groktypename (build_tree_list (build_tree_list (NULL_TREE,
objc_protocol_template),
NULL_TREE));
if (IDENTIFIER_GLOBAL_VALUE (ident))
decl = IDENTIFIER_GLOBAL_VALUE (ident);
else
{
decl = build_decl (VAR_DECL, ident, ptype);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 0;
TREE_USED (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
make_decl_rtl (decl, 0, 1);
pushdecl_top_level (decl);
}
current_obstack = save_current_obstack;
rtl_obstack = save_rtl_obstack;
PROTOCOL_FORWARD_DECL (p) = decl;
}
tree
build_protocol_expr (protoname)
tree protoname;
{
tree expr;
tree p;
if (!doing_objc_thang)
objc_fatal ();
p = lookup_protocol (protoname);
if (!p)
{
error ("Cannot find protocol declaration for `%s'",
IDENTIFIER_POINTER (protoname));
return error_mark_node;
}
if (!PROTOCOL_FORWARD_DECL (p))
build_protocol_reference (p);
expr = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
TREE_TYPE (expr) = protocol_type;
#ifdef NEXT_PDO
add_static_object (PROTOCOL_FORWARD_DECL (p),protocol_id);
#endif
return expr;
}
tree
build_selector_expr (selnamelist)
tree selnamelist;
{
tree selname;
if (!doing_objc_thang)
objc_fatal ();
if (TREE_CODE (selnamelist) == IDENTIFIER_NODE)
selname = selnamelist;
else if (TREE_CODE (selnamelist) == TREE_LIST)
selname = build_keyword_selector (selnamelist);
if (flag_typed_selectors)
return build_typed_selector_reference (selname, 0);
else
return build_selector_reference (selname);
}
tree
build_encode_expr (type)
tree type;
{
tree result;
char *string;
if (!doing_objc_thang)
objc_fatal ();
encode_type (type, obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
obstack_1grow (&util_obstack, 0);
string = obstack_finish (&util_obstack);
result = my_build_string (strlen (string) + 1, string);
obstack_free (&util_obstack, util_firstobj);
return result;
}
tree
build_ivar_reference (id)
tree id;
{
if (TREE_CODE (method_context) == CLASS_METHOD_DECL)
{
warning ("instance variable `%s' accessed in class method",
IDENTIFIER_POINTER (id));
TREE_TYPE (self_decl) = instance_type;
}
return build_component_ref (build_indirect_ref (self_decl, "->"), id);
}
#define HASH_ALLOC_LIST_SIZE 170
#define ATTR_ALLOC_LIST_SIZE 170
#define SIZEHASHTABLE 257
#define HASHFUNCTION(key) ((HOST_WIDE_INT) key & 0x7fffffff)
static void
hash_init ()
{
nst_method_hash_list = (hash *)xmalloc (SIZEHASHTABLE * sizeof (hash));
cls_method_hash_list = (hash *)xmalloc (SIZEHASHTABLE * sizeof (hash));
if (!nst_method_hash_list || !cls_method_hash_list)
perror ("unable to allocate space in objc-act.c");
else
{
int i;
for (i = 0; i < SIZEHASHTABLE; i++)
{
nst_method_hash_list[i] = 0;
cls_method_hash_list[i] = 0;
}
}
}
static void
hash_enter (hashlist, method)
hash *hashlist;
tree method;
{
static hash hash_alloc_list = 0;
static int hash_alloc_index = 0;
hash obj;
int slot = HASHFUNCTION (METHOD_SEL_NAME (method)) % SIZEHASHTABLE;
if (! hash_alloc_list || hash_alloc_index >= HASH_ALLOC_LIST_SIZE)
{
hash_alloc_index = 0;
hash_alloc_list = (hash) xmalloc (sizeof (struct hashed_entry)
* HASH_ALLOC_LIST_SIZE);
if (! hash_alloc_list)
perror ("unable to allocate in objc-act.c");
}
obj = &hash_alloc_list[hash_alloc_index++];
obj->list = 0;
obj->next = hashlist[slot];
obj->key = method;
hashlist[slot] = obj;
}
static hash
hash_lookup (hashlist, sel_name)
hash *hashlist;
tree sel_name;
{
hash target;
target = hashlist[HASHFUNCTION (sel_name) % SIZEHASHTABLE];
while (target)
{
if (sel_name == METHOD_SEL_NAME (target->key))
return target;
target = target->next;
}
return 0;
}
static void
hash_add_attr (entry, value)
hash entry;
tree value;
{
static attr attr_alloc_list = 0;
static int attr_alloc_index = 0;
attr obj;
if (! attr_alloc_list || attr_alloc_index >= ATTR_ALLOC_LIST_SIZE)
{
attr_alloc_index = 0;
attr_alloc_list = (attr) xmalloc (sizeof (struct hashed_attribute)
* ATTR_ALLOC_LIST_SIZE);
if (! attr_alloc_list)
perror ("unable to allocate in objc-act.c");
}
obj = &attr_alloc_list[attr_alloc_index++];
obj->next = entry->list;
obj->value = value;
entry->list = obj;
}
static tree
lookup_method (mchain, method)
tree mchain;
tree method;
{
tree key;
if (TREE_CODE (method) == IDENTIFIER_NODE)
key = method;
else
key = METHOD_SEL_NAME (method);
while (mchain)
{
if (METHOD_SEL_NAME (mchain) == key)
return mchain;
mchain = TREE_CHAIN (mchain);
}
return NULL_TREE;
}
static tree
lookup_instance_method_static (interface, ident)
tree interface;
tree ident;
{
tree inter = interface;
tree chain = CLASS_NST_METHODS (inter);
tree meth = NULL_TREE;
do
{
if ((meth = lookup_method (chain, ident)))
return meth;
if (CLASS_CATEGORY_LIST (inter))
{
tree category = CLASS_CATEGORY_LIST (inter);
chain = CLASS_NST_METHODS (category);
do
{
if ((meth = lookup_method (chain, ident)))
return meth;
if (CLASS_PROTOCOL_LIST (category))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (category), ident, 0))))
return meth;
}
if ((category = CLASS_CATEGORY_LIST (category)))
chain = CLASS_NST_METHODS (category);
}
while (category);
}
if (CLASS_PROTOCOL_LIST (inter))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (inter), ident, 0))))
return meth;
}
if ((inter = lookup_interface (CLASS_SUPER_NAME (inter))))
chain = CLASS_NST_METHODS (inter);
}
while (inter);
return meth;
}
static tree
lookup_class_method_static (interface, ident)
tree interface;
tree ident;
{
tree inter = interface;
tree chain = CLASS_CLS_METHODS (inter);
tree meth = NULL_TREE;
tree root_inter = NULL_TREE;
do
{
if ((meth = lookup_method (chain, ident)))
return meth;
if (CLASS_CATEGORY_LIST (inter))
{
tree category = CLASS_CATEGORY_LIST (inter);
chain = CLASS_CLS_METHODS (category);
do
{
if ((meth = lookup_method (chain, ident)))
return meth;
if (CLASS_PROTOCOL_LIST (category))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (category), ident, 1))))
return meth;
}
if ((category = CLASS_CATEGORY_LIST (category)))
chain = CLASS_CLS_METHODS (category);
}
while (category);
}
if (CLASS_PROTOCOL_LIST (inter))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (inter), ident, 1))))
return meth;
}
root_inter = inter;
if ((inter = lookup_interface (CLASS_SUPER_NAME (inter))))
chain = CLASS_CLS_METHODS (inter);
}
while (inter);
return lookup_instance_method_static (root_inter, ident);
}
tree
add_class_method (class, method)
tree class;
tree method;
{
tree mth;
tree super = class;
hash hsh;
preserve_data ();
while (CLASS_SUPER_NAME (super))
{
if ((super = lookup_interface (CLASS_SUPER_NAME (super))) == 0)
break;
else if ((mth = lookup_method (CLASS_CLS_METHODS (super), method)))
{
if (!comp_proto_with_proto (method, mth))
{
error ("mismatch method `+%s' with super class prototype",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
error_with_decl (mth, "super class declaration of `+%s'");
}
break;
}
}
if (!(mth = lookup_method (CLASS_CLS_METHODS (class), method)))
{
TREE_CHAIN (method) = CLASS_CLS_METHODS (class);
CLASS_CLS_METHODS (class) = method;
METHOD_ORIGIN (method) = class;
}
else
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
error ("duplicate definition of class method `%s'.",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
else
{
if (!comp_proto_with_proto (method, mth))
error ("duplicate declaration of class method `%s'.",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
}
}
if (!(hsh = hash_lookup (cls_method_hash_list, METHOD_SEL_NAME (method))))
{
hash_enter (cls_method_hash_list, method);
}
else
{
if (!comp_proto_with_proto (method, hsh->key))
hash_add_attr (hsh, method);
}
return method;
}
tree
add_instance_method (class, method)
tree class;
tree method;
{
tree mth;
tree super = class;
hash hsh;
preserve_data ();
while (CLASS_SUPER_NAME (super))
{
if ((super = lookup_interface (CLASS_SUPER_NAME (super))) == 0)
break;
else if ((mth = lookup_method (CLASS_NST_METHODS (super), method)))
{
if (!comp_proto_with_proto (method, mth))
{
error ("mismatch method `-%s' with super class prototype",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
error_with_decl (mth, "super class declaration of `-%s'");
}
break;
}
}
if (!(mth = lookup_method (CLASS_NST_METHODS (class), method)))
{
TREE_CHAIN (method) = CLASS_NST_METHODS (class);
CLASS_NST_METHODS (class) = method;
METHOD_ORIGIN (method) = class;
}
else
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
error ("duplicate definition of instance method `%s'.",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
else
{
if (!comp_proto_with_proto (method, mth))
error ("duplicate declaration of instance method `%s'.",
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
}
}
if (!(hsh = hash_lookup (nst_method_hash_list, METHOD_SEL_NAME (method))))
{
hash_enter (nst_method_hash_list, method);
}
else
{
if (!comp_proto_with_proto (method, hsh->key))
hash_add_attr (hsh, method);
}
return method;
}
static tree
add_class (class)
tree class;
{
TREE_CHAIN (class) = interface_chain;
interface_chain = class;
return interface_chain;
}
static void
add_category (class, category)
tree class;
tree category;
{
tree cat = CLASS_CATEGORY_LIST (class);
while (cat)
{
if (CLASS_SUPER_NAME (cat) == CLASS_SUPER_NAME (category))
{
warning ("duplicate interface declaration for category `%s(%s)'",
IDENTIFIER_POINTER (CLASS_NAME (class)),
IDENTIFIER_POINTER (CLASS_SUPER_NAME (category)));
if (CLASS_CLS_METHODS (cat))
warning_with_decl (CLASS_CLS_METHODS (cat), "previous declaration", 0);
else if (CLASS_NST_METHODS (cat))
warning_with_decl (CLASS_NST_METHODS (cat), "previous declaration", 0);
}
cat = CLASS_CATEGORY_LIST (cat);
}
CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (class);
CLASS_CATEGORY_LIST (class) = category;
}
tree
add_instance_variable (class, public, declarator, declspecs, width)
tree class;
int public;
tree declarator;
tree declspecs;
tree width;
{
tree field_decl, raw_decl, field_type;
char *type_name, *ivar_name;
raw_decl = build_tree_list (declspecs , declarator);
if (CLASS_RAW_IVARS (class))
chainon (CLASS_RAW_IVARS (class), raw_decl);
else
CLASS_RAW_IVARS (class) = raw_decl;
field_decl = grokfield (input_filename, lineno,
declarator, declspecs, width);
field_type = TREE_TYPE(field_decl);
ivar_name = IDENTIFIER_POINTER (DECL_NAME (field_decl));
if (TREE_CODE (field_type) == REFERENCE_TYPE)
{
error ("illegal reference type specified for instance variable `%s'",
ivar_name);
return class;
}
#ifdef OBJCPLUS
if(IS_AGGR_TYPE(field_type) && (TYPE_NEEDS_CONSTRUCTING(field_type)
|| TYPE_NEEDS_DESTRUCTOR(field_type) || TYPE_VIRTUAL_P(field_type)))
{
type_name = IDENTIFIER_POINTER(objcplus_TYPE_NAME(field_type));
if(TYPE_VIRTUAL_P(field_type)) {
error ("type `%s' has virtual member functions", type_name);
error ("illegal aggregate type `%s' specified for instance variable `%s'",
type_name, ivar_name);
return class;
}
if(TYPE_NEEDS_CONSTRUCTING(field_type))
warning ("type `%s' has a user-defined constructor", type_name);
if(TYPE_NEEDS_DESTRUCTOR(field_type))
warning ("type `%s' has a user-defined destructor", type_name);
warning("C++ constructors and destructors will not be invoked for Objective-C fields");
}
#endif
switch (public)
{
case 0:
TREE_PUBLIC (field_decl) = 0;
TREE_PRIVATE (field_decl) = 0;
TREE_PROTECTED (field_decl) = 1;
break;
case 1:
TREE_PUBLIC (field_decl) = 1;
TREE_PRIVATE (field_decl) = 0;
TREE_PROTECTED (field_decl) = 0;
break;
case 2:
TREE_PUBLIC (field_decl) = 0;
TREE_PRIVATE (field_decl) = 1;
TREE_PROTECTED (field_decl) = 0;
break;
}
if (CLASS_IVARS (class))
chainon (CLASS_IVARS (class), field_decl);
else
CLASS_IVARS (class) = field_decl;
return class;
}
tree
is_ivar (decl_chain, ident)
tree decl_chain;
tree ident;
{
for ( ; decl_chain; decl_chain = TREE_CHAIN (decl_chain))
if (DECL_NAME (decl_chain) == ident)
return decl_chain;
return NULL_TREE;
}
int
is_private (decl)
tree decl;
{
if (TREE_PRIVATE (decl)
&& ! is_ivar (CLASS_IVARS (implementation_template), DECL_NAME (decl)))
{
error ("instance variable `%s' is declared private",
IDENTIFIER_POINTER (DECL_NAME (decl)));
return 1;
}
else
return 0;
}
int
is_public (expr, identifier)
tree expr;
tree identifier;
{
tree basetype = TREE_TYPE (expr);
enum tree_code code = TREE_CODE (basetype);
tree decl;
if (code == RECORD_TYPE)
{
if (TREE_STATIC_TEMPLATE (basetype))
{
if (!lookup_interface (objcplus_TYPE_NAME (basetype)))
{
error ("Cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (objcplus_TYPE_NAME (basetype)));
return 0;
}
if ((decl = is_ivar (TYPE_FIELDS (basetype), identifier)))
{
if (TREE_PUBLIC (decl))
return 1;
if (implementation_context
&& (((TREE_CODE (implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
|| (TREE_CODE (implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE))
&& (CLASS_NAME (implementation_context)
== objcplus_TYPE_NAME (basetype))))
return ! is_private (decl);
error ("instance variable `%s' is declared %s",
IDENTIFIER_POINTER (identifier),
TREE_PRIVATE (decl) ? "private" : "protected");
return 0;
}
}
else if (implementation_context && (basetype == objc_object_reference))
{
TREE_TYPE (expr) = uprivate_record;
warning ("static access to object of type `id'");
}
}
return 1;
}
tree
get_class_ivars (interface)
tree interface;
{
if (!doing_objc_thang)
objc_fatal ();
#ifdef OBJCPLUS
return build_tree_list ((tree)access_default_node,
build_ivar_chain (interface, 1));
#else
return build_ivar_chain (interface, 1);
#endif
}
static int
check_methods (chain, list, mtype)
tree chain;
tree list;
int mtype;
{
int first = 1;
while (chain)
{
if (!lookup_method (list, chain))
{
if (first)
{
if (TREE_CODE (implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
warning ("incomplete implementation of class `%s'",
IDENTIFIER_POINTER (CLASS_NAME (implementation_context)));
else if (TREE_CODE (implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE)
warning ("incomplete implementation of category `%s'",
IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context)));
first = 0;
}
warning ("method definition for `%c%s' not found",
mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
}
chain = TREE_CHAIN (chain);
}
return first;
}
static int
conforms_to_protocol (class, protocol)
tree class;
tree protocol;
{
while (protocol)
{
tree p = CLASS_PROTOCOL_LIST (class);
if(p && TREE_CODE(protocol) == PROTOCOL_INTERFACE_TYPE
&& TREE_VALUE(p) == protocol)
break;
while (p && TREE_VALUE (p) != TREE_VALUE (protocol))
p = TREE_CHAIN (p);
if (!p)
{
tree super = (CLASS_SUPER_NAME (class)
? lookup_interface (CLASS_SUPER_NAME (class))
: NULL_TREE);
int tmp = super ? conforms_to_protocol (super, protocol) : 0;
if (!tmp)
return 0;
}
protocol = TREE_CHAIN (protocol);
}
return 1;
}
static int
check_methods_accessible (chain, context, mtype)
tree chain;
tree context;
int mtype;
{
int first = 1;
tree list;
tree base_context = context;
while (chain)
{
context = base_context;
while (context)
{
if (mtype == '+')
list = CLASS_CLS_METHODS (context);
else
list = CLASS_NST_METHODS (context);
if (lookup_method (list, chain))
break;
else if (TREE_CODE (context) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (context) == CLASS_INTERFACE_TYPE)
context = (CLASS_SUPER_NAME (context)
? lookup_interface (CLASS_SUPER_NAME (context))
: NULL_TREE);
else if (TREE_CODE (context) == CATEGORY_IMPLEMENTATION_TYPE
|| TREE_CODE (context) == CATEGORY_INTERFACE_TYPE)
context = (CLASS_NAME (context)
? lookup_interface (CLASS_NAME (context))
: NULL_TREE);
else
abort ();
}
if (context == NULL_TREE)
{
if (first)
{
if (TREE_CODE (implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
warning ("incomplete implementation of class `%s'",
IDENTIFIER_POINTER
(CLASS_NAME (implementation_context)));
else if (TREE_CODE (implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE)
warning ("incomplete implementation of category `%s'",
IDENTIFIER_POINTER
(CLASS_SUPER_NAME (implementation_context)));
first = 0;
}
warning ("method definition for `%c%s' not found",
mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
}
chain = TREE_CHAIN (chain);
}
return first;
}
static void
check_protocols (proto_list, type, name)
tree proto_list;
char *type;
char *name;
{
for ( ; proto_list; proto_list = TREE_CHAIN (proto_list))
{
tree p = TREE_VALUE (proto_list);
check_protocol (p, type, name);
}
}
tree
start_class (code, class_name, super_name, protocol_list)
enum tree_code code;
tree class_name;
tree super_name;
tree protocol_list;
{
tree class, decl;
c_language = clk_objective_c;
#ifdef OBJCPLUS
if(current_namespace != global_namespace) {
error("Objective-C declarations may only appear in global scope");
}
#endif
if (flag_gen_index)
{
switch (code)
{
case CLASS_INTERFACE_TYPE:
dump_symbol_info ("+ch ", class_name->identifier.pointer, lineno);
if (super_name != NULL)
dump_symbol_info ("+ci ", super_name->identifier.pointer, 0);
break;
case CLASS_IMPLEMENTATION_TYPE:
dump_symbol_info ("+cm ", class_name->identifier.pointer, lineno);
if (super_name != NULL)
dump_symbol_info ("+ci ", super_name->identifier.pointer, 0);
break;
case CATEGORY_INTERFACE_TYPE:
dump_symbol_info ("+Ch ", super_name->identifier.pointer, lineno);
dump_symbol_info ("+ci ", class_name->identifier.pointer, lineno);
break;
case CATEGORY_IMPLEMENTATION_TYPE:
dump_symbol_info ("+Cm ", super_name->identifier.pointer, lineno);
dump_symbol_info ("+ci ", class_name->identifier.pointer, lineno);
break;
default:
break;
}
if (protocol_list)
{
tree protocol_node = protocol_list;
do
{
dump_symbol_info ("+Pi ", IDENTIFIER_POINTER (TREE_VALUE (protocol_node)), 0);
protocol_node = TREE_CHAIN (protocol_node);
}
while (protocol_node);
}
}
if ((code == CLASS_IMPLEMENTATION_TYPE)
&& objc_implementation_context)
{
warning ("`@end' missing in implementation context");
finish_class (objc_implementation_context);
objc_ivar_chain = NULL_TREE;
objc_implementation_context = NULL_TREE;
}
if (code == CLASS_INTERFACE_TYPE)
{
push_obstacks_nochange ();
end_temporary_allocation ();
}
if (!doing_objc_thang)
objc_fatal ();
#ifdef OBJCPLUS
{
struct obstack *ambient_obstack = current_obstack;
current_obstack = &permanent_obstack;
#endif
class = make_node (code);
TYPE_BINFO (class) = make_tree_vec (5);
#ifdef OBJCPLUS
current_obstack = ambient_obstack;
}
#endif
CLASS_NAME (class) = class_name;
CLASS_SUPER_NAME (class) = super_name;
CLASS_CLS_METHODS (class) = NULL_TREE;
if (! is_class_name (class_name) && (decl = objcplus_lookup_name (class_name)))
{
error ("`%s' redeclared as different kind of symbol",
IDENTIFIER_POINTER (class_name));
error_with_decl (decl, "previous declaration of `%s'");
}
if (code == CLASS_IMPLEMENTATION_TYPE)
{
{
static tree implemented_classes = 0;
tree chain = implemented_classes;
for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain))
if (TREE_VALUE (chain) == class_name)
{
error ("reimplementation of class `%s'",
IDENTIFIER_POINTER (class_name));
return error_mark_node;
}
implemented_classes = perm_tree_cons (NULL_TREE, class_name,
implemented_classes);
}
if (!self_id)
self_id = get_identifier ("self");
if (!ucmd_id)
ucmd_id = get_identifier ("_cmd");
#ifndef NEXT_OBJC_RUNTIME
if (!unused_list)
unused_list
= build_tree_list (get_identifier ("__unused__"), NULL_TREE);
#endif
if (!objc_super_template)
objc_super_template = build_super_template ();
method_slot = 0;
implementation_context = class;
if (!(implementation_template = lookup_interface (class_name)))
{
warning ("Cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (class_name));
add_class (implementation_template = implementation_context);
}
if (super_name
&& (super_name != CLASS_SUPER_NAME (implementation_template)))
{
tree previous_name = CLASS_SUPER_NAME (implementation_template);
char *name = previous_name ? IDENTIFIER_POINTER (previous_name) : "";
error ("conflicting super class name `%s'",
IDENTIFIER_POINTER (super_name));
error ("previous declaration of `%s'", name);
}
else if (! super_name)
{
CLASS_SUPER_NAME (implementation_context)
= CLASS_SUPER_NAME (implementation_template);
}
}
else if (code == CLASS_INTERFACE_TYPE)
{
if (lookup_interface (class_name))
warning ("duplicate interface declaration for class `%s'",
IDENTIFIER_POINTER (class_name));
else
add_class (class);
if (protocol_list)
CLASS_PROTOCOL_LIST (class)
= lookup_and_install_protocols (protocol_list);
}
else if (code == CATEGORY_INTERFACE_TYPE)
{
tree class_category_is_assoc_with;
if (!(class_category_is_assoc_with = lookup_interface (class_name)))
{
error ("Cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (class_name));
exit (FATAL_EXIT_CODE);
}
else
add_category (class_category_is_assoc_with, class);
if (protocol_list)
CLASS_PROTOCOL_LIST (class)
= lookup_and_install_protocols (protocol_list);
}
else if (code == CATEGORY_IMPLEMENTATION_TYPE)
{
if (!self_id)
self_id = get_identifier ("self");
if (!ucmd_id)
ucmd_id = get_identifier ("_cmd");
#ifndef NEXT_OBJC_RUNTIME
if (!unused_list)
unused_list
= build_tree_list (get_identifier ("__unused__"), NULL_TREE);
#endif
if (!objc_super_template)
objc_super_template = build_super_template ();
method_slot = 0;
implementation_context = class;
if (!(implementation_template = lookup_interface (class_name)))
{
error ("Cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (class_name));
exit (FATAL_EXIT_CODE);
}
}
return class;
}
tree
continue_class (class)
tree class;
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
{
struct imp_entry *imp_entry;
tree ivar_context;
if (CLASS_IVARS (class))
check_ivars (implementation_template, class);
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
ivar_context = build_private_template (implementation_template);
if (!objc_class_template)
build_class_template ();
if (!(imp_entry = (struct imp_entry *) xmalloc (sizeof (struct imp_entry))))
perror ("unable to allocate in objc-act.c");
imp_entry->next = imp_list;
imp_entry->imp_context = class;
imp_entry->imp_template = implementation_template;
synth_forward_declarations ();
imp_entry->class_decl = UOBJC_CLASS_decl;
imp_entry->meta_decl = UOBJC_METACLASS_decl;
imp_list = imp_entry;
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
imp_count++;
else
cat_count++;
#ifdef OBJCPLUS
pop_lang_context ();
#endif
return ivar_context;
}
else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
{
tree record;
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
record = xref_tag (RECORD_TYPE, CLASS_NAME (class));
if (!TYPE_FIELDS (record))
{
#ifdef OBJCPLUS
build_private_template (class);
#else
objcplus_finish_struct (record, build_ivar_chain (class, 0));
CLASS_STATIC_TEMPLATE (class) = record;
#endif
TREE_STATIC_TEMPLATE (record) = 1;
}
#ifdef OBJCPLUS
pop_lang_context ();
#endif
return NULL_TREE;
}
else
return error_mark_node;
}
void
finish_class (class)
tree class;
{
int save_flag_dump_symbols = flag_dump_symbols;
int save_flag_gen_index = flag_gen_index;
if (flag_dump_symbols)
{
switch (TREE_CODE (class))
{
case CLASS_INTERFACE_TYPE:
printf ("-ch %u\n", lineno);
break;
case CLASS_IMPLEMENTATION_TYPE:
printf ("-cm %u\n", lineno);
break;
case CATEGORY_INTERFACE_TYPE:
printf ("-Ch %u\n", lineno);
break;
case CATEGORY_IMPLEMENTATION_TYPE:
printf ("-Cm %u\n", lineno);
break;
default:
printf ("-?? %u\n", lineno);
break;
}
}
if (flag_gen_index)
{
switch (TREE_CODE (class))
{
case CLASS_INTERFACE_TYPE:
dump_symbol_info ("-ch ", NULL, lineno);
break;
case CLASS_IMPLEMENTATION_TYPE:
dump_symbol_info ("-cm ", NULL, lineno);
break;
case CATEGORY_INTERFACE_TYPE:
dump_symbol_info ("-Ch ", NULL, lineno);
break;
case CATEGORY_IMPLEMENTATION_TYPE:
dump_symbol_info ("-Cm ", NULL, lineno);
break;
default:
dump_symbol_info ("-?? ", NULL, lineno);
break;
}
}
flag_dump_symbols = 0;
flag_gen_index = 0;
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
{
if (implementation_template != implementation_context)
{
check_methods (CLASS_CLS_METHODS (implementation_template),
CLASS_CLS_METHODS (implementation_context), '+');
check_methods (CLASS_NST_METHODS (implementation_template),
CLASS_NST_METHODS (implementation_context), '-');
if (CLASS_PROTOCOL_LIST (implementation_template))
check_protocols (CLASS_PROTOCOL_LIST (implementation_template),
"class",
IDENTIFIER_POINTER (CLASS_NAME (implementation_context)));
}
}
else if (TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
{
tree category = CLASS_CATEGORY_LIST (implementation_template);
while (category)
{
if (CLASS_SUPER_NAME (class) == CLASS_SUPER_NAME (category))
break;
category = CLASS_CATEGORY_LIST (category);
}
if (category)
{
check_methods (CLASS_CLS_METHODS (category),
CLASS_CLS_METHODS (implementation_context), '+');
check_methods (CLASS_NST_METHODS (category),
CLASS_NST_METHODS (implementation_context), '-');
if (CLASS_PROTOCOL_LIST (category))
check_protocols (CLASS_PROTOCOL_LIST (category),
"category",
IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context)));
}
}
else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
{
tree decl_specs;
char *class_name = IDENTIFIER_POINTER (CLASS_NAME (class));
char *string = (char *) alloca (strlen (class_name) + 3);
sprintf (string, "_%s", class_name);
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]);
decl_specs = tree_cons (NULL_TREE, objc_object_reference, decl_specs);
define_decl (build1 (INDIRECT_REF, NULL_TREE, get_identifier (string)),
decl_specs);
}
flag_dump_symbols = save_flag_dump_symbols;
flag_gen_index = save_flag_gen_index;
}
static tree
add_protocol (protocol)
tree protocol;
{
TREE_CHAIN (protocol) = protocol_chain;
protocol_chain = protocol;
return protocol_chain;
}
static tree
lookup_protocol (ident)
tree ident;
{
tree chain;
for (chain = protocol_chain; chain; chain = TREE_CHAIN (chain))
{
if (ident == PROTOCOL_NAME (chain))
return chain;
}
return NULL_TREE;
}
void
objc_declare_protocols (names)
tree names;
{
tree list;
if (!doing_objc_thang)
objc_fatal ();
#ifdef OBJCPLUS
if(current_namespace != global_namespace) {
error("Objective-C declarations may only appear in global scope");
}
#endif
for (list = names; list; list = TREE_CHAIN (list))
{
tree name = TREE_VALUE (list);
if (lookup_protocol (name) == NULL_TREE)
{
tree protocol = make_node (PROTOCOL_INTERFACE_TYPE);
TYPE_BINFO (protocol) = make_tree_vec (2);
PROTOCOL_NAME (protocol) = name;
PROTOCOL_LIST (protocol) = NULL_TREE;
add_protocol (protocol);
PROTOCOL_DEFINED (protocol) = 0;
PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
}
}
}
tree
start_protocol (code, name, list)
enum tree_code code;
tree name;
tree list;
{
tree protocol;
if (!doing_objc_thang)
objc_fatal ();
#ifdef OBJCPLUS
if(current_namespace != global_namespace) {
error("Objective-C declarations may only appear in global scope");
}
#endif
if (!objc_protocol_template)
objc_protocol_template = build_protocol_template ();
protocol = lookup_protocol (name);
if (!protocol)
{
protocol = make_node (code);
TYPE_BINFO (protocol) = make_tree_vec (2);
PROTOCOL_NAME (protocol) = name;
PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list);
add_protocol (protocol);
PROTOCOL_DEFINED (protocol) = 1;
PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
check_protocol_recursively (protocol, list);
}
else if (! PROTOCOL_DEFINED (protocol))
{
PROTOCOL_DEFINED (protocol) = 1;
PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list);
check_protocol_recursively (protocol, list);
}
else
{
warning ("duplicate declaration for protocol `%s'",
IDENTIFIER_POINTER (name));
}
if (flag_gen_index)
{
tree chain = PROTOCOL_LIST (protocol);
while (chain)
{
dump_symbol_info ("+Pi ",
IDENTIFIER_POINTER
(PROTOCOL_NAME (TREE_VALUE (chain))),
lineno);
chain = TREE_CHAIN (chain);
}
}
return protocol;
}
void
finish_protocol (protocol)
tree protocol;
{
}
static void
encode_type_qualifiers (declspecs)
tree declspecs;
{
tree spec;
for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
{
if (ridpointers[(int) RID_CONST] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'r');
else if (ridpointers[(int) RID_IN] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'n');
else if (ridpointers[(int) RID_INOUT] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'N');
else if (ridpointers[(int) RID_OUT] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'o');
else if (ridpointers[(int) RID_BYCOPY] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'O');
else if (ridpointers[(int) RID_BYREF] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'R');
else if (ridpointers[(int) RID_ONEWAY] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'V');
}
}
static void
encode_pointer (type, curtype, format)
tree type;
int curtype;
int format;
{
tree pointer_to = TREE_TYPE (type);
if (TREE_CODE (pointer_to) == RECORD_TYPE)
{
if (objcplus_TYPE_NAME (pointer_to)
&& TREE_CODE (objcplus_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE)
{
char *name = IDENTIFIER_POINTER (objcplus_TYPE_NAME (pointer_to));
if (strcmp (name, TAG_OBJECT) == 0)
{
obstack_1grow (&util_obstack, '@');
return;
}
else if (TREE_STATIC_TEMPLATE (pointer_to))
{
if (generating_instance_variables)
{
obstack_1grow (&util_obstack, '@');
obstack_1grow (&util_obstack, '"');
obstack_grow (&util_obstack, name, strlen (name));
obstack_1grow (&util_obstack, '"');
return;
}
else
{
obstack_1grow (&util_obstack, '@');
return;
}
}
else if (strcmp (name, TAG_CLASS) == 0)
{
obstack_1grow (&util_obstack, '#');
return;
}
#ifndef OBJC_INT_SELECTORS
else if (strcmp (name, TAG_SELECTOR) == 0)
{
obstack_1grow (&util_obstack, ':');
return;
}
#endif
}
}
else if (TREE_CODE (pointer_to) == INTEGER_TYPE
&& TYPE_MODE (pointer_to) == QImode)
{
tree pname;
if (objcplus_TYPE_NAME (type))
{
tree tname = TREE_CODE (objcplus_TYPE_NAME (type)) == IDENTIFIER_NODE
? objcplus_TYPE_NAME (type)
: DECL_NAME (objcplus_TYPE_NAME (type));
if (!strcmp (IDENTIFIER_POINTER (tname), TAG_ATOM))
{
obstack_1grow (&util_obstack, '%');
return;
}
}
pname = TREE_CODE (objcplus_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE
? objcplus_TYPE_NAME (pointer_to)
: DECL_NAME (objcplus_TYPE_NAME (pointer_to));
if (!!strcmp (IDENTIFIER_POINTER (pname), "BOOL"))
{
obstack_1grow (&util_obstack, '*');
return;
}
}
obstack_1grow (&util_obstack, '^');
encode_type (pointer_to, curtype, format);
}
static void
encode_array (type, curtype, format)
tree type;
int curtype;
int format;
{
tree an_int_cst = objcplus_TYPE_SIZE (type);
tree array_of = TREE_TYPE (type);
char buffer[40];
if (an_int_cst == NULL)
{
encode_pointer (type, curtype, format);
return;
}
sprintf (buffer, "[%d",
(TREE_INT_CST_LOW (an_int_cst)
/ TREE_INT_CST_LOW (objcplus_TYPE_SIZE (array_of))));
obstack_grow (&util_obstack, buffer, strlen (buffer));
encode_type (array_of, curtype, format);
obstack_1grow (&util_obstack, ']');
return;
}
static void
encode_aggregate_within (type, curtype, format, left, right)
tree type;
int curtype;
int format;
int left;
int right;
{
tree name, fields;
if(TYPE_MAIN_VARIANT(type)) {
type = TYPE_MAIN_VARIANT(type);
}
name = TYPE_NAME (type);
fields = TYPE_FIELDS (type);
#ifdef OBJCPLUS
if(name && TREE_CODE(name) == TYPE_DECL && DECL_NAME(name)) {
name = DECL_NAME(name);
}
#endif
if (obstack_object_size (&util_obstack) > 0
&& *(obstack_next_free (&util_obstack) - 1) == '^')
{
if (obstack_object_size (&util_obstack) - curtype == 1
&& format == OBJC_ENCODE_INLINE_DEFS)
{
if (!TYPE_WAS_ANONYMOUS(type) && name && TREE_CODE (name) == IDENTIFIER_NODE)
{
obstack_1grow (&util_obstack, left);
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (name),
strlen (IDENTIFIER_POINTER (name)));
obstack_1grow (&util_obstack, '=');
}
else
{
obstack_1grow (&util_obstack, left);
obstack_grow (&util_obstack, "?=", 2);
}
for ( ; fields; fields = TREE_CHAIN (fields))
if(TREE_CODE(fields) == FIELD_DECL)
encode_field_decl (fields, curtype, format);
obstack_1grow (&util_obstack, right);
}
else if (!TYPE_WAS_ANONYMOUS(type) && name && TREE_CODE (name) == IDENTIFIER_NODE)
{
obstack_1grow (&util_obstack, left);
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (name),
strlen (IDENTIFIER_POINTER (name)));
obstack_1grow (&util_obstack, right);
}
else
{
obstack_1grow (&util_obstack, left);
obstack_1grow (&util_obstack, '?');
obstack_1grow (&util_obstack, right);
}
}
else
{
if (format == OBJC_ENCODE_INLINE_DEFS
|| generating_instance_variables)
{
obstack_1grow (&util_obstack, left);
if (!TYPE_WAS_ANONYMOUS(type) && name && TREE_CODE (name) == IDENTIFIER_NODE)
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (name),
strlen (IDENTIFIER_POINTER (name)));
else
obstack_1grow (&util_obstack, '?');
obstack_1grow (&util_obstack, '=');
for (; fields; fields = TREE_CHAIN (fields))
{
if (generating_instance_variables)
{
tree fname = DECL_NAME (fields);
obstack_1grow (&util_obstack, '"');
if (fname && TREE_CODE (fname) == IDENTIFIER_NODE)
{
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (fname),
strlen (IDENTIFIER_POINTER (fname)));
}
obstack_1grow (&util_obstack, '"');
}
if(TREE_CODE(fields) == FIELD_DECL)
encode_field_decl (fields, curtype, format);
}
obstack_1grow (&util_obstack, right);
}
else
{
obstack_1grow (&util_obstack, left);
if (!TYPE_WAS_ANONYMOUS(type) && name && TREE_CODE (name) == IDENTIFIER_NODE)
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (name),
strlen (IDENTIFIER_POINTER (name)));
else
obstack_1grow (&util_obstack, '?');
obstack_1grow (&util_obstack, right);
}
}
}
static void
encode_aggregate (type, curtype, format)
tree type;
int curtype;
int format;
{
enum tree_code code = TREE_CODE (type);
switch (code)
{
case RECORD_TYPE:
{
encode_aggregate_within(type, curtype, format, '{', '}');
break;
}
case UNION_TYPE:
{
encode_aggregate_within(type, curtype, format, '(', ')');
break;
}
case ENUMERAL_TYPE:
obstack_1grow (&util_obstack, 'i');
break;
default:
break;
}
}
static void
encode_bitfield (width, format)
int width;
int format;
{
char buffer[40];
sprintf (buffer, "b%d", width);
obstack_grow (&util_obstack, buffer, strlen (buffer));
}
static void
encode_type (type, curtype, format)
tree type;
int curtype;
int format;
{
enum tree_code code = TREE_CODE (type);
if (code == INTEGER_TYPE)
{
if (TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) == 0
&& TREE_INT_CST_HIGH (TYPE_MIN_VALUE (type)) == 0)
{
if (TYPE_MODE (type) == QImode)
obstack_1grow (&util_obstack, 'C');
else if (TYPE_MODE (type) == HImode)
obstack_1grow (&util_obstack, 'S');
else if (TYPE_MODE (type) == SImode)
{
if (type == long_unsigned_type_node)
obstack_1grow (&util_obstack, 'L');
else
obstack_1grow (&util_obstack, 'I');
}
else if (TYPE_MODE (type) == DImode)
obstack_1grow (&util_obstack, 'Q');
}
else
{
if (TYPE_MODE (type) == QImode)
obstack_1grow (&util_obstack, 'c');
else if (TYPE_MODE (type) == HImode)
obstack_1grow (&util_obstack, 's');
else if (TYPE_MODE (type) == SImode)
{
if (type == long_integer_type_node)
obstack_1grow (&util_obstack, 'l');
else
obstack_1grow (&util_obstack, 'i');
}
else if (TYPE_MODE (type) == DImode)
obstack_1grow (&util_obstack, 'q');
}
}
else if (code == REAL_TYPE)
{
if (TYPE_MODE (type) == SFmode)
obstack_1grow (&util_obstack, 'f');
else if (TYPE_MODE (type) == DFmode
|| TYPE_MODE (type) == TFmode)
obstack_1grow (&util_obstack, 'd');
}
else if (code == VOID_TYPE)
obstack_1grow (&util_obstack, 'v');
else if (code == ARRAY_TYPE)
encode_array (type, curtype, format);
else if (code == POINTER_TYPE)
encode_pointer (type, curtype, format);
else if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
encode_aggregate (type, curtype, format);
else if (code == FUNCTION_TYPE)
obstack_1grow (&util_obstack, '?');
}
static void
encode_complete_bitfield (int position, tree type, int size)
{
enum tree_code code = TREE_CODE (type);
char buffer[40];
char charType = '?';
if (code == INTEGER_TYPE)
{
if (TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) == 0
&& TREE_INT_CST_HIGH (TYPE_MIN_VALUE (type)) == 0)
{
if (TYPE_MODE (type) == QImode)
charType = 'C';
else if (TYPE_MODE (type) == HImode)
charType = 'S';
else if (TYPE_MODE (type) == SImode)
{
if (type == long_unsigned_type_node)
charType = 'L';
else
charType = 'I';
}
else if (TYPE_MODE (type) == DImode)
charType = 'Q';
}
else
{
if (TYPE_MODE (type) == QImode)
charType = 'c';
else if (TYPE_MODE (type) == HImode)
charType = 's';
else if (TYPE_MODE (type) == SImode)
{
if (type == long_integer_type_node)
charType = 'l';
else
charType = 'i';
}
else if (TYPE_MODE (type) == DImode)
charType = 'q';
}
}
else
abort ();
sprintf (buffer, "b%d%c%d", position, charType, size);
obstack_grow (&util_obstack, buffer, strlen (buffer));
}
static void
encode_field_decl (field_decl, curtype, format)
tree field_decl;
int curtype;
int format;
{
tree type;
type = TREE_TYPE (field_decl);
if (type == error_mark_node)
return;
#ifdef OBJCPLUS
if (TREE_STATIC (field_decl))
return;
#endif
if (flag_next_runtime)
{
if (DECL_BIT_FIELD (field_decl))
encode_bitfield (DECL_FIELD_SIZE (field_decl), format);
else if (TREE_CODE (objcplus_TYPE_SIZE (type)) == INTEGER_CST
&& DECL_FIELD_SIZE (field_decl)
&& TYPE_MODE (type) > DECL_MODE (field_decl))
encode_bitfield (DECL_FIELD_SIZE (field_decl), format);
else
encode_type (TREE_TYPE (field_decl), curtype, format);
}
else
{
if (DECL_BIT_FIELD (field_decl)
|| (TREE_CODE (objcplus_TYPE_SIZE (type)) == INTEGER_CST
&& DECL_FIELD_SIZE (field_decl)
&& TYPE_MODE (type) > DECL_MODE (field_decl)))
{
encode_complete_bitfield (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field_decl)),
DECL_BIT_FIELD_TYPE (field_decl),
DECL_FIELD_SIZE (field_decl));
}
else
encode_type (TREE_TYPE (field_decl), curtype, format);
}
}
static tree
expr_last (complex_expr)
tree complex_expr;
{
tree next;
if (complex_expr)
while ((next = TREE_OPERAND (complex_expr, 0)))
complex_expr = next;
return complex_expr;
}
void
start_method_def (method)
tree method;
{
tree decl_specs;
method_context = method;
UOBJC_SUPER_decl = NULL_TREE;
pushlevel (0);
if (TREE_CODE (method_context) == INSTANCE_METHOD_DECL)
decl_specs = build_tree_list (NULL_TREE, uprivate_record);
else
decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
#ifndef NEXT_OBJC_RUNTIME
objcplus_push_parm_decl (build_tree_list
(build_tree_list (decl_specs,
build1 (INDIRECT_REF, NULL_TREE, self_id)),
build_tree_list (unused_list, NULL_TREE)));
#else
objcplus_push_parm_decl (build_tree_list (decl_specs,
build1 (INDIRECT_REF, NULL_TREE, self_id)));
#endif
#ifdef OBJC_INT_SELECTORS
decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_UNSIGNED]);
decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_INT], decl_specs);
objcplus_push_parm_decl (build_tree_list (build_tree_list (decl_specs, ucmd_id),
build_tree_list (unused_list, NULL_TREE)));
#else
decl_specs = build_tree_list (NULL_TREE,
xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)));
#ifndef NEXT_OBJC_RUNTIME
objcplus_push_parm_decl (build_tree_list
(build_tree_list (decl_specs,
build1 (INDIRECT_REF, NULL_TREE, ucmd_id)),
build_tree_list (unused_list, NULL_TREE)));
#else
objcplus_push_parm_decl (build_tree_list (decl_specs,
build1 (INDIRECT_REF, NULL_TREE, ucmd_id)));
#endif
#endif
if (METHOD_SEL_ARGS (method))
{
tree arglist = METHOD_SEL_ARGS (method);
do
{
tree arg_spec = TREE_PURPOSE (TREE_TYPE (arglist));
tree arg_decl = TREE_VALUE (TREE_TYPE (arglist));
if (arg_decl)
{
tree last_expr = expr_last (arg_decl);
TREE_OPERAND (last_expr, 0) = KEYWORD_ARG_NAME (arglist);
#ifdef OBJCPLUS
objcplus_push_parm_decl (build_tree_list (arg_spec, arg_decl));
#else
objcplus_push_parm_decl (build_tree_list
(build_tree_list (arg_spec, arg_decl),
build_tree_list (NULL_TREE, NULL_TREE)));
TREE_OPERAND (last_expr, 0) = NULL_TREE;
#endif
}
else
objcplus_push_parm_decl (build_tree_list (arg_spec,
KEYWORD_ARG_NAME (arglist)));
arglist = TREE_CHAIN (arglist);
}
while (arglist);
}
if (METHOD_ADD_ARGS (method) > (tree)1)
{
tree akey = TREE_PURPOSE (METHOD_ADD_ARGS (method));
while (akey)
{
tree nextkey = TREE_CHAIN (akey);
pushdecl (akey);
akey = nextkey;
}
}
}
static void
warn_with_method (message, mtype, method)
char *message;
char mtype;
tree method;
{
tree func = current_function_decl;
char method_name[BUFSIZE];
char *md;
current_function_decl = method;
if (count_error (1) == 0)
return;
report_error_function (DECL_SOURCE_FILE (method));
method_name[0] = 0;
sprintf (errbuf, "%s `%c%s'\0",
message, mtype, gen_method_decl (method, method_name));
warning_with_file_and_line (DECL_SOURCE_FILE (method),
DECL_SOURCE_LINE (method),
errbuf);
current_function_decl = func;
}
static int
comp_method_with_proto (method, proto)
tree method, proto;
{
static tree function_type = 0;
if (!function_type)
{
struct obstack *ambient_obstack = current_obstack;
current_obstack = &permanent_obstack;
function_type = make_node (FUNCTION_TYPE);
current_obstack = ambient_obstack;
}
TYPE_ARG_TYPES (function_type) = get_arg_type_list (proto, METHOD_DEF, 0);
TREE_TYPE (function_type) = groktypename (TREE_TYPE (proto));
return comptypes (TREE_TYPE (METHOD_DEFINITION (method)), function_type);
}
static int
comp_proto_with_proto (proto1, proto2)
tree proto1, proto2;
{
static tree function_type1 = 0, function_type2 = 0;
if (!function_type1)
{
struct obstack *ambient_obstack = current_obstack;
current_obstack = &permanent_obstack;
function_type1 = make_node (FUNCTION_TYPE);
function_type2 = make_node (FUNCTION_TYPE);
current_obstack = ambient_obstack;
}
TYPE_ARG_TYPES (function_type1) = get_arg_type_list (proto1, METHOD_REF, 0);
TYPE_ARG_TYPES (function_type2) = get_arg_type_list (proto2, METHOD_REF, 0);
TREE_TYPE (function_type1) = groktypename (TREE_TYPE (proto1));
TREE_TYPE (function_type2) = groktypename (TREE_TYPE (proto2));
if (!comptypes (function_type1, function_type2))
return 0;
if (DIRECT_METHOD_FLAG(proto1) != DIRECT_METHOD_FLAG(proto2))
{
if (DIRECT_METHOD_FLAG(proto1))
error ("method `%s' previously declared without __direct__ modifier",
IDENTIFIER_POINTER (METHOD_SEL_NAME (proto1)));
else
error ("method `%s' previously declared __direct__",
IDENTIFIER_POINTER (METHOD_SEL_NAME (proto1)));
return 0;
}
if (STATIC_METHOD_FLAG(proto1) != STATIC_METHOD_FLAG(proto2))
{
if (STATIC_METHOD_FLAG(proto1))
error ("method `%s' previously declared without static modifier",
IDENTIFIER_POINTER (METHOD_SEL_NAME (proto1)));
else
error ("method `%s' previously declared static",
IDENTIFIER_POINTER (METHOD_SEL_NAME (proto1)));
return 0;
}
return 1;
}
static void
really_start_method (method, parmlist)
tree method, parmlist;
{
tree sc_spec, ret_spec, ret_decl, decl_specs;
tree method_decl, method_id;
char *buf, *sel_name, *class_name, *cat_name;
if (! DIRECT_METHOD_FLAG (method) || STATIC_METHOD_FLAG (method))
sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
else
sc_spec = NULL_TREE;
ret_spec = TREE_PURPOSE (TREE_TYPE (method));
decl_specs = chainon (sc_spec, ret_spec);
sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
class_name = IDENTIFIER_POINTER (CLASS_NAME (implementation_context));
cat_name = ((TREE_CODE (implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
? NULL
: IDENTIFIER_POINTER (CLASS_SUPER_NAME (implementation_context)));
method_slot++;
if (DIRECT_METHOD_FLAG (method))
cat_name = "__direct__";
buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name)
+ (cat_name ? strlen (cat_name) : 0));
OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL,
class_name, cat_name, sel_name, method_slot);
method_id = get_identifier (buf);
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
method_decl = build_nt (CALL_EXPR, method_id, parmlist, NULL_TREE);
if ((ret_decl = TREE_VALUE (TREE_TYPE (method))))
{
tree save_expr = expr_last (ret_decl);
TREE_OPERAND (save_expr, 0) = method_decl;
method_decl = ret_decl;
start_function (decl_specs, method_decl, NULL_TREE, NULL_TREE, 0);
#ifdef OBJCPLUS
if (! current_function_parms_stored)
store_parm_decls ();
#endif
TREE_OPERAND (save_expr, 0) = NULL_TREE;
}
else
{
TREE_VALUE (TREE_TYPE (method)) = method_decl;
start_function (decl_specs, method_decl, NULL_TREE, NULL_TREE, 0);
#ifdef OBJCPLUS
if (! current_function_parms_stored)
store_parm_decls ();
#endif
TREE_VALUE (TREE_TYPE (method)) = NULL_TREE;
}
DECL_INLINE (current_function_decl) = INLINE_METHOD_FLAG(method);
#ifdef OBJCPLUS
self_decl = DECL_ARGUMENTS(current_function_decl);
TREE_USED (self_decl) = 1;
TREE_USED (TREE_CHAIN (self_decl)) = 1;
#endif
#ifdef OBJCPLUS
pop_lang_context ();
#endif
METHOD_DEFINITION (method) = current_function_decl;
if (implementation_template != implementation_context)
{
tree proto;
if (TREE_CODE (method) == INSTANCE_METHOD_DECL)
proto = lookup_instance_method_static (implementation_template,
METHOD_SEL_NAME (method));
else
proto = lookup_class_method_static (implementation_template,
METHOD_SEL_NAME (method));
if (proto && ! comp_method_with_proto (method, proto))
{
char type = (TREE_CODE (method) == INSTANCE_METHOD_DECL ? '-' : '+');
warn_with_method ("conflicting types for", type, method);
warn_with_method ("previous declaration of", type, proto);
}
}
}
void
continue_method_def ()
{
tree parmlist;
int save_flag_dump_symbols = flag_dump_symbols;
int save_flag_gen_index = flag_gen_index;
flag_dump_symbols = 0;
flag_gen_index = 0;
if (METHOD_ADD_ARGS (method_context) == (tree)1)
parmlist = objcplus_get_parm_info (0);
else
parmlist = objcplus_get_parm_info (1);
#ifndef OBJCPLUS
self_decl = TREE_PURPOSE (parmlist);
#endif
poplevel (0, 0, 0);
really_start_method (method_context, parmlist);
#ifndef OBJCPLUS
store_parm_decls ();
#endif
flag_dump_symbols = save_flag_dump_symbols;
flag_gen_index = save_flag_gen_index;
}
void
add_objc_super_decl ()
{
int save_flag_dump_symbols = flag_dump_symbols;
int save_flag_gen_index = flag_gen_index;
flag_dump_symbols = 0;
flag_gen_index = 0;
if (!UOBJC_SUPER_decl)
{
UOBJC_SUPER_decl = start_decl (get_identifier (UTAG_SUPER),
build_tree_list (NULL_TREE,
objc_super_template),
0);
objcplus_finish_decl (UOBJC_SUPER_decl, NULL_TREE, NULL_TREE);
TREE_USED (UOBJC_SUPER_decl) = 1;
DECL_ARTIFICIAL (UOBJC_SUPER_decl) = 1;
}
flag_dump_symbols = save_flag_dump_symbols;
flag_gen_index = save_flag_gen_index;
}
tree
get_super_receiver ()
{
if (method_context)
{
tree super_expr, super_expr_list;
super_expr = build_component_ref (UOBJC_SUPER_decl, self_id);
super_expr = build_modify_expr (super_expr, NOP_EXPR, self_decl);
super_expr_list = build_tree_list (NULL_TREE, super_expr);
super_expr = build_component_ref (UOBJC_SUPER_decl,
get_identifier ("class"));
if (TREE_CODE (implementation_context) == CLASS_IMPLEMENTATION_TYPE)
{
super_expr = build_modify_expr (super_expr, NOP_EXPR,
((TREE_CODE (method_context)
== INSTANCE_METHOD_DECL)
? ucls_super_ref
: uucls_super_ref));
}
else
{
tree super_name = CLASS_SUPER_NAME (implementation_template);
tree super_class;
if (!super_name)
{
error ("no super class declared in interface for `%s'",
IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
return error_mark_node;
}
super_class = get_orig_class_reference (super_name);
if (TREE_CODE (method_context) == CLASS_METHOD_DECL)
super_class
= build_component_ref (build_indirect_ref (super_class, "->"),
get_identifier ("isa"));
super_class = build_c_cast (TREE_TYPE (ucls_super_ref), super_class);
super_expr = build_modify_expr (super_expr, NOP_EXPR, super_class);
}
chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr));
super_expr = build_unary_op (ADDR_EXPR, UOBJC_SUPER_decl, 0);
chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr));
return build_compound_expr (super_expr_list);
}
else
{
error ("[super ...] must appear in a method context");
return error_mark_node;
}
}
static tree
encode_method_def (func_decl)
tree func_decl;
{
tree parms;
int stack_size;
int max_parm_end = 0;
char buffer[40];
tree result;
#if defined (NEXT_SEMANTICS)
tree user_args;
int i = 0;
user_args = METHOD_SEL_ARGS(method_context);
encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_context)));
#endif
encode_type (TREE_TYPE (TREE_TYPE (func_decl)),
obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
for (parms = DECL_ARGUMENTS (func_decl); parms;
parms = TREE_CHAIN (parms))
{
int parm_end = forwarding_offset (parms);
if (parm_end > 0)
parm_end += TREE_INT_CST_LOW (objcplus_TYPE_SIZE (TREE_TYPE (parms))) / BITS_PER_UNIT;
else
parm_end = -parm_end;
if (max_parm_end < parm_end)
max_parm_end = parm_end;
}
stack_size = max_parm_end - ( flag_next_runtime
? OBJC_FORWARDING_MIN_OFFSET
: 0);
sprintf (buffer, "%d", stack_size);
obstack_grow (&util_obstack, buffer, strlen (buffer));
for (parms = DECL_ARGUMENTS (func_decl); parms;
parms = TREE_CHAIN (parms))
{
if (i++ > 1)
{
encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (user_args)));
user_args = TREE_CHAIN (user_args);
}
encode_type (TREE_TYPE (parms),
obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
sprintf (buffer, "%d", forwarding_offset (parms));
if (offset_is_register && !flag_next_runtime)
obstack_1grow (&util_obstack, '+');
obstack_grow (&util_obstack, buffer, strlen (buffer));
}
obstack_1grow (&util_obstack, 0);
result = get_identifier (obstack_finish (&util_obstack));
obstack_free (&util_obstack, util_firstobj);
return result;
}
void
finish_method_def ()
{
int save_flag_dump_symbols = flag_dump_symbols;
int save_flag_gen_index = flag_gen_index;
flag_dump_symbols = 0;
flag_gen_index = 0;
METHOD_ENCODING (method_context) = encode_method_def (current_function_decl);
objcplus_finish_function (0);
method_context = NULL_TREE;
flag_dump_symbols = save_flag_dump_symbols;
flag_gen_index = save_flag_gen_index;
}
int
lang_report_error_function (decl)
tree decl;
{
if (method_context)
{
fprintf (stderr, "In method `%s'\n",
IDENTIFIER_POINTER (METHOD_SEL_NAME (method_context)));
return 1;
}
else
return 0;
}
static int
is_complex_decl (type)
tree type;
{
return (TREE_CODE (type) == ARRAY_TYPE
|| TREE_CODE (type) == FUNCTION_TYPE
|| (TREE_CODE (type) == POINTER_TYPE && ! IS_ID (type)));
}
static char tmpbuf[256];
static void
adorn_decl (decl, str)
tree decl;
char *str;
{
enum tree_code code = TREE_CODE (decl);
if (code == ARRAY_REF)
{
tree an_int_cst = TREE_OPERAND (decl, 1);
if (an_int_cst && TREE_CODE (an_int_cst) == INTEGER_CST)
sprintf (str + strlen (str), "[%d]", TREE_INT_CST_LOW (an_int_cst));
else
strcat (str, "[]");
}
else if (code == ARRAY_TYPE)
{
tree an_int_cst = objcplus_TYPE_SIZE (decl);
tree array_of = TREE_TYPE (decl);
if (an_int_cst && TREE_CODE (an_int_cst) == INTEGER_TYPE)
sprintf (str + strlen (str), "[%d]",
(TREE_INT_CST_LOW (an_int_cst)
/ TREE_INT_CST_LOW (objcplus_TYPE_SIZE (array_of))));
else
strcat (str, "[]");
}
else if (code == CALL_EXPR)
{
tree chain = TREE_PURPOSE (TREE_OPERAND (decl, 1));
strcat (str, "(");
while (chain)
{
gen_declaration (chain, str);
chain = TREE_CHAIN (chain);
if (chain)
strcat (str, ", ");
}
strcat (str, ")");
}
else if (code == FUNCTION_TYPE)
{
tree chain = TYPE_ARG_TYPES (decl);
strcat (str, "(");
while (chain && TREE_VALUE (chain) != void_type_node)
{
gen_declaration (TREE_VALUE (chain), str);
chain = TREE_CHAIN (chain);
if (chain && TREE_VALUE (chain) != void_type_node)
strcat (str, ", ");
}
strcat (str, ")");
}
else if (code == INDIRECT_REF)
{
strcpy (tmpbuf, "*");
if (TREE_TYPE (decl) && TREE_CODE (TREE_TYPE (decl)) == TREE_LIST)
{
tree chain;
for (chain = nreverse (copy_list (TREE_TYPE (decl)));
chain;
chain = TREE_CHAIN (chain))
{
if (TREE_CODE (TREE_VALUE (chain)) == IDENTIFIER_NODE)
{
strcat (tmpbuf, " ");
strcat (tmpbuf, IDENTIFIER_POINTER (TREE_VALUE (chain)));
}
}
if (str[0])
strcat (tmpbuf, " ");
}
strcat (tmpbuf, str);
strcpy (str, tmpbuf);
}
else if (code == POINTER_TYPE)
{
strcpy (tmpbuf, "*");
if (TREE_READONLY (decl) || TYPE_VOLATILE (decl))
{
if (TREE_READONLY (decl))
strcat (tmpbuf, " const");
if (TYPE_VOLATILE (decl))
strcat (tmpbuf, " volatile");
if (str[0])
strcat (tmpbuf, " ");
}
strcat (tmpbuf, str);
strcpy (str, tmpbuf);
}
}
static char *
gen_declarator (decl, buf, name)
tree decl;
char *buf;
char *name;
{
if (decl)
{
enum tree_code code = TREE_CODE (decl);
char *str;
tree op;
int wrap = 0;
switch (code)
{
case ARRAY_REF:
case INDIRECT_REF:
case CALL_EXPR:
op = TREE_OPERAND (decl, 0);
if ((code == ARRAY_REF || code == CALL_EXPR)
&& op && TREE_CODE (op) == INDIRECT_REF)
wrap = 1;
str = gen_declarator (op, buf, name);
if (wrap)
{
strcpy (tmpbuf, "(");
strcat (tmpbuf, str);
strcat (tmpbuf, ")");
strcpy (str, tmpbuf);
}
adorn_decl (decl, str);
break;
case ARRAY_TYPE:
case FUNCTION_TYPE:
case POINTER_TYPE:
strcpy (buf, name);
str = buf;
do
{
op = (is_complex_decl (TREE_TYPE (decl))
? TREE_TYPE (decl) : NULL_TREE);
adorn_decl (decl, str);
if (code == POINTER_TYPE
&& op && (TREE_CODE (op) == FUNCTION_TYPE
|| TREE_CODE (op) == ARRAY_TYPE))
{
strcpy (tmpbuf, "(");
strcat (tmpbuf, str);
strcat (tmpbuf, ")");
strcpy (str, tmpbuf);
}
decl = (is_complex_decl (TREE_TYPE (decl))
? TREE_TYPE (decl) : NULL_TREE);
}
while (decl && (code = TREE_CODE (decl)))
;
break;
case IDENTIFIER_NODE:
strcpy (buf, IDENTIFIER_POINTER (decl));
return buf;
}
return str;
}
else
{
strcpy (buf, name);
return buf;
}
}
static void
gen_declspecs (declspecs, buf, raw)
tree declspecs;
char *buf;
int raw;
{
if (raw)
{
tree chain;
for (chain = nreverse (copy_list (declspecs));
chain; chain = TREE_CHAIN (chain))
{
tree aspec = TREE_VALUE (chain);
if (TREE_CODE (aspec) == IDENTIFIER_NODE)
strcat (buf, IDENTIFIER_POINTER (aspec));
else if (TREE_CODE (aspec) == RECORD_TYPE)
{
if (objcplus_TYPE_NAME (aspec))
{
tree protocol_list = TYPE_PROTOCOL_LIST (aspec);
if (! TREE_STATIC_TEMPLATE (aspec))
strcat (buf, "struct ");
strcat (buf, IDENTIFIER_POINTER (objcplus_TYPE_NAME (aspec)));
if (protocol_list)
{
tree chain = protocol_list;
strcat (buf, " <");
while (chain)
{
strcat (buf,
IDENTIFIER_POINTER
(PROTOCOL_NAME (TREE_VALUE (chain))));
chain = TREE_CHAIN (chain);
if (chain)
strcat (buf, ", ");
}
strcat (buf, ">");
}
}
else
strcat (buf, "untagged struct");
}
else if (TREE_CODE (aspec) == UNION_TYPE)
{
if (objcplus_TYPE_NAME (aspec))
{
if (! TREE_STATIC_TEMPLATE (aspec))
strcat (buf, "union ");
strcat (buf, IDENTIFIER_POINTER (objcplus_TYPE_NAME (aspec)));
}
else
strcat (buf, "untagged union");
}
else if (TREE_CODE (aspec) == ENUMERAL_TYPE)
{
if (objcplus_TYPE_NAME (aspec))
{
if (! TREE_STATIC_TEMPLATE (aspec))
strcat (buf, "enum ");
strcat (buf, IDENTIFIER_POINTER (objcplus_TYPE_NAME (aspec)));
}
else
strcat (buf, "untagged enum");
}
else if (TREE_CODE (aspec) == TYPE_DECL && DECL_NAME (aspec))
strcat (buf, IDENTIFIER_POINTER (DECL_NAME (aspec)));
else if (IS_ID (aspec))
{
tree protocol_list = TYPE_PROTOCOL_LIST (aspec);
strcat (buf, "id");
if (protocol_list)
{
tree chain = protocol_list;
strcat (buf, " <");
while (chain)
{
strcat (buf,
IDENTIFIER_POINTER
(PROTOCOL_NAME (TREE_VALUE (chain))));
chain = TREE_CHAIN (chain);
if (chain)
strcat (buf, ", ");
}
strcat (buf, ">");
}
}
if (TREE_CHAIN (chain))
strcat (buf, " ");
}
}
else
{
if (TREE_READONLY (declspecs))
strcat (buf, "const ");
if (TYPE_VOLATILE (declspecs))
strcat (buf, "volatile ");
switch (TREE_CODE (declspecs))
{
case INTEGER_TYPE:
declspecs = TYPE_MAIN_VARIANT (declspecs);
if (declspecs == short_integer_type_node)
strcat (buf, "short int ");
else if (declspecs == integer_type_node)
strcat (buf, "int ");
else if (declspecs == long_integer_type_node)
strcat (buf, "long int ");
else if (declspecs == long_long_integer_type_node)
strcat (buf, "long long int ");
else if (declspecs == signed_char_type_node
|| declspecs == char_type_node)
strcat (buf, "char ");
else if (declspecs == short_unsigned_type_node)
strcat (buf, "unsigned short ");
else if (declspecs == unsigned_type_node)
strcat (buf, "unsigned int ");
else if (declspecs == long_unsigned_type_node)
strcat (buf, "unsigned long ");
else if (declspecs == long_long_unsigned_type_node)
strcat (buf, "unsigned long long ");
else if (declspecs == unsigned_char_type_node)
strcat (buf, "unsigned char ");
break;
case REAL_TYPE:
declspecs = TYPE_MAIN_VARIANT (declspecs);
if (declspecs == float_type_node)
strcat (buf, "float ");
else if (declspecs == double_type_node)
strcat (buf, "double ");
else if (declspecs == long_double_type_node)
strcat (buf, "long double ");
break;
case RECORD_TYPE:
if (objcplus_TYPE_NAME (declspecs)
&& TREE_CODE (objcplus_TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
{
tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
if (! TREE_STATIC_TEMPLATE (declspecs))
strcat (buf, "struct ");
strcat (buf, IDENTIFIER_POINTER (objcplus_TYPE_NAME (declspecs)));
if (protocol_list)
{
tree chain = protocol_list;
strcat (buf, " <");
while (chain)
{
strcat (buf,
IDENTIFIER_POINTER
(PROTOCOL_NAME (TREE_VALUE (chain))));
chain = TREE_CHAIN (chain);
if (chain)
strcat (buf, ", ");
}
strcat (buf, ">");
}
}
else
strcat (buf, "untagged struct");
strcat (buf, " ");
break;
case UNION_TYPE:
if (objcplus_TYPE_NAME (declspecs)
&& TREE_CODE (objcplus_TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
{
strcat (buf, "union ");
strcat (buf, IDENTIFIER_POINTER (objcplus_TYPE_NAME (declspecs)));
strcat (buf, " ");
}
else
strcat (buf, "untagged union ");
break;
case ENUMERAL_TYPE:
if (objcplus_TYPE_NAME (declspecs)
&& TREE_CODE (objcplus_TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
{
strcat (buf, "enum ");
strcat (buf, IDENTIFIER_POINTER (objcplus_TYPE_NAME (declspecs)));
strcat (buf, " ");
}
else
strcat (buf, "untagged enum ");
break;
case VOID_TYPE:
strcat (buf, "void ");
break;
case POINTER_TYPE:
{
tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
strcat (buf, "id");
if (protocol_list)
{
tree chain = protocol_list;
strcat (buf, " <");
while (chain)
{
strcat (buf, IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (chain))));
chain = TREE_CHAIN (chain);
if (chain)
strcat (buf, ", ");
}
strcat (buf, ">");
}
}
}
}
}
static char *
gen_declaration (atype_or_adecl, buf)
tree atype_or_adecl;
char *buf;
{
char declbuf[256];
if (TREE_CODE (atype_or_adecl) == TREE_LIST)
{
tree declspecs;
tree declarator;
declarator = TREE_VALUE (atype_or_adecl);
declspecs = TREE_PURPOSE (atype_or_adecl);
gen_declspecs (declspecs, buf, 1);
if (declarator)
{
strcat (buf, " ");
strcat (buf, gen_declarator (declarator, declbuf, ""));
}
}
else
{
tree atype;
tree declspecs;
tree declarator;
if (TREE_CODE (atype_or_adecl) == FIELD_DECL
|| TREE_CODE (atype_or_adecl) == PARM_DECL
|| TREE_CODE (atype_or_adecl) == FUNCTION_DECL)
atype = TREE_TYPE (atype_or_adecl);
else
atype = atype_or_adecl;
if (is_complex_decl (atype))
{
tree chain;
declarator = chain = atype;
do
chain = TREE_TYPE (chain);
while (is_complex_decl (chain));
declspecs = chain;
}
else
{
declspecs = atype;
declarator = NULL_TREE;
}
gen_declspecs (declspecs, buf, 0);
if (TREE_CODE (atype_or_adecl) == FIELD_DECL
|| TREE_CODE (atype_or_adecl) == PARM_DECL
|| TREE_CODE (atype_or_adecl) == FUNCTION_DECL)
{
char *decl_name = (DECL_NAME (atype_or_adecl)
? IDENTIFIER_POINTER (DECL_NAME (atype_or_adecl))
: "");
if (declarator)
{
strcat (buf, " ");
strcat (buf, gen_declarator (declarator, declbuf, decl_name));
}
else if (decl_name[0])
{
strcat (buf, " ");
strcat (buf, decl_name);
}
}
else if (declarator)
{
strcat (buf, " ");
strcat (buf, gen_declarator (declarator, declbuf, ""));
}
}
return buf;
}
#define RAW_TYPESPEC(meth) (TREE_VALUE (TREE_PURPOSE (TREE_TYPE (meth))))
static char *
gen_method_decl (method, buf)
tree method;
char *buf;
{
tree chain;
if (RAW_TYPESPEC (method) != objc_object_reference)
{
strcpy (buf, "(");
gen_declaration (TREE_TYPE (method), buf);
strcat (buf, ")");
}
chain = METHOD_SEL_ARGS (method);
if (chain)
{
do
{
if (KEYWORD_KEY_NAME (chain))
strcat (buf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
strcat (buf, ":");
if (RAW_TYPESPEC (chain) != objc_object_reference)
{
strcat (buf, "(");
gen_declaration (TREE_TYPE (chain), buf);
strcat (buf, ")");
}
strcat (buf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
if ((chain = TREE_CHAIN (chain)))
strcat (buf, " ");
}
while (chain);
if (METHOD_ADD_ARGS (method) == (tree)1)
strcat (buf, ", ...");
else if (METHOD_ADD_ARGS (method))
{
chain = TREE_PURPOSE (METHOD_ADD_ARGS (method));
while (chain)
{
strcat (buf, ", ");
gen_declaration (chain, buf);
chain = TREE_CHAIN (chain);
}
}
}
else
strcat (buf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
return buf;
}
static void
dump_interface (fp, chain)
FILE *fp;
tree chain;
{
char *buf = (char *)xmalloc (256);
char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain));
tree ivar_decls = CLASS_RAW_IVARS (chain);
tree nst_methods = CLASS_NST_METHODS (chain);
tree cls_methods = CLASS_CLS_METHODS (chain);
fprintf (fp, "\n@interface %s", my_name);
if (CLASS_SUPER_NAME (chain))
{
char *super_name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain));
fprintf (fp, " : %s\n", super_name);
}
else
fprintf (fp, "\n");
if (ivar_decls)
{
fprintf (fp, "{\n");
do
{
bzero (buf, 256);
fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls, buf));
ivar_decls = TREE_CHAIN (ivar_decls);
}
while (ivar_decls);
fprintf (fp, "}\n");
}
while (nst_methods)
{
bzero (buf, 256);
fprintf (fp, "- %s;\n", gen_method_decl (nst_methods, buf));
nst_methods = TREE_CHAIN (nst_methods);
}
while (cls_methods)
{
bzero (buf, 256);
fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods, buf));
cls_methods = TREE_CHAIN (cls_methods);
}
fprintf (fp, "\n@end");
}
static void
init_objc ()
{
#ifdef OBJCPLUS
#define LAST_CODE LAST_CPLUS_TREE_CODE
#else
#define LAST_CODE LAST_AND_UNUSED_TREE_CODE
#endif
gcc_obstack_init (&util_obstack);
util_firstobj = (char *) obstack_finish (&util_obstack);
my_friendly_assert(LAST_OBJC_TREE_CODE < MAX_TREE_CODES, 2952);
bcopy ((char *) objc_tree_code_type,
(char *) (tree_code_type + (int) LAST_CODE),
(((int) LAST_OBJC_TREE_CODE - (int) LAST_CODE)
* sizeof (char *)));
bcopy ((char *) objc_tree_code_length,
(char *) (tree_code_length + (int) LAST_CODE),
(((int) LAST_OBJC_TREE_CODE - (int) LAST_CODE)
* sizeof (int)));
bcopy ((char *) objc_tree_code_name,
(char *) (tree_code_name + (int) LAST_CODE),
(((int) LAST_OBJC_TREE_CODE - (int) LAST_CODE)
* sizeof (char *)));
errbuf = (char *)xmalloc (BUFSIZE);
hash_init ();
synth_module_prologue ();
}
static void
finish_objc ()
{
struct imp_entry *impent;
tree chain;
int save_warn_missing_braces = warn_missing_braces;
int save_flag_dump_symbols = flag_dump_symbols;
int save_flag_gen_index = flag_gen_index;
warn_missing_braces = 0;
flag_dump_symbols = 0;
flag_gen_index = 0;
if (objc_implementation_context)
{
warning ("`@end' missing in implementation context");
finish_class (implementation_context);
objc_ivar_chain = NULL_TREE;
objc_implementation_context = NULL_TREE;
}
generate_forward_declaration_to_string_table ();
#ifdef OBJC_PROLOGUE
OBJC_PROLOGUE;
#endif
if (implementation_context || class_names_chain
|| meth_var_names_chain || meth_var_types_chain
|| sel_ref_chain || obj_def_chain)
{
no_objc = 0;
generate_objc_symtab_decl ();
}
for (impent = imp_list; impent; impent = impent->next)
{
implementation_context = impent->imp_context;
implementation_template = impent->imp_template;
UOBJC_CLASS_decl = impent->class_decl;
UOBJC_METACLASS_decl = impent->meta_decl;
if (TREE_CODE (implementation_context) == CLASS_IMPLEMENTATION_TYPE)
{
generate_ivar_lists ();
generate_dispatch_tables ();
generate_shared_structures ();
}
else
{
generate_dispatch_tables ();
generate_category (implementation_context);
}
}
if (! flag_next_runtime || sel_ref_chain)
build_selector_translation_table ();
#if 1
if (protocol_chain)
generate_protocols ();
#endif
if (! no_objc)
{
char *init_name = build_module_descriptor ();
if (init_name)
assemble_constructor (init_name);
}
for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
{
handle_class_ref (chain);
if (TREE_PURPOSE (chain))
generate_classref_translation_entry (chain);
}
for (impent = imp_list; impent; impent = impent->next)
handle_impent (impent);
generate_strings ();
if (flag_gen_declaration)
{
add_class (implementation_context);
dump_interface (gen_declaration_file, implementation_context);
}
if (warn_selector)
{
int slot;
hash hsh;
for (slot = 0; slot < SIZEHASHTABLE; slot++)
for (hsh = cls_method_hash_list[slot]; hsh; hsh = hsh->next)
if (hsh->list)
{
tree meth = hsh->key;
char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL
? '-' : '+');
attr loop;
warning ("potential selector conflict for method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
warn_with_method ("found", type, meth);
for (loop = hsh->list; loop; loop = loop->next)
warn_with_method ("found", type, loop->value);
}
for (slot = 0; slot < SIZEHASHTABLE; slot++)
for (hsh = nst_method_hash_list[slot]; hsh; hsh = hsh->next)
if (hsh->list)
{
tree meth = hsh->key;
char type = (TREE_CODE (meth) == INSTANCE_METHOD_DECL
? '-' : '+');
attr loop;
warning ("potential selector conflict for method `%s'",
IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
warn_with_method ("found", type, meth);
for (loop = hsh->list; loop; loop = loop->next)
warn_with_method ("found", type, loop->value);
}
}
warn_missing_braces = save_warn_missing_braces;
flag_dump_symbols = save_flag_dump_symbols;
flag_gen_index = save_flag_gen_index;
}
static void
generate_classref_translation_entry (chain)
tree chain;
{
tree expr, name, decl_specs, decl, sc_spec;
tree type;
type = TREE_TYPE (TREE_PURPOSE (chain));
expr = add_objc_string (TREE_VALUE (chain), class_names);
expr = build_c_cast (type, expr);
name = DECL_NAME (TREE_PURPOSE (chain));
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
decl_specs = tree_cons (NULL_TREE, type, sc_spec);
decl = start_decl (name, decl_specs, 1);
end_temporary_allocation ();
objcplus_finish_decl (decl, expr, NULL_TREE);
return;
}
static void
handle_any_ref (val, isClass)
tree val;
int isClass;
{
char *name = IDENTIFIER_POINTER(val);
tree decl;
char *string;
tree exp;
if (isClass != 0)
{
string = (char *) alloca (strlen (name) + 30);
sprintf (string, "*%sobjc_class_name_%s", (flag_next_runtime ?".":"__"), name);
}
else
{
string = name;
}
#ifdef DECLARE_UNRESOLVED_REFERENCE
if (flag_next_runtime)
{
DECLARE_UNRESOLVED_REFERENCE(string);
return;
}
#endif
decl = build_decl (VAR_DECL, get_identifier (string), char_type_node);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
pushdecl (decl);
rest_of_decl_compilation (decl, 0, 0, 0);
exp = build1 (ADDR_EXPR, string_type_node, decl);
#if defined(TARGET_SNAKE) && defined(NEXT_PDO)
if (flag_pic)
objc_cls_refs_section ();
else
#endif
text_section ();
assemble_constant_align (exp);
assemble_external (decl);
output_constant (exp, int_size_in_bytes (string_type_node));
}
static void
handle_class_ref (chain)
tree chain;
{
handle_any_ref (TREE_VALUE(chain), 1);
}
static void
handle_impent (impent)
struct imp_entry *impent;
{
char *string;
implementation_context = impent->imp_context;
implementation_template = impent->imp_template;
if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
{
char *class_name = IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
string = (char *) malloc (strlen (class_name) + 30);
sprintf (string, "*%sobjc_class_name_%s",
(flag_next_runtime ? "." : "__"), class_name);
}
else if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
char *class_name = IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
char *class_super_name
= IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context));
string = (char *) malloc (strlen (class_name)
+ strlen (class_super_name) + 30);
sprintf (string, "*%sobjc_category_name_%s_%s",
(flag_next_runtime ? "." : "__"), class_name, class_super_name);
}
else
return;
#ifdef DECLARE_CLASS_REFERENCE
if (flag_next_runtime)
{
DECLARE_CLASS_REFERENCE (string);
}
#else
text_section ();
assemble_global (string);
assemble_align (UNITS_PER_WORD);
assemble_label (string);
assemble_zeros (UNITS_PER_WORD);
#endif
free (string);
}
#ifdef DEBUG
static void
objc_debug (fp)
FILE *fp;
{
char *buf = (char *)xmalloc (256);
{
tree loop = UOBJC_MODULES_decl;
fprintf (fp, "\n\nfunction prototypes:\n");
while (loop)
{
if (TREE_CODE (loop) == FUNCTION_DECL && DECL_INITIAL (loop))
{
bzero (errbuf, BUFSIZE);
gen_declaration (loop, errbuf);
fprintf (fp, "%s;\n", errbuf);
}
loop = TREE_CHAIN (loop);
}
}
{
tree loop;
int i, index = 0, offset = 0;
hash hashlist;
for (i = 0; i < SIZEHASHTABLE; i++)
{
if (hashlist = nst_method_hash_list[i])
{
fprintf (fp, "\n\nnst_method_hash_list[%d]:\n", i);
do
{
bzero (buf, 256);
fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf));
hashlist = hashlist->next;
}
while (hashlist);
}
}
for (i = 0; i < SIZEHASHTABLE; i++)
{
if (hashlist = cls_method_hash_list[i])
{
fprintf (fp, "\n\ncls_method_hash_list[%d]:\n", i);
do
{
bzero (buf, 256);
fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf));
hashlist = hashlist->next;
}
while (hashlist);
}
}
fprintf (fp, "\nsel_refdef_chain:\n");
for (loop = sel_refdef_chain; loop; loop = TREE_CHAIN (loop))
{
fprintf (fp, "(index: %4d offset: %4d) %s\n", index, offset,
IDENTIFIER_POINTER (TREE_VALUE (loop)));
index++;
offset += IDENTIFIER_LENGTH (TREE_VALUE (loop)) + 1;
}
fprintf (fp, "\n (max_selector_index: %4d.\n", max_selector_index);
}
}
#endif
#ifndef OBJCPLUS
void
print_lang_statistics ()
{
}
#endif
void
emit_class_ivars(class_name)
tree class_name;
{
tree interface = lookup_interface (class_name);
if (interface) {
tree ivar = build_ivar_chain (interface, 1);
for(; ivar; ivar = TREE_CHAIN (ivar)) {
finish_member_declaration (copy_node(ivar));
}
}
else
{
error ("Cannot find interface declaration for `%s'",
IDENTIFIER_POINTER (class_name));
}
}