--- parser3/src/classes/hash.C	2003/02/06 11:56:31	1.54.2.8
+++ parser3/src/classes/hash.C	2003/03/21 13:42:26	1.54.2.13.2.5
@@ -5,7 +5,7 @@
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
-static const char* IDENT_HASH_C="$Date: 2003/02/06 11:56:31 $";
+static const char* IDENT_HASH_C="$Date: 2003/03/21 13:42:26 $";
 
 #include "classes.h"
 #include "pa_vmethod_frame.h"
@@ -22,7 +22,7 @@ static const char* IDENT_HASH_C="$Date:
 
 class MHash: public Methoded {
 public: // VStateless_class
-	ValuePtr create_new_value() { return ValuePtr(new VHash()); }
+	Value* create_new_value() { return Value*(new VHash()); }
 
 public:
 	MHash();
@@ -32,14 +32,14 @@ public: // Methoded
 
 // global variable
 
-MethodedPtr hash_class(new MHash);
+DECLARE_CLASS_VAR(hash, new MHash, 0);
 
 // methods
 
 #ifndef DOXYGEN
 class Hash_sql_event_handlers: public SQL_Driver_query_event_handlers {
-	StringPtr method_name;
-	StringPtr statement_string; const char* statement_cstr;
+	const String& method_name;
+	const String& statement_string; const char* statement_cstr;
 	bool distinct;
 	HashStringValue& rows_hash;
 	HashStringValue* row_hash;
@@ -47,20 +47,21 @@ class Hash_sql_event_handlers: public SQ
 	ArrayString columns;
 	int row_index;
 public:
-	Hash_sql_event_handlers(StringPtr amethod_name,
-		StringPtr astatement_string, const char* astatement_cstr,
+	Hash_sql_event_handlers(const String& amethod_name,
+		const String& astatement_string, const char* astatement_cstr,
 		bool adistinct,
 		HashStringValue& arows_hash): 
 		method_name(amethod_name),
-		statement_string(astatement_string),
-		statement_cstr(astatement_cstr),
+		statement_string(astatement_string), statement_cstr(astatement_cstr),
 		distinct(adistinct),
 		rows_hash(arows_hash),
-		row_index(0) {
+		row_hash(0),
+		column_index(0),
+		row_index(0){
 	}
 	bool add_column(SQL_Error& error, void *ptr, size_t size) {
 		try {
-			StringPtr column(new String);
+			const String& column(new String);
 			column->APPEND_TAINTED(
 				(const char* )ptr, size, 
 				statement_cstr, 0);
@@ -88,13 +89,13 @@ public:
 	}
 	bool add_row_cell(SQL_Error& error, void *ptr, size_t size) {
 		try {
-			StringPtr cell(new String);
+			const String& cell(new String);
 			if(size)
 				cell->APPEND_TAINTED(
 					(const char* )ptr, size, 
 					statement_cstr, row_index++);
 			if(column_index==0) {
-				VHashPtr row_vhash(new VHash);
+				VHash* row_vhash(new VHash);
 				row_hash=&row_vhash->hash();
 				if(rows_hash.put_dont_replace(cell, row_vhash)) // put. existed?
 					if(!distinct) {
@@ -104,7 +105,7 @@ public:
 						return true;
 					}
 			} else
-				row_hash->put(columns[column_index], ValuePtr(new VString(cell)));
+				row_hash->put(columns[column_index], Value*(new VString(cell)));
 			column_index++;
 
 			return false;
@@ -123,9 +124,9 @@ static void copy_all_overwrite_to(
 								  HashStringValue* dest) {
 	dest->put(key, value);
 }
-static void _create_or_add(Request& r, StringPtr method_name, MethodParams& params) {
-	if(params.count()) {
-		ValuePtr vb=params.as_no_junction(0, "param must be hash");
+static void _create_or_add(Request& r, const String& method_name, MethodParams* params) {
+	if(params->count()) {
+		Value* vb=params->as_no_junction(0, "param must be hash");
 		if(HashStringValue* b=vb->get_hash(method_name))
 			b->for_each(copy_all_overwrite_to, &(GET_SELF(r, VHash).hash()));
 	}
@@ -137,8 +138,8 @@ static void remove_key_from(
 							HashStringValue* dest) {
 	dest->remove(key);
 }
-static void _sub(Request& r, StringPtr method_name, MethodParams& params) {
-	ValuePtr vb=params.as_no_junction(0, "param must be hash");
+static void _sub(Request& r, const String& method_name, MethodParams* params) {
+	Value* vb=params->as_no_junction(0, "param must be hash");
 	if(HashStringValue* b=vb->get_hash(method_name))
 		b->for_each(remove_key_from, &GET_SELF(r, VHash).hash());
 }
@@ -149,13 +150,13 @@ static void copy_all_dontoverwrite_to(
 								  HashStringValue* dest) {
 	dest->put_dont_replace(key, value);
 }
-static void _union(Request& r, StringPtr method_name, MethodParams& params) {
+static void _union(Request& r, const String& method_name, MethodParams* params) {
 	// dest = copy of self
-	ValuePtr result(new VHash(GET_SELF(r, VHash).hash()));
+	Value* result(new VHash(GET_SELF(r, VHash).hash()));
 	// dest += b
-	ValuePtr vb=params.as_no_junction(0, "param must be hash");
+	Value* vb=params->as_no_junction(0, "param must be hash");
 	if(HashStringValue* b=vb->get_hash(method_name))
-		b->for_each(copy_all_dontoverwrite_to, result->get_hash(Exception::undefined_source));
+		b->for_each(copy_all_dontoverwrite_to, result->get_hash(0));
 
 	// return result
 	r.write_no_lang(result);
@@ -174,12 +175,12 @@ static void copy_intersection_to(
 	if(info->b->get(key))
 		info->dest->put_dont_replace(key, value);
 }
-static void _intersection(Request& r, StringPtr method_name, MethodParams& params) {
-	ValuePtr result(new VHash);
+static void _intersection(Request& r, const String& method_name, MethodParams* params) {
+	Value* result(new VHash);
 	// dest += b
-	ValuePtr vb=params.as_no_junction(0, "param must be hash");
+	Value* vb=params->as_no_junction(0, "param must be hash");
 	if(HashStringValue* b=vb->get_hash(method_name)) {
-		Copy_intersection_to_info info={b, result->get_hash(Exception::undefined_source)};
+		Copy_intersection_to_info info={b, result->get_hash(0)};
 		GET_SELF(r, VHash).hash().for_each(copy_intersection_to, &info);
 	}
 
@@ -194,38 +195,42 @@ static bool intersects(
 	return b->get(key);
 }
 
-static void _intersects(Request& r, StringPtr method_name, MethodParams& params) {
+static void _intersects(Request& r, const String& method_name, MethodParams* params) {
 	bool result=false;
 
-	ValuePtr vb=params.as_no_junction(0, "param must be hash");
+	Value* vb=params->as_no_junction(0, "param must be hash");
 	if(HashStringValue* b=vb->get_hash(method_name))
 		result=GET_SELF(r, VHash).hash().first_that(intersects, b);
 
 	// return result
-	r.write_no_lang(ValuePtr(new VBool(result)));
+	r.write_no_lang(Value*(new VBool(result)));
 }
 
 
-static void _sql(Request& r, StringPtr method_name, MethodParams& params) {
-	ValuePtr statement=params.as_junction(0, "statement must be code");
+extern const String& sql_limit_name;
+extern const String& sql_offset_name;
+extern const String& sql_default_name;
+extern const String& sql_distinct_name;
+static void _sql(Request& r, const String& method_name, MethodParams* params) {
+	Value* statement=params->as_junction(0, "statement must be code");
 
 	ulong limit=0;
 	ulong offset=0;
 	bool distinct=false;
-	if(params.count()>1) {
-		ValuePtr voptions=params.as_no_junction(1, "options must be hash, not code");
+	if(params->count()>1) {
+		Value* voptions=params->as_no_junction(1, "options must be hash, not code");
 		if(!voptions->is_string())
 			if(HashStringValue* options=voptions->get_hash(method_name)) {
 				int valid_options=0;
-				if(ValuePtr vlimit=options->get(sql_limit_name)) {
+				if(Value* vlimit=options->get(sql_limit_name)) {
 					valid_options++;
 					limit=(ulong)r.process_to_value(vlimit)->as_double();
 				}
-				if(ValuePtr voffset=options->get(sql_offset_name)) {
+				if(Value* voffset=options->get(sql_offset_name)) {
 					valid_options++;
 					offset=(ulong)r.process_to_value(voffset)->as_double();
 				}
-				if(ValuePtr vdistinct=options->get(sql_distinct_name)) {
+				if(Value* vdistinct=options->get(sql_distinct_name)) {
 					valid_options++;
 					distinct=r.process_to_value(vdistinct)->as_bool();
 				}
@@ -239,10 +244,10 @@ static void _sql(Request& r, StringPtr m
 					"options must be hash");
 	}
 
-	Temp_lang temp_lang(r, String::UL_SQL);
-	StringPtr statement_string=r.process_to_string(statement);
+	Temp_lang temp_lang(r, String::L_SQL);
+	const String& statement_string=r.process_to_string(statement);
 	const char* statement_cstr=
-		statement_string->cstr(r.pool(), String::UL_UNSPECIFIED, r.connection(method_name));
+		statement_string->cstr(r.String::L_UNSPECIFIED, r.connection(method_name));
 	HashStringValue& hash=GET_SELF(r, VHash).hash(method_name);
 	hash.clear();	
 	Hash_sql_event_handlers handlers(method_name,
@@ -261,37 +266,36 @@ static void keys_collector(
 						   Table *table) {
 	Table::element_type row(new ArrayString);
 	*row+=key;
-	table+=row;
+	*table+=row;
 }
-static void _keys(Request& r, StringPtr method_name, MethodParams& ) {
+static void _keys(Request& r, const String& method_name, MethodParams* ) {
 	Table::columns_type columns(new ArrayString);
-	*columns+=StringPtr(new String("key"));
-	TablePtr table(new Table(method_name, columns));
+	*columns+=String* (new String("key"));
+	Table* table(new Table(method_name, columns));
 
 	GET_SELF(r, VHash).hash(method_name).for_each(keys_collector, table.get());
 
-	r.write_no_lang(ValuePtr(new VTable(table)));
+	r.write_no_lang(Value*(new VTable(table)));
 }
 
-static void _count(Request& r, StringPtr method_name, MethodParams& ) {
-	r.write_no_lang(ValuePtr(new VInt(GET_SELF(r, VHash).hash(method_name).count())));
+static void _count(Request& r, const String& method_name, MethodParams* ) {
+	r.write_no_lang(Value*(new VInt(GET_SELF(r, VHash).hash(method_name).count())));
 }
 
-static void _delete(Request& r, StringPtr method_name, MethodParams& params) {
-	Pool& pool=r.pool();
+static void _delete(Request& r, const String& method_name, MethodParams* params) {
 
-	GET_SELF(r, VHash).hash(method_name).remove(params.as_string(0, "key must be string"));
+	GET_SELF(r, VHash).hash(method_name).remove(params->as_string(0, "key must be string"));
 }
 
 #ifndef DOXYGEN
 struct Foreach_info {
 	Request *r;
-	StringPtr key_var_name;
-	StringPtr value_var_name;
-	ValuePtr body_code;
-	ValuePtr delim_maybe_code;
+	const String& key_var_name;
+	const String& value_var_name;
+	Value* body_code;
+	Value* delim_maybe_code;
 
-	VStringPtr vkey;
+	const VString& vkey;
 	bool need_delim;
 };
 #endif
@@ -305,22 +309,22 @@ static void one_foreach_cycle(
 	ncontext.put_element(info->value_var_name, avalue, false);
 
 	StringOrValue sv_processed=info->r->process(info->body_code);
-	StringPtr s_processed=sv_processed.get_string();
-	if(info->delim_maybe_code && s_processed && s_processed->size()) { // delimiter set and we have body
+	const String& s_processed=sv_processed.get_string();
+	if(info->delim_maybe_code && s_processed && s_processed->length()) { // delimiter set and we have body
 		if(info->need_delim) // need delim & iteration produced string?
 			info->r->write_pass_lang(info->r->process(info->delim_maybe_code));
 		info->need_delim=true;
 	}
 	info->r->write_pass_lang(sv_processed);
 }
-static void _foreach(Request& r, StringPtr method_name, MethodParams& params) {
+static void _foreach(Request& r, const String& method_name, MethodParams* params) {
 	Foreach_info info;
 	info.r=&r;
-	info.key_var_name=params.as_string(0, "key-var name must be string");
-	info.value_var_name=params.as_string(1, "value-var name must be string");
-	info.body_code=params.as_junction(2, "body must be code");
-	info.delim_maybe_code=params.count()>3?params.get(3):ValuePtr(0);
-	info.vkey=VStringPtr(new VString);
+	info.key_var_name=params->as_string(0, "key-var name must be string");
+	info.value_var_name=params->as_string(1, "value-var name must be string");
+	info.body_code=params->as_junction(2, "body must be code");
+	info.delim_maybe_code=params->count()>3?params->get(3):0;
+	info.vkey=VString* (new VString);
 
 	VHash& self=GET_SELF(r, VHash);
 	HashStringValue& hash=self.hash(method_name);