[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.53 and 1.63

version 1.53, 2001/05/21 16:38:46 version 1.63, 2001/07/18 10:06:04
Line 4 Line 4
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
   
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)          Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
   
         $Id$  
 */  */
   static const char *RCSId="$Id$"; 
   
 #include "classes.h"  #include "classes.h"
 #include "pa_request.h"  #include "pa_request.h"
Line 24 Line 23
 // 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
Line 59  static void _double(Request& r, const St Line 55  static void _double(Request& r, const St
 /*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) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& fmt=params->get_junction(0, "fmt must be code");          Value& fmt=params->as_junction(0, "fmt must be code");
   
         Temp_lang temp_lang(r, String::UL_PASS_APPENDED);          Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
         char *buf=format(pool, r.self->as_double(), r.process(fmt).as_string().cstr());          char *buf=format(pool, r.self->as_double(), r.process(fmt).as_string().cstr());
           
         r.write_no_lang(String(pool, buf));          String result(pool);
           result.APPEND_CLEAN(buf, 0, 
                   method_name.origin().file,
                   method_name.origin().line);
           r.write_no_lang(result);
 }  }
   
 static void _left(Request& r, const String&, MethodParams *params) {  static void _left(Request& r, const String&, MethodParams *params) {
Line 98  static void _mid(Request& r, const Strin Line 98  static void _mid(Request& r, const Strin
 static void _pos(Request& r, const String& method_name, MethodParams *params) {  static void _pos(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Value& substr=params->get_no_junction(0, "substr must not be code");          Value& substr=params->as_no_junction(0, "substr must not be code");
                   
         const String& string=*static_cast<VString *>(r.self)->get_string();          const String& string=*static_cast<VString *>(r.self)->get_string();
         r.write_assign_lang(*new(pool) VInt(pool, string.pos(substr.as_string())));          r.write_assign_lang(*new(pool) VInt(pool, string.pos(substr.as_string())));
Line 107  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) {
         Value& delim_value=params->get_no_junction(0, "delimiter must not be code");          Value& delim_value=params->as_no_junction(0, "delimiter must not be code");
   
         string.split(result, 0, delim_value.as_string());          string.split(result, 0, delim_value.as_string());
 }  }
Line 116  static void _lsplit(Request& r, const St Line 116  static void _lsplit(Request& r, const St
         Pool& pool=r.pool();          Pool& pool=r.pool();
         const String& string=*static_cast<VString *>(r.self)->get_string();          const String& string=*static_cast<VString *>(r.self)->get_string();
   
         Array& row=*new(pool) Array(pool);          Array pieces(pool);
         split_list(r, method_name, params, string, row);          split_list(r, method_name, params, string, pieces);
   
         Table& table=*new(pool) Table(pool, &string,           Array& columns=*new(pool) Array(pool);
                 0/*nameless*/, 1/*row preallocate(and only)*/);          columns+=new(pool) String(pool, "piece");
         table+=&row;  
   
           Table& table=*new(pool) Table(pool, &string, 
                   &columns, pieces.size());
           int size=pieces.quick_size();
           for(int i=0; i<size; i++) {
                   Array& row=*new(pool) Array(pool);
                   row+=pieces.quick_get(i);
                   table+=&row;
           }
         r.write_no_lang(*new(pool) VTable(pool, &table));          r.write_no_lang(*new(pool) VTable(pool, &table));
 }  }
   
Line 130  static void _rsplit(Request& r, const St Line 137  static void _rsplit(Request& r, const St
         Pool& pool=r.pool();          Pool& pool=r.pool();
         const String& string=*static_cast<VString *>(r.self)->get_string();          const String& string=*static_cast<VString *>(r.self)->get_string();
   
         Array list(pool);          Array pieces(pool);
         split_list(r, method_name, params, string, list);          split_list(r, method_name, params, string, pieces);
   
         Array& row=*new(pool) Array(pool);          Array& columns=*new(pool) Array(pool);
         for(int i=list.size(); --i>=0; )          columns+=new(pool) String(pool, "piece");
                 row+=list.get(i);  
   
         Table& table=*new(pool) Table(pool, &string,           Table& table=*new(pool) Table(pool, &string, 
                 0/*nameless*/, 1/*row preallocate(and only)*/);                  &columns, pieces.size());
         table+=&row;          for(int i=pieces.size(); --i>=0; ) {
                   Array& row=*new(pool) Array(pool);
                   row+=pieces.get(i);
                   table+=&row;
           }
   
         r.write_no_lang(*new(pool) VTable(pool, &table));          r.write_no_lang(*new(pool) VTable(pool, &table));
 }  }
Line 194  static void _match(Request& r, const Str Line 204  static void _match(Request& r, const Str
         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();
   
         Value& regexp=params->get_no_junction(0, "regexp must not be code");          Value& regexp=params->as_no_junction(0, "regexp must not be code");
   
         const String *options=          const String *options=
                 params->size()>1?                  params->size()>1?
                 &params->get_no_junction(1, "options must not be code").as_string():0;                  &params->as_no_junction(1, "options must not be code").as_string():0;
   
         Value *result;          Value *result;
         Temp_lang temp_lang(r, String::UL_PASS_APPENDED);          Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
         Table *table;          Table *table;
         if(params->size()<3) { // search          if(params->size()<3) { // search
                 if(src.match(r.pcre_tables,                  bool matched=src.match(r.pcre_tables,
                         &method_name,                           &method_name, 
                         regexp.as_string(), options,                          regexp.as_string(), options,
                         &table,                          &table,
                         search_action, 0)) {                          search_action, 0);
                         // matched                  // matched
                         if(table->columns()->size()==3 && // just matched[3=pre/match/post], no substrings                  if(table->columns()->size()==3 && // just matched[3=pre/match/post], no substrings
                                 table->size()==1)  // just one row, not /g_lobal search                          table->size()<=1)  // just one row, not /g_lobal search
                                 result=new(pool) VBool(pool, true);                          result=new(pool) VBool(pool, matched);
                         else // table of pre/match/post+substrings                  else // table of pre/match/post+substrings
                                 result=new(pool) VTable(pool, table);                          result=new(pool) VTable(pool, table);
                 } else // not matched [not global]  
                         result=new(pool) VBool(pool, false);  
         } else { // replace          } else { // replace
                 Value& replacement_code=params->get_junction(2, "replacement code must be code");                  Value& replacement_code=params->as_junction(2, "replacement code must be code");
   
                 String& dest=*new(pool) String(pool);                  String& dest=*new(pool) String(pool);
                 Replace_action_info replace_action_info={                  Replace_action_info replace_action_info={
Line 253  static void _lower(Request& r, const Str Line 261  static void _lower(Request& r, const Str
         change_case(r, method_name, params, String::CC_LOWER);          change_case(r, method_name, params, String::CC_LOWER);
 }  }
   
 String& sql_result_string(Request& r, const String& method_name, MethodParams *params) {  const String* sql_result_string(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         if(!r.connection)          if(!r.connection)
Line 261  String& sql_result_string(Request& r, co Line 269  String& sql_result_string(Request& r, co
                         &method_name,                          &method_name,
                         "without connect");                          "without connect");
   
         Value& statement=params->get_junction(0, "statement must be code");          Value& statement=params->as_junction(0, "statement must be code");
   
         ulong offset=0;          ulong offset=(ulong)(params->size()>2?params->as_int(2, r):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);          Temp_lang temp_lang(r, String::UL_SQL);
         const String& statement_string=r.process(statement).as_string();          const String& statement_string=r.process(statement).as_string();
Line 294  String& sql_result_string(Request& r, co Line 298  String& sql_result_string(Request& r, co
         if(sql_column_count!=1)          if(sql_column_count!=1)
                 PTHROW(0, 0,                  PTHROW(0, 0,
                         &statement_string,                          &statement_string,
                         "result must contain only one column");                          "result must contain exactly one column");
   
           if(!sql_row_count)
                   return 0; // no lines, should return second param[default value]
   
         if(sql_row_count!=1)          if(sql_row_count>1)
                 PTHROW(0, 0,                  PTHROW(0, 0,
                         &statement_string,                          &statement_string,
                         "result must contain only one row");                          "result must not contain more then one row");   
   
         String& result=*new(pool) String(pool);          String *result=new(pool) String(pool);
         SQL_Driver::Cell& cell=sql_rows[0][0];          SQL_Driver::Cell& cell=sql_rows[0][0];
         result.APPEND_TAINTED(          result->APPEND_TAINTED(
                 (const char *)cell.ptr, cell.size,                  (const char *)cell.ptr, cell.size,
                 statement_cstr, 0);                  statement_cstr, 0);
                   
Line 313  String& sql_result_string(Request& r, co Line 320  String& sql_result_string(Request& r, co
 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();
   
         VString& result=*new(pool) VString(sql_result_string(r, method_name, params));          const String *string=sql_result_string(r, method_name, params);
           if(!string) {
                   Value& default_code=params->as_junction(1, "default result must code");
                   Value& processed_code=r.process(default_code);
                   string=processed_code.get_string();
                   if(!string)
                           string=empty_string;
           }
           VString& result=*new(pool) VString(*string);
         result.set_name(method_name);          result.set_name(method_name);
         r.write_assign_lang(result);          r.write_assign_lang(result);
 }  }
Line 360  MString::MString(Pool& apool) : Methoded Line 375  MString::MString(Pool& apool) : Methoded
         // ^string.tolower[]          // ^string.tolower[]
         add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);          add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);
   
         // ^string:sql[query]          // ^string:sql[query]{default}
         // ^string:sql[query](offset)          // ^string:sql[query]{default}(offset)
         add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 2);          add_native_method("sql", Method::CT_STATIC, _sql, 2, 3);
 }         }       
   
 // global variable  // global variable
Removed from v.1.53  
changed lines
  Added in v.1.63

E-mail: