void SimpleBackend::tryNextFunction () {
RK_TRACE (PHP);
if ((!busy) && (!command_stack.isEmpty ())) {
// clean up previous command if applicable
if (command_stack.first ()->complete) {
delete command_stack.first ();
command_stack.pop_front ();
if (!command_stack.count ()) return;
}
busy = true;
command_stack.first ()->complete = true;
current_flags = command_stack.first ()->flags;
current_type = command_stack.first ()->type;
current_values.clear ();
template_pos = 0;
if (current_type == Preprocess) current_template = preprocess_template;
else if (current_type == Printout) current_template = printout_template;
else if (current_type == Calculate) current_template = calculate_template;
else if (current_type == Preview) current_template = preview_template;
template_sep = current_template.indexOf ("!!!");
if (template_sep < 0) {
commandFinished ("");
return;
}
processCall ();
}
}
void
serverPstreamConn_impl::processRecdPacket(packetPtr const callPacketP,
callInfo *const callInfoP) {
packetPtr responsePacketP;
try {
processCall(this->registryP, callPacketP, callInfoP,
&responsePacketP);
} catch (exception const &e) {
throwf("Error executing received packet as an XML-RPC RPC. %s",
e.what());
}
try {
this->packetSocketP->writeWait(responsePacketP);
} catch (exception const &e) {
throwf("Failed to write the response to the packet socket. %s",
e.what());
}
}
void StackMachine::execute(Code * code) {
code_ = code;
data_stack_.reserve(max_stack_size_);
return_addresses_.reserve(max_stack_size_);
stack_frame_starts_.reserve(max_stack_size_);
stack_top_ptr_ = data_stack_.data();
return_addresses_top_ptr_ = return_addresses_.data();
stack_frame_starts_top_ptr_ = stack_frame_starts_.data();
current_stack_frame_start_ = stack_top_ptr_;
frame_start_of_last_function_call_.reserve(functionsCount(code));
current_function_ = nullptr;
processCall(0);
run();
}
int main (int argc, char *argv[])
{
int currArg = 1;
int lastArg = 0;
int i;
if(argc < 4 || argc > 8) {
printError("Usage: PDGCS_read [-g] [-TARG:abi=nXX] [-TENV:PIC] -o <output_file> <input_file>\n");
exit(1);
}
while( lastArg != currArg ){
lastArg = currArg;
if(!strncmp(argv[currArg], "-g",2)) {
if(argv[currArg][2] == '\0')
Debug_Level = 2;
else
Debug_Level = atoi(&argv[currArg][2]);
currArg++;
}
if (!strncmp(argv[currArg], "-ej",3)) {
One_Trip_Do_Loops = 1;
currArg++;
}
if (!strncmp(argv[currArg], "-YVF_CHAR",9)) {
VF_CHAR_OPTION = 1;
currArg++;
}
if (!strncmp(argv[currArg], "-TENV:PIC",9)) {
Gen_PIC_Shared = 1;
currArg++;
}
if (!strncmp(argv[currArg], "-TARG:abi=n32",13)) {
ABI_Name = "n32";
currArg++;
}
if (!strncmp(argv[currArg], "-TARG:abi=n64",13)) {
ABI_Name = "n64";
currArg++;
}
if (!strncmp(argv[currArg], "-std_return",11)) {
Standard_Return = 1;
currArg++;
}
if(!strncmp(argv[currArg], "-f90debug_names:folded",22)){
Debug_Name_Folding = 1;
currArg++;
}
if(!strncmp(argv[currArg], "-f90debug_names:asis",20)){
Debug_Name_Folding = 0;
currArg++;
}
}
PDGCS_entry_no_SGI_fe();
if(strcmp(argv[currArg], "-o")) {
printError("Usage: no output file specified\n");
for(i = 0; i < argc; i++)
printf("%s\n", argv[i]);
}
currArg++;
Irb_File_Name = strdup(argv[currArg]);
currArg++;
infile = fopen(argv[currArg], "r");
if(!infile)
{
char buf[1024];
sprintf(buf, "Unable to open file: \"%s\"", argv[currArg]);
printError(buf);
}
initPdgTbl();
while(processCall());
return 0;
}
void StackMachine::run() {
while (true) {
Instruction current_instruction = currentBytecode().getInsn(current_location_++);
char const * v = 0;
switch (current_instruction) {
case BC_DLOAD:
push(currentBytecode().getDouble(current_location_));
current_location_ += sizeof(double);
break;
case BC_DLOAD0:
push(0.0);
break;
case BC_DLOAD1:
push(1.0);
break;
case BC_ILOAD:
push(currentBytecode().getInt64(current_location_));
current_location_ += sizeof(vm_int_t);
break;
case BC_ILOAD0:
push(vm_int_t(0L));
break;
case BC_ILOAD1:
push(vm_int_t(1L));
break;
case BC_SLOAD:
push(code_->constantById(getCurrent2BytesAndShiftLocation()).c_str());
break;
case BC_SLOAD0:
push(__EMPTY_STRING);
break;
case BC_DADD:
PUSH_BINARY_RESULT(double, std::plus<double>());
break;
case BC_DSUB:
PUSH_BINARY_RESULT(double, std::minus<double>());
break;
case BC_DMUL:
PUSH_BINARY_RESULT(double, std::multiplies<double>());
break;
case BC_DDIV:
PUSH_BINARY_RESULT(double, std::divides<double>());
break;
case BC_IADD:
PUSH_BINARY_RESULT(vm_int_t, std::plus<vm_int_t>());
break;
case BC_ISUB:
PUSH_BINARY_RESULT(vm_int_t, std::minus<vm_int_t>());
break;
case BC_IMUL:
PUSH_BINARY_RESULT(vm_int_t, std::multiplies<vm_int_t>());
break;
case BC_IDIV:
PUSH_BINARY_RESULT(vm_int_t, std::divides<vm_int_t>());
break;
case BC_IMOD:
PUSH_BINARY_RESULT(vm_int_t, std::modulus<vm_int_t>());
break;
case BC_IAOR:
PUSH_BINARY_RESULT(vm_int_t, std::bit_or<vm_int_t>());
break;
case BC_IAAND:
PUSH_BINARY_RESULT(vm_int_t, std::bit_and<vm_int_t>());
break;
case BC_IAXOR:
PUSH_BINARY_RESULT(vm_int_t, std::bit_xor<vm_int_t>());
break;
case BC_DCMP:
PUSH_BINARY_RESULT_(double, vm_int_t, cmp<double>);
break;
case BC_ICMP:
PUSH_BINARY_RESULT(vm_int_t, cmp<vm_int_t>);
break;
case BC_DNEG:
push(-popDouble());
break;
case BC_INEG:
push(-popInt());
break;
case BC_IPRINT:
os_ << popInt();
os_.flush();
break;
case BC_DPRINT:
os_ << popDouble();
os_.flush();
break;
case BC_SPRINT:
v = popString();
os_ << (v == 0 ? "" : v);
os_.flush();
break;
case BC_I2D:
push((double) popInt());
break;
case BC_S2I:
v = popString();
try {
push((vm_int_t) v);
} catch (std::exception & e) {
throwError("S2I conversion error: " + string(v));
}
break;
case BC_D2I:
push((vm_int_t) popDouble());
break;
case BC_POP:
pop();
break;
case BC_LOADDVAR0:
loadLocalVar<double>(0);
break;
case BC_LOADDVAR1:
loadLocalVar<double>(1);
break;
case BC_LOADDVAR2:
loadLocalVar<double>(2);
break;
case BC_LOADDVAR3:
loadLocalVar<double>(3);
break;
case BC_LOADDVAR:
loadLocalVar<double>(getCurrent2BytesAndShiftLocation());
break;
case BC_LOADIVAR0:
loadLocalVar<vm_int_t>(0);
break;
case BC_LOADIVAR1:
loadLocalVar<vm_int_t>(1);
break;
case BC_LOADIVAR2:
loadLocalVar<vm_int_t>(2);
break;
case BC_LOADIVAR3:
loadLocalVar<vm_int_t>(3);
break;
case BC_LOADIVAR:
loadLocalVar<vm_int_t>(getCurrent2BytesAndShiftLocation());
break;
case BC_LOADSVAR0:
loadLocalVar<vm_str_t>(0);
break;
case BC_LOADSVAR1:
loadLocalVar<vm_str_t>(1);
break;
case BC_LOADSVAR2:
loadLocalVar<vm_str_t>(2);
break;
case BC_LOADSVAR3:
loadLocalVar<vm_str_t>(3);
break;
case BC_LOADSVAR:
loadLocalVar<vm_str_t>(getCurrent2BytesAndShiftLocation());
break;
case BC_STOREDVAR0:
storeLocalVar<double>(0);
break;
case BC_STOREDVAR1:
storeLocalVar<double>(1);
break;
case BC_STOREDVAR2:
storeLocalVar<double>(2);
break;
case BC_STOREDVAR3:
storeLocalVar<double>(3);
break;
case BC_STOREDVAR:
storeLocalVar<double>(getCurrent2BytesAndShiftLocation());
break;
case BC_STOREIVAR0:
storeLocalVar<vm_int_t>(0);
break;
case BC_STOREIVAR1:
storeLocalVar<vm_int_t>(1);
break;
case BC_STOREIVAR2:
storeLocalVar<vm_int_t>(2);
break;
case BC_STOREIVAR3:
storeLocalVar<vm_int_t>(3);
break;
case BC_STOREIVAR:
storeLocalVar<vm_int_t>(getCurrent2BytesAndShiftLocation());
break;
case BC_STORESVAR0:
storeLocalVar<vm_str_t>(0);
break;
case BC_STORESVAR1:
storeLocalVar<vm_str_t>(1);
break;
case BC_STORESVAR2:
storeLocalVar<vm_str_t>(2);
break;
case BC_STORESVAR3:
storeLocalVar<vm_str_t>(3);
break;
case BC_STORESVAR:
storeLocalVar<vm_str_t>(getCurrent2BytesAndShiftLocation());
break;
case BC_LOADCTXDVAR:
processLoadContextVar<double>();
break;
case BC_LOADCTXIVAR:
processLoadContextVar<vm_int_t>();
break;
case BC_LOADCTXSVAR:
processLoadContextVar<vm_str_t>();
break;
case BC_STORECTXDVAR:
processStoreContextVar<double>();
break;
case BC_STORECTXIVAR:
processStoreContextVar<vm_int_t>();
break;
case BC_STORECTXSVAR:
processStoreContextVar<vm_str_t>();
break;
case BC_JA:
current_location_ = calculateTransitionAndShiftLocation();
continue;
case BC_IFICMPE:
case BC_IFICMPNE:
case BC_IFICMPL:
case BC_IFICMPLE:
case BC_IFICMPG:
case BC_IFICMPGE: {
index_t transition = calculateTransitionAndShiftLocation();
vm_int_t a = popInt();
vm_int_t b = popInt();
if (ifSatisfied(current_instruction, cmp(a, b))) {
current_location_= transition;
continue;
}
break;
}
case BC_CALL:
processCall(getCurrent2BytesAndShiftLocation());
break;
case BC_CALLNATIVE:
processNativeCall(getCurrent2BytesAndShiftLocation());
continue;
case BC_RETURN:
if (processReturn()) {
return;
}
continue;
default:
throwError("unsupported insn=" + string(bytecodeName(current_instruction)));
return;
}
}
}
Status *BytecodeInterpreter::execute(vector<Var *> &) try {
#ifdef BCPRINT
disassemble();
return Status::Ok();
#endif
#ifdef MATHVM_WITH_SDL
pre_init_sdl();
#endif
processCall(0);
while (pointer() < bc()->length()) {
Instruction instruction = next();
switch (instruction) {
case BC_INVALID: throw "Invalid code";
case BC_DLOAD: operandStack.push_back(bc_read<double>()); break;
case BC_ILOAD: operandStack.push_back(bc_read<int64_t>()); break;
case BC_SLOAD: operandStack.push_back(constantById(bc_read<uint16_t>()).c_str()); break;
case BC_DLOAD0: operandStack.push_back((double)0); break;
case BC_ILOAD0: operandStack.push_back((int64_t)0); break;
case BC_SLOAD0: operandStack.push_back(constantById(0).c_str()); break;
case BC_DLOAD1: operandStack.push_back((double)1.0); break;
case BC_ILOAD1: operandStack.push_back((int64_t)1); break;
case BC_DLOADM1: operandStack.push_back((double) - 1.0); break;
case BC_ILOADM1: operandStack.push_back((int64_t) - 1); break;
case BC_DADD: operandStack.push_back(pop_return().d + pop_return().d); break;
case BC_IADD: operandStack.push_back(pop_return().i + pop_return().i); break;
case BC_DSUB: operandStack.push_back(pop_return().d - pop_return().d); break;
case BC_ISUB: operandStack.push_back(pop_return().i - pop_return().i); break;
case BC_DMUL: operandStack.push_back(pop_return().d * pop_return().d); break;
case BC_IMUL: operandStack.push_back(pop_return().i * pop_return().i); break;
case BC_DDIV: operandStack.push_back(pop_return().d / pop_return().d); break;
case BC_IDIV: operandStack.push_back(pop_return().i / pop_return().i); break;
case BC_IMOD: operandStack.push_back(pop_return().i % pop_return().i); break;
case BC_IAOR: operandStack.push_back(pop_return().i | pop_return().i); break;
case BC_IAAND: operandStack.push_back(pop_return().i & pop_return().i); break;
case BC_IAXOR: operandStack.push_back(pop_return().i ^ pop_return().i); break;
case BC_DNEG: operandStack.back().d = -operandStack.back().d; break;
case BC_INEG: operandStack.back().i = -operandStack.back().i; break;
case BC_DPRINT: std::cout << pop_return().d << std::flush; break;
case BC_IPRINT: std::cout << pop_return().i << std::flush; break;
case BC_SPRINT: std::cout << pop_return().c << std::flush; break;
case BC_I2D: operandStack.back().d = operandStack.back().i; break;
case BC_D2I : operandStack.back().i = operandStack.back().d; break;
case BC_S2I: operandStack.back().i = reinterpret_cast<int64_t>(operandStack.back().c); break;
case BC_SWAP: std::iter_swap(operandStack.end() - 1, operandStack.end() - 2); break;
case BC_POP: operandStack.pop_back(); break;
case BC_LOADDVAR:
case BC_LOADIVAR:
case BC_LOADSVAR: operandStack.push_back(value(bc_read<uint16_t>())); break;
case BC_STOREDVAR:
case BC_STOREIVAR:
case BC_STORESVAR: value(bc_read<uint16_t>()) = pop_return(); break;
case BC_LOADCTXDVAR:
case BC_LOADCTXIVAR:
case BC_LOADCTXSVAR: operandStack.push_back(value(bc_read<uint16_t>(), bc_read<uint16_t>())); break;
case BC_STORECTXDVAR:
case BC_STORECTXIVAR:
case BC_STORECTXSVAR: value(bc_read<uint16_t>(), bc_read<uint16_t>()) = pop_return(); break;
case BC_DCMP: operandStack.push_back(compare<double>(pop_return().d, pop_return().d)); break;
case BC_ICMP: operandStack.push_back(compare<int64_t>(pop_return().i, pop_return().i)); break;
case BC_JA: pointer() += bc()->getInt16(pointer()); break;
case BC_IFICMPE: pointer() += pop_return().i == pop_return().i ? bc()->getInt16(pointer()) : sizeof(int16_t); break;
case BC_IFICMPNE: pointer() += pop_return().i != pop_return().i ? bc()->getInt16(pointer()) : sizeof(int16_t); break;
case BC_IFICMPG: pointer() += pop_return().i > pop_return().i ? bc()->getInt16(pointer()) : sizeof(int16_t); break;
case BC_IFICMPGE: pointer() += pop_return().i >= pop_return().i ? bc()->getInt16(pointer()) : sizeof(int16_t); break;
case BC_IFICMPL: pointer() += pop_return().i < pop_return().i ? bc()->getInt16(pointer()) : sizeof(int16_t); break;
case BC_IFICMPLE: pointer() += pop_return().i <= pop_return().i ? bc()->getInt16(pointer()) : sizeof(int16_t); break;
case BC_CALL: processCall(bc_read<uint16_t>()); break;
case BC_CALLNATIVE: processNativeCall(bc_read<uint16_t>()); break;
case BC_RETURN: processReturn(); break;
case BC_BREAK: break;
case BC_DUMP: std::cout << operandStack.back().i << std::endl; break;
case BC_STOP: return Status::Warning("Execution stopped");
default: throw "Not implemented"; break;
}
}
return Status::Ok();
} catch (const char *msg) {
return Status::Error(msg);
}
virtual double Run(CVectorBratAlgorithmParam& args) override
{
double result;
return processCall( PyObject_CallMethod( m_instance, ccast( "Run" ),ccast( "(O)"), createPyArguments( args ) ), result );
}
void SimpleBackend::writeData (const QString &data) {
RK_TRACE (PHP);
current_values.append (data);
processCall ();
}
virtual std::string GetOutputUnit() const override
{
std::string result;
return processCall( PyObject_CallMethod( m_instance, ccast( "GetOutputUnit" ), nullptr ), result );
}
virtual std::string GetInputParamUnit(uint32_t indexParam) const override
{
std::string result;
return processCall( PyObject_CallMethod( m_instance, ccast( "GetInputParamUnit" ), ccast( "(i)" ), indexParam ), result );
}
virtual CBratAlgorithmParam::bratAlgoParamTypeVal GetInputParamFormat(uint32_t indexParam) const override
{
uint32_t result;
return (CBratAlgorithmParam::bratAlgoParamTypeVal)
processCall( PyObject_CallMethod( m_instance, ccast( "GetInputParamFormat" ), ccast( "(i)" ), indexParam ), result );
}
virtual uint32_t GetNumInputParam() const override
{
uint32_t result;
return processCall( PyObject_CallMethod( m_instance, ccast( "GetNumInputParam" ), nullptr ), result );
}
virtual std::string GetDescription() const override
{
std::string result;
return processCall( PyObject_CallMethod( m_instance, ccast( "GetDescription" ), nullptr ), result );
}
