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

Diff for /parser3/src/classes/string.C between versions 1.44 and 1.53

version 1.44, 2001/05/04 10:42:37 version 1.53, 2001/05/21 16:38:46
Line 15 Line 15
 #include "pa_vtable.h"  #include "pa_vtable.h"
 #include "pa_vbool.h"  #include "pa_vbool.h"
 #include "pa_string.h"  #include "pa_string.h"
   #include "pa_sql_connection.h"
   
 // defines  // defines
   
Line 23 Line 24
 // class  // class
   
 class MString : public Methoded {  class MString : public Methoded {
   public: // VStateless_class
           Value *create_new_value(Pool& pool) { return new(pool) VString(pool); }
   
 public:  public:
         MString(Pool& pool);          MString(Pool& pool);
 public: // Methoded  public: // Methoded
         bool used_directly() { return false; }          bool used_directly() { return true; }
 };  };
   
 // methods  // methods
   
 static void _length(Request& r, const String&, MethodParams *) {  static void _length(Request& r, const String& method_name, MethodParams *) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         Value& value=*new(pool) VDouble(pool, r.self->get_string()->size());          Value& result=*new(pool) VDouble(pool, r.self->get_string()->size());
         r.write_no_lang(value);          result.set_name(method_name);
           r.write_no_lang(result);
 }  }
   
 static void _int(Request& r, const String&, MethodParams *) {  static void _int(Request& r, const String& method_name, MethodParams *) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         Value& value=*new(pool) VInt(pool, (int)r.self->as_double());          Value& result=*new(pool) VInt(pool, r.self->as_int());
         r.write_no_lang(value);          result.set_name(method_name);
           r.write_no_lang(result);
 }  }
   
 static void _double(Request& r, const String&, MethodParams *) {  static void _double(Request& r, const String& method_name, MethodParams *) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         Value& value=*new(pool) VDouble(pool, r.self->as_double());          Value& result=*new(pool) VDouble(pool, r.self->as_double());
         r.write_no_lang(value);          result.set_name(method_name);
           r.write_no_lang(result);
 }  }
   
 /*not static*/void _string_format(Request& r, const String& method_name, MethodParams *params) {  /*not static*/void _string_format(Request& r, const String& method_name, MethodParams *params) {
Line 100  static void _pos(Request& r, const Strin Line 107  static void _pos(Request& r, const Strin
 static void split_list(Request& r, const String& method_name, MethodParams *params,  static void split_list(Request& r, const String& method_name, MethodParams *params,
                                            const String& string,                                              const String& string, 
                                            Array& result) {                                             Array& result) {
         Pool& pool=r.pool();  
   
         Value& delim_value=params->get_no_junction(0, "delimiter must not be code");          Value& delim_value=params->get_no_junction(0, "delimiter must not be code");
   
         string.split(result, 0, delim_value.as_string(), String::UL_CLEAN, -1);          string.split(result, 0, delim_value.as_string());
 }  }
   
 static void _lsplit(Request& r, const String& method_name, MethodParams *params) {  static void _lsplit(Request& r, const String& method_name, MethodParams *params) {
Line 158  static void replace_action(Table& table, Line 163  static void replace_action(Table& table,
                 // piece from last match['start'] to beginning of this match['finish']                  // piece from last match['start'] to beginning of this match['finish']
                 if(start!=finish)                  if(start!=finish)
                         *ai.dest << ai.src->mid(start, finish);//ai.dest->APPEND_CONST("-");                          *ai.dest << ai.src->mid(start, finish);//ai.dest->APPEND_CONST("-");
                 // store found parts in one-record Vtable                  // store found parts in one-record VTable
                 if(table.size()) // middle                  if(table.size()) // middle
                         table.put(0, row);                          table.put(0, row);
                 else // begin                  else // begin
Line 168  static void replace_action(Table& table, Line 173  static void replace_action(Table& table,
                         vtable.set_name(*ai.origin);                          vtable.set_name(*ai.origin);
   
                         Junction *junction=ai.replacement_code->get_junction();                          Junction *junction=ai.replacement_code->get_junction();
                         junction->rcontext=junction->root=&vtable;                          junction->rcontext=/*must be some way to get to 
                                                              outside world junction->root=*/&vtable;
                         Value& replaced=ai.request->process(*ai.replacement_code, ai.origin, false);                          Value& replaced=ai.request->process(*ai.replacement_code, ai.origin, false);
   
                         /*                          /*
Line 183  static void replace_action(Table& table, Line 189  static void replace_action(Table& table,
                 *ai.dest << *ai.post_match;                  *ai.dest << *ai.post_match;
 }  }
   
 /** search/replace  /// @todo use pcre:study somehow
         ^string.match[regexp][options]  
         ^string.match[regexp][options]{replacement-code}  
 */  
 static void _match(Request& r, const String& method_name, MethodParams *params) {  static void _match(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         const String& src=*static_cast<VString *>(r.self)->get_string();          const String& src=*static_cast<VString *>(r.self)->get_string();
Line 235  static void _match(Request& r, const Str Line 238  static void _match(Request& r, const Str
         r.write_assign_lang(*result);          r.write_assign_lang(*result);
 }  }
   
   static void change_case(Request& r, const String& method_name, MethodParams *params, 
                                                   String::Change_case_kind kind) {
           Pool& pool=r.pool();
           const String& src=*static_cast<VString *>(r.self)->get_string();
   
           r.write_assign_lang(*new(pool) VString(src.change_case(pool, r.pcre_tables,
                   kind)));
   }
   static void _upper(Request& r, const String& method_name, MethodParams *params) {
           change_case(r, method_name, params, String::CC_UPPER);
   }
   static void _lower(Request& r, const String& method_name, MethodParams *params) {
           change_case(r, method_name, params, String::CC_LOWER);
   }
   
   String& sql_result_string(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 offset=0;
           if(params->size()>1) {
                   Value& offset_code=params->get_junction(1, "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, 0,
                           &sql_column_count, &sql_columns,
                           &sql_row_count, &sql_rows);
           }
           PCATCH(e) { // query 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());
           
           if(sql_column_count!=1)
                   PTHROW(0, 0,
                           &statement_string,
                           "result must contain only one column");
   
           if(sql_row_count!=1)
                   PTHROW(0, 0,
                           &statement_string,
                           "result must contain only one row");
   
           String& result=*new(pool) String(pool);
           SQL_Driver::Cell& cell=sql_rows[0][0];
           result.APPEND_TAINTED(
                   (const char *)cell.ptr, cell.size,
                   statement_cstr, 0);
           
           return result;
   }
   
   static void _sql(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
   
           VString& result=*new(pool) VString(sql_result_string(r, method_name, params));
           result.set_name(method_name);
           r.write_assign_lang(result);
   }
   
 // constructor  // constructor
   
 MString::MString(Pool& apool) : Methoded(apool) {  MString::MString(Pool& apool) : Methoded(apool) {
Line 271  MString::MString(Pool& apool) : Methoded Line 354  MString::MString(Pool& apool) : Methoded
         // ^string.match[regexp][options]          // ^string.match[regexp][options]
         // ^string.match[regexp][options]{replacement-code}          // ^string.match[regexp][options]{replacement-code}
         add_native_method("match", Method::CT_DYNAMIC, _match, 1, 3);          add_native_method("match", Method::CT_DYNAMIC, _match, 1, 3);
   
           // ^string.toupper[]
           add_native_method("upper", Method::CT_DYNAMIC, _upper, 0, 0);
           // ^string.tolower[]
           add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);
   
           // ^string:sql[query]
           // ^string:sql[query](offset)
           add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 2);
 }         }       
   
 // global variable  // global variable
Removed from v.1.44  
changed lines
  Added in v.1.53

E-mail: