[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.64 and 1.75

version 1.64, 2001/09/14 15:41:59 version 1.75, 2001/10/23 14:43:44
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 42  int __snprintf(char *b, size_t s, const Line 42  int __snprintf(char *b, size_t s, const
   
 #endif  #endif
   
   // under WIN32 "t" mode fixes DOS chars OK, can't say that about other systems/ line break styles
   static void fix_line_breaks(char *src, size_t& size) {
           char *dest=src;
           // fix DOS: \r\n -> \n
           // fix Macintosh: \r -> \n
           char *bol=src;
           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,
Line 67  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);*/
Line 91  bool file_read(Pool& pool, const String& Line 112  bool file_read(Pool& pool, const String&
                         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);
Line 148  void file_write(Pool& pool, Line 171  void file_write(Pool& pool,
                         return;                          return;
                 }                  }
         }          }
         PTHROW(0, 0,           throw Exception(0, 0, 
                 &file_spec,                   &file_spec, 
                 "write failed: %s (%d), actual filename '%s'",                   "write failed: %s (%d), actual filename '%s'", 
                         strerror(errno), errno, fname);                          strerror(errno), errno, fname);
Line 165  static void rmdir(const String& file_spe Line 188  static void rmdir(const String& file_spe
 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_SPEC);          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);
Line 179  void file_move(Pool& pool, const String& Line 202  void file_move(Pool& pool, const String&
         create_dir_for_file(new_spec);          create_dir_for_file(new_spec);
   
         if(rename(old_spec_cstr, new_spec_cstr)!=0)          if(rename(old_spec_cstr, new_spec_cstr)!=0)
                 PTHROW(0, 0,                   throw Exception(0, 0, 
                         &old_spec,                           &old_spec, 
                         "rename failed: %s (%d), actual filename '%s' to '%s'",                           "rename failed: %s (%d), actual filename '%s' to '%s'", 
                                 strerror(errno), errno, old_spec_cstr, new_spec_cstr);                                  strerror(errno), errno, old_spec_cstr, new_spec_cstr);
Line 192  static bool entry_readable(const String& Line 215  static bool entry_readable(const String&
     const char *fname=file_spec.cstr(String::UL_FILE_SPEC);      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 203  bool file_readable(const String& file_sp Line 226  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_SPEC), X_OK)==0;      return access(file_spec.cstr(String::UL_FILE_SPEC), X_OK)==0;
 }  }
Line 218  bool file_stat(const String& file_spec, Line 247  bool file_stat(const String& file_spec,
     struct stat finfo;      struct stat finfo;
         if(stat(fname, &finfo)!=0)          if(stat(fname, &finfo)!=0)
                 if(fail_on_read_problem)                  if(fail_on_read_problem)
                         PTHROW(0, 0,                           throw Exception(0, 0, 
                                 &file_spec,                                   &file_spec, 
                                 "getting file size failed: %s (%d), real filename '%s'",                                   "getting file size failed: %s (%d), real filename '%s'", 
                                         strerror(errno), errno, fname);                                          strerror(errno), errno, fname);
Line 357  static void append_attribute_subattribut Line 386  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 416  bool StrEqNc(const char *s1, const char Line 445  bool StrEqNc(const char *s1, const char
         }          }
 }  }
   
 char *unquote(char*& current, char stop_at) {  
         char *result=current;  
         char *dest=current;  
         // skip leading WS  
         while(*current==' ' || *current=='\t')  
                 current++;  
         if(!*current)  
                 return current=0;  
   
         bool quoted=*current=='"';  
         if(quoted)  
                 current++;  
   
         for(; *current; ) {  
                 if(quoted)  
                         switch(*current) {  
                         case '\\': // "...\c  
                                 if(current[1])  
                                         current++;  
                                 break;  
                         case '"':  
                                 current++;  
                                 goto break2;  
                         }  
                 else  
                         if(*current==stop_at)  
                                 break;  
   
                 *dest++=*current++;  
         }  
 break2:  
         if(*current)  
                 current++; // skip 'stop_at'  
         *dest=0;  
         return result;  
 }  
   
 static int isLeap(int year) {  static int isLeap(int year) {
     return !(      return !(
              (year % 4) || ((year % 400) && !(year % 100))               (year % 4) || ((year % 400) && !(year % 100))
Line 476  int getMonthDays(int year, int month) { Line 468  int getMonthDays(int year, int month) {
     };      };
     return monthDays[month];      return monthDays[month];
 }  }
   
   void remove_crlf(char *start, char *end) {
           for(char *p=start; p<end; p++)
                   switch(*p) {
                           case '\n': *p='|'; break;
                           case '\r': *p=' '; break;
                   }
   }
Removed from v.1.64  
changed lines
  Added in v.1.75

E-mail: