--- parser3/src/include/pa_request.h	2001/04/06 10:32:18	1.78
+++ parser3/src/include/pa_request.h	2003/10/21 04:45:19	1.166
@@ -1,76 +1,182 @@
 /** @file
 	Parser: request class decl.
 
-	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
-
-	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
-
-	$Id: pa_request.h,v 1.78 2001/04/06 10:32:18 paf Exp $
+	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
 
-#include "pa_pool.h"
+static const char* IDENT_REQUEST_H="$Date: 2003/10/21 04:45:19 $";
+
 #include "pa_hash.h"
 #include "pa_wcontext.h"
 #include "pa_value.h"
 #include "pa_stack.h"
-#include "pa_vclass.h"
-#include "pa_vobject.h"
-#include "pa_venv.h"
-#include "pa_vform.h"
-#include "pa_vrequest.h"
-#include "pa_vresponse.h"
-#include "pa_vcookie.h"
-#include "pa_sql_driver_manager.h"
-
-#ifndef NO_STRING_ORIGIN
-#	define COMPILE_PARAMS  \
-		const char *source, \
-		VStateless_class *aclass, const String *name, \
-		VStateless_class *base_class, \
-		const char *file
-#	define COMPILE(source, aclass, name, base_class, file)  \
-		real_compile(source, aclass, name, base_class, file)
-#else
-#	define COMPILE_PARAMS  \
-		const char *source, \
-		VStateless_class *aclass, const String *name, \
-		VStateless_class *base_class
-#	define COMPILE(source, aclass, name, base_class, file)  \
-		real_compile(source, aclass, name, base_class)
+#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;
+const size_t pseudo_file_no__process=1;
+
+// forwards
+
 class Temp_lang;
+class Methoded;
+class VMethodFrame;
+class GdomeDOMString_auto_ptr;
+class VMail;
+class VForm;
+class VResponse;
+class VCookie;
+class VStateless_class;
 
 /// Main workhorse.
-class Request : public Pooled {
-	friend Temp_lang;
+class Request: public PA_Object {
+	friend class Temp_lang;
+	friend class Temp_connection;
+	friend class Request_context_saver;
+	friend class Temp_request_self;
+	friend class Exception_trace;
+
 public:
+	class Trace {
+		const String* fname;
+		Operation::Origin forigin;
+	public:
+		Trace(): fname(0) {}
+		void clear() { fname=0; }
+		operator bool() const { return fname!=0; }
 
-	/// some information from web server
-	class Info {
+		Trace(const String* aname, const Operation::Origin aorigin):
+			fname(aname), forigin(aorigin) {}
+
+		const String* name() const { return fname; }
+		const Operation::Origin origin() const { return forigin; }
+	};
+
+
+private:
+	union StackItem {
+		Value* fvalue;
+		ArrayOperation* fops;
+		VMethodFrame* fmethod_frame;
 	public:
-		const char *document_root;
-		const char *path_translated;
-		const char *method;
-		const char *query_string;
-		const char *uri;
-		const char *content_type;
-		size_t content_length;
-		const char *cookie;
-		const char *user_agent;
+		Value& value() const { return *fvalue; }
+		const String& string() const { 
+			const String* result=fvalue->get_string();
+			assert(result);
+			return *result; 
+		}
+		ArrayOperation& ops() const { return *fops; }
+		VMethodFrame& method_frame() const { return *fmethod_frame; }
+
+		/// needed to fill unused Array entries
+		StackItem() {}
+		StackItem(Value& avalue): fvalue(&avalue) {}		
+		StackItem(ArrayOperation& aops): fops(&aops) {}
+		StackItem(VMethodFrame& amethod_frame): fmethod_frame(&amethod_frame) {}
 	};
-	
-	Request(Pool& apool,
-		Info& ainfo,
-		String::Untaint_lang adefault_lang ///< all tainted data default untainting lang
+
+	class Exception_trace: public Stack<Trace> {
+		size_t fbottom;
+	public:
+		Exception_trace(): fbottom(0) {}
+
+		size_t bottom_index() { return fbottom; }
+		void set_bottom_index(size_t abottom) { fbottom=abottom; }
+		element_type bottom_value() { return get(bottom_index()); }
+
+		void clear() {
+			ftop=fbottom=0;
+		}
+
+		bool is_empty() {
+			return ftop==fbottom;
+		}
+
+		const element_type extract_origin(const String*& problem_source);
+	};
+
+	///@{ core data
+
+	/// classes
+	HashStringValue fclasses;
+
+	/// already used files to avoid cyclic uses
+	Hash<const String::Body, bool> used_files;
+	/// list of all used files, Operation::file_no = index to it
+	Array<String::Body> file_list;
+
+	/**	endless execute(execute(... preventing counter 
+		@see ANTI_ENDLESS_EXECUTE_RECOURSION
+	*/
+	uint anti_endless_execute_recoursion;
+
+	///@}
+
+	/// execution stack
+	Stack<StackItem> stack;
+
+	/// exception stack trace
+	Exception_trace exception_trace;
+public:
+
+	//@{ request processing status
+	/// 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:
+	size_t register_file(String::Body file_spec);
+
+	struct Exception_details {
+		const Trace trace;
+		const String* problem_source;
+		VHash& vhash;
+
+		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);
+
+	/// @see Stack::wipe_unused
+	void wipe_unused_execution_stack() {
+		stack.wipe_unused();
+	}
+
+#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() {}
+	~Request();
 
 	/// global classes
-	Hash& classes() { return fclasses; }
+	HashStringValue& classes() { return fclasses; }
 
 	/**
 		core request processing
@@ -78,152 +184,286 @@ public:
 		BEWARE: may throw exception to you: catch it!
 	*/
 	void core(
-		const char *root_auto_path, ///< path to system auto.p file
-		bool root_auto_fail, ///< fail if system auto.p file not found
-		const char *site_auto_path, ///< path to site auto.p file
-		bool site_auto_fail, ///< fail if site auto.p file not found
+		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(const Array& 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.
-	VStateless_class *use_file(
-		const String& file_spec, bool fail_on_read_problem=true,
-		const String *name=0, 
-		VStateless_class *base_class=0); // core.C
+	void use_file(VStateless_class& aclass,
+		const String& file_name, 
+		const String* main_alias=0,
+		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
-	VStateless_class *use_buf(
-		const char *source, const char *file,
-		VStateless_class *aclass=0, const String *name=0, 
-		VStateless_class *base_class=0); // core.C
+	void use_buf(VStateless_class& aclass,
+		const char* source, 
+		const String* main_alias,
+		uint file_no); // pa_request.C
+
 	/// processes any code-junction there may be inside of @a value
-	Value& process(
-		Value& value, 
-		const String *name=0,
-		bool intercept_string=true); // execute.C
+	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::UL_CLEAN);
+		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::UL_PASS_APPENDED); 
-	}
-	/// appending possible string, assigning untaint language
-	void write_assign_lang(Value& avalue) {
-		wcontext->write(avalue, flang); 
+		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::UL_PASS_APPENDED); 
+		wcontext->write(avalue, String::L_PASS_APPENDED); 
 	}
-	/// appending sure value, that would be converted to clean string
-	void write_no_lang(Value& avalue) {
-		wcontext->write(avalue, String::UL_CLEAN);
+	DEFINE_DUAL(pass)
+
+	/// appending possible string, assigning untaint language
+	void write_assign_lang(Value& avalue) {
+		wcontext->write(avalue, flang); 
 	}
-	/// appending sure value, not VString
-	void write_expr_result(Value& avalue) {
-		wcontext->write(avalue); 
+	/// appending string, assigning untaint language
+	void write_assign_lang(const String& astring) {
+		wcontext->write(astring, flang); 
 	}
-
-	/// handy is-value-a-junction ensurer
-	void fail_if_junction_(bool is, Value& value, 
-		const String& method_name, const char *msg);
+	DEFINE_DUAL(assign)
 
 	/// 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& 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(bool fail_on_error=true) { 
+		if(fail_on_error && !fconnection)
+			throw Exception("parser.runtime",
+				0,
+				"outside of 'connect' operator");
+
+		return fconnection; 
+	}
+
+	void set_interrupted(bool ainterrupted) { finterrupted=ainterrupted; }
+	bool get_interrupted() { return finterrupted; }
+
 public:
 	
 	/// info from web server
-	Info& info;
+	Request_info& request_info;
 
-	/// operators are methods of this class
-	VClass OP;
-	/// $env:fields here
-	VEnv env;
-	/// $form:elements here
-	VForm form;
-	/// $request:elements here
-	VRequest request;
-	/// $response:
-	VResponse response;
-	/// $cookie:
-	VCookie cookie;
+	/// info about ServerAPI
+	SAPI_Info& sapi_info;
 
-	/// $MAIN:MIME-TYPES
-	Table *mime_types;
+	/// source, client, mail charsets
+	Request_charsets charsets;
 
-	/// contexts
-	Value *self, *root, *rcontext;
-	/// contexts
-	WContext *wcontext;
+	/// '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
 
-	/// connection
-	SQL_Connection *connection;
-	/// table of protocol's libraries. read from $SQL:drivers
-	Table *protocol2library;
+	template<typename T> T& get_self() {
+		return *static_cast<T*>(get_self().get());
+	}
+	*/
 
-private: // core data
+#ifdef XML
+public: // charset helpers
 
-	// classes
-	Hash fclasses;
+	/// @see Charset::transcode
+	GdomeDOMString_auto_ptr transcode(const String& s);
+	/// @see Charset::transcode
+	GdomeDOMString_auto_ptr transcode(const String::Body s);
+	/// @see Charset::transcode
+	const String& transcode(GdomeDOMString* s);
+	/// @see Charset::transcode
+	const String& transcode(xmlChar* s);
 
-	// already used files to avoid cyclic uses
-	Hash used_files;
+#endif
 
-	// execution stack
-	Stack stack;
+private:
+
+	/// already executed some @conf method
+	bool configure_admin_done;
+
+	void configure_admin(VStateless_class& conf_class);
 
 private: // compile.C
 
-	VStateless_class& real_compile(COMPILE_PARAMS);
+	VStateless_class& compile(VStateless_class* aclass, 
+		const char* source, const String* main_alias, 
+		uint file_no);
 
 private: // execute.C
 
-	const String *execute_method(Value& aself, const Method& method, 
-		bool return_cstr=true);
-	const String *execute_method(Value& aself, const String& method_name, 
-		bool return_cstr=true);
-
-	Value *get_element();
+	/// for @postprocess[body]
+	StringOrValue 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);
 
-private: // lang&raw 
-	
-	String::Untaint_lang flang;
+	Value& get_element(Value& ncontext, const String& name, bool can_call_operator);
 
 private: // defaults
 
-	const String::Untaint_lang fdefault_lang;
-	Value *default_content_type;
+	const String::Language fdefault_lang;
+
+private: // mime types
+
+	/// $MAIN:MIME-TYPES
+	Table *mime_types;
 
 private: // lang manipulation
 
-	String::Untaint_lang set_lang(String::Untaint_lang alang) {
-		String::Untaint_lang result=flang;
+	String::Language set_lang(String::Language alang) {
+		String::Language result=flang;
 		flang=alang;
 		return result;
 	}
-	void restore_lang(String::Untaint_lang alang) {
+	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(const VFile& body_file, bool header_only);
+	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
+	size_t exception_trace_top;
+	size_t exception_trace_bottom;
+	/// execution stack
+	size_t stack;
+	uint anti_endless_execute_recoursion;
+	/// 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_top(ar.exception_trace.top_index()),	
+		exception_trace_bottom(ar.exception_trace.bottom_index()),	
+		stack(ar.stack.top_index()),
+		anti_endless_execute_recoursion(ar.anti_endless_execute_recoursion),
+		method_frame(ar.method_frame),
+		rcontext(ar.rcontext),
+		wcontext(ar.wcontext),
+		flang(ar.flang),
+		fconnection(ar.fconnection),
+		fr(ar) {}
+	void restore() {
+		fr.exception_trace.set_top_index(exception_trace_top);
+		fr.exception_trace.set_bottom_index(exception_trace_bottom);
+		fr.stack.set_top_index(stack);
+		fr.anti_endless_execute_recoursion=anti_endless_execute_recoursion;
+		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::Untaint_lang saved_lang;
+	String::Language saved_lang;
 public:
-	Temp_lang(Request& arequest, String::Untaint_lang alang) : 
+	Temp_lang(Request& arequest, String::Language alang) : 
 		frequest(arequest),
 		saved_lang(arequest.set_lang(alang)) {
 	}
@@ -232,4 +472,44 @@ public:
 	}
 };
 
+///	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;
+
+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