[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.178 and 1.185

version 1.178, 2009/04/28 04:53:52 version 1.185, 2009/07/07 05:47:43
Line 332  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 353  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);
Line 402  static void _match(Request& r, MethodPar Line 405  static void _match(Request& r, MethodPar
                 }                  }
   
         } 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 411  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);  
                   if(is_junction)
                           temp_match_var=new Temp_value_element(
                                   *replacement_code->get_junction()->method_frame,
                                   match_var_name, vtable);
   
                 src.match(vregex,                  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 538  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 606  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 644  static void _trim(Request& r, MethodPara Line 667  static void _trim(Request& r, MethodPara
                 }                  }
         }          }
   
         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 671  static void _base64(Request& r, MethodPa Line 694  static void _base64(Request& r, MethodPa
                                         "Invalid \\x00 character found while decode to string. Decode it to file instead.");                                          "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)
                                 r.write_assign_lang(*new String(decoded, length, true/*tainted*/));                                  r.write_assign_lang(*new String(decoded, String::L_TAINTED));
                         }  
                 }                  }
         } else {          } else {
                 // encode: ^str.base64[]                  // 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/*tainted. once ?param=base64(something) was needed*/));                  r.write_assign_lang(*new String(encoded, String::L_TAINTED/*once ?param=base64(something) was needed*/));
         }          }
 }  }
   
Removed from v.1.178  
changed lines
  Added in v.1.185

E-mail: