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); }