[BACK]Return to op.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/op.C between versions 1.107 and 1.122

version 1.107, 2002/09/10 14:56:33 version 1.122, 2002/10/16 08:22:13
Line 25  static const char* IDENT_OP_C="$Date$"; Line 25  static const char* IDENT_OP_C="$Date$";
   
 // class  // class
   
 class MOP : public Methoded {  class VClassMAIN: public VClass {
 public:  public:
         MOP(Pool& pool);          VClassMAIN(Pool& apool);
 public: // Methoded  
         bool used_directly() { return true; }  
         void configure_user(Request& r);  
   
 private:  
         String main_sql_name;  
         String main_sql_drivers_name;  
 };  };
   
 // methods  // methods
Line 102  static void _taint(Request& r, const Str Line 95  static void _taint(Request& r, const Str
   
 static void _process(Request& r, const String& method_name, MethodParams *params) {  static void _process(Request& r, const String& method_name, MethodParams *params) {
         Pool& pool=r.pool();          Pool& pool=r.pool();
         VStateless_class& self_class=*r.self->get_class();  
         const Method *main_method;          const Method *main_method;
           Value& target_self=params->size()>1?
                   params->as_no_junction(0, "target must not be code")
                   :r.get_method_frame()->caller()->self();
         {          {
                   Value& vjunction=params->as_junction(params->size()-1, "body must be code");
   
                   VStateless_class *target_class=target_self.get_class();
                   if(!target_class)
                           throw Exception("parser.runtime",
                                   &method_name,
                                   "no target class");
                   
                   // evaluate source to process
                   const String& source=r.process_to_string(vjunction);
   
                 // temporary remove language change                  // temporary remove language change
                 Temp_lang temp_lang(r, String::UL_PASS_APPENDED);                  Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
                 // temporary zero @main so to maybe-replace it in processed code                  // temporary zero @main so to maybe-replace it in processed code
                 Temp_method temp_method_main(self_class, r.main_method_name, 0);                  Temp_method temp_method_main(*target_class, r.main_method_name, 0);
                 // temporary zero @auto so it wouldn't be auto-called in Request::use_buf                  // temporary zero @auto so it wouldn't be auto-called in Request::use_buf
                 Temp_method temp_method_auto(self_class, *auto_method_name, 0);                  Temp_method temp_method_auto(*target_class, *auto_method_name, 0);
                                   
                 // evaluate source to process  
                 const String& source=r.process_to_string(params->as_junction(0, "body must be code"));  
                 // calculate pseudo file name of processed chars                  // calculate pseudo file name of processed chars
                 // would be something like "/some/file(4) process"                  // would be something like "/some/file(4) process"
                 char local_place[MAX_STRING];                  char local_place[MAX_STRING];
Line 137  static void _process(Request& r, const S Line 141  static void _process(Request& r, const S
   
                 // process source code, append processed methods to 'self' class                  // process source code, append processed methods to 'self' class
                 // maybe-define new @main                  // maybe-define new @main
                 r.use_buf(                  r.use_buf(*target_class,
                         source.cstr(String::UL_UNSPECIFIED, r.connection(0)),                           source.cstr(String::UL_UNSPECIFIED, r.connection(0)), 
                         *new(pool) String(pool, heap_place, place_size, true /*tainted*/),                          *new(pool) String(pool, heap_place, place_size, true /*tainted*/),
                         heap_place,                           heap_place);
                         &self_class);  
                                   
                 // main_method                  // main_method
                 main_method=self_class.get_method(r.main_method_name);                  main_method=target_class->get_method(r.main_method_name);
         }          }
         // after restoring current-request-lang          // after restoring current-request-lang
         // maybe-execute @main[]          // maybe-execute @main[]
         if(main_method) {          if(main_method) {
                   // temporarily set method_frame's self to target_self
                   Temp_method_frame_self tmfs(*r.get_method_frame(), target_self);
                 // execute!                       // execute!     
                 r.execute(*main_method->parser_code);                  r.execute(*main_method->parser_code);
         }          }
Line 185  static void _while(Request& r, const Str Line 190  static void _while(Request& r, const Str
   
 static void _use(Request& r, const String& method_name, MethodParams *params) {  static void _use(Request& r, const String& method_name, MethodParams *params) {
         Value& vfile=params->as_no_junction(0, "file name must not be code");          Value& vfile=params->as_no_junction(0, "file name must not be code");
         r.use_file(vfile.as_string());          r.use_file(r.main_class, vfile.as_string());
 }  }
   
 static void _for(Request& r, const String& method_name, MethodParams *params) {  static void _for(Request& r, const String& method_name, MethodParams *params) {
Line 203  static void _for(Request& r, const Strin Line 208  static void _for(Request& r, const Strin
   
         bool need_delim=false;          bool need_delim=false;
         VInt *vint=new(pool) VInt(pool, 0);          VInt *vint=new(pool) VInt(pool, 0);
         r.method_frame->put_element(var_name, vint, false);          r.get_method_frame()->caller()->put_element(var_name, vint, false);
         for(int i=from; i<=to; i++) {          for(int i=from; i<=to; i++) {
                 vint->set_int(i);                  vint->set_int(i);
   
                 StringOrValue processed_body=r.process(body_code);                  StringOrValue sv_processed=r.process(body_code);
                 if(delim_maybe_code) { // delimiter set?                  const String *s_processed=sv_processed.get_string();
                         const String *string=processed_body.get_string();                  if(delim_maybe_code && s_processed && s_processed->size()) { // delimiter set and we have body
                         if(need_delim && string && string->size()) // need delim & iteration produced string?                          if(need_delim) // need delim & iteration produced string?
                                 r.write_pass_lang(r.process(*delim_maybe_code));                                  r.write_pass_lang(r.process(*delim_maybe_code));
                         need_delim=true;                          need_delim=true;
                 }                  }
                 r.write_pass_lang(processed_body);                  r.write_pass_lang(sv_processed);
         }          }
 }  }
   
Line 243  struct timeval mt[2]; Line 248  struct timeval mt[2];
         Value& url=params->as_no_junction(0, "url must not be code");          Value& url=params->as_no_junction(0, "url must not be code");
         Value& body_code=params->as_junction(1, "body must be code");          Value& body_code=params->as_junction(1, "body must be code");
   
         Table *protocol2driver_and_client=          Table *protocol2driver_and_client=0;
                 static_cast<Table *>(r.classes_conf.get(r.OP.name()));          if(Value *sql=r.main_class.get_element(*new(pool) String(pool, MAIN_SQL_NAME), &r.main_class, false)) {
                   if(Value *element=sql->get_element(*new(pool) String(pool, MAIN_SQL_DRIVERS_NAME), sql, false)) {
                           protocol2driver_and_client=element->get_table();
                   }
           }
   
 #ifdef RESOURCES_DEBUG  #ifdef RESOURCES_DEBUG
 //measure:before  //measure:before
Line 577  static void _try_operator(Request& r, co Line 586  static void _try_operator(Request& r, co
         Value& catch_code=params->as_junction(1, "catch_code must be code");          Value& catch_code=params->as_junction(1, "catch_code must be code");
   
         StringOrValue result;          StringOrValue result;
   
         // taking snapshot of request processing status  
         //int ssexception_trace=r.exception_trace.top_index();  
         int sstack=r.stack.top_index();  
         Value *sself=r.self;  
         VMethodFrame *smethod_frame=r.method_frame;  
         Value *srcontext=r.rcontext;    
         WContext *swcontext=r.wcontext;   
         try {          try {
                   Request_context_saver context_saved(r); // taking snapshot of request processing status, restoring it at }
                 result=r.process(body_code);                  result=r.process(body_code);
                   context_saved.restore(); // manually restoring context
         } catch(const Exception& e) {          } catch(const Exception& e) {
                 // restoring request processing status  
                 //r.exception_trace.top_index(ssexception_trace);  
                 r.stack.top_index(sstack);  
                 r.self=sself; r.method_frame=smethod_frame, r.rcontext=srcontext; r.wcontext=swcontext;  
                   
                   
                 VHash& vhash=exception2vhash(pool, e);                  VHash& vhash=exception2vhash(pool, e);
   
                 Junction *junction=catch_code.get_junction();                  Junction *junction=catch_code.get_junction();
Line 647  static void _throw_operator(Request& r, Line 644  static void _throw_operator(Request& r,
                   
 // constructor  // constructor
   
 MOP::MOP(Pool& apool) : Methoded(apool, "OP"),  VClassMAIN::VClassMAIN(Pool& apool): VClass(apool) {
         main_sql_name(apool, MAIN_SQL_NAME),          set_name(*NEW String(pool(), MAIN_CLASS_NAME));
         main_sql_drivers_name(apool, MAIN_SQL_DRIVERS_NAME)  
 {  
         // ^if(condition){code-when-true}          // ^if(condition){code-when-true}
         // ^if(condition){code-when-true}{code-when-false}          // ^if(condition){code-when-true}{code-when-false}
         add_native_method("if", Method::CT_ANY, _if, 2, 3);          add_native_method("if", Method::CT_ANY, _if, 2, 3);
Line 662  MOP::MOP(Pool& apool) : Methoded(apool, Line 658  MOP::MOP(Pool& apool) : Methoded(apool,
         add_native_method("taint", Method::CT_ANY, _taint, 1, 2);          add_native_method("taint", Method::CT_ANY, _taint, 1, 2);
   
         // ^process[code]          // ^process[code]
         add_native_method("process", Method::CT_ANY, _process, 1, 1);          add_native_method("process", Method::CT_ANY, _process, 1, 2);
   
         // ^rem{code}          // ^rem{code}
         add_native_method("rem", Method::CT_ANY, _rem, 1, 10000);          add_native_method("rem", Method::CT_ANY, _rem, 1, 10000);
Line 708  MOP::MOP(Pool& apool) : Methoded(apool, Line 704  MOP::MOP(Pool& apool) : Methoded(apool,
   
 // constructor & configurator  // constructor & configurator
   
 Methoded *MOP_create(Pool& pool) {  VClass& VClassMAIN_create(Pool& pool) {
         return new(pool) MOP(pool);          return *new(pool) VClassMAIN(pool);
 }  
   
 void MOP::configure_user(Request& r) {  
         Pool& pool=r.pool();  
   
         // $MAIN:SQL.drivers  
         if(Value *sql=r.main_class->get_element(main_sql_name, r.main_class, false))  
                 if(Value *element=sql->get_element(main_sql_drivers_name, sql, false))  
                         if(Table *protocol2library=element->get_table())  
                                 r.classes_conf.put(name(), protocol2library);  
 }  }
Removed from v.1.107  
changed lines
  Added in v.1.122

E-mail: