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.217 and 1.241

version 1.217, 2015/04/08 18:08:52	version 1.241, 2016/11/22 22:31:38
Line 1	Line 1
/** @file	/** @file
Parser: request class decl.	Parser: request class decl.

Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

Line 21	Line 21

// consts	// consts

const uint ANTI_ENDLESS_EXECUTE_RECOURSION=1000;
const size_t pseudo_file_no__process=1;	const size_t pseudo_file_no__process=1;

// forwards	// forwards
Line 36 class VCookie;	Line 35 class VCookie;
class VStateless_class;	class VStateless_class;
class VConsole;	class VConsole;

	extern int pa_execute_recoursion_limit;
	extern int pa_loop_limit;

/// Main workhorse.	/// Main workhorse.
class Request: public PA_Object {	class Request: public PA_Object {
friend class Temp_lang;	friend class Temp_lang;
Line 52 public:	Line 54 public:
public:	public:
Trace(): fname(0) {}	Trace(): fname(0) {}
void clear() { fname=0; }	void clear() { fname=0; }
operator bool() const { return fname!=0; }

Trace(const String* aname, const Operation::Origin aorigin):	Trace(const String* aname, const Operation::Origin aorigin):
fname(aname), forigin(aorigin) {}	fname(aname), forigin(aorigin) {}
Line 87 private:	Line 88 private:

/// needed to fill unused Array entries	/// needed to fill unused Array entries
StackItem() {}	StackItem() {}
StackItem(Value& avalue): fvalue(&avalue) {}	StackItem(Value& avalue): fvalue(&avalue) {}
StackItem(ArrayOperation& aops): fops(&aops) {}	StackItem(ArrayOperation& aops): fops(&aops) {}
StackItem(VMethodFrame& amethod_frame): fmethod_frame(&amethod_frame) {}	StackItem(VMethodFrame& amethod_frame): fmethod_frame(&amethod_frame) {}
};	};
Line 108 private:	Line 109 private:
bool is_empty() {	bool is_empty() {
return fused==fbottom;	return fused==fbottom;
}	}

const element_type extract_origin(const String*& problem_source);
};	};

///@{ core data	///@{ core data

/// classes	/// classes
HashString<Value*> fclasses;	HashString<VStateless_class*> fclasses;

/// already used files to avoid cyclic uses	/// already used files to avoid cyclic uses
HashString<bool> used_files;	HashString<bool> used_files;
Line 123 private:	Line 122 private:
/// list of all used files, Operation::file_no = index to it	/// list of all used files, Operation::file_no = index to it
Array<String::Body> file_list;	Array<String::Body> file_list;

/** endless execute(execute(... preventing counter	/// endless execute(execute(... preventing counter
@see ANTI_ENDLESS_EXECUTE_RECOURSION
*/
uint anti_endless_execute_recoursion;	uint anti_endless_execute_recoursion;

///@}	///@}
Line 145 public:	Line 142 public:
Value* rcontext;	Value* rcontext;
WContext* wcontext;	WContext* wcontext;
/// current language	/// current language
String::Language flang;	String::Language flang;
/// current connection	/// current connection
SQL_Connection* fconnection;	SQL_Connection* fconnection;
//@}	//@}
Line 158 public:	Line 155 public:
uint register_file(String::Body file_spec);	uint register_file(String::Body file_spec);

struct Exception_details {	struct Exception_details {
const Trace trace;	const Operation::Origin origin;
const String* problem_source;	const String* problem_source;
VHash& vhash;	VHash& vhash;
	Exception_details(const Operation::Origin aorigin, const String* aproblem_source, VHash& avhash): origin(aorigin), problem_source(aproblem_source), vhash(avhash) {}
Exception_details(
const Trace atrace,
const String* aproblem_source,
VHash& avhash): trace(atrace), problem_source(aproblem_source), vhash(avhash) {}
};	};
Exception_details get_details(const Exception& e);	Exception_details get_details(const Exception& e);
const char* get_exception_cstr(const Exception& e, Exception_details& details);	const char* get_exception_cstr(const Exception& e, Exception_details& details);
Line 187 public:	Line 180 public:
~Request();	~Request();

/// global classes	/// global classes
HashString<Value*>& classes() { return fclasses; }	HashString<VStateless_class*>& classes() { return fclasses; }
Value* get_class(const String& name);	VStateless_class* get_class(const String& name);
	void put_class(VStateless_class *aclass){ classes().put(aclass->type(), aclass); }

/**	/**
core request processing	core request processing

BEWARE: may throw exception to you: catch it!	BEWARE: may throw exception to you: catch it!
*/	*/
void core(	void core(const char* config_filespec, bool config_fail_on_read_problem, bool header_only);
const char* config_filespec, ///< system config filespec
bool config_fail_on_read_problem, ///< fail if system config file not found
bool header_only);

/// executes ops	/// executes ops
void execute(ArrayOperation& ops); // execute.C	void execute(ArrayOperation& ops); // execute.C
void op_call(VMethodFrame &frame);
void op_call_write(VMethodFrame &frame);	template<typename Frame> void call(Frame& frame){
Value& construct(Value &class_value, const Method &method);	VMethodFrame *saved_method_frame=method_frame;
	Value* saved_rcontext=rcontext;
	WContext *saved_wcontext=wcontext;

	rcontext=wcontext=method_frame=&frame;

	frame.call(*this);

	wcontext=saved_wcontext;
	rcontext=saved_rcontext;
	method_frame=saved_method_frame;
	}

	template<typename Frame> void call_write(Frame& frame){
	VMethodFrame *saved_method_frame=method_frame;
	Value* saved_rcontext=rcontext;

	rcontext=method_frame=&frame;

	frame.call(*this);

	rcontext=saved_rcontext;
	method_frame=saved_method_frame;
	}

	Value& construct(VStateless_class &class_value, const Method &method);

/// execute ops with anti-recoursion check	/// execute ops with anti-recoursion check
void recoursion_checked_execute(/const String& name, /ArrayOperation& ops) {	void recoursion_checked_execute(ArrayOperation& ops) {
// anti_endless_execute_recoursion	if(++anti_endless_execute_recoursion==pa_execute_recoursion_limit) {
if(++anti_endless_execute_recoursion==ANTI_ENDLESS_EXECUTE_RECOURSION) {
anti_endless_execute_recoursion=0; // give @exception a chance	anti_endless_execute_recoursion=0; // give @exception a chance
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "call canceled - endless recursion detected");
0, //&name,
"call canceled - endless recursion detected");
}	}
execute(ops); // execute it	execute(ops); // execute it
anti_endless_execute_recoursion--;	anti_endless_execute_recoursion--;
}	}

///	///
void use_file_directly(VStateless_class& aclass,	void use_file_directly(VStateless_class& aclass, const String& file_spec, bool fail_on_read_problem=true, bool fail_on_file_absence=true);
const String& file_spec,
bool fail_on_read_problem=true,
bool fail_on_file_absence=true);

/// 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.
void use_file(VStateless_class& aclass,	void use_file(VStateless_class& aclass, const String& file_name, const String* use_filespec);
const String& file_name,
const String* use_filespec);	/// for @USE only, calls ^use (which may be user-defined)
	void use_file(const String& file_name, const String* use_filespec, Operation::Origin origin);

/// compiles a @a source buffer	/// compiles a @a source buffer
void use_buf(VStateless_class& aclass,	void use_buf(VStateless_class& aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset=0);
const char* source,
const String* main_alias,
uint file_no,
int line_no_offset=0);

/// processes any code-junction there may be inside of @a value	/// processes any code-junction there may be inside of @a value
StringOrValue process_getter(Junction& junction); // execute.C	Value& process_getter(Junction& junction); // execute.C
StringOrValue process(Value& input_value, bool intercept_string=true); // execute.C	Value& process(Value& input_value); // execute.C
void process_write(Value& input_value); // execute.C	void process_write(Value& input_value); // execute.C

//@{ convinient helpers	//@{ convinient helpers
const String& process_to_string(Value& input_value) {	const String& process_to_string(Value& input_value) {
return process(input_value, true/intercept_string/).as_string();	return process(input_value).as_string();
}
Value& process_to_value(Value& input_value, bool intercept_string=true) {
return process(input_value, intercept_string).as_value();
}	}
//@}	//@}
const String* get_method_filename(const Method* method); // execute.C	const String* get_method_filename(const Method* method); // execute.C
const String* get_used_filename(uint file_no);	const String* get_used_filename(uint file_no);

#define DEFINE_DUAL(modification) \	/// appending string with it's languages
void write_##modification##_lang(StringOrValue dual) { \	inline void write(const String& astring) {
if(const String* string=dual.get_string()) \	wcontext->write(astring);
write_##modification##_lang(*string); \	}
else \
write_##modification##_lang(*dual.get_value()); \	/// in [] and {} appending string if get_string is not null, else appending value
}	/// in () appending string if is_string, else appending value
	inline void write(Value& avalue) {
/// appending, sure of clean string inside	wcontext->write_as_string(avalue);
void write_no_lang(const String& astring) {	}
wcontext->write(astring,
(String::Language)(String::L_CLEAN \| (flang & String::L_OPTIMIZE_BIT) ));	/// allways appending value
}	inline void write_value(Value& avalue) {
/// appending sure value, that would be converted to clean string	wcontext->write(avalue);
void write_no_lang(Value& avalue) {
if(wcontext->get_in_expression())
wcontext->write(avalue);
else
wcontext->write(avalue,
(String::Language)(String::L_CLEAN \| (flang & String::L_OPTIMIZE_BIT) ));
}

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

/// appending possible string, assigning untaint language
void write_assign_lang(Value& avalue) {
wcontext->write(avalue, flang);
}
/// appending string, assigning untaint language
void write_assign_lang(const String& astring) {
wcontext->write(astring, flang);
}	}
DEFINE_DUAL(assign)

/// 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 307 public:	Line 285 public:
const String& mime_type_of(const char* user_file_name_cstr);	const String& mime_type_of(const char* user_file_name_cstr);

/// returns current SQL connection if any	/// returns current SQL connection if any
SQL_Connection* connection(bool fail_on_error=true) {	SQL_Connection* connection(bool fail_on_error=true) {
if(fail_on_error && !fconnection)	if(fail_on_error && !fconnection)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "outside of 'connect' operator");
0,	return fconnection;
"outside of 'connect' operator");

return fconnection;
}	}

void set_interrupted(bool ainterrupted) { finterrupted=ainterrupted; }	void set_interrupted(bool ainterrupted) { finterrupted=ainterrupted; }
Line 356 public: // status read methods	Line 331 public: // status read methods

VMethodFrame *get_method_frame() { return method_frame; }	VMethodFrame *get_method_frame() { return method_frame; }
Value& get_self();	Value& get_self();
#define GET_SELF(request, type) (static_cast<type &>(request.get_self()))
/* for strange reason call to this:
r.get_self<VHash>()
refuses to compile

template<typename T> T& get_self() {	#define GET_SELF(request, type) (static_cast<type &>(request.get_self()))
return static_cast<T>(get_self().get());
}
*/

/// public for ^reflection:copy[]	/// public for ^reflection:copy[]
void put_element(Value& ncontext, const String& name, Value* value);	void put_element(Value& ncontext, const String& name, Value* value);
Line 372 public: // status read methods	Line 340 public: // status read methods
/// for @main[]	/// for @main[]
const String* execute_virtual_method(Value& aself, const String& method_name);	const String* execute_virtual_method(Value& aself, const String& method_name);

/// executes parser method, use op_call(frame) to execute native method
void execute_method(VMethodFrame& aframe);

//{ for @conf[filespec] and @auto[filespec] and parser://method/call	//{ for @conf[filespec] and @auto[filespec] and parser://method/call
const String* execute_method(Value& aself,	const String* execute_method(Value& aself, const Method& method, Value* optional_param, bool do_return_string);
const Method& method, Value* optional_param,
bool do_return_string);
struct Execute_nonvirtual_method_result {	struct Execute_nonvirtual_method_result {
const String* string;	const String* string;
Method* method;	Method* method;
Execute_nonvirtual_method_result(): string(0), method(0) {}	Execute_nonvirtual_method_result(): string(0), method(0) {}
};	};
Execute_nonvirtual_method_result execute_nonvirtual_method(VStateless_class& aclass,
const String& method_name,	Execute_nonvirtual_method_result execute_nonvirtual_method(VStateless_class& aclass, const String& method_name, VString* optional_param, bool do_return_string);
VString* optional_param,
bool do_return_string);
//}	//}

#ifdef XML	#ifdef XML
Line 413 private:	Line 375 private:

private: // compile.C	private: // compile.C

ArrayClass& compile(VStateless_class* aclass,	ArrayClass& compile(VStateless_class* aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset);
const char* source, const String* main_alias,
uint file_no,
int line_no_offset);

private: // execute.C	private: // execute.C

Value& get_element(Value& ncontext, const String& name);	Value& get_element(Value& ncontext, const String& name);
	#ifdef FEATURE_GET_ELEMENT4CALL
	Value& get_element4call(Value& ncontext, const String& name);
	#endif

private: // defaults	private: // defaults

Line 478 class Request_context_saver {	Line 440 class Request_context_saver {
SQL_Connection* fconnection;	SQL_Connection* fconnection;

public:	public:
Request_context_saver(Request& ar) :	Request_context_saver(Request& ar) :
fr(ar),	fr(ar),
exception_trace_top(ar.exception_trace.top_index()),	exception_trace_top(ar.exception_trace.top_index()),
exception_trace_bottom(ar.exception_trace.bottom_index()),	exception_trace_bottom(ar.exception_trace.bottom_index()),
stack(ar.stack.top_index()),	stack(ar.stack.top_index()),
anti_endless_execute_recoursion(ar.anti_endless_execute_recoursion),	anti_endless_execute_recoursion(ar.anti_endless_execute_recoursion),
method_frame(ar.method_frame),	method_frame(ar.method_frame),
Line 500 public:	Line 462 public:
}	}
};	};

/// Auto-object used for temporary changing Request::flang.
class Temp_lang {
Request& frequest;
String::Language saved_lang;
public:
Temp_lang(Request& arequest, String::Language alang) :
frequest(arequest),
saved_lang(arequest.set_lang(alang)) {
}
~Temp_lang() {
frequest.restore_lang(saved_lang);
}
};

/// Auto-object used for temporary changing Request::fconnection.	/// Auto-object used for temporary changing Request::fconnection.
class Temp_connection {	class Temp_connection {
Request& frequest;	Request& frequest;
SQL_Connection* saved_connection;	SQL_Connection* saved_connection;
public:	public:
Temp_connection(Request& arequest, SQL_Connection* aconnection) :	Temp_connection(Request& arequest, SQL_Connection* aconnection) :
frequest(arequest),	frequest(arequest),
saved_connection(arequest.set_connection(aconnection)) {	saved_connection(arequest.set_connection(aconnection)) {
}	}
~Temp_connection() {	~Temp_connection() {
frequest.restore_connection(saved_connection);	frequest.restore_connection(saved_connection);
}	}
};	};
Line 535 public:	Line 483 public:
InCycle(Request& arequest) : frequest(arequest) {	InCycle(Request& arequest) : frequest(arequest) {
frequest.set_in_cycle(1);	frequest.set_in_cycle(1);
}	}
~InCycle() {	~InCycle() {
frequest.set_in_cycle(-1);	frequest.set_in_cycle(-1);
}	}
};	};
Line 572 public:	Line 520 public:

extern const String main_method_name;	extern const String main_method_name;
extern const String auto_method_name;	extern const String auto_method_name;
extern const String body_name;

extern const String exception_type_part_name;	extern const String exception_type_part_name;
extern const String exception_source_part_name;	extern const String exception_source_part_name;

E-mail:

Removed from v.1.217
changed lines
	Added in v.1.241