quakeforge/tools/qfcc/source/class.c

1649 lines
41 KiB
C
Raw Normal View History

2002-05-08 21:24:24 +00:00
/*
2002-10-22 14:53:18 +00:00
class.c
2002-05-08 21:24:24 +00:00
2002-10-22 14:53:18 +00:00
QC class support code
2002-05-08 21:24:24 +00:00
Copyright (C) 2002 Bill Currie
2002-05-08 21:24:24 +00:00
Author: Bill Currie <bill@taniwha.org>
Date: 2002/5/7
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
2002-06-01 04:41:25 +00:00
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
2002-06-01 04:41:25 +00:00
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <stdlib.h>
2002-05-08 21:24:24 +00:00
#include "QF/dstring.h"
2002-05-10 00:00:23 +00:00
#include "QF/hash.h"
#include "QF/pr_obj.h"
#include "QF/va.h"
2002-05-08 21:24:24 +00:00
#include "qfcc.h"
#include "codespace.h"
2002-05-08 21:24:24 +00:00
#include "class.h"
2002-06-04 18:44:03 +00:00
#include "def.h"
#include "defspace.h"
#include "diagnostic.h"
#include "emit.h"
2002-05-16 22:33:11 +00:00
#include "expr.h"
2002-05-10 00:00:23 +00:00
#include "method.h"
#include "options.h"
#include "reloc.h"
#include "shared.h"
#include "strpool.h"
2002-05-15 19:10:23 +00:00
#include "struct.h"
#include "symtab.h"
2002-05-08 21:24:24 +00:00
#include "type.h"
#include "value.h"
2002-05-08 21:24:24 +00:00
2002-05-10 00:00:23 +00:00
static hashtab_t *class_hash;
2002-05-15 19:10:23 +00:00
static hashtab_t *category_hash;
2002-05-10 00:00:23 +00:00
static hashtab_t *protocol_hash;
// these will be built up further
type_t type_obj_selector = { ev_invalid, 0, ty_struct};
type_t type_SEL = { ev_pointer, "SEL", ty_none, {{&type_obj_selector}}};
type_t type_IMP = { ev_func, "IMP", ty_none,
{{&type_id, -3, {&type_id, &type_SEL}}}};
type_t type_obj_super = { ev_invalid, 0 };
type_t type_SuperPtr = { ev_pointer, 0, ty_none, {{&type_obj_super}}};
type_t type_supermsg = { ev_func, ".supermsg", ty_none,
{{&type_id, -3, {&type_SuperPtr, &type_SEL}}}};
type_t type_obj_method = { ev_invalid, 0, ty_struct };
type_t type_obj_method_description = { ev_invalid, 0, ty_struct };
type_t type_obj_category = { ev_invalid, 0, ty_struct};
type_t type_obj_ivar = { ev_invalid, 0, ty_struct};
type_t type_obj_module = { ev_invalid, 0, ty_struct};
type_t type_moduleptr = { ev_pointer, 0, ty_none, {{&type_obj_module}}};
2011-02-09 15:15:19 +00:00
type_t type_obj_exec_class = { ev_func, 0, ty_none,
{{&type_void, 1, { &type_moduleptr }}}};
type_t type_obj_object = {ev_invalid, 0, ty_struct};
type_t type_id = { ev_pointer, "id", ty_none, {{&type_obj_object}}};
type_t type_obj_class = { ev_invalid, 0, ty_struct};
type_t type_Class = { ev_pointer, 0, ty_none, {{&type_obj_class}}};
type_t type_obj_protocol = { ev_invalid, 0, ty_struct};
int obj_initialized = 0;
static struct_def_t sel_struct[] = {
{"sel_id", &type_string},
{"sel_types", &type_string},
{0, 0}
};
static struct_def_t method_struct[] = {
{"method_name", &type_SEL},
{"method_types", &type_string},
{"method_imp", &type_IMP},
{0, 0}
};
static struct_def_t method_desc_struct[] = {
{"name", &type_string},
{"types", &type_string},
{0, 0}
};
static struct_def_t category_struct[] = {
{"category_name", &type_string},
{"class_name", &type_string},
{"instance_methods", &type_pointer},
{"class_methods", &type_pointer},
{"protocols", &type_pointer},
{0, 0}
};
static struct_def_t ivar_struct[] = {
{"ivar_name", &type_string},
{"ivar_type", &type_string},
{"ivar_offset", &type_integer},
{0, 0}
};
static struct_def_t super_struct[] = {
{"self", &type_id},
{"class", &type_Class},
{0, 0}
};
static struct_def_t module_struct[] = {
{"version", &type_integer},
{"size", &type_integer},
{"name", &type_string},
{"symtab", &type_pointer},
{0, 0}
};
static struct_def_t class_struct[] = {
{"class_pointer", &type_Class},
{"super_class", &type_Class},
{"name", &type_string},
{"version", &type_integer},
{"info", &type_integer},
{"instance_size", &type_integer},
{"ivars", &type_pointer},
{"methods", &type_pointer},
{"dtable", &type_pointer},
{"subclass_list", &type_pointer},
{"sibling_class", &type_pointer},
{"protocols", &type_pointer},
{"gc_object_type", &type_pointer},
{0, 0}
};
static struct_def_t protocol_struct[] = {
{"class_pointer", &type_Class},
{"protocol_name", &type_string},
{"protocol_list", &type_pointer},
{"instance_methods", &type_pointer},
{"class_methods", &type_pointer},
{0, 0}
};
static struct_def_t object_struct[] = {
{"class_pointer", &type_Class},
{0, 0}
};
int
obj_is_id (const type_t *type)
{
if (type == &type_id)
return 1;
// type may be a qualified id, in which case it will be a pointer to
// a qualified obj_object struct
if (type->type != ev_pointer)
return 0;
if (!is_struct (type->t.fldptr.type))
return 0;
// if the the symtabs match, then type is id in disguise
if (type->t.fldptr.type->t.symtab == type_obj_object.t.symtab)
return 1;
return 0;
}
int
obj_is_class (const type_t *type)
{
if (type->type == ev_invalid && type->meta == ty_class)
return 1;
return 0;
}
int
obj_is_Class (const type_t *type)
{
if (type == &type_Class)
return 1;
// type may be a qualified Class, in which case it will be a pointer to
// a qualified obj_class struct
if (type->type != ev_pointer)
return 0;
if (!is_struct (type->t.fldptr.type))
return 0;
// if the the symtabs match, then type is Class in disguise
if (type->t.fldptr.type->t.symtab == type_obj_class.t.symtab)
return 1;
return 0;
}
int
obj_is_classptr (const type_t *type)
{
// easy cases first :)
if (obj_is_id (type) || obj_is_Class (type))
return 1;
if (type->type != ev_pointer)
return 0;
type = type->t.fldptr.type;
if (obj_is_class (type))
return 1;
return 0;
}
static protocollist_t *
obj_get_class_protos (const type_t *type)
{
if (is_pointer (type))
type = type->t.fldptr.type;
if (obj_is_class (type))
return type->t.class->protocols;
return 0;
}
static protocollist_t *
obj_get_protos (const type_t *type)
{
if (is_pointer (type))
type = type->t.fldptr.type;
return type->protos;
}
static category_t *
obj_get_categories (const type_t *type)
{
if (is_pointer (type))
type = type->t.fldptr.type;
if (obj_is_class (type))
return type->t.class->categories;
return 0;
}
static const char *
obj_classname (const type_t *type)
{
static dstring_t *str;
protocollist_t *protos;
if (!str)
str = dstring_new ();
dstring_clearstr (str);
if (obj_is_id (type)) {
dstring_copystr (str, "id");
} else if (obj_is_Class (type)) {
dstring_copystr (str, "Class");
} else {
if (is_pointer (type))
type = type->t.fldptr.type;
if (obj_is_class (type))
dstring_copystr (str, type->t.class->name);
}
if ((protos = obj_get_protos (type)))
print_protocollist (str, protos);
return str->str;
}
static int
category_implements (category_t *cat, protocol_t *protocol)
{
for (; cat; cat = cat->next) {
if (!cat->protocols)
continue;
if (procollist_find_protocol (cat->protocols, protocol))
return 1;
}
return 0;
}
int
obj_types_assignable (const type_t *dst, const type_t *src)
{
class_t *dst_class, *src_class;
category_t *cat;
int dst_is_proto, src_is_proto;
protocollist_t *dst_protos = 0, *src_protos = 0;
int i;
//puts ("%$$\"$#%");
if (!obj_is_classptr (dst) || !obj_is_classptr (src))
return -1;
dst_is_proto = obj_is_id (dst) && (dst_protos = obj_get_protos (dst));
src_is_proto = obj_is_id (src) && (src_protos = obj_get_protos (src));
if (dst_is_proto) {
if (src_is_proto) {
// id <protos> = id <protos>
for (i = 0; i < dst_protos->count; i++) {
if (!procollist_find_protocol (src_protos,
dst_protos->list[i])) {
warning (0, "type %s does not conform to the %s protocol",
obj_classname (src), dst_protos->list[i]->name);
return 1;
}
}
} else if (!obj_is_id (src)) {
src_protos = obj_get_class_protos (src);
for (i = 0; i < dst_protos->count; i++) {
if (procollist_find_protocol (src_protos, dst_protos->list[i]))
continue;
cat = obj_get_categories (src);
if (cat && category_implements (cat, dst_protos->list[i]))
continue;
warning (0, "class %s does not implement to the %s protocol",
obj_classname (src), dst_protos->list[i]->name);
return 1;
}
return 1;
}
} else if (src_is_proto) {
} else {
}
if (obj_is_id (dst) || obj_is_id (src))
return 1;
// check dst is a base class of src
dst_class = dst->t.fldptr.type->t.class;
src_class = src->t.fldptr.type->t.class;
//printf ("%s %s\n", dst_class->name, src_class->name);
while (dst_class != src_class && src_class) {
src_class = src_class->super_class;
//if (src_class)
// printf ("%s %s\n", dst_class->name, src_class->name);
}
if (dst_class == src_class)
return 1;
return 0;
}
2002-05-10 00:00:23 +00:00
static const char *
class_get_key (const void *class, void *unused)
2002-05-10 00:00:23 +00:00
{
return ((class_t *) class)->name;
2002-05-10 00:00:23 +00:00
}
static const char *
protocol_get_key (const void *protocol, void *unused)
2002-05-10 00:00:23 +00:00
{
return ((protocol_t *) protocol)->name;
}
const char *
get_class_name (class_type_t *class_type, int pretty)
{
switch (class_type->type) {
case ct_class:
if (pretty)
return class_type->c.class->name;
else
return va ("%s_", class_type->c.class->name);
case ct_category:
if (pretty)
return va ("%s (%s)", class_type->c.category->class->name,
class_type->c.category->name);
else
return va ("%s_%s", class_type->c.category->class->name,
class_type->c.category->name);
case ct_protocol:
return va ("<%s>", class_type->c.protocol->name);
}
return "???";
}
symbol_t *
class_symbol (class_type_t *class_type, int external)
{
const char *name = 0;
type_t *type = 0;
symbol_t *sym;
switch (class_type->type) {
case ct_category:
name = va ("_OBJ_CATEGORY_%s_%s",
class_type->c.category->class->name,
class_type->c.category->name);
type = &type_obj_category;
break;
case ct_class:
name = va ("_OBJ_CLASS_%s", class_type->c.class->name);
type = &type_obj_class;
break;
case ct_protocol:
return 0; // probably in error recovery
}
sym = make_symbol (name, type, pr.far_data,
external ? sc_extern : sc_global);
if (!sym->table)
symtab_addsymbol (pr.symtab, sym);
return sym;
}
static class_t *
_get_class (symbol_t *sym, int create)
2002-05-08 21:24:24 +00:00
{
2002-05-10 00:00:23 +00:00
class_t *c;
if (!class_hash)
class_hash = Hash_NewTable (1021, class_get_key, 0, 0);
if (sym) {
c = Hash_Find (class_hash, sym->name);
2002-05-10 00:00:23 +00:00
if (c || !create)
return c;
}
2002-05-08 21:24:24 +00:00
2002-05-10 00:00:23 +00:00
c = calloc (sizeof (class_t), 1);
c->methods = new_methodlist ();
c->class_type.type = ct_class;
c->class_type.c.class = c;
if (sym) {
c->name = sym->name;
Hash_Add (class_hash, c);
sym->sy_type = sy_class;
}
sym = class_symbol (&c->class_type, 1);
c->def = sym->s.def;
return c;
}
class_t *
get_class (symbol_t *sym, int create)
{
class_t *c;
type_t new;
if (!(c = _get_class (sym, create)))
return c;
memset (&new, 0, sizeof (new));
new.type = ev_invalid;
new.name = c->name;
new.meta = ty_class;
new.t.class = c;
c->type = find_type (&new);
if (sym)
sym->type = c->type;
2002-05-08 21:24:24 +00:00
return c;
}
static void
set_self_type (class_t *class, method_t *method)
{
if (method->instance)
method->params->type = pointer_type (class->type);
else
method->params->type = &type_Class;
}
static void
methods_set_self_type (class_t *class, methodlist_t *methods)
{
method_t *method;
for (method = methods->head; method; method = method->next)
set_self_type (class, method);
}
2002-05-10 00:00:23 +00:00
void
class_add_methods (class_t *class, methodlist_t *methods)
{
if (!methods)
return;
2002-11-14 18:17:43 +00:00
*class->methods->tail = methods->head;
class->methods->tail = methods->tail;
2002-05-10 00:00:23 +00:00
free (methods);
methods_set_self_type (class, class->methods);
2002-05-10 00:00:23 +00:00
}
void
class_add_protocols (class_t *class, protocollist_t *protocols)
2002-05-10 00:00:23 +00:00
{
int i;
2002-05-10 00:00:23 +00:00
protocol_t *p;
methodlist_t *methods;
2002-05-10 00:00:23 +00:00
if (!protocols)
return;
methods = class->methods;
for (i = 0; i < protocols->count; i++) {
p = protocols->list[i];
copy_methods (methods, p->methods);
if (p->protocols)
class_add_protocols (class, p->protocols);
2002-05-10 00:00:23 +00:00
}
class->protocols = protocols;
2002-05-10 00:00:23 +00:00
}
static void
begin_category (category_t *category)
{
pr_category_t *pr_category;
class_t *class = category->class;
symbol_t *sym;
def_t *def;
defspace_t *space;
current_class = &category->class_type;
sym = class_symbol (current_class, 0);
category->def = def = sym->s.def;
def->initialized = def->constant = def->nosave = 1;
space = def->space;
pr_category = &D_STRUCT (pr_category_t, def);
EMIT_STRING (space, pr_category->category_name, category->name);
EMIT_STRING (space, pr_category->class_name, class->name);
EMIT_DEF (space, pr_category->protocols,
emit_protocol_list (category->protocols,
va ("%s_%s", class->name, category->name)));
}
typedef struct {
int count;
symbol_t *ivars;
dstring_t *encoding;
} ivar_data_t;
static void
emit_ivar_count (def_t *def, void *data, int index)
{
ivar_data_t *ivar_data = (ivar_data_t *) data;
if (def->type != &type_integer)
internal_error (0, "%s: expected integer def", __FUNCTION__);
D_INT (def) = ivar_data->count;
}
static void
emit_ivar_list_item (def_t *def, void *data, int index)
{
ivar_data_t *ivar_data = (ivar_data_t *) data;
symbol_t *ivar_sym;
pr_ivar_t *ivar;
defspace_t *space;
#if 0
//FIXME the type is dynamic, so need a way to pass it before it cn be
//checked
if (def->type != &XXX)
internal_error (0, "%s: expected XXX def",
__FUNCTION__);
#endif
if (index < 0 || index >= ivar_data->count)
internal_error (0, "%s: out of bounds index: %d %d",
__FUNCTION__, index, ivar_data->count);
for (ivar_sym = ivar_data->ivars; ivar_sym; ivar_sym = ivar_sym->next) {
if (ivar_sym->sy_type != sy_var)
continue;
if (!index--)
break;
}
ivar = D_POINTER (pr_ivar_t, def);
space = def->space;
dstring_clearstr (ivar_data->encoding);
EMIT_STRING (space, ivar->ivar_name, ivar_sym->name);
encode_type (ivar_data->encoding, ivar_sym->type);
EMIT_STRING (space, ivar->ivar_type, ivar_data->encoding->str);
ivar->ivar_offset = ivar_sym->s.offset;
}
static def_t *
emit_ivars (symtab_t *ivars, const char *name)
{
static struct_def_t ivar_list_struct[] = {
{"ivar_count", &type_integer, emit_ivar_count},
{"ivar_list", 0, emit_ivar_list_item},
{0, 0}
};
2011-02-14 12:25:55 +00:00
ivar_data_t ivar_data = {0, 0, 0};
symbol_t *s;
def_t *def;
ivar_data.encoding = dstring_newstr ();
2011-02-14 12:25:55 +00:00
if (ivars) {
ivar_data.ivars = ivars->symbols;
for (s = ivars->symbols; s; s = s->next)
if (s->sy_type == sy_var)
ivar_data.count++;
}
ivar_list_struct[1].type = array_type (&type_obj_ivar, ivar_data.count);
def = emit_structure (va ("_OBJ_INSTANCE_VARIABLES_%s", name), 's',
ivar_list_struct, 0, &ivar_data, sc_static);
dstring_delete (ivar_data.encoding);
return def;
}
static void
begin_class (class_t *class)
{
def_t *meta_def;
pr_class_t *meta;
pr_class_t *pr_class;
symbol_t *sym;
def_t *def;
defspace_t *space;
sym = make_symbol (va ("_OBJ_METACLASS_%s", class->name),
&type_obj_class, pr.far_data, sc_static);
meta_def = sym->s.def;
meta_def->initialized = meta_def->constant = meta_def->nosave = 1;
space = meta_def->space;
meta = &D_STRUCT (pr_class_t, meta_def);
EMIT_STRING (space, meta->class_pointer, class->name);
if (class->super_class)
EMIT_STRING (space, meta->super_class, class->super_class->name);
EMIT_STRING (space, meta->name, class->name);
meta->info = _PR_CLS_META;
meta->instance_size = type_size (&type_obj_class);
if (!class->super_class) {
// The ivars list for the meta class struct get emitted only for the
// root class of the hierachy.
// NOTE: type_obj_class is not actually a class
EMIT_DEF (space, meta->ivars,
emit_ivars (type_obj_class.t.symtab, "Class"));
} else {
meta->ivars = 0;
}
current_class = &class->class_type;
sym = class_symbol (current_class, 0);
class->def = def = sym->s.def;
def->initialized = def->constant = def->nosave = 1;
space = def->space;
pr_class = &D_STRUCT (pr_class_t, def);
EMIT_DEF (space, pr_class->class_pointer, meta_def);
if (class->super_class) {
class_type_t class_type = {ct_class, {0}};
class_type.c.class = class->super_class;
EMIT_STRING (space, pr_class->super_class, class->super_class->name);
class_symbol (&class_type, 1);
}
EMIT_STRING (space, pr_class->name, class->name);
pr_class->info = _PR_CLS_CLASS;
EMIT_DEF (space, pr_class->protocols,
emit_protocol_list (class->protocols, class->name));
}
2003-07-27 18:50:17 +00:00
void
2002-11-14 18:17:43 +00:00
class_begin (class_type_t *class_type)
2002-05-15 19:10:23 +00:00
{
if (current_class) {
warning (0, "‘@end’ missing in implementation context");
class_finish (current_class);
current_class = 0;
}
switch (class_type->type) {
case ct_category:
begin_category (class_type->c.category);
break;
case ct_class:
begin_class (class_type->c.class);
break;
case ct_protocol:
return; // probably error recovery
2002-05-16 22:33:11 +00:00
}
}
void
emit_class_ref (const char *class_name)
{
symbol_t *ref_sym;
symbol_t *name_sym;
def_t *ref_def;
def_t *name_def;
ref_sym = make_symbol (va (".obj_class_ref_%s", class_name), &type_pointer,
pr.far_data, sc_static);
if (!ref_sym->table)
symtab_addsymbol (pr.symtab, ref_sym);
ref_def = ref_sym->s.def;
if (ref_def->initialized)
return;
ref_def->initialized = ref_def->constant = ref_def->nosave = 1;
name_sym = make_symbol (va (".obj_class_name_%s", class_name),
&type_pointer, pr.far_data, sc_extern);
if (!name_sym->table)
symtab_addsymbol (pr.symtab, name_sym);
name_def = name_sym->s.def;
if (!name_def->external)
D_INT (ref_def) = name_def->offset;
reloc_def_def (name_def, ref_def);
}
2003-07-27 18:50:17 +00:00
static void
emit_class_name (const char *class_name)
{
symbol_t *name_sym;
def_t *name_def;
name_sym = make_symbol (va (".obj_class_name_%s", class_name),
&type_pointer, pr.far_data, sc_global);
if (!name_sym->table)
symtab_addsymbol (pr.symtab, name_sym);
name_def = name_sym->s.def;
if (name_def->initialized)
return;
name_def->initialized = name_def->constant = 1;
name_def->nosave = 1;
D_INT (name_def) = 0;
}
void
emit_category_ref (const char *class_name, const char *category_name)
{
symbol_t *ref_sym;
symbol_t *name_sym;
def_t *ref_def;
def_t *name_def;
ref_sym = make_symbol (va (".obj_category_ref_%s_%s",
class_name, category_name),
&type_pointer, pr.far_data, sc_static);
if (!ref_sym->table)
symtab_addsymbol (pr.symtab, ref_sym);
ref_def = ref_sym->s.def;
if (ref_def->initialized)
return;
ref_def->initialized = ref_def->constant = 1;
ref_def->nosave = 1;
name_sym = make_symbol (va (".obj_category_name_%s_%s",
class_name, category_name),
&type_pointer, pr.far_data, sc_extern);
if (!name_sym->table)
symtab_addsymbol (pr.symtab, name_sym);
name_def = name_sym->s.def;
if (!name_def->external)
D_INT (ref_def) = name_def->offset;
reloc_def_def (name_def, ref_def);
}
2003-07-27 18:50:17 +00:00
static void
emit_category_name (const char *class_name, const char *category_name)
{
symbol_t *name_sym;
def_t *name_def;
name_sym = make_symbol (va (".obj_category_name_%s_%s",
class_name, category_name),
&type_pointer, pr.far_data, sc_global);
if (!name_sym->table)
symtab_addsymbol (pr.symtab, name_sym);
name_def = name_sym->s.def;
if (name_def->initialized)
return;
name_def->initialized = name_def->constant = 1;
name_def->nosave = 1;
D_INT (name_def) = 0;
}
static void
finish_category (category_t *category)
2002-05-16 22:33:11 +00:00
{
pr_category_t *pr_category;
class_t *class = category->class;
char *name;
defspace_t *space;
2003-07-24 19:41:59 +00:00
if (!category->def) // probably in error recovery
return;
name = nva ("%s_%s", class->name, category->name);
pr_category = &D_STRUCT (pr_category_t, category->def);
space = category->def->space;
EMIT_DEF (space, pr_category->instance_methods,
emit_methods (category->methods, name, 1));
EMIT_DEF (space, pr_category->class_methods,
emit_methods (category->methods, name, 0));
free (name);
emit_class_ref (class->name);
emit_category_name (class->name, category->name);
}
static void
finish_class (class_t *class)
{
pr_class_t *meta;
pr_class_t *cls;
defspace_t *space;
2002-05-16 22:33:11 +00:00
if (pr.error_count) // probably in error recovery
return;
space = class->def->space;
cls = &D_STRUCT (pr_class_t, class->def);
2002-05-16 22:33:11 +00:00
meta = &G_STRUCT (space, pr_class_t, cls->class_pointer);
EMIT_DEF (space, meta->methods, emit_methods (class->methods,
class->name, 0));
2011-03-08 13:45:34 +00:00
cls->instance_size = type_size (class->type);
EMIT_DEF (space, cls->ivars, emit_ivars (class->ivars, class->name));
EMIT_DEF (space, cls->methods, emit_methods (class->methods,
class->name, 1));
if (class->super_class)
emit_class_ref (class->super_class->name);
emit_class_name (class->name);
}
void
class_finish (class_type_t *class_type)
{
switch (class_type->type) {
case ct_category:
finish_category (class_type->c.category);
break;
case ct_class:
finish_class (class_type->c.class);
break;
case ct_protocol:
return; // probably in error recovery
}
}
2002-05-16 22:33:11 +00:00
class_t *
extract_class (class_type_t *class_type)
{
switch (class_type->type) {
case ct_class:
return current_class->c.class;
case ct_category:
return current_class->c.category->class;
case ct_protocol:
return 0; // probably in error recovery
}
return 0; // should not happen
}
2003-07-27 18:50:17 +00:00
int
class_access (class_type_t *class_type, class_t *class)
2002-11-14 18:17:43 +00:00
{
class_t *cur;
if (class_type) {
if (!(cur = extract_class (class_type)))
return vis_private;
if (cur == class)
return vis_private;
cur = cur->super_class;
while (cur) {
if (cur == class)
return vis_protected;
cur = cur->super_class;
}
}
return vis_public;
2002-11-14 18:17:43 +00:00
}
symbol_t *
class_find_ivar (class_t *class, int vis, const char *name)
{
symbol_t *ivar;
ivar = symtab_lookup (class->ivars, name);
if (ivar) {
if (ivar->visibility > (vis_t) vis)
goto access_error;
return ivar;
}
error (0, "%s.%s does not exist", class->name, name);
return 0;
2003-07-24 19:41:59 +00:00
access_error:
error (0, "%s.%s is not accessable here", class->name, name);
return 0;
}
2003-07-27 18:50:17 +00:00
method_t *
2002-11-14 18:17:43 +00:00
class_find_method (class_type_t *class_type, method_t *method)
{
methodlist_t *methods = 0, *start_methods;
method_t *m;
dstring_t *sel;
class_t *class = 0, *start_class;
switch (class_type->type) {
case ct_category:
methods = class_type->c.category->methods;
class = class_type->c.category->class;
break;
case ct_class:
class = class_type->c.class;
methods = class->methods;
break;
case ct_protocol:
return 0; // probably in error recovery
}
start_methods = methods;
start_class = class;
while (class) {
for (m = methods->head; m; m = m->next)
if (method_compare (method, m)) {
if (m->type != method->type)
error (0, "method type mismatch");
if (methods != start_methods) {
m = copy_method (m);
set_self_type (start_class, m);
add_method (start_methods, m);
}
method_set_param_names (m, method);
return m;
}
if (class->methods == methods)
class = class->super_class;
else
methods = class->methods;
2002-11-14 18:17:43 +00:00
}
sel = dstring_newstr ();
selector_name (sel, (keywordarg_t *)method->selector);
set_self_type (start_class, method);
add_method (start_methods, method);
dstring_delete (sel);
return method;
}
2003-07-27 18:50:17 +00:00
method_t *
class_message_response (class_t *class, int class_msg, expr_t *sel)
{
selector_t *selector;
method_t *m;
class_t *c = class;
category_t *cat;
selector = get_selector (sel);
if (!selector)
return 0;
if (class && class->type != &type_obj_object) {
2003-07-29 17:38:29 +00:00
while (c) {
for (cat = c->categories; cat; cat = cat->next) {
for (m = cat->methods->head; m; m = m->next) {
2010-12-16 07:41:16 +00:00
if (((!c->super_class && class_msg)
|| class_msg != m->instance)
&& strcmp (selector->name, m->name) == 0)
return m;
}
}
for (m = c->methods->head; m; m = m->next) {
2010-12-16 07:41:16 +00:00
if (((!c->super_class && class_msg)
|| class_msg != m->instance)
&& strcmp (selector->name, m->name) == 0)
return m;
}
2003-07-29 17:38:29 +00:00
c = c->super_class;
}
//FIXME right option?
if (options.warnings.interface_check)
2010-12-16 07:41:16 +00:00
warning (sel, "%s may not respond to %c%s", class->name,
class_msg ? '+' : '-', selector->name);
}
m = find_method (selector->name);
if (m)
return m;
//FIXME right option?
if (options.warnings.interface_check)
warning (sel, "could not find method for %c%s",
class_msg ? '+' : '-', selector->name);
return 0;
}
static uintptr_t
category_get_hash (const void *_c, void *unused)
2002-05-15 19:10:23 +00:00
{
category_t *c = (category_t *) _c;
return Hash_String (c->name) ^ Hash_String (c->class->name);
2002-05-15 19:10:23 +00:00
}
2003-07-27 18:50:17 +00:00
static int
category_compare (const void *_c1, const void *_c2, void *unused)
2002-05-15 19:10:23 +00:00
{
category_t *c1 = (category_t *) _c1;
category_t *c2 = (category_t *) _c2;
return strcmp (c1->name, c2->name) == 0
2003-07-24 19:41:59 +00:00
&& strcmp (c1->class->name, c2->class->name) == 0;
2002-05-15 19:10:23 +00:00
}
symtab_t *
class_new_ivars (class_t *class)
{
symtab_t *ivars;
symtab_t *super_ivars = 0;
if (class->super_class)
super_ivars = class->super_class->ivars;
ivars = new_symtab (super_ivars, stab_local);
return ivars;
}
2003-07-27 18:50:17 +00:00
void
class_add_ivars (class_t *class, symtab_t *ivars)
{
int base = 0;
symbol_t *sym;
if (class->super_class)
base = type_size (class->super_class->type);
for (sym = ivars->symbols; sym; sym = sym->next)
sym->s.offset += base;
class->ivars = ivars;
}
static int
compare_symbols (symbol_t *s1, symbol_t *s2)
{
if (s1->visibility != s2->visibility)
return 0;
if (s1->name != s2->name) // works thanks to save_string
return 0;
if (s1->sy_type != s2->sy_type)
return 0;
if (s1->type != s2->type)
return 0;
return 1;
}
2003-07-27 18:50:17 +00:00
void
class_check_ivars (class_t *class, symtab_t *ivars)
2002-05-15 19:10:23 +00:00
{
2011-01-24 12:13:37 +00:00
symbol_t *civ, *iv;
int missmatch = 0;
2011-01-24 12:13:37 +00:00
if (!class->ivars != !ivars) {
missmatch = 1;
} else if (ivars) {
2011-01-24 12:13:37 +00:00
for (civ = class->ivars->symbols, iv = ivars->symbols;
civ && iv; civ = civ->next, iv = iv->next) {
if (!compare_symbols (civ, iv)) {
missmatch = 1;
break;
}
2011-01-24 12:13:37 +00:00
}
}
2011-01-24 12:13:37 +00:00
//FIXME right option?
if (missmatch && options.warnings.interface_check)
2011-01-24 12:13:37 +00:00
warning (0, "instance variable missmatch for %s", class->name);
class_add_ivars (class, ivars);
2002-05-15 19:10:23 +00:00
}
2003-07-27 18:50:17 +00:00
category_t *
get_category (symbol_t *class_name, const char *category_name, int create)
2002-05-15 19:10:23 +00:00
{
2002-11-14 18:17:43 +00:00
category_t *category;
class_t *class;
2002-05-15 19:10:23 +00:00
if (!category_hash) {
category_hash = Hash_NewTable (1021, 0, 0, 0);
Hash_SetHashCompare (category_hash,
2003-07-24 19:41:59 +00:00
category_get_hash, category_compare);
2002-05-15 19:10:23 +00:00
}
class = get_class (class_name, 0);
if (!class) {
error (0, "undefined class %s", class_name->name);
2002-11-14 18:17:43 +00:00
return 0;
}
2002-05-15 19:10:23 +00:00
if (class_name && category_name) {
2002-11-14 18:17:43 +00:00
category_t _c = {0, category_name, class};
category = Hash_FindElement (category_hash, &_c);
if (category || !create)
return category;
2002-05-15 19:10:23 +00:00
}
2002-11-14 18:17:43 +00:00
category = calloc (sizeof (category_t), 1);
category->next = class->categories;
class->categories = category;
category->name = category_name;
category->class = class;
category->methods = new_methodlist ();
category->class_type.type = ct_category;
2002-11-14 18:17:43 +00:00
category->class_type.c.category = category;
2002-05-15 19:10:23 +00:00
if (class_name && category_name)
2002-11-14 18:17:43 +00:00
Hash_AddElement (category_hash, category);
return category;
}
2003-07-27 18:50:17 +00:00
void
2002-11-14 18:17:43 +00:00
category_add_methods (category_t *category, methodlist_t *methods)
{
if (!methods)
return;
*category->methods->tail = methods->head;
category->methods->tail = methods->tail;
free (methods);
methods_set_self_type (category->class, category->methods);
2002-11-14 18:17:43 +00:00
}
2003-07-27 18:50:17 +00:00
void
category_add_protocols (category_t *category, protocollist_t *protocols)
2002-11-14 18:17:43 +00:00
{
int i;
2002-11-14 18:17:43 +00:00
protocol_t *p;
methodlist_t *methods;
2002-11-14 18:17:43 +00:00
if (!protocols)
return;
2002-11-14 18:17:43 +00:00
methods = category->methods;
2002-11-14 18:17:43 +00:00
for (i = 0; i < protocols->count; i++) {
p = protocols->list[i];
2002-11-14 18:17:43 +00:00
copy_methods (methods, p->methods);
if (p->protocols)
category_add_protocols (category, p->protocols);
2002-11-14 18:17:43 +00:00
}
category->protocols = protocols;
2002-05-15 19:10:23 +00:00
}
symbol_t *
class_pointer_symbol (class_t *class)
2002-05-10 00:00:23 +00:00
{
2002-05-16 22:33:11 +00:00
def_t *def;
symbol_t *sym;
class_type_t class_type = {ct_class, {0}};
2002-11-14 18:17:43 +00:00
class_type.c.class = class;
2002-05-16 22:33:11 +00:00
sym = make_symbol (va ("_OBJ_CLASS_POINTER_%s", class->name),
&type_Class,
pr.near_data, sc_static);
if (!sym->table)
symtab_addsymbol (pr.symtab, sym);
def = sym->s.def;
if (def->initialized)
return sym;
def->initialized = def->constant = 1;
def->nosave = 1;
if (!class->def)
class->def = class_symbol (&class_type, 1)->s.def;
if (!class->def->external)
D_INT (def) = class->def->offset;
reloc_def_def (class->def, def);
return sym;
2002-05-10 00:00:23 +00:00
}
2011-01-24 12:13:37 +00:00
typedef struct {
def_t *refs;
class_t **classes;
int cls_def_cnt;
category_t **categories;
int cat_def_cnt;
} obj_symtab_data_t;
static void
emit_symtab_ref_cnt (def_t *def, void *data, int index)
{
obj_symtab_data_t *da = (obj_symtab_data_t *)data;
if (def->type != &type_integer)
internal_error (0, "%s: expected integer def", __FUNCTION__);
D_INT (def) = 0;
if (da->refs)
D_INT (def) = da->refs->type->t.array.size;
2011-01-24 12:13:37 +00:00
}
static void
emit_symtab_refs (def_t *def, void *data, int index)
{
obj_symtab_data_t *da = (obj_symtab_data_t *)data;
if (def->type != &type_SEL)
internal_error (0, "%s: expected SEL def", __FUNCTION__);
D_INT (def) = 0;
if (da->refs)
2011-02-09 06:58:32 +00:00
EMIT_DEF (def->space, D_INT (def), da->refs);
2011-01-24 12:13:37 +00:00
}
static void
emit_symtab_cls_def_cnt (def_t *def, void *data, int index)
{
obj_symtab_data_t *da = (obj_symtab_data_t *)data;
if (def->type != &type_integer)
internal_error (0, "%s: expected integer def", __FUNCTION__);
D_INT (def) = da->cls_def_cnt;
}
static void
emit_symtab_cat_def_cnt (def_t *def, void *data, int index)
{
obj_symtab_data_t *da = (obj_symtab_data_t *)data;
if (def->type != &type_integer)
internal_error (0, "%s: expected integer def", __FUNCTION__);
D_INT (def) = da->cat_def_cnt;
}
static void
emit_symtab_defs (def_t *def, void *data, int index)
{
obj_symtab_data_t *da = (obj_symtab_data_t *)data;
if (!is_array (def->type) || def->type->t.array.type->type != ev_pointer)
internal_error (0, "%s: expected array of pointers def", __FUNCTION__);
2011-01-24 12:13:37 +00:00
if (index < 0 || index >= da->cls_def_cnt + da->cat_def_cnt)
internal_error (0, "%s: out of bounds index: %d %d",
__FUNCTION__, index,
da->cls_def_cnt + da->cat_def_cnt);
if (index < da->cls_def_cnt) {
class_t **cl;
for (cl = da->classes; *cl; cl++)
if ((*cl)->def && !(*cl)->def->external)
if (!index--)
break;
EMIT_DEF (def->space, D_INT (def), (*cl)->def);
2011-01-24 12:13:37 +00:00
} else {
category_t **ca;
index -= da->cls_def_cnt;
for (ca = da->categories; *ca; ca++)
if ((*ca)->def && !(*ca)->def->external)
if (!index--)
break;
EMIT_DEF (def->space, D_INT (def), (*ca)->def);
2011-01-24 12:13:37 +00:00
}
}
2003-07-27 18:50:17 +00:00
void
class_finish_module (void)
{
static struct_def_t symtab_struct[] = {
2011-01-24 12:13:37 +00:00
{"sel_ref_cnt", &type_integer, emit_symtab_ref_cnt},
{"refs", &type_SEL, emit_symtab_refs},
{"cls_def_cnt", &type_integer, emit_symtab_cls_def_cnt},
{"cat_def_cnt", &type_integer, emit_symtab_cat_def_cnt},
{"defs", 0, emit_symtab_defs},
{0, 0}
};
2011-01-24 12:13:37 +00:00
obj_symtab_data_t data = {0, 0, 0, 0, 0};
class_t **cl;
category_t **ca;
def_t *symtab_def;
symbol_t *module_sym;
2011-01-24 12:13:37 +00:00
pr_module_t *module;
symbol_t *exec_class_sym;
symbol_t *init_sym;
expr_t *init_expr;
2011-03-01 01:56:03 +00:00
storage_class_t save_storage;
2011-01-24 12:13:37 +00:00
data.refs = emit_selectors ();
if (class_hash) {
2011-01-24 12:13:37 +00:00
data.classes = (class_t **) Hash_GetList (class_hash);
for (cl = data.classes; *cl; cl++)
2002-11-14 18:17:43 +00:00
if ((*cl)->def && !(*cl)->def->external)
2011-01-24 12:13:37 +00:00
data.cls_def_cnt++;
}
if (category_hash) {
2011-01-24 12:13:37 +00:00
data.categories = (category_t **) Hash_GetList (category_hash);
for (ca = data.categories; *ca; ca++)
2002-11-14 18:17:43 +00:00
if ((*ca)->def && !(*ca)->def->external)
2011-01-24 12:13:37 +00:00
data.cat_def_cnt++;
}
2011-01-24 12:13:37 +00:00
if (!data.refs && !data.cls_def_cnt && !data.cat_def_cnt)
return;
symtab_struct[4].type = array_type (&type_pointer,
2011-01-24 12:13:37 +00:00
data.cls_def_cnt + data.cat_def_cnt);
symtab_def = emit_structure ("_OBJ_SYMTAB", 's', symtab_struct, 0, &data,
sc_static);
free (data.classes);
free (data.categories);
2011-01-24 12:13:37 +00:00
module_sym = make_symbol ("_OBJ_MODULE", &type_obj_module, pr.far_data,
sc_static);
symtab_addsymbol (current_symtab, module_sym);
2011-01-24 12:13:37 +00:00
module = &D_STRUCT (pr_module_t, module_sym->s.def);
module->size = type_size (&type_obj_module);
2011-01-24 12:13:37 +00:00
EMIT_STRING (module_sym->s.def->space, module->name,
GETSTR (pr.source_file));
EMIT_DEF (module_sym->s.def->space, module->symtab, symtab_def);
exec_class_sym = symtab_lookup (pr.symtab, "__obj_exec_class");
if (!exec_class_sym) {
exec_class_sym = new_symbol_type ("__obj_exec_class",
&type_obj_exec_class);
exec_class_sym = function_symbol (exec_class_sym, 0, 1);
make_function (exec_class_sym, 0, exec_class_sym->table->space,
sc_extern);
}
init_sym = new_symbol_type (".ctor", &type_function);
init_sym = function_symbol (init_sym, 0, 1);
init_expr = new_block_expr ();
append_expr (init_expr,
build_function_call (new_symbol_expr (exec_class_sym),
exec_class_sym->type,
address_expr (new_symbol_expr (module_sym),
0, 0)));
2011-03-01 01:56:03 +00:00
save_storage = current_storage;
current_storage = sc_static;
current_func = begin_function (init_sym, 0, current_symtab, 1);
build_code_function (init_sym, 0, init_expr);;
current_func = 0;
2011-03-01 01:56:03 +00:00
current_storage = save_storage;
}
2002-05-08 21:24:24 +00:00
protocol_t *
2002-05-10 00:00:23 +00:00
get_protocol (const char *name, int create)
2002-05-08 21:24:24 +00:00
{
2002-05-10 00:00:23 +00:00
protocol_t *p;
2003-07-24 19:41:59 +00:00
if (!protocol_hash)
protocol_hash = Hash_NewTable (1021, protocol_get_key, 0, 0);
2002-05-10 00:00:23 +00:00
if (name) {
p = Hash_Find (protocol_hash, name);
if (p || !create)
return p;
}
2002-05-08 21:24:24 +00:00
2002-05-10 00:00:23 +00:00
p = calloc (sizeof (protocol_t), 1);
2002-05-08 21:24:24 +00:00
p->name = name;
p->methods = new_methodlist ();
p->class_type.type = ct_protocol;
p->class_type.c.protocol = p;
2002-05-15 19:10:23 +00:00
if (name)
Hash_Add (protocol_hash, p);
2002-05-08 21:24:24 +00:00
return p;
}
2002-05-10 00:00:23 +00:00
void
protocol_add_methods (protocol_t *protocol, methodlist_t *methods)
2002-05-08 21:24:24 +00:00
{
2002-05-10 00:00:23 +00:00
if (!methods)
return;
*protocol->methods->tail = methods->head;
protocol->methods->tail = methods->tail;
free (methods);
2002-05-08 21:24:24 +00:00
}
2002-05-10 00:00:23 +00:00
void
protocol_add_protocols (protocol_t *protocol, protocollist_t *protocols)
2002-05-08 21:24:24 +00:00
{
protocol->protocols = protocols;
2002-05-08 21:24:24 +00:00
}
2002-05-10 00:00:23 +00:00
def_t *
protocol_def (protocol_t *protocol)
2002-05-08 21:24:24 +00:00
{
return make_symbol (protocol->name, &type_obj_protocol,
pr.far_data, sc_static)->s.def;
2002-05-08 21:24:24 +00:00
}
2002-05-15 19:10:23 +00:00
protocollist_t *
new_protocol_list (void)
2002-05-15 19:10:23 +00:00
{
protocollist_t *protocollist = malloc (sizeof (protocollist_t));
protocollist->count = 0;
protocollist->list = 0;
return protocollist;
}
protocollist_t *
add_protocol (protocollist_t *protocollist, const char *name)
{
protocol_t *protocol = get_protocol (name, 0);
if (!protocol) {
error (0, "undefined protocol `%s'", name);
return protocollist;
}
protocollist->count++;
protocollist->list = realloc (protocollist->list,
sizeof (protocol_t) * protocollist->count);
protocollist->list[protocollist->count - 1] = protocol;
return protocollist;
}
int
procollist_find_protocol (protocollist_t *protocollist, protocol_t *proto)
{
int i;
if (!protocollist)
return 0;
for (i = 0; i < protocollist->count; i++)
if (protocollist->list[i] == proto)
return 1;
return 0;
}
int
compare_protocols (protocollist_t *protos1, protocollist_t *protos2)
{
int i;
if (protos1 == protos2)
return 1;
if (!protos1 || !protos2)
return 0;
if (protos1->count != protos2->count)
return 0;
for (i = 0; i < protos1->count; i++)
if (!procollist_find_protocol (protos2, protos1->list[i]))
return 0;
return 1;
}
void
print_protocollist (dstring_t *dstr, protocollist_t *protocollist)
{
int i;
dstring_appendstr (dstr, "<");
for (i = 0; i < protocollist->count; i++)
dasprintf (dstr, "%s%s", i ? "," : "", protocollist->list[i]->name);
dstring_appendstr (dstr, ">");
}
def_t *
emit_protocol (protocol_t *protocol)
{
def_t *proto_def;
pr_protocol_t *proto;
defspace_t *space;
proto_def = make_symbol (va ("_OBJ_PROTOCOL_%s", protocol->name),
&type_obj_protocol, pr.far_data, sc_static)->s.def;
if (proto_def->initialized)
return proto_def;
proto_def->initialized = proto_def->constant = 1;
proto_def->nosave = 1;
space = proto_def->space;
proto = &D_STRUCT (pr_protocol_t, proto_def);
proto->class_pointer = 0;
EMIT_STRING (space, proto->protocol_name, protocol->name);
EMIT_DEF (space, proto->protocol_list,
emit_protocol_list (protocol->protocols,
va ("PROTOCOL_%s", protocol->name)));
EMIT_DEF (space, proto->instance_methods,
emit_method_descriptions (protocol->methods, protocol->name, 1));
EMIT_DEF (space, proto->class_methods,
emit_method_descriptions (protocol->methods, protocol->name, 0));
emit_class_ref ("Protocol");
return proto_def;
}
def_t *
emit_protocol_list (protocollist_t *protocols, const char *name)
{
2011-01-24 12:13:37 +00:00
//FIXME use emit_struct
static struct_def_t proto_list_struct[] = {
{"next", &type_pointer},
{"count", &type_integer},
{"list", 0}, // type will be filled in at run time
{0, 0},
};
type_t *proto_list_type;
def_t *proto_list_def;
defspace_t *space;
pr_protocol_list_t *proto_list;
int i;
if (!protocols)
return 0;
proto_list_struct[2].type = array_type (&type_pointer, protocols->count);
proto_list_type = make_structure (0, 's', proto_list_struct, 0)->type;
proto_list_def = make_symbol (va ("_OBJ_PROTOCOLS_%s", name),
proto_list_type,
pr.far_data, sc_static)->s.def;
proto_list_def->initialized = proto_list_def->constant = 1;
proto_list_def->nosave = 1;
space = proto_list_def->space;
proto_list = &D_STRUCT (pr_protocol_list_t, proto_list_def);
proto_list->next = 0;
proto_list->count = protocols->count;
for (i = 0; i < protocols->count; i++)
EMIT_DEF (space, proto_list->list[i],
emit_protocol (protocols->list[i]));
return proto_list_def;
}
void
clear_classes (void)
{
if (class_hash)
Hash_FlushTable (class_hash);
if (protocol_hash)
Hash_FlushTable (protocol_hash);
if (category_hash)
Hash_FlushTable (category_hash);
obj_initialized = 0;
}
symtab_t *
class_to_struct (class_t *class, symtab_t *symtab)
{
symtab_t *parent = symtab->parent;
symtab_t *ivars = class->ivars;
symtab_t *ancestor;
if (!ivars)
return symtab;
// disconnect the struct symbol table from the scope
symtab->parent = 0;
// find the ancestor of the ivars symbol table chain
for (ancestor = ivars; ancestor->parent; ancestor = ancestor->parent)
;
// connect the ivars symbol table chain to the struct symbol table
ancestor->parent = symtab;
// create a new struct symbol table from the ivars symbol table chain
symtab = symtab_flat_copy (ivars, 0);
// disconnect the ivars symbol table chain
ancestor->parent = 0;
// connect the new struct symbol table to the scope
symtab->parent = parent;
return symtab;
}
symtab_t *
class_ivar_scope (class_type_t *class_type, symtab_t *parent)
{
class_t *class = extract_class (class_type);
if (!class->ivars)
return 0;
return symtab_flat_copy (class->ivars, parent);
}
void
class_finish_ivar_scope (class_type_t *class_type, symtab_t *ivar_scope,
symtab_t *param_scope)
{
class_t *class = extract_class (class_type);
type_t *class_ptr = pointer_type (class->type);
symbol_t *sym;
symbol_t *self;
expr_t *self_expr;
if (!ivar_scope)
return;
self = symtab_lookup (param_scope, "self");
if (!self)
internal_error (0, "I've lost my self!");
self_expr = new_symbol_expr (self);
if (self->type != class_ptr) {
debug (0, "class method scope");
//FIXME should generate a warning on access
self_expr = cast_expr (class_ptr, self_expr);
}
for (sym = ivar_scope->symbols; sym; sym = sym->next) {
if (sym->sy_type != sy_var)
continue;
sym->sy_type = sy_expr;
sym->s.expr = field_expr (copy_expr (self_expr),
new_symbol_expr (new_symbol (sym->name)));
}
}
static void
init_objective_structs (void)
{
make_structure ("obj_selector", 's', sel_struct, &type_obj_selector);
chain_type (&type_obj_selector);
chain_type (&type_SEL);
chain_type (&type_IMP);
make_structure ("obj_method", 's', method_struct, &type_obj_method);
chain_type (&type_obj_method);
make_structure ("obj_method_description", 's', method_desc_struct,
&type_obj_method_description);
chain_type (&type_obj_method_description);
make_structure ("obj_category", 's', category_struct, &type_obj_category);
chain_type (&type_obj_category);
make_structure ("obj_ivar", 's', ivar_struct, &type_obj_ivar);
chain_type (&type_obj_ivar);
make_structure ("obj_super", 's', super_struct, &type_obj_super);
chain_type (&type_obj_super);
chain_type (&type_SuperPtr);
chain_type (&type_supermsg);
symtab_addsymbol (current_symtab, new_symbol ("id"));
}
static void
init_classes (void)
{
make_structure ("obj_class", 's', class_struct, &type_obj_class);
chain_type (&type_obj_class);
chain_type (&type_Class);
make_structure ("obj_object", 's', object_struct, &type_obj_object);
chain_type (&type_obj_object);
chain_type (&type_id);
make_structure ("obj_protocol", 's', protocol_struct, &type_obj_protocol);
chain_type (&type_obj_protocol);
}
static void
class_init_obj_module (void)
{
make_structure ("obj_module", 's', module_struct, &type_obj_module);
chain_type (&type_obj_module);
chain_type (&type_moduleptr);
chain_type (&type_obj_exec_class);
}
void
class_init (void)
{
symtab_t *cs = current_symtab;
current_symtab = pr.symtab;
class_init_obj_module ();
init_classes ();
init_objective_structs ();
obj_initialized = 1;
current_symtab = cs;
}