--- parser3/src/include/Attic/pa_value.h	2001/02/23 21:59:07	1.21
+++ parser3/src/include/Attic/pa_value.h	2001/03/09 08:19:47	1.48
@@ -1,5 +1,6 @@
+
 /*
-  $Id: pa_value.h,v 1.21 2001/02/23 21:59:07 paf Exp $
+  $Id: pa_value.h,v 1.48 2001/03/09 08:19:47 paf Exp $
 */
 
 /*
@@ -12,65 +13,83 @@
 #include "pa_pool.h"
 #include "pa_string.h"
 #include "pa_array.h"
-//#include "pa_voperator.h"
+#include "pa_exception.h"
+
+#define NAME_NAME "NAME"
 
 class Value;
 class VClass;
-//class VOperator;
 class Junction;
 class WContext;
+class VAliased;
+class Request;
+
+typedef void (*Native_code_ptr)(Request& request, Array *params);
 
 class Method : public Pooled {
 public:
 	const String& name;
-	Array& params_names;
-	Array& locals_names;
-	Array& code;
+	// either numbered params // for native-code methods = operators
+	int min_numbered_params_count, max_numbered_params_count;
+	// or named params&locals // for parser-code methods
+	Array *params_names;  Array *locals_names;
+	// the Code
+	const Array *parser_code;/*OR*/Native_code_ptr native_code;
 
 	Method(
 		Pool& apool,
 		const String& aname,
-		Array& aparams_names,
-		Array& alocals_names,
-		Array& acode) : 
+		int amin_numbered_params_count, int amax_numbered_params_count,
+		Array *aparams_names, Array *alocals_names,
+		const Array *aparser_code, Native_code_ptr anative_code) : 
 
 		Pooled(apool),
 		name(aname),
-		params_names(aparams_names),
-		locals_names(alocals_names),
-		code(acode) {
+		min_numbered_params_count(amin_numbered_params_count),
+		max_numbered_params_count(amax_numbered_params_count),
+		params_names(aparams_names), locals_names(alocals_names),
+		parser_code(aparser_code), native_code(anative_code) {
 	}
-};
 
-/*
-class Operator : public Method {
-	// operator module static vars stored in there
-	VOperator_class *self;
+	void check_actual_numbered_params(Array *actual_numbered_params) {
+		int actual_count=actual_numbered_params?actual_numbered_params->size():0;
+		if(actual_count<min_numbered_params_count) // not proper count? bark
+			THROW(0, 0,
+				&name,
+				"native method accepts minimum %d parameters", 
+					min_numbered_params_count);
+
+	}
 };
-*/
 
 class Junction : public Pooled {
 public:
 
 	Junction(Pool& apool,
-		Method *amethod,
+		Value& aself,
+		VClass *avclass, Method *amethod,
 		Value *aroot,
-		Value *aself,
 		Value *arcontext,
-		Array *acode) : Pooled(apool),
+		WContext *awcontext,
+		const Array *acode) : Pooled(apool),
 		
-		method(amethod),
-		root(aroot),
 		self(aself),
+		vclass(avclass), method(amethod),
+		root(aroot),
 		rcontext(arcontext),
+		wcontext(awcontext),
 		code(acode) {
 	}
 
-	Method *method;
+	// always present
+	Value& self;
+	// either these // so called 'method-junction'
+	VClass *vclass;  Method *method;
+	// or these are present // so called 'code-junction'
 	Value *root;
-	Value *self;
 	Value *rcontext;
