[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.233 and 1.239

version 1.233, 2016/11/01 23:10:41 version 1.239, 2019/09/06 10:17:07
Line 1 Line 1
 /** @file  /** @file
         Parser: @b string parser class.          Parser: @b string parser class.
   
         Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)          Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
   
Line 172  static void _mid(Request& r, MethodParam Line 172  static void _mid(Request& r, MethodParam
   
         ssize_t sbegin=params.as_int(0, "p must be int", r);          ssize_t sbegin=params.as_int(0, "p must be int", r);
         if(sbegin<0)          if(sbegin<0)
                 throw Exception(PARSER_RUNTIME,                  throw Exception(PARSER_RUNTIME, 0,  "p(%d) must be >=0", sbegin);
                         0,   
                         "p(%d) must be >=0", sbegin);  
         size_t begin=(size_t)sbegin;          size_t begin=(size_t)sbegin;
   
         size_t end;          size_t end;
Line 182  static void _mid(Request& r, MethodParam Line 180  static void _mid(Request& r, MethodParam
         if(params.count()>1) {          if(params.count()>1) {
                 ssize_t sn=params.as_int(1, "n must be int", r);                  ssize_t sn=params.as_int(1, "n must be int", r);
                 if(sn<0)                  if(sn<0)
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", sn);
                                 0,   
                                 "n(%d) must be >=0", sn);  
                 end=begin+(size_t)sn;                  end=begin+(size_t)sn;
         } else {          } else {
                 length=string.length(r.charsets.source());                  length=string.length(r.charsets.source());
Line 238  static int split_options(const String* o Line 234  static int split_options(const String* o
                         if(options->pos(o->keyL)!=STRING_NOT_FOUND                           if(options->pos(o->keyL)!=STRING_NOT_FOUND 
                                 || (o->keyU && options->pos(o->keyU)!=STRING_NOT_FOUND)) {                                  || (o->keyU && options->pos(o->keyU)!=STRING_NOT_FOUND)) {
                                 if(result & o->checkBit)                                  if(result & o->checkBit)
                                         throw Exception(PARSER_RUNTIME,                                          throw Exception(PARSER_RUNTIME, options, "conflicting split options");
                                                 options,  
                                                 "conflicting split options");  
                                 result |= o->setBit;                                  result |= o->setBit;
                         }                          }
         }          }
Line 286  static Table& split_horizontal(ArrayStri Line 280  static Table& split_horizontal(ArrayStri
         return table;          return table;
 }  }
   
 static void split_with_options(Request& r, MethodParams& params,  static void split_with_options(Request& r, MethodParams& params, int bits) {
                                                            int bits) {  
         const String& string=GET_SELF(r, VString).string();          const String& string=GET_SELF(r, VString).string();
         size_t params_count=params.count();          size_t params_count=params.count();
   
Line 298  static void split_with_options(Request& Line 291  static void split_with_options(Request&
                 const String* options=0;                  const String* options=0;
                 if(params_count>1)                  if(params_count>1)
                         options=&params.as_string(1, OPTIONS_MUST_NOT_BE_CODE);                          options=&params.as_string(1, OPTIONS_MUST_NOT_BE_CODE);
                   
                 bits=split_options(options);                  bits=split_options(options);
         }          }
   
Line 309  static void split_with_options(Request& Line 301  static void split_with_options(Request&
         if(params_count>2){          if(params_count>2){
                 column_name=&params.as_string(2, COLUMN_NAME_MUST_BE_STRING);                  column_name=&params.as_string(2, COLUMN_NAME_MUST_BE_STRING);
                 if (horizontal && !column_name->is_empty())                   if (horizontal && !column_name->is_empty()) 
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME, column_name, "column name can't be specified with horisontal split");
                                 column_name,  
                                 "column name can't be specified with horisontal split");  
         }           } 
         if(!column_name || column_name->is_empty())          if(!column_name || column_name->is_empty())
                 column_name=new String("piece");                  column_name=new String("piece");
Line 345  struct Replace_action_info { Line 335  struct Replace_action_info {
 };  };
 #endif  #endif
 /// @todo they can do $global[$result] there, getting pointer to later-invalid local var, kill this  /// @todo they can do $global[$result] there, getting pointer to later-invalid local var, kill this
 static void replace_action(Table& table, ArrayString* row,   static void replace_action(Table& table, ArrayString* row, int prestart, int prefinish, int poststart, int postfinish, void *info) {
                                 int prestart, int prefinish,   
                                 int poststart, int postfinish,  
                                 void *info) {  
         Replace_action_info& ai=*static_cast<Replace_action_info *>(info);          Replace_action_info& ai=*static_cast<Replace_action_info *>(info);
         if(row) { // begin&middle          if(row) { // begin&middle
                 // piece from last match['prestart'] to beginning of this match['prefinish']                  // piece from last match['prestart'] to beginning of this match['prefinish']
Line 381  static void _match(Request& r, MethodPar Line 368  static void _match(Request& r, MethodPar
   
         if(Value* value=regexp.as(VREGEX_TYPE)){          if(Value* value=regexp.as(VREGEX_TYPE)){
                 if(options && options->is_defined())                  if(options && options->is_defined())
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME, 0, "you can not specify regex-object and options together");
                                 0,  
                                 "you can not specify regex-object and options together"  
                         );  
                 vregex=static_cast<VRegex*>(value);                  vregex=static_cast<VRegex*>(value);
         } else {          } else {
                 vregex=new VRegex(r.charsets.source(),                  vregex=new VRegex(r.charsets.source(), &regexp.as_string(), (options) ? (&options->as_string()) : 0);
                         &regexp.as_string(),  
                         (options)?(&options->as_string()):0);  
                 vregex->study();                  vregex->study();
                 vrcleaner.vregex=vregex;                  vrcleaner.vregex=vregex;
         }          }
Line 398  static void _match(Request& r, MethodPar Line 380  static void _match(Request& r, MethodPar
         int matches_count=0;          int matches_count=0;
   
         if(params_count<3) { // search          if(params_count<3) { // search
                 Table* table=src.match(vregex,                  Table* table=src.match(vregex, search_action, 0, matches_count);
                         search_action, 0,  
                         matches_count);  
   
                 if(table){                  if(table){
                         r.write(*new VTable(table));                          r.write(*new VTable(table));
Line 421  static void _match(Request& r, MethodPar Line 401  static void _match(Request& r, MethodPar
                         if(replacement->is_defined())                          if(replacement->is_defined())
                                 replacement_code=replacement;                                  replacement_code=replacement;
                 } else if(!replacement->is_void())                  } else if(!replacement->is_void())
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME, 0, "replacement option should be junction or string");
                                 0,  
                                 "replacement option should be junction or string");  
   
                 Value* default_code=(params_count==4)?&params.as_junction(3, "default value must be code"):0;                  Value* default_code=(params_count==4) ? &params.as_junction(3, "default value must be code") : 0;
   
                 String result;                  String result;
                 VTable* vtable=new VTable;                  VTable* vtable=new VTable;
Line 451  static void _match(Request& r, MethodPar Line 429  static void _match(Request& r, MethodPar
         }          }
 }  }
   
 static void change_case(Request& r, MethodParams&,   static void change_case(Request& r, MethodParams&, String::Change_case_kind kind) {
                                                 String::Change_case_kind kind) {  
         const String& src=GET_SELF(r, VString).string();          const String& src=GET_SELF(r, VString).string();
   
         r.write(src.change_case(r.charsets.source(), kind));          r.write(src.change_case(r.charsets.source(), kind));
Line 481  public: Line 458  public:
   
         bool add_column(SQL_Error& error, const char* /*str*/, size_t /*length*/) {          bool add_column(SQL_Error& error, const char* /*str*/, size_t /*length*/) {
                 if(got_column) {                  if(got_column) {
                         error=SQL_Error(PARSER_RUNTIME,                          error=SQL_Error(PARSER_RUNTIME, /*statement_string,*/ "result must contain exactly one column");
                                 //statement_string,  
                                 "result must contain exactly one column");  
                         return true;                          return true;
                 }                  }
                 got_column=true;                  got_column=true;
Line 493  public: Line 468  public:
         bool add_row(SQL_Error& /*error*/) { /* ignore */ return false; }          bool add_row(SQL_Error& /*error*/) { /* ignore */ return false; }
         bool add_row_cell(SQL_Error& error, const char* str, size_t) {          bool add_row_cell(SQL_Error& error, const char* str, size_t) {
                 if(got_cell) {                  if(got_cell) {
                         error=SQL_Error(PARSER_RUNTIME,                          error=SQL_Error(PARSER_RUNTIME, /*statement_string,*/ "result must not contain more then one row");
                                 //statement_string,  
                                 "result must not contain more then one row");  
                         return true;                          return true;
                 }                  }
   
Line 504  public: Line 477  public:
                         result=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */ );                          result=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */ );
                         return false;                          return false;
                 } catch(...) {                  } catch(...) {
                         error=SQL_Error("exception occured in String_sql_event_handlers::add_row_cell");                          error=SQL_Error("exception occurred in String_sql_event_handlers::add_row_cell");
                         return true;                          return true;
                 }                  }
         }          }
 };  };
 #endif  #endif
 extern String sql_bind_name;  
 extern String sql_limit_name;  
 extern String sql_offset_name;  
 extern String sql_default_name;  
 extern String sql_distinct_name;  
 extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);  extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);
 extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);  extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);
   
Line 581  static void _sql(Request& r, MethodParam Line 550  static void _sql(Request& r, MethodParam
                 if(default_code) {                  if(default_code) {
                         string=&r.process_to_string(*default_code);                          string=&r.process_to_string(*default_code);
                 } else                  } else
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME, 0, "produced no result, but no default option specified");
                                 0,  
                                 "produced no result, but no default option specified");  
         }          }
   
         r.write(*string);          r.write(*string);
Line 599  static void _replace(Request& r, MethodP Line 566  static void _replace(Request& r, MethodP
                 r.write(src.replace(dict));                  r.write(src.replace(dict));
         } else {          } else {
                 // ^string.replace[from-string;to-string]                  // ^string.replace[from-string;to-string]
                 Dictionary dict(                  Dictionary dict(params.as_string(0, "from must be string"), params.as_string(1, "to must be string"));
                                                 params.as_string(0, "from must be string"),  
                                                 params.as_string(1, "to must be string")  
                                         );  
                 r.write(src.replace(dict));                  r.write(src.replace(dict));
         }          }
   
Line 673  static void _trim(Request& r, MethodPara Line 637  static void _trim(Request& r, MethodPara
                         else if(params_count==1)                          else if(params_count==1)
                                 chars=skind.cstr();                                  chars=skind.cstr();
                         else                          else
                                 throw Exception(PARSER_RUNTIME,                                  throw Exception(PARSER_RUNTIME, &skind, "'kind' must be one of " TRIM_START_OPTION ", " TRIM_BOTH_OPTION ", " TRIM_END_OPTION);
                                         &skind,  
                                         "'kind' must be one of " TRIM_START_OPTION ", " TRIM_BOTH_OPTION ", " TRIM_END_OPTION);  
                 }                  }
   
                 if(params_count>1) {                  if(params_count>1) {
Line 710  static void _base64(Request& r, MethodPa Line 672  static void _base64(Request& r, MethodPa
                 pa_base64_decode(cstr, strlen(cstr), decoded, length, strict);                  pa_base64_decode(cstr, strlen(cstr), decoded, length, strict);
                 if(decoded && length){                  if(decoded && length){
                         if(memchr((const char*)decoded, 0, length))                          if(memchr((const char*)decoded, 0, length))
                                 throw Exception(PARSER_RUNTIME,                                  throw Exception(PARSER_RUNTIME, 0, "Invalid \\x00 character found while decode to string. Decode it to file instead.");
                                         0,  
                                         "Invalid \\x00 character found while decode to string. Decode it to file instead.");  
   
                         fix_line_breaks(decoded, length);                          fix_line_breaks(decoded, length);
                         if(length)                          if(length)
Line 826  MString::MString(): Methoded("string") { Line 786  MString::MString(): Methoded("string") {
         // ^string.split[delim][options]          // ^string.split[delim][options]
         // ^string.split[delim][options][column name]          // ^string.split[delim][options][column name]
         add_native_method("split", Method::CT_DYNAMIC, _split, 1, 3);          add_native_method("split", Method::CT_DYNAMIC, _split, 1, 3);
                 // old names for backward compatibility          // old names for backward compatibility
                 // ^string.lsplit[delim]          // ^string.lsplit[delim]
                 add_native_method("lsplit", Method::CT_DYNAMIC, _lsplit, 1, 1);          add_native_method("lsplit", Method::CT_DYNAMIC, _lsplit, 1, 1);
                 // ^string.rsplit[delim]          // ^string.rsplit[delim]
                 add_native_method("rsplit", Method::CT_DYNAMIC, _rsplit, 1, 1);          add_native_method("rsplit", Method::CT_DYNAMIC, _rsplit, 1, 1);
           
         // ^string.match[regexp][options]          // ^string.match[regexp][options]
         // ^string.match[regexp][options]{replacement-code}          // ^string.match[regexp][options]{replacement-code}
         // ^string.match[regexp][options]{replacement-code}{code-if-nothing-is-found}          // ^string.match[regexp][options]{replacement-code}{code-if-nothing-is-found}
Removed from v.1.233  
changed lines
  Added in v.1.239

E-mail: