[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.156 and 1.163

version 1.156, 2005/08/26 11:12:45 version 1.163, 2005/12/01 15:51:06
Line 22  static const char * const IDENT_OP_C="$D Line 22  static const char * const IDENT_OP_C="$D
   
 // limits  // limits
   
 #define MAX_LOOPS 10000  #define MAX_LOOPS 20000
   
 // defines  // defines
   
Line 76  public: Line 76  public:
                 ULN("optimized-xml", XML|String::L_OPTIMIZE_BIT);                  ULN("optimized-xml", XML|String::L_OPTIMIZE_BIT);
                 ULN("html", HTML);                  ULN("html", HTML);
                 ULN("optimized-html", HTML|String::L_OPTIMIZE_BIT);                  ULN("optimized-html", HTML|String::L_OPTIMIZE_BIT);
                   ULN("regex", REGEX);
                 #undef ULN                  #undef ULN
         }          }
 } untaint_lang_name2enum;  } untaint_lang_name2enum;
Line 229  static void _rem(Request&, MethodParams& Line 230  static void _rem(Request&, MethodParams&
   
 static void _while(Request& r, MethodParams& params) {  static void _while(Request& r, MethodParams& params) {
         Value& vcondition=params.as_junction(0, "condition must be expression");          Value& vcondition=params.as_junction(0, "condition must be expression");
         Value& body=params.as_junction(1, "body must be code");          Value& body_code=params.as_junction(1, "body must be code");
           Value* delim_maybe_code=params.count()>2?&params[2]:0;
   
         // while...          // while...
         int endless_loop_count=0;          int endless_loop_count=0;
           bool need_delim=false;
         while(true) {          while(true) {
                 if(++endless_loop_count>=MAX_LOOPS) // endless loop?                  if(++endless_loop_count>=MAX_LOOPS) // endless loop?
                         throw Exception("parser.runtime",                          throw Exception("parser.runtime",
Line 244  static void _while(Request& r, MethodPar Line 247  static void _while(Request& r, MethodPar
                 if(!condition) // ...condition is true                  if(!condition) // ...condition is true
                         break;                          break;
   
                 // write processed body                  StringOrValue sv_processed=r.process(body_code);
                 r.write_pass_lang(r.process(body));                  const String* s_processed=sv_processed.get_string();
                   if(delim_maybe_code && s_processed && s_processed->length()) { // delimiter set and we have body
                           if(need_delim) // need delim & iteration produced string?
                                   r.write_pass_lang(r.process(*delim_maybe_code));
                           need_delim=true;
                   }
                   r.write_pass_lang(sv_processed);
         }          }
 }  }
   
Line 378  static void _case(Request& r, MethodPara Line 387  static void _case(Request& r, MethodPara
         int count=params.count();          int count=params.count();
         Value& code=params.as_junction(--count, "case result must be code");          Value& code=params.as_junction(--count, "case result must be code");
                   
           Value& searching=data->searching;
           bool we_are_searching_string_or_void=searching.is_string() || searching.is_void();
         for(int i=0; i<count; i++) {          for(int i=0; i<count; i++) {
                 Value& value=r.process_to_value(params[i]);                  Value& value=r.process_to_value(params[i]);
   
                 if(value.as_string() == CASE_DEFAULT_VALUE) {                  if(value.is_string() && value.as_string() == CASE_DEFAULT_VALUE) {
                         data->_default=&code;                          data->_default=&code;
                         break;                          break;
                 }                  }
   
                 bool matches;                  bool matches;
                 if(data->searching.is_string())                  if(we_are_searching_string_or_void)
                         matches=data->searching.as_string() == value.as_string();                          matches=searching.as_string() == value.as_string();
                 else                  else
                         matches=data->searching.as_double() == value.as_double();                          matches=searching.as_double() == value.as_double();
   
                 if(matches) {                  if(matches) {
                         if(data->found)                          if(data->found)
Line 416  struct Try_catch_result { Line 427  struct Try_catch_result {
 template<class I>  template<class I>
 static Try_catch_result try_catch(Request& r,   static Try_catch_result try_catch(Request& r, 
                   StringOrValue body_code(Request&, I), I info,                     StringOrValue body_code(Request&, I), I info, 
                   Value* catch_code)                     Value* catch_code, bool could_be_handled_by_caller=false) 
 {  {
         Try_catch_result result;          Try_catch_result result;
         if(!catch_code) {          if(!catch_code) {
Line 447  static Try_catch_result try_catch(Reques Line 458  static Try_catch_result try_catch(Reques
                 bool bhandled=false;                  bool bhandled=false;
                 if(vhandled) {                  if(vhandled) {
                         if(vhandled->is_string()) { // not simple $exception.handled(1/0)?                          if(vhandled->is_string()) { // not simple $exception.handled(1/0)?
                                 result.exception_should_be_handled=vhandled->get_string(); // considering 'recovered' and let the caller recover                                  if(could_be_handled_by_caller) { // and we can possibly handle it
                                 return result;                                          result.exception_should_be_handled=vhandled->get_string(); // considering 'recovered' and let the caller recover
                         }                                          return result;
                                   }
                         bhandled=vhandled->as_bool();                                             
                                   bhandled=false;
                           } else
                                   bhandled=vhandled->as_bool();           
                 }                  }
   
                 if(!bhandled) {                  if(!bhandled) {
Line 509  static void locked_process_and_cache_put Line 523  static void locked_process_and_cache_put
         Locked_process_and_cache_put_action_info& info=          Locked_process_and_cache_put_action_info& info=
                 *static_cast<Locked_process_and_cache_put_action_info *>(context);                  *static_cast<Locked_process_and_cache_put_action_info *>(context);
   
   
           const String* body_from_disk=info.scope->body_from_disk;
         // body->process           // body->process 
         Try_catch_result result=try_catch(*info.r,           Try_catch_result result=try_catch(*info.r, 
                 process_cache_body_code, info.body_code,                  process_cache_body_code, info.body_code,
                 info.catch_code);                  info.catch_code, body_from_disk!=0 /*we have something old=we can handle=recover later*/);
   
         if(result.exception_should_be_handled) {          if(result.exception_should_be_handled) {
                 if(*result.exception_should_be_handled==CACHE_EXCEPTION_HANDLED_CACHE_NAME) {                  if(*result.exception_should_be_handled==CACHE_EXCEPTION_HANDLED_CACHE_NAME) {
                         if(const String* body_from_disk=info.scope->body_from_disk) // we have something old?                          assert(body_from_disk);
                                 info.processed_code=body_from_disk;                          info.processed_code=body_from_disk;
                         else  
                                 throw Exception(0,  
                                         new String("$"EXCEPTION_VAR_NAME"."EXCEPTION_HANDLED_PART_NAME"["CACHE_EXCEPTION_HANDLED_CACHE_NAME"]"),  
                                         "fallback failed - there is no old cached body");  
                 } else                  } else
                         throw Exception("parser.runtime",                          throw Exception("parser.runtime",
                                 result.exception_should_be_handled,                                  result.exception_should_be_handled,
Line 611  static const String& as_file_spec(Reques Line 623  static const String& as_file_spec(Reques
         return r.absolute(params.as_string(index, "filespec must be string"));          return r.absolute(params.as_string(index, "filespec must be string"));
 }  }
 static void _cache(Request& r, MethodParams& params) {  static void _cache(Request& r, MethodParams& params) {
           if(params.count()==0)
           {
                   // return current expiration time
                   Cache_scope* scope=static_cast<Cache_scope*>(r.classes_conf.get(cache_data_name));
                   if(!scope)
                           throw Exception("parser.runtime",
                                   0,
                                   "expire-time get without cache");
                   r.write_no_lang(*new VDate(scope->expires));
                   return;
           }
   
         time_t now=time(0);          time_t now=time(0);
   
         // ^cache[filename] ^cache(seconds) ^cache[expires date]          // ^cache[filename] ^cache(seconds) ^cache[expires date]
Line 796  VClassMAIN::VClassMAIN(): VClass() { Line 820  VClassMAIN::VClassMAIN(): VClass() {
         add_native_method("rem", Method::CT_ANY, _rem, 1, 10000);          add_native_method("rem", Method::CT_ANY, _rem, 1, 10000);
   
         // ^while(condition){code}          // ^while(condition){code}
         add_native_method("while", Method::CT_ANY, _while, 2, 2);          add_native_method("while", Method::CT_ANY, _while, 2, 3);
   
         // ^use[file]          // ^use[file]
         add_native_method("use", Method::CT_ANY, _use, 1, 1);          add_native_method("use", Method::CT_ANY, _use, 1, 1);
Line 814  VClassMAIN::VClassMAIN(): VClass() { Line 838  VClassMAIN::VClassMAIN(): VClass() {
   
         // ^cache[file_spec](time){code}[{catch code}] time=0 no cache          // ^cache[file_spec](time){code}[{catch code}] time=0 no cache
         // ^cache[file_spec] delete cache          // ^cache[file_spec] delete cache
         add_native_method("cache", Method::CT_ANY, _cache, 1, 4);          // ^cache[] get current expiration time
           add_native_method("cache", Method::CT_ANY, _cache, 0, 4);
                   
         // switch          // switch
   
Removed from v.1.156  
changed lines
  Added in v.1.163

E-mail: