parser3/src/classes/op.C - diff

Return to op.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/op.C between versions 1.252 and 1.291

version 1.252, 2019/11/22 22:37:30	version 1.291, 2026/10/31 17:03:23
Line 1	Line 1
/** @file	/** @file
Parser: parser @b operators.	Parser: parser @b operators.

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

#include "classes.h"	#include "classes.h"
Line 17	Line 17
#include "pa_vmethod_frame.h"	#include "pa_vmethod_frame.h"
#include "pa_vclass.h"	#include "pa_vclass.h"
#include "pa_charset.h"	#include "pa_charset.h"
	#include "pa_varray.h"

	#ifdef HAVE_SYSLOG
	#include "syslog.h"
	#endif

volatile const char * IDENT_OP_C="$Id$";	volatile const char * IDENT_OP_C="$Id$";

Line 29 volatile const char * IDENT_OP_C="$Id$";	Line 34 volatile const char * IDENT_OP_C="$Id$";
class VClassMAIN: public VClass {	class VClassMAIN: public VClass {
public:	public:
VClassMAIN();	VClassMAIN();
	/// native methods are copied from the donor
	VClassMAIN(VClassMAIN& donor): VClass(MAIN_CLASS_NAME, 0, &donor) {}
};	};

// defines for statics	// defines for statics
Line 52 static const String exception_var_name(E	Line 59 static const String exception_var_name(E

#define CACHE_EXCEPTION_HANDLED_CACHE_NAME "cache"	#define CACHE_EXCEPTION_HANDLED_CACHE_NAME "cache"

// helpers

class Untaint_lang_name2enum: public HashString<String::Language> {
public:
Untaint_lang_name2enum() {
#define ULN(name, LANG) put(name, (value_type)(String::L_##LANG));
ULN("clean", CLEAN);
ULN("as-is", AS_IS);
ULN("optimized-as-is", AS_IS\|String::L_OPTIMIZE_BIT);
ULN("file-spec", FILE_SPEC);
ULN("http-header", HTTP_HEADER);
ULN("mail-header", MAIL_HEADER);
ULN("uri", URI);
ULN("sql", SQL);
ULN("js", JS);
ULN("xml", XML);
ULN("optimized-xml", XML\|String::L_OPTIMIZE_BIT);
ULN("html", HTML);
ULN("optimized-html", HTML\|String::L_OPTIMIZE_BIT);
ULN("regex", REGEX);
ULN("parser-code", PARSER_CODE);
ULN("json", JSON);
#undef ULN
}
} untaint_lang_name2enum;

// methods	// methods

static void _if(Request& r, MethodParams& params) {	static void _if(Request& r, MethodParams& params) {
Line 96 static void _if(Request& r, MethodParams	Line 77 static void _if(Request& r, MethodParams
r.process_write(params[i]);	r.process_write(params[i]);
}	}

String::Language get_untaint_lang(const String& lang_name){
String::Language lang=untaint_lang_name2enum.get(lang_name);
if(!lang)
throw Exception(PARSER_RUNTIME, &lang_name, "invalid taint language");
return lang;
}

static void _untaint(Request& r, MethodParams& params) {	static void _untaint(Request& r, MethodParams& params) {
String::Language lang;	String::Language lang;
if(params.count()==1)	if(params.count()==1)
lang=String::L_AS_IS; // mark as simply 'as-is'. useful in html from sql	lang=String::L_AS_IS; // mark as simply 'as-is'. useful in html from sql
else	else
lang=get_untaint_lang(params.as_string(0, "lang must be string"));	lang=String::name2lang(params.as_string(0, "lang must be string"));

Value& vbody=params.as_junction(params.count()-1, "body must be code");	Value& vbody=params.as_junction(params.count()-1, "body must be code");
Value& result=r.process(vbody);	Value& result=r.process(vbody);
Line 126 static void _taint(Request& r, MethodPar	Line 100 static void _taint(Request& r, MethodPar
if(params.count()==1)	if(params.count()==1)
lang=String::L_TAINTED; // mark as simply 'tainted'. useful in table:create	lang=String::L_TAINTED; // mark as simply 'tainted'. useful in table:create
else	else
lang=get_untaint_lang(params.as_string(0, "lang must be string"));	lang=String::name2lang(params.as_string(0, "lang must be string"));

{	{
Value& vbody=params.as_no_junction(params.count()-1, "body must not be code");	Value& vbody=params.as_no_junction(params.count()-1, "body must not be code");
Line 137 static void _taint(Request& r, MethodPar	Line 111 static void _taint(Request& r, MethodPar
}	}

static void _apply_taint(Request& r, MethodParams& params) {	static void _apply_taint(Request& r, MethodParams& params) {
String::Language lang=params.count()==1 ? String::L_AS_IS : get_untaint_lang(params.as_string(0, "lang must be string"));	String::Language lang=params.count()==1 ? String::L_AS_IS : String::name2lang(params.as_string(0, "lang must be string"));
const String &sbody=params.as_string(params.count()-1, "body must be string");	const String &sbody=params.as_string(params.count()-1, "body must be string");
String::Body result_body=sbody.cstr_to_string_body_untaint(lang, r.connection(false), &r.charsets);	String::Body result_body=sbody.cstr_to_string_body_untaint(lang, r.connection(false), &r.charsets);
r.write(*new String(result_body, String::L_AS_IS));	r.write(*new String(result_body, String::L_AS_IS));
Line 174 static void _process(Request& r, MethodP	Line 148 static void _process(Request& r, MethodP
size_t options_index=index+1;	size_t options_index=index+1;
if(options_index<params.count())	if(options_index<params.count())
if(HashStringValue* options=params.as_hash(options_index)) {	if(HashStringValue* options=params.as_hash(options_index)) {

int valid_options=0;
for(HashStringValue::Iterator i(*options); i; i.next() ){	for(HashStringValue::Iterator i(*options); i; i.next() ){

String::Body key=i.key();	String::Body key=i.key();
Value* value=i.value();	Value* value=i.value();

if(key == "main") {	if(key == "main") {
valid_options++;
main_alias=&value->as_string();	main_alias=&value->as_string();
} else if(key == "file") {	} else if(key == "file") {
valid_options++;
file_alias=&value->as_string();	file_alias=&value->as_string();
} else if(key == "lineno") {	} else if(key == "lineno") {
valid_options++;
line_no_alias_offset=value->as_int();	line_no_alias_offset=value->as_int();
} else if(key == "replace") {	} else if(key == "replace") {
valid_options++;
allow_class_replace=r.process(*value).as_bool();	allow_class_replace=r.process(*value).as_bool();
}	} else
	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
}	}

if(valid_options!=options->count())
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
}	}

uint processe_file_no=file_alias ? r.register_file(r.absolute(*file_alias)) : pseudo_file_no__process;	uint processe_file_no=file_alias ? r.register_file(r.full_disk_path(*file_alias)) : pseudo_file_no__process;
// process...{string}	// process...{string}
Value& vjunction=params.as_junction(index, "body must be code");	Value& vjunction=params.as_junction(index, "body must be code");
// evaluate source to process	// evaluate source to process
Line 208 static void _process(Request& r, MethodP	Line 172 static void _process(Request& r, MethodP

Temp_class_replace class_replace(r, allow_class_replace);	Temp_class_replace class_replace(r, allow_class_replace);

r.use_buf(*target_class, source.untaint_cstr(String::L_PARSER_CODE, r.connection(false)), main_alias, processe_file_no, line_no_alias_offset);	const char* code=source.untaint_cstr(String::L_PARSER_CODE, r.connection(false));
	// compiler knows only \n (files are normalized on load)
	if(strchr(code, '\r')) {
	size_t length=strlen(code);
	char* normalized=pa_strdup(code, length);
	fix_line_breaks(normalized, length);
	code=normalized;
	}

	r.use_buf(*target_class, code, main_alias, processe_file_no, line_no_alias_offset);

// main_method	// main_method
main_method=target_class->get_method(main_method_name);	main_method=target_class->get_method(main_method_name);
Line 279 static void _while(Request& r, MethodPar	Line 252 static void _while(Request& r, MethodPar
}	}

static void _use(Request& r, MethodParams& params) {	static void _use(Request& r, MethodParams& params) {
Value& vfile=params.as_no_junction(0, FILE_NAME_MUST_NOT_BE_CODE);	const String& file_name=params.as_file_name(0);

bool allow_class_replace=false;
const String* use_origin=0;	const String* use_origin=0;
	bool allow_class_replace=false;
	bool load_auto_p=false;

if(params.count()==2)	if(params.count()==2)
if(HashStringValue* options=params.as_hash(1)) {	if(HashStringValue* options=params.as_hash(1)) {
int valid_options=0;
for(HashStringValue::Iterator i(*options); i; i.next() ){	for(HashStringValue::Iterator i(*options); i; i.next() ){

String::Body key=i.key();	String::Body key=i.key();
Value* value=i.value();	Value* value=i.value();

if(key == "replace") {
valid_options++;
allow_class_replace=r.process(*value).as_bool();
}

if(key == "origin") {	if(key == "origin") {
valid_options++;
use_origin=&value->as_string();	use_origin=&value->as_string();
}	} else if(key == "replace") {
	allow_class_replace=r.process(*value).as_bool();
if(valid_options!=options->count())	} else if(key == "main") {
	load_auto_p=r.process(*value).as_bool();
	} else
throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);	throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
}	}
}	}
Line 313 static void _use(Request& r, MethodParam	Line 280 static void _use(Request& r, MethodParam

Temp_class_replace class_replace(r, allow_class_replace);	Temp_class_replace class_replace(r, allow_class_replace);

r.use_file(r.main_class, vfile.as_string(), use_origin);	r.use_file(file_name, use_origin, load_auto_p);
}	}

static void set_skip(Request& r, Request::Skip askip) {	static void set_skip(Request& r, Request::Skip askip) {
Line 333 static void _continue(Request& r, Method	Line 300 static void _continue(Request& r, Method
static void _return(Request& r, MethodParams& params) {	static void _return(Request& r, MethodParams& params) {
VMethodFrame& caller=*r.get_method_frame()->caller();	VMethodFrame& caller=*r.get_method_frame()->caller();
if(params.count())	if(params.count())
r.put_element(caller, Symbols::RESULT_SYMBOL, &params[0]);	r.put_element(caller, Symbols::RESULT_SYMBOL, &r.process(params[0]));
r.set_skip_return(caller);	r.set_skip_return(caller);
}	}

Line 395 static void _eval(Request& r, MethodPara	Line 362 static void _eval(Request& r, MethodPara
if(fmt.is_empty()){	if(fmt.is_empty()){
r.write(value_result);	r.write(value_result);
} else {	} else {
r.write(String(format(value_result.as_double(), fmt.cstrm())));	r.write(String(format_double(value_result.as_double(), fmt.cstrm())));
}	}
} else	} else
r.write(value_result);	r.write(value_result);
Line 529 public:	Line 496 public:
arequest.set_skip(Request::SKIP_NOTHING);	arequest.set_skip(Request::SKIP_NOTHING);
}	}
~Temp_skip() {	~Temp_skip() {
if(frequest.get_skip() == Request::SKIP_NOTHING)	// the interruption is not restored: if it is not set now, it is already thrown
	if(frequest.get_skip() == Request::SKIP_NOTHING && saved_skip != Request::SKIP_INTERRUPTED)
frequest.set_skip(saved_skip);	frequest.set_skip(saved_skip);
}	}
};	};
Line 540 template<class I>	Line 508 template<class I>
static Try_catch_result try_catch(Request& r, Value& body_code(Request&, I), I info, Value* catch_code, bool could_be_handled_by_caller=false) {	static Try_catch_result try_catch(Request& r, Value& body_code(Request&, I), I info, Value* catch_code, bool could_be_handled_by_caller=false) {
Try_catch_result result;	Try_catch_result result;

// minor bug: context not restored if only finally code is present, see #1062
if(!catch_code) {	if(!catch_code) {
result.processed_code=body_code(r, info);	result.processed_code=body_code(r, info);
return result;	return result;
Line 548 static Try_catch_result try_catch(Reques	Line 515 static Try_catch_result try_catch(Reques

// taking snapshot of try-context	// taking snapshot of try-context
Request_context_saver try_context(r);	Request_context_saver try_context(r);
	size_t trace_start=r.exception_trace.top_index();

try {	try {
result.processed_code=body_code(r, info);	result.processed_code=body_code(r, info);
	} catch(const Uncatchable_exception&) {
	rethrow;
} catch(const Exception& e) {	} catch(const Exception& e) {
Request_context_saver throw_context(r); // remembering exception stack trace	size_t trace_bottom=r.exception_trace.bottom_index();
	size_t trace_top=r.exception_trace.top_index();

Request::Exception_details details=r.get_details(e);	VException& details=*new VException(r, e);

try_context.restore(); // restoring try-context for code after try and catch-code	try_context.restore(); // restoring try-context for catch code
	r.recursion_limit_try_restore(); // here to allow "endless" recursion in catch

{	r.exception_trace.set_bottom_index(trace_top); // keep the original trace occupied; errors in catch start after it
Temp_value_element temp(r, *catch_code->get_junction()->method_frame, exception_var_name, &details.vhash);
Temp_skip temp_skip(r);
result.processed_code=r.process(*catch_code);
}

// retriving $exception.handled
Value* vhandled=details.vhash.hash().get(exception_handled_part_name);

bool bhandled=false;	bool bhandled=false;
if(vhandled) {	try {
if(vhandled->is_string()) { // not simple $exception.handled(1/0)?	{
if(bhandled=could_be_handled_by_caller) { // and we can possibly handle it	Temp_value_element temp(r, *catch_code->get_junction()->method_frame, exception_var_name, &details);
result.exception_should_be_handled=vhandled->get_string(); // considering 'recovered' and let the caller recover	Temp_skip temp_skip(r);
}	result.processed_code=r.process(*catch_code);
} else	}
bhandled=vhandled->as_bool();
	Value* vhandled=details.handled();
	if(vhandled) {
	if(vhandled->is_string()) { // not simple $exception.handled(1/0)?
	if(bhandled=could_be_handled_by_caller) { // and we can possibly handle it
	result.exception_should_be_handled=vhandled->get_string(); // considering 'recovered' and let the caller recover
	}
	} else
	bhandled=vhandled->as_bool();
	}
	} catch(...) {
	try_context.restore(); // restore execution for finally, but keep new error trace.
	r.recursion_limit_try_restore(); // here to allow "endless" recursion in finally
	details.expire_trace();
	rethrow;
}	}

	details.expire_trace();
if(!bhandled){	if(!bhandled){
throw_context.restore(); // restoring exception stack trace creared by try_context.restore()	r.exception_trace.set_range(trace_bottom, trace_top);
rethrow;	rethrow;
}	}

	r.exception_trace.set_range(trace_start, trace_start);
}	}

return result;	return result;
Line 650 static void locked_process_and_cache_put	Line 633 static void locked_process_and_cache_put
} else	} else
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME,
result.exception_should_be_handled,	result.exception_should_be_handled,
"$" EXCEPTION_VAR_NAME "." EXCEPTION_HANDLED_PART_NAME " value must be "	"$" EXCEPTION_VAR_NAME ".handled value must be "
"either boolean or string '" CACHE_EXCEPTION_HANDLED_CACHE_NAME "'");	"either boolean or string '" CACHE_EXCEPTION_HANDLED_CACHE_NAME "'");
} else	} else
info.processed_code=&((Value &)result.processed_code).as_string();	info.processed_code=&((Value &)result.processed_code).as_string();
Line 666 static void locked_process_and_cache_put	Line 649 static void locked_process_and_cache_put
prolog.expires=info.scope->expires;	prolog.expires=info.scope->expires;

// buffer -write> file	// buffer -write> file
write(f, serialized.str, serialized.length);	if(write(f, serialized.str, serialized.length)<0)
	throw Exception("file.write", 0, "write failed: %s (%d)", strerror(errno), errno);
} else // expired!	} else // expired!
info.scope->expires=0; // flag it so that could be easily checked by caller	info.scope->expires=0; // flag it so that could be easily checked by caller
}	}
Line 701 struct Cache_get_result {	Line 685 struct Cache_get_result {
};	};
#endif	#endif

static Cache_get_result cache_get(Request_charsets& charsets, const String& file_spec, time_t now) {	static Cache_get_result cache_get(const String& file_spec, time_t now) {
Cache_get_result result={0, false};	Cache_get_result result={0, false};

File_read_result file=file_read(charsets, file_spec, false /as_text/, 0, /no params/ false /fail_on_read_problem/);	File_read_result file=file_read_binary(file_spec, false /fail_on_read_problem/);
if(file.success && file.length /ignore reads which are empty due to non-unary open+lockEX conflict with lockSH/) {	if(file.success && file.length /ignore reads which are empty due to non-unary open+lockEX conflict with lockSH/) {

Data_string_serialized_prolog& prolog = reinterpret_cast<Data_string_serialized_prolog >(file.str);	Data_string_serialized_prolog& prolog = reinterpret_cast<Data_string_serialized_prolog >(file.str);
Line 723 static Cache_get_result cache_get(Reques	Line 707 static Cache_get_result cache_get(Reques

static time_t as_expires(Request& r, MethodParams& params, int index, time_t now) {	static time_t as_expires(Request& r, MethodParams& params, int index, time_t now) {
time_t result;	time_t result;
if(Value* vdate=params[index].as(VDATE_TYPE))	if(VDate* vdate=dynamic_cast<VDate*>(&params[index]))
result=(time_t)(static_cast<VDate*>(vdate)->get_time());	result=(time_t)vdate->get_time();
else	else
result=now+(time_t)params.as_double(index, "lifespan must be date or number", r);	result=now+(time_t)params.as_double(index, "lifespan must be date or number", r);

Line 732 static time_t as_expires(Request& r, Met	Line 716 static time_t as_expires(Request& r, Met
}	}

static const String& as_file_spec(Request& r, MethodParams& params, int index) {	static const String& as_file_spec(Request& r, MethodParams& params, int index) {
return r.absolute(params.as_string(index, "filespec must be string"));	return r.full_disk_path(params.as_string(index, "filespec must be string"));
}	}

static void _cache(Request& r, MethodParams& params) {	static void _cache(Request& r, MethodParams& params) {
Line 783 static void _cache(Request& r, MethodPar	Line 767 static void _cache(Request& r, MethodPar
catch_code=&params.as_junction(3, "catch_code must be code");	catch_code=&params.as_junction(3, "catch_code must be code");

if(scope.expires>now) {	if(scope.expires>now) {
Cache_get_result cached=cache_get(r.charsets, file_spec, now);	Cache_get_result cached=cache_get(file_spec, now);

if(cached.body) { // have cached copy	if(cached.body) { // have cached copy
if(cached.expired) {	if(cached.expired) {
Line 832 static void _try_operator(Request& r, Me	Line 816 static void _try_operator(Request& r, Me
try{	try{
// process try and catch code	// process try and catch code
result=try_catch(r, process_try_body_code, &body_code, &catch_code);	result=try_catch(r, process_try_body_code, &body_code, &catch_code);
	} catch(const Uncatchable_exception&) {
	rethrow;
} catch(...){	} catch(...){
// process finally code but ignore the result	// process finally code but ignore the result
if(finally_code){	if(finally_code){
	size_t trace_bottom=r.exception_trace.bottom_index();
	size_t trace_top=r.exception_trace.top_index();
	r.exception_trace.set_bottom_index(trace_top);
Temp_skip temp(r);	Temp_skip temp(r);
/* Value &finally_result= / r.process(finally_code);	/* Value &finally_result= / r.process(finally_code);
	r.exception_trace.set_range(trace_bottom, trace_top);
}	}
rethrow;	rethrow;
}	}
Line 855 static void _try_operator(Request& r, Me	Line 845 static void _try_operator(Request& r, Me
// no exception in try/catch, writing processed body_code or catch_code	// no exception in try/catch, writing processed body_code or catch_code
r.write(result.processed_code);	r.write(result.processed_code);
}	}

}	}

static void _throw_operator(Request&, MethodParams& params) {	static void _throw_operator(Request&, MethodParams& params) {
if(params.count()==1 && !params[0].is_string()) {	if(params.count()==1 && !params[0].is_string()) {
if(HashStringValue *hash=params[0].get_hash()) {	if(HashStringValue *hash=params[0].get_hash()) {
const char* type=0;	const char* type=0;
if(Value* value=hash->get(exception_type_part_name))	if(Value* value=hash->get(Symbols::TYPE_SYMBOL))
type=value->as_string().cstr();	type=value->as_string().cstr();
const String* source=0;	const String* source=0;
if(Value* value=hash->get(exception_source_part_name))	if(Value* value=hash->get(Symbols::SOURCE_SYMBOL))
source=&value->as_string();	source=&value->as_string();
const char* comment=0;	const char* comment=0;
if(Value* value=hash->get(exception_comment_part_name))	if(Value* value=hash->get(Symbols::COMMENT_SYMBOL))
comment=value->as_string().cstr();	comment=value->as_string().cstr();

throw Exception(type,	throw Exception(type, source, "%s", comment); // to avoid MAX_STRING limit
source?source:0,
"%s", comment?comment:"");
} else	} else
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "one-param version has hash or string param");
0,
"one-param version has hash or string param");
} else {	} else {
const char* type=params.as_string(0, "type must be string").cstr();	const char* type=params.as_string(0, "type must be string").cstr();
const String* source=params.count()>1? &params.as_string(1, "source must be string"):0;	const String* source=params.count()>1 ? &params.as_string(1, "source must be string") : 0;
const char* comment=params.count()>2? params.as_string(2, "comment must be string").cstr():0;	const char* comment=params.count()>2 ? params.as_string(2, "comment must be string").cstr() : 0;
throw Exception(type, source, "%s", comment?comment:"");	throw Exception(type, source, "%s", comment); // to avoid MAX_STRING limit
}	}
}	}

static void _sleep_operator(Request& r, MethodParams& params) {	static void _sleep_operator(Request& r, MethodParams& params) {
double seconds=params.as_double(0, "seconds must be double", r);	double seconds=params.as_double(0, "seconds must be double", r);
if(seconds>0)	// sleeping by ticks to notice the interruption
pa_sleep((int)trunc(seconds), (int)trunc((seconds-trunc(seconds))*1000000));	for(double tick; seconds>0 && !r.get_skip(); seconds-=tick){
}	tick=seconds<0.1 ? seconds : 0.1;
	pa_sleep(0, (unsigned long)(tick*1000000));
	}
	}

	static void _a_operator(Request& r, MethodParams& params) {
	VArray& result=*new VArray;
	ArrayValue& array=result.array();

#if defined(WIN32) && defined(_DEBUG)	int count=params.count();
	for(int i=0; i<count; i++)
	array+=&r.process(params[i]);
	array.confirm_all_used();

	r.write(result);
	}

	#ifdef HAVE_SYSLOG
	static int log_level(const String &name){
	if(name.is_empty()) return LOG_INFO;
	const char *sname = str_upper(name.cstr());

	if(!strcmp(sname,"INFO")) return LOG_INFO;
	if(!strcmp(sname,"WARNING")) return LOG_WARNING;
	if(!strcmp(sname,"ERROR")) return LOG_ERR;
	if(!strcmp(sname,"DEBUG")) return LOG_DEBUG;
	throw Exception("syslog", &name, "invalid log level value");
	}
	#endif

	static void _syslog_operator(Request& r, MethodParams& params) {
	const char* message=params.as_string(1, "message must be string").cstr();
	#ifdef HAVE_SYSLOG
	const char* ident=params.as_string(0, "ident must be string").cstr();
	int level=params.count()>2 ? log_level(params.as_string(2, "level must be string")) : LOG_INFO;

	openlog(*ident ? ident : "parser3", LOG_PID, LOG_USER);
	syslog(level, "%s", message);
	closelog();
	(void)r;
	#else
	SAPI::log(r.sapi_info, "syslog: %s", message);
	#endif
	}

	#if defined(WIN32) && defined(_DEBUG) && !defined(_WIN64)
# define PA_BPT	# define PA_BPT
static void _bpt(Request&, MethodParams&) {	static void _bpt(Request&, MethodParams&) {
_asm int 3;	_asm int 3;
Line 980 VClassMAIN::VClassMAIN(): VClass(MAIN_CL	Line 1008 VClassMAIN::VClassMAIN(): VClass(MAIN_CL
add_native_method("throw", Method::CT_ANY, _throw_operator, 1, 3);	add_native_method("throw", Method::CT_ANY, _throw_operator, 1, 3);

add_native_method("sleep", Method::CT_ANY, _sleep_operator, 1, 1);	add_native_method("sleep", Method::CT_ANY, _sleep_operator, 1, 1);

	// equivalent to ^array::create[...]
	add_native_method("A", Method::CT_ANY, _a_operator, 0, 10000, Method::CO_WITHOUT_FRAME);

	// ^syslog[ident;message[;info\|warning\|error\|debug]]
	add_native_method("syslog", Method::CT_ANY, _syslog_operator, 2, 3);
}	}

// constructor & configurator	// constructor & configurator

VStateless_class& VClassMAIN_create() {	VStateless_class& VClassMAIN_create() {
return *new VClassMAIN;	// adding native methods from a singleton
	static VClassMAIN* prototype=new VClassMAIN;
	return new VClassMAIN(prototype);
}	}

E-mail:

Removed from v.1.252
changed lines
	Added in v.1.291