parser3/src/include/pa_request.h - diff

Return to pa_request.h CVS log

Up to [parser3project] / parser3 / src / include

Diff for /parser3/src/include/pa_request.h between versions 1.127 and 1.135

version 1.127, 2002/04/11 13:33:39	version 1.135, 2002/06/11 12:20:41
Line 30	Line 30
#include <sys/resource.h>	#include <sys/resource.h>
#endif	#endif

	// consts

	#define MAIN_METHOD_NAME "main"
	const uint ANTI_ENDLESS_EXECUTE_RECOURSION=500;

	// defines

#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
# define COMPILE_PARAMS \	# define COMPILE_PARAMS \
const char *source, \	const char *source, \
Line 74 public:	Line 81 public:
const char *content_type;	const char *content_type;
size_t content_length;	size_t content_length;
const char *cookie;	const char *cookie;
const char *user_agent;
};	};

Request(Pool& apool,	Request(Pool& apool,
Line 102 public:	Line 108 public:
/// executes ops	/// executes ops
void execute(const Array& ops); // execute.C	void execute(const Array& ops); // execute.C
/// execute ops with anti-recoursion check	/// execute ops with anti-recoursion check
void recoursion_checked_execute(const String *name, const Array& ops);	void recoursion_checked_execute(const String *name, const Array& ops) {
	// anti_endless_execute_recoursion
	if(++anti_endless_execute_recoursion==ANTI_ENDLESS_EXECUTE_RECOURSION) {
	anti_endless_execute_recoursion=0; // give @exception a chance
	throw Exception("parser.runtime",
	name,
	"call canceled - endless recursion detected");
	}
	execute(ops); // execute it
	anti_endless_execute_recoursion--;
	}

/// compiles the file, maybe forcing it's class @a name and @a base_class.	/// compiles the file, maybe forcing it's class @a name and @a base_class.
VStateless_class *use_file(	VStateless_class *use_file(
Line 116 public:	Line 132 public:
VStateless_class aclass=0, const String name=0,	VStateless_class aclass=0, const String name=0,
VStateless_class *base_class=0); // core.C	VStateless_class *base_class=0); // core.C

//@{ convinient inline helpers @see Request::process	/// processes any code-junction there may be inside of @a value
const String& process_to_string(Value& input_value,	StringOrValue process(Value& input_value, bool intercept_string=true); // execute.C
const String *result_name=0) {	//@{ convinient helpers
const String *result;	const String& process_to_string(Value& input_value) {
process_internal(input_value, result_name, true/intercept_string/, &result, 0);	return process(input_value, true/intercept_string/).as_string();
return *result;	}
}	Value& process_to_value(Value& input_value, bool intercept_string=true) {
Value& process_to_value(Value& input_value,	return process(input_value, intercept_string).as_value();
const String *result_name=0,
bool intercept_string=true) {
Value *result;
process_internal(input_value, result_name, intercept_string, 0, &result);
return *result;
}	}
//@}	//@}


	#define DEFINE_DUAL(modification) \
	void write_##modification##_lang(StringOrValue dual) { \
	if(const String *string=dual.get_string()) \
	write_##modification##_lang(*string); \
	else \
	write_##modification##_lang(*dual.get_value()); \
	}
	#define DEFINE_DUAL_CHECKED(modification) \
	void write_##modification##_lang(StringOrValue dual, const String *origin) { \
	if(const String *string=dual.get_string()) \
	write_##modification##_lang(*string); \
	else \
	write_##modification##_lang(*dual.get_value(), origin); \
	}

/// appending, sure of clean string inside	/// appending, sure of clean string inside
void write_no_lang(const String& astring) {	void write_no_lang(const String& astring) {
wcontext->write(astring,	wcontext->write(astring,
String::UL_CLEAN \| flang&String::UL_OPTIMIZE_BIT);	String::UL_CLEAN \| flang&String::UL_OPTIMIZE_BIT);
}	}
	/// appending sure value, that would be converted to clean string
	void write_no_lang(Value& avalue) {
	if(wcontext->get_in_expression())
	wcontext->write(avalue);
	else
	wcontext->write(avalue,
	String::UL_CLEAN \| flang&String::UL_OPTIMIZE_BIT);
	}
	//DEFINE_DUAL(no)

/// appending string, passing language built into string being written	/// appending string, passing language built into string being written
void write_pass_lang(const String& astring) {	void write_pass_lang(const String& astring) {
wcontext->write(astring, String::UL_PASS_APPENDED);	wcontext->write(astring, String::UL_PASS_APPENDED);
}	}
	/// appending possible string, passing language built into string being written
	void write_pass_lang(Value& avalue) {
	wcontext->write(avalue, String::UL_PASS_APPENDED);
	}
	DEFINE_DUAL(pass)

/// appending possible string, assigning untaint language	/// appending possible string, assigning untaint language
void write_assign_lang(Value& avalue) {	void write_assign_lang(Value& avalue) {
wcontext->write(avalue, flang);	wcontext->write(avalue, flang);
}	}
	/// appending possible string, assigning untaint language
	void write_assign_lang(Value& avalue, const String *origin) {
	wcontext->write(avalue, flang, origin);
	}
/// appending string, assigning untaint language	/// appending string, assigning untaint language
void write_assign_lang(const String& astring) {	void write_assign_lang(const String& astring) {
wcontext->write(astring, flang);	wcontext->write(astring, flang);
}	}
/// appending possible string, passing language built into string being written	DEFINE_DUAL(assign)
void write_pass_lang(Value& avalue) {	DEFINE_DUAL_CHECKED(assign)
wcontext->write(avalue, String::UL_PASS_APPENDED);
}
/// appending sure value, that would be converted to clean string
void write_no_lang(Value& avalue) {
if(wcontext->get_in_expression())
wcontext->write(avalue);
else
wcontext->write(avalue,
String::UL_CLEAN \| flang&String::UL_OPTIMIZE_BIT);
}
/// appending sure value, not VString
void write_expr_result(Value& avalue) {
wcontext->write(avalue);
}

/// returns relative to @a path path to @a file	/// returns relative to @a path path to @a file
const String& relative(const char *apath, const String& relative_name);	const String& relative(const char *apath, const String& relative_name);
Line 185 public:	Line 218 public:
return fconnection;	return fconnection;
}	}

	bool origins_mode() {
	return main_class->get_element(*origins_mode_name)!=0; // $ORIGINS mode
	}

public:	public:

/// info from web server	/// info from web server
Line 192 public:	Line 229 public:
/// user's post data	/// user's post data
char *post_data; size_t post_size;	char *post_data; size_t post_size;

	/// name of 'main' method
	const String main_method_name;

/// operators are methods of this class	/// operators are methods of this class
Methoded& OP;	Methoded& OP;
/// $env:fields	/// $env:fields
Line 253 private: // execute.C	Line 293 private: // execute.C
const String& method_name,	const String& method_name,
bool return_cstr);	bool return_cstr);

Value *get_element(bool can_call_operator);	Value get_element(const String & remember_name, bool can_call_operator);

private: // defaults	private: // defaults

Line 297 private:	Line 337 private:
/// connection	/// connection
SQL_Connection *fconnection;	SQL_Connection *fconnection;


private:

/// processes any code-junction there may be inside of @a value
void process_internal(
Value& input_value, const String *result_name,
bool intercept_string,
const String string_result, Value value_result); // execute.C

void output_result(const VFile& body_file, bool header_only);	void output_result(const VFile& body_file, bool header_only);
};	};

E-mail:

Removed from v.1.127
changed lines
	Added in v.1.135