[BACK]Return to pa_vclass.h CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / include

Diff for /parser3/src/include/Attic/pa_vclass.h between versions 1.9 and 1.25.2.1

version 1.9, 2001/02/24 08:28:35 version 1.25.2.1, 2001/03/08 17:39:08
Line 5 Line 5
 #ifndef PA_VCLASS_H  #ifndef PA_VCLASS_H
 #define PA_VCLASS_H  #define PA_VCLASS_H
   
 #include "pa_value.h"  #include "pa_valiased.h"
 #include "pa_vhash.h"  #include "pa_vhash.h"
   #include "pa_vstring.h"
 #include "pa_vjunction.h"  #include "pa_vjunction.h"
   
 class VClass : public Value {  #define CLASS_NAME "CLASS"
   #define BASE_NAME "BASE"
   
   class VClass : public VAliased {
 public: // Value  public: // Value
                   
         // all: for error reporting after fail(), etc          // all: for error reporting after fail(), etc
         const char *type() const { return "Class"; }          const char *type() const { return "class"; }
   
         // object_class: (field)=STATIC.value;(STATIC)=hash;(method)=method_ref with self=object_class          // object_class: (field)=STATIC.value;(STATIC)=hash;(method)=method_ref with self=object_class
         Value *get_element(const String& name) {          Value *get_element(const String& aname);
                 // $STATIC=STATIC hash  
                 if(name==STATIC_NAME)  
                         return &STATIC;  
   
                 // $method=junction(this+method)  
                 if(Method *method=static_cast<Method *>(methods.get(name))) {  
                         Junction& j=*NEW Junction(pool(),   
                                 method,  
                                 this,0,0,0);  
   
                         return NEW VJunction(j);  
                 }  
   
                 // $field=STATIC.field  
                 return STATIC.get_element(name);  
         }  
   
         // object_class, operator_class: (field)=value - static values only          // object_class, operator_class: (field)=value - static values only
         void put_element(const String& name, Value *value) {          void put_element(const String& name, Value *value);
                 STATIC.put_element(name, value);  
         }  
   
         // object_class, object_instance: object_class          // object_class, object_instance: object_class
         VClass *get_class() { return this; /*TODO: think when?*/ }          VClass *get_class() { return this; }
   
         // object_class: true when this class is derived from 'ancestor'  
         bool is_or_derived_from(VClass& ancestor) {  
                 if(this==&ancestor)  
                         return true; // it's me  
   
                 return parents_hash.get(ancestor.name())!=0;  
         }  
   
 public: // usage  public: // usage
           
         const String& name() const { return *fname; }  
   
 public: // creation  
   
         VClass(Pool& apool, String& aname, const Array& immediate_parents) :           VClass(Pool& apool) : VAliased(apool, *this), 
                 Value(apool),                   fbase(0),
                 fname(&aname),                  ffields(apool),
                 STATIC(apool),                  fmethods(apool) {
                 methods(apool),  
                 parents(apool),  
                 parents_hash(apool) {  
                 // TODO: monkey immediate_parents   
                         // fill parents & parents_hash  
         }          }
           
         void rename(String *aname) { fname=aname; }  
   
         void add_method(const String& name, Method& method) {          void add_method(const String& name, Method& method) {
                 methods.put(name, &method);                  fmethods.put(name, &method);
         }          }
         void add_parent(VClass& parent) {  //      Hash& methods() { return fmethods; }
                 parents+=&parent;          
                 parents_hash.put(parent.name(), &parent);          void set_base(VClass& abase) {
                   // remember the guy
                   fbase=&abase;
           }
           VClass *base() { return fbase; }
   
           bool is_or_derived_from(VClass& vclass) {
                   return 
                           this==&vclass || 
                           fbase && fbase->is_or_derived_from(vclass);
           }
   
           Junction *get_junction(VAliased& self, const String& name) {
                   if(Method *method=static_cast<Method *>(fmethods.get(name)))
                           return NEW Junction(pool(), self, this, method, 0,0,0,0);
                   if(fbase)
                           return fbase->get_junction(self, name);
                   return 0; 
         }          }
   
 private:  private:
   
         String *fname;          Value *get_field(const String& name) {
         VHash STATIC;                  Value *result=static_cast<Value *>(ffields.get(name));
         Hash methods;                  if(!result && fbase)
         Array parents;  Hash parents_hash;                          result=fbase->get_field(name);
                   return result;
           }
                   
           void set_field(const String& name, Value *value) {
                   if(fbase && fbase->replace_field(name, value))
                           return;
   
                   ffields.put(name, value);
           }
           bool replace_field(const String& name, Value *value) {
                   return 
                           (fbase && fbase->replace_field(name, value)) ||
                           ffields.put_replace(name, value);
           }
           
   private:
   
           VClass *fbase;
           Hash ffields;
           Hash fmethods;
 };  };
   
 #endif  #endif
Removed from v.1.9  
changed lines
  Added in v.1.25.2.1

E-mail: