[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.78 and 1.84

version 1.78, 2001/10/09 07:06:00 version 1.84, 2001/10/19 12:43:30
Line 41  static void _length(Request& r, const St Line 41  static void _length(Request& r, const St
   
 static void _int(Request& r, const String& method_name, MethodParams *params) {  static void _int(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         bool convert_problem=false; Exception rethrow_me;  
         int converted;          int converted;
         PTRY {          Value *default_code=params->size()>0?
                   default_code=&params->as_junction(0, "default must be int"):0; // (default)
           try {
                 converted=r.self->as_int();                  converted=r.self->as_int();
           } catch(...) { // convert problem
                   if(!default_code) // we have a problem when no default
                           /*re*/throw;
                   else
                           converted=r.process(*default_code).as_int();
         }          }
         PCATCH(e) { // convert problem  
                 if(convert_problem=params->size()==0) { // we have a problem when do not have default  
                         rethrow_me=e;    
                         converted=0;  
                 } else  
                         converted=params->as_int(0, "default must be int", r); // (default)  
         }  
         PEND_CATCH  
         if(convert_problem)  
                 PTHROW(rethrow_me.type(), rethrow_me.code(),   
                         rethrow_me.problem_source(),  
                         rethrow_me.comment());  
   
         Value& result=*new(pool) VInt(pool, converted);          Value& result=*new(pool) VInt(pool, converted);
         result.set_name(method_name);          result.set_name(method_name);
Line 66  static void _int(Request& r, const Strin Line 60  static void _int(Request& r, const Strin
   
 static void _double(Request& r, const String& method_name, MethodParams *params) {  static void _double(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         bool convert_problem=false; Exception rethrow_me;  
         double converted;          double converted;
         PTRY {          Value *default_code=params->size()>0?
                   default_code=&params->as_junction(0, "default must be double"):0; // (default)
           try {
                 converted=r.self->as_double();                  converted=r.self->as_double();
           } catch(...) { // convert problem
                   if(!default_code) // we have a problem when no default
                           /*re*/throw;  
                   else
                           converted=r.process(*default_code).as_double();
         }          }
         PCATCH(e) { // convert problem  
                 if(convert_problem=params->size()==0) { // we have a problem when do not have default  
                         rethrow_me=e;    
                         converted=0;  
                 } else  
                         converted=params->as_double(0, "default must be double", r); // (default)  
         }  
         PEND_CATCH  
         if(convert_problem)  
                 PTHROW(rethrow_me.type(), rethrow_me.code(),   
                         rethrow_me.problem_source(),  
                         rethrow_me.comment());  
   
         Value& result=*new(pool) VDouble(pool, converted);          Value& result=*new(pool) VDouble(pool, converted);
         result.set_name(method_name);          result.set_name(method_name);
Line 125  static void _right(Request& r, const Str Line 113  static void _right(Request& r, const Str
 static void _mid(Request& r, const String&, MethodParams *params) {  static void _mid(Request& r, const String&, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
           const String& string=*static_cast<VString *>(r.self)->get_string();
   
         size_t p=(size_t)params->as_int(0, "p must be int", r);          size_t p=(size_t)params->as_int(0, "p must be int", r);
         size_t n=(size_t)params->as_int(1, "n must be int", r);          size_t n=params->size()>1?
                   (size_t)params->as_int(1, "n must be int", r):string.size();
                   
         const String& string=*static_cast<VString *>(r.self)->get_string();  
         r.write_assign_lang(*new(pool) VString(string.mid(p, p+n)));          r.write_assign_lang(*new(pool) VString(string.mid(p, p+n)));
 }  }
   
Line 316  public: Line 306  public:
   
         void add_column(void *ptr, size_t size) {          void add_column(void *ptr, size_t size) {
                 if(got_column)                  if(got_column)
                         PTHROW(0, 0,                          throw Exception(0, 0,
                                 &statement_string,                                  &statement_string,
                                 "result must contain exactly one column");                                  "result must contain exactly one column");
                 got_column=true;                  got_column=true;
Line 325  public: Line 315  public:
         void add_row() { /* ignore */ }          void add_row() { /* ignore */ }
         void add_row_cell(void *ptr, size_t size) {          void add_row_cell(void *ptr, size_t size) {
                 if(got_cell)                  if(got_cell)
                         PTHROW(0, 0,                          throw Exception(0, 0,
                                 &statement_string,                                  &statement_string,
                                 "result must not contain more then one row");                                  "result must not contain more then one row");
                 got_cell=true;                  got_cell=true;
Line 343  public: Line 333  public:
 };  };
 #endif  #endif
 const String* sql_result_string(Request& r, const String& method_name, MethodParams *params,  const String* sql_result_string(Request& r, const String& method_name, MethodParams *params,
                                                                 Hash *&options) {                                                                  Hash *& options, Value *& default_code) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         if(!r.connection)          if(!r.connection)
                 PTHROW(0, 0,                  throw Exception(0, 0,
                         &method_name,                          &method_name,
                         "without connect");                          "without connect");
   
Line 355  const String* sql_result_string(Request& Line 345  const String* sql_result_string(Request&
   
         ulong limit=0;          ulong limit=0;
         ulong offset=0;          ulong offset=0;
           default_code=0;
         if(params->size()>1) {          if(params->size()>1) {
                 Value& voptions=params->as_no_junction(1, "options must be hash, not code");                  Value& voptions=params->as_no_junction(1, "options must be hash, not code");
                 if(voptions.is_defined())                  if(voptions.is_defined())
Line 363  const String* sql_result_string(Request& Line 354  const String* sql_result_string(Request&
                                         limit=(ulong)r.process(*vlimit).as_double();                                          limit=(ulong)r.process(*vlimit).as_double();
                                 if(Value *voffset=(Value *)options->get(*sql_offset_name))                                  if(Value *voffset=(Value *)options->get(*sql_offset_name))
                                         offset=(ulong)r.process(*voffset).as_double();                                          offset=(ulong)r.process(*voffset).as_double();
                                   if(default_code=(Value *)options->get(*sql_default_name)) {
                                           if(!default_code->get_junction())
                                                   throw Exception(0, 0,
                                                           &method_name,
                                                           "default option must be code");
                                   }
                         } else                          } else
                                 PTHROW(0, 0,                                  throw Exception(0, 0,
                                         &method_name,                                          &method_name,
                                         "options must be hash");                                          "options must be hash");
         } else          } else
Line 375  const String* sql_result_string(Request& Line 372  const String* sql_result_string(Request&
         const char *statement_cstr=          const char *statement_cstr=
                 statement_string.cstr(String::UL_UNSPECIFIED, r.connection);                  statement_string.cstr(String::UL_UNSPECIFIED, r.connection);
         String_sql_event_handlers handlers(pool, statement_string, statement_cstr);          String_sql_event_handlers handlers(pool, statement_string, statement_cstr);
         bool need_rethrow=false; Exception rethrow_me;          try {
         PTRY {  
                 r.connection->query(                  r.connection->query(
                         statement_cstr, offset, limit,                           statement_cstr, offset, limit, 
                         handlers);                          handlers);
           } catch(const Exception& e) { // query problem
                   // give more specific source [were url]
                   throw Exception(e.type(), e.code(),
                           &statement_string, 
                           "%s", e.comment());
         }          }
         PCATCH(e) { // query problem  
                 rethrow_me=e;  need_rethrow=true;  
         }  
         PEND_CATCH  
         if(need_rethrow)  
                 PTHROW(rethrow_me.type(), rethrow_me.code(),  
                         &statement_string, // setting more specific source [were url]  
                         rethrow_me.comment());  
                   
         if(!handlers.got_cell)          if(!handlers.got_cell)
                 return 0; // no lines, caller should return second param[default value]                  return 0; // no lines, caller should return second param[default value]
Line 400  static void _sql(Request& r, const Strin Line 393  static void _sql(Request& r, const Strin
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         Hash *options;          Hash *options;
         const String *string=sql_result_string(r, method_name, params, options);          Value *default_code;
           const String *string=sql_result_string(r, method_name, params, options, default_code);
         if(!string) {          if(!string) {
                 if(options) {                  if(default_code) {
                         if(Value *vdefault=(Value *)options->get(*sql_default_name)) {                          string=r.process(*default_code).get_string();
                                 if(!vdefault->get_junction())                          if(!string)
                                         PTHROW(0, 0,                                  string=new(pool) String(pool);
                                                 &method_name,  
                                                 "default option must be code");  
                                 string=r.process(*vdefault).get_string();  
                                 if(!string)  
                                         string=empty_string;  
                         } else  
                                 PTHROW(0, 0,  
                                         &method_name,  
                                         "produced no result, but no default option specified");  
                 } else                  } else
                         PTHROW(0, 0,                          throw Exception(0, 0,
                                 &method_name,                                  &method_name,
                                 "produced no result, but no options (no default) specified");                                  "produced no result, but no default option specified");
         }          }
         VString& result=*new(pool) VString(*string);          VString& result=*new(pool) VString(*string);
         result.set_name(method_name);          result.set_name(method_name);
Line 431  static void _replace(Request& r, const S Line 416  static void _replace(Request& r, const S
   
         Table *table=params->as_no_junction(0, "parameter must not be code").get_table();          Table *table=params->as_no_junction(0, "parameter must not be code").get_table();
         if(!table)          if(!table)
                 PTHROW(0, 0,                  throw Exception(0, 0,
                         &method_name,                          &method_name,
                         "parameter must be table");                          "parameter must be table");
   
         Dictionary dict(*table);          Dictionary dict(*table);
         r.write_assign_lang(*new(pool) VString(src.replace(pool, dict)));          r.write_assign_lang(*new(pool) VString(src.replace(pool, dict)));
 }  }
   
   static void _save(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           Value& vfile_name=params->as_no_junction(0, 
                   "file name must not be code");
   
           const String& src=*static_cast<VString *>(r.self)->get_string();
   
           // write
           file_write(pool, r.absolute(vfile_name.as_string()), 
                   src.cstr(String::UL_AS_IS), src.size(), true);
   }
   
 // constructor  // constructor
   
 MString::MString(Pool& apool) : Methoded(apool) {  MString::MString(Pool& apool) : Methoded(apool) {
Line 462  MString::MString(Pool& apool) : Methoded Line 460  MString::MString(Pool& apool) : Methoded
         // ^string.right(n)          // ^string.right(n)
         add_native_method("right", Method::CT_DYNAMIC, _right, 1, 1);          add_native_method("right", Method::CT_DYNAMIC, _right, 1, 1);
         // ^string.mid(p;n)          // ^string.mid(p;n)
         add_native_method("mid", Method::CT_DYNAMIC, _mid, 2, 2);          add_native_method("mid", Method::CT_DYNAMIC, _mid, 1, 2);
   
         // ^string.pos[substr]          // ^string.pos[substr]
         add_native_method("pos", Method::CT_DYNAMIC, _pos, 1, 1);          add_native_method("pos", Method::CT_DYNAMIC, _pos, 1, 1);
Line 487  MString::MString(Pool& apool) : Methoded Line 485  MString::MString(Pool& apool) : Methoded
   
         // ^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]  
           add_native_method("save", Method::CT_DYNAMIC, _save, 1, 1);
 }         }       
   
 // global variable  // global variable
Removed from v.1.78  
changed lines
  Added in v.1.84

E-mail: