[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.17 and 1.89.2.13.2.10

version 1.17, 2001/03/19 20:07:36 version 1.89.2.13.2.10, 2003/04/07 15:32:57
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly used functions.          Parser: commonly used functions.
   
         Copyright (c) 2001 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: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)  
   
         $Id$  
 */  */
   
 #ifndef PA_COMMON_H  #ifndef PA_COMMON_H
 #define PA_COMMON_H  #define PA_COMMON_H
   
 #ifdef HAVE_CONFIG_H  static const char* IDENT_COMMON_H="$Date$";
 #       include "pa_config.h"  
 #endif  
   
 #ifdef WIN32  
 #       include <sys/locking.h>  
 #endif  
   
 #include <stdio.h>  #include "pa_string.h"
 #include <stdarg.h>  #include "pa_hash.h"
 #include "pa_pool.h"  
   
 class String;  
 class Value;  class Value;
   typedef Hash<const StringBody , Value*> HashStringValue;
   
 #ifdef WIN32  // replace system s*nprintf with our versions
   #undef vsnprintf 
 #define open _open  int __vsnprintf(char *, size_t, const char* , va_list);
 #define close _close  
 #define read _read  
 #define stat _stat  
   
 #define vsnprintf __vsnprintf   #define vsnprintf __vsnprintf 
   #undef snprintf
   int __snprintf(char *, size_t, const char* , ...);
 #define snprintf __snprintf  #define snprintf __snprintf
   
 int __vsnprintf(char *, size_t, const char *, va_list);  #if _MSC_VER
 int __snprintf(char *, size_t, const char *, ...);  /*
   inline int open( const char* filename, int oflag ) { return _open(filename, oflag); }
 //flock  inline int close( int handle ) { return _close(handle); }
 #define LOCK_EX _LK_NBLCK  inline int read( int handle, void *buffer, unsigned int count ) { return _read(handle,buffer,count); }
 #define LOCK_UN _LK_UNLCK  inline int write( int handle, const void *buffer, unsigned int count ) { return _write(handle,buffer,count); }
 void flock(int fd, int operation);  inline int stat( const char* path, struct _stat *buffer ) { return _stat(path, buffer); }
   inline long lseek( int handle, long offset, int origin ) { return _lseek(handle, offset, origin); }
   */
   
 //access  //access
 #define F_OK 0  #define F_OK 0
