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

version 1.166, 2008/07/18 09:12:17 version 1.178, 2009/04/28 04:53:52
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 360  static void replace_action(Table& table, Line 362  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);
                   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
Line 398  static void _match(Request& r, MethodPar Line 416  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 570  static void _replace(Request& r, MethodP Line 589  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 601  static void _trim(Request& r, MethodPara Line 621  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 637  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();
                 }                  }
         }          }
Line 639  static void _append(Request& r, MethodPa Line 659  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 767  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.178

E-mail: