--- parser3/src/classes/string.C	2001/10/09 07:06:00	1.78
+++ parser3/src/classes/string.C	2001/11/09 11:59:13	1.89
@@ -2,9 +2,9 @@
 	Parser: @b string parser class.
 
 	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
-	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
+	Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)
 
-	$Id: string.C,v 1.78 2001/10/09 07:06:00 parser Exp $
+	$Id: string.C,v 1.89 2001/11/09 11:59:13 paf Exp $
 */
 
 #include "classes.h"
@@ -41,23 +41,17 @@ static void _length(Request& r, const St
 
 static void _int(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
-	bool convert_problem=false; Exception rethrow_me;
 	int converted;
-	PTRY {
+	Value *default_code=params->size()>0?
+		default_code=&params->as_junction(0, "default must be int"):0; // (default)
+	try {
 		converted=r.self->as_int();
+	} catch(...) { // convert problem
+		if(!default_code) // we have a problem when no default
+			/*re*/throw;
+		else
+			converted=r.process(*default_code).as_int();
 	}
-	PCATCH(e) { // convert problem
-		if(convert_problem=params->size()==0) { // we have a problem when do not have default
-			rethrow_me=e;  
-			converted=0;
-		} else
-			converted=params->as_int(0, "default must be int", r); // (default)
-	}
-	PEND_CATCH
-	if(convert_problem)
-		PTHROW(rethrow_me.type(), rethrow_me.code(), 
-			rethrow_me.problem_source(),
-			rethrow_me.comment());
 
 	Value& result=*new(pool) VInt(pool, converted);
 	result.set_name(method_name);
@@ -66,23 +60,17 @@ static void _int(Request& r, const Strin
 
 static void _double(Request& r, const String& method_name, MethodParams *params) {
 	Pool& pool=r.pool();
-	bool convert_problem=false; Exception rethrow_me;
 	double converted;
-	PTRY {
+	Value *default_code=params->size()>0?
+		default_code=&params->as_junction(0, "default must be double"):0; // (default)
+	try {
 		converted=r.self->as_double();
+	} catch(...) { // convert problem
+		if(!default_code) // we have a problem when no default
+			/*re*/throw;  
+		else
+			converted=r.process(*default_code).as_double();
 	}
-	PCATCH(e) { // convert problem
-		if(convert_problem=params->size()==0) { // we have a problem when do not have default
-			rethrow_me=e;  
-			converted=0;
-		} else
-			converted=params->as_double(0, "default must be double", r); // (default)
-	}
-	PEND_CATCH
-	if(convert_problem)
-		PTHROW(rethrow_me.type(), rethrow_me.code(), 
-			rethrow_me.problem_source(),
-			rethrow_me.comment());
 
 	Value& result=*new(pool) VDouble(pool, converted);
 	result.set_name(method_name);
@@ -95,7 +83,8 @@ static void _double(Request& r, const St
 	Value& fmt=params->as_junction(0, "fmt must be code");
 
 	Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
-	char *buf=format(pool, r.self->as_double(), r.process(fmt).as_string().cstr());
+	char *buf=format(pool, r.self->as_double(), 
+		r.process(fmt).as_string().cstr(String::UL_UNSPECIFIED));
 
 	String result(pool);
 	result.APPEND_CLEAN(buf, 0, 
@@ -125,10 +114,12 @@ static void _right(Request& r, const Str
 static void _mid(Request& r, const String&, MethodParams *params) {
 	Pool& pool=r.pool();
 
+	const String& string=*static_cast<VString *>(r.self)->get_string();
+
 	size_t p=(size_t)params->as_int(0, "p must be int", r);
-	size_t n=(size_t)params->as_int(1, "n must be int", r);
+	size_t n=params->size()>1?
+		(size_t)params->as_int(1, "n must be int", r):string.size();
 	
-	const String& string=*static_cast<VString *>(r.self)->get_string();
 	r.write_assign_lang(*new(pool) VString(string.mid(p, p+n)));
 }
 
@@ -316,7 +307,7 @@ public:
 
 	void add_column(void *ptr, size_t size) {
 		if(got_column)
-			PTHROW(0, 0,
+			throw Exception(0, 0,
 				&statement_string,
 				"result must contain exactly one column");
 		got_column=true;
@@ -325,7 +316,7 @@ public:
 	void add_row() { /* ignore */ }
 	void add_row_cell(void *ptr, size_t size) {
 		if(got_cell)
-			PTHROW(0, 0,
+			throw Exception(0, 0,
 				&statement_string,
 				"result must not contain more then one row");
 		got_cell=true;
@@ -343,11 +334,11 @@ public:
 };
 #endif
 const String* sql_result_string(Request& r, const String& method_name, MethodParams *params,
-								Hash *&options) {
+								Hash *& options, Value *& default_code) {
 	Pool& pool=r.pool();
 
 	if(!r.connection)
-		PTHROW(0, 0,
+		throw Exception(0, 0,
 			&method_name,
 			"without connect");
 
@@ -355,16 +346,23 @@ const String* sql_result_string(Request&
 
 	ulong limit=0;
 	ulong offset=0;
+	default_code=0;
 	if(params->size()>1) {
 		Value& voptions=params->as_no_junction(1, "options must be hash, not code");
 		if(voptions.is_defined())
-			if(options=voptions.get_hash()) {
+			if(options=voptions.get_hash(&method_name)) {
 				if(Value *vlimit=(Value *)options->get(*sql_limit_name))
 					limit=(ulong)r.process(*vlimit).as_double();
 				if(Value *voffset=(Value *)options->get(*sql_offset_name))
 					offset=(ulong)r.process(*voffset).as_double();
+				if(default_code=(Value *)options->get(*sql_default_name)) {
+					if(!default_code->get_junction())
+						throw Exception(0, 0,
+							&method_name,
+							"default option must be code");
+				}
 			} else
-				PTHROW(0, 0,
+				throw Exception(0, 0,
 					&method_name,
 					"options must be hash");
 	} else
@@ -375,20 +373,16 @@ const String* sql_result_string(Request&
 	const char *statement_cstr=
 		statement_string.cstr(String::UL_UNSPECIFIED, r.connection);
 	String_sql_event_handlers handlers(pool, statement_string, statement_cstr);
-	bool need_rethrow=false; Exception rethrow_me;
-	PTRY {
+	try {
 		r.connection->query(
 			statement_cstr, offset, limit, 
 			handlers);
+	} catch(const Exception& e) { // query problem
+		// give more specific source [were url]
+		throw Exception(e.type(), e.code(),
+			&statement_string, 
+			"%s", e.comment());
 	}
-	PCATCH(e) { // query problem
-		rethrow_me=e;  need_rethrow=true;
-	}
-	PEND_CATCH
-	if(need_rethrow)
-		PTHROW(rethrow_me.type(), rethrow_me.code(),
-			&statement_string, // setting more specific source [were url]
-			rethrow_me.comment());
 	
 	if(!handlers.got_cell)
 		return 0; // no lines, caller should return second param[default value]
@@ -400,25 +394,17 @@ static void _sql(Request& r, const Strin
 	Pool& pool=r.pool();
 
 	Hash *options;
-	const String *string=sql_result_string(r, method_name, params, options);
+	Value *default_code;
+	const String *string=sql_result_string(r, method_name, params, options, default_code);
 	if(!string) {
-		if(options) {
-			if(Value *vdefault=(Value *)options->get(*sql_default_name)) {
-				if(!vdefault->get_junction())
-					PTHROW(0, 0,
-						&method_name,
-						"default option must be code");
-				string=r.process(*vdefault).get_string();
-				if(!string)
-					string=empty_string;
-			} else
-				PTHROW(0, 0,
-					&method_name,
-					"produced no result, but no default option specified");
+		if(default_code) {
+			string=r.process(*default_code).get_string();
+			if(!string)
+				string=new(pool) String(pool);
 		} else
-			PTHROW(0, 0,
+			throw Exception(0, 0,
 				&method_name,
-				"produced no result, but no options (no default) specified");
+				"produced no result, but no default option specified");
 	}
 	VString& result=*new(pool) VString(*string);
 	result.set_name(method_name);
@@ -431,13 +417,38 @@ static void _replace(Request& r, const S
 
 	Table *table=params->as_no_junction(0, "parameter must not be code").get_table();
 	if(!table)
-		PTHROW(0, 0,
+		throw Exception(0, 0,
 			&method_name,
 			"parameter must be table");
 
 	Dictionary dict(*table);
 	r.write_assign_lang(*new(pool) VString(src.replace(pool, dict)));
 }
+
+static void _save(Request& r, const String& method_name, MethodParams *params) {
+	Pool& pool=r.pool();
+	const String& file_name=params->as_string(params->size()-1, 
+		"file name must be string");
+
+	const String& src=*static_cast<VString *>(r.self)->get_string();
+
+	bool do_append=false;
+	if(params->size()>1) {
+		const String& mode=params->as_string(0, "mode must be string");
+		if(mode=="append")
+			do_append=true;
+		else
+			throw Exception(0, 0,
+				&mode,
+				"unknown mode, must be 'append'");
+	}		
+
+	// write
+	const char *buf=src.cstr(String::UL_UNSPECIFIED);
+	file_write(pool, r.absolute(file_name), 
+		buf, strlen(buf), true, do_append);
+}
+
 // constructor
 
 MString::MString(Pool& apool) : Methoded(apool) {
@@ -462,7 +473,7 @@ MString::MString(Pool& apool) : Methoded
 	// ^string.right(n)
 	add_native_method("right", Method::CT_DYNAMIC, _right, 1, 1);
 	// ^string.mid(p;n)
-	add_native_method("mid", Method::CT_DYNAMIC, _mid, 2, 2);
+	add_native_method("mid", Method::CT_DYNAMIC, _mid, 1, 2);
 
 	// ^string.pos[substr]
 	add_native_method("pos", Method::CT_DYNAMIC, _pos, 1, 1);
@@ -487,6 +498,9 @@ MString::MString(Pool& apool) : Methoded
 
 	// ^string.replace[table]
 	add_native_method("replace", Method::CT_DYNAMIC, _replace, 1, 1);
+
+	// ^string.save[file]  
+	add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
 }	
 
 // global variable