-	Array *code;
+	WContext *wcontext;
+	const Array *code;
 };
 
 class Value : public Pooled {
@@ -78,75 +97,88 @@ public: // Value
 
 	// all: for error reporting after fail(), etc
 	virtual const char *type() const =0;
-	const String *name() const { return fname; }
+	String& name() const { return *fname; }
+
+	// unknown: false
+	// others: true
+	virtual bool get_defined() { return true; }
+	// string: fvalue as VDouble
+	// bool: this
+	// double: this
+	// int: this
+	virtual Value *get_expr_result() { failed("getting expression result of '%s'"); return 0; }
 
 	// string: value
 	// unknown: ""
+	// double: value
+	// bool: must be 0: so in ^if(1>2) it would'nt become "FALSE" string which is 'true'
 	// others: 0
 	virtual String *get_string() { return 0; }
 	
 	// string: value
-	virtual void put_string(String *astring) { failed("storing string to %s:%s"); }
+	// double: value
+	// integer: finteger
+	// bool: value
+	virtual double get_double() { failed("getting numerical value of '%s'"); return 0; }
+
+	// unknown: false
+	// bool: value
+	// double: 0 or !0
+	// string: empty or not
+	// hash: size!=0
+	// TODO table: count!=0
+	// others: true
+	virtual bool get_bool() { return true; }
 
 	// junction: auto_calc,root,self,rcontext,wcontext, code
-	virtual Junction *get_junction() { failed("can not call '%s', is not a method or a junction (it is '%s')"); return 0; }
+	virtual Junction *get_junction() { return 0; }
 
 	// hash: (key)=value
 	// object_class: (field)=STATIC.value;(STATIC)=hash;(method)=method_ref with self=object_class
-	// object_instance: (field)=value;(STATIC)=hash;(method)=method_ref
+	// object_instance: (field)=value;(CLASS)=vclass;(method)=method_ref
 	// operator_class: (field)=value - static values only
-	// wcontext: transparent
-	// frame: my or self_transparent
-	virtual Value *get_element(const String& name) { failed("getting element from %s:%s"); return 0; }
+	// codeframe: wcontext_transparent
+	// methodframe: my or self_transparent
+	virtual Value *get_element(const String& name) { failed("type is '%s', can not get element from it"); return 0; }
 	
 	// hash: (key)=value
 	// object_class, operator_class: (field)=value - static values only
-	// wcontext: transparent
-	// frame: my or self_transparent
-	virtual void put_element(const String& name, Value *value) { failed("putting element to %s:%s"); }
+	// object_instance: (field)=value
+	// codeframe: wcontext_transparent
+	// methodframe: my or self_transparent
+	virtual void put_element(const String& name, Value *value) { failed("type is '%s', can not put element to it"); }
 
 	// object_class, object_instance: object_class
-	// frame: transparent
-	// wcontext: transparent
+	// wcontext: none yet | transparent
 	virtual VClass *get_class() { return 0; }
 
-	// object_class: true when this class is this or derived from 'ancestor'
-	// frame: transparent
+	// valiased: this
 	// wcontext: transparent
-	virtual bool is_or_derived_from(VClass& ancestor) { failed("thoghts of ancestors of %s:%s"); return false; }
+	// methodframe: self_transparent
+	virtual VAliased *get_aliased() { return 0; }
 
 public: // usage
 
-	Value(Pool& apool) : Pooled(apool), fname(0) {}
+	Value(Pool& apool) : Pooled(apool), fname(new(apool) String(apool)) {
+		fname->APPEND_CONST("unnamed");
+	}
 
-	void set_name(const String& aname) { fname=&aname; }
+	void set_name(String& aname) { fname=&aname; }
 
 	String& as_string() {
 		String *result=get_string(); 
 		if(!result)
-			failed("getting string of %s:%s");
+			failed("getting string of '%s'");
 		return *result;
 	}
 
 private:
 
-	const String *fname;
+	String *fname;
 
 private: 
 
-	void failed(char *action);
+	void failed(char *action) const;
 };
 
-/*
-descendants:
-	text:+ value:String
-    hash:+ keys&values:Hash
-    table:+ columns_order:Array, columns:Hash, rows:Array
-    object_class:+ STATIC:Hash, methods:Hash
-    object_instance:+ object_class, fields:Hash
-    method_ref:+ self:Value/object_class, method:String
-    method_self_n_params_n_locals:+ self:Value/object_class[1st try], params_locals&values:Hash[2nd try]
-	junction:+ self:Value, code:String
-*/
-
 #endif