[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.163 and 1.175

version 1.163, 2001/10/01 08:53:58 version 1.175, 2001/11/05 10:21:27
Line 9 Line 9
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   
 #include "pcre.h"  //#include "pcre.h"
 #include "internal.h"  //#include "internal.h"
 extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c  extern "C" unsigned char pcre_default_tables[]; // pcre/chartables.c
   
 #include "pa_sapi.h"  #include "pa_sapi.h"
Line 25  extern "C" unsigned char pcre_default_ta Line 25  extern "C" unsigned char pcre_default_ta
 #include "pa_vtable.h"  #include "pa_vtable.h"
 #include "pa_vfile.h"  #include "pa_vfile.h"
 #include "pa_dictionary.h"  #include "pa_dictionary.h"
   #include "pa_charset_manager.h"
 #ifdef XML  
 #       include <util/XercesDefs.hpp>  
 #       include <util/TransENameMap.hpp>  
 #       include <util/XML256TableTranscoder.hpp>  
 #       include <util/PlatformUtils.hpp>  
 #       include <PlatformSupport/XalanTranscodingServices.hpp>  
 #endif  
   
 /// content type of exception response, when no @MAIN:exception handler defined  /// content type of exception response, when no @MAIN:exception handler defined
 const char *UNHANDLED_EXCEPTION_CONTENT_TYPE="text/plain";  const char *UNHANDLED_EXCEPTION_CONTENT_TYPE="text/plain";
Line 43  const char *ORIGINS_CONTENT_TYPE="text/p Line 36  const char *ORIGINS_CONTENT_TYPE="text/p
   
 Methoded *MOP_create(Pool&);  Methoded *MOP_create(Pool&);
   
   
 inline void prepare_case_tables(unsigned char *tables) {  
         unsigned char *lcc_table=tables+lcc_offset;  
         unsigned char *fcc_table=tables+fcc_offset;  
         for(int i=0; i<0x100; i++)  
                 lcc_table[i]=fcc_table[i]=i;  
 }  
 inline void cstr2ctypes(unsigned char *tables, const unsigned char *cstr,   
                                                 unsigned char bit) {  
         unsigned char *ctypes_table=tables+ctypes_offset;  
         ctypes_table[0]=bit;  
         for(; *cstr; cstr++) {  
                 unsigned char c=*cstr;  
                 ctypes_table[c]|=bit;  
         }  
 }  
 inline unsigned int to_wchar_code(const String *s) {  
         if(!s || s->size()==0)  
                 return 0;  
         if(s->size()==1)  
                 return (unsigned int)s->first_char();  
         return (unsigned int)s->as_int();  
 }  
 inline bool to_bool(const String *s) {  
         return s && s->size()!=0;  
 }  
 static void element2ctypes(unsigned char c, bool belongs,  
                                                    unsigned char *tables,  unsigned char bit, int group_offset=-1) {  
         if(!belongs)  
                 return;  
   
         unsigned char *ctypes_table=tables+ctypes_offset;  
   
         ctypes_table[c]|=bit;  
         if(group_offset>=0)  
                 tables[cbits_offset+group_offset+c/8] |= 1 << (c%8);  
 }  
 static void element2case(unsigned char from, unsigned char to,  
                                                  unsigned char *tables) {  
         if(!to)   
                 return;  
   
         unsigned char *lcc_table=tables+lcc_offset;  
         unsigned char *fcc_table=tables+fcc_offset;  
         lcc_table[from]=to;  
         fcc_table[from]=to; fcc_table[to]=from;  
 }  
   
 #ifndef DOXYGEN  
 struct Charset_tables {  
         // pcre_tables  
         unsigned char *pcre_tables;  
 #ifdef XML  
         // transcoder  
         XMLCh *fromTable;  
         XMLTransService::TransRec *toTable;  
         unsigned int toTableSz;  
 #endif  
 };  
 #endif  
   
 static void ctype_table_row_to_charset_tables(Array::Item *value, void *info) {  
         Array& row=*static_cast<Array *>(value);  
         Charset_tables& tables=*static_cast<Charset_tables *>(info);  
           
 // char white-space     digit   hex-digit       letter  word    lowercase       unicode1        unicode2          
         unsigned int c=to_wchar_code(row.get_string(0));  
           
         // pcre_tables  
         element2ctypes(c, to_bool(row.get_string(1)), tables.pcre_tables, ctype_space, cbit_space);  
         element2ctypes(c, to_bool(row.get_string(2)), tables.pcre_tables, ctype_digit, cbit_digit);  
         element2ctypes(c, to_bool(row.get_string(3)), tables.pcre_tables, ctype_xdigit);  
         element2ctypes(c, to_bool(row.get_string(4)), tables.pcre_tables, ctype_letter);  
         element2ctypes(c, to_bool(row.get_string(5)), tables.pcre_tables, ctype_word, cbit_word);  
         element2case(c, to_wchar_code(row.get_string(6)), tables.pcre_tables);  
   
 #ifdef XML  
         // transcoder  
         XMLCh unicode1=row.size()>7?(XMLCh)to_wchar_code(row.get_string(7)):0;  
         XMLCh unicode2=row.size()>8?(XMLCh)to_wchar_code(row.get_string(8)):0;  
         if(!tables.fromTable[c])  
                 tables.fromTable[c]=unicode1?unicode1:(XMLCh)c;  
         tables.toTable[tables.toTableSz].intCh=unicode1?unicode1:(XMLCh)c;  
         tables.toTable[tables.toTableSz].extCh=(XMLByte)c;  
         tables.toTableSz++;  
         if(unicode2) {  
                 tables.toTable[tables.toTableSz].intCh=unicode2;  
                 tables.toTable[tables.toTableSz].extCh=(XMLByte)c;  
                 tables.toTableSz++;  
         }  
 #endif  
 }  
 static int sort_cmp_Trans_rec_intCh(const void *a, const void *b) {  
         const XMLCh ca=static_cast<const XMLTransService::TransRec *>(a)->intCh;  
         const XMLCh cb=static_cast<const XMLTransService::TransRec *>(b)->intCh;  
         // move zeros to end of table  
         if(ca==0)  
                 return +1;  
         if(cb==0)  
                 return -1;  
   
         //  
         return ca-cb;  
 }  
   
   
 #ifdef XML  
 template <class TType> class ENameMapFor2 : public ENameMap  
 {  
 public :  
     // -----------------------------------------------------------------------  
     //  Constructors and Destructor  
     // -----------------------------------------------------------------------  
     ENameMapFor2(  
                 const XMLCh* const encodingName  
         , const XMLCh* const                        fromTable  
         , const XMLTransService::TransRec* const    toTable  
         , const unsigned int                        toTableSize  
                 ) : ENameMap(encodingName),  
                 ffromTable(fromTable),  
                 ftoTable(toTable),  
                 ftoTableSize(toTableSize) {}  
     ~ENameMapFor2() {}  
   
     // -----------------------------------------------------------------------  
     //  Implementation of virtual factory method  
     // -----------------------------------------------------------------------  
     virtual XMLTranscoder* makeNew(const unsigned int blockSize) const {  
                 return new TType(  
                         getKey(),   
                         blockSize,  
                         ffromTable,  
                         ftoTable, ftoTableSize);  
         }  
 private:  
         const XMLCh* const                        ffromTable;  
         const XMLTransService::TransRec* const    ftoTable;  
         const unsigned int                        ftoTableSize;  
   
 private :  
     // -----------------------------------------------------------------------  
     //  Unimplemented constructors and operators  
     // -----------------------------------------------------------------------  
     ENameMapFor2();  
     ENameMapFor2(const ENameMapFor2<TType>&);  
     void operator=(const ENameMapFor2<TType>&);  
 };  
   
 class XML256TableTranscoder2 : public XML256TableTranscoder  
 {  
 public :  
     XML256TableTranscoder2(  
         const   XMLCh* const                        encodingName  
         , const unsigned int                        blockSize  
         , const XMLCh* const                        fromTable  
         , const XMLTransService::TransRec* const    toTable  
         , const unsigned int                        toTableSize  
                 ) : XML256TableTranscoder(encodingName, blockSize, fromTable, toTable, toTableSize) {}  
   
 private :  
     XML256TableTranscoder2();  
     XML256TableTranscoder2(const XML256TableTranscoder2&);  
     void operator=(const XML256TableTranscoder2&);  
 };  
 #endif  
   
 #ifdef XALAN_HACK_DIGITAL_ENTITIES  
 static void hack_s_maximumCharacterValues(const XalanDOMString& encoding) {  
 /*  
         open:  
                 xml-xalan/c/src/PlatformSupport/XalanTranscodingServices.hpp   
         find:   
                 static const MaximumCharacterValueMapType&      s_maximumCharacterValues;  
         paste to next line:  
                 friend static void hack_s_maximumCharacterValues(const XalanDOMString& encoding); // hack by paf  
 */  
   
         /**/  
         const_cast<XalanTranscodingServices::MaximumCharacterValueMapType &>(  
                 XalanTranscodingServices::s_maximumCharacterValues).insert(  
                 XalanTranscodingServices::MaximumCharacterValueMapType::value_type(encoding, 0xFFFF));  
                 /**/  
 }  
 #endif  
   
 /// @todo addEncoding only once!  
 static void load_charset(const Hash::Key& akey, Hash::Val *avalue,   static void load_charset(const Hash::Key& akey, Hash::Val *avalue, 
                                                                                   void *info) {                                                                                    void *info) {
           Value& value=*static_cast<Value *>(avalue);
         Hash& CTYPE=*static_cast<Hash *>(info);          Hash& CTYPE=*static_cast<Hash *>(info);
         Pool& pool=CTYPE.pool();  
   
         Charset_tables tables={  
                 // pcre_tables  
                 // lowcase, flipcase, bits digit+word+whitespace, masks  
                 (unsigned char *)pool.calloc(tables_length) // pcre_tables  
 #ifdef XML  
                 // transcoder  
                 , (XMLCh *)pool.calloc(sizeof(XMLCh)*0x100) // fromTable  
                 , 0 // toTable  
                 , 0 // toTableSz  
 #endif  
         };  
         prepare_case_tables(tables.pcre_tables);  
         cstr2ctypes(tables.pcre_tables, (const unsigned char *)"*+?{^.$|()[", ctype_meta);  
   
         // fill tables          Charset_connection& connection=charset_manager->get_connection(akey, value.as_string());
         Value& value=*static_cast<Value *>(avalue);  
         if(Table *table=value.get_table()) {  
 #ifdef XML  
                 tables.toTable=(XMLTransService::TransRec *)pool.calloc(  
                         sizeof(XMLTransService::TransRec)*table->size()*2);  
 #endif  
                 table->for_each(ctype_table_row_to_charset_tables, &tables);  
 #ifdef XML  
                 // sort by the Unicode code point  
                 _qsort(tables.toTable, tables.toTableSz, sizeof(*tables.toTable),   
                         sort_cmp_Trans_rec_intCh);  
 #endif  
         } else  
                 PTHROW(0, 0,  
                         &value.name(),  
                         "must be hash");  
   
         // charset->pcre_tables           // charset->pcre_tables 
         CTYPE.put(akey, tables.pcre_tables);          CTYPE.put(akey, connection.pcre_tables());
   
 #ifdef XML  
         // charset->transcoder  
         XalanDOMString sencoding(akey.cstr());  
 #ifdef XALAN_HACK_DIGITAL_ENTITIES  
         hack_s_maximumCharacterValues(sencoding);  
 #endif  
         const XMLCh* const auto_encoding_cstr=sencoding.c_str();  
         int size=sizeof(XMLCh)*(sencoding.size()+1);  
         XMLCh* pool_encoding_cstr=(XMLCh*)malloc(size);  
         memcpy(pool_encoding_cstr, auto_encoding_cstr, size);  
     XMLString::upperCase(pool_encoding_cstr);  
   
     XMLPlatformUtils::fgTransService->addEncoding(  
                 pool_encoding_cstr,   
                 new ENameMapFor2<XML256TableTranscoder2>(  
                         pool_encoding_cstr  
                         , tables.fromTable  
                         , tables.toTable  
                         , tables.toTableSz  
                 ));  
 #endif  
 }  }
   
 //  //
Line 299  Request::Request(Pool& apool, Line 54  Request::Request(Pool& apool,
         stack(apool),          stack(apool),
         OP(*MOP_create(apool)),          OP(*MOP_create(apool)),
         env(apool),          env(apool),
           status(apool),
         form(apool),          form(apool),
         math(apool),          math(apool),
         request(apool, *this),          request(apool, *this),
Line 315  Request::Request(Pool& apool, Line 71  Request::Request(Pool& apool,
         main_class(0),          main_class(0),
         connection(0),          connection(0),
         classes_conf(apool),          classes_conf(apool),
         anti_endless_execute_recoursion(0)                anti_endless_execute_recoursion(0),
           trace(apool)
 {  {
         /// directly used          /// directly used
         // operators          // operators
Line 327  Request::Request(Pool& apool, Line 84  Request::Request(Pool& apool,
         /// methodless          /// methodless
         // env class          // env class
         classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);          classes().put(*NEW String(pool(), ENV_CLASS_NAME), &env);
           // status class
           classes().put(*NEW String(pool(), STATUS_CLASS_NAME), &status);
         // request class          // request class
         classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);                 classes().put(*NEW String(pool(), REQUEST_CLASS_NAME), &request);       
         // cookie class          // cookie class
Line 356  void Request::core( Line 115  void Request::core(
                                    const char *site_config_filespec, bool site_config_fail_on_read_problem,                                     const char *site_config_filespec, bool site_config_fail_on_read_problem,
                                    bool header_only) {                                     bool header_only) {
         //_asm { int 3 }          //_asm { int 3 }
         bool need_rethrow=false;  Exception rethrow_me;          try {
         TRY {  
                 char *auto_filespec=(char *)malloc(MAX_STRING);                  char *auto_filespec=(char *)malloc(MAX_STRING);
                                   
                 // loading root config                  // loading root config
Line 370  void Request::core( Line 128  void Request::core(
                                 main_class_name, main_class);                                  main_class_name, main_class);
                 }                  }
   
                   if(main_class) {
                           /* $MAIN:CHARSETS[
                                           $.charsetname1[/full/path/to/charset/file.cfg]
                                           ...
                                   ]
                           */
                           if(Value *vcharsets=main_class->get_element(*charsets_name)) {
                                   if(Hash *charsets=vcharsets->get_hash(0))
                                           charsets->for_each(load_charset, &CTYPE);
                                   else
                                           throw Exception(0, 0,
                                                   &vcharsets->name(),
                                                   "must be hash");
                           }
                   }
   
                 // configure root options                  // configure root options
                 //      until someone with less privileges have overriden them                  //      until someone with less privileges have overriden them
                 OP.configure_admin(*this);                  OP.configure_admin(*this);
Line 430  void Request::core( Line 204  void Request::core(
                 // value must be allocated on request's pool for that pool used on                  // value must be allocated on request's pool for that pool used on
                 // meaning constructing @see attributed_meaning_to_string                  // meaning constructing @see attributed_meaning_to_string
                 default_content_type=defaults?defaults->get_element(*content_type_name):0;                  default_content_type=defaults?defaults->get_element(*content_type_name):0;
 #ifdef XML  
                 // record default charset                  // record default charset
                 if(default_content_type)                  if(default_content_type)
                         if(Hash *hash=default_content_type->get_hash())                          if(Hash *hash=default_content_type->get_hash(0))
                                 if(Value *vcharset=(Value *)hash->get(*charset_name))                                  if(Value *vcharset=(Value *)hash->get(*charset_name))
                                         pool().set_charset(vcharset->as_string());                                                        pool().set_charset(vcharset->as_string());              
 #endif  
   
                 if(Value *element=main_class->get_element(*user_html_name))                  if(Value *element=main_class->get_element(*user_html_name))
                         if(Table *table=element->get_table())                          if(Table *table=element->get_table())
Line 447  void Request::core( Line 219  void Request::core(
                         if(Table *table=element->get_table())                          if(Table *table=element->get_table())
                                 mime_types=table;                                                         mime_types=table;                       
   
                 if(Value *vcharsets=main_class->get_element(*charsets_name)) {  
                         if(Hash *charsets=vcharsets->get_hash())  
                                 charsets->for_each(load_charset, &CTYPE);  
                         else  
                                 THROW(0, 0,  
                                         &vcharsets->name(),  
                                         "must be hash");  
                 }  
   
                 // filling form fields                  // filling form fields
                 form.fill_fields_and_tables(*this);                  form.fill_fields_and_tables(*this);
   
Line 466  void Request::core( Line 229  void Request::core(
                 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(0,0,                          throw Exception(0,0,
                                 0,                                   0, 
                                 "'"MAIN_METHOD_NAME"' method not found");                                  "'"MAIN_METHOD_NAME"' method not found");
   
Line 504  void Request::core( Line 267  void Request::core(
   
                 // OK. write out the result                  // OK. write out the result
                 output_result(*body_file, header_only);                  output_result(*body_file, header_only);
         }           } catch(const Exception& e) { // request handling problem
         CATCH(e) { // request handling problem  
                 // we're returning not result, but error explanation                  // we're returning not result, but error explanation
                 TRY {                  try {
                         // log the beast                          // log the beast
                         const String *problem_source=e.problem_source();                          const String *problem_source=e.problem_source();
                         if(problem_source && problem_source->size())                          if(problem_source && problem_source->size())
Line 520  void Request::core( Line 282  void Request::core(
                                         problem_source->origin().file?problem_source->origin().file:"global",                                          problem_source->origin().file?problem_source->origin().file:"global",
                                         problem_source->origin().line,                                          problem_source->origin().line,
 #endif  #endif
                                         problem_source->cstr(String::UL_AS_IS),                                          problem_source->cstr(),
                                         e.comment(),                                          e.comment(),
                                         e.type()?e.type()->cstr(String::UL_AS_IS):"-",                                          e.type()?e.type()->cstr():"-",
                                         e.code()?e.code()->cstr(String::UL_AS_IS):"-"                                          e.code()?e.code()->cstr():"-"
                                 );                                  );
                         else                          else
                                 SAPI::log(pool(),                                  SAPI::log(pool(),
                                         "%s [%s %s]",                                          "%s [%s %s]",
                                         e.comment(),                                          e.comment(),
                                         e.type()?e.type()->cstr(String::UL_AS_IS):"-",                                          e.type()?e.type()->cstr():"-",
                                         e.code()?e.code()->cstr(String::UL_AS_IS):"-"                                          e.code()?e.code()->cstr():"-"
                                         );                                          );
   
                           /// @test log stack trace
   
                         // reset language to default                          // reset language to default
                         flang=fdefault_lang;                          flang=fdefault_lang;
                         if(flang==String::UL_USER_HTML)                          if(flang==String::UL_USER_HTML)
Line 550  void Request::core( Line 314  void Request::core(
                                 if(Value *value=main_class->get_element(*exception_method_name))                                  if(Value *value=main_class->get_element(*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 
                                                         //      @exception[origin;source;comment;type;code]                                                          //      @exception[origin;source;comment;type;code;stack]
                                                         VMethodFrame frame(pool(), value->name(), *junction);                                                          VMethodFrame frame(pool(), value->name(), *junction);
                                                         frame.set_self(*main_class);                                                          frame.set_self(*main_class);
   
Line 563  void Request::core( Line 327  void Request::core(
                                                                 const Origin& origin=problem_source->origin();                                                                  const Origin& origin=problem_source->origin();
                                                                 if(origin.file) {                                                                  if(origin.file) {
                                                                         char *buf=(char *)malloc(MAX_STRING);                                                                          char *buf=(char *)malloc(MAX_STRING);
                                                                         size_t buf_size=snprintf(buf, MAX_STRING, "%s(%d):",                                                                           size_t buf_size=snprintf(buf, MAX_STRING, "%s(%d)", 
                                                                                 origin.file, 1+origin.line);                                                                                  origin.file, 1+origin.line);
                                                                         String *origin_file_line=NEW String(pool(),                                                                          origin_value=NEW VString(*NEW String(pool(),
                                                                                 buf, buf_size, true);                                                                                  buf, buf_size, true));
                                                                         origin_value=NEW VString(*origin_file_line);  
                                                                 }                                                                  }
                                                         }                                                          }
 #endif  #endif
Line 611  void Request::core( Line 374  void Request::core(
                                                                 code_value=NEW VVoid(pool());                                                                  code_value=NEW VVoid(pool());
                                                         frame.store_param(method->name, code_value);                                                          frame.store_param(method->name, code_value);
   
                                                           // $stack[^table::set{name      origin}]
                                                           Array& stack_trace_columns=*NEW Array(pool());
                                                           stack_trace_columns+=NEW String(pool(), "name");
                                                           stack_trace_columns+=NEW String(pool(), "origin");
                                                           Table& stack_trace=*NEW Table(pool(), 0, &stack_trace_columns);
                                                           Array_iter tracei(trace);
                                                           while(tracei.has_next()) {
                                                                   Array& row=*NEW Array(pool());
   
                                                                   const String *name=(const String *)tracei.next();
                                                                   row+=name; // name column
   #ifndef NO_STRING_ORIGIN
                                                                   const Origin& origin=name->origin();
                                                                   if(origin.file) {
                                                                           char *buf=(char *)malloc(MAX_STRING);
                                                                           size_t buf_size=snprintf(buf, MAX_STRING, "%s(%d)", 
                                                                                   origin.file, 1+origin.line);
                                                                           row+=NEW String(pool(), buf, buf_size, true); // origin column
                                                                   }
   #endif
                                                                   stack_trace+=&row;
                                                           }
                                                           frame.store_param(method->name, 
                                                                   NEW VTable(pool(), &stack_trace));
   
                                                         // future $response:body=                                                          // future $response:body=
                                                         //   execute ^exception[origin;source;comment;type;code]                                                          //   execute ^exception[origin;source;comment;type;code;stack]
                                                         body_string=execute_method(frame, *method);                                                          body_string=execute_method(frame, *method);
                                                 }                                                  }
                         }                          }
Line 632  void Request::core( Line 420  void Request::core(
                                                 origin.file, 1+origin.line);                                                  origin.file, 1+origin.line);
 #endif  #endif
                                         printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ",                                           printed+=snprintf(buf+printed, MAX_STRING-printed, "'%s' ", 
                                                 problem_source->cstr(String::UL_AS_IS));                                                  problem_source->cstr());
                                 }                                  }
                                 printed+=snprintf(buf+printed, MAX_STRING-printed, "%s",                                   printed+=snprintf(buf+printed, MAX_STRING-printed, "%s", 
                                         e.comment());                                          e.comment());
                                 const String *type=e.type();                                  const String *type=e.type();
                                 if(type) {                                  if(type) {
                                         printed+=snprintf(buf+printed, MAX_STRING-printed, "  type: %s",                                           printed+=snprintf(buf+printed, MAX_STRING-printed, "  type: %s", 
                                                 type->cstr(String::UL_AS_IS));                                                  type->cstr());
                                         const String *code=e.code();                                          const String *code=e.code();
                                         if(code)                                          if(code)
                                                 printed+=snprintf(buf+printed, MAX_STRING-printed, ", code: %s",                                                   printed+=snprintf(buf+printed, MAX_STRING-printed, ", code: %s", 
                                                 code->cstr(String::UL_AS_IS));                                                  code->cstr());
                                 }                                  }
   
                                 // future $response:content-type                                  // future $response:content-type
Line 658  void Request::core( Line 446  void Request::core(
   
                         // ERROR. write it out                          // ERROR. write it out
                         output_result(*body_file, header_only);                          output_result(*body_file, header_only);
                   } catch(const Exception& ) {
                           /*re*/throw;
                 }                  }
                 CATCH(e) {  
                         // exception in request exception handler  
                         // remember to rethrow it  
                         rethrow_me=e;  need_rethrow=true;   
                 }  
                 END_CATCH  
         }          }
         END_CATCH // do not use pool() after this point - no exception handler set  
                   // any throw() would try to use zero exception() pointer   
   
         if(need_rethrow) // were there an exception for us to rethrow?  
                 THROW(rethrow_me.type(), rethrow_me.code(),  
                         rethrow_me.problem_source(),  
                         rethrow_me.comment());  
 }  }
   
 VStateless_class *Request::use_file(const String& file_name,   VStateless_class *Request::use_file(const String& file_name, 
Line 703  VStateless_class *Request::use_file(cons Line 480  VStateless_class *Request::use_file(cons
                                                         break; // found along class_path                                                          break; // found along class_path
                                         }                                          }
                                 } else                                  } else
                                         THROW(0, 0,                                          throw Exception(0, 0,
                                                 &element->name(),                                                  &element->name(),
                                                 "must be string or table");                                                  "must be string or table");
                                 if(!file_spec)                                  if(!file_spec)
                                         THROW(0, 0,                                          throw Exception(0, 0,
                                                 &file_name,                                                  &file_name,
                                                 "not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);                                                  "not found along " MAIN_CLASS_NAME ":" CLASS_PATH_NAME);
                         }                          }
                 if(!file_spec)                  if(!file_spec)
                         THROW(0, 0,                          throw Exception(0, 0,
                                 &file_name,                                  &file_name,
                                 "usage failed - no " MAIN_CLASS_NAME  ":" CLASS_PATH_NAME " were specified");                                  "usage failed - no " MAIN_CLASS_NAME  ":" CLASS_PATH_NAME " were specified");
         }          }
Line 766  static void add_header_attribute(const H Line 543  static void add_header_attribute(const H
         Pool& pool=lmeaning.pool();          Pool& pool=lmeaning.pool();
   
         SAPI::add_header_attribute(pool,          SAPI::add_header_attribute(pool,
                 aattribute.cstr(String::UL_AS_IS),                   aattribute.cstr(), 
                 attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER).cstr());                  attributed_meaning_to_string(lmeaning, String::UL_HTTP_HEADER).cstr());
 }  }
 void Request::output_result(const VFile& body_file, bool header_only) {  void Request::output_result(const VFile& body_file, bool header_only) {
Line 789  void Request::output_result(const VFile& Line 566  void Request::output_result(const VFile&
         if(VString *vfile_name=static_cast<VString *>(body_file.fields().get(*name_name)))          if(VString *vfile_name=static_cast<VString *>(body_file.fields().get(*name_name)))
                 if(vfile_name->string()!=NONAME_DAT) {                  if(vfile_name->string()!=NONAME_DAT) {
                         VHash& vhash=*NEW VHash(pool());                          VHash& vhash=*NEW VHash(pool());
                         vhash.hash().put(*content_disposition_filename_name, vfile_name);                          vhash.hash(0).put(*content_disposition_filename_name, vfile_name);
                         response.fields().put(*content_disposition_name, &vhash);                          response.fields().put(*content_disposition_name, &vhash);
                 }                  }
   
Line 823  const String& Request::mime_type_of(cons Line 600  const String& Request::mime_type_of(cons
                                 if(const String *result=mime_types->item(1))                                  if(const String *result=mime_types->item(1))
                                         return *result;                                          return *result;
                                 else                                  else
                                         THROW(0, 0,                                          throw Exception(0, 0,
                                                 mime_types->origin_string(),                                                  mime_types->origin_string(),
                                                 "MIME-TYPE table column elements must not be empty");                                                  "MIME-TYPE table column elements must not be empty");
                 }                  }
         return *NEW String(pool(), "application/octet-stream");          return *NEW String(pool(), "application/octet-stream");
 }  }
   
 unsigned char *Request::pcre_tables() {  const unsigned char *Request::pcre_tables() {
         if(unsigned char *result=(unsigned char *)CTYPE.get(pool().get_charset()))          if(unsigned char *result=(unsigned char *)CTYPE.get(pool().get_charset()))
                 return result;                  return result;
   
           // this is not for pcre itself, 
           // it can do default, it's for string.lower&co
         return pcre_default_tables;          return pcre_default_tables;
 }  }
Removed from v.1.163  
changed lines
  Added in v.1.175

E-mail: