class.c File Reference

#include "class.h"
#include "strings.h"
#include "variable.h"
#include "frames.h"
#include "rules.h"
#include "newstr.h"
#include "hash.h"

Include dependency graph for class.c:

Go to the source code of this file.

Classes

struct import_base_data

Functions

void check_defined (LIST *class_names)

char * class_module_name (char *declared_name)

void import_base_rule (void *r_, void *d_)

void import_base_rules (module_t *class, char *base)

For each exported rule 'n', declared in class module for base, imports that rule in 'class' as 'n' and as 'base.n'.

char * make_class_module (LIST *xname, LIST *bases, FRAME *frame)

Variables

hash * classes = 0

Function Documentation

void check_defined ( LIST * class_names ) [static]

Definition at line 13 of file class.c.
References classes, hashcheck, HASHDATA, LIST, _list::next, p, and _list::string.
Referenced by make_class_module().
00014 { 00015 for (; class_names; class_names = class_names->next) { 00016 char** p = &class_names->string; 00017 if (!hashcheck(classes, (HASHDATA**)&p)) { 00018 printf("Class %s is not defined\n", class_names->string); 00019 abort(); 00020 } 00021 } 00022 }

char* class_module_name ( char * declared_name ) [static]

Definition at line 24 of file class.c.
References newstr(), string_append(), string_free(), string_new(), and string::value.
Referenced by import_base_rules(), and make_class_module().
00025 { 00026 string name[1]; 00027 char* result; 00028 00029 string_new(name); 00030 string_append(name, "class@"); 00031 string_append(name, declared_name); 00032 00033 result = newstr(name->value); 00034 string_free(name); 00035 00036 return result; 00037 }

Here is the call graph for this function:

void import_base_rule ( void * r_,

void * d_

) [static]

Definition at line 45 of file class.c.
References module_t::class_module, d, _rule::exported, import_rule(), _rule::module, _rule::name, r, RULE, string_append(), string_free(), string_new(), string_push_back(), and string::value.
Referenced by import_base_rules().
00046 { 00047 RULE* r = (RULE*)r_; 00048 RULE* ir1; 00049 RULE* ir2; 00050 struct import_base_data* d = (struct import_base_data*)d_; 00051 string qualified_name[1]; 00052 int basename_lenght = strlen(d->base_name)+1; 00053 00054 string_new(qualified_name); 00055 string_append(qualified_name, d->base_name); 00056 string_push_back(qualified_name, '.'); 00057 string_append(qualified_name, r->name); 00058 00059 ir1 = import_rule(r, d->class_module, r->name); 00060 ir2 = import_rule(r, d->class_module, qualified_name->value); 00061 00062 /* Copy 'exported' flag. */ 00063 ir1->exported = ir2->exported = r->exported; 00064 00065 /* If we're importing class method, localize it. */ 00066 if (r->module == d->base_module 00067 || r->module->class_module && r->module->class_module == d->base_module) { 00068 ir1->module = ir2->module = d->class_module; 00069 } 00070 00071 string_free(qualified_name); 00072 }

Here is the call graph for this function:

void import_base_rules ( module_t * class,

char * base

) [static]

For each exported rule 'n', declared in class module for base, imports that rule in 'class' as 'n' and as 'base.n'.
Imported rules are localized and marked as exported.
Definition at line 78 of file class.c.
References bindmodule(), class_module_name(), d, hashenumerate(), import_base_rule(), import_module(), imported_modules(), and module_t::rules.
Referenced by make_class_module().
00079 { 00080 module_t* base_module = bindmodule(class_module_name(base)); 00081 struct import_base_data d; 00082 d.base_name = base; 00083 d.base_module = base_module; 00084 d.class_module = class; 00085 00086 if (base_module->rules) 00087 hashenumerate(base_module->rules, import_base_rule, &d); 00088 00089 import_module( imported_modules(base_module), class ); 00090 }

Here is the call graph for this function:

char* make_class_module ( LIST * xname,

LIST * bases,

FRAME * frame

)

Definition at line 92 of file class.c.
References bindmodule(), check_defined(), class_module_name(), classes, enter_module(), exit_module(), FRAME, hashcheck, HASHDATA, hashenter, hashinit(), import_base_rules(), LIST, frame::module, _list::next, _list::string, var_set(), and VAR_SET.
Referenced by compile_class().
00093 { 00094 char* name = class_module_name(xname->string); 00095 char** pp = &xname->string; 00096 module_t* class_module = 0; 00097 module_t* outer_module = frame->module; 00098 00099 if (!classes) 00100 classes = hashinit(sizeof(char*), "classes"); 00101 00102 00103 if (hashcheck(classes, (HASHDATA**)&pp)) { 00104 printf("Class %s already defined\n", xname->string); 00105 abort(); 00106 } else { 00107 hashenter(classes, (HASHDATA**)&pp); 00108 } 00109 check_defined(bases); 00110 00111 class_module = bindmodule(name); 00112 00113 exit_module( outer_module ); 00114 enter_module( class_module ); 00115 00116 var_set("__name__", xname, VAR_SET); 00117 var_set("__bases__", bases, VAR_SET); 00118 00119 exit_module( class_module ); 00120 enter_module( outer_module ); 00121 00122 for(; bases; bases = bases->next) 00123 import_base_rules(class_module, bases->string); 00124 00125 00126 00127 return name; 00128 }

Here is the call graph for this function:

Variable Documentation

struct hash* classes = 0 [static]

Definition at line 11 of file class.c.
Referenced by check_defined(), and make_class_module().

Generated on Mon Nov 8 17:07:56 2004 for MPT by

1.3.9.1


Classes
struct	import_base_data
Functions
void	check_defined (LIST *class_names)
char *	class_module_name (char *declared_name)
void	import_base_rule (void r_, void d_)
void	import_base_rules (module_t class, char base)
	For each exported rule 'n', declared in class module for base, imports that rule in 'class' as 'n' and as 'base.n'.
char *	make_class_module (LIST xname, LIST bases, FRAME *frame)
Variables
hash *	classes = 0