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.58 and 1.71

version 1.58, 2001/04/06 12:34:50	version 1.71, 2001/05/07 13:29:47
Line 9	Line 9
*/	*/

#include "pa_config_includes.h"	#include "pa_config_includes.h"

	#include "pcre.h"

	#include "classes.h"
#include "pa_common.h"	#include "pa_common.h"
#include "pa_request.h"	#include "pa_request.h"
#include "_table.h"
#include "pa_vtable.h"	#include "pa_vtable.h"
#include "pa_vint.h"	#include "pa_vint.h"
#include "pa_sql_connection.h"	#include "pa_sql_connection.h"
#include "pa_dir.h"	#include "pa_dir.h"

// global var	// defines

	#define TABLE_CLASS_NAME "table"

	// class

	class MTable : public Methoded {
	public: // VStateless_class
	Value *create_new_value(Pool& pool) { return new(pool) VTable(pool); }

VStateless_class *table_class;	public:
	MTable(Pool& pool);

	public: // Methoded
	bool used_directly() { return true; }
	};

// methods	// methods
static void _set(Request& r, const String& method_name, Array *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=static_cast<Value >(params->get(params->size()-1));	Value& vdata=params->get_junction(params->size()-1, "body must be code");
// forcing {this body type}
r.fail_if_junction_(false, *vdata, method_name, "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();

size_t pos_after=0;	size_t pos_after=0;
// parse columns	// parse columns
Line 66 static void _set(Request& r, const Strin	Line 81 static void _set(Request& r, const Strin
static_cast<VTable *>(r.self)->set_table(table);	static_cast<VTable *>(r.self)->set_table(table);
}	}

static void _load(Request& r, const String& method_name, Array *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=static_cast<Value >(params->get(params->size()-1));	Value& vfilename=params->get_no_junction(params->size()-1,
// forcing [this file name type]	"file name must not be code");
r.fail_if_junction_(true, *vfilename,
method_name, "file name must not be code");

// loading text	// loading text
char *data=file_read_text(pool, r.absolute(vfilename->as_string()));	char *data=file_read_text(pool, r.absolute(vfilename.as_string()));

// parse columns	// parse columns
Array *columns;	Array *columns;
Line 117 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 void _save(Request& r, const String& method_name, Array *params) {	static void _save(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Value vtable_name=static_cast<Value >(params->get(params->size()-1));	Value& vtable_name=params->get_no_junction(params->size()-1,
// forcing this body type]	"file name must not be code");
r.fail_if_junction_(true, *vtable_name,
method_name, "file name must not be code");

Table& table=static_cast<VTable *>(r.self)->table();	Table& table=static_cast<VTable *>(r.self)->table();

Line 162 static void _save(Request& r, const Stri	Line 173 static void _save(Request& r, const Stri
}	}

// write	// write
file_write(pool, r.absolute(vtable_name->as_string()),	file_write(pool, r.absolute(vtable_name.as_string()),
sdata.cstr(), sdata.size(), true);	sdata.cstr(), sdata.size(), true);
}	}

static void _count(Request& r, const String&method_name, Array *) {	static void _count(Request& r, const String&, 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());
r.write_no_lang(value);	r.write_no_lang(value);
}	}

static void _line(Request& r, const String& method_name, Array *) {	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());
r.write_no_lang(value);	r.write_no_lang(value);
}	}

static void _offset(Request& r, const String& method_name, Array *params) {	static void _offset(Request& r, const String& method_name, MethodParams *params) {
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())
table.shift((int)r.process(static_cast<Value >(params->get(0))).as_double());	table.shift((int)r.process(params->get(0)).as_double());
else {	else {
Value& value=*new(pool) VInt(pool, table.current());	Value& value=*new(pool) VInt(pool, table.current());
r.write_no_lang(value);	r.write_no_lang(value);
}	}
}	}

/// @test $a.menu{ $a[123] }	static void _menu(Request& r, const String& method_name, MethodParams *params) {
static void _menu(Request& r, const String& method_name, Array *params) {	Value& body_code=params->get_junction(0, "body must be code");
Value& body_code=static_cast<Value >(params->get(0));
// forcing ^menu{this param type}
r.fail_if_junction_(false, body_code,
method_name, "body must be code");

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

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

Line 213 static void _menu(Request& r, const Stri	Line 221 static void _menu(Request& r, const Stri
}	}
r.write_pass_lang(processed_body);	r.write_pass_lang(processed_body);
}	}
table.set_current(saved_current);	table.set_current(saved_current); vtable.unlock();
}	}

