parser3/src/main/pa_common.C - diff

Return to pa_common.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_common.C between versions 1.51 and 1.75

version 1.51, 2001/04/25 11:02:57	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$	$Id$
*/	*/

#include "pa_config_includes.h"
#include "pa_common.h"	#include "pa_common.h"
#include "pa_types.h"	#include "pa_types.h"
#include "pa_exception.h"	#include "pa_exception.h"
Line 44 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,
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 68 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 76 bool file_read(Pool& pool, const String&	Line 96 bool file_read(Pool& pool, const String&
if(!max_size) { // eof	if(!max_size) { // eof
data=0;	data=0;
read_size=0;	read_size=0;
return true;	} else {
	data=pool.malloc(max_size+(as_text?1:0));
	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)", strerror(errno), errno);	"read failed: %s (%d), actual filename '%s'",
	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 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, O_WRONLY\|O_CREAT\|_O_BINARY, 0666))>0)
close(f);	close(f);
Line 142 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)", strerror(errno), errno);	"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) {
if(unlink(file_spec.cstr(String::UL_FILE_NAME))!=0)	const char *fname=file_spec.cstr(String::UL_FILE_SPEC);
PTHROW(0, 0,	if(unlink(fname)!=0)
	throw Exception(0, 0,
&file_spec,	&file_spec,
"unlink failed: %s (%d)", strerror(errno), errno);	"unlink failed: %s (%d), actual filename '%s'",
	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 179 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_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,
"write failed: %s (%d)", strerror(errno), errno);	&file_spec,
return finfo.st_size;	"getting file size failed: %s (%d), real filename '%s'",
	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 306 const char *unescape_chars(Pool& pool, c	Line 372 const char *unescape_chars(Pool& pool, c
return s;	return s;
}	}

	/// used by attributed_meaning_to_string / append_attribute_subattribute
struct Attributed_meaning_info {	struct Attributed_meaning_info {
String::Untaint_lang lang;	String *header; // header line being constructed
String *header;	String::Untaint_lang lang; // language in which to append to that line
};	};
static void append_attribute_subattribute(const Hash::Key& akey, Hash::Val *avalue,	static void append_attribute_subattribute(const Hash::Key& akey, Hash::Val *avalue,
void *info) {	void *info) {
Line 319 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);

Attributed_meaning_info attributed_meaning_info={	Attributed_meaning_info attributed_meaning_info={
lang,	&result,
&result	lang
};	};
hash->for_each(append_attribute_subattribute, &attributed_meaning_info);	hash->for_each(append_attribute_subattribute, &attributed_meaning_info);
} else // result value	} else // result value
Line 378 bool StrEqNc(const char *s1, const char	Line 445 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;
}	}

E-mail:

Removed from v.1.51
changed lines
	Added in v.1.75