Line 50  void flock(int fd, int operation); Line 41  void flock(int fd, int operation);
 #define W_OK 2  #define W_OK 2
 #define R_OK 4  #define R_OK 4
   
 #define strcasecmp _stricmp  #ifndef strcasecmp
 #define strncasecmp _strnicmp  #       define strcasecmp _stricmp
 #define mkdir(path, mode) _mkdir(path)  #endif
   #ifndef strncasecmp
 #define putenv _putenv  #       define strncasecmp _strnicmp
   #endif
   #ifndef mkdir
   #       define mkdir(path, mode) _mkdir(path)
   #endif
   
   #ifndef putenv
   #       define putenv _putenv
 #endif  #endif
   
 /// @todo define it  
 #ifdef SUN  
 //flock  
 #define LOCK_EX F_LOCK  
 #define LOCK_UN F_ULOCK  
 void flock(int fd, int operation);  
 #endif  #endif
   
 /// @todo use somewhere  /// yields to OS for secs secs and usecs milliseconds
 void lock(FILE *f, long position);  int pa_sleep(unsigned long secs, unsigned long usecs);
 /// @todo use somewhere  
 void unlock(FILE *f);  /** under WIN32 "t" mode fixes DOS chars OK, 
           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
                        );
   
   typedef void (*File_read_action)(
                                    struct stat& finfo,
                                    int f, 
                                    const String& file_spec, const char* fname, bool as_text,
                                    void *context);
   
 /**  /**
         read specified file using pool,           shared-lock specified file, 
           do actions under lock.
         if fail_on_read_problem is true[default] throws an exception          if fail_on_read_problem is true[default] throws an exception
           
           @returns true if read OK
 */  */
 char *file_read(Pool& pool,   bool file_read_action_under_lock(const String& file_spec, 
                                 const char *fname,                                   const char* action_name, File_read_action action, void *context,
                                   bool as_text=false,
                                 bool fail_on_read_problem=true);                                  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!
   
           @returns true if read OK
   */
   char *file_read_text(Charset& charset, 
                                            const String& file_spec, 
                                            bool fail_on_read_problem=true,
                                            HashStringValue* options=0/*, HashStringValue* * out_fields=0*/);
   
   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!
   
           @returns true if read OK
   */
   File_read_result file_read(Charset& charset, 
                              const String& file_spec, 
                              bool as_text,
                              HashStringValue* options=0,
                              bool fail_on_read_problem=true);
   
   typedef void (*File_write_action)(int f, void *context);
   
 /**  /**
         write data to specified file using pool,           lock specified file exclusively, 
           do actions under lock.
         throws an exception in case of problems          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
 */  */
 void file_write(Pool& pool,   bool file_write_action_under_lock(
                                 const char *fname,                                  const String& file_spec, 
                                 const char *data, size_t size,                                   const char* action_name, File_write_action action, void *context,
                                 bool exclusive=false);                                  bool as_text=false,
                                   bool do_append=false,
                                   bool do_block=true,
                                   bool fail_on_lock_problem=true);
   
 /**  /**
         scans for \a delim[default \n] in \a *row_ref,           write data to specified file, 
         @return piece of line before it or end of string, if no \a delim found          throws an exception in case of problems
         assigns \a *row_ref to point right after delimiter if there were one  */
         or to zero if no \a delim were found.  void file_write(
                                   const String& file_spec,
                                   const char* data, size_t size, 
                                   bool as_text,
                                   bool do_append=false);
   
   /**
           delete specified file 
           throws an exception in case of problems
   */
   bool file_delete(const String& file_spec, bool fail_on_read_problem=true);
   /**
           move specified file 
           throws an exception in case of problems
   */
   void file_move(const String& old_spec, const String& new_spec);
   
   bool entry_exists(const char* fname, struct stat *afinfo=0);
   bool entry_exists(const String& file_spec);
   bool file_readable(const String& file_spec);
   bool dir_readable(const String& file_spec);
   const String* file_readable(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);
   
   /**
           scans for @a delim[default \n] in @a *row_ref, 
           @return piece of line before it or end of string, if no @a delim found
           assigns @a *row_ref to point right after delimiter if there were one
           or to zero if no @a delim were found.
 */  */
 char *getrow(char **row_ref,char delim='\n');  char *getrow(char **row_ref,char delim='\n');
 //char *lsplit(char *,char);  char *lsplit(char *string, char delim);
 char *lsplit(char **string_ref,char delim);  char *lsplit(char **string_ref,char delim);
 char *rsplit(char *string, char delim);  char *rsplit(char *string, char delim);
 char *format(Pool& pool, double value, char *fmt);  const char* format(double value, char *fmt);
   
 #ifndef max  #ifndef max
 inline int max(int a,int b) { return a>b?a:b; }  inline int max(int a, int b) { return a>b?a:b; }
 inline int min(int a,int b){ return a<b?a:b; }  inline int min(int a, int b){ return a<b?a:b; }
   inline size_t max(size_t a, size_t b) { return a>b?a:b; }
   inline size_t min(size_t a, size_t b){ return a<b?a:b; }
   #endif
   
   size_t stdout_write(const void *buf, size_t size);
   
   char *unescape_chars(const char* cp, int len);
   
   #ifdef WIN32
   void back_slashes_to_slashes(char *s);
   //void slashes_to_back_slashes(char *s);
   #endif
   
   #ifndef _qsort
   #       define _qsort(names,cnt,sizeof_names,func_addr) \
                   qsort(names,cnt,sizeof_names,func_addr)
 #endif  #endif
   
 size_t stdout_write(const char *buf, size_t size);  bool StrEqNc(const char* s1, const char* s2, bool strict=true);
   
   #define SECS_PER_DAY (60*60*24)
   int getMonthDays(int year, int month);
   
   void remove_crlf(char *start, char *end);
   
   #ifdef PA_SAFE_MODE 
   void check_safe_mode(stat finfo, const String& file_spec, const char* fname); 
   #endif 
   
 const char *unescape_chars(Pool& pool, const char *cp, int len);  // globals
   
 const String& attributed_meaning_string(Value *meaning);  extern const String file_status_name;
   
 #endif  #endif
Removed from v.1.17  
changed lines
  Added in v.1.89.2.13.2.10

E-mail: