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

Diff for /parser3/src/main/pa_request.C between versions 1.188 and 1.195

version 1.188, 2001/12/21 12:47:56 version 1.195, 2002/03/18 15:29:46
Line 1 Line 1
 /** @file  /** @file
         Parser: request class main part. @see compile.C and execute.C.          Parser: request class main part. @see compile.C and execute.C.
   
         Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         $Id$          $Id$
 */  */
Line 30  const char *DEFAULT_CONTENT_TYPE="text/h Line 30  const char *DEFAULT_CONTENT_TYPE="text/h
 const char *ORIGINS_CONTENT_TYPE="text/plain";  const char *ORIGINS_CONTENT_TYPE="text/plain";
   
 Methoded *MOP_create(Pool&);  Methoded *MOP_create(Pool&);
   // op.C
   VHash& exception2vhash(Pool& pool, const Exception& e);
   
 static void load_charset(const Hash::Key& akey, Hash::Val *avalue,   static void load_charset(const Hash::Key& akey, Hash::Val *avalue, 
                                                                                   void *) {                                                                                    void *) {
         Value& value=*static_cast<Value *>(avalue);          charsets->load_charset(akey, static_cast<Value *>(avalue)->as_string());
   
         if(!charsets->get(akey)) // don't we know that charset?  
                 charsets->put(akey,   
                         new(charsets->pool()) Charset(charsets->pool(), akey, &value.as_string()));  
 }  }
   
 //  //
Line 62  Request::Request(Pool& apool, Line 60  Request::Request(Pool& apool,
         default_content_type(0),          default_content_type(0),
         mime_types(0),          mime_types(0),
         main_class(0),          main_class(0),
         connection(0),          fconnection(0),
         classes_conf(apool),          classes_conf(apool),
         anti_endless_execute_recoursion(0),          anti_endless_execute_recoursion(0),
         trace(apool)          trace(apool)
Line 106  Request::Request(Pool& apool, Line 104  Request::Request(Pool& apool,
         classes().put(math.get_class()->base()->name(), &math);           classes().put(math.get_class()->base()->name(), &math); 
 }  }
   
   Request::~Request() {
   #ifdef XML
           // if for some strange reason xml generic errors failed to be reported, free them up
           if(const char *xml_generic_errors=xmlGenericErrors()) {
                   SAPI::log(pool(), "warning: unreported xmlGenericErrors: %s", xml_generic_errors);
                   free((void *)xml_generic_errors);
           }
   #endif
   }
   
   
 /**  /**
         load MAIN class, execute @main.          load MAIN class, execute @main.
         MAIN class consists of all the auto.p files we'd manage to find          MAIN class consists of all the auto.p files we'd manage to find
Line 228  gettimeofday(&mt[0],NULL); Line 237  gettimeofday(&mt[0],NULL);
 gettimeofday(&mt[1],NULL);  gettimeofday(&mt[1],NULL);
 #endif  #endif
                 // execute @main[]                  // execute @main[]
                 const String *body_string=execute_virtual_method(                  const String *body_string=execute_virtual_method(*main_class, *main_method_name);
                         *main_class, *main_method_name);  
                 if(!body_string)                  if(!body_string)
                         throw Exception(0,0,                          throw Exception(0,0,
                                 0,                                   0, 
Line 337  t[9]-t[3] Line 345  t[9]-t[3]
                         if(main_class) { // we've managed to end up with some main_class                          if(main_class) { // we've managed to end up with some main_class
                                 // maybe we'd be lucky enough as to report an error                                  // maybe we'd be lucky enough as to report an error
                                 // in a gracefull way...                                  // in a gracefull way...
                                 if(Value *value=main_class->get_element(*exception_method_name))                                  if(Value *value=main_class->get_element(*unhandled_exception_method_name))
                                         if(Junction *junction=value->get_junction())                                          if(Junction *junction=value->get_junction())
                                                 if(const Method *method=junction->method) {                                                  if(const Method *method=junction->method) {
                                                         // preparing to pass parameters to                                                           // preparing to pass parameters to 
Line 345  t[9]-t[3] Line 353  t[9]-t[3]
                                                         VMethodFrame frame(pool(), value->name(), *junction);                                                          VMethodFrame frame(pool(), value->name(), *junction);
                                                         frame.set_self(*main_class);                                                          frame.set_self(*main_class);
   
                                                         const String *problem_source=e.problem_source();                                                          frame.store_param(method->name, &exception2vhash(pool(), e));
                                                         // origin  
                                                         Value *origin_value=0;  
 #ifndef NO_STRING_ORIGIN  
                                                         if(problem_source && problem_source->size()) {  
                                                                 const Origin& origin=problem_source->origin();  
                                                                 if(origin.file) {  
                                                                         char *buf=(char *)malloc(MAX_STRING);  
                                                                         size_t buf_size=snprintf(buf, MAX_STRING, ORIGIN_FILE_LINE_FORMAT,   
                                                                                 origin.file, 1+origin.line);  
                                                                         origin_value=NEW VString(*NEW String(pool(),  
                                                                                 buf, buf_size, true));  
                                                                 }  
                                                         }  
 #endif  
                                                         frame.store_param(method->name,   
                                                                 origin_value?origin_value:NEW VVoid(pool()));  
   
                                                         // source  
                                                         Value *source_value=0;  
                                                         if(problem_source && problem_source->size()) {  
                                                                 String& problem_source_copy=*NEW String(pool());  
                                                                 problem_source_copy.append(*problem_source,   
                                                                         flang, true);  
                                                                 source_value=NEW VString(problem_source_copy);  
                                                         }  
                                                         frame.store_param(method->name,   
                                                                 source_value?source_value:NEW VVoid(pool()));  
   
                                                         // comment  
                                                         String *comment_value=NEW String(pool(),  
                                                                 e.comment(), 0, true);  
                                                         frame.store_param(method->name,   
                                                                 NEW VString(*comment_value));  
   
                                                         // type  
                                                         Value *type_value;  
                                                         if(e.type()) {  
                                                                 String& type_copy=*NEW String(pool());  
                                                                 type_value=NEW VString(type_copy.append(*e.type(),   
                                                                         flang, true));  
                                                         } else  
                                                                 type_value=NEW VVoid(pool());  
                                                         frame.store_param(method->name, type_value);  
   
                                                         // code  
                                                         Value *code_value;  
                                                         if(e.code()) {  
                                                                 String& code_copy=*NEW String(pool());  
                                                                 code_value=NEW VString(code_copy.append(*e.code(),   
                                                                         flang, true));  
                                                         } else  
                                                                 code_value=NEW VVoid(pool());  
                                                         frame.store_param(method->name, code_value);  
   
                                                         // $stack[^table::set{name      origin}]                                                          // $stack[^table::set{name      origin}]
                                                         Array& stack_trace_columns=*NEW Array(pool());                                                          Array& stack_trace_columns=*NEW Array(pool());
                                                         stack_trace_columns+=NEW String(pool(), "name");                                                          stack_trace_columns+=NEW String(pool(), "name");
                                                         stack_trace_columns+=NEW String(pool(), "origin");                                                          stack_trace_columns+=NEW String(pool(), "file");
                                                           stack_trace_columns+=NEW String(pool(), "lineno");
                                                         Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);                                                          Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);
                                                         Array_iter tracei(trace);                                                          Array_iter tracei(trace);
                                                         while(tracei.has_next()) {                                                          while(tracei.has_next()) {
Line 414  t[9]-t[3] Line 369  t[9]-t[3]
 #ifndef NO_STRING_ORIGIN  #ifndef NO_STRING_ORIGIN
                                                                 const Origin& origin=name->origin();                                                                  const Origin& origin=name->origin();
                                                                 if(origin.file) {                                                                  if(origin.file) {
                                                                         char *buf=(char *)malloc(MAX_STRING);                                                                          row+=NEW String(pool(), origin.file, 0, true); // file column
                                                                         size_t buf_size=snprintf(buf, MAX_STRING, ORIGIN_FILE_LINE_FORMAT,                                                                           char *buf=(char *)malloc(MAX_NUMBER);
                                                                                 origin.file, 1+origin.line);                                                                          size_t buf_size=snprintf(buf, MAX_NUMBER, "%d", 1+origin.line);
                                                                         row+=NEW String(pool(), buf, buf_size, true); // origin column                                                                          row+=NEW String(pool(), buf, buf_size, true); // line column
                                                                 }                                                                  }
 #endif  #endif
                                                                 stack_trace+=&row;                                                                  stack_trace+=&row;
Removed from v.1.188  
changed lines
  Added in v.1.195

E-mail: