Return to pa_request.h CVS log

Up to [parser3project] / parser3 / src / include

execute.C compiled

/** @file
	Parser: request class decl.

	Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/

#ifndef PA_REQUEST_H
#define PA_REQUEST_H

static const char* IDENT_REQUEST_H="$Date: 2003/03/21 14:27:51 $";

#include "pa_request_info.h"
#include "pa_hash.h"
#include "pa_wcontext.h"
#include "pa_value.h"
#include "pa_stack.h"
#include "pa_request_info.h"
#include "pa_request_charsets.h"
#include "pa_sapi.h"

#ifdef RESOURCES_DEBUG
#include <sys/resource.h>
#endif

// consts

const uint ANTI_ENDLESS_EXECUTE_RECOURSION=1000;

// forwards

class Temp_lang;
class Methoded;
class VMethodFrame;
class GdomeDOMString_auto_ptr;
class VMail; DECLARE_OBJECT_PTR(VMail);
class VForm; DECLARE_OBJECT_PTR(VForm);
class VResponse; DECLARE_OBJECT_PTR(VResponse);
class VCookie; DECLARE_OBJECT_PTR(VCookie);
class VStateless_class; DECLARE_OBJECT_PTR(VStateless_class);

/// Main workhorse.
class Request: public PA_Object {
	friend class Temp_lang;
	friend class Temp_connection;
	friend class Request_context_saver;
	friend class Temp_request_self;

	///@{ core data

	/// classes
	HashStringValue fclasses;

	/// already used files to avoid cyclic uses
	Hash<String* , bool> used_files;

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

	///@}

public:

	union StackItem {
		const String* string() const { return value->get_string(); }
		Value* value;
		ArrayOperation* ops;
		VMethodFrame* method_frame;

		/// needed to fill unused Array entries
		StackItem() {}
		StackItem(Value* avalue): value(avalue) {}		
		StackItem(ArrayOperation* aops): ops(aops) {}
		StackItem(VMethodFrame* amethod_frame): method_frame(amethod_frame) {}
	};

	//@{ request processing status
	/// exception stack trace
	Stack<String*> exception_trace;
	/// execution stack
	Stack<StackItem> stack;
	/// contexts
	VMethodFrame* method_frame;
	Value* rcontext;
	WContext* wcontext;
	/// current language
	String::Language flang; 
	/// current connection
	SQL_Connection* fconnection;
	//@}
	/// interrupted flag, raised on signals [SIGPIPE]
	bool finterrupted;

public:

#ifdef RESOURCES_DEBUG
	/// measures
	double sql_connect_time;
	double sql_request_time;
#endif	

	Request(SAPI_Info& asapi_info, Request_info& arequest_info,
		String::Language adefault_lang, ///< all tainted data default untainting lang
		bool status_allowed ///<  status class allowed
	);
	~Request();

	/// global classes
	HashStringValue& classes() { return fclasses; }

	/**
		core request processing

		BEWARE: may throw exception to you: catch it!
	*/
	void core(
		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
	void execute(ArrayOperation& ops); // execute.C
	/// execute ops with anti-recoursion check
	void recoursion_checked_execute(/*const String& name, */ArrayOperation& 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",
				0, //&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.
	void use_file(VStateless_class& aclass,
		const String& file_name, 
		bool ignore_class_path=false, 
		bool fail_on_read_problem=true, bool fail_on_file_absence=true); // pa_request.C
	/// compiles a @a source buffer
	void use_buf(VStateless_class& aclass,
		const char* source, 
		const String& filespec, const char* filespec_cstr); // pa_request.C

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

	
#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()); \
	}

	/// appending, sure of clean string inside
	void write_no_lang(const String& astring) {
		wcontext->write(astring, 
			(String::Language)(String::L_CLEAN | flang&String::L_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::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 
	const String& relative(const char* apath, const String& relative_name);

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

	/// returns the mime type of 'user_file_name_cstr'
	const String& mime_type_of(const char* user_file_name_cstr);

	/// returns current SQL connection if any
	SQL_Connection* connection(const String* source) { 
		if(!fconnection && source)
			throw Exception("parser.runtime",
				source,
				"outside of 'connect' operator");

		return fconnection; 
	}

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

public:
	
	/// info from web server
	Request_info& request_info;

	/// info about ServerAPI
	SAPI_Info& sapi_info;

	/// source, client, mail charsets
	Request_charsets charsets;

	/// 'MAIN' class conglomerat & operators are methods of this class
	VStateless_class& main_class;
	/// $form:elements
	VForm& form;
	/// $mail
	VMail& mail;
	/// $response:elements
	VResponse& response;
	/// $cookie:elements
	VCookie& cookie;

	/// classes configured data
	HashStringObject classes_conf;

public: // status read methods

	VMethodFrame *get_method_frame() { return method_frame; }
	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() {
		return *static_cast<T*>(get_self().get());
	}
	*/

#ifdef XML
public: // charset helpers

	/// @see Charset::transcode
	GdomeDOMString_auto_ptr transcode(const String& s);
	/// @see Charset::transcode
	const String& transcode(GdomeDOMString* s
#ifndef NO_STRING_ORIGIN
		, const String& origin
#endif
		);
	/// @see Charset::transcode
	const String& transcode(xmlChar* s
#ifndef NO_STRING_ORIGIN
		, const String& origin
#endif
		);

#endif

private:

	/// already executed some @conf method
	bool configure_admin_done;

	void configure_admin(VStateless_class& conf_class, const String* source);

private: // compile.C

	VStateless_class& real_compile(VStateless_class* aclass, const char* source, const char* file);

private: // execute.C

	/// for @postprocess[body]
	const String& execute_method(VMethodFrame& amethodFrame, const Method& method);
	//{ for @conf[filespec] and @auto[filespec]
	const String* execute_method(Value& aself, 
		const Method& method, VString* optional_param,
		bool do_return_string);
	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);
	//}
	/// for @main[]
	const String* execute_virtual_method(Value& aself, const String& method_name);

	Value* get_element(bool can_call_operator);

private: // defaults

	const String::Language fdefault_lang;

private: // mime types

	/// $MAIN: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

	SQL_Connection* set_connection(SQL_Connection* aconnection) {
		SQL_Connection* result=fconnection;
		fconnection=aconnection;
		return result;
	}
	void restore_connection(SQL_Connection* aconnection) {
		fconnection=aconnection;
	}

private:

	void output_result(VFile* body_file, bool header_only, bool as_attachment);
};

/// Auto-object used to save request context across ^try body
class Request_context_saver {
	Request& fr;

	/// exception stack trace
	int exception_trace;
	/// execution stack
	int stack;
	/// contexts
	VMethodFrame *method_frame;
	Value *rcontext;
	WContext *wcontext;
	/// current language
	String::Language flang; 
	/// current connection
	SQL_Connection* fconnection;

public:
	Request_context_saver(Request& ar) : 
		exception_trace(ar.exception_trace.top_index()),	
		stack(ar.stack.top_index()),
		method_frame(ar.method_frame),
		rcontext(ar.rcontext),
		wcontext(ar.wcontext),
		flang(ar.flang),
		fconnection(ar.fconnection),
		fr(ar) {}
	void restore() {
		fr.exception_trace.top_index(exception_trace);
		fr.stack.top_index(stack);
		fr.method_frame=method_frame, fr.rcontext=rcontext; fr.wcontext=wcontext;
		fr.flang=flang;
		fr.fconnection=fconnection;
	}
};

///	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.
class Temp_connection {
	Request& frequest;
	SQL_Connection* saved_connection;
public:
	Temp_connection(Request& arequest, SQL_Connection* aconnection) : 
		frequest(arequest),
		saved_connection(arequest.set_connection(aconnection)) {
	}
	~Temp_connection() { 
		frequest.restore_connection(saved_connection); 
	}
};


// defines for externs

#define CONTENT_DISPOSITION_NAME "content-disposition"
#define CONTENT_DISPOSITION_VALUE "attachment"
#define CONTENT_DISPOSITION_FILENAME_NAME "filename"

// externs

extern const String& main_method_name;
extern const String& auto_method_name;
extern const String& body_name;
extern const String& content_disposition_name;
extern const String& content_disposition_value;
extern const String& content_disposition_filename_name;

// defines for statics

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

#endif