qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-26 14:20:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

getting closer to working categories

Browse source
This commit is contained in:
Bill Currie 2002-11-14 18:17:43 +00:00
parent e544c1247f
commit 3c215ce13f
7 changed files with 228 additions and 172 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
tools/qfcc/include/class.h
View file

@ -32,6 +32,14 @@
#ifndef __class_h
#define __class_h
typedef struct class_type_s {
int is_class;
union {
struct category_s *category;
struct class_s *class;
} c;
} class_type_t;
typedef struct class_s {
int defined;
const char *name;
@ -42,45 +50,53 @@ typedef struct class_s {
struct protocollist_s *protocols;
struct def_s *def;
struct type_s *type;
class_type_t class_type;
} class_t;
typedef struct category_s {
struct category_s *next;
const char *name;
class_t *class;
int defined;
struct methodlist_s *methods;
struct protocollist_s *protocols;
struct def_s *def;
class_type_t class_type;
} category_t;
extern class_t class_id;
extern class_t class_Class;
extern class_t class_Protocol;
extern class_t *current_class;
extern class_type_t *current_class;
struct expr_s;
struct method_s;
struct protocol_s;
struct type_s;
struct def_s *class_def (class_t *class, int external);
struct def_s *class_def (class_type_t *class_type, int external);
void class_init (void);
class_t *get_class (const char *name, int create);
void class_add_methods (class_t *class, struct methodlist_s *methods);
void class_add_protocol_methods (class_t *class, struct expr_s *protocols);
void class_add_protocol (class_t *class, struct protocol_s *protocol);
void class_add_ivars (class_t *class, struct type_s *ivars);
void class_check_ivars (class_t *class, struct type_s *ivars);
void class_begin (class_t *class);
void class_finish (class_t *class);
void class_begin (class_type_t *class_type);
void class_finish (class_type_t *class_type);
int class_access (class_type_t *current_class, class_t *class);
struct struct_field_s *class_find_ivar (class_t *class, int protected,
const char *name);
struct expr_s *class_ivar_expr (class_t *class, const char *name);
struct method_s *class_find_method (class_t *class, struct method_s *method);
struct expr_s *class_ivar_expr (class_type_t *class_type, const char *name);
struct method_s *class_find_method (class_type_t *class_type,
struct method_s *method);
struct method_s *class_message_response (class_t *class, struct expr_s *sel);
struct def_s *class_pointer_def (class_t *class);
class_t *get_category (const char *class_name, const char *category_name,
int create);
struct def_s *class_pointer_def (class_t *class_type);
category_t *get_category (const char *class_name, const char *category_name,
int create);
void category_add_methods (category_t *category, struct methodlist_s *methods);
void category_add_protocol_methods (category_t *category,
struct expr_s *protocols);
void class_finish_module (void);
typedef struct protocol_s {

2
tools/qfcc/include/method.h
View file

@ -66,7 +66,7 @@ struct dstring_s;
method_t *new_method (struct type_s *ret_type, param_t *selector,
param_t *opt_parms);
void add_method (methodlist_t *methodlist, method_t *method);
struct def_s *method_def (struct class_s *class, method_t *method);
struct def_s *method_def (struct class_type_s *class_type, method_t *method);
methodlist_t *new_methodlist (void);
void copy_methods (methodlist_t *dst, methodlist_t *src);

274
tools/qfcc/source/class.c
View file

@ -87,20 +87,18 @@ class_init (void)
}
def_t *
class_def (class_t *class, int external)
class_def (class_type_t *class_type, int external)
{
const char *name;
type_t *type;
storage_class_t storage = external ? st_extern : st_global;
if (!class->name)
return 0;
if (class->categories) {
name = va ("_OBJ_CATEGORY_%s_%s",
class->name, class->categories->name);
if (!class_type->is_class) {
name = va ("_OBJ_CATEGORY_%s_%s", class_type->c.category->class->name,
class_type->c.category->name);
type = type_category;
} else {
name = va ("_OBJ_CLASS_%s", class->name);
name = va ("_OBJ_CLASS_%s", class_type->c.class->name);
type = type_Class.aux_type;
}
return get_def (type, name, pr.scope, storage);
@ -125,6 +123,8 @@ get_class (const char *name, int create)
new = *type_Class.aux_type;
new.class = c;
c->type = pointer_type (find_type (&new));
c->class_type.is_class = 1;
c->class_type.c.class = c;
if (name)
Hash_Add (class_hash, c);
return c;
@ -135,18 +135,11 @@ class_add_methods (class_t *class, methodlist_t *methods)
{
if (!methods)
return;
if (class->categories) {
category_t *category = class->categories;
if (!category->methods)
category->methods = new_methodlist ();
*category->methods->tail = methods->head;
category->methods->tail = methods->tail;
} else {
if (!class->methods)
class->methods = new_methodlist ();
*class->methods->tail = methods->head;
class->methods->tail = methods->tail;
}
if (!class->methods)
class->methods = new_methodlist ();
*class->methods->tail = methods->head;
class->methods->tail = methods->tail;
free (methods);
}
@ -158,23 +151,13 @@ class_add_protocol_methods (class_t *class, expr_t *protocols)
if (!protocol_hash)
protocol_hash = Hash_NewTable (1021, protocol_get_key, 0, 0);
if (class->categories) {
if (!class->categories->methods)
class->categories->methods = new_methodlist ();
} else {
if (!class->methods)
class->methods = new_methodlist ();
}
if (!class->methods)
class->methods = new_methodlist ();
for (e = protocols; e; e = e->next) {
methodlist_t *methods;
method_t **m;
if (class->categories)
methods = class->categories->methods;
else
methods = class->methods;
m = methods->tail;
methodlist_t *methods = class->methods;
method_t **m = methods->tail;
if (!(p = get_protocol (e->e.string_val, 0))) {
error (e, "undefined protocol `%s'", e->e.string_val);
@ -189,35 +172,32 @@ class_add_protocol_methods (class_t *class, expr_t *protocols)
}
void
class_add_protocol (class_t *class, protocol_t *protocol)
class_begin (class_type_t *class_type)
{
if (!class->protocols)
class->protocols = new_protocollist ();
add_protocol (class->protocols, protocol);
}
if (!class_type->is_class) {
pr_category_t *pr_category;
category_t *category = class_type->c.category;
class_t *class = category->class;
void
class_begin (class_t *class)
{
current_class = class;
class->def = class_def (class, 0);
if (class->name && class->categories) {
pr_category_t *category;
class->def->initialized = class->def->constant = 1;
category = &G_STRUCT (pr_category_t, class->def->ofs);
EMIT_STRING (category->category_name, class->categories->name);
EMIT_STRING (category->class_name, class->name);
EMIT_DEF (category->protocols,
emit_protocol_list (class->categories->protocols,
current_class = &category->class_type;
category->def = class_def (class_type, 0);
category->def->initialized = category->def->constant = 1;
pr_category = &G_STRUCT (pr_category_t, category->def->ofs);
EMIT_STRING (pr_category->category_name, category->name);
EMIT_STRING (pr_category->class_name, class->name);
EMIT_DEF (pr_category->protocols,
emit_protocol_list (category->protocols,
va ("%s_%s",
class->name,
class->categories->name)));
} else if (class->name) {
category->name)));
} else {
def_t *meta_def;
pr_class_t *meta;
pr_class_t *cls;
class_t *class = class_type->c.class;
current_class = &class->class_type;
class->def = class_def (class_type, 0);
meta_def = get_def (type_Class.aux_type,
va ("_OBJ_METACLASS_%s", class->name),
pr.scope, st_static);
@ -237,8 +217,10 @@ class_begin (class_t *class)
cls = &G_STRUCT (pr_class_t, class->def->ofs);
EMIT_DEF (cls->class_pointer, meta_def);
if (class->super_class) {
class_type_t class_type = {1, {0}};
class_type.c.class = class->super_class;
EMIT_STRING (cls->super_class, class->super_class->name);
class_def (class->super_class, 1);
class_def (&class_type, 1);
}
EMIT_STRING (cls->name, class->name);
cls->info = _PR_CLS_CLASS;
@ -247,13 +229,14 @@ class_begin (class_t *class)
}
void
class_finish (class_t *class)
class_finish (class_type_t *class_type)
{
if (class->name && class->categories) {
if (!class_type->is_class) {
pr_category_t *pr_category;
category_t *category = class->categories;
category_t *category = class_type->c.category;
class_t *class = category->class;
pr_category = &G_STRUCT (pr_category_t, class->def->ofs);
pr_category = &G_STRUCT (pr_category_t, category->def->ofs);
EMIT_DEF (pr_category->instance_methods,
emit_methods (category->methods, va ("%s_%s",
class->name,
@ -262,9 +245,10 @@ class_finish (class_t *class)
emit_methods (category->methods, va ("%s_%s",
class->name,
category->name), 0));
} else if (class->name) {
} else {
pr_class_t *meta;
pr_class_t *cls;
class_t *class = class_type->c.class;
cls = &G_STRUCT (pr_class_t, class->def->ofs);
@ -280,6 +264,16 @@ class_finish (class_t *class)
}
}
int
class_access (class_type_t *current_class, class_t *class)
{
if (!current_class)
return 1;
if (current_class->is_class)
return current_class->c.class != class;
return current_class->c.category->class != class;
}
struct_field_t *
class_find_ivar (class_t *class, int protected, const char *name)
{
@ -309,14 +303,19 @@ class_find_ivar (class_t *class, int protected, const char *name)
}
expr_t *
class_ivar_expr (class_t *class, const char *name)
class_ivar_expr (class_type_t *class_type, const char *name)
{
struct_field_t *ivar;
class_t *c;
class_t *c, *class;
if (!class)
if (!class_type)
return 0;
if (class_type->is_class) {
class = class_type->c.class;
} else {
class = class_type->c.category->class;
}
ivar = struct_find_field (class->ivars, name);
if (!ivar) {
for (c = class->super_class; c; c = c->super_class) {
@ -336,16 +335,22 @@ class_ivar_expr (class_t *class, const char *name)
}
method_t *
class_find_method (class_t *class, method_t *method)
class_find_method (class_type_t *class_type, method_t *method)
{
methodlist_t *methods;
method_t *m;
dstring_t *sel;
const char *class_name;
const char *category_name = 0;
if (class->categories)
methods = class->categories->methods;
else
methods = class->methods;
if (!class_type->is_class) {
methods = class_type->c.category->methods;
category_name = class_type->c.category->name;
class_name = class_type->c.category->class->name;
} else {
methods = class_type->c.class->methods;
class_name = class_type->c.class->name;
}
for (m = methods->head; m; m = m->next)
if (method_compare (method, m))
return m;
@ -353,8 +358,8 @@ class_find_method (class_t *class, method_t *method)
selector_name (sel, (keywordarg_t *)method->selector);
warning (0, "%s method %s not in %s%s",
method->instance ? "instance" : "class",
sel->str, class->name,
class->categories ? va (" (%s)", class->categories->name) : "");
sel->str, class_name,
category_name ? va (" (%s)", category_name) : "");
dstring_delete (sel);
return method;
}
@ -423,10 +428,10 @@ class_check_ivars (class_t *class, struct type_s *ivars)
class->ivars = ivars;
}
class_t *
category_t *
get_category (const char *class_name, const char *category_name, int create)
{
category_t *c;
category_t *category;
class_t *class;
if (!category_hash) {
@ -437,41 +442,76 @@ get_category (const char *class_name, const char *category_name, int create)
class = get_class (class_name, 0);
if (!class) {
error (0, "undefined class %s", class_name);
return get_class (0, 1);
return 0;
}
if (class_name && category_name) {
class_t _c = {0, category_name, class};
category_t _c = {0, category_name, class};
c = Hash_FindElement (category_hash, &_c);
if (c) {
category_t **cat = &class->categories;
category_t *t;
while (*cat != c)
cat = &(*cat)->next;
t = *cat;
*cat = (*cat)->next;
t->next = class->categories;
class->categories = t;
return class;
}
if (!create)
return 0;
category = Hash_FindElement (category_hash, &_c);
if (category || !create)
return category;
}
c = calloc (sizeof (category_t), 1);
c->next = class->categories;
class->categories = c;
c->name = category_name;
c->class = class;
category = calloc (sizeof (category_t), 1);
category->next = class->categories;
class->categories = category;
category->name = category_name;
category->class = class;
category->class_type.is_class = 0;
category->class_type.c.category = category;
if (class_name && category_name)
Hash_AddElement (category_hash, c);
return c->class;
Hash_AddElement (category_hash, category);
return category;
}
void
category_add_methods (category_t *category, methodlist_t *methods)
{
if (!methods)
return;
if (!category->methods)
category->methods = new_methodlist ();
*category->methods->tail = methods->head;
category->methods->tail = methods->tail;
free (methods);
}
void
category_add_protocol_methods (category_t *category, expr_t *protocols)
{
expr_t *e;
protocol_t *p;
type_t *type;
if (!protocol_hash)
protocol_hash = Hash_NewTable (1021, protocol_get_key, 0, 0);
if (!category->methods)
category->methods = new_methodlist ();
type = category->class->type;
for (e = protocols; e; e = e->next) {
methodlist_t *methods = category->methods;
method_t **m = methods->tail;
if (!(p = get_protocol (e->e.string_val, 0))) {
error (e, "undefined protocol `%s'", e->e.string_val);
continue;
}
copy_methods (methods, p->methods);
while (*m) {
(*m)->params->type = type;
m = &(*m)->next;
}
}
}
def_t *
class_pointer_def (class_t *class)
{
def_t *def;
class_type_t class_type = {1, {0}};
class_type.c.class = class;
def = get_def (class->type,
va ("_OBJ_CLASS_POINTER_%s", class->name),
@ -480,7 +520,7 @@ class_pointer_def (class_t *class)
return def;
def->initialized = def->constant = 1;
if (!class->def)
class->def = class_def (class, 1);
class->def = class_def (&class_type, 1);
if (!class->def->external)
G_INT (def->ofs) = class->def->ofs;
reloc_def_def (class->def, def->ofs);
@ -490,9 +530,8 @@ class_pointer_def (class_t *class)
void
class_finish_module (void)
{
class_t **classes = 0;
class_t **categories = 0;
class_t **t;
class_t **classes = 0, **cl;
category_t **categories = 0, **ca;
int num_classes = 0;
int num_categories = 0;
int i;
@ -509,14 +548,14 @@ class_finish_module (void)
if (class_hash) {
classes = (class_t **) Hash_GetList (class_hash);
for (t = classes; *t; t++)
if ((*t)->def && !(*t)->def->external)
for (cl = classes; *cl; cl++)
if ((*cl)->def && !(*cl)->def->external)
num_classes++;
}
if (category_hash) {
categories = (class_t **) Hash_GetList (category_hash);
for (t = categories; *t; t++)
if ((*t)->def && !(*t)->def->external)
categories = (category_t **) Hash_GetList (category_hash);
for (ca = categories; *ca; ca++)
if ((*ca)->def && !(*ca)->def->external)
num_categories++;
}
if (!num_classes && !num_categories)
@ -534,18 +573,18 @@ class_finish_module (void)
symtab->cat_def_cnt = num_categories;
def_ptr = symtab->defs;
if (classes) {
for (t = classes; *t; t++) {
if ((*t)->def && !(*t)->def->external) {
reloc_def_def ((*t)->def, POINTER_OFS (def_ptr));
*def_ptr++ = (*t)->def->ofs;
for (cl = classes; *cl; cl++) {
if ((*cl)->def && !(*cl)->def->external) {
reloc_def_def ((*cl)->def, POINTER_OFS (def_ptr));
*def_ptr++ = (*cl)->def->ofs;
}
}
}
if (categories) {
for (t = categories; *t; t++) {
if ((*t)->def && !(*t)->def->external) {
reloc_def_def ((*t)->def, POINTER_OFS (def_ptr));
*def_ptr++ = (*t)->def->ofs;
for (ca = categories; *ca; ca++) {
if ((*ca)->def && !(*ca)->def->external) {
reloc_def_def ((*ca)->def, POINTER_OFS (def_ptr));
*def_ptr++ = (*ca)->def->ofs;
}
}
}
@ -639,15 +678,6 @@ new_protocollist (void)
return protocollist;
}
void
add_protocol (protocollist_t *protocollist, protocol_t *protocol)
{
protocollist->list = realloc (protocollist->list,
(protocollist->count + 1)
* sizeof (protocollist_t));
protocollist->list[protocollist->count++] = protocol;
}
def_t *
emit_protocol (protocol_t *protocol)
{

5
tools/qfcc/source/expr.c
View file

@ -1181,8 +1181,11 @@ field_expr (expr_t *e1, expr_t *e2)
case ev_object:
case ev_class:
if (e2->type == ex_name) {
int protected;
class = t1->aux_type->class;
field = class_find_ivar (class, current_class != class,
protected = class_access (current_class, class);
field = class_find_ivar (class, protected,
e2->e.string_val);
if (!field)
return new_error_expr ();

15
tools/qfcc/source/method.c
View file

@ -104,16 +104,25 @@ add_method (methodlist_t *methodlist, method_t *method)
}
def_t *
method_def (class_t *class, method_t *method)
method_def (class_type_t *class_type, method_t *method)
{
dstring_t *str = dstring_newstr ();
def_t *def;
char *s;
const char *class_name;
const char *category_name = "";
if (class_type->is_class) {
class_name = class_type->c.class->name;
} else {
class_name = class_type->c.category->class->name;
category_name = class_type->c.category->name;
}
dsprintf (str, "_%c_%s_%s_%s",
method->instance ? 'i' : 'c',
class->name,
class->categories ? class->categories->name : "",
class_name,
category_name,
method->name);
str->str[--str->size - 1] = 0;
for (s = str->str; *s; s++)

60
tools/qfcc/source/qc-parse.y
View file

@ -107,6 +107,8 @@ expr_t *argv_expr (void);
struct param_s *param;
struct method_s *method;
struct class_s *class;
struct category_s *category;
struct class_type_s *class_type;
struct protocol_s *protocol;
struct keywordarg_s *keywordarg;
struct methodlist_s *methodlist;
@ -159,8 +161,9 @@ expr_t *argv_expr (void);
%type <expr> protocolrefs
%type <keywordarg> messageargs keywordarg keywordarglist selectorarg
%type <keywordarg> keywordnamelist keywordname
%type <class> class_name new_class_name class_with_super new_class_with_super
%type <class> category_name new_category_name
%type <class> class_name new_class_name class_with_super new_class_with_super
%type <class> classdef
%type <category> category_name new_category_name
%type <protocol> protocol_name
%type <methodlist> methodprotolist methodprotolist2
%type <type> ivar_decl_list
@ -172,7 +175,7 @@ expr_t *argv_expr (void);
function_t *current_func;
param_t *current_params;
expr_t *current_init;
class_t *current_class;
class_type_t *current_class;
expr_t *local_expr;
expr_t *break_label;
expr_t *continue_label;
@ -938,7 +941,6 @@ new_class_name
error (0, "redefinition of `%s'", $1);
$$ = get_class (0, 1);
}
current_class = $$;
}
;
@ -956,7 +958,6 @@ new_class_with_super
{
$1->super_class = $3;
$$ = $1;
current_class = $$;
}
;
@ -979,7 +980,6 @@ new_category_name
error (0, "redefinition of category `%s (%s)'", $1, $3);
$$ = get_category (0, 0, 1);
}
current_class = $$;
}
;
@ -999,38 +999,42 @@ protocol_name
classdef
: INTERFACE new_class_name
protocolrefs { class_add_protocol_methods ($2, $3);}
'{' ivar_decl_list '}' { class_add_ivars ($2, $6); }
methodprotolist { class_add_methods ($2, $9); }
'{' { $$ = $2; }
ivar_decl_list '}' { class_add_ivars ($2, $7); $$ = $2; }
methodprotolist { class_add_methods ($2, $10); }
END { current_class = 0; }
| INTERFACE new_class_name
protocolrefs { class_add_protocol_methods ($2, $3);}
protocolrefs { class_add_protocol_methods ($2, $3); $$ = $2; }
methodprotolist { class_add_methods ($2, $5); }
END { current_class = 0; }
| INTERFACE new_class_with_super
protocolrefs { class_add_protocol_methods ($2, $3);}
'{' ivar_decl_list '}' { class_add_ivars ($2, $6); }
methodprotolist { class_add_methods ($2, $9); }
'{' { $$ = $2; }
ivar_decl_list '}' { class_add_ivars ($2, $7); $$ = $2; }
methodprotolist { class_add_methods ($2, $10); }
END { current_class = 0; }
| INTERFACE new_class_with_super
protocolrefs { class_add_protocol_methods ($2, $3);}
protocolrefs { class_add_protocol_methods ($2, $3); $$ = $2; }
methodprotolist { class_add_methods ($2, $5); }
END { current_class = 0; }
| INTERFACE new_category_name
protocolrefs { class_add_protocol_methods ($2, $3);}
methodprotolist { class_add_methods ($2, $5); }
protocolrefs { category_add_protocol_methods ($2, $3); $$ = $2->class;}
methodprotolist { category_add_methods ($2, $5); }
END { current_class = 0; }
| IMPLEMENTATION class_name { class_begin ($2); }
'{' ivar_decl_list '}' { class_check_ivars ($2, $5); }
| IMPLEMENTATION class_name { class_begin ($2); }
| IMPLEMENTATION class_with_super { class_begin ($2); }
'{' ivar_decl_list '}' { class_check_ivars ($2, $5); }
| IMPLEMENTATION class_with_super { class_begin ($2); }
| IMPLEMENTATION category_name { class_begin ($2); }
| IMPLEMENTATION class_name { class_begin (&$2->class_type); }
'{' { $$ = $2; }
ivar_decl_list '}' { class_check_ivars ($2, $6); }
| IMPLEMENTATION class_name { class_begin (&$2->class_type); }
| IMPLEMENTATION class_with_super { class_begin (&$2->class_type); }
'{' { $$ = $2; }
ivar_decl_list '}' { class_check_ivars ($2, $6); }
| IMPLEMENTATION class_with_super { class_begin (&$2->class_type); }
| IMPLEMENTATION category_name { class_begin (&$2->class_type); }
;
protocoldef
: PROTOCOL protocol_name
protocolrefs { protocol_add_protocol_methods ($2, $3); }
protocolrefs { protocol_add_protocol_methods ($2, $3); $<class>$ = 0; }
methodprotolist { protocol_add_methods ($2, $5); }
END
;
@ -1045,9 +1049,9 @@ ivar_decl_list
{
current_visibility = vis_protected;
current_ivars = new_struct (0);
if (current_class->super_class)
if ($<class>0->super_class)
new_struct_field (current_ivars,
current_class->super_class->ivars, 0,
$<class>0->super_class->ivars, 0,
vis_private);
}
ivar_decl_list_2
@ -1158,10 +1162,10 @@ methodprotolist
;
methodprotolist2
: methodproto
: { } methodproto
{
$$ = new_methodlist ();
add_method ($$, $1);
add_method ($$, $2);
}
| methodprotolist2 methodproto
{
@ -1180,8 +1184,8 @@ methodproto
| '-' methoddecl ';'
{
$2->instance = 1;
if (current_class)
$2->params->type = current_class->type;
if ($<class>-1)
$2->params->type = $<class>-1->type;
$$ = $2;
}
;

8
tools/qfcc/source/type.c
View file

@ -235,8 +235,6 @@ array_type (type_t *aux, int size)
void
print_type (type_t *type)
{
class_t *class;
if (!type) {
printf (" (null)");
return;
@ -275,11 +273,7 @@ print_type (type_t *type)
break;
case ev_object:
case ev_class:
class = type->class;
printf (" %s%s",
class->name,
class->categories ? va (" (%s)", class->categories->name)
: "");
printf (" %s", type->class->name);
break;
case ev_struct:
printf (" %s %s", pr_type_name[type->type], type->name);