[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.185

version 1.166, 2008/07/18 09:12:17 version 1.185, 2009/07/07 05:47:43
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"
   
 // class  // class
   
Line 116  static void _bool(Request& r, MethodPara Line 117  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 284  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 301  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 332  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 354  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, false)){
                   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");
   
                 String result;                  String result;
                 VTable* vtable=new VTable;                  VTable* vtable=new VTable;
Line 393  static void _match(Request& r, MethodPar Line 428  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,                   Temp_value_element* temp_match_var=0;
                         match_var_name, vtable);  
                 src.match(r.charsets.source(),                  if(is_junction)
                         r.process_to_string(regexp), options,                          temp_match_var=new Temp_value_element(
                                   *replacement_code->get_junction()->method_frame,
                                   match_var_name, vtable);
   
                   src.match(vregex,
                         replace_action, &info,                          replace_action, &info,
                         matches_count);                          matches_count);
   
                   if(temp_match_var)
                           delete temp_match_var;
   
                 r.write_assign_lang(result);                  r.write_assign_lang(result);
         }          }
 }  }
Line 519  const String* sql_result_string(Request& Line 562  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 613  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);          size_t params_count=params.count();
           const String& file_name=params.as_string(params_count-1, 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;          bool do_append=false;
         if(params.count()>1) {          if(params_count>1) {
                 const String& mode=params.as_string(0, "mode must be string");                  const String& mode=params.as_string(0, "mode must be string");
                 if(mode=="append")                  if(mode=="append")
                         do_append=true;                          do_append=true;
Line 586  static void _save(Request& r, MethodPara Line 630  static void _save(Request& r, MethodPara
         }                         }               
   
         // write          // write
         const char* buf=src.cstr(String::L_UNSPECIFIED, r.connection(false/*no error if none*/));          String::Body sbody=src.cstr_to_string_body_untaint(String::L_AS_IS, r.connection(false/*no error if none*/));
         file_write(r.absolute(file_name),           file_write(r.absolute(file_name), sbody.cstr(), sbody.length(), true, do_append);
                 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 644  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 660  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 682  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 727  MString::MString(): Methoded("string") { Line 789  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[]
           // ^string:js-unescape[escaped%uXXXXstring]
           add_native_method("js-escape", Method::CT_ANY, _escape, 0, 0);
           add_native_method("js-unescape", Method::CT_STATIC, _unescape, 1, 1);
 }         }       
Removed from v.1.166  
changed lines
  Added in v.1.185

E-mail: