[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.166 and 1.192

version 1.166, 2008/07/18 09:12:17 version 1.192, 2010/04/05 00:57:01
Line 1 Line 1
 /** @file  /** @file
         Parser: @b string parser class.          Parser: @b string parser class.
   
         Copyright (c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2009 ArtLebedev Group (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 19  static const char * const IDENT_STRING_C Line 19  static const char * const IDENT_STRING_C
 #include "pa_sql_connection.h"  #include "pa_sql_connection.h"
 #include "pa_dictionary.h"  #include "pa_dictionary.h"
 #include "pa_vmethod_frame.h"  #include "pa_vmethod_frame.h"
   #include "pa_vregex.h"
   #include "pa_charsets.h"
   
 // class  // class
   
Line 40  DECLARE_CLASS_VAR(string, new MString, 0 Line 42  DECLARE_CLASS_VAR(string, new MString, 0
 #define TRIM_END_OPTION "right"  #define TRIM_END_OPTION "right"
 #define TRIM_BOTH_OPTION "both"  #define TRIM_BOTH_OPTION "both"
   
   #define MODE_APPEND "append"
   
 // statics  // statics
   
 static const String match_var_name(MATCH_VAR_NAME);  static const String match_var_name(MATCH_VAR_NAME);
Line 116  static void _bool(Request& r, MethodPara Line 120  static void _bool(Request& r, MethodPara
                         rethrow; // we have a problem when no default                          rethrow; // we have a problem when no default
         }          }
   
         r.write_no_lang(*new VBool(converted));          r.write_no_lang(VBool::get(converted));
 }  }
   
 /*not static*/void _string_format(Request& r, MethodParams& params) {  /*not static*/void _string_format(Request& r, MethodParams& params) {
Line 283  static Table& split_horizontal(ArrayStri Line 287  static Table& split_horizontal(ArrayStri
 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();
   
         ArrayString pieces;          ArrayString pieces;
         split_list(params, 0, string, pieces);          split_list(params, 0, string, pieces);
   
         if(!bits) {          if(!bits) {
                 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 299  static void split_with_options(Request& Line 304  static void split_with_options(Request&
         bool horizontal=(bits & SPLIT_HORIZONTAL) !=0;          bool horizontal=(bits & SPLIT_HORIZONTAL) !=0;
   
         const String* column_name=0;          const String* column_name=0;
         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->length())                   if (horizontal && !column_name->is_empty()) 
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME,
                                 column_name,                                  column_name,
                                 "column name can't be specified with horisontal split");                                  "column name can't be specified with horisontal split");
         }           } 
         if(!column_name || !column_name->length())          if(!column_name || column_name->is_empty())
                 column_name=new String("piece");                  column_name=new String("piece");
   
         Table& table=horizontal?split_horizontal(pieces, right):split_vertical(pieces, right, column_name);          Table& table=horizontal?split_horizontal(pieces, right):split_vertical(pieces, right, column_name);
Line 330  static void search_action(Table& table, Line 335  static void search_action(Table& table,
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct Replace_action_info {  struct Replace_action_info {
         Request* request;            Request* request;
         const String* src;  String* dest;          const String* src;
           String* dest;
         VTable* vtable;          VTable* vtable;
         Value* replacement_code;          Value* replacement_code;
 };  };
 #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 prestart, int prefinish, 
                            int poststart, int postfinish,                                  int poststart, int postfinish,
                            void *info) {                                  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 351  static void replace_action(Table& table, Line 357  static void replace_action(Table& table,
                         table.put(0, row);                          table.put(0, row);
                 else // begin                  else // begin
                         table+=row;                          table+=row;
                 { // execute 'replacement_code' in 'table' context  
                         ai.vtable->set_table(table);  
   
                         *ai.dest << ai.request->process_to_string(*ai.replacement_code);                  { // execute 'replacement_code' in 'table' context
                           if(ai.replacement_code){
                                   ai.vtable->set_table(table);
                                   *ai.dest << ai.request->process_to_string(*ai.replacement_code);
                           }
                 }                  }
         } else // end          } else // end
                 *ai.dest << ai.src->mid(poststart, postfinish);                  *ai.dest << ai.src->mid(poststart, postfinish);
 }  }
   
 /// @todo use pcre:study somehow  
 static void _match(Request& r, MethodParams& params) {  static void _match(Request& r, MethodParams& params) {
           size_t params_count=params.count();
   
         Value& regexp=params.as_no_junction(0, "regexp must not be code");          Value& regexp=params.as_no_junction(0, "regexp must not be code");
           Value* options=(params_count>1)?&params.as_no_junction(1, OPTIONS_MUST_NOT_BE_CODE):0;
   
         const String* options=          VRegex* vregex;
                 params.count()>1?          VRegexCleaner vrcleaner;
                 &params.as_no_junction(1, "options must not be code").as_string():0;  
           if(Value* value=regexp.as(VREGEX_TYPE)){
                   if(options && options->is_defined())
                           throw Exception(PARSER_RUNTIME,
                                   0,
                                   "you can not specify regex-object and options together"
                           );
                   vregex=static_cast<VRegex*>(value);
           } else {
                   vregex=new VRegex(r.charsets.source(),
                           &regexp.as_string(),
                           (options)?(&options->as_string()):0);
                   vregex->study();
                   vrcleaner.vregex=vregex;
           }
   
         Temp_lang temp_lang(r, String::L_PASS_APPENDED);          Temp_lang temp_lang(r, String::L_PASS_APPENDED);
         const String& src=GET_SELF(r, VString).string();          const String& src=GET_SELF(r, VString).string();
         int matches_count=0;          int matches_count=0;
         if(params.count()<3) { // search  
                 Table* table=src.match(r.charsets.source(),          if(params_count<3) { // search
                         regexp.as_string(), options,                  Table* table=src.match(vregex,
                         search_action, 0,                          search_action, 0,
                         matches_count);                          matches_count);
                 // r.write_assign_lang(*new VTable(table));  
                 if(table){                  if(table){
                         r.write_assign_lang(*new VTable(table));                          r.write_no_lang(*new VTable(table));
                 } else {                  } else {
                         r.write_assign_lang(*new VInt(matches_count));                          r.write_no_lang(*new VInt(matches_count));
                 }                  }
   
         } else { // replace          } else { // replace
                 Value& replacement_code=params.as_junction(2, "replacement param must be code");  
                   Value* replacement_code=0;
                   bool is_junction=false;
   
                   Value* replacement=&params[2];
                   if(replacement->get_junction()){
                           replacement_code=replacement;
                           is_junction=true;
                   } else if(replacement->is_string()){
                           if(replacement->is_defined())
                                   replacement_code=replacement;
                   } else if(!replacement->is_void())
                           throw Exception(PARSER_RUNTIME,
                                   0,
                                   "replacement option should be junction or string");
   
                   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 393  static void _match(Request& r, MethodPar Line 433  static void _match(Request& r, MethodPar
                         &src,                          &src,
                         &result,                          &result,
                         vtable,                          vtable,
                         &replacement_code                          replacement_code
                 };                  };
                 Temp_value_element temp_match_var(  
                         *replacement_code.get_junction()->method_frame,                   if(is_junction){
                         match_var_name, vtable);                          Temp_value_element temp( *replacement_code->get_junction()->method_frame, match_var_name, vtable);
                 src.match(r.charsets.source(),                          src.match(vregex, replace_action, &info, matches_count);
                         r.process_to_string(regexp), options,                  } else {
                         replace_action, &info,                          src.match(vregex, replace_action, &info, matches_count);
                         matches_count);                  }
                 r.write_assign_lang(result);  
                   if(!matches_count && default_code)
                           r.process_write(*default_code);
                   else
                           r.write_assign_lang(result);
         }          }
 }  }
   
Line 519  const String* sql_result_string(Request& Line 563  const String* sql_result_string(Request&
   
         Temp_lang temp_lang(r, String::L_SQL);          Temp_lang temp_lang(r, String::L_SQL);
         const String& statement_string=r.process_to_string(statement);          const String& statement_string=r.process_to_string(statement);
         const char* statement_cstr=          const char* statement_cstr=statement_string.untaint_cstr(r.flang, r.connection());
                 statement_string.cstr(String::L_UNSPECIFIED, r.connection());  
         String_sql_event_handlers handlers(statement_string, statement_cstr);          String_sql_event_handlers handlers(statement_string, statement_cstr);
   
         r.connection()->query(          r.connection()->query(
Line 570  static void _replace(Request& r, MethodP Line 614  static void _replace(Request& r, MethodP
 }  }
   
 static void _save(Request& r, MethodParams& params) {  static void _save(Request& r, MethodParams& params) {
         const String& file_name=params.as_string(params.count()-1, FILE_NAME_MUST_BE_STRING);          bool do_append=false;
           Charset* asked_charset=0;
   
           size_t file_name_index=0;
           if(params.count()>1)
                   if(HashStringValue* options=params.as_no_junction(1, "second parameter should be string or hash").get_hash()){
                           int valid_options=0;
                           if(Value* vcharset_name=options->get(PA_CHARSET_NAME)){
                                   asked_charset=&::charsets.get(vcharset_name->as_string().change_case(r.charsets.source(), String::CC_UPPER));
                                   valid_options++;
                           }
                           if(Value* vappend=options->get(MODE_APPEND)){
                                   do_append=vappend->as_bool();
                                   valid_options++;
                           }
                           if(valid_options != options->count())
                                   throw Exception(PARSER_RUNTIME,
                                           0,
                                           INVALID_OPTION_PASSED);
                   } else {
                           const String& mode=params.as_string(0, "mode must be string");
                           if(mode==MODE_APPEND){
                                   do_append=true;
                                   file_name_index++;
                           } else
                                   throw Exception(PARSER_RUNTIME,
                                           &mode,
                                           "unknown mode, must be 'append'");
                   }
   
           const String& file_name=params.as_string(file_name_index, FILE_NAME_MUST_BE_STRING);
         const String& src=GET_SELF(r, VString).string();          const String& src=GET_SELF(r, VString).string();
   
         bool do_append=false;          String::Body sbody=src.cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false/*no error if none*/));
         if(params.count()>1) {  
                 const String& mode=params.as_string(0, "mode must be string");  
                 if(mode=="append")  
                         do_append=true;  
                 else  
                         throw Exception(PARSER_RUNTIME,  
                                 &mode,  
                                 "unknown mode, must be 'append'");  
         }                 
   
         // write          // write
         const char* buf=src.cstr(String::L_UNSPECIFIED, r.connection(false/*no error if none*/));          file_write(r.charsets, r.absolute(file_name), sbody.cstr(), sbody.length(), true, do_append, asked_charset);
         file_write(r.absolute(file_name),   
                 buf, strlen(buf), true, do_append);  
 }  }
   
 static void _normalize(Request& r, MethodParams&) {  static void _normalize(Request& r, MethodParams&) {
Line 601  static void _trim(Request& r, MethodPara Line 663  static void _trim(Request& r, MethodPara
         const String& src=GET_SELF(r, VString).string();          const String& src=GET_SELF(r, VString).string();
   
         String::Trim_kind kind=String::TRIM_BOTH;          String::Trim_kind kind=String::TRIM_BOTH;
           size_t params_count=params.count();
         const char* chars=0;          const char* chars=0;
         if(params.count()>0) {          if(params_count>0) {
                 const String& skind=params.as_string(0,                   const String& skind=params.as_string(0, "'where' must be string");
                         "'where' must be string");                  if(!skind.is_empty())
                 if(skind.length())  
                         if(skind==TRIM_BOTH_OPTION)                          if(skind==TRIM_BOTH_OPTION)
                                 kind=String::TRIM_BOTH;                                  kind=String::TRIM_BOTH;
                         else if(skind==TRIM_START_OPTION || skind=="start")                          else if(skind==TRIM_START_OPTION || skind=="start")
Line 617  static void _trim(Request& r, MethodPara Line 679  static void _trim(Request& r, MethodPara
                                         &skind,                                          &skind,
                                         "'kind' must be one of "TRIM_START_OPTION", "TRIM_BOTH_OPTION", "TRIM_END_OPTION);                                          "'kind' must be one of "TRIM_START_OPTION", "TRIM_BOTH_OPTION", "TRIM_END_OPTION);
   
                 if(params.count()>1) {                  if(params_count>1) {
                         const String& schars=params.as_string(1, "'chars' must be string");                          const String& schars=params.as_string(1, "'chars' must be string");
                         if(schars.length())                          if(!schars.is_empty())
                                 chars=schars.cstr();                                  chars=schars.cstr();
                 }                  }
         }          }
   
         r.write_assign_lang(src.trim(kind, chars));          r.write_assign_lang(src.trim(kind, chars, &r.charsets.source()));
 }  }
   
 static void _append(Request& r, MethodParams& params) {  static void _append(Request& r, MethodParams& params) {
Line 639  static void _append(Request& r, MethodPa Line 701  static void _append(Request& r, MethodPa
   
 static void _base64(Request& r, MethodParams& params) {  static void _base64(Request& r, MethodParams& params) {
         if(params.count()) {          if(params.count()) {
                 // decode                  // decode: ^string:base64[encoded]
                 const char* cstr=params.as_string(0, PARAMETER_MUST_BE_STRING).cstr();                  const char* cstr=params.as_string(0, PARAMETER_MUST_BE_STRING).cstr();
                 char* decoded_cstr=0;                  char* decoded=0;
                 size_t decoded_size=0;                  size_t length=0;
                 pa_base64_decode(cstr, strlen(cstr), decoded_cstr, decoded_size);                  pa_base64_decode(cstr, strlen(cstr), decoded, length);
                 if(decoded_cstr && decoded_size)                  if(decoded && length){
                         r.write_assign_lang(*new String(decoded_cstr, decoded_size, true));                          if(memchr((const char*)decoded, 0, length))
                                   throw Exception(PARSER_RUNTIME,
                                           0,
                                           "Invalid \\x00 character found while decode to string. Decode it to file instead.");
   
                           fix_line_breaks(decoded, length);
                           if(length)
                                   r.write_assign_lang(*new String(decoded, String::L_TAINTED));
                   }
         } else {          } else {
                 // encode                   // encode: ^str.base64[]
                 VString& self=GET_SELF(r, VString);                  VString& self=GET_SELF(r, VString);
                 const char* cstr=self.string().cstr();                  const char* cstr=self.string().cstr();
                 const char* encoded=pa_base64_encode(cstr, strlen(cstr));                  const char* encoded=pa_base64_encode(cstr, strlen(cstr));
                 r.write_assign_lang(*new String(encoded, 0, true/*once ?param=base64(something) was needed*/));                  r.write_assign_lang(*new String(encoded, String::L_TAINTED/*once ?param=base64(something) was needed*/));
         }          }
 }  }
   
   static void _escape(Request& r, MethodParams&){
           const String& src=GET_SELF(r, VString).string();
           r.write_assign_lang(src.escape(r.charsets.source()));
   }
   
   static void _unescape(Request& r, MethodParams& params){
           const String& src=params.as_string(0, PARAMETER_MUST_BE_STRING);
           if(const char* result=unescape_chars(src.cstr(), src.length(), &r.charsets.source(), true/* don't unescape '+' char */))
                   r.write_assign_lang(*new String(result));
   }
   
 // constructor  // constructor
   
 MString::MString(): Methoded("string") {  MString::MString(): Methoded("string") {
Line 698  MString::MString(): Methoded("string") { Line 779  MString::MString(): Methoded("string") {
                   
         // ^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);          // ^string.match[regexp][options]{replacement-code}{code-if-nothing-is-found}
           add_native_method("match", Method::CT_DYNAMIC, _match, 1, 4);
   
         // ^string.upper[]          // ^string.upper[]
         add_native_method("upper", Method::CT_DYNAMIC, _upper, 0, 0);          add_native_method("upper", Method::CT_DYNAMIC, _upper, 0, 0);
         // ^string.lower[]          // ^string.lower[]
         add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);          add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);
   
         // ^sql[query]          // ^string:sql{query}
         // ^sql[query][options hash]          // ^string:sql{query}[options hash]
         add_native_method("sql", Method::CT_STATIC, _sql, 1, 2);          add_native_method("sql", Method::CT_STATIC, _sql, 1, 2);
   
         // ^string.replace[table]          // ^string.replace[table]
         add_native_method("replace", Method::CT_DYNAMIC, _replace, 1, 1);          add_native_method("replace", Method::CT_DYNAMIC, _replace, 1, 1);
   
         // ^string.save[file]            // ^string.save[append][file]
           // ^string.save[file]
           // ^string.save[file][$.append(true) $.charset[...]]
         add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);          add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
   
         // ^string.normalize[]            // ^string.normalize[]  
Line 727  MString::MString(): Methoded("string") { Line 811  MString::MString(): Methoded("string") {
         // ^string.base64[] << encode          // ^string.base64[] << encode
         // ^string:base64[encoded string] << decode               // ^string:base64[encoded string] << decode     
         add_native_method("base64", Method::CT_ANY, _base64, 0, 1);          add_native_method("base64", Method::CT_ANY, _base64, 0, 1);
   
           // ^string.js-escape[]
           add_native_method("js-escape", Method::CT_ANY, _escape, 0, 0);
   
           // ^string:js-unescape[escaped%uXXXXstring]
           add_native_method("js-unescape", Method::CT_STATIC, _unescape, 1, 1);
 }         }       
Removed from v.1.166  
changed lines
  Added in v.1.192

E-mail: