void JITLinker::ReferenceHelper :: writeReference(MemoryWriter& writer, ref_t reference, size_t disp, _Module* module)
{
ref_t mask = reference & mskAnyRef;
ref_t refID = reference & ~mskAnyRef;
//// check if it is a constant, resolve it immediately
//if (mask == mskLinkerConstant) {
// writer.writeDWord(getLinkerConstant(refID));
// return;
//}
if (!module)
module = _module;
ref_t position = writer.Position();
writer.writeDWord(disp);
// vmt entry offset should be resolved later
if (mask == mskVMTEntryOffset) {
_references->add(position, RefInfo(reference, module));
return;
}
// try to resolve immediately
void* vaddress = _owner->_loader->resolveReference(
_owner->_loader->retrieveReference(module, refID, mask), mask);
if (vaddress != LOADER_NOTLOADED) {
resolveReference(writer.Memory(), position, (ref_t)vaddress, mask, _owner->_virtualMode);
}
// or resolve later
else _references->add(position, RefInfo(reference, module));
}
int CFParser :: buildDerivationTree(_ScriptReader& reader, size_t startRuleId, MemoryWriter& writer)
{
DerivationQueue predictions;
predictions.push(DerivationItem(startRuleId, 0, -1));
ScriptBookmark bm;
while (predictions.Count() > 0) {
predictions.push(DerivationItem(0));
bm = reader.read();
int terminalOffset = writer.Position();
writer.write(&bm, sizeof(ScriptBookmark));
DerivationItem current = predictions.pop();
while (current.ruleId != 0) {
if (current.ruleId == -1) {
return current.trace;
}
predict(predictions, current, reader, bm, terminalOffset, writer);
current = predictions.pop();
}
}
throw EParseError(bm.column, bm.row);
}
void TriangleEncoder::encode(
const vector<TriangleVertexInfo>& triangle_vertex_infos,
const vector<GVector3>& triangle_vertices,
const vector<size_t>& triangle_indices,
const size_t item_begin,
const size_t item_count,
MemoryWriter& writer)
{
for (size_t i = 0; i < item_count; ++i)
{
const size_t triangle_index = triangle_indices[item_begin + i];
const TriangleVertexInfo& vertex_info = triangle_vertex_infos[triangle_index];
writer.write(static_cast<uint32>(vertex_info.m_motion_segment_count));
if (vertex_info.m_motion_segment_count == 0)
{
writer.write(
GTriangleType(
triangle_vertices[vertex_info.m_vertex_index + 0],
triangle_vertices[vertex_info.m_vertex_index + 1],
triangle_vertices[vertex_info.m_vertex_index + 2]));
}
else
{
writer.write(
&triangle_vertices[vertex_info.m_vertex_index],
(vertex_info.m_motion_segment_count + 1) * 3 * sizeof(GVector3));
}
}
}
FMT_FUNC void SystemError::init(
int err_code, CStringRef format_str, ArgList args) {
error_code_ = err_code;
MemoryWriter w;
format_system_error(w, err_code, format(format_str, args));
std::runtime_error &base = *this;
base = std::runtime_error(w.str());
}
FMT_FUNC void fmt::WindowsError::init(
int err_code, StringRef format_str, ArgList args) {
error_code_ = err_code;
MemoryWriter w;
internal::format_windows_error(w, err_code, format(format_str, args));
std::runtime_error &base = *this;
base = std::runtime_error(w.str());
}
void Instance::ImageReferenceHelper :: writeReference(MemoryWriter& writer, ref_t reference, size_t disp, _Module* module)
{
size_t pos = reference & ~mskAnyRef;
if (test(reference, mskRelCodeRef)) {
writer.writeDWord(pos - writer.Position() - 4);
}
else writer.writeDWord((test(reference, mskRDataRef) ? _statBase : _codeBase) + pos + disp);
}
inline int writeTrailItem(MemoryWriter& writer, int nonterminal, int next)
{
int offset = writer.Position();
writer.writeDWord(nonterminal);
writer.writeDWord(next);
return offset;
}
int JITCompiler32 :: allocateConstant(MemoryWriter& writer, size_t objectOffset)
{
writer.writeBytes(0, objectOffset);
alignCode(&writer, VA_ALIGNMENT, false);
return writer.Position() - 4;
}
inline int writeDerivationItem(MemoryWriter& writer, int key, int terminal, int trace)
{
int offset = writer.Position();
writer.writeDWord(key);
writer.writeDWord(terminal);
writer.writeDWord(trace);
return offset;
}
size_t JITLinker :: loadMethod(ReferenceHelper& refHelper, MemoryReader& reader, MemoryWriter& writer)
{
size_t position = writer.Position();
// method just in time compilation
_compiler->compileProcedure(refHelper, reader, writer);
return _virtualMode ? position : (size_t)writer.Memory()->get(position);
}
void Instance::ImageReferenceHelper :: writeReference(MemoryWriter& writer, void* vaddress, bool relative, size_t disp)
{
ref_t address = (ref_t)vaddress;
// calculate relative address
if (relative)
address -= ((ref_t)writer.Address() + 4);
writer.writeDWord(address + disp);
}
void ECodesAssembler :: writeCommand(ByteCommand command, MemoryWriter& writer)
{
writer.writeByte(command.code);
if (command.code > MAX_SINGLE_ECODE) {
writer.writeDWord(command.argument);
}
if (command.code > MAX_DOUBLE_ECODE) {
writer.writeDWord(command.additional);
}
}
void ECodesAssembler :: writeCommand(ByteCommand command, MemoryWriter& writer)
{
writer.writeByte(command.code);
if (command.code >= 0x20) {
writer.writeDWord(command.argument);
}
if (command.code >= 0xE0) {
writer.writeDWord(command.additional);
}
}
void ECodesAssembler :: fixJump(const wchar16_t* label, MemoryWriter& writer, LabelInfo& info)
{
_Memory* code = writer.Memory();
Map<const wchar16_t*, int>::Iterator it = info.fwdJumps.start();
while (!it.Eof()) {
if (StringHelper::compare(it.key(), label)) {
(*code)[*it] = writer.Position();
}
it++;
}
}
void ECodesAssembler :: fixJump(ident_t label, MemoryWriter& writer, LabelInfo& info)
{
_Memory* code = writer.Memory();
Map<ident_t, int>::Iterator it = info.fwdJumps.start();
while (!it.Eof()) {
if (label.compare(it.key())) {
(*code)[*it] = writer.Position() - *it - 4;
}
it++;
}
}
void JITLinker::ReferenceHelper :: writeReference(MemoryWriter& writer, void* vaddress, bool relative, size_t disp)
{
if (!_owner->_virtualMode) {
ref_t address = (ref_t)vaddress;
// calculate relative address
if (relative)
address -= ((ref_t)writer.Address() + 4);
writer.writeDWord(address + disp);
}
else if (relative) {
writer.writeRef(((ref_t)vaddress | mskRelCodeRef), disp);
}
else writer.writeRef((ref_t)vaddress, disp);
}
void ECodesAssembler :: compileJump(ByteCode code, TokenInfo& token, MemoryWriter& writer, LabelInfo& info)
{
writer.writeByte(code);
int label = 0;
token.read();
if (info.labels.exist(token.value)) {
label = info.labels.get(token.value) - writer.Position() - 4;
}
else {
info.fwdJumps.add(token.value, writer.Position());
}
writer.writeDWord(label);
}
void JITCompiler32 :: allocateVMT(MemoryWriter& vmtWriter, size_t flags, size_t vmtLength)
{
alignCode(&vmtWriter, VA_ALIGNMENT, false);
// create VMT header:
// dummy package reference
vmtWriter.writeDWord(0);
// vmt length
vmtWriter.writeDWord(vmtLength);
// vmt flags
vmtWriter.writeDWord(flags);
// dummy class reference
vmtWriter.writeDWord(0);
int position = vmtWriter.Position();
size_t vmtSize = 0;
if (test(flags, elStandartVMT)) {
// + VMT length
vmtSize = vmtLength * sizeof(VMTEntry);
}
vmtWriter.writeBytes(0, vmtSize);
vmtWriter.seek(position);
}
void ECodesAssembler :: compileRJump(ByteCode code, TokenInfo& token, MemoryWriter& writer, LabelInfo& info, _Module* binary)
{
writer.writeByte(code);
int label = 0;
token.read();
if (info.labels.exist(token.value)) {
label = info.labels.get(token.value) - writer.Position() - 8;
}
else {
info.fwdJumps.add(token.value, writer.Position() + 4);
}
size_t reference = compileRArg(token, binary);
writer.writeDWord(reference);
writer.writeDWord(label);
}
void ECodesAssembler :: compileMccJump(ByteCode code, TokenInfo& token, MemoryWriter& writer, LabelInfo& info)
{
writer.writeByte(code);
int label = 0;
token.read();
if (info.labels.exist(token.value)) {
label = info.labels.get(token.value) - writer.Position() - 8;
}
else {
info.fwdJumps.add(token.value, 4 + writer.Position());
}
int message = token.readInteger(constants);
writer.writeDWord(message);
writer.writeDWord(label);
}
inline void writeTapeRecord(MemoryWriter& tape, size_t command, ident_t value, bool forward = false)
{
tape.writeDWord(command);
if (!emptystr(value)) {
if (forward) {
tape.writeDWord(getlength(value) + 1 + FORWARD_PREFIX_NS_LEN);
tape.writeLiteral(FORWARD_PREFIX_NS, FORWARD_PREFIX_NS_LEN);
tape.writeLiteral(value, getlength(value) + 1);
}
else {
tape.writeDWord(getlength(value) + 1);
tape.writeLiteral(value, getlength(value) + 1);
}
}
else tape.writeDWord(0);
}
inline void writeTapeRecord(MemoryWriter& tape, size_t command, ident_t value1, ident_t value2)
{
tape.writeDWord(command);
// write total length including equal sign
tape.writeDWord(getlength(value1) + getlength(value2) + 2);
if (!emptystr(value1)) {
tape.writeLiteral(value1, getlength(value1));
tape.writeChar('=');
}
if (!emptystr(value2)) {
tape.writeLiteral(value2);
}
else tape.writeChar((char)0);
}
bool ex_writer(void *arg) {
ITheFramework *frame = Factory::GetFramework();
Decorator *decorator = ssi_create (Decorator, 0, true);
frame->AddDecorator(decorator);
Mouse *mouse = ssi_create (Mouse, 0, true);
ITransformable *cursor_p = frame->AddProvider(mouse, SSI_MOUSE_CURSOR_PROVIDER_NAME);
frame->AddSensor(mouse);
File::SetLogLevel(SSI_LOG_LEVEL_DEBUG);
bool continuous = true;
MemoryWriter *memory;
memory = ssi_create(MemoryWriter, 0, true);
memory->getOptions()->setSize("10.0s");
frame->AddConsumer(cursor_p, memory, "0.5s");
FileWriter *writer;
writer = ssi_create(FileWriter, 0, true);
writer->getOptions()->setPath("");
writer->getOptions()->setDelim(" ; ");
writer->getOptions()->type = File::ASCII;
writer->getOptions()->stream = continuous;
frame->AddConsumer(cursor_p, writer, "0.5s");
writer = ssi_create (FileWriter, 0, true);
writer->getOptions()->setPath("cursor_txt");
writer->getOptions()->type = File::ASCII;
writer->getOptions()->setDelim(";");
writer->getOptions()->stream = continuous;
writer->getOptions()->setMeta("some=meta;hello=world");
frame->AddConsumer(cursor_p, writer, "0.5s");
writer = ssi_create (FileWriter, 0, true);
writer->getOptions()->setPath("cursor_bin");
writer->getOptions()->type = File::BINARY;
writer->getOptions()->stream = continuous;
frame->AddConsumer(cursor_p, writer, "0.5s");
writer = ssi_create (FileWriter, 0, true);
writer->getOptions()->setPath("cursor_lz4");
writer->getOptions()->type = File::BIN_LZ4;
writer->getOptions()->stream = continuous;
frame->AddConsumer(cursor_p, writer, "0.5s");
decorator->add("console", 0, 0, 650, 800);
decorator->add("plot*", 650, 0, 400, 400);
decorator->add("monitor*", 650, 400, 400, 400);
frame->Start();
frame->Wait();
frame->Stop();
frame->Clear();
ssi_stream_print(memory->getStream(), stdout);
return true;
}
void JITCompiler32 :: fixVMT(MemoryWriter& vmtWriter, void* classClassVAddress, void* packageVAddress, int count, bool virtualMode)
{
_Memory* image = vmtWriter.Memory();
// update class package reference if available
if (packageVAddress != NULL) {
int position = vmtWriter.Position();
vmtWriter.seek(position - 0x10);
if (virtualMode) {
vmtWriter.writeRef((ref_t)packageVAddress, 0);
}
else vmtWriter.writeDWord((int)packageVAddress);
vmtWriter.seek(position);
}
// update class vmt reference if available
if (classClassVAddress != NULL) {
vmtWriter.seek(vmtWriter.Position() - 4);
if (virtualMode) {
vmtWriter.writeRef((ref_t)classClassVAddress, 0);
}
else vmtWriter.writeDWord((int)classClassVAddress);
}
// if in virtual mode mark method addresses as reference
if (virtualMode) {
ref_t entryPosition = vmtWriter.Position();
for (int i = 0 ; i < count ; i++) {
image->addReference(mskCodeRef, entryPosition + 4);
entryPosition += 8;
}
}
}
void Instance::ImageReferenceHelper :: writeTape(MemoryWriter& tape, void* vaddress, int mask)
{
int ref = (size_t)vaddress - (test(mask, mskRDataRef) ? _statBase : _codeBase);
tape.writeDWord(ref | mask);
}
bool Extract(params_t ¶ms, FilePath *inPath, FilePath *outPath, FilePath *annoPath)
{
ssi_char_t *toPath = 0;
if (ssi_strcmp(outPath->getExtension(), annoPath ? SSI_FILE_TYPE_SAMPLES : SSI_FILE_TYPE_STREAM, false))
{
toPath = ssi_strcpy(outPath->getPath());
}
else
{
toPath = ssi_strcpy(outPath->getPathFull());
}
Chain *chain = ssi_create_id(Chain, 0, "chain");
chain->getOptions()->set(params.chainPathAbsolute);
ssi_stream_t from;
bool result = false;
bool isVideoFile = IsVideoFile(inPath->getNameFull());
bool isAudioFile = IsAudioFile(inPath->getNameFull());
if (isVideoFile)
{
if (annoPath)
{
ssi_wrn("cannot extract video features for an annotation");
return false;
}
FFMPEGReader *reader = ssi_create(FFMPEGReader, 0, false);
reader->getOptions()->setUrl(inPath->getPathFull());
reader->getOptions()->bestEffort = true;
FileWriter *writer = ssi_create(FileWriter, 0, false);
writer->getOptions()->overwrite = true;
writer->getOptions()->setPath(toPath);
writer->getOptions()->type = File::BINARY;
FileProvider *provider = new FileProvider(writer, chain);
reader->setProvider(SSI_FFMPEGREADER_VIDEO_PROVIDER_NAME, provider);
reader->connect();
reader->start();
reader->wait();
reader->stop();
reader->disconnect();
delete provider;
delete reader;
delete writer;
}
else if (isAudioFile)
{
FFMPEGReader *reader = ssi_create(FFMPEGReader, 0, false);
reader->getOptions()->setUrl(inPath->getPathFull());
reader->getOptions()->ablock = 0.05;
reader->getOptions()->bestEffort = true;
if (!reader->initAudioStream(inPath->getPathFull(), from)
|| from.num == 0)
{
return false;
}
MemoryWriter *writer = ssi_create(MemoryWriter, 0, false);
writer->setStream(from);
FileProvider *provider = new FileProvider(writer);
reader->setProvider(SSI_FFMPEGREADER_AUDIO_PROVIDER_NAME, provider);
reader->connect();
reader->start();
reader->wait();
reader->stop();
reader->disconnect();
delete provider;
delete reader;
delete writer;
result = true;
}
else
{
result = FileTools::ReadStreamFile(inPath->getPathFull(), from);
}
if (result)
{
ssi_stream_t to;
if (annoPath)
{
Annotation annotation;
if (result &= annotation.load(annoPath->getPathFull()))
{
if (annotation.getScheme()->type != SSI_SCHEME_TYPE::DISCRETE)
{
ssi_wrn("cannot extract features from a continuous annotation");
return false;
}
if (!ssi_strcmp(params.step, "0")) {
ssi_size_t step = 0, left = 0, right = 0;
if (!ssi_parse_samples(params.step, step, from.sr)) {
ssi_wrn("could not parse step size '%s'", params.step);
return false;
}
if (!ssi_parse_samples(params.left, left, from.sr)) {
ssi_wrn("could not parse left size '%s'", params.left);
return false;
}
if (!ssi_parse_samples(params.right, right, from.sr)) {
ssi_wrn("could not parse right size '%s'", params.right);
return false;
}
ssi_time_t step_t = step / from.sr;
ssi_time_t left_t = left / from.sr;
ssi_time_t right_t = right / from.sr;
annotation.convertToFrames(step_t, params.restClassName[0] == '\0' ? 0 : params.restClassName);
if (left_t > 0.0 || right_t > 0.0)
{
annotation.addOffset(left_t, right_t);
}
}
SampleList samples;
if (result &= annotation.extractSamples(from, &samples))
{
ISTransform samples_t(&samples);
samples_t.setTransformer(0, *chain);
samples_t.callEnter();
result &= ModelTools::SaveSampleList(samples_t, toPath, params.ascii ? File::ASCII : File::BINARY);
samples_t.callFlush();
}
}
}
else
{
if (ssi_strcmp(params.step, "0"))
{
SignalTools::Transform(from, to, *chain, 0u);
}
else
{
SignalTools::Transform(from, to, *chain, params.step, params.left, params.right);
}
result &= FileTools::WriteStreamFile(params.ascii ? File::ASCII : File::BINARY, toPath, to);
ssi_stream_destroy(to);
}
ssi_stream_destroy(from);
}
delete[] toPath;
return result;
}
inline void writeTapeRecord(MemoryWriter& tape, size_t command)
{
tape.writeDWord(command);
tape.writeDWord(0);
}
void ECodesAssembler :: compileCommand(TokenInfo& token, MemoryWriter& writer, LabelInfo& info, _Module* binary)
{
bool recognized = true;
ByteCode opcode = ByteCodeCompiler::code(token.value);
switch (opcode)
{
case bcNop:
case bcBreakpoint:
case bcPushB:
case bcPop:
case bcPushM:
case bcMCopyVerb:
case bcThrow:
case bcMCopySubj:
case bcPushA:
case bcPopA:
case bcACopyB:
case bcBCopyA:
case bcPopM:
case bcBSRedirect:
case bcBSGRedirect:
case bcClose:
case bcPopB:
case bcMQuit:
case bcGet:
case bcSet:
case bcALoadD:
case bcDDec:
case bcGetLen:
case bcDInc:
writeCommand(ByteCommand(opcode), writer);
break;
case bcCallR:
case bcACopyR:
compileRCommand(opcode, token, writer, binary);
break;
case bcACopyF:
case bcACallVI:
case bcALoadSI:
case bcASaveSI:
case bcPushFI:
case bcALoadAI:
case bcMLoadAI:
case bcMLoadSI:
case bcMLoadFI:
case bcMAddAI:
case bcPushAI:
case bcMSaveParams:
case bcPushSI:
case bcACopyS:
case bcDAddAI:
case bcDSubAI:
case bcDAddSI:
case bcDSubSI:
case bcDLoadAI:
case bcDSaveAI:
case bcDLoadSI:
case bcDSaveSI:
case bcDLoadFI:
case bcDSaveFI:
case bcPopSI:
compileICommand(opcode, token, writer);
break;
case bcOpen:
case bcMAdd:
case bcAJumpVI:
case bcMCopy:
case bcMReset:
case bcQuitN:
case bcPushN:
case bcPopI:
case bcDCopy:
compileNCommand(opcode, token, writer);
break;
case bcJump:
case bcDElse:
case bcDThen:
case bcWSTest:
case bcBSTest:
case bcTest:
compileJump(opcode, token, writer, info);
break;
case bcMElse:
case bcMThen:
case bcMElseVerb:
case bcMThenVerb:
compileMccJump(opcode, token, writer, info);
break;
case bcTestFlag:
case bcAElseSI:
case bcAThenSI:
case bcElseFlag:
case bcMElseAI:
case bcMThenAI:
case bcDElseN:
case bcDThenN:
compileNJump(opcode, token, writer, info);
break;
case bcSCallVI:
compileNNCommand(opcode, token, writer);
break;
default:
recognized = false;
break;
}
// check if it is function
if (!recognized) {
ByteCode code = bcNone;
const wchar16_t* func = token.value;
if (token.value[0]=='n') {
code = bcNFunc;
func++;
}
else if (token.value[0]=='l') {
code = bcLFunc;
func++;
}
else if (token.value[0]=='r') {
code = bcRFunc;
func++;
}
else if (token.value[0]=='w' && token.value[1]=='s') {
code = bcWSFunc;
func+=2;
}
else if (token.value[0]=='b' && token.value[1]=='s') {
code = bcBSFunc;
func+=2;
}
if (code != bcNone) {
FunctionCode function = ByteCodeCompiler::codeFunction(func);
if (function != fnUnknown) {
writeCommand(ByteCommand(code, function), writer);
recognized = true;
}
}
}
if (!recognized) {
info.labels.add(token.value, writer.Position());
fixJump(token.value, writer, info);
writeCommand(ByteCommand(bcNop), writer);
token.read(_T(":"), _T("':' expected (%d)\n"));
}
token.read();
}
void ECodesAssembler :: compileCommand(TokenInfo& token, MemoryWriter& writer, LabelInfo& info, _Module* binary)
{
bool recognized = true;
ByteCode opcode = ByteCodeCompiler::code(token.value);
if (opcode != bcNone) {
switch (opcode)
{
case bcCallR:
case bcACopyR:
case bcPushR:
compileRCommand(opcode, token, writer, binary);
break;
case bcCallExtR:
compileExtCommand(opcode, token, writer, binary);
break;
case bcACallVI:
case bcAJumpVI:
case bcALoadSI:
case bcBLoadSI:
case bcBLoadFI:
case bcACopyS:
case bcACopyF:
case bcBCopyS:
case bcBCopyF:
case bcALoadAI:
case bcALoadFI:
case bcPushAI:
case bcOpen:
case bcAddN:
case bcMulN:
case bcDLoadFI:
case bcDLoadSI:
case bcDSaveFI:
case bcDSaveSI:
case bcRestore:
case bcReserve:
case bcALoadBI:
case bcASaveSI:
case bcASaveFI:
case bcNSaveI:
case bcNLoadI:
case bcESwapSI:
case bcBSwapSI:
case bcAXSaveBI:
case bcELoadFI:
case bcELoadSI:
case bcESaveSI:
case bcESaveFI:
case bcShiftN:
case bcEAddN:
case bcDSwapSI:
case bcAJumpI:
case bcACallI:
case bcNReadI:
case bcNWriteI:
compileICommand(opcode, token, writer);
break;
case bcQuitN:
case bcPopI:
case bcDCopy:
case bcECopy:
case bcSetVerb:
case bcSetSubj:
case bcAndN:
case bcOrN:
case bcPushN:
compileNCommand(opcode, token, writer);
break;
case bcCopyM:
compileMCommand(opcode, token, writer, binary);
break;
case bcIfB:
case bcElseB:
case bcIf:
case bcElse:
case bcLess:
case bcNotLess:
case bcNext:
case bcJump:
case bcHook:
case bcAddress:
compileJump(opcode, token, writer, info);
break;
case bcIfM:
case bcElseM:
compileMccJump(opcode, token, writer, info);
break;
case bcIfN:
case bcElseN:
case bcLessN:
compileNJump(opcode, token, writer, info);
break;
case bcIfR:
case bcElseR:
compileRJump(opcode, token, writer, info, binary);
break;
case bcNewN:
compileCreateCommand(opcode, token, writer, binary);
break;
case bcSelectR:
compileRRCommand(opcode, token, writer, binary);
break;
case bcXIndexRM:
compileRMCommand(opcode, token, writer, binary);
break;
default:
writeCommand(ByteCommand(opcode), writer);
break;
}
}
else recognized = false;
if (!recognized) {
info.labels.add(token.value, writer.Position());
fixJump(token.value, writer, info);
writeCommand(ByteCommand(bcNop), writer);
token.read(":", "':' expected (%d)\n");
}
token.read();
}
FMT_FUNC int fprintf(std::FILE *f, CStringRef format, ArgList args) {
MemoryWriter w;
printf(w, format, args);
std::size_t size = w.size();
return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
}
