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.52 and 1.60

version 1.52, 2001/05/19 18:35:40	version 1.60, 2001/07/09 16:13:17
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
Line 55 static void _double(Request& r, const St	Line 55 static void _double(Request& r, const St
/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());
Line 94 static void _mid(Request& r, const Strin	Line 94 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 103 static void _pos(Request& r, const Strin	Line 103 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) {
Value& delim_value=params->get_no_junction(0, "delimiter must not be code");	Value& delim_value=params->as_no_junction(0, "delimiter must not be code");

string.split(result, 0, delim_value.as_string());	string.split(result, 0, delim_value.as_string());
}	}
Line 190 static void _match(Request& r, const Str	Line 190 static void _match(Request& r, const Str
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 249 static void _lower(Request& r, const Str	Line 247 static void _lower(Request& r, const Str
change_case(r, method_name, params, String::CC_LOWER);	change_case(r, method_name, params, String::CC_LOWER);
}	}

	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=0;
	if(params->size()>1) {
	Value& offset_code=params->as_junction(1, "offset must be expression");
	offset=(ulong)r.process(offset_code).as_double();
	}

	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!=1)
	PTHROW(0, 0,
	&statement_string,
	"result must contain exactly 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();

	VString& result=*new(pool) VString(sql_result_string(r, method_name, params));
	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 290 MString::MString(Pool& apool) : Methoded	Line 353 MString::MString(Pool& apool) : Methoded
add_native_method("upper", Method::CT_DYNAMIC, _upper, 0, 0);	add_native_method("upper", Method::CT_DYNAMIC, _upper, 0, 0);
// ^string.tolower[]	// ^string.tolower[]
add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);	add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);

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

// global variable	// global variable

E-mail:

Removed from v.1.52
changed lines
	Added in v.1.60