[BACK]Return to table.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/table.C between versions 1.62 and 1.72

version 1.62, 2001/04/15 13:32:39 version 1.72, 2001/05/08 06:00:34
Line 12 Line 12
   
 #include "pcre.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"
   #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  // methods
   
 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
Line 186  static void _offset(Request& r, const St Line 201  static void _offset(Request& r, const St
         }          }
 }  }
   
 /// @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, MethodParams *params) {
         Value& body_code=params->get_junction(0, "body must be code");          Value& body_code=params->get_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;
   
         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 207  static void _menu(Request& r, const Stri Line 222  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, MethodParams *params) {  static void _empty(Request& r, const String& method_name, MethodParams *params) {
Line 218  static void _empty(Request& r, const Str Line 233  static void _empty(Request& r, const Str
                 r.write_pass_lang(r.process(params->get(1)));                  r.write_pass_lang(r.process(params->get(1)));
 }  }
   
   /// used by table: _record / store_column_item_to_hash
 struct Record_info {  struct Record_info {
         Pool *pool;          Pool *pool;
         Table *table;          Table *table;
Line 313  static void _sort(Request& r, const Stri Line 329  static void _sort(Request& r, const Stri
 }  }
   
 static void _locate(Request& r, const String& method_name, MethodParams *params) {  static void _locate(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
   
         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(          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);
           r.write_no_lang(result);
 static void _found(Request& r, const String& method_name, MethodParams *params) {  
         if(static_cast<VTable *>(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")));  
 }  }
   
 static void _flip(Request& r, const String& method_name, MethodParams *params) {  static void _flip(Request& r, const String& method_name, MethodParams *params) {
Line 357  static void _append(Request& r, const St Line 370  static void _append(Request& r, const St
         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, MethodParams *params) {  static void _join(Request& r, const String& method_name, MethodParams *params) {
Line 392  static void _join(Request& r, const Stri Line 409  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, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
Line 468  static void _sql(Request& r, const Strin Line 484  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]  
 /// ^table:dir[path][regexp]  
 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();
   
Line 487  static void _dir(Request& r, const Strin Line 501  static void _dir(Request& r, const Strin
                 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,
                         pcre_tables);                          r.pcre_tables);
   
                 if(!regexp_code)                  if(!regexp_code)
                         PTHROW(0, 0,                          PTHROW(0, 0,
Line 529  static void _dir(Request& r, const Strin Line 543  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_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);                                  method_name.origin().file, method_name.origin().line);
                                   
                         Array& row=*new(pool) Array(pool);                          Array& row=*new(pool) Array(pool);
Line 545  static void _dir(Request& r, const Strin Line 559  static void _dir(Request& r, const Strin
         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}{when-not-found}  
         vclass.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);
 }  }
Removed from v.1.62  
changed lines
  Added in v.1.72

E-mail: