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.108 and 1.119

version 1.108, 2002/04/22 14:10:55	version 1.119, 2002/08/29 12:22:46
Line 3	Line 3

Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	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"

// class	// class

Line 103 static void _right(Request& r, const Str	Line 104 static void _right(Request& r, const Str

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=static_cast<VString *>(r.self)->optimized_string(r.origins_mode());	const String& string=*r.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=params->size()>1?	size_t n=params->size()>1?
(size_t)params->as_int(1, "n must be int", r):string.size();	(size_t)max(0, params->as_int(1, "n must be int", r)):string.size();

r.write_assign_lang(string.mid(p, p+n));	r.write_assign_lang(string.mid(p, p+n));
}	}
Line 121 static void _pos(Request& r, const Strin	Line 122 static void _pos(Request& r, const Strin
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)->optimized_string(r.origins_mode());	#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)->optimized_string(r.origins_mode());

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.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, int, int, void ) {	static void search_action(Table& table, Array row, int, int, int, int, void ) {
Line 223 static void _match(Request& r, const Str	Line 301 static void _match(Request& r, const Str
const String& src=static_cast<VString *>(r.self)->string();	const String& src=static_cast<VString *>(r.self)->string();

bool was_global;	bool was_global;
bool matched=src.match(0,	bool matched=src.match(
&method_name,	&method_name,
regexp.as_string(), options,	regexp.as_string(), options,
&table,	&table,
Line 238 static void _match(Request& r, const Str	Line 316 static void _match(Request& r, const Str
result=new(pool) VBool(pool, matched);	result=new(pool) VBool(pool, matched);
r.write_assign_lang(*result);	r.write_assign_lang(*result);
} else { // replace	} else { // replace
char* src_cstr;	const String& src=*r.self->get_string();
const String& src=static_cast<VString *>(r.self)->optimized_string(r.origins_mode(), &src_cstr);

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

Line 252 static void _match(Request& r, const Str	Line 329 static void _match(Request& r, const Str
&replacement_code	&replacement_code
};	};
Temp_value_element temp_match_var(	Temp_value_element temp_match_var(
*replacement_code.get_junction()->root,	*replacement_code.get_junction()->method_frame,
*match_var_name, &vtable);	*match_var_name, &vtable);
src.match(src_cstr,	src.match(
&method_name,	&method_name,
r.process_to_string(regexp), options,	r.process_to_string(regexp), options,
&table,	&table,
Line 328 const String* sql_result_string(Request&	Line 405 const String* sql_result_string(Request&
default_code=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(&method_name)) {	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_to_value(*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_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 352 const String* sql_result_string(Request&	Line 431 const String* sql_result_string(Request&
const char *statement_cstr=	const char *statement_cstr=
statement_string.cstr(String::UL_UNSPECIFIED, r.connection(&method_name));	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);
try {	r.connection(&method_name)->query(
r.connection(&method_name)->query(	statement_cstr, offset, limit,
statement_cstr, offset, limit,	handlers,
handlers);	statement_string);
} catch(const Exception& e) { // query problem
// give more specific source [were url]
throw Exception("sql.execute",
&statement_string,
"%s", e.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 391 static void _sql(Request& r, const Strin	Line 464 static void _sql(Request& r, const Strin

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)->optimized_string(false/unused*/,	const String& src=*r.self->get_string();
0/cstr not needed/, true/*optimization forced,
so that replace fould strings that span across pices*/);

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 428 static void _save(Request& r, const Stri	Line 499 static void _save(Request& r, const Stri
buf, strlen(buf), true, do_append);	buf, strlen(buf), true, do_append);
}	}

	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/));
	}

// constructor	// constructor

MString::MString(Pool& apool) : Methoded(apool, "string") {	MString::MString(Pool& apool) : Methoded(apool, "string") {
Line 454 MString::MString(Pool& apool) : Methoded	Line 529 MString::MString(Pool& apool) : Methoded
// ^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 477 MString::MString(Pool& apool) : Methoded	Line 556 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.108
changed lines
	Added in v.1.119