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.190 and 1.221

version 1.190, 2009/07/06 12:13:30	version 1.221, 2015/09/22 23:37:44
Line 1	Line 1
/** @file	/** @file
Parser: parser @b operators.	Parser: parser @b operators.

Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2012 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)
*/	*/

static const char * const IDENT_OP_C="$Date$";

#include "classes.h"	#include "classes.h"
#include "pa_vmethod_frame.h"	#include "pa_vmethod_frame.h"

Line 20 static const char * const IDENT_OP_C="$D	Line 18 static const char * const IDENT_OP_C="$D
#include "pa_vclass.h"	#include "pa_vclass.h"
#include "pa_charset.h"	#include "pa_charset.h"

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

// limits	// limits

#define MAX_LOOPS 20000	#define MAX_LOOPS 20000
Line 27 static const char * const IDENT_OP_C="$D	Line 27 static const char * const IDENT_OP_C="$D
// defines	// defines

#define CASE_DEFAULT_VALUE "DEFAULT"	#define CASE_DEFAULT_VALUE "DEFAULT"
#define PROCESS_MAIN_OPTION_NAME "main"
#define PROCESS_FILE_OPTION_NAME "file"
#define PROCESS_LINENO_OPTION_NAME "lineno"

// class	// class

Line 38 public:	Line 35 public:
VClassMAIN();	VClassMAIN();
};	};

// defines for globals

#define CYCLE_DATA_NAME "CYCLE-DATA"

// globals

//^for & co
String cycle_data_name(CYCLE_DATA_NAME);

// defines for statics	// defines for statics

#define SWITCH_DATA_NAME "SWITCH-DATA"	#define SWITCH_DATA_NAME "SWITCH-DATA"
Line 75 public:	Line 63 public:
Untaint_lang_name2enum() {	Untaint_lang_name2enum() {
#define ULN(name, LANG) \	#define ULN(name, LANG) \
put(String::Body(name), (value_type)(String::L_##LANG));	put(String::Body(name), (value_type)(String::L_##LANG));
	ULN("clean", CLEAN);
ULN("as-is", AS_IS);	ULN("as-is", AS_IS);
ULN("optimized-as-is", AS_IS\|String::L_OPTIMIZE_BIT);	ULN("optimized-as-is", AS_IS\|String::L_OPTIMIZE_BIT);
ULN("file-spec", FILE_SPEC);	ULN("file-spec", FILE_SPEC);
Line 88 public:	Line 77 public:
ULN("html", HTML);	ULN("html", HTML);
ULN("optimized-html", HTML\|String::L_OPTIMIZE_BIT);	ULN("optimized-html", HTML\|String::L_OPTIMIZE_BIT);
ULN("regex", REGEX);	ULN("regex", REGEX);
	ULN("parser-code", PARSER_CODE);
	ULN("json", JSON);
#undef ULN	#undef ULN
}	}
} untaint_lang_name2enum;	} untaint_lang_name2enum;
Line 95 public:	Line 86 public:
// methods	// methods

static void _if(Request& r, MethodParams& params) {	static void _if(Request& r, MethodParams& params) {
bool condition=params.as_bool(0, "condition must be expression", r);	size_t max_param=params.count()-1;
if(condition)	size_t i=0;
r.process_write(*params.get(1));	do {
else if(params.count()>2)	bool condition=params.as_bool(i, "condition must be expression", r);
r.process_write(*params.get(2));	if(condition) {
	r.process_write(*params.get(i+1));
	return;
	}
	i+=2;
	} while (i < max_param);

	if(i == max_param)
	r.process_write(*params.get(i));
}	}

static String::Language get_untaint_lang(MethodParams& params, int index){	String::Language get_untaint_lang(const String& lang_name){
const String& lang_name=params.as_string(index, "lang must be string");
String::Language lang=untaint_lang_name2enum.get(lang_name);	String::Language lang=untaint_lang_name2enum.get(lang_name);
if(!lang)	if(!lang)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, &lang_name, "invalid taint language");
&lang_name,
"invalid taint language");
return lang;	return lang;
}	}

Line 117 static void _untaint(Request& r, MethodP	Line 113 static void _untaint(Request& r, MethodP
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, 0);	lang=get_untaint_lang(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");

StringOrValue result;	Temp_lang temp_lang(r, lang); // set temporarily specified ^untaint[language;
{	StringOrValue result=r.process(vbody); // process marking tainted with that lang
Temp_lang temp_lang(r, lang); // set temporarily specified ^untaint[language;
result=r.process(vbody); // process marking tainted with that lang
}
r.write_assign_lang(result);	r.write_assign_lang(result);
}	}
}	}
Line 136 static void _taint(Request& r, MethodPar	Line 129 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, 0);	lang=get_untaint_lang(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");

String result;	String result(vbody.as_string(), lang); // force result language to specified
result.append(
vbody.as_string(), // process marking tainted with that lang
lang, true); // force result language to specified
r.write_assign_lang(result);	r.write_assign_lang(result);
}	}
}	}

	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"));
	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);
	r.write_pass_lang(*new String(result_body, String::L_AS_IS));
	}

static void _process(Request& r, MethodParams& params) {	static void _process(Request& r, MethodParams& params) {
Method* main_method;	Method* main_method;

Line 162 static void _process(Request& r, MethodP	Line 159 static void _process(Request& r, MethodP
}	}

{	{
VStateless_class *target_class=target_self->get_last_derived_class();	VStateless_class *target_class=target_self->get_class();
if(!target_class)	if(!target_class)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME,
0,	0,
"no target class");	"no target class");

// temporary remove language change	// temporary remove language change
Temp_lang temp_lang(r, String::L_PASS_APPENDED);	Temp_lang temp_lang(r, String::L_PARSER_CODE);
// temporary zero @main so to maybe-replace it in processed code	// temporary zero @main so to maybe-replace it in processed code
Temp_method temp_method_main(*target_class, main_method_name, 0);	Temp_method temp_method_main(*target_class, main_method_name, 0);
// temporary zero @auto so it wouldn't be auto-called in Request::use_buf	// temporary zero @auto so it wouldn't be auto-called in Request::use_buf
Temp_method temp_method_auto(*target_class, auto_method_name, 0);	Temp_method temp_method_auto(*target_class, auto_method_name, 0);

size_t options_index=index+1;
HashStringValue* options=0;
if(options_index<params.count()) {
Value& voptions=params.as_no_junction(options_index, "options must not be code");
options=voptions.get_hash();
if(!options)
throw Exception(PARSER_RUNTIME,
0,
"options must be hash");
}

const String* main_alias=0;	const String* main_alias=0;
const String* file_alias=0;	const String* file_alias=0;
int line_no_alias_offset=0;	int line_no_alias_offset=0;
if(options) {	bool allow_class_replace=false;
int valid_options=0;
if(Value* vmain_alias=options->get(PROCESS_MAIN_OPTION_NAME)) {	size_t options_index=index+1;
valid_options++;	if(options_index<params.count())
main_alias=&vmain_alias->as_string();	if(HashStringValue* options=params.as_hash(options_index)) {
}
if(Value* vfile_alias=options->get(PROCESS_FILE_OPTION_NAME)) {	int valid_options=0;
valid_options++;	for(HashStringValue::Iterator i(*options); i; i.next() ){
file_alias=&vfile_alias->as_string();
}	String::Body key=i.key();
if(Value* vline_no_alias_offset=options->get(PROCESS_LINENO_OPTION_NAME)) {	Value* value=i.value();
valid_options++;
line_no_alias_offset=vline_no_alias_offset->as_int();	if(key == "main") {
	valid_options++;
	main_alias=&value->as_string();
	} else if(key == "file") {
	valid_options++;
	file_alias=&value->as_string();
	} else if(key == "lineno") {
	valid_options++;
	line_no_alias_offset=value->as_int();
	} else if(key == "replace") {
	valid_options++;
	allow_class_replace=r.process_to_value(*value).as_bool();
	}
	}

	if(valid_options!=options->count())
	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?	uint processe_file_no=file_alias?
r.register_file(r.absolute(*file_alias))	r.register_file(r.absolute(*file_alias))
Line 217 static void _process(Request& r, MethodP	Line 213 static void _process(Request& r, MethodP
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
const String& source=r.process_to_string(vjunction);	const String& source=r.process_to_string(vjunction);

	Temp_class_replace class_replace(r, allow_class_replace);

r.use_buf(*target_class,	r.use_buf(*target_class,
source.untaint_cstr(String::L_AS_IS, r.connection(false)),	source.untaint_cstr(String::L_AS_IS, r.connection(false)),
main_alias,	main_alias,
Line 229 static void _process(Request& r, MethodP	Line 228 static void _process(Request& r, MethodP
// after restoring current-request-lang	// after restoring current-request-lang
// maybe-execute @main[]	// maybe-execute @main[]
if(main_method) {	if(main_method) {
// temporarily set method_frame's self to target_self	VMethodFrame frame(main_method, r.get_method_frame()->caller(), target_self);
Temp_method_frame_self tmfs(r.get_method_frame(), target_self);	frame.empty_params();
// execute!	r.op_call(frame);
r.execute(*main_method->parser_code);	r.write_pass_lang(frame.result());
}	}
}	}

Line 241 static void _rem(Request&, MethodParams&	Line 240 static void _rem(Request&, MethodParams&
}	}

static void _while(Request& r, MethodParams& params) {	static void _while(Request& r, MethodParams& params) {
Temp_hash_value<const String::Body, void*>	InCycle temp(r);
cycle_data_setter(r.classes_conf, cycle_data_name, /any not null flag/&r);

Value& vcondition=params.as_expression(0, "condition must be number, bool or expression");	Value& vcondition=params.as_expression(0, "condition must be number, bool or expression");

Line 298 static void _while(Request& r, MethodPar	Line 296 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);	Value& vfile=params.as_no_junction(0, FILE_NAME_MUST_NOT_BE_CODE);
r.use_file(r.main_class, vfile.as_string());
	bool allow_class_replace=false;

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

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

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

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

	Temp_class_replace class_replace(r, allow_class_replace);

	// _use could be called from the parser3 method only, so caller is always defined
	r.use_file(r.main_class, vfile.as_string(), r.get_method_filename(&r.get_method_frame()->caller()->method));
}	}

static void set_skip(Request& r, Request::Skip askip) {	static void set_skip(Request& r, Request::Skip askip) {
void* data=r.classes_conf.get(cycle_data_name);	if(!r.get_in_cycle())
if(!data)	throw Exception(askip==Request::SKIP_BREAK?"parser.break":"parser.continue",
throw Exception(PARSER_RUNTIME,
0,	0,
"without cycle");	"without cycle");

Line 320 static void _continue(Request& r, Method	Line 341 static void _continue(Request& r, Method
}	}

static void _for(Request& r, MethodParams& params) {	static void _for(Request& r, MethodParams& params) {
Temp_hash_value<const String::Body, void*>	InCycle temp(r);
cycle_data_setter(r.classes_conf, cycle_data_name, /any not null flag/&r);

const String& var_name=params.as_string(0, "var name must be string");	const String& var_name=params.as_string(0, "var name must be string");
int from=params.as_int(1, "from must be int", r);	int from=params.as_int(1, "from must be int", r);
Line 337 static void _for(Request& r, MethodParam	Line 357 static void _for(Request& r, MethodParam
VInt* vint=new VInt(0);	VInt* vint=new VInt(0);

VMethodFrame& caller=*r.get_method_frame()->caller();	VMethodFrame& caller=*r.get_method_frame()->caller();
caller.put_element(caller, var_name, vint, false);	r.put_element(caller, var_name, vint);
if(delim_maybe_code){ // delimiter set	if(delim_maybe_code){ // delimiter set
bool need_delim=false;	bool need_delim=false;

Line 389 static void _eval(Request& r, MethodPara	Line 409 static void _eval(Request& r, MethodPara
}	}

static void _connect(Request& r, MethodParams& params) {	static void _connect(Request& r, MethodParams& params) {
#ifdef RESOURCES_DEBUG
struct timeval mt[2];
#endif
Value& url=params.as_no_junction(0, "url must not be code");	Value& url=params.as_no_junction(0, "url must not be code");
Value& body_code=params.as_junction(1, "body must be code");	Value& body_code=params.as_junction(1, "body must be code");

Table* protocol2driver_and_client=0;	Table* protocol2driver_and_client=0;
if(Value* sql=r.main_class.get_element(String(MAIN_SQL_NAME), r.main_class, false)) {	if(Value* sql=r.main_class.get_element(String(MAIN_SQL_NAME))) {
if(Value* element=sql->get_element(String(MAIN_SQL_DRIVERS_NAME), *sql, false)) {	if(Value* element=sql->get_element(String(MAIN_SQL_DRIVERS_NAME))) {
protocol2driver_and_client=element->get_table();	protocol2driver_and_client=element->get_table();
}	}
}	}

#ifdef RESOURCES_DEBUG
//measure:before
gettimeofday(&mt[0],NULL);
#endif
// connect	// connect
SQL_Connection* connection=SQL_driver_manager->get_connection(url.as_string(),	SQL_Connection* connection=SQL_driver_manager->get_connection(url.as_string(),
protocol2driver_and_client,	protocol2driver_and_client,
r.charsets.source().NAME().cstr(),	r.charsets.source().NAME().cstr(),
r.request_info.document_root);	r.request_info.document_root);

#ifdef RESOURCES_DEBUG
//measure:after connect
gettimeofday(&mt[1],NULL);

double t[2];
for(int i=0;i<2;i++)
t[i]=mt[i].tv_sec+mt[i].tv_usec/1000000.0;

r.sql_connect_time+=t[1]-t[0];
#endif
Temp_connection temp_connection(r, connection);	Temp_connection temp_connection(r, connection);

// execute body	// execute body
try {	try {
r.process_write(body_code);	r.process_write(body_code);
Line 441 public:	Line 445 public:
Request& r;	Request& r;
const String* searching_string;	const String* searching_string;
double searching_double;	double searching_double;
	bool searching_bool;
Value* found;	Value* found;
Value* _default;	Value* _default;
public:	public:
Line 450 public:	Line 455 public:
if(asearching.is_string() \|\| asearching.is_void()){	if(asearching.is_string() \|\| asearching.is_void()){
searching_string=&asearching.as_string();	searching_string=&asearching.as_string();
searching_double=0;	searching_double=0;
	searching_bool=false;
} else {	} else {
searching_string=0;	searching_string=0;
searching_double=asearching.as_double();	searching_double=asearching.as_double();
	searching_bool=asearching.is_bool();
}	}
}	}
};	};
#endif	#endif
static void _switch(Request& r, MethodParams& params) {	static void _switch(Request& r, MethodParams& params) {
Switch_data* data=new Switch_data(r, r.process_to_value(params[0]));	Switch_data* data=new Switch_data(r, r.process_to_value(params[0]));
Temp_hash_value<const String::Body, void*>	Temp_hash_value<HashString<void>, void> switch_data_setter(&r.classes_conf, switch_data_name, data);
switch_data_setter(r.classes_conf, switch_data_name, data);

Value& cases_code=params.as_junction(1, "switch cases must be code");	Value& cases_code=params.as_junction(1, "switch cases must be code");
// execution of found ^case[...]{code} must be in context of ^switch[...]{code}	// execution of found ^case[...]{code} must be in context of ^switch[...]{code}
Line 502 static void _case(Request& r, MethodPara	Line 508 static void _case(Request& r, MethodPara
bool matches;	bool matches;
if(data->searching_string)	if(data->searching_string)
matches=(*data->searching_string) == value.as_string();	matches=(*data->searching_string) == value.as_string();
	else if(data->searching_bool \|\| value.is_bool())
	matches=(data->searching_double != 0) == value.as_bool();
else	else
matches=data->searching_double == value.as_double();	matches=data->searching_double == value.as_double();

Line 545 static Try_catch_result try_catch(Reques	Line 553 static Try_catch_result try_catch(Reques

Junction* junction=catch_code->get_junction();	Junction* junction=catch_code->get_junction();
Value* method_frame=junction->method_frame;	Value* method_frame=junction->method_frame;
Value* saved_exception_var_value=method_frame->get_element(exception_var_name, *method_frame, false);	Value* saved_exception_var_value=method_frame->get_element(exception_var_name);
VMethodFrame& frame=*junction->method_frame;	VMethodFrame& frame=*junction->method_frame;
frame.put_element(frame, exception_var_name, &details.vhash, false);	frame.put_element(exception_var_name, &details.vhash);

result.processed_code=r.process(*catch_code);	result.processed_code=r.process(*catch_code);

// retriving $exception.handled, restoring $exception var	// retriving $exception.handled, restoring $exception var
Value* vhandled=details.vhash.hash().get(exception_handled_part_name);	Value* vhandled=details.vhash.hash().get(exception_handled_part_name);
frame.put_element(frame, exception_var_name, saved_exception_var_value, false);	frame.put_element(exception_var_name, saved_exception_var_value);

bool bhandled=false;	bool bhandled=false;
if(vhandled) {	if(vhandled) {
Line 638 static void locked_process_and_cache_put	Line 646 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 "." EXCEPTION_HANDLED_PART_NAME " 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=&result.processed_code.as_string();	info.processed_code=&result.processed_code.as_string();

Line 716 static Cache_get_result cache_get(Reques	Line 724 static Cache_get_result cache_get(Reques
static time_t as_expires(Request& r, MethodParams& params,	static time_t as_expires(Request& r, MethodParams& params,
int index, time_t now) {	int index, time_t now) {
time_t result;	time_t result;
if(Value* vdate=params[index].as(VDATE_TYPE, false))	if(Value* vdate=params[index].as(VDATE_TYPE))
result=static_cast<VDate*>(vdate)->get_time();	result=(time_t)(static_cast<VDate*>(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 731 static void _cache(Request& r, MethodPar	Line 739 static void _cache(Request& r, MethodPar
// ^cache[] -- return current expiration time	// ^cache[] -- return current expiration time
Cache_scope* scope=static_cast<Cache_scope*>(r.classes_conf.get(cache_data_name));	Cache_scope* scope=static_cast<Cache_scope*>(r.classes_conf.get(cache_data_name));
if(!scope)	if(!scope)
throw Exception(PARSER_RUNTIME,	throw Exception(PARSER_RUNTIME, 0, "expire-time get without cache");
0,	r.write_no_lang(*new VDate((pa_time_t)scope->expires));
"expire-time get without cache");
r.write_no_lang(*new VDate(scope->expires));
return;	return;
}	}

Line 769 static void _cache(Request& r, MethodPar	Line 775 static void _cache(Request& r, MethodPar

Cache_scope scope={as_expires(r, params, 1, now), 0};	Cache_scope scope={as_expires(r, params, 1, now), 0};

Temp_hash_value<const String::Body, void*>	Temp_hash_value<HashString<void>, void> cache_scope_setter(&r.classes_conf, cache_data_name, &scope);
cache_scope_setter(r.classes_conf, cache_data_name, &scope);
Value& body_code=params.as_junction(2, "body_code must be code");	Value& body_code=params.as_junction(2, "body_code must be code");
Value* catch_code=0;	Value* catch_code=0;
if(params.count()>3)	if(params.count()>3)
Line 878 static void _throw_operator(Request&, Me	Line 883 static void _throw_operator(Request&, Me

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);
pa_sleep((int)trunc(seconds), (int)trunc(seconds*1000));	if(seconds>0)
	pa_sleep((int)trunc(seconds), (int)trunc((seconds-trunc(seconds))*1000000));
}	}

#if defined(WIN32) && defined(_DEBUG)	#if defined(WIN32) && defined(_DEBUG)
Line 900 VClassMAIN::VClassMAIN(): VClass() {	Line 906 VClassMAIN::VClassMAIN(): VClass() {

// ^if(condition){code-when-true}	// ^if(condition){code-when-true}
// ^if(condition){code-when-true}{code-when-false}	// ^if(condition){code-when-true}{code-when-false}
add_native_method("if", Method::CT_ANY, _if, 2, 3, Method::CO_WITHOUT_FRAME);	// ^if(condition){code-when-true} (another condition){code-when-true} ... {code-when-false}
	add_native_method("if", Method::CT_ANY, _if, 2, 10000, Method::CO_WITHOUT_FRAME);

	// ^untaint[as-is\|uri\|sql\|js\|html\|html-typo\|regex\|parser-code]{code}
	add_native_method("untaint", Method::CT_ANY, _untaint, 1, 2, Method::CO_WITHOUT_FRAME);

// ^untaint[as-is\|uri\|sql\|js\|html\|html-typo\|regex]{code}	// ^taint[as-is\|uri\|sql\|js\|html\|html-typo\|regex\|parser-code]{code}
add_native_method("untaint", Method::CT_ANY, _untaint, 1, 2);	add_native_method("taint", Method::CT_ANY, _taint, 1, 2, Method::CO_WITHOUT_FRAME);

// ^taint[as-is\|uri\|sql\|js\|html\|html-typo\|regex]{code}	// ^apply-taint[untaint lang][string]
add_native_method("taint", Method::CT_ANY, _taint, 1, 2);	add_native_method("apply-taint", Method::CT_ANY, _apply_taint, 1, 2, Method::CO_WITHOUT_FRAME);

// ^process[code]	// ^process{code}
	// ^process[context]{code}[options hash]
add_native_method("process", Method::CT_ANY, _process, 1, 3);	add_native_method("process", Method::CT_ANY, _process, 1, 3);

// ^rem{code}	// ^rem{code}
Line 917 VClassMAIN::VClassMAIN(): VClass() {	Line 928 VClassMAIN::VClassMAIN(): VClass() {
// ^while(condition){code}	// ^while(condition){code}
add_native_method("while", Method::CT_ANY, _while, 2, 3, Method::CO_WITHOUT_FRAME);	add_native_method("while", Method::CT_ANY, _while, 2, 3, Method::CO_WITHOUT_FRAME);

// ^use[file]	// ^use[file[;options hash]]
add_native_method("use", Method::CT_ANY, _use, 1, 1);	add_native_method("use", Method::CT_ANY, _use, 1, 2);

// ^break[]	// ^break[]
add_native_method("break", Method::CT_ANY, _break, 0, 0, Method::CO_WITHOUT_FRAME);	add_native_method("break", Method::CT_ANY, _break, 0, 0, Method::CO_WITHOUT_FRAME);

E-mail:

Removed from v.1.190
changed lines
	Added in v.1.221