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.44 and 1.63

version 1.44, 2001/05/04 10:42:37	version 1.63, 2001/07/18 10:06:04
Line 4	Line 4
Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)	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://design.ru/paf)

$Id$
*/	*/
	static const char *RCSId="$Id$";

#include "classes.h"	#include "classes.h"
#include "pa_request.h"	#include "pa_request.h"
Line 15	Line 14
#include "pa_vtable.h"	#include "pa_vtable.h"
#include "pa_vbool.h"	#include "pa_vbool.h"
#include "pa_string.h"	#include "pa_string.h"
	#include "pa_sql_connection.h"

// defines	// defines

Line 26 class MString : public Methoded {	Line 26 class MString : public Methoded {
public:	public:
MString(Pool& pool);	MString(Pool& pool);
public: // Methoded	public: // Methoded
bool used_directly() { return false; }	bool used_directly() { return true; }
};	};

// methods	// methods

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

static void _int(Request& r, const String&, MethodParams *) {	static void _int(Request& r, const String& method_name, MethodParams *) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Value& value=*new(pool) VInt(pool, (int)r.self->as_double());	Value& result=*new(pool) VInt(pool, r.self->as_int());
r.write_no_lang(value);	result.set_name(method_name);
	r.write_no_lang(result);
}	}

static void _double(Request& r, const String&, MethodParams *) {	static void _double(Request& r, const String& method_name, MethodParams *) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Value& value=*new(pool) VDouble(pool, r.self->as_double());	Value& result=*new(pool) VDouble(pool, r.self->as_double());
r.write_no_lang(value);	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->get_junction(0, "fmt must be code");	Value& fmt=params->as_junction(0, "fmt must be code");

Temp_lang temp_lang(r, String::UL_PASS_APPENDED);	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());

r.write_no_lang(String(pool, buf));	String result(pool);
	result.APPEND_CLEAN(buf, 0,
	method_name.origin().file,
	method_name.origin().line);
	r.write_no_lang(result);
}	}

