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.34 and 1.46

version 1.34, 2001/02/24 11:20:33	version 1.46, 2001/02/25 17:33:44
Line 10	Line 10
#include "pa_vunknown.h"	#include "pa_vunknown.h"
#include "pa_vcframe.h"	#include "pa_vcframe.h"
#include "pa_vmframe.h"	#include "pa_vmframe.h"
	#include "pa_vobject.h"

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

Line 19	Line 20


char *opcode_name[]={	char *opcode_name[]={
"STRING", "CODE",	"STRING", "CODE", "CLASS",
"WITH_ROOT", "WITH_SELF", "WITH_READ", "WITH_WRITE",	"WITH_ROOT", "WITH_SELF", "WITH_READ", "WITH_WRITE",
"CONSTRUCT",	"CONSTRUCT",
"EXPRESSION_EVAL", "MODIFY_EVAL",	"EXPRESSION_EVAL", "MODIFY_EVAL",
Line 35 char *opcode_name[]={	Line 36 char *opcode_name[]={
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();
//printf("size=%d\n", size);	//fprintf(stderr, "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);
printf("%8X\n", op.cast);	fprintf(stderr, "%8X\n", op.cast);
}	}
}	}

int size=ops.size();	int size=ops.size();
//printf("size=%d\n", size);	//fprintf(stderr, "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);
printf("%s%s", level4, "", opcode_name[op.code]);	fprintf(stderr, "%s%s", level4, "", opcode_name[op.code]);

if(op.code==OP_STRING) {	if(op.code==OP_STRING) {
VString vstring=static_cast<VString >(ops.quick_get(++i));	VString vstring=static_cast<VString >(ops.quick_get(++i));
printf(" \"%s\"", vstring->get_string()->cstr());	fprintf(stderr, " \"%s\"", vstring->get_string()->cstr());
}	}
printf("\n");	if(op.code==OP_CLASS) {
	VClass vclass=static_cast<VClass >(ops.quick_get(++i));
	fprintf(stderr, " \"%s\"", vclass->name().cstr());
	}
	fprintf(stderr, "\n");

if(op.code==OP_CODE) {	if(op.code==OP_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));
Line 65 void dump(int level, const Array& ops) {	Line 70 void dump(int level, const Array& ops) {

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

int size=ops.size();	int size=ops.size();
//printf("size=%d\n", size);	//fprintf(stderr, "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);
printf("%d:%s", stack.top(), opcode_name[op.code]);	fprintf(stderr, "%d:%s", stack.top(), opcode_name[op.code]);

switch(op.code) {	switch(op.code) {
// param in next instruction	// param in next instruction
case OP_STRING:	case OP_STRING:
{	{
VString vstring=static_cast<VString >(ops.quick_get(++i));	VString vstring=static_cast<VString >(ops.quick_get(++i));
printf(" \"%s\"", vstring->get_string()->cstr());	fprintf(stderr, " \"%s\"", vstring->get_string()->cstr());
PUSH(vstring);	PUSH(vstring);
break;	break;
}	}
case OP_CODE:	case OP_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));
printf(" (%d)", local_ops->size());	fprintf(stderr, " (%d)\n", local_ops->size());
	dump(1, *local_ops);
Junction& j=*NEW Junction(pool(),	Junction& j=*NEW Junction(pool(),
*self,	*self, 0, 0,
0,
root,rcontext,wcontext,local_ops);	root,rcontext,wcontext,local_ops);

Value *value=NEW VJunction(j);	Value *value=NEW VJunction(j);
PUSH(value);	PUSH(value);
break;	break;
}	}
	case OP_CLASS:
// OP_WITH
case OP_WITH_WRITE:
{	{
PUSH(wcontext);	VClass vclass=static_cast<VClass >(ops.quick_get(++i));
	fprintf(stderr, " \"%s\"", vclass->name().cstr());
	PUSH(vclass);
break;	break;
}	}
case OP_WITH_READ:
	// OP_WITH
	case OP_WITH_SELF:
{	{
PUSH(rcontext);	PUSH(self);
break;	break;
}	}
case OP_WITH_ROOT:	case OP_WITH_ROOT:
Line 116 void Request::execute(const Array& ops)	Line 123 void Request::execute(const Array& ops)
PUSH(root);	PUSH(root);
break;	break;
}	}
case OP_WITH_SELF:	case OP_WITH_READ:
{	{
PUSH(self);	PUSH(rcontext);
	break;
	}
	case OP_WITH_WRITE:
	{
	PUSH(wcontext);
break;	break;
}	}

// ...	// ...
	case OP_CONSTRUCT:
	{
	Value *value=POP();
	String& name=POP_NAME();
	Value *ncontext=POP();
	value->set_name(name);
	ncontext->put_element(name, value);
	break;
	}
	// TODO: OP_EXPRESSION_EVAL, OP_MODIFY_EVAL,
case OP_WRITE:	case OP_WRITE:
{	{
Value *value=POP();	Value *value=POP();
Line 144 void Request::execute(const Array& ops)	Line 166 void Request::execute(const Array& ops)
break;	break;
}	}

case OP_CONSTRUCT:
{
Value *value=POP();
String& name=POP_NAME();
Value *ncontext=POP();
value->set_name(name);
ncontext->put_element(name, value);
break;
}

case OP_CREATE_EWPOOL:	case OP_CREATE_EWPOOL:
{	{
PUSH(wcontext);	PUSH(wcontext);
wcontext=NEW WWrapper(pool(), 0 /* empty */);	wcontext=NEW WWrapper(pool(), 0 /* empty /, true / constructing */);
break;	break;
}	}
case OP_REDUCE_EWPOOL:	case OP_REDUCE_EWPOOL:
{	{
Value *value=wcontext->value_or_string();	Value *value=wcontext->result();
wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
PUSH(value);	PUSH(value);
break;	break;
Line 174 void Request::execute(const Array& ops)	Line 187 void Request::execute(const Array& ops)
PUSH(rcontext);	PUSH(rcontext);
rcontext=ncontext;	rcontext=ncontext;
PUSH(wcontext);	PUSH(wcontext);
wcontext=NEW WWrapper(pool(), ncontext);	wcontext=NEW WWrapper(pool(), ncontext, false /* not constructing */);
break;	break;
}	}
case OP_REDUCE_RWPOOL:	case OP_REDUCE_RWPOOL:
{	{
String *string=wcontext->get_string();	String *string=wcontext->get_string();
Value *value=NEW VString(string);	Value value=NEW VString(string);
wcontext=static_cast<WContext *>(POP());	wcontext=static_cast<WContext *>(POP());
rcontext=POP();	rcontext=POP();
PUSH(value);	PUSH(value);
break;	break;
}	}

	// CALL
case OP_GET_METHOD_FRAME:	case OP_GET_METHOD_FRAME:
{	{
Value *value=POP();	Value *value=POP();
Line 194 void Request::execute(const Array& ops)	Line 208 void Request::execute(const Array& ops)
Junction *junction=value->get_junction();	Junction *junction=value->get_junction();
if(!junction)	if(!junction)
THROW(0,0,	THROW(0,0,
value->name(),	&value->name(),
"is not a method or a junction (it is '%s'), can not call it",	"type is '%s', can not call it (must be method or junction)",
value->type());	value->type());
//unless(method) method=operators.get_method[...;code/native_code](name)	//unless(method) method=operators.get_method[...;code/native_code](name)
VMethodFrame frame=NEW VMethodFrame(pool(), junction);	VMethodFrame frame=NEW VMethodFrame(pool(), junction);
PUSH(frame);	PUSH(frame);
Line 212 void Request::execute(const Array& ops)	Line 226 void Request::execute(const Array& ops)

case OP_CALL:	case OP_CALL:
{	{
printf("->\n");	fprintf(stderr, "->\n");
VMethodFrame frame=static_cast<VMethodFrame >(POP());	VMethodFrame frame=static_cast<VMethodFrame >(POP());
frame->fill_unspecified_params();	frame->fill_unspecified_params();
PUSH(self); PUSH(root); PUSH(rcontext); PUSH(wcontext);	PUSH(self);
//left_class=ncontext.get_class()	PUSH(root);
//right_class=frame.self.get_class()	PUSH(rcontext);
//self=f(left_class[thoughts' food], right_self[junction], right_class[static], wcontext.value()[dynamic], new(right_class)[construct])	PUSH(wcontext);
self=&frame->junction.self; // TODO: �� frame..self
frame->set_self(self);	VClass *called_class=frame->junction.self.get_class();
	// constructing?
	if(wcontext->constructing()) { // yes
	// constructor call: $some(^class:method(..))
	self=NEW VObject(pool(), *called_class);
	frame->write(self);
	} else { // no
	// context is object & is it my class or my parent's class?
	VClass *read_class=rcontext->get_class();
	if(read_class && read_class->is_or_derived_from(*called_class)) // yes
	self=rcontext; // class dynamic call
	else // no
	self=&frame->junction.self; // static or simple dynamic call
	}
	frame->set_self(*self);
	VAliased aliased=reinterpret_cast<VAliased >(self->get_aliased());
	Temp_alias temp_alias(aliased, frame->junction.vclass);
root=rcontext=wcontext=frame;	root=rcontext=wcontext=frame;
execute(frame->junction.method->code);	execute(frame->junction.method->code);
Value *value=wcontext->value();	Value *value=wcontext->result();
wcontext=static_cast<WContext *>(POP()); rcontext=POP(); root=POP(); self=POP();
	wcontext=static_cast<WContext *>(POP());
	rcontext=POP();
	root=POP();
	self=static_cast<VAliased *>(POP());
wcontext->write(value);	wcontext->write(value);
printf("<-returned");	fprintf(stderr, "<-returned");
break;	break;
}	}


default:	default:
printf("\tTODO");	fprintf(stderr, "\tTODO");
break;	break;
}	}
printf("\n");	fprintf(stderr, "\n");
}	}
}	}

Line 246 Value *Request::get_element() {	Line 279 Value *Request::get_element() {

if(value) {	if(value) {
Junction *junction=value->get_junction();	Junction *junction=value->get_junction();
if(junction && junction->code) { // is it a code junction?	if(junction && junction->code) { // is it a code-junction?
// autocalc it	// autocalc it
printf("ja->\n");	fprintf(stderr, "ja->\n");
PUSH(self); PUSH(root); PUSH(rcontext); PUSH(wcontext);	PUSH(self);
	PUSH(root);
	PUSH(rcontext);
	PUSH(wcontext);

// 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;	VCodeFrame frame(pool(), *junction->wcontext); wcontext=&frame;
Line 257 Value *Request::get_element() {	Line 294 Value *Request::get_element() {
root=junction->root;	root=junction->root;
rcontext=junction->rcontext;	rcontext=junction->rcontext;
execute(*junction->code);	execute(*junction->code);
// CodeFrame soul: string writes intercepted	// CodeFrame soul:
String *code_string_result=frame.get_string();	// string writes were intercepted
wcontext=static_cast<WContext *>(POP()); rcontext=POP(); root=POP(); self=POP();	// returning them as the result of getting code-junction
// writing string result to current context	value=NEW VString(*frame.get_string());
wcontext->write(code_string_result);
printf("<-ja returned");	wcontext=static_cast<WContext *>(POP());
	rcontext=POP();
	root=POP();
	self=static_cast<VAliased *>(POP());
	fprintf(stderr, "<-ja returned");
}	}
} else {	} else {
value=NEW VUnknown(pool());	value=NEW VUnknown(pool());

E-mail:

Removed from v.1.34
changed lines
	Added in v.1.46