mirror of
https://github.com/corda/corda.git
synced 2025-01-10 15:03:02 +00:00
6f1d02dae7
The trick is to make all destructors non-virtual. This is safe because we never use the delete operator, which is the only case where virtual destructors are relevant. This is a better solution than implementing our own delete operator, because we want libraries loaded at runtime to use the libstdc++ version, not ours.
149 lines
3.2 KiB
C++
149 lines
3.2 KiB
C++
/* Copyright (c) 2008, Avian Contributors
|
|
|
|
Permission to use, copy, modify, and/or distribute this software
|
|
for any purpose with or without fee is hereby granted, provided
|
|
that the above copyright notice and this permission notice appear
|
|
in all copies.
|
|
|
|
There is NO WARRANTY for this software. See license.txt for
|
|
details. */
|
|
|
|
#ifndef PROCESSOR_H
|
|
#define PROCESSOR_H
|
|
|
|
#include "common.h"
|
|
#include "system.h"
|
|
#include "heap.h"
|
|
|
|
namespace vm {
|
|
|
|
class Processor {
|
|
public:
|
|
class StackWalker;
|
|
|
|
class StackVisitor {
|
|
public:
|
|
virtual bool visit(StackWalker* walker) = 0;
|
|
};
|
|
|
|
class StackWalker {
|
|
public:
|
|
virtual void walk(StackVisitor* v) = 0;
|
|
|
|
virtual object method() = 0;
|
|
|
|
virtual int ip() = 0;
|
|
|
|
virtual unsigned count() = 0;
|
|
};
|
|
|
|
virtual Thread*
|
|
makeThread(Machine* m, object javaThread, Thread* parent) = 0;
|
|
|
|
virtual object
|
|
makeMethod(Thread* t,
|
|
uint8_t vmFlags,
|
|
uint8_t returnCode,
|
|
uint8_t parameterCount,
|
|
uint8_t parameterFootprint,
|
|
uint16_t flags,
|
|
uint16_t offset,
|
|
object name,
|
|
object spec,
|
|
object class_,
|
|
object code) = 0;
|
|
|
|
virtual object
|
|
makeClass(Thread* t,
|
|
uint16_t flags,
|
|
uint8_t vmFlags,
|
|
uint8_t arrayDimensions,
|
|
uint16_t fixedSize,
|
|
uint16_t arrayElementSize,
|
|
object objectMask,
|
|
object name,
|
|
object super,
|
|
object interfaceTable,
|
|
object virtualTable,
|
|
object fieldTable,
|
|
object methodTable,
|
|
object staticTable,
|
|
object loader,
|
|
unsigned vtableLength) = 0;
|
|
|
|
virtual void
|
|
initVtable(Thread* t, object c) = 0;
|
|
|
|
virtual void
|
|
initClass(Thread* t, object c) = 0;
|
|
|
|
virtual void
|
|
visitObjects(Thread* t, Heap::Visitor* v) = 0;
|
|
|
|
virtual void
|
|
walkStack(Thread* t, StackVisitor* v) = 0;
|
|
|
|
virtual int
|
|
lineNumber(Thread* t, object method, int ip) = 0;
|
|
|
|
virtual object*
|
|
makeLocalReference(Thread* t, object o) = 0;
|
|
|
|
virtual void
|
|
disposeLocalReference(Thread* t, object* r) = 0;
|
|
|
|
virtual object
|
|
invokeArray(Thread* t, object method, object this_, object arguments) = 0;
|
|
|
|
virtual object
|
|
invokeList(Thread* t, object method, object this_, bool indirectObjects,
|
|
va_list arguments) = 0;
|
|
|
|
virtual object
|
|
invokeList(Thread* t, const char* className, const char* methodName,
|
|
const char* methodSpec, object this_, va_list arguments) = 0;
|
|
|
|
virtual void
|
|
dispose(Thread* t) = 0;
|
|
|
|
virtual void
|
|
dispose() = 0;
|
|
|
|
virtual object
|
|
getStackTrace(Thread* t, Thread* target) = 0;
|
|
|
|
object
|
|
invoke(Thread* t, object method, object this_, ...)
|
|
{
|
|
va_list a;
|
|
va_start(a, this_);
|
|
|
|
object r = invokeList(t, method, this_, false, a);
|
|
|
|
va_end(a);
|
|
|
|
return r;
|
|
}
|
|
|
|
object
|
|
invoke(Thread* t, const char* className, const char* methodName,
|
|
const char* methodSpec, object this_, ...)
|
|
{
|
|
va_list a;
|
|
va_start(a, this_);
|
|
|
|
object r = invokeList(t, className, methodName, methodSpec, this_, a);
|
|
|
|
va_end(a);
|
|
|
|
return r;
|
|
}
|
|
};
|
|
|
|
Processor*
|
|
makeProcessor(System* system, Allocator* allocator);
|
|
|
|
} // namespace vm
|
|
|
|
#endif//PROCESSOR_H
|