--- parser3/src/classes/table.C 2001/04/03 05:23:37 1.44 +++ parser3/src/classes/table.C 2001/05/08 06:42:54 1.73 @@ -1,34 +1,52 @@ /** @file - Parser: table parser class. + Parser: @b table parser class. Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com) Author: Alexander Petrosyan (http://design.ru/paf) - $Id: table.C,v 1.44 2001/04/03 05:23:37 paf Exp $ + $Id: table.C,v 1.73 2001/05/08 06:42:54 paf Exp $ */ #include "pa_config_includes.h" + +#include "pcre.h" + +#include "classes.h" #include "pa_common.h" #include "pa_request.h" -#include "_table.h" #include "pa_vtable.h" #include "pa_vint.h" +#include "pa_sql_connection.h" +#include "pa_dir.h" +#include "pa_vbool.h" + +// defines + +#define TABLE_CLASS_NAME "table" -// global var +// class -VStateless_class *table_class; +class MTable : public Methoded { +public: // VStateless_class + Value *create_new_value(Pool& pool) { return new(pool) VTable(pool); } + +public: + MTable(Pool& pool); + +public: // Methoded + bool used_directly() { return true; } +}; // 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(); // data is last parameter - Value *vdata=static_cast(params->get(params->size()-1)); - // forcing {this body type} - r.fail_if_junction_(false, *vdata, method_name, "body must be junction"); + Value& vdata=params->get_junction(params->size()-1, "body must be code"); - Temp_lang temp_lang(r, String::UL_AS_IS); - const String& data=r.process(*vdata).as_string(); + Temp_lang temp_lang(r, String::UL_PASS_APPENDED); + const String& data=r.process(vdata).as_string(); size_t pos_after=0; // parse columns @@ -64,19 +82,14 @@ static void _set(Request& r, const Strin static_cast(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(); // filename is last parameter - Value *vfilename=static_cast(params->get(params->size()-1)); - // forcing [this file name type] - r.fail_if_junction_(true, *vfilename, - method_name, "file name must not be junction"); - - // forcing untaint language - String lfilename(pool); - lfilename.append(vfilename->as_string(), String::UL_FILE_NAME, true); + Value& vfilename=params->get_no_junction(params->size()-1, + "file name must not be code"); + // loading text - char *data=file_read_text(pool, r.absolute(lfilename)); + char *data=file_read_text(pool, r.absolute(vfilename.as_string())); // parse columns Array *columns; @@ -93,8 +106,7 @@ static void _load(Request& r, const Stri if(char *row_chars=getrow(&data)) do { String *name=new(pool) String(pool); - // never reaches user, can mark it 'clean' - name->APPEND_CLEAN(lsplit(&row_chars, '\t'), 0, file, line++); + name->APPEND_TAINTED(lsplit(&row_chars, '\t'), 0, file, line++); *columns+=name; } while(row_chars); } @@ -119,17 +131,10 @@ static void _load(Request& r, const Stri static_cast(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(); - Value *vtable_name=static_cast(params->get(params->size()-1)); - // forcing this body type] - r.fail_if_junction_(true, *vtable_name, - method_name, "file name must not be junction"); - - // forcing untaint language - String ltable_name(pool); - ltable_name.append(vtable_name->as_string(), - String::UL_FILE_NAME, true); + Value& vtable_name=params->get_no_junction(params->size()-1, + "file name must not be code"); Table& table=static_cast(r.self)->table(); @@ -169,43 +174,42 @@ static void _save(Request& r, const Stri } // write - file_write(pool, r.absolute(ltable_name), sdata.cstr(), sdata.size(), true); + file_write(pool, r.absolute(vtable_name.as_string()), + 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(); Value& value=*new(pool) VInt(pool, static_cast(r.self)->table().size()); 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(); Value& value=*new(pool) VInt(pool, 1+static_cast(r.self)->table().current()); 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(); Table& table=static_cast(r.self)->table(); if(params->size()) - table.shift((int)r.process(*static_cast(params->get(0))).as_double()); + table.shift((int)r.process(params->get(0)).as_double()); else { Value& value=*new(pool) VInt(pool, table.current()); r.write_no_lang(value); } } -static void _menu(Request& r, const String& method_name, Array *params) { - Value& body_code=*static_cast(params->get(0)); - // forcing ^menu{this param type} - r.fail_if_junction_(false, body_code, - method_name, "body must be junction"); +static void _menu(Request& r, const String& method_name, MethodParams *params) { + Value& body_code=params->get_junction(0, "body must be code"); - Value *delim_code=params->size()==2?static_cast(params->get(1)):0; + Value *delim_code=params->size()==2?¶ms->get(1):0; - Table& table=static_cast(r.self)->table(); + VTable& vtable=*static_cast(r.self); + Table& table=vtable.table(); bool need_delim=false; - int saved_current=table.current(); + vtable.lock(); int saved_current=table.current(); for(int row=0; row(r.self)->table(); - if(table.size()==0) { - Value& value=r.process(*static_cast(params->get(0))); - r.write_pass_lang(value); - } else if(params->size()==2) { - Value& value=r.process(*static_cast(params->get(1))); - r.write_pass_lang(value); - } + if(table.size()==0) + r.write_pass_lang(r.process(params->get(0))); + else if(params->size()>1) + r.write_pass_lang(r.process(params->get(1))); } +/// used by table: _record / store_column_item_to_hash struct Record_info { Pool *pool; Table *table; @@ -240,23 +242,22 @@ struct Record_info { static void store_column_item_to_hash(Array::Item *item, void *info) { Record_info& ri=*static_cast(info); String& column_name=*static_cast(item); - const String *column_item=ri.table->item(column_name); Value *value; - if(column_item) + 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, Array *params) { +static void _record(Request& r, const String& method_name, MethodParams *params) { Table& table=static_cast(r.self)->table(); if(const Array *columns=table.columns()) { Pool& pool=r.pool(); - Value& value=*new(pool) VHash(pool); - Record_info record_info={&pool, &table, value.get_hash()}; + 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); - - r.write_no_lang(value); + result.set_name(method_name); + r.write_no_lang(result); } } @@ -283,19 +284,12 @@ static int sort_cmp_double(const void *a else return 0; } -static void _sort(Request& r, const String& method_name, Array *params) { - Value& key_maker=*(Value *)params->get(0); - // forcing ^sort{this} ^sort(or this) param type - r.fail_if_junction_(false, key_maker, method_name, "key-maker must be junction"); - - bool reverse; - 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 junction"); - reverse=order.as_string()=="desc"; - } else - reverse=false; +static void _sort(Request& r, const String& method_name, MethodParams *params) { + Value& key_maker=params->get_junction(0, "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": + false; Table& table=static_cast(r.self)->table(); @@ -311,7 +305,7 @@ static void _sort(Request& r, const Stri for(i=0; i(r.self); Table& table=vtable.table(); - vtable.last_locate_was_successful=table.locate( - static_cast(params->get(0))->as_string(), - static_cast(params->get(1))->as_string()); -} - -static void _found(Request& r, const String& method_name, Array *params) { - if(static_cast(r.self)->last_locate_was_successful) { - Value& then_code=*static_cast(params->get(0)); - // forcing ^found{this param type} - r.fail_if_junction_(false, then_code, - method_name, "found-parameter must be junction"); - r.write_pass_lang(r.process(then_code)); - } else if(params->size()==2) { - Value& else_code=*static_cast(params->get(1)); - // forcing ^found{this param type} - r.fail_if_junction_(false, else_code, - method_name, "not found-parameter must be junction"); - r.write_pass_lang(r.process(else_code)); - } + Value& result=*new(pool) VBool(pool, table.locate( + params->get(0).as_string(), + params->get(1).as_string())); + result.set_name(method_name); + r.write_no_lang(result); } -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(); VTable& vtable=*static_cast(r.self); @@ -377,48 +359,36 @@ static void _flip(Request& r, const Stri vtable.set_table(new_table); } -/// @test use String::split -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(); // data is last parameter - Value *value=static_cast(params->get(0)); - // forcing [this body type] - r.fail_if_junction_(true, *value, method_name, "body must not be junction"); - - const String& string=static_cast(value)->as_string(); + const String& string= + r.process(params->get_junction(0, "body must be code")).as_string(); // parse cells Array& row=*new(pool) Array(pool); - size_t pos_after=0; - int pos_before; - while((pos_before=string.pos("\t", 1, pos_after, String::UL_CLEAN))>=0) { - row+=&string.piece(pos_after, pos_before); - pos_after=pos_before+1/*\t*/; - } - // last piece - if(pos_after(r.self)->table()+=&row; + VTable& vtable=*static_cast(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(); - Value *value=static_cast(params->get(0)); - // forcing [this table ref type] - r.fail_if_junction_(true, *value, method_name, "table ref must not be junction"); - - Table *maybe_src=value->get_table(); + Table *maybe_src=params->get_no_junction(0, "table ref must not be code").get_table(); if(!maybe_src) - RTHROW(0, 0, + PTHROW(0, 0, &method_name, "source is not a table"); Table& src=*maybe_src; Table& dest=static_cast(r.self)->table(); if(&src == &dest) - RTHROW(0, 0, + PTHROW(0, 0, &method_name, "source and destination are same table"); @@ -438,58 +408,225 @@ static void _join(Request& r, const Stri } } -// initialize +static void _sql(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->get_junction(0, "statement must be code"); + + 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; + if(params->size()>2) { + Value& offset_code=params->get_junction(2, "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, limit, + &sql_column_count, &sql_columns, + &sql_row_count, &sql_rows); + } + PCATCH(e) { // connect/process 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()); + + Array& table_columns=*new(pool) Array(pool); + for(unsigned int i=0; i(r.self)->set_table(table); +} + +static void _dir(Request& r, const String& method_name, MethodParams *params) { + Pool& pool=r.pool(); + + Value& relative_path=params->get_no_junction(0, "path must not be code"); + + const String *regexp; + pcre *regexp_code; + int ovecsize; + int *ovector; + if(params->size()>1) { + regexp=¶ms->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, + ®exp->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()) + .cstr(String::UL_FILE_NAME); + + Array& columns=*new(pool) Array(pool); + columns+=new(pool) String(pool, "name"); + Table& table=*new(pool) Table(pool, &method_name, &columns); + + LOAD_DIR(absolute_path_cstr, + size_t file_name_size=strlen(ffblk.ff_name); + bool suits=true; + if(regexp_code) { + int exec_result=pcre_exec(regexp_code, 0, + ffblk.ff_name, file_name_size, 0, + 0, ovector, ovecsize); + + 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; + } + ); -void initialize_table_class(Pool& pool, VStateless_class& vclass) { - // ^table.set{data} - // ^table.set[nameless]{data} - vclass.add_native_method("set", Method::CT_DYNAMIC, _set, 1, 2); - - // ^table.load[file] - // ^table.load[nameless;file] - vclass.add_native_method("load", Method::CT_DYNAMIC, _load, 1, 2); + if(regexp_code) + (*pcre_free)(regexp_code); + + // replace any previous table value + static_cast(r.self)->set_table(table); +} + +// constructor + +MTable::MTable(Pool& apool) : Methoded(apool) { + set_name(*NEW String(pool(), TABLE_CLASS_NAME)); + + // ^table:set{data} + // ^table:set[nameless]{data} + add_native_method("set", Method::CT_DYNAMIC, _set, 1, 2); + + // ^table:load[file] + // ^table:load[nameless;file] + add_native_method("load", Method::CT_DYNAMIC, _load, 1, 2); // ^table.save[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[] - vclass.add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0); + add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0); // ^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[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}[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}{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[] - 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(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] - vclass.add_native_method("locate", Method::CT_DYNAMIC, _locate, 2, 2); - // ^table.found{when-found} - // ^table.found{when-found}{when-not-found} - vclass.add_native_method("found", Method::CT_DYNAMIC, _found, 1, 2); + add_native_method("locate", Method::CT_DYNAMIC, _locate, 2, 2); // ^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} - vclass.add_native_method("append", Method::CT_DYNAMIC, _append, 1, 1); + add_native_method("append", Method::CT_DYNAMIC, _append, 1, 1); // ^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])] + add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 3); + + // ^table:dir[path] + // ^table:dir[path][regexp] + 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); }