--- parser3/src/classes/table.C 2001/04/20 14:18:30 1.63 +++ parser3/src/classes/table.C 2001/05/08 10:23:50 1.78 @@ -5,26 +5,41 @@ Author: Alexander Petrosyan (http://design.ru/paf) - $Id: table.C,v 1.63 2001/04/20 14:18:30 paf Exp $ + $Id: table.C,v 1.78 2001/05/08 10:23:50 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" -// global var +// defines -VStateless_class *table_class; +#define TABLE_CLASS_NAME "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, MethodParams *params) { Pool& pool=r.pool(); // data is last parameter @@ -178,23 +193,24 @@ static void _line(Request& r, const Stri 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(params->get(0)).as_double()); - else { + if(params->size()) { + Value& offset_expr=params->get_junction(0, "offset must be expression"); + table.shift((int)r.process(offset_expr).as_double()); + } else { Value& value=*new(pool) VInt(pool, table.current()); r.write_no_lang(value); } } -/// @test $a.menu{ $a[123] } 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?¶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) - r.write_pass_lang(r.process(params->get(0))); - else if(params->size()>1) - r.write_pass_lang(r.process(params->get(1))); + + 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; @@ -226,27 +242,88 @@ 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, MethodParams *params) { +static void _record(Request& r, const String& method_name, MethodParams *) { 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); + result.set_name(method_name); + r.write_no_lang(result); + } +} + +/// used by table: _hash / table_row_to_hash +struct Row_info { + Table *table; + int key_field; + Array *value_fields; + Hash *hash; +}; +static void table_row_to_hash(Array::Item *value, void *info) { + Array& row=*static_cast(value); + Row_info& ri=*static_cast(info); + Pool& pool=ri.table->pool(); + + if(ri.key_fieldsize(); i++) { + int value_field=ri.value_fields->get_int(i); + if(value_fieldcolumns()->get_string(value_field), + new(pool) VString(*row.get_string(value_field))); + } - r.write_no_lang(value); + ri.hash->put(*row.get_string(ri.key_field), &result); } } +static void _hash(Request& r, const String& method_name, MethodParams *params) { + Table& table=static_cast(r.self)->table(); + if(const Array *columns=table.columns()) + if(columns->size()>1) { + Pool& pool=r.pool(); + + const String& key_field_name=params->get_no_junction(0, + "key field name must not be code").as_string(); + int key_field=table.column_name2index(key_field_name, true); + int value_fields_count=params->size()-1; + bool value_fields_by_params=value_fields_count!=0; + if(!value_fields_by_params) + value_fields_count=columns->size()-1; // all columns except key + Array value_fields(pool, value_fields_count); + if(value_fields_by_params) { + for(int i=1; isize(); i++) { + const String& value_field_name=params->get_no_junction(i, + "value field name must not be code").as_string(); + value_fields+=table.column_name2index(value_field_name, true); + } + } else { // by all columns except key + for(int i=0; isize(); i++) + if(i!=key_field) + value_fields+=i; + } + + // integers: key_field & value_fields + Value& result=*new(pool) VHash(pool); + Row_info row_info={&table, key_field, &value_fields, result.get_hash()}; + table.for_each(table_row_to_hash, &row_info); + result.set_name(method_name); + r.write_no_lang(result); + } +} -struct Seq_item { +/// used by table: _sort / sort_cmp_string|sort_cmp_double +struct Table_seq_item { Array *row; union { char *c_str; @@ -255,13 +332,13 @@ struct Seq_item { }; static int sort_cmp_string(const void *a, const void *b) { return strcmp( - static_cast(a)->value.c_str, - static_cast(b)->value.c_str + static_cast(a)->value.c_str, + static_cast(b)->value.c_str ); } static int sort_cmp_double(const void *a, const void *b) { - double va=static_cast(a)->value.d; - double vb=static_cast(b)->value.d; + double va=static_cast(a)->value.d; + double vb=static_cast(b)->value.d; if(vavb) @@ -282,7 +359,7 @@ static void _sort(Request& r, const Stri if(!table.size()) return; - Seq_item *seq=(Seq_item *)malloc(sizeof(Seq_item)*table.size()); + Table_seq_item *seq=(Table_seq_item *)malloc(sizeof(Table_seq_item)*table.size()); int i; // calculate key values @@ -301,7 +378,7 @@ static void _sort(Request& r, const Stri seq[i].value.d=value.as_double(); } // sort keys - _qsort(seq, table.size(), sizeof(Seq_item), + _qsort(seq, table.size(), sizeof(Table_seq_item), key_values_are_strings?sort_cmp_string:sort_cmp_double); // reorder table as they require in 'seq' @@ -313,18 +390,15 @@ static void _sort(Request& r, const Stri } static void _locate(Request& r, const String& method_name, MethodParams *params) { + Pool& pool=r.pool(); + VTable& vtable=*static_cast(r.self); Table& table=vtable.table(); - vtable.last_locate_was_successful=table.locate( + Value& result=*new(pool) VBool(pool, table.locate( params->get(0).as_string(), - params->get(1).as_string()); -} - -static void _found(Request& r, const String& method_name, MethodParams *params) { - if(static_cast(r.self)->last_locate_was_successful) - r.write_pass_lang(r.process(params->get_junction(0, "found-parameter must be code"))); - else if(params->size()==2) - r.write_pass_lang(r.process(params->get_junction(0, "else-parameter must be code"))); + params->get(1).as_string())); + result.set_name(method_name); + r.write_no_lang(result); } static void _flip(Request& r, const String& method_name, MethodParams *params) { @@ -357,7 +431,11 @@ static void _append(Request& r, const St Array& row=*new(pool) Array(pool); string.split(row, 0, "\t", 1, String::UL_CLEAN); - static_cast(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, MethodParams *params) { @@ -392,7 +470,6 @@ static void _join(Request& r, const Stri } } -/// ^table:sql{query}[(count[;offset])] static void _sql(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); @@ -468,8 +545,6 @@ static void _sql(Request& r, const Strin static_cast(r.self)->set_table(table); } -/// ^table:dir[path] -/// ^table:dir[path][regexp] static void _dir(Request& r, const String& method_name, MethodParams *params) { Pool& pool=r.pool(); @@ -529,7 +604,7 @@ static void _dir(Request& r, const Strin 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_TAINTED(file_name_cstr, file_name_size, + 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); @@ -545,65 +620,80 @@ static void _dir(Request& r, const Strin static_cast(r.self)->set_table(table); } -// initialize -void initialize_table_class(Pool& pool, VStateless_class& vclass) { +// constructor + +MTable::MTable(Pool& apool) : Methoded(apool) { + set_name(*NEW String(pool(), TABLE_CLASS_NAME)); + // ^table:set{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[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[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); + // ^table.empty[] + add_native_method("empty", Method::CT_DYNAMIC, _empty, 0, 0); // ^table.record[] - vclass.add_native_method("record", Method::CT_DYNAMIC, _record, 0, 0); + add_native_method("record", Method::CT_DYNAMIC, _record, 0, 0); + + /** @fn _hash + ^table:hash[key field name] + ^table:hash[key field name][value field name;...] + */ + add_native_method("hash", Method::CT_DYNAMIC, _hash, 1, 1000); // ^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])] - 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][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); }