parser3/src/classes/string.C - diff

Return to string.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/string.C between versions 1.78 and 1.124

version 1.78, 2001/10/09 07:06:00	version 1.124, 2002/12/09 12:19:16
Line 1	Line 1
/** @file	/** @file
Parser: @b string parser class.	Parser: @b string parser class.

Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)

$Id$
*/	*/

	static const char* IDENT_STRING_C="$Date$";

#include "classes.h"	#include "classes.h"
#include "pa_request.h"	#include "pa_request.h"
#include "pa_vdouble.h"	#include "pa_vdouble.h"
Line 16	Line 16
#include "pa_string.h"	#include "pa_string.h"
#include "pa_sql_connection.h"	#include "pa_sql_connection.h"
#include "pa_dictionary.h"	#include "pa_dictionary.h"
	#include "pa_vmethod_frame.h"
// defines

#define STRING_CLASS_NAME "string"

// class	// class

Line 34 public: // Methoded	Line 31 public: // Methoded

static void _length(Request& r, const String& method_name, MethodParams *) {	static void _length(Request& r, const String& method_name, MethodParams *) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Value& result=*new(pool) VDouble(pool, r.self->get_string()->size());	double result=r.get_self()->get_string()->size();
result.set_name(method_name);	r.write_no_lang(*new(pool) VDouble(pool, result));
r.write_no_lang(result);
}	}

static void _int(Request& r, const String& method_name, MethodParams *params) {	static void _int(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
bool convert_problem=false; Exception rethrow_me;	const String *self_string=r.get_self()->get_string();
int converted;	int converted;
PTRY {	Value *default_code=params->size()>0?&params->as_junction(0, "default must be int"):0; // (default)
converted=r.self->as_int();	try {
}	if(!self_string \|\| self_string->is_empty())
PCATCH(e) { // convert problem	throw Exception("parser.runtime",
if(convert_problem=params->size()==0) { // we have a problem when do not have default	&method_name,
rethrow_me=e;	"parameter is empty string, error converting");
converted=0;	converted=self_string->as_int();
} else	} catch(...) { // convert problem
converted=params->as_int(0, "default must be int", r); // (default)	if(!default_code) // we have a problem when no default
	/re/throw;
	else
	converted=r.process_to_value(*default_code).as_int();
}	}
PEND_CATCH	r.write_no_lang(*new(pool) VInt(pool, converted));
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);
r.write_no_lang(result);
}	}

static void _double(Request& r, const String& method_name, MethodParams *params) {	static void _double(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
bool convert_problem=false; Exception rethrow_me;	const String *self_string=r.get_self()->get_string();
double converted;	double converted;
PTRY {	Value *default_code=params->size()>0?&params->as_junction(0, "default must be double"):0; // (default)
converted=r.self->as_double();	try {
}	if(!self_string \|\| self_string->is_empty())
PCATCH(e) { // convert problem	throw Exception("parser.runtime",
if(convert_problem=params->size()==0) { // we have a problem when do not have default	&method_name,
rethrow_me=e;	"parameter is empty string, error converting");
converted=0;	converted=self_string->as_double();
} else	} catch(...) { // convert problem
converted=params->as_double(0, "default must be double", r); // (default)	if(!default_code) // we have a problem when no default
	/re/throw;
	else
	converted=r.process_to_value(*default_code).as_double();
}	}
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);	r.write_no_lang(*new(pool) VDouble(pool, converted));
result.set_name(method_name);
r.write_no_lang(result);
}	}

/not static/void _string_format(Request& r, const String& method_name, MethodParams *params) {	/not static/void _string_format(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

Value& fmt=params->as_junction(0, "fmt must be code");	Value& fmt_maybe_code=params->get(0);
	// for some time due to stupid {} in original design
	const String& fmt=r.process_to_string(fmt_maybe_code);

Temp_lang temp_lang(r, String::UL_PASS_APPENDED);	char *buf=format(pool, r.get_self()->as_double(), fmt.cstr());
char *buf=format(pool, r.self->as_double(), r.process(fmt).as_string().cstr());

String result(pool);	String result(pool);
result.APPEND_CLEAN(buf, 0,	result.APPEND_CLEAN(buf, 0,
Line 109 static void _left(Request& r, const Stri	Line 97 static void _left(Request& r, const Stri

size_t n=(size_t)params->as_int(0, "n must be int", r);	size_t n=(size_t)params->as_int(0, "n must be int", r);

const String& string=static_cast<VString >(r.self)->get_string();	const String& string=static_cast<VString *>(r.get_self())->string();
r.write_assign_lang(*new(pool) VString(string.mid(0, n)));	r.write_assign_lang(string.mid(0, n));
}	}

static void _right(Request& r, const String&, MethodParams *params) {	static void _right(Request& r, const String&, MethodParams *params) {
Line 118 static void _right(Request& r, const Str	Line 106 static void _right(Request& r, const Str

size_t n=(size_t)params->as_int(0, "n must be int", r);	size_t n=(size_t)params->as_int(0, "n must be int", r);

const String& string=static_cast<VString >(r.self)->get_string();	const String& string=static_cast<VString *>(r.get_self())->string();
r.write_assign_lang(*new(pool) VString(string.mid(string.size()-n, string.size())));	r.write_assign_lang(string.mid(string.size()-n, string.size()));
}	}

static void _mid(Request& r, const String&, MethodParams *params) {	static void _mid(Request& r, const String&, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
	const String& string=*r.get_self()->get_string();

size_t p=(size_t)params->as_int(0, "p must be int", r);	size_t p=(size_t)max(0, 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)max(0, 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(string.mid(p, p+n));
r.write_assign_lang(*new(pool) VString(string.mid(p, p+n)));
}	}

static void _pos(Request& r, const String& method_name, MethodParams *params) {	static void _pos(Request& r, const String& method_name, MethodParams *params) {
Line 137 static void _pos(Request& r, const Strin	Line 126 static void _pos(Request& r, const Strin

Value& substr=params->as_no_junction(0, "substr must not be code");	Value& substr=params->as_no_junction(0, "substr must not be code");

const String& string=static_cast<VString >(r.self)->get_string();	const String& string=static_cast<VString *>(r.get_self())->string();
r.write_assign_lang(*new(pool) VInt(pool, string.pos(substr.as_string())));	r.write_assign_lang(*new(pool) VInt(pool, string.pos(substr.as_string())));
}	}

static void split_list(Request& r, const String& method_name, MethodParams *params,	static void split_list(Request& r, const String& method_name,
	MethodParams *params, int paramIndex,
const String& string,	const String& string,
Array& result) {	Array& result) {
Value& delim_value=params->as_no_junction(0, "delimiter must not be code");	Value& delim_value=params->as_no_junction(paramIndex, "delimiter must not be code");

string.split(result, 0, delim_value.as_string());	string.split(result, 0, delim_value.as_string());
}	}

static void _lsplit(Request& r, const String& method_name, MethodParams *params) {	#define SPLIT_LEFT 0x0001
Pool& pool=r.pool();	#define SPLIT_RIGHT 0x0010
const String& string=static_cast<VString >(r.self)->get_string();	#define SPLIT_HORIZONTAL 0x0100
	#define SPLIT_VERTICAL 0x1000

	static int split_options(const String *options) {
	struct Split_option {
	const char *keyL;
	const char *keyU;
	int setBit;
	int checkBit;
	} split_option[]={
	{"l", "L", SPLIT_LEFT, SPLIT_RIGHT}, // 0xVHRL
	{"r", "R", SPLIT_RIGHT, SPLIT_LEFT},
	{"h", "H", SPLIT_HORIZONTAL, SPLIT_VERTICAL},
	{"v", "V", SPLIT_VERTICAL, SPLIT_HORIZONTAL},
	{0}
	};

	int result=0;
	if(options) {
	for(Split_option *o=split_option; o->keyL; o++)
	if(options->pos(o->keyL)>=0
	\|\| (o->keyU && options->pos(o->keyU)>=0)) {
	if(result & o->checkBit)
	throw Exception("parser.runtime",
	options,
	"conflicting split options");
	result \|= o->setBit;
	}
	}

Array pieces(pool);	return result;
split_list(r, method_name, params, string, pieces);	}

	static Table *split_vertical(Request& r, const String& string, Array& pieces, bool right) {
	Pool& pool=r.pool();

Array& columns=*new(pool) Array(pool);	Array& columns=*new(pool) Array(pool);
columns+=new(pool) String(pool, "piece");	columns+=new(pool) String(pool, "piece");

Table& table=*new(pool) Table(pool, &string,	Table& table=*new(pool) Table(pool, &string,
&columns, pieces.size());	&columns, pieces.size());
Array_iter i(pieces);	if(right) { // right
while(i.has_next()) {	for(int i=pieces.size(); --i>=0; ) {
Array& row=*new(pool) Array(pool);	Array& row=*new(pool) Array(pool);
row+=i.next();	row+=pieces.get(i);
table+=&row;	table+=&row;
	}
	} else { // left
	Array_iter i(pieces);
	while(i.has_next()) {
	Array& row=*new(pool) Array(pool);
	row+=i.next();
	table+=&row;
	}
}	}
r.write_no_lang(*new(pool) VTable(pool, &table));
	return &table;
}	}

static void _rsplit(Request& r, const String& method_name, MethodParams *params) {	static Table *split_horizontal(Request& r, const String& string, Array& pieces, bool right) {
Pool& pool=r.pool();	Pool& pool=r.pool();
const String& string=static_cast<VString >(r.self)->get_string();

Array pieces(pool);	Table& table=new(pool) Table(pool, &string, 0 / nameless */);
split_list(r, method_name, params, string, pieces);	Array& row=*new(pool) Array(pool);
	if(right) { // right
	for(int i=pieces.size(); --i>=0; ) {
	row+=pieces.get(i);
	}
	} else { // left
	Array_iter i(pieces);
	while(i.has_next()) {
	row+=i.next();
	}
	}
	table+=&row;

Array& columns=*new(pool) Array(pool);	return &table;
columns+=new(pool) String(pool, "piece");	}

Table& table=*new(pool) Table(pool, &string,	static void split_with_options(Request& r, const String& method_name, MethodParams *params,
&columns, pieces.size());	int bits) {
for(int i=pieces.size(); --i>=0; ) {	Pool& pool=r.pool();
Array& row=*new(pool) Array(pool);	const String& string=*r.get_self()->get_string();
row+=pieces.get(i);
table+=&row;	Array pieces(pool);
	split_list(r, method_name, params, 0,
	string, pieces);

	if(!bits) {
	const String *options=0;
	if(params->size()>1) {
	options=&params->as_string(1, "options must not be code");
	}
	bits=split_options(options);
}	}

r.write_no_lang(*new(pool) VTable(pool, &table));	bool right=(bits & SPLIT_RIGHT) != 0;
	bool horizontal=(bits & SPLIT_HORIZONTAL) !=0;
	Table *table;
	if(horizontal)
	table=split_horizontal(r, string, pieces, right);
	else
	table=split_vertical(r, string, pieces, right);

	r.write_no_lang(*new(pool) VTable(pool, table));
	}
	static void _split(Request& r, const String& method_name, MethodParams *params) {
	split_with_options(r, method_name, params, 0 /* maybe-determine from param #2 */);
	}
	static void _lsplit(Request& r, const String& method_name, MethodParams *params) {
	split_with_options(r, method_name, params, SPLIT_LEFT);
	}
	static void _rsplit(Request& r, const String& method_name, MethodParams *params) {
	split_with_options(r, method_name, params, SPLIT_RIGHT);
}	}

static void search_action(Table& table, Array row, int, int, void ) {	static void search_action(Table& table, Array row, int, int, int, int, void ) {
if(row)	if(row)
table+=row;	table+=row;
}	}
Line 200 static void search_action(Table& table,	Line 266 static void search_action(Table& table,
struct Replace_action_info {	struct Replace_action_info {
Request request; const String origin;	Request request; const String origin;
const String src; String dest;	const String src; String dest;
	VTable *vtable;
Value *replacement_code;	Value *replacement_code;
const String *post_match;
};	};
#endif	#endif
static void replace_action(Table& table, Array *row, int start, int finish,	/// @todo they can do $global[$result] there, getting pointer to later-invalid local var, kill this
void *info) {	static void replace_action(Table& table, Array *row,
	int prestart, int prefinish,
	int poststart, int postfinish,
	void *info) {
Replace_action_info& ai=static_cast<Replace_action_info >(info);	Replace_action_info& ai=static_cast<Replace_action_info >(info);
if(row) { // begin&middle	if(row) { // begin&middle
// piece from last match['start'] to beginning of this match['finish']	// piece from last match['prestart'] to beginning of this match['prefinish']
if(start!=finish)	if(prestart!=prefinish)
*ai.dest << ai.src->mid(start, finish);//ai.dest->APPEND_CONST("-");	*ai.dest << ai.src->mid(prestart, prefinish);//ai.dest->APPEND_CONST("-");
// store found parts in one-record VTable	// store found parts in one-record VTable
if(table.size()) // middle	if(table.size()) // middle
table.put(0, row);	table.put(0, row);
else // begin	else // begin
table+=row;	table+=row;
{ // execute 'replacement_code' in 'table' context	{ // execute 'replacement_code' in 'table' context
VTable& vtable=*new(table.pool()) VTable(table.pool(), &table);	ai.vtable->set_table(table);
vtable.set_name(*ai.origin);

Junction *junction=ai.replacement_code->get_junction();	ai.dest << ai.request->process_to_string(ai.replacement_code);
Value saved_match_var_value=junction->root->get_element(match_var_name);
junction->root->put_element(*match_var_name, &vtable);
Value& replaced=ai.request->process(*ai.replacement_code, ai.origin, false);
junction->root->put_element(*match_var_name, saved_match_var_value);

/*
ai.dest->APPEND_CONST("(");
ai.dest << (String )row->get(1/match* /);
ai.dest->APPEND_CONST(")");
*/
*ai.dest << replaced.as_string();
}	}
ai.post_match=(String )row->get(2/post_match*/);
} else // end	} else // end
ai.dest << ai.post_match;	*ai.dest << ai.src->mid(poststart, postfinish);
}	}

/// @todo use pcre:study somehow	/// @todo use pcre:study somehow
static void _match(Request& r, const String& method_name, MethodParams *params) {	static void _match(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
const String& src=static_cast<VString >(r.self)->get_string();

Value& regexp=params->as_no_junction(0, "regexp must not be code");	Value& regexp=params->as_no_junction(0, "regexp must not be code");

const String *options=	const String *options=
params->size()>1?	params->size()>1?
&params->as_no_junction(1, "options must not be code").as_string():0;	&params->as_no_junction(1, "options must not be code").as_string():0;

Value *result;
Temp_lang temp_lang(r, String::UL_PASS_APPENDED);	Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
Table *table;	Table *table;
if(params->size()<3) { // search	if(params->size()<3) { // search
	const String& src=static_cast<VString *>(r.get_self())->string();

bool was_global;	bool was_global;
bool matched=src.match(r.pcre_tables(),	bool matched=src.match(
&method_name,	&method_name,
regexp.as_string(), options,	regexp.as_string(), options,
&table,	&table,
search_action, 0,	search_action, 0,
&was_global);	&was_global);
	Value *result;
// matched	// matched
// not (just matched[3=pre/match/post], no substrings) or Global search	// not (just matched[3=pre/match/post], no substrings) or Global search
if(table->columns()->size()>3 \|\| was_global)	if(table->columns()->size()>3 \|\| was_global)
result=new(pool) VTable(pool, table); // table of pre/match/post+substrings	result=new(pool) VTable(pool, table/TODO: clone this when table would be stacked!/); // table of pre/match/post+substrings
else	else
result=new(pool) VBool(pool, matched);	result=new(pool) VBool(pool, matched);
	r.write_assign_lang(*result);
} else { // replace	} else { // replace
Value& replacement_code=params->as_junction(2, "replacement code must be code");	const String& src=*r.get_self()->get_string();

String& dest=*new(pool) String(pool);	Value& replacement_code=params->as_junction(2, "replacement param must be code");

	String& result=*new(pool) String(pool);
	VTable vtable(pool);
Replace_action_info replace_action_info={	Replace_action_info replace_action_info={
&r, &method_name,	&r, &method_name,
&src, &dest,	&src, &result,
&replacement_code,	&vtable,
&src	&replacement_code
};	};
src.match(r.pcre_tables(),	Temp_value_element temp_match_var(
	*replacement_code.get_junction()->method_frame,
	*match_var_name, &vtable);
	src.match(
&method_name,	&method_name,
r.process(regexp).as_string(), options,	r.process_to_string(regexp), options,
&table,	&table,
replace_action, &replace_action_info);	replace_action, &replace_action_info);
result=new(pool) VString(dest);	r.write_assign_lang(result);
}	}
result->set_name(method_name);
r.write_assign_lang(*result);
}	}

static void change_case(Request& r, const String& method_name, MethodParams *params,	static void change_case(Request& r, const String& method_name, MethodParams *params,
String::Change_case_kind kind) {	String::Change_case_kind kind) {
Pool& pool=r.pool();	Pool& pool=r.pool();
const String& src=static_cast<VString >(r.self)->get_string();	const String& src=static_cast<VString *>(r.get_self())->string();

r.write_assign_lang(*new(pool) VString(src.change_case(pool, r.pcre_tables(),	r.write_assign_lang(src.change_case(pool, kind));
kind)));
}	}
static void _upper(Request& r, const String& method_name, MethodParams *params) {	static void _upper(Request& r, const String& method_name, MethodParams *params) {
change_case(r, method_name, params, String::CC_UPPER);	change_case(r, method_name, params, String::CC_UPPER);
Line 306 static void _lower(Request& r, const Str	Line 366 static void _lower(Request& r, const Str
class String_sql_event_handlers : public SQL_Driver_query_event_handlers {	class String_sql_event_handlers : public SQL_Driver_query_event_handlers {
public:	public:
String_sql_event_handlers(Pool& apool,	String_sql_event_handlers(Pool& apool,
const String& astatement_string, const char *astatement_cstr) :	const String& astatement_string, const char *astatement_cstr):
pool(apool),	pool(apool),
statement_string(astatement_string),	statement_string(astatement_string),
statement_cstr(astatement_cstr),	statement_cstr(astatement_cstr),
Line 314 public:	Line 374 public:
result=new(pool) String(pool);	result=new(pool) String(pool);
}	}

void add_column(void *ptr, size_t size) {	bool add_column(SQL_Error& error, void *ptr, size_t size) {
if(got_column)	if(got_column) {
PTHROW(0, 0,	error=SQL_Error("parser.runtime",
&statement_string,	&statement_string,
"result must contain exactly one column");	"result must contain exactly one column");
	return true;
	}
got_column=true;	got_column=true;
	return false;
}	}
void before_rows() { /* ignore */ }	bool before_rows(SQL_Error& /error/ ) { /* ignore */ return false; }
void add_row() { /* ignore */ }	bool add_row(SQL_Error& /error/) { /* ignore */ return false; }
void add_row_cell(void *ptr, size_t size) {	bool add_row_cell(SQL_Error& error, void *ptr, size_t size) {
if(got_cell)	if(got_cell) {
PTHROW(0, 0,	error=SQL_Error("parser.runtime",
&statement_string,	&statement_string,
"result must not contain more then one row");	"result must not contain more then one row");
got_cell=true;	return true;
	}

result->APPEND_TAINTED((const char *)ptr, size, statement_cstr, 0);	try {
	got_cell=true;
	result->APPEND_TAINTED((const char *)ptr, size, statement_cstr, 0);
	return false;
	} catch(...) {
	error=SQL_Error("exception occured in String_sql_event_handlers::add_row_cell");
	return true;
	}
}	}

private:	private:
Line 343 public:	Line 414 public:
};	};
#endif	#endif
const String* sql_result_string(Request& r, const String& method_name, MethodParams *params,	const String* sql_result_string(Request& r, const String& method_name, MethodParams *params,
Hash *&options) {	Hash & options, Value & default_code) {
Pool& pool=r.pool();	Pool& pool=r.pool();

if(!r.connection)
PTHROW(0, 0,
&method_name,
"without connect");

Value& statement=params->as_junction(0, "statement must be code");	Value& statement=params->as_junction(0, "statement must be code");

ulong limit=0;	ulong limit=0;
ulong offset=0;	ulong offset=0;
	default_code=0;
if(params->size()>1) {	if(params->size()>1) {
Value& voptions=params->as_no_junction(1, "options must be hash, not code");	Value& voptions=params->as_no_junction(1, "options must be hash, not code");
if(voptions.is_defined())	if(!voptions.is_string())
if(options=voptions.get_hash()) {	if(options=voptions.get_hash(&method_name)) {
if(Value vlimit=(Value )options->get(*sql_limit_name))	if(Value vlimit=(Value )options->get(*sql_limit_name))
limit=(ulong)r.process(*vlimit).as_double();	limit=(ulong)r.process_to_value(*vlimit).as_double();
if(Value voffset=(Value )options->get(*sql_offset_name))	if(Value voffset=(Value )options->get(*sql_offset_name))
offset=(ulong)r.process(*voffset).as_double();	offset=(ulong)r.process_to_value(*voffset).as_double();
	if(default_code=(Value )options->get(sql_default_name)) {
	if(Junction *default_junction=default_code->get_junction())
	;//default_junction->change_context(statement.get_junction());
	else
	throw Exception("parser.runtime",
	&method_name,
	"default option must be code");
	}
} else	} else
PTHROW(0, 0,	throw Exception("parser.runtime",
&method_name,	&method_name,
"options must be hash");	"options must be hash");
} else	} else
options=0;	options=0;

Temp_lang temp_lang(r, String::UL_SQL);	Temp_lang temp_lang(r, String::UL_SQL);
const String& statement_string=r.process(statement).as_string();	const String& statement_string=r.process_to_string(statement);
const char *statement_cstr=	const char *statement_cstr=
statement_string.cstr(String::UL_UNSPECIFIED, r.connection);	statement_string.cstr(String::UL_UNSPECIFIED, r.connection(&method_name));
String_sql_event_handlers handlers(pool, statement_string, statement_cstr);	String_sql_event_handlers handlers(pool, statement_string, statement_cstr);
bool need_rethrow=false; Exception rethrow_me;	r.connection(&method_name)->query(
PTRY {	statement_cstr, offset, limit,
r.connection->query(	handlers,
statement_cstr, offset, limit,	statement_string);
handlers);
}
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)	if(!handlers.got_cell)
return 0; // no lines, caller should return second param[default value]	return 0; // no lines, caller should return second param[default value]
Line 400 static void _sql(Request& r, const Strin	Line 465 static void _sql(Request& r, const Strin
Pool& pool=r.pool();	Pool& pool=r.pool();

Hash *options;	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(!string) {
if(options) {	if(default_code) {
if(Value vdefault=(Value )options->get(*sql_default_name)) {	string=&r.process_to_string(*default_code);
if(!vdefault->get_junction())	if(!string)
PTHROW(0, 0,	string=new(pool) String(pool);
&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");
} else	} else
PTHROW(0, 0,	throw Exception("parser.runtime",
&method_name,	&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);	r.write_assign_lang(*string);
r.write_assign_lang(result);
}	}

static void _replace(Request& r, const String& method_name, MethodParams *params) {	static void _replace(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
const String& src=static_cast<VString >(r.self)->get_string();	const String& src=*r.get_self()->get_string();

Table *table=params->as_no_junction(0, "parameter must not be code").get_table();	Table *table=params->as_no_junction(0, "parameter must not be code").get_table();
if(!table)	if(!table)
PTHROW(0, 0,	throw Exception("parser.runtime",
&method_name,	&method_name,
"parameter must be table");	"parameter must be table");

Dictionary dict(*table);	Dictionary dict(*table);
r.write_assign_lang(*new(pool) VString(src.replace(pool, dict)));	r.write_assign_lang(src.replace(pool, dict));
}	}
// constructor

MString::MString(Pool& apool) : Methoded(apool) {	static void _save(Request& r, const String& method_name, MethodParams *params) {
set_name(*NEW String(pool(), STRING_CLASS_NAME));	const String& file_name=params->as_string(params->size()-1,
	"file name must be string");

	const String& src=static_cast<VString *>(r.get_self())->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("parser.runtime",
	&mode,
	"unknown mode, must be 'append'");
	}

	// write
	const char buf=src.cstr(String::UL_UNSPECIFIED, r.connection(0/no error if none*/));
	file_write(r.absolute(file_name),
	buf, strlen(buf), true, do_append);
	}

	static void _normalize(Request& r, const String& method_name, MethodParams * /params/) {
	r.write_assign_lang(r.get_self()->get_string()->join_chains(r.pool(), 0/cstr/));
	}

	// constructor

	MString::MString(Pool& apool) : Methoded(apool, "string") {
// ^string.length[]	// ^string.length[]
add_native_method("length", Method::CT_DYNAMIC, _length, 0, 0);	add_native_method("length", Method::CT_DYNAMIC, _length, 0, 0);

Line 462 MString::MString(Pool& apool) : Methoded	Line 543 MString::MString(Pool& apool) : Methoded
// ^string.right(n)	// ^string.right(n)
add_native_method("right", Method::CT_DYNAMIC, _right, 1, 1);	add_native_method("right", Method::CT_DYNAMIC, _right, 1, 1);
// ^string.mid(p;n)	// ^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]	// ^string.pos[substr]
add_native_method("pos", Method::CT_DYNAMIC, _pos, 1, 1);	add_native_method("pos", Method::CT_DYNAMIC, _pos, 1, 1);

// ^string.lsplit[delim]	// ^string.split[delim]
add_native_method("lsplit", Method::CT_DYNAMIC, _lsplit, 1, 1);	// ^string.split[delim][options]
// ^string.rsplit[delim]	add_native_method("split", Method::CT_DYNAMIC, _split, 1, 2);
add_native_method("rsplit", Method::CT_DYNAMIC, _rsplit, 1, 1);	// old names for backward compatibility
	// ^string.lsplit[delim]
	add_native_method("lsplit", Method::CT_DYNAMIC, _lsplit, 1, 1);
	// ^string.rsplit[delim]
	add_native_method("rsplit", Method::CT_DYNAMIC, _rsplit, 1, 1);

// ^string.match[regexp][options]	// ^string.match[regexp][options]
// ^string.match[regexp][options]{replacement-code}	// ^string.match[regexp][options]{replacement-code}
add_native_method("match", Method::CT_DYNAMIC, _match, 1, 3);	add_native_method("match", Method::CT_DYNAMIC, _match, 1, 3);
Line 487 MString::MString(Pool& apool) : Methoded	Line 572 MString::MString(Pool& apool) : Methoded

// ^string.replace[table]	// ^string.replace[table]
add_native_method("replace", Method::CT_DYNAMIC, _replace, 1, 1);	add_native_method("replace", Method::CT_DYNAMIC, _replace, 1, 1);

	// ^string.save[file]
	add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);

	// ^string.normalize[]
	add_native_method("normalize", Method::CT_DYNAMIC, _normalize, 0, 0);
}	}

// global variable	// global variable

E-mail:

Removed from v.1.78
changed lines
	Added in v.1.124