[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.20 and 1.89.2.13.2.4

version 1.20, 2001/03/21 14:06:43 version 1.89.2.13.2.4, 2003/03/20 14:19:08
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  
   
 #include <stdio.h>  
 #include <stdarg.h>  
 #include "pa_pool.h"  
   
 class String;  #include "pa_string.h"
 class Value;  #include "pa_hash.h"
   
 #ifdef WIN32  //#include "pa_value.h"
   //typedef Hash<String* , ValuePtr> HashStringValue;
   
 #ifndef open  class HashStringValue;
 #       define open _open  
 #endif  // replace system s*nprintf with our versions
 #ifndef close  #undef vsnprintf 
 #       define close _close  int __vsnprintf(char *, size_t, const char* , va_list);
 #endif  #define vsnprintf __vsnprintf 
 #ifndef read  #undef snprintf
 #       define read _read  int __snprintf(char *, size_t, const char* , ...);
 #endif  #define snprintf __snprintf
 #ifndef stat  
 #       define stat _stat  #if _MSC_VER
 #endif  /*
   inline int open( const char* filename, int oflag ) { return _open(filename, oflag); }
 #ifndef vsnprintf  inline int close( int handle ) { return _close(handle); }
 #       define vsnprintf __vsnprintf   inline int read( int handle, void *buffer, unsigned int count ) { return _read(handle,buffer,count); }
 int __vsnprintf(char *, size_t, const char *, va_list);  inline int write( int handle, const void *buffer, unsigned int count ) { return _write(handle,buffer,count); }
 #endif  inline int stat( const char* path, struct _stat *buffer ) { return _stat(path, buffer); }
 #ifndef snprintf  inline long lseek( int handle, long offset, int origin ) { return _lseek(handle, offset, origin); }
 #       define snprintf __snprintf  */
 int __snprintf(char *, size_t, const char *, ...);  
 #endif  
   
 //access  //access
 #define F_OK 0  #define F_OK 0
Line 68  int __snprintf(char *, size_t, const cha Line 59  int __snprintf(char *, size_t, const cha
   
 #endif  #endif
   
   #ifdef HAVE_TRUNC
   #       ifndef trunc
   extern "C" double trunc(double);
   #       endif
   #else
   inline double trunc(double param) { return param > 0? floor(param) : ceil(param); }
   #endif
   
   #ifdef HAVE_ROUND
   #       ifndef round
   extern "C" double round(double);
   #       endif
   #else
   inline double round(double param) { return floor(param+0.5); }
   #endif
   #ifdef HAVE_SIGN
   #       ifndef sign
   extern "C" double sign(double);
   #       endif
   #else
   inline double sign(double param) { return param > 0 ? 1 : ( param < 0 ? -1 : 0 ); }
   #endif
   
   /// yields to OS for secs secs and usecs milliseconds
   int pa_sleep(unsigned long secs, unsigned long usecs);
   
   /** under WIN32 "t" mode fixes DOS chars OK, 
           can't say that about other systems/ line break styles
   */
   void fix_line_breaks(
                        char *buf,
                        size_t& size ///< 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);
   
   /**
           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!
   
           @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 text file using pool,           read specified file using 
         if fail_on_read_problem is true[default] throws an exception          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(Pool& pool,   File_read_result file_read(Charset& charset, 
                                          const char *fname,                              const String& file_spec, 
                                          bool fail_on_read_problem=true);                             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 as_text/*,                                  bool as_text=false,
                                 bool exclusive=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(
                                   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(String& path, 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,           scans for @a delim[default \n] in @a *row_ref, 
Line 93  void file_write(Pool& pool, Line 203  void file_write(Pool& pool,
         or to zero if no @a delim were found.          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);
   
 const char *unescape_chars(Pool& pool, const char *cp, int len);  // globals
   
 const String& attributed_meaning_to_string(Value& meaning);  extern const String file_status_name;
   
 #endif  #endif
Removed from v.1.20  
changed lines
  Added in v.1.89.2.13.2.4

E-mail: