parser3/src/classes/file.C - diff

Return to file.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/file.C between versions 1.107.2.16.2.8 and 1.107.2.16.2.15

E-mail:

version 1.107.2.16.2.8, 2003/03/24 13:43:39	version 1.107.2.16.2.15, 2003/04/08 16:11:53
Line 102 static const StringBody cdate_name("cdat	Line 102 static const StringBody cdate_name("cdat

// methods	// methods

static void _save(Request& r, MethodParams* params) {	static void _save(Request& r, MethodParams& params) {
Value& vmode_name=params-> as_no_junction(0, "mode must not be code");	Value& vmode_name=params. as_no_junction(0, "mode must not be code");
Value& vfile_name=params->as_no_junction(1, "file name must not be code");	Value& vfile_name=params.as_no_junction(1, "file name must not be code");

// save	// save
GET_SELF(r, VFile).save(r.absolute(vfile_name.as_string()),	GET_SELF(r, VFile).save(r.absolute(vfile_name.as_string()),
vmode_name.as_string()==TEXT_MODE_NAME);	vmode_name.as_string()==TEXT_MODE_NAME);
}	}

static void _delete(Request& r, MethodParams* params) {	static void _delete(Request& r, MethodParams& params) {
Value& vfile_name=params->as_no_junction(0, "file name must not be code");	Value& vfile_name=params.as_no_junction(0, "file name must not be code");

// unlink	// unlink
file_delete(r.absolute(vfile_name.as_string()));	file_delete(r.absolute(vfile_name.as_string()));
}	}

static void _move(Request& r, MethodParams* params) {	static void _move(Request& r, MethodParams& params) {
Value& vfrom_file_name=params->as_no_junction(0, "from file name must not be code");	Value& vfrom_file_name=params.as_no_junction(0, "from file name must not be code");
Value& vto_file_name=params->as_no_junction(1, "to file name must not be code");	Value& vto_file_name=params.as_no_junction(1, "to file name must not be code");

// move	// move
file_move(	file_move(
Line 134 static void _load_pass_param(	Line 134 static void _load_pass_param(
HashStringValue *dest) {	HashStringValue *dest) {
dest->put(key, value);	dest->put(key, value);
}	}
static void _load(Request& r, MethodParams* params) {	static void _load(Request& r, MethodParams& params) {
Value& vmode_name=params-> as_no_junction(0, "mode must not be code");	Value& vmode_name=params. as_no_junction(0, "mode must not be code");
const String& lfile_name=r.absolute(params->as_no_junction(1, "file name must not be code").as_string());	const String& lfile_name=r.absolute(params.as_no_junction(1, "file name must not be code").as_string());
Value* third_param=params->count()>2?&params->as_no_junction(2, "filename or options must not be code")	Value* third_param=params.count()>2?&params.as_no_junction(2, "filename or options must not be code")
:0;	:0;
HashStringValue* third_param_hash=third_param?third_param->get_hash():0;	HashStringValue* third_param_hash=third_param?third_param->get_hash():0;
int alt_filename_param_index=2;	size_t alt_filename_param_index=2;
if(third_param_hash)	if(third_param_hash)
alt_filename_param_index++;	alt_filename_param_index++;

File_read_result file=file_read(r.charsets.source(), lfile_name,	File_read_result file=file_read(r.charsets, lfile_name,
vmode_name.as_string()==TEXT_MODE_NAME,	vmode_name.as_string()==TEXT_MODE_NAME,
third_param_hash	third_param_hash
);	);

const char *user_file_name=params->count()>alt_filename_param_index?	const char *user_file_name=params.count()>alt_filename_param_index?
params->as_string(alt_filename_param_index, "filename must be string").cstr()	params.as_string(alt_filename_param_index, "filename must be string").cstr()
:lfile_name.cstr(String::L_FILE_SPEC);	:lfile_name.cstr(String::L_FILE_SPEC);

Value* vcontent_type=0;	Value* vcontent_type=0;
Line 165 static void _load(Request& r, MethodPara	Line 165 static void _load(Request& r, MethodPara
file.headers->for_each(_load_pass_param, &self.fields());	file.headers->for_each(_load_pass_param, &self.fields());
}	}

static void _stat(Request& r, MethodParams* params) {	static void _stat(Request& r, MethodParams& params) {
Value& vfile_name=params->as_no_junction(0, "file name must not be code");	Value& vfile_name=params.as_no_junction(0, "file name must not be code");

const String& lfile_name=vfile_name.as_string();	const String& lfile_name=vfile_name.as_string();

Line 224 struct Pass_cgi_header_attribute_info {	Line 224 struct Pass_cgi_header_attribute_info {
};	};
#endif	#endif
static void pass_cgi_header_attribute(	static void pass_cgi_header_attribute(
ArrayString::element_type astring,	ArrayString::element_type astring,
Pass_cgi_header_attribute_info* info) {	Pass_cgi_header_attribute_info* info) {
int colon_pos=astring->pos(":", 1);	size_t colon_pos=astring->pos(':');
if(colon_pos>0) {	if(colon_pos==STRING_NOT_FOUND) {
const String& key=astring->mid(0, colon_pos).change_case(	const String& key=astring->mid(0, colon_pos).change_case(
*info->charset, String::CC_UPPER);	*info->charset, String::CC_UPPER);
Value* value=new VString(astring->mid(colon_pos+1, astring->length()));	Value* value=new VString(astring->mid(colon_pos+1, astring->length()));
Line 237 static void pass_cgi_header_attribute(	Line 237 static void pass_cgi_header_attribute(
}	}
}	}
/// @todo fix `` in perl - they produced flipping consoles and no output to perl	/// @todo fix `` in perl - they produced flipping consoles and no output to perl
static void _exec_cgi(Request& r, MethodParams* params,	static void _exec_cgi(Request& r, MethodParams& params,
bool cgi) {	bool cgi) {

Value& vfile_name=params->as_no_junction(0, "file name must not be code");	Value& vfile_name=params.as_no_junction(0, "file name must not be code");

const String& script_name=r.absolute(vfile_name.as_string());	const String& script_name=r.absolute(vfile_name.as_string());

Line 279 static void _exec_cgi(Request& r, Method	Line 279 static void _exec_cgi(Request& r, Method
bool stdin_specified=false;	bool stdin_specified=false;
// environment & stdin from param	// environment & stdin from param
String in;	String in;
if(params->count()>1) {	if(params.count()>1) {
Value& venv=params->as_no_junction(1, "env must not be code");	Value& venv=params.as_no_junction(1, "env must not be code");
if(HashStringValue* user_env=venv.get_hash()) {	if(HashStringValue* user_env=venv.get_hash()) {
Append_env_pair_info info;	Append_env_pair_info info;
info.env=&env;	info.env=&env;
Line 291 static void _exec_cgi(Request& r, Method	Line 291 static void _exec_cgi(Request& r, Method
in.append(*sstdin, String::L_CLEAN, true);	in.append(*sstdin, String::L_CLEAN, true);
} else	} else
if(VFile* vfile=static_cast<VFile *>(info.vstdin->as("file", false)))	if(VFile* vfile=static_cast<VFile *>(info.vstdin->as("file", false)))
in.append((const char* )vfile->value_ptr(), vfile->value_size(), String::L_TAINTED);	in.append_know_length((const char* )vfile->value_ptr(), vfile->value_size(), String::L_TAINTED);
else	else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
0,	0,
Line 302 static void _exec_cgi(Request& r, Method	Line 302 static void _exec_cgi(Request& r, Method

// argv from params	// argv from params
ArrayString argv;	ArrayString argv;
if(params->count()>2) {	if(params.count()>2) {
for(int i=2; i<params->count(); i++)	for(size_t i=2; i<params.count(); i++)
argv+=&params->as_string(i, "parameter must be string");	argv+=&params.as_string(i, "parameter must be string");
}	}

// passing POST data	// passing POST data
if(!stdin_specified) // if $.stdin[...] not specified	if(!stdin_specified) // if $.stdin[...] not specified @todo zeroterminate post_data!
in.append(r.request_info.post_data, r.request_info.post_size, String::L_CLEAN);	in.append_know_length(r.request_info.post_data, r.request_info.post_size, String::L_CLEAN);

// exec!	// exec!
PA_exec_result execution=	PA_exec_result execution=
Line 323 static void _exec_cgi(Request& r, Method	Line 323 static void _exec_cgi(Request& r, Method
const String* header=0;	const String* header=0;
if(cgi) { // ^file:cgi	if(cgi) { // ^file:cgi
// construct with 'out' body and header	// construct with 'out' body and header
int dos_pos=execution.out.pos("\r\n\r\n", 4);	size_t dos_pos=execution.out.pos("\r\n\r\n", 4);
int unix_pos=execution.out.pos("\n\n", 2);	size_t unix_pos=execution.out.pos("\n\n", 2);

bool unix_header_break;	bool unix_header_break;
switch((dos_pos >= 0?10:00) + (unix_pos >= 0?01:00)) {	switch((dos_pos!=STRING_NOT_FOUND?10:00) + (unix_pos!=STRING_NOT_FOUND?01:00)) {
case 10: // dos	case 10: // dos
unix_header_break=false;	unix_header_break=false;
break;	break;
Line 386 static void _exec_cgi(Request& r, Method	Line 386 static void _exec_cgi(Request& r, Method
StringBody("stderr"),	StringBody("stderr"),
new VString(execution.err));	new VString(execution.err));
}	}
static void _exec(Request& r, MethodParams* params) {	static void _exec(Request& r, MethodParams& params) {
_exec_cgi(r, params, false);	_exec_cgi(r, params, false);
}	}
static void _cgi(Request& r, MethodParams* params) {	static void _cgi(Request& r, MethodParams& params) {
_exec_cgi(r, params, true);	_exec_cgi(r, params, true);
}	}

static void _list(Request& r, MethodParams* params) {	static void _list(Request& r, MethodParams& params) {
Value& relative_path=params->as_no_junction(0, "path must not be code");	Value& relative_path=params.as_no_junction(0, "path must not be code");

const String* regexp;	const String* regexp;
pcre *regexp_code;	pcre *regexp_code;
const int ovecsize=(1/match/)*3;	const int ovecsize=(1/match/)*3;
int ovector[ovecsize];	int ovector[ovecsize];
if(params->count()>1) {	if(params.count()>1) {
regexp=&params->as_no_junction(1, "regexp must not be code").as_string();	regexp=&params.as_no_junction(1, "regexp must not be code").as_string();

const char* pattern=regexp->cstr();	const char* pattern=regexp->cstr();
const char* errptr;	const char* errptr;
Line 469 static void lock_execute_body(int , void	Line 469 static void lock_execute_body(int , void
// execute body	// execute body
info.r->write_assign_lang(info.r->process(*info.body_code));	info.r->write_assign_lang(info.r->process(*info.body_code));
};	};
static void _lock(Request& r, MethodParams* params) {	static void _lock(Request& r, MethodParams& params) {
Lock_execute_body_info info;	Lock_execute_body_info info;
info.r=&r;	info.r=&r;
const String& file_spec=r.absolute(params->as_string(0, "file name must be string"));	const String& file_spec=r.absolute(params.as_string(0, "file name must be string"));
info.body_code=&params->as_junction(1, "body must be code");	info.body_code=&params.as_junction(1, "body must be code");

file_write_action_under_lock(file_spec, "lock", lock_execute_body, &info);	file_write_action_under_lock(file_spec, "lock", lock_execute_body, &info);
}	}
Line 493 static int lastposafter(const String& s,	Line 493 static int lastposafter(const String& s,
return after;	return after;
}	}

static void _find(Request& r, MethodParams* params) {	static void _find(Request& r, MethodParams& params) {
const String& file_name=params->as_no_junction(0, "file name must not be code").as_string();	const String& file_name=params.as_no_junction(0, "file name must not be code").as_string();
const String* file_spec;	const String* file_spec;
if(file_name.first_char()=='/')	if(file_name.first_char()=='/')
file_spec=&file_name;	file_spec=&file_name;
Line 524 static void _find(Request& r, MethodPara	Line 524 static void _find(Request& r, MethodPara
}	}

// no way, not found	// no way, not found
if(params->count()==2) {	if(params.count()==2) {
Value& not_found_code=params->as_junction(1, "not-found param must be code");	Value& not_found_code=params.as_junction(1, "not-found param must be code");
r.write_pass_lang(r.process(not_found_code));	r.write_pass_lang(r.process(not_found_code));
}	}
}	}

static void _dirname(Request& r, MethodParams* params) {	static void _dirname(Request& r, MethodParams& params) {
const String& file_spec=params->as_string(0, "file name must be string");	const String& file_spec=params.as_string(0, "file name must be string");
// /a/some.tar.gz > /a	// /a/some.tar.gz > /a
// /a/b/ > /a	// /a/b/ > /a
int afterslash=lastposafter(file_spec, 0, "/", 1, true);	int afterslash=lastposafter(file_spec, 0, "/", 1, true);
Line 541 static void _dirname(Request& r, MethodP	Line 541 static void _dirname(Request& r, MethodP
r.write_assign_lang(String(".", 1));	r.write_assign_lang(String(".", 1));
}	}

static void _basename(Request& r, MethodParams* params) {	static void _basename(Request& r, MethodParams& params) {
const String& file_spec=params->as_string(0, "file name must be string");	const String& file_spec=params.as_string(0, "file name must be string");
// /a/some.tar.gz > some.tar.gz	// /a/some.tar.gz > some.tar.gz
int afterslash=lastposafter(file_spec, 0, "/", 1);	int afterslash=lastposafter(file_spec, 0, "/", 1);
r.write_assign_lang(file_spec.mid(afterslash, file_spec.length()));	r.write_assign_lang(file_spec.mid(afterslash, file_spec.length()));
}	}

static void _justname(Request& r, MethodParams* params) {	static void _justname(Request& r, MethodParams& params) {
const String& file_spec=params->as_string(0, "file name must be string");	const String& file_spec=params.as_string(0, "file name must be string");
// /a/some.tar.gz > some.tar	// /a/some.tar.gz > some.tar
int afterslash=lastposafter(file_spec, 0, "/", 1);	int afterslash=lastposafter(file_spec, 0, "/", 1);
int afterdot=lastposafter(file_spec, afterslash, ".", 1);	int afterdot=lastposafter(file_spec, afterslash, ".", 1);
r.write_assign_lang(file_spec.mid(afterslash, afterdot!=afterslash?afterdot-1:file_spec.length()));	r.write_assign_lang(file_spec.mid(afterslash, afterdot!=afterslash?afterdot-1:file_spec.length()));
}	}
static void _justext(Request& r, MethodParams* params) {	static void _justext(Request& r, MethodParams& params) {
const String& file_spec=params->as_string(0, "file name must be string");	const String& file_spec=params.as_string(0, "file name must be string");
// /a/some.tar.gz > gz	// /a/some.tar.gz > gz
int afterdot=lastposafter(file_spec, 0, ".", 1);	int afterdot=lastposafter(file_spec, 0, ".", 1);
if(afterdot>0)	if(afterdot>0)
r.write_assign_lang(file_spec.mid(afterdot, file_spec.length()));	r.write_assign_lang(file_spec.mid(afterdot, file_spec.length()));
}	}

static void _fullpath(Request& r, MethodParams* params) {	static void _fullpath(Request& r, MethodParams& params) {
const String& file_spec=params->as_string(0, "file name must be string");	const String& file_spec=params.as_string(0, "file name must be string");
const String* result;	const String* result;
if(file_spec.first_char()=='/')	if(file_spec.first_char()=='/')
result=&file_spec;	result=&file_spec;

Removed from v.1.107.2.16.2.8
changed lines
	Added in v.1.107.2.16.2.15