[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.65 and 1.73

version 1.65, 2001/07/23 11:19:25 version 1.73, 2001/09/05 15:05:27
Line 15  static const char *RCSId="$Id$"; Line 15  static const char *RCSId="$Id$";
 #include "pa_vbool.h"  #include "pa_vbool.h"
 #include "pa_string.h"  #include "pa_string.h"
 #include "pa_sql_connection.h"  #include "pa_sql_connection.h"
   #include "pa_dictionary.h"
   
 // defines  // defines
   
Line 38  static void _length(Request& r, const St Line 39  static void _length(Request& r, const St
         r.write_no_lang(result);          r.write_no_lang(result);
 }  }
   
 static void _int(Request& r, const String& method_name, MethodParams *) {  static void _int(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         Value& result=*new(pool) VInt(pool, r.self->as_int());          bool convert_problem=false; Exception rethrow_me;
           int converted;
           PTRY {
                   converted=r.self->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, 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);
         result.set_name(method_name);          result.set_name(method_name);
         r.write_no_lang(result);          r.write_no_lang(result);
 }  }
   
 static void _double(Request& r, const String& method_name, MethodParams *) {  static void _double(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         Value& result=*new(pool) VDouble(pool, r.self->as_double());          bool convert_problem=false; Exception rethrow_me;
           double converted;
           PTRY {
                   converted=r.self->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, 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);
         result.set_name(method_name);          result.set_name(method_name);
         r.write_no_lang(result);          r.write_no_lang(result);
 }  }
Line 124  static void _lsplit(Request& r, const St Line 161  static void _lsplit(Request& r, const St
   
         Table& table=*new(pool) Table(pool, &string,           Table& table=*new(pool) Table(pool, &string, 
                 &columns, pieces.size());                  &columns, pieces.size());
         int size=pieces.quick_size();          Array_iter i(pieces);
         for(int i=0; i<size; i++) {          while(i.has_next()) {
                 Array& row=*new(pool) Array(pool);                  Array& row=*new(pool) Array(pool);
                 row+=pieces.quick_get(i);                  row+=i.next();
                 table+=&row;                  table+=&row;
         }          }
         r.write_no_lang(*new(pool) VTable(pool, &table));          r.write_no_lang(*new(pool) VTable(pool, &table));
Line 183  static void replace_action(Table& table, Line 220  static void replace_action(Table& table,
                         vtable.set_name(*ai.origin);                          vtable.set_name(*ai.origin);
   
                         Junction *junction=ai.replacement_code->get_junction();                          Junction *junction=ai.replacement_code->get_junction();
                         junction->rcontext=/*must be some way to get to                           Value *saved_match_var_value=junction->root->get_element(*match_var_name);
                                                            outside world junction->root=*/&vtable;                          junction->root->put_element(*match_var_name, &vtable);
                         Value& replaced=ai.request->process(*ai.replacement_code, ai.origin, false);                          Value& replaced=ai.request->process(*ai.replacement_code, ai.origin, false);
                           junction->root->put_element(*match_var_name, saved_match_var_value);
   
                         /*                          /*
                         ai.dest->APPEND_CONST("(");                          ai.dest->APPEND_CONST("(");
Line 303  public: Line 341  public:
         String *result;          String *result;
 };  };
 #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) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         if(!r.connection)          if(!r.connection)
Line 313  const String* sql_result_string(Request& Line 352  const String* sql_result_string(Request&
   
         Value& statement=params->as_junction(0, "statement must be code");          Value& statement=params->as_junction(0, "statement must be code");
   
         ulong offset=(ulong)(params->size()>2?params->as_int(2, r):0);          ulong limit=0;
           ulong offset=0;
           if(params->size()>1) {
                   Value& voptions=params->as_no_junction(1, "options must be hash, not code");
                   if(voptions.is_defined())
                           if(options=voptions.get_hash()) {
                                   if(Value *vlimit=(Value *)options->get(*sql_limit_name))
                                           limit=(ulong)r.process(*vlimit).as_double();
                                   if(Value *voffset=(Value *)options->get(*sql_offset_name))
                                           offset=(ulong)r.process(*voffset).as_double();
                           } else
                                   PTHROW(0, 0,
                                           &method_name,
                                           "options must be hash");
           } else
                   options=0;
   
         Temp_lang temp_lang(r, String::UL_SQL);          Temp_lang temp_lang(r, String::UL_SQL);
         const String& statement_string=r.process(statement).as_string();          const String& statement_string=r.process(statement).as_string();
Line 323  const String* sql_result_string(Request& Line 377  const String* sql_result_string(Request&
         bool need_rethrow=false; Exception rethrow_me;          bool need_rethrow=false; Exception rethrow_me;
         PTRY {          PTRY {
                 r.connection->query(                  r.connection->query(
                         statement_cstr, offset, 0,                          statement_cstr, offset, limit, 
                         handlers);                          handlers);
         }          }
         PCATCH(e) { // query problem          PCATCH(e) { // query problem
Line 344  const String* sql_result_string(Request& Line 398  const String* sql_result_string(Request&
 static void _sql(Request& r, const String& method_name, MethodParams *params) {  static void _sql(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
   
         const String *string=sql_result_string(r, method_name, params);          Hash *options;
           const String *string=sql_result_string(r, method_name, params, options);
         if(!string) {          if(!string) {
                 Value& default_code=params->as_junction(1, "default result must code");                  if(options) {
                 Value& processed_code=r.process(default_code);                          if(Value *vdefault=(Value *)options->get(*sql_default_name)) {
                 string=processed_code.get_string();                                  if(!vdefault->get_junction())
                 if(!string)                                          PTHROW(0, 0,
                         string=empty_string;                                                  &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
                           PTHROW(0, 0,
                                   &method_name,
                                   "produced no result, but no options (no default) specified");
         }          }
         VString& result=*new(pool) VString(*string);          VString& result=*new(pool) VString(*string);
         result.set_name(method_name);          result.set_name(method_name);
         r.write_assign_lang(result);          r.write_assign_lang(result);
 }  }
   
   static void _replace(Request& r, const String& method_name, MethodParams *params) {
           Pool& pool=r.pool();
           const String& src=*static_cast<VString *>(r.self)->get_string();
   
           Table *table=params->as_no_junction(0, "parameter must not be code").get_table();
           if(!table)
                   PTHROW(0, 0,
                           &method_name,
                           "parameter must be table");
   
           Dictionary dict(*table);
           r.write_assign_lang(*new(pool) VString(src.replace(pool, dict)));
   }
 // constructor  // constructor
   
 MString::MString(Pool& apool) : Methoded(apool) {  MString::MString(Pool& apool) : Methoded(apool) {
Line 367  MString::MString(Pool& apool) : Methoded Line 447  MString::MString(Pool& apool) : Methoded
         add_native_method("length", Method::CT_DYNAMIC, _length, 0, 0);          add_native_method("length", Method::CT_DYNAMIC, _length, 0, 0);
                   
         // ^string.int[]          // ^string.int[]
         add_native_method("int", Method::CT_DYNAMIC, _int, 0, 0);          // ^string.int(default)
                   add_native_method("int", Method::CT_DYNAMIC, _int, 0, 1);
         // ^string.double[]          // ^string.double[]
         add_native_method("double", Method::CT_DYNAMIC, _double, 0, 0);          // ^string.double(default)
           add_native_method("double", Method::CT_DYNAMIC, _double, 0, 1);
   
         // ^string.format{format}          // ^string.format{format}
         add_native_method("format", Method::CT_DYNAMIC, _string_format, 1, 1);          add_native_method("format", Method::CT_DYNAMIC, _string_format, 1, 1);
Line 399  MString::MString(Pool& apool) : Methoded Line 480  MString::MString(Pool& apool) : Methoded
         // ^string.tolower[]          // ^string.tolower[]
         add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);          add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);
   
         // ^string:sql[query]{default}          // ^sql[query]
         // ^string:sql[query]{default}(offset)          // ^sql[query][$.limit(1) $.offset(2) $.default[n/a]]
         add_native_method("sql", Method::CT_STATIC, _sql, 2, 3);          add_native_method("sql", Method::CT_STATIC, _sql, 1, 2);
   
           // ^string.replace[table]
           add_native_method("replace", Method::CT_DYNAMIC, _replace, 1, 1);
 }         }       
   
 // global variable  // global variable
Removed from v.1.65  
changed lines
  Added in v.1.73

E-mail: