[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.56 and 1.83

version 1.56, 2001/06/28 07:44:17 version 1.83, 2001/10/31 16:19:58
Line 2 Line 2
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)          Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)
   
         Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)          Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)
   
           $Id$
 */  */
 static const char *RCSId="$Id$";   
   
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_types.h"  #include "pa_types.h"
Line 16  static const char *RCSId="$Id$"; Line 16  static const char *RCSId="$Id$";
 #include "pa_hash.h"  #include "pa_hash.h"
 #include "pa_string.h"  #include "pa_string.h"
   
 #ifndef WIN32  #ifndef _O_TEXT
 #       ifndef _O_TEXT  #       define _O_TEXT 0
 #               define _O_TEXT 0  #endif
 #       endif  #ifndef _O_BINARY
 #       ifndef _O_BINARY  #       define _O_BINARY 0
 #               define _O_BINARY 0  #endif
 #       endif  #ifndef O_TRUNC
   #       define O_TRUNC 0
 #endif  #endif
   
 #if _MSC_VER  #if _MSC_VER
Line 42  int __snprintf(char *b, size_t s, const Line 43  int __snprintf(char *b, size_t s, const
   
 #endif  #endif
   
   void fix_line_breaks(char *cstr, size_t& size) {
           char *dest=cstr;
           // fix DOS: \r\n -> \n
           // fix Macintosh: \r -> \n
           char *bol=cstr;
           while(char *eol=strchr(bol, '\r')) {
                   size_t len=eol-bol;
                   if(dest!=bol)
                           memcpy(dest, bol, len);
                   dest+=len;
                   *dest++='\n';
   
                   if(eol[1]=='\n') { // \r,\n = DOS
                           bol=eol+2;
                           size--;
                   } else // \r,not \n = Macintosh
                           bol=eol+1;
           }
           // last piece without \r, including terminating 0
           if(dest!=bol)
                   strcpy(dest, bol);
   }
   
 char *file_read_text(Pool& pool, const String& file_spec, bool fail_on_read_problem) {  char *file_read_text(Pool& pool, const String& file_spec, bool fail_on_read_problem) {
         void *result;          void *result;  size_t size;
         size_t size;          return file_read(pool, file_spec, result, size, true, fail_on_read_problem)?(char *)result:0;
         return file_read(pool, file_spec, result, size, true,   
                 fail_on_read_problem)?(char *)result:0;  
 }  }
 bool file_read(Pool& pool, const String& file_spec,   bool file_read(Pool& pool, const String& file_spec, 
                            void*& data, size_t& read_size, bool as_text,                             void*& data, size_t& read_size, bool as_text,
                            bool fail_on_read_problem,                             bool fail_on_read_problem,
                            size_t offset, size_t limit) {                             size_t offset, size_t limit) {
         const char *fname=file_spec.cstr(String::UL_FILE_NAME);          const char *fname=file_spec.cstr(String::UL_FILE_SPEC);
   //printf("file_read(%s)\n", fname);
         int f;          int f;
     struct stat finfo;      struct stat finfo;
   
Line 66  bool file_read(Pool& pool, const String& Line 88  bool file_read(Pool& pool, const String&
         //   they delay update till open, so we would receive "!^test[" string          //   they delay update till open, so we would receive "!^test[" string
         //   if would do stat, next open.          //   if would do stat, next open.
     if(      if(
                 (f=open(fname, O_RDONLY|(as_text?_O_TEXT:_O_BINARY)))>=0 &&                   (f=open(fname, O_RDONLY|(as_text?_O_BINARY/*_O_TEXT*/:_O_BINARY)))>=0 && 
                 stat(fname, &finfo)==0) {                  stat(fname, &finfo)==0) {
                 /*if(exclusive)                  /*if(exclusive)
                         flock(f, LOCK_EX);*/                          flock(f, LOCK_EX);*/
                 size_t max_size=limit?min(offset+limit, finfo.st_size)-offset:finfo.st_size;                  size_t max_size=limit?min(offset+limit, finfo.st_size)-offset:finfo.st_size;
                 if(!max_size) { // eof                  if(!max_size) { // eof
                         data=0;                          if(as_text) {
                                   data=pool.malloc(1);
                                   *(char*)data=0;
                           } else 
                                   data=0;
                         read_size=0;                          read_size=0;
                         return true;                  } else {
                           data=pool.malloc(max_size+(as_text?1:0), 3);
                           if(offset)
                                   lseek(f, offset, SEEK_SET);
                           read_size=read(f, data, max_size);
                 }                  }
                 data=pool.malloc(max_size+(as_text?1:0));  
                 if(offset)  
                         lseek(f, offset, SEEK_SET);  
                 read_size=read(f, data, max_size);  
                 /*if(exclusive)                  /*if(exclusive)
                         flock(f, LOCK_UN);*/                          flock(f, LOCK_UN);*/
                 close(f);                  close(f);
                   if(!max_size) // eof
                           return true;
   
                 if(read_size>=0 && read_size<=max_size) {                  if(read_size>=0 && read_size<=max_size) {
                         if(as_text)                          if(as_text)
                                 ((char*&)data)[read_size]=0;                                  ((char*&)data)[read_size]=0;
                 } else                  } else
                         PTHROW(0, 0,                           throw Exception(0, 0, 
                                 &file_spec,                                   &file_spec, 
                                 "read failed: actually read %d bytes count not in [0..%lu] valid range",                                   "read failed: actually read %d bytes count not in [0..%lu] valid range", 
                                         read_size, (unsigned long)max_size); //never                                          read_size, (unsigned long)max_size); //never
                                   
                 return true;//prepare_config(result, remove_empty_lines);                  if(as_text)
                           fix_line_breaks((char *)data, read_size);
                   return true;
     }      }
         if(fail_on_read_problem)          if(fail_on_read_problem)
                 PTHROW(0, 0,                   throw Exception(0, 0, 
                         &file_spec,                           &file_spec, 
                         "read failed: %s (%d), actual filename '%s'",                           "read failed: %s (%d), actual filename '%s'", 
                                 strerror(errno), errno, fname);                                  strerror(errno), errno, fname);
     return false;      return false;
 }  }
   
   static void create_dir_for_file(const String& file_spec) {
           size_t pos_after=1;
           int pos_before;
           while((pos_before=file_spec.pos("/", 1, pos_after))>=0) {
                   mkdir(file_spec.mid(0, pos_before).cstr(String::UL_FILE_SPEC), 0775);
                   pos_after=pos_before+1;
           }
   }
   
 void file_write(Pool& pool,   void file_write(Pool& pool, 
                                 const String& file_spec,                                   const String& file_spec, 
                                 const void *data, size_t size,                                   const void *data, size_t size, 
                                 bool as_text/*,                                   bool as_text,
                                   bool do_append/*, 
                                 bool exclusive*/) {                                  bool exclusive*/) {
         const char *fname=file_spec.cstr(String::UL_FILE_NAME);          const char *fname=file_spec.cstr(String::UL_FILE_SPEC);
         int f;          int f;
         if(access(fname, W_OK)!=0) {/*no*/          if(access(fname, W_OK)!=0) // no
                 size_t pos_after=1;                  create_dir_for_file(file_spec);
                 int pos_before;  
                 while((pos_before=file_spec.pos("/", 1, pos_after))>=0) {  
                         mkdir(file_spec.mid(0, pos_before).cstr(String::UL_FILE_NAME), 0775);  
                         pos_after=pos_before+1;  
                 }  
   
                 if((f=open(fname, O_WRONLY|O_CREAT|_O_BINARY, 0666))>0)          if((f=open(fname, 
                         close(f);                  O_CREAT|O_RDWR
         }                  |(as_text?_O_TEXT:_O_BINARY)
         if(access(fname, R_OK|W_OK)==0) {                  |(do_append?O_APPEND:O_TRUNC), 0666))>=0) {
                 int mode=O_RDWR|(as_text?_O_TEXT:_O_BINARY)                  /*if(exclusive)
 #ifdef WIN32                          flock(f, LOCK_EX);*/
                         |O_TRUNC                  
 #endif                  if(size) write(f, data, size);
                 ;  #if O_TRUNC==0
                 if((f=open(fname, mode, 0666))>=0) {                  ftruncate(f, size);
                         /*if(exclusive)  
                                 flock(f, LOCK_EX);*/  
                           
                         if(size) write(f, data, size);  
 #ifndef WIN32  
                         ftruncate(f, size);  
 #endif  #endif
                         /*if(exclusive)                  /*if(exclusive)
                                 flock(f, LOCK_UN);*/                          flock(f, LOCK_UN);*/
                         close(f);                  close(f);
                         return;          } else
                 }                  throw Exception(0, 0, 
         }                          &file_spec, 
         PTHROW(0, 0,                           "write failed: %s (%d), actual filename '%s'", 
                 &file_spec,                                   strerror(errno), errno, fname);
                 "write failed: %s (%d), actual filename '%s'",   
                         strerror(errno), errno, fname);  
 }  }
   
   // throws nothing! [this is required in file_move & file_delete]
 static void rmdir(const String& file_spec, size_t pos_after) {  static void rmdir(const String& file_spec, size_t pos_after) {
         int pos_before;          int pos_before;
         if((pos_before=file_spec.pos("/", 1, pos_after))>=0)          if((pos_before=file_spec.pos("/", 1, pos_after))>=0)
                 rmdir(file_spec, pos_before+1);                  rmdir(file_spec, pos_before+1);
                   
         rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::UL_FILE_NAME));          rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::UL_FILE_SPEC));
 }  }
 void file_delete(Pool& pool, const String& file_spec) {  void file_delete(Pool& pool, const String& file_spec) {
         const char *fname=file_spec.cstr(String::UL_FILE_NAME);          const char *fname=file_spec.cstr(String::UL_FILE_SPEC);
         if(unlink(fname)!=0)          if(unlink(fname)!=0)
                 PTHROW(0, 0,                   throw Exception(0, 0, 
                         &file_spec,                           &file_spec, 
                         "unlink failed: %s (%d), actual filename '%s'",                           "unlink failed: %s (%d), actual filename '%s'", 
                                 strerror(errno), errno, fname);                                  strerror(errno), errno, fname);
   
         rmdir(file_spec, 1);          rmdir(file_spec, 1);
 }  }
   void file_move(Pool& pool, const String& old_spec, const String& new_spec) {
           const char *old_spec_cstr=old_spec.cstr(String::UL_FILE_SPEC);
           const char *new_spec_cstr=new_spec.cstr(String::UL_FILE_SPEC);
           
           create_dir_for_file(new_spec);
   
           if(rename(old_spec_cstr, new_spec_cstr)!=0)
                   throw Exception(0, 0, 
                           &old_spec, 
                           "rename failed: %s (%d), actual filename '%s' to '%s'", 
                                   strerror(errno), errno, old_spec_cstr, new_spec_cstr);
   
           rmdir(old_spec, 1);
   }
   
   
 static bool entry_readable(const String& file_spec, bool need_dir) {  static bool entry_readable(const String& file_spec, bool need_dir) {
     const char *fname=file_spec.cstr(String::UL_FILE_NAME);      const char *fname=file_spec.cstr(String::UL_FILE_SPEC);
         struct stat finfo;          struct stat finfo;
         if(access(fname, R_OK)==0 && stat(fname, &finfo)==0) {          if(access(fname, R_OK)==0 && stat(fname, &finfo)==0) {
                 bool is_dir=(bool)(finfo.st_mode&S_IFDIR);                  bool is_dir=finfo.st_mode&S_IFDIR != 0;
                 return is_dir==need_dir;                  return is_dir==need_dir;
         }          }
         return false;          return false;
Line 181  bool file_readable(const String& file_sp Line 223  bool file_readable(const String& file_sp
 bool dir_readable(const String& file_spec) {  bool dir_readable(const String& file_spec) {
         return entry_readable(file_spec, true);          return entry_readable(file_spec, true);
 }  }
   String *file_readable(const String& path, const String& name) {
           String *result=new(path.pool()) String(path);
           *result << "/";
           *result << name;
           return file_readable(*result)?result:0;
   }
 bool file_executable(const String& file_spec) {  bool file_executable(const String& file_spec) {
     return access(file_spec.cstr(String::UL_FILE_NAME), X_OK)==0;      return access(file_spec.cstr(String::UL_FILE_SPEC), X_OK)==0;
 }  }
   
 size_t file_size(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) {
         Pool& pool=file_spec.pool();          Pool& pool=file_spec.pool();
         const char *fname=file_spec.cstr(String::UL_FILE_NAME);          const char *fname=file_spec.cstr(String::UL_FILE_SPEC);
     struct stat finfo;      struct stat finfo;
         if(stat(fname, &finfo)!=0)          if(stat(fname, &finfo)!=0)
                 PTHROW(0, 0,                   if(fail_on_read_problem)
                         &file_spec,                           throw Exception(0, 0, 
                         "getting file size failed: %s (%d), real filename '%s'",                                   &file_spec, 
                                 strerror(errno), errno, fname);                                  "getting file size failed: %s (%d), real filename '%s'", 
         return finfo.st_size;                                          strerror(errno), errno, fname);
                   else
                           return false;
           rsize=finfo.st_size;
           ratime=finfo.st_atime;
           rmtime=finfo.st_mtime;
           rctime=finfo.st_ctime;
           return true;
 }  }
   
 char *getrow(char **row_ref, char delim) {  char *getrow(char **row_ref, char delim) {
Line 240  char *rsplit(char *string, char delim) { Line 300  char *rsplit(char *string, char delim) {
   
 /// @todo less stupid type detection  /// @todo less stupid type detection
 char *format(Pool& pool, double value, char *fmt) {  char *format(Pool& pool, double value, char *fmt) {
         char *result=(char *)pool.malloc(MAX_NUMBER);          char *result=(char *)pool.malloc(MAX_NUMBER, 4);
         if(fmt)          if(fmt)
                 if(strpbrk(fmt, "diouxX"))                  if(strpbrk(fmt, "diouxX"))
                         if(strpbrk(fmt, "ouxX"))                          if(strpbrk(fmt, "ouxX"))
Line 271  size_t stdout_write(const void *buf, siz Line 331  size_t stdout_write(const void *buf, siz
 #endif  #endif
 }  }
   
 const 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);          char *s=(char *)pool.malloc(len + 1, 5);
         enum EscapeState {          enum EscapeState {
                 EscapeRest,                   EscapeRest, 
                 EscapeFirst,                   EscapeFirst, 
Line 323  static void append_attribute_subattribut Line 383  static void append_attribute_subattribut
   
         // ...; charset=windows1251          // ...; charset=windows1251
         *ami.header << "; ";          *ami.header << "; ";
         ami.header->append(akey, ami.lang, true);          ami.header->append(akey, ami.lang);
         *ami.header << "=";          *ami.header << "=";
         ami.header->append(static_cast<Value *>(avalue)->as_string(), ami.lang, true);          ami.header->append(static_cast<Value *>(avalue)->as_string(), ami.lang);
 }  }
 const String& attributed_meaning_to_string(Value& meaning,   const String& attributed_meaning_to_string(Value& meaning, 
                                                                                    String::Untaint_lang lang) {                                                                                     String::Untaint_lang lang) {
         String &result=*new(meaning.pool()) String(meaning.pool());          String &result=*new(meaning.pool()) String(meaning.pool());
         if(Hash *hash=meaning.get_hash()) {          if(Hash *hash=meaning.get_hash(0)) {
                 // $value(value) $subattribute(subattribute value)                  // $value(value) $subattribute(subattribute value)
                 if(Value *value=static_cast<Value *>(hash->get(*value_name)))                  if(Value *value=static_cast<Value *>(hash->get(*value_name)))
                         result.append(value->as_string(), lang, true);                          result.append(value->as_string(), lang, true);
Line 382  bool StrEqNc(const char *s1, const char Line 442  bool StrEqNc(const char *s1, const char
         }          }
 }  }
   
 char *unquote(char*& current, char stop_at) {  static int isLeap(int year) {
         char *result=current;      return !(
         char *dest=current;               (year % 4) || ((year % 400) && !(year % 100))
         // skip leading WS              );
         while(*current==' ' || *current=='\t')  }
                 current++;  
         if(!*current)  int getMonthDays(int year, int month) {
                 return current=0;      int monthDays[]={
           31,
         bool quoted=*current=='"';          isLeap(year) ? 29 : 28,
         if(quoted)          31,
                 current++;          30,
           31,
         for(; *current; ) {          30,
                 if(quoted)          31,
                         switch(*current) {          31,
                         case '\\': // "...\c          30,
                                 if(current[1])          31,
                                         current++;          30,
                                 break;          31
                         case '"':      };
                                 current++;      return monthDays[month];
                                 goto break2;  }
                         }  
                 else  void remove_crlf(char *start, char *end) {
                         if(*current==stop_at)          for(char *p=start; p<end; p++)
                                 break;                  switch(*p) {
                           case '\n': *p='|'; break;
                 *dest++=*current++;                          case '\r': *p=' '; break;
         }                  }
 break2:  
         if(*current)  
                 current++; // skip 'stop_at'  
         *dest=0;  
         return result;  
 }  }
Removed from v.1.56  
changed lines
  Added in v.1.83

E-mail: