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.234 and 1.266

version 1.234, 2016/10/25 23:37:52	version 1.266, 2024/09/22 13:56:09
Line 1	Line 1
/** @file	/** @file
Parser: request class decl.	Parser: request class decl.

Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2023 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <paf@design.ru>
*/	*/

#ifndef PA_REQUEST_H	#ifndef PA_REQUEST_H
Line 19	Line 19
#include "pa_request_charsets.h"	#include "pa_request_charsets.h"
#include "pa_sapi.h"	#include "pa_sapi.h"

	// defines for externs

	#define EXCEPTION_HANDLED_PART_NAME "handled"


	// externs

	extern const String main_method_name;
	extern const String auto_method_name;

	extern const String exception_type_part_name;
	extern const String exception_source_part_name;
	extern const String exception_comment_part_name;
	extern const String exception_handled_part_name;

	// defines for statics

	#define MAIN_CLASS_NAME "MAIN"
	#define AUTO_FILE_NAME "auto.p"

// consts	// consts

const size_t pseudo_file_no__process=1;	const size_t pseudo_file_no__process=1;
Line 35 class VCookie;	Line 55 class VCookie;
class VStateless_class;	class VStateless_class;
class VConsole;	class VConsole;

extern int pa_execute_recoursion_limit;
extern int pa_loop_limit;	extern int pa_loop_limit;
	extern int pa_array_limit;
	extern int pa_execute_recoursion_limit;
	extern int pa_httpd_timeout;
	extern size_t pa_file_size_limit;

/// Main workhorse.	/// Main workhorse.
class Request: public PA_Object {	class Request: public PA_Object {
Line 64 public:	Line 87 public:

enum Skip {	enum Skip {
SKIP_NOTHING,	SKIP_NOTHING,
	SKIP_CONTINUE,
SKIP_BREAK,	SKIP_BREAK,
SKIP_CONTINUE	SKIP_RETURN,
	SKIP_INTERRUPTED
};	};

private:	private:
Line 86 private:	Line 111 private:
ArrayOperation& ops() const { return *fops; }	ArrayOperation& ops() const { return *fops; }
VMethodFrame& method_frame() const { return *fmethod_frame; }	VMethodFrame& method_frame() const { return *fmethod_frame; }

/// needed to fill unused Array entries
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 103 private:	Line 126 private:
element_type bottom_value() { return get(bottom_index()); }	element_type bottom_value() { return get(bottom_index()); }

void clear() {	void clear() {
fused=fbottom=0;	fsize=fbottom=0;
}	}

bool is_empty() {	bool is_empty() {
return fused==fbottom;	return fsize==fbottom;
}	}

	Table &table(Request &r);
};	};

///@{ core data	///@{ core data
Line 123 private:	Line 148 private:
Array<String::Body> file_list;	Array<String::Body> file_list;

/// endless execute(execute(... preventing counter	/// endless execute(execute(... preventing counter
uint anti_endless_execute_recoursion;	int anti_endless_execute_recoursion;

///@}	///@}

Line 146 public:	Line 171 public:
/// current connection	/// current connection
SQL_Connection* fconnection;	SQL_Connection* fconnection;
//@}	//@}
/// interrupted flag, raised on signals [SIGPIPE]
bool finterrupted;	private:
Skip fskip;
int fin_cycle;	int fin_cycle;
	Skip fskip;
	VMethodFrame* freturn_method_frame;

public:	public:
uint register_file(String::Body file_spec);	uint register_file(String::Body file_spec);
Line 182 public:	Line 209 public:
/// global classes	/// global classes
HashString<VStateless_class*>& classes() { return fclasses; }	HashString<VStateless_class*>& classes() { return fclasses; }
VStateless_class* get_class(const String& name);	VStateless_class* get_class(const String& name);
	VStateless_class& get_class_ref(const String& name);
void put_class(VStateless_class *aclass){ classes().put(aclass->type(), aclass); }	void put_class(VStateless_class *aclass){ classes().put(aclass->type(), aclass); }
	bool add_class(const char* atype, VStateless_class *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(const char* config_filespec, bool config_fail_on_read_problem, bool header_only);	void core(const char* config_filespec, bool header_only, const String& amain_method_name = main_method_name, const String* amain_class_name = NULL);

/// executes ops	/// executes ops
void execute(ArrayOperation& ops); // execute.C	void execute(ArrayOperation& ops); // execute.C
void call(VMethodFrame &frame);
void call_expression(VMethodFrame &frame);	template<typename Frame> void call(Frame& frame){
void call_write(VMethodFrame &frame);	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);	Value& construct(VStateless_class &class_value, const Method &method);

/// execute ops with anti-recoursion check	/// execute ops with anti-recoursion check
Line 208 public:	Line 261 public:
}	}

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

	/// compiles the file in main class context by default
	void use_file(const String& file_name, const String* use_filespec, bool with_auto_p=false);

/// compiles the file, maybe forcing it's class @a name and @a base_class.	/// for @USE only, calls ^use (which may be user-defined)
void use_file(VStateless_class& aclass, const String& file_name, const String* use_filespec);	void use_file(const String& file_name, const String* use_filespec, Operation::Origin origin);
void use_file(VStateless_class& aclass, 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, const char* source, const String* main_alias, uint file_no, int line_no_offset=0);	void use_buf(VStateless_class& aclass, const char* source, const String* main_alias, uint file_no, int line_no_offset=0);
Line 227 public:	Line 282 public:
return process(input_value).as_string();	return process(input_value).as_string();
}	}
//@}	//@}
const String* get_method_filename(const Method* method); // execute.C	const Operation::Origin get_method_origin(const Method* method); // execute.C
const String* get_used_filename(uint file_no);	const String* get_method_filespec(const Method* method); // execute.C
	const String* get_used_filespec(uint file_no);

/// appending, sure of clean string inside	/// appending string with it's languages
void write_no_lang(const String& astring) {	inline void write(const String& astring) {
wcontext->write(astring,	wcontext->write(astring);
(String::Language)(String::L_CLEAN \| (flang & String::L_OPTIMIZE_BIT) ));	}
}
/// appending sure value, that would be converted to clean string	/// in [] and {} appending string if get_string is not null, else appending value
void write_no_lang(Value& avalue) {	/// in () appending string if is_string, else appending value
if(wcontext->get_in_expression())	inline void write(Value& avalue) {
wcontext->write(avalue);	wcontext->write_as_string(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);
}	}

/// appending sure value	/// allways appending value
void write_value(Value& avalue) {	inline void write_value(Value& avalue) {
wcontext->write(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);

/// returns an absolute @a path to relative @a name	const String& full_disk_path(const String& relative_name);
const String& absolute(const String& relative_name);

/// returns the mime type of 'user_file_name'	/// returns the mime type of 'user_file_name'
const String& mime_type_of(const String* file_name);	const String& mime_type_of(const String* file_name);
Line 276 public:	Line 320 public:
return fconnection;	return fconnection;
}	}

void set_interrupted(bool ainterrupted) { finterrupted=ainterrupted; }
bool get_interrupted() { return finterrupted; }

void set_skip(Skip askip) { fskip=askip; }
Skip get_skip() { return fskip; }	Skip get_skip() { return fskip; }
	void set_skip(Skip askip) { fskip=askip; }
	void set_skip_return(VMethodFrame& amethod_frame) { fskip=SKIP_RETURN; freturn_method_frame=&amethod_frame; }
	inline bool check_skip_break() { bool result=fskip >= SKIP_BREAK; if(fskip <= SKIP_BREAK) fskip=SKIP_NOTHING; return result; }
	inline void check_skip_return() { if(fskip==SKIP_RETURN && method_frame==freturn_method_frame) fskip=SKIP_NOTHING; }

void set_in_cycle(int adelta) { fin_cycle+=adelta; }	void set_in_cycle(int adelta) { fin_cycle+=adelta; }
bool get_in_cycle() { return fin_cycle>0; }	bool get_in_cycle() { return fin_cycle>0; }
Line 322 public: // status read methods	Line 366 public: // status read methods
/// 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);

/// for @main[]	/// for @main[] and parser://method/call
const String* execute_virtual_method(Value& aself, const String& method_name);	const String* execute_method(VStateless_class& aclass, const String& method_name, Value* optional_param = 0);

/// 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]
const String* execute_method(Value& aself, const Method& method, Value* optional_param, bool do_return_string);	bool execute_method_if_exists(VStateless_class& aclass, const String& method_name, Value* optional_param);
	bool execute_auto_method_if_exists(VStateless_class& aclass, const String& method_name, Value* optional_param);

struct Execute_nonvirtual_method_result {
const String* string;
Method* method;
Execute_nonvirtual_method_result(): string(0), method(0) {}
};

Execute_nonvirtual_method_result execute_nonvirtual_method(VStateless_class& aclass, const String& method_name, VString* optional_param, bool do_return_string);
//}	//}

#ifdef XML	#ifdef XML
Line 381 private: // mime types	Line 416 private: // mime types
/// $MAIN:MIME-TYPES	/// $MAIN:MIME-TYPES
Table *mime_types;	Table *mime_types;

private: // lang manipulation

String::Language set_lang(String::Language alang) {
String::Language result=flang;
flang=alang;
return result;
}
void restore_lang(String::Language alang) {
flang=alang;
}

private: // connection manipulation	private: // connection manipulation

SQL_Connection* set_connection(SQL_Connection* aconnection) {	SQL_Connection* set_connection(SQL_Connection* aconnection) {
Line 450 public:	Line 474 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;
Line 490 public:	Line 500 public:
}	}
};	};

	/// Auto-object used for break out of cycle check
	class TempSkip4Delimiter {
	Request& frequest;
	Request::Skip fskip;
	public:
	TempSkip4Delimiter(Request& arequest) : frequest(arequest), fskip(arequest.get_skip()) {
	frequest.set_skip(Request::SKIP_NOTHING);
	}
	// returns true if break required, should be called
	bool check_break() {
	if(frequest.get_skip())
	fskip=frequest.get_skip();
	frequest.set_skip(fskip <= Request::SKIP_BREAK ? Request::SKIP_NOTHING : fskip);
	return fskip >= Request::SKIP_BREAK;
	}
	};

/// Auto-object used for temporary changing Request::allow_class_replace.	/// Auto-object used for temporary changing Request::allow_class_replace.
class Temp_class_replace {	class Temp_class_replace {
Request& frequest;	Request& frequest;
Line 513 public:	Line 540 public:
~Temp_value_element();	~Temp_value_element();
};	};

// defines for externs

#define EXCEPTION_HANDLED_PART_NAME "handled"


// externs

extern const String main_method_name;
extern const String auto_method_name;

extern const String exception_type_part_name;
extern const String exception_source_part_name;
extern const String exception_comment_part_name;
extern const String exception_handled_part_name;

// defines for statics

#define MAIN_CLASS_NAME "MAIN"
#define AUTO_FILE_NAME "auto.p"

#endif	#endif

E-mail:

Removed from v.1.234
changed lines
	Added in v.1.266