name string | code string | asm string | file string |
|---|---|---|---|
ReadDO(MemFile&, std::shared_ptr<Disk>&) | bool ReadDO(MemFile& file, std::shared_ptr<Disk>& disk)
{
Format fmt{ RegularFormat::DO };
// For now, rely on the file size and extension
if (file.size() != fmt.disk_size() || !IsFileExt(file.name(), "do"))
return false;
file.rewind();
disk->format(fmt, file.data());
disk->strType = "... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2c(%rsp), %r12
movq %r12, %rdi
movl $0x1d, %esi
callq 0x5db04
movq %r14, %rdi
callq 0x64c8e
movl %eax, %r15d
movq %r12, %rdi
callq 0x5e142
movl %eax, %r12d
movb $0x1, %bpl
cmpl %eax, %r15d
jne 0x8b4... | /simonowen[P]samdisk/src/types/do.cpp |
ReadDS2(MemFile&, std::shared_ptr<Disk>&) | bool ReadDS2(MemFile& file, std::shared_ptr<Disk>& disk)
{
std::string path = file.path();
MemFile file2;
Format fmt{ RegularFormat::MGT };
// The input should be half a standard SAM disk in size
if (!file.rewind() || file.size() != fmt.disk_size() / 2)
return false;
// Require the su... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x64c9e
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x41ad6
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
xorl %eax,... | /simonowen[P]samdisk/src/types/ds2.cpp |
util::exception::exception<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [24]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [24]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8b8c1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8b889
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x50318(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [24]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const (&) [24]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x35760
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x356a0
movq %r14, %rdi
callq 0x35210
movq %rsp, %rdi
movq %r14, %rsi
movq %ra... | /simonowen[P]samdisk/include/utils.h |
ReadDSC(MemFile&, std::shared_ptr<Disk>&) | bool ReadDSC(MemFile& file, std::shared_ptr<Disk>& disk)
{
file.rewind();
// ToDo: std::string for file extension
std::string strPath = file.path();
MemFile file2;
MemFile* pfileHeader = &file, * pfileData = &file2;
// If we've been given the header, open the data file
if (IsFileExt(strPat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, 0x48(%rsp)
movq %rdi, %r14
callq 0x64db2
movq %r14, %rdi
callq 0x64c9e
leaq 0xa0(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x90(%rsp), %rdi
callq 0... | /simonowen[P]samdisk/src/types/dsc.cpp |
void Message<int&, int>(MsgType, char const*, int&, int&&) | void Message(MsgType type, const char* pcsz_, Args&& ...args)
{
std::string msg = util::fmt(pcsz_, std::forward<Args>(args)...);
if (type == msgError)
throw util::exception(msg);
if (type != msgStatus)
{
if (seen_messages.find(msg) != seen_messages.end())
return;
s... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movl (%rdx), %edx
movl (%rcx), %ecx
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x784cc
testl %ebx, %ebx
je 0x8c304
cmpl $0x4, %ebx
je 0x8c361
leaq 0x53bbe(%rip), %r14 # 0xdfdf8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x418a4
addq $0x8, %r14
cmpq %r14, %rax
j... | /simonowen[P]samdisk/include/Util.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [22], char const*>(char const (&) [22], char const*&&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x35760
movq %r15, %rdi
callq 0x35210
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x356a0
movq (%r14), %r14
testq %r14, %r14
je 0x8c495
m... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [20], char const*>(char const (&) [20], char const*&&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x35760
movq %r15, %rdi
callq 0x35210
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x356a0
movq (%r14), %r14
testq %r14, %r14
je 0x8c562
m... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [27], char const*>(char const (&) [27], char const*&&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x35760
movq %r15, %rdi
callq 0x35210
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x356a0
movq (%r14), %r14
testq %r14, %r14
je 0x8c62f
m... | /simonowen[P]samdisk/include/utils.h |
ReadDSK(MemFile&, std::shared_ptr<Disk>&) | bool ReadDSK(MemFile& file, std::shared_ptr<Disk>& disk)
{
uint8_t ab[256];
if (!file.rewind() || !file.read(&ab, sizeof(ab)))
return false;
auto peh = reinterpret_cast<EDSK_HEADER*>(ab);
if (memcmp(peh->szSignature, EDSK_SIGNATURE, 8) && // match: "EXTENDED" only
memcmp(peh->szSignatu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, 0x48(%rsp)
movq %rdi, %rbx
callq 0x64db2
testb %al, %al
je 0x8d3cf
leaq 0x150(%rsp), %rsi
movq %rbx, %rdi
movl $0x100, %edx # imm = 0x100
callq 0x64d0c
testb %al, %al
je 0x8d3cf
movq 0x150(... | /simonowen[P]samdisk/src/types/dsk.cpp |
WriteDSK(_IO_FILE*, std::shared_ptr<Disk>&) | bool WriteDSK(FILE* f_, std::shared_ptr<Disk>& disk)
{
MEMORY mem(ESDK_MAX_TRACK_SIZE);
auto pbTrack = mem.pb;
uint8_t abHeader[256] = {}; // EDSK file header is fixed at 256 bytes - don't change!
auto peh = reinterpret_cast<EDSK_HEADER*>(abHeader);
auto pbIndex = reinterpret_cast<uint8_t*>(peh + 1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %r12
movq %rdi, %r15
movl $0xff00, %edi # imm = 0xFF00
callq 0x77560
movq %rax, 0x18(%rsp)
leaq 0x162(%rsp), %rbx
movl $0xde, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x352d0
movups 0x245d... | /simonowen[P]samdisk/src/types/dsk.cpp |
util::exception::exception<char const (&) [25], unsigned char&, char const (&) [2]>(char const (&) [25], unsigned char&, char const (&) [2]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8f5c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e769
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4d438(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
util::exception::exception<char const (&) [28], CylHead&>(char const (&) [28], CylHead&) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8f68d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e7df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4d3c2(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
void Message<unsigned char&, unsigned char&, unsigned char&, char const*>(MsgType, char const*, unsigned char&, unsigned char&, unsigned char&, char const*&&) | void Message(MsgType type, const char* pcsz_, Args&& ...args)
{
std::string msg = util::fmt(pcsz_, std::forward<Args>(args)...);
if (type == msgError)
throw util::exception(msg);
if (type != msgStatus)
{
if (seen_messages.find(msg) != seen_messages.end())
return;
s... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movzbl (%rdx), %edx
movzbl (%rcx), %ecx
movzbl (%r8), %r8d
movq (%r9), %r9
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x784cc
testl %ebx, %ebx
je 0x8e91b
cmpl $0x4, %ebx
je 0x8e978
leaq 0x515a7(%rip), %r14 # 0xdfdf8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x... | /simonowen[P]samdisk/include/Util.h |
util::exception::exception<char const (&) [20], CylHead&, char const (&) [16]>(char const (&) [20], CylHead&, char const (&) [16]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8f795
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ea1d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4d184(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
void Message<unsigned char&, unsigned char&, char const*>(MsgType, char const*, unsigned char&, unsigned char&, char const*&&) | void Message(MsgType type, const char* pcsz_, Args&& ...args)
{
std::string msg = util::fmt(pcsz_, std::forward<Args>(args)...);
if (type == msgError)
throw util::exception(msg);
if (type != msgStatus)
{
if (seen_messages.find(msg) != seen_messages.end())
return;
s... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movzbl (%rdx), %edx
movzbl (%rcx), %ecx
movq (%r8), %r8
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x784cc
testl %ebx, %ebx
je 0x8eb55
cmpl $0x4, %ebx
je 0x8ebb2
leaq 0x5136d(%rip), %r14 # 0xdfdf8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x418a4
addq $0x8, %r... | /simonowen[P]samdisk/include/Util.h |
util::exception::exception<char const (&) [20], CylHead&, char const (&) [9], int&>(char const (&) [20], CylHead&, char const (&) [9], int&) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8f8bf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ec57
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4cf4a(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
void Message<char const*, int, int&>(MsgType, char const*, char const*&&, int&&, int&) | void Message(MsgType type, const char* pcsz_, Args&& ...args)
{
std::string msg = util::fmt(pcsz_, std::forward<Args>(args)...);
if (type == msgError)
throw util::exception(msg);
if (type != msgStatus)
{
if (seen_messages.find(msg) != seen_messages.end())
return;
s... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movq (%rdx), %rdx
movl (%rcx), %ecx
movl (%r8), %r8d
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x784cc
testl %ebx, %ebx
je 0x8ed8e
cmpl $0x4, %ebx
je 0x8edeb
leaq 0x51134(%rip), %r14 # 0xdfdf8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x418a4
addq $0x8, %r14
... | /simonowen[P]samdisk/include/Util.h |
void Message<unsigned long&, unsigned char const&>(MsgType, char const*, unsigned long&, unsigned char const&) | void Message(MsgType type, const char* pcsz_, Args&& ...args)
{
std::string msg = util::fmt(pcsz_, std::forward<Args>(args)...);
if (type == msgError)
throw util::exception(msg);
if (type != msgStatus)
{
if (seen_messages.find(msg) != seen_messages.end())
return;
s... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movq (%rdx), %rdx
movzbl (%rcx), %ecx
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x784cc
testl %ebx, %ebx
je 0x8ef4f
cmpl $0x4, %ebx
je 0x8efac
leaq 0x50f73(%rip), %r14 # 0xdfdf8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x418a4
addq $0x8, %r14
cmpq %r14, %rax... | /simonowen[P]samdisk/include/Util.h |
void Message<unsigned long&>(MsgType, char const*, unsigned long&) | void Message(MsgType type, const char* pcsz_, Args&& ...args)
{
std::string msg = util::fmt(pcsz_, std::forward<Args>(args)...);
if (type == msgError)
throw util::exception(msg);
if (type != msgStatus)
{
if (seen_messages.find(msg) != seen_messages.end())
return;
s... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movq (%rdx), %rdx
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x784cc
testl %ebx, %ebx
je 0x8f10d
cmpl $0x4, %ebx
je 0x8f16a
leaq 0x50db5(%rip), %r14 # 0xdfdf8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x418a4
addq $0x8, %r14
cmpq %r14, %rax
jne 0x8f147
leaq 0x... | /simonowen[P]samdisk/include/Util.h |
util::exception::exception<CylHead&, char const (&) [46]>(CylHead&, char const (&) [46]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8f9fa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f20f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4c992(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
util::exception::exception<CylHead&, char const (&) [8], int&, char const (&) [29], int, char const (&) [2]>(CylHead&, char const (&) [8], int&, char const (&) [29], int&&, char const (&) [2]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8fb00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f44e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4c7... | /simonowen[P]samdisk/include/utils.h |
util::exception::exception<char const (&) [12]>(char const (&) [12]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8fc68
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f4c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4c6de(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [28], CylHead&>(char const (&) [28], CylHead&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x35760
movq %r15, %rdi
callq 0x35210
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x356a0
movl (%r14), %edx
movl 0x4(%r14), %ecx
le... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [20], CylHead&, char const (&) [16]>(char const (&) [20], CylHead&, char const (&) [16]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x35760
movq %r12, %rdi
callq 0x35210
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x356a0
movl (%r15), %... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [20], CylHead&, char const (&) [9], int&>(char const (&) [20], CylHead&, char const (&) [9], int&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
callq 0x35760
movq %r13, %rdi
callq 0x35210
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
ca... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<CylHead&, char const (&) [46]>(CylHead&, char const (&) [46]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x35760
movl (%r15), %edx
movl 0x4(%r15), %ecx
leaq 0x1c3b4(%rip), %rsi # 0xabddb
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x784cc
movq 0x8(%rsp), %rsi
movq 0x10(... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<CylHead&, char const (&) [8], int&, char const (&) [29], int, char const (&) [2]>(CylHead&, char const (&) [8], int&, char const (&) [29], int&&, char const (&) [2]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x35760
movl (%rbp), %edx
movl 0x4(%rbp), %ecx
leaq 0x1c2a1(%rip), %rsi # 0xabddb
mov... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [12]>(char const (&) [12]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x35760
movq %r14, %rdi
callq 0x35210
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x356a0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x35920
movq 0x4d2c7(%rip... | /simonowen[P]samdisk/include/utils.h |
ReadDTI(MemFile&, std::shared_ptr<Disk>&) | bool ReadDTI(MemFile& file, std::shared_ptr<Disk>& disk)
{
file.rewind();
DTI_HEADER dh;
if (!file.read(&dh, sizeof(dh)) || memcmp(dh.abSignature, DTI_SIGNATURE, sizeof(dh.abSignature)))
return false;
Format::Validate(dh.bTracks, dh.bSides);
auto uBlock = (dh.bBlockHigh << 8) | dh.bBlockL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %rbx
callq 0x64db2
leaq 0xc(%rsp), %rsi
movq %rbx, 0x38(%rsp)
movq %rbx, %rdi
movl $0x8, %edx
callq 0x64d0c
testb %al, %al
je 0x8fd43
cmpl $0x32473248, 0xc(%rsp) # imm = 0x32473248
je 0x8fd57
xorl %eax, ... | /simonowen[P]samdisk/src/types/dti.cpp |
util::exception::exception<char const (&) [31], int&, char const (&) [2]>(char const (&) [31], int&, char const (&) [2]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9059f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90405
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4b79c(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
util::exception::exception<char const (&) [22], CylHead&>(char const (&) [22], CylHead&) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x90667
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9047b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4b726(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
util::exception::exception<char const (&) [22], int&, char const (&) [6], CylHead&>(char const (&) [22], int&, char const (&) [6], CylHead&) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9076f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x904f1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4b6b0(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
util::exception::exception<char const (&) [35], char&, char const (&) [2]>(char const (&) [35], char&, char const (&) [2]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x908a9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90567
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4b63a(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [31], int&, char const (&) [2]>(char const (&) [31], int&, char const (&) [2]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x35760
movq %r12, %rdi
callq 0x35210
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x356a0
movl (%r15), %e... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [22], CylHead&>(char const (&) [22], CylHead&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x35760
movq %r15, %rdi
callq 0x35210
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x356a0
movl (%r14), %edx
movl 0x4(%r14), %ecx
le... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [35], char&, char const (&) [2]>(char const (&) [35], char&, char const (&) [2]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x35760
movq %r12, %rdi
callq 0x35210
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x356a0
movb (%r15), %a... | /simonowen[P]samdisk/include/utils.h |
ReadFD(MemFile&, std::shared_ptr<Disk>&) | bool ReadFD(MemFile& file, std::shared_ptr<Disk>& disk)
{
Format fmt;
if (!IsFileExt(file.name(), "fd"))
return false;
switch (file.size())
{
case 655360:
fmt = RegularFormat::TO_640K_MFM;
break;
case 327680:
fmt = RegularFormat::TO_320K_MFM;
break;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movaps 0x1b6d2(%rip), %xmm0 # 0xac070
movups %xmm0, (%rsp)
movaps 0x1b6d7(%rip), %xmm0 # 0xac080
movups %xmm0, 0x10(%rsp)
movsd 0x1dc3a(%rip), %xmm0 # 0xae5f0
movups %xmm0, 0x20(%rsp)
movq $0x1, 0... | /simonowen[P]samdisk/src/types/fd.cpp |
ReadFDI(MemFile&, std::shared_ptr<Disk>&) | bool ReadFDI(MemFile& file, std::shared_ptr<Disk>& disk)
{
FDI_HEADER fh;
if (!file.rewind() || !file.read(&fh, sizeof(fh)))
return false;
else if (memcmp(fh.abSignature, FDI_SIGNATURE, sizeof(fh.abSignature)))
return false;
int cyls = fh.bTracks[0];
int heads = fh.bSides[0];
Fo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, 0xa8(%rsp)
movq %rdi, %r12
callq 0x64db2
testb %al, %al
je 0x90d92
leaq 0x5a(%rsp), %rsi
movq %r12, %rdi
movl $0xe, %edx
callq 0x64d0c
testb %al, %al
je 0x90d92
movzwl 0x5a(%rsp), %eax
xorl $0x4446, %... | /simonowen[P]samdisk/src/types/fdi.cpp |
util::exception::exception<char const (&) [20], CylHead&, char const (&) [15], int&>(char const (&) [20], CylHead&, char const (&) [15], int&) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x91b1c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x91769
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4a438(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
void Message<unsigned char&, char const*>(MsgType, char const*, unsigned char&, char const*&&) | void Message(MsgType type, const char* pcsz_, Args&& ...args)
{
std::string msg = util::fmt(pcsz_, std::forward<Args>(args)...);
if (type == msgError)
throw util::exception(msg);
if (type != msgStatus)
{
if (seen_messages.find(msg) != seen_messages.end())
return;
s... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movzbl (%rdx), %edx
movq (%rcx), %rcx
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x784cc
testl %ebx, %ebx
je 0x9191d
cmpl $0x4, %ebx
je 0x9197a
leaq 0x4e5a5(%rip), %r14 # 0xdfdf8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x418a4
addq $0x8, %r14
cmpq %r14, %rax... | /simonowen[P]samdisk/include/Util.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<CylHead&, char const (&) [24], unsigned char&, char const (&) [2]>(CylHead&, char const (&) [24], unsigned char&, char const (&) [2]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x35760
movl (%r13), %edx
movl 0x4(%r13), %ecx
leaq 0x1a3c2(%rip), %rsi # 0xabddb
leaq 0x8(%rsp), %rdi
xorl %ea... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [20], CylHead&, char const (&) [15], int&>(char const (&) [20], CylHead&, char const (&) [15], int&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
callq 0x35760
movq %r13, %rdi
callq 0x35210
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
ca... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [19], CylHead&, char const (&) [9], unsigned char&, char const (&) [8], int&>(char const (&) [19], CylHead&, char const (&) [9], unsigned char&, char const (&) [8], int&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x35760
movq %rbp, %rdi
callq 0x35210
movq %rbx, %rdi
movq %rbp, %rs... | /simonowen[P]samdisk/include/utils.h |
to_string[abi:cxx11](FloppyInterfaceMode) | std::string to_string(FloppyInterfaceMode interface_mode)
{
switch (interface_mode)
{
case IBMPC_DD_FLOPPYMODE: return "IBMPC_DD_FLOPPYMODE"; break;
case IBMPC_HD_FLOPPYMODE: return "IBMPC_HD_FLOPPYMODE"; break;
case ATARIST_DD_FLOPPYMODE: return "ATARIST_DD_FLOPPYMODE"; break;
case ATAR... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0xd, %esi
ja 0x91e01
movl %esi, %eax
leaq 0x2087f(%rip), %rcx # 0xb2664
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x208b7(%rip), %rsi # 0xb26ac
leaq 0x208c3(%rip), %rdx # 0xb26bf
jmp 0x91f0d
cmpl $0xfe, %esi
jne 0x91e8... | /simonowen[P]samdisk/src/types/hfe.cpp |
to_string[abi:cxx11](TrackEncoding) | std::string to_string(TrackEncoding track_encoding)
{
switch (track_encoding)
{
case ISOIBM_MFM_ENCODING: return "ISOIBM_MFM_ENCODING"; break;
case AMIGA_MFM_ENCODING: return "AMIGA_MFM_ENCODING"; break;
case ISOIBM_FM_ENCODING: return "ISOIBM_FM_ENCODING"; break;
case EMU_FM_ENC... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x3, %esi
ja 0x91f4c
movl %esi, %eax
leaq 0x20769(%rip), %rcx # 0xb269c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2089e(%rip), %rsi # 0xb27e1
leaq 0x208aa(%rip), %rdx # 0xb27f4
jmp 0x91fa2
cmpl $0xff, %esi
jne 0x91f6... | /simonowen[P]samdisk/src/types/hfe.cpp |
ReadHFE(MemFile&, std::shared_ptr<Disk>&) | bool ReadHFE(MemFile& file, std::shared_ptr<Disk>& disk)
{
HFE_HEADER hh;
if (!file.rewind() || !file.read(&hh, sizeof(hh)) || memcmp(&hh.header_signature, HFE_SIGNATURE, sizeof(hh.header_signature)))
return false;
if (hh.format_revision != 0)
throw util::exception("unsupported HFE format r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
movq %rsi, 0x18(%rsp)
movq %rdi, %r15
callq 0x64db2
testb %al, %al
je 0x91ff8
leaq 0x52(%rsp), %rsi
movq %r15, %rdi
movl $0x1a, %edx
callq 0x64d0c
testb %al, %al
je 0x91ff8
movabsq $0x4546434950435848, %rax # im... | /simonowen[P]samdisk/src/types/hfe.cpp |
WriteHFE(_IO_FILE*, std::shared_ptr<Disk>&) | bool WriteHFE(FILE* f_, std::shared_ptr<Disk>& disk)
{
std::vector<uint8_t> header(256, 0xff);
auto& hh = *reinterpret_cast<HFE_HEADER*>(header.data());
auto& track0 = disk->read_track({ 0, 0 });
strncpy(hh.header_signature, HFE_SIGNATURE, sizeof(hh.header_signature));
hh.format_revision = 0x00;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rsi, %r13
movq %rdi, %r12
movl $0x100, %edi # imm = 0x100
callq 0x355b0
movq %rax, %r14
movl $0x100, %edx # imm = 0x100
movq %rax, %rdi
movl $0xff, %esi
callq 0x352d0
movq (%r13), %rd... | /simonowen[P]samdisk/src/types/hfe.cpp |
util::exception::exception<char const (&) [34], unsigned char&, char const (&) [2]>(char const (&) [34], unsigned char&, char const (&) [2]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x93420
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x930e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x48abe(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
util::exception::exception<char const (&) [11]>(char const (&) [11]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9367f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x93245
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x4895c(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [34], unsigned char&, char const (&) [2]>(char const (&) [34], unsigned char&, char const (&) [2]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x35760
movq %r12, %rdi
callq 0x35210
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x356a0
movzbl (%r15), ... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [24], unsigned short&, char const (&) [6]>(char const (&) [24], unsigned short&, char const (&) [6]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x35760
movq %r12, %rdi
callq 0x35210
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x356a0
movzwl (%r15), ... | /simonowen[P]samdisk/include/utils.h |
WriteIMD(_IO_FILE*, std::shared_ptr<Disk>&) | bool WriteIMD(FILE* /*f_*/, std::shared_ptr<Disk>&/*disk*/)
{
throw std::logic_error("IMD writing not implemented");
#if 0
time_t now = time(NULL);
struct tm* tm = localtime(&now);
// Format a suitable ASCII header
auto strHeader = util::fmt("IMD SAMdisk%02u%02u%02u, %02u/%02u/%04u %02u:%02u:%02u",... | pushq %r14
pushq %rbx
pushq %rax
movl $0x10, %edi
callq 0x35260
movq %rax, %rbx
leaq 0x1e527(%rip), %rsi # 0xb29ff
movq %rax, %rdi
callq 0x35850
movq 0x48ae9(%rip), %rsi # 0xdcfd0
movq 0x48aa2(%rip), %rdx # 0xdcf90
movq %rbx, %rdi
callq 0x35a50
movq %rax, %r14
movq %rbx, %rdi
callq 0x35430
movq %r14, %rdi
c... | /simonowen[P]samdisk/src/types/imd.cpp |
util::exception::exception<char const (&) [22], unsigned char&, char const (&) [6], CylHead&, char const (&) [9], int&>(char const (&) [22], unsigned char&, char const (&) [6], CylHead&, char const (&) [9], int&) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x94b1e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x946ba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x474... | /simonowen[P]samdisk/include/utils.h |
util::exception::exception<char const (&) [34], CylHead&, char const (&) [9], int&>(char const (&) [34], CylHead&, char const (&) [9], int&) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x94c92
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9472f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x47472(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [22], unsigned char&, char const (&) [6], CylHead&, char const (&) [9], int&>(char const (&) [22], unsigned char&, char const (&) [6], CylHead&, char const (&) [9], int&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x35760
movq %rbp, %rdi
callq 0x35210
movq %rbx, %rdi
movq %rbp, %rs... | /simonowen[P]samdisk/include/utils.h |
ReadLIF(MemFile&, std::shared_ptr<Disk>&) | bool ReadLIF(MemFile& file, std::shared_ptr<Disk>& disk)
{
Format fmt{ RegularFormat::LIF };
// For now, rely on the file size and extension
if (file.size() != fmt.disk_size() || !IsFileExt(file.name(), "lif"))
return false;
file.rewind();
disk->format(fmt, file.data());
disk->strType ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2c(%rsp), %r12
movq %r12, %rdi
movl $0x1b, %esi
callq 0x5db04
movq %r14, %rdi
callq 0x64c8e
movl %eax, %r15d
movq %r12, %rdi
callq 0x5e142
movl %eax, %r12d
movb $0x1, %bpl
cmpl %eax, %r15d
jne 0x95d... | /simonowen[P]samdisk/src/types/lif.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [22], CylHead const&, char const (&) [3], unsigned int&>(char const (&) [22], CylHead const&, char const (&) [3], unsigned int&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
callq 0x35760
movq %r13, %rdi
callq 0x35210
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
ca... | /simonowen[P]samdisk/include/utils.h |
ReadMGT(MemFile&, std::shared_ptr<Disk>&) | bool ReadMGT(MemFile& file, std::shared_ptr<Disk>& disk)
{
if (file.size() != MGT_DISK_SIZE)
return false;
// Read the first sector, which contains disk information.
std::array<uint8_t, SECTOR_SIZE> sector0;
if (!file.rewind() || !file.read(sector0))
return false;
MGT_DISK_INFO di{... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rsi, %rbx
movq %rdi, %r14
callq 0x64c8e
cmpl $0xc8000, %eax # imm = 0xC8000
jne 0x98583
movq %r14, %rdi
callq 0x64db2
testb %al, %al
je 0x98583
movq %r14, %rdi
callq 0x64c96
cmpl $0x200, %eax ... | /simonowen[P]samdisk/src/types/mgt.cpp |
util::exception::exception<char const (&) [20], CylHead&, char const (&) [8]>(char const (&) [20], CylHead&, char const (&) [8]) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x99003
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x98d7d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x42e24(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [20], CylHead&, char const (&) [8]>(char const (&) [20], CylHead&, char const (&) [8]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x35760
movq %r12, %rdi
callq 0x35210
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x356a0
movl (%r15), %... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [43], CylHead&>(char const (&) [43], CylHead&) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x35760
movq %r15, %rdi
callq 0x35210
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x356a0
movl (%r14), %edx
movl 0x4(%r14), %ecx
le... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [24], int, char const (&) [5], int&, char const (&) [6], CylHead&, char const (&) [8]>(char const (&) [24], int&&, char const (&) [5], int&, char const (&) [6], CylHead&, char const (&) [8]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x35760
movq %rbp, %rdi
callq 0x35210
movq %rbx, %rdi
movq %rbp, %rs... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [20], CylHead&, char const (&) [13]>(char const (&) [20], CylHead&, char const (&) [13]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x35760
movq %r12, %rdi
callq 0x35210
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x356a0
movl (%r15), %... | /simonowen[P]samdisk/include/utils.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::make_string<char const (&) [21], CylHead&, char const (&) [6]>(char const (&) [21], CylHead&, char const (&) [6]) | std::string make_string(Args&& ... args)
{
std::ostringstream ss;
(void)std::initializer_list<bool> {(ss << args, false)...};
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x35760
movq %r12, %rdi
callq 0x35210
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x356a0
movl (%r15), %... | /simonowen[P]samdisk/include/utils.h |
ReadSuperCardPro(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Disk>&) | bool ReadSuperCardPro(const std::string& path, std::shared_ptr<Disk>& disk)
{
// ToDo: use path to select from multiple devices?
if (util::lowercase(path) != "scp:")
return false;
auto supercardpro = SuperCardPro::Open();
if (!supercardpro)
throw util::exception("failed to open SuperCar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x78866
leaq 0x110d6(%rip), %rsi # 0xb3766
movq %r15, %rdi
callq 0x35120
movl %eax, %ebx
movq (%r15), %rdi
leaq 0x28(%rsp), %r13
cmpq %r13, %rdi
je 0xa26b4
m... | /simonowen[P]samdisk/src/types/scp_dev.cpp |
VersionString[abi:cxx11](int) | static std::string VersionString(int version)
{
std::stringstream ss;
if (version)
ss << (version >> 4) << "." << (version & 0xf);
return ss.str();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x353f0
testl %ebp, %ebp
je 0xa2997
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
sarl $0x4, %esi
callq 0x35a80
movq %rax, %r14
leaq 0x983e(%rip), %rsi # 0xac1bb
movl $0x1, %edx
movq %rax,... | /simonowen[P]samdisk/src/types/scp_dev.cpp |
WriteSuperCardPro(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Disk>&) | bool WriteSuperCardPro(const std::string& path, std::shared_ptr<Disk>& disk)
{
if (util::lowercase(path) != "scp:")
return false;
auto supercardpro = SuperCardPro::Open();
if (!supercardpro)
throw util::exception("failed to open SuperCard Pro device");
auto scp_dev_disk = std::make_sha... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x78866
leaq 0x10d48(%rip), %rsi # 0xb3766
movq %r15, %rdi
callq 0x35120
movl %eax, %ebx
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xa2a42
movq 0x30(%rsp), %rsi
i... | /simonowen[P]samdisk/src/types/scp_dev.cpp |
util::exception::exception<char const (&) [13], unsigned int&, char const (&) [14], CylHead&>(char const (&) [13], unsigned int&, char const (&) [14], CylHead&) | explicit exception(Args&& ... args)
: std::runtime_error(make_string(std::forward<Args>(args)...)) {} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa6547
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35710
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa6391
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x355d0
leaq 0x35810(%rip), %rax # 0xdbba8
movq %rax, ... | /simonowen[P]samdisk/include/utils.h |
ReadUnsupported(MemFile&, std::shared_ptr<Disk>&) | bool ReadUnsupported(MemFile& file, std::shared_ptr<Disk>&/*disk*/)
{
std::array<char, SECTOR_SIZE> buf;
if (!file.rewind() || !file.read(buf))
return false;
std::string strType;
if (std::string(buf.data() + 0x00, 12) == "CPC-Emulator" && std::string(buf.data() + 0x10, 10) == "DiskImageV")
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0x64db2
testb %al, %al
je 0xa6983
movq %rbx, %rdi
callq 0x64c96
cmpl $0x200, %eax # imm = 0x200
jl 0xa6983
movq 0x58(%rbx), %rax
movq (%rax), %r12
movl 0x8(%rax), %ecx
movq 0x12(%rax), %rdx
movq %rdx, 0xe... | /simonowen[P]samdisk/src/types/unsupp.cpp |
ReadWOZ(MemFile&, std::shared_ptr<Disk>&) | bool ReadWOZ(MemFile& file, std::shared_ptr<Disk>& disk)
{
WOZ_HEADER wh;
if (!file.rewind() || !file.read(&wh, sizeof(wh)) || memcmp(&wh.sig, WOZ_SIGNATURE, sizeof(wh.sig)))
return false;
else if (wh.ff != 0xff || memcmp(&wh.lfcrlf, "\n\r\n", 3))
return false;
auto crc = util::le_value... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, 0x28(%rsp)
movq %rdi, %r14
callq 0x64db2
testb %al, %al
je 0xa757d
leaq 0xd4(%rsp), %rsi
movq %r14, %rdi
movl $0xc, %edx
callq 0x64d0c
testb %al, %al
je 0xa757d
xorl %r15d, %r15d
cmpl $0x315a4f57, 0xd... | /simonowen[P]samdisk/src/types/woz.cpp |
unzOpen2 | extern unzFile ZEXPORT unzOpen2(const char* path,
zlib_filefunc_def* pzlib_filefunc32_def)
{
if (pzlib_filefunc32_def != NULL)
{
zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill, pzlib_filefunc32_def);
return... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0xa852c
movq %rsp, %r14
movq %r14, %rdi
callq 0xa823b
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa853c
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x58, %rsp
popq %rbx
popq %r14
jm... | /simonowen[P]samdisk/src/unzip.c |
unzOpenInternal | local unzFile unzOpenInternal(const void* path,
zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
int is64bitOpenFunction)
{
unz64_s us;
unz64_s* s;
ZPOS64_T central_pos;
uLong uL;
uLong number_disk; /* number of the current dist, used for
spanin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rsp)
leaq 0x78(%rsp), %rdi
testq %rsi, %rsi
je 0xa8571
movl $0xb, %ecx
rep movsq (%rsi), %es:(%rdi)
jmp 0xa8576
callq 0xa83a1
leaq 0x78(%rs... | /simonowen[P]samdisk/src/unzip.c |
unzClose | extern int ZEXPORT unzClose(unzFile file)
{
unz64_s* s;
if (file == NULL)
return UNZ_PARAMERROR;
s = (unz64_s*)file;
if (s->pfile_in_zip_read != NULL)
unzCloseCurrentFile(file);
ZCLOSE64(s->z_filefunc, s->filestream);
TRYFREE(s);
return UNZ_OK;
} | testq %rdi, %rdi
je 0xa8d95
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x140(%rdi)
je 0xa8d7e
movq %rbx, %rdi
callq 0xa8d9b
movq 0x38(%rbx), %rdi
movq 0x60(%rbx), %rsi
callq *0x28(%rbx)
movq %rbx, %rdi
callq 0x356d0
xorl %eax, %eax
popq %rbx
retq
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
retq
| /simonowen[P]samdisk/src/unzip.c |
unzCloseCurrentFile | extern int ZEXPORT unzCloseCurrentFile(unzFile file)
{
int err = UNZ_OK;
unz64_s* s;
file_in_zip64_read_info_s* pfile_in_zip_read_info;
if (file == NULL)
return UNZ_PARAMERROR;
s = (unz64_s*)file;
pfile_in_zip_read_info = s->pfile_in_zip_read;
if (pfile_in_zip_read_info == NULL)
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffff9a, %ebx # imm = 0xFFFFFF9A
testq %rdi, %rdi
je 0xa8e2a
movq %rdi, %r14
movq 0x140(%rdi), %r15
testq %r15, %r15
je 0xa8e2a
xorl %ebx, %ebx
cmpq $0x0, 0xc0(%r15)
jne 0xa8dea
cmpl $0x0, 0x138(%r15)
jne 0xa8dea
movq 0xa8(%r15), %rax
xorl %ecx, %ecx... | /simonowen[P]samdisk/src/unzip.c |
unz64local_GetCurrentFileInfoInternal | local int unz64local_GetCurrentFileInfoInternal(unzFile file,
unz_file_info64* pfile_info,
unz_file_info64_internal
* pfile_info_internal,
char* szFileName,
uLong fileNameBufferSize,
void* extraField,
uLong extraFieldBufferSize,
char* szComment,
uLong commentBufferSize)
{
unz64_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
testq %rdi, %rdi
je 0xa915c
movq %rdi, %r15
movq %r8, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
movq %r9, 0x8(%rsp)
movq 0x60(%rdi), %rsi
movq 0x78(%rdi), %rdx
addq 0x88(%rdi), %rdx
xorl %ecx, %ecx
call... | /simonowen[P]samdisk/src/unzip.c |
unzGetCurrentFileInfo | extern int ZEXPORT unzGetCurrentFileInfo(unzFile file,
unz_file_info* pfile_info,
char* szFileName, uLong fileNameBufferSize,
void* extraField, uLong extraFieldBufferSize,
char* szComment, uLong commentBufferSize)
{
int err;
unz_file_info64 file_info64;
err = unz64local_GetCurrentFileInfoInt... | pushq %rbx
subq $0xa0, %rsp
movq %r8, %rax
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rbx
movaps 0xb0(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movq %r9, (%rsp)
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
movq %rax, %r9
callq 0xa8e94
testl %eax, %eax
jne 0xa9547
movq 0x18(%rsp), %rcx
movq %rcx, (%rbx)
movq 0x20(%rsp), %rcx
movq %... | /simonowen[P]samdisk/src/unzip.c |
unzLocateFile | extern int ZEXPORT unzLocateFile(unzFile file, const char* szFileName, int iCaseSensitivity)
{
unz64_s* s;
int err;
/* We remember the 'current' position in the file so that we can jump
* back there if we fail.
*/
unz_file_info64 cur_file_infoSaved;
unz_file_info64_internal cur_file_info_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movl $0xffffff9a, %r12d # imm = 0xFFFFFF9A
testq %rdi, %rdi
je 0xa97f5
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x35210
cmpq $0xff, %rax
ja 0xa97f5
cmpq $0x0, 0x90(%rbx)
je 0xa9... | /simonowen[P]samdisk/src/unzip.c |
unzGetFilePos | extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos* file_pos)
{
unz64_s* s;
if (file == NULL || file_pos == NULL)
return UNZ_PARAMERROR;
s = (unz64_s*)file;
if (!s->current_file_ok)
return UNZ_END_OF_LIST_OF_FILE;
file_pos->pos_in_zip_directory = s->pos_in_central_dir;... | testq %rdi, %rdi
je 0xa986b
xorl %eax, %eax
cmpq $0x0, 0x90(%rdi)
je 0xa9874
movq 0x80(%rdi), %rcx
movq 0x88(%rdi), %rdx
movb $0x1, %dil
jmp 0xa987b
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
xorl %edi, %edi
jmp 0xa987b
movl $0xffffff9c, %eax # imm = 0xFFFFFF9C
xorl %edi, %edi
testb %dil, %dil
je 0xa9887
mov... | /simonowen[P]samdisk/src/unzip.c |
unzGoToFilePos | extern int ZEXPORT unzGoToFilePos(
unzFile file,
unz_file_pos* file_pos)
{
unz64_file_pos file_pos64;
if (file_pos == NULL)
return UNZ_PARAMERROR;
file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
file_pos64.num_of_file = file_pos->num_of_file;
return unzGoToFilePos6... | testq %rsi, %rsi
je 0xa9922
subq $0x18, %rsp
movq (%rsi), %rcx
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, %rsi
callq 0xa9888
addq $0x18, %rsp
retq
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
retq
| /simonowen[P]samdisk/src/unzip.c |
unzReadCurrentFile | extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, unsigned len)
{
int err = UNZ_OK;
uInt iRead = 0;
unz64_s* s;
file_in_zip64_read_info_s* pfile_in_zip_read_info;
if (file == NULL)
return UNZ_PARAMERROR;
s = (unz64_s*)file;
pfile_in_zip_read_info = s->pfile_in_zip_read;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xffffff9a, %ebp # imm = 0xFFFFFF9A
testq %rdi, %rdi
je 0xaa0ee
movq 0x140(%rdi), %r14
testq %r14, %r14
je 0xaa0ee
cmpq $0x0, (%r14)
je 0xaa0d5
testl %edx, %edx
je 0xaa0dc
movq %rsi, 0x20(%r14)
movl %edx, 0x28(%r14)
movl %edx... | /simonowen[P]samdisk/src/unzip.c |
unztell | extern z_off_t ZEXPORT unztell(unzFile file)
{
unz64_s* s;
file_in_zip64_read_info_s* pfile_in_zip_read_info;
if (file == NULL)
return UNZ_PARAMERROR;
s = (unz64_s*)file;
pfile_in_zip_read_info = s->pfile_in_zip_read;
if (pfile_in_zip_read_info == NULL)
return UNZ_PARAMERROR;
... | movq $-0x66, %rax
testq %rdi, %rdi
je 0xaa122
movq 0x140(%rdi), %rcx
testq %rcx, %rcx
je 0xaa122
movq 0x30(%rcx), %rax
retq
| /simonowen[P]samdisk/src/unzip.c |
unzeof | extern int ZEXPORT unzeof(unzFile file)
{
unz64_s* s;
file_in_zip64_read_info_s* pfile_in_zip_read_info;
if (file == NULL)
return UNZ_PARAMERROR;
s = (unz64_s*)file;
pfile_in_zip_read_info = s->pfile_in_zip_read;
if (pfile_in_zip_read_info == NULL)
return UNZ_PARAMERROR;
if... | movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
testq %rdi, %rdi
je 0xaa166
movq 0x140(%rdi), %rcx
testq %rcx, %rcx
je 0xaa166
xorl %eax, %eax
cmpq $0x0, 0xc0(%rcx)
sete %al
retq
| /simonowen[P]samdisk/src/unzip.c |
unzGetLocalExtrafield | extern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, unsigned len)
{
unz64_s* s;
file_in_zip64_read_info_s* pfile_in_zip_read_info;
uInt read_now;
ZPOS64_T size_to_read;
if (file == NULL)
return UNZ_PARAMERROR;
s = (unz64_s*)file;
pfile_in_zip_read_info = s->pfile_in_zi... | movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
testq %rdi, %rdi
je 0xaa226
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x140(%rdi), %r12
testq %r12, %r12
je 0xaa21b
movq %rsi, %rbx
movl 0x90(%r12), %r15d
movq 0x98(%r12), %rax
subq %rax, %r15
testq %rsi, %rsi
je 0xaa214
movl %edx, %ecx
cmpq %rcx, %r15
c... | /simonowen[P]samdisk/src/unzip.c |
unzGetOffset64 | extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)
{
unz64_s* s;
if (file == NULL)
return 0; //UNZ_PARAMERROR;
s = (unz64_s*)file;
if (!s->current_file_ok)
return 0;
if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
if (s->num_file == s->gi.number_entry)
... | testq %rdi, %rdi
je 0xaa2db
cmpq $0x0, 0x90(%rdi)
je 0xaa2db
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0xaa2de
cmpq $0xffff, %rax # imm = 0xFFFF
je 0xaa2de
cmpq %rax, 0x80(%rdi)
jne 0xaa2de
xorl %eax, %eax
retq
movq 0x88(%rdi), %rax
retq
| /simonowen[P]samdisk/src/unzip.c |
unzSetOffset64 | extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)
{
unz64_s* s;
int err;
if (file == NULL)
return UNZ_PARAMERROR;
s = (unz64_s*)file;
s->pos_in_central_dir = pos;
s->num_file = s->gi.number_entry; /* hack */
err = unz64local_GetCurrentFileInfoInternal(file, &s->cur... | testq %rdi, %rdi
je 0xaa378
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, 0x88(%rdi)
movq 0x68(%rdi), %rax
movq %rax, 0x80(%rdi)
leaq 0xb0(%rdi), %rsi
leaq 0x138(%rdi), %rdx
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xa8e94
xorl %ecx, %e... | /simonowen[P]samdisk/src/unzip.c |
unz64local_getLong | local int unz64local_getLong(const zlib_filefunc64_32_def* pzlib_filefunc_def,
voidpf filestream,
uLong* pX)
{
uLong x;
int i = 0;
int err;
err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);
x = (uLong)i;
if (err == UNZ_OK)
err = unz64local_getByte(pzlib_filefunc_def... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
movq %r12, %rdx
callq 0xaa614
movslq (%r12), %r12
testl %eax, %eax
jne 0xaa3c4
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xaa614
movslq 0x4... | /simonowen[P]samdisk/src/unzip.c |
unz64local_getLong64 | local int unz64local_getLong64(const zlib_filefunc64_32_def* pzlib_filefunc_def,
voidpf filestream,
ZPOS64_T* pX)
{
ZPOS64_T x;
int i = 0;
int err;
err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);
x = (ZPOS64_T)i;
if (err == UNZ_OK)
err = unz64local_getByte(pzlib_f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
movq %r12, %rdx
callq 0xaa614
movslq (%r12), %rcx
movq %rcx, 0x18(%rsp)
testl %eax, %eax
je 0xaa469
xorl %eax, %eax
jmp 0xaa47e
leaq 0x4(%rsp), ... | /simonowen[P]samdisk/src/unzip.c |
unz64local_getShort | local int unz64local_getShort(const zlib_filefunc64_32_def* pzlib_filefunc_def,
voidpf filestream,
uLong* pX)
{
uLong x;
int i = 0;
int err;
err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);
x = (uLong)i;
if (err == UNZ_OK)
err = unz64local_getByte(pzlib_filefunc_de... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
movq %r12, %rdx
callq 0xaa614
movl %eax, %ecx
movslq (%r12), %r12
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0xaa5f1
leaq 0x4(%rsp), %rdx
movq %r15, %rd... | /simonowen[P]samdisk/src/unzip.c |
test_bitstream_r_3 | static void
test_bitstream_r_3(void) {
uint64_t result;
START_TEST();
bitstream_r_init(&_stream_r, buffer, 3);
/* try to read 24 bits */
CHECK_TRUE(bitstream_r_read(&_stream_r, &result, 25), "should fail reading 57 bits");
END_TEST();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1bd4(%rip), %rdi # 0x30f3
callq 0x1f30
leaq 0x3b85(%rip), %rdi # 0x50b0
leaq 0x3b5e(%rip), %rsi # 0x5090
movl $0x3, %edx
callq 0x1070
leaq 0x3b6d(%rip), %rdi # 0x50b0
leaq -0x8(%rbp), %rsi
movl $0x19, %edx
callq 0x1050
cmpl $0x0, %eax
setne %al
movz... | /OLSR[P]OONF/src/tests/common/test_common_bitstream.c |
cunit_named_check | void
cunit_named_check(bool cond, const char *name, int line, const char *format, ...) {
va_list ap;
if (cond) {
success++;
return;
}
fail++;
va_start(ap, format);
printf("\t%s (%d) fail: ", name, line);
vprintf(format, ap);
puts("\n");
va_end(ap);
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x201b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)... | /OLSR[P]OONF/src/tests/cunit/cunit.c |
secp256k1_ge_set_gej_var | static void secp256k1_ge_set_gej_var(secp256k1_ge *r, secp256k1_gej *a) {
secp256k1_fe z2, z3;
r->infinity = a->infinity;
if (a->infinity) {
return;
}
secp256k1_fe_inv_var(&a->z, &a->z);
secp256k1_fe_sqr(&z2, &a->z);
secp256k1_fe_mul(&z3, &a->z, &z2);
secp256k1_fe_mul(&a->x, &a->... | movl 0x78(%rsi), %eax
movl %eax, 0x50(%rdi)
testl %eax, %eax
je 0xd07c
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsi), %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0x183d4
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x18060
movq... | /tangramproject[P]secp256k1-zkp/src/group_impl.h |
secp256k1_aggsig_export_secnonce_single | int secp256k1_aggsig_export_secnonce_single(const secp256k1_context* ctx, unsigned char* secnonce32, const unsigned char* seed) {
secp256k1_scalar secnonce;
secp256k1_gej pubnonce;
secp256k1_rfc6979_hmac_sha256 rng;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(secp256k1_ecmult_gen_context_is_built(&ctx->ec... | pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x1301d
movq %rdx, %rax
movq %rsi, %rbx
leaq 0x2c(%rsp), %r15
movl $0x20, %edx
movq %r15, %rdi
movq %rax, %rsi
callq 0xf20d
leaq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0x3100
testl %eax, %eax
j... | /tangramproject[P]secp256k1-zkp/src/modules/aggsig/main_impl.h |
lest::run(std::vector<lest::test, std::allocator<lest::test>>, int, char**, std::ostream&) | inline int run( tests specification, int argc, char * argv[], std::ostream & os = std::cout )
{
return run( specification, texts( argv + 1, argv + argc ), os );
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x28(%rsp), %rdi
callq 0xe948
movslq %ebp, %rax
leaq (%r14,%rax,8), %rdx
addq $0x8, %r14
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %r14, %rsi
callq 0xf16a
movaps 0x10(%rsp), %xmm0
leaq 0x40(%rsp)... | /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::split_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline auto split_option( text arg ) -> std::tuple<text, text>
{
auto pos = arg.rfind( '=' );
return pos == text::npos
? std::make_tuple( arg, "" )
: std::make_tuple( arg.substr( 0, pos ), arg.substr( pos + 1 ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x3d
popq %rsi
pushq $-0x1
popq %rdx
movq %r15, %rdi
callq 0x44f0
movq %rax, %r14
cmpq $-0x1, %rax
je 0x106d1
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x42b0
leaq 0x1(%r14), %rdx
movq %... | /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline int repeat( text opt, text arg )
{
const int num = lest::stoi( arg );
if ( indefinite( num ) || num >= 0 )
return num;
throw std::runtime_error( "expecting '-1' or positive number with option '" + opt + "', got '" + arg + "' (try option --help)" );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x4390
movq %r12, %rdi
callq 0x10db9
movl %eax, %ebx
movq %r12, %rdi
callq 0x4140
cmpl $-0x1, %ebx
jl 0x109db
movl %ebx, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14... | /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::match(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline bool match( texts whats, text line )
{
for ( auto & what : whats )
{
if ( search( what, line ) )
return true;
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %r13
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rax, %r12
cmpq %r13, %rax
je 0x1237e
movq %r14, %rdi
movq %r12, %rsi
callq 0x4390
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4390
movq %... | /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::times::operator()(lest::test) | times & operator()( test testing )
{
timer t;
try
{
testing.behaviour( output( testing.name ) );
}
catch( message const & )
{
++failures;
}
os << std::setw(3) << ( 1000 * t.elapsed_seconds() ) << " ms: " << testing.name << "\... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4050
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4390
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1300c
leaq 0x20(%r14), %rdi
movq %rax, %rsi
callq 0x12ff8
leaq 0x8(%rsp), %rdi
callq 0x4140
movq... | /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::report(std::ostream&, lest::message const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline void report( std::ostream & os, message const & e, text test )
{
os << e.where << ": " << colourise( e.kind ) << e.note << ": " << test << ": " << colourise( e.what() ) << std::endl;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
addq $0x30, %rsi
leaq 0xd0(%rsp), %r12
movq %r12, %rdi
callq 0x13696
movq %r15, %rdi
movq %r12, %rsi
callq 0x13672
leaq 0xb4e49(%rip), %rsi # 0xc8071
movq %rax, %rdi
callq 0x4260
movq %rax, %r15
leaq 0x10(%r... | /martinmoene[P]expected-lite/test/lest/lest.hpp |
lest::make_char_string[abi:cxx11](char) | inline std::string make_char_string( char chr ) { return "\'" + make_tran_string( std::string( 1, chr ) ) + "\'" ; } | pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x4310
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xbc88a
leaq 0x8c5c(%rip), %rsi # 0xc53f7
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rd... | /martinmoene[P]expected-lite/test/lest/lest.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.