parser3/src/classes/table.C - diff

Return to table.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/table.C between versions 1.79 and 1.100

version 1.79, 2001/05/08 10:39:20	version 1.100, 2001/08/07 13:54:13
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 "pa_config_includes.h"	#include "pa_config_includes.h"

Line 43 public: // Methoded	Line 42 public: // Methoded
static void _set(Request& r, const String& method_name, MethodParams *params) {	static void _set(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
// data is last parameter	// data is last parameter
Value& vdata=params->get_junction(params->size()-1, "body must be code");	Value& vdata=params->as_junction(params->size()-1, "body must be code");

Temp_lang temp_lang(r, String::UL_PASS_APPENDED);	Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
const String& data=r.process(vdata).as_string();	const String& data=r.process(vdata).as_string();
Line 66 static void _set(Request& r, const Strin	Line 65 static void _set(Request& r, const Strin
// parse cells	// parse cells
Array rows(pool);	Array rows(pool);
data.split(rows, &pos_after, "\n", 1, String::UL_CLEAN);	data.split(rows, &pos_after, "\n", 1, String::UL_CLEAN);
int size=rows.quick_size();	Array_iter i(rows);
for(int i=0; i<size; i++) {	while(i.has_next()) {
Array& row=*new(pool) Array(pool);	Array& row=*new(pool) Array(pool);
const String& string=*rows.quick_get_string(i);	const String& string=*i.next_string();
// remove empty lines	// remove empty lines
if(!string.size())	if(!string.size())
continue;	continue;
Line 85 static void _set(Request& r, const Strin	Line 84 static void _set(Request& r, const Strin
static void _load(Request& r, const String& method_name, MethodParams *params) {	static void _load(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
// filename is last parameter	// filename is last parameter
Value& vfilename=params->get_no_junction(params->size()-1,	Value& vfilename=params->as_no_junction(params->size()-1,
"file name must not be code");	"file name must not be code");

// loading text	// loading text
Line 131 static void _load(Request& r, const Stri	Line 130 static void _load(Request& r, const Stri
static_cast<VTable *>(r.self)->set_table(table);	static_cast<VTable *>(r.self)->set_table(table);
}	}

	static Table *fill_month_days(Request& r,
	const String& method_name, MethodParams *params, bool rus){
	Pool& pool=r.pool();
	Table result=new(pool) Table(pool, &method_name, 0/&columns*/);

	int year=params->as_int(1, r);
	int month=max(1, min(params->as_int(2, r), 12)) -1;

	tm tmIn={0, 0, 0, 1, month, year-1900};
	time_t t=mktime(&tmIn);
	if(t<0)
	PTHROW(0, 0,
	&method_name,
	"invalid date");
	tm *tmOut=localtime(&t);

	int weekDay1=tmOut->tm_wday;
	if(rus)
	weekDay1=weekDay1?weekDay1-1:6; //sunday last
	int monthDays=getMonthDays(year, month);

	for(int _day=1-weekDay1; _day<=monthDays;) {
	Array& row=*new(pool) Array(pool, 7);
	for(int wday=0; wday<7; wday++, _day++) {
	String *cell=new(pool) String(pool);
	if(_day>=1 && _day<=monthDays) {
	char buf=(char )malloc(2+1);
	cell->APPEND_CLEAN(buf, sprintf(buf, "%02d", _day),
	method_name.origin().file, method_name.origin().line);
	}
	row+=cell;
	}
	*result+=&row;
	}

	return result;
	}

	static Table *fill_week_days(Request& r,
	const String& method_name, MethodParams *params, bool rus){
	Pool& pool=r.pool();
	Array& columns=*new(pool) Array(pool, 4);
	columns+=new(pool) String(pool, "year");
	columns+=new(pool) String(pool, "month");
	columns+=new(pool) String(pool, "day");
	columns+=new(pool) String(pool, "weekday");
	Table *result=new(pool) Table(pool, &method_name, &columns);

	int year=params->as_int(1, r);
	int month=max(1, min(params->as_int(2, r), 12)) -1;
	int day=params->as_int(3, r);

	tm tmIn={0, 0, 18, day, month, year-1900};
	time_t t=mktime(&tmIn);
	if(t<0)
	PTHROW(0, 0,
	&method_name,
	"invalid date");
	tm *tmOut=localtime(&t);

	int baseWeekDay=tmOut->tm_wday;
	if(rus)
	baseWeekDay=baseWeekDay?baseWeekDay-1:6; //sunday last

	t-=baseWeekDay*SECS_PER_DAY;

	for(int curWeekDay=0; curWeekDay<7; curWeekDay++, t+=SECS_PER_DAY) {
	tm *tmOut=localtime(&t);
	Array& row=*new(pool) Array(pool, 4);
	#define WDFILL(size, value) { \
	char buf=(char )malloc(size+1); \
	String *cell=new(pool) String(pool); \
	cell->APPEND_CLEAN(buf, sprintf(buf, "%0"#size"d", value), \
	method_name.origin().file, \
	method_name.origin().line); \
	row+=cell; \
	}
	WDFILL(4, 1900+tmOut->tm_year);
	WDFILL(2, 1+tmOut->tm_mon);
	WDFILL(2, tmOut->tm_mday);
	WDFILL(2, tmOut->tm_wday);
	*result+=&row;
	}

	return result;
	}

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

	const String& what=params->as_string(0, "format must be strig");
	bool rus=false;
	if(what=="rus")
	rus=true;
	else if(what=="eng")
	rus=false;
	else
	PTHROW(0, 0,
	&what,
	"must be rus\|eng");

	Table *result=0;
	if(params->size()==1+2)
	result=fill_month_days(r, method_name, params, rus);
	else // 1+3
	result=fill_week_days(r, method_name, params, rus);

	// replace any previous table value
	static_cast<VTable >(r.self)->set_table(result);
	}




static void _save(Request& r, const String& method_name, MethodParams *params) {	static void _save(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Value& vtable_name=params->get_no_junction(params->size()-1,	Value& vtable_name=params->as_no_junction(params->size()-1,
"file name must not be code");	"file name must not be code");

Table& table=static_cast<VTable *>(r.self)->table();	Table& table=static_cast<VTable *>(r.self)->table();
Line 142 static void _save(Request& r, const Stri	Line 255 static void _save(Request& r, const Stri
if(params->size()==1) { // not nameless=named output	if(params->size()==1) { // not nameless=named output
// write out names line	// write out names line
if(table.columns()) { // named table	if(table.columns()) { // named table
for(int column=0; column<table.columns()->size(); column++) {	Array_iter i(*table.columns());
if(column)	while(i.has_next()) {
sdata.APPEND_CONST("\t");	sdata.append(i.next_string(), //static_cast<String *>(table.columns()->quick_get(column)),
sdata.append(static_cast<String >(table.columns()->quick_get(column)),
String::UL_TABLE);	String::UL_TABLE);
	if(i.has_next())
	sdata.APPEND_CONST("\t");
}	}
} else { // nameless table	} else { // nameless table
int lsize=table.size()?static_cast<Array *>(table.get(0))->size():0;	if(int lsize=table.size()?static_cast<Array *>(table.get(0))->size():0)
if(lsize)
for(int column=0; column<lsize; column++) {	for(int column=0; column<lsize; column++) {
char cindex_tab=(char )malloc(MAX_NUMBER);	char cindex_tab=(char )malloc(MAX_NUMBER);
snprintf(cindex_tab, MAX_NUMBER, "%d\t", column);	snprintf(cindex_tab, MAX_NUMBER, "%d\t", column);
Line 162 static void _save(Request& r, const Stri	Line 275 static void _save(Request& r, const Stri
sdata.APPEND_CONST("\n");	sdata.APPEND_CONST("\n");
}	}
// data lines	// data lines
for(int index=0; index<table.size(); index++) {	Array_iter i(table);
Array row=static_cast<Array >(table.quick_get(index));	while(i.has_next()) {
for(int column=0; column<row->size(); column++) {	Array_iter c(static_cast<Array >(i.next()));
if(column)	while(c.has_next()) {
sdata.APPEND_CONST("\t");	sdata.append(c.next_string(), //static_cast<String *>(row->quick_get(column)),
sdata.append(static_cast<String >(row->quick_get(column)),
String::UL_TABLE);	String::UL_TABLE);
	if(c.has_next())
	sdata.APPEND_CONST("\t");
}	}
sdata.APPEND_CONST("\n");	sdata.APPEND_CONST("\n");
}	}
Line 178 static void _save(Request& r, const Stri	Line 292 static void _save(Request& r, const Stri
sdata.cstr(), sdata.size(), true);	sdata.cstr(), sdata.size(), true);
}	}

static void _count(Request& r, const String&, MethodParams *) {	static void _count(Request& r, const String& method_name, MethodParams *) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Value& value=new(pool) VInt(pool, static_cast<VTable >(r.self)->table().size());	Value& value=new(pool) VInt(pool, static_cast<VTable >(r.self)->table().size());
	value.set_name(method_name);
r.write_no_lang(value);	r.write_no_lang(value);
}	}

static void _line(Request& r, const String& method_name, MethodParams *) {	static void _line(Request& r, const String& method_name, MethodParams *) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Value& value=new(pool) VInt(pool, 1+static_cast<VTable >(r.self)->table().current());	Value& value=new(pool) VInt(pool, 1+static_cast<VTable >(r.self)->table().current());
	value.set_name(method_name);
r.write_no_lang(value);	r.write_no_lang(value);
}	}

Line 194 static void _offset(Request& r, const St	Line 310 static void _offset(Request& r, const St
Pool& pool=r.pool();	Pool& pool=r.pool();
Table& table=static_cast<VTable *>(r.self)->table();	Table& table=static_cast<VTable *>(r.self)->table();
if(params->size()) {	if(params->size()) {
Value& offset_expr=params->get_junction(0, "offset must be expression");	Value& offset_expr=params->as_junction(0, "offset must be expression");
table.shift((int)r.process(offset_expr).as_double());	table.shift(r.process(offset_expr).as_int());
} else {	} else {
Value& value=*new(pool) VInt(pool, table.current());	Value& value=*new(pool) VInt(pool, table.current());
	value.set_name(method_name);
r.write_no_lang(value);	r.write_no_lang(value);
}	}
}	}

static void _menu(Request& r, const String& method_name, MethodParams *params) {	static void _menu(Request& r, const String& method_name, MethodParams *params) {
Value& body_code=params->get_junction(0, "body must be code");	Value& body_code=params->as_junction(0, "body must be code");

Value *delim_code=params->size()==2?&params->get(1):0;	Value *delim_code=params->size()==2?&params->get(1):0;

VTable& vtable=static_cast<VTable >(r.self);	VTable& vtable=static_cast<VTable >(r.self);
Table& table=vtable.table();	Table& table=vtable.table();
bool need_delim=false;	bool need_delim=false;
vtable.lock(); int saved_current=table.current();	int saved_current=table.current();
for(int row=0; row<table.size(); row++) {	int size=table.size();
	for(int row=0; row<size; row++) {
table.set_current(row);	table.set_current(row);

Value& processed_body=r.process(body_code);	Value& processed_body=r.process(body_code);
Line 223 static void _menu(Request& r, const Stri	Line 341 static void _menu(Request& r, const Stri
}	}
r.write_pass_lang(processed_body);	r.write_pass_lang(processed_body);
}	}
table.set_current(saved_current); vtable.unlock();	table.set_current(saved_current);
}	}

static void _empty(Request& r, const String& method_name, MethodParams *params) {	static void _empty(Request& r, const String& method_name, MethodParams *params) {
Line 233 static void _empty(Request& r, const Str	Line 351 static void _empty(Request& r, const Str
r.write_no_lang(*new(pool) VBool(pool, table.size()==0));	r.write_no_lang(*new(pool) VBool(pool, table.size()==0));
}	}

/// used by table: _record / store_column_item_to_hash
struct Record_info {
Pool *pool;
Table *table;
Hash *hash;
};
static void store_column_item_to_hash(Array::Item item, void info) {
Record_info& ri=static_cast<Record_info >(info);
String& column_name=static_cast<String >(item);
Value *value;
if(const String *column_item=ri.table->item(column_name))
value=new(ri.pool) VString(column_item);
else
value=new(ri.pool) VUnknown(ri.pool);
ri.hash->put(column_name, value);
}
static void _record(Request& r, const String& method_name, MethodParams *) {
Table& table=static_cast<VTable *>(r.self)->table();
if(const Array *columns=table.columns()) {
Pool& pool=r.pool();
Value& result=*new(pool) VHash(pool);
Record_info record_info={&pool, &table, result.get_hash()};
columns->for_each(store_column_item_to_hash, &record_info);
result.set_name(method_name);
r.write_no_lang(result);
}
}

/// used by table: _hash / table_row_to_hash	/// used by table: _hash / table_row_to_hash
struct Row_info {	struct Row_info {
Table *table;	Table *table;
Line 280 static void table_row_to_hash(Array::Ite	Line 370 static void table_row_to_hash(Array::Ite
int value_field=ri.value_fields->get_int(i);	int value_field=ri.value_fields->get_int(i);
if(value_field<row.size())	if(value_field<row.size())
hash.put(	hash.put(
*ri.table->columns()->get_string(value_field),	*ri.table->columns()->get_string(value_field),
new(pool) VString(*row.get_string(value_field)));	new(pool) VString(*row.get_string(value_field)));
}	}

Line 288 static void table_row_to_hash(Array::Ite	Line 378 static void table_row_to_hash(Array::Ite
}	}
}	}
static void _hash(Request& r, const String& method_name, MethodParams *params) {	static void _hash(Request& r, const String& method_name, MethodParams *params) {
	Pool& pool=r.pool();
Table& table=static_cast<VTable *>(r.self)->table();	Table& table=static_cast<VTable *>(r.self)->table();
	Value& result=*new(pool) VHash(pool);
if(const Array *columns=table.columns())	if(const Array *columns=table.columns())
if(columns->size()>1) {	if(columns->size()>1) {
Pool& pool=r.pool();

const String& key_field_name=params->get_no_junction(0,	const String& key_field_name=params->as_no_junction(0,
"key field name must not be code").as_string();	"key field name must not be code").as_string();
int key_field=table.column_name2index(key_field_name, true);	int key_field=table.column_name2index(key_field_name, true);
int value_fields_count=params->size()-1;	int value_fields_count=params->size()-1;
Line 303 static void _hash(Request& r, const Stri	Line 394 static void _hash(Request& r, const Stri
Array value_fields(pool, value_fields_count);	Array value_fields(pool, value_fields_count);
if(value_fields_by_params) {	if(value_fields_by_params) {
for(int i=1; i<params->size(); i++) {	for(int i=1; i<params->size(); i++) {
const String& value_field_name=params->get_no_junction(i,	const String& value_field_name=params->as_no_junction(i,
"value field name must not be code").as_string();	"value field name must not be code").as_string();
value_fields+=table.column_name2index(value_field_name, true);	value_fields+=table.column_name2index(value_field_name, true);
}	}
Line 314 static void _hash(Request& r, const Stri	Line 405 static void _hash(Request& r, const Stri
}	}

// integers: key_field & value_fields	// integers: key_field & value_fields
Value& result=*new(pool) VHash(pool);
Row_info row_info={&table, key_field, &value_fields, result.get_hash()};	Row_info row_info={&table, key_field, &value_fields, result.get_hash()};
table.for_each(table_row_to_hash, &row_info);	table.for_each(table_row_to_hash, &row_info);
result.set_name(method_name);
r.write_no_lang(result);
}	}
	result.set_name(method_name);
	r.write_no_lang(result);
}	}

/// used by table: _sort / sort_cmp_string\|sort_cmp_double	/// used by table: _sort / sort_cmp_string\|sort_cmp_double
Line 347 static int sort_cmp_double(const void *a	Line 437 static int sort_cmp_double(const void *a
return 0;	return 0;
}	}
static void _sort(Request& r, const String& method_name, MethodParams *params) {	static void _sort(Request& r, const String& method_name, MethodParams *params) {
Value& key_maker=params->get_junction(0, "key-maker must be code");	Value& key_maker=params->as_junction(0, "key-maker must be code");

bool reverse=params->size()==2/..[asc\|desc]/?	bool reverse=params->size()==2/..[asc\|desc]/?
reverse=params->get_no_junction(1, "order must not be code").as_string()=="desc":	reverse=params->as_no_junction(1, "order must not be code").as_string()=="desc":
false;	false;

Table& table=static_cast<VTable *>(r.self)->table();	Table& table=static_cast<VTable *>(r.self)->table();
Line 395 static void _locate(Request& r, const St	Line 485 static void _locate(Request& r, const St
VTable& vtable=static_cast<VTable >(r.self);	VTable& vtable=static_cast<VTable >(r.self);
Table& table=vtable.table();	Table& table=vtable.table();
Value& result=*new(pool) VBool(pool, table.locate(	Value& result=*new(pool) VBool(pool, table.locate(
params->get(0).as_string(),	params->get(0).as_string(),
params->get(1).as_string()));	params->get(1).as_string()));
result.set_name(method_name);	result.set_name(method_name);
r.write_no_lang(result);	r.write_no_lang(result);
Line 418 static void _flip(Request& r, const Stri	Line 508 static void _flip(Request& r, const Stri
new_table+=&new_row;	new_table+=&new_row;
}	}

vtable.set_table(new_table);	r.write_no_lang(*new(pool) VTable(pool, &new_table));
}	}

static void _append(Request& r, const String& method_name, MethodParams *params) {	static void _append(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
// data is last parameter	// data is last parameter
const String& string=	const String& string=
r.process(params->get_junction(0, "body must be code")).as_string();	r.process(params->as_junction(0, "body must be code")).as_string();

// parse cells	// parse cells
Array& row=*new(pool) Array(pool);	Array& row=*new(pool) Array(pool);
string.split(row, 0, "\t", 1, String::UL_CLEAN);	string.split(row, 0, "\t", 1, String::UL_CLEAN);

VTable& vtable=static_cast<VTable >(r.self);	VTable& vtable=static_cast<VTable >(r.self);
// disable ^a.menu{^a.append[]}
vtable.lock();
vtable.table()+=&row;	vtable.table()+=&row;
vtable.unlock();
}	}

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

Table *maybe_src=params->get_no_junction(0, "table ref must not be code").get_table();	Table *maybe_src=params->as_no_junction(0, "table ref must not be code").get_table();
if(!maybe_src)	if(!maybe_src)
PTHROW(0, 0,	PTHROW(0, 0,
&method_name,	&method_name,
"source is not a table");	"source is not a table");

Table& src=*maybe_src;	Table& src=*maybe_src;
Table& dest=static_cast<VTable *>(r.self)->table();	Table& dest=static_cast<VTable *>(r.self)->table();
if(&src == &dest)	if(&src == &dest)
PTHROW(0, 0,	PTHROW(0, 0,
&method_name,	&method_name,
"source and destination are same table");	"source and destination are same table");

if(const Array *dest_columns=dest.columns()) { // dest is named	if(const Array *dest_columns=dest.columns()) { // dest is named
Line 470 static void _join(Request& r, const Stri	Line 557 static void _join(Request& r, const Stri
}	}
}	}

	#ifndef DOXYGEN
	class Table_sql_event_handlers : public SQL_Driver_query_event_handlers {
	public:
	Table_sql_event_handlers(Pool& apool, const String& amethod_name,
	const String& astatement_string, const char *astatement_cstr) :
	pool(apool),
	method_name(amethod_name),
	statement_string(astatement_string),
	statement_cstr(astatement_cstr),
	columns(*new(pool) Array(pool)),
	row(0), row_index(0),
	table(0)
	{
	}

	void add_column(void *ptr, size_t size) {
	String *column=new(pool) String(pool);
	column->APPEND_TAINTED(
	(const char *)ptr, size,
	statement_cstr, 0);
	columns+=column;
	}
	void before_rows() {
	table=new(pool) Table(pool, &method_name, &columns);
	}
	void add_row() {
	(*table)+=(row=new(pool) Array(pool));
	}
	void add_row_cell(void *ptr, size_t size) {
	String *cell=new(pool) String(pool);
	if(size)
	cell->APPEND_TAINTED(
	(const char *)ptr, size,
	statement_cstr, row_index++);
	(*row)+=cell;
	}

	private:
	Pool& pool;
	const String& method_name;
	const String& statement_string; const char *statement_cstr;
	Array& columns;
	Array *row;
	uint row_index;
	public:
	Table *table;
	};
	#endif
static void _sql(Request& r, const String& method_name, MethodParams *params) {	static void _sql(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

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

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

ulong limit=0;	ulong limit=0;
if(params->size()>1) {
Value& limit_code=params->get_junction(1, "limit must be expression");
limit=(uint)r.process(limit_code).as_double();
}

ulong offset=0;	ulong offset=0;
if(params->size()>2) {	if(params->size()>1) {
Value& offset_code=params->get_junction(2, "offset must be expression");	Value& options_param=params->as_no_junction(1, "options must be hash, not code");
offset=(ulong)r.process(offset_code).as_double();	if(Hash *options=options_param.get_hash()) {
	if(Value vlimit=(Value )options->get(*sql_limit_name))
	limit=(ulong)r.process(*vlimit).as_double();
	if(Value voffset=(Value )options->get(*sql_offset_name))
	offset=(ulong)r.process(*voffset).as_double();
	} else
	PTHROW(0, 0,
	&method_name,
	"options must be hash");
}	}

Temp_lang temp_lang(r, String::UL_SQL);	Temp_lang temp_lang(r, String::UL_SQL);
const String& statement_string=r.process(statement).as_string();	const String& statement_string=r.process(statement).as_string();
const char *statement_cstr=	const char *statement_cstr=
statement_string.cstr(String::UL_UNSPECIFIED, r.connection);	statement_string.cstr(String::UL_UNSPECIFIED, r.connection);
unsigned int sql_column_count; SQL_Driver::Cell *sql_columns;	Table_sql_event_handlers handlers(pool, method_name,
unsigned long sql_row_count; SQL_Driver::Cell **sql_rows;	statement_string, statement_cstr);
bool need_rethrow=false; Exception rethrow_me;	bool need_rethrow=false; Exception rethrow_me;
PTRY {	PTRY {
r.connection->query(	r.connection->query(
statement_cstr, offset, limit,	statement_cstr, offset, limit,
&sql_column_count, &sql_columns,	handlers);
&sql_row_count, &sql_rows);
}	}
PCATCH(e) { // connect/process problem	PCATCH(e) { // query problem
rethrow_me=e; need_rethrow=true;	rethrow_me=e; need_rethrow=true;
}	}
PEND_CATCH	PEND_CATCH
if(need_rethrow)	if(need_rethrow)
PTHROW(rethrow_me.type(), rethrow_me.code(),	PTHROW(rethrow_me.type(), rethrow_me.code(),
&statement_string, // setting more specific source [were url]	&statement_string, // setting more specific source [were url]
rethrow_me.comment());	rethrow_me.comment());

Array& table_columns=*new(pool) Array(pool);
for(unsigned int i=0; i<sql_column_count; i++) {
String& table_column=*new(pool) String(pool);
table_column.APPEND_TAINTED(
(const char *)sql_columns[i].ptr, sql_columns[i].size,
statement_cstr, 0);
table_columns+=&table_column;
}

Table& table=*new(pool) Table(pool, &method_name, &table_columns);	Table *result=
	handlers.table?handlers.table: // query resulted in table? return it
{	new(pool) Table(pool, &method_name, 0); // query returned no table, fake it
for(unsigned long r=0; r<sql_row_count; r++) {
SQL_Driver::Cell *sql_cells=sql_rows[r];
Array& table_row=*new(pool) Array(pool);

for(unsigned int i=0; i<sql_column_count; i++) {
String& table_cell=*new(pool) String(pool);
table_cell.APPEND_TAINTED(
(const char *)sql_cells[i].ptr, sql_cells[i].size,
statement_cstr, r);
table_row+=&table_cell;
}
table+=&table_row;
}
}

// replace any previous table value	// replace any previous table value
static_cast<VTable *>(r.self)->set_table(table);	static_cast<VTable >(r.self)->set_table(result);
}	}

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

Value& relative_path=params->get_no_junction(0, "path must not be code");	Value& relative_path=params->as_no_junction(0, "path must not be code");

const String *regexp;	const String *regexp;
pcre *regexp_code;	pcre *regexp_code;
int ovecsize;	int ovecsize;
int *ovector;	int *ovector;
if(params->size()>1) {	if(params->size()>1) {
regexp=&params->get_no_junction(1, "regexp must not be code").as_string();	regexp=&params->as_no_junction(1, "regexp must not be code").as_string();

const char *pattern=regexp->cstr(String::UL_AS_IS);	const char *pattern=regexp->cstr(String::UL_AS_IS);
const char *errptr;	const char *errptr;
int erroffset;	int erroffset;
regexp_code=pcre_compile(pattern, PCRE_EXTRA \| PCRE_DOTALL,	regexp_code=pcre_compile(pattern, PCRE_EXTRA \| PCRE_DOTALL,
&errptr, &erroffset,	&errptr, &erroffset,
r.pcre_tables);	r.pcre_tables);

if(!regexp_code)	if(!regexp_code)
PTHROW(0, 0,	PTHROW(0, 0,
&regexp->mid(erroffset, regexp->size()),	&regexp->mid(erroffset, regexp->size()),
"regular expression syntax error - %s", errptr);	"regular expression syntax error - %s", errptr);

ovector=(int )malloc(sizeof(int)(ovecsize=(1/match/)*3));	ovector=(int )malloc(sizeof(int)(ovecsize=(1/match/)*3));
Line 585 static void _dir(Request& r, const Strin	Line 699 static void _dir(Request& r, const Strin
size_t file_name_size=strlen(ffblk.ff_name);	size_t file_name_size=strlen(ffblk.ff_name);
bool suits=true;	bool suits=true;
if(regexp_code) {	if(regexp_code) {
int exec_result=pcre_exec(regexp_code, 0,	int exec_result=pcre_exec(regexp_code, 0,
ffblk.ff_name, file_name_size, 0,	ffblk.ff_name, file_name_size, 0,
0, ovector, ovecsize);	0, ovector, ovecsize);

if(exec_result==PCRE_ERROR_NOMATCH)	if(exec_result==PCRE_ERROR_NOMATCH)
suits=false;	suits=false;
else if(exec_result<0) {	else if(exec_result<0) {
(*pcre_free)(regexp_code);	(*pcre_free)(regexp_code);
PTHROW(0, 0,	PTHROW(0, 0,
regexp,	regexp,
"regular expression execute (%d)",	"regular expression execute (%d)",
exec_result);	exec_result);
}	}
Line 604 static void _dir(Request& r, const Strin	Line 718 static void _dir(Request& r, const Strin
char file_name_cstr=(char )r.malloc(file_name_size);	char file_name_cstr=(char )r.malloc(file_name_size);
memcpy(file_name_cstr, ffblk.ff_name, file_name_size);	memcpy(file_name_cstr, ffblk.ff_name, file_name_size);
String &file_name=*new(pool) String(pool);	String &file_name=*new(pool) String(pool);
file_name.APPEND(file_name_cstr, file_name_size, String::UL_FILE_NAME,	file_name.APPEND(file_name_cstr, file_name_size, String::UL_FILE_NAME,
method_name.origin().file, method_name.origin().line);	method_name.origin().file, method_name.origin().line);

Array& row=*new(pool) Array(pool);	Array& row=*new(pool) Array(pool);
Line 620 static void _dir(Request& r, const Strin	Line 734 static void _dir(Request& r, const Strin
static_cast<VTable *>(r.self)->set_table(table);	static_cast<VTable *>(r.self)->set_table(table);
}	}

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

	Array& result_columns=*new(pool) Array(pool);
	result_columns+=new(pool) String(pool, "column");
	Table& result_table=*new(pool) Table(pool, &method_name, &result_columns);

	Table& source_table=static_cast<VTable *>(r.self)->table();
	if(const Array *source_columns=source_table.columns()) {
	Array_iter i(*source_columns);
	while(i.has_next()) {
	Array& result_row=*new(pool) Array(pool);
	result_row+=i.next();
	result_table+=&result_row;
	}
	}

	VTable& result=*new(pool) VTable(pool, &result_table);
	result.set_name(method_name);
	r.write_no_lang(result);
	}

// constructor	// constructor

MTable::MTable(Pool& apool) : Methoded(apool) {	MTable::MTable(Pool& apool) : Methoded(apool) {
Line 633 MTable::MTable(Pool& apool) : Methoded(a	Line 769 MTable::MTable(Pool& apool) : Methoded(a
// ^table:load[nameless;file]	// ^table:load[nameless;file]
add_native_method("load", Method::CT_DYNAMIC, _load, 1, 2);	add_native_method("load", Method::CT_DYNAMIC, _load, 1, 2);

	// ^table:calendar[month\|montheng;year;month]
	// ^table:calendar[week\|weekeng;year;month;day]
	add_native_method("calendar", Method::CT_DYNAMIC, _calendar, 3, 4);

// ^table.save[file]	// ^table.save[file]
// ^table.save[nameless;file]	// ^table.save[nameless;file]
add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);	add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
Line 654 MTable::MTable(Pool& apool) : Methoded(a	Line 794 MTable::MTable(Pool& apool) : Methoded(a
// ^table.empty[]	// ^table.empty[]
add_native_method("empty", Method::CT_DYNAMIC, _empty, 0, 0);	add_native_method("empty", Method::CT_DYNAMIC, _empty, 0, 0);

// ^table.record[]
add_native_method("record", Method::CT_DYNAMIC, _record, 0, 0);

// ^table:hash[key field name]	// ^table:hash[key field name]
// ^table:hash[key field name][value field name;...]	// ^table:hash[key field name][value field name;...]
add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 1000);	add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 1000);
Line 678 MTable::MTable(Pool& apool) : Methoded(a	Line 815 MTable::MTable(Pool& apool) : Methoded(a
add_native_method("join", Method::CT_DYNAMIC, _join, 1, 1);	add_native_method("join", Method::CT_DYNAMIC, _join, 1, 1);


// ^table:sql[query][(count[;offset])]	// ^table:sql[query]
add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 3);	// ^table:sql[query][$.limit(1) $.offset(2)]
	add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 2);

// ^table:dir[path]	// ^table:dir[path]
// ^table:dir[path][regexp]	// ^table:dir[path][regexp]
add_native_method("dir", Method::CT_DYNAMIC, _dir, 1, 2);	add_native_method("dir", Method::CT_DYNAMIC, _dir, 1, 2);

	// ^table:columns[]
	add_native_method("columns", Method::CT_DYNAMIC, _columns, 0, 0);
}	}

// global variable	// global variable

E-mail:

Removed from v.1.79
changed lines
	Added in v.1.100