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.99 and 1.112

version 1.99, 2002/04/10 09:53:14	version 1.112, 2002/06/25 14:28:57
Line 17	Line 17
#include "pa_sql_connection.h"	#include "pa_sql_connection.h"
#include "pa_dictionary.h"	#include "pa_dictionary.h"

// defines

#define STRING_CLASS_NAME "string"

// class	// class

class MString : public Methoded {	class MString : public Methoded {
Line 34 public: // Methoded	Line 30 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.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) {
Line 52 static void _int(Request& r, const Strin	Line 47 static void _int(Request& r, const Strin
else	else
converted=r.process_to_value(*default_code).as_int();	converted=r.process_to_value(*default_code).as_int();
}	}
	r.write_no_lang(*new(pool) VInt(pool, converted));
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) {
Line 72 static void _double(Request& r, const St	Line 64 static void _double(Request& r, const St
converted=r.process_to_value(*default_code).as_double();	converted=r.process_to_value(*default_code).as_double();
}	}

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) {
Line 98 static void _left(Request& r, const Stri	Line 88 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.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 107 static void _right(Request& r, const Str	Line 97 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.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.self->get_string();
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 p=(size_t)params->as_int(0, "p must be int", r);
size_t n=params->size()>1?	size_t n=params->size()>1?
(size_t)params->as_int(1, "n must be int", r):string.size();	(size_t)params->as_int(1, "n must be int", r):string.size();

r.write_assign_lang(*new(pool) VString(string.mid(p, p+n)));	r.write_assign_lang(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 128 static void _pos(Request& r, const Strin	Line 117 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.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())));
}	}

Line 142 static void split_list(Request& r, const	Line 131 static void split_list(Request& r, const

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

Array pieces(pool);	Array pieces(pool);
split_list(r, method_name, params, string, pieces);	split_list(r, method_name, params, string, pieces);
Line 163 static void _lsplit(Request& r, const St	Line 152 static void _lsplit(Request& r, const St

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

Array pieces(pool);	Array pieces(pool);
split_list(r, method_name, params, string, pieces);	split_list(r, method_name, params, string, pieces);
Line 182 static void _rsplit(Request& r, const St	Line 171 static void _rsplit(Request& r, const St
r.write_no_lang(*new(pool) VTable(pool, &table));	r.write_no_lang(*new(pool) VTable(pool, &table));
}	}

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 191 static void search_action(Table& table,	Line 180 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);
const String& replaced=ai.request->process_to_string(*ai.replacement_code, ai.origin);
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;
}	}
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.self)->string();

bool was_global;	bool was_global;
bool matched=src.match(	bool matched=src.match(
&method_name,	&method_name,
Line 251 static void _match(Request& r, const Str	Line 229 static void _match(Request& r, const Str
&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
	const String& src=*r.self->get_string();

Value& replacement_code=params->as_junction(2, "replacement param must be code");	Value& replacement_code=params->as_junction(2, "replacement param must be code");

String& dest=*new(pool) String(pool);	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
};	};
	Temp_value_element temp_match_var(
	*replacement_code.get_junction()->root,
	*match_var_name, &vtable);
src.match(	src.match(
&method_name,	&method_name,
r.process_to_string(regexp), 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.self)->string();

r.write_assign_lang(*new(pool) VString(src.change_case(pool,	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 351 const String* sql_result_string(Request&	Line 334 const String* sql_result_string(Request&
if(Value voffset=(Value )options->get(*sql_offset_name))	if(Value voffset=(Value )options->get(*sql_offset_name))
offset=(ulong)r.process_to_value(*voffset).as_double();	offset=(ulong)r.process_to_value(*voffset).as_double();
if(default_code=(Value )options->get(sql_default_name)) {	if(default_code=(Value )options->get(sql_default_name)) {
if(!default_code->get_junction())	if(Junction *default_junction=default_code->get_junction())
	default_junction->change_context(statement.get_junction());
	else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
&method_name,	&method_name,
"default option must be code");	"default option must be code");
Line 401 static void _sql(Request& r, const Strin	Line 386 static void _sql(Request& r, const Strin
&method_name,	&method_name,
"produced no result, but no default option 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.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)
Line 417 static void _replace(Request& r, const S	Line 401 static void _replace(Request& r, const S
"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));
}	}

static void _save(Request& r, const String& method_name, MethodParams *params) {	static void _save(Request& r, const String& method_name, MethodParams *params) {
const String& file_name=params->as_string(params->size()-1,	const String& file_name=params->as_string(params->size()-1,
"file name must be string");	"file name must be string");

const String& src=static_cast<VString >(r.self)->get_string();	const String& src=static_cast<VString *>(r.self)->string();

bool do_append=false;	bool do_append=false;
if(params->size()>1) {	if(params->size()>1) {
Line 443 static void _save(Request& r, const Stri	Line 427 static void _save(Request& r, const Stri
buf, strlen(buf), true, do_append);	buf, strlen(buf), true, do_append);
}	}

// constructor	static void _normalize(Request& r, const String& method_name, MethodParams * /params/) {
	r.write_assign_lang(r.self->get_string()->join_chains(r.pool(), 0/cstr/));
MString::MString(Pool& apool) : Methoded(apool) {	}
set_name(*NEW String(pool(), STRING_CLASS_NAME));

	// 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 495 MString::MString(Pool& apool) : Methoded	Line 480 MString::MString(Pool& apool) : Methoded

// ^string.save[file]	// ^string.save[file]
add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);	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.99
changed lines
	Added in v.1.112