parser3/src/classes/int.C - diff

Return to int.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/int.C between versions 1.49.2.3 and 1.65

version 1.49.2.3, 2003/02/04 14:12:42	version 1.65, 2016/03/31 21:46:20
Line 1	Line 1
/** @file	/** @file
Parser: @b int parser class.	Parser: @b int parser class.

Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2015 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* IDENT_INT_C="$Date$";

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

#include "pa_request.h"	#include "pa_request.h"
#include "pa_vdouble.h"	#include "pa_vdouble.h"
#include "pa_vint.h"	#include "pa_vint.h"
	#include "pa_vbool.h"

	volatile const char * IDENT_INT_C="$Id$" IDENT_PA_VINT_H;

// externs	// externs

void _string_format(Request& r, StringPtr method_name, MethodParams& /params/);	void _string_format(Request& r, MethodParams&);

// class	// class

class MInt : public Methoded {	class MInt: public Methoded {
public:	public:
MInt();	MInt();
public: // Methoded
bool used_directly() { return true; }
};	};

// global variable	// global variable

MethodedPtr int_class(new MInt);	DECLARE_CLASS_VAR(int, new MInt);

// methods	// methods

static void _int(Request& r, StringPtr method_name, MethodParams& params) {	static void _int(Request& r, MethodParams&) {
// just checking (default) syntax validity, never really using it here, just for string.int compatibility	VInt& vint=GET_SELF(r, VInt);
if(params.count()>0)	r.write_no_lang(*new VInt(vint.get_int()));
params.as_junction(0, "default must be int");

VInt& vint=static_cast<VInt >(r.get_self().get());
r.write_no_lang(ValuePtr(new VInt(vint.get_int())));
}	}

static void _double(Request& r, StringPtr method_name, MethodParams& params) {	static void _double(Request& r, MethodParams&) {
// just checking (default) syntax validity, never really using it here, just for string.doube compatibility	VInt& vint=GET_SELF(r, VInt);
if(params.count()>0)	r.write_no_lang(*new VDouble(vint.as_double()));
params.as_junction(0, "default must be double");	}

VInt& vint=static_cast<VInt >(r.get_self().get());	static void _bool(Request& r, MethodParams&) {
r.write_no_lang(ValuePtr(new VDouble(vint.as_double())));	VInt& vint=GET_SELF(r, VInt);
	r.write_no_lang(VBool::get(vint.as_bool()));
}	}

typedef void (*vint_op_func_ptr)(VInt& vint, double param);	typedef void (*vint_op_func_ptr)(VInt& vint, double param);
Line 61 static void __mod(VInt& vint, double par	Line 57 static void __mod(VInt& vint, double par

static void vint_op(Request& r, MethodParams& params,	static void vint_op(Request& r, MethodParams& params,
vint_op_func_ptr func) {	vint_op_func_ptr func) {
VInt& vint=static_cast<VInt >(r.get_self().get());	VInt& vint=GET_SELF(r, VInt);
double param=params.count()?params.as_double(0, "param must be numerical", r):1;	double param=params.count()?params.as_double(0, "param must be numerical", r):1;
(*func)(vint, param);	(*func)(vint, param);
}	}

static void _inc(Request& r, StringPtr /method_name/, MethodParams& params) { vint_op(r, params, &__inc); }	static void _inc(Request& r, MethodParams& params) { vint_op(r, params, &__inc); }
static void _dec(Request& r, StringPtr /method_name/, MethodParams& params) { vint_op(r, params, &__dec); }	static void _dec(Request& r, MethodParams& params) { vint_op(r, params, &__dec); }
static void _mul(Request& r, StringPtr /method_name/, MethodParams& params) { vint_op(r, params, &__mul); }	static void _mul(Request& r, MethodParams& params) { vint_op(r, params, &__mul); }
static void _div(Request& r, StringPtr /method_name/, MethodParams& params) { vint_op(r, params, &__div); }	static void _div(Request& r, MethodParams& params) { vint_op(r, params, &__div); }
static void _mod(Request& r, StringPtr /method_name/, MethodParams& params) { vint_op(r, params, &__mod); }	static void _mod(Request& r, MethodParams& params) { vint_op(r, params, &__mod); }

// from string.C	// from string.C
extern	extern const String* sql_result_string(Request& r, MethodParams& params, Value*& default_code);
StringPtr sql_result_string(Request& r, StringPtr method_name, MethodParams& params,
HashStringValuePtr& options, ValuePtr& default_code);

static void _sql(Request& r, StringPtr method_name, MethodParams& params) {	static void _sql(Request& r, MethodParams& params) {
int val;	int val;
HashStringValuePtr options(0);	Value* default_code=0;
ValuePtr default_code(0);	if(const String* string=sql_result_string(r, params, default_code))
if(StringPtr string=sql_result_string(r, method_name, params, options, default_code))
val=string->as_int();	val=string->as_int();
else	else
if(default_code)	if(default_code)
val=r.process_to_value(default_code)->as_int();	val=r.process_to_value(*default_code).as_int();
else {	else {
throw Exception("parser.runtime",	throw Exception(PARSER_RUNTIME,
method_name,	0,
"produced no result, but no default option specified");	"produced no result, but no default option specified");
val=0; //calm, compiler
}	}
r.write_no_lang(ValuePtr(new VInt(val)));	r.write_no_lang(*new VInt(val));
}	}

// constructor	// constructor

MInt::MInt(): Methoded("int") {	MInt::MInt(): Methoded("int") {
// ^int.int[]	// ^int.int[]
	// ^int.int[default for ^string.int compatibility]
add_native_method("int", Method::CT_DYNAMIC, _int, 0, 1);	add_native_method("int", Method::CT_DYNAMIC, _int, 0, 1);

// ^int.double[]	// ^int.double[]
	// ^int.double[default for ^string.double compatibility]
add_native_method("double", Method::CT_DYNAMIC, _double, 0, 1);	add_native_method("double", Method::CT_DYNAMIC, _double, 0, 1);
	// ^int.bool[]
	// ^int.bool[default for ^string.bool compatibility]
	add_native_method("bool", Method::CT_DYNAMIC, _bool, 0, 1);

// ^int.inc[]	// ^int.inc[]
// ^int.inc[offset]	// ^int.inc[offset]

E-mail:

Removed from v.1.49.2.3
changed lines
	Added in v.1.65