static void _empty(Request& r, const String& method_name, Array *params) {	static void _empty(Request& r, const String& method_name, MethodParams *params) {
Table& table=static_cast<VTable *>(r.self)->table();	Table& table=static_cast<VTable *>(r.self)->table();
if(table.size()==0) {	if(table.size()==0)
Value& value=r.process(static_cast<Value >(params->get(0)));	r.write_pass_lang(r.process(params->get(0)));
r.write_pass_lang(value);	else if(params->size()>1)
} else if(params->size()==2) {	r.write_pass_lang(r.process(params->get(1)));
Value& value=r.process(static_cast<Value >(params->get(1)));
r.write_pass_lang(value);
}
}	}

	/// used by table: _record / store_column_item_to_hash
struct Record_info {	struct Record_info {
Pool *pool;	Pool *pool;
Table *table;	Table *table;
Line 243 static void store_column_item_to_hash(Ar	Line 249 static void store_column_item_to_hash(Ar
value=new(ri.pool) VUnknown(ri.pool);	value=new(ri.pool) VUnknown(ri.pool);
ri.hash->put(column_name, value);	ri.hash->put(column_name, value);
}	}
static void _record(Request& r, const String& method_name, Array *params) {	static void _record(Request& r, const String& method_name, MethodParams *params) {
Table& table=static_cast<VTable *>(r.self)->table();	Table& table=static_cast<VTable *>(r.self)->table();
if(const Array *columns=table.columns()) {	if(const Array *columns=table.columns()) {
Pool& pool=r.pool();	Pool& pool=r.pool();
Line 278 static int sort_cmp_double(const void *a	Line 284 static int sort_cmp_double(const void *a
else	else
return 0;	return 0;
}	}
static void _sort(Request& r, const String& method_name, Array *params) {	static void _sort(Request& r, const String& method_name, MethodParams *params) {
Value& key_maker=(Value )params->get(0);	Value& key_maker=params->get_junction(0, "key-maker must be code");
// forcing ^sort{this} ^sort(or this) param type
r.fail_if_junction_(false, key_maker, method_name, "key-maker must be code");	bool reverse=params->size()==2/..[asc\|desc]/?
	reverse=params->get_no_junction(1, "order must not be code").as_string()=="desc":
bool reverse;	false;
if(params->size()==2) { // ..[asc\|desc]
Value& order=(Value )params->get(1);
// forcing ..[this param-type]
r.fail_if_junction_(true, order, method_name, "order must not be code");
reverse=order.as_string()=="desc";
} else
reverse=false;

Table& table=static_cast<VTable *>(r.self)->table();	Table& table=static_cast<VTable *>(r.self)->table();

Line 306 static void _sort(Request& r, const Stri	Line 305 static void _sort(Request& r, const Stri
for(i=0; i<table.size(); i++) {	for(i=0; i<table.size(); i++) {
table.set_current(i);	table.set_current(i);
// calculate key value	// calculate key value
seq[i].row=(Array *)table.get(i);	seq[i].row=(MethodParams *)table.get(i);
Value& value=r.process(key_maker).as_expr_result(true/return string as-is*/);	Value& value=r.process(key_maker).as_expr_result(true/return string as-is*/);
if(i==0) // determining key values type by first one	if(i==0) // determining key values type by first one
key_values_are_strings=value.is_string();	key_values_are_strings=value.is_string();
Line 328 static void _sort(Request& r, const Stri	Line 327 static void _sort(Request& r, const Stri
table.set_current(0);	table.set_current(0);
}	}

static void _locate(Request& r, const String& method_name, Array *params) {	static void _locate(Request& r, const String& method_name, MethodParams *params) {
VTable& vtable=static_cast<VTable >(r.self);	VTable& vtable=static_cast<VTable >(r.self);
Table& table=vtable.table();	Table& table=vtable.table();
vtable.last_locate_was_successful=table.locate(	vtable.last_locate_was_successful=table.locate(
static_cast<Value *>(params->get(0))->as_string(),	params->get(0).as_string(),
static_cast<Value *>(params->get(1))->as_string());	params->get(1).as_string());
}	}

static void _found(Request& r, const String& method_name, Array *params) {	static void _found(Request& r, const String& method_name, MethodParams *params) {
if(static_cast<VTable *>(r.self)->last_locate_was_successful) {	if(static_cast<VTable *>(r.self)->last_locate_was_successful)
Value& then_code=static_cast<Value >(params->get(0));	r.write_pass_lang(r.process(params->get_junction(0, "found-parameter must be code")));
// forcing ^found{this param type}	else if(params->size()==2)
r.fail_if_junction_(false, then_code,	r.write_pass_lang(r.process(params->get_junction(0, "else-parameter must be code")));
method_name, "found-parameter must be code");
r.write_pass_lang(r.process(then_code));
} else if(params->size()==2) {
Value& else_code=static_cast<Value >(params->get(1));
// forcing ^found{this param type}
r.fail_if_junction_(false, else_code,
method_name, "not found-parameter must be code");
r.write_pass_lang(r.process(else_code));
}
}	}

static void _flip(Request& r, const String& method_name, Array *params) {	static void _flip(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VTable& vtable=static_cast<VTable >(r.self);	VTable& vtable=static_cast<VTable >(r.self);

Line 372 static void _flip(Request& r, const Stri	Line 362 static void _flip(Request& r, const Stri
vtable.set_table(new_table);	vtable.set_table(new_table);
}	}

static void _append(Request& r, const String& method_name, Array *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
Value value=static_cast<Value >(params->get(0));	const String& string=
// forcing {this body type}	r.process(params->get_junction(0, "body must be code")).as_string();
r.fail_if_junction_(false, *value, method_name, "body must be code");

const String& string=r.process(*value).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);

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

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

Value value=static_cast<Value >(params->get(0));	Table *maybe_src=params->get_no_junction(0, "table ref must not be code").get_table();
// forcing [this table ref type]
r.fail_if_junction_(true, *value, method_name, "table ref must not be code");

Table *maybe_src=value->get_table();
if(!maybe_src)	if(!maybe_src)
PTHROW(0, 0,	PTHROW(0, 0,
&method_name,	&method_name,
Line 424 static void _join(Request& r, const Stri	Line 411 static void _join(Request& r, const Stri
}	}
}	}

/// ^table:sql{query}[(count[;offset])]	static void _sql(Request& r, const String& method_name, MethodParams *params) {
static void _sql(Request& r, const String& method_name, Array *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

if(!r.connection)	if(!r.connection)
Line 433 static void _sql(Request& r, const Strin	Line 419 static void _sql(Request& r, const Strin
&method_name,	&method_name,
"without connect");	"without connect");

Value& statement=static_cast<Value >(params->get(0));	Value& statement=params->get_junction(0, "statement must be code");
// forcing {this query param type}
r.fail_if_junction_(false, statement, method_name, "statement must be code");

ulong limit=0;	ulong limit=0;
if(params->size()>1) {	if(params->size()>1) {
Value& limit_code=static_cast<Value >(params->get(1));	Value& limit_code=params->get_junction(1, "limit must be expression");
// forcing (this limit param type)
r.fail_if_junction_(false, limit_code, method_name, "limit must be expression");
limit=(uint)r.process(limit_code).as_double();	limit=(uint)r.process(limit_code).as_double();
}	}

ulong offset=0;	ulong offset=0;
if(params->size()>2) {	if(params->size()>2) {
Value& offset_code=static_cast<Value >(params->get(2));	Value& offset_code=params->get_junction(2, "offset must be expression");
// forcing (this limit param type)
r.fail_if_junction_(false, offset_code, method_name, "offset must be expression");
offset=(ulong)r.process(offset_code).as_double();	offset=(ulong)r.process(offset_code).as_double();
}	}

Line 506 static void _sql(Request& r, const Strin	Line 486 static void _sql(Request& r, const Strin
static_cast<VTable *>(r.self)->set_table(table);	static_cast<VTable *>(r.self)->set_table(table);
}	}

/// ^table:dir[path]	static void _dir(Request& r, const String& method_name, MethodParams *params) {
/// ^table:dir[path][regexp]
static void _dir(Request& r, const String& method_name, Array *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();

Value& relative_path=static_cast<Value >(params->get(0));	Value& relative_path=params->get_no_junction(0, "path must not be code");
// forcing [path]
r.fail_if_junction_(true, relative_path, method_name, "path must not be code");	const String *regexp;
	pcre *regexp_code;
	int ovecsize;
	int *ovector;
	if(params->size()>1) {
	regexp=&params->get_no_junction(1, "regexp must not be code").as_string();

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

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

	ovector=(int )malloc(sizeof(int)(ovecsize=(1/match/)*3));
	} else
	regexp_code=0;


const char* absolute_path_cstr=r.absolute(relative_path.as_string())	const char* absolute_path_cstr=r.absolute(relative_path.as_string())
.cstr(String::UL_FILE_NAME);	.cstr(String::UL_FILE_NAME);
Line 523 static void _dir(Request& r, const Strin	Line 523 static void _dir(Request& r, const Strin
Table& table=*new(pool) Table(pool, &method_name, &columns);	Table& table=*new(pool) Table(pool, &method_name, &columns);

LOAD_DIR(absolute_path_cstr,	LOAD_DIR(absolute_path_cstr,
Array& row=*new(pool) Array(pool);
size_t file_name_size=strlen(ffblk.ff_name);	size_t file_name_size=strlen(ffblk.ff_name);
char file_name=(char )r.malloc(file_name_size);	bool suits=true;
memcpy(file_name, ffblk.ff_name, file_name_size);	if(regexp_code) {
String &string=*new(pool) String(pool);	int exec_result=pcre_exec(regexp_code, 0,
string.APPEND_TAINTED(file_name, file_name_size,	ffblk.ff_name, file_name_size, 0,
method_name.origin().file, method_name.origin().line);	0, ovector, ovecsize);
row+=&string;
table+=&row;	if(exec_result==PCRE_ERROR_NOMATCH)
	suits=false;
	else if(exec_result<0) {
	(*pcre_free)(regexp_code);
	PTHROW(0, 0,
	regexp,
	"regular expression execute (%d)",
	exec_result);
	}
	}

	if(suits) {
	char file_name_cstr=(char )r.malloc(file_name_size);
	memcpy(file_name_cstr, ffblk.ff_name, file_name_size);
	String &file_name=*new(pool) String(pool);
	file_name.APPEND(file_name_cstr, file_name_size, String::UL_FILE_NAME,
	method_name.origin().file, method_name.origin().line);

	Array& row=*new(pool) Array(pool);
	row+=&file_name;
	table+=&row;
	}
);	);

	if(regexp_code)
	(*pcre_free)(regexp_code);

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

// initialize	// constructor
void initialize_table_class(Pool& pool, VStateless_class& vclass) {
	MTable::MTable(Pool& apool) : Methoded(apool) {
	set_name(*NEW String(pool(), TABLE_CLASS_NAME));

// ^table:set{data}	// ^table:set{data}
// ^table:set[nameless]{data}	// ^table:set[nameless]{data}
vclass.add_native_method("set", Method::CT_DYNAMIC, _set, 1, 2);	add_native_method("set", Method::CT_DYNAMIC, _set, 1, 2);

// ^table:load[file]	// ^table:load[file]
// ^table:load[nameless;file]	// ^table:load[nameless;file]
vclass.add_native_method("load", Method::CT_DYNAMIC, _load, 1, 2);	add_native_method("load", Method::CT_DYNAMIC, _load, 1, 2);

// ^table.save[file]	// ^table.save[file]
// ^table.save[nameless;file]	// ^table.save[nameless;file]
vclass.add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);	add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);

// ^table.count[]	// ^table.count[]
vclass.add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0);	add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0);

// ^table.line[]	// ^table.line[]
vclass.add_native_method("line", Method::CT_DYNAMIC, _line, 0, 0);	add_native_method("line", Method::CT_DYNAMIC, _line, 0, 0);

// ^table.offset[]	// ^table.offset[]
// ^table.offset[offset]	// ^table.offset[offset]
vclass.add_native_method("offset", Method::CT_DYNAMIC, _offset, 0, 1);	add_native_method("offset", Method::CT_DYNAMIC, _offset, 0, 1);

// ^table.menu{code}	// ^table.menu{code}
// ^table.menu{code}[delim]	// ^table.menu{code}[delim]
vclass.add_native_method("menu", Method::CT_DYNAMIC, _menu, 1, 2);	add_native_method("menu", Method::CT_DYNAMIC, _menu, 1, 2);

// ^table.empty{code-when-empty}	// ^table.empty{code-when-empty}
// ^table.empty{code-when-empty}{code-when-not}	// ^table.empty{code-when-empty}{code-when-not}
vclass.add_native_method("empty", Method::CT_DYNAMIC, _empty, 1, 2);	add_native_method("empty", Method::CT_DYNAMIC, _empty, 1, 2);

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

// ^table.sort{string-key-maker} ^table.sort{string-key-maker}[asc\|desc]	// ^table.sort{string-key-maker} ^table.sort{string-key-maker}[asc\|desc]
// ^table.sort(numeric-key-maker) ^table.sort(numeric-key-maker)[asc\|desc]	// ^table.sort(numeric-key-maker) ^table.sort(numeric-key-maker)[asc\|desc]
vclass.add_native_method("sort", Method::CT_DYNAMIC, _sort, 1, 2);	add_native_method("sort", Method::CT_DYNAMIC, _sort, 1, 2);

// ^table.locate[field;value]	// ^table.locate[field;value]
vclass.add_native_method("locate", Method::CT_DYNAMIC, _locate, 2, 2);	add_native_method("locate", Method::CT_DYNAMIC, _locate, 2, 2);
// ^table.found{when-found}	// ^table.found{when-found}
// ^table.found{when-found}{when-not-found}	// ^table.found{when-found}{when-not-found}
vclass.add_native_method("found", Method::CT_DYNAMIC, _found, 1, 2);	add_native_method("found", Method::CT_DYNAMIC, _found, 1, 2);

// ^table.flip[]	// ^table.flip[]
vclass.add_native_method("flip", Method::CT_DYNAMIC, _flip, 0, 0);	add_native_method("flip", Method::CT_DYNAMIC, _flip, 0, 0);

// ^table.append{r{tab}e{tab}c{tab}o{tab}r{tab}d}	// ^table.append{r{tab}e{tab}c{tab}o{tab}r{tab}d}
vclass.add_native_method("append", Method::CT_DYNAMIC, _append, 1, 1);	add_native_method("append", Method::CT_DYNAMIC, _append, 1, 1);

// ^table.join[table]	// ^table.join[table]
vclass.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][(count[;offset])]
vclass.add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 3);	add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 3);

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

	// global variable

	Methoded *table_class;

	// creator

	Methoded *MTable_create(Pool& pool) {
	return table_class=new(pool) MTable(pool);
}	}

E-mail:

Removed from v.1.58
changed lines
	Added in v.1.71