parser3/src/main/execute.C - diff

Return to execute.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/execute.C between versions 1.69 and 1.122

version 1.69, 2001/03/08 12:19:21	version 1.122, 2001/03/21 14:06:45
Line 1	Line 1
/*	/** @file
$Id$	Parser: executor part of request class.

	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)

	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)

	$Id$
*/	*/

#include "pa_array.h"
#include "code.h"	#include "code.h"
	#include "pa_array.h"
#include "pa_request.h"	#include "pa_request.h"
#include "pa_vstring.h"	#include "pa_vstring.h"
#include "pa_vhash.h"	#include "pa_vhash.h"
Line 13	Line 19
#include "pa_vobject.h"	#include "pa_vobject.h"
#include "pa_vdouble.h"	#include "pa_vdouble.h"
#include "pa_vbool.h"	#include "pa_vbool.h"
	#include "pa_vtable.h"

#include <stdio.h>	#include <stdio.h>
	#include <string.h>

#define PUSH(value) stack.push(value)	#define PUSH(value) stack.push(value)
#define POP() static_cast<Value *>(stack.pop())	#define POP() static_cast<Value *>(stack.pop())
Line 23	Line 31

char *opcode_name[]={	char *opcode_name[]={
// literals	// literals
"VALUE", "CODE__STORE_PARAM",	"VALUE", "CURLY_CODE__STORE_PARAM", "EXPR_CODE__STORE_PARAM",

// actions	// actions
"WITH_SELF", "WITH_ROOT", "WITH_READ", "WITH_WRITE",	"WITH_SELF", "WITH_ROOT", "WITH_READ", "WITH_WRITE",
"GET_CLASS",	"GET_CLASS",
"CONSTRUCT",	"CONSTRUCT_VALUE", "CONSTRUCT_DOUBLE",
"WRITE",	"WRITE_VALUE", "WRITE_EXPR_RESULT", "STRING__WRITE",
"GET_ELEMENT", "GET_ELEMENT__WRITE",	"GET_ELEMENT", "GET_ELEMENT__WRITE",
"CREATE_EWPOOL", "REDUCE_EWPOOL",	"CREATE_EWPOOL", "REDUCE_EWPOOL",
"CREATE_RWPOOL", "REDUCE_RWPOOL",	"CREATE_RWPOOL", "REDUCE_RWPOOL",
Line 45 char *opcode_name[]={	Line 53 char *opcode_name[]={
"BIN_AND", "BIN_OR", "BIN_XOR",	"BIN_AND", "BIN_OR", "BIN_XOR",
"LOG_AND", "LOG_OR", "LOG_XOR",	"LOG_AND", "LOG_OR", "LOG_XOR",
"NUM_LT", "NUM_GT", "NUM_LE", "NUM_GE", "NUM_EQ", "NUM_NE",	"NUM_LT", "NUM_GT", "NUM_LE", "NUM_GE", "NUM_EQ", "NUM_NE",
"STR_LT", "STR_GT", "STR_LE", "STR_GE", "STR_EQ", "STR_NE"	"STR_LT", "STR_GT", "STR_LE", "STR_GE", "STR_EQ", "STR_NE",
	"IS"
};	};

	void va_log_printf(const char *fmt,va_list args) {
	return;
	vfprintf(stderr, fmt, args);
	}

	void log_printf(const char *fmt, ...) {
	// TODO: куда-нибудь пристроить
	va_list args;
	va_start(args,fmt);
	va_log_printf(fmt,args);
	va_end(args);
	}

void dump(int level, const Array& ops) {	void dump(int level, const Array& ops) {
if(0){	if(0){
int size=ops.size();	int size=ops.size();
//fprintf(stderr, "size=%d\n", size);	//log_printf("size=%d\n", size);
for(int i=0; i<size; i++) {	for(int i=0; i<size; i++) {
Operation op;	Operation op;
op.cast=ops.quick_get(i);	op.cast=ops.quick_get(i);
fprintf(stderr, "%8X\n", op.cast);	log_printf("%8X\n", op.cast);
}	}
}	}

int size=ops.size();	int size=ops.size();
//fprintf(stderr, "size=%d\n", size);	//log_printf("size=%d\n", size);
for(int i=0; i<size; i++) {	for(int i=0; i<size; i++) {
Operation op;	Operation op;
op.cast=ops.quick_get(i);	op.cast=ops.quick_get(i);
fprintf(stderr, "%s%s", level4, "", opcode_name[op.code]);	log_printf("%s%s", level4, "", opcode_name[op.code]);

if(op.code==OP_VALUE) {	if(op.code==OP_VALUE \|\| op.code==OP_STRING__WRITE) {
Value value=static_cast<Value >(ops.quick_get(++i));	Value value=static_cast<Value >(ops.quick_get(++i));
fprintf(stderr, " \"%s\" %s", value->get_string()->cstr(), value->type());	log_printf(" \"%s\" %s", value->get_string()->cstr(), value->type());
}	}
fprintf(stderr, "\n");	log_printf("\n");

if(op.code==OP_CODE__STORE_PARAM) {	if(op.code==OP_CURLY_CODE__STORE_PARAM \|\| op.code==OP_EXPR_CODE__STORE_PARAM) {
const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));	const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));
dump(level+1, *local_ops);	dump(level+1, *local_ops);
}	}
}	}
fflush(stderr);
}	}

void Request::execute(const Array& ops) {	void Request::execute(const Array& ops) {
if(1) {	if(1) {
fputs("source----------------------------\n", stderr);	log_printf("source----------------------------\n");
dump(0, ops);	dump(0, ops);
fputs("execution-------------------------\n", stderr);	log_printf("execution-------------------------\n");
}	}

int size=ops.size();	int size=ops.size();
//fprintf(stderr, "size=%d\n", size);	//log_printf("size=%d\n", size);
for(int i=0; i<size; i++) {	for(int i=0; i<size; i++) {
Operation op;	Operation op;
op.cast=ops.quick_get(i);	op.cast=ops.quick_get(i);
fprintf(stderr, "%d:%s", stack.top()+1, opcode_name[op.code]); fflush(stderr);	log_printf("%d:%s", stack.top_index()+1, opcode_name[op.code]);

switch(op.code) {	switch(op.code) {
// param in next instruction	// param in next instruction
case OP_VALUE:	case OP_VALUE:
{	{
Value value=static_cast<Value >(ops.quick_get(++i));	Value value=static_cast<Value >(ops.quick_get(++i));
fprintf(stderr, " \"%s\" %s", value->get_string()->cstr(), value->type());	log_printf(" \"%s\" %s", value->get_string()->cstr(), value->type());
PUSH(value);	PUSH(value);
break;	break;
}	}
case OP_CODE__STORE_PARAM:	case OP_CURLY_CODE__STORE_PARAM:
	case OP_EXPR_CODE__STORE_PARAM:
{	{
VMethodFrame frame=static_cast<VMethodFrame >(stack[stack.top()]);	VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());
// code	// code
const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));	const Array local_ops=reinterpret_cast<const Array >(ops.quick_get(++i));
fprintf(stderr, " (%d)\n", local_ops->size());	log_printf(" (%d)\n", local_ops->size());
dump(1, *local_ops);	dump(1, *local_ops);

	// when they evaluate expression parameter,
	// the object expression result
	// does not need to be written into calling frame
	// it must go into any expressions using that parameter
	// hence, zeroing junction.wcontext being created
	// later, in .process would test that field
	// in decision "which wwrapper to use"
Junction& j=*NEW Junction(pool(),	Junction& j=*NEW Junction(pool(),
*self, 0, 0,	*self, 0, 0,
root, frame, frame, local_ops);	root, frame, op.code==OP_EXPR_CODE__STORE_PARAM?0:frame, local_ops);

Value *value=NEW VJunction(j);	Value *value=NEW VJunction(j);
value->set_name(frame->name());

// store param	// store param
frame->store_param(value);	frame->store_param(frame->name(), value);
break;	break;
}	}
case OP_GET_CLASS:	case OP_GET_CLASS:
{	{
String& name=POP_NAME();	// maybe the do ^class:method[] call, remember the fact
VClass vclass=static_cast<VClass >(classes().get(name));	wcontext->set_somebody_entered_some_class();
if(!vclass)
	const String& name=POP_NAME();
	Value value=static_cast<Value >(classes().get(name));
	if(!value)
THROW(0,0,	THROW(0,0,
&name,	&name,
": undefined class");	": undefined class");

PUSH(vclass);	PUSH(value);
break;	break;
}	}

Line 158 void Request::execute(const Array& ops)	Line 189 void Request::execute(const Array& ops)
}	}

// OTHER ACTIONS BUT WITHs	// OTHER ACTIONS BUT WITHs
case OP_CONSTRUCT:	case OP_CONSTRUCT_VALUE:
{	{
Value *value=POP();	Value *value=POP();
String& name=POP_NAME();	const String& name=POP_NAME();
Value *ncontext=POP();	Value *ncontext=POP();
value->set_name(name);
ncontext->put_element(name, value);	ncontext->put_element(name, value);
	value->set_name(name);
break;	break;
}	}
case OP_WRITE:	case OP_CONSTRUCT_EXPR:
{	{
Value *value=POP();	Value *value=POP();
wcontext->write(value);	const String& name=POP_NAME();
	Value *ncontext=POP();
	ncontext->put_element(name, value->get_expr_result());
	value->set_name(name);
	break;
	}
	case OP_WRITE_VALUE:
	{
	Value *value=POP();
	write_assign_lang(*value);
	break;
	}
	case OP_WRITE_EXPR_RESULT:
	{
	Value *value=POP();
	write_expr_result(*value->get_expr_result());
	break;
	}
	case OP_STRING__WRITE:
	{
	VString vstring=static_cast<VString >(ops.quick_get(++i));
	log_printf(" \"%s\"", vstring->string().cstr());
	write_no_lang(vstring->string());
break;	break;
}	}

Line 184 void Request::execute(const Array& ops)	Line 237 void Request::execute(const Array& ops)
case OP_GET_ELEMENT__WRITE:	case OP_GET_ELEMENT__WRITE:
{	{
Value *value=get_element();	Value *value=get_element();
wcontext->write(value);	write_assign_lang(*value);
break;	break;
}	}

Line 214 void Request::execute(const Array& ops)	Line 267 void Request::execute(const Array& ops)
}	}
case OP_REDUCE_RWPOOL:	case OP_REDUCE_RWPOOL:
{	{
String *string=wcontext->get_string();	const String *string=wcontext->get_string();
Value value=string?NEW VString(string):NEW VString(pool());	Value *value;
	if(string)
	value=NEW VString(*string);
	else
	value=NEW VUnknown(pool());
wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
rcontext=POP();	rcontext=POP();
PUSH(value);	PUSH(value);
Line 231 void Request::execute(const Array& ops)	Line 288 void Request::execute(const Array& ops)
{	{
// from "$a $b" part of expression taking only string value,	// from "$a $b" part of expression taking only string value,
// ignoring any other content of wcontext	// ignoring any other content of wcontext
String *string=wcontext->get_string();	const String *string=wcontext->get_string();
Value value=string?NEW VString(string):NEW VString(pool());	Value *value;
	if(string)
	value=NEW VString(*string);
	else
	NEW VUnknown(pool());
wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
PUSH(value);	PUSH(value);
break;	break;
Line 242 void Request::execute(const Array& ops)	Line 303 void Request::execute(const Array& ops)
case OP_GET_METHOD_FRAME:	case OP_GET_METHOD_FRAME:
{	{
Value *value=POP();	Value *value=POP();
// [self/class?;params;local;code/native_code](name)	// info:
	// code compiled so that this one's always method-junction,
	// not a code-junction
Junction *junction=value->get_junction();	Junction *junction=value->get_junction();
if(!junction)	if(!junction)
THROW(0,0,	THROW(0,0,
&value->name(),	&value->name(),
"type is '%s', can not call it (must be method or junction)",	"(%s) not a method or junction, can not call it",
value->type());	value->type());
//unless(method) method=operators.get_method[...;code/native_code](name)
VMethodFrame frame=NEW VMethodFrame(pool(), junction);	VMethodFrame frame=NEW VMethodFrame(pool(), junction);
frame->set_name(junction->self.name());	frame->set_name(value->name());
PUSH(frame);	PUSH(frame);
break;	break;
}	}
case OP_STORE_PARAM:	case OP_STORE_PARAM:
{	{
Value *value=POP();	Value *value=POP();
VMethodFrame frame=static_cast<VMethodFrame >(stack[0]);	VMethodFrame frame=static_cast<VMethodFrame >(stack.top_value());
frame->store_param(value);	frame->store_param(frame->name(), value);
break;	break;
}	}

case OP_CALL:	case OP_CALL:
{	{
fprintf(stderr, "->\n");	log_printf("->\n");
VMethodFrame frame=static_cast<VMethodFrame >(POP());	VMethodFrame frame=static_cast<VMethodFrame >(POP());
frame->fill_unspecified_params();	frame->fill_unspecified_params();
PUSH(self);	PUSH(self);
Line 273 void Request::execute(const Array& ops)	Line 336 void Request::execute(const Array& ops)
PUSH(rcontext);	PUSH(rcontext);
PUSH(wcontext);	PUSH(wcontext);

VClass *called_class=frame->junction.self.get_class();	VStateless_class *called_class=frame->junction.self.get_class();
// constructing?	// is context object or class & is it my class or my parent's class?
if(wcontext->constructing()) { // yes	VStateless_class *read_class=rcontext->get_class();
// constructor call: $some(^class:method(..))	if(read_class && read_class->is_or_derived_from(*called_class)) // yes
frame->write(self=NEW VObject(pool(), *called_class));	self=rcontext; // class dynamic call
} else { // no	else // no, not me or relative of mine (total stranger)
// context is object or class & is it my class or my parent's class?	if(
VClass *read_class=rcontext->get_class();	wcontext->constructing() && // constructing?
if(read_class && read_class->is_or_derived_from(*called_class)) // yes	wcontext->somebody_entered_some_class()) { // ^class:method[..]?
self=rcontext; // class dynamic call	// yes, this is a constructor call
else // no	// some stateless_object derivates with constructors
self=&frame->junction.self; // static or simple dynamic call	if(called_class==table_class)///called_class->name()==TABLE_CLASS_NAME)
}	self=NEW VTable(pool());
	else // stateful object
	self=NEW VObject(pool(), *called_class);
	frame->write(*self,
	String::UL_NO // not used, always an object, not string
	);
	} else
	self=&frame->junction.self; // no, static or simple dynamic call

frame->set_self(*self);	frame->set_self(*self);
root=rcontext=wcontext=frame;	root=rcontext=wcontext=frame;
{	{
// take object or class from any wrappers	// take object or class from any wrappers
VAliased *aliased=self->get_aliased();	// and substitute class alias to the class they are called AS
// substitute class alias to the class they are called AS	Temp_alias temp_alias(self->get_aliased(), frame->junction.vclass);
Temp_alias temp_alias(aliased, frame->junction.vclass);
	const Method& method=*frame->junction.method;
Method& method=*frame->junction.method;	if(method.native_code) { // native code?
if(method.native_code) // native code?	method.check_actual_numbered_params(
(method.native_code)(this); // execute it	frame->junction.self,
else // parser code	frame->name(), frame->numbered_params());
	(*method.native_code)(
	*this,
	frame->name(), frame->numbered_params()); // execute it
	} else // parser code
execute(*method.parser_code); // execute it	execute(*method.parser_code); // execute it
}	}
Value *value=wcontext->result();	Value *value=wcontext->result();
Line 308 void Request::execute(const Array& ops)	Line 383 void Request::execute(const Array& ops)
self=static_cast<VAliased *>(POP());	self=static_cast<VAliased *>(POP());

PUSH(value);	PUSH(value);
fprintf(stderr, "<-returned");	log_printf("<-returned");
break;	break;
}	}

Line 323 void Request::execute(const Array& ops)	Line 398 void Request::execute(const Array& ops)
case OP_INV:	case OP_INV:
{	{
Value *operand=POP();	Value *operand=POP();
Value *value=NEW VDouble(pool(),	Value *value=NEW VDouble(pool(), ~(int)operand->get_double());
~static_cast<int>(operand->get_double()));
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 345 void Request::execute(const Array& ops)	Line 419 void Request::execute(const Array& ops)
case OP_IN:	case OP_IN:
{	{
Value *operand=POP();	Value *operand=POP();
Value value=NEW VBool(pool(), true/TODO*/);	const char *path=operand->as_string().cstr();
	Value *value=NEW VBool(pool(), strcmp(path, info.uri)<=0);
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 390 void Request::execute(const Array& ops)	Line 465 void Request::execute(const Array& ops)
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(),	Value *value=NEW VDouble(pool(),
static_cast<int>(a->get_double()) %	(int)a->get_double() %
static_cast<int>(b->get_double()));	(int)b->get_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 399 void Request::execute(const Array& ops)	Line 474 void Request::execute(const Array& ops)
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(),	Value *value=NEW VDouble(pool(),
static_cast<int>(a->get_double()) &	(int)a->get_double() &
static_cast<int>(b->get_double()));	(int)b->get_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 408 void Request::execute(const Array& ops)	Line 483 void Request::execute(const Array& ops)
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(),	Value *value=NEW VDouble(pool(),
static_cast<int>(a->get_double()) \|	(int)a->get_double() \|
static_cast<int>(b->get_double()));	(int)b->get_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 417 void Request::execute(const Array& ops)	Line 492 void Request::execute(const Array& ops)
{	{
Value b=POP(); Value a=POP();	Value b=POP(); Value a=POP();
Value *value=NEW VDouble(pool(),	Value *value=NEW VDouble(pool(),
static_cast<int>(a->get_double()) ^	(int)a->get_double() ^
static_cast<int>(b->get_double()));	(int)b->get_double());
PUSH(value);	PUSH(value);
break;	break;
}	}
Line 527 void Request::execute(const Array& ops)	Line 602 void Request::execute(const Array& ops)
PUSH(value);	PUSH(value);
break;	break;
}	}
	case OP_IS:
	{
	Value b=POP(); Value a=POP();
	Value *value=NEW VBool(pool(), b->as_string() == a->type());
	PUSH(value);
	break;
	}

default:	default:
THROW(0,0,	THROW(0,0,
0,	0,
"unhandled '%s' opcode", opcode_name[op.code]);	"unhandled '%s' opcode", opcode_name[op.code]);
}	}
fprintf(stderr, "\n");	log_printf("\n");
}	}
}	}

Value *Request::get_element() {	Value *Request::get_element() {
String& name=POP_NAME();	const String& name=POP_NAME();
Value *ncontext=POP();	Value *ncontext=POP();
Value *value=ncontext->get_element(name);	Value *value=ncontext->get_element(name);

if(value) {	if(value)
Junction *junction=value->get_junction();	value=&process(*value, &name); // process possible code-junction
if(junction && junction->code) { // is it a code-junction?	else {
// autocalc it	value=NEW VUnknown(pool());
fprintf(stderr, "ja->\n");	value->set_name(name);
PUSH(self);	}
PUSH(root);
PUSH(rcontext);	return value;
PUSH(wcontext);	}

	/**
	intercept_string:
	- true:
	they want result=string value,
	possible object result goes to wcontext
	- false:
	they want any result[string\|object]
	nothing goes to wcontext.
	used in (expression) params evaluation
	*/
	Value& Request::process(Value& value, const String *name, bool intercept_string) {
	Value *result;
	Junction *junction=value.get_junction();
	if(junction && junction->code) { // is it a code-junction?
	// process it
	log_printf("ja->\n");
	PUSH(self);
	PUSH(root);
	PUSH(rcontext);
	PUSH(wcontext);

	WContext *frame;
	// for expression method params
	// wcontext is set 0
	// using the fact in decision "which wwrapper to use"
	bool using_code_frame=intercept_string && junction->wcontext;
	if(using_code_frame) {
// almost plain wwrapper about junction wcontext,	// almost plain wwrapper about junction wcontext,
// BUT intercepts string writes	// BUT intercepts string writes
VCodeFrame frame(pool(), *junction->wcontext); wcontext=&frame;	frame=NEW VCodeFrame(pool(), *junction->wcontext);
self=&junction->self;	} else {
root=junction->root;	// plain wwrapper
rcontext=junction->rcontext;	frame=NEW WWrapper(pool(), 0/empty/, false/not constructing/);
execute(*junction->code);	}

	wcontext=frame;
	self=&junction->self;
	root=junction->root;
	rcontext=junction->rcontext;
	execute(*junction->code);
	if(using_code_frame) {
// CodeFrame soul:	// CodeFrame soul:
// string writes were intercepted	// string writes were intercepted
// returning them as the result of getting code-junction	// returning them as the result of getting code-junction
value=NEW VString(*frame.get_string());	result=NEW VString(*frame->get_string());
	} else
	result=frame->result();

	wcontext=static_cast<WContext *>(POP());
	rcontext=POP();
	root=POP();
	self=static_cast<VAliased *>(POP());

	log_printf("<-ja returned");
	} else
	result=&value;

wcontext=static_cast<WContext *>(POP());	if(name)
rcontext=POP();	result->set_name(*name);
root=POP();	return *result;
self=static_cast<VAliased *>(POP());	}

fprintf(stderr, "<-ja returned");	const String *Request::execute_method(Value& aself, const Method& method, bool return_cstr) {
}	PUSH(self);
} else	PUSH(root);
value=NEW VUnknown(pool());	PUSH(rcontext);
	PUSH(wcontext);

	// initialize contexts
	root=rcontext=self=&aself;
	wcontext=NEW WWrapper(pool(), &aself, false /* not constructing */);

	// execute!
	execute(*method.parser_code);

	// result
	const String *result;
	if(return_cstr)
	result=&wcontext->as_string();
	else
	result=0; // ignore result

	wcontext=static_cast<WContext *>(POP());
	rcontext=POP();
	root=POP();
	self=static_cast<VAliased *>(POP());

	// return
	return result;
	}

value->set_name(name);	const String *Request::execute_method(Value& aself,
return value;	const String& method_name, bool return_cstr) {
	if(Value *value=aself.get_element(method_name))
	if(Junction *junction=value->get_junction())
	if(const Method *method=junction->method)
	return execute_method(aself, *method, return_cstr);

	return 0;
}	}

E-mail:

Removed from v.1.69
changed lines
	Added in v.1.122