static void _left(Request& r, const String&, MethodParams *params) {	static void _left(Request& r, const String&, MethodParams *params) {
Line 91 static void _mid(Request& r, const Strin	Line 98 static void _mid(Request& r, const Strin
static void _pos(Request& r, const String& method_name, MethodParams *params) {	static void _pos(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

Value& substr=params->get_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)->get_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 100 static void _pos(Request& r, const Strin	Line 107 static void _pos(Request& r, const Strin
static void split_list(Request& r, const String& method_name, MethodParams *params,	static void split_list(Request& r, const String& method_name, MethodParams *params,
const String& string,	const String& string,
Array& result) {	Array& result) {
Pool& pool=r.pool();	Value& delim_value=params->as_no_junction(0, "delimiter must not be code");

Value& delim_value=params->get_no_junction(0, "delimiter must not be code");

string.split(result, 0, delim_value.as_string(), String::UL_CLEAN, -1);	string.split(result, 0, delim_value.as_string());
}	}

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=static_cast<VString >(r.self)->get_string();

Array& row=*new(pool) Array(pool);	Array pieces(pool);
split_list(r, method_name, params, string, row);	split_list(r, method_name, params, string, pieces);

Table& table=*new(pool) Table(pool, &string,	Array& columns=*new(pool) Array(pool);
0/nameless/, 1/row preallocate(and only)/);	columns+=new(pool) String(pool, "piece");
table+=&row;

	Table& table=*new(pool) Table(pool, &string,
	&columns, pieces.size());
	int size=pieces.quick_size();
	for(int i=0; i<size; i++) {
	Array& row=*new(pool) Array(pool);
	row+=pieces.quick_get(i);
	table+=&row;
	}
r.write_no_lang(*new(pool) VTable(pool, &table));	r.write_no_lang(*new(pool) VTable(pool, &table));
}	}

Line 125 static void _rsplit(Request& r, const St	Line 137 static void _rsplit(Request& r, const St
Pool& pool=r.pool();	Pool& pool=r.pool();
const String& string=static_cast<VString >(r.self)->get_string();	const String& string=static_cast<VString >(r.self)->get_string();

Array list(pool);	Array pieces(pool);
split_list(r, method_name, params, string, list);	split_list(r, method_name, params, string, pieces);

Array& row=*new(pool) Array(pool);	Array& columns=*new(pool) Array(pool);
for(int i=list.size(); --i>=0; )	columns+=new(pool) String(pool, "piece");
row+=list.get(i);

Table& table=*new(pool) Table(pool, &string,	Table& table=*new(pool) Table(pool, &string,
0/nameless/, 1/row preallocate(and only)/);	&columns, pieces.size());
table+=&row;	for(int i=pieces.size(); --i>=0; ) {
	Array& row=*new(pool) Array(pool);
	row+=pieces.get(i);
	table+=&row;
	}

r.write_no_lang(*new(pool) VTable(pool, &table));	r.write_no_lang(*new(pool) VTable(pool, &table));
}	}
Line 158 static void replace_action(Table& table,	Line 173 static void replace_action(Table& table,
// piece from last match['start'] to beginning of this match['finish']	// piece from last match['start'] to beginning of this match['finish']
if(start!=finish)	if(start!=finish)
*ai.dest << ai.src->mid(start, finish);//ai.dest->APPEND_CONST("-");	*ai.dest << ai.src->mid(start, finish);//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
Line 168 static void replace_action(Table& table,	Line 183 static void replace_action(Table& table,
vtable.set_name(*ai.origin);	vtable.set_name(*ai.origin);

Junction *junction=ai.replacement_code->get_junction();	Junction *junction=ai.replacement_code->get_junction();
junction->rcontext=junction->root=&vtable;	junction->rcontext=/*must be some way to get to
	outside world junction->root=*/&vtable;
Value& replaced=ai.request->process(*ai.replacement_code, ai.origin, false);	Value& replaced=ai.request->process(*ai.replacement_code, ai.origin, false);

/*	/*
Line 183 static void replace_action(Table& table,	Line 199 static void replace_action(Table& table,
ai.dest << ai.post_match;	ai.dest << ai.post_match;
}	}

/** search/replace	/// @todo use pcre:study somehow
^string.match[regexp][options]
^string.match[regexp][options]{replacement-code}
*/
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();	const String& src=static_cast<VString >(r.self)->get_string();

Value& regexp=params->get_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->get_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;	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
if(src.match(r.pcre_tables,	bool matched=src.match(r.pcre_tables,
&method_name,	&method_name,
regexp.as_string(), options,	regexp.as_string(), options,
&table,	&table,
search_action, 0)) {	search_action, 0);
// matched	// matched
if(table->columns()->size()==3 && // just matched[3=pre/match/post], no substrings	if(table->columns()->size()==3 && // just matched[3=pre/match/post], no substrings
table->size()==1) // just one row, not /g_lobal search	table->size()<=1) // just one row, not /g_lobal search
result=new(pool) VBool(pool, true);	result=new(pool) VBool(pool, matched);
else // table of pre/match/post+substrings	else // table of pre/match/post+substrings
result=new(pool) VTable(pool, table);	result=new(pool) VTable(pool, table);
} else // not matched [not global]
result=new(pool) VBool(pool, false);
} else { // replace	} else { // replace
Value& replacement_code=params->get_junction(2, "replacement code must be code");	Value& replacement_code=params->as_junction(2, "replacement code must be code");

String& dest=*new(pool) String(pool);	String& dest=*new(pool) String(pool);
Replace_action_info replace_action_info={	Replace_action_info replace_action_info={
Line 235 static void _match(Request& r, const Str	Line 246 static void _match(Request& r, const Str
r.write_assign_lang(*result);	r.write_assign_lang(*result);
}	}

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

	r.write_assign_lang(*new(pool) VString(src.change_case(pool, r.pcre_tables,
	kind)));
	}
	static void _upper(Request& r, const String& method_name, MethodParams *params) {
	change_case(r, method_name, params, String::CC_UPPER);
	}
	static void _lower(Request& r, const String& method_name, MethodParams *params) {
	change_case(r, method_name, params, String::CC_LOWER);
	}

	const String* sql_result_string(Request& r, const String& method_name, MethodParams *params) {
	Pool& pool=r.pool();

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

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

	ulong offset=(ulong)(params->size()>2?params->as_int(2, r):0);

	Temp_lang temp_lang(r, String::UL_SQL);
	const String& statement_string=r.process(statement).as_string();
	const char *statement_cstr=
	statement_string.cstr(String::UL_UNSPECIFIED, r.connection);
	unsigned int sql_column_count; SQL_Driver::Cell *sql_columns;
	unsigned long sql_row_count; SQL_Driver::Cell **sql_rows;
	bool need_rethrow=false; Exception rethrow_me;
	PTRY {
	r.connection->query(
	statement_cstr, offset, 0,
	&sql_column_count, &sql_columns,
	&sql_row_count, &sql_rows);
	}
	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(sql_column_count!=1)
	PTHROW(0, 0,
	&statement_string,
	"result must contain exactly one column");

	if(!sql_row_count)
	return 0; // no lines, should return second param[default value]

	if(sql_row_count>1)
	PTHROW(0, 0,
	&statement_string,
	"result must not contain more then one row");

	String *result=new(pool) String(pool);
	SQL_Driver::Cell& cell=sql_rows[0][0];
	result->APPEND_TAINTED(
	(const char *)cell.ptr, cell.size,
	statement_cstr, 0);

	return result;
	}

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

	const String *string=sql_result_string(r, method_name, params);
	if(!string) {
	Value& default_code=params->as_junction(1, "default result must code");
	Value& processed_code=r.process(default_code);
	string=processed_code.get_string();
	if(!string)
	string=empty_string;
	}
	VString& result=new(pool) VString(string);
	result.set_name(method_name);
	r.write_assign_lang(result);
	}

// constructor	// constructor

MString::MString(Pool& apool) : Methoded(apool) {	MString::MString(Pool& apool) : Methoded(apool) {
Line 271 MString::MString(Pool& apool) : Methoded	Line 369 MString::MString(Pool& apool) : Methoded
// ^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);

	// ^string.toupper[]
	add_native_method("upper", Method::CT_DYNAMIC, _upper, 0, 0);
	// ^string.tolower[]
	add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);

	// ^string:sql[query]{default}
	// ^string:sql[query]{default}(offset)
	add_native_method("sql", Method::CT_STATIC, _sql, 2, 3);
}	}

// global variable	// global variable

E-mail:

Removed from v.1.44
changed lines
	Added in v.1.63