[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.83 and 1.89

version 1.83, 2001/10/17 15:44:47 version 1.89, 2001/11/09 11:59:13
Line 2 Line 2
         Parser: @b string parser class.          Parser: @b string parser class.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)          Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)
   
         $Id$          $Id$
 */  */
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;
         Value *default_code=params->size()>0?          Value *default_code=params->size()>0?
                 default_code=&params->as_junction(0, "default must be int"):0; // (default)                  default_code=&params->as_junction(0, "default must be int"):0; // (default)
         PTRY {          try {
                 converted=r.self->as_int();                  converted=r.self->as_int();
         }          } catch(...) { // convert problem
         PCATCH(e) { // convert problem                  if(!default_code) // we have a problem when no default
                 if(convert_problem=!default_code) { // we have a problem when no default                          /*re*/throw;
                         rethrow_me=e;                    else
                         converted=0;  
                 } else  
                         converted=r.process(*default_code).as_int();                          converted=r.process(*default_code).as_int();
         }          }
         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 68  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;
         Value *default_code=params->size()>0?          Value *default_code=params->size()>0?
                 default_code=&params->as_junction(0, "default must be double"):0; // (default)                  default_code=&params->as_junction(0, "default must be double"):0; // (default)
         PTRY {          try {
                 converted=r.self->as_double();                  converted=r.self->as_double();
         }          } catch(...) { // convert problem
         PCATCH(e) { // convert problem                  if(!default_code) // we have a problem when no default
                 if(convert_problem=!default_code) { // we have a problem when no default                          /*re*/throw;  
                         rethrow_me=e;                    else
                         converted=0;  
                 } else  
                         converted=r.process(*default_code).as_double();                          converted=r.process(*default_code).as_double();
         }          }
         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 99  static void _double(Request& r, const St Line 83  static void _double(Request& r, const St
         Value& fmt=params->as_junction(0, "fmt must be code");          Value& fmt=params->as_junction(0, "fmt must be code");
   
         Temp_lang temp_lang(r, String::UL_PASS_APPENDED);          Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
         char *buf=format(pool, r.self->as_double(), r.process(fmt).as_string().cstr());          char *buf=format(pool, r.self->as_double(), 
                   r.process(fmt).as_string().cstr(String::UL_UNSPECIFIED));
   
         String result(pool);          String result(pool);
         result.APPEND_CLEAN(buf, 0,           result.APPEND_CLEAN(buf, 0, 
Line 322  public: Line 307  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 331  public: Line 316  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 353  const String* sql_result_string(Request& Line 338  const String* sql_result_string(Request&
         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 365  const String* sql_result_string(Request& Line 350  const String* sql_result_string(Request&
         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())
                         if(options=voptions.get_hash()) {                          if(options=voptions.get_hash(&method_name)) {
                                 if(Value *vlimit=(Value *)options->get(*sql_limit_name))                                  if(Value *vlimit=(Value *)options->get(*sql_limit_name))
                                         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=(Value *)options->get(*sql_default_name)) {
                                         if(!default_code->get_junction())                                          if(!default_code->get_junction())
                                                 PTHROW(0, 0,                                                  throw Exception(0, 0,
                                                         &method_name,                                                          &method_name,
                                                         "default option must be code");                                                          "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 388  const String* sql_result_string(Request& Line 373  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 421  static void _sql(Request& r, const Strin Line 402  static void _sql(Request& r, const Strin
                         if(!string)                          if(!string)
                                 string=new(pool) String(pool);                                  string=new(pool) String(pool);
                 } else                  } else
                         PTHROW(0, 0,                          throw Exception(0, 0,
                                 &method_name,                                  &method_name,
                                 "produced no result, but no default option specified");                                  "produced no result, but no default option specified");
         }          }
Line 436  static void _replace(Request& r, const S Line 417  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");
   
Line 446  static void _replace(Request& r, const S Line 427  static void _replace(Request& r, const S
   
 static void _save(Request& r, const String& method_name, MethodParams *params) {  static void _save(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         Value& vfile_name=params->as_no_junction(0,           const String& file_name=params->as_string(params->size()-1, 
                 "file name must not be code");                  "file name must be string");
   
         const String& src=*static_cast<VString *>(r.self)->get_string();          const String& src=*static_cast<VString *>(r.self)->get_string();
   
           bool do_append=false;
           if(params->size()>1) {
                   const String& mode=params->as_string(0, "mode must be string");
                   if(mode=="append")
                           do_append=true;
                   else
                           throw Exception(0, 0,
                                   &mode,
                                   "unknown mode, must be 'append'");
           }               
   
         // write          // write
         file_write(pool, r.absolute(vfile_name.as_string()),           const char *buf=src.cstr(String::UL_UNSPECIFIED);
                 src.cstr(String::UL_AS_IS), src.size(), true);          file_write(pool, r.absolute(file_name), 
                   buf, strlen(buf), true, do_append);
 }  }
   
 // constructor  // constructor
Line 507  MString::MString(Pool& apool) : Methoded Line 500  MString::MString(Pool& apool) : Methoded
         add_native_method("replace", Method::CT_DYNAMIC, _replace, 1, 1);          add_native_method("replace", Method::CT_DYNAMIC, _replace, 1, 1);
   
         // ^string.save[file]            // ^string.save[file]  
         add_native_method("save", Method::CT_DYNAMIC, _save, 1, 1);          add_native_method("save", Method::CT_DYNAMIC, _save, 1, 2);
 }         }       
   
 // global variable  // global variable
Removed from v.1.83  
changed lines
  Added in v.1.89

E-mail: