--- parser3/src/include/Attic/pa_vclass.h	2001/02/23 18:12:44	1.7
+++ parser3/src/include/Attic/pa_vclass.h	2001/03/08 17:14:51	1.24
@@ -1,88 +1,117 @@
 /*
-  $Id: pa_vclass.h,v 1.7 2001/02/23 18:12:44 paf Exp $
+  $Id: pa_vclass.h,v 1.24 2001/03/08 17:14:51 paf Exp $
 */
 
 #ifndef PA_VCLASS_H
 #define PA_VCLASS_H
 
-#include "pa_value.h"
+#include "pa_valiased.h"
 #include "pa_vhash.h"
+#include "pa_vstring.h"
+#include "pa_vjunction.h"
 
-class VClass : public Value {
+#define CLASS_NAME "CLASS"
+#define BASE_NAME "BASE"
+
+class VClass : public VAliased {
 public: // Value
 	
 	// 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
-	Value *get_element(const String& name) {
-		// $STATIC=STATIC hash
-		if(name==STATIC_NAME)
-			return &STATIC;
-
-		// $method=junction(this+method)
-		if(Method *method=static_cast<Method *>(methods.get(name))) {
-			Pool& p=pool();
-			Junction *j=new(p) Junction(p, 
-				method,
-				this,this,this,0);
-
-			return NEW VJunction(j);
-		}
-
-		// $field=STATIC.field
-		return STATIC.get_element(name);
+	Value *get_element(const String& aname) {
+		// $NAME=my name
+		if(aname==NAME_NAME)
+			return NEW VString(fclass_alias->name());
+		// $CLASS=my class=myself
+		if(aname==CLASS_NAME)
+			return fclass_alias;
+		// $BASE=my parent
+		if(aname==BASE_NAME)
+			return fclass_alias->base();
+		// $method=junction(self+class+method)
+		if(Junction *junction=get_junction(*this, aname))
+			return NEW VJunction(*junction);
+		// $field=static field
+		return get_field(aname);
 	}
 
 	// object_class, operator_class: (field)=value - static values only
 	void put_element(const String& name, Value *value) {
-		STATIC.put_element(name, value);
+		set_field(name, value);
 	}
 
 	// object_class, object_instance: object_class
-	VClass *get_class() { return this; /*TODO: think when?*/ }
-
-	// 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;
-	}
+	VClass *get_class() { return this; }
 
 public: // usage
-	
-	const String& name() const { return *fname; }
 
-public: // creation
+	VClass(Pool& apool) : VAliased(apool, *this), 
+		fbase(0),
+		ffields(*new(apool) Hash(apool)),
+		fmethods(*new(apool) Hash(apool)) {
+	}
 
-	VClass(Pool& apool, String& aname, const Array& immediate_parents) : 
-		Value(apool), 
-		fname(&aname),
-		STATIC(apool),
-		methods(apool),
-		parents(apool),
-		parents_hash(apool) {
-		// TODO: monkey immediate_parents 
-			// fill parents & parents_hash
+	VClass(Pool& apool, 
+		VClass *abase, Hash& afields, Hash& amethods) : VAliased(apool, *this), 
+
+		fbase(abase),
+		ffields(afields),
+		fmethods(amethods) {
 	}
-	
-	void rename(String *aname) { fname=aname; }
 
 	void add_method(const String& name, Method& method) {
-		methods.put(name, &method);
+		fmethods.put(name, &method);
 	}
-	void add_parent(VClass& parent) {
-		parents+=&parent;
-		parents_hash.put(parent.name(), &parent);
+//	Hash& methods() { return fmethods; }
+	
+	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:
 
-	String *fname;
-	VHash STATIC;
-	Hash methods;
-	Array parents;  Hash parents_hash;
+	Value *get_field(const String& name) {
+		Value *result=static_cast<Value *>(ffields.get(name));
+		if(!result && fbase)
+			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