The Machine Perception Toolbox

[Introduction]- [News]- [Download]- [Screenshots]- [Manual (pdf)]- [Forums]- [API Reference]- [Repository ]

 

Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

class.c

Go to the documentation of this file.
00001 
00002 #include "class.h"
00003 #include "strings.h"
00004 #include "variable.h"
00005 #include "frames.h"
00006 #include "rules.h"
00007 #include "newstr.h"
00008 
00009 #include "hash.h"
00010 
00011 static struct hash* classes = 0;
00012 
00013 static void check_defined(LIST* class_names)
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 }
00023 
00024 static char* class_module_name(char* declared_name)
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 }
00038 
00039 struct import_base_data {
00040     char* base_name;
00041     module_t* base_module;
00042     module_t* class_module;
00043 };
00044 
00045 static void import_base_rule(void* r_, void* d_)
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 }
00073 
00078 static void import_base_rules(module_t* class, char* base)
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 }
00091 
00092 char* make_class_module(LIST* xname, LIST* bases, FRAME* frame)
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 }

Generated on Mon Nov 8 17:07:31 2004 for MPT by  doxygen 1.3.9.1