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.243 and 1.256

version 1.243, 2019/11/20 20:48:25	version 1.256, 2024/10/02 22:54:02
Line 1	Line 1
/** @file	/** @file
Parser: @b string parser class.	Parser: @b string parser class.

Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2023 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
*/	*/

#include "classes.h"	#include "classes.h"
Line 147 static void _bool(Request& r, MethodPara	Line 147 static void _bool(Request& r, MethodPara
// for some time due to stupid {} in original design	// for some time due to stupid {} in original design
const String& fmt=r.process_to_string(fmt_maybe_code);	const String& fmt=r.process_to_string(fmt_maybe_code);

const char* buf=format(r.get_self().as_double(), fmt.trim().cstrm());	const char* buf=format_double(r.get_self().as_double(), fmt.trim().cstrm());

r.write(String(buf));	r.write(String(buf));
}	}

static void _left(Request& r, MethodParams& params) {	static void _left(Request& r, MethodParams& params) {
ssize_t sn=params.as_int(0, "n must be int", r);	int sn=params.as_int(0, "n must be int", r);
const String& string=GET_SELF(r, VString).string();	const String& string=GET_SELF(r, VString).string();
r.write(sn<0 ? string : string.mid(r.charsets.source(), 0, (size_t)sn));	r.write(sn<0 ? string : string.mid(r.charsets.source(), 0, sn));
}	}

static void _right(Request& r, MethodParams& params) {	static void _right(Request& r, MethodParams& params) {
ssize_t sn=params.as_int(0, "n must be int", r);	int sn=params.as_int(0, "n must be int", r);
if(sn>0){	if(sn>0){
size_t n=(size_t)sn;	size_t n=sn;
const String& string=GET_SELF(r, VString).string();	const String& string=GET_SELF(r, VString).string();
size_t length=string.length(r.charsets.source());	size_t length=string.length(r.charsets.source());
r.write(n<length ? string.mid(r.charsets.source(), length-n, length, length) : string);	r.write(n<length ? string.mid(r.charsets.source(), length-n, length, length) : string);
Line 171 static void _right(Request& r, MethodPar	Line 171 static void _right(Request& r, MethodPar
static void _mid(Request& r, MethodParams& params) {	static void _mid(Request& r, MethodParams& params) {
const String& string=GET_SELF(r, VString).string();	const String& string=GET_SELF(r, VString).string();

ssize_t sbegin=params.as_int(0, "p must be int", r);	int begin=params.as_int(0, "p must be int", r);
if(sbegin<0)	if(begin<0)
throw Exception(PARSER_RUNTIME, 0, "p(%d) must be >=0", sbegin);	throw Exception(PARSER_RUNTIME, 0, "p(%d) must be >=0", begin);
size_t begin=(size_t)sbegin;

size_t end;	size_t end;
size_t length=0;	size_t length=0;

if(params.count()>1) {	if(params.count()>1) {
ssize_t sn=params.as_int(1, "n must be int", r);	int n=params.as_int(1, "n must be int", r);
if(sn<0)	if(n<0)
throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", sn);	throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", n);
end=begin+(size_t)sn;	end=begin+n;
} else {	} else {
length=string.length(r.charsets.source());	length=string.length(r.charsets.source());
end=length;	end=length;
Line 195 static void _pos(Request& r, MethodParam	Line 195 static void _pos(Request& r, MethodParam
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=GET_SELF(r, VString).string();	const String& string=GET_SELF(r, VString).string();
ssize_t offset=0;	int offset=0;
if(params.count()>1){	if(params.count()>1){
offset=params.as_int(1, "n must be int", r);	offset=params.as_int(1, "n must be int", r);
if(offset<0)	if(offset<0)
throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", offset);	throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", offset);
}	}

r.write(*new VInt((int)string.pos(r.charsets.source(), substr.as_string(), (size_t)offset)));	r.write(*new VInt((int)string.pos(r.charsets.source(), substr.as_string(), offset)));
}	}

static void split_list(MethodParams& params, int paramIndex, const String& string, ArrayString& result) {	struct Split_action_info {
Value& delim_value=params.as_no_junction(paramIndex, "delimiter must not be code");	const String& src;
string.split(result, 0, delim_value.as_string());	ArrayString &result;
	};

	static void split_action(Table& , ArrayString* row, int prestart, int prefinish, int poststart, int postfinish, void *info) {
	Split_action_info& ai=static_cast<Split_action_info >(info);
	if(row) { // begin&middle
	// piece from last match['prestart'] to beginning of this match['prefinish']
	ai.result += &ai.src.mid(prestart, prefinish);
	} else // end
	if(poststart != postfinish)
	ai.result += &ai.src.mid(poststart, postfinish);
	}

	static void split_list(Value& delim_value, const String& string, ArrayString& result) {
	if(VRegex vregex=dynamic_cast<VRegex>(&delim_value)){
	vregex->study();

	int matches_count=0;
	Split_action_info ai = { string, result };

	string.match(vregex, split_action, &ai, matches_count);
	} else
	string.split(result, 0, delim_value.as_string());
}	}

#define SPLIT_LEFT 0x0001	#define SPLIT_LEFT 0x0001
Line 255 static Table& split_vertical(ArrayString	Line 277 static Table& split_vertical(ArrayString
table+=row;	table+=row;
}	}
} else { // left	} else { // left
Array_iterator<const String*> i(pieces);	for(ArrayString::Iterator i(pieces); i; ) {
while(i.has_next()) {
Table::element_type row(new ArrayString);	Table::element_type row(new ArrayString);
*row+=i.next();	*row+=i.next();
table+=row;	table+=row;
Line 273 static Table& split_horizontal(ArrayStri	Line 294 static Table& split_horizontal(ArrayStri
for(int i=pieces.count(); --i>=0; )	for(int i=pieces.count(); --i>=0; )
*row+=pieces[i];	*row+=pieces[i];
} else { // left	} else { // left
for(Array_iterator<const String*> i(pieces); i.has_next(); )	for(ArrayString::Iterator i(pieces); i; )
*row+=i.next();	*row+=i.next();
}	}
table+=row;	table+=row;
Line 286 static void split_with_options(Request&	Line 307 static void split_with_options(Request&
size_t params_count=params.count();	size_t params_count=params.count();

ArrayString pieces;	ArrayString pieces;
split_list(params, 0, string, pieces);	split_list(params.as_no_junction(0, "delimiter must not be code"), string, pieces);

if(!bits) {	if(!bits) {
const String* options=0;	const String* options=0;
Line 364 static void _match(Request& r, MethodPar	Line 385 static void _match(Request& r, MethodPar
Value& regexp=params.as_no_junction(0, "regexp must not be code");	Value& regexp=params.as_no_junction(0, "regexp must not be code");
Value* options=(params_count>1)?&params.as_no_junction(1, OPTIONS_MUST_NOT_BE_CODE):0;	Value* options=(params_count>1)?&params.as_no_junction(1, OPTIONS_MUST_NOT_BE_CODE):0;

VRegex* vregex;	VRegex* vregex=dynamic_cast<VRegex*>(&regexp);
VRegexCleaner vrcleaner;	VRegexCleaner vrcleaner;

if(Value* value=regexp.as(VREGEX_TYPE)){	if(vregex){
if(options && options->is_defined())	if(options && options->is_defined())
throw Exception(PARSER_RUNTIME, 0, "you can not specify regex-object and options together");	throw Exception(PARSER_RUNTIME, 0, "you cannot specify regex-object and options together");
vregex=static_cast<VRegex*>(value);
} else {	} else {
vregex=new VRegex(r.charsets.source(), &regexp.as_string(), (options) ? (&options->as_string()) : 0);	vregex=new VRegex(r.charsets.source(), &regexp.as_string(), (options) ? (&options->as_string()) : 0);
vregex->study();	vregex->study();
Line 466 public:	Line 486 public:
bool add_row(SQL_Error& /error/) { /* ignore */ return false; }	bool add_row(SQL_Error& /error/) { /* ignore */ return false; }
bool add_row_cell(SQL_Error& error, const char* str, size_t) {	bool add_row_cell(SQL_Error& error, const char* str, size_t) {
if(got_cell) {	if(got_cell) {
error=SQL_Error("result must not contain more then one row");	error=SQL_Error("result must contain no more than one row");
return true;	return true;
}	}
try {	try {
Line 553 static void _replace(Request& r, MethodP	Line 573 static void _replace(Request& r, MethodP

if(params.count()==1) {	if(params.count()==1) {
// ^string.replace[table]	// ^string.replace[table]
Table* table=params.as_table(0, "param");	if(Table* table=params.as_table(0, "param")){
Dictionary dict(*table);	Dictionary dict(*table);
r.write(src.replace(dict));	r.write(src.replace(dict));
	} else
	r.write(src);
} else {	} else {
// ^string.replace[from-string;to-string]	// ^string.replace[from-string;to-string]
Dictionary dict(params.as_string(0, "from must be string"), params.as_string(1, "to must be string"));	Dictionary dict(params.as_string(0, "from must be string"), params.as_string(1, "to must be string"));
Line 602 static void _save(Request& r, MethodPara	Line 624 static void _save(Request& r, MethodPara
String::Body sbody=src.cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets);	String::Body sbody=src.cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false), &r.charsets);

// write	// write
file_write(r.charsets, r.absolute(file_name), sbody.cstr(), sbody.length(), true, do_append, asked_charset);	file_write(r.charsets, r.full_disk_path(file_name), sbody.cstr(), sbody.length(), true, do_append, asked_charset);
}	}

static void _normalize(Request& r, MethodParams&) {	static void _normalize(Request& r, MethodParams&) {

E-mail:

Removed from v.1.243
changed lines
	Added in v.1.256