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

Diff for /parser3/src/main/pa_common.C between versions 1.126 and 1.145.2.2

version 1.126, 2002/11/25 14:10:52 version 1.145.2.2, 2003/03/17 15:09:25
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
   
Line 12  static const char* IDENT_COMMON_C="$Date Line 12  static const char* IDENT_COMMON_C="$Date
 #include "pa_globals.h"  #include "pa_globals.h"
 #include "pa_hash.h"  #include "pa_hash.h"
 #include "pa_vstring.h"  #include "pa_vstring.h"
   #include "pa_vdate.h"
   
 #ifdef WIN32  #ifdef WIN32
 #       include <windows.h>  #       include <windows.h>
Line 28  static const char* IDENT_COMMON_C="$Date Line 29  static const char* IDENT_COMMON_C="$Date
 #       define _O_BINARY 0  #       define _O_BINARY 0
 #endif  #endif
   
   #ifdef HAVE_FTRUNCATE
   #       define PA_O_TRUNC 0
   #else
   #       ifdef _O_TRUNC
   #               define PA_O_TRUNC _O_TRUNC
   #       else
   #               error you must have either ftruncate function or _O_TRUNC bit declared
   #       endif
   #endif
   
 // locking constants  // locking constants
   
 #ifdef HAVE_FLOCK  #ifdef HAVE_FLOCK
Line 73  static int unlock(int fd) { FLOCK(F_TLOC Line 84  static int unlock(int fd) { FLOCK(F_TLOC
 #endif  #endif
 #endif  #endif
   
   #define DEFAULT_USER_AGENT "parser3"
   
 static char* strnchr(char* buf, size_t size, char c) {  
         // sanity check  
         if(!buf)  
                 return 0;  
   
         for(;  size-->0; buf++) {  
                 if(*buf==c)  
                         return buf;  
         }  
   
         return 0;  
 }  
   
 void fix_line_breaks(char* buf, size_t& size) {  void fix_line_breaks(char* buf, size_t& size) {
           if(size==0)
                   return;
   
         //_asm int 3;          //_asm int 3;
         const char* const eob=buf+size;          const char* const eob=buf+size;
         char* dest=buf;          char* dest=buf;
         // fix DOS: \r\n -> \n          // fix DOS: \r\n -> \n
         // fix Macintosh: \r -> \n          // fix Macintosh: \r -> \n
         char* bol=buf;          char* bol=buf;
         while(char* eol=strnchr(bol, eob -bol, '\r')) {          while(char* eol=(char*)memchr(bol, '\r', eob -bol)) {
                 size_t len=eol-bol;                  size_t len=eol-bol;
                 if(dest!=bol)                  if(dest!=bol)
                         memcpy(dest, bol, len);                           memcpy(dest, bol, len); 
Line 136  static bool set_addr(struct sockaddr_in Line 139  static bool set_addr(struct sockaddr_in
     return true;      return true;
 }  }
   
 static void http_read_response(String& response, int sock){  static int http_read_response(String& response, int sock, bool fail_on_status_ne_200){
           const String* status_code=0;
           ssize_t EOLat=0;
         while(true) {          while(true) {
                 char *buf=(char *)response.pool().malloc(MAX_STRING);                   char *buf=(char *)response.pool().malloc_atomic(MAX_STRING); 
                 ssize_t size=recv(sock, buf, MAX_STRING, 0);                   ssize_t size=recv(sock, buf, MAX_STRING, 0); 
                 if(size<=0)                  if(size<=0)
                         break;                          break;
                 response.APPEND_TAINTED(buf, size, "http response", 0);                   response.APPEND_TAINTED(buf, size, "remote HTTP server response", 0); 
     }                  if(!status_code && (EOLat=response.pos("\r\n", 2))>=0) { // checking status in first response
                           const String& status_line=response.mid(0, (size_t)EOLat);
                           Array astatus(response.pool()); 
                           size_t pos_after_ref=0; status_line.split(astatus, &pos_after_ref, " ", 1); 
                           status_code=astatus.get_string(1); 
   
                           if(fail_on_status_ne_200 && *status_code!="200")
                                   throw Exception("http.status",
                                           status_code,
                                           "invalid HTTP response status");
                   }
           }
           if(status_code)
                   return status_code->as_int();
           else
                   throw Exception("http.response",
                           0,
                           "bad response from host - no status found (size=%lu)", response.size()); 
 }  }
   
 /* ********************** request *************************** */  /* ********************** request *************************** */
   
 #if defined(SIGALRM) && defined(HAVE_SIGSETJMP) && defined(HAVE_SIGLONGJMP)  #if defined(SIGALRM) && defined(HAVE_SIGSETJMP) && defined(HAVE_SIGLONGJMP)
 #       define WE_CAN_USE_ALARM  #       define PA_USE_ALARM
 #endif  #endif
   
 #ifdef WE_CAN_USE_ALARM  #ifdef PA_USE_ALARM
 static sigjmp_buf timeout_env;  static sigjmp_buf timeout_env;
 static void timeout_handler(int sig){  static void timeout_handler(int sig){
     siglongjmp(timeout_env, 1);       siglongjmp(timeout_env, 1); 
 }  }
 #endif  #endif
   
 static void http_request(String& response,  static int http_request(String& response,
                                                         const String *origin_string,                                                           const String *origin_string, 
                                                         const char* host, int port,                                                           const char* host, int port, 
                                                         const char* request,                                                           const char* request, 
                                                         int timeout){                                                          int timeout,
                                                           bool fail_on_status_ne_200){
         if(!host)          if(!host)
                 throw Exception("http.host",                   throw Exception("http.host", 
                         origin_string,                           origin_string, 
                         "zero hostname");  //never                          "zero hostname");  //never
   
 #ifdef WE_CAN_USE_ALARM  #ifdef PA_USE_ALARM
     signal(SIGALRM, timeout_handler);       signal(SIGALRM, timeout_handler); 
 #endif  #endif
         int sock=-1;          int sock=-1;
         try {  #ifdef PA_USE_ALARM
 #ifdef WE_CAN_USE_ALARM          if(sigsetjmp(timeout_env, 1)) {
                 if(sigsetjmp(timeout_env, 1))                  // stupid gcc [2.95.4] generated bad code
                         throw Exception("http.timeout",                   // which failed to handle sigsetjmp+throw: crashed inside of pre-throw code.
                                 origin_string,                   // rewritten simplier [though duplicating closesocket code]
                                 "timeout occured while retrieving document");                   if(sock>=0) 
                 else {                          closesocket(sock); 
                         alarm(timeout);                   throw Exception("http.timeout", 
                           origin_string, 
                           "timeout occured while retrieving document"); 
           } else {
                   alarm(timeout); 
 #endif  #endif
           try {
                   int result;
                         struct sockaddr_in dest;                          struct sockaddr_in dest;
                                   
                 if(!set_addr(&dest, host, port))                  if(!set_addr(&dest, host, port))
                                 throw Exception("http.host",                                   throw Exception("http.host", 
                                         origin_string,                                           origin_string, 
                                         "can't resolve hostname \"%s\"", host);                                           "can not resolve hostname \"%s\"", host); 
                                                   
                         if((sock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP/*0*/))<0)                          if((sock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP/*0*/))<0)
                                 throw Exception("http.connect",                                   throw Exception("http.connect", 
                                         origin_string,                                           origin_string, 
                                         "can't make socket : %s (%d)", strerror(errno), errno);                                           "can not make socket: %s (%d)", strerror(errno), errno); 
                         if(connect(sock, (struct sockaddr *)&dest, sizeof(dest)))                          if(connect(sock, (struct sockaddr *)&dest, sizeof(dest)))
                                 throw Exception("http.connect",                                   throw Exception("http.connect", 
                                         origin_string,                                           origin_string, 
                                         "can't connect to host \"%s\": %s (%d)", host, strerror(errno), errno);                                           "can not connect to host \"%s\": %s (%d)", host, strerror(errno), errno); 
                         size_t request_size=strlen(request);                          size_t request_size=strlen(request);
                         if(send(sock, request, request_size, 0)!=(ssize_t)request_size)                          if(send(sock, request, request_size, 0)!=(ssize_t)request_size)
                                 throw Exception("http.connect",                                   throw Exception("http.connect", 
                                         origin_string,                                           origin_string, 
                                         "error sending request : %s (%d)", strerror(errno), errno);                                           "error sending request: %s (%d)", strerror(errno), errno); 
   
                         http_read_response(response, sock);                           result=http_read_response(response, sock, fail_on_status_ne_200); 
                         if(sock>=0)                           closesocket(sock); 
                                 closesocket(sock);   #ifdef PA_USE_ALARM
 #ifdef WE_CAN_USE_ALARM                          alarm(0); 
                 }  
 #endif  #endif
                   return result;
         } catch(...) {          } catch(...) {
                 if(sock>=0)                   if(sock>=0) 
                         closesocket(sock);                           closesocket(sock); 
 #ifdef WE_CAN_USE_ALARM  #ifdef PA_USE_ALARM
                 alarm(0);                   alarm(0); 
 #endif  #endif
                 /*re*/throw;                  /*re*/throw;
         }          }
 }  }
   
 static void headers_foreacher(const Hash::Key& key, Hash::Val *value, void *info)  #ifndef DOXYGEN
   struct Http_pass_header_info {
           String* request;
           bool user_agent_specified;
   };
   #endif
   static void http_pass_header(const Hash::Key& key, Hash::Val *value, void *info)
 {  {
     String * request=static_cast<String *>(info);           Http_pass_header_info& i=*static_cast<Http_pass_header_info *>(info);
     *(request)<<key<<": "<<*(static_cast<Value *>(value))->get_string()<<"\n";           Pool& pool=i.request->pool();
       
       *(i.request)<<key<<": "
                   << attributed_meaning_to_string(*static_cast<Value *>(value), String::UL_HTTP_HEADER, false)
                   <<"\n"; 
           
           if(key.change_case(pool, String::CC_UPPER)=="USER-AGENT")
                   i.user_agent_specified=true;
 }  }
   
 static void file_read_http(Pool& pool, const String& file_spec,   static void file_read_http(Pool& pool, const String& file_spec, 
                                         void*& data, size_t& data_size,                                           void*& data, size_t& data_size, 
                                         Hash *params=0, Hash** out_fields=0) {                                          Hash *options=0, Hash** out_fields=0) {
         char host[MAX_STRING];           char host[MAX_STRING]; 
         char* uri;           const char* uri; 
         int port;          int port;
         const char* method="GET";           const char* method="GET"; 
         int timeout=2;          int timeout=2;
           bool fail_on_status_ne_200=true;
           Value *vheaders=0;
   
           String& connect_string=*new(pool) String(pool); // must not be local [exception may be reported outside]
           // not in ^sql{... UL_SQL ...} spirit, but closer to ^file::load one
           connect_string.append(file_spec, String::UL_URI); // tainted pieces -> URI pieces
   
         char* connect_string=file_spec.cstr(String::UL_UNSPECIFIED);           char* connect_string_cstr=connect_string.cstr(String::UL_UNSPECIFIED); 
         if(strncmp(connect_string, "http://", 7)!=0)          if(strncmp(connect_string_cstr, "http://", 7)!=0)
                 throw Exception(0,                   throw Exception(0, 
                         &file_spec,                           &connect_string, 
                         "does not start with http://"); //never                          "does not start with http://"); //never
         connect_string+=7;          connect_string_cstr+=7;
   
         strncpy(host, connect_string, sizeof(host)-1);  host[sizeof(host)-1]=0;          strncpy(host, connect_string_cstr, sizeof(host)-1);  host[sizeof(host)-1]=0;
         char* host_uri=lsplit(host, '/');           char* host_uri=lsplit(host, '/'); 
         uri=host_uri?connect_string+(host_uri-1-host):"/";           uri=host_uri?connect_string_cstr+(host_uri-1-host):"/"; 
         char* port_cstr=lsplit(host, ':');           char* port_cstr=lsplit(host, ':'); 
         char* error_pos=0;          char* error_pos=0;
         port=port_cstr?strtol(port_cstr, &error_pos, 0):80;          port=port_cstr?strtol(port_cstr, &error_pos, 0):80;
   
         if(params) {          if(options) {
                 if(Value *method_element=static_cast<Value *>(params->get(*http_method_name)))                  int valid_options=0;
                         method=method_element->as_string().cstr();                   if(Value *vmethod=static_cast<Value *>(options->get(*http_method_name))) {
                 if(Value *timeout_element=static_cast<Value *>(params->get(*http_timeout_name)))                          valid_options++;
                         timeout=timeout_element->as_int();                           method=vmethod->as_string().cstr(); 
         }                  }
                   if(Value *vtimeout=static_cast<Value *>(options->get(*http_timeout_name))) {
                           valid_options++;
                           timeout=vtimeout->as_int(); 
                   }
                   if(vheaders=static_cast<Value *>(options->get(*http_headers_name))) {
                           valid_options++;
                   }
                   if(Value *vany_status=static_cast<Value *>(options->get(*http_any_status_name))) {
                           valid_options++;
                           fail_on_status_ne_200=!vany_status->as_bool(); 
                   }
   
                   if(valid_options!=options->size())
                           throw Exception("parser.runtime",
                                   0,
                                   "invalid option passed");
           } 
   
         //making request          //making request
         String request(pool);           String request(pool);
         request<< method <<" "<< uri <<" HTTP/1.0\nHost: "<< host<<"\n";           request<< method <<" "<< uri <<" HTTP/1.0\nHost: "<< host<<"\n"; 
         if(params)          bool user_agent_specified=false;
                 if(Value *headers_element=static_cast<Value *>(params->get(*http_headers_name)))          if(vheaders && !vheaders->is_string()) { // allow empty
                 {                  if(Hash *headers=vheaders->get_hash(&connect_string)) {
                         Hash *headers=headers_element->get_hash(&file_spec);                           Http_pass_header_info info={&request};
                         headers->for_each(headers_foreacher, &request);                           headers->for_each(http_pass_header, &info); 
                 }                          user_agent_specified=info.user_agent_specified;
                   } else
                           throw Exception("parser.runtime", 
                                   &connect_string,
                                   "headers param must be hash"); 
           };
           if(!user_agent_specified) // defaulting
                   request << "user-agent: " DEFAULT_USER_AGENT "\n";
         request<<"\n";           request<<"\n"; 
                   
         //sending request          //sending request
         String response(pool);           String response(pool); 
         http_request(response,          int status_code=http_request(response,
                 &file_spec, host, port, request.cstr(String::UL_UNSPECIFIED), timeout);                   &connect_string, host, port, request.cstr(String::UL_UNSPECIFIED), 
                   timeout, fail_on_status_ne_200); 
                   
         //processing results              //processing results    
         int pos=response.pos("\r\n\r\n", 4);           int pos=response.pos("\r\n\r\n", 4); 
         if(pos<1){          if(pos<1){
                 throw Exception("http.response",                   throw Exception("http.response", 
                         &file_spec,                          &connect_string,
                         "bad response from host - no headers found");                           "bad response from host - no headers found"); 
         }          }
         String header_block=response.mid(0, pos);           String header_block=response.mid(0, pos); 
Line 286  static void file_read_http(Pool& pool, c Line 358  static void file_read_http(Pool& pool, c
         size_t pos_after_ref=0;          size_t pos_after_ref=0;
         header_block.split(aheaders, &pos_after_ref, "\r\n", 2);           header_block.split(aheaders, &pos_after_ref, "\r\n", 2); 
                   
         //processing status code  
         const String *status_line=aheaders.get_string(0);   
         if(!status_line){  
                 throw Exception("http.response",   
                         &file_spec,  
                         "bad response from host - no status line ");   
         }  
         //processing headers          //processing headers
         Array astatus(pool);   
         pos_after_ref=0;  
         status_line->split(astatus, &pos_after_ref, " ", 1);   
         const String * status_code=astatus.get_string(1);   
           
         for(int i=1;i<aheaders.size();i++) {          for(int i=1;i<aheaders.size();i++) {
                 if(const String *line=aheaders.get_string(i)) {                  if(const String *line=aheaders.get_string(i)) {
                         pos=line->pos(": ", 2);                           pos=line->pos(": ", 2); 
                         if(pos<1)                          if(pos<1)
                                 throw Exception("http.response",                                   throw Exception("http.response", 
                                         &file_spec,                                          &connect_string,
                                         "bad response from host - bad header \"%s\"", line->cstr());                                           "bad response from host - bad header \"%s\"", line->cstr()); 
                                                                   
                         headers.put(line->mid(0, pos), new(pool) VString(line->mid(pos+2, line->size())));                           headers.put(
                                   line->mid(0, pos).change_case(pool, String::CC_UPPER), 
                                   new(pool) VString(line->mid(pos+2, line->size()))); 
                 } else                  } else
                         throw Exception("http.response",                           throw Exception("http.response", 
                                 &file_spec,                                   &connect_string, 
                                 "bad response from host - bad headers \"%s\"", header_block.cstr());                                   "bad response from host - bad headers \"%s\"", header_block.cstr()); 
         }          }
   
         // output response          // output response
         data=body.cstr(); data_size=body.size();          data=body.cstr(); data_size=body.size();
         if(out_fields) {          if(out_fields) {
                 headers.put(*file_status_name, new(pool) VString(*status_code));                   headers.put(*file_status_name, new(pool) VInt(pool, status_code)); 
                 *out_fields=&headers;                  *out_fields=&headers;
         }          }
 }  }
Line 334  static void file_read_action(Pool& pool, Line 396  static void file_read_action(Pool& pool,
                                                          void *context) {                                                           void *context) {
         File_read_action_info& info=*static_cast<File_read_action_info *>(context);           File_read_action_info& info=*static_cast<File_read_action_info *>(context); 
         if(size_t to_read_size=(size_t)finfo.st_size) {           if(size_t to_read_size=(size_t)finfo.st_size) { 
                 *info.data=pool.malloc(to_read_size+(as_text?1:0), 3);                   *info.data=pool.malloc_atomic(to_read_size+(as_text?1:0), 3); 
                 *info.data_size=(size_t)read(f, *info.data, to_read_size);                   *info.data_size=(size_t)read(f, *info.data, to_read_size); 
   
                 if(ssize_t(*info.data_size)<0 || *info.data_size>to_read_size)                  if(ssize_t(*info.data_size)<0 || *info.data_size>to_read_size)
Line 344  static void file_read_action(Pool& pool, Line 406  static void file_read_action(Pool& pool,
                                         *info.data_size, to_read_size);                                           *info.data_size, to_read_size); 
         } else { // empty file          } else { // empty file
                 if(as_text) {                  if(as_text) {
                         *info.data=pool.malloc(1);                           *info.data=pool.malloc_atomic(1); 
                         *(char*)(*info.data)=0;                          *(char*)(*info.data)=0;
                 } else                   } else 
                         *info.data=0;                          *info.data=0;
Line 369  bool file_read(Pool& pool, const String& Line 431  bool file_read(Pool& pool, const String&
         }          }
   
         if(result && as_text) {          if(result && as_text) {
                   // UTF-8 signature: EF BB BF
                   if(data_size>=3) {
                           char *in=(char *)data;
                           if((in[0] == '\xEF') && (in[1] == '\xBB') &&
                                   (in[2] == '\xBF')) {
                                   data=in+3; data_size-=3;// skip prefix
                           }
                   }
   
                 fix_line_breaks((char *)(data), data_size);                   fix_line_breaks((char *)(data), data_size); 
                 // note: after fixing                  // note: after fixing
                 ((char*&)(data))[data_size]=0;                  ((char*&)(data))[data_size]=0;
Line 408  bool file_read_action_under_lock(Pool& p Line 479  bool file_read_action_under_lock(Pool& p
                                         "stat failed: %s (%d), actual filename '%s'",                                           "stat failed: %s (%d), actual filename '%s'", 
                                                 strerror(errno), errno, fname);                                                   strerror(errno), errno, fname); 
   
 #ifdef NO_FOREIGN_GROUP_FILES  #ifdef PA_SAFE_MODE
                         if(finfo.st_gid/*foreign?*/!=getegid()) {                          if(finfo.st_uid/*foreign?*/!=geteuid()
                                   && finfo.st_gid/*foreign?*/!=getegid())
                                 throw Exception("parser.runtime",                                   throw Exception("parser.runtime", 
                                         &file_spec,                                           &file_spec, 
                                         "parser reading files of foreign group disabled [recompile parser without --disable-foreign-group-files configure option], actual filename '%s'",                                           "parser is in safe mode: reading files of foreign group and user disabled [recompile parser with --disable-safe-mode configure option], actual filename '%s'", 
                                                 fname);                                                   fname); 
 #endif  #endif
   
Line 460  bool file_write_action_under_lock( Line 532  bool file_write_action_under_lock(
         if((f=open(fname,           if((f=open(fname, 
                 O_CREAT|O_RDWR                  O_CREAT|O_RDWR
                 |(as_text?_O_TEXT:_O_BINARY)                  |(as_text?_O_TEXT:_O_BINARY)
                 |(do_append?O_APPEND:0), 0664))>=0) {                  |(do_append?O_APPEND:PA_O_TRUNC), 0664))>=0) {
                 if((do_block?lock_exclusive_blocking(f):lock_exclusive_nonblocking(f))!=0) {                  if((do_block?lock_exclusive_blocking(f):lock_exclusive_nonblocking(f))!=0) {
                         Exception e("file.lock",                           Exception e("file.lock", 
                                 &file_spec,                                   &file_spec, 
Line 475  bool file_write_action_under_lock( Line 547  bool file_write_action_under_lock(
                 try {                  try {
                         action(f, context);                           action(f, context); 
                 } catch(...) {                  } catch(...) {
   #ifdef HAVE_FTRUNCATE
                         if(!do_append)                          if(!do_append)
                                 ftruncate(f, lseek(f, 0, SEEK_CUR)); // one can not use O_TRUNC, read lower                                  ftruncate(f, lseek(f, 0, SEEK_CUR)); // one can not use O_TRUNC, read lower
   #endif
                         unlock(f);close(f);                           unlock(f);close(f); 
                         /*re*/throw;                          /*re*/throw;
                 }                  }
                                   
   #ifdef HAVE_FTRUNCATE
                 if(!do_append)                  if(!do_append)
                         ftruncate(f, lseek(f, 0, SEEK_CUR)); // O_TRUNC truncates even exclusevely write-locked file [thanks to Igor Milyakov <virtan@rotabanner.com> for discovering]                          ftruncate(f, lseek(f, 0, SEEK_CUR)); // O_TRUNC truncates even exclusevely write-locked file [thanks to Igor Milyakov <virtan@rotabanner.com> for discovering]
   #endif
                 unlock(f);close(f);                   unlock(f);close(f); 
                 return true;                  return true;
         } else          } else
Line 688  char* format(Pool& pool, double value, c Line 764  char* format(Pool& pool, double value, c
         else          else
                 size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);                   size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value); 
                   
         char* pool_buf=(char *)pool.malloc(size+1, 4);           char* pool_buf=(char *)pool.malloc_atomic(size+1, 4); 
         memcpy(pool_buf, local_buf, size+1);           memcpy(pool_buf, local_buf, size+1); 
         return pool_buf;          return pool_buf;
 }  }
Line 710  size_t stdout_write(const void *buf, siz Line 786  size_t stdout_write(const void *buf, siz
 }  }
   
 char* unescape_chars(Pool& pool, const char* cp, int len) {  char* unescape_chars(Pool& pool, const char* cp, int len) {
         char* s=(char *)pool.malloc(len + 1, 5);           char* s=(char *)pool.malloc_atomic(len + 1, 5); 
         enum EscapeState {          enum EscapeState {
                 EscapeRest,                   EscapeRest, 
                 EscapeFirst,                   EscapeFirst, 
Line 879  int pa_sleep(unsigned long secs, unsigne Line 955  int pa_sleep(unsigned long secs, unsigne
         return (select(0, NULL, NULL, NULL, &t) == -1 ? errno : 0);           return (select(0, NULL, NULL, NULL, &t) == -1 ? errno : 0); 
 #endif  #endif
 }  }
   
   
   // attributed meaning
   
   static size_t date_attribute(const VDate& vdate, char *buf, size_t buf_size) {
       const char month_names[12][4]={
                   "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
       const char days[7][4]={
                   "Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
   
           time_t when=vdate.get_time();
           struct tm *tms=gmtime(&when);
           if(!tms)
                   throw Exception(0,
                           0,
                           "bad time in attribute value (seconds from epoch=%ld)", when);
           return snprintf(buf, MAX_STRING, "%s, %.2d-%s-%.4d %.2d:%.2d:%.2d GMT", 
                   days[tms->tm_wday],
                   tms->tm_mday,month_names[tms->tm_mon],tms->tm_year+1900,
                   tms->tm_hour,tms->tm_min,tms->tm_sec);
   }
   static void append_attribute_meaning(String& result,
                                                                            Value& value, String::Untaint_lang lang, bool forced) {
           if(const String *string=value.get_string())
                   result.append(string->join_chains(result.pool(), 0), lang, forced);
           else
                   if(Value *vdate=value.as(VDATE_TYPE, false)) {
                           char *buf=(char *)result.malloc_atomic(MAX_STRING);
                           size_t size=date_attribute(*static_cast<VDate *>(vdate), 
                                   buf, MAX_STRING);
   
                           result.APPEND_CLEAN(buf, size, "converted from date", 0);
                   } else
                           throw Exception("parser.runtime",
                                   &result,
                                   "trying to append here neither string nor date (%s)",
                                           value.type());
   }
   #ifndef DOXYGEN
   struct Attributed_meaning_info {
           String *header; // header line being constructed
           String::Untaint_lang lang; // language in which to append to that line
           bool forced; // do they force that lang?
   };
   #endif
   static void append_attribute_subattribute(const Hash::Key& akey, Hash::Val *avalue, 
                                                                                     void *info) {
           if(akey==VALUE_NAME)
                   return;
   
           Attributed_meaning_info& ami=*static_cast<Attributed_meaning_info *>(info);
   
           // ...; charset=windows1251
           *ami.header << "; ";
           ami.header->append(akey, ami.lang, ami.forced);
           *ami.header << "=";
           append_attribute_meaning(*ami.header, *static_cast<Value *>(avalue), ami.lang, ami.forced);
   }
   const String& attributed_meaning_to_string(Value& meaning, 
                                                                                      String::Untaint_lang lang, bool forced) {
           String &result=*new(meaning.pool()) String(meaning.pool());
           if(Hash *hash=meaning.get_hash(0)) {
                   // $value(value) $subattribute(subattribute value)
                   if(Value *value=static_cast<Value *>(hash->get(*value_name)))
                           append_attribute_meaning(result, *value, lang, forced);
   
                   Attributed_meaning_info attributed_meaning_info={&result, lang};
                   hash->for_each(append_attribute_subattribute, &attributed_meaning_info);
           } else // result value
                   append_attribute_meaning(result, meaning, lang, forced);
   
           return result;
   }
Removed from v.1.126  
changed lines
  Added in v.1.145.2.2

E-mail: