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.46.2.1 and 1.56

version 1.46.2.1, 2001/04/16 11:26:43	version 1.56, 2001/06/28 07:44:17
Line 1	Line 1

/** @file	/** @file
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_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 74 bool file_read(Pool& pool, const String&	Line 71 bool file_read(Pool& pool, const String&
/*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
	data=0;
	read_size=0;
	return true;
	}
data=pool.malloc(max_size+(as_text?1:0));	data=pool.malloc(max_size+(as_text?1:0));
if(offset)	if(offset)
lseek(f, offset, SEEK_SET);	lseek(f, offset, SEEK_SET);
Line 96 bool file_read(Pool& pool, const String&	Line 98 bool file_read(Pool& pool, const String&
if(fail_on_read_problem)	if(fail_on_read_problem)
PTHROW(0, 0,	PTHROW(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;
}	}

/// @test mkdirs
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,
Line 108 void file_write(Pool& pool,	Line 110 void file_write(Pool& pool,
bool exclusive*/) {	bool exclusive*/) {
const char *fname=file_spec.cstr(String::UL_FILE_NAME);	const char *fname=file_spec.cstr(String::UL_FILE_NAME);
int f;	int f;
if(access(fname, F_OK)!=0) {/no/	if(access(fname, W_OK)!=0) {/no/
	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_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 134 void file_write(Pool& pool,	Line 143 void file_write(Pool& pool,
}	}
PTHROW(0, 0,	PTHROW(0, 0,
&file_spec,	&file_spec,
"write failed: %s (%d)", strerror(errno), errno);	"write failed: %s (%d), actual filename '%s'",
	strerror(errno), errno, fname);
}	}

	static void rmdir(const String& file_spec, size_t pos_after) {
	int pos_before;
	if((pos_before=file_spec.pos("/", 1, pos_after))>=0)
	rmdir(file_spec, pos_before+1);

	rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::UL_FILE_NAME));
	}
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_NAME);
	if(unlink(fname)!=0)
PTHROW(0, 0,	PTHROW(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);
}	}


	static bool entry_readable(const String& file_spec, bool need_dir) {
	const char *fname=file_spec.cstr(String::UL_FILE_NAME);
	struct stat finfo;
	if(access(fname, R_OK)==0 && stat(fname, &finfo)==0) {
	bool is_dir=(bool)(finfo.st_mode&S_IFDIR);
	return is_dir==need_dir;
	}
	return false;
	}
bool file_readable(const String& file_spec) {	bool file_readable(const String& file_spec) {
return access(file_spec.cstr(String::UL_FILE_NAME), R_OK)==0;	return entry_readable(file_spec, false);
	}
	bool dir_readable(const String& file_spec) {
	return entry_readable(file_spec, true);
}	}
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_NAME), X_OK)==0;
Line 158 size_t file_size(const String& file_spec	Line 192 size_t file_size(const String& file_spec
if(stat(fname, &finfo)!=0)	if(stat(fname, &finfo)!=0)
PTHROW(0, 0,	PTHROW(0, 0,
&file_spec,	&file_spec,
"write failed: %s (%d)", strerror(errno), errno);	"getting file size failed: %s (%d), real filename '%s'",
	strerror(errno), errno, fname);
return finfo.st_size;	return finfo.st_size;
}	}

Line 274 const char *unescape_chars(Pool& pool, c	Line 309 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 286 static void append_attribute_subattribut	Line 322 static void append_attribute_subattribut
Attributed_meaning_info& ami=static_cast<Attributed_meaning_info >(info);	Attributed_meaning_info& ami=static_cast<Attributed_meaning_info >(info);

// ...; charset=windows1251	// ...; charset=windows1251
ami.header->APPEND_CONST("; ");	*ami.header << "; ";
ami.header->append(akey, ami.lang, true);	ami.header->append(akey, ami.lang, true);
ami.header->APPEND_CONST("=");	*ami.header << "=";
ami.header->append(static_cast<Value *>(avalue)->as_string(),	ami.header->append(static_cast<Value *>(avalue)->as_string(), ami.lang, true);
ami.lang, true);
}	}
const String& attributed_meaning_to_string(Value& meaning, String::Untaint_lang lang) {	const String& attributed_meaning_to_string(Value& meaning,
	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()) {
// $value(value) $subattribute(subattribute value)	// $value(value) $subattribute(subattribute value)
Line 300 const String& attributed_meaning_to_stri	Line 336 const String& attributed_meaning_to_stri
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 345 bool StrEqNc(const char *s1, const char	Line 381 bool StrEqNc(const char *s1, const char
s2++;	s2++;
}	}
}	}

	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;
	}

E-mail:

Removed from v.1.46.2.1
changed lines
	Added in v.1.56