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

version 1.166, 2008/07/18 09:12:17 version 1.174, 2009/04/22 04:38:36
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 360  static void replace_action(Table& table, Line 361  static void replace_action(Table& table,
                 *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;
   
           VRegex* vregex;
           VRegexCleaner vrcleaner;
   
         const String* options=          if(Value* value=regexp.as(VREGEX_TYPE, false)){
                 params.count()>1?                  if(options && options->is_defined())
                 &params.as_no_junction(1, "options must not be code").as_string():0;                          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);
                   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_assign_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
Line 398  static void _match(Request& r, MethodPar Line 414  static void _match(Request& r, MethodPar
                 Temp_value_element temp_match_var(                  Temp_value_element temp_match_var(
                         *replacement_code.get_junction()->method_frame,                           *replacement_code.get_junction()->method_frame, 
                         match_var_name, vtable);                          match_var_name, vtable);
                 src.match(r.charsets.source(),  
                         r.process_to_string(regexp), options,                  src.match(vregex,
                         replace_action, &info,                          replace_action, &info,
                         matches_count);                          matches_count);
   
                 r.write_assign_lang(result);                  r.write_assign_lang(result);
         }          }
 }  }
Line 639  static void _append(Request& r, MethodPa Line 656  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, length, true/*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, 0, true/*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 764  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.174

E-mail: