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

Diff for /parser3/src/include/pa_common.h between versions 1.166 and 1.201

version 1.166, 2016/07/29 13:30:41 version 1.201, 2026/09/30 16:44:19
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly used functions.          Parser: commonly used functions.
   
         Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)          Copyright (c) 2001-2026 Art. Lebedev Studio (https://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
 */  */
   
 #ifndef PA_COMMON_H  #ifndef PA_COMMON_H
Line 20  class Request; Line 20  class Request;
 #define HTTP_STATUS_CAPITALIZED "Status"  #define HTTP_STATUS_CAPITALIZED "Status"
   
 #define HTTP_CONTENT_LENGTH             "content-length"  #define HTTP_CONTENT_LENGTH             "content-length"
 #define HTTP_CONTENT_LENGTH_CAPITALIZED "Content-Length"  
   
 #define HTTP_CONTENT_TYPE               "content-type"  #define HTTP_CONTENT_TYPE               "content-type"
 #define HTTP_CONTENT_TYPE_UPPER         "CONTENT-TYPE"  #define HTTP_CONTENT_TYPE_UPPER         "CONTENT-TYPE"
Line 39  class Request; Line 38  class Request;
 #define HTTP_CONTENT_TYPE_MULTIPART_RELATED     "multipart/related"  #define HTTP_CONTENT_TYPE_MULTIPART_RELATED     "multipart/related"
 #define HTTP_CONTENT_TYPE_MULTIPART_MIXED       "multipart/mixed"  #define HTTP_CONTENT_TYPE_MULTIPART_MIXED       "multipart/mixed"
   
 #define BASE64_STRICT_OPTION_NAME "strict"  extern const String content_disposition_filename_name;
   
 const String content_disposition_filename_name(CONTENT_DISPOSITION_FILENAME_NAME);  
   
 #define HASH_ORDER  #define HASH_ORDER
   
Line 54  class Value; Line 51  class Value;
 typedef HASH_STRING<Value*> HashStringValue;  typedef HASH_STRING<Value*> HashStringValue;
   
 // replace system s*nprintf with our versions  // replace system s*nprintf with our versions
 #undef vsnprintf   #undef vsnprintf
 int __vsnprintf(char *, size_t, const char* , va_list);  int pa_vsnprintf(char *, size_t, const char* , va_list);
 #define vsnprintf __vsnprintf   #define vsnprintf pa_vsnprintf 
 #undef snprintf  #undef snprintf
 int __snprintf(char *, size_t, const char* , ...);  int pa_snprintf(char *, size_t, const char* , ...);
 #define snprintf __snprintf  #define snprintf pa_snprintf
   
 #ifdef _MSC_VER  #ifdef _MSC_VER
   
 //access  
 #define F_OK 0  
 #define X_OK 1  
 #define W_OK 2  
 #define R_OK 4  
   
 #ifndef strcasecmp  #ifndef strcasecmp
 #       define strcasecmp _stricmp  #       define strcasecmp _stricmp
 #endif  #endif
Line 79  int __snprintf(char *, size_t, const cha Line 70  int __snprintf(char *, size_t, const cha
   
 #endif  #endif
   
 /**   
         file related functions  
 */  
   
 #define FILE_BUFFER_SIZE        4096  
   
 int pa_lock_shared_blocking(int fd);  
 int pa_lock_exclusive_blocking(int fd);  
 int pa_lock_exclusive_nonblocking(int fd);  
 int pa_unlock(int fd);  
   
 void create_dir_for_file(const String& file_spec);  
   
 int pa_get_valid_file_options_count(HashStringValue& options);  
   
 typedef void (*File_read_action)(struct stat& finfo, int f, const String& file_spec, void *context);  
   
 /**  
         shared-lock specified file,   
         do actions under lock.  
         if fail_on_read_problem is true[default] throws an exception  
           
         @returns true if read OK  
 */  
 bool file_read_action_under_lock(const String& file_spec,   
                                 const char* action_name, File_read_action action, void *context,  
                                 bool as_text=false,  
                                 bool fail_on_read_problem=true);  
   
 /**  
         read specified text file using   
         if fail_on_read_problem is true[default] throws an exception  
   
         WARNING: charset is used for http header case conversion, it's not a charset of input file!  
 */  
 char *file_read_text(Request_charsets& charsets,   
                                         const String& file_spec,   
                                         bool fail_on_read_problem=true,  
                                         HashStringValue* options=0,  
                                         bool transcode_result=true);  
   
 char *file_load_text(Request& r,   
                                         const String& file_spec,   
                                         bool fail_on_read_problem=true,  
                                         HashStringValue* options=0,  
                                         bool transcode_result=true);  
   
 struct File_read_result {  
         bool success;  
         char* str; size_t length;  
         HashStringValue* headers;  
 };  
   
 /**  
         read specified file using   
         if fail_on_read_problem is true[default] throws an exception  
   
         WARNING: charset is used for http header case conversion, it's not a charset of input file!  
 */  
 File_read_result file_read(Request_charsets& charsets,  
                                 const String& file_spec,  
                                 bool as_text,  
                                 HashStringValue* options=0,  
                                 bool fail_on_read_problem=true,  
                                 char* buf=0, size_t offset=0, size_t size=0, bool transcode_text_result=true);  
   
 File_read_result file_load(Request& r,  
                                 const String& file_spec,  
                                 bool as_text,  
                                 HashStringValue* options=0,  
                                 bool fail_on_read_problem=true,  
                                 char* buf=0, size_t offset=0, size_t size=0, bool transcode_text_result=true);  
   
 typedef void (*File_write_action)(int f, void *context);  
   
 /**  
         lock specified file exclusively,   
         do actions under lock.  
         throws an exception in case of problems  
           
         if block=false does non-blocking lock  
         @returns true if locked OK, or false if non-blocking locking failed  
 */  
 bool file_write_action_under_lock(  
                                 const String& file_spec,   
                                 const char* action_name,  
                                 File_write_action action,  
                                 void *context,  
                                 bool as_text=false,  
                                 bool do_append=false,  
                                 bool do_block=true,  
                                 bool fail_on_lock_problem=true);  
   
 /**  
         write data to specified file,   
         throws an exception in case of problems  
 */  
 void file_write(  
                                 Request_charsets& charsets,  
                                 const String& file_spec,  
                                 const char* data,  
                                 size_t size,   
                                 bool as_text,  
                                 bool do_append=false,  
                                 Charset* asked_charset=0);  
   
 /**  
         delete specified file   
         throws an exception in case of problems  
 */  
 bool file_delete(const String& file_spec, bool fail_on_problem=true, bool keep_empty_dirs=false);  
 /**  /**
         move specified file   
         throws an exception in case of problems  
 */  
 void file_move(const String& old_spec, const String& new_spec, bool keep_empty_dirs=false);  
   
 bool entry_exists(const char* fname, struct stat *afinfo=0);  
 bool entry_exists(const String& file_spec);  
 bool file_exist(const String& file_spec);  
 bool dir_exists(const String& file_spec);  
 const String* file_exist(const String& path, const String& name);  
 bool file_executable(const String& file_spec);  
   
 bool file_stat(const String& file_spec, size_t& rsize, time_t& ratime, time_t& rmtime, time_t& rctime, bool fail_on_read_problem=true);  
   
 size_t stdout_write(const void *buf, size_t size);  
   
 void check_safe_mode(struct stat finfo, const String& file_spec, const char* fname);   
   
 int file_block_read(const int f, unsigned char* buffer, const size_t size);  
   
 /**   
         String related functions          String related functions
 */  */
   
 /** under WIN32 "t" mode fixes DOS chars OK,   // Under WIN32 "t" mode fixes DOS chars OK, can't say that about other systems/ line break styles
         can't say that about other systems/ line break styles  
 */  
 void fix_line_breaks(char *str, size_t& length /* < may change! used to speedup next actions */);  void fix_line_breaks(char *str, size_t& length /* < may change! used to speedup next actions */);
   
 char *getrow(char **row_ref,char delim='\n');  char *getrow(char **row_ref,char delim='\n');
   
   // Return the last occurrence of any character in chars or NULL if absent
   const char *strrpbrk(const char *string, const char *chars);
   inline char *strrpbrk(char *string, const char *chars) {
           return (char*)strrpbrk((const char*)string, chars);
   }
   
   // Split at the first occurrence of delimiter; return the suffix or NULL if absent
 char *lsplit(char *string, char delim);  char *lsplit(char *string, char delim);
 char *lsplit(char **string_ref,char delim);  // Return the prefix; advance *string_ref to the suffix or set it to NULL if delimiter is absent
 char *rsplit(char *string, char delim);  char *lsplit(char **string_ref, char delim);
   
 const char* format(double value, const char *fmt);  // Split at the last occurrence of delimiter(s); return the suffix or NULL if absent
   char *rsplit(char *string, char delim);
   char *rsplit(char *string, const char *delims);
   
 char* unescape_chars(const char* cp, int len, Charset* client_charset=0, bool js=false/*true==decode \uXXXX and don't convert '+' to space*/);  char* unescape_chars(const char* cp, int len, Charset* client_charset=0, bool js=false/*true==decode \uXXXX and don't convert '+' to space*/);
   
Line 235  inline int pa_strncasecmp(const char* st Line 102  inline int pa_strncasecmp(const char* st
         return strncasecmp(str, substr, count ? count : strlen(substr));          return strncasecmp(str, substr, count ? count : strlen(substr));
 }  }
   
 #ifdef WIN32  // copy of the path with '/' only
 void back_slashes_to_slashes(char *s);  char* backslashes_to_slashes(const char* path);
 #endif  // same, keeping the string languages
   const String& backslashes_to_slashes(const String& path);
   
 size_t strpos(const char *str, const char *substr);  size_t strpos(const char *str, const char *substr);
   
 int remove_crlf(char *start, char *end);  size_t remove_crlf(char *start, char *end);
   
 inline bool pa_isalpha(unsigned char c) { return (((c>='A') && (c<='Z')) || ((c>='a') && (c<='z'))); }  inline bool pa_isalpha(unsigned char c) { return (((c>='A') && (c<='Z')) || ((c>='a') && (c<='z'))); }
 inline bool pa_isalnum(unsigned char c) { return (((c>='0') && (c<='9')) || pa_isalpha(c)); }  inline bool pa_isalnum(unsigned char c) { return (((c>='0') && (c<='9')) || pa_isalpha(c)); }
   
   void pa_strncpy(char *dst, const char *src, size_t dst_size);
   char *pa_strcat(const char *a, const char *b, const char *c = 0);
   
 const char* capitalize(const char* s);  const char* capitalize(const char* s);
 char *str_lower(const char *s, size_t helper_length=0);  char *str_lower(const char *s, size_t length);
 char *str_upper(const char *s, size_t helper_length=0);  char *str_upper(const char *s, size_t length);
   inline char *str_lower(const char *s) { return str_lower(s, strlen(s)); }
   inline char *str_upper(const char *s) { return str_upper(s, strlen(s)); }
   
 const char* hex_string(unsigned char* bytes, size_t size, bool upcase);  const char* hex_string(unsigned char* bytes, size_t size, bool upcase);
 extern const char* hex_digits;  extern const char* hex_digits;
   
 void pa_base64_decode(const char *in, size_t in_size, char*& result, size_t& result_size, bool strict=false);  
 char* pa_base64_encode(const char *in, size_t in_size);  
 char* pa_base64_encode(const String& file_spec);  
   
 const char *pa_idna_encode(const char *in, Charset &source);  const char *pa_idna_encode(const char *in, Charset &source);
 const char *pa_idna_decode(const char *in, Charset &source);  const char *pa_idna_decode(const char *in, Charset &source);
   
 const unsigned long pa_crc32(const char *in, size_t in_size);  unsigned long pa_crc32(const char *in, size_t in_size);
 const unsigned long pa_crc32(const String& file_spec);  unsigned long pa_crc32(const String& file_spec);
   
 /**   /**
         Mix functions          Mix functions
 */  */
   
 #define PA_DEFAULT(A,B) ((A) ? (A):(B) )  #define PA_DEFAULT(A,B) ((A) ? (A):(B) )
   
 // some stuff for use with .for_each  
 static void copy_all_overwrite_to(HashStringValue::key_type key, HashStringValue::value_type value, HashStringValue* dest) {  
         dest->put(key, value);  
 }  
   
 static void remove_key_from(HashStringValue::key_type key, HashStringValue::value_type /*value*/, HashStringValue* dest) {  
         dest->remove(key);  
 }  
   
 Charset* detect_charset(const char* content_type);  Charset* detect_charset(const char* content_type);
   
 // globals  // globals
Line 286  extern const String file_status_name; Line 146  extern const String file_status_name;
   
 // global defines for file options which are handled but not checked elsewhere, we check them  // global defines for file options which are handled but not checked elsewhere, we check them
   
 #define PA_SQL_LIMIT_NAME "limit"  
 #define PA_SQL_OFFSET_NAME "offset"  
 #define PA_COLUMN_SEPARATOR_NAME "separator"  #define PA_COLUMN_SEPARATOR_NAME "separator"
 #define PA_COLUMN_ENCLOSER_NAME "encloser"  #define PA_COLUMN_ENCLOSER_NAME "encloser"
 #define PA_CHARSET_NAME "charset"  #define PA_CHARSET_NAME "charset"
Line 296  extern const String file_status_name; Line 154  extern const String file_status_name;
 // globals defines for sql options  // globals defines for sql options
   
 #define SQL_BIND_NAME "bind"  #define SQL_BIND_NAME "bind"
   #define PA_SQL_LIMIT_NAME "limit"
   #define PA_SQL_OFFSET_NAME "offset"
 #define SQL_DEFAULT_NAME "default"  #define SQL_DEFAULT_NAME "default"
 #define SQL_DISTINCT_NAME "distinct"  #define SQL_DISTINCT_NAME "distinct"
 #define SQL_VALUE_TYPE_NAME "type"  #define SQL_VALUE_TYPE_NAME "type"
   
   extern String sql_bind_name;
   extern String sql_limit_name;
   extern String sql_offset_name;
   extern String sql_default_name;
   extern String sql_distinct_name;
   extern String sql_value_type_name;
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 enum Table2hash_distint { D_ILLEGAL, D_FIRST };  enum Table2hash_distint { D_ILLEGAL, D_FIRST };
 enum Table2hash_value_type { C_HASH, C_STRING, C_TABLE, C_CODE };  enum Table2hash_value_type { C_HASH, C_STRING, C_TABLE, C_CODE };
 #endif  #endif
   
 #endif  #endif
   
Removed from v.1.166  
changed lines
  Added in v.1.201

E